Merge pull request #3237 from Tyriar/r4_10

v4.10.0
2021-01-29 09:25:08 -08:00 · 2021-01-29 09:14:31 -08:00 · 2021-01-23 19:07:26 +01:00 · 2021-01-23 19:00:39 +01:00 · 2021-01-23 09:12:47 -08:00 · 2021-01-23 17:09:43 +01:00
200 changed files with 9800 additions and 7272 deletions
@@ -1,16 +0,0 @@
-node_modules/
-*.swp
-.lock-wscript
-lib/
-Makefile.gyp
-*.Makefile
-*.target.gyp.mk
-*.node
-example/*.log
-docs/
-npm-debug.log
-/.idea/
-.env
-build/
-.vscode/
-.git/
@@ -9,52 +9,66 @@
    "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",
+      "addons/xterm-addon-attach/test/tsconfig.json",
      "addons/xterm-addon-fit/src/tsconfig.json",
+      "addons/xterm-addon-fit/test/tsconfig.json",
+      "addons/xterm-addon-ligatures/src/tsconfig.json",
      "addons/xterm-addon-search/src/tsconfig.json",
-      "addons/xterm-addon-unicode11/src/tsconfig.json",
-      "addons/xterm-addon-web-links/src/tsconfig.json",
-      "addons/xterm-addon-webgl/src/tsconfig.json",
+      "addons/xterm-addon-search/test/tsconfig.json",
      "addons/xterm-addon-serialize/src/tsconfig.json",
-      "addons/xterm-addon-serialize/benchmark/tsconfig.json"
+      "addons/xterm-addon-serialize/test/tsconfig.json",
+      "addons/xterm-addon-serialize/benchmark/tsconfig.json",
+      "addons/xterm-addon-unicode11/src/tsconfig.json",
+      "addons/xterm-addon-unicode11/test/tsconfig.json",
+      "addons/xterm-addon-web-links/src/tsconfig.json",
+      "addons/xterm-addon-web-links/test/tsconfig.json",
+      "addons/xterm-addon-webgl/src/tsconfig.json",
+      "addons/xterm-addon-webgl/test/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/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",
-      "always"
-    ],
    "@typescript-eslint/member-delimiter-style": [
-      "error",
+      "warn",
      {
        "multiline": {
          "delimiter": "semi",
@@ -67,7 +81,7 @@
      }
    ],
    "@typescript-eslint/naming-convention": [
-      "error",
+      "warn",
      { "selector": "default", "format": ["camelCase"] },
      // variableLike
      { "selector": "variable", "format": ["camelCase", "UPPER_CASE"] },
@@ -83,19 +97,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 +117,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": ["/"],
@@ -1,19 +0,0 @@
-FROM node:8
-MAINTAINER Paris Kasidiaris <paris@sourcelair.com>
-
-# Set the working directory
-WORKDIR /usr/src/app
-
-# Set an entrypoint, to automatically install node modules
-ENTRYPOINT ["/bin/bash", "-c", "if [[ ! -d node_modules ]]; then npm install; fi; exec \"${@:0}\";"]
-CMD ["npm", "run", "start"]
-
-# First, install dependencies to improve layer caching
-COPY package.json /usr/src/app/
-RUN npm install
-
-# Add the code
-COPY . /usr/src/app
-
-# Run the tests and build, to make sure everything is working nicely
-RUN npm run build && npm run test
@@ -87,7 +87,7 @@ The xterm.js team maintains the following addons but they can be built by anyone

 Since xterm.js is typically implemented as a developer tool, only modern browsers are supported officially. Specifically the latest versions of *Chrome*, *Edge*, *Firefox* and *Safari*.

-We also partially support *Intenet Explorer 11*, meaning xterm.js should work for the most part, but we reserve the right to not provide workarounds specifically for it unless it's absolutely necessary to get the basic input/output flow working.
+We also partially support *Internet Explorer 11*, meaning xterm.js should work for the most part, but we reserve the right to not provide workarounds specifically for it unless it's absolutely necessary to get the basic input/output flow working.

 Xterm.js works seamlessly in [Electron](https://electronjs.org/) apps and may even work on earlier versions of the browsers, these are the versions we strive to keep working.

@@ -161,7 +161,16 @@ 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
+- [**Repl.it**](https://repl.it): Collaborative browser based IDE with support for 50+ different languages.
+- [**TeleType**](https://github.com/akshaykmr/TeleType): cli tool that allows you to share your terminal online conveniently. Show off mad cli-fu, help a colleague, teach, or troubleshoot.
+- [**Intervue**](https://www.intervue.io): Pair programming for interviews. Multiple programming languages supported, with results displayed by xterm.js.
+- [**TRASA**](https://trasa.io): Zero trust access to Web, SSH, RDP and Database services.  
+- [**Commas**](https://github.com/CyanSalt/commas): Commas is a hackable terminal and command runner.
+- [**Devtron**](https://github.com/devtron-labs/devtron): Software Delivery Workflow For Kubernetes. 
 [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.
@@ -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/"
@@ -10,7 +10,7 @@
  "repository": "https://github.com/xtermjs/xterm.js",
  "license": "MIT",
  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p src",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package"
@@ -12,8 +12,7 @@
    "removeComments": true,
    "strict": true,
    "types": [
-      "../../../node_modules/@types/mocha",
-      "../../../out-test/api/TestUtils"
+      "../../../node_modules/@types/mocha"
    ]
  },
  "include": [
@@ -5,7 +5,7 @@

 import WebSocket = require('ws');
 import { openTerminal, pollFor, getBrowserType } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright-core';
+import { Browser, Page } from 'playwright';

 const APP = 'http://127.0.0.1:3000/test';

@@ -17,7 +17,7 @@ const height = 600;
 describe('AttachAddon', () => {
  before(async function(): Promise<any> {
    const browserType = getBrowserType();
-    browser = await browserType.launch({ dumpio: true,
+    browser = await browserType.launch({
      headless: process.argv.indexOf('--headless') !== -1
    });
    page = await (await browser.newContext()).newPage();
@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [
+      "es2015"
+    ],
+    "rootDir": ".",
+    "outDir": "../out-test",
+    "sourceMap": true,
+    "removeComments": true,
+    "strict": true,
+    "types": [
+      "../../../node_modules/@types/mocha",
+      "../../../node_modules/@types/node",
+      "../../../out-test/api/TestUtils"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ]
+}
@@ -0,0 +1,8 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" },
+    { "path": "./test" }
+  ]
+}
@@ -1,6 +1,6 @@
 {
  "name": "xterm-addon-fit",
-  "version": "0.3.0",
+  "version": "0.5.0",
  "author": {
    "name": "The xterm.js authors",
    "url": "https://xtermjs.org/"
@@ -10,7 +10,7 @@
  "repository": "https://github.com/xtermjs/xterm.js",
  "license": "MIT",
  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p src",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package"
@@ -59,6 +59,10 @@ export class FitAddon implements ITerminalAddon {
    // TODO: Remove reliance on private API
    const core = (this._terminal as any)._core;

+    if (core._renderService.dimensions.actualCellWidth === 0 || core._renderService.dimensions.actualCellHeight === 0) {
+      return undefined;
+    }
+
    const parentElementStyle = window.getComputedStyle(this._terminal.element.parentElement);
    const parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height'));
    const parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')));
@@ -12,8 +12,7 @@
    "removeComments": true,
    "strict": true,
    "types": [
-      "../../../node_modules/@types/mocha",
-      "../../../out-test/api/TestUtils"
+      "../../../node_modules/@types/mocha"
    ]
  },
  "include": [
@@ -5,7 +5,7 @@

 import { assert } from 'chai';
 import { openTerminal, getBrowserType } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright-core';
+import { Browser, Page } from 'playwright';

 const APP = 'http://127.0.0.1:3000/test';

@@ -17,12 +17,16 @@ const height = 768;
 describe('FitAddon', () => {
  before(async function(): Promise<any> {
    const browserType = getBrowserType();
-    browser = await browserType.launch({ dumpio: true,
+    browser = await browserType.launch({
      headless: process.argv.indexOf('--headless') !== -1
    });
    page = await (await browser.newContext()).newPage();
    await page.setViewportSize({ width, height });
    await page.goto(APP);
+  });
+
+  beforeEach(async function(): Promise<any> {
+    await page.evaluate(`document.querySelector('#terminal-container').style.display=''`);
    await openTerminal(page);
  });

@@ -30,6 +34,10 @@ describe('FitAddon', () => {
    await browser.close();
  });

+  afterEach(async function(): Promise<any> {
+    await page.evaluate(`window.term.dispose()`);
+  });
+
  it('no terminal', async function(): Promise<any> {
    await page.evaluate(`window.fit = new FitAddon();`);
    assert.equal(await page.evaluate(`window.fit.proposeDimensions()`), undefined);
@@ -63,6 +71,15 @@ describe('FitAddon', () => {
        rows: 1
      });
    });
+
+    it('hidden', async function(): Promise<any> {
+      await page.evaluate(`window.term.dispose()`);
+      await page.evaluate(`document.querySelector('#terminal-container').style.display='none'`);
+      await page.evaluate(`window.term = new Terminal()`);
+      await page.evaluate(`window.term.open(document.querySelector('#terminal-container'))`);
+      await loadFit();
+      assert.equal(await page.evaluate(`window.fit.proposeDimensions()`), undefined);
+    });
  });

  describe('fit', () => {
@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [
+      "es2015"
+    ],
+    "rootDir": ".",
+    "outDir": "../out-test",
+    "sourceMap": true,
+    "removeComments": true,
+    "strict": true,
+    "types": [
+      "../../../node_modules/@types/mocha",
+      "../../../node_modules/@types/node",
+      "../../../out-test/api/TestUtils"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ]
+}
@@ -0,0 +1,8 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" },
+    { "path": "./test" }
+  ]
+}
@@ -0,0 +1,13 @@
+node_modules/
+.nyc_output/
+coverage/
+
+lib/
+fonts/
+
+.env
+.vscode/
+*.swp
+*.tgz
+npm-debug.log*
+yarn-error.log*
@@ -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
@@ -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.
@@ -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
@@ -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);
+});
@@ -0,0 +1,47 @@
+{
+  "name": "xterm-addon-ligatures",
+  "version": "0.4.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.1.0",
+    "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"
+  }
+}
@@ -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 {}
+}
+
@@ -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'
+];
@@ -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));
+}
@@ -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 [];
+  });
+}
@@ -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']);
+  });
+});
@@ -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));
+}
@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "commonjs",
+    "sourceMap": true,
+    "outDir": "../out",
+    "rootDir": ".",
+    "strict": true,
+    "noUnusedLocals": true,
+    "preserveWatchOutput": true,
+    "types": [
+      "../../../node_modules/@types/mocha"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ]
+}
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" }
+  ]
+}
@@ -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;
+  }
+}
@@ -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'
+  }
+};
@@ -0,0 +1,244 @@
+# 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:
+  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-finder@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/font-finder/-/font-finder-1.1.0.tgz#2bff2b2762acba720239c8bec898a96daae90858"
+  integrity sha512-wpCL2uIbi6GurJbU7ZlQ3nGd61Ho+dSU6U83/xJT5UPFfN35EeCW/rOtS+5k+IuEZu2SYmHzDIPL9eA5tSYRAw==
+  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"
@@ -1,6 +1,6 @@
 {
  "name": "xterm-addon-search",
-  "version": "0.6.0",
+  "version": "0.8.0",
  "author": {
    "name": "The xterm.js authors",
    "url": "https://xtermjs.org/"
@@ -10,7 +10,7 @@
  "repository": "https://github.com/xtermjs/xterm.js",
  "license": "MIT",
  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p src",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package"
@@ -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);
@@ -154,8 +158,15 @@ export class SearchAddon implements ITerminalAddon {
    };

    if (incremental) {
+      // Try to expand selection to right first.
      result = this._findInLine(term, searchPosition, searchOptions, false);
-      if (!(result && result.row === startRow && result.col === startCol)) {
+      const isOldResultHighlighted = result && result.row === startRow && result.col === startCol;
+      if (!isOldResultHighlighted) {
+        // If selection was not able to be expanded to the right, then try reverse search
+        if (currentSelection) {
+          searchPosition.startRow = currentSelection.endRow;
+          searchPosition.startCol = currentSelection.endColumn;
+        }
        result = this._findInLine(term, searchPosition, searchOptions, true);
      }
    } else {
@@ -175,7 +186,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) {
@@ -241,6 +252,7 @@ export class SearchAddon implements ITerminalAddon {
   * @param term The search term.
   * @param position The position to start the search.
   * @param searchOptions Search options.
+   * @param isReverseSearch Whether the search should start from the right side of the terminal and search to the left.
   * @return The search result if it was found.
   */
  protected _findInLine(term: string, searchPosition: ISearchPosition, searchOptions: ISearchOptions = {}, isReverseSearch: boolean = false): ISearchResult | undefined {
@@ -12,8 +12,7 @@
    "removeComments": true,
    "strict": true,
    "types": [
-      "../../../node_modules/@types/mocha",
-      "../../../out-test/api/TestUtils"
+      "../../../node_modules/@types/mocha"
    ]
  },
  "include": [
@@ -7,7 +7,7 @@ import { assert } from 'chai';
 import { readFile } from 'fs';
 import { resolve } from 'path';
 import { openTerminal, writeSync, getBrowserType } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright-core';
+import { Browser, Page } from 'playwright';

 const APP = 'http://127.0.0.1:3000/test';

@@ -19,7 +19,7 @@ const height = 600;
 describe('Search Tests', function(): void {
  before(async function(): Promise<any> {
    const browserType = getBrowserType();
-    browser = await browserType.launch({ dumpio: true,
+    browser = await browserType.launch({
      headless: process.argv.indexOf('--headless') !== -1
    });
    page = await (await browser.newContext()).newPage();
@@ -111,8 +111,15 @@ describe('Search Tests', function(): void {
      let fixture: string;
      before(async () => {
        const rawFixture = await new Promise<Buffer>(r => readFile(resolve(__dirname, '../fixtures/issue-2444'), (err, data) => r(data)));
-        fixture = rawFixture.toString()
-          .replace(/\n/g, '\\n\\r')
+        if (process.platform === 'win32') {
+          fixture = rawFixture.toString()
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r');
+        } else {
+          fixture = rawFixture.toString()
+            .replace(/\n/g, '\\n\\r');
+        }
+        fixture = fixture
          .replace(/'/g, '\\\'');
      });
      it('should find all occurrences using findNext', async () => {
@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [
+      "es6",
+    ],
+    "rootDir": ".",
+    "outDir": "../out-test",
+    "sourceMap": true,
+    "removeComments": true,
+    "strict": true,
+    "types": [
+      "../../../node_modules/@types/mocha",
+      "../../../node_modules/@types/node",
+      "../../../out-test/api/TestUtils"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ]
+}
@@ -0,0 +1,8 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" },
+    { "path": "./test" }
+  ]
+}
@@ -7,21 +7,21 @@ 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);
  }
 }

-perfContext('Terminal: sh -c "dd if=/dev/random count=40 bs=1k | hexdump | lolcat -f"', () => {
+perfContext('Terminal: sh -c "dd if=/dev/urandom count=40 bs=1k | hexdump | lolcat -f"', () => {
  let content = '';
  let contentUtf8: Uint8Array;

  before(async () => {
-    const p = spawn('sh', ['-c', 'dd if=/dev/random count=40 bs=1k | hexdump | lolcat -f'], {
+    const p = spawn('sh', ['-c', 'dd if=/dev/urandom count=40 bs=1k | hexdump | lolcat -f'], {
      name: 'xterm-256color',
      cols: 80,
      rows: 25,
@@ -11,8 +11,6 @@
    "paths": {
      "common/*": ["../../../src/common/*"],
      "browser/*": ["../../../src/browser/*"],
-      "public/*": ["../../../src/public/*"],
-      "Terminal": ["../../../src/Terminal"],
      "SerializeAddon": ["../src/SerializeAddon"]
    }
  },
@@ -1,6 +1,6 @@
 {
  "name": "xterm-addon-serialize",
-  "version": "0.2.0",
+  "version": "0.4.0",
  "author": {
    "name": "The xterm.js authors",
    "url": "https://xtermjs.org/"
@@ -9,13 +9,13 @@
  "types": "typings/xterm-addon-serialize.d.ts",
  "license": "MIT",
  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p src",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package",
    "benchmark": "NODE_PATH=../../out:./out:./out-benchmark/ ../../node_modules/.bin/xterm-benchmark -r 5 -c benchmark/benchmark.json",
-    "benchmark-baseline": "NODE_PATH=../../out:./out:./out-benchmark/ ../../node_modules/.bin/xterm-benchmark -r 5 -c benchmark/benchmark.json --baseline out-benchmark/addons/xterm-addon-serialize/benchmark/*benchmark.js",
-    "benchmark-eval": "NODE_PATH=../../out:./out:./out-benchmark/ ../../node_modules/.bin/xterm-benchmark -r 5 -c benchmark/benchmark.json --eval out-benchmark/addons/xterm-addon-serialize/benchmark/*benchmark.js"
+    "benchmark-baseline": "NODE_PATH=../../out:./out:./out-benchmark/ ../../node_modules/.bin/xterm-benchmark -r 5 -c benchmark/benchmark.json --baseline out-benchmark/benchmark/*benchmark.js",
+    "benchmark-eval": "NODE_PATH=../../out:./out:./out-benchmark/ ../../node_modules/.bin/xterm-benchmark -r 5 -c benchmark/benchmark.json --eval out-benchmark/benchmark/*benchmark.js"
  },
  "peerDependencies": {
    "xterm": "^4.0.0"
@@ -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();
@@ -138,7 +138,7 @@ class StringSerializeHandler extends BaseSerializeHandler {
    // Count number of null cells encountered after the last non-null cell and move the cursor
    // if a non-null cell is found (eg. \t or cursor move)
    if (cell.getChars() === '') {
-      this._nullCellCount++;
+      this._nullCellCount += cell.getWidth();
    } else if (this._nullCellCount > 0) {
      this._currentRow += `\x1b[${this._nullCellCount}C`;
      this._nullCellCount = 0;
@@ -18,8 +18,7 @@
    },
    "strict": true,
    "types": [
-      "../../../node_modules/@types/mocha",
-      "../../../out-test/api/TestUtils"
+      "../../../node_modules/@types/mocha"
    ]
  },
  "include": [
@@ -5,7 +5,7 @@

 import { assert } from 'chai';
 import { openTerminal, writeSync, getBrowserType } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright-core';
+import { Browser, Page } from 'playwright';

 const APP = 'http://127.0.0.1:3000/test';

@@ -17,7 +17,7 @@ const height = 600;
 describe('SerializeAddon', () => {
  before(async function(): Promise<any> {
    const browserType = getBrowserType();
-    browser = await browserType.launch({ dumpio: true,
+    browser = await browserType.launch({
      headless: process.argv.indexOf('--headless') !== -1
    });
    page = await (await browser.newContext()).newPage();
@@ -270,6 +270,35 @@ describe('SerializeAddon', () => {
    await writeSync(page, lines.join('\\r\\n'));
    assert.equal(await page.evaluate(`serializeAddon.serialize();`), expected.join('\r\n'));
  });
+
+  it('serialize CJK correctly', async () => {
+    const lines = [
+      '中文中文',
+      '12中文',
+      '中文12',
+      '1中文中文中' // this line is going to be wrapped at last character because it has line length of 11 (1+2*5)
+    ];
+    const expected = [
+      '中文中文',
+      '12中文',
+      '中文12',
+      '1中文中文',
+      '中'
+    ];
+    await writeSync(page, lines.join('\\r\\n'));
+    assert.equal(await page.evaluate(`serializeAddon.serialize();`), expected.join('\r\n'));
+  });
+
+  it('serialize CJK Mixed with tab correctly', async () => {
+    const lines = [
+      '中文\t12' // CJK mixed with tab
+    ];
+    const expected = [
+      '中文\x1b[4C12'
+    ];
+    await writeSync(page, lines.join('\\r\\n'));
+    assert.equal(await page.evaluate(`serializeAddon.serialize();`), expected.join('\r\n'));
+  });
 });

 function newArray<T>(initial: T | ((index: number) => T), count: number): T[] {
@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [
+      "es2015"
+    ],
+    "rootDir": ".",
+    "outDir": "../out-test",
+    "sourceMap": true,
+    "removeComments": true,
+    "baseUrl": ".",
+    "paths": {
+      "common/*": [
+        "../../../src/common/*"
+      ]
+    },
+    "strict": true,
+    "types": [
+      "../../../node_modules/@types/mocha",
+      "../../../node_modules/@types/node",
+      "../../../out-test/api/TestUtils"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ],
+  "references": [
+    {
+      "path": "../../../src/common"
+    }
+  ]
+}
@@ -0,0 +1,9 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" },
+    { "path": "./test" },
+    { "path": "./benchmark" }
+  ]
+}
@@ -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/"
@@ -10,7 +10,7 @@
  "repository": "https://github.com/xtermjs/xterm.js",
  "license": "MIT",
  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p src",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package"
@@ -18,8 +18,7 @@
      ]
    },
    "types": [
-      "../../../node_modules/@types/mocha",
-      "../../../out-test/api/TestUtils"
+      "../../../node_modules/@types/mocha"
    ]
  },
  "include": [
@@ -5,7 +5,7 @@

 import { assert } from 'chai';
 import { openTerminal, getBrowserType } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright-core';
+import { Browser, Page } from 'playwright';

 const APP = 'http://127.0.0.1:3000/test';

@@ -17,7 +17,7 @@ const height = 600;
 describe('Unicode11Addon', () => {
  before(async function(): Promise<any> {
    const browserType = getBrowserType();
-    browser = await browserType.launch({ dumpio: true,
+    browser = await browserType.launch({
      headless: process.argv.indexOf('--headless') !== -1
    });
    page = await (await browser.newContext()).newPage();
@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2015",
+    "lib": [
+      "dom",
+      "es2015"
+    ],
+    "rootDir": ".",
+    "outDir": "../out-test",
+    "sourceMap": true,
+    "removeComments": true,
+    "strict": true,
+    "baseUrl": ".",
+    "paths": {
+      "common/*": [
+        "../../../src/common/*"
+      ]
+    },
+    "types": [
+      "../../../node_modules/@types/mocha",
+      "../../../node_modules/@types/node",
+      "../../../out-test/api/TestUtils"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ],
+  "references": [
+    {
+      "path": "../../../src/common"
+    }
+  ]
+}
@@ -0,0 +1,8 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" },
+    { "path": "./test" }
+  ]
+}
@@ -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/"
@@ -10,7 +10,7 @@
  "repository": "https://github.com/xtermjs/xterm.js",
  "license": "MIT",
  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p src",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package"
@@ -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;
  }

  /**
@@ -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 + ')?';
@@ -12,8 +12,7 @@
    "removeComments": true,
    "strict": true,
    "types": [
-      "../../../node_modules/@types/mocha",
-      "../../../out-test/api/TestUtils"
+      "../../../node_modules/@types/mocha"
    ]
  },
  "include": [
@@ -5,7 +5,7 @@

 import { assert } from 'chai';
 import { openTerminal, pollFor, writeSync, getBrowserType } from '../../../out-test/api/TestUtils';
-import { Browser, Page } from 'playwright-core';
+import { Browser, Page } from 'playwright';

 const APP = 'http://127.0.0.1:3000/test';

@@ -17,7 +17,7 @@ const height = 600;
 describe('WebLinksAddon', () => {
  before(async function(): Promise<any> {
    const browserType = getBrowserType();
-    browser = await browserType.launch({ dumpio: true,
+    browser = await browserType.launch({
      headless: process.argv.indexOf('--headless') !== -1
    });
    page = await (await browser.newContext()).newPage();
@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [
+      "es2015"
+    ],
+    "rootDir": ".",
+    "outDir": "../out-test",
+    "sourceMap": true,
+    "removeComments": true,
+    "strict": true,
+    "types": [
+      "../../../node_modules/@types/mocha",
+      "../../../node_modules/@types/node",
+      "../../../out-test/api/TestUtils"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ]
+}
@@ -0,0 +1,8 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" },
+    { "path": "./test" }
+  ]
+}
@@ -3,3 +3,5 @@
 tsconfig.json
 .yarnrc
 webpack.config.js
+out-test/
+test/
@@ -1,6 +1,6 @@
 {
  "name": "xterm-addon-webgl",
-  "version": "0.6.0",
+  "version": "0.9.0",
  "author": {
    "name": "The xterm.js authors",
    "url": "https://xtermjs.org/"
@@ -10,7 +10,7 @@
  "repository": "https://github.com/xtermjs/xterm.js",
  "license": "MIT",
  "scripts": {
-    "build": "../../node_modules/.bin/tsc -p src",
+    "build": "../../node_modules/.bin/tsc -p .",
    "prepackage": "npm run build",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package"
@@ -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;
@@ -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;
@@ -196,7 +196,7 @@ export class RectangleRenderer {
    } else {
      // Draw first row
      const startCol = model.viewportStartRow === model.viewportCappedStartRow ? model.startCol : 0;
-      const startRowEndCol = model.viewportCappedStartRow === model.viewportCappedEndRow ? model.endCol : terminal.cols;
+      const startRowEndCol = model.viewportCappedStartRow === model.viewportEndRow ? model.endCol : terminal.cols;
      this._addRectangleFloat(
        this._vertices.selection,
        0,
@@ -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,
@@ -42,7 +43,6 @@ export class RenderModel implements IRenderModel {
  public clear(): void {
    fill(this.cells, 0, 0);
    fill(this.lineLengths, 0, 0);
-    this.clearSelection();
  }

  public clearSelection(): void {
@@ -56,6 +56,7 @@ export interface IRenderModel {

 export interface ISelectionRenderModel {
  hasSelection: boolean;
+  columnSelectMode: boolean;
  viewportStartRow: number;
  viewportEndRow: number;
  viewportCappedStartRow: number;
@@ -40,4 +40,8 @@ export class WebglAddon implements ITerminalAddon {
  public get textureAtlas(): HTMLCanvasElement | undefined {
    return this._renderer?.textureAtlas;
  }
+
+  public clearTextureAtlas(): void {
+    this._renderer?.clearCharAtlas();
+  }
 }
@@ -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,8 +116,12 @@ 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();
+    this._model.clearSelection();
  }

  public onDevicePixelRatioChange(): void {
@@ -147,8 +150,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();

@@ -156,6 +159,7 @@ export class WebglRenderer extends Disposable implements IRenderer {

    // Force a full refresh
    this._model.clear();
+    this._model.clearSelection();
  }

  public onCharSizeChanged(): void {
@@ -170,15 +174,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 {
@@ -212,6 +216,14 @@ export class WebglRenderer extends Disposable implements IRenderer {
    this._glyphRenderer.setAtlas(this._charAtlas);
  }

+  public clearCharAtlas(): void {
+    this._charAtlas?.clearTexture();
+    this._model.clear();
+    this._updateModel(0, this._terminal.rows - 1);
+    this._glyphRenderer.updateSelection(this._model);
+    this._onRequestRedraw.fire({ start: 0, end: this._terminal.rows - 1 });
+  }
+
  public clear(): void {
    this._renderLayers.forEach(l => l.reset(this._terminal));
  }
@@ -226,7 +238,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;
@@ -241,6 +253,7 @@ export class WebglRenderer extends Disposable implements IRenderer {
    // Tell renderer the frame is beginning
    if (this._glyphRenderer.beginFrame()) {
      this._model.clear();
+      this._model.clearSelection();
    }

    // Update model to reflect what's drawn
@@ -292,7 +305,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 +327,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;
@@ -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.
@@ -101,7 +101,7 @@ export class WebglCharAtlas implements IDisposable {
    }
  }

-  protected _doWarmUp(): void {
+  private _doWarmUp(): void {
    // Pre-fill with ASCII 33-126
    for (let i = 33; i < 126; i++) {
      const rasterizedGlyph = this._drawToCache(i, DEFAULT_COLOR, DEFAULT_COLOR);
@@ -115,17 +115,26 @@ export class WebglCharAtlas implements IDisposable {

  public beginFrame(): boolean {
    if (this._currentRowY > TEXTURE_CAPACITY) {
-      this._cacheCtx.clearRect(0, 0, TEXTURE_WIDTH, TEXTURE_HEIGHT);
-      this._cacheMap = {};
-      this._currentRowHeight = 0;
-      this._currentRowX = 0;
-      this._currentRowY = 0;
-      this._doWarmUp();
+      this.clearTexture();
+      this.warmUp();
      return true;
    }
    return false;
  }

+  public clearTexture(): void {
+    if (this._currentRowX === 0 && this._currentRowY === 0) {
+      return;
+    }
+    this._cacheCtx.clearRect(0, 0, TEXTURE_WIDTH, TEXTURE_HEIGHT);
+    this._cacheMap = {};
+    this._cacheMapCombined = {};
+    this._currentRowHeight = 0;
+    this._currentRowX = 0;
+    this._currentRowY = 0;
+    this._didWarmUp = false;
+  }
+
  public getRasterizedGlyphCombinedChar(chars: string, bg: number, fg: number): IRasterizedGlyph {
    let rasterizedGlyphSet = this._cacheMapCombined[chars];
    if (!rasterizedGlyphSet) {
@@ -349,7 +358,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 +368,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
@@ -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);
@@ -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 = {
@@ -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();
  }
 }
@@ -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
@@ -21,8 +21,7 @@
    },
    "strict": true,
    "types": [
-      "../../../node_modules/@types/mocha",
-      "../../../out-test/api/TestUtils"
+      "../../../node_modules/@types/mocha"
    ]
  },
  "include": [
@@ -3,11 +3,11 @@
 * @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';
-import { Browser, Page } from 'playwright-core';
+import { Browser, Page } from 'playwright';

 const APP = 'http://127.0.0.1:3000/test';

@@ -16,14 +16,12 @@ let page: Page;
 const width = 800;
 const height = 600;

-let itWebgl: (expectation: string, callback?: (this: Mocha.ITestCallbackContext, done: MochaDone) => any) => Mocha.ITest | void;
-
 describe('WebGL Renderer Integration Tests', async () => {
  const browserType = getBrowserType();
  const isHeadless = process.argv.indexOf('--headless') !== -1;
  // Firefox works only in non-headless mode https://github.com/microsoft/playwright/issues/1032
  const areTestsEnabled = browserType.name() === 'chromium' || (browserType.name() === 'firefox' && !isHeadless);
-  itWebgl = areTestsEnabled ? it : it.skip;
+  const itWebgl = areTestsEnabled ? it : it.skip;

  itWebgl('dispose removes renderer canvases', async function(): Promise<void> {
    await setupBrowser();
@@ -341,10 +339,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 +664,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]);
        }
      }
@@ -899,7 +892,7 @@ async function getCellColor(col: number, row: number): Promise<number[]> {

 async function setupBrowser(options: ITerminalOptions = { rendererType: 'dom' }): Promise<void> {
  const browserType = getBrowserType();
-  browser = await browserType.launch({ dumpio: true,
+  browser = await browserType.launch({
    headless: process.argv.indexOf('--headless') !== -1
  });
  page = await (await browser.newContext()).newPage();
@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [
+      "es6",
+    ],
+    "rootDir": ".",
+    "outDir": "../out-test",
+    "sourceMap": true,
+    "removeComments": true,
+    "baseUrl": ".",
+    "paths": {
+      "common/*": [
+        "../../../src/common/*"
+      ],
+      "browser/*": [
+        "../../../src/browser/*"
+      ]
+    },
+    "strict": true,
+    "types": [
+      "../../../node_modules/@types/mocha",
+      "../../../node_modules/@types/node",
+      "../../../out-test/api/TestUtils"
+    ]
+  },
+  "include": [
+    "./**/*",
+    "../../../typings/xterm.d.ts"
+  ],
+  "references": [
+    {
+      "path": "../../../src/common"
+    },
+    {
+      "path": "../../../src/browser"
+    }
+  ]
+}
@@ -0,0 +1,8 @@
+{
+  "files": [],
+  "include": [],
+  "references": [
+    { "path": "./src" },
+    { "path": "./test" }
+  ]
+}
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { Terminal, IDisposable, ITerminalAddon } from 'xterm';
+import { Terminal, ITerminalAddon } from 'xterm';

 declare module 'xterm-addon-webgl' {
  /**
@@ -15,7 +15,7 @@ declare module 'xterm-addon-webgl' {
    constructor(preserveDrawingBuffer?: boolean);

    /**
-     * Activates the addon
+     * Activates the addon.
     * @param terminal The terminal the addon is being loaded in.
     */
    public activate(terminal: Terminal): void;
@@ -24,5 +24,10 @@ declare module 'xterm-addon-webgl' {
     * Disposes the addon.
     */
    public dispose(): void;
+
+    /**
+     * Clears the terminal's texture atlas and triggers a redraw.
+     */
+    public clearTextureAtlas(): void;
  }
 }
@@ -98,11 +98,6 @@ jobs:
    inputs:
      versionSpec: '1.x'
    displayName: 'Install Yarn'
-  - task: CacheBeta@1
-    inputs:
-      key: yarn2 | $(Agent.OS) | yarn.lock
-      path: node_modules
-    displayName: Cache node modules
  - script: yarn --frozen-lockfile
    displayName: 'Install dependencies and build'
  - script: |
@@ -122,11 +117,6 @@ jobs:
    inputs:
      versionSpec: '10.x'
    displayName: 'Install Node.js'
-  - task: CacheBeta@1
-    inputs:
-      key: yarn2 | $(Agent.OS) | yarn.lock
-      path: node_modules
-    displayName: Cache node modules
  - script: yarn --frozen-lockfile
    displayName: 'Install dependencies and build'
  - script: |
@@ -1,23 +0,0 @@
-/**
- * Copyright (c) 2020 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-const playwright = require('playwright-core');
-const fs = require('fs');
-
-// Default to chromium
-let browserType = playwright['chromium'];
-const index = process.argv.indexOf('--browser');
-if (index !== -1 && process.argv.length > index + 1 && typeof process.argv[index + 1] === 'string') {
-  const string = process.argv[index + 1];
-  if (string === 'firefox' || string === 'webkit') {
-    browserType = playwright[string];
-  }
-}
-
-const exists = fs.existsSync(browserType.executablePath());
-if (!exists) {
-  console.log(`Downloading ${browserType.name()}`);
-  browserType.downloadBrowserIfNeeded().then(() => process.exit(0));
-}
@@ -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('-');
@@ -359,7 +359,7 @@ function empty(ar) {
 }

 function* parseMultiLineGen(filename, s) {
-  if (!~s.indexOf('@vt:')) {
+  if (!s.includes('@vt:')) {
    return;
  }
  const lines = s.split('\n').map(el => el.trim().replace(/[*]/, '').replace(/\s/, ''));
@@ -413,7 +413,7 @@ function parseSingleLine(filename, s) {
  const line = s.trim();
  const match = line.match(REX_VT_LINE);
  if (match !== null) {
-    if (!~TYPES.indexOf(match[2])) {
+    if (!TYPES.includes(match[2])) {
      throw new Error(`unkown vt-command type "${match[2]}" specified in "${filename}"`);
    }
    return {
@@ -25,7 +25,7 @@ if (fs.existsSync(addonsPath)) {

  // walk all addon folders
  fs.readdir(addonsPath, (err, files) => {
-    files.forEach(folder => {
+    for (const folder of files) {
      const addonPath = path.join(addonsPath, folder);

      // install only if there are dependencies listed
@@ -51,6 +51,6 @@ if (fs.existsSync(addonsPath)) {
      } else {
        console.log('Skipped', folder);
      }
-    });
+    }
  });
 }
@@ -11,7 +11,7 @@ const path = require('path');
 // Setup auth
 fs.writeFileSync(`${process.env['HOME']}/.npmrc`, `//registry.npmjs.org/:_authToken=${process.env['NPM_AUTH_TOKEN']}`);

-const isDryRun = process.argv.indexOf('--dry') !== -1;
+const isDryRun = process.argv.includes('--dry');
 if (isDryRun) {
  console.log('Publish dry run');
 }
@@ -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'),
@@ -35,13 +36,13 @@ const addonPackageDirs = [
  path.resolve(__dirname, '../addons/xterm-addon-webgl')
 ];
 console.log(`Checking if addons need to be published`);
-addonPackageDirs.forEach(p => {
+for (const p of addonPackageDirs) {
  const addon = path.basename(p);
-  if (changedFiles.some(e => e.indexOf(addon) !== -1)) {
+  if (changedFiles.some(e => e.includes(addon))) {
    console.log(`Try publish ${addon}`);
    checkAndPublishPackage(p);
  }
-});
+}

 // Publish website if it's a stable release
 if (isStableRelease) {
@@ -53,7 +54,7 @@ function checkAndPublishPackage(packageDir) {

  // Determine if this is a stable or beta release
  const publishedVersions = getPublishedVersions(packageJson);
-  const isStableRelease = publishedVersions.indexOf(packageJson.version) === -1;
+  const isStableRelease = !publishedVersions.includes(packageJson.version);

  // Get the next version
  let nextVersion = isStableRelease ? packageJson.version : getNextBetaVersion(packageJson);
@@ -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',
 ];
@@ -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-test/*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);
@@ -88,19 +88,19 @@ function evalButtonCode(code) {
  if (code & 64) {
    button |= 4
  }
-  let actionS = 'press';
+  let action = 'press';
  let buttonS = reverseButtons[button];
  if (button === 3) {
    buttonS = '<none>';
-    actionS = 'release';
+    action = 'release';
  }
  if (move) {
-    actionS = 'move';
+    action = 'move';
  } else if (4 <= button && button <= 7) {
    buttonS = 'wheel';
-    actionS = button === 4 ? 'up' : button === 5 ? 'down' : button === 6 ? 'left' : 'right';
+    action = button === 4 ? 'up' : button === 5 ? 'down' : button === 6 ? 'left' : 'right';
  }
-  return {button: buttonS, action: actionS, modifier};
+  return {button: buttonS, action, modifier};
 }

 // protocols
@@ -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;
@@ -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';
@@ -93,7 +93,7 @@ const paddingElement = <HTMLInputElement>document.getElementById('padding');

 function setPadding(): void {
  term.element.style.padding = parseInt(paddingElement.value, 10).toString() + 'px';
-  term.fit();
+  addons.fit.instance.fit();
 }

 function getSearchOptions(e: KeyboardEvent): ISearchOptions {
@@ -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 {
@@ -43,15 +43,15 @@ function startServer() {
    const env = Object.assign({}, process.env);
    env['COLORTERM'] = 'truecolor';
    var cols = parseInt(req.query.cols),
-        rows = parseInt(req.query.rows),
-        term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
-          name: 'xterm-256color',
-          cols: cols || 80,
-          rows: rows || 24,
-          cwd: env.PWD,
-          env: env,
-          encoding: USE_BINARY ? null : 'utf8'
-        });
+      rows = parseInt(req.query.rows),
+      term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
+        name: 'xterm-256color',
+        cols: cols || 80,
+        rows: rows || 24,
+        cwd: process.platform === 'win32' ? undefined : env.PWD,
+        env: env,
+        encoding: USE_BINARY ? null : 'utf8'
+      });

    console.log('Created terminal with PID: ' + term.pid);
    terminals[term.pid] = term;
@@ -1,17 +0,0 @@
-version: "3"
-
-services:
-  web:
-    image: xtermjs/xterm.js:latest
-    build: .
-    volumes:
-      - ./:/usr/src/app
-    ports:
-      - ${XTERMJS_PORT:-3000}:3000
-    command: ["npm", "start"]
-
-  watch:
-    build: .
-    volumes:
-      - ./:/usr/src/app
-    command: ["npm", "run", "watch"]
@@ -1,7 +1,7 @@
 {
  "name": "xterm",
  "description": "Full xterm terminal, in your browser",
-  "version": "4.5.0",
+  "version": "4.10.0",
  "main": "lib/xterm.js",
  "style": "css/xterm.css",
  "types": "typings/xterm.d.ts",
@@ -11,16 +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",
-    "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",
+    "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",
    "test-unit": "node ./bin/test.js",
    "test-unit-coverage": "node ./bin/test.js --coverage",
    "build": "tsc -b ./tsconfig.all.json",
@@ -36,37 +33,37 @@
    "vtfeatures": "node bin/extract_vtfeatures.js src/**/*.ts src/*.ts"
  },
  "devDependencies": {
-    "@types/chai": "^4.2.11",
+    "@types/chai": "^4.2.14",
    "@types/debug": "^4.1.5",
    "@types/deep-equal": "^1.0.1",
-    "@types/glob": "^7.1.1",
-    "@types/jsdom": "^16.2.0",
-    "@types/mocha": "^7.0.2",
+    "@types/glob": "^7.1.3",
+    "@types/jsdom": "^16.2.5",
+    "@types/mocha": "^8.0.3",
    "@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.24",
+    "@types/ws": "^7.2.9",
+    "@typescript-eslint/eslint-plugin": "^4.0.0",
+    "@typescript-eslint/parser": "^3.10.1",
    "chai": "^4.2.0",
-    "deep-equal": "^2.0.2",
-    "eslint": "^6.8.0",
+    "deep-equal": "^2.0.4",
+    "eslint": "^7.12.1",
    "express": "^4.17.1",
    "express-ws": "^4.0.0",
    "glob": "^7.0.5",
-    "jsdom": "^16.2.2",
-    "mocha": "^7.1.1",
+    "jsdom": "^16.4.0",
+    "mocha": "^8.2.1",
    "mustache": "^4.0.1",
    "node-pty": "^0.9.0",
-    "nyc": "^15.0.1",
-    "playwright-core": "^0.11.1",
-    "source-map-loader": "^0.2.4",
-    "ts-loader": "^6.0.4",
-    "typescript": "3.8",
+    "nyc": "^15.1.0",
+    "playwright": "^1.5.2",
+    "source-map-loader": "^1.1.2",
+    "ts-loader": "^8.0.8",
+    "typescript": "4.0",
    "utf8": "^3.0.0",
-    "webpack": "^4.35.3",
-    "webpack-cli": "^3.3.11",
-    "ws": "^7.0.0",
+    "webpack": "^5.4.0",
+    "webpack-cli": "^4.2.0",
+    "ws": "^7.3.1",
    "xterm-benchmark": "^0.1.3"
  }
 }
@@ -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;
-  }
-}
@@ -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;
-}
@@ -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;

@@ -55,8 +56,8 @@ export class AccessibilityManager extends Disposable {
    this._accessibilityTreeRoot.classList.add('xterm-accessibility');

    this._rowContainer = document.createElement('div');
-    this._rowContainer.classList.add('xterm-accessibility-tree');
    this._rowContainer.setAttribute('role', 'list');
+    this._rowContainer.classList.add('xterm-accessibility-tree');
    this._rowElements = [];
    for (let i = 0; i < this._terminal.rows; i++) {
      this._rowElements[i] = this._createAccessibilityTreeNode();
@@ -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);
    }
  }

@@ -261,7 +263,7 @@ export class AccessibilityManager extends Disposable {
      const element = this._rowElements[i];
      if (element) {
        if (lineData.length === 0) {
-          element.innerHTML = '&nbsp;';
+          element.innerText = '\u00a0';
        } else {
          element.textContent = lineData;
        }
@@ -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);
 }

 /**
@@ -101,8 +89,8 @@ export function moveTextAreaUnderMouseCursor(ev: MouseEvent, textarea: HTMLTextA
 export function rightClickHandler(ev: MouseEvent, textarea: HTMLTextAreaElement, screenElement: HTMLElement, selectionService: ISelectionService, shouldSelectWord: boolean): void {
  moveTextAreaUnderMouseCursor(ev, textarea, screenElement);

-  if (shouldSelectWord && !selectionService.isClickInSelection(ev)) {
-    selectionService.selectWordAtCursor(ev);
+  if (shouldSelectWord) {
+    selectionService.rightClickSelect(ev);
  }

  // Get textarea ready to copy from the context menu
@@ -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 });
+      });
    });
  });

@@ -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');
  }
 }

@@ -17,9 +17,8 @@ const DEFAULT_SELECTION = {
  rgba: 0xFFFFFF4D
 };

-// An IIFE to generate DEFAULT_ANSI_COLORS. Do not mutate DEFAULT_ANSI_COLORS, instead make a copy
-// and mutate that.
-export const DEFAULT_ANSI_COLORS = (() => {
+// An IIFE to generate DEFAULT_ANSI_COLORS.
+export const DEFAULT_ANSI_COLORS = Object.freeze((() => {
  const colors = [
    // dark:
    css.toColor('#2e3436'),
@@ -64,7 +63,7 @@ export const DEFAULT_ANSI_COLORS = (() => {
  }

  return colors;
-})();
+})());

 /**
 * Manages the source of truth for a terminal's colors.
@@ -92,7 +91,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 +114,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]);
@@ -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);
+    });
+  });
+});
@@ -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);
+  }
+}
--- a/Show More
+++ b/Show More