Bump version to 3.7.0

Fix broken search addon

CONTRIBUTING.md

@@ -23,7 +23,7 @@ opening an issue, read these pointers.
 - Mention precisely what went wrong. What did you expect to happen? What happened instead? Describe the
   exact steps a maintainer has to take to make the problem occur.
 
-- If the problem can not be reproduced in the [demo of xterm.js](README.md#demo), please provide an HTML document that demonstrates the problem.
+- If the problem can not be reproduced in the [demo of xterm.js](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo), please provide an HTML document that demonstrates the problem.
 
 - Be polite. Issues with an indignant or belligerent tone tend to be moved to the
   bottom of the pile.
@@ -33,6 +33,7 @@ opening an issue, read these pointers.
 - Make sure you have a [GitHub account](https://github.com/join)
 - Fork [xterm.js](https://github.com/sourcelair/xterm.js/)
   ([how to fork a repo](https://help.github.com/articles/fork-a-repo))
+- Get the [xterm.js demo](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo) running
 - Make your changes
 - If your changes are easy to test or likely to regress, add tests. Tests go into `test`, directory.
 - Follow the general code style of the rest of the project (see below).

LICENSE

@@ -1,3 +1,4 @@
+Copyright (c) 2017-2018, The xterm.js authors (https://github.com/xtermjs/xterm.js)
 Copyright (c) 2014-2016, SourceLair Private Company (https://www.sourcelair.com)
 Copyright (c) 2012-2013, Christopher Jeffrey (https://github.com/chjj/)
 

README.md

@@ -169,6 +169,7 @@ computational environment for Jupyter, supporting interactive data science and s
 - [**cPanel & WHM**](https://cpanel.com): The hosting platform of choice.
 - [**Nutanix**](https://github.com/nutanix): Nutanix Enterprise Cloud uses xterm in the webssh functionality within Nutanix Calm, and is also looking to move our old noserial (termjs) functionality to xterm.js
 - [**SSH Web Client**](https://github.com/roke22/PHP-SSH2-Web-Client): SSH Web Client with PHP.
+- [**Shellvault**](https://www.shellvault.io): The cloud-based SSH terminal you can access from anywhere.
 
 [And much more...](https://github.com/xtermjs/xterm.js/network/dependents)
 

fixtures/typings-test/tsconfig.json

@@ -4,6 +4,7 @@
   ],
   "compilerOptions": {
     "module": "commonjs",
-    "target": "es5"
+    "target": "es5",
+    "noEmit": true
   }
 }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "main": "lib/public/Terminal.js",
   "types": "typings/xterm.d.ts",
   "repository": "https://github.com/xtermjs/xterm.js",

src/Buffer.test.ts

@@ -5,9 +5,10 @@
 
 import { assert } from 'chai';
 import { ITerminal } from './Types';
-import { Buffer } from './Buffer';
+import { Buffer, DEFAULT_ATTR } from './Buffer';
 import { CircularList } from './common/CircularList';
 import { MockTerminal } from './utils/TestUtils.test';
+import { BufferLine } from './BufferLine';
 
 const INIT_COLS = 80;
 const INIT_ROWS = 24;
@@ -36,13 +37,13 @@ describe('Buffer', () => {
 
   describe('fillViewportRows', () => {
     it('should fill the buffer with blank lines based on the size of the viewport', () => {
-      const blankLineChar = terminal.blankLine()[0];
+      const blankLineChar = BufferLine.blankLine(terminal.cols, DEFAULT_ATTR).get(0);
       buffer.fillViewportRows();
       assert.equal(buffer.lines.length, INIT_ROWS);
       for (let y = 0; y < INIT_ROWS; y++) {
         assert.equal(buffer.lines.get(y).length, INIT_COLS);
         for (let x = 0; x < INIT_COLS; x++) {
-          assert.deepEqual(buffer.lines.get(y)[x], blankLineChar);
+          assert.deepEqual(buffer.lines.get(y).get(x), blankLineChar);
         }
       }
     });
@@ -66,40 +67,40 @@ describe('Buffer', () => {
     describe('wrapped', () => {
       it('should return a range for the first row', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(1)).isWrapped = true;
+        buffer.lines.get(1).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(0), { first: 0, last: 1 });
       });
       it('should return a range for a middle row wrapping upwards', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(12)).isWrapped = true;
+        buffer.lines.get(12).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 11, last: 12 });
       });
       it('should return a range for a middle row wrapping downwards', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(13)).isWrapped = true;
+        buffer.lines.get(13).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 12, last: 13 });
       });
       it('should return a range for a middle row wrapping both ways', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(11)).isWrapped = true;
-        (<any> buffer.lines.get(12)).isWrapped = true;
-        (<any> buffer.lines.get(13)).isWrapped = true;
-        (<any> buffer.lines.get(14)).isWrapped = true;
+        buffer.lines.get(11).isWrapped = true;
+        buffer.lines.get(12).isWrapped = true;
+        buffer.lines.get(13).isWrapped = true;
+        buffer.lines.get(14).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(12), { first: 10, last: 14 });
       });
       it('should return a range for the last row', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(23)).isWrapped = true;
+        buffer.lines.get(23).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 1), { first: 22, last: 23 });
       });
       it('should return a range for a row that wraps upward to first row', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(1)).isWrapped = true;
+        buffer.lines.get(1).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(1), { first: 0, last: 1 });
       });
       it('should return a range for a row that wraps downward to last row', () => {
         buffer.fillViewportRows();
-        (<any> buffer.lines.get(buffer.lines.length - 1)).isWrapped = true;
+        buffer.lines.get(buffer.lines.length - 1).isWrapped = true;
         assert.deepEqual(buffer.getWrappedRangeForLine(buffer.lines.length - 2), { first: 22, last: 23 });
       });
     });
@@ -154,11 +155,11 @@ describe('Buffer', () => {
           assert.equal(buffer.lines.maxLength, INIT_ROWS);
           buffer.y = INIT_ROWS - 1;
           buffer.fillViewportRows();
-          buffer.lines.get(5)[0][1] = 'a';
-          buffer.lines.get(INIT_ROWS - 1)[0][1] = 'b';
+          buffer.lines.get(5).get(0)[1] = 'a';
+          buffer.lines.get(INIT_ROWS - 1).get(0)[1] = 'b';
           buffer.resize(INIT_COLS, INIT_ROWS - 5);
-          assert.equal(buffer.lines.get(0)[0][1], 'a');
-          assert.equal(buffer.lines.get(INIT_ROWS - 1 - 5)[0][1], 'b');
+          assert.equal(buffer.lines.get(0).get(0)[1], 'a');
+          assert.equal(buffer.lines.get(INIT_ROWS - 1 - 5).get(0)[1], 'b');
         });
       });
     });
