nodejs · Avi-D-coder · Jan 26, 2019 · Jan 29, 2019 · Feb 6, 2019 · Feb 7, 2019
diff --git a/lib/readline.js b/lib/readline.js
@@ -454,16 +454,27 @@ Interface.prototype._normalWrite = function(b) {
   }
 };
 
+// Count the Unicode code points in a string.
+function codePointLen(str) {
+  let count = 0;
+  // eslint-disable-next-line no-unused-vars
+  for (const char of str) {
+    count++;
+  }
+  return count;
+}
+
 Interface.prototype._insertString = function(c) {
   if (this.cursor < this.line.length) {
     var beg = this.line.slice(0, this.cursor);
     var end = this.line.slice(this.cursor, this.line.length);
     this.line = beg + c + end;
-    this.cursor += c.length;
+    // Count Unicode code points
+    this.cursor += codePointLen(c);
     this._refreshLine();
   } else {
     this.line += c;
-    this.cursor += c.length;
+    this.cursor += codePointLen(c);
 
     if (this._getCursorPos().cols === 0) {
       this._refreshLine();
@@ -580,27 +591,57 @@ Interface.prototype._wordLeft = function() {
 Interface.prototype._wordRight = function() {
   if (this.cursor < this.line.length) {
     var trailing = this.line.slice(this.cursor);
-    var match = trailing.match(/^(?:\s+|\W+|\w+)\s*/);
+    var match = trailing.match(/^(?:\s+|[^\w\s]+|\w+)\s*/);
     this._moveCursor(match[0].length);
   }
 };
 
+function codePointLeftOf(i, str) {
+  // obtain the code point to the left
+  let previousChar;
+  let len = 0;
+  for (const char of str) {
+    len += char.length;
+    previousChar = char;
+    if (len === i) {
+      return previousChar;
+    }
+  }
+}
+
+function codePointRightOf(i, str) {
+  // obtain the code point to the right
+  let len = 0;
+  for (const char of str) {
+    len += char.length;
+    if (len > i) {
+      // UTF-16 units comprising the character
+      return char;
+    }
+  }
+}
 
 Interface.prototype._deleteLeft = function() {
   if (this.cursor > 0 && this.line.length > 0) {
-    this.line = this.line.slice(0, this.cursor - 1) +
+    // The number of UTF-16 units comprising the character to the left
+    const charSize = codePointLeftOf(this.cursor, this.line).length;
+    this.line = this.line.slice(0, this.cursor - charSize) +
                 this.line.slice(this.cursor, this.line.length);
 
-    this.cursor--;
+    this.cursor -= charSize;
     this._refreshLine();
   }
 };
 
 
 Interface.prototype._deleteRight = function() {
-  this.line = this.line.slice(0, this.cursor) +
-              this.line.slice(this.cursor + 1, this.line.length);
-  this._refreshLine();
+  if (this.cursor < this.line.length) {
+    // The number of UTF-16 units comprising the character to the left
+    const charSize = codePointRightOf(this.cursor, this.line).length;
+    this.line = this.line.slice(0, this.cursor) +
+      this.line.slice(this.cursor + charSize, this.line.length);
+    this._refreshLine();
+  }
 };
 
 
@@ -952,11 +993,16 @@ Interface.prototype._ttyWrite = function(s, key) {
         break;
 
       case 'left':
-        this._moveCursor(-1);
+        if (this.cursor > 0) {
+          // obtain the code point to the left
+          this._moveCursor(-codePointLeftOf(this.cursor, this.line).length);
+        }
         break;
 
       case 'right':
-        this._moveCursor(+1);
+        if (this.cursor < this.line.length) {
+          this._moveCursor(+codePointRightOf(this.cursor, this.line).length);
+        }
         break;
 
       case 'home':

diff --git a/test/parallel/test-readline-interface.js b/test/parallel/test-readline-interface.js
@@ -650,6 +650,94 @@ function isWarned(emitter) {
       rli.close();
     }
 
+    // Back and Forward one astral character
+    {
+      const fi = new FakeInput();
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        prompt: '',
+        terminal: terminal
+      });
+      fi.emit('data', '💻');
+
+      // move left one character/code point
+      fi.emit('keypress', '.', { name: 'left' });
+      let cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 0);
+
+      // move right one character/code point
+      fi.emit('keypress', '.', { name: 'right' });
+      cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 2);
+
+      rli.on('line', common.mustCall((line) => {
+        assert.strictEqual(line, '💻');
+      }));
+      fi.emit('data', '\n');
+      rli.close();
+    }
+
+    // Two astral characters left
+    {
+      const fi = new FakeInput();
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        prompt: '',
+        terminal: terminal
+      });
+      fi.emit('data', '💻');
+
+      // move left one character/code point
+      fi.emit('keypress', '.', { name: 'left' });
+      let cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 0);
+
+      fi.emit('data', '🐕');
+      cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 2);
+
+      rli.on('line', common.mustCall((line) => {
+        assert.strictEqual(line, '🐕💻');
+      }));
+      fi.emit('data', '\n');
+      rli.close();
+    }
+
+    // Two astral characters right
+    {
+      const fi = new FakeInput();
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        prompt: '',
+        terminal: terminal
+      });
+      fi.emit('data', '💻');
+
+      // move left one character/code point
+      fi.emit('keypress', '.', { name: 'right' });
+      let cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 2);
+
+      fi.emit('data', '🐕');
+      cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 4);
+
+      rli.on('line', common.mustCall((line) => {
+        assert.strictEqual(line, '💻🐕');
+      }));
+      fi.emit('data', '\n');
+      rli.close();
+    }
+
     {
       // `wordLeft` and `wordRight`
       const fi = new FakeInput();
@@ -791,6 +879,32 @@ function isWarned(emitter) {
       rli.close();
     }
 
+    // deleteLeft astral character
+    {
+      const fi = new FakeInput();
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        prompt: '',
+        terminal: terminal
+      });
+      fi.emit('data', '💻');
+      let cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 2);
+
+      // Delete left character
+      fi.emit('keypress', '.', { ctrl: true, name: 'h' });
+      cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 0);
+      rli.on('line', common.mustCall((line) => {
+        assert.strictEqual(line, '');
+      }));
+      fi.emit('data', '\n');
+      rli.close();
+    }
+
     // deleteRight
     {
       const fi = new FakeInput();
@@ -820,6 +934,34 @@ function isWarned(emitter) {
       rli.close();
     }
 
+    // deleteRight astral character
+    {
+      const fi = new FakeInput();
+      const rli = new readline.Interface({
+        input: fi,
+        output: fi,
+        prompt: '',
+        terminal: terminal
+      });
+      fi.emit('data', '💻');
+
+      // Go to the start of the line
+      fi.emit('keypress', '.', { ctrl: true, name: 'a' });
+      let cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 0);
+
+      // Delete right character
+      fi.emit('keypress', '.', { ctrl: true, name: 'd' });
+      cursorPos = rli._getCursorPos();
+      assert.strictEqual(cursorPos.rows, 0);
+      assert.strictEqual(cursorPos.cols, 0);
+      rli.on('line', common.mustCall((line) => {
+        assert.strictEqual(line, '');
+      }));
+      fi.emit('data', '\n');
+      rli.close();
+    }
 
     // deleteLineLeft
     {