Merge pull request #3002 from xtermjs/Tyriar-patch-1

v4.8.0

.eslintrc.json

@@ -9,7 +9,6 @@
     "project": [
       "src/browser/tsconfig.json",
       "src/common/tsconfig.json",
-      "src/tsconfig.json",
       "test/api/tsconfig.json",
       "test/benchmark/tsconfig.json",
       "addons/xterm-addon-attach/src/tsconfig.json",
@@ -19,42 +18,55 @@
       "addons/xterm-addon-web-links/src/tsconfig.json",
       "addons/xterm-addon-webgl/src/tsconfig.json",
       "addons/xterm-addon-serialize/src/tsconfig.json",
-      "addons/xterm-addon-serialize/benchmark/tsconfig.json"
+      "addons/xterm-addon-serialize/benchmark/tsconfig.json",
+      "addons/xterm-addon-ligatures/src/tsconfig.json"
     ],
     "sourceType": "module"
   },
   "ignorePatterns": [
-    "**/typings/*.d.ts"
+    "**/typings/*.d.ts",
+    "**/node_modules",
+    "**/*.js"
   ],
   "plugins": [
     "@typescript-eslint"
   ],
   "rules": {
+    "no-extra-semi": "error",
     "@typescript-eslint/array-type": [
-      "error",
+      "warn",
       {
         "default": "array-simple",
         "readonly": "generic"
       }
     ],
-    "@typescript-eslint/class-name-casing": "error",
-    "@typescript-eslint/consistent-type-definitions": "error",
+    "@typescript-eslint/class-name-casing": "warn",
+    "@typescript-eslint/consistent-type-definitions": "warn",
     "@typescript-eslint/explicit-function-return-type": [
-      "error",
+      "warn",
       {
         "allowExpressions": true
       }
     ],
+    "@typescript-eslint/explicit-member-accessibility": [
+      "warn",
+      {
+        "accessibility": "explicit",
+        "overrides": {
+          "constructors": "off"
+        }
+      }
+    ],
     "@typescript-eslint/indent": [
-      "error",
+      "warn",
       2
     ],
     "@typescript-eslint/interface-name-prefix": [
-      "error",
+      "warn",
       "always"
     ],
     "@typescript-eslint/member-delimiter-style": [
-      "error",
+      "warn",
       {
         "multiline": {
           "delimiter": "semi",
@@ -67,7 +79,7 @@
       }
     ],
     "@typescript-eslint/naming-convention": [
-      "error",
+      "warn",
       { "selector": "default", "format": ["camelCase"] },
       // variableLike
       { "selector": "variable", "format": ["camelCase", "UPPER_CASE"] },
@@ -83,19 +95,19 @@
       { "selector": "typeLike", "format": ["PascalCase"] },
       { "selector": "interface", "format": ["PascalCase"], "prefix": ["I"] }
     ],
-    "@typescript-eslint/prefer-namespace-keyword": "error",
-    "@typescript-eslint/type-annotation-spacing": "error",
+    "@typescript-eslint/prefer-namespace-keyword": "warn",
+    "@typescript-eslint/type-annotation-spacing": "warn",
     "@typescript-eslint/quotes": [
-      "error",
+      "warn",
       "single",
       { "allowTemplateLiterals": true }
     ],
     "@typescript-eslint/semi": [
-      "error",
+      "warn",
       "always"
     ],
     "comma-dangle": [
-      "error",
+      "warn",
       {
         "objects": "never",
         "arrays": "never",
@@ -103,43 +115,43 @@
       }
     ],
     "curly": [
-      "error",
+      "warn",
       "multi-line"
     ],
-    "eol-last": "error",
+    "eol-last": "warn",
     "eqeqeq": [
-      "error",
+      "warn",
       "always"
     ],
-    "keyword-spacing": "error",
-    "new-parens": "error",
-    "no-duplicate-imports": "error",
+    "keyword-spacing": "warn",
+    "new-parens": "warn",
+    "no-duplicate-imports": "warn",
     "no-else-return": [
-      "error",
+      "warn",
       {
         "allowElseIf": false
       }
     ],
-    "no-eval": "error",
-    "no-irregular-whitespace": "error",
+    "no-eval": "warn",
+    "no-irregular-whitespace": "warn",
     "no-restricted-imports": [
-      "error",
+      "warn",
       {
         "patterns": [
           ".*\\/out\\/.*"
         ]
       }
     ],
-    "no-trailing-spaces": "error",
-    "no-unsafe-finally": "error",
-    "no-var": "error",
+    "no-trailing-spaces": "warn",
+    "no-unsafe-finally": "warn",
+    "no-var": "warn",
     "one-var": [
-      "error",
+      "warn",
       "never"
     ],
-    "prefer-const": "error",
+    "prefer-const": "warn",
     "spaced-comment": [
-      "error",
+      "warn",
       "always",
       {
         "markers": ["/"],

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:8
+FROM node:12
 MAINTAINER Paris Kasidiaris <paris@sourcelair.com>
 
 # Set the working directory

README.md

@@ -161,7 +161,10 @@ Xterm.js is used in several world-class applications to provide great terminal e
 - [**FluffOS**](https://www.fluffos.info): Active maintained LPMUD driver with websocket support.
 - [**x-terminal**](https://atom.io/packages/x-terminal): Atom plugin for providing terminals inside your Atom workspace.
 - [**CoCalc**](https://cocalc.com/): Lots of free software pre-installed, to chat, collaborate, develop, program, publish, research, share, teach, in C++, HTML, Julia, Jupyter, LaTeX, Markdown, Python, R, SageMath, Scala, ...
-
+- [**Dank Domain**](https://www.DDgame.us/): Open source multiuser medieval game supporting old & new terminal emulation.
+- [**DockerStacks**](https://docker-stacks.com/): Local LAMP/LEMP development studio
+- [**Codecademy**](https://codecademy.com/): Uses xterm.js in its courses on Bash. 
+- [**Laravel Ssh Web Client**](https://github.com/roke22/Laravel-ssh-client): Laravel server inventory with ssh web client to connect at server using xterm.js
 [And much more...](https://github.com/xtermjs/xterm.js/network/dependents)
 
 Do you use xterm.js in your application as well? Please [open a Pull Request](https://github.com/sourcelair/xterm.js/pulls) to include it here. We would love to have it in our list. Note: Please add any new contributions to the end of the list only.

addons/xterm-addon-attach/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-attach",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-fit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-fit",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-ligatures/.gitignore

@@ -0,0 +1,13 @@
+node_modules/
+.nyc_output/
+coverage/
+
+lib/
+fonts/
+
+.env
+.vscode/
+*.swp
+*.tgz
+npm-debug.log*
+yarn-error.log*

addons/xterm-addon-ligatures/.npmignore

@@ -0,0 +1,48 @@
+# Blacklist - exclude everything except npm defaults such as LICENSE, etc
+*
+!*/
+
+# Whitelist - entries to be included must be negated with "!"
+!*.js
+!*.json
+
+# Whitelist - lib/
+!lib/**/*.d.ts
+
+!lib/**/*.js
+!lib/**/*.js.map
+
+# Whitelist - out/
+!out/**/*.d.ts
+
+!out/**/*.js
+!out/**/*.js.map
+
+# Whitelist - src/
+!src/**/*.ts
+!src/**/*.d.ts
+
+!src/**/*.js
+!src/**/*.js.map
+
+# Whitelist - typings/
+!typings/**/*.d.ts
+
+# Blacklist - (normal behavior) these will override any whitelist
+*.test.ts
+*.test.d.ts
+*.test.js
+*.test.js.map
+
+docs/
+/.idea/
+.vscode/
+coverage/
+.nyc_output/
+fonts/
+
+**/*.api.js
+**/*.api.ts
+tsconfig.json
+.yarnrc
+webpack.config.js

addons/xterm-addon-ligatures/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

addons/xterm-addon-ligatures/README.md

@@ -0,0 +1,53 @@
+## xterm-addon-ligatures
+
+Add support for programming ligatures to [xterm.js] when running in environments with access to [Node.js] APIs (such as [Electron]).
+
+### Requirements
+
+ * [Node.js] 8.x or higher (present in [Electron] 1.8.3 or higher)
+ * [xterm.js] 4.0.0 or higher using the default canvas renderer
+
+### Install
+
+```bash
+npm install --save xterm-addon-ligatures
+```
+
+### Usage
+
+```ts
+import { Terminal } from 'xterm';
+import { LigaturesAddon } from 'xterm-addon-ligatures';
+
+const terminal = new Terminal();
+const ligaturesAddon = new LigaturesAddon();
+terminal.open(containerElement);
+terminal.loadAddon(ligaturesAddon);
+```
+
+### How It Works
+
+In a browser environment, font ligature information is read directly by the web browser and used to render text correctly without any intervention from the developer. As of version 3, xterm.js uses the canvas to render characters individually, resulting in a significant performance boost. However, this means that it can no longer lean on the browser to determine when to draw font ligatures.
+
+This package locates the font file on disk for the font currently in use by the terminal and parses the ligature information out of it (via the [font-ligatures] package). As text is rendered in xterm.js, this package annotates it with the locations of ligatures, allowing xterm.js to render it correctly.
+
+Since this package depends on being able to find and resolve a system font from disk, it has to have system access that isn't available in the web browser. As a result, this package is mainly useful in environments that combine browser and Node.js runtimes (such as [Electron]).
+
+### Fonts
+
+This package makes use of the following fonts for testing:
+
+ * [Fira Code][Fira Code] - [Licensed under the OFL][Fira Code License] by Nikita
+   Prokopov, Mozilla Foundation with reserved names Fira Code, Fira Mono, and
+   Fira Sans
+ * [Iosevka] - [Licensed under the OFL][Iosevka License] by Belleve Invis with
+   reserved name Iosevka
+
+[xterm.js]: https://github.com/xtermjs/xterm.js
+[Electron]: https://electronjs.org/
+[Node.js]: https://nodejs.org/
+[font-ligatures]: https://github.com/princjef/font-ligatures
+[Fira Code]: https://github.com/tonsky/FiraCode
+[Fira Code License]: https://github.com/tonsky/FiraCode/blob/master/LICENSE
+[Iosevka]: https://github.com/be5invis/Iosevka
+[Iosevka License]: https://github.com/be5invis/Iosevka/blob/master/LICENSE.md

addons/xterm-addon-ligatures/bin/download-fonts.js

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+
+const axios = require('axios').default;
+const mkdirp = require('mkdirp');
+const yauzl = require('yauzl');
+
+const urls = {
+  fira: 'https://github.com/tonsky/FiraCode/raw/d42e7276fa925e5f82748f3ec9ea429736611b48/distr/otf/FiraCode-Regular.otf',
+  iosevka: 'https://github.com/be5invis/Iosevka/releases/download/v1.14.3/01-iosevka-1.14.3.zip'
+};
+
+const writeFile = util.promisify(fs.writeFile);
+const fontsFolder = path.join(__dirname, '../fonts');
+
+async function download() {
+  await mkdirp(fontsFolder);
+
+  await downloadFiraCode();
+  await downloadIosevka();
+
+  console.log('Loaded all fonts for testing')
+}
+
+async function downloadFiraCode() {
+  const file = path.join(fontsFolder, 'firaCode.otf');
+  if (await util.promisify(fs.exists)(file)) {
+    console.log('Fira Code already loaded');
+  } else {
+    console.log('Downloading Fira Code...');
+    await writeFile(
+      file,
+      (await axios.get(urls.fira, { responseType: 'arraybuffer' })).data
+    );
+  }
+}
+
+async function downloadIosevka() {
+  const file = path.join(fontsFolder, 'iosevka.ttf');
+  if (await util.promisify(fs.exists)(file)) {
+    console.log('Iosevka already loaded');
+  } else {
+    console.log('Downloading Iosevka...');
+    const iosevkaContents = (await axios.get(urls.iosevka, { responseType: 'arraybuffer' })).data;
+    const iosevkaZipfile = await util.promisify(yauzl.fromBuffer)(iosevkaContents);
+    await new Promise((resolve, reject) => {
+      iosevkaZipfile.on('entry', entry => {
+        if (entry.fileName === 'ttf/iosevka-regular.ttf') {
+          iosevkaZipfile.openReadStream(entry, (err, stream) => {
+            if (err) {
+              return reject(err);
+            }
+
+            const writeStream = fs.createWriteStream(file);
+            stream.pipe(writeStream);
+            writeStream.on('close', () => resolve());
+          });
+        }
+      });
+    });
+  }
+}
+
+download();
+
+process.on('unhandledRejection', e => {
+  console.error(e);
+  process.exit(1);
+});

addons/xterm-addon-ligatures/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "xterm-addon-ligatures",
+  "version": "0.3.0",
+  "description": "Add support for programming ligatures to xterm.js",
+  "author": {
+    "name": "The xterm.js authors",
+    "url": "https://xtermjs.org/"
+  },
+  "main": "lib/xterm-addon-ligatures.js",
+  "types": "typings/xterm-addon-ligatures.d.ts",
+  "repository": "https://github.com/xtermjs/xterm.js",
+  "engines": {
+    "node": ">8.0.0"
+  },
+  "scripts": {
+    "prepare": "node bin/download-fonts.js",
+    "build": "tsc -p src",
+    "watch": "tsc -w -p src",
+    "prepackage": "npm run build",
+    "package": "webpack",
+    "pretest": "npm run build",
+    "test": "nyc mocha out/**/*.test.js",
+    "prepublish": "npm run package"
+  },
+  "keywords": [
+    "font",
+    "ligature",
+    "xterm",
+    "xterm.js",
+    "terminal"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "font-finder": "^1.0.4",
+    "font-ligatures": "^1.3.3"
+  },
+  "devDependencies": {
+    "@types/sinon": "^5.0.1",
+    "axios": "^0.18.0",
+    "mkdirp": "0.5.5",
+    "sinon": "6.3.5",
+    "yauzl": "^2.10.0"
+  },
+  "peerDependencies": {
+    "xterm": "^4.0.0"
+  }
+}

addons/xterm-addon-ligatures/src/LigaturesAddon.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { Terminal } from 'xterm';
+import { enableLigatures } from '.';
+
+export interface ITerminalAddon {
+  activate(terminal: Terminal): void;
+  dispose(): void;
+}
+
+export class LigaturesAddon implements ITerminalAddon {
+  constructor() {}
+
+  public activate(terminal: Terminal): void {
+    enableLigatures(terminal);
+  }
+
+  public dispose(): void {}
+}
+

addons/xterm-addon-ligatures/src/font.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import * as fontFinder from 'font-finder';
+import * as fontLigatures from 'font-ligatures';
+
+import parse from './parse';
+
+let fontsPromise: Promise<fontFinder.FontList> | undefined = undefined;
+
+/**
+ * Loads the font ligature wrapper for the specified font family if it could be
+ * resolved, throwing if it is unable to find a suitable match.
+ * @param fontFamily The CSS font family definition to resolve
+ * @param cacheSize The size of the ligature cache to maintain if the font is resolved
+ */
+export default async function load(fontFamily: string, cacheSize: number): Promise<fontLigatures.Font | undefined> {
+  if (!fontsPromise) {
+    fontsPromise = fontFinder.list();
+  }
+
+  const fonts = await fontsPromise;
+  for (const family of parse(fontFamily)) {
+    // If we reach one of the generic font families, the font resolution
+    // will end for the browser and we can't determine the specific font
+    // used. Throw.
+    if (genericFontFamilies.includes(family)) {
+      return undefined;
+    }
+
+    if (fonts.hasOwnProperty(family) && fonts[family].length > 0) {
+      return await fontLigatures.loadFile(fonts[family][0].path, { cacheSize });
+    }
+  }
+
+  // If none of the fonts could resolve, throw an error
+  return undefined;
+}
+
+// https://drafts.csswg.org/css-fonts-4/#generic-font-families
+const genericFontFamilies = [
+  'serif',
+  'sans-serif',
+  'cursive',
+  'fantasy',
+  'monospace',
+  'system-ui',
+  'emoji',
+  'math',
+  'fangsong'
+];

addons/xterm-addon-ligatures/src/index.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import * as path from 'path';
+import * as sinon from 'sinon';
+import { assert } from 'chai';
+import * as fontFinder from 'font-finder';
+import * as fontLigatures from 'font-ligatures';
+
+import * as ligatureSupport from '.';
+
+describe('xterm-addon-ligatures', () => {
+  let onRefresh: sinon.SinonStub;
+  let term: MockTerminal;
+
+  // -> forms a ligature in Fira Code and Iosevka, but www only forms a ligature
+  // in Fira Code
+  const input = 'a -> b www c';
+
+  before(() => {
+    sinon.stub(fontFinder, 'list').returns(Promise.resolve({
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      'Fira Code': [{
+        path: path.join(__dirname, '../fonts/firaCode.otf'),
+        style: fontFinder.Style.Regular,
+        type: fontFinder.Type.Monospace,
+        weight: 400
+      }],
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      'Iosevka': [{
+        path: path.join(__dirname, '../fonts/iosevka.ttf'),
+        style: fontFinder.Style.Regular,
+        type: fontFinder.Type.Monospace,
+        weight: 400
+      }],
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      'Nonexistant Font': [{
+        path: path.join(__dirname, '../fonts/nonexistant.ttf'),
+        style: fontFinder.Style.Regular,
+        type: fontFinder.Type.Monospace,
+        weight: 400
+      }]
+    } as fontFinder.FontList));
+  });
+
+  beforeEach(() => {
+    onRefresh = sinon.stub();
+    term = new MockTerminal(onRefresh);
+    ligatureSupport.enableLigatures(term as any);
+  });
+
+  it('registers itself correctly', () => {
+    const term = new MockTerminal(sinon.spy());
+    assert.isUndefined(term.joiner);
+    ligatureSupport.enableLigatures(term as any);
+    assert.isFunction(term.joiner);
+  });
+
+  it('registers itself correctly when called directly', () => {
+    const term = new MockTerminal(sinon.spy());
+    assert.isUndefined(term.joiner);
+    ligatureSupport.enableLigatures(term as any);
+    assert.isFunction(term.joiner);
+  });
+
+  it('returns an empty set of ranges on the first call while the font is loading', () => {
+    assert.deepEqual(term.joiner!(input), []);
+  });
+
+  it('returns the correct set of ranges once the font has loaded', done => {
+    assert.deepEqual(term.joiner!(input), []);
+    onRefresh.callsFake(() => {
+      assert.deepEqual(term.joiner!(input), [[2, 4], [7, 10]]);
+      done();
+    });
+  });
+
+  it('handles quoted font names', done => {
+    term.setOption('fontFamily', '"Fira Code", monospace');
+    assert.deepEqual(term.joiner!(input), []);
+    onRefresh.callsFake(() => {
+      assert.deepEqual(term.joiner!(input), [[2, 4], [7, 10]]);
+      done();
+    });
+  });
+
+  it('falls back to later fonts if earlier ones are not present', done => {
+    term.setOption('fontFamily', 'notinstalled, Fira Code, monospace');
+    assert.deepEqual(term.joiner!(input), []);
+    onRefresh.callsFake(() => {
+      assert.deepEqual(term.joiner!(input), [[2, 4], [7, 10]]);
+      done();
+    });
+  });
+
+  it('uses the current font value', done => {
+    // The first three calls are all synchronous so that we don't allow time for
+    // any fonts to load while we're switching things around
+    term.setOption('fontFamily', 'Fira Code');
+    assert.deepEqual(term.joiner!(input), []);
+    term.setOption('fontFamily', 'notinstalled');
+    assert.deepEqual(term.joiner!(input), []);
+    term.setOption('fontFamily', 'Iosevka');
+    assert.deepEqual(term.joiner!(input), []);
+    onRefresh.callsFake(() => {
+      assert.deepEqual(term.joiner!(input), [[2, 4]]);
+
+      // And switch it back to Fira Code for good measure
+      term.setOption('fontFamily', 'Fira Code');
+
+      // At this point, we haven't loaded the new font, so the result reverts
+      // back to empty until that happens
+      assert.deepEqual(term.joiner!(input), []);
+
+      onRefresh.callsFake(() => {
+        assert.deepEqual(term.joiner!(input), [[2, 4], [7, 10]]);
+        done();
+      });
+    });
+  });
+
+  it('allows multiple terminal instances that use different fonts', done => {
+    const onRefresh2 = sinon.stub();
+    const term2 = new MockTerminal(onRefresh2);
+    term2.setOption('fontFamily', 'Iosevka');
+    ligatureSupport.enableLigatures(term2 as any);
+
+    assert.deepEqual(term.joiner!(input), []);
+    onRefresh.callsFake(() => {
+      assert.deepEqual(term.joiner!(input), [[2, 4], [7, 10]]);
+      assert.deepEqual(term2.joiner!(input), []);
+      onRefresh2.callsFake(() => {
+        assert.deepEqual(term2.joiner!(input), [[2, 4]]);
+        assert.deepEqual(term.joiner!(input), [[2, 4], [7, 10]]);
+        done();
+      });
+    });
+  });
+
+  it('fails if it finds but cannot load the font', async () => {
+    term.setOption('fontFamily', 'Nonexistant Font, monospace');
+    assert.deepEqual(term.joiner!(input), []);
+    await delay(500);
+    assert.isTrue(onRefresh.notCalled);
+    assert.throws(() => term.joiner!(input));
+  });
+
+  it('returns nothing if the font is not present on the system', async () => {
+    term.setOption('fontFamily', 'notinstalled');
+    assert.deepEqual(term.joiner!(input), []);
+    await delay(500);
+    assert.isTrue(onRefresh.notCalled);
+    assert.deepEqual(term.joiner!(input), []);
+  });
+
+  it('returns nothing if no specific font is specified', async () => {
+    term.setOption('fontFamily', 'monospace');
+    assert.deepEqual(term.joiner!(input), []);
+    await delay(500);
+    assert.isTrue(onRefresh.notCalled);
+    assert.deepEqual(term.joiner!(input), []);
+  });
+
+  it('returns nothing if no fonts are provided', async () => {
+    term.setOption('fontFamily', '');
+    assert.deepEqual(term.joiner!(input), []);
+    await delay(500);
+    assert.isTrue(onRefresh.notCalled);
+    assert.deepEqual(term.joiner!(input), []);
+  });
+
+  it('fails when given malformed inputs', async () => {
+    term.setOption('fontFamily', {} as any);
+    assert.deepEqual(term.joiner!(input), []);
+    await delay(500);
+    assert.isTrue(onRefresh.notCalled);
+    assert.throws(() => term.joiner!(input));
+  });
+
+  it('ensures no empty errors are thrown', async () => {
+    sinon.stub(fontLigatures, 'loadFile').callsFake(async () => { throw undefined; });
+    term.setOption('fontFamily', 'Iosevka');
+    assert.deepEqual(term.joiner!(input), []);
+    await delay(500);
+    assert.isTrue(onRefresh.notCalled);
+    assert.throws(() => term.joiner!(input), 'Failure while loading font');
+    (fontLigatures.loadFile as sinon.SinonStub).restore();
+  });
+});
+
+class MockTerminal {
+  private _options: { [name: string]: string | number } = {
+    fontFamily: 'Fira Code, monospace',
+    rows: 50
+  };
+  public joiner?: (text: string) => [number, number][];
+  public refresh: (start: number, end: number) => void;
+
+  constructor(onRefresh: (start: number, end: number) => void) {
+    this.refresh = onRefresh;
+  }
+
+  public registerCharacterJoiner(handler: (text: string) => [number, number][]): number {
+    this.joiner = handler;
+    return 1;
+  }
+  public deregisterCharacterJoiner(id: number): void {
+    this.joiner = undefined;
+  }
+  public setOption(name: string, value: string | number): void {
+    this._options[name] = value;
+  }
+  public getOption(name: string): string | number {
+    return this._options[name];
+  }
+}
+
+function delay(delayMs: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, delayMs));
+}

addons/xterm-addon-ligatures/src/index.ts

@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { Terminal } from 'xterm';
+import { Font } from 'font-ligatures';
+
+import load from './font';
+
+const enum LoadingState {
+  UNLOADED,
+  LOADING,
+  LOADED,
+  FAILED
+}
+
+// Caches 100K characters worth of ligatures. In practice this works out to
+// about 650 KB worth of cache, when a moderate number of ligatures are present.
+const CACHE_SIZE = 100000;
+
+/**
+ * Enable ligature support for the provided Terminal instance. To function
+ * properly, this must be called after `open()` is called on the therminal. If
+ * the font currently in use supports ligatures, the terminal will automatically
+ * start to render them.
+ * @param term Terminal instance from xterm.js
+ */
+export function enableLigatures(term: Terminal): void {
+  let currentFontName: string | undefined = undefined;
+  let font: Font | undefined = undefined;
+  let loadingState: LoadingState = LoadingState.UNLOADED;
+  let loadError: any | undefined = undefined;
+
+  term.registerCharacterJoiner((text: string): [number, number][] => {
+    // If the font hasn't been loaded yet, load it and return an empty result
+    const termFont = term.getOption('fontFamily');
+    if (
+      termFont &&
+      (loadingState === LoadingState.UNLOADED || currentFontName !== termFont)
+    ) {
+      font = undefined;
+      loadingState = LoadingState.LOADING;
+      currentFontName = termFont;
+      const currentCallFontName = currentFontName;
+
+      load(currentCallFontName, CACHE_SIZE)
+        .then(f => {
+          // Another request may have come in while we were waiting, so make
+          // sure our font is still vaild.
+          if (currentCallFontName === term.getOption('fontFamily')) {
+            loadingState = LoadingState.LOADED;
+            font = f;
+
+            // Only refresh things if we actually found a font
+            if (f) {
+              term.refresh(0, term.getOption('rows') - 1);
+            }
+          }
+        })
+        .catch(e => {
+          // Another request may have come in while we were waiting, so make
+          // sure our font is still vaild.
+          if (currentCallFontName === term.getOption('fontFamily')) {
+            loadingState = LoadingState.FAILED;
+            font = undefined;
+            loadError = e;
+          }
+        });
+    }
+
+    if (font && loadingState === LoadingState.LOADED) {
+      // We clone the entries to avoid the internal cache of the ligature finder
+      // getting messed up.
+      return font.findLigatureRanges(text).map<[number, number]>(
+        range => [range[0], range[1]]
+      );
+    }
+    if (loadingState === LoadingState.FAILED) {
+      throw loadError || new Error('Failure while loading font');
+    }
+
+    return [];
+  });
+}

addons/xterm-addon-ligatures/src/parse.test.ts

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { assert } from 'chai';
+
+import parse from './parse';
+
+// TODO: integrate tests from http://test.csswg.org/suites/css-fonts-4_dev/nightly-unstable/
+describe('parse', () => {
+  it('parses individual families', () => {
+    assert.deepEqual(parse('monospace'), ['monospace']);
+  });
+
+  it('parses multiple families', () => {
+    assert.deepEqual(parse('Arial, Verdana, serif'), ['Arial', 'Verdana', 'serif']);
+  });
+
+  it('parses quoted families', () => {
+    assert.deepEqual(parse('"Times New Roman", serif'), ['Times New Roman', 'serif']);
+  });
+
+  it('parses single quoted families', () => {
+    assert.deepEqual(parse('\'Times New Roman\', serif'), ['Times New Roman', 'serif']);
+  });
+
+  it('parses families with spaces in their names', () => {
+    assert.deepEqual(parse('Times New Roman, serif'), ['Times New Roman', 'serif']);
+  });
+
+  it('collapses multiple spaces together in identifiers', () => {
+    assert.deepEqual(parse('Times   New Roman, serif'), ['Times New Roman', 'serif']);
+  });
+
+  it('does not collapse multiple spaces together in quoted strings', () => {
+    assert.deepEqual(parse('"Times   New Roman", serif'), ['Times   New Roman', 'serif']);
+  });
+
+  it('handles escaped characters in strings', () => {
+    assert.deepEqual(parse('"quote \\" slash \\\\ slashquote \\\\\\"", serif'), ['quote " slash \\ slashquote \\"', 'serif']);
+  });
+
+  it('fails if a family has an unterminated string', () => {
+    assert.throws(() => parse('"Unterminated, serif'));
+  });
+
+  it('handles unicode escape sequences', () => {
+    assert.deepEqual(parse('"space\\20 between", serif'), ['space between', 'serif']);
+  });
+
+  it('swallows only the first space after a unicode escape', () => {
+    assert.deepEqual(parse('"two-space\\20  between", serif'), ['two-space  between', 'serif']);
+  });
+
+  it('automatically ends the unicode escape after six digits', () => {
+    assert.deepEqual(parse('space\\000020between, serif'), ['space between', 'serif']);
+  });
+
+  it('handles unicode escapes at the end of the family', () => {
+    assert.deepEqual(parse('endswithbrace \\7b, serif'), ['endswithbrace {', 'serif']);
+  });
+
+  it('handles unicode escapes at the end of the input', () => {
+    assert.deepEqual(parse('endswithbrace \\7b'), ['endswithbrace {']);
+  });
+
+  it('handles other escaped characters in identifiers', () => {
+    assert.deepEqual(parse('has\\,comma'), ['has,comma']);
+  });
+
+  it('swallows escaped newlines in strings', () => {
+    assert.deepEqual(parse('"multi \\\nline", serif'), ['multi line', 'serif']);
+  });
+});

addons/xterm-addon-ligatures/src/parse.ts

@@ -0,0 +1,180 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+interface IParseContext {
+  input: string;
+  offset: number;
+}
+
+/**
+ * Parses a CSS font family value, returning the component font families
+ * contained within.
+ *
+ * @param family The CSS font family input string to parse
+ */
+export default function parse(family: string): string[] {
+  if (typeof family !== 'string') {
+    throw new Error('Font family must be a string');
+  }
+
+  const context: IParseContext = {
+    input: family,
+    offset: 0
+  };
+
+  const families = [];
+  let currentFamily = '';
+
+  // Work through the input character by character until there are none left.
+  // This lexing and parsing in one pass.
+  while (context.offset < context.input.length) {
+    const char = context.input[context.offset++];
+    switch (char) {
+      // String
+      case '\'':
+      case '"':
+        currentFamily += parseString(context, char);
+        break;
+      // End of family
+      case ',':
+        families.push(currentFamily);
+        currentFamily = '';
+        break;
+      default:
+        // Identifiers (whitespace between families is swallowed)
+        if (!/\s/.test(char)) {
+          context.offset--;
+          currentFamily += parseIdentifier(context);
+          families.push(currentFamily);
+          currentFamily = '';
+        }
+    }
+  }
+
+  return families;
+}
+
+/**
+ * Parse a CSS string.
+ *
+ * @param context Parsing input and offset
+ * @param quoteChar The quote character for the string (' or ")
+ */
+function parseString(context: IParseContext, quoteChar: '\'' | '"'): string {
+  let str = '';
+  let escaped = false;
+  while (context.offset < context.input.length) {
+    const char = context.input[context.offset++];
+    if (escaped) {
+      if (/[0-9a-fA-F]/.test(char)) {
+        // Unicode escape
+        context.offset--;
+        str += parseUnicode(context);
+      } else if (char !== '\n') {
+        // Newlines are ignored if escaped. Other characters are used as is.
+        str += char;
+      }
+      escaped = false;
+    } else {
+      switch (char) {
+        // Terminated quote
+        case quoteChar:
+          return str;
+        // Begin escape
+        case '\\':
+          escaped = true;
+          break;
+        // Add character to string
+        default:
+          str += char;
+      }
+    }
+  }
+
+  throw new Error('Unterminated string');
+}
+
+/**
+ * Parse a CSS custom identifier.
+ *
+ * @param context Parsing input and offset
+ */
+function parseIdentifier(context: IParseContext): string {
+  let str = '';
+  let escaped = false;
+  while (context.offset < context.input.length) {
+    const char = context.input[context.offset++];
+    if (escaped) {
+      if (/[0-9a-fA-F]/.test(char)) {
+        // Unicode escape
+        context.offset--;
+        str += parseUnicode(context);
+      } else {
+        // Everything else is used as is
+        str += char;
+      }
+      escaped = false;
+    } else {
+      switch (char) {
+        // Begin escape
+        case '\\':
+          escaped = true;
+          break;
+        // Terminate identifier
+        case ',':
+          return str;
+        default:
+          if (/\s/.test(char)) {
+            // Whitespace is collapsed into a single space within an identifier
+            if (!str.endsWith(' ')) {
+              str += ' ';
+            }
+          } else {
+            // Add other characters directly
+            str += char;
+          }
+      }
+    }
+  }
+
+  return str;
+}
+
+/**
+ * Parse a CSS unicode escape.
+ *
+ * @param context Parsing input and offset
+ */
+function parseUnicode(context: IParseContext): string {
+  let str = '';
+  while (context.offset < context.input.length) {
+    const char = context.input[context.offset++];
+    if (/\s/.test(char)) {
+      // The first whitespace character after a unicode escape indicates the end
+      // of the escape and is swallowed.
+      return unicodeToString(str);
+    }
+    if (str.length >= 6 || !/[0-9a-fA-F]/.test(char)) {
+      // If the next character is not a valid hex digit or we have reached the
+      // maximum of 6 digits in the escape, terminate the escape.
+      context.offset--;
+      return unicodeToString(str);
+    }
+
+    // Otherwise, just add it to the escape
+    str += char;
+  }
+
+  return unicodeToString(str);
+}
+
+/**
+ * Convert a unicode code point from a hex string to a utf8 string.
+ *
+ * @param codePoint Unicode code point represented as a hex string
+ */
+function unicodeToString(codePoint: string): string {
+  return String.fromCodePoint(parseInt(codePoint, 16));
+}

addons/xterm-addon-ligatures/src/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "es2017",
+        "module": "commonjs",
+        "sourceMap": true,
+        "outDir": "../out",
+        "rootDir": ".",
+        "strict": true,
+        "noUnusedLocals": true,
+        "preserveWatchOutput": true
+    },
+    "include": [
+        "./**/*",
+        "../../../typings/xterm.d.ts"
+    ]
+}

addons/xterm-addon-ligatures/typings/xterm-addon-ligatures.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * This contains the type declarations for the xterm-addon-ligatures library.
+ * Note that some interfaces may differ between this file and the actual
+ * implementation in src/, that's because this file declares the *public* API
+ * which is intended to be stable and consumed by external programs.
+ */
+
+import { Terminal, ITerminalAddon } from 'xterm';
+
+declare module 'xterm-addon-ligatures' {
+  /**
+   * An xterm.js addon that enables web links.
+   */
+  export class LigaturesAddon implements ITerminalAddon {
+    /**
+     * Creates a new ligatures addon.
+     */
+    constructor();
+
+    /**
+     * Activates the addon
+     * @param terminal The terminal the addon is being loaded in.
+     */
+    public activate(terminal: Terminal): void;
+
+    /**
+     * Disposes the addon.
+     */
+    public dispose(): void;
+  }
+}

addons/xterm-addon-ligatures/webpack.config.js

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+const path = require('path');
+
+const addonName = 'LigaturesAddon';
+const mainFile = 'xterm-addon-ligatures.js';
+
+module.exports = {
+  entry: `./out/${addonName}.js`,
+  devtool: 'source-map',
+  target: 'electron-renderer',
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        use: ["source-map-loader"],
+        enforce: "pre",
+        exclude: /node_modules/
+      }
+    ]
+  },
+  output: {
+    filename: mainFile,
+    path: path.resolve('./lib'),
+    library: addonName,
+    libraryTarget: 'umd'
+  },
+  mode: 'production',
+  externals: {
+    'font-finder':'font-finder',
+    'font-ligatures':'font-ligatures'
+  }
+};

addons/xterm-addon-ligatures/yarn.lock

@@ -0,0 +1,236 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@sinonjs/commons@^1", "@sinonjs/commons@^1.0.2", "@sinonjs/commons@^1.3.0", "@sinonjs/commons@^1.7.0":
+  version "1.8.0"
+  resolved "https://registry.yarnpkg.com/@sinonjs/commons/-/commons-1.8.0.tgz#c8d68821a854c555bba172f3b06959a0039b236d"
+  integrity sha512-wEj54PfsZ5jGSwMX68G8ZXFawcSglQSXqCftWX3ec8MDUzQdHgcKvw97awHbY0efQEL5iKUOAmmVtoYgmrSG4Q==
+  dependencies:
+    type-detect "4.0.8"
+
+"@sinonjs/formatio@^3.0.0", "@sinonjs/formatio@^3.2.1":
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/@sinonjs/formatio/-/formatio-3.2.2.tgz#771c60dfa75ea7f2d68e3b94c7e888a78781372c"
+  integrity sha512-B8SEsgd8gArBLMD6zpRw3juQ2FVSsmdd7qlevyDqzS9WTCtvF55/gAL+h6gue8ZvPYcdiPdvueM/qm//9XzyTQ==
+  dependencies:
+    "@sinonjs/commons" "^1"
+    "@sinonjs/samsam" "^3.1.0"
+
+"@sinonjs/samsam@^2.1.2":
+  version "2.1.3"
+  resolved "https://registry.yarnpkg.com/@sinonjs/samsam/-/samsam-2.1.3.tgz#62cf2a9b624edc795134135fe37fc2ae8ea36be3"
+  integrity sha512-8zNeBkSKhU9a5cRNbpCKau2WWPfan+Q2zDlcXvXyhn9EsMqgYs4qzo0XHNVlXC6ABQL8fT6nV+zzo5RTHJzyXw==
+
+"@sinonjs/samsam@^3.1.0":
+  version "3.3.3"
+  resolved "https://registry.yarnpkg.com/@sinonjs/samsam/-/samsam-3.3.3.tgz#46682efd9967b259b81136b9f120fd54585feb4a"
+  integrity sha512-bKCMKZvWIjYD0BLGnNrxVuw4dkWCYsLqFOUWw8VgKF/+5Y+mE7LfHWPIYoDXowH+3a9LsWDMo0uAP8YDosPvHQ==
+  dependencies:
+    "@sinonjs/commons" "^1.3.0"
+    array-from "^2.1.1"
+    lodash "^4.17.15"
+
+"@sinonjs/text-encoding@^0.7.1":
+  version "0.7.1"
+  resolved "https://registry.yarnpkg.com/@sinonjs/text-encoding/-/text-encoding-0.7.1.tgz#8da5c6530915653f3a1f38fd5f101d8c3f8079c5"
+  integrity sha512-+iTbntw2IZPb/anVDbypzfQa+ay64MW0Zo8aJ8gZPWMMK6/OubMVb6lUPMagqjOPnmtauXnFCACVl3O7ogjeqQ==
+
+"@types/sinon@^5.0.1":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@types/sinon/-/sinon-5.0.1.tgz#a15b36ec42f1f53166617491feabd1734cb03e21"
+
+array-from@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/array-from/-/array-from-2.1.1.tgz#cfe9d8c26628b9dc5aecc62a9f5d8f1f352c1195"
+  integrity sha1-z+nYwmYoudxa7MYqn12PHzUsEZU=
+
+axios@^0.18.0:
+  version "0.18.1"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-0.18.1.tgz#ff3f0de2e7b5d180e757ad98000f1081b87bcea3"
+  dependencies:
+    follow-redirects "1.5.10"
+    is-buffer "^2.0.2"
+
+buffer-crc32@~0.2.3:
+  version "0.2.13"
+  resolved "https://registry.yarnpkg.com/buffer-crc32/-/buffer-crc32-0.2.13.tgz#0d333e3f00eac50aa1454abd30ef8c2a5d9a7242"
+
+debug@=3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
+  dependencies:
+    ms "2.0.0"
+
+diff@^3.5.0:
+  version "3.5.0"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-3.5.0.tgz#800c0dd1e0a8bfbc95835c202ad220fe317e5a12"
+
+fd-slicer@~1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/fd-slicer/-/fd-slicer-1.1.0.tgz#25c7c89cb1f9077f8891bbe61d8f390eae256f1e"
+  dependencies:
+    pend "~1.2.0"
+
+follow-redirects@1.5.10:
+  version "1.5.10"
+  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.5.10.tgz#7b7a9f9aea2fdff36786a94ff643ed07f4ff5e2a"
+  dependencies:
+    debug "=3.1.0"
+
+font-finder@^1.0.3, font-finder@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/font-finder/-/font-finder-1.0.4.tgz#2ca944954dd8d0e1b5bdc4c596cc08607761d89b"
+  dependencies:
+    get-system-fonts "^2.0.0"
+    promise-stream-reader "^1.0.1"
+
+font-ligatures@^1.3.3:
+  version "1.3.3"
+  resolved "https://registry.yarnpkg.com/font-ligatures/-/font-ligatures-1.3.3.tgz#63fff18dc8adb3a11fe5eec1f4e8d7edfa8075b9"
+  integrity sha512-NSGpHgVNX81M7AWS1XylK1UZbN3QllfUIDAAuPv6TUcl5O2b781JcKS5L2RopAU0AqlTyX3ZuX/04eaMpbVrHA==
+  dependencies:
+    font-finder "^1.0.3"
+    lru-cache "^4.1.3"
+    opentype.js "^0.8.0"
+
+get-system-fonts@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/get-system-fonts/-/get-system-fonts-2.0.0.tgz#a43b9a33f05c0715a60176d2aad5ce6e98f0a3c6"
+
+has-flag@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
+
+is-buffer@^2.0.2:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-2.0.3.tgz#4ecf3fcf749cbd1e472689e109ac66261a25e725"
+
+isarray@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf"
+
+just-extend@^4.0.2:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/just-extend/-/just-extend-4.1.0.tgz#7278a4027d889601640ee0ce0e5a00b992467da4"
+  integrity sha512-ApcjaOdVTJ7y4r08xI5wIqpvwS48Q0PBG4DJROcEkH1f8MdAiNFyFxz3xoL0LWAVwjrwPYZdVHHxhRHcx/uGLA==
+
+lodash.get@^4.4.2:
+  version "4.4.2"
+  resolved "https://registry.yarnpkg.com/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99"
+
+lodash@^4.17.15:
+  version "4.17.19"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.19.tgz#e48ddedbe30b3321783c5b4301fbd353bc1e4a4b"
+  integrity sha512-JNvd8XER9GQX0v2qJgsaN/mzFCNA5BRe/j8JN9d+tWyGLSodKQHKFicdwNYzWwI3wjRnaKPsGj1XkBjx/F96DQ==
+
+lolex@^2.7.5:
+  version "2.7.5"
+  resolved "https://registry.yarnpkg.com/lolex/-/lolex-2.7.5.tgz#113001d56bfc7e02d56e36291cc5c413d1aa0733"
+  integrity sha512-l9x0+1offnKKIzYVjyXU2SiwhXDLekRzKyhnbyldPHvC7BvLPVpdNUNR2KeMAiCN2D/kLNttZgQD5WjSxuBx3Q==
+
+lolex@^5.0.1:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/lolex/-/lolex-5.1.2.tgz#953694d098ce7c07bc5ed6d0e42bc6c0c6d5a367"
+  integrity sha512-h4hmjAvHTmd+25JSwrtTIuwbKdwg5NzZVRMLn9saij4SZaepCrTCxPr35H/3bjwfMJtN+t3CX8672UIkglz28A==
+  dependencies:
+    "@sinonjs/commons" "^1.7.0"
+
+lru-cache@^4.1.3:
+  version "4.1.3"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-4.1.3.tgz#a1175cf3496dfc8436c156c334b4955992bce69c"
+  dependencies:
+    pseudomap "^1.0.2"
+    yallist "^2.1.2"
+
+minimist@^1.2.5:
+  version "1.2.5"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
+  integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
+
+mkdirp@0.5.5:
+  version "0.5.5"
+  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
+  integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==
+  dependencies:
+    minimist "^1.2.5"
+
+ms@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
+
+nise@^1.4.5:
+  version "1.5.3"
+  resolved "https://registry.yarnpkg.com/nise/-/nise-1.5.3.tgz#9d2cfe37d44f57317766c6e9408a359c5d3ac1f7"
+  integrity sha512-Ymbac/94xeIrMf59REBPOv0thr+CJVFMhrlAkW/gjCIE58BGQdCj0x7KRCb3yz+Ga2Rz3E9XXSvUyyxqqhjQAQ==
+  dependencies:
+    "@sinonjs/formatio" "^3.2.1"
+    "@sinonjs/text-encoding" "^0.7.1"
+    just-extend "^4.0.2"
+    lolex "^5.0.1"
+    path-to-regexp "^1.7.0"
+
+opentype.js@^0.8.0:
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/opentype.js/-/opentype.js-0.8.0.tgz#acabcfa1642fbe894a3e4d759e43ba694e02bd35"
+  dependencies:
+    tiny-inflate "^1.0.2"
+
+path-to-regexp@^1.7.0:
+  version "1.7.0"
+  resolved "https://registry.yarnpkg.com/path-to-regexp/-/path-to-regexp-1.7.0.tgz#59fde0f435badacba103a84e9d3bc64e96b9937d"
+  dependencies:
+    isarray "0.0.1"
+
+pend@~1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/pend/-/pend-1.2.0.tgz#7a57eb550a6783f9115331fcf4663d5c8e007a50"
+
+promise-stream-reader@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/promise-stream-reader/-/promise-stream-reader-1.0.1.tgz#4e793a79c9d49a73ccd947c6da9c127f12923649"
+
+pseudomap@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3"
+
+sinon@6.3.5:
+  version "6.3.5"
+  resolved "https://registry.yarnpkg.com/sinon/-/sinon-6.3.5.tgz#0f6d6a5b4ebaad1f6e8e019395542d1d02c144a0"
+  integrity sha512-xgoZ2gKjyVRcF08RrIQc+srnSyY1JDJtxu3Nsz07j1ffjgXoY6uPLf/qja6nDBZgzYYEovVkFryw2+KiZz11xQ==
+  dependencies:
+    "@sinonjs/commons" "^1.0.2"
+    "@sinonjs/formatio" "^3.0.0"
+    "@sinonjs/samsam" "^2.1.2"
+    diff "^3.5.0"
+    lodash.get "^4.4.2"
+    lolex "^2.7.5"
+    nise "^1.4.5"
+    supports-color "^5.5.0"
+    type-detect "^4.0.8"
+
+supports-color@^5.5.0:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
+  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
+  dependencies:
+    has-flag "^3.0.0"
+
+tiny-inflate@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/tiny-inflate/-/tiny-inflate-1.0.2.tgz#93d9decffc8805bd57eae4310f0b745e9b6fb3a7"
+
+type-detect@4.0.8, type-detect@^4.0.8:
+  version "4.0.8"
+  resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c"
+
+yallist@^2.1.2:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-2.1.2.tgz#1c11f9218f076089a47dd512f93c6699a6a81d52"
+
+yauzl@^2.10.0:
+  version "2.10.0"
+  resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.10.0.tgz#c7eb17c93e112cb1086fa6d8e51fb0667b79a5f9"
+  dependencies:
+    buffer-crc32 "~0.2.3"
+    fd-slicer "~1.1.0"

addons/xterm-addon-search/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-search",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-search/src/SearchAddon.ts

@@ -110,8 +110,12 @@ export class SearchAddon implements ITerminalAddon {
       }
     }
 
-    // If there is only one result, return true.
-    if (!result && currentSelection) return true;
+    // If there is only one result, wrap back and return selection if it exists.
+    if (!result && currentSelection) {
+      searchPosition.startRow = currentSelection.startRow;
+      searchPosition.startCol = 0;
+      result = this._findInLine(term, searchPosition, searchOptions);
+    }
 
     // Set selection and scroll if a result was found
     return this._selectResult(result);
@@ -175,7 +179,7 @@ export class SearchAddon implements ITerminalAddon {
     }
     // If we hit the top and didn't search from the very bottom wrap back down
     if (!result && startRow !== (this._terminal.buffer.active.baseY + this._terminal.rows)) {
-      for (let y = (this._terminal.buffer.active.baseY + this._terminal.rows); y > startRow; y--) {
+      for (let y = (this._terminal.buffer.active.baseY + this._terminal.rows); y >= startRow; y--) {
         searchPosition.startRow = y;
         result = this._findInLine(term, searchPosition, searchOptions, isReverseSearch);
         if (result) {

addons/xterm-addon-serialize/benchmark/SerializeAddon.benchmark.ts

@@ -7,11 +7,11 @@ import { perfContext, before, ThroughputRuntimeCase } from 'xterm-benchmark';
 
 import { spawn } from 'node-pty';
 import { Utf8ToUtf32, stringFromCodePoint } from 'common/input/TextDecoder';
-import { Terminal } from 'public/Terminal';
+import { Terminal } from 'browser/public/Terminal';
 import { SerializeAddon } from 'SerializeAddon';
 
 class TestTerminal extends Terminal {
-  writeSync(data: string): void {
+  public writeSync(data: string): void {
     (this as any)._core.writeSync(data);
   }
 }

addons/xterm-addon-serialize/benchmark/tsconfig.json

@@ -11,8 +11,6 @@
     "paths": {
       "common/*": ["../../../src/common/*"],
       "browser/*": ["../../../src/browser/*"],
-      "public/*": ["../../../src/public/*"],
-      "Terminal": ["../../../src/Terminal"],
       "SerializeAddon": ["../src/SerializeAddon"]
     }
   },

addons/xterm-addon-serialize/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-serialize",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-serialize/src/SerializeAddon.ts

@@ -15,7 +15,7 @@ function constrain(value: number, low: number, high: number): number {
 abstract class BaseSerializeHandler {
   constructor(private _buffer: IBuffer) { }
 
-  serialize(startRow: number, endRow: number): string {
+  public serialize(startRow: number, endRow: number): string {
     // we need two of them to flip between old and new cell
     const cell1 = this._buffer.getNullCell();
     const cell2 = this._buffer.getNullCell();

addons/xterm-addon-unicode11/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-unicode11",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-web-links/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-web-links",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-web-links/src/WebLinkProvider.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { ILinkProvider, IBufferCellPosition, ILink, Terminal, IBuffer } from 'xterm';
+import { ILinkProvider, IBufferCellPosition, ILink, Terminal } from 'xterm';
 
 export class WebLinkProvider implements ILinkProvider {
 
@@ -15,19 +15,20 @@ export class WebLinkProvider implements ILinkProvider {
 
   }
 
-  provideLink(position: IBufferCellPosition, callback: (link: ILink | undefined) => void): void {
-    callback(LinkComputer.computeLink(position, this._regex, this._terminal, this._handler));
+  public provideLinks(y: number, callback: (links: ILink[] | undefined) => void): void {
+    callback(LinkComputer.computeLink(y, this._regex, this._terminal, this._handler));
   }
 }
 
 export class LinkComputer {
-  public static computeLink(position: IBufferCellPosition, regex: RegExp, terminal: Terminal, handler: (event: MouseEvent, uri: string) => void): ILink | undefined {
+  public static computeLink(y: number, regex: RegExp, terminal: Terminal, handler: (event: MouseEvent, uri: string) => void): ILink[] {
     const rex = new RegExp(regex.source, (regex.flags || '') + 'g');
 
-    const [line, startLineIndex] = LinkComputer._translateBufferLineToStringWithWrap(position.y - 1, false, terminal);
+    const [line, startLineIndex] = LinkComputer._translateBufferLineToStringWithWrap(y - 1, false, terminal);
 
     let match;
     let stringIndex = -1;
+    const result: ILink[] = [];
 
     while ((match = rex.exec(line)) !== null) {
       const text = match[1];
@@ -68,8 +69,10 @@ export class LinkComputer {
         }
       };
 
-      return { range, text, activate: handler };
+      result.push({ range, text, activate: handler });
     }
+
+    return result;
   }
 
   /**

addons/xterm-addon-web-links/src/WebLinksAddon.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { Terminal, ILinkMatcherOptions, ITerminalAddon, ILinkProvider, IDisposable } from 'xterm';
+import { Terminal, ILinkMatcherOptions, ITerminalAddon, IDisposable } from 'xterm';
 import { WebLinkProvider } from './WebLinkProvider';
 
 const protocolClause = '(https?:\\/\\/)';
@@ -15,7 +15,7 @@ const ipClause = '((\\d{1,3}\\.){3}\\d{1,3})';
 const localHostClause = '(localhost)';
 const portClause = '(:\\d{1,5})';
 const hostClause = '((' + domainBodyClause + '\\.' + tldClause + ')|' + ipClause + '|' + localHostClause + ')' + portClause + '?';
-const pathCharacterSet = '(\\/[\\/\\w\\.\\-%~:+]*)*([^:"\'\\s])';
+const pathCharacterSet = '(\\/[\\/\\w\\.\\-%~:+@]*)*([^:"\'\\s])';
 const pathClause = '(' + pathCharacterSet + ')?';
 const queryStringHashFragmentCharacterSet = '[0-9\\w\\[\\]\\(\\)\\/\\?\\!#@$%&\'*+,:;~\\=\\.\\-]*';
 const queryStringClause = '(\\?' + queryStringHashFragmentCharacterSet + ')?';

addons/xterm-addon-webgl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm-addon-webgl",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "author": {
     "name": "The xterm.js authors",
     "url": "https://xtermjs.org/"

addons/xterm-addon-webgl/src/GlyphRenderer.ts

@@ -213,14 +213,14 @@ export class GlyphRenderer {
     // a_cellpos only changes on resize
   }
 
-  public updateSelection(model: IRenderModel, columnSelectMode: boolean): void {
+  public updateSelection(model: IRenderModel): void {
     const terminal = this._terminal;
 
     this._vertices.selectionAttributes = slice(this._vertices.attributes, 0);
 
     const bg = (this._colors.selectionOpaque.rgba >>> 8) | Attributes.CM_RGB;
 
-    if (columnSelectMode) {
+    if (model.selection.columnSelectMode) {
       const startCol = model.selection.startCol;
       const width = model.selection.endCol - startCol;
       const height = model.selection.viewportCappedEndRow - model.selection.viewportCappedStartRow + 1;

addons/xterm-addon-webgl/src/RectangleRenderer.ts

@@ -171,7 +171,7 @@ export class RectangleRenderer {
     );
   }
 
-  public updateSelection(model: ISelectionRenderModel, columnSelectMode: boolean): void {
+  public updateSelection(model: ISelectionRenderModel): void {
     const terminal = this._terminal;
 
     if (!model.hasSelection) {
@@ -179,7 +179,7 @@ export class RectangleRenderer {
       return;
     }
 
-    if (columnSelectMode) {
+    if (model.columnSelectMode) {
       const startCol = model.startCol;
       const width = model.endCol - startCol;
       const height = model.viewportCappedEndRow - model.viewportCappedStartRow + 1;

addons/xterm-addon-webgl/src/RenderModel.ts

@@ -22,6 +22,7 @@ export class RenderModel implements IRenderModel {
     this.lineLengths = new Uint32Array(0);
     this.selection = {
       hasSelection: false,
+      columnSelectMode: false,
       viewportStartRow: 0,
       viewportEndRow: 0,
       viewportCappedStartRow: 0,

addons/xterm-addon-webgl/src/Types.d.ts

@@ -56,6 +56,7 @@ export interface IRenderModel {
 
 export interface ISelectionRenderModel {
   hasSelection: boolean;
+  columnSelectMode: boolean;
   viewportStartRow: number;
   viewportEndRow: number;
   viewportCappedStartRow: number;

addons/xterm-addon-webgl/src/WebglRenderer.api.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { ITerminalOptions } from '../../../src/Types';
+import { ITerminalOptions } from '../../../src/common/Types';
 import { ITheme } from 'xterm';
 import { assert } from 'chai';
 import { openTerminal, pollFor, writeSync, getBrowserType } from '../../../out-test/api/TestUtils';
@@ -341,10 +341,6 @@ describe('WebGL Renderer Integration Tests', async () => {
       await writeSync(page, data);
       for (let y = 0; y < 240 / 16; y++) {
         for (let x = 0; x < 16; x++) {
-          const cssColor = COLORS_16_TO_255[y * 16 + x];
-          const r = parseInt(cssColor.substr(1, 2), 16);
-          const g = parseInt(cssColor.substr(3, 2), 16);
-          const b = parseInt(cssColor.substr(5, 2), 16);
           await pollFor(page, () => getCellColor(x + 1, y + 1), [0, 0, 0, 255]);
         }
       }
@@ -670,7 +666,6 @@ describe('WebGL Renderer Integration Tests', async () => {
       await writeSync(page, data);
       for (let y = 0; y < 16; y++) {
         for (let x = 0; x < 16; x++) {
-          const i = y * 16 + x;
           await pollFor(page, () => getCellColor(x + 1, y + 1), [0, 0, 0, 255]);
         }
       }

addons/xterm-addon-webgl/src/WebglRenderer.ts

@@ -3,7 +3,6 @@
  * @license MIT
  */
 
-import { ITerminal } from '../../../src/Types';
 import { GlyphRenderer } from './GlyphRenderer';
 import { LinkRenderLayer } from './renderLayer/LinkRenderLayer';
 import { CursorRenderLayer } from './renderLayer/CursorRenderLayer';
@@ -16,8 +15,8 @@ import { Disposable } from 'common/Lifecycle';
 import { NULL_CELL_CODE } from 'common/buffer/Constants';
 import { Terminal, IEvent } from 'xterm';
 import { IRenderLayer } from './renderLayer/Types';
-import { IRenderDimensions, IRenderer, IRequestRefreshRowsEvent } from 'browser/renderer/Types';
-import { IColorSet } from 'browser/Types';
+import { IRenderDimensions, IRenderer, IRequestRedrawEvent } from 'browser/renderer/Types';
+import { ITerminal, IColorSet } from 'browser/Types';
 import { EventEmitter } from 'common/EventEmitter';
 import { CellData } from 'common/buffer/CellData';
 
@@ -39,8 +38,8 @@ export class WebglRenderer extends Disposable implements IRenderer {
   private _core: ITerminal;
   private _isAttached: boolean;
 
-  private _onRequestRefreshRows = new EventEmitter<IRequestRefreshRowsEvent>();
-  public get onRequestRefreshRows(): IEvent<IRequestRefreshRowsEvent> { return this._onRequestRefreshRows.event; }
+  private _onRequestRedraw = new EventEmitter<IRequestRedrawEvent>();
+  public get onRequestRedraw(): IEvent<IRequestRedrawEvent> { return this._onRequestRedraw.event; }
 
   constructor(
     private _terminal: Terminal,
@@ -52,8 +51,8 @@ export class WebglRenderer extends Disposable implements IRenderer {
     this._core = (this._terminal as any)._core;
 
     this._renderLayers = [
-      new LinkRenderLayer(this._core.screenElement, 2, this._colors, this._core),
-      new CursorRenderLayer(this._core.screenElement, 3, this._colors, this._onRequestRefreshRows)
+      new LinkRenderLayer(this._core.screenElement!, 2, this._colors, this._core),
+      new CursorRenderLayer(this._core.screenElement!, 3, this._colors, this._onRequestRedraw)
     ];
     this.dimensions = {
       scaledCharWidth: 0,
@@ -83,7 +82,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
     if (!this._gl) {
       throw new Error('WebGL2 not supported ' + this._gl);
     }
-    this._core.screenElement.appendChild(this._canvas);
+    this._core.screenElement!.appendChild(this._canvas);
 
     this._rectangleRenderer = new RectangleRenderer(this._terminal, this._colors, this._gl, this.dimensions);
     this._glyphRenderer = new GlyphRenderer(this._terminal, this._colors, this._gl, this.dimensions);
@@ -91,12 +90,12 @@ export class WebglRenderer extends Disposable implements IRenderer {
     // Update dimensions and acquire char atlas
     this.onCharSizeChanged();
 
-    this._isAttached = document.body.contains(this._core.screenElement);
+    this._isAttached = document.body.contains(this._core.screenElement!);
   }
 
   public dispose(): void {
     this._renderLayers.forEach(l => l.dispose());
-    this._core.screenElement.removeChild(this._canvas);
+    this._core.screenElement!.removeChild(this._canvas);
     super.dispose();
   }
 
@@ -117,6 +116,9 @@ export class WebglRenderer extends Disposable implements IRenderer {
 
     this._refreshCharAtlas();
 
+    this._rectangleRenderer.updateSelection(this._model.selection);
+    this._glyphRenderer.updateSelection(this._model);
+
     // Force a full refresh
     this._model.clear();
   }
@@ -147,8 +149,8 @@ export class WebglRenderer extends Disposable implements IRenderer {
     this._canvas.style.height = `${this.dimensions.canvasHeight}px`;
 
     // Resize the screen
-    this._core.screenElement.style.width = `${this.dimensions.canvasWidth}px`;
-    this._core.screenElement.style.height = `${this.dimensions.canvasHeight}px`;
+    this._core.screenElement!.style.width = `${this.dimensions.canvasWidth}px`;
+    this._core.screenElement!.style.height = `${this.dimensions.canvasHeight}px`;
     this._glyphRenderer.setDimensions(this.dimensions);
     this._glyphRenderer.onResize();
 
@@ -170,15 +172,15 @@ export class WebglRenderer extends Disposable implements IRenderer {
     this._renderLayers.forEach(l => l.onFocus(this._terminal));
   }
 
-  public onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void {
+  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void {
     this._renderLayers.forEach(l => l.onSelectionChanged(this._terminal, start, end, columnSelectMode));
 
-    this._updateSelectionModel(start, end);
+    this._updateSelectionModel(start, end, columnSelectMode);
 
-    this._rectangleRenderer.updateSelection(this._model.selection, columnSelectMode);
-    this._glyphRenderer.updateSelection(this._model, columnSelectMode);
+    this._rectangleRenderer.updateSelection(this._model.selection);
+    this._glyphRenderer.updateSelection(this._model);
 
-    this._onRequestRefreshRows.fire({ start: 0, end: this._terminal.rows - 1 });
+    this._onRequestRedraw.fire({ start: 0, end: this._terminal.rows - 1 });
   }
 
   public onCursorMove(): void {
@@ -226,7 +228,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
 
   public renderRows(start: number, end: number): void {
     if (!this._isAttached) {
-      if (document.body.contains(this._core.screenElement) && (this._core as any)._charSizeService.width && (this._core as any)._charSizeService.height) {
+      if (document.body.contains(this._core.screenElement!) && (this._core as any)._charSizeService.width && (this._core as any)._charSizeService.height) {
         this._updateDimensions();
         this._refreshCharAtlas();
         this._isAttached = true;
@@ -292,7 +294,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
     this._rectangleRenderer.updateBackgrounds(this._model);
   }
 
-  private _updateSelectionModel(start: [number, number], end: [number, number]): void {
+  private _updateSelectionModel(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void {
     const terminal = this._terminal;
 
     // Selection does not exist
@@ -314,6 +316,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
     }
 
     this._model.selection.hasSelection = true;
+    this._model.selection.columnSelectMode = columnSelectMode;
     this._model.selection.viewportStartRow = viewportStartRow;
     this._model.selection.viewportEndRow = viewportEndRow;
     this._model.selection.viewportCappedStartRow = viewportCappedStartRow;

addons/xterm-addon-webgl/src/atlas/CharAtlasUtils.ts

@@ -20,7 +20,7 @@ export function generateConfig(scaledCharWidth: number, scaledCharHeight: number
     background: colors.background,
     cursor: NULL_COLOR,
     cursorAccent: NULL_COLOR,
-    selection: NULL_COLOR,
+    selectionTransparent: NULL_COLOR,
     selectionOpaque: NULL_COLOR,
     // For the static char atlas, we only use the first 16 colors, but we need all 256 for the
     // dynamic character atlas.

addons/xterm-addon-webgl/src/atlas/WebglCharAtlas.ts

@@ -349,7 +349,7 @@ export class WebglCharAtlas implements IDisposable {
     const fontStyle = italic ? 'italic' : '';
     this._tmpCtx.font =
       `${fontStyle} ${fontWeight} ${this._config.fontSize * this._config.devicePixelRatio}px ${this._config.fontFamily}`;
-    this._tmpCtx.textBaseline = 'top';
+    this._tmpCtx.textBaseline = 'middle';
 
     this._tmpCtx.fillStyle = this._getForegroundCss(bg, bgColorMode, bgColor, fg, fgColorMode, fgColor, inverse, bold);
 
@@ -359,7 +359,7 @@ export class WebglCharAtlas implements IDisposable {
     }
 
     // Draw the character
-    this._tmpCtx.fillText(chars, TMP_CANVAS_GLYPH_PADDING, TMP_CANVAS_GLYPH_PADDING);
+    this._tmpCtx.fillText(chars, TMP_CANVAS_GLYPH_PADDING, TMP_CANVAS_GLYPH_PADDING + this._config.scaledCharHeight / 2);
     this._tmpCtx.restore();
 
     // clear the background from the character to avoid issues with drawing over the previous

addons/xterm-addon-webgl/src/renderLayer/BaseRenderLayer.ts

@@ -58,7 +58,7 @@ export abstract class BaseRenderLayer implements IRenderLayer {
   public onFocus(terminal: Terminal): void {}
   public onCursorMove(terminal: Terminal): void {}
   public onGridChanged(terminal: Terminal, startRow: number, endRow: number): void {}
-  public onSelectionChanged(terminal: Terminal, start: [number, number], end: [number, number], columnSelectMode: boolean = false): void {}
+  public onSelectionChanged(terminal: Terminal, start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean = false): void {}
 
   public setColors(terminal: Terminal, colorSet: IColorSet): void {
     this._refreshCharAtlas(terminal, colorSet);

addons/xterm-addon-webgl/src/renderLayer/CursorRenderLayer.ts

@@ -8,7 +8,7 @@ import { BaseRenderLayer } from './BaseRenderLayer';
 import { ICellData } from 'common/Types';
 import { CellData } from 'common/buffer/CellData';
 import { IColorSet } from 'browser/Types';
-import { IRenderDimensions, IRequestRefreshRowsEvent } from 'browser/renderer/Types';
+import { IRenderDimensions, IRequestRedrawEvent } from 'browser/renderer/Types';
 import { IEventEmitter } from 'common/EventEmitter';
 
 interface ICursorState {
@@ -34,7 +34,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
     container: HTMLElement,
     zIndex: number,
     colors: IColorSet,
-    private _onRequestRefreshRowsEvent: IEventEmitter<IRequestRefreshRowsEvent>
+    private _onRequestRefreshRowsEvent: IEventEmitter<IRequestRedrawEvent>
   ) {
     super(container, 'cursor', zIndex, true, colors);
     this._state = {

addons/xterm-addon-webgl/src/renderLayer/LinkRenderLayer.ts

@@ -3,24 +3,23 @@
  * @license MIT
  */
 
-import { ILinkifierAccessor } from '../../../../src/Types';
 import { Terminal } from 'xterm';
 import { BaseRenderLayer } from './BaseRenderLayer';
 import { INVERTED_DEFAULT_COLOR } from 'browser/renderer/atlas/Constants';
 import { is256Color } from '../atlas/CharAtlasUtils';
-import { IColorSet, ILinkifierEvent } from 'browser/Types';
+import { ITerminal, IColorSet, ILinkifierEvent } from 'browser/Types';
 import { IRenderDimensions } from 'browser/renderer/Types';
 
 export class LinkRenderLayer extends BaseRenderLayer {
   private _state: ILinkifierEvent | undefined;
 
-  constructor(container: HTMLElement, zIndex: number, colors: IColorSet, terminal: ILinkifierAccessor) {
+  constructor(container: HTMLElement, zIndex: number, colors: IColorSet, terminal: ITerminal) {
     super(container, 'link', zIndex, true, colors);
-    terminal.linkifier.onLinkHover(e => this._onLinkHover(e));
-    terminal.linkifier.onLinkLeave(e => this._onLinkLeave(e));
+    terminal.linkifier.onShowLinkUnderline(e => this._onShowLinkUnderline(e));
+    terminal.linkifier.onHideLinkUnderline(e => this._onHideLinkUnderline(e));
 
-    terminal.linkifier2.onLinkHover(e => this._onLinkHover(e));
-    terminal.linkifier2.onLinkLeave(e => this._onLinkLeave(e));
+    terminal.linkifier2.onShowLinkUnderline(e => this._onShowLinkUnderline(e));
+    terminal.linkifier2.onHideLinkUnderline(e => this._onHideLinkUnderline(e));
   }
 
   public resize(terminal: Terminal, dim: IRenderDimensions): void {
@@ -45,7 +44,7 @@ export class LinkRenderLayer extends BaseRenderLayer {
     }
   }
 
-  private _onLinkHover(e: ILinkifierEvent): void {
+  private _onShowLinkUnderline(e: ILinkifierEvent): void {
     if (e.fg === INVERTED_DEFAULT_COLOR) {
       this._ctx.fillStyle = this._colors.background.css;
     } else if (e.fg !== undefined && is256Color(e.fg)) {
@@ -69,7 +68,7 @@ export class LinkRenderLayer extends BaseRenderLayer {
     this._state = e;
   }
 
-  private _onLinkLeave(e: ILinkifierEvent): void {
+  private _onHideLinkUnderline(e: ILinkifierEvent): void {
     this._clearCurrentLink();
   }
 }

addons/xterm-addon-webgl/src/renderLayer/Types.ts

@@ -42,7 +42,7 @@ export interface IRenderLayer extends IDisposable {
   /**
    * Calls when the selection changes.
    */
-  onSelectionChanged(terminal: Terminal, start: [number, number], end: [number, number], columnSelectMode: boolean): void;
+  onSelectionChanged(terminal: Terminal, start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
 
   /**
    * Registers a handler to join characters to render as a group

bin/extract_vtfeatures.js

@@ -1,7 +1,7 @@
 /**
  * Copyright (c) 2019 The xterm.js authors. All rights reserved.
  * @license MIT
- * 
+ *
  * Script to extract vt features documented in docstrings.
  */
 const fs = require('fs');
@@ -265,7 +265,7 @@ To denote the sequences the tables use the same abbreviations as xterm does:
   function hideDetailSections() {
     for (let section of document.getElementsByClassName('sequence-details')) section.style.display = 'none';
   }
-  
+
   function decorateDetailLinks() {
     for (let link of document.getElementsByClassName('link-details')) {
       link.addEventListener("click", toggleDetails, false);
@@ -344,11 +344,11 @@ function applyMacros(s) {
   return s;
 }
 
-function replaceStatus(s) {
-  if (s === 'supported') return '<span title="supported">✓</span>';
-  if (s === 'unsupported') return '<span title="unsupported">✗</span>';
-  return s;
-}
+// function replaceStatus(s) {
+//   if (s === 'supported') return '<span title="supported">✓</span>';
+//   if (s === 'unsupported') return '<span title="unsupported">✗</span>';
+//   return s;
+// }
 
 function createAnchorSlug(s) {
   return s.toLowerCase().split(' ').join('-');

bin/publish.js

@@ -28,6 +28,7 @@ if (changedFiles.some(e => e.search(/^addons\//) === -1)) {
 const addonPackageDirs = [
   path.resolve(__dirname, '../addons/xterm-addon-attach'),
   path.resolve(__dirname, '../addons/xterm-addon-fit'),
+  path.resolve(__dirname, '../addons/xterm-addon-ligatures'),
   path.resolve(__dirname, '../addons/xterm-addon-search'),
   path.resolve(__dirname, '../addons/xterm-addon-serialize'),
   path.resolve(__dirname, '../addons/xterm-addon-unicode11'),

bin/test.js

@@ -13,7 +13,6 @@ const env = { ...process.env };
 env.NODE_PATH = path.resolve(__dirname, '../out');
 
 let testFiles = [
-  './out/*test.js',
   './out/**/*test.js',
   './addons/**/out/*test.js',
 ];

bin/test_api.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+const cp = require('child_process');
+const path = require('path');
+
+
+// Add `out` to the NODE_PATH so absolute paths can be resolved.
+const env = { ...process.env };
+env.NODE_PATH = path.resolve(__dirname, '../out');
+
+let testFiles = [
+  './addons/**/out/*api.js',
+  './out-test/**/*api.js',
+];
+
+
+let flagArgs = [];
+
+if (process.argv.length > 2) {
+  const args = process.argv.slice(2);
+  flagArgs = args.filter(e => e.startsWith('--')).map(arg => arg.split('=')).reduce((arr, val) => arr.concat([...val], []));
+  console.info(flagArgs);
+  // ability to inject particular test files via
+  // yarn test [testFileA testFileB ...]
+  files = args.filter(e => !e.startsWith('--'));
+  if (files.length) {
+    testFiles = files;
+  }
+}
+
+
+
+env.DEBUG = flagArgs.indexOf('--debug') >= 0 ? 'debug' : '';
+
+const run = cp.spawnSync(
+  npmBinScript('mocha'),
+  [...testFiles, ...flagArgs],
+  {
+    cwd: path.resolve(__dirname, '..'),
+    env,
+    stdio: 'inherit'
+  }
+);
+
+function npmBinScript(script) {
+  return path.resolve(__dirname, `../node_modules/.bin/` + (process.platform === 'win32' ? `${script}.cmd` : script));
+}
+
+process.exit(run.status);

css/xterm.css

@@ -59,10 +59,10 @@
 }
 
 .xterm .xterm-helper-textarea {
-    /*
-     * HACK: to fix IE's blinking cursor
-     * Move textarea out of the screen to the far left, so that the cursor is not visible.
-     */
+    padding: 0;
+    border: 0;
+    margin: 0;
+    /* Move textarea out of the screen to the far left, so that the cursor is not visible */
     position: absolute;
     opacity: 0;
     left: -9999em;

demo/client.ts

@@ -8,7 +8,7 @@
 /// <reference path="../typings/xterm.d.ts"/>
 
 // Use tsc version (yarn watch)
-import { Terminal } from '../out/public/Terminal';
+import { Terminal } from '../out/browser/public/Terminal';
 import { AttachAddon } from '../addons/xterm-addon-attach/out/AttachAddon';
 import { FitAddon } from '../addons/xterm-addon-fit/out/FitAddon';
 import { SearchAddon, ISearchOptions } from '../addons/xterm-addon-search/out/SearchAddon';
@@ -112,9 +112,15 @@ const disposeRecreateButtonHandler = () => {
     term = null;
     window.term = null;
     socket = null;
+    addons.attach.instance = undefined;
+    addons.fit.instance = undefined;
+    addons.search.instance = undefined;
+    addons.serialize.instance = undefined;
+    addons.unicode11.instance = undefined;
+    addons['web-links'].instance = undefined;
+    addons.webgl.instance = undefined;
     document.getElementById('dispose').innerHTML = 'Recreate Terminal';
-  }
-  else {
+  } else {
     createTerminal();
     document.getElementById('dispose').innerHTML = 'Dispose terminal';
   }
@@ -357,7 +363,7 @@ function initAddons(term: TerminalType): void {
     if (!addon.canChange) {
       checkbox.disabled = true;
     }
-    checkbox.addEventListener('change', () => {
+    addDomListener(checkbox, 'change', () => {
       if (checkbox.checked) {
         addon.instance = new addon.ctor();
         term.loadAddon(addon.instance);
@@ -386,7 +392,9 @@ function initAddons(term: TerminalType): void {
     wrapper.appendChild(label);
     fragment.appendChild(wrapper);
   });
-  document.getElementById('addons-container').appendChild(fragment);
+  const container = document.getElementById('addons-container');
+  container.innerHTML = '';
+  container.appendChild(fragment);
 }
 
 function addDomListener(element: HTMLElement, type: string, handler: (...args: any[]) => any): void {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "4.5.0",
+  "version": "4.8.0",
   "main": "lib/xterm.js",
   "style": "css/xterm.css",
   "types": "typings/xterm.d.ts",
@@ -11,13 +11,13 @@
     "prepackage": "npm run build",
     "package": "webpack",
     "start": "node demo/start",
-    "lint": "eslint -c .eslintrc.json --ext .ts src/ addons/",
+    "lint": "eslint -c .eslintrc.json --max-warnings 0 --ext .ts src/ addons/",
     "test": "npm run test-unit",
     "posttest": "npm run lint",
     "test-api": "npm run test-api-chromium",
-    "test-api-chromium": "mocha \"**/*.api.js\" --browser chromium --timeout 20000",
-    "test-api-firefox": "mocha \"**/*.api.js\" --browser firefox --timeout 20000",
-    "test-api-webkit": "mocha \"**/*.api.js\" --browser webkit --timeout 20000",
+    "test-api-chromium": "node ./bin/test_api.js --browser=chromium --timeout=20000",
+    "test-api-firefox": "node ./bin/test_api.js --browser=firefox --timeout=20000",
+    "test-api-webkit": "node ./bin/test_api.js --browser=webkit --timeout=20000",
     "pretest-api-chromium": "node ./bin/download_browser.js --browser chromium",
     "pretest-api-firefox": "node ./bin/download_browser.js --browser firefox",
     "pretest-api-webkit": "node ./bin/download_browser.js --browser webkit",
@@ -39,34 +39,34 @@
     "@types/chai": "^4.2.11",
     "@types/debug": "^4.1.5",
     "@types/deep-equal": "^1.0.1",
-    "@types/glob": "^7.1.1",
-    "@types/jsdom": "^16.2.0",
+    "@types/glob": "^7.1.3",
+    "@types/jsdom": "^16.2.3",
     "@types/mocha": "^7.0.2",
     "@types/node": "^10.17.17",
     "@types/utf8": "^2.1.6",
-    "@types/webpack": "^4.41.10",
-    "@types/ws": "^7.2.3",
-    "@typescript-eslint/eslint-plugin": "^2.27.0",
-    "@typescript-eslint/parser": "^2.27.0",
+    "@types/webpack": "^4.41.21",
+    "@types/ws": "^7.2.6",
+    "@typescript-eslint/eslint-plugin": "^2.34.0",
+    "@typescript-eslint/parser": "^2.34.0",
     "chai": "^4.2.0",
-    "deep-equal": "^2.0.2",
+    "deep-equal": "^2.0.3",
     "eslint": "^6.8.0",
     "express": "^4.17.1",
     "express-ws": "^4.0.0",
     "glob": "^7.0.5",
-    "jsdom": "^16.2.2",
-    "mocha": "^7.1.1",
+    "jsdom": "^16.3.0",
+    "mocha": "^8.0.1",
     "mustache": "^4.0.1",
     "node-pty": "^0.9.0",
-    "nyc": "^15.0.1",
+    "nyc": "^15.1.0",
     "playwright-core": "^0.11.1",
-    "source-map-loader": "^0.2.4",
-    "ts-loader": "^6.0.4",
-    "typescript": "3.8",
+    "source-map-loader": "^1.0.1",
+    "ts-loader": "^8.0.0",
+    "typescript": "3.9",
     "utf8": "^3.0.0",
-    "webpack": "^4.35.3",
-    "webpack-cli": "^3.3.11",
-    "ws": "^7.0.0",
+    "webpack": "^4.43.0",
+    "webpack-cli": "^3.3.12",
+    "ws": "^7.3.1",
     "xterm-benchmark": "^0.1.3"
   }
 }

src/TestUtils.test.ts

@@ -1,360 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { IRenderer, IRenderDimensions, CharacterJoinerHandler, IRequestRefreshRowsEvent } from 'browser/renderer/Types';
-import { IInputHandlingTerminal, ICompositionHelper, ITerminal, IBrowser, ITerminalOptions } from './Types';
-import { IBuffer, IBufferStringIterator, IBufferSet } from 'common/buffer/Types';
-import { IBufferLine, ICellData, IAttributeData, ICircularList, XtermListener, ICharset } from 'common/Types';
-import { Buffer } from 'common/buffer/Buffer';
-import * as Browser from 'common/Platform';
-import { IDisposable, IMarker, IEvent, ISelectionPosition, ILinkProvider } from 'xterm';
-import { Terminal } from './Terminal';
-import { AttributeData } from 'common/buffer/AttributeData';
-import { IColorManager, IColorSet, ILinkMatcherOptions, ILinkifier, IViewport, ILinkifier2 } from 'browser/Types';
-import { IOptionsService, IUnicodeService } from 'common/services/Services';
-import { EventEmitter } from 'common/EventEmitter';
-import { IParams, IFunctionIdentifier } from 'common/parser/Types';
-import { ISelectionService } from 'browser/services/Services';
-
-export class TestTerminal extends Terminal {
-  get curAttrData(): IAttributeData { return (this as any)._inputHandler._curAttrData; }
-  keyDown(ev: any): boolean { return this._keyDown(ev); }
-  keyPress(ev: any): boolean { return this._keyPress(ev); }
-}
-
-export class MockTerminal implements ITerminal {
-  onBlur: IEvent<void>;
-  onFocus: IEvent<void>;
-  onA11yChar: IEvent<string>;
-  onA11yTab: IEvent<number>;
-  onCursorMove: IEvent<void>;
-  onLineFeed: IEvent<void>;
-  onSelectionChange: IEvent<void>;
-  onData: IEvent<string>;
-  onBinary: IEvent<string>;
-  onTitleChange: IEvent<string>;
-  onScroll: IEvent<number>;
-  onKey: IEvent<{ key: string, domEvent: KeyboardEvent }>;
-  onRender: IEvent<{ start: number, end: number }>;
-  onResize: IEvent<{ cols: number, rows: number }>;
-  markers: IMarker[];
-  optionsService: IOptionsService;
-  unicodeService: IUnicodeService;
-  addMarker(cursorYOffset: number): IMarker {
-    throw new Error('Method not implemented.');
-  }
-  selectLines(start: number, end: number): void {
-    throw new Error('Method not implemented.');
-  }
-  scrollToLine(line: number): void {
-    throw new Error('Method not implemented.');
-  }
-  static string: any;
-  setOption(key: any, value: any): void {
-    throw new Error('Method not implemented.');
-  }
-  blur(): void {
-    throw new Error('Method not implemented.');
-  }
-  focus(): void {
-    throw new Error('Method not implemented.');
-  }
-  resize(columns: number, rows: number): void {
-    throw new Error('Method not implemented.');
-  }
-  writeln(data: string): void {
-    throw new Error('Method not implemented.');
-  }
-  paste(data: string): void {
-    throw new Error('Method not implemented.');
-  }
-  open(parent: HTMLElement): void {
-    throw new Error('Method not implemented.');
-  }
-  attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void {
-    throw new Error('Method not implemented.');
-  }
-  addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable {
-    throw new Error('Method not implemented.');
-  }
-  addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable {
-    throw new Error('Method not implemented.');
-  }
-  addEscHandler(id: IFunctionIdentifier, handler: () => boolean): IDisposable {
-    throw new Error('Method not implemented.');
-  }
-  addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
-    throw new Error('Method not implemented.');
-  }
-  registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => boolean | void, options?: ILinkMatcherOptions): number {
-    throw new Error('Method not implemented.');
-  }
-  deregisterLinkMatcher(matcherId: number): void {
-    throw new Error('Method not implemented.');
-  }
-  registerLinkProvider(linkProvider: ILinkProvider): IDisposable {
-    throw new Error('Method not implemented.');
-  }
-  hasSelection(): boolean {
-    throw new Error('Method not implemented.');
-  }
-  getSelection(): string {
-    throw new Error('Method not implemented.');
-  }
-  getSelectionPosition(): ISelectionPosition | undefined {
-    throw new Error('Method not implemented.');
-  }
-  clearSelection(): void {
-    throw new Error('Method not implemented.');
-  }
-  select(column: number, row: number, length: number): void {
-    throw new Error('Method not implemented.');
-  }
-  selectAll(): void {
-    throw new Error('Method not implemented.');
-  }
-  dispose(): void {
-    throw new Error('Method not implemented.');
-  }
-  scrollPages(pageCount: number): void {
-    throw new Error('Method not implemented.');
-  }
-  scrollToTop(): void {
-    throw new Error('Method not implemented.');
-  }
-  scrollToBottom(): void {
-    throw new Error('Method not implemented.');
-  }
-  clear(): void {
-    throw new Error('Method not implemented.');
-  }
-  write(data: string): void {
-    throw new Error('Method not implemented.');
-  }
-  writeUtf8(data: Uint8Array): void {
-    throw new Error('Method not implemented.');
-  }
-  bracketedPasteMode: boolean;
-  renderer: IRenderer;
-  linkifier: ILinkifier;
-  linkifier2: ILinkifier2;
-  isFocused: boolean;
-  options: ITerminalOptions = {};
-  element: HTMLElement;
-  screenElement: HTMLElement;
-  rowContainer: HTMLElement;
-  selectionContainer: HTMLElement;
-  selectionService: ISelectionService;
-  textarea: HTMLTextAreaElement;
-  rows: number;
-  cols: number;
-  browser: IBrowser = <any>Browser;
-  writeBuffer: string[];
-  children: HTMLElement[];
-  cursorHidden: boolean;
-  cursorState: number;
-  scrollback: number;
-  buffers: IBufferSet;
-  buffer: IBuffer;
-  viewport: IViewport;
-  applicationCursor: boolean;
-  handler(data: string): void {
-    throw new Error('Method not implemented.');
-  }
-  on(event: string, callback: (...args: any[]) => void): void {
-    throw new Error('Method not implemented.');
-  }
-  off(type: string, listener: XtermListener): void {
-    throw new Error('Method not implemented.');
-  }
-  addDisposableListener(type: string, handler: XtermListener): IDisposable {
-    throw new Error('Method not implemented.');
-  }
-  scrollLines(disp: number, suppressScrollEvent: boolean): void {
-    throw new Error('Method not implemented.');
-  }
-  scrollToRow(absoluteRow: number): number {
-    throw new Error('Method not implemented.');
-  }
-  cancel(ev: Event, force?: boolean): void {
-    throw new Error('Method not implemented.');
-  }
-  log(text: string): void {
-    throw new Error('Method not implemented.');
-  }
-  emit(event: string, data: any): void {
-    throw new Error('Method not implemented.');
-  }
-  reset(): void {
-    throw new Error('Method not implemented.');
-  }
-  showCursor(): void {
-    throw new Error('Method not implemented.');
-  }
-  refresh(start: number, end: number): void {
-    throw new Error('Method not implemented.');
-  }
-  registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
-  deregisterCharacterJoiner(joinerId: number): void { }
-}
-
-export class MockInputHandlingTerminal implements IInputHandlingTerminal {
-  onA11yCharEmitter: EventEmitter<string>;
-  onA11yTabEmitter: EventEmitter<number>;
-  insertMode: boolean;
-  bracketedPasteMode: boolean;
-  sendFocus: boolean;
-  buffers: IBufferSet;
-  buffer: IBuffer = new MockBuffer();
-  viewport: IViewport;
-  scroll(eraseAttr: IAttributeData, isWrapped?: boolean): void {
-    throw new Error('Method not implemented.');
-  }
-  is(term: string): boolean {
-    throw new Error('Method not implemented.');
-  }
-  resize(x: number, y: number): void {
-    throw new Error('Method not implemented.');
-  }
-  showCursor(): void {
-    throw new Error('Method not implemented.');
-  }
-  handler(data: string): void {
-    throw new Error('Method not implemented.');
-  }
-  handleTitle(title: string): void {
-    throw new Error('Method not implemented.');
-  }
-}
-
-export class MockBuffer implements IBuffer {
-  markers: IMarker[];
-  addMarker(y: number): IMarker {
-    throw new Error('Method not implemented.');
-  }
-  isCursorInViewport: boolean;
-  lines: ICircularList<IBufferLine>;
-  ydisp: number;
-  ybase: number;
-  hasScrollback: boolean;
-  y: number;
-  x: number;
-  tabs: any;
-  scrollBottom: number;
-  scrollTop: number;
-  savedY: number;
-  savedX: number;
-  savedCharset: ICharset | null;
-  savedCurAttrData = new AttributeData();
-  translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string {
-    return Buffer.prototype.translateBufferLineToString.apply(this, arguments);
-  }
-  getWrappedRangeForLine(y: number): { first: number, last: number } {
-    return Buffer.prototype.getWrappedRangeForLine.apply(this, arguments);
-  }
-  nextStop(x?: number): number {
-    throw new Error('Method not implemented.');
-  }
-  prevStop(x?: number): number {
-    throw new Error('Method not implemented.');
-  }
-  setLines(lines: ICircularList<IBufferLine>): void {
-    this.lines = lines;
-  }
-  getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
-    return Buffer.prototype.getBlankLine.apply(this, arguments);
-  }
-  stringIndexToBufferIndex(lineIndex: number, stringIndex: number): number[] {
-    return Buffer.prototype.stringIndexToBufferIndex.apply(this, arguments);
-  }
-  iterator(trimRight: boolean, startIndex?: number, endIndex?: number): IBufferStringIterator {
-    return Buffer.prototype.iterator.apply(this, arguments);
-  }
-  getNullCell(attr?: IAttributeData): ICellData {
-    throw new Error('Method not implemented.');
-  }
-  getWhitespaceCell(attr?: IAttributeData): ICellData {
-    throw new Error('Method not implemented.');
-  }
-}
-
-export class MockRenderer implements IRenderer {
-  onRequestRefreshRows: IEvent<IRequestRefreshRowsEvent>;
-  onCanvasResize: IEvent<{ width: number, height: number }>;
-  onRender: IEvent<{ start: number, end: number }>;
-  dispose(): void {
-    throw new Error('Method not implemented.');
-  }
-  colorManager: IColorManager;
-  on(type: string, listener: XtermListener): void {
-    throw new Error('Method not implemented.');
-  }
-  off(type: string, listener: XtermListener): void {
-    throw new Error('Method not implemented.');
-  }
-  emit(type: string, data?: any): void {
-    throw new Error('Method not implemented.');
-  }
-  addDisposableListener(type: string, handler: XtermListener): IDisposable {
-    throw new Error('Method not implemented.');
-  }
-  dimensions: IRenderDimensions;
-  setColors(colors: IColorSet): void {
-    throw new Error('Method not implemented.');
-  }
-  onResize(cols: number, rows: number): void { }
-  onCharSizeChanged(): void { }
-  onBlur(): void { }
-  onFocus(): void { }
-  onSelectionChanged(start: [number, number], end: [number, number]): void { }
-  onCursorMove(): void { }
-  onOptionsChanged(): void { }
-  onDevicePixelRatioChange(): void { }
-  clear(): void { }
-  renderRows(start: number, end: number): void { }
-  registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
-  deregisterCharacterJoiner(): boolean { return true; }
-}
-
-export class MockViewport implements IViewport {
-  dispose(): void {
-    throw new Error('Method not implemented.');
-  }
-  scrollBarWidth: number = 0;
-  onThemeChange(colors: IColorSet): void {
-    throw new Error('Method not implemented.');
-  }
-  onWheel(ev: WheelEvent): boolean {
-    throw new Error('Method not implemented.');
-  }
-  onTouchStart(ev: TouchEvent): void {
-    throw new Error('Method not implemented.');
-  }
-  onTouchMove(ev: TouchEvent): boolean {
-    throw new Error('Method not implemented.');
-  }
-  syncScrollArea(): void { }
-  getLinesScrolled(ev: WheelEvent): number {
-    throw new Error('Method not implemented.');
-  }
-}
-
-export class MockCompositionHelper implements ICompositionHelper {
-  compositionstart(): void {
-    throw new Error('Method not implemented.');
-  }
-  compositionupdate(ev: CompositionEvent): void {
-    throw new Error('Method not implemented.');
-  }
-  compositionend(): void {
-    throw new Error('Method not implemented.');
-  }
-  updateCompositionElements(dontRecurse?: boolean): void {
-    throw new Error('Method not implemented.');
-  }
-  keydown(ev: KeyboardEvent): boolean {
-    return true;
-  }
-}

src/Types.d.ts

@@ -1,236 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { ITerminalOptions as IPublicTerminalOptions, IDisposable, IMarker, ISelectionPosition, ILinkProvider } from 'xterm';
-import { ICharset, IAttributeData, CharData, CoreMouseEventType } from 'common/Types';
-import { IEvent, IEventEmitter } from 'common/EventEmitter';
-import { IColorSet, ILinkifier, ILinkMatcherOptions, IViewport, ILinkifier2 } from 'browser/Types';
-import { IOptionsService, IUnicodeService } from 'common/services/Services';
-import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IParams, IFunctionIdentifier } from 'common/parser/Types';
-
-export type CustomKeyEventHandler = (event: KeyboardEvent) => boolean;
-
-export type LineData = CharData[];
-
-/**
- * This interface encapsulates everything needed from the Terminal by the
- * InputHandler. This cleanly separates the large amount of methods needed by
- * InputHandler cleanly from the ITerminal interface.
- */
-export interface IInputHandlingTerminal {
-  insertMode: boolean;
-  bracketedPasteMode: boolean;
-  sendFocus: boolean;
-
-  buffers: IBufferSet;
-  buffer: IBuffer;
-  viewport: IViewport;
-
-  onA11yCharEmitter: IEventEmitter<string>;
-  onA11yTabEmitter: IEventEmitter<number>;
-
-  scroll(eraseAttr: IAttributeData, isWrapped?: boolean): void;
-  is(term: string): boolean;
-  resize(x: number, y: number): void;
-  showCursor(): void;
-  handleTitle(title: string): void;
-}
-
-export interface ICompositionHelper {
-  compositionstart(): void;
-  compositionupdate(ev: CompositionEvent): void;
-  compositionend(): void;
-  updateCompositionElements(dontRecurse?: boolean): void;
-  keydown(ev: KeyboardEvent): boolean;
-}
-
-/**
- * Calls the parser and handles actions generated by the parser.
- */
-export interface IInputHandler {
-  parse(data: string | Uint8Array): void;
-  print(data: Uint32Array, start: number, end: number): void;
-
-  /** C0 BEL */ bell(): void;
-  /** C0 LF */ lineFeed(): void;
-  /** C0 CR */ carriageReturn(): void;
-  /** C0 BS */ backspace(): void;
-  /** C0 HT */ tab(): void;
-  /** C0 SO */ shiftOut(): void;
-  /** C0 SI */ shiftIn(): void;
-
-  /** CSI @ */ insertChars(params: IParams): void;
-  /** CSI SP @ */ scrollLeft(params: IParams): void;
-  /** CSI A */ cursorUp(params: IParams): void;
-  /** CSI SP A */ scrollRight(params: IParams): void;
-  /** CSI B */ cursorDown(params: IParams): void;
-  /** CSI C */ cursorForward(params: IParams): void;
-  /** CSI D */ cursorBackward(params: IParams): void;
-  /** CSI E */ cursorNextLine(params: IParams): void;
-  /** CSI F */ cursorPrecedingLine(params: IParams): void;
-  /** CSI G */ cursorCharAbsolute(params: IParams): void;
-  /** CSI H */ cursorPosition(params: IParams): void;
-  /** CSI I */ cursorForwardTab(params: IParams): void;
-  /** CSI J */ eraseInDisplay(params: IParams): void;
-  /** CSI K */ eraseInLine(params: IParams): void;
-  /** CSI L */ insertLines(params: IParams): void;
-  /** CSI M */ deleteLines(params: IParams): void;
-  /** CSI P */ deleteChars(params: IParams): void;
-  /** CSI S */ scrollUp(params: IParams): void;
-  /** CSI T */ scrollDown(params: IParams, collect?: string): void;
-  /** CSI X */ eraseChars(params: IParams): void;
-  /** CSI Z */ cursorBackwardTab(params: IParams): void;
-  /** CSI ` */ charPosAbsolute(params: IParams): void;
-  /** CSI a */ hPositionRelative(params: IParams): void;
-  /** CSI b */ repeatPrecedingCharacter(params: IParams): void;
-  /** CSI c */ sendDeviceAttributesPrimary(params: IParams): void;
-  /** CSI > c */ sendDeviceAttributesSecondary(params: IParams): void;
-  /** CSI d */ linePosAbsolute(params: IParams): void;
-  /** CSI e */ vPositionRelative(params: IParams): void;
-  /** CSI f */ hVPosition(params: IParams): void;
-  /** CSI g */ tabClear(params: IParams): void;
-  /** CSI h */ setMode(params: IParams, collect?: string): void;
-  /** CSI l */ resetMode(params: IParams, collect?: string): void;
-  /** CSI m */ charAttributes(params: IParams): void;
-  /** CSI n */ deviceStatus(params: IParams, collect?: string): void;
-  /** CSI p */ softReset(params: IParams, collect?: string): void;
-  /** CSI q */ setCursorStyle(params: IParams, collect?: string): void;
-  /** CSI r */ setScrollRegion(params: IParams, collect?: string): void;
-  /** CSI s */ saveCursor(params: IParams): void;
-  /** CSI u */ restoreCursor(params: IParams): void;
-  /** CSI ' } */ insertColumns(params: IParams): void;
-  /** CSI ' ~ */ deleteColumns(params: IParams): void;
-  /** OSC 0
-      OSC 2 */ setTitle(data: string): void;
-  /** ESC E */ nextLine(): void;
-  /** ESC = */ keypadApplicationMode(): void;
-  /** ESC > */ keypadNumericMode(): void;
-  /** ESC % G
-      ESC % @ */ selectDefaultCharset(): void;
-  /** ESC ( C
-      ESC ) C
-      ESC * C
-      ESC + C
-      ESC - C
-      ESC . C
-      ESC / C */ selectCharset(collectAndFlag: string): void;
-  /** ESC D */ index(): void;
-  /** ESC H */ tabSet(): void;
-  /** ESC M */ reverseIndex(): void;
-  /** ESC c */ fullReset(): void;
-  /** ESC n
-      ESC o
-      ESC |
-      ESC }
-      ESC ~ */ setgLevel(level: number): void;
-  /** ESC # 8 */ screenAlignmentPattern(): void;
-}
-
-export interface ITerminal extends IPublicTerminal, IElementAccessor, IBufferAccessor, ILinkifierAccessor {
-  screenElement: HTMLElement;
-  browser: IBrowser;
-  buffer: IBuffer;
-  buffers: IBufferSet;
-  viewport: IViewport;
-  bracketedPasteMode: boolean;
-  optionsService: IOptionsService;
-  // TODO: We should remove options once components adopt optionsService
-  options: ITerminalOptions;
-  unicodeService: IUnicodeService;
-
-  onBlur: IEvent<void>;
-  onFocus: IEvent<void>;
-  onA11yChar: IEvent<string>;
-  onA11yTab: IEvent<number>;
-
-  scrollLines(disp: number, suppressScrollEvent?: boolean): void;
-  cancel(ev: Event, force?: boolean): boolean | void;
-  showCursor(): void;
-}
-
-// Portions of the public API that are required by the internal Terminal
-export interface IPublicTerminal extends IDisposable {
-  textarea: HTMLTextAreaElement | undefined;
-  rows: number;
-  cols: number;
-  buffer: IBuffer;
-  markers: IMarker[];
-  onCursorMove: IEvent<void>;
-  onData: IEvent<string>;
-  onBinary: IEvent<string>;
-  onKey: IEvent<{ key: string, domEvent: KeyboardEvent }>;
-  onLineFeed: IEvent<void>;
-  onScroll: IEvent<number>;
-  onSelectionChange: IEvent<void>;
-  onRender: IEvent<{ start: number, end: number }>;
-  onResize: IEvent<{ cols: number, rows: number }>;
-  onTitleChange: IEvent<string>;
-  blur(): void;
-  focus(): void;
-  resize(columns: number, rows: number): void;
-  open(parent: HTMLElement): void;
-  attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void;
-  addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable;
-  addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable;
-  addEscHandler(id: IFunctionIdentifier, callback: () => boolean): IDisposable;
-  addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable;
-  registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => void, options?: ILinkMatcherOptions): number;
-  deregisterLinkMatcher(matcherId: number): void;
-  registerLinkProvider(linkProvider: ILinkProvider): IDisposable;
-  registerCharacterJoiner(handler: (text: string) => [number, number][]): number;
-  deregisterCharacterJoiner(joinerId: number): void;
-  addMarker(cursorYOffset: number): IMarker;
-  hasSelection(): boolean;
-  getSelection(): string;
-  getSelectionPosition(): ISelectionPosition | undefined;
-  clearSelection(): void;
-  select(column: number, row: number, length: number): void;
-  selectAll(): void;
-  selectLines(start: number, end: number): void;
-  dispose(): void;
-  scrollLines(amount: number): void;
-  scrollPages(pageCount: number): void;
-  scrollToTop(): void;
-  scrollToBottom(): void;
-  scrollToLine(line: number): void;
-  clear(): void;
-  write(data: string | Uint8Array, callback?: () => void): void;
-  paste(data: string): void;
-  refresh(start: number, end: number): void;
-  reset(): void;
-}
-
-export interface IBufferAccessor {
-  buffer: IBuffer;
-}
-
-export interface IElementAccessor {
-  readonly element: HTMLElement | undefined;
-}
-
-export interface ILinkifierAccessor {
-  linkifier: ILinkifier;
-  linkifier2: ILinkifier2;
-}
-
-// TODO: The options that are not in the public API should be reviewed
-export interface ITerminalOptions extends IPublicTerminalOptions {
-  [key: string]: any;
-  cancelEvents?: boolean;
-  convertEol?: boolean;
-  termName?: string;
-}
-
-export interface IBrowser {
-  isNode: boolean;
-  userAgent: string;
-  platform: string;
-  isFirefox: boolean;
-  isMac: boolean;
-  isIpad: boolean;
-  isIphone: boolean;
-  isWindows: boolean;
-}

src/browser/AccessibilityManager.ts

@@ -3,8 +3,8 @@
  * @license MIT
  */
 
-import * as Strings from './browser/LocalizableStrings';
-import { ITerminal } from './Types';
+import * as Strings from 'browser/LocalizableStrings';
+import { ITerminal } from 'browser/Types';
 import { IBuffer } from 'common/buffer/Types';
 import { isMac } from 'common/Platform';
 import { RenderDebouncer } from 'browser/RenderDebouncer';
@@ -12,6 +12,7 @@ import { addDisposableDomListener } from 'browser/Lifecycle';
 import { Disposable } from 'common/Lifecycle';
 import { ScreenDprMonitor } from 'browser/ScreenDprMonitor';
 import { IRenderService } from 'browser/services/Services';
+import { removeElementFromParent } from 'browser/Dom';
 
 const MAX_ROWS_TO_READ = 20;
 
@@ -79,6 +80,9 @@ export class AccessibilityManager extends Disposable {
     this._liveRegion.setAttribute('aria-live', 'assertive');
     this._accessibilityTreeRoot.appendChild(this._liveRegion);
 
+    if (!this._terminal.element) {
+      throw new Error('Cannot enable accessibility before Terminal.open');
+    }
     this._terminal.element.insertAdjacentElement('afterbegin', this._accessibilityTreeRoot);
 
     this.register(this._renderRowsDebouncer);
@@ -103,7 +107,7 @@ export class AccessibilityManager extends Disposable {
 
   public dispose(): void {
     super.dispose();
-    this._terminal.element.removeChild(this._accessibilityTreeRoot);
+    removeElementFromParent(this._accessibilityTreeRoot);
     this._rowElements.length = 0;
   }
 
@@ -237,9 +241,7 @@ export class AccessibilityManager extends Disposable {
 
     // Only detach/attach on mac as otherwise messages can go unaccounced
     if (isMac) {
-      if (this._liveRegion.parentNode) {
-        this._accessibilityTreeRoot.removeChild(this._liveRegion);
-      }
+      removeElementFromParent(this._liveRegion);
     }
   }
 

src/browser/Clipboard.ts

@@ -42,17 +42,17 @@ export function copyHandler(ev: ClipboardEvent, selectionService: ISelectionServ
  * @param ev The original paste event to be handled
  * @param term The terminal on which to apply the handled paste event
  */
-export function handlePasteEvent(ev: ClipboardEvent, textarea: HTMLTextAreaElement, bracketedPasteMode: boolean, coreService: ICoreService): void {
+export function handlePasteEvent(ev: ClipboardEvent, textarea: HTMLTextAreaElement, coreService: ICoreService): void {
   ev.stopPropagation();
   if (ev.clipboardData) {
     const text = ev.clipboardData.getData('text/plain');
-    paste(text, textarea, bracketedPasteMode, coreService);
+    paste(text, textarea, coreService);
   }
 }
 
-export function paste(text: string, textarea: HTMLTextAreaElement, bracketedPasteMode: boolean, coreService: ICoreService): void {
+export function paste(text: string, textarea: HTMLTextAreaElement, coreService: ICoreService): void {
   text = prepareTextForTerminal(text);
-  text = bracketTextForPaste(text, bracketedPasteMode);
+  text = bracketTextForPaste(text, coreService.decPrivateModes.bracketedPasteMode);
   coreService.triggerDataEvent(text, true);
   textarea.value = '';
 }
@@ -70,7 +70,6 @@ export function moveTextAreaUnderMouseCursor(ev: MouseEvent, textarea: HTMLTextA
   const top = ev.clientY - pos.top - 10;
 
   // Bring textarea at the cursor position
-  textarea.style.position = 'absolute';
   textarea.style.width = '20px';
   textarea.style.height = '20px';
   textarea.style.left = `${left}px`;
@@ -78,17 +77,6 @@ export function moveTextAreaUnderMouseCursor(ev: MouseEvent, textarea: HTMLTextA
   textarea.style.zIndex = '1000';
 
   textarea.focus();
-
-  // Reset the terminal textarea's styling
-  // Timeout needs to be long enough for click event to be handled.
-  setTimeout(() => {
-    textarea.style.position = '';
-    textarea.style.width = '';
-    textarea.style.height = '';
-    textarea.style.left = '';
-    textarea.style.top = '';
-    textarea.style.zIndex = '';
-  }, 200);
 }
 
 /**

src/browser/Color.test.ts

@@ -117,11 +117,43 @@ describe('Color', () => {
         assert.deepEqual(color.opaque({ css: '#ffffffff', rgba: 0xffffffff }), { css: '#ffffff', rgba: 0xffffffFF });
       });
     });
+
+    describe('isOpaque', () => {
+      it('should return true for opaque colors', () => {
+        assert.ok(color.isOpaque(css.toColor('#000000')));
+        assert.ok(color.isOpaque(css.toColor('#000000ff')));
+        assert.ok(color.isOpaque(css.toColor('#808080')));
+        assert.ok(color.isOpaque(css.toColor('#808080ff')));
+        assert.ok(color.isOpaque(css.toColor('#ffffff')));
+        assert.ok(color.isOpaque(css.toColor('#ffffffff')));
+      });
+      it('should return false for transparent colors', () => {
+        assert.ok(!color.isOpaque(css.toColor('#00000000')));
+        assert.ok(!color.isOpaque(css.toColor('#00000080')));
+        assert.ok(!color.isOpaque(css.toColor('#000000fe')));
+        assert.ok(!color.isOpaque(css.toColor('#80808000')));
+        assert.ok(!color.isOpaque(css.toColor('#80808080')));
+        assert.ok(!color.isOpaque(css.toColor('#808080fe')));
+        assert.ok(!color.isOpaque(css.toColor('#ffffff00')));
+        assert.ok(!color.isOpaque(css.toColor('#ffffff80')));
+        assert.ok(!color.isOpaque(css.toColor('#fffffffe')));
+      });
+    });
+
+    describe('opacity', () => {
+      it('should make the color transparent', () => {
+        assert.deepEqual(color.opacity(css.toColor('#000000'), 0), { css: '#00000000', rgba: 0x00000000 });
+        assert.deepEqual(color.opacity(css.toColor('#000000'), 0.25), { css: '#00000040', rgba: 0x00000040 });
+        assert.deepEqual(color.opacity(css.toColor('#000000'), 0.5), { css: '#00000080', rgba: 0x00000080 });
+        assert.deepEqual(color.opacity(css.toColor('#000000'), 0.75), { css: '#000000bf', rgba: 0x000000bf });
+        assert.deepEqual(color.opacity(css.toColor('#000000'), 1), { css: '#000000ff', rgba: 0x000000ff });
+      });
+    });
   });
 
   describe('css', () => {
     describe('toColor', () => {
-      it('should covert a CSS string to an IColor', () => {
+      it('should convert the #rrggbb format to an IColor', () => {
         assert.deepEqual(css.toColor('#000000'), { css: '#000000', rgba: 0x000000FF });
         assert.deepEqual(css.toColor('#101010'), { css: '#101010', rgba: 0x101010FF });
         assert.deepEqual(css.toColor('#202020'), { css: '#202020', rgba: 0x202020FF });
@@ -140,6 +172,25 @@ describe('Color', () => {
         assert.deepEqual(css.toColor('#f0f0f0'), { css: '#f0f0f0', rgba: 0xf0f0f0FF });
         assert.deepEqual(css.toColor('#ffffff'), { css: '#ffffff', rgba: 0xffffffFF });
       });
+      it('should convert the #rrggbbaa format to an IColor', () => {
+        assert.deepEqual(css.toColor('#00000000'), { css: '#00000000', rgba: 0x00000000 });
+        assert.deepEqual(css.toColor('#10101010'), { css: '#10101010', rgba: 0x10101010 });
+        assert.deepEqual(css.toColor('#20202020'), { css: '#20202020', rgba: 0x20202020 });
+        assert.deepEqual(css.toColor('#30303030'), { css: '#30303030', rgba: 0x30303030 });
+        assert.deepEqual(css.toColor('#40404040'), { css: '#40404040', rgba: 0x40404040 });
+        assert.deepEqual(css.toColor('#50505050'), { css: '#50505050', rgba: 0x50505050 });
+        assert.deepEqual(css.toColor('#60606060'), { css: '#60606060', rgba: 0x60606060 });
+        assert.deepEqual(css.toColor('#70707070'), { css: '#70707070', rgba: 0x70707070 });
+        assert.deepEqual(css.toColor('#80808080'), { css: '#80808080', rgba: 0x80808080 });
+        assert.deepEqual(css.toColor('#90909090'), { css: '#90909090', rgba: 0x90909090 });
+        assert.deepEqual(css.toColor('#a0a0a0a0'), { css: '#a0a0a0a0', rgba: 0xa0a0a0a0 });
+        assert.deepEqual(css.toColor('#b0b0b0b0'), { css: '#b0b0b0b0', rgba: 0xb0b0b0b0 });
+        assert.deepEqual(css.toColor('#c0c0c0c0'), { css: '#c0c0c0c0', rgba: 0xc0c0c0c0 });
+        assert.deepEqual(css.toColor('#d0d0d0d0'), { css: '#d0d0d0d0', rgba: 0xd0d0d0d0 });
+        assert.deepEqual(css.toColor('#e0e0e0e0'), { css: '#e0e0e0e0', rgba: 0xe0e0e0e0 });
+        assert.deepEqual(css.toColor('#f0f0f0f0'), { css: '#f0f0f0f0', rgba: 0xf0f0f0f0 });
+        assert.deepEqual(css.toColor('#ffffffff'), { css: '#ffffffff', rgba: 0xffffffff });
+      });
     });
   });
 

src/browser/Color.ts

@@ -48,6 +48,10 @@ export namespace color {
     return { css, rgba };
   }
 
+  export function isOpaque(color: IColor): boolean {
+    return (color.rgba & 0xFF) === 0xFF;
+  }
+
   export function ensureContrastRatio(bg: IColor, fg: IColor, ratio: number): IColor | undefined {
     const result = rgba.ensureContrastRatio(bg.rgba, fg.rgba, ratio);
     if (!result) {
@@ -68,6 +72,15 @@ export namespace color {
       rgba: rgbaColor
     };
   }
+
+  export function opacity(color: IColor, opacity: number): IColor {
+    const a = Math.round(opacity * 0xFF);
+    const [r, g, b] = rgba.toChannels(color.rgba);
+    return {
+      css: channels.toCss(r, g, b, a),
+      rgba: channels.toRgba(r, g, b, a)
+    };
+  }
 }
 
 /**
@@ -75,10 +88,19 @@ export namespace color {
  */
 export namespace css {
   export function toColor(css: string): IColor {
-    return {
-      css,
-      rgba: (parseInt(css.slice(1), 16) << 8 | 0xFF) >>> 0
-    };
+    switch (css.length) {
+      case 7: // #rrggbb
+        return {
+          css,
+          rgba: (parseInt(css.slice(1), 16) << 8 | 0xFF) >>> 0
+        };
+      case 9: // #rrggbbaa
+        return {
+          css,
+          rgba: parseInt(css.slice(1), 16) >>> 0
+        };
+    }
+    throw new Error('css.toColor: Unsupported css format');
   }
 }
 

src/browser/ColorManager.ts

@@ -92,7 +92,7 @@ export class ColorManager implements IColorManager {
       background: DEFAULT_BACKGROUND,
       cursor: DEFAULT_CURSOR,
       cursorAccent: DEFAULT_CURSOR_ACCENT,
-      selection: DEFAULT_SELECTION,
+      selectionTransparent: DEFAULT_SELECTION,
       selectionOpaque: color.blend(DEFAULT_BACKGROUND, DEFAULT_SELECTION),
       ansi: DEFAULT_ANSI_COLORS.slice(),
       contrastCache: this._contrastCache
@@ -115,8 +115,16 @@ export class ColorManager implements IColorManager {
     this.colors.background = this._parseColor(theme.background, DEFAULT_BACKGROUND);
     this.colors.cursor = this._parseColor(theme.cursor, DEFAULT_CURSOR, true);
     this.colors.cursorAccent = this._parseColor(theme.cursorAccent, DEFAULT_CURSOR_ACCENT, true);
-    this.colors.selection = this._parseColor(theme.selection, DEFAULT_SELECTION, true);
-    this.colors.selectionOpaque = color.blend(this.colors.background, this.colors.selection);
+    this.colors.selectionTransparent = this._parseColor(theme.selection, DEFAULT_SELECTION, true);
+    this.colors.selectionOpaque = color.blend(this.colors.background, this.colors.selectionTransparent);
+    /**
+     * If selection color is opaque, blend it with background with 0.3 opacity
+     * Issue #2737
+     */
+    if (color.isOpaque(this.colors.selectionTransparent)) {
+      const opacity = 0.3;
+      this.colors.selectionTransparent = color.opacity(this.colors.selectionTransparent, opacity);
+    }
     this.colors.ansi[0] = this._parseColor(theme.black, DEFAULT_ANSI_COLORS[0]);
     this.colors.ansi[1] = this._parseColor(theme.red, DEFAULT_ANSI_COLORS[1]);
     this.colors.ansi[2] = this._parseColor(theme.green, DEFAULT_ANSI_COLORS[2]);

src/browser/Dom.test.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2020 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import jsdom = require('jsdom');
+import { removeElementFromParent } from 'browser/Dom';
+import { strictEqual, doesNotThrow } from 'assert';
+
+describe('Dom', () => {
+  const dom = new jsdom.JSDOM();
+  const document = dom.window.document;
+
+  describe('removeElementFromParent', () => {
+    it('should remove single child', () => {
+      const e = document.createElement('div');
+      document.body.appendChild(e);
+      strictEqual(e.parentElement, document.body);
+      removeElementFromParent(e);
+      strictEqual(e.parentElement, null);
+    });
+    it('should remove multiple elements', () => {
+      const e1 = document.createElement('div');
+      const e2 = document.createElement('div');
+      document.body.appendChild(e1);
+      document.body.appendChild(e2);
+      strictEqual(e1.parentElement, document.body);
+      strictEqual(e2.parentElement, document.body);
+      removeElementFromParent(e1, e2);
+      strictEqual(e1.parentElement, null);
+      strictEqual(e2.parentElement, null);
+    });
+    it('should not throw on undefined', () => {
+      const e = document.createElement('div');
+      document.body.appendChild(e);
+      strictEqual(e.parentElement, document.body);
+      doesNotThrow(() => removeElementFromParent(undefined, e));
+      strictEqual(e.parentElement, null);
+    });
+  });
+});

src/browser/Dom.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2020 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+export function removeElementFromParent(...elements: (HTMLElement | undefined)[]): void {
+  for (const e of elements) {
+    e?.parentElement?.removeChild(e);
+  }
+}

src/browser/Lifecycle.ts

@@ -14,9 +14,9 @@ export function addDisposableDomListener(
   node: Element | Window | Document,
   type: string,
   handler: (e: any) => void,
-  useCapture?: boolean
+  options?: boolean | AddEventListenerOptions
 ): IDisposable {
-  node.addEventListener(type, handler, useCapture);
+  node.addEventListener(type, handler, options);
   let disposed = false;
   return {
     dispose: () => {
@@ -24,7 +24,7 @@ export function addDisposableDomListener(
         return;
       }
       disposed = true;
-      node.removeEventListener(type, handler, useCapture);
+      node.removeEventListener(type, handler, options);
     }
   };
 }

src/browser/Linkifier.test.ts

@@ -9,13 +9,13 @@ import { IBufferLine } from 'common/Types';
 import { Linkifier } from 'browser/Linkifier';
 import { BufferLine } from 'common/buffer/BufferLine';
 import { CellData } from 'common/buffer/CellData';
-import { MockLogService, MockBufferService, MockOptionsService } from 'common/TestUtils.test';
+import { MockLogService, MockBufferService } from 'common/TestUtils.test';
 import { IBufferService } from 'common/services/Services';
 import { UnicodeService } from 'common/services/UnicodeService';
 
 class TestLinkifier extends Linkifier {
   constructor(bufferService: IBufferService) {
-    super(bufferService, new MockLogService(), new MockOptionsService(), new UnicodeService());
+    super(bufferService, new MockLogService(), new UnicodeService());
     Linkifier._timeBeforeLatency = 0;
   }
 
@@ -24,14 +24,14 @@ class TestLinkifier extends Linkifier {
 }
 
 class TestMouseZoneManager implements IMouseZoneManager {
-  dispose(): void {
+  public dispose(): void {
   }
   public clears: number = 0;
   public zones: IMouseZone[] = [];
-  add(zone: IMouseZone): void {
+  public add(zone: IMouseZone): void {
     this.zones.push(zone);
   }
-  clearAll(): void {
+  public clearAll(): void {
     this.clears++;
   }
 }

src/browser/Linkifier.ts

@@ -35,18 +35,17 @@ export class Linkifier implements ILinkifier {
   private _nextLinkMatcherId = 0;
   private _rowsToLinkify: { start: number | undefined, end: number | undefined };
 
-  private _onLinkHover = new EventEmitter<ILinkifierEvent>();
-  public get onLinkHover(): IEvent<ILinkifierEvent> { return this._onLinkHover.event; }
-  private _onLinkLeave = new EventEmitter<ILinkifierEvent>();
-  public get onLinkLeave(): IEvent<ILinkifierEvent> { return this._onLinkLeave.event; }
+  private _onShowLinkUnderline = new EventEmitter<ILinkifierEvent>();
+  public get onShowLinkUnderline(): IEvent<ILinkifierEvent> { return this._onShowLinkUnderline.event; }
+  private _onHideLinkUnderline = new EventEmitter<ILinkifierEvent>();
+  public get onHideLinkUnderline(): IEvent<ILinkifierEvent> { return this._onHideLinkUnderline.event; }
   private _onLinkTooltip = new EventEmitter<ILinkifierEvent>();
   public get onLinkTooltip(): IEvent<ILinkifierEvent> { return this._onLinkTooltip.event; }
 
   constructor(
-    protected readonly _bufferService: IBufferService,
-    private readonly _logService: ILogService,
-    private readonly _optionsService: IOptionsService,
-    private readonly _unicodeService: IUnicodeService
+    @IBufferService protected readonly _bufferService: IBufferService,
+    @ILogService private readonly _logService: ILogService,
+    @IUnicodeService private readonly _unicodeService: IUnicodeService
   ) {
     this._rowsToLinkify = {
       start: undefined,
@@ -307,7 +306,7 @@ export class Linkifier implements ILinkifier {
         }
       },
       () => {
-        this._onLinkHover.fire(this._createLinkHoverEvent(x1, y1, x2, y2, fg));
+        this._onShowLinkUnderline.fire(this._createLinkHoverEvent(x1, y1, x2, y2, fg));
         this._element!.classList.add('xterm-cursor-pointer');
       },
       e => {
@@ -319,7 +318,7 @@ export class Linkifier implements ILinkifier {
         }
       },
       () => {
-        this._onLinkLeave.fire(this._createLinkHoverEvent(x1, y1, x2, y2, fg));
+        this._onHideLinkUnderline.fire(this._createLinkHoverEvent(x1, y1, x2, y2, fg));
         this._element!.classList.remove('xterm-cursor-pointer');
         if (matcher.hoverLeaveCallback) {
           matcher.hoverLeaveCallback();

src/browser/Linkifier2.test.ts

@@ -14,6 +14,10 @@ class TestLinkifier2 extends Linkifier2 {
     super(bufferService);
   }
 
+  public set currentLink(link: any) {
+    this._currentLink = link;
+  }
+
   public linkHover(element: HTMLElement, link: ILink, event: MouseEvent): void {
     this._linkHover(element, link, event);
   }
@@ -27,11 +31,6 @@ describe('Linkifier2', () => {
   let bufferService: IBufferService;
   let linkifier: TestLinkifier2;
 
-  beforeEach(() => {
-    bufferService = new MockBufferService(100, 10);
-    linkifier = new TestLinkifier2(bufferService);
-  });
-
   const link: ILink = {
     text: 'foo',
     range: {
@@ -47,8 +46,23 @@ describe('Linkifier2', () => {
     activate: () => { }
   };
 
-  it('onLinkHover event range is correct', done => {
-    linkifier.onLinkHover(e => {
+  beforeEach(() => {
+    bufferService = new MockBufferService(100, 10);
+    linkifier = new TestLinkifier2(bufferService);
+    linkifier.currentLink = {
+      link,
+      state: {
+        decorations: {
+          underline: true,
+          pointerCursor: true
+        },
+        isHovered: true
+      }
+    };
+  });
+
+  it('onShowLinkUnderline event range is correct', done => {
+    linkifier.onShowLinkUnderline(e => {
       assert.equal(link.range.start.x - 1, e.x1);
       assert.equal(link.range.start.y - 1, e.y1);
       assert.equal(link.range.end.x, e.x2);
@@ -60,8 +74,8 @@ describe('Linkifier2', () => {
     linkifier.linkHover({ classList: { add: () => { } } } as any, link, {} as any);
   });
 
-  it('onLinkLeave event range is correct', done => {
-    linkifier.onLinkLeave(e => {
+  it('onHideLinkUnderline event range is correct', done => {
+    linkifier.onHideLinkUnderline(e => {
       assert.equal(link.range.start.x - 1, e.x1);
       assert.equal(link.range.start.y - 1, e.y1);
       assert.equal(link.range.end.x, e.x2);

src/browser/Linkifier2.ts

@@ -3,31 +3,47 @@
  * @license MIT
  */
 
-import { ILinkifier2, ILinkProvider, IBufferCellPosition, ILink, ILinkifierEvent } from './Types';
+import { ILinkifier2, ILinkProvider, IBufferCellPosition, ILink, ILinkifierEvent, ILinkDecorations } from 'browser/Types';
 import { IDisposable } from 'common/Types';
 import { IMouseService, IRenderService } from './services/Services';
 import { IBufferService } from 'common/services/Services';
 import { EventEmitter, IEvent } from 'common/EventEmitter';
+import { Disposable, getDisposeArrayDisposable, disposeArray } from 'common/Lifecycle';
+import { addDisposableDomListener } from 'browser/Lifecycle';
 
-export class Linkifier2 implements ILinkifier2 {
+interface ILinkState {
+  decorations: ILinkDecorations;
+  isHovered: boolean;
+}
+
+interface ILinkWithState {
+  link: ILink;
+  state?: ILinkState;
+}
+
+export class Linkifier2 extends Disposable implements ILinkifier2 {
   private _element: HTMLElement | undefined;
   private _mouseService: IMouseService | undefined;
   private _renderService: IRenderService | undefined;
   private _linkProviders: ILinkProvider[] = [];
-  private _currentLink: ILink | undefined;
+  protected _currentLink: ILinkWithState | undefined;
   private _lastMouseEvent: MouseEvent | undefined;
   private _linkCacheDisposables: IDisposable[] = [];
   private _lastBufferCell: IBufferCellPosition | undefined;
+  private _isMouseOut: boolean = true;
+  private _activeProviderReplies: Map<Number, ILinkWithState[] | undefined> | undefined;
+  private _activeLine: number = -1;
 
-  private _onLinkHover = new EventEmitter<ILinkifierEvent>();
-  public get onLinkHover(): IEvent<ILinkifierEvent> { return this._onLinkHover.event; }
-  private _onLinkLeave = new EventEmitter<ILinkifierEvent>();
-  public get onLinkLeave(): IEvent<ILinkifierEvent> { return this._onLinkLeave.event; }
+  private _onShowLinkUnderline = this.register(new EventEmitter<ILinkifierEvent>());
+  public get onShowLinkUnderline(): IEvent<ILinkifierEvent> { return this._onShowLinkUnderline.event; }
+  private _onHideLinkUnderline = this.register(new EventEmitter<ILinkifierEvent>());
+  public get onHideLinkUnderline(): IEvent<ILinkifierEvent> { return this._onHideLinkUnderline.event; }
 
   constructor(
-    private readonly _bufferService: IBufferService
+    @IBufferService private readonly _bufferService: IBufferService
   ) {
-
+    super();
+    this.register(getDisposeArrayDisposable(this._linkCacheDisposables));
   }
 
   public registerLinkProvider(linkProvider: ILinkProvider): IDisposable {
@@ -49,8 +65,12 @@ export class Linkifier2 implements ILinkifier2 {
     this._mouseService = mouseService;
     this._renderService = renderService;
 
-    this._element.addEventListener('mousemove', this._onMouseMove.bind(this));
-    this._element.addEventListener('click', this._onMouseDown.bind(this));
+    this.register(addDisposableDomListener(this._element, 'mouseleave', () => {
+      this._isMouseOut = true;
+      this._clearCurrentLink();
+    }));
+    this.register(addDisposableDomListener(this._element, 'mousemove', this._onMouseMove.bind(this)));
+    this.register(addDisposableDomListener(this._element, 'click', this._onClick.bind(this)));
   }
 
   private _onMouseMove(event: MouseEvent): void {
@@ -61,10 +81,24 @@ export class Linkifier2 implements ILinkifier2 {
     }
 
     const position = this._positionFromMouseEvent(event, this._element, this._mouseService);
-
     if (!position) {
       return;
     }
+    this._isMouseOut = false;
+
+    // Ignore the event if it's an embedder created hover widget
+    const composedPath = event.composedPath() as HTMLElement[];
+    for (let i = 0; i < composedPath.length; i++) {
+      const target = composedPath[i];
+      // Hit Terminal.element, break and continue
+      if (target.classList.contains('xterm')) {
+        break;
+      }
+      // It's a hover, don't respect hover event
+      if (target.classList.contains('xterm-hover')) {
+        return;
+      }
+    }
 
     if (!this._lastBufferCell || (position.x !== this._lastBufferCell.x || position.y !== this._lastBufferCell.y)) {
       this._onHover(position);
@@ -73,59 +107,124 @@ export class Linkifier2 implements ILinkifier2 {
   }
 
   private _onHover(position: IBufferCellPosition): void {
-    if (this._currentLink) {
-      // Check the if the link is in the mouse position
-      const isInPosition = this._linkAtPosition(this._currentLink, position);
+    // TODO: This currently does not cache link provider results across wrapped lines, activeLine should be something like `activeRange: {startY, endY}`
+    // Check if we need to clear the link
+    if (this._activeLine !== position.y) {
+      this._clearCurrentLink();
+      this._askForLink(position, false);
+      return;
+    }
 
-      // Check if we need to clear the link
-      if (!isInPosition) {
-        this._clearCurrentLink();
-        this._askForLink(position);
-      }
-    } else {
-      this._askForLink(position);
+    // Check the if the link is in the mouse position
+    const isCurrentLinkInPosition = this._currentLink && this._linkAtPosition(this._currentLink.link, position);
+    if (!isCurrentLinkInPosition) {
+      this._clearCurrentLink();
+      this._askForLink(position, true);
     }
   }
 
-  private _askForLink(position: IBufferCellPosition): void {
-    const providerReplies: Map<Number, ILink | undefined> = new Map();
+  private _askForLink(position: IBufferCellPosition, useLineCache: boolean): void {
+    if (!this._activeProviderReplies || !useLineCache) {
+      this._activeProviderReplies = new Map();
+      this._activeLine = position.y;
+    }
     let linkProvided = false;
 
     // There is no link cached, so ask for one
     this._linkProviders.forEach((linkProvider, i) => {
-      linkProvider.provideLink(position, (link: ILink | undefined) => {
-        providerReplies.set(i, link);
+      if (useLineCache) {
+        const existingReply = this._activeProviderReplies?.get(i);
+        // If there isn't a reply, the provider hasn't responded yet.
 
-        // Check if every provider before this one has come back undefined
-        let hasLinkBefore = false;
-        for (let j = 0; j < i; j++) {
-          if (!providerReplies.has(j) || providerReplies.get(j)) {
-            hasLinkBefore = true;
+        // TODO: If there isn't a reply yet it means that the provider is still resolving. Ensuring
+        // provideLinks isn't triggered again saves ILink.hover firing twice though. This probably
+        // needs promises to get fixed
+        if (existingReply) {
+          linkProvided = this._checkLinkProviderResult(i, position, linkProvided);
+        }
+      } else {
+        linkProvider.provideLinks(position.y, (links: ILink[] | undefined) => {
+          if (this._isMouseOut) {
+            return;
           }
-        }
+          const linksWithState: ILinkWithState[] | undefined = links?.map(link  => ({ link }));
+          this._activeProviderReplies?.set(i, linksWithState);
+          linkProvided = this._checkLinkProviderResult(i, position, linkProvided);
 
-        // If all providers with higher priority came back undefined, then this link should be used
-        if (!hasLinkBefore && link) {
-          linkProvided = true;
-          this._handleNewLink(link);
-        }
-
-        // Check if all the providers have responded
-        if (providerReplies.size === this._linkProviders.length && !linkProvided) {
-          // Respect the order of the link providers
-          for (let j = 0; j < providerReplies.size; j++) {
-            const currentLink = providerReplies.get(j);
-            if (currentLink) {
-              this._handleNewLink(currentLink);
-              break;
-            }
+          // If all providers have responded, remove lower priority links that intersect ranges of
+          // higher priority links
+          if (this._activeProviderReplies?.size === this._linkProviders.length) {
+            this._removeIntersectingLinks(position.y, this._activeProviderReplies);
           }
-        }
-      });
+        });
+      }
     });
   }
 
-  private _onMouseDown(event: MouseEvent): void {
+  private _removeIntersectingLinks(y: number, replies: Map<Number, ILinkWithState[] | undefined>): void {
+    const occupiedCells = new Set<number>();
+    for (let i = 0; i < replies.size; i++) {
+      const providerReply = replies.get(i);
+      if (!providerReply) {
+        continue;
+      }
+      for (let i = 0; i < providerReply.length; i++) {
+        const linkWithState = providerReply[i];
+        const startX = linkWithState.link.range.start.y < y ? 0 : linkWithState.link.range.start.x;
+        const endX = linkWithState.link.range.end.y > y ? this._bufferService.cols : linkWithState.link.range.end.x;
+        for (let x = startX; x <= endX; x++) {
+          if (occupiedCells.has(x)) {
+            providerReply.splice(i--, 1);
+            break;
+          }
+          occupiedCells.add(x);
+        }
+      }
+    }
+  }
+
+  private _checkLinkProviderResult(index: number, position: IBufferCellPosition, linkProvided: boolean): boolean {
+    if (!this._activeProviderReplies) {
+      return linkProvided;
+    }
+
+    const links = this._activeProviderReplies.get(index);
+
+    // Check if every provider before this one has come back undefined
+    let hasLinkBefore = false;
+    for (let j = 0; j < index; j++) {
+      if (!this._activeProviderReplies.has(j) || this._activeProviderReplies.get(j)) {
+        hasLinkBefore = true;
+      }
+    }
+
+    // If all providers with higher priority came back undefined, then this provider's link for
+    // the position should be used
+    if (!hasLinkBefore && links) {
+      const linkAtPosition = links.find(link => this._linkAtPosition(link.link, position));
+      if (linkAtPosition) {
+        linkProvided = true;
+        this._handleNewLink(linkAtPosition);
+      }
+    }
+
+    // Check if all the providers have responded
+    if (this._activeProviderReplies.size === this._linkProviders.length && !linkProvided) {
+      // Respect the order of the link providers
+      for (let j = 0; j < this._activeProviderReplies.size; j++) {
+        const currentLink = this._activeProviderReplies.get(j)?.find(link => this._linkAtPosition(link.link, position));
+        if (currentLink) {
+          linkProvided = true;
+          this._handleNewLink(currentLink);
+          break;
+        }
+      }
+    }
+
+    return linkProvided;
+  }
+
+  private _onClick(event: MouseEvent): void {
     if (!this._element || !this._mouseService || !this._currentLink) {
       return;
     }
@@ -136,8 +235,8 @@ export class Linkifier2 implements ILinkifier2 {
       return;
     }
 
-    if (this._linkAtPosition(this._currentLink, position)) {
-      this._currentLink.activate(event, this._currentLink.text);
+    if (this._linkAtPosition(this._currentLink.link, position)) {
+      this._currentLink.link.activate(event, this._currentLink.link.text);
     }
   }
 
@@ -147,15 +246,14 @@ export class Linkifier2 implements ILinkifier2 {
     }
 
     // If we have a start and end row, check that the link is within it
-    if (!startRow || !endRow || (this._currentLink.range.start.y >= startRow && this._currentLink.range.end.y <= endRow)) {
-      this._linkLeave(this._element, this._currentLink, this._lastMouseEvent);
+    if (!startRow || !endRow || (this._currentLink.link.range.start.y >= startRow && this._currentLink.link.range.end.y <= endRow)) {
+      this._linkLeave(this._element, this._currentLink.link, this._lastMouseEvent);
       this._currentLink = undefined;
-      this._linkCacheDisposables.forEach(l => l.dispose());
-      this._linkCacheDisposables = [];
+      disposeArray(this._linkCacheDisposables);
     }
   }
 
-  private _handleNewLink(link: ILink): void {
+  private _handleNewLink(linkWithState: ILinkWithState): void {
     if (!this._element || !this._lastMouseEvent || !this._mouseService) {
       return;
     }
@@ -167,37 +265,90 @@ export class Linkifier2 implements ILinkifier2 {
     }
 
     // Trigger hover if the we have a link at the position
-    if (this._linkAtPosition(link, position)) {
-      this._currentLink = link;
-      this._linkHover(this._element, link, this._lastMouseEvent);
+    if (this._linkAtPosition(linkWithState.link, position)) {
+      this._currentLink = linkWithState;
+      this._currentLink.state = {
+        decorations: {
+          underline: linkWithState.link.decorations === undefined ? true : linkWithState.link.decorations.underline,
+          pointerCursor: linkWithState.link.decorations === undefined ? true : linkWithState.link.decorations.pointerCursor
+        },
+        isHovered: true
+      };
+      this._linkHover(this._element, linkWithState.link, this._lastMouseEvent);
+
+      // Add listener for tracking decorations changes
+      linkWithState.link.decorations = {} as ILinkDecorations;
+      Object.defineProperties(linkWithState.link.decorations, {
+        pointerCursor: {
+          get: () => this._currentLink?.state?.decorations.pointerCursor,
+          set: v => {
+            if (this._currentLink?.state && this._currentLink.state.decorations.pointerCursor !== v) {
+              this._currentLink.state.decorations.pointerCursor = v;
+              if (this._currentLink.state.isHovered) {
+                this._element?.classList.toggle('xterm-cursor-pointer', v);
+              }
+            }
+          }
+        },
+        underline: {
+          get: () => this._currentLink?.state?.decorations.underline,
+          set: v => {
+            if (this._currentLink?.state && this._currentLink?.state?.decorations.underline !== v) {
+              this._currentLink.state.decorations.underline = v;
+              if (this._currentLink.state.isHovered) {
+                this._fireUnderlineEvent(linkWithState.link, v);
+              }
+            }
+          }
+        }
+      });
 
       // Add listener for rerendering
       if (this._renderService) {
-        this._linkCacheDisposables.push(this._renderService.onRender(e => {
-          this._clearCurrentLink(e.start + 1 + this._bufferService.buffer.ydisp, e.end + 1 + this._bufferService.buffer.ydisp);
+        this._linkCacheDisposables.push(this._renderService.onRenderedBufferChange(e => {
+          // When start is 0 a scroll most likely occurred, make sure links above the fold also get
+          // cleared.
+          const start = e.start === 0 ? 0 : e.start + 1 + this._bufferService.buffer.ydisp;
+          this._clearCurrentLink(start, e.end + 1 + this._bufferService.buffer.ydisp);
         }));
       }
     }
   }
 
   protected _linkHover(element: HTMLElement, link: ILink, event: MouseEvent): void {
-    const range = link.range;
-    const scrollOffset = this._bufferService.buffer.ydisp;
-
-    this._onLinkHover.fire(this._createLinkHoverEvent(range.start.x - 1, range.start.y - scrollOffset - 1, range.end.x, range.end.y - scrollOffset - 1, undefined));
-    element.classList.add('xterm-cursor-pointer');
+    if (this._currentLink?.state) {
+      this._currentLink.state.isHovered = true;
+      if (this._currentLink.state.decorations.underline) {
+        this._fireUnderlineEvent(link, true);
+      }
+      if (this._currentLink.state.decorations.pointerCursor) {
+        element.classList.add('xterm-cursor-pointer');
+      }
+    }
 
     if (link.hover) {
       link.hover(event, link.text);
     }
   }
 
-  protected _linkLeave(element: HTMLElement, link: ILink, event: MouseEvent): void {
+  private _fireUnderlineEvent(link: ILink, showEvent: boolean): void {
     const range = link.range;
     const scrollOffset = this._bufferService.buffer.ydisp;
+    const event = this._createLinkUnderlineEvent(range.start.x - 1, range.start.y - scrollOffset - 1, range.end.x, range.end.y - scrollOffset - 1, undefined);
+    const emitter = showEvent ? this._onShowLinkUnderline : this._onHideLinkUnderline;
+    emitter.fire(event);
+  }
 
-    this._onLinkLeave.fire(this._createLinkHoverEvent(range.start.x - 1, range.start.y - scrollOffset - 1, range.end.x, range.end.y - scrollOffset - 1, undefined));
-    element.classList.remove('xterm-cursor-pointer');
+  protected _linkLeave(element: HTMLElement, link: ILink, event: MouseEvent): void {
+    if (this._currentLink?.state) {
+      this._currentLink.state.isHovered = false;
+      if (this._currentLink.state.decorations.underline) {
+        this._fireUnderlineEvent(link, false);
+      }
+      if (this._currentLink.state.decorations.pointerCursor) {
+        element.classList.remove('xterm-cursor-pointer');
+      }
+    }
 
     if (link.leave) {
       link.leave(event, link.text);
@@ -237,7 +388,7 @@ export class Linkifier2 implements ILinkifier2 {
     return { x: coords[0], y: coords[1] + this._bufferService.buffer.ydisp };
   }
 
-  private _createLinkHoverEvent(x1: number, y1: number, x2: number, y2: number, fg: number | undefined): ILinkifierEvent {
+  private _createLinkUnderlineEvent(x1: number, y1: number, x2: number, y2: number, fg: number | undefined): ILinkifierEvent {
     return { x1, y1, x2, y2, cols: this._bufferService.cols, fg };
   }
 }

src/browser/MouseZoneManager.ts

@@ -7,9 +7,7 @@ import { Disposable } from 'common/Lifecycle';
 import { addDisposableDomListener } from 'browser/Lifecycle';
 import { IMouseService, ISelectionService } from 'browser/services/Services';
 import { IMouseZoneManager, IMouseZone } from 'browser/Types';
-import { IBufferService } from 'common/services/Services';
-
-const HOVER_DURATION = 500;
+import { IBufferService, IOptionsService } from 'common/services/Services';
 
 /**
  * The MouseZoneManager allows components to register zones within the terminal
@@ -37,7 +35,8 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {
     private readonly _screenElement: HTMLElement,
     @IBufferService private readonly _bufferService: IBufferService,
     @IMouseService private readonly _mouseService: IMouseService,
-    @ISelectionService private readonly _selectionService: ISelectionService
+    @ISelectionService private readonly _selectionService: ISelectionService,
+    @IOptionsService private readonly _optionsService: IOptionsService
   ) {
     super();
 
@@ -151,7 +150,7 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {
     }
 
     // Restart the tooltip timeout
-    this._tooltipTimeout = <number><any>setTimeout(() => this._onTooltip(e), HOVER_DURATION);
+    this._tooltipTimeout = window.setTimeout(() => this._onTooltip(e), this._optionsService.options.linkTooltipHoverDuration);
   }
 
   private _onTooltip(e: MouseEvent): void {

src/browser/RenderDebouncer.ts

@@ -26,7 +26,7 @@ export class RenderDebouncer implements IDisposable {
     }
   }
 
-  public refresh(rowStart: number, rowEnd: number, rowCount: number): void {
+  public refresh(rowStart: number | undefined, rowEnd: number | undefined, rowCount: number): void {
     this._rowCount = rowCount;
     // Get the min/max row start/end for the arg values
     rowStart = rowStart !== undefined ? rowStart : 0;
@@ -49,15 +49,15 @@ export class RenderDebouncer implements IDisposable {
     }
 
     // Clamp values
-    this._rowStart = Math.max(this._rowStart, 0);
-    this._rowEnd = Math.min(this._rowEnd, this._rowCount - 1);
+    const start = Math.max(this._rowStart, 0);
+    const end = Math.min(this._rowEnd, this._rowCount - 1);
 
-    // Run render callback
-    this._renderCallback(this._rowStart, this._rowEnd);
-
-    // Reset debouncer
+    // Reset debouncer (this happens before render callback as the render could trigger it again)
     this._rowStart = undefined;
     this._rowEnd = undefined;
     this._animationFrame = undefined;
+
+    // Run render callback
+    this._renderCallback(start, end);
   }
 }

src/browser/ScreenDprMonitor.ts

@@ -44,12 +44,12 @@ export class ScreenDprMonitor extends Disposable {
   }
 
   private _updateDpr(): void {
-    if (!this._resolutionMediaMatchList || !this._outerListener) {
+    if (!this._outerListener) {
       return;
     }
 
     // Clear listeners for old DPR
-    this._resolutionMediaMatchList.removeListener(this._outerListener);
+    this._resolutionMediaMatchList?.removeListener(this._outerListener);
 
     // Add listeners for new DPR
     this._currentDevicePixelRatio = window.devicePixelRatio;

src/browser/Terminal.test.ts

@@ -4,12 +4,12 @@
  */
 
 import { assert, expect } from 'chai';
-import { MockViewport, MockCompositionHelper, MockRenderer, TestTerminal } from './TestUtils.test';
+import { MockViewport, MockCompositionHelper, MockRenderer, TestTerminal } from 'browser/TestUtils.test';
 import { DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine';
 import { CellData } from 'common/buffer/CellData';
 import { IBufferService, IUnicodeService } from 'common/services/Services';
 import { Linkifier } from 'browser/Linkifier';
-import { MockLogService, MockOptionsService, MockUnicodeService } from 'common/TestUtils.test';
+import { MockLogService, MockUnicodeService } from 'common/TestUtils.test';
 import { IRegisteredLinkMatcher, IMouseZoneManager, IMouseZone } from 'browser/Types';
 
 const INIT_COLS = 80;
@@ -121,7 +121,7 @@ describe('Terminal', () => {
         assert.equal(e, 'title');
         done();
       });
-      term.handleTitle('title');
+      term.write('\x1b]2;title\x07');
     });
   });
 
@@ -140,7 +140,6 @@ describe('Terminal', () => {
     };
 
     beforeEach(() => {
-      term.showCursor = () => { };
       term.clearSelection = () => { };
     });
 
@@ -396,62 +395,62 @@ describe('Terminal', () => {
     describe('scroll() function', () => {
       describe('when scrollback > 0', () => {
         it('should create a new line and scroll', () => {
-          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
-          term.buffer.lines.get(INIT_ROWS - 1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(0)!.setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(INIT_ROWS - 1)!.setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS + 1);
-          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 1).loadCell(0, new CellData()).getChars(), 'b');
-          assert.equal(term.buffer.lines.get(INIT_ROWS).loadCell(0, new CellData()).getChars(), '');
+          assert.equal(term.buffer.lines.get(0)!.loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 1)!.loadCell(0, new CellData()).getChars(), 'b');
+          assert.equal(term.buffer.lines.get(INIT_ROWS)!.loadCell(0, new CellData()).getChars(), '');
         });
 
         it('should properly scroll inside a scroll region (scrollTop set)', () => {
-          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
-          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
-          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(0)!.setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1)!.setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2)!.setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
-          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c');
+          assert.equal(term.buffer.lines.get(0)!.loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(1)!.loadCell(0, new CellData()).getChars(), 'c');
         });
 
         it('should properly scroll inside a scroll region (scrollBottom set)', () => {
-          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
-          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
-          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
-          term.buffer.lines.get(3).setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
-          term.buffer.lines.get(4).setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
+          term.buffer.lines.get(0)!.setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1)!.setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2)!.setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(3)!.setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
+          term.buffer.lines.get(4)!.setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
           term.buffer.y = 3;
           term.buffer.scrollBottom = 3;
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS + 1);
-          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a', '\'a\' should be pushed to the scrollback');
-          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'b');
-          assert.equal(term.buffer.lines.get(2).loadCell(0, new CellData()).getChars(), 'c');
-          assert.equal(term.buffer.lines.get(3).loadCell(0, new CellData()).getChars(), 'd');
-          assert.equal(term.buffer.lines.get(4).loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(5).loadCell(0, new CellData()).getChars(), 'e');
+          assert.equal(term.buffer.lines.get(0)!.loadCell(0, new CellData()).getChars(), 'a', '\'a\' should be pushed to the scrollback');
+          assert.equal(term.buffer.lines.get(1)!.loadCell(0, new CellData()).getChars(), 'b');
+          assert.equal(term.buffer.lines.get(2)!.loadCell(0, new CellData()).getChars(), 'c');
+          assert.equal(term.buffer.lines.get(3)!.loadCell(0, new CellData()).getChars(), 'd');
+          assert.equal(term.buffer.lines.get(4)!.loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(5)!.loadCell(0, new CellData()).getChars(), 'e');
         });
 
         it('should properly scroll inside a scroll region (scrollTop and scrollBottom set)', () => {
-          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
-          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
-          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
-          term.buffer.lines.get(3).setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
-          term.buffer.lines.get(4).setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
+          term.buffer.lines.get(0)!.setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1)!.setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2)!.setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(3)!.setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
+          term.buffer.lines.get(4)!.setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.buffer.scrollBottom = 3;
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
-          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c', '\'b\' should be removed from the buffer');
-          assert.equal(term.buffer.lines.get(2).loadCell(0, new CellData()).getChars(), 'd');
-          assert.equal(term.buffer.lines.get(3).loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4).loadCell(0, new CellData()).getChars(), 'e');
+          assert.equal(term.buffer.lines.get(0)!.loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(1)!.loadCell(0, new CellData()).getChars(), 'c', '\'b\' should be removed from the buffer');
+          assert.equal(term.buffer.lines.get(2)!.loadCell(0, new CellData()).getChars(), 'd');
+          assert.equal(term.buffer.lines.get(3)!.loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4)!.loadCell(0, new CellData()).getChars(), 'e');
         });
       });
 
@@ -462,65 +461,65 @@ describe('Terminal', () => {
         });
 
         it('should create a new line and shift everything up', () => {
-          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
-          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
-          term.buffer.lines.get(INIT_ROWS - 1).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(0)!.setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1)!.setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(INIT_ROWS - 1)!.setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           assert.equal(term.buffer.lines.length, INIT_ROWS);
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS);
           // 'a' gets pushed out of buffer
-          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'b');
-          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), '');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 2).loadCell(0, new CellData()).getChars(), 'c');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 1).loadCell(0, new CellData()).getChars(), '');
+          assert.equal(term.buffer.lines.get(0)!.loadCell(0, new CellData()).getChars(), 'b');
+          assert.equal(term.buffer.lines.get(1)!.loadCell(0, new CellData()).getChars(), '');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 2)!.loadCell(0, new CellData()).getChars(), 'c');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 1)!.loadCell(0, new CellData()).getChars(), '');
         });
 
         it('should properly scroll inside a scroll region (scrollTop set)', () => {
-          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
-          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
-          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(0)!.setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1)!.setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2)!.setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
-          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c');
+          assert.equal(term.buffer.lines.get(0)!.loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(1)!.loadCell(0, new CellData()).getChars(), 'c');
         });
 
         it('should properly scroll inside a scroll region (scrollBottom set)', () => {
-          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
-          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
-          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
-          term.buffer.lines.get(3).setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
-          term.buffer.lines.get(4).setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
+          term.buffer.lines.get(0)!.setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1)!.setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2)!.setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(3)!.setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
+          term.buffer.lines.get(4)!.setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
           term.buffer.y = 3;
           term.buffer.scrollBottom = 3;
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'b');
-          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c');
-          assert.equal(term.buffer.lines.get(2).loadCell(0, new CellData()).getChars(), 'd');
-          assert.equal(term.buffer.lines.get(3).loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4).loadCell(0, new CellData()).getChars(), 'e');
+          assert.equal(term.buffer.lines.get(0)!.loadCell(0, new CellData()).getChars(), 'b');
+          assert.equal(term.buffer.lines.get(1)!.loadCell(0, new CellData()).getChars(), 'c');
+          assert.equal(term.buffer.lines.get(2)!.loadCell(0, new CellData()).getChars(), 'd');
+          assert.equal(term.buffer.lines.get(3)!.loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4)!.loadCell(0, new CellData()).getChars(), 'e');
         });
 
         it('should properly scroll inside a scroll region (scrollTop and scrollBottom set)', () => {
-          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
-          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
-          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
-          term.buffer.lines.get(3).setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
-          term.buffer.lines.get(4).setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
+          term.buffer.lines.get(0)!.setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1)!.setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2)!.setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(3)!.setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
+          term.buffer.lines.get(4)!.setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
           term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
           term.buffer.scrollTop = 1;
           term.buffer.scrollBottom = 3;
           term.scroll(DEFAULT_ATTR_DATA.clone());
           assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
-          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c', '\'b\' should be removed from the buffer');
-          assert.equal(term.buffer.lines.get(2).loadCell(0, new CellData()).getChars(), 'd');
-          assert.equal(term.buffer.lines.get(3).loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4).loadCell(0, new CellData()).getChars(), 'e');
+          assert.equal(term.buffer.lines.get(0)!.loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(1)!.loadCell(0, new CellData()).getChars(), 'c', '\'b\' should be removed from the buffer');
+          assert.equal(term.buffer.lines.get(2)!.loadCell(0, new CellData()).getChars(), 'd');
+          assert.equal(term.buffer.lines.get(3)!.loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4)!.loadCell(0, new CellData()).getChars(), 'e');
         });
       });
     });
@@ -531,7 +530,6 @@ describe('Terminal', () => {
     let evKeyPress: any;
 
     beforeEach(() => {
-      term.showCursor = () => { };
       term.clearSelection = () => { };
       // term.compositionHelper = {
       //   isComposing: false,
@@ -724,11 +722,11 @@ describe('Terminal', () => {
       const cell = new CellData();
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
         term.writeSync(high + String.fromCharCode(i));
-        const tchar = term.buffer.lines.get(0).loadCell(0, cell);
+        const tchar = term.buffer.lines.get(0)!.loadCell(0, cell);
         expect(tchar.getChars()).eql(high + String.fromCharCode(i));
         expect(tchar.getChars().length).eql(2);
         expect(tchar.getWidth()).eql(1);
-        expect(term.buffer.lines.get(0).loadCell(1, cell).getChars()).eql('');
+        expect(term.buffer.lines.get(0)!.loadCell(1, cell).getChars()).eql('');
         term.reset();
       }
     });
@@ -738,9 +736,9 @@ describe('Terminal', () => {
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
         term.buffer.x = term.cols - 1;
         term.writeSync(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0).loadCell(term.buffer.x - 1, cell).getChars()).eql(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0).loadCell(term.buffer.x - 1, cell).getChars().length).eql(2);
-        expect(term.buffer.lines.get(1).loadCell(0, cell).getChars()).eql('');
+        expect(term.buffer.lines.get(0)!.loadCell(term.buffer.x - 1, cell).getChars()).eql(high + String.fromCharCode(i));
+        expect(term.buffer.lines.get(0)!.loadCell(term.buffer.x - 1, cell).getChars().length).eql(2);
+        expect(term.buffer.lines.get(1)!.loadCell(0, cell).getChars()).eql('');
         term.reset();
       }
     });
@@ -751,10 +749,10 @@ describe('Terminal', () => {
         term.buffer.x = term.cols - 1;
 
         term.writeSync('a' + high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars()).eql('a');
-        expect(term.buffer.lines.get(1).loadCell(0, cell).getChars()).eql(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(1).loadCell(0, cell).getChars().length).eql(2);
-        expect(term.buffer.lines.get(1).loadCell(1, cell).getChars()).eql('');
+        expect(term.buffer.lines.get(0)!.loadCell(term.cols - 1, cell).getChars()).eql('a');
+        expect(term.buffer.lines.get(1)!.loadCell(0, cell).getChars()).eql(high + String.fromCharCode(i));
+        expect(term.buffer.lines.get(1)!.loadCell(0, cell).getChars().length).eql(2);
+        expect(term.buffer.lines.get(1)!.loadCell(1, cell).getChars()).eql('');
         term.reset();
       }
     });
@@ -770,9 +768,9 @@ describe('Terminal', () => {
         }
         term.writeSync('a' + high + String.fromCharCode(i));
         // auto wraparound mode should cut off the rest of the line
-        expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars()).eql(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars().length).eql(2);
-        expect(term.buffer.lines.get(1).loadCell(1, cell).getChars()).eql('');
+        expect(term.buffer.lines.get(0)!.loadCell(term.cols - 1, cell).getChars()).eql(high + String.fromCharCode(i));
+        expect(term.buffer.lines.get(0)!.loadCell(term.cols - 1, cell).getChars().length).eql(2);
+        expect(term.buffer.lines.get(1)!.loadCell(1, cell).getChars()).eql('');
         term.reset();
       }
     });
@@ -782,11 +780,11 @@ describe('Terminal', () => {
       for (let i = 0xDC00; i <= 0xDCFF; ++i) {
         term.writeSync(high);
         term.writeSync(String.fromCharCode(i));
-        const tchar = term.buffer.lines.get(0).loadCell(0, cell);
+        const tchar = term.buffer.lines.get(0)!.loadCell(0, cell);
         expect(tchar.getChars()).eql(high + String.fromCharCode(i));
         expect(tchar.getChars().length).eql(2);
         expect(tchar.getWidth()).eql(1);
-        expect(term.buffer.lines.get(0).loadCell(1, cell).getChars()).eql('');
+        expect(term.buffer.lines.get(0)!.loadCell(1, cell).getChars()).eql('');
         term.reset();
       }
     });
@@ -796,7 +794,7 @@ describe('Terminal', () => {
     const cell = new CellData();
     it('café', () => {
       term.writeSync('cafe\u0301');
-      term.buffer.lines.get(0).loadCell(3, cell);
+      term.buffer.lines.get(0)!.loadCell(3, cell);
       expect(cell.getChars()).eql('e\u0301');
       expect(cell.getChars().length).eql(2);
       expect(cell.getWidth()).eql(1);
@@ -804,11 +802,11 @@ describe('Terminal', () => {
     it('café - end of line', () => {
       term.buffer.x = term.cols - 1 - 3;
       term.writeSync('cafe\u0301');
-      term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
+      term.buffer.lines.get(0)!.loadCell(term.cols - 1, cell);
       expect(cell.getChars()).eql('e\u0301');
       expect(cell.getChars().length).eql(2);
       expect(cell.getWidth()).eql(1);
-      term.buffer.lines.get(0).loadCell(1, cell);
+      term.buffer.lines.get(0)!.loadCell(1, cell);
       expect(cell.getChars()).eql('');
       expect(cell.getChars().length).eql(0);
       expect(cell.getWidth()).eql(1);
@@ -816,12 +814,12 @@ describe('Terminal', () => {
     it('multiple combined é', () => {
       term.writeSync(Array(100).join('e\u0301'));
       for (let i = 0; i < term.cols; ++i) {
-        term.buffer.lines.get(0).loadCell(i, cell);
+        term.buffer.lines.get(0)!.loadCell(i, cell);
         expect(cell.getChars()).eql('e\u0301');
         expect(cell.getChars().length).eql(2);
         expect(cell.getWidth()).eql(1);
       }
-      term.buffer.lines.get(1).loadCell(0, cell);
+      term.buffer.lines.get(1)!.loadCell(0, cell);
       expect(cell.getChars()).eql('e\u0301');
       expect(cell.getChars().length).eql(2);
       expect(cell.getWidth()).eql(1);
@@ -829,12 +827,12 @@ describe('Terminal', () => {
     it('multiple surrogate with combined', () => {
       term.writeSync(Array(100).join('\uD800\uDC00\u0301'));
       for (let i = 0; i < term.cols; ++i) {
-        term.buffer.lines.get(0).loadCell(i, cell);
+        term.buffer.lines.get(0)!.loadCell(i, cell);
         expect(cell.getChars()).eql('\uD800\uDC00\u0301');
         expect(cell.getChars().length).eql(3);
         expect(cell.getWidth()).eql(1);
       }
-      term.buffer.lines.get(1).loadCell(0, cell);
+      term.buffer.lines.get(1)!.loadCell(0, cell);
       expect(cell.getChars()).eql('\uD800\uDC00\u0301');
       expect(cell.getChars().length).eql(3);
       expect(cell.getWidth()).eql(1);
@@ -857,7 +855,7 @@ describe('Terminal', () => {
     it('line of ￥ even', () => {
       term.writeSync(Array(50).join('￥'));
       for (let i = 0; i < term.cols; ++i) {
-        term.buffer.lines.get(0).loadCell(i, cell);
+        term.buffer.lines.get(0)!.loadCell(i, cell);
         if (i % 2) {
           expect(cell.getChars()).eql('');
           expect(cell.getChars().length).eql(0);
@@ -868,7 +866,7 @@ describe('Terminal', () => {
           expect(cell.getWidth()).eql(2);
         }
       }
-      term.buffer.lines.get(1).loadCell(0, cell);
+      term.buffer.lines.get(1)!.loadCell(0, cell);
       expect(cell.getChars()).eql('￥');
       expect(cell.getChars().length).eql(1);
       expect(cell.getWidth()).eql(2);
@@ -877,7 +875,7 @@ describe('Terminal', () => {
       term.buffer.x = 1;
       term.writeSync(Array(50).join('￥'));
       for (let i = 1; i < term.cols - 1; ++i) {
-        term.buffer.lines.get(0).loadCell(i, cell);
+        term.buffer.lines.get(0)!.loadCell(i, cell);
         if (!(i % 2)) {
           expect(cell.getChars()).eql('');
           expect(cell.getChars().length).eql(0);
@@ -888,11 +886,11 @@ describe('Terminal', () => {
           expect(cell.getWidth()).eql(2);
         }
       }
-      term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
+      term.buffer.lines.get(0)!.loadCell(term.cols - 1, cell);
       expect(cell.getChars()).eql('');
       expect(cell.getChars().length).eql(0);
       expect(cell.getWidth()).eql(1);
-      term.buffer.lines.get(1).loadCell(0, cell);
+      term.buffer.lines.get(1)!.loadCell(0, cell);
       expect(cell.getChars()).eql('￥');
       expect(cell.getChars().length).eql(1);
       expect(cell.getWidth()).eql(2);
@@ -901,7 +899,7 @@ describe('Terminal', () => {
       term.buffer.x = 1;
       term.writeSync(Array(50).join('￥\u0301'));
       for (let i = 1; i < term.cols - 1; ++i) {
-        term.buffer.lines.get(0).loadCell(i, cell);
+        term.buffer.lines.get(0)!.loadCell(i, cell);
         if (!(i % 2)) {
           expect(cell.getChars()).eql('');
           expect(cell.getChars().length).eql(0);
@@ -912,11 +910,11 @@ describe('Terminal', () => {
           expect(cell.getWidth()).eql(2);
         }
       }
-      term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
+      term.buffer.lines.get(0)!.loadCell(term.cols - 1, cell);
       expect(cell.getChars()).eql('');
       expect(cell.getChars().length).eql(0);
       expect(cell.getWidth()).eql(1);
-      term.buffer.lines.get(1).loadCell(0, cell);
+      term.buffer.lines.get(1)!.loadCell(0, cell);
       expect(cell.getChars()).eql('￥\u0301');
       expect(cell.getChars().length).eql(2);
       expect(cell.getWidth()).eql(2);
@@ -924,7 +922,7 @@ describe('Terminal', () => {
     it('line of ￥ with combining even', () => {
       term.writeSync(Array(50).join('￥\u0301'));
       for (let i = 0; i < term.cols; ++i) {
-        term.buffer.lines.get(0).loadCell(i, cell);
+        term.buffer.lines.get(0)!.loadCell(i, cell);
         if (i % 2) {
           expect(cell.getChars()).eql('');
           expect(cell.getChars().length).eql(0);
@@ -935,7 +933,7 @@ describe('Terminal', () => {
           expect(cell.getWidth()).eql(2);
         }
       }
-      term.buffer.lines.get(1).loadCell(0, cell);
+      term.buffer.lines.get(1)!.loadCell(0, cell);
       expect(cell.getChars()).eql('￥\u0301');
       expect(cell.getChars().length).eql(2);
       expect(cell.getWidth()).eql(2);
@@ -944,7 +942,7 @@ describe('Terminal', () => {
       term.buffer.x = 1;
       term.writeSync(Array(50).join('\ud843\ude6d\u0301'));
       for (let i = 1; i < term.cols - 1; ++i) {
-        term.buffer.lines.get(0).loadCell(i, cell);
+        term.buffer.lines.get(0)!.loadCell(i, cell);
         if (!(i % 2)) {
           expect(cell.getChars()).eql('');
           expect(cell.getChars().length).eql(0);
@@ -955,11 +953,11 @@ describe('Terminal', () => {
           expect(cell.getWidth()).eql(2);
         }
       }
-      term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
+      term.buffer.lines.get(0)!.loadCell(term.cols - 1, cell);
       expect(cell.getChars()).eql('');
       expect(cell.getChars().length).eql(0);
       expect(cell.getWidth()).eql(1);
-      term.buffer.lines.get(1).loadCell(0, cell);
+      term.buffer.lines.get(1)!.loadCell(0, cell);
       expect(cell.getChars()).eql('\ud843\ude6d\u0301');
       expect(cell.getChars().length).eql(3);
       expect(cell.getWidth()).eql(2);
@@ -967,7 +965,7 @@ describe('Terminal', () => {
     it('line of surrogate fullwidth with combining even', () => {
       term.writeSync(Array(50).join('\ud843\ude6d\u0301'));
       for (let i = 0; i < term.cols; ++i) {
-        term.buffer.lines.get(0).loadCell(i, cell);
+        term.buffer.lines.get(0)!.loadCell(i, cell);
         if (i % 2) {
           expect(cell.getChars()).eql('');
           expect(cell.getChars().length).eql(0);
@@ -978,7 +976,7 @@ describe('Terminal', () => {
           expect(cell.getWidth()).eql(2);
         }
       }
-      term.buffer.lines.get(1).loadCell(0, cell);
+      term.buffer.lines.get(1)!.loadCell(0, cell);
       expect(cell.getChars()).eql('\ud843\ude6d\u0301');
       expect(cell.getChars().length).eql(3);
       expect(cell.getWidth()).eql(2);
@@ -991,42 +989,42 @@ describe('Terminal', () => {
       term.writeSync(Array(9).join('0123456789').slice(-80));
       term.buffer.x = 10;
       term.buffer.y = 0;
-      term.insertMode = true;
+      term.write('\x1b[4h');
       term.writeSync('abcde');
-      expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('a');
-      expect(term.buffer.lines.get(0).loadCell(14, cell).getChars()).eql('e');
-      expect(term.buffer.lines.get(0).loadCell(15, cell).getChars()).eql('0');
-      expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('4');
+      expect(term.buffer.lines.get(0)!.length).eql(term.cols);
+      expect(term.buffer.lines.get(0)!.loadCell(10, cell).getChars()).eql('a');
+      expect(term.buffer.lines.get(0)!.loadCell(14, cell).getChars()).eql('e');
+      expect(term.buffer.lines.get(0)!.loadCell(15, cell).getChars()).eql('0');
+      expect(term.buffer.lines.get(0)!.loadCell(79, cell).getChars()).eql('4');
     });
     it('fullwidth - insert', () => {
       term.writeSync(Array(9).join('0123456789').slice(-80));
       term.buffer.x = 10;
       term.buffer.y = 0;
-      term.insertMode = true;
+      term.write('\x1b[4h');
       term.writeSync('￥￥￥');
-      expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('￥');
-      expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('');
-      expect(term.buffer.lines.get(0).loadCell(14, cell).getChars()).eql('￥');
-      expect(term.buffer.lines.get(0).loadCell(15, cell).getChars()).eql('');
-      expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('3');
+      expect(term.buffer.lines.get(0)!.length).eql(term.cols);
+      expect(term.buffer.lines.get(0)!.loadCell(10, cell).getChars()).eql('￥');
+      expect(term.buffer.lines.get(0)!.loadCell(11, cell).getChars()).eql('');
+      expect(term.buffer.lines.get(0)!.loadCell(14, cell).getChars()).eql('￥');
+      expect(term.buffer.lines.get(0)!.loadCell(15, cell).getChars()).eql('');
+      expect(term.buffer.lines.get(0)!.loadCell(79, cell).getChars()).eql('3');
     });
     it('fullwidth - right border', () => {
       term.writeSync(Array(41).join('￥'));
       term.buffer.x = 10;
       term.buffer.y = 0;
-      term.insertMode = true;
+      term.write('\x1b[4h');
       term.writeSync('a');
-      expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('a');
-      expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('￥');
-      expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('');  // fullwidth char got replaced
+      expect(term.buffer.lines.get(0)!.length).eql(term.cols);
+      expect(term.buffer.lines.get(0)!.loadCell(10, cell).getChars()).eql('a');
+      expect(term.buffer.lines.get(0)!.loadCell(11, cell).getChars()).eql('￥');
+      expect(term.buffer.lines.get(0)!.loadCell(79, cell).getChars()).eql('');  // fullwidth char got replaced
       term.writeSync('b');
-      expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('b');
-      expect(term.buffer.lines.get(0).loadCell(12, cell).getChars()).eql('￥');
-      expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('');  // empty cell after fullwidth
+      expect(term.buffer.lines.get(0)!.length).eql(term.cols);
+      expect(term.buffer.lines.get(0)!.loadCell(11, cell).getChars()).eql('b');
+      expect(term.buffer.lines.get(0)!.loadCell(12, cell).getChars()).eql('￥');
+      expect(term.buffer.lines.get(0)!.loadCell(79, cell).getChars()).eql('');  // empty cell after fullwidth
     });
   });
 
@@ -1271,9 +1269,9 @@ describe('Terminal', () => {
       terminal.writeSync(input);
       const s = terminal.buffer.iterator(true).next().content;
       assert.equal(input, s);
-      const stringIndex = s.match(/😃/).index;
+      const stringIndex = s.match(/😃/)!.index!;
       const bufferIndex = terminal.buffer.stringIndexToBufferIndex(0, stringIndex);
-      assert(terminal.buffer.lines.get(bufferIndex[0]).loadCell(bufferIndex[1], new CellData()).getChars(), '😃');
+      assert(terminal.buffer.lines.get(bufferIndex[0])!.loadCell(bufferIndex[1], new CellData()).getChars(), '😃');
     });
 
     it('multiline fullwidth chars with offset 1 (currently tests for broken behavior)', () => {
@@ -1300,7 +1298,7 @@ describe('Terminal', () => {
       assert.equal(input, s);
       for (let i = 0; i < input.length; ++i) {
         const bufferIndex = terminal.buffer.stringIndexToBufferIndex(0, i, true);
-        assert.equal(input[i], terminal.buffer.lines.get(bufferIndex[0]).loadCell(bufferIndex[1], new CellData()).getChars());
+        assert.equal(input[i], terminal.buffer.lines.get(bufferIndex[0])!.loadCell(bufferIndex[1], new CellData()).getChars());
       }
     });
 
@@ -1318,7 +1316,7 @@ describe('Terminal', () => {
             : (i % 3 === 1)
               ? input.substr(i, 2)
               : input.substr(i - 1, 2),
-          terminal.buffer.lines.get(bufferIndex[0]).loadCell(bufferIndex[1], new CellData()).getChars());
+          terminal.buffer.lines.get(bufferIndex[0])!.loadCell(bufferIndex[1], new CellData()).getChars());
       }
     });
 
@@ -1372,15 +1370,15 @@ describe('Terminal', () => {
 
       const normalTerminal = new TestTerminal({rows: 5, cols: 10, windowsMode: false});
       normalTerminal.writeSync(data.join(''));
-      assert.equal(normalTerminal.buffer.lines.get(0).isWrapped, false);
-      assert.equal(normalTerminal.buffer.lines.get(1).isWrapped, false);
-      assert.equal(normalTerminal.buffer.lines.get(2).isWrapped, false);
+      assert.equal(normalTerminal.buffer.lines.get(0)!.isWrapped, false);
+      assert.equal(normalTerminal.buffer.lines.get(1)!.isWrapped, false);
+      assert.equal(normalTerminal.buffer.lines.get(2)!.isWrapped, false);
 
       const windowsModeTerminal = new TestTerminal({rows: 5, cols: 10, windowsMode: true});
       windowsModeTerminal.writeSync(data.join(''));
-      assert.equal(windowsModeTerminal.buffer.lines.get(0).isWrapped, false);
-      assert.equal(windowsModeTerminal.buffer.lines.get(1).isWrapped, true, 'This line should wrap in Windows mode as the previous line ends in a non-null character');
-      assert.equal(windowsModeTerminal.buffer.lines.get(2).isWrapped, false);
+      assert.equal(windowsModeTerminal.buffer.lines.get(0)!.isWrapped, false);
+      assert.equal(windowsModeTerminal.buffer.lines.get(1)!.isWrapped, true, 'This line should wrap in Windows mode as the previous line ends in a non-null character');
+      assert.equal(windowsModeTerminal.buffer.lines.get(2)!.isWrapped, false);
     });
 
     it('should mark lines as wrapped when the line ends in a non-null character after a CUP', () => {
@@ -1392,22 +1390,154 @@ describe('Terminal', () => {
 
       const normalTerminal = new TestTerminal({rows: 5, cols: 10, windowsMode: false});
       normalTerminal.writeSync(data.join(''));
-      assert.equal(normalTerminal.buffer.lines.get(0).isWrapped, false);
-      assert.equal(normalTerminal.buffer.lines.get(1).isWrapped, false);
-      assert.equal(normalTerminal.buffer.lines.get(2).isWrapped, false);
+      assert.equal(normalTerminal.buffer.lines.get(0)!.isWrapped, false);
+      assert.equal(normalTerminal.buffer.lines.get(1)!.isWrapped, false);
+      assert.equal(normalTerminal.buffer.lines.get(2)!.isWrapped, false);
 
       const windowsModeTerminal = new TestTerminal({rows: 5, cols: 10, windowsMode: true});
       windowsModeTerminal.writeSync(data.join(''));
-      assert.equal(windowsModeTerminal.buffer.lines.get(0).isWrapped, false);
-      assert.equal(windowsModeTerminal.buffer.lines.get(1).isWrapped, true, 'This line should wrap in Windows mode as the previous line ends in a non-null character');
-      assert.equal(windowsModeTerminal.buffer.lines.get(2).isWrapped, false);
+      assert.equal(windowsModeTerminal.buffer.lines.get(0)!.isWrapped, false);
+      assert.equal(windowsModeTerminal.buffer.lines.get(1)!.isWrapped, true, 'This line should wrap in Windows mode as the previous line ends in a non-null character');
+      assert.equal(windowsModeTerminal.buffer.lines.get(2)!.isWrapped, false);
+    });
+  });
+  it('convertEol setting', function(): void {
+    // not converting
+    const termNotConverting = new TestTerminal({cols: 15, rows: 10});
+    termNotConverting.writeSync('Hello\nWorld');
+    expect(termNotConverting.buffer.lines.get(0)!.translateToString(false)).equals('Hello          ');
+    expect(termNotConverting.buffer.lines.get(1)!.translateToString(false)).equals('     World     ');
+    expect(termNotConverting.buffer.lines.get(0)!.translateToString(true)).equals('Hello');
+    expect(termNotConverting.buffer.lines.get(1)!.translateToString(true)).equals('     World');
+
+    // converting
+    const termConverting = new TestTerminal({cols: 15, rows: 10, convertEol: true});
+    termConverting.writeSync('Hello\nWorld');
+    expect(termConverting.buffer.lines.get(0)!.translateToString(false)).equals('Hello          ');
+    expect(termConverting.buffer.lines.get(1)!.translateToString(false)).equals('World          ');
+    expect(termConverting.buffer.lines.get(0)!.translateToString(true)).equals('Hello');
+    expect(termConverting.buffer.lines.get(1)!.translateToString(true)).equals('World');
+  });
+  describe('Terminal InputHandler integration', () => {
+    function getLines(term: TestTerminal, limit: number = term.rows): string[] {
+      const res: string[] = [];
+      for (let i = 0; i < limit; ++i) {
+        res.push(term.buffer.lines.get(i)!.translateToString(true));
+      }
+      return res;
+    }
+
+    // This suite cannot live in InputHandler unless Terminal.scroll moved into IBufferService
+    describe('SL/SR/DECIC/DECDC', () => {
+      let term: TestTerminal;
+      beforeEach(() => {
+        term = new TestTerminal({cols: 5, rows: 5, scrollback: 1});
+      });
+      it('SL (scrollLeft)', () => {
+        term.writeSync('12345'.repeat(6));
+        term.writeSync('\x1b[ @');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '2345', '2345', '2345', '2345', '2345']);
+        term.writeSync('\x1b[0 @');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '345', '345', '345', '345', '345']);
+        term.writeSync('\x1b[2 @');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '5', '5', '5', '5', '5']);
+      });
+      it('SR (scrollRight)', () => {
+        term.writeSync('12345'.repeat(6));
+        term.writeSync('\x1b[ A');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', ' 1234', ' 1234', ' 1234', ' 1234', ' 1234']);
+        term.writeSync('\x1b[0 A');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '  123', '  123', '  123', '  123', '  123']);
+        term.writeSync('\x1b[2 A');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '    1', '    1', '    1', '    1', '    1']);
+      });
+      it('insertColumns (DECIC)', () => {
+        term.writeSync('12345'.repeat(6));
+        term.writeSync('\x1b[3;3H');
+        term.writeSync('\x1b[\'}');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '12 34', '12 34', '12 34', '12 34', '12 34']);
+        term.reset();
+        term.writeSync('12345'.repeat(6));
+        term.writeSync('\x1b[3;3H');
+        term.writeSync('\x1b[1\'}');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '12 34', '12 34', '12 34', '12 34', '12 34']);
+        term.reset();
+        term.writeSync('12345'.repeat(6));
+        term.writeSync('\x1b[3;3H');
+        term.writeSync('\x1b[2\'}');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '12  3', '12  3', '12  3', '12  3', '12  3']);
+      });
+      it('deleteColumns (DECDC)', () => {
+        term.writeSync('12345'.repeat(6));
+        term.writeSync('\x1b[3;3H');
+        term.writeSync('\x1b[\'~');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '1245', '1245', '1245', '1245', '1245']);
+        term.reset();
+        term.writeSync('12345'.repeat(6));
+        term.writeSync('\x1b[3;3H');
+        term.writeSync('\x1b[1\'~');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '1245', '1245', '1245', '1245', '1245']);
+        term.reset();
+        term.writeSync('12345'.repeat(6));
+        term.writeSync('\x1b[3;3H');
+        term.writeSync('\x1b[2\'~');
+        assert.deepEqual(getLines(term, term.rows + 1), ['12345', '125', '125', '125', '125', '125']);
+      });
+    });
+
+    describe('BS with reverseWraparound set/unset', () => {
+      const ttyBS = '\x08 \x08';  // tty ICANON sends <BS SP BS> on pressing BS
+
+      beforeEach(() => {
+        term = new TestTerminal({cols: 5, rows: 5, scrollback: 1});
+      });
+
+      describe('reverseWraparound set', () => {
+        it('should not reverse outside of scroll margins', () => {
+          // prepare buffer content
+          term.writeSync('#####abcdefghijklmnopqrstuvwxy');
+          assert.deepEqual(getLines(term, 6), ['#####', 'abcde', 'fghij', 'klmno', 'pqrst', 'uvwxy']);
+          assert.equal(term.buffer.ydisp, 1);
+          assert.equal(term.buffer.x, 5);
+          assert.equal(term.buffer.y, 4);
+          term.writeSync(ttyBS.repeat(100));
+          assert.deepEqual(getLines(term, 6), ['#####', 'abcde', 'fghij', 'klmno', 'pqrst', '    y']);
+
+          term.writeSync('\x1b[?45h');
+          term.writeSync('uvwxy');
+
+          // set top/bottom to 1/3 (0-based)
+          term.writeSync('\x1b[2;4r');
+          // place cursor below scroll bottom
+          term.buffer.x = 5;
+          term.buffer.y = 4;
+          term.writeSync(ttyBS.repeat(100));
+          assert.deepEqual(getLines(term, 6), ['#####', 'abcde', 'fghij', 'klmno', 'pqrst', '     ']);
+
+          term.writeSync('uvwxy');
+          // place cursor within scroll margins
+          term.buffer.x = 5;
+          term.buffer.y = 3;
+          term.writeSync(ttyBS.repeat(100));
+          assert.deepEqual(getLines(term, 6), ['#####', 'abcde', '     ', '     ', '     ', 'uvwxy']);
+          assert.equal(term.buffer.x, 0);
+          assert.equal(term.buffer.y, term.buffer.scrollTop);  // stops at 0, scrollTop
+
+          term.writeSync('fghijklmnopqrst');
+          // place cursor above scroll top
+          term.buffer.x = 5;
+          term.buffer.y = 0;
+          term.writeSync(ttyBS.repeat(100));
+          assert.deepEqual(getLines(term, 6), ['#####', '     ', 'fghij', 'klmno', 'pqrst', 'uvwxy']);
+        });
+      });
     });
   });
 });
 
 class TestLinkifier extends Linkifier {
   constructor(bufferService: IBufferService, unicodeService: IUnicodeService) {
-    super(bufferService, new MockLogService(), new MockOptionsService(), unicodeService);
+    super(bufferService, new MockLogService(), unicodeService);
     Linkifier._timeBeforeLatency = 0;
   }
 
@@ -1416,14 +1546,14 @@ class TestLinkifier extends Linkifier {
 }
 
 class TestMouseZoneManager implements IMouseZoneManager {
-  dispose(): void {
+  public dispose(): void {
   }
   public clears: number = 0;
   public zones: IMouseZone[] = [];
-  add(zone: IMouseZone): void {
+  public add(zone: IMouseZone): void {
     this.zones.push(zone);
   }
-  clearAll(): void {
+  public clearAll(): void {
     this.clears++;
   }
 }

src/browser/Terminal2.test.ts

@@ -8,18 +8,18 @@ import * as path from 'path';
 import * as os from 'os';
 import * as fs from 'fs';
 import * as pty from 'node-pty';
-import { Terminal } from './Terminal';
+import { Terminal } from 'browser/Terminal';
 import { IDisposable } from 'xterm';
 
 // all test files expect terminal in 80x25
 const COLS = 80;
 const ROWS = 25;
 
-const TESTFILES = glob.sync('**/escape_sequence_files/*.in', { cwd: path.join(__dirname, '..')});
+const TESTFILES = glob.sync('**/escape_sequence_files/*.in', { cwd: path.join(__dirname, '../..')});
 const SKIP_FILES = [
   't0084-CBT.in',
   't0101-NLM.in',
-  't0103-reverse_wrap.in',
+  't0103-reverse_wrap.in',  // not comparable, we deviate from xterm reverse wrap on purpose
   't0504-vim.in'
 ];
 if (os.platform() === 'darwin') {
@@ -60,7 +60,7 @@ describe('Escape Sequence Files', function(): void {
     ptyTerm._master.destroy();
   });
 
-  FILES.forEach(filename => {
+  for (const filename of FILES) {
     (process.platform === 'win32' ? it.skip : it)(filename.split('/').slice(-1)[0], async () => {
       // reset terminal and handler
       if (customHandler) {
@@ -93,7 +93,7 @@ describe('Escape Sequence Files', function(): void {
         throw new Error(formatError(fs.readFileSync(filename, 'utf8'), content, expected));
       }
     });
-  });
+  }
 });
 
 /**
@@ -124,7 +124,7 @@ function terminalToString(term: Terminal): string {
   let result = '';
   let lineText = '';
   for (let line = term.buffer.ybase; line < term.buffer.ybase + term.rows; line++) {
-    lineText = term.buffer.lines.get(line).translateToString(true);
+    lineText = term.buffer.lines.get(line)!.translateToString(true);
     // rtrim empty cells as xterm does
     lineText = lineText.replace(/\s+$/, '');
     result += lineText;

src/browser/TestUtils.test.ts

@@ -3,19 +3,342 @@
  * @license MIT
  */
 
+import { IDisposable, IMarker, ISelectionPosition, ILinkProvider } from 'xterm';
 import { IEvent, EventEmitter } from 'common/EventEmitter';
-import { ICharSizeService, IMouseService } from 'browser/services/Services';
+import { ICharSizeService, IMouseService, IRenderService, ISelectionService } from 'browser/services/Services';
+import { IRenderDimensions, IRenderer, CharacterJoinerHandler, IRequestRedrawEvent } from 'browser/renderer/Types';
+import { IColorSet, ILinkMatcherOptions, ITerminal, ILinkifier, ILinkifier2, IBrowser, IViewport, IColorManager, ICompositionHelper } from 'browser/Types';
+import { IBuffer, IBufferStringIterator, IBufferSet } from 'common/buffer/Types';
+import { IBufferLine, ICellData, IAttributeData, ICircularList, XtermListener, ICharset, ITerminalOptions } from 'common/Types';
+import { Buffer } from 'common/buffer/Buffer';
+import * as Browser from 'common/Platform';
+import { Terminal } from 'browser/Terminal';
+import { IUnicodeService, IOptionsService } from 'common/services/Services';
+import { IFunctionIdentifier, IParams } from 'common/parser/Types';
+import { AttributeData } from 'common/buffer/AttributeData';
+
+export class TestTerminal extends Terminal {
+  public get curAttrData(): IAttributeData { return (this as any)._inputHandler._curAttrData; }
+  public keyDown(ev: any): boolean | undefined { return this._keyDown(ev); }
+  public keyPress(ev: any): boolean { return this._keyPress(ev); }
+}
+
+export class MockTerminal implements ITerminal {
+  public onBlur!: IEvent<void>;
+  public onFocus!: IEvent<void>;
+  public onA11yChar!: IEvent<string>;
+  public onA11yTab!: IEvent<number>;
+  public onCursorMove!: IEvent<void>;
+  public onLineFeed!: IEvent<void>;
+  public onSelectionChange!: IEvent<void>;
+  public onData!: IEvent<string>;
+  public onBinary!: IEvent<string>;
+  public onTitleChange!: IEvent<string>;
+  public onScroll!: IEvent<number>;
+  public onKey!: IEvent<{ key: string, domEvent: KeyboardEvent }>;
+  public onRender!: IEvent<{ start: number, end: number }>;
+  public onResize!: IEvent<{ cols: number, rows: number }>;
+  public markers!: IMarker[];
+  public optionsService!: IOptionsService;
+  public unicodeService!: IUnicodeService;
+  public addMarker(cursorYOffset: number): IMarker {
+    throw new Error('Method not implemented.');
+  }
+  public selectLines(start: number, end: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public scrollToLine(line: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public static string: any;
+  public setOption(key: any, value: any): void {
+    throw new Error('Method not implemented.');
+  }
+  public blur(): void {
+    throw new Error('Method not implemented.');
+  }
+  public focus(): void {
+    throw new Error('Method not implemented.');
+  }
+  public resize(columns: number, rows: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public writeln(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  public paste(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  public open(parent: HTMLElement): void {
+    throw new Error('Method not implemented.');
+  }
+  public attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  public addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  public addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  public addEscHandler(id: IFunctionIdentifier, handler: () => boolean): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  public addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  public registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => boolean | void, options?: ILinkMatcherOptions): number {
+    throw new Error('Method not implemented.');
+  }
+  public deregisterLinkMatcher(matcherId: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public registerLinkProvider(linkProvider: ILinkProvider): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  public hasSelection(): boolean {
+    throw new Error('Method not implemented.');
+  }
+  public getSelection(): string {
+    throw new Error('Method not implemented.');
+  }
+  public getSelectionPosition(): ISelectionPosition | undefined {
+    throw new Error('Method not implemented.');
+  }
+  public clearSelection(): void {
+    throw new Error('Method not implemented.');
+  }
+  public select(column: number, row: number, length: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public selectAll(): void {
+    throw new Error('Method not implemented.');
+  }
+  public dispose(): void {
+    throw new Error('Method not implemented.');
+  }
+  public scrollPages(pageCount: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public scrollToTop(): void {
+    throw new Error('Method not implemented.');
+  }
+  public scrollToBottom(): void {
+    throw new Error('Method not implemented.');
+  }
+  public clear(): void {
+    throw new Error('Method not implemented.');
+  }
+  public write(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  public writeUtf8(data: Uint8Array): void {
+    throw new Error('Method not implemented.');
+  }
+  public bracketedPasteMode!: boolean;
+  public renderer!: IRenderer;
+  public linkifier!: ILinkifier;
+  public linkifier2!: ILinkifier2;
+  public isFocused!: boolean;
+  public options: ITerminalOptions = {};
+  public element!: HTMLElement;
+  public screenElement!: HTMLElement;
+  public rowContainer!: HTMLElement;
+  public selectionContainer!: HTMLElement;
+  public selectionService!: ISelectionService;
+  public textarea!: HTMLTextAreaElement;
+  public rows!: number;
+  public cols!: number;
+  public browser: IBrowser = <any>Browser;
+  public writeBuffer!: string[];
+  public children!: HTMLElement[];
+  public cursorHidden!: boolean;
+  public cursorState!: number;
+  public scrollback!: number;
+  public buffers!: IBufferSet;
+  public buffer!: IBuffer;
+  public viewport!: IViewport;
+  public applicationCursor!: boolean;
+  public handler(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  public on(event: string, callback: (...args: any[]) => void): void {
+    throw new Error('Method not implemented.');
+  }
+  public off(type: string, listener: XtermListener): void {
+    throw new Error('Method not implemented.');
+  }
+  public addDisposableListener(type: string, handler: XtermListener): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  public scrollLines(disp: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public scrollToRow(absoluteRow: number): number {
+    throw new Error('Method not implemented.');
+  }
+  public cancel(ev: Event, force?: boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  public log(text: string): void {
+    throw new Error('Method not implemented.');
+  }
+  public emit(event: string, data: any): void {
+    throw new Error('Method not implemented.');
+  }
+  public reset(): void {
+    throw new Error('Method not implemented.');
+  }
+  public refresh(start: number, end: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
+  public deregisterCharacterJoiner(joinerId: number): void { }
+}
+
+export class MockBuffer implements IBuffer {
+  public markers!: IMarker[];
+  public addMarker(y: number): IMarker {
+    throw new Error('Method not implemented.');
+  }
+  public isCursorInViewport!: boolean;
+  public lines!: ICircularList<IBufferLine>;
+  public ydisp!: number;
+  public ybase!: number;
+  public hasScrollback!: boolean;
+  public y!: number;
+  public x!: number;
+  public tabs: any;
+  public scrollBottom!: number;
+  public scrollTop!: number;
+  public savedY!: number;
+  public savedX!: number;
+  public savedCharset: ICharset | undefined;
+  public savedCurAttrData = new AttributeData();
+  public translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string {
+    return Buffer.prototype.translateBufferLineToString.apply(this, arguments as any);
+  }
+  public getWrappedRangeForLine(y: number): { first: number, last: number } {
+    return Buffer.prototype.getWrappedRangeForLine.apply(this, arguments as any);
+  }
+  public nextStop(x?: number): number {
+    throw new Error('Method not implemented.');
+  }
+  public prevStop(x?: number): number {
+    throw new Error('Method not implemented.');
+  }
+  public setLines(lines: ICircularList<IBufferLine>): void {
+    this.lines = lines;
+  }
+  public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
+    return Buffer.prototype.getBlankLine.apply(this, arguments as any);
+  }
+  public stringIndexToBufferIndex(lineIndex: number, stringIndex: number): number[] {
+    return Buffer.prototype.stringIndexToBufferIndex.apply(this, arguments as any);
+  }
+  public iterator(trimRight: boolean, startIndex?: number, endIndex?: number): IBufferStringIterator {
+    return Buffer.prototype.iterator.apply(this, arguments as any);
+  }
+  public getNullCell(attr?: IAttributeData): ICellData {
+    throw new Error('Method not implemented.');
+  }
+  public getWhitespaceCell(attr?: IAttributeData): ICellData {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export class MockRenderer implements IRenderer {
+  public onRequestRedraw!: IEvent<IRequestRedrawEvent>;
+  public onCanvasResize!: IEvent<{ width: number, height: number }>;
+  public onRender!: IEvent<{ start: number, end: number }>;
+  public dispose(): void {
+    throw new Error('Method not implemented.');
+  }
+  public colorManager!: IColorManager;
+  public on(type: string, listener: XtermListener): void {
+    throw new Error('Method not implemented.');
+  }
+  public off(type: string, listener: XtermListener): void {
+    throw new Error('Method not implemented.');
+  }
+  public emit(type: string, data?: any): void {
+    throw new Error('Method not implemented.');
+  }
+  public addDisposableListener(type: string, handler: XtermListener): IDisposable {
+    throw new Error('Method not implemented.');
+  }
+  public dimensions!: IRenderDimensions;
+  public setColors(colors: IColorSet): void {
+    throw new Error('Method not implemented.');
+  }
+  public onResize(cols: number, rows: number): void { }
+  public onCharSizeChanged(): void { }
+  public onBlur(): void { }
+  public onFocus(): void { }
+  public onSelectionChanged(start: [number, number], end: [number, number]): void { }
+  public onCursorMove(): void { }
+  public onOptionsChanged(): void { }
+  public onDevicePixelRatioChange(): void { }
+  public clear(): void { }
+  public renderRows(start: number, end: number): void { }
+  public registerCharacterJoiner(handler: CharacterJoinerHandler): number { return 0; }
+  public deregisterCharacterJoiner(): boolean { return true; }
+}
+
+export class MockViewport implements IViewport {
+  public dispose(): void {
+    throw new Error('Method not implemented.');
+  }
+  public scrollBarWidth: number = 0;
+  public onThemeChange(colors: IColorSet): void {
+    throw new Error('Method not implemented.');
+  }
+  public onWheel(ev: WheelEvent): boolean {
+    throw new Error('Method not implemented.');
+  }
+  public onTouchStart(ev: TouchEvent): void {
+    throw new Error('Method not implemented.');
+  }
+  public onTouchMove(ev: TouchEvent): boolean {
+    throw new Error('Method not implemented.');
+  }
+  public syncScrollArea(): void { }
+  public getLinesScrolled(ev: WheelEvent): number {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export class MockCompositionHelper implements ICompositionHelper {
+  public get isComposing(): boolean {
+    return false;
+  }
+  public compositionstart(): void {
+    throw new Error('Method not implemented.');
+  }
+  public compositionupdate(ev: CompositionEvent): void {
+    throw new Error('Method not implemented.');
+  }
+  public compositionend(): void {
+    throw new Error('Method not implemented.');
+  }
+  public updateCompositionElements(dontRecurse?: boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  public keydown(ev: KeyboardEvent): boolean {
+    return true;
+  }
+}
 
 export class MockCharSizeService implements ICharSizeService {
-  serviceBrand: any;
-  get hasValidSize(): boolean { return this.width > 0 && this.height > 0; }
-  onCharSizeChange: IEvent<void> = new EventEmitter<void>().event;
+  public serviceBrand: undefined;
+  public get hasValidSize(): boolean { return this.width > 0 && this.height > 0; }
+  public onCharSizeChange: IEvent<void> = new EventEmitter<void>().event;
   constructor(public width: number, public height: number) {}
-  measure(): void {}
+  public measure(): void {}
 }
 
 export class MockMouseService implements IMouseService {
-  serviceBrand: any;
+  public serviceBrand: undefined;
   public getCoords(event: {clientX: number, clientY: number}, element: HTMLElement, colCount: number, rowCount: number, isSelection?: boolean): [number, number] | undefined {
     throw new Error('Not implemented');
   }
@@ -24,3 +347,72 @@ export class MockMouseService implements IMouseService {
     throw new Error('Not implemented');
   }
 }
+
+export class MockRenderService implements IRenderService {
+  public serviceBrand: undefined;
+  public onDimensionsChange: IEvent<IRenderDimensions> = new EventEmitter<IRenderDimensions>().event;
+  public onRenderedBufferChange: IEvent<{ start: number, end: number }, void> = new EventEmitter<{ start: number, end: number }>().event;
+  public onRefreshRequest: IEvent<{ start: number, end: number}, void> = new EventEmitter<{ start: number, end: number }>().event;
+  public dimensions: IRenderDimensions = {
+    scaledCharWidth: 0,
+    scaledCharHeight: 0,
+    scaledCellWidth: 0,
+    scaledCellHeight: 0,
+    scaledCharLeft: 0,
+    scaledCharTop: 0,
+    scaledCanvasWidth: 0,
+    scaledCanvasHeight: 0,
+    canvasWidth: 0,
+    canvasHeight: 0,
+    actualCellWidth: 0,
+    actualCellHeight: 0
+  };
+  public refreshRows(start: number, end: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public resize(cols: number, rows: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public changeOptions(): void {
+    throw new Error('Method not implemented.');
+  }
+  public setRenderer(renderer: IRenderer): void {
+    throw new Error('Method not implemented.');
+  }
+  public setColors(colors: IColorSet): void {
+    throw new Error('Method not implemented.');
+  }
+  public onDevicePixelRatioChange(): void {
+    throw new Error('Method not implemented.');
+  }
+  public onResize(cols: number, rows: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public onCharSizeChanged(): void {
+    throw new Error('Method not implemented.');
+  }
+  public onBlur(): void {
+    throw new Error('Method not implemented.');
+  }
+  public onFocus(): void {
+    throw new Error('Method not implemented.');
+  }
+  public onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  public onCursorMove(): void {
+    throw new Error('Method not implemented.');
+  }
+  public clear(): void {
+    throw new Error('Method not implemented.');
+  }
+  public registerCharacterJoiner(handler: CharacterJoinerHandler): number {
+    throw new Error('Method not implemented.');
+  }
+  public deregisterCharacterJoiner(joinerId: number): boolean {
+    throw new Error('Method not implemented.');
+  }
+  public dispose(): void {
+    throw new Error('Method not implemented.');
+  }
+}

src/browser/Types.d.ts

@@ -3,9 +3,108 @@
  * @license MIT
  */
 
+import { IDisposable, IMarker, ISelectionPosition } from 'xterm';
 import { IEvent } from 'common/EventEmitter';
-import { IDisposable } from 'common/Types';
+import { ICoreTerminal, CharData, ITerminalOptions } from 'common/Types';
 import { IMouseService, IRenderService } from './services/Services';
+import { IBuffer, IBufferSet } from 'common/buffer/Types';
+import { IFunctionIdentifier, IParams } from 'common/parser/Types';
+
+export interface ITerminal extends IPublicTerminal, ICoreTerminal {
+  element: HTMLElement | undefined;
+  screenElement: HTMLElement | undefined;
+  browser: IBrowser;
+  buffer: IBuffer;
+  buffers: IBufferSet;
+  viewport: IViewport | undefined;
+  // TODO: We should remove options once components adopt optionsService
+  options: ITerminalOptions;
+  linkifier: ILinkifier;
+  linkifier2: ILinkifier2;
+
+  onBlur: IEvent<void>;
+  onFocus: IEvent<void>;
+  onA11yChar: IEvent<string>;
+  onA11yTab: IEvent<number>;
+
+  cancel(ev: Event, force?: boolean): boolean | void;
+}
+
+// Portions of the public API that are required by the internal Terminal
+export interface IPublicTerminal extends IDisposable {
+  textarea: HTMLTextAreaElement | undefined;
+  rows: number;
+  cols: number;
+  buffer: IBuffer;
+  markers: IMarker[];
+  onCursorMove: IEvent<void>;
+  onData: IEvent<string>;
+  onBinary: IEvent<string>;
+  onKey: IEvent<{ key: string, domEvent: KeyboardEvent }>;
+  onLineFeed: IEvent<void>;
+  onScroll: IEvent<number>;
+  onSelectionChange: IEvent<void>;
+  onRender: IEvent<{ start: number, end: number }>;
+  onResize: IEvent<{ cols: number, rows: number }>;
+  onTitleChange: IEvent<string>;
+  blur(): void;
+  focus(): void;
+  resize(columns: number, rows: number): void;
+  open(parent: HTMLElement): void;
+  attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void;
+  addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable;
+  addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable;
+  addEscHandler(id: IFunctionIdentifier, callback: () => boolean): IDisposable;
+  addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable;
+  registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => void, options?: ILinkMatcherOptions): number;
+  deregisterLinkMatcher(matcherId: number): void;
+  registerLinkProvider(linkProvider: ILinkProvider): IDisposable;
+  registerCharacterJoiner(handler: (text: string) => [number, number][]): number;
+  deregisterCharacterJoiner(joinerId: number): void;
+  addMarker(cursorYOffset: number): IMarker | undefined;
+  hasSelection(): boolean;
+  getSelection(): string;
+  getSelectionPosition(): ISelectionPosition | undefined;
+  clearSelection(): void;
+  select(column: number, row: number, length: number): void;
+  selectAll(): void;
+  selectLines(start: number, end: number): void;
+  dispose(): void;
+  scrollLines(amount: number): void;
+  scrollPages(pageCount: number): void;
+  scrollToTop(): void;
+  scrollToBottom(): void;
+  scrollToLine(line: number): void;
+  clear(): void;
+  write(data: string | Uint8Array, callback?: () => void): void;
+  paste(data: string): void;
+  refresh(start: number, end: number): void;
+  reset(): void;
+}
+
+export type CustomKeyEventHandler = (event: KeyboardEvent) => boolean;
+
+export type LineData = CharData[];
+
+export interface ICompositionHelper {
+  readonly isComposing: boolean;
+  compositionstart(): void;
+  compositionupdate(ev: CompositionEvent): void;
+  compositionend(): void;
+  updateCompositionElements(dontRecurse?: boolean): void;
+  keydown(ev: KeyboardEvent): boolean;
+}
+
+export interface IBrowser {
+  isNode: boolean;
+  userAgent: string;
+  platform: string;
+  isFirefox: boolean;
+  isMac: boolean;
+  isIpad: boolean;
+  isIphone: boolean;
+  isWindows: boolean;
+}
 
 export interface IColorManager {
   colors: IColorSet;
@@ -22,7 +121,7 @@ export interface IColorSet {
   background: IColor;
   cursor: IColor;
   cursorAccent: IColor;
-  selection: IColor;
+  selectionTransparent: IColor;
   /** The selection blended on top of background. */
   selectionOpaque: IColor;
   ansi: IColor[];
@@ -96,8 +195,8 @@ export interface ILinkifierEvent {
 }
 
 export interface ILinkifier {
-  onLinkHover: IEvent<ILinkifierEvent>;
-  onLinkLeave: IEvent<ILinkifierEvent>;
+  onShowLinkUnderline: IEvent<ILinkifierEvent>;
+  onHideLinkUnderline: IEvent<ILinkifierEvent>;
   onLinkTooltip: IEvent<ILinkifierEvent>;
 
   attachToDom(element: HTMLElement, mouseZoneManager: IMouseZoneManager): void;
@@ -107,8 +206,8 @@ export interface ILinkifier {
 }
 
 export interface ILinkifier2 {
-  onLinkHover: IEvent<ILinkifierEvent>;
-  onLinkLeave: IEvent<ILinkifierEvent>;
+  onShowLinkUnderline: IEvent<ILinkifierEvent>;
+  onHideLinkUnderline: IEvent<ILinkifierEvent>;
 
   attachToDom(element: HTMLElement, mouseService: IMouseService, renderService: IRenderService): void;
   registerLinkProvider(linkProvider: ILinkProvider): IDisposable;
@@ -166,17 +265,23 @@ export interface IMouseZone {
 }
 
 interface ILinkProvider {
-  provideLink(position: IBufferCellPosition, callback: (link: ILink | undefined) => void): void;
+  provideLinks(y: number, callback: (links: ILink[] | undefined) => void): void;
 }
 
 interface ILink {
   range: IBufferRange;
   text: string;
+  decorations?: ILinkDecorations;
   activate(event: MouseEvent, text: string): void;
   hover?(event: MouseEvent, text: string): void;
   leave?(event: MouseEvent, text: string): void;
 }
 
+interface ILinkDecorations {
+  pointerCursor: boolean;
+  underline: boolean;
+}
+
 interface IBufferRange {
   start: IBufferCellPosition;
   end: IBufferCellPosition;

src/browser/input/CompositionHelper.ts

@@ -22,6 +22,7 @@ export class CompositionHelper {
    * IME. This variable determines whether the compositionText should be displayed on the UI.
    */
   private _isComposing: boolean;
+  public get isComposing(): boolean { return this._isComposing; }
 
   /**
    * The position within the input textarea's value of the current composition.
@@ -118,7 +119,6 @@ export class CompositionHelper {
   private _finalizeComposition(waitForPropagation: boolean): void {
     this._compositionView.classList.remove('active');
     this._isComposing = false;
-    this._clearTextareaPosition();
 
     if (!waitForPropagation) {
       // Cancel any delayed composition send requests and send the input immediately.
@@ -218,13 +218,4 @@ export class CompositionHelper {
       setTimeout(() => this.updateCompositionElements(true), 0);
     }
   }
-
-  /**
-   * Clears the textarea's position so that the cursor does not blink on IE.
-   * @private
-   */
-  private _clearTextareaPosition(): void {
-    this._textarea.style.left = '';
-    this._textarea.style.top = '';
-  }
 }

src/browser/input/MoveToCell.ts

@@ -105,11 +105,6 @@ function moveToRequestedCol(startX: number, startY: number, targetX: number, tar
   ).length, sequence(direction, applicationCursor));
 }
 
-function moveHorizontallyOnly(startX: number, startY: number, targetX: number, targetY: number, bufferService: IBufferService, applicationCursor: boolean): string {
-  const direction = horizontalDirection(startX, startY, targetX, targetY, bufferService, applicationCursor);
-  return repeat(Math.abs(startX - targetX), sequence(direction, applicationCursor));
-}
-
 /**
  * Utility functions
  */

src/browser/public/AddonManager.test.ts

@@ -24,11 +24,11 @@ describe('AddonManager', () => {
     it('should call addon constructor', () => {
       let called = false;
       class Addon implements ITerminalAddon {
-        activate(terminal: any): void {
+        public activate(terminal: any): void {
           assert.equal(terminal, 'foo', 'The first constructor arg should be Terminal');
           called = true;
         }
-        dispose(): void { }
+        public dispose(): void { }
       }
       manager.loadAddon('foo' as any, new Addon());
       assert.equal(called, true);
@@ -39,12 +39,12 @@ describe('AddonManager', () => {
     it('should dispose all loaded addons', () => {
       let called = 0;
       class Addon implements ITerminalAddon {
-        activate(): void {}
-        dispose(): void { called++; }
+        public activate(): void {}
+        public dispose(): void { called++; }
       }
-      manager.loadAddon(null, new Addon());
-      manager.loadAddon(null, new Addon());
-      manager.loadAddon(null, new Addon());
+      manager.loadAddon(null!, new Addon());
+      manager.loadAddon(null!, new Addon());
+      manager.loadAddon(null!, new Addon());
       assert.equal(manager.addons.length, 3);
       manager.dispose();
       assert.equal(called, 3);

src/browser/public/Terminal.ts

@@ -4,12 +4,12 @@
  */
 
 import { Terminal as ITerminalApi, ITerminalOptions, IMarker, IDisposable, ILinkMatcherOptions, ITheme, ILocalizableStrings, ITerminalAddon, ISelectionPosition, IBuffer as IBufferApi, IBufferNamespace as IBufferNamespaceApi, IBufferLine as IBufferLineApi, IBufferCell as IBufferCellApi, IParser, IFunctionIdentifier, ILinkProvider, IUnicodeHandling, IUnicodeVersionProvider } from 'xterm';
-import { ITerminal } from '../Types';
+import { ITerminal } from 'browser/Types';
 import { IBufferLine, ICellData } from 'common/Types';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
 import { CellData } from 'common/buffer/CellData';
 import { Terminal as TerminalCore } from '../Terminal';
-import * as Strings from '../browser/LocalizableStrings';
+import * as Strings from '../LocalizableStrings';
 import { IEvent, EventEmitter } from 'common/EventEmitter';
 import { AddonManager } from './AddonManager';
 import { IParams } from 'common/parser/Types';
@@ -17,13 +17,19 @@ import { IParams } from 'common/parser/Types';
 export class Terminal implements ITerminalApi {
   private _core: ITerminal;
   private _addonManager: AddonManager;
-  private _parser: IParser;
+  private _parser: IParser | undefined;
 
   constructor(options?: ITerminalOptions) {
     this._core = new TerminalCore(options);
     this._addonManager = new AddonManager();
   }
 
+  private _checkProposedApi(): void {
+    if (!this._core.optionsService.options.allowProposedApi) {
+      throw new Error('You must set the allowProposedApi option to true to use proposed API');
+    }
+  }
+
   public get onCursorMove(): IEvent<void> { return this._core.onCursorMove; }
   public get onLineFeed(): IEvent<void> { return this._core.onLineFeed; }
   public get onSelectionChange(): IEvent<void> { return this._core.onSelectionChange; }
@@ -37,19 +43,27 @@ export class Terminal implements ITerminalApi {
 
   public get element(): HTMLElement | undefined { return this._core.element; }
   public get parser(): IParser {
+    this._checkProposedApi();
     if (!this._parser) {
       this._parser = new ParserApi(this._core);
     }
     return this._parser;
   }
   public get unicode(): IUnicodeHandling {
+    this._checkProposedApi();
     return new UnicodeApi(this._core);
   }
   public get textarea(): HTMLTextAreaElement | undefined { return this._core.textarea; }
   public get rows(): number { return this._core.rows; }
   public get cols(): number { return this._core.cols; }
-  public get buffer(): IBufferNamespaceApi { return new BufferNamespaceApi(this._core.buffers); }
-  public get markers(): ReadonlyArray<IMarker> { return this._core.markers; }
+  public get buffer(): IBufferNamespaceApi {
+    this._checkProposedApi();
+    return new BufferNamespaceApi(this._core.buffers);
+  }
+  public get markers(): ReadonlyArray<IMarker> {
+    this._checkProposedApi();
+    return this._core.markers;
+  }
   public blur(): void {
     this._core.blur();
   }
@@ -67,25 +81,31 @@ export class Terminal implements ITerminalApi {
     this._core.attachCustomKeyEventHandler(customKeyEventHandler);
   }
   public registerLinkMatcher(regex: RegExp, handler: (event: MouseEvent, uri: string) => void, options?: ILinkMatcherOptions): number {
+    this._checkProposedApi();
     return this._core.registerLinkMatcher(regex, handler, options);
   }
   public deregisterLinkMatcher(matcherId: number): void {
+    this._checkProposedApi();
     this._core.deregisterLinkMatcher(matcherId);
   }
   public registerLinkProvider(linkProvider: ILinkProvider): IDisposable {
+    this._checkProposedApi();
     return this._core.registerLinkProvider(linkProvider);
   }
   public registerCharacterJoiner(handler: (text: string) => [number, number][]): number {
+    this._checkProposedApi();
     return this._core.registerCharacterJoiner(handler);
   }
   public deregisterCharacterJoiner(joinerId: number): void {
+    this._checkProposedApi();
     this._core.deregisterCharacterJoiner(joinerId);
   }
-  public registerMarker(cursorYOffset: number): IMarker {
+  public registerMarker(cursorYOffset: number): IMarker | undefined {
+    this._checkProposedApi();
     this._verifyIntegers(cursorYOffset);
     return this._core.addMarker(cursorYOffset);
   }
-  public addMarker(cursorYOffset: number): IMarker {
+  public addMarker(cursorYOffset: number): IMarker | undefined {
     return this.registerMarker(cursorYOffset);
   }
   public hasSelection(): boolean {
@@ -184,11 +204,11 @@ export class Terminal implements ITerminalApi {
   }
 
   private _verifyIntegers(...values: number[]): void {
-    values.forEach(value => {
+    for (const value of values) {
       if (value === Infinity || isNaN(value) || value % 1 !== 0) {
         throw new Error('This API only accepts integers');
       }
-    });
+    }
   }
 }
 

src/browser/renderer/BaseRenderLayer.ts

@@ -16,6 +16,7 @@ import { CellData } from 'common/buffer/CellData';
 import { IBufferService, IOptionsService } from 'common/services/Services';
 import { throwIfFalsy } from 'browser/renderer/RendererUtils';
 import { channels, color, rgba } from 'browser/Color';
+import { removeElementFromParent } from 'browser/Dom';
 
 export abstract class BaseRenderLayer implements IRenderLayer {
   private _canvas: HTMLCanvasElement;
@@ -60,7 +61,7 @@ export abstract class BaseRenderLayer implements IRenderLayer {
   }
 
   public dispose(): void {
-    this._container.removeChild(this._canvas);
+    removeElementFromParent(this._canvas);
     this._charAtlas?.dispose();
   }
 
@@ -77,7 +78,7 @@ export abstract class BaseRenderLayer implements IRenderLayer {
   public onFocus(): void {}
   public onCursorMove(): void {}
   public onGridChanged(startRow: number, endRow: number): void {}
-  public onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean = false): void {}
+  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean = false): void {}
 
   public setColors(colorSet: IColorSet): void {
     this._refreshCharAtlas(colorSet);

src/browser/renderer/CursorRenderLayer.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { IRenderDimensions, IRequestRefreshRowsEvent } from 'browser/renderer/Types';
+import { IRenderDimensions, IRequestRedrawEvent } from 'browser/renderer/Types';
 import { BaseRenderLayer } from 'browser/renderer/BaseRenderLayer';
 import { ICellData } from 'common/Types';
 import { CellData } from 'common/buffer/CellData';
@@ -36,9 +36,9 @@ export class CursorRenderLayer extends BaseRenderLayer {
     zIndex: number,
     colors: IColorSet,
     rendererId: number,
-    private _onRequestRefreshRowsEvent: IEventEmitter<IRequestRefreshRowsEvent>,
-    readonly bufferService: IBufferService,
-    readonly optionsService: IOptionsService,
+    private _onRequestRedraw: IEventEmitter<IRequestRedrawEvent>,
+    bufferService: IBufferService,
+    optionsService: IOptionsService,
     private readonly _coreService: ICoreService,
     private readonly _coreBrowserService: ICoreBrowserService
   ) {
@@ -83,14 +83,14 @@ export class CursorRenderLayer extends BaseRenderLayer {
     if (this._cursorBlinkStateManager) {
       this._cursorBlinkStateManager.pause();
     }
-    this._onRequestRefreshRowsEvent.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
+    this._onRequestRedraw.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
   }
 
   public onFocus(): void {
     if (this._cursorBlinkStateManager) {
       this._cursorBlinkStateManager.resume();
     } else {
-      this._onRequestRefreshRowsEvent.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
+      this._onRequestRedraw.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
     }
   }
 
@@ -107,7 +107,7 @@ export class CursorRenderLayer extends BaseRenderLayer {
     }
     // Request a refresh from the terminal as management of rendering is being
     // moved back to the terminal
-    this._onRequestRefreshRowsEvent.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
+    this._onRequestRedraw.fire({ start: this._bufferService.buffer.y, end: this._bufferService.buffer.y });
   }
 
   public onCursorMove(): void {

src/browser/renderer/LinkRenderLayer.ts

@@ -20,15 +20,15 @@ export class LinkRenderLayer extends BaseRenderLayer {
     rendererId: number,
     linkifier: ILinkifier,
     linkifier2: ILinkifier2,
-    readonly bufferService: IBufferService,
-    readonly optionsService: IOptionsService
+    bufferService: IBufferService,
+    optionsService: IOptionsService
   ) {
     super(container, 'link', zIndex, true, colors, rendererId, bufferService, optionsService);
-    linkifier.onLinkHover(e => this._onLinkHover(e));
-    linkifier.onLinkLeave(e => this._onLinkLeave(e));
+    linkifier.onShowLinkUnderline(e => this._onShowLinkUnderline(e));
+    linkifier.onHideLinkUnderline(e => this._onHideLinkUnderline(e));
 
-    linkifier2.onLinkHover(e => this._onLinkHover(e));
-    linkifier2.onLinkLeave(e => this._onLinkLeave(e));
+    linkifier2.onShowLinkUnderline(e => this._onShowLinkUnderline(e));
+    linkifier2.onHideLinkUnderline(e => this._onHideLinkUnderline(e));
   }
 
   public resize(dim: IRenderDimensions): void {
@@ -53,7 +53,7 @@ export class LinkRenderLayer extends BaseRenderLayer {
     }
   }
 
-  private _onLinkHover(e: ILinkifierEvent): void {
+  private _onShowLinkUnderline(e: ILinkifierEvent): void {
     if (e.fg === INVERTED_DEFAULT_COLOR) {
       this._ctx.fillStyle = this._colors.background.css;
     } else if (e.fg && is256Color(e.fg)) {
@@ -77,7 +77,7 @@ export class LinkRenderLayer extends BaseRenderLayer {
     this._state = e;
   }
 
-  private _onLinkLeave(e: ILinkifierEvent): void {
+  private _onHideLinkUnderline(e: ILinkifierEvent): void {
     this._clearCurrentLink();
   }
 }

src/browser/renderer/Renderer.ts

@@ -6,7 +6,7 @@
 import { TextRenderLayer } from 'browser/renderer/TextRenderLayer';
 import { SelectionRenderLayer } from 'browser/renderer/SelectionRenderLayer';
 import { CursorRenderLayer } from 'browser/renderer/CursorRenderLayer';
-import { IRenderLayer, IRenderer, IRenderDimensions, CharacterJoinerHandler, ICharacterJoinerRegistry, IRequestRefreshRowsEvent } from 'browser/renderer/Types';
+import { IRenderLayer, IRenderer, IRenderDimensions, CharacterJoinerHandler, ICharacterJoinerRegistry, IRequestRedrawEvent } from 'browser/renderer/Types';
 import { LinkRenderLayer } from 'browser/renderer/LinkRenderLayer';
 import { CharacterJoinerRegistry } from 'browser/renderer/CharacterJoinerRegistry';
 import { Disposable } from 'common/Lifecycle';
@@ -27,29 +27,28 @@ export class Renderer extends Disposable implements IRenderer {
 
   public dimensions: IRenderDimensions;
 
-  private _onRequestRefreshRows = new EventEmitter<IRequestRefreshRowsEvent>();
-  public get onRequestRefreshRows(): IEvent<IRequestRefreshRowsEvent> { return this._onRequestRefreshRows.event; }
+  private _onRequestRedraw = new EventEmitter<IRequestRedrawEvent>();
+  public get onRequestRedraw(): IEvent<IRequestRedrawEvent> { return this._onRequestRedraw.event; }
 
   constructor(
     private _colors: IColorSet,
     private readonly _screenElement: HTMLElement,
-    readonly linkifier: ILinkifier,
-    readonly linkifier2: ILinkifier2,
+    linkifier: ILinkifier,
+    linkifier2: ILinkifier2,
     @IBufferService private readonly _bufferService: IBufferService,
     @ICharSizeService private readonly _charSizeService: ICharSizeService,
     @IOptionsService private readonly _optionsService: IOptionsService,
-    @ICoreService readonly coreService: ICoreService,
-    @ICoreBrowserService readonly coreBrowserService: ICoreBrowserService
+    @ICoreService coreService: ICoreService,
+    @ICoreBrowserService coreBrowserService: ICoreBrowserService
   ) {
     super();
     const allowTransparency = this._optionsService.options.allowTransparency;
     this._characterJoinerRegistry = new CharacterJoinerRegistry(this._bufferService);
-
     this._renderLayers = [
       new TextRenderLayer(this._screenElement, 0, this._colors, this._characterJoinerRegistry, allowTransparency, this._id, this._bufferService, _optionsService),
       new SelectionRenderLayer(this._screenElement, 1, this._colors, this._id, this._bufferService, _optionsService),
       new LinkRenderLayer(this._screenElement, 2, this._colors, this._id, linkifier, linkifier2, this._bufferService, _optionsService),
-      new CursorRenderLayer(this._screenElement, 3, this._colors, this._id, this._onRequestRefreshRows, this._bufferService, _optionsService, coreService, coreBrowserService)
+      new CursorRenderLayer(this._screenElement, 3, this._colors, this._id, this._onRequestRedraw, this._bufferService, _optionsService, coreService, coreBrowserService)
     ];
     this.dimensions = {
       scaledCharWidth: 0,
@@ -71,8 +70,10 @@ export class Renderer extends Disposable implements IRenderer {
   }
 
   public dispose(): void {
+    for (const l of this._renderLayers) {
+      l.dispose();
+    }
     super.dispose();
-    this._renderLayers.forEach(l => l.dispose());
     removeTerminalFromCache(this._id);
   }
 
@@ -87,12 +88,11 @@ export class Renderer extends Disposable implements IRenderer {
 
   public setColors(colors: IColorSet): void {
     this._colors = colors;
-
     // Clear layers and force a full render
-    this._renderLayers.forEach(l => {
+    for (const l of this._renderLayers) {
       l.setColors(this._colors);
       l.reset();
-    });
+    }
   }
 
   public onResize(cols: number, rows: number): void {
@@ -100,7 +100,9 @@ export class Renderer extends Disposable implements IRenderer {
     this._updateDimensions();
 
     // Resize all render layers
-    this._renderLayers.forEach(l => l.resize(this.dimensions));
+    for (const l of this._renderLayers) {
+      l.resize(this.dimensions);
+    }
 
     // Resize the screen
     this._screenElement.style.width = `${this.dimensions.canvasWidth}px`;
@@ -119,7 +121,7 @@ export class Renderer extends Disposable implements IRenderer {
     this._runOperation(l => l.onFocus());
   }
 
-  public onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean = false): void {
+  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean = false): void {
     this._runOperation(l => l.onSelectionChanged(start, end, columnSelectMode));
   }
 
@@ -136,7 +138,9 @@ export class Renderer extends Disposable implements IRenderer {
   }
 
   private _runOperation(operation: (layer: IRenderLayer) => void): void {
-    this._renderLayers.forEach(l => operation(l));
+    for (const l of this._renderLayers) {
+      operation(l);
+    }
   }
 
   /**
@@ -144,7 +148,9 @@ export class Renderer extends Disposable implements IRenderer {
    * necessary before queueing up the next one.
    */
   public renderRows(start: number, end: number): void {
-    this._renderLayers.forEach(l => l.onGridChanged(start, end));
+    for (const l of this._renderLayers) {
+      l.onGridChanged(start, end);
+    }
   }
 
   /**

src/browser/renderer/SelectionRenderLayer.ts

@@ -23,8 +23,8 @@ export class SelectionRenderLayer extends BaseRenderLayer {
     zIndex: number,
     colors: IColorSet,
     rendererId: number,
-    readonly bufferService: IBufferService,
-    readonly optionsService: IOptionsService
+    bufferService: IBufferService,
+    optionsService: IOptionsService
   ) {
     super(container, 'selection', zIndex, true, colors, rendererId, bufferService, optionsService);
     this._clearState();
@@ -52,7 +52,7 @@ export class SelectionRenderLayer extends BaseRenderLayer {
     }
   }
 
-  public onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void {
+  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void {
     // Selection has not changed
     if (!this._didStateChange(start, end, columnSelectMode, this._bufferService.buffer.ydisp)) {
       return;
@@ -78,7 +78,7 @@ export class SelectionRenderLayer extends BaseRenderLayer {
       return;
     }
 
-    this._ctx.fillStyle = this._colors.selection.css;
+    this._ctx.fillStyle = this._colors.selectionTransparent.css;
 
     if (columnSelectMode) {
       const startCol = start[0];
@@ -110,7 +110,7 @@ export class SelectionRenderLayer extends BaseRenderLayer {
     this._state.ydisp = this._bufferService.buffer.ydisp;
   }
 
-  private _didStateChange(start: [number, number], end: [number, number], columnSelectMode: boolean, ydisp: number): boolean {
+  private _didStateChange(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean, ydisp: number): boolean {
     return !this._areCoordinatesEqual(start, this._state.start) ||
       !this._areCoordinatesEqual(end, this._state.end) ||
       columnSelectMode !== this._state.columnSelectMode ||

src/browser/renderer/TextRenderLayer.ts

@@ -36,8 +36,8 @@ export class TextRenderLayer extends BaseRenderLayer {
     characterJoinerRegistry: ICharacterJoinerRegistry,
     alpha: boolean,
     rendererId: number,
-    readonly bufferService: IBufferService,
-    readonly optionsService: IOptionsService
+    bufferService: IBufferService,
+    optionsService: IOptionsService
   ) {
     super(container, 'text', zIndex, alpha, colors, rendererId, bufferService, optionsService);
     this._state = new GridCache<CharData>();
@@ -188,13 +188,13 @@ export class TextRenderLayer extends BaseRenderLayer {
 
       if (y !== startY) {
         // our row changed, draw the previous row
-        ctx.fillStyle = prevFillStyle ? prevFillStyle : '';
+        ctx.fillStyle = prevFillStyle || '';
         this._fillCells(startX, startY, cols - startX, 1);
         startX = x;
         startY = y;
       } else if (prevFillStyle !== nextFillStyle) {
         // our color changed, draw the previous characters in this row
-        ctx.fillStyle = prevFillStyle ? prevFillStyle : '';
+        ctx.fillStyle = prevFillStyle || '';
         this._fillCells(startX, startY, x - startX, 1);
         startX = x;
         startY = y;

src/browser/renderer/Types.d.ts

@@ -24,7 +24,7 @@ export interface IRenderDimensions {
   actualCellHeight: number;
 }
 
-export interface IRequestRefreshRowsEvent {
+export interface IRequestRedrawEvent {
   start: number;
   end: number;
 }
@@ -36,7 +36,11 @@ export interface IRequestRefreshRowsEvent {
 export interface IRenderer extends IDisposable {
   readonly dimensions: IRenderDimensions;
 
-  readonly onRequestRefreshRows: IEvent<IRequestRefreshRowsEvent>;
+  /**
+   * Fires when the renderer is requesting to be redrawn on the next animation
+   * frame but is _not_ a result of content changing (eg. selection changes).
+   */
+  readonly onRequestRedraw: IEvent<IRequestRedrawEvent>;
 
   dispose(): void;
   setColors(colors: IColorSet): void;
@@ -45,7 +49,7 @@ export interface IRenderer extends IDisposable {
   onCharSizeChanged(): void;
   onBlur(): void;
   onFocus(): void;
-  onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void;
+  onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
   onCursorMove(): void;
   onOptionsChanged(): void;
   clear(): void;
@@ -100,7 +104,7 @@ export interface IRenderLayer extends IDisposable {
   /**
    * Calls when the selection changes.
    */
-  onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void;
+  onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
 
   /**
    * Registers a handler to join characters to render as a group

src/browser/renderer/dom/DomRenderer.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { IRenderer, IRenderDimensions, CharacterJoinerHandler, IRequestRefreshRowsEvent } from 'browser/renderer/Types';
+import { IRenderer, IRenderDimensions, CharacterJoinerHandler, IRequestRedrawEvent } from 'browser/renderer/Types';
 import { BOLD_CLASS, ITALIC_CLASS, CURSOR_CLASS, CURSOR_STYLE_BLOCK_CLASS, CURSOR_BLINK_CLASS, CURSOR_STYLE_BAR_CLASS, CURSOR_STYLE_UNDERLINE_CLASS, DomRendererRowFactory } from 'browser/renderer/dom/DomRendererRowFactory';
 import { INVERTED_DEFAULT_COLOR } from 'browser/renderer/atlas/Constants';
 import { Disposable } from 'common/Lifecycle';
@@ -12,6 +12,7 @@ import { ICharSizeService } from 'browser/services/Services';
 import { IOptionsService, IBufferService } from 'common/services/Services';
 import { EventEmitter, IEvent } from 'common/EventEmitter';
 import { color } from 'browser/Color';
+import { removeElementFromParent } from 'browser/Dom';
 
 const TERMINAL_CLASS_PREFIX = 'xterm-dom-renderer-owner-';
 const ROW_CONTAINER_CLASS = 'xterm-rows';
@@ -39,8 +40,7 @@ export class DomRenderer extends Disposable implements IRenderer {
 
   public dimensions: IRenderDimensions;
 
-  private _onRequestRefreshRows = new EventEmitter<IRequestRefreshRowsEvent>();
-  public get onRequestRefreshRows(): IEvent<IRequestRefreshRowsEvent> { return this._onRequestRefreshRows.event; }
+  public get onRequestRedraw(): IEvent<IRequestRedrawEvent> { return new EventEmitter<IRequestRedrawEvent>().event; }
 
   constructor(
     private _colors: IColorSet,
@@ -54,7 +54,6 @@ export class DomRenderer extends Disposable implements IRenderer {
     @IBufferService private readonly _bufferService: IBufferService
   ) {
     super();
-
     this._rowContainer = document.createElement('div');
     this._rowContainer.classList.add(ROW_CONTAINER_CLASS);
     this._rowContainer.style.lineHeight = 'normal';
@@ -87,19 +86,20 @@ export class DomRenderer extends Disposable implements IRenderer {
     this._screenElement.appendChild(this._rowContainer);
     this._screenElement.appendChild(this._selectionContainer);
 
-    this._linkifier.onLinkHover(e => this._onLinkHover(e));
-    this._linkifier.onLinkLeave(e => this._onLinkLeave(e));
+    this._linkifier.onShowLinkUnderline(e => this._onLinkHover(e));
+    this._linkifier.onHideLinkUnderline(e => this._onLinkLeave(e));
 
-    this._linkifier2.onLinkHover(e => this._onLinkHover(e));
-    this._linkifier2.onLinkLeave(e => this._onLinkLeave(e));
+    this._linkifier2.onShowLinkUnderline(e => this._onLinkHover(e));
+    this._linkifier2.onHideLinkUnderline(e => this._onLinkLeave(e));
   }
 
   public dispose(): void {
     this._element.classList.remove(TERMINAL_CLASS_PREFIX + this._terminalClass);
-    this._screenElement.removeChild(this._rowContainer);
-    this._screenElement.removeChild(this._selectionContainer);
-    this._screenElement.removeChild(this._themeStyleElement);
-    this._screenElement.removeChild(this._dimensionsStyleElement);
+
+    // Outside influences such as React unmounts may manipulate the DOM before our disposal.
+    // https://github.com/xtermjs/xterm.js/issues/2960
+    removeElementFromParent(this._rowContainer, this._selectionContainer, this._themeStyleElement, this._dimensionsStyleElement);
+
     super.dispose();
   }
 
@@ -117,13 +117,13 @@ export class DomRenderer extends Disposable implements IRenderer {
     this.dimensions.actualCellWidth = this.dimensions.canvasWidth / this._bufferService.cols;
     this.dimensions.actualCellHeight = this.dimensions.canvasHeight / this._bufferService.rows;
 
-    this._rowElements.forEach(element => {
+    for (const element of this._rowElements) {
       element.style.width = `${this.dimensions.canvasWidth}px`;
       element.style.height = `${this.dimensions.actualCellHeight}px`;
       element.style.lineHeight = `${this.dimensions.actualCellHeight}px`;
       // Make sure rows don't overflow onto following row
       element.style.overflow = 'hidden';
-    });
+    }
 
     if (!this._dimensionsStyleElement) {
       this._dimensionsStyleElement = document.createElement('style');
@@ -225,7 +225,7 @@ export class DomRenderer extends Disposable implements IRenderer {
       `}` +
       `${this._terminalSelector} .${SELECTION_CLASS} div {` +
       ` position: absolute;` +
-      ` background-color: ${this._colors.selection.css};` +
+      ` background-color: ${this._colors.selectionTransparent.css};` +
       `}`;
     // Colors
     this._colors.ansi.forEach((c, i) => {
@@ -274,7 +274,7 @@ export class DomRenderer extends Disposable implements IRenderer {
     this._rowContainer.classList.add(FOCUS_CLASS);
   }
 
-  public onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void {
+  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void {
     // Remove all selections
     while (this._selectionContainer.children.length) {
       this._selectionContainer.removeChild(this._selectionContainer.children[0]);
@@ -347,7 +347,9 @@ export class DomRenderer extends Disposable implements IRenderer {
   }
 
   public clear(): void {
-    this._rowElements.forEach(e => e.innerHTML = '');
+    for (const e of this._rowElements) {
+      e.innerHTML = '';
+    }
   }
 
   public renderRows(start: number, end: number): void {

src/browser/selection/Types.d.ts

@@ -8,3 +8,8 @@ export interface ISelectionRedrawRequestEvent {
   end: [number, number] | undefined;
   columnSelectMode: boolean;
 }
+
+export interface ISelectionRequestScrollLinesEvent {
+  amount: number;
+  suppressScrollEvent: boolean;
+}

src/browser/services/CharSizeService.ts

@@ -8,7 +8,7 @@ import { IEvent, EventEmitter } from 'common/EventEmitter';
 import { ICharSizeService } from 'browser/services/Services';
 
 export class CharSizeService implements ICharSizeService {
-  serviceBrand: any;
+  public serviceBrand: undefined;
 
   public width: number = 0;
   public height: number = 0;
@@ -20,8 +20,8 @@ export class CharSizeService implements ICharSizeService {
   public get onCharSizeChange(): IEvent<void> { return this._onCharSizeChange.event; }
 
   constructor(
-    readonly document: Document,
-    readonly parentElement: HTMLElement,
+    document: Document,
+    parentElement: HTMLElement,
     @IOptionsService private readonly _optionsService: IOptionsService
   ) {
     this._measureStrategy = new DomMeasureStrategy(document, parentElement, this._optionsService);

src/browser/services/CoreBrowserService.ts

@@ -6,7 +6,7 @@
 import { ICoreBrowserService } from './Services';
 
 export class CoreBrowserService implements ICoreBrowserService {
-  serviceBrand: any;
+  public serviceBrand: undefined;
 
   constructor(
     private _textarea: HTMLTextAreaElement

src/browser/services/MouseService.ts

@@ -7,7 +7,7 @@ import { ICharSizeService, IRenderService, IMouseService } from './Services';
 import { getCoords, getRawByteCoords } from 'browser/input/Mouse';
 
 export class MouseService implements IMouseService {
-  serviceBrand: any;
+  public serviceBrand: undefined;
 
   constructor(
     @IRenderService private readonly _renderService: IRenderService,

src/browser/services/RenderService.ts

@@ -10,24 +10,37 @@ import { Disposable } from 'common/Lifecycle';
 import { ScreenDprMonitor } from 'browser/ScreenDprMonitor';
 import { addDisposableDomListener } from 'browser/Lifecycle';
 import { IColorSet } from 'browser/Types';
-import { IOptionsService } from 'common/services/Services';
+import { IOptionsService, IBufferService } from 'common/services/Services';
 import { ICharSizeService, IRenderService } from 'browser/services/Services';
 
+interface ISelectionState {
+  start: [number, number] | undefined;
+  end: [number, number] | undefined;
+  columnSelectMode: boolean;
+}
+
 export class RenderService extends Disposable implements IRenderService {
-  serviceBrand: any;
+  public serviceBrand: undefined;
 
   private _renderDebouncer: RenderDebouncer;
   private _screenDprMonitor: ScreenDprMonitor;
 
   private _isPaused: boolean = false;
   private _needsFullRefresh: boolean = false;
+  private _isNextRenderRedrawOnly: boolean = true;
+  private _needsSelectionRefresh: boolean = false;
   private _canvasWidth: number = 0;
   private _canvasHeight: number = 0;
+  private _selectionState: ISelectionState = {
+    start: undefined,
+    end: undefined,
+    columnSelectMode: false
+  };
 
   private _onDimensionsChange = new EventEmitter<IRenderDimensions>();
   public get onDimensionsChange(): IEvent<IRenderDimensions> { return this._onDimensionsChange.event; }
   private _onRender = new EventEmitter<{ start: number, end: number }>();
-  public get onRender(): IEvent<{ start: number, end: number }> { return this._onRender.event; }
+  public get onRenderedBufferChange(): IEvent<{ start: number, end: number }> { return this._onRender.event; }
   private _onRefreshRequest = new EventEmitter<{ start: number, end: number }>();
   public get onRefreshRequest(): IEvent<{ start: number, end: number }> { return this._onRefreshRequest.event; }
 
@@ -36,11 +49,15 @@ export class RenderService extends Disposable implements IRenderService {
   constructor(
     private _renderer: IRenderer,
     private _rowCount: number,
-    readonly screenElement: HTMLElement,
-    @IOptionsService readonly optionsService: IOptionsService,
-    @ICharSizeService readonly charSizeService: ICharSizeService
+    screenElement: HTMLElement,
+    @IOptionsService optionsService: IOptionsService,
+    @ICharSizeService charSizeService: ICharSizeService,
+    @IBufferService bufferService: IBufferService
   ) {
     super();
+
+    this.register({ dispose: () => this._renderer.dispose() });
+
     this._renderDebouncer = new RenderDebouncer((start, end) => this._renderRows(start, end));
     this.register(this._renderDebouncer);
 
@@ -48,11 +65,12 @@ export class RenderService extends Disposable implements IRenderService {
     this._screenDprMonitor.setListener(() => this.onDevicePixelRatioChange());
     this.register(this._screenDprMonitor);
 
+    this.register(bufferService.onResize(e => this._fullRefresh()));
     this.register(optionsService.onOptionChange(() => this._renderer.onOptionsChanged()));
     this.register(charSizeService.onCharSizeChange(() => this.onCharSizeChanged()));
 
     // No need to register this as renderer is explicitly disposed in RenderService.dispose
-    this._renderer.onRequestRefreshRows(e => this.refreshRows(e.start, e.end));
+    this._renderer.onRequestRedraw(e => this.refreshRows(e.start, e.end, true));
 
     // dprchange should handle this case, we need this as well for browsers that don't support the
     // matchMedia query.
@@ -68,24 +86,38 @@ export class RenderService extends Disposable implements IRenderService {
   }
 
   private _onIntersectionChange(entry: IntersectionObserverEntry): void {
-    this._isPaused = entry.intersectionRatio === 0;
+    this._isPaused = !entry.isIntersecting;
     if (!this._isPaused && this._needsFullRefresh) {
       this.refreshRows(0, this._rowCount - 1);
       this._needsFullRefresh = false;
     }
   }
 
-  public refreshRows(start: number, end: number): void {
+  public refreshRows(start: number, end: number, isRedrawOnly: boolean = false): void {
     if (this._isPaused) {
       this._needsFullRefresh = true;
       return;
     }
+    if (!isRedrawOnly) {
+      this._isNextRenderRedrawOnly = false;
+    }
     this._renderDebouncer.refresh(start, end, this._rowCount);
   }
 
   private _renderRows(start: number, end: number): void {
     this._renderer.renderRows(start, end);
-    this._onRender.fire({ start, end });
+
+    // Update selection if needed
+    if (this._needsSelectionRefresh) {
+      this._renderer.onSelectionChanged(this._selectionState.start, this._selectionState.end, this._selectionState.columnSelectMode);
+      this._needsSelectionRefresh = false;
+    }
+
+    // Fire render event only if it was not a redraw
+    if (!this._isNextRenderRedrawOnly) {
+      this._onRender.fire({ start, end });
+    }
+    this._isNextRenderRedrawOnly = true;
   }
 
   public resize(cols: number, rows: number): void {
@@ -108,7 +140,6 @@ export class RenderService extends Disposable implements IRenderService {
   }
 
   public dispose(): void {
-    this._renderer.dispose();
     super.dispose();
   }
 
@@ -116,8 +147,11 @@ export class RenderService extends Disposable implements IRenderService {
     // TODO: RenderService should be the only one to dispose the renderer
     this._renderer.dispose();
     this._renderer = renderer;
-    this._renderer.onRequestRefreshRows(e => this.refreshRows(e.start, e.end));
-    this.refreshRows(0, this._rowCount - 1);
+    this._renderer.onRequestRedraw(e => this.refreshRows(e.start, e.end, true));
+
+    // Force a refresh
+    this._needsSelectionRefresh = true;
+    this._fullRefresh();
   }
 
   private _fullRefresh(): void {
@@ -156,7 +190,10 @@ export class RenderService extends Disposable implements IRenderService {
     this._renderer.onFocus();
   }
 
-  public onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void {
+  public onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void {
+    this._selectionState.start = start;
+    this._selectionState.end = end;
+    this._selectionState.columnSelectMode = columnSelectMode;
     this._renderer.onSelectionChanged(start, end, columnSelectMode);
   }
 

src/browser/services/SelectionService.test.ts

@@ -10,16 +10,18 @@ import { IBufferLine } from 'common/Types';
 import { MockBufferService, MockOptionsService, MockCoreService } from 'common/TestUtils.test';
 import { BufferLine } from 'common/buffer/BufferLine';
 import { IBufferService, IOptionsService } from 'common/services/Services';
-import { MockCharSizeService, MockMouseService } from 'browser/TestUtils.test';
+import { MockMouseService, MockRenderService } from 'browser/TestUtils.test';
 import { CellData } from 'common/buffer/CellData';
 import { IBuffer } from 'common/buffer/Types';
+import { IRenderService } from 'browser/services/Services';
 
 class TestSelectionService extends SelectionService {
   constructor(
     bufferService: IBufferService,
-    optionsService: IOptionsService
+    optionsService: IOptionsService,
+    renderService: IRenderService
   ) {
-    super(() => {}, null!, null!, new MockCharSizeService(10, 10), bufferService, new MockCoreService(), new MockMouseService(), optionsService);
+    super(null!, null!, bufferService, new MockCoreService(), new MockMouseService(), optionsService, renderService);
   }
 
   public get model(): SelectionModel { return this._model; }
@@ -46,7 +48,10 @@ describe('SelectionService', () => {
     optionsService = new MockOptionsService();
     bufferService = new MockBufferService(20, 20, optionsService);
     buffer = bufferService.buffer;
-    selectionService = new TestSelectionService(bufferService, optionsService);
+    const renderService = new MockRenderService();
+    renderService.dimensions.canvasHeight = 10 * 20;
+    renderService.dimensions.canvasWidth = 10 * 20;
+    selectionService = new TestSelectionService(bufferService, optionsService, renderService);
   });
 
   function stringToRow(text: string): IBufferLine {

src/browser/services/SelectionService.ts

@@ -3,17 +3,18 @@
  * @license MIT
  */
 
-import { ISelectionRedrawRequestEvent } from 'browser/selection/Types';
+import { ISelectionRedrawRequestEvent, ISelectionRequestScrollLinesEvent } from 'browser/selection/Types';
 import { IBuffer } from 'common/buffer/Types';
 import { IBufferLine, IDisposable } from 'common/Types';
 import * as Browser from 'common/Platform';
 import { SelectionModel } from 'browser/selection/SelectionModel';
 import { CellData } from 'common/buffer/CellData';
 import { EventEmitter, IEvent } from 'common/EventEmitter';
-import { ICharSizeService, IMouseService, ISelectionService } from 'browser/services/Services';
+import { ICharSizeService, IMouseService, ISelectionService, IRenderService } from 'browser/services/Services';
 import { IBufferService, IOptionsService, ICoreService } from 'common/services/Services';
 import { getCoordsRelativeToElement } from 'browser/input/Mouse';
 import { moveToCellSequence } from 'browser/input/MoveToCell';
+import { Disposable } from 'common/Lifecycle';
 
 /**
  * The number of pixels the mouse needs to be above or below the viewport in
@@ -66,8 +67,8 @@ export const enum SelectionMode {
  * not handled by the SelectionService but the onRedrawRequest event is fired
  * when the selection is ready to be redrawn (on an animation frame).
  */
-export class SelectionService implements ISelectionService {
-  serviceBrand: any;
+export class SelectionService extends Disposable implements ISelectionService {
+  public serviceBrand: undefined;
 
   protected _model: SelectionModel;
 
@@ -105,23 +106,26 @@ export class SelectionService implements ISelectionService {
 
   private _mouseDownTimeStamp: number = 0;
 
-  private _onLinuxMouseSelection = new EventEmitter<string>();
+  private _onLinuxMouseSelection = this.register(new EventEmitter<string>());
   public get onLinuxMouseSelection(): IEvent<string> { return this._onLinuxMouseSelection.event; }
-  private _onRedrawRequest = new EventEmitter<ISelectionRedrawRequestEvent>();
-  public get onRedrawRequest(): IEvent<ISelectionRedrawRequestEvent> { return this._onRedrawRequest.event; }
-  private _onSelectionChange = new EventEmitter<void>();
+  private _onRedrawRequest = this.register(new EventEmitter<ISelectionRedrawRequestEvent>());
+  public get onRequestRedraw(): IEvent<ISelectionRedrawRequestEvent> { return this._onRedrawRequest.event; }
+  private _onSelectionChange = this.register(new EventEmitter<void>());
   public get onSelectionChange(): IEvent<void> { return this._onSelectionChange.event; }
+  private _onRequestScrollLines = this.register(new EventEmitter<ISelectionRequestScrollLinesEvent>());
+  public get onRequestScrollLines(): IEvent<ISelectionRequestScrollLinesEvent> { return this._onRequestScrollLines.event; }
 
   constructor(
-    private readonly _scrollLines: (amount: number, suppressEvent: boolean) => void,
     private readonly _element: HTMLElement,
     private readonly _screenElement: HTMLElement,
-    @ICharSizeService private readonly _charSizeService: ICharSizeService,
     @IBufferService private readonly _bufferService: IBufferService,
     @ICoreService private readonly _coreService: ICoreService,
     @IMouseService private readonly _mouseService: IMouseService,
-    @IOptionsService private readonly _optionsService: IOptionsService
+    @IOptionsService private readonly _optionsService: IOptionsService,
+    @IRenderService private readonly _renderService: IRenderService
   ) {
+    super();
+
     // Init listeners
     this._mouseMoveListener = event => this._onMouseMove(<MouseEvent>event);
     this._mouseUpListener = event => this._onMouseUp(<MouseEvent>event);
@@ -131,7 +135,7 @@ export class SelectionService implements ISelectionService {
       }
     });
     this._trimListener = this._bufferService.buffer.lines.onTrim(amount => this._onTrim(amount));
-    this._bufferService.buffers.onBufferActivate(e => this._onBufferActivate(e));
+    this.register(this._bufferService.buffers.onBufferActivate(e => this._onBufferActivate(e)));
 
     this.enable();
 
@@ -374,7 +378,7 @@ export class SelectionService implements ISelectionService {
    */
   private _getMouseEventScrollAmount(event: MouseEvent): number {
     let offset = getCoordsRelativeToElement(event, this._screenElement)[1];
-    const terminalHeight = this._bufferService.rows * Math.ceil(this._charSizeService.height * this._optionsService.options.lineHeight);
+    const terminalHeight = this._renderService.dimensions.canvasHeight;
     if (offset >= 0 && offset <= terminalHeight) {
       return 0;
     }
@@ -633,7 +637,7 @@ export class SelectionService implements ISelectionService {
       return;
     }
     if (this._dragScrollAmount) {
-      this._scrollLines(this._dragScrollAmount, false);
+      this._onRequestScrollLines.fire({ amount: this._dragScrollAmount, suppressScrollEvent: false });
       // Re-evaluate selection
       // If the cursor was above or below the viewport, make sure it's at the
       // start or end of the viewport respectively. This should only happen when
@@ -663,8 +667,8 @@ export class SelectionService implements ISelectionService {
 
     this._removeMouseDownListeners();
 
-    if (this.selectionText.length <= 1 && timeElapsed < ALT_CLICK_MOVE_CURSOR_TIME) {
-      if (event.altKey && this._bufferService.buffer.ybase === this._bufferService.buffer.ydisp) {
+    if (this.selectionText.length <= 1 && timeElapsed < ALT_CLICK_MOVE_CURSOR_TIME && event.altKey) {
+      if (this._bufferService.buffer.ybase === this._bufferService.buffer.ydisp) {
         const coordinates = this._mouseService.getCoords(
           event,
           this._element,

src/browser/services/Services.ts

@@ -6,13 +6,13 @@
 import { IEvent } from 'common/EventEmitter';
 import { IRenderDimensions, IRenderer, CharacterJoinerHandler } from 'browser/renderer/Types';
 import { IColorSet } from 'browser/Types';
-import { ISelectionRedrawRequestEvent } from 'browser/selection/Types';
+import { ISelectionRedrawRequestEvent as ISelectionRequestRedrawEvent, ISelectionRequestScrollLinesEvent } from 'browser/selection/Types';
 import { createDecorator } from 'common/services/ServiceRegistry';
 import { IDisposable } from 'common/Types';
 
 export const ICharSizeService = createDecorator<ICharSizeService>('CharSizeService');
 export interface ICharSizeService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   readonly width: number;
   readonly height: number;
@@ -25,14 +25,14 @@ export interface ICharSizeService {
 
 export const ICoreBrowserService = createDecorator<ICoreBrowserService>('CoreBrowserService');
 export interface ICoreBrowserService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   readonly isFocused: boolean;
 }
 
 export const IMouseService = createDecorator<IMouseService>('MouseService');
 export interface IMouseService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   getCoords(event: {clientX: number, clientY: number}, element: HTMLElement, colCount: number, rowCount: number, isSelection?: boolean): [number, number] | undefined;
   getRawByteCoords(event: MouseEvent, element: HTMLElement, colCount: number, rowCount: number): { x: number, y: number } | undefined;
@@ -40,10 +40,14 @@ export interface IMouseService {
 
 export const IRenderService = createDecorator<IRenderService>('RenderService');
 export interface IRenderService extends IDisposable {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   onDimensionsChange: IEvent<IRenderDimensions>;
-  onRender: IEvent<{ start: number, end: number }>;
+  /**
+   * Fires when buffer changes are rendered. This does not fire when only cursor
+   * or selections are rendered.
+   */
+  onRenderedBufferChange: IEvent<{ start: number, end: number }>;
   onRefreshRequest: IEvent<{ start: number, end: number }>;
 
   dimensions: IRenderDimensions;
@@ -59,7 +63,7 @@ export interface IRenderService extends IDisposable {
   onCharSizeChanged(): void;
   onBlur(): void;
   onFocus(): void;
-  onSelectionChanged(start: [number, number], end: [number, number], columnSelectMode: boolean): void;
+  onSelectionChanged(start: [number, number] | undefined, end: [number, number] | undefined, columnSelectMode: boolean): void;
   onCursorMove(): void;
   clear(): void;
   registerCharacterJoiner(handler: CharacterJoinerHandler): number;
@@ -68,7 +72,7 @@ export interface IRenderService extends IDisposable {
 
 export const ISelectionService = createDecorator<ISelectionService>('SelectionService');
 export interface ISelectionService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   readonly selectionText: string;
   readonly hasSelection: boolean;
@@ -76,7 +80,8 @@ export interface ISelectionService {
   readonly selectionEnd: [number, number] | undefined;
 
   readonly onLinuxMouseSelection: IEvent<string>;
-  readonly onRedrawRequest: IEvent<ISelectionRedrawRequestEvent>;
+  readonly onRequestRedraw: IEvent<ISelectionRequestRedrawEvent>;
+  readonly onRequestScrollLines: IEvent<ISelectionRequestScrollLinesEvent>;
   readonly onSelectionChange: IEvent<void>;
 
   disable(): void;
@@ -96,7 +101,7 @@ export interface ISelectionService {
 
 export const ISoundService = createDecorator<ISoundService>('SoundService');
 export interface ISoundService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   playBellSound(): void;
 }

src/browser/services/SoundService.ts

@@ -7,11 +7,11 @@ import { IOptionsService } from 'common/services/Services';
 import { ISoundService } from 'browser/services/Services';
 
 export class SoundService implements ISoundService {
-  serviceBrand: any;
+  public serviceBrand: undefined;
 
   private static _audioContext: AudioContext;
 
-  static get audioContext(): AudioContext | null {
+  public static get audioContext(): AudioContext | null {
     if (!SoundService._audioContext) {
       const audioContextCtor: typeof AudioContext = (<any>window).AudioContext || (<any>window).webkitAudioContext;
       if (!audioContextCtor) {

src/browser/tsconfig.json

@@ -14,7 +14,10 @@
       "common/*": [ "./common/*" ]
     }
   },
-  "include": [ "./**/*" ],
+  "include": [
+    "./**/*",
+    "../../typings/xterm.d.ts"
+  ],
   "references": [
     { "path": "../common" }
   ]

src/common/CoreTerminal.ts

@@ -0,0 +1,338 @@
+/**
+ * Copyright (c) 2014-2020 The xterm.js authors. All rights reserved.
+ * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+ * @license MIT
+ *
+ * Originally forked from (with the author's permission):
+ *   Fabrice Bellard's javascript vt100 for jslinux:
+ *   http://bellard.org/jslinux/
+ *   Copyright (c) 2011 Fabrice Bellard
+ *   The original design remains. The terminal itself
+ *   has been extended to include xterm CSI codes, among
+ *   other features.
+ *
+ * Terminal Emulation References:
+ *   http://vt100.net/
+ *   http://invisible-island.net/xterm/ctlseqs/ctlseqs.txt
+ *   http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+ *   http://invisible-island.net/vttest/
+ *   http://www.inwap.com/pdp10/ansicode.txt
+ *   http://linux.die.net/man/4/console_codes
+ *   http://linux.die.net/man/7/urxvt
+ */
+
+import { Disposable } from 'common/Lifecycle';
+import { IInstantiationService, IOptionsService, IBufferService, ILogService, ICharsetService, ICoreService, ICoreMouseService, IUnicodeService, IDirtyRowService } from 'common/services/Services';
+import { InstantiationService } from 'common/services/InstantiationService';
+import { LogService } from 'common/services/LogService';
+import { BufferService, MINIMUM_COLS, MINIMUM_ROWS } from 'common/services/BufferService';
+import { OptionsService } from 'common/services/OptionsService';
+import { ITerminalOptions, IDisposable, IBufferLine, IAttributeData, ICoreTerminal } from 'common/Types';
+import { CoreService } from 'common/services/CoreService';
+import { EventEmitter, IEvent, forwardEvent } from 'common/EventEmitter';
+import { CoreMouseService } from 'common/services/CoreMouseService';
+import { DirtyRowService } from 'common/services/DirtyRowService';
+import { UnicodeService } from 'common/services/UnicodeService';
+import { CharsetService } from 'common/services/CharsetService';
+import { updateWindowsModeWrappedState } from 'common/WindowsMode';
+import { IFunctionIdentifier, IParams } from 'common/parser/Types';
+import { IBufferSet } from 'common/buffer/Types';
+import { InputHandler } from 'common/InputHandler';
+import { WriteBuffer } from 'common/input/WriteBuffer';
+
+export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
+  protected readonly _instantiationService: IInstantiationService;
+  protected readonly _bufferService: IBufferService;
+  protected readonly _logService: ILogService;
+  protected readonly _coreService: ICoreService;
+  protected readonly _charsetService: ICharsetService;
+  protected readonly _coreMouseService: ICoreMouseService;
+  protected readonly _dirtyRowService: IDirtyRowService;
+
+  public readonly unicodeService: IUnicodeService;
+  public readonly optionsService: IOptionsService;
+
+  protected _inputHandler: InputHandler;
+  private _writeBuffer: WriteBuffer;
+  private _windowsMode: IDisposable | undefined;
+  /** An IBufferline to clone/copy from for new blank lines */
+  private _cachedBlankLine: IBufferLine | undefined;
+
+  private _onBinary = new EventEmitter<string>();
+  public get onBinary(): IEvent<string> { return this._onBinary.event; }
+  private _onData = new EventEmitter<string>();
+  public get onData(): IEvent<string> { return this._onData.event; }
+  protected _onLineFeed = new EventEmitter<void>();
+  public get onLineFeed(): IEvent<void> { return this._onLineFeed.event; }
+  private _onResize = new EventEmitter<{ cols: number, rows: number }>();
+  public get onResize(): IEvent<{ cols: number, rows: number }> { return this._onResize.event; }
+  protected _onScroll = new EventEmitter<number>();
+  public get onScroll(): IEvent<number> { return this._onScroll.event; }
+
+  public get cols(): number { return this._bufferService.cols; }
+  public get rows(): number { return this._bufferService.rows; }
+  public get buffers(): IBufferSet { return this._bufferService.buffers; }
+
+  constructor(
+    options: ITerminalOptions
+  ) {
+    super();
+
+    // Setup and initialize services
+    this._instantiationService = new InstantiationService();
+    this.optionsService = new OptionsService(options);
+    this._instantiationService.setService(IOptionsService, this.optionsService);
+    this._bufferService = this.register(this._instantiationService.createInstance(BufferService));
+    this._instantiationService.setService(IBufferService, this._bufferService);
+    this._logService = this._instantiationService.createInstance(LogService);
+    this._instantiationService.setService(ILogService, this._logService);
+    this._coreService = this.register(this._instantiationService.createInstance(CoreService, () => this.scrollToBottom()));
+    this._instantiationService.setService(ICoreService, this._coreService);
+    this._coreMouseService = this._instantiationService.createInstance(CoreMouseService);
+    this._instantiationService.setService(ICoreMouseService, this._coreMouseService);
+    this._dirtyRowService = this._instantiationService.createInstance(DirtyRowService);
+    this._instantiationService.setService(IDirtyRowService, this._dirtyRowService);
+    this.unicodeService = this._instantiationService.createInstance(UnicodeService);
+    this._instantiationService.setService(IUnicodeService, this.unicodeService);
+    this._charsetService = this._instantiationService.createInstance(CharsetService);
+    this._instantiationService.setService(ICharsetService, this._charsetService);
+
+    // Register input handler and handle/forward events
+    this._inputHandler = new InputHandler(this._bufferService, this._charsetService, this._coreService, this._dirtyRowService, this._logService, this.optionsService, this._coreMouseService, this.unicodeService);
+    this.register(forwardEvent(this._inputHandler.onLineFeed, this._onLineFeed));
+    this.register(this._inputHandler);
+
+    // Setup listeners
+    this.register(forwardEvent(this._bufferService.onResize, this._onResize));
+    this.register(forwardEvent(this._coreService.onData, this._onData));
+    this.register(forwardEvent(this._coreService.onBinary, this._onBinary));
+    this.register(this.optionsService.onOptionChange(key => this._updateOptions(key)));
+
+    // Setup WriteBuffer
+    this._writeBuffer = new WriteBuffer(data => this._inputHandler.parse(data));
+  }
+
+  public dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    super.dispose();
+    this._windowsMode?.dispose();
+    this._windowsMode = undefined;
+  }
+
+  public write(data: string | Uint8Array, callback?: () => void): void {
+    this._writeBuffer.write(data, callback);
+  }
+
+  public writeSync(data: string | Uint8Array): void {
+    this._writeBuffer.writeSync(data);
+  }
+
+  public resize(x: number, y: number): void {
+    if (isNaN(x) || isNaN(y)) {
+      return;
+    }
+
+    x = Math.max(x, MINIMUM_COLS);
+    y = Math.max(y, MINIMUM_ROWS);
+
+    this._bufferService.resize(x, y);
+  }
+
+  /**
+   * Scroll the terminal down 1 row, creating a blank line.
+   * @param isWrapped Whether the new line is wrapped from the previous line.
+   */
+  public scroll(eraseAttr: IAttributeData, isWrapped: boolean = false): void {
+    const buffer = this._bufferService.buffer;
+
+    let newLine: IBufferLine | undefined;
+    newLine = this._cachedBlankLine;
+    if (!newLine || newLine.length !== this.cols || newLine.getFg(0) !== eraseAttr.fg || newLine.getBg(0) !== eraseAttr.bg) {
+      newLine = buffer.getBlankLine(eraseAttr, isWrapped);
+      this._cachedBlankLine = newLine;
+    }
+    newLine.isWrapped = isWrapped;
+
+    const topRow = buffer.ybase + buffer.scrollTop;
+    const bottomRow = buffer.ybase + buffer.scrollBottom;
+
+    if (buffer.scrollTop === 0) {
+      // Determine whether the buffer is going to be trimmed after insertion.
+      const willBufferBeTrimmed = buffer.lines.isFull;
+
+      // Insert the line using the fastest method
+      if (bottomRow === buffer.lines.length - 1) {
+        if (willBufferBeTrimmed) {
+          buffer.lines.recycle().copyFrom(newLine);
+        } else {
+          buffer.lines.push(newLine.clone());
+        }
+      } else {
+        buffer.lines.splice(bottomRow + 1, 0, newLine.clone());
+      }
+
+      // Only adjust ybase and ydisp when the buffer is not trimmed
+      if (!willBufferBeTrimmed) {
+        buffer.ybase++;
+        // Only scroll the ydisp with ybase if the user has not scrolled up
+        if (!this._bufferService.isUserScrolling) {
+          buffer.ydisp++;
+        }
+      } else {
+        // When the buffer is full and the user has scrolled up, keep the text
+        // stable unless ydisp is right at the top
+        if (this._bufferService.isUserScrolling) {
+          buffer.ydisp = Math.max(buffer.ydisp - 1, 0);
+        }
+      }
+    } else {
+      // scrollTop is non-zero which means no line will be going to the
+      // scrollback, instead we can just shift them in-place.
+      const scrollRegionHeight = bottomRow - topRow + 1 /* as it's zero-based */;
+      buffer.lines.shiftElements(topRow + 1, scrollRegionHeight - 1, -1);
+      buffer.lines.set(bottomRow, newLine.clone());
+    }
+
+    // Move the viewport to the bottom of the buffer unless the user is
+    // scrolling.
+    if (!this._bufferService.isUserScrolling) {
+      buffer.ydisp = buffer.ybase;
+    }
+
+    // Flag rows that need updating
+    this._dirtyRowService.markRangeDirty(buffer.scrollTop, buffer.scrollBottom);
+
+    this._onScroll.fire(buffer.ydisp);
+  }
+
+  /**
+   * Scroll the display of the terminal
+   * @param disp The number of lines to scroll down (negative scroll up).
+   * @param suppressScrollEvent Don't emit the scroll event as scrollLines. This is used
+   * to avoid unwanted events being handled by the viewport when the event was triggered from the
+   * viewport originally.
+   */
+  public scrollLines(disp: number, suppressScrollEvent?: boolean): void {
+    const buffer = this._bufferService.buffer;
+    if (disp < 0) {
+      if (buffer.ydisp === 0) {
+        return;
+      }
+      this._bufferService.isUserScrolling = true;
+    } else if (disp + buffer.ydisp >= buffer.ybase) {
+      this._bufferService.isUserScrolling = false;
+    }
+
+    const oldYdisp = buffer.ydisp;
+    buffer.ydisp = Math.max(Math.min(buffer.ydisp + disp, buffer.ybase), 0);
+
+    // No change occurred, don't trigger scroll/refresh
+    if (oldYdisp === buffer.ydisp) {
+      return;
+    }
+
+    if (!suppressScrollEvent) {
+      this._onScroll.fire(buffer.ydisp);
+    }
+  }
+
+  /**
+   * Scroll the display of the terminal by a number of pages.
+   * @param pageCount The number of pages to scroll (negative scrolls up).
+   */
+  public scrollPages(pageCount: number): void {
+    this.scrollLines(pageCount * (this.rows - 1));
+  }
+
+  /**
+   * Scrolls the display of the terminal to the top.
+   */
+  public scrollToTop(): void {
+    this.scrollLines(-this._bufferService.buffer.ydisp);
+  }
+
+  /**
+   * Scrolls the display of the terminal to the bottom.
+   */
+  public scrollToBottom(): void {
+    this.scrollLines(this._bufferService.buffer.ybase - this._bufferService.buffer.ydisp);
+  }
+
+  public scrollToLine(line: number): void {
+    const scrollAmount = line - this._bufferService.buffer.ydisp;
+    if (scrollAmount !== 0) {
+      this.scrollLines(scrollAmount);
+    }
+  }
+
+  /** Add handler for ESC escape sequence. See xterm.d.ts for details. */
+  public addEscHandler(id: IFunctionIdentifier, callback: () => boolean): IDisposable {
+    return this._inputHandler.addEscHandler(id, callback);
+  }
+
+  /** Add handler for DCS escape sequence. See xterm.d.ts for details. */
+  public addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable {
+    return this._inputHandler.addDcsHandler(id, callback);
+  }
+
+  /** Add handler for CSI escape sequence. See xterm.d.ts for details. */
+  public addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable {
+    return this._inputHandler.addCsiHandler(id, callback);
+  }
+
+  /** Add handler for OSC escape sequence. See xterm.d.ts for details. */
+  public addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
+    return this._inputHandler.addOscHandler(ident, callback);
+  }
+
+  protected _setup(): void {
+    if (this.optionsService.options.windowsMode) {
+      this._enableWindowsMode();
+    }
+  }
+
+  public reset(): void {
+    this._inputHandler.reset();
+    this._bufferService.reset();
+    this._charsetService.reset();
+    this._coreService.reset();
+    this._coreMouseService.reset();
+  }
+
+  protected _updateOptions(key: string): void {
+    // TODO: These listeners should be owned by individual components
+    switch (key) {
+      case 'scrollback':
+        this.buffers.resize(this.cols, this.rows);
+        break;
+      case 'windowsMode':
+        if (this.optionsService.options.windowsMode) {
+          this._enableWindowsMode();
+        } else {
+          this._windowsMode?.dispose();
+          this._windowsMode = undefined;
+        }
+        break;
+    }
+  }
+
+  protected _enableWindowsMode(): void {
+    if (!this._windowsMode) {
+      const disposables: IDisposable[] = [];
+      disposables.push(this.onLineFeed(updateWindowsModeWrappedState.bind(null, this._bufferService)));
+      disposables.push(this.addCsiHandler({ final: 'H' }, () => {
+        updateWindowsModeWrappedState(this._bufferService);
+        return false;
+      }));
+      this._windowsMode = {
+        dispose: () => {
+          for (const d of disposables) {
+            d.dispose();
+          }
+        }
+      };
+    }
+  }
+}

src/common/EventEmitter.ts

@@ -63,3 +63,7 @@ export class EventEmitter<T, U = void> implements IEventEmitter<T, U> {
     this._disposed = true;
   }
 }
+
+export function forwardEvent<T>(from: IEvent<T>, to: IEventEmitter<T>): IDisposable {
+  return from(e => to.fire(e));
+}