@@ -179,7 +180,7 @@ describe('Buffer', () => {
           buffer.fillViewportRows();
           // Create 10 extra blank lines
           for (let i = 0; i < 10; i++) {
-            buffer.lines.push(terminal.blankLine());
+            buffer.lines.push(BufferLine.blankLine(terminal.cols, DEFAULT_ATTR));
           }
           // Set cursor to the bottom of the buffer
           buffer.y = INIT_ROWS - 1;
@@ -199,7 +200,7 @@ describe('Buffer', () => {
           buffer.fillViewportRows();
           // Create 10 extra blank lines
           for (let i = 0; i < 10; i++) {
-            buffer.lines.push(terminal.blankLine());
+            buffer.lines.push(BufferLine.blankLine(terminal.cols, DEFAULT_ATTR));
           }
           // Set cursor to the bottom of the buffer
           buffer.y = INIT_ROWS - 1;
@@ -272,34 +273,34 @@ describe('Buffer', () => {
 
   describe ('translateBufferLineToString', () => {
     it('should handle selecting a section of ascii text', () => {
-      buffer.lines.set(0, [
-        [ null, 'a', 1, 'a'.charCodeAt(0)],
-        [ null, 'b', 1, 'b'.charCodeAt(0)],
-        [ null, 'c', 1, 'c'.charCodeAt(0)],
-        [ null, 'd', 1, 'd'.charCodeAt(0)]
-      ]);
+      const line = new BufferLine();
+      line.push([ null, 'a', 1, 'a'.charCodeAt(0)]);
+      line.push([ null, 'b', 1, 'b'.charCodeAt(0)]);
+      line.push([ null, 'c', 1, 'c'.charCodeAt(0)]);
+      line.push([ null, 'd', 1, 'd'.charCodeAt(0)]);
+      buffer.lines.set(0, line);
 
       const str = buffer.translateBufferLineToString(0, true, 0, 2);
       assert.equal(str, 'ab');
     });
 
     it('should handle a cut-off double width character by including it', () => {
-      buffer.lines.set(0, [
-        [ null, '語', 2, 35486 ],
-        [ null, '', 0, null],
-        [ null, 'a', 1, 'a'.charCodeAt(0)]
-      ]);
+      const line = new BufferLine();
+      line.push([ null, '語', 2, 35486 ]);
+      line.push([ null, '', 0, null]);
+      line.push([ null, 'a', 1, 'a'.charCodeAt(0)]);
+      buffer.lines.set(0, line);
 
       const str1 = buffer.translateBufferLineToString(0, true, 0, 1);
       assert.equal(str1, '語');
     });
 
     it('should handle a zero width character in the middle of the string by not including it', () => {
-      buffer.lines.set(0, [
-        [ null, '語', 2, '語'.charCodeAt(0) ],
-        [ null, '', 0, null],
-        [ null, 'a', 1, 'a'.charCodeAt(0)]
-      ]);
+      const line = new BufferLine();
+      line.push([ null, '語', 2, '語'.charCodeAt(0) ]);
+      line.push([ null, '', 0, null]);
+      line.push([ null, 'a', 1, 'a'.charCodeAt(0)]);
+      buffer.lines.set(0, line);
 
       const str0 = buffer.translateBufferLineToString(0, true, 0, 1);
       assert.equal(str0, '語');
@@ -312,10 +313,10 @@ describe('Buffer', () => {
     });
 
     it('should handle single width emojis', () => {
-      buffer.lines.set(0, [
-        [ null, '😁', 1, '😁'.charCodeAt(0) ],
-        [ null, 'a', 1, 'a'.charCodeAt(0)]
-      ]);
+      const line = new BufferLine();
+      line.push([ null, '😁', 1, '😁'.charCodeAt(0) ]);
+      line.push([ null, 'a', 1, 'a'.charCodeAt(0)]);
+      buffer.lines.set(0, line);
 
       const str1 = buffer.translateBufferLineToString(0, true, 0, 1);
       assert.equal(str1, '😁');
@@ -325,10 +326,10 @@ describe('Buffer', () => {
     });
 
     it('should handle double width emojis', () => {
-      buffer.lines.set(0, [
-        [ null, '😁', 2, '😁'.charCodeAt(0) ],
-        [ null, '', 0, null]
-      ]);
+      const line = new BufferLine();
+      line.push([ null, '😁', 2, '😁'.charCodeAt(0) ]);
+      line.push([ null, '', 0, null]);
+      buffer.lines.set(0, line);
 
       const str1 = buffer.translateBufferLineToString(0, true, 0, 1);
       assert.equal(str1, '😁');
@@ -336,11 +337,11 @@ describe('Buffer', () => {
       const str2 = buffer.translateBufferLineToString(0, true, 0, 2);
       assert.equal(str2, '😁');
 
-      buffer.lines.set(0, [
-        [ null, '😁', 2, '😁'.charCodeAt(0) ],
-        [ null, '', 0, null],
-        [ null, 'a', 1, 'a'.charCodeAt(0)]
-      ]);
+      const line2 = new BufferLine();
+      line2.push([ null, '😁', 2, '😁'.charCodeAt(0) ]);
+      line2.push([ null, '', 0, null]);
+      line2.push([ null, 'a', 1, 'a'.charCodeAt(0)]);
+      buffer.lines.set(0, line2);
 
       const str3 = buffer.translateBufferLineToString(0, true, 0, 3);
       assert.equal(str3, '😁a');

src/Buffer.ts

@@ -4,9 +4,10 @@
  */
 
 import { CircularList } from './common/CircularList';
-import { LineData, CharData, ITerminal, IBuffer } from './Types';
+import { CharData, ITerminal, IBuffer, IBufferLine } from './Types';
 import { EventEmitter } from './EventEmitter';
 import { IMarker } from 'xterm';
+import { BufferLine } from './BufferLine';
 
 export const DEFAULT_ATTR = (0 << 18) | (257 << 9) | (256 << 0);
 export const CHAR_DATA_ATTR_INDEX = 0;
@@ -27,7 +28,7 @@ export const NULL_CELL_CODE = 32;
  *   - scroll position
  */
 export class Buffer implements IBuffer {
-  public lines: CircularList<LineData>;
+  public lines: CircularList<IBufferLine>;
   public ydisp: number;
   public ybase: number;
   public y: number;
@@ -84,7 +85,7 @@ export class Buffer implements IBuffer {
     if (this.lines.length === 0) {
       let i = this._terminal.rows;
       while (i--) {
-        this.lines.push(this._terminal.blankLine());
+        this.lines.push(BufferLine.blankLine(this._terminal.cols, DEFAULT_ATTR));
       }
     }
   }
@@ -97,7 +98,7 @@ export class Buffer implements IBuffer {
     this.ybase = 0;
     this.y = 0;
     this.x = 0;
-    this.lines = new CircularList<LineData>(this._getCorrectBufferLength(this._terminal.rows));
+    this.lines = new CircularList<IBufferLine>(this._getCorrectBufferLength(this._terminal.rows));
     this.scrollTop = 0;
     this.scrollBottom = this._terminal.rows - 1;
     this.setupTabStops();
@@ -146,7 +147,7 @@ export class Buffer implements IBuffer {
             } else {
               // Add a blank line if there is no buffer left at the top to scroll to, or if there
               // are blank lines after the cursor
-              this.lines.push(this._terminal.blankLine(undefined, undefined, newCols));
+              this.lines.push(BufferLine.blankLine(newCols, DEFAULT_ATTR));
             }
           }
         }
@@ -223,7 +224,7 @@ export class Buffer implements IBuffer {
     let endIndex = endCol;
 
     for (let i = 0; i < line.length; i++) {
-      const char = line[i];
+      const char = line.get(i);
       lineString += char[CHAR_DATA_CHAR_INDEX];
       // Adjust start and end cols for wide characters if they affect their
       // column indexes
@@ -268,11 +269,11 @@ export class Buffer implements IBuffer {
     let first = y;
     let last = y;
     // Scan upwards for wrapped lines
-    while (first > 0 && (<any>this.lines.get(first)).isWrapped) {
+    while (first > 0 && this.lines.get(first).isWrapped) {
       first--;
     }
     // Scan downwards for wrapped lines
-    while (last + 1 < this.lines.length && (<any>this.lines.get(last + 1)).isWrapped) {
+    while (last + 1 < this.lines.length && this.lines.get(last + 1).isWrapped) {
       last++;
     }
     return { first, last };
@@ -283,7 +284,7 @@ export class Buffer implements IBuffer {
    * @param i The index to start setting up tab stops from.
    */
   public setupTabStops(i?: number): void {
-    if (i != null) {
+    if (i !== null && i !== undefined) {
       if (!this.tabs[i]) {
         i = this.prevStop(i);
       }
@@ -302,7 +303,7 @@ export class Buffer implements IBuffer {
    * @param x The position to move the cursor to the previous tab stop.
    */
   public prevStop(x?: number): number {
-    if (x == null) {
+    if (x === null || x === undefined) {
       x = this.x;
     }
     while (!this.tabs[--x] && x > 0);
@@ -314,7 +315,7 @@ export class Buffer implements IBuffer {
    * @param x The position to move the cursor one tab stop forward.
    */
   public nextStop(x?: number): number {
-    if (x == null) {
+    if (x === null || x === undefined) {
       x = this.x;
     }
     while (!this.tabs[++x] && x < this._terminal.cols);

src/BufferLine.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+import * as chai from 'chai';
+import { BufferLine } from './BufferLine';
+import { CharData, IBufferLine } from './Types';
+import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE, CHAR_DATA_ATTR_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, CHAR_DATA_CODE_INDEX } from './Buffer';
+
+
+class TestBufferLine extends BufferLine {
+  public toArray(): CharData[] {
+    return this._data;
+  }
+}
+
+describe('BufferLine', function(): void {
+  it('ctor', function(): void {
+    let line: IBufferLine = new TestBufferLine();
+    chai.expect(line.length).equals(0);
+    chai.expect(line.pop()).equals(undefined);
+    chai.expect(line.isWrapped).equals(false);
+    line = new TestBufferLine(10);
+    chai.expect(line.length).equals(10);
+    chai.expect(line.pop()).eql([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+    chai.expect(line.isWrapped).equals(false);
+    line = new TestBufferLine(10, null, true);
+    chai.expect(line.length).equals(10);
+    chai.expect(line.pop()).eql([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+    chai.expect(line.isWrapped).equals(true);
+    line = new TestBufferLine(10, [123, 'a', 456, 789], true);
+    chai.expect(line.length).equals(10);
+    chai.expect(line.pop()).eql([123, 'a', 456, 789]);
+    chai.expect(line.isWrapped).equals(true);
+  });
+  it('splice', function(): void {
+    const line = new TestBufferLine();
+    const data: CharData[] = [
+      [1, 'a', 0, 0],
+      [2, 'b', 0, 0],
+      [3, 'c', 0, 0]
+    ];
+    for (let i = 0; i < data.length; ++i) line.push(data[i]);
+    chai.expect(line.length).equals(data.length);
+    const removed1 = line.splice(1, 1, [4, 'd', 0, 0]);
+    const removed2 = data.splice(1, 1, [4, 'd', 0, 0]);
+    chai.expect(removed1).eql(removed2);
+    chai.expect(line.toArray()).eql(data);
+  });
+  it('TerminalLine.blankLine', function(): void {
+    const line = TestBufferLine.blankLine(5, 123);
+    chai.expect(line.length).equals(5);
+    chai.expect(line.isWrapped).equals(false);
+    const ch = line.get(0);
+    chai.expect(ch[CHAR_DATA_ATTR_INDEX]).equals(123);
+    chai.expect(ch[CHAR_DATA_CHAR_INDEX]).equals(NULL_CELL_CHAR);
+    chai.expect(ch[CHAR_DATA_WIDTH_INDEX]).equals(NULL_CELL_WIDTH);
+    chai.expect(ch[CHAR_DATA_CODE_INDEX]).equals(NULL_CELL_CODE);
+  });
+  it('insertCells', function(): void {
+    const line = new TestBufferLine();
+    const data: CharData[] = [
+      [1, 'a', 0, 0],
+      [2, 'b', 0, 0],
+      [3, 'c', 0, 0]
+    ];
+    for (let i = 0; i < data.length; ++i) line.push(data[i]);
+    line.insertCells(1, 3, [4, 'd', 0, 0]);
+    chai.expect(line.toArray()).eql([[1, 'a', 0, 0], [4, 'd', 0, 0], [4, 'd', 0, 0]]);
+  });
+  it('deleteCells', function(): void {
+    const line = new TestBufferLine();
+    const data: CharData[] = [
+      [1, 'a', 0, 0],
+      [2, 'b', 0, 0],
+      [3, 'c', 0, 0],
+      [4, 'd', 0, 0],
+      [5, 'e', 0, 0]
+    ];
+    for (let i = 0; i < data.length; ++i) line.push(data[i]);
+    line.deleteCells(1, 2, [6, 'f', 0, 0]);
+    chai.expect(line.toArray()).eql([[1, 'a', 0, 0], [4, 'd', 0, 0], [5, 'e', 0, 0], [6, 'f', 0, 0], [6, 'f', 0, 0]]);
+  });
+  it('replaceCells', function(): void {
+    const line = new TestBufferLine();
+    const data: CharData[] = [
+      [1, 'a', 0, 0],
+      [2, 'b', 0, 0],
+      [3, 'c', 0, 0],
+      [4, 'd', 0, 0],
+      [5, 'e', 0, 0]
+    ];
+    for (let i = 0; i < data.length; ++i) line.push(data[i]);
+    line.replaceCells(2, 4, [6, 'f', 0, 0]);
+    chai.expect(line.toArray()).eql([[1, 'a', 0, 0], [2, 'b', 0, 0], [6, 'f', 0, 0], [6, 'f', 0, 0], [5, 'e', 0, 0]]);
+  });
+});

src/BufferLine.ts

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+import { CharData, IBufferLine } from './Types';
+import { NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR } from './Buffer';
+
+/**
+ * Class representing a terminal line.
+ */
+export class BufferLine implements IBufferLine {
+  static blankLine(cols: number, attr: number, isWrapped?: boolean): IBufferLine {
+    const ch: CharData = [attr, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE];
+    return new BufferLine(cols, ch, isWrapped);
+  }
+  protected _data: CharData[];
+  public isWrapped = false;
+  public length: number;
+
+  constructor(cols?: number, ch?: CharData, isWrapped?: boolean) {
+    this._data = [];
+    this.length = this._data.length;
+    if (cols) {
+      if (!ch) {
+        ch = [0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE];
+      }
+      for (let i = 0; i < cols; i++) {
+        this.push(ch);  // Note: the ctor ch is not cloned (resembles old behavior)
+      }
+    }
+    if (isWrapped) {
+      this.isWrapped = true;
+    }
+  }
+
+  public get(index: number): CharData {
+    return this._data[index];
+  }
+
+  public set(index: number, data: CharData): void {
+    this._data[index] = data;
+  }
+
+  public pop(): CharData | undefined  {
+    const data = this._data.pop();
+    this.length = this._data.length;
+    return data;
+  }
+
+  public push(data: CharData): void {
+    this._data.push(data);
+    this.length = this._data.length;
+  }
+
+  public splice(start: number, deleteCount: number, ...items: CharData[]): CharData[] {
+    const removed = this._data.splice(start, deleteCount, ...items);
+    this.length = this._data.length;
+    return removed;
+  }
+
+  /** insert n cells ch at pos, right cells are lost (stable length)  */
+  public insertCells(pos: number, n: number, ch: CharData): void {
+    while (n--) {
+      this.splice(pos, 0, ch);
+      this.pop();
+    }
+  }
+
+  /** delete n cells at pos, right side is filled with fill (stable length) */
+  public deleteCells(pos: number, n: number, fill: CharData): void {
+    while (n--) {
+      this.splice(pos, 1);
+      this.push(fill);
+    }
+  }
+
+  /** replace cells from pos to pos + n - 1 with fill */
+  public replaceCells(start: number, end: number, fill: CharData): void {
+    while (start < end  && start < this.length) {
+      this.set(start++, fill);  // Note: fill is not cloned (resembles old behavior)
+    }
+  }
+}

src/InputHandler.test.ts

@@ -3,9 +3,102 @@
  * @license MIT
  */
 
-import { assert } from 'chai';
+import { assert, expect } from 'chai';
 import { InputHandler } from './InputHandler';
 import { MockInputHandlingTerminal } from './utils/TestUtils.test';
+import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, CHAR_DATA_CHAR_INDEX } from './Buffer';
+import { Terminal } from './Terminal';
+import { IBufferLine } from './Types';
+
+
+// TODO: This and the sections related to this object in associated tests can be
+// removed safely after InputHandler refactors are finished
+class OldInputHandler extends InputHandler {
+  public eraseInLine(params: number[]): void {
+    switch (params[0]) {
+      case 0:
+        this.eraseRight(this._terminal.buffer.x, this._terminal.buffer.y);
+        break;
+      case 1:
+        this.eraseLeft(this._terminal.buffer.x, this._terminal.buffer.y);
+        break;
+      case 2:
+        this.eraseLine(this._terminal.buffer.y);
+        break;
+    }
+  }
+
+  public eraseInDisplay(params: number[]): void {
+    let j;
+    switch (params[0]) {
+      case 0:
+        this.eraseRight(this._terminal.buffer.x, this._terminal.buffer.y);
+        j = this._terminal.buffer.y + 1;
+        for (; j < this._terminal.rows; j++) {
+          this.eraseLine(j);
+        }
+        break;
+      case 1:
+        this.eraseLeft(this._terminal.buffer.x, this._terminal.buffer.y);
+        j = this._terminal.buffer.y;
+        while (j--) {
+          this.eraseLine(j);
+        }
+        break;
+      case 2:
+        j = this._terminal.rows;
+        while (j--) this.eraseLine(j);
+        break;
+      case 3:
+        // Clear scrollback (everything not in viewport)
+        const scrollBackSize = this._terminal.buffer.lines.length - this._terminal.rows;
+        if (scrollBackSize > 0) {
+          this._terminal.buffer.lines.trimStart(scrollBackSize);
+          this._terminal.buffer.ybase = Math.max(this._terminal.buffer.ybase - scrollBackSize, 0);
+          this._terminal.buffer.ydisp = Math.max(this._terminal.buffer.ydisp - scrollBackSize, 0);
+          // Force a scroll event to refresh viewport
+          this._terminal.emit('scroll', 0);
+        }
+        break;
+    }
+  }
+
+  /**
+   * Erase in the identified line everything from "x" to the end of the line (right).
+   * @param x The column from which to start erasing to the end of the line.
+   * @param y The line in which to operate.
+   */
+  public eraseRight(x: number, y: number): void {
+    const line = this._terminal.buffer.lines.get(this._terminal.buffer.ybase + y);
+    if (!line) {
+      return;
+    }
+    line.replaceCells(x, this._terminal.cols, [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+    this._terminal.updateRange(y);
+  }
+
+  /**
+   * Erase in the identified line everything from "x" to the start of the line (left).
+   * @param x The column from which to start erasing to the start of the line.
+   * @param y The line in which to operate.
+   */
+  public eraseLeft(x: number, y: number): void {
+    const line = this._terminal.buffer.lines.get(this._terminal.buffer.ybase + y);
+    if (!line) {
+      return;
+    }
+    line.replaceCells(0, x + 1, [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+    this._terminal.updateRange(y);
+  }
+
+  /**
+   * Erase all content in the given line
+   * @param y The line to erase all of its contents.
+   */
+  public eraseLine(y: number): void {
+    this.eraseRight(0, y);
+  }
+}
 
 describe('InputHandler', () => {
   describe('save and restore cursor', () => {
@@ -84,4 +177,302 @@ describe('InputHandler', () => {
       assert.equal(terminal.bracketedPasteMode, false);
     });
   });
+  describe('regression tests', function(): void {
+    type CharData = [number, string, number, number];
+
+    function lineContent(line: IBufferLine): string {
+      let content = '';
+      for (let i = 0; i < line.length; ++i) content += line.get(i)[CHAR_DATA_CHAR_INDEX];
+      return content;
+    }
+
+    function termContent(term: Terminal): string[] {
+      const result = [];
+      for (let i = 0; i < term.rows; ++i) result.push(lineContent(term.buffer.lines.get(i)));
+      return result;
+    }
+
+    it('insertChars', function(): void {
+      const term = new Terminal();
+      const inputHandler = new InputHandler(term);
+
+      // old variant of the method
+      function insertChars(params: number[]): void {
+        let param = params[0];
+        if (param < 1) param = 1;
+
+        // make buffer local for faster access
+        const buffer = term.buffer;
+
+        const row = buffer.y + buffer.ybase;
+        let j = buffer.x;
+        const ch: CharData = [term.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
+        while (param-- && j < term.cols) {
+          buffer.lines.get(row).splice(j++, 0, ch);
+          buffer.lines.get(row).pop();
+        }
+      }
+
+      // insert some data in first and second line
+      inputHandler.parse(Array(term.cols - 9).join('a'));
+      inputHandler.parse('1234567890');
+      inputHandler.parse(Array(term.cols - 9).join('a'));
+      inputHandler.parse('1234567890');
+      const line1: IBufferLine = term.buffer.lines.get(0); // line for old variant
+      const line2: IBufferLine = term.buffer.lines.get(1); // line for new variant
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '1234567890');
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '1234567890');
+
+      // insert one char from params = [0]
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      insertChars([0]);
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + ' 123456789');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.insertChars([0]);
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + ' 123456789');
+      expect(lineContent(line2)).equals(lineContent(line1));
+
+      // insert one char from params = [1]
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      insertChars([1]);
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '  12345678');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.insertChars([1]);
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '  12345678');
+      expect(lineContent(line2)).equals(lineContent(line1));
+
+      // insert two chars from params = [2]
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      insertChars([2]);
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '    123456');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.insertChars([2]);
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '    123456');
+      expect(lineContent(line2)).equals(lineContent(line1));
+
+      // insert 10 chars from params = [10]
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      insertChars([10]);
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '          ');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.insertChars([10]);
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '          ');
+      expect(lineContent(line2)).equals(lineContent(line1));
+    });
+    it('deleteChars', function(): void {
+      const term = new Terminal();
+      const inputHandler = new InputHandler(term);
+
+      // old variant of the method
+      function deleteChars(params: number[]): void {
+        let param: number = params[0];
+        if (param < 1) {
+          param = 1;
+        }
+
+        // make buffer local for faster access
+        const buffer = term.buffer;
+
+        const row = buffer.y + buffer.ybase;
+        const ch: CharData = [term.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
+        while (param--) {
+          buffer.lines.get(row).splice(buffer.x, 1);
+          buffer.lines.get(row).push(ch);
+        }
+        term.updateRange(buffer.y);
+      }
+
+      // insert some data in first and second line
+      inputHandler.parse(Array(term.cols - 9).join('a'));
+      inputHandler.parse('1234567890');
+      inputHandler.parse(Array(term.cols - 9).join('a'));
+      inputHandler.parse('1234567890');
+      const line1: IBufferLine = term.buffer.lines.get(0); // line for old variant
+      const line2: IBufferLine = term.buffer.lines.get(1); // line for new variant
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '1234567890');
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '1234567890');
+
+      // delete one char from params = [0]
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      deleteChars([0]);
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '234567890 ');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.deleteChars([0]);
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '234567890 ');
+      expect(lineContent(line2)).equals(lineContent(line1));
+
+      // insert one char from params = [1]
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      deleteChars([1]);
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '34567890  ');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.deleteChars([1]);
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '34567890  ');
+      expect(lineContent(line2)).equals(lineContent(line1));
+
+      // insert two chars from params = [2]
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      deleteChars([2]);
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '567890    ');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.deleteChars([2]);
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '567890    ');
+      expect(lineContent(line2)).equals(lineContent(line1));
+
+      // insert 10 chars from params = [10]
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      deleteChars([10]);
+      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '          ');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.deleteChars([10]);
+      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '          ');
+      expect(lineContent(line2)).equals(lineContent(line1));
+    });
+    it('eraseInLine', function(): void {
+      const term = new Terminal();
+      const inputHandler = new InputHandler(term);
+      const oldInputHandler = new OldInputHandler(term);
+
+      // fill 6 lines to test 3 different states
+      inputHandler.parse(Array(term.cols + 1).join('a'));
+      inputHandler.parse(Array(term.cols + 1).join('a'));
+      inputHandler.parse(Array(term.cols + 1).join('a'));
+      inputHandler.parse(Array(term.cols + 1).join('a'));
+      inputHandler.parse(Array(term.cols + 1).join('a'));
+      inputHandler.parse(Array(term.cols + 1).join('a'));
+
+      // params[0] - right erase
+      term.buffer.y = 0;
+      term.buffer.x = 70;
+      oldInputHandler.eraseInLine([0]);
+      expect(lineContent(term.buffer.lines.get(0))).equals(Array(71).join('a') + '          ');
+      term.buffer.y = 1;
+      term.buffer.x = 70;
+      inputHandler.eraseInLine([0]);
+      expect(lineContent(term.buffer.lines.get(1))).equals(Array(71).join('a') + '          ');
+
+      // params[1] - left erase
+      term.buffer.y = 2;
+      term.buffer.x = 70;
+      oldInputHandler.eraseInLine([1]);
+      expect(lineContent(term.buffer.lines.get(2))).equals(Array(71).join(' ') + ' aaaaaaaaa');
+      term.buffer.y = 3;
+      term.buffer.x = 70;
+      inputHandler.eraseInLine([1]);
+      expect(lineContent(term.buffer.lines.get(3))).equals(Array(71).join(' ') + ' aaaaaaaaa');
+
+      // params[1] - left erase
+      term.buffer.y = 4;
+      term.buffer.x = 70;
+      oldInputHandler.eraseInLine([2]);
+      expect(lineContent(term.buffer.lines.get(4))).equals(Array(term.cols + 1).join(' '));
+      term.buffer.y = 5;
+      term.buffer.x = 70;
+      inputHandler.eraseInLine([2]);
+      expect(lineContent(term.buffer.lines.get(5))).equals(Array(term.cols + 1).join(' '));
+
+    });
+    it('eraseInDisplay', function(): void {
+      const termOld = new Terminal();
+      const inputHandlerOld = new OldInputHandler(termOld);
+      const termNew = new Terminal();
+      const inputHandlerNew = new InputHandler(termNew);
+
+      // fill display with a's
+      for (let i = 0; i < termOld.rows; ++i) inputHandlerOld.parse(Array(termOld.cols + 1).join('a'));
+      for (let i = 0; i < termNew.rows; ++i) inputHandlerNew.parse(Array(termOld.cols + 1).join('a'));
+      const data = [];
+      for (let i = 0; i < termOld.rows; ++i) data.push(Array(termOld.cols + 1).join('a'));
+      expect(termContent(termOld)).eql(data);
+      expect(termContent(termOld)).eql(termContent(termNew));
+
+      // params [0] - right and below erase
+      termOld.buffer.y = 5;
+      termOld.buffer.x = 40;
+      inputHandlerOld.eraseInDisplay([0]);
+      termNew.buffer.y = 5;
+      termNew.buffer.x = 40;
+      inputHandlerNew.eraseInDisplay([0]);
+      expect(termContent(termNew)).eql(termContent(termOld));
+
+      // reset
+      termOld.buffer.y = 0;
+      termOld.buffer.x = 0;
+      termNew.buffer.y = 0;
+      termNew.buffer.x = 0;
+      for (let i = 0; i < termOld.rows; ++i) inputHandlerOld.parse(Array(termOld.cols + 1).join('a'));
+      for (let i = 0; i < termNew.rows; ++i) inputHandlerNew.parse(Array(termOld.cols + 1).join('a'));
+
+      // params [1] - left and above
+      termOld.buffer.y = 5;
+      termOld.buffer.x = 40;
+      inputHandlerOld.eraseInDisplay([1]);
+      termNew.buffer.y = 5;
+      termNew.buffer.x = 40;
+      inputHandlerNew.eraseInDisplay([1]);
+      expect(termContent(termNew)).eql(termContent(termOld));
+
+      // reset
+      termOld.buffer.y = 0;
+      termOld.buffer.x = 0;
+      termNew.buffer.y = 0;
+      termNew.buffer.x = 0;
+      for (let i = 0; i < termOld.rows; ++i) inputHandlerOld.parse(Array(termOld.cols + 1).join('a'));
+      for (let i = 0; i < termNew.rows; ++i) inputHandlerNew.parse(Array(termOld.cols + 1).join('a'));
+
+      // params [2] - whole screen
+      termOld.buffer.y = 5;
+      termOld.buffer.x = 40;
+      inputHandlerOld.eraseInDisplay([2]);
+      termNew.buffer.y = 5;
+      termNew.buffer.x = 40;
+      inputHandlerNew.eraseInDisplay([2]);
+      expect(termContent(termNew)).eql(termContent(termOld));
+    });
+  });
+  it('convertEol setting', function(): void {
+    // not converting
+    let s = '';
+    const termNotConverting = new Terminal({cols: 15, rows: 10});
+    (termNotConverting as any)._inputHandler.parse('Hello\nWorld');
+    for (let i = 0; i < termNotConverting.cols; ++i) {
+      s += termNotConverting.buffer.lines.get(0).get(i)[CHAR_DATA_CHAR_INDEX];
+    }
+    expect(s).equals('Hello          ');
+    s = '';
+    for (let i = 0; i < termNotConverting.cols; ++i) {
+      s += termNotConverting.buffer.lines.get(1).get(i)[CHAR_DATA_CHAR_INDEX];
+    }
+    expect(s).equals('     World     ');
+
+    // converting
+    s = '';
+    const termConverting = new Terminal({cols: 15, rows: 10, convertEol: true});
+    (termConverting as any)._inputHandler.parse('Hello\nWorld');
+    for (let i = 0; i < termConverting.cols; ++i) {
+      s += termConverting.buffer.lines.get(0).get(i)[CHAR_DATA_CHAR_INDEX];
+    }
+    expect(s).equals('Hello          ');
+    s = '';
+    for (let i = 0; i < termConverting.cols; ++i) {
+      s += termConverting.buffer.lines.get(1).get(i)[CHAR_DATA_CHAR_INDEX];
+    }
+    expect(s).equals('World          ');
+  });
 });

src/InputHandler.ts

@@ -4,7 +4,7 @@
  * @license MIT
  */
 
-import { CharData, IInputHandler, IDcsHandler, IEscapeSequenceParser, IBuffer, IInputHandlingTerminal } from './Types';
+import { IInputHandler, IDcsHandler, IEscapeSequenceParser, IBuffer, IInputHandlingTerminal } from './Types';
 import { C0, C1 } from './common/data/EscapeSequences';
 import { CHARSETS, DEFAULT_CHARSET } from './core/data/Charsets';
 import { CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, CHAR_DATA_CODE_INDEX, DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE } from './Buffer';
@@ -13,6 +13,7 @@ import { wcwidth } from './CharWidth';
 import { EscapeSequenceParser } from './EscapeSequenceParser';
 import { ICharset } from './core/Types';
 import { Disposable } from './common/Lifecycle';
+import { BufferLine } from './BufferLine';
 
 /**
  * Map collect to glevel. Used in `selectCharset`.
@@ -116,7 +117,7 @@ export class InputHandler extends Disposable implements IInputHandler {
   private _surrogateHigh: string;
 
   constructor(
-      private _terminal: IInputHandlingTerminal,
+      protected _terminal: IInputHandlingTerminal,
       private _parser: IEscapeSequenceParser = new EscapeSequenceParser())
   {
     super();
@@ -381,18 +382,20 @@ export class InputHandler extends Disposable implements IInputHandler {
       // since they always follow a cell consuming char
       // therefore we can test for buffer.x to avoid overflow left
       if (!chWidth && buffer.x) {
-        if (bufferRow[buffer.x - 1]) {
-          if (!bufferRow[buffer.x - 1][CHAR_DATA_WIDTH_INDEX]) {
+        const chMinusOne = bufferRow.get(buffer.x - 1);
+        if (chMinusOne) {
+          if (!chMinusOne[CHAR_DATA_WIDTH_INDEX]) {
             // found empty cell after fullwidth, need to go 2 cells back
             // it is save to step 2 cells back here
             // since an empty cell is only set by fullwidth chars
-            if (bufferRow[buffer.x - 2]) {
-              bufferRow[buffer.x - 2][CHAR_DATA_CHAR_INDEX] += char;
-              bufferRow[buffer.x - 2][CHAR_DATA_CODE_INDEX] = code;
+            const chMinusTwo = bufferRow.get(buffer.x - 2);
+            if (chMinusTwo) {
+              chMinusTwo[CHAR_DATA_CHAR_INDEX] += char;
+              chMinusTwo[CHAR_DATA_CODE_INDEX] = code;
             }
           } else {
-            bufferRow[buffer.x - 1][CHAR_DATA_CHAR_INDEX] += char;
-            bufferRow[buffer.x - 1][CHAR_DATA_CODE_INDEX] = code;
+            chMinusOne[CHAR_DATA_CHAR_INDEX] += char;
+            chMinusOne[CHAR_DATA_CODE_INDEX] = code;
           }
         }
         continue;
@@ -412,7 +415,7 @@ export class InputHandler extends Disposable implements IInputHandler {
           } else {
             // The line already exists (eg. the initial viewport), mark it as a
             // wrapped line
-            (<any>buffer.lines.get(buffer.y)).isWrapped = true;
+            buffer.lines.get(buffer.y).isWrapped = true;
           }
           // row changed, get it again
           bufferRow = buffer.lines.get(buffer.y + buffer.ybase);
@@ -435,10 +438,11 @@ export class InputHandler extends Disposable implements IInputHandler {
           // remove last cell
           // if it's width is 0, we have to adjust the second last cell as well
           const removed = bufferRow.pop();
+          const chMinusTwo = bufferRow.get(buffer.x - 2);
           if (removed[CHAR_DATA_WIDTH_INDEX] === 0
-              && bufferRow[this._terminal.cols - 2]
-              && bufferRow[this._terminal.cols - 2][CHAR_DATA_WIDTH_INDEX] === 2) {
-                bufferRow[this._terminal.cols - 2] = [curAttr, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE];
+              && chMinusTwo
+              && chMinusTwo[CHAR_DATA_WIDTH_INDEX] === 2) {
+                bufferRow.set(this._terminal.cols - 2, [curAttr, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
           }
 
           // insert empty cell at cursor
@@ -447,11 +451,11 @@ export class InputHandler extends Disposable implements IInputHandler {
       }
 
       // write current char to buffer and advance cursor
-      bufferRow[buffer.x++] = [curAttr, char, chWidth, code];
+      bufferRow.set(buffer.x++, [curAttr, char, chWidth, code]);
 
       // fullwidth char - also set next cell to placeholder stub and advance cursor
       if (chWidth === 2) {
-        bufferRow[buffer.x++] = [curAttr, '', 0, undefined];
+        bufferRow.set(buffer.x++, [curAttr, '', 0, undefined]);
       }
     }
     this._terminal.updateRange(buffer.y);
@@ -473,7 +477,7 @@ export class InputHandler extends Disposable implements IInputHandler {
     // make buffer local for faster access
     const buffer = this._terminal.buffer;
 
-    if (this._terminal.convertEol) {
+    if (this._terminal.options.convertEol) {
       buffer.x = 0;
     }
     buffer.y++;
@@ -546,20 +550,12 @@ export class InputHandler extends Disposable implements IInputHandler {
    * Insert Ps (Blank) Character(s) (default = 1) (ICH).
    */
   public insertChars(params: number[]): void {
-    let param = params[0];
-    if (param < 1) param = 1;
-
-    // make buffer local for faster access
-    const buffer = this._terminal.buffer;
-
-    const row = buffer.y + buffer.ybase;
-    let j = buffer.x;
-    const ch: CharData = [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
-
-    while (param-- && j < this._terminal.cols) {
-      buffer.lines.get(row).splice(j++, 0, ch);
-      buffer.lines.get(row).pop();
-    }
+    this._terminal.buffer.lines.get(this._terminal.buffer.y + this._terminal.buffer.ybase).insertCells(
+      this._terminal.buffer.x,
+      params[0] || 1,
+      [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+    );
+    this._terminal.updateRange(this._terminal.buffer.y);
   }
 
   /**
@@ -719,6 +715,21 @@ export class InputHandler extends Disposable implements IInputHandler {
     }
   }
 
+  /**
+   * Helper method to erase cells in a terminal row.
+   * The cell gets replaced with the eraseChar of the terminal.
+   * @param y row index
+   * @param start first cell index to be erased
+   * @param end   end - 1 is last erased cell
+   */
+  private _eraseInBufferLine(y: number, start: number, end: number): void {
+    this._terminal.buffer.lines.get(this._terminal.buffer.ybase + y).replaceCells(
+      start,
+      end,
+      [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+    );
+  }
+
   /**
    * CSI Ps J  Erase in Display (ED).
    *     Ps = 0  -> Erase Below (default).
@@ -735,22 +746,30 @@ export class InputHandler extends Disposable implements IInputHandler {
     let j;
     switch (params[0]) {
       case 0:
-        this._terminal.eraseRight(this._terminal.buffer.x, this._terminal.buffer.y);
-        j = this._terminal.buffer.y + 1;
+        j = this._terminal.buffer.y;
+        this._terminal.updateRange(j);
+        this._eraseInBufferLine(j++, this._terminal.buffer.x, this._terminal.cols);
         for (; j < this._terminal.rows; j++) {
-          this._terminal.eraseLine(j);
+          this._eraseInBufferLine(j, 0, this._terminal.cols);
         }
+        this._terminal.updateRange(j);
         break;
       case 1:
-        this._terminal.eraseLeft(this._terminal.buffer.x, this._terminal.buffer.y);
         j = this._terminal.buffer.y;
+        this._terminal.updateRange(j);
+        this._eraseInBufferLine(j, 0, this._terminal.buffer.x + 1);
         while (j--) {
-          this._terminal.eraseLine(j);
+          this._eraseInBufferLine(j, 0, this._terminal.cols);
         }
+        this._terminal.updateRange(0);
         break;
       case 2:
         j = this._terminal.rows;
-        while (j--) this._terminal.eraseLine(j);
+        this._terminal.updateRange(j - 1);
+        while (j--) {
+          this._eraseInBufferLine(j, 0, this._terminal.cols);
+        }
+        this._terminal.updateRange(0);
         break;
       case 3:
         // Clear scrollback (everything not in viewport)
@@ -780,15 +799,16 @@ export class InputHandler extends Disposable implements IInputHandler {
   public eraseInLine(params: number[]): void {
     switch (params[0]) {
       case 0:
-        this._terminal.eraseRight(this._terminal.buffer.x, this._terminal.buffer.y);
+        this._eraseInBufferLine(this._terminal.buffer.y, this._terminal.buffer.x, this._terminal.cols);
         break;
       case 1:
-        this._terminal.eraseLeft(this._terminal.buffer.x, this._terminal.buffer.y);
+        this._eraseInBufferLine(this._terminal.buffer.y, 0, this._terminal.buffer.x + 1);
         break;
       case 2:
-        this._terminal.eraseLine(this._terminal.buffer.y);
+        this._eraseInBufferLine(this._terminal.buffer.y, 0, this._terminal.cols);
         break;
     }
+    this._terminal.updateRange(this._terminal.buffer.y);
   }
 
   /**
@@ -812,7 +832,7 @@ export class InputHandler extends Disposable implements IInputHandler {
       // test: echo -e '\e[44m\e[1L\e[0m'
       // blankLine(true) - xterm/linux behavior
       buffer.lines.splice(scrollBottomAbsolute - 1, 1);
-      buffer.lines.splice(row, 0, this._terminal.blankLine(true));
+      buffer.lines.splice(row, 0, BufferLine.blankLine(this._terminal.cols, this._terminal.eraseAttr()));
     }
 
     // this.maxRange();
@@ -842,7 +862,7 @@ export class InputHandler extends Disposable implements IInputHandler {
       // test: echo -e '\e[44m\e[1M\e[0m'
       // blankLine(true) - xterm/linux behavior
       buffer.lines.splice(row, 1);
-      buffer.lines.splice(j, 0, this._terminal.blankLine(true));
+      buffer.lines.splice(j, 0, BufferLine.blankLine(this._terminal.cols, this._terminal.eraseAttr()));
     }
 
     // this.maxRange();
@@ -855,22 +875,12 @@ export class InputHandler extends Disposable implements IInputHandler {
    * Delete Ps Character(s) (default = 1) (DCH).
    */
   public deleteChars(params: number[]): void {
-    let param: number = params[0];
-    if (param < 1) {
-      param = 1;
-    }
-
-    // make buffer local for faster access
-    const buffer = this._terminal.buffer;
-
-    const row = buffer.y + buffer.ybase;
-    const ch: CharData = [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
-
-    while (param--) {
-      buffer.lines.get(row).splice(buffer.x, 1);
-      buffer.lines.get(row).push(ch);
-    }
-    this._terminal.updateRange(buffer.y);
+    this._terminal.buffer.lines.get(this._terminal.buffer.y + this._terminal.buffer.ybase).deleteCells(
+      this._terminal.buffer.x,
+      params[0] || 1,
+      [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+    );
+    this._terminal.updateRange(this._terminal.buffer.y);
   }
 
   /**
@@ -884,7 +894,7 @@ export class InputHandler extends Disposable implements IInputHandler {
 
     while (param--) {
       buffer.lines.splice(buffer.ybase + buffer.scrollTop, 1);
-      buffer.lines.splice(buffer.ybase + buffer.scrollBottom, 0, this._terminal.blankLine());
+      buffer.lines.splice(buffer.ybase + buffer.scrollBottom, 0, BufferLine.blankLine(this._terminal.cols, DEFAULT_ATTR));
     }
     // this.maxRange();
     this._terminal.updateRange(buffer.scrollTop);
@@ -903,7 +913,7 @@ export class InputHandler extends Disposable implements IInputHandler {
 
       while (param--) {
         buffer.lines.splice(buffer.ybase + buffer.scrollBottom, 1);
-        buffer.lines.splice(buffer.ybase + buffer.scrollTop, 0, this._terminal.blankLine());
+        buffer.lines.splice(buffer.ybase + buffer.scrollBottom, 0, BufferLine.blankLine(this._terminal.cols, DEFAULT_ATTR));
       }
       // this.maxRange();
       this._terminal.updateRange(buffer.scrollTop);
@@ -916,21 +926,11 @@ export class InputHandler extends Disposable implements IInputHandler {
    * Erase Ps Character(s) (default = 1) (ECH).
    */
   public eraseChars(params: number[]): void {
-    let param = params[0];
-    if (param < 1) {
-      param = 1;
-    }
-
-    // make buffer local for faster access
-    const buffer = this._terminal.buffer;
-
-    const row = buffer.y + buffer.ybase;
-    let j = buffer.x;
-    const ch: CharData = [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
-
-    while (param-- && j < this._terminal.cols) {
-      buffer.lines.get(row)[j++] = ch;
-    }
+    this._terminal.buffer.lines.get(this._terminal.buffer.y + this._terminal.buffer.ybase).replaceCells(
+      this._terminal.buffer.x,
+      this._terminal.buffer.x + (params[0] || 1),
+      [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+    );
   }
 
   /**
@@ -982,17 +982,14 @@ export class InputHandler extends Disposable implements IInputHandler {
    * CSI Ps b  Repeat the preceding graphic character Ps times (REP).
    */
   public repeatPrecedingCharacter(params: number[]): void {
-    let param = params[0] || 1;
-
     // make buffer local for faster access
     const buffer = this._terminal.buffer;
-
     const line = buffer.lines.get(buffer.ybase + buffer.y);
-    const ch = line[buffer.x - 1] || [DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE];
-
-    while (param--) {
-      line[buffer.x++] = ch;
-    }
+    line.replaceCells(buffer.x,
+      buffer.x + (params[0] || 1),
+      line.get(buffer.x - 1) || [DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+    );
+    // FIXME: no updateRange here?
   }
 
   /**
@@ -1631,6 +1628,9 @@ export class InputHandler extends Disposable implements IInputHandler {
         // not bold nor faint
         flags &= ~FLAGS.BOLD;
         flags &= ~FLAGS.DIM;
+      } else if (p === 23) {
+        // not italic
+        flags &= ~FLAGS.ITALIC;
       } else if (p === 24) {
         // not underlined
         flags &= ~FLAGS.UNDERLINE;

src/Linkifier.test.ts

@@ -5,10 +5,11 @@
 
 import { assert } from 'chai';
 import { IMouseZoneManager, IMouseZone } from './ui/Types';
-import { ILinkMatcher, LineData, ITerminal } from './Types';
+import { ILinkMatcher, ITerminal, IBufferLine } from './Types';
 import { Linkifier } from './Linkifier';
 import { MockBuffer, MockTerminal } from './utils/TestUtils.test';
 import { CircularList } from './common/CircularList';
+import { BufferLine } from './BufferLine';
 
 class TestLinkifier extends Linkifier {
   constructor(terminal: ITerminal) {
@@ -42,14 +43,14 @@ describe('Linkifier', () => {
     terminal = new MockTerminal();
     terminal.cols = 100;
     terminal.buffer = new MockBuffer();
-    (<MockBuffer>terminal.buffer).setLines(new CircularList<LineData>(20));
+    (<MockBuffer>terminal.buffer).setLines(new CircularList<IBufferLine>(20));
     terminal.buffer.ydisp = 0;
     linkifier = new TestLinkifier(terminal);
     mouseZoneManager = new TestMouseZoneManager();
   });
 
-  function stringToRow(text: string): LineData {
-    const result: LineData = [];
+  function stringToRow(text: string): IBufferLine {
+    const result = new BufferLine();
     for (let i = 0; i < text.length; i++) {
       result.push([0, text.charAt(i), 1, text.charCodeAt(i)]);
     }

src/Linkifier.ts

@@ -4,9 +4,10 @@
  */
 
 import { IMouseZoneManager } from './ui/Types';
-import { ILinkHoverEvent, ILinkMatcher, LinkMatcherHandler, LinkHoverEventTypes, ILinkMatcherOptions, ILinkifier, ITerminal, LineData } from './Types';
+import { ILinkHoverEvent, ILinkMatcher, LinkMatcherHandler, LinkHoverEventTypes, ILinkMatcherOptions, ILinkifier, ITerminal, IBufferLine } from './Types';
 import { MouseZone } from './ui/MouseZoneManager';
 import { EventEmitter } from './EventEmitter';
+import { CHAR_DATA_ATTR_INDEX } from './Buffer';
 
 /**
  * The Linkifier applies links to rows shortly after they have been refreshed.
@@ -24,7 +25,7 @@ export class Linkifier extends EventEmitter implements ILinkifier {
   private _mouseZoneManager: IMouseZoneManager;
   private _rowsTimeoutId: number;
   private _nextLinkMatcherId = 0;
-  private _rowsToLinkify: {start: number, end: number};
+  private _rowsToLinkify: { start: number, end: number };
 
   constructor(
     protected _terminal: ITerminal
@@ -163,13 +164,13 @@ export class Linkifier extends EventEmitter implements ILinkifier {
       return;
     }
 
-    if ((<any>this._terminal.buffer.lines.get(absoluteRowIndex)).isWrapped) {
+    if (this._terminal.buffer.lines.get(absoluteRowIndex).isWrapped) {
       // Only attempt to linkify rows that start in the viewport
       if (rowIndex !== 0) {
         return;
       }
       // If the first row is wrapped, backtrack to find the origin row and linkify that
-      let line: LineData;
+      let line: IBufferLine;
 
       do {
         rowIndex--;
@@ -180,14 +181,14 @@ export class Linkifier extends EventEmitter implements ILinkifier {
           break;
         }
 
-      } while ((<any>line).isWrapped);
+      } while (line.isWrapped);
     }
 
     // Construct full unwrapped line text
     let text = this._terminal.buffer.translateBufferLineToString(absoluteRowIndex, false);
     let currentIndex = absoluteRowIndex + 1;
     while (currentIndex < this._terminal.buffer.lines.length &&
-        (<any>this._terminal.buffer.lines.get(currentIndex)).isWrapped) {
+      this._terminal.buffer.lines.get(currentIndex).isWrapped) {
       text += this._terminal.buffer.translateBufferLineToString(currentIndex++, false);
     }
 
@@ -216,6 +217,12 @@ export class Linkifier extends EventEmitter implements ILinkifier {
     // Get index, match.index is for the outer match which includes negated chars
     const index = text.indexOf(uri);
 
+    // Get cell color
+    const line = this._terminal.buffer.lines.get(this._terminal.buffer.ydisp + rowIndex);
+    const char = line.get(index);
+    const attr: number = char[CHAR_DATA_ATTR_INDEX];
+    const fg = (attr >> 9) & 0x1ff;
+
     // Ensure the link is valid before registering
     if (matcher.validationCallback) {
       matcher.validationCallback(uri, isValid => {
@@ -224,11 +231,11 @@ export class Linkifier extends EventEmitter implements ILinkifier {
           return;
         }
         if (isValid) {
-          this._addLink(offset + index, rowIndex, uri, matcher);
+          this._addLink(offset + index, rowIndex, uri, matcher, fg);
         }
       });
     } else {
-      this._addLink(offset + index, rowIndex, uri, matcher);
+      this._addLink(offset + index, rowIndex, uri, matcher, fg);
     }
 
     // Recursively check for links in the rest of the text
@@ -245,8 +252,9 @@ export class Linkifier extends EventEmitter implements ILinkifier {
    * @param y The row the link is on.
    * @param uri The URI of the link.
    * @param matcher The link matcher for the link.
+   * @param fg The link color for hover event.
    */
-  private _addLink(x: number, y: number, uri: string, matcher: ILinkMatcher): void {
+  private _addLink(x: number, y: number, uri: string, matcher: ILinkMatcher, fg: number): void {
     const x1 = x % this._terminal.cols;
     const y1 = y + Math.floor(x / this._terminal.cols);
     let x2 = (x1 + uri.length) % this._terminal.cols;
@@ -268,17 +276,17 @@ export class Linkifier extends EventEmitter implements ILinkifier {
         window.open(uri, '_blank');
       },
       e => {
-        this.emit(LinkHoverEventTypes.HOVER, this._createLinkHoverEvent(x1, y1, x2, y2));
+        this.emit(LinkHoverEventTypes.HOVER, this._createLinkHoverEvent(x1, y1, x2, y2, fg));
         this._terminal.element.classList.add('xterm-cursor-pointer');
       },
       e => {
-        this.emit(LinkHoverEventTypes.TOOLTIP, this._createLinkHoverEvent(x1, y1, x2, y2));
+        this.emit(LinkHoverEventTypes.TOOLTIP, this._createLinkHoverEvent(x1, y1, x2, y2, fg));
         if (matcher.hoverTooltipCallback) {
           matcher.hoverTooltipCallback(e, uri);
         }
       },
       () => {
-        this.emit(LinkHoverEventTypes.LEAVE, this._createLinkHoverEvent(x1, y1, x2, y2));
+        this.emit(LinkHoverEventTypes.LEAVE, this._createLinkHoverEvent(x1, y1, x2, y2, fg));
         this._terminal.element.classList.remove('xterm-cursor-pointer');
         if (matcher.hoverLeaveCallback) {
           matcher.hoverLeaveCallback();
@@ -293,7 +301,7 @@ export class Linkifier extends EventEmitter implements ILinkifier {
     ));
   }
 
-  private _createLinkHoverEvent(x1: number, y1: number, x2: number, y2: number): ILinkHoverEvent {
-    return { x1, y1, x2, y2, cols: this._terminal.cols };
+  private _createLinkHoverEvent(x1: number, y1: number, x2: number, y2: number, fg: number): ILinkHoverEvent {
+    return { x1, y1, x2, y2, cols: this._terminal.cols, fg };
   }
 }

src/SelectionManager.test.ts

@@ -8,8 +8,9 @@ import { CharMeasure } from './ui/CharMeasure';
 import { SelectionManager, SelectionMode } from './SelectionManager';
 import { SelectionModel } from './SelectionModel';
 import { BufferSet } from './BufferSet';
-import { LineData, CharData, ITerminal, IBuffer } from './Types';
+import { ITerminal, IBuffer, IBufferLine } from './Types';
 import { MockTerminal } from './utils/TestUtils.test';
+import { BufferLine } from './BufferLine';
 
 class TestMockTerminal extends MockTerminal {
   emit(event: string, data: any): void {}
@@ -52,16 +53,18 @@ describe('SelectionManager', () => {
     selectionManager = new TestSelectionManager(terminal, null);
   });
 
-  function stringToRow(text: string): LineData {
-    const result: LineData = [];
+  function stringToRow(text: string): IBufferLine {
+    const result = new BufferLine();
     for (let i = 0; i < text.length; i++) {
       result.push([0, text.charAt(i), 1, text.charCodeAt(i)]);
     }
     return result;
   }
 
-  function stringArrayToRow(chars: string[]): LineData {
-    return chars.map(c => <CharData>[0, c, 1, c.charCodeAt(0)]);
+  function stringArrayToRow(chars: string[]): IBufferLine {
+    const line = new BufferLine();
+    chars.map(c => line.push([0, c, 1, c.charCodeAt(0)]));
+    return line;
   }
 
   describe('_selectWordAt', () => {
@@ -97,7 +100,8 @@ describe('SelectionManager', () => {
     });
     it('should expand selection for wide characters', () => {
       // Wide characters use a special format
-      buffer.lines.set(0, [
+      const line = new BufferLine();
+      const data: [number, string, number, number][] = [
         [null, '中', 2, '中'.charCodeAt(0)],
         [null, '', 0, null],
         [null, '文', 2, '文'.charCodeAt(0)],
@@ -113,7 +117,9 @@ describe('SelectionManager', () => {
         [null, 'f', 1, 'f'.charCodeAt(0)],
         [null, 'o', 1, 'o'.charCodeAt(0)],
         [null, 'o', 1, 'o'.charCodeAt(0)]
-      ]);
+      ];
+      for (let i = 0; i < data.length; ++i) line.push(data[i]);
+      buffer.lines.set(0, line);
       // Ensure wide characters take up 2 columns
       selectionManager.selectWordAt([0, 0]);
       assert.equal(selectionManager.selectionText, '中文');
@@ -186,7 +192,7 @@ describe('SelectionManager', () => {
     it('should expand upwards or downards for wrapped lines', () => {
       buffer.lines.set(0, stringToRow('                                                                             foo'));
       buffer.lines.set(1, stringToRow('bar                                                                             '));
-      (<any>buffer.lines.get(1)).isWrapped = true;
+      buffer.lines.get(1).isWrapped = true;
       selectionManager.selectWordAt([1, 1]);
       assert.equal(selectionManager.selectionText, 'foobar');
       selectionManager.model.clearSelection();
@@ -200,10 +206,10 @@ describe('SelectionManager', () => {
       buffer.lines.set(2, stringToRow('bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'));
       buffer.lines.set(3, stringToRow('cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'));
       buffer.lines.set(4, stringToRow('bar                                                                             '));
-      (<any>buffer.lines.get(1)).isWrapped = true;
-      (<any>buffer.lines.get(2)).isWrapped = true;
-      (<any>buffer.lines.get(3)).isWrapped = true;
-      (<any>buffer.lines.get(4)).isWrapped = true;
+      buffer.lines.get(1).isWrapped = true;
+      buffer.lines.get(2).isWrapped = true;
+      buffer.lines.get(3).isWrapped = true;
+      buffer.lines.get(4).isWrapped = true;
       selectionManager.selectWordAt([78, 0]);
       assert.equal(selectionManager.selectionText, expectedText);
       selectionManager.model.clearSelection();
@@ -339,7 +345,7 @@ describe('SelectionManager', () => {
     it('should select the entire wrapped line', () => {
       buffer.lines.set(0, stringToRow('foo'));
       const line2 = stringToRow('bar');
-      (<any>line2).isWrapped = true;
+      line2.isWrapped = true;
       buffer.lines.set(1, line2);
       selectionManager.selectLineAt(0);
       assert.equal(selectionManager.selectionText, 'foobar', 'The selected text is correct');

src/SelectionManager.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { ITerminal, ISelectionManager, IBuffer, CharData, XtermListener } from './Types';
+import { ITerminal, ISelectionManager, IBuffer, CharData, XtermListener, IBufferLine } from './Types';
 import { MouseHelper } from './utils/MouseHelper';
 import * as Browser from './shared/utils/Browser';
 import { CharMeasure } from './ui/CharMeasure';
@@ -204,7 +204,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
       for (let i = start[1] + 1; i <= end[1] - 1; i++) {
         const bufferLine = this._buffer.lines.get(i);
         const lineText = this._buffer.translateBufferLineToString(i, true);
-        if ((<any>bufferLine).isWrapped) {
+        if (bufferLine.isWrapped) {
           result[result.length - 1] += lineText;
         } else {
           result.push(lineText);
@@ -215,7 +215,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
       if (start[1] !== end[1]) {
         const bufferLine = this._buffer.lines.get(end[1]);
         const lineText = this._buffer.translateBufferLineToString(end[1], true, 0, end[0]);
-        if ((<any>bufferLine).isWrapped) {
+        if (bufferLine.isWrapped) {
           result[result.length - 1] += lineText;
         } else {
           result.push(lineText);
@@ -500,7 +500,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
 
     // If the mouse is over the second half of a wide character, adjust the
     // selection to cover the whole character
-    const char = line[this._model.selectionStart[0]];
+    const char = line.get(this._model.selectionStart[0]);
     if (char[CHAR_DATA_WIDTH_INDEX] === 0) {
       this._model.selectionStart[0]++;
     }
@@ -590,7 +590,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
     // selection. Note that selections at the very end of the line will never
     // have a character.
     if (this._model.selectionEnd[1] < this._buffer.lines.length) {
-      const char = this._buffer.lines.get(this._model.selectionEnd[1])[this._model.selectionEnd[0]];
+      const char = this._buffer.lines.get(this._model.selectionEnd[1]).get(this._model.selectionEnd[0]);
       if (char && char[CHAR_DATA_WIDTH_INDEX] === 0) {
         this._model.selectionEnd[0]++;
       }
@@ -661,10 +661,10 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
    * latter takes into account wide characters.
    * @param coords The coordinates to find the 2 index for.
    */
-  private _convertViewportColToCharacterIndex(bufferLine: any, coords: [number, number]): number {
+  private _convertViewportColToCharacterIndex(bufferLine: IBufferLine, coords: [number, number]): number {
     let charIndex = coords[0];
     for (let i = 0; coords[0] >= i; i++) {
-      const char = bufferLine[i];
+      const char = bufferLine.get(i);
       if (char[CHAR_DATA_WIDTH_INDEX] === 0) {
         // Wide characters aren't included in the line string so decrement the
         // index so the index is back on the wide character.
@@ -733,24 +733,24 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
 
       // Consider the initial position, skip it and increment the wide char
       // variable
-      if (bufferLine[startCol][CHAR_DATA_WIDTH_INDEX] === 0) {
+      if (bufferLine.get(startCol)[CHAR_DATA_WIDTH_INDEX] === 0) {
         leftWideCharCount++;
         startCol--;
       }
-      if (bufferLine[endCol][CHAR_DATA_WIDTH_INDEX] === 2) {
+      if (bufferLine.get(endCol)[CHAR_DATA_WIDTH_INDEX] === 2) {
         rightWideCharCount++;
         endCol++;
       }
 
       // Adjust the end index for characters whose length are > 1 (emojis)
-      if (bufferLine[endCol][CHAR_DATA_CHAR_INDEX].length > 1) {
-        rightLongCharOffset += bufferLine[endCol][CHAR_DATA_CHAR_INDEX].length - 1;
-        endIndex += bufferLine[endCol][CHAR_DATA_CHAR_INDEX].length - 1;
+      if (bufferLine.get(endCol)[CHAR_DATA_CHAR_INDEX].length > 1) {
+        rightLongCharOffset += bufferLine.get(endCol)[CHAR_DATA_CHAR_INDEX].length - 1;
+        endIndex += bufferLine.get(endCol)[CHAR_DATA_CHAR_INDEX].length - 1;
       }
 
       // Expand the string in both directions until a space is hit
-      while (startCol > 0 && startIndex > 0 && !this._isCharWordSeparator(bufferLine[startCol - 1])) {
-        const char = bufferLine[startCol - 1];
+      while (startCol > 0 && startIndex > 0 && !this._isCharWordSeparator(bufferLine.get(startCol - 1))) {
+        const char = bufferLine.get(startCol - 1);
         if (char[CHAR_DATA_WIDTH_INDEX] === 0) {
           // If the next character is a wide char, record it and skip the column
           leftWideCharCount++;
@@ -764,8 +764,8 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
         startIndex--;
         startCol--;
       }
-      while (endCol < bufferLine.length && endIndex + 1 < line.length && !this._isCharWordSeparator(bufferLine[endCol + 1])) {
-        const char = bufferLine[endCol + 1];
+      while (endCol < bufferLine.length && endIndex + 1 < line.length && !this._isCharWordSeparator(bufferLine.get(endCol + 1))) {
+        const char = bufferLine.get(endCol + 1);
         if (char[CHAR_DATA_WIDTH_INDEX] === 2) {
           // If the next character is a wide char, record it and skip the column
           rightWideCharCount++;
@@ -808,9 +808,9 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
 
     // Recurse upwards if the line is wrapped and the word wraps to the above line
     if (followWrappedLinesAbove) {
-      if (start === 0 && bufferLine[0][CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+      if (start === 0 && bufferLine.get(0)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
         const previousBufferLine = this._buffer.lines.get(coords[1] - 1);
-        if (previousBufferLine && (<any>bufferLine).isWrapped && previousBufferLine[this._terminal.cols - 1][CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+        if (previousBufferLine && bufferLine.isWrapped && previousBufferLine.get(this._terminal.cols - 1)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
           const previousLineWordPosition = this._getWordAt([this._terminal.cols - 1, coords[1] - 1], false, true, false);
           if (previousLineWordPosition) {
             const offset = this._terminal.cols - previousLineWordPosition.start;
@@ -823,9 +823,9 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
 
     // Recurse downwards if the line is wrapped and the word wraps to the next line
     if (followWrappedLinesBelow) {
-      if (start + length === this._terminal.cols && bufferLine[this._terminal.cols - 1][CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+      if (start + length === this._terminal.cols && bufferLine.get(this._terminal.cols - 1)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
         const nextBufferLine = this._buffer.lines.get(coords[1] + 1);
-        if (nextBufferLine && (<any>nextBufferLine).isWrapped && nextBufferLine[0][CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+        if (nextBufferLine && nextBufferLine.isWrapped && nextBufferLine.get(0)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
           const nextLineWordPosition = this._getWordAt([0, coords[1] + 1], false, false, true);
           if (nextLineWordPosition) {
             length += nextLineWordPosition.length;

src/Terminal.integration.ts

@@ -67,7 +67,7 @@ function terminalToString(term: Terminal): string {
   for (let line = term.buffer.ybase; line < term.buffer.ybase + term.rows; line++) {
     lineText = '';
     for (let cell = 0; cell < term.cols; ++cell) {
-      lineText += term.buffer.lines.get(line)[cell][CHAR_DATA_CHAR_INDEX];
+      lineText += term.buffer.lines.get(line).get(cell)[CHAR_DATA_CHAR_INDEX];
     }
     // rtrim empty cells as xterm does
     lineText = lineText.replace(/\s+$/, '');
@@ -105,6 +105,7 @@ if (os.platform() !== 'win32') {
     // omit stack trace for escape sequence files
     Error.stackTraceLimit = 0;
     const files = glob.sync('**/escape_sequence_files/*.in', { cwd: path.join(__dirname, '..')});
+    // for (let i = 0; i < files.length; ++i) console.debug(i, files[i]);
     // only successful tests for now
     const skip = [
       10, 16, 17, 19, 32, 33, 34, 35, 36, 39,
@@ -163,7 +164,5 @@ describe('typings', () => {
     const fixtureDir = path.join(__dirname, '..', 'fixtures', 'typings-test');
     const result = cp.spawnSync(tsc, { cwd: fixtureDir });
     assert.equal(result.status, 0, `build did not succeed:\nstdout: ${result.stdout.toString()}\nstderr: ${result.stderr.toString()}\n`);
-    // Clean up
-    fs.unlinkSync(path.join(fixtureDir, 'typings-test.js'));
   });
 });

src/Terminal.test.ts

@@ -6,7 +6,8 @@
 import { assert, expect } from 'chai';
 import { Terminal } from './Terminal';
 import { MockViewport, MockCompositionHelper, MockRenderer } from './utils/TestUtils.test';
-import { CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX } from './Buffer';
+import { CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, DEFAULT_ATTR } from './Buffer';
+import { BufferLine } from './BufferLine';
 
 const INIT_COLS = 80;
 const INIT_ROWS = 24;
@@ -141,7 +142,7 @@ describe('term.js addons', () => {
       assert.equal(term.buffer.lines.length, term.rows);
       assert.deepEqual(term.buffer.lines.get(0), promptLine);
       for (let i = 1; i < term.rows; i++) {
-        assert.deepEqual(term.buffer.lines.get(i), term.blankLine());
+        assert.deepEqual(term.buffer.lines.get(i), BufferLine.blankLine(term.cols, DEFAULT_ATTR));
       }
     });
     it('should clear a buffer larger than rows', () => {
@@ -158,7 +159,7 @@ describe('term.js addons', () => {
       assert.equal(term.buffer.lines.length, term.rows);
       assert.deepEqual(term.buffer.lines.get(0), promptLine);
       for (let i = 1; i < term.rows; i++) {
-        assert.deepEqual(term.buffer.lines.get(i), term.blankLine());
+        assert.deepEqual(term.buffer.lines.get(i), BufferLine.blankLine(term.cols, DEFAULT_ATTR));
       }
     });
     it('should not break the prompt when cleared twice', () => {
@@ -171,7 +172,7 @@ describe('term.js addons', () => {
       assert.equal(term.buffer.lines.length, term.rows);
       assert.deepEqual(term.buffer.lines.get(0), promptLine);
       for (let i = 1; i < term.rows; i++) {
-        assert.deepEqual(term.buffer.lines.get(i), term.blankLine());
+        assert.deepEqual(term.buffer.lines.get(i), BufferLine.blankLine(term.cols, DEFAULT_ATTR));
       }
     });
   });
@@ -337,62 +338,62 @@ describe('term.js addons', () => {
     describe('scroll() function', () => {
       describe('when scrollback > 0', () => {
         it('should create a new line and scroll', () => {
-          term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(INIT_ROWS - 1)[0][CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
+          term.buffer.lines.get(INIT_ROWS - 1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.scroll();
           assert.equal(term.buffer.lines.length, INIT_ROWS + 1);
-          assert.equal(term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 1)[0][CHAR_DATA_CHAR_INDEX], 'b');
-          assert.equal(term.buffer.lines.get(INIT_ROWS)[0][CHAR_DATA_CHAR_INDEX], ' ');
+          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 1).get(0)[CHAR_DATA_CHAR_INDEX], 'b');
+          assert.equal(term.buffer.lines.get(INIT_ROWS).get(0)[CHAR_DATA_CHAR_INDEX], ' ');
         });
 
         it('should properly scroll inside a scroll region (scrollTop set)', () => {
-          term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
+          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.scroll();
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX], 'c');
+          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
+          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
         });
 
         it('should properly scroll inside a scroll region (scrollBottom set)', () => {
-          term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX] = 'c';
-          term.buffer.lines.get(3)[0][CHAR_DATA_CHAR_INDEX] = 'd';
-          term.buffer.lines.get(4)[0][CHAR_DATA_CHAR_INDEX] = 'e';
+          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
+          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX] = 'd';
+          term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX] = 'e';
           term.buffer.y = 3;
           term.buffer.scrollBottom = 3;
           term.scroll();
           assert.equal(term.buffer.lines.length, INIT_ROWS + 1);
-          assert.equal(term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX], 'a', '\'a\' should be pushed to the scrollback');
-          assert.equal(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX], 'b');
-          assert.equal(term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX], 'c');
-          assert.equal(term.buffer.lines.get(3)[0][CHAR_DATA_CHAR_INDEX], 'd');
-          assert.equal(term.buffer.lines.get(4)[0][CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(5)[0][CHAR_DATA_CHAR_INDEX], 'e');
+          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a', '\'a\' should be pushed to the scrollback');
+          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'b');
+          assert.equal(term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
+          assert.equal(term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX], 'd');
+          assert.equal(term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(5).get(0)[CHAR_DATA_CHAR_INDEX], 'e');
         });
 
         it('should properly scroll inside a scroll region (scrollTop and scrollBottom set)', () => {
-          term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX] = 'c';
-          term.buffer.lines.get(3)[0][CHAR_DATA_CHAR_INDEX] = 'd';
-          term.buffer.lines.get(4)[0][CHAR_DATA_CHAR_INDEX] = 'e';
+          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
+          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX] = 'd';
+          term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX] = 'e';
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.buffer.scrollBottom = 3;
           term.scroll();
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX], 'c', '\'b\' should be removed from the buffer');
-          assert.equal(term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX], 'd');
-          assert.equal(term.buffer.lines.get(3)[0][CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4)[0][CHAR_DATA_CHAR_INDEX], 'e');
+          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
+          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c', '\'b\' should be removed from the buffer');
+          assert.equal(term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX], 'd');
+          assert.equal(term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX], 'e');
         });
       });
 
@@ -403,65 +404,65 @@ describe('term.js addons', () => {
         });
 
         it('should create a new line and shift everything up', () => {
-          term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(INIT_ROWS - 1)[0][CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
+          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(INIT_ROWS - 1).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           assert.equal(term.buffer.lines.length, INIT_ROWS);
           term.scroll();
           assert.equal(term.buffer.lines.length, INIT_ROWS);
           // 'a' gets pushed out of buffer
-          assert.equal(term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX], 'b');
-          assert.equal(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX], ' ');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 2)[0][CHAR_DATA_CHAR_INDEX], 'c');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 1)[0][CHAR_DATA_CHAR_INDEX], ' ');
+          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'b');
+          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], ' ');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 2).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 1).get(0)[CHAR_DATA_CHAR_INDEX], ' ');
         });
 
         it('should properly scroll inside a scroll region (scrollTop set)', () => {
-          term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
+          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.scroll();
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX], 'c');
+          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
+          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
         });
 
         it('should properly scroll inside a scroll region (scrollBottom set)', () => {
-          term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX] = 'c';
-          term.buffer.lines.get(3)[0][CHAR_DATA_CHAR_INDEX] = 'd';
-          term.buffer.lines.get(4)[0][CHAR_DATA_CHAR_INDEX] = 'e';
+          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
+          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX] = 'd';
+          term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX] = 'e';
           term.buffer.y = 3;
           term.buffer.scrollBottom = 3;
           term.scroll();
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX], 'b');
-          assert.equal(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX], 'c');
-          assert.equal(term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX], 'd');
-          assert.equal(term.buffer.lines.get(3)[0][CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4)[0][CHAR_DATA_CHAR_INDEX], 'e');
+          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'b');
+          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
+          assert.equal(term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX], 'd');
+          assert.equal(term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX], 'e');
         });
 
         it('should properly scroll inside a scroll region (scrollTop and scrollBottom set)', () => {
-          term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX] = 'c';
-          term.buffer.lines.get(3)[0][CHAR_DATA_CHAR_INDEX] = 'd';
-          term.buffer.lines.get(4)[0][CHAR_DATA_CHAR_INDEX] = 'e';
+          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
+          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX] = 'd';
+          term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX] = 'e';
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.buffer.scrollBottom = 3;
           term.scroll();
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0)[0][CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX], 'c', '\'b\' should be removed from the buffer');
-          assert.equal(term.buffer.lines.get(2)[0][CHAR_DATA_CHAR_INDEX], 'd');
-          assert.equal(term.buffer.lines.get(3)[0][CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4)[0][CHAR_DATA_CHAR_INDEX], 'e');
+          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
+          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c', '\'b\' should be removed from the buffer');
+          assert.equal(term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX], 'd');
+          assert.equal(term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX], 'e');
         });
       });
     });
@@ -654,11 +655,11 @@ describe('term.js addons', () => {
       const high = String.fromCharCode(0xD800);
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
         term.write(high + String.fromCharCode(i));
-        const tchar = term.buffer.lines.get(0)[0];
+        const tchar = term.buffer.lines.get(0).get(0);
         expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
         expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
         expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-        expect(term.buffer.lines.get(0)[1][CHAR_DATA_CHAR_INDEX]).eql(' ');
+        expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
         term.reset();
       }
     });
@@ -667,9 +668,9 @@ describe('term.js addons', () => {
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
         term.buffer.x = term.cols - 1;
         term.write(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0)[term.buffer.x - 1][CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0)[term.buffer.x - 1][CHAR_DATA_CHAR_INDEX].length).eql(2);
-        expect(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX]).eql(' ');
+        expect(term.buffer.lines.get(0).get(term.buffer.x - 1)[CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
+        expect(term.buffer.lines.get(0).get(term.buffer.x - 1)[CHAR_DATA_CHAR_INDEX].length).eql(2);
+        expect(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX]).eql(' ');
         term.reset();
       }
     });
@@ -679,10 +680,10 @@ describe('term.js addons', () => {
         term.buffer.x = term.cols - 1;
         term.wraparoundMode = true;
         term.write('a' + high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0)[term.cols - 1][CHAR_DATA_CHAR_INDEX]).eql('a');
-        expect(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(1)[0][CHAR_DATA_CHAR_INDEX].length).eql(2);
-        expect(term.buffer.lines.get(1)[1][CHAR_DATA_CHAR_INDEX]).eql(' ');
+        expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX]).eql('a');
+        expect(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
+        expect(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX].length).eql(2);
+        expect(term.buffer.lines.get(1).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
         term.reset();
       }
     });
@@ -693,9 +694,9 @@ describe('term.js addons', () => {
         term.wraparoundMode = false;
         term.write('a' + high + String.fromCharCode(i));
         // auto wraparound mode should cut off the rest of the line
-        expect(term.buffer.lines.get(0)[term.cols - 1][CHAR_DATA_CHAR_INDEX]).eql('a');
-        expect(term.buffer.lines.get(0)[term.cols - 1][CHAR_DATA_CHAR_INDEX].length).eql(1);
-        expect(term.buffer.lines.get(1)[1][CHAR_DATA_CHAR_INDEX]).eql(' ');
+        expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX]).eql('a');
+        expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX].length).eql(1);
+        expect(term.buffer.lines.get(1).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
         term.reset();
       }
     });
@@ -704,11 +705,11 @@ describe('term.js addons', () => {
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
         term.write(high);
         term.write(String.fromCharCode(i));
-        const tchar = term.buffer.lines.get(0)[0];
+        const tchar = term.buffer.lines.get(0).get(0);
         expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
         expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
         expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-        expect(term.buffer.lines.get(0)[1][CHAR_DATA_CHAR_INDEX]).eql(' ');
+        expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
         term.reset();
       }
     });
@@ -717,30 +718,30 @@ describe('term.js addons', () => {
   describe('unicode - combining characters', () => {
     it('café', () => {
       term.write('cafe\u0301');
-      expect(term.buffer.lines.get(0)[3][CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
-      expect(term.buffer.lines.get(0)[3][CHAR_DATA_CHAR_INDEX].length).eql(2);
-      expect(term.buffer.lines.get(0)[3][CHAR_DATA_WIDTH_INDEX]).eql(1);
+      expect(term.buffer.lines.get(0).get(3)[CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
+      expect(term.buffer.lines.get(0).get(3)[CHAR_DATA_CHAR_INDEX].length).eql(2);
+      expect(term.buffer.lines.get(0).get(3)[CHAR_DATA_WIDTH_INDEX]).eql(1);
     });
     it('café - end of line', () => {
       term.buffer.x = term.cols - 1 - 3;
       term.write('cafe\u0301');
-      expect(term.buffer.lines.get(0)[term.cols - 1][CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
-      expect(term.buffer.lines.get(0)[term.cols - 1][CHAR_DATA_CHAR_INDEX].length).eql(2);
-      expect(term.buffer.lines.get(0)[term.cols - 1][CHAR_DATA_WIDTH_INDEX]).eql(1);
-      expect(term.buffer.lines.get(0)[1][CHAR_DATA_CHAR_INDEX]).eql(' ');
-      expect(term.buffer.lines.get(0)[1][CHAR_DATA_CHAR_INDEX].length).eql(1);
-      expect(term.buffer.lines.get(0)[1][CHAR_DATA_WIDTH_INDEX]).eql(1);
+      expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
+      expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX].length).eql(2);
+      expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_WIDTH_INDEX]).eql(1);
+      expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
+      expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_CHAR_INDEX].length).eql(1);
+      expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_WIDTH_INDEX]).eql(1);
     });
     it('multiple combined é', () => {
       term.wraparoundMode = true;
       term.write(Array(100).join('e\u0301'));
       for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0)[i];
+        const tchar = term.buffer.lines.get(0).get(i);
         expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
         expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
         expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
       }
-      const tchar = term.buffer.lines.get(1)[0];
+      const tchar = term.buffer.lines.get(1).get(0);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
@@ -749,12 +750,12 @@ describe('term.js addons', () => {
       term.wraparoundMode = true;
       term.write(Array(100).join('\uD800\uDC00\u0301'));
       for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0)[i];
+        const tchar = term.buffer.lines.get(0).get(i);
         expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\uD800\uDC00\u0301');
         expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
         expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
       }
-      const tchar = term.buffer.lines.get(1)[0];
+      const tchar = term.buffer.lines.get(1).get(0);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\uD800\uDC00\u0301');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
@@ -777,7 +778,7 @@ describe('term.js addons', () => {
       term.wraparoundMode = true;
       term.write(Array(50).join('￥'));
       for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0)[i];
+        const tchar = term.buffer.lines.get(0).get(i);
         if (i % 2) {
           expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
           expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
@@ -788,7 +789,7 @@ describe('term.js addons', () => {
           expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
         }
       }
-      const tchar = term.buffer.lines.get(1)[0];
+      const tchar = term.buffer.lines.get(1).get(0);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
@@ -798,7 +799,7 @@ describe('term.js addons', () => {
       term.buffer.x = 1;
       term.write(Array(50).join('￥'));
       for (let i = 1; i < term.cols - 1; ++i) {
-        const tchar = term.buffer.lines.get(0)[i];
+        const tchar = term.buffer.lines.get(0).get(i);
         if (!(i % 2)) {
           expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
           expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
@@ -809,11 +810,11 @@ describe('term.js addons', () => {
           expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
         }
       }
-      let tchar = term.buffer.lines.get(0)[term.cols - 1];
+      let tchar = term.buffer.lines.get(0).get(term.cols - 1);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(' ');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-      tchar = term.buffer.lines.get(1)[0];
+      tchar = term.buffer.lines.get(1).get(0);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
@@ -823,7 +824,7 @@ describe('term.js addons', () => {
       term.buffer.x = 1;
       term.write(Array(50).join('￥\u0301'));
       for (let i = 1; i < term.cols - 1; ++i) {
-        const tchar = term.buffer.lines.get(0)[i];
+        const tchar = term.buffer.lines.get(0).get(i);
         if (!(i % 2)) {
           expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
           expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
@@ -834,11 +835,11 @@ describe('term.js addons', () => {
           expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
         }
       }
-      let tchar = term.buffer.lines.get(0)[term.cols - 1];
+      let tchar = term.buffer.lines.get(0).get(term.cols - 1);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(' ');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-      tchar = term.buffer.lines.get(1)[0];
+      tchar = term.buffer.lines.get(1).get(0);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥\u0301');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
@@ -847,7 +848,7 @@ describe('term.js addons', () => {
       term.wraparoundMode = true;
       term.write(Array(50).join('￥\u0301'));
       for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0)[i];
+        const tchar = term.buffer.lines.get(0).get(i);
         if (i % 2) {
           expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
           expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
@@ -858,7 +859,7 @@ describe('term.js addons', () => {
           expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
         }
       }
-      const tchar = term.buffer.lines.get(1)[0];
+      const tchar = term.buffer.lines.get(1).get(0);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥\u0301');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
@@ -868,7 +869,7 @@ describe('term.js addons', () => {
       term.buffer.x = 1;
       term.write(Array(50).join('\ud843\ude6d\u0301'));
       for (let i = 1; i < term.cols - 1; ++i) {
-        const tchar = term.buffer.lines.get(0)[i];
+        const tchar = term.buffer.lines.get(0).get(i);
         if (!(i % 2)) {
           expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
           expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
@@ -879,11 +880,11 @@ describe('term.js addons', () => {
           expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
         }
       }
-      let tchar = term.buffer.lines.get(0)[term.cols - 1];
+      let tchar = term.buffer.lines.get(0).get(term.cols - 1);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(' ');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-      tchar = term.buffer.lines.get(1)[0];
+      tchar = term.buffer.lines.get(1).get(0);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\ud843\ude6d\u0301');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
@@ -892,7 +893,7 @@ describe('term.js addons', () => {
       term.wraparoundMode = true;
       term.write(Array(50).join('\ud843\ude6d\u0301'));
       for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0)[i];
+        const tchar = term.buffer.lines.get(0).get(i);
         if (i % 2) {
           expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
           expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
@@ -903,7 +904,7 @@ describe('term.js addons', () => {
           expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
         }
       }
-      const tchar = term.buffer.lines.get(1)[0];
+      const tchar = term.buffer.lines.get(1).get(0);
       expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\ud843\ude6d\u0301');
       expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
       expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
@@ -918,10 +919,10 @@ describe('term.js addons', () => {
       term.insertMode = true;
       term.write('abcde');
       expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0)[10][CHAR_DATA_CHAR_INDEX]).eql('a');
-      expect(term.buffer.lines.get(0)[14][CHAR_DATA_CHAR_INDEX]).eql('e');
-      expect(term.buffer.lines.get(0)[15][CHAR_DATA_CHAR_INDEX]).eql('0');
-      expect(term.buffer.lines.get(0)[79][CHAR_DATA_CHAR_INDEX]).eql('4');
+      expect(term.buffer.lines.get(0).get(10)[CHAR_DATA_CHAR_INDEX]).eql('a');
+      expect(term.buffer.lines.get(0).get(14)[CHAR_DATA_CHAR_INDEX]).eql('e');
+      expect(term.buffer.lines.get(0).get(15)[CHAR_DATA_CHAR_INDEX]).eql('0');
+      expect(term.buffer.lines.get(0).get(79)[CHAR_DATA_CHAR_INDEX]).eql('4');
     });
     it('fullwidth - insert', () => {
       term.write(Array(9).join('0123456789').slice(-80));
@@ -930,11 +931,11 @@ describe('term.js addons', () => {
       term.insertMode = true;
       term.write('￥￥￥');
       expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0)[10][CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(term.buffer.lines.get(0)[11][CHAR_DATA_CHAR_INDEX]).eql('');
-      expect(term.buffer.lines.get(0)[14][CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(term.buffer.lines.get(0)[15][CHAR_DATA_CHAR_INDEX]).eql('');
-      expect(term.buffer.lines.get(0)[79][CHAR_DATA_CHAR_INDEX]).eql('3');
+      expect(term.buffer.lines.get(0).get(10)[CHAR_DATA_CHAR_INDEX]).eql('￥');
+      expect(term.buffer.lines.get(0).get(11)[CHAR_DATA_CHAR_INDEX]).eql('');
+      expect(term.buffer.lines.get(0).get(14)[CHAR_DATA_CHAR_INDEX]).eql('￥');
+      expect(term.buffer.lines.get(0).get(15)[CHAR_DATA_CHAR_INDEX]).eql('');
+      expect(term.buffer.lines.get(0).get(79)[CHAR_DATA_CHAR_INDEX]).eql('3');
     });
     it('fullwidth - right border', () => {
       term.write(Array(41).join('￥'));
@@ -943,14 +944,14 @@ describe('term.js addons', () => {
       term.insertMode = true;
       term.write('a');
       expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0)[10][CHAR_DATA_CHAR_INDEX]).eql('a');
-      expect(term.buffer.lines.get(0)[11][CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(term.buffer.lines.get(0)[79][CHAR_DATA_CHAR_INDEX]).eql(' ');  // fullwidth char got replaced
+      expect(term.buffer.lines.get(0).get(10)[CHAR_DATA_CHAR_INDEX]).eql('a');
+      expect(term.buffer.lines.get(0).get(11)[CHAR_DATA_CHAR_INDEX]).eql('￥');
+      expect(term.buffer.lines.get(0).get(79)[CHAR_DATA_CHAR_INDEX]).eql(' ');  // fullwidth char got replaced
       term.write('b');
       expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0)[11][CHAR_DATA_CHAR_INDEX]).eql('b');
-      expect(term.buffer.lines.get(0)[12][CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(term.buffer.lines.get(0)[79][CHAR_DATA_CHAR_INDEX]).eql('');  // empty cell after fullwidth
+      expect(term.buffer.lines.get(0).get(11)[CHAR_DATA_CHAR_INDEX]).eql('b');
+      expect(term.buffer.lines.get(0).get(12)[CHAR_DATA_CHAR_INDEX]).eql('￥');
+      expect(term.buffer.lines.get(0).get(79)[CHAR_DATA_CHAR_INDEX]).eql('');  // empty cell after fullwidth
     });
   });
 });

src/Terminal.ts

@@ -21,7 +21,7 @@
  *   http://linux.die.net/man/7/urxvt
  */
 
-import { IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminalOptions, ITerminal, IBrowser, ILinkifier, ILinkMatcherOptions, CustomKeyEventHandler, LinkMatcherHandler, CharData, LineData, CharacterJoinerHandler } from './Types';
+import { IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminalOptions, ITerminal, IBrowser, ILinkifier, ILinkMatcherOptions, CustomKeyEventHandler, LinkMatcherHandler, CharData, CharacterJoinerHandler } from './Types';
 import { IMouseZoneManager } from './ui/Types';
 import { IRenderer } from './renderer/Types';
 import { BufferSet } from './BufferSet';
@@ -52,6 +52,7 @@ import { DomRenderer } from './renderer/dom/DomRenderer';
 import { IKeyboardEvent } from './common/Types';
 import { evaluateKeyboardEvent } from './core/input/Keyboard';
 import { KeyboardResultType, ICharset } from './core/Types';
+import { BufferLine } from './BufferLine';
 
 // Let it work inside Node.js for automated testing purposes.
 const document = (typeof window !== 'undefined') ? window.document : null;
@@ -133,7 +134,6 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
   // TODO: This can be changed to an enum or boolean, 0 and 1 seem to be the only options
   public cursorState: number;
   public cursorHidden: boolean;
-  public convertEol: boolean;
 
   private _customKeyEventHandler: CustomKeyEventHandler;
 
@@ -251,7 +251,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
 
   private _setup(): void {
     Object.keys(DEFAULT_OPTIONS).forEach((key) => {
-      if (this.options[key] == null) {
+      if (this.options[key] === null || this.options[key] === undefined) {
         this.options[key] = DEFAULT_OPTIONS[key];
       }
     });
@@ -503,10 +503,11 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
   /**
    * Binds the desired focus behavior on a given terminal object.
    */
-  private _onTextAreaFocus(): void {
+  private _onTextAreaFocus(ev: KeyboardEvent): void {
     if (this.sendFocus) {
       this.handler(C0.ESC + '[I');
     }
+    this.updateCursorStyle(ev);
     this.element.classList.add('focus');
     this.showCursor();
     this.emit('focus');
@@ -679,7 +680,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
     this.textarea.setAttribute('autocapitalize', 'off');
     this.textarea.setAttribute('spellcheck', 'false');
     this.textarea.tabIndex = 0;
-    this.register(addDisposableDomListener(this.textarea, 'focus', () => this._onTextAreaFocus()));
+    this.register(addDisposableDomListener(this.textarea, 'focus', (ev: KeyboardEvent) => this._onTextAreaFocus(ev)));
     this.register(addDisposableDomListener(this.textarea, 'blur', () => this._onTextAreaBlur()));
     this._helperContainer.appendChild(this.textarea);
 
@@ -960,9 +961,9 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
       // 1, and 2 - with 64 added
       switch ((<any>ev).overrideType || ev.type) {
         case 'mousedown':
-          button = ev.button != null
+          button = ev.button !== null && ev.button !== undefined
             ? +ev.button
-          : ev.which != null
+          : ev.which !== null && ev.which !== undefined
             ? ev.which - 1
           : null;
 
@@ -1169,7 +1170,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    * @param isWrapped Whether the new line is wrapped from the previous line.
    */
   public scroll(isWrapped?: boolean): void {
-    const newLine = this.blankLine(undefined, isWrapped);
+    const newLine = BufferLine.blankLine(this.cols, DEFAULT_ATTR, isWrapped);
     const topRow = this.buffer.ybase + this.buffer.scrollTop;
     const bottomRow = this.buffer.ybase + this.buffer.scrollBottom;
 
@@ -1587,7 +1588,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
 
     if (ev.charCode) {
       key = ev.charCode;
-    } else if (ev.which == null) {
+    } else if (ev.which === null || ev.which === undefined) {
       key = ev.keyCode;
     } else if (ev.which !== 0 && ev.charCode !== 0) {
       key = ev.which;
@@ -1707,41 +1708,6 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
     this._refreshEnd = this.rows - 1;
   }
 
-  /**
-   * Erase in the identified line everything from "x" to the end of the line (right).
-   * @param x The column from which to start erasing to the end of the line.
-   * @param y The line in which to operate.
-   */
-  public eraseRight(x: number, y: number): void {
-    const line = this.buffer.lines.get(this.buffer.ybase + y);
-    if (!line) {
-      return;
-    }
-    const ch: CharData = [this.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
-    for (; x < this.cols; x++) {
-      line[x] = ch;
-    }
-    this.updateRange(y);
-  }
-
-  /**
-   * Erase in the identified line everything from "x" to the start of the line (left).
-   * @param x The column from which to start erasing to the start of the line.
-   * @param y The line in which to operate.
-   */
-  public eraseLeft(x: number, y: number): void {
-    const line = this.buffer.lines.get(this.buffer.ybase + y);
-    if (!line) {
-      return;
-    }
-    const ch: CharData = [this.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
-    x++;
-    while (x--) {
-      line[x] = ch;
-    }
-    this.updateRange(y);
-  }
-
   /**
    * Clear the entire buffer, making the prompt line the new first line.
    */
@@ -1756,47 +1722,12 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
     this.buffer.ybase = 0;
     this.buffer.y = 0;
     for (let i = 1; i < this.rows; i++) {
-      this.buffer.lines.push(this.blankLine());
+      this.buffer.lines.push(BufferLine.blankLine(this.cols, DEFAULT_ATTR));
     }
     this.refresh(0, this.rows - 1);
     this.emit('scroll', this.buffer.ydisp);
   }
 
-  /**
-   * Erase all content in the given line
-   * @param y The line to erase all of its contents.
-   */
-  public eraseLine(y: number): void {
-    this.eraseRight(0, y);
-  }
-
-  /**
-   * Return the data array of a blank line
-   * @param cur First bunch of data for each "blank" character.
-   * @param isWrapped Whether the new line is wrapped from the previous line.
-   * @param cols The number of columns in the terminal, if this is not
-   * set, the terminal's current column count would be used.
-   */
-  public blankLine(cur?: boolean, isWrapped?: boolean, cols?: number): LineData {
-    const attr = cur ? this.eraseAttr() : DEFAULT_ATTR;
-
-    const ch: CharData = [attr, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // width defaults to 1 halfwidth character
-    const line: LineData = [];
-
-    // TODO: It is not ideal that this is a property on an array, a buffer line
-    // class should be added that will hold this data and other useful functions.
-    if (isWrapped) {
-      (<any>line).isWrapped = isWrapped;
-    }
-
-    cols = cols || this.cols;
-    for (let i = 0; i < cols; i++) {
-      line[i] = ch;
-    }
-
-    return line;
-  }
-
   /**
    * If cur return the back color xterm feature attribute. Else return default attribute.
    * @param cur
@@ -1883,7 +1814,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
       // blankLine(true) is xterm/linux behavior
       const scrollRegionHeight = this.buffer.scrollBottom - this.buffer.scrollTop;
       this.buffer.lines.shiftElements(this.buffer.y + this.buffer.ybase, scrollRegionHeight, 1);
-      this.buffer.lines.set(this.buffer.y + this.buffer.ybase, this.blankLine(true));
+      this.buffer.lines.set(this.buffer.y + this.buffer.ybase, BufferLine.blankLine(this.cols, this.eraseAttr()));
       this.updateRange(this.buffer.scrollTop);
       this.updateRange(this.buffer.scrollBottom);
     } else {
@@ -1932,7 +1863,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
   public matchColor(r1: number, g1: number, b1: number): number {
     const hash = (r1 << 16) | (g1 << 8) | b1;
 
-    if (matchColorCache[hash] != null) {
+    if (matchColorCache[hash] !== null && matchColorCache[hash] !== undefined) {
       return matchColorCache[hash];
     }
 

src/Types.ts

@@ -66,15 +66,10 @@ export interface IInputHandlingTerminal extends IEventEmitter {
 
   bell(): void;
   focus(): void;
-  convertEol: boolean;
   updateRange(y: number): void;
   scroll(isWrapped?: boolean): void;
   setgLevel(g: number): void;
   eraseAttr(): number;
-  eraseRight(x: number, y: number): void;
-  eraseLine(y: number): void;
-  eraseLeft(x: number, y: number): void;
-  blankLine(cur?: boolean, isWrapped?: boolean): LineData;
   is(term: string): boolean;
   setgCharset(g: number, charset: ICharset): void;
   resize(x: number, y: number): void;
@@ -204,6 +199,7 @@ export interface ILinkHoverEvent {
   x2: number;
   y2: number;
   cols: number;
+  fg: number;
 }
 
 export interface ITerminal extends PublicTerminal, IElementAccessor, IBufferAccessor, ILinkifierAccessor {
@@ -233,7 +229,6 @@ export interface ITerminal extends PublicTerminal, IElementAccessor, IBufferAcce
   cancel(ev: Event, force?: boolean): boolean | void;
   log(text: string): void;
   showCursor(): void;
-  blankLine(cur?: boolean, isWrapped?: boolean, cols?: number): LineData;
 }
 
 export interface IBufferAccessor {
@@ -272,7 +267,7 @@ export interface ITerminalOptions extends IPublicTerminalOptions {
 }
 
 export interface IBuffer {
-  readonly lines: ICircularList<LineData>;
+  readonly lines: ICircularList<IBufferLine>;
   ydisp: number;
   ybase: number;
   y: number;
@@ -511,3 +506,19 @@ export interface IEscapeSequenceParser extends IDisposable {
   setErrorHandler(callback: (state: IParsingState) => IParsingState): void;
   clearErrorHandler(): void;
 }
+
+/**
+ * Interface for a line in the terminal buffer.
+ */
+export interface IBufferLine {
+  length: number;
+  isWrapped: boolean;
+  get(index: number): CharData;
+  set(index: number, value: CharData): void;
+  pop(): CharData | undefined;
+  push(data: CharData): void;
+  splice(start: number, deleteCount: number, ...items: CharData[]): CharData[];
+  insertCells(pos: number, n: number, ch: CharData): void;
+  deleteCells(pos: number, n: number, fill: CharData): void;
+  replaceCells(start: number, end: number, fill: CharData): void;
+}

src/Viewport.ts

@@ -28,6 +28,9 @@ export class Viewport extends Disposable implements IViewport {
   // quick fix and could have a more robust solution in place that reset the value when needed.
   private _wheelPartialScroll: number = 0;
 
+  private _refreshAnimationFrame: number | null = null;
+  private _ignoreNextScrollEvent: boolean = false;
+
   /**
    * Creates a new Viewport.
    * @param _terminal The terminal this viewport belongs to.
@@ -62,6 +65,12 @@ export class Viewport extends Disposable implements IViewport {
    * necessary.
    */
   private _refresh(): void {
+    if (this._refreshAnimationFrame === null) {
+      this._refreshAnimationFrame = requestAnimationFrame(() => this._innerRefresh());
+    }
+  }
+
+  private _innerRefresh(): void {
     if (this._charMeasure.height > 0) {
       this._currentRowHeight = this._terminal.renderer.dimensions.scaledCellHeight / window.devicePixelRatio;
       this._lastRecordedViewportHeight = this._viewportElement.offsetHeight;
@@ -71,6 +80,17 @@ export class Viewport extends Disposable implements IViewport {
         this._scrollArea.style.height = this._lastRecordedBufferHeight + 'px';
       }
     }
+
+    // Sync scrollTop
+    const scrollTop = this._terminal.buffer.ydisp * this._currentRowHeight;
+    if (this._viewportElement.scrollTop !== scrollTop) {
+      // Ignore the next scroll event which will be triggered by setting the scrollTop as we do not
+      // want this event to scroll the terminal
+      this._ignoreNextScrollEvent = true;
+      this._viewportElement.scrollTop = scrollTop;
+    }
+
+    this._refreshAnimationFrame = null;
   }
 
   /**
@@ -90,12 +110,6 @@ export class Viewport extends Disposable implements IViewport {
         this._refresh();
       }
     }
-
-    // Sync scrollTop
-    const scrollTop = this._terminal.buffer.ydisp * this._currentRowHeight;
-    if (this._viewportElement.scrollTop !== scrollTop) {
-      this._viewportElement.scrollTop = scrollTop;
-    }
   }
 
   /**
@@ -110,6 +124,13 @@ export class Viewport extends Disposable implements IViewport {
       return;
     }
 
+    // Ignore the event if it was flagged to ignore (when the source of the event is from Viewport)
+    if (this._ignoreNextScrollEvent) {
+      this._ignoreNextScrollEvent = false;
+      return;
+    }
+
+
     const newRow = Math.round(this._viewportElement.scrollTop / this._currentRowHeight);
     const diff = newRow - this._terminal.buffer.ydisp;
     this._terminal.scrollLines(diff, true);

src/addons/attach/attach.ts

@@ -53,7 +53,7 @@ export function attach(term: Terminal, socket: WebSocket, bidirectional: boolean
         const fileReader = new FileReader();
 
         fileReader.addEventListener('load', () => {
-          str = myTextDecoder.decode(this.result);
+          str = myTextDecoder.decode(fileReader.result);
           displayData(str);
         });
         fileReader.readAsArrayBuffer(ev.data);

src/addons/search/SearchHelper.ts

@@ -117,7 +117,7 @@ export class SearchHelper implements ISearchHelper {
     if (searchIndex >= 0) {
       const line = this._terminal._core.buffer.lines.get(y);
       for (let i = 0; i < searchIndex; i++) {
-        const charData = line[i];
+        const charData = line.get(i);
         // Adjust the searchIndex to normalize emoji into single chars
         const char = charData[1/*CHAR_DATA_CHAR_INDEX*/];
         if (char.length > 1) {

src/addons/search/search.test.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { assert, expect } from 'chai';
+import * as search from './search';
+import { SearchHelper } from './SearchHelper';
+import { ISearchHelper } from './Interfaces';
+
+
+class MockTerminalPlain {}
+
+class MockTerminal {
+  private _core: any;
+  public searchHelper: ISearchHelper;
+  constructor(options: any) {
+    this._core = new (require('../../../lib/Terminal').Terminal)(options);
+    this.searchHelper = new SearchHelper(this as any);
+  }
+  get core(): any {
+    return this._core;
+  }
+  pushWriteData(): void {
+    this._core._innerWrite();
+  }
+}
+
+describe('search addon', function(): void {
+  describe('apply', () => {
+    it('should register findNext and findPrevious', () => {
+      search.apply(<any>MockTerminalPlain);
+      assert.equal(typeof (<any>MockTerminalPlain).prototype.findNext, 'function');
+      assert.equal(typeof (<any>MockTerminalPlain).prototype.findPrevious, 'function');
+    });
+  });
+  it('Searchhelper - should find correct position', function(): void {
+    search.apply(<any>MockTerminal);
+    const term = new MockTerminal({cols: 20, rows: 3});
+    term.core.write('Hello World\r\ntest\n123....hello');
+    term.pushWriteData();
+    const hello0 = (term.searchHelper as any)._findInLine('Hello', 0);
+    const hello1 = (term.searchHelper as any)._findInLine('Hello', 1);
+    const hello2 = (term.searchHelper as any)._findInLine('Hello', 2);
+    expect(hello0).eql({col: 0, row: 0, term: 'Hello'});
+    expect(hello1).eql(undefined);
+    expect(hello2).eql({col: 11, row: 2, term: 'Hello'});
+  });
+});

src/addons/winptyCompat/winptyCompat.ts

@@ -30,11 +30,11 @@ export function winptyCompatInit(terminal: Terminal): void {
   // wrapped.
   addonTerminal.on('linefeed', () => {
     const line = addonTerminal._core.buffer.lines.get(addonTerminal._core.buffer.ybase + addonTerminal._core.buffer.y - 1);
-    const lastChar = line[addonTerminal.cols - 1];
+    const lastChar = line.get(addonTerminal.cols - 1);
 
     if (lastChar[CHAR_DATA_CODE_INDEX] !== NULL_CELL_CODE) {
       const nextLine = addonTerminal._core.buffer.lines.get(addonTerminal._core.buffer.ybase + addonTerminal._core.buffer.y);
-      (<any>nextLine).isWrapped = true;
+      nextLine.isWrapped = true;
     }
   });
 }

src/handlers/AltClickHandler.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { ITerminal, ICircularList, LineData } from '../Types';
+import { ITerminal, ICircularList, IBufferLine } from '../Types';
 import { C0 } from '../common/data/EscapeSequences';
 
 const enum Direction {
@@ -18,7 +18,7 @@ export class AltClickHandler {
   private _startCol: number;
   private _endRow: number;
   private _endCol: number;
-  private _lines: ICircularList<LineData>;
+  private _lines: ICircularList<IBufferLine>;
 
   constructor(
     private _mouseEvent: MouseEvent,
@@ -138,7 +138,7 @@ export class AltClickHandler {
     for (let i = 0; i < Math.abs(startRow - endRow); i++) {
       const direction = this._verticalDirection() === Direction.UP ? -1 : 1;
 
-      if ((<any>this._lines.get(startRow + (direction * i))).isWrapped) {
+      if (this._lines.get(startRow + (direction * i)).isWrapped) {
         wrappedRows++;
       }
     }
@@ -152,12 +152,12 @@ export class AltClickHandler {
    */
   private _wrappedRowsForRow(currentRow: number): number {
     let rowCount = 0;
-    let lineWraps = (<any>this._lines.get(currentRow)).isWrapped;
+    let lineWraps = this._lines.get(currentRow).isWrapped;
 
     while (lineWraps && currentRow >= 0 && currentRow < this._terminal.rows) {
       rowCount++;
       currentRow--;
-      lineWraps = (<any>this._lines.get(currentRow)).isWrapped;
+      lineWraps = this._lines.get(currentRow).isWrapped;
     }
 
     return rowCount;

src/renderer/CharacterJoinerRegistry.test.ts

@@ -1,11 +1,12 @@
 import { assert } from 'chai';
 
-import { LineData, CharData } from '../Types';
 import { MockTerminal, MockBuffer } from '../utils/TestUtils.test';
 import { CircularList } from '../common/CircularList';
 
 import { ICharacterJoinerRegistry } from './Types';
 import { CharacterJoinerRegistry } from './CharacterJoinerRegistry';
+import { BufferLine } from '../BufferLine';
+import { IBufferLine } from '../Types';
 
 describe('CharacterJoinerRegistry', () => {
   let registry: ICharacterJoinerRegistry;
@@ -14,22 +15,25 @@ describe('CharacterJoinerRegistry', () => {
     const terminal = new MockTerminal();
     terminal.cols = 16;
     terminal.buffer = new MockBuffer();
-    const lines = new CircularList<LineData>(7);
-    lines.set(0, lineData('a -> b -> c -> d'));
-    lines.set(1, lineData('a -> b => c -> d'));
-    lines.set(2, [...lineData('a -> b -', 0xFFFFFFFF), ...lineData('> c -> d', 0)]);
-    lines.set(3, lineData('no joined ranges'));
-    lines.set(4, []);
-    lines.set(5, [...lineData('a', 0x11111111), ...lineData(' -> b -> c -> '), ...lineData('d', 0x22222222)]);
-    lines.set(6, [
-      ...lineData('wi'),
-      [0, '￥', 2, '￥'.charCodeAt(0)],
-      [0, '', 0, null],
-      ...lineData('deemo'),
-      [0, '\xf0\x9f\x98\x81', 1, 128513],
-      [0, ' ', 1, ' '.charCodeAt(0)],
-      ...lineData('jiabc')
-    ]);
+    const lines = new CircularList<IBufferLine>(7);
+    lines.set(0, lineData([['a -> b -> c -> d']]));
+    lines.set(1, lineData([['a -> b => c -> d']]));
+    lines.set(2, lineData([['a -> b -', 0xFFFFFFFF], ['> c -> d', 0]]));
+
+    lines.set(3, lineData([['no joined ranges']]));
+    lines.set(4, new BufferLine());
+    lines.set(5, lineData([['a', 0x11111111], [' -> b -> c -> '], ['d', 0x22222222]]));
+    const line6 = lineData([['wi']]);
+    line6.push([0, '￥', 2, '￥'.charCodeAt(0)]);
+    line6.push([0, '', 0, null]);
+    let sub = lineData([['deemo']]);
+    for (let i = 0; i < sub.length; ++i) line6.push(sub.get(i));
+    line6.push([0, '\xf0\x9f\x98\x81', 1, 128513]);
+    line6.push([0, ' ', 1, ' '.charCodeAt(0)]);
+    sub = lineData([['jiabc']]);
+    for (let i = 0; i < sub.length; ++i) line6.push(sub.get(i));
+    lines.set(6, line6);
+
     (<MockBuffer>terminal.buffer).setLines(lines);
     terminal.buffer.ydisp = 0;
     registry = new CharacterJoinerRegistry(terminal);
@@ -257,8 +261,16 @@ describe('CharacterJoinerRegistry', () => {
   });
 });
 
-function lineData(line: string, attr: number = 0): LineData {
-  return line.split('').map<CharData>(char => [attr, char, 1, char.charCodeAt(0)]);
+type IPartialLineData = ([string] | [string, number]);
+
+function lineData(data: IPartialLineData[]): IBufferLine {
+  const tline = new BufferLine();
+  for (let i = 0; i < data.length; ++i) {
+    const line = data[i][0];
+    const attr = <number>(data[i][1] || 0);
+    line.split('').map(char => tline.push([attr, char, 1, char.charCodeAt(0)]));
+  }
+  return tline;
 }
 
 function substringJoiner(substring: string): (sequence: string) => [number, number][] {

src/renderer/CharacterJoinerRegistry.ts

@@ -1,5 +1,5 @@
 import { CHAR_DATA_ATTR_INDEX, CHAR_DATA_WIDTH_INDEX, CHAR_DATA_CHAR_INDEX } from '../Buffer';
-import { ITerminal, LineData } from '../Types';
+import { ITerminal, IBufferLine } from '../Types';
 import { ICharacterJoinerRegistry, ICharacterJoiner } from './Types';
 
 export class CharacterJoinerRegistry implements ICharacterJoinerRegistry {
@@ -51,10 +51,10 @@ export class CharacterJoinerRegistry implements ICharacterJoinerRegistry {
     let rangeStartColumn = 0;
     let currentStringIndex = 0;
     let rangeStartStringIndex = 0;
-    let rangeAttr = line[0][CHAR_DATA_ATTR_INDEX] >> 9;
+    let rangeAttr = line.get(0)[CHAR_DATA_ATTR_INDEX] >> 9;
 
     for (let x = 0; x < this._terminal.cols; x++) {
-      const charData = line[x];
+      const charData = line.get(x);
       const chars = charData[CHAR_DATA_CHAR_INDEX];
       const width = charData[CHAR_DATA_WIDTH_INDEX];
       const attr = charData[CHAR_DATA_ATTR_INDEX] >> 9;
@@ -115,7 +115,7 @@ export class CharacterJoinerRegistry implements ICharacterJoinerRegistry {
    * @param startIndex Start position of the range to search in the string (inclusive)
    * @param endIndex End position of the range to search in the string (exclusive)
    */
-  private _getJoinedRanges(line: string, startIndex: number, endIndex: number, lineData: LineData, startCol: number): [number, number][] {
+  private _getJoinedRanges(line: string, startIndex: number, endIndex: number, lineData: IBufferLine, startCol: number): [number, number][] {
     const text = line.substring(startIndex, endIndex);
     // At this point we already know that there is at least one joiner so
     // we can just pull its value and assign it directly rather than
@@ -140,7 +140,7 @@ export class CharacterJoinerRegistry implements ICharacterJoinerRegistry {
    * @param line Cell data for the relevant line in the terminal
    * @param startCol Offset within the line to start from
    */
-  private _stringRangesToCellRanges(ranges: [number, number][], line: LineData, startCol: number): void {
+  private _stringRangesToCellRanges(ranges: [number, number][], line: IBufferLine, startCol: number): void {
     let currentRangeIndex = 0;
     let currentRangeStarted = false;
     let currentStringIndex = 0;
@@ -152,7 +152,7 @@ export class CharacterJoinerRegistry implements ICharacterJoinerRegistry {
     }
 
     for (let x = startCol; x < this._terminal.cols; x++) {
-      const charData = line[x];
+      const charData = line.get(x);
       const width = charData[CHAR_DATA_WIDTH_INDEX];
       const length = charData[CHAR_DATA_CHAR_INDEX].length;
 

src/renderer/CursorRenderLayer.ts

@@ -127,7 +127,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
       return;
     }
 
-    const charData = terminal.buffer.lines.get(cursorY)[terminal.buffer.x];
+    const charData = terminal.buffer.lines.get(cursorY).get(terminal.buffer.x);
     if (!charData) {
       return;
     }

src/renderer/LinkRenderLayer.ts

@@ -6,6 +6,7 @@
 import { ILinkHoverEvent, ITerminal, ILinkifierAccessor, LinkHoverEventTypes } from '../Types';
 import { IColorSet, IRenderDimensions } from './Types';
 import { BaseRenderLayer } from './BaseRenderLayer';
+import { INVERTED_DEFAULT_COLOR } from './atlas/Types';
 
 export class LinkRenderLayer extends BaseRenderLayer {
   private _state: ILinkHoverEvent = null;
@@ -39,7 +40,15 @@ export class LinkRenderLayer extends BaseRenderLayer {
   }
 
   private _onLinkHover(e: ILinkHoverEvent): void {
-    this._ctx.fillStyle = this._colors.foreground.css;
+    if (e.fg === INVERTED_DEFAULT_COLOR) {
+      this._ctx.fillStyle = this._colors.background.css;
+    } else if (e.fg < 256) {
+      // 256 color support
+      this._ctx.fillStyle = this._colors.ansi[e.fg].css;
+    } else {
+      this._ctx.fillStyle = this._colors.foreground.css;
+    }
+
     if (e.y1 === e.y2) {
       // Single line link
       this.fillBottomLineAtCells(e.x1, e.y1, e.x2 - e.x1);

src/renderer/TextRenderLayer.ts

@@ -71,7 +71,7 @@ export class TextRenderLayer extends BaseRenderLayer {
       const line = terminal.buffer.lines.get(row);
       const joinedRanges = joinerRegistry ? joinerRegistry.getJoinedCharacters(row) : [];
       for (let x = 0; x < terminal.cols; x++) {
-        const charData = line[x];
+        const charData = line.get(x);
         let code: number = <number>charData[CHAR_DATA_CODE_INDEX];
 
         // Can either represent character(s) for a single cell or multiple cells
@@ -124,7 +124,7 @@ export class TextRenderLayer extends BaseRenderLayer {
           // get removed, and `a` would not re-render because it thinks it's
           // already in the correct state.
           // this._state.cache[x][y] = OVERLAP_OWNED_CHAR_DATA;
-          if (lastCharX < line.length - 1 && line[lastCharX + 1][CHAR_DATA_CODE_INDEX] === NULL_CELL_CODE) {
+          if (lastCharX < line.length - 1 && line.get(lastCharX + 1)[CHAR_DATA_CODE_INDEX] === NULL_CELL_CODE) {
             width = 2;
             // this._clearChar(x + 1, y);
             // The overlapping char's char data will force a clear and render when the

src/renderer/atlas/DynamicCharAtlas.ts

@@ -94,7 +94,7 @@ export default class DynamicCharAtlas extends BaseCharAtlas {
   ): boolean {
     const glyphKey = getGlyphCacheKey(glyph);
     const cacheValue = this._cacheMap.get(glyphKey);
-    if (cacheValue != null) {
+    if (cacheValue !== null && cacheValue !== undefined) {
       this._drawFromCache(ctx, cacheValue, x, y);
       return true;
     } else if (this._canCache(glyph) && this._drawToCacheCount < FRAME_CACHE_DRAW_LIMIT) {

src/renderer/atlas/StaticCharAtlas.ts

@@ -53,7 +53,7 @@ export default class StaticCharAtlas extends BaseCharAtlas {
     y: number
   ): boolean {
     // we're not warmed up yet
-    if (this._texture == null) {
+    if (this._texture === null || this._texture === undefined) {
       return false;
     }
 

src/renderer/dom/DomRendererRowFactory.test.ts

@@ -6,14 +6,15 @@
 import jsdom = require('jsdom');
 import { assert } from 'chai';
 import { DomRendererRowFactory } from './DomRendererRowFactory';
-import { LineData } from '../../Types';
 import { DEFAULT_ATTR, NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR } from '../../Buffer';
 import { FLAGS } from '../Types';
+import { BufferLine } from '../../BufferLine';
+import { IBufferLine } from '../../Types';
 
 describe('DomRendererRowFactory', () => {
   let dom: jsdom.JSDOM;
   let rowFactory: DomRendererRowFactory;
-  let lineData: LineData;
+  let lineData: IBufferLine;
 
   beforeEach(() => {
     dom = new jsdom.JSDOM('');
@@ -31,9 +32,9 @@ describe('DomRendererRowFactory', () => {
     });
 
     it('should set correct attributes for double width characters', () => {
-      lineData[0] = [DEFAULT_ATTR, '語', 2, '語'.charCodeAt(0)];
+      lineData.set(0, [DEFAULT_ATTR, '語', 2, '語'.charCodeAt(0)]);
       // There should be no element for the following "empty" cell
-      lineData[1] = [DEFAULT_ATTR, '', 0, undefined];
+      lineData.set(1, [DEFAULT_ATTR, '', 0, undefined]);
       const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
       assert.equal(getFragmentHtml(fragment),
         '<span style="width: 10px;">語</span>'
@@ -49,8 +50,8 @@ describe('DomRendererRowFactory', () => {
     });
 
     it('should not render cells that go beyond the terminal\'s columns', () => {
-      lineData[0] = [DEFAULT_ATTR, 'a', 1, 'a'.charCodeAt(0)];
-      lineData[1] = [DEFAULT_ATTR, 'b', 1, 'b'.charCodeAt(0)];
+      lineData.set(0, [DEFAULT_ATTR, 'a', 1, 'a'.charCodeAt(0)]);
+      lineData.set(1, [DEFAULT_ATTR, 'b', 1, 'b'.charCodeAt(0)]);
       const fragment = rowFactory.createRow(lineData, false, 0, 5, 1);
       assert.equal(getFragmentHtml(fragment),
         '<span>a</span>'
@@ -59,7 +60,7 @@ describe('DomRendererRowFactory', () => {
 
     describe('attributes', () => {
       it('should add class for bold', () => {
-        lineData[0] = [DEFAULT_ATTR | (FLAGS.BOLD << 18), 'a', 1, 'a'.charCodeAt(0)];
+        lineData.set(0, [DEFAULT_ATTR | (FLAGS.BOLD << 18), 'a', 1, 'a'.charCodeAt(0)]);
         const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
         assert.equal(getFragmentHtml(fragment),
           '<span class="xterm-bold">a</span>' +
@@ -68,7 +69,7 @@ describe('DomRendererRowFactory', () => {
       });
 
       it('should add class for italic', () => {
-        lineData[0] = [DEFAULT_ATTR | (FLAGS.ITALIC << 18), 'a', 1, 'a'.charCodeAt(0)];
+        lineData.set(0, [DEFAULT_ATTR | (FLAGS.ITALIC << 18), 'a', 1, 'a'.charCodeAt(0)]);
         const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
         assert.equal(getFragmentHtml(fragment),
           '<span class="xterm-italic">a</span>' +
@@ -79,7 +80,7 @@ describe('DomRendererRowFactory', () => {
       it('should add classes for 256 foreground colors', () => {
         const defaultAttrNoFgColor = (0 << 9) | (256 << 0);
         for (let i = 0; i < 256; i++) {
-          lineData[0] = [defaultAttrNoFgColor | (i << 9), 'a', 1, 'a'.charCodeAt(0)];
+          lineData.set(0, [defaultAttrNoFgColor | (i << 9), 'a', 1, 'a'.charCodeAt(0)]);
           const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
           assert.equal(getFragmentHtml(fragment),
             `<span class="xterm-fg-${i}">a</span>` +
@@ -91,7 +92,7 @@ describe('DomRendererRowFactory', () => {
       it('should add classes for 256 background colors', () => {
         const defaultAttrNoBgColor = (257 << 9) | (0 << 0);
         for (let i = 0; i < 256; i++) {
-          lineData[0] = [defaultAttrNoBgColor | (i << 0), 'a', 1, 'a'.charCodeAt(0)];
+          lineData.set(0, [defaultAttrNoBgColor | (i << 0), 'a', 1, 'a'.charCodeAt(0)]);
           const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
           assert.equal(getFragmentHtml(fragment),
             `<span class="xterm-bg-${i}">a</span>` +
@@ -101,7 +102,7 @@ describe('DomRendererRowFactory', () => {
       });
 
       it('should correctly invert colors', () => {
-        lineData[0] = [(FLAGS.INVERSE << 18) | (2 << 9) | (1 << 0), 'a', 1, 'a'.charCodeAt(0)];
+        lineData.set(0, [(FLAGS.INVERSE << 18) | (2 << 9) | (1 << 0), 'a', 1, 'a'.charCodeAt(0)]);
         const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
         assert.equal(getFragmentHtml(fragment),
           '<span class="xterm-fg-1 xterm-bg-2">a</span>' +
@@ -110,7 +111,7 @@ describe('DomRendererRowFactory', () => {
       });
 
       it('should correctly invert default fg color', () => {
-        lineData[0] = [(FLAGS.INVERSE << 18) | (257 << 9) | (1 << 0), 'a', 1, 'a'.charCodeAt(0)];
+        lineData.set(0, [(FLAGS.INVERSE << 18) | (257 << 9) | (1 << 0), 'a', 1, 'a'.charCodeAt(0)]);
         const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
         assert.equal(getFragmentHtml(fragment),
           '<span class="xterm-fg-1 xterm-bg-15">a</span>' +
@@ -119,7 +120,7 @@ describe('DomRendererRowFactory', () => {
       });
 
       it('should correctly invert default bg color', () => {
-        lineData[0] = [(FLAGS.INVERSE << 18) | (1 << 9) | (256 << 0), 'a', 1, 'a'.charCodeAt(0)];
+        lineData.set(0, [(FLAGS.INVERSE << 18) | (1 << 9) | (256 << 0), 'a', 1, 'a'.charCodeAt(0)]);
         const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
         assert.equal(getFragmentHtml(fragment),
           '<span class="xterm-fg-0 xterm-bg-1">a</span>' +
@@ -129,7 +130,7 @@ describe('DomRendererRowFactory', () => {
 
       it('should turn bold fg text bright', () => {
         for (let i = 0; i < 8; i++) {
-          lineData[0] = [(FLAGS.BOLD << 18) | (i << 9) | (256 << 0), 'a', 1, 'a'.charCodeAt(0)];
+          lineData.set(0, [(FLAGS.BOLD << 18) | (i << 9) | (256 << 0), 'a', 1, 'a'.charCodeAt(0)]);
           const fragment = rowFactory.createRow(lineData, false, 0, 5, 20);
           assert.equal(getFragmentHtml(fragment),
             `<span class="xterm-bold xterm-fg-${i + 8}">a</span>` +
@@ -146,8 +147,8 @@ describe('DomRendererRowFactory', () => {
     return element.innerHTML;
   }
 
-  function createEmptyLineData(cols: number): LineData {
-    const lineData: LineData = [];
+  function createEmptyLineData(cols: number): IBufferLine {
+    const lineData = new BufferLine();
     for (let i = 0; i < cols; i++) {
       lineData.push([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
     }

src/renderer/dom/DomRendererRowFactory.ts

@@ -3,9 +3,9 @@
  * @license MIT
  */
 
-import { LineData } from '../../Types';
 import { CHAR_DATA_CHAR_INDEX, CHAR_DATA_ATTR_INDEX, CHAR_DATA_WIDTH_INDEX } from '../../Buffer';
 import { FLAGS } from '../Types';
+import { IBufferLine } from '../../Types';
 
 export const BOLD_CLASS = 'xterm-bold';
 export const ITALIC_CLASS = 'xterm-italic';
@@ -17,7 +17,7 @@ export class DomRendererRowFactory {
   ) {
   }
 
-  public createRow(lineData: LineData, isCursorRow: boolean, cursorX: number, cellWidth: number, cols: number): DocumentFragment {
+  public createRow(lineData: IBufferLine, isCursorRow: boolean, cursorX: number, cellWidth: number, cols: number): DocumentFragment {
     const fragment = this._document.createDocumentFragment();
     let colCount = 0;
 
@@ -27,7 +27,7 @@ export class DomRendererRowFactory {
         continue;
       }
 
-      const charData = lineData[x];
+      const charData = lineData.get(x);
       const char: string = charData[CHAR_DATA_CHAR_INDEX];
       const attr: number = charData[CHAR_DATA_ATTR_INDEX];
       const width: number = charData[CHAR_DATA_WIDTH_INDEX];

src/ui/RenderDebouncer.ts

@@ -22,11 +22,16 @@ export class RenderDebouncer implements IDisposable {
     }
   }
 
-  public refresh(rowStart?: number, rowEnd?: number): void {
-    rowStart = rowStart || 0;
-    rowEnd = rowEnd || this._terminal.rows - 1;
-    this._rowStart = this._rowStart !== undefined ? Math.min(this._rowStart, rowStart) : rowStart;
-    this._rowEnd = this._rowEnd !== undefined ? Math.max(this._rowEnd, rowEnd) : rowEnd;
+  public refresh(rowStart: number, rowEnd: number): void {
+    // Get the min/max row start/end for the arg values
+    rowStart = rowStart !== null && rowStart !== undefined ? rowStart : 0;
+    rowEnd = rowEnd !== null && rowEnd !== undefined ? rowEnd : this._terminal.rows - 1;
+    // Check whether the row start/end values have already been set
+    const isRowStartSet = this._rowStart !== undefined && this._rowStart !== null;
+    const isRowEndSet = this._rowEnd !== undefined && this._rowEnd !== null;
+    // Set the properties to the updated values
+    this._rowStart = isRowStartSet ? Math.min(this._rowStart, rowStart) : rowStart;
+    this._rowEnd = isRowEndSet ? Math.max(this._rowEnd, rowEnd) : rowEnd;
 
     if (this._animationFrame) {
       return;

src/utils/MouseHelper.ts

@@ -11,7 +11,7 @@ export class MouseHelper {
 
   public static getCoordsRelativeToElement(event: {pageX: number, pageY: number}, element: HTMLElement): [number, number] {
     // Ignore browsers that don't support MouseEvent.pageX
-    if (event.pageX == null) {
+    if (event.pageX === null || event.pageX === undefined) {
       return null;
     }
 

src/utils/TestUtils.test.ts

@@ -4,8 +4,8 @@
  */
 
 import { IColorSet, IRenderer, IRenderDimensions, IColorManager } from '../renderer/Types';
-import { LineData, IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminal, IBuffer, IBufferSet, IBrowser, ICharMeasure, ISelectionManager, ITerminalOptions, ICircularList, ILinkifier, IMouseHelper, ILinkMatcherOptions, XtermListener, CharacterJoinerHandler } from '../Types';
-import { Buffer, NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR } from '../Buffer';
+import { IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminal, IBuffer, IBufferSet, IBrowser, ICharMeasure, ISelectionManager, ITerminalOptions, ICircularList, ILinkifier, IMouseHelper, ILinkMatcherOptions, XtermListener, CharacterJoinerHandler, IBufferLine } from '../Types';
+import { Buffer } from '../Buffer';
 import * as Browser from '../shared/utils/Browser';
 import { ITheme, IDisposable, IMarker } from 'xterm';
 
@@ -145,14 +145,6 @@ export class MockTerminal implements ITerminal {
   refresh(start: number, end: number): void {
     throw new Error('Method not implemented.');
   }
-  blankLine(cur?: boolean, isWrapped?: boolean, cols?: number): LineData {
-    const line: LineData = [];
-    cols = cols || this.cols;
-    for (let i = 0; i < cols; i++) {
-      line.push([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
-    }
-    return line;
-  }
   registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
   deregisterCharacterJoiner(joinerId: number): void { }
 }
@@ -228,9 +220,6 @@ export class MockInputHandlingTerminal implements IInputHandlingTerminal {
   eraseLeft(x: number, y: number): void {
     throw new Error('Method not implemented.');
   }
-  blankLine(cur?: boolean, isWrapped?: boolean): [number, string, number, number][] {
-    throw new Error('Method not implemented.');
-  }
   prevStop(x?: number): number {
     throw new Error('Method not implemented.');
   }
@@ -295,7 +284,7 @@ export class MockInputHandlingTerminal implements IInputHandlingTerminal {
 
 export class MockBuffer implements IBuffer {
   isCursorInViewport: boolean;
-  lines: ICircularList<[number, string, number, number][]>;
+  lines: ICircularList<IBufferLine>;
   ydisp: number;
   ybase: number;
   hasScrollback: boolean;
@@ -318,7 +307,7 @@ export class MockBuffer implements IBuffer {
   prevStop(x?: number): number {
     throw new Error('Method not implemented.');
   }
-  setLines(lines: ICircularList<[number, string, number, number][]>): void {
+  setLines(lines: ICircularList<IBufferLine>): void {
     this.lines = lines;
   }
 }

tslint.json

@@ -59,10 +59,7 @@
         "esSpecCompliant": true
       }
     ],
-    "triple-equals": [
-      true,
-      "allow-null-check"
-    ],
+    "triple-equals": true,
     "typedef-whitespace": [
       true,
       {

typings/xterm.d.ts

@@ -39,6 +39,16 @@ declare module 'xterm' {
      */
     bellStyle?: 'none' /*| 'visual'*/ | 'sound' /*| 'both'*/;
 
+    /**
+     * When enabled the cursor will be set to the beginning of the next line
+     * with every new line. This equivalent to sending '\r\n' for each '\n'.
+     * Normally the termios settings of the underlying PTY deals with the
+     * translation of '\n' to '\r\n' and this setting should not be used. If you
+     * deal with data from a non-PTY related source, this settings might be
+     * useful.
+     */
+    convertEol?: boolean;
+
     /**
      * The number of columns in the terminal.
      */
@@ -425,6 +435,12 @@ declare module 'xterm' {
      */
     emit(type: string, data?: any): void;
 
+    /**
+     * Adds an event listener to the Terminal, returning an IDisposable that can
+     * be used to conveniently remove the event listener.
+     * @param type The type of event.
+     * @param handler The event handler.
+     */
     addDisposableListener(type: string, handler: (...args: any[]) => void): IDisposable;
 
     /**