v3.13.1

Add sanity check in AccessibilityManager
Fixes #2082
2019-05-16 09:59:08 -07:00 · 2019-05-16 09:58:45 -07:00 · 2019-05-09 09:42:56 -07:00 · 2019-05-09 09:37:07 -07:00 · 2019-05-09 08:20:58 -07:00 · 2019-05-09 08:20:19 -07:00
147 changed files with 8200 additions and 3623 deletions
@@ -0,0 +1,22 @@
+FROM node:10
+
+# Configure apt
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update \
+    && apt-get -y install --no-install-recommends apt-utils 2>&1
+
+# Verify git and process tools are installed
+RUN apt-get install -y git procps
+
+# Install yarn
+RUN apt-get install -y curl apt-transport-https lsb-release \
+    && curl -sS https://dl.yarnpkg.com/$(lsb_release -is | tr '[:upper:]' '[:lower:]')/pubkey.gpg | apt-key add - 2>/dev/null \
+    && echo "deb https://dl.yarnpkg.com/$(lsb_release -is | tr '[:upper:]' '[:lower:]')/ stable main" | tee /etc/apt/sources.list.d/yarn.list \
+    && apt-get update \
+    && apt-get -y install --no-install-recommends yarn
+
+# Clean up
+RUN apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf /var/lib/apt/lists/*
+ENV DEBIAN_FRONTEND=dialog
@@ -0,0 +1,9 @@
+{
+  "name": "xterm.js",
+  "dockerFile": "Dockerfile",
+  "appPort": 3000,
+  "extensions": [
+    "editorconfig.editorconfig",
+    "ms-vscode.vscode-typescript-tslint-plugin"
+  ]
+}
@@ -1,8 +1,8 @@
 ---
 name: Question
-about: The issue tracker is not for questions. Please ask questions on https://stackoverflow.com/questions/tagged/xtermjs or https://gitter.im/sourcelair/xterm.js.
+about: The issue tracker is not for questions. Please ask questions on https://stackoverflow.com/questions/tagged/xtermjs
 ---

 🛑 The issue tracker is not for questions 🛑

-If you have a question, please ask it on https://stackoverflow.com/questions/tagged/xtermjs or https://gitter.im/sourcelair/xterm.js.
+If you have a question, please ask it on https://stackoverflow.com/questions/tagged/xtermjs.
@@ -12,7 +12,6 @@ npm-debug.log
 /.idea/
 .env
 build/
-.vscode/
 .DS_Store
 fixtures/typings-test/*.js
 package-lock.json
@@ -42,6 +42,7 @@ lib/test/
 docs/
 /.idea/
 .vscode/
+bin/
 build/
 fixtures/
 coverage/
@@ -0,0 +1,45 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Unit Tests",
+      "cwd": "${workspaceRoot}",
+      "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/mocha",
+      "windows": {
+        "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/mocha.cmd"
+      },
+      "runtimeArgs": [
+        "--colors",
+        "--recursive",
+        "${workspaceRoot}/lib"
+      ],
+      "sourceMaps": true,
+      "outFiles": [ "${workspaceRoot}/lib/**/*.js" ],
+      "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "type": "chrome",
+      "request": "launch",
+      "name": "Demo Client",
+      "url": "http://127.0.0.1:3000",
+      "webRoot": "${workspaceFolder}/"
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Demo Server",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": [
+        "run",
+        "start-debug"
+      ],
+      "port": 9229,
+      "serverReadyAction": {
+        "action": "openExternally",
+        "pattern": "App listening to (http://.*?:[0-9]+)"
+      }
+    }
+  ]
+}
@@ -0,0 +1,3 @@
+{
+  "typescript.preferences.quoteStyle": "single"
+}
@@ -0,0 +1,51 @@
+{
+	"version": "2.0.0",
+	"presentation": {
+		"echo": false,
+		"reveal": "always",
+		"focus": false,
+		"panel": "dedicated",
+		"showReuseMessage": true
+	},
+	"tasks": [
+		{
+			"type": "npm",
+			"script": "test",
+			"group": "test",
+			"problemMatcher": []
+		},
+		{
+			"type": "npm",
+			"script": "watch",
+			"group": "build",
+			"isBackground": true,
+			"problemMatcher": [],
+			"presentation": {
+				"group": "vscode"
+			}
+		},
+		{
+			"type": "npm",
+			"script": "start",
+			"group": "build",
+			"isBackground": true,
+			"problemMatcher": [],
+			"presentation": {
+				"group": "vscode"
+			}
+		},
+		{
+			"label": "Start demo",
+			"dependsOn": ["npm: watch", "npm: start"],
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+			"isBackground": true,
+			"problemMatcher": [],
+			"presentation": {
+				"group": "vscode"
+			}
+		}
+	]
+}
@@ -1,134 +0,0 @@
-List of xterm.js contributors. Updated before every release.
-
-7PH <b.raymond@cern.ch>
-7PH <b.raymond@protonmail.com>
-Adrian Labbé <adrilabbelol@gmail.com>
-Aleksandr Andrienko <aandrienko@codenvy.com>
-Aleksandr Andriienko <oandriie@redhat.com>
-Alessandro Nadalin <alessandro.nadalin@gmail.com>
-Alexander Olsson <noseglid@gmail.com>
-Alexandre Petit-Pas <petitpasalexandre@gmail.com>
-Alexey Kontsevoy <alexey@gravitational.com>
-Andres Mejia <amejia004@gmail.com>
-Anish Athalye <me@anishathalye.com>
-Anthony Lapenna <lapenna.anthony@gmail.com>
-Antonin Stefanutti <antonin@stefanutti.fr>
-Antonis Kalipetis <akalipetis@sourcelair.com>
-Anton Skshidlevsky <meefik@gmail.com>
-Anton Yurovskykh <anton.yurovskykh@gmail.com>
-Artem Arbatskiy <artyom.arbatskiy@gmail.com>
-Austin Robertson <austinrobertson@gmail.com>
-ayapi <colors.aya@gmail.com>
-Ben Hall <ben@benhall.me.uk>
-Benjamin Fischer <benjamin.fischer@rwth-aachen.de>
-Benjamin Raymond <b.raymond@cern.ch>
-Benjamin Woodruff <github@benjam.info>
-Bill Church <billchurch@users.noreply.github.com>
-Bob Reid <bobreid@Bobs-MacBook-Pro.local>
-bottleofwater <nison.mael+bottleofwater@gmail.com>
-Brandon Bayer <b@bayer.ws>
-Brian Mock <brian@mockbrian.com>
-Bruno Ribeiro <b.m.fernandes.ribeiro@gmail.com>
-Bruno Ribeito <b.m.fernandes.ribeiro@gmail.com>
-Carson Anderson <carson@betterservers.com>
-CHaBou <chabup@delean.fr>
-Christian Budde Christensen <budde377@gmail.com>
-Christof Marti <chrmarti@microsoft.com>
-Christopher Jeffrey <chjjeffrey@gmail.com>
-coderaiser <mnemonic.enemy@gmail.com>
-Damien Tournoud <damien@platform.sh>
-Dan Brown <jdanbrown@gmail.com>
-Daniel Griffen <dagriffe@microsoft.com>
-Daniel Griffen <daniel@griffen.io>
-Daniel Imms <daimms@microsoft.com>
-Daniel Risacher <drisacher@gmail.com>
-Dan Kaplun <dbkaplun@twitch.tv>
-Darin Morrison <freebroccolo@users.noreply.github.com>
-dcylabs <dcylabs@gmail.com>
-Dominik Csapak <d.csapak@proxmox.com>
-Edgar Andrés Margffoy Tuay <andfoy@gmail.com>
-Elliot Saba <staticfloat@gmail.com>
-Exile <exile@chamber.ee>
-Felipe Gasper <felipe@felipegasper.com>
-Felix <30559812+felixse@users.noreply.github.com>
-ficristo <ficristo.work@gmail.com>
-Gary Ritchie <gary@rstudio.com>
-hiro-su <h.sugipon@gmail.com>
-Ian Lewis <ianlewis@google.com>
-imoses <ido@twiggle.com>
-InDieTasten <indietasten@gmail.com>
-irokas <akasidiari@inf.uth.gr>
-Jakob Gillich <jakob@gillich.me>
-Jan Kuri <jkuri88@gmail.com>
-Jean Bruenn <himself@jeanbruenn.info>
-Jeff Principe <princjef@gmail.com>
-Jeremy Danyow <jedanyow@microsoft.com>
-Jianhui Zhao <jianhuizhao329@gmail.com>
-Joao Moreno <jomo@microsoft.com>
-Joao Moreno <mail@joaomoreno.com>
-Johannes Zellner <johannes@nebulon.de>
-Jon Austin <jon.i.austin@gmail.com>
-Jon Kohler <jon@nutanix.com>
-Jon Masters <jon.masters@sky.com>
-Jörg Breitbart <jerch@rockborn.de>
-Jose Anton <roke22@gmail.com>
-jpoth <poth.john@gmail.com>
-Justin Luk <jluk@users.noreply.github.com>
-Justin Mecham <justin@mecham.me>
-Kirill Merkushev <lanwen@yandex.ru>
-Krasimir Tsonev <krasimir@outset.ws>
-Ledion Bitincka <lbitincka@gmail.com>
-Linus Unnebäck <linus@folkdatorn.se>
-Luca <LucaT1@users.noreply.github.com>
-Lucian Buzzo <lucian.buzzo@gmail.com>
-Lukas Drgon <lukas.drgon@gmail.com>
-Lukas Geiger <lukas.geiger94@gmail.com>
-Maël Nison <nison.mael@gmail.com>
-Marc Dumais <marc.dumais@ericsson.com>
-Marek Libra <mlibra@redhat.com>
-Markus F.X.J. Oberhumer <markus@oberhumer.com>
-Martin Chloride <i@martincl2.me>
-Martin Koppehel <martin.koppehel@st.ovgu.de>
-Martin Wang <jiahaow@ca.ibm.com>
-Matt Bierner <matb@microsoft.com>
-Matthew James <matthew.d.james87@gmail.com>
-Michael Irwin <mikesir87@gmail.com>
-Mikko Karvonen <mikko.karvonen@arm.com>
-mofux <t.zilz@mofux.org>
-muji <muji@tmpfs.org>
-Nicolas Ramz <nicolas.ramz@gmail.com>
-npezza93 <npezza93@gmail.com>
-Oleksandr Andriienko <oandriie@redhat.com>
-Paris Kasidiaris <pariskasidiaris@gmail.com>
-Paris Kasidiaris <paris@sourcelair.com>
-Peng Xiao <pengxiao@outlook.com>
-Peter Baumgarten <me@peterbaumgarten.com>
-Philip Olson <philip.olson@protonmail.ch>
-PowerHat <31401273+7PH@users.noreply.github.com>
-PowerHat <b.raymond@protonmail.com>
-pro-src <34285059+pro-src@users.noreply.github.com>
-pro-src <rodneyd.teal@gmail.com>
-Rick Baker <rick@ricktbaker.com>
-runarberg <runar@greenqloud.com>
-Saad Malik <simfox3@gmail.com>
-Samuel Williams <samuel.williams@oriontransfer.co.nz>
-Saswat Das <saswatds@users.noreply.github.com>
-Saul Costa <saul@codevolve.com>
-Segev Finer <segev208@gmail.com>
-Shuanglei Tao <tsl0922@gmail.com>
-sitzmar <sitzmar@gmail.com>
-Steven Silvester <steven.silvester@ieee.org>
-stuicey <stuicey@users.noreply.github.com>
-Sven-Hendrik Haase <svenstaro@gmail.com>
-t-amqi <umberos@gmail.com>
-Thanasis Daglis <thanasis@sourcelair.com>
-thomas <thomas@kreativkonzentrat.de>
-Thomas Zilz <t.zilz@mofux.org>
-Tine Jozelj <tine.jozelj@outlook.com>
-Tyler Jewell <tjewell@codenvy.com>
-Vincent Woo <me@vincentwoo.com>
-Viraj Sinha <virajosinha@gmail.com>
-yutaka <shigure@refy.net>
-YuviPanda <yuvipanda@gmail.com>
-ZHAO Xudong <zxdong@gmail.com>
-赵雪珂 <zhaoxueke@onething.net>
@@ -30,23 +30,24 @@ opening an issue, read these pointers.

 ## Contributing code

- Make sure you have a [GitHub account](https://github.com/join)
+You can find issues to work on by looking at the [help wanted](https://github.com/xtermjs/xterm.js/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) or [good first issue](https://github.com/xtermjs/xterm.js/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) issues. It's a good idea to comment on the issue saying that you're taking it, just in case someone else comes along and you duplicate work. Once you have your issue, here are the steps to contribute:
+
 - Fork [xterm.js](https://github.com/sourcelair/xterm.js/)
-  ([how to fork a repo](https://help.github.com/articles/fork-a-repo))
- Get the [xterm.js demo](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo) running
- Make your changes
+  ([how to fork a repo](https://help.github.com/articles/fork-a-repo)).
+- Get the [xterm.js demo](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo) running.
+- Make your changes.
 - If your changes are easy to test or likely to regress, add tests. Tests go into `test`, directory.
 - Follow the general code style of the rest of the project (see below).
 - Submit a pull request
 ([how to create a pull request](https://help.github.com/articles/fork-a-repo)).
  Don't put more than one feature/fix in a single pull request.

-By contributing code to xterm.js you
+By contributing code to xterm.js you:

- - agree to license the contributed code under xterm.js' [MIT
+ - Agree to license the contributed code under xterm.js' [MIT
   license](LICENSE).

- - confirm that you have the right to contribute and license the code
+ - Confirm that you have the right to contribute and license the code
   in question. (Either you hold all rights on the code, or the rights
   holder has explicitly granted the right to use it like this,
   through a compatible open source license or through a direct
@@ -16,4 +16,4 @@ RUN npm install
 COPY . /usr/src/app

 # Run the tests and build, to make sure everything is working nicely
-RUN npm run build && npm run webpack && npm run test
+RUN npm run build && npm run test
@@ -1,4 +1,4 @@
-Copyright (c) 2017-2018, The xterm.js authors (https://github.com/xtermjs/xterm.js)
+Copyright (c) 2017-2019, The xterm.js authors (https://github.com/xtermjs/xterm.js)
 Copyright (c) 2014-2016, SourceLair Private Company (https://www.sourcelair.com)
 Copyright (c) 2012-2013, Christopher Jeffrey (https://github.com/chjj/)

@@ -2,25 +2,22 @@

 [![Build Status](https://dev.azure.com/xtermjs/xterm.js/_apis/build/status/xtermjs.xterm.js)](https://dev.azure.com/xtermjs/xterm.js/_build/latest?definitionId=3)
 [![Coverage Status](https://coveralls.io/repos/github/xtermjs/xterm.js/badge.svg?branch=master)](https://coveralls.io/github/xtermjs/xterm.js?branch=master)
-[![Gitter](https://badges.gitter.im/sourcelair/xterm.js.svg)](https://gitter.im/sourcelair/xterm.js?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-[![jsDelivr Hits](https://data.jsdelivr.com/v1/package/npm/xterm/badge?style=rounded)](https://www.jsdelivr.com/package/npm/xterm)

-Xterm.js is a terminal front-end component written in JavaScript that works in the browser.
-
-It enables applications to provide fully featured terminals to their users and create great development experiences.
+Xterm.js is a front-end component written in TypeScript that lets applications bring fully-featured terminals to their users in the browser. It's used by popular projects such as VS Code, Hyper and Theia.

 ## Features
- **Text-based application support**: Use xterm.js to work with applications like `bash`, `git` etc.
- **Curses-based application support**: Use xterm.js to work with applications like `vim`, `tmux` etc.
- **Mouse events support**: Xterm.js captures mouse events like click and scroll and passes them to the terminal's back-end controlling process
- **CJK (Chinese, Japanese, Korean) character support**: Xterm.js renders CJK characters seamlessly
- **IME support**: Insert international (including CJK) characters using IME input with your keyboard
- **Self-contained library**: Xterm.js works on its own. It does not require any external libraries like jQuery or React to work
- **Modular, event-based API**: Lets you build addons and themes with ease
+
+- **Terminal apps just work**: Xterm.js works with most terminal apps such as `bash`, `vim` and `tmux`, this includes support for curses-based apps and mouse event support.
+- **Perfomant**: Xterm.js is *really* fast, it even includes a GPU-accelerated renderer.
+- **Rich unicode support**: Supports CJK, emojis and IMEs.
+- **Self-contained**: Requires zero dependencies to work.
+- **Accessible**: Screen reader support can be turned on using the `screenReaderMode` option.
+- **And much more**: Links, theming, addons, well documented API, etc.

 ## What xterm.js is not
- Xterm.js is not a terminal application that you can download and use on your computer
- Xterm.js is not `bash`. Xterm.js can be connected to processes like `bash` and let you interact with them (provide input, receive output)
+
+- Xterm.js is not a terminal application that you can download and use on your computer.
+- Xterm.js is not `bash`. Xterm.js can be connected to processes like `bash` and let you interact with them (provide input, receive output).

 ## Getting Started

@@ -30,7 +27,7 @@ First you need to install the module, we ship exclusively through [npm](https://
 npm install xterm
 ```

-To start using xterm.js on your browser, add the `xterm.js` and `xterm.css` to the head of your html page. Then create a `<div id="terminal"></div>` onto which xterm can attach itself.
+To start using xterm.js on your browser, add the `xterm.js` and `xterm.css` to the head of your html page. Then create a `<div id="terminal"></div>` onto which xterm can attach itself. Finally instantiate the `Terminal` object and then call the `open` function with the DOM object of the `div`.

 ```html
 <!doctype html>
@@ -44,39 +41,30 @@ To start using xterm.js on your browser, add the `xterm.js` and `xterm.css` to t
      <script>
        var term = new Terminal();
        term.open(document.getElementById('terminal'));
-        term.write('Hello from \x1B[1;3;31mxterm.js\x1B[0m $ ')
+        term.write('Hello from \x1B[1;3;31mxterm.js\x1B[0m $ ')
      </script>
    </body>
  </html>
 ```

-Finally instantiate the `Terminal` object and then call the `open` function with the DOM object of the `div`.
-
 ### Importing

-The proposed way to load xterm.js is via the ES6 module syntax.
+The recommended way to load xterm.js is via the ES6 module syntax:

 ```javascript
 import { Terminal } from 'xterm';
 ```

-### API
-
-The full API for xterm.js is contained within the [TypeScript declaration file](https://github.com/xtermjs/xterm.js/blob/master/typings/xterm.d.ts), use the branch/tag picker in GitHub (`w`) to navigate to the correct version of the API.
-
-Note that some APIs are marked *experimental*, these are added so we can experiment with new ideas without committing to support it like a normal semver API. Note that these APIs can change radically between versions so be sure to read release notes if you plan on using experimental APIs.
-
 ### Addons

-Addons are JavaScript modules that extend the `Terminal` prototype with new methods and attributes to provide additional functionality. There are a handful available in the main repository in the `src/addons` directory and you can even write your own, by using xterm.js' public API.
+Addons are JavaScript modules that extend the `Terminal` prototype with new methods and attributes to provide additional functionality. There are a handful available in the main repository in the `src/addons` directory and you can even write your own by using the [public API](https://github.com/xtermjs/xterm.js/blob/master/typings/xterm.d.ts).

 To use an addon, just import the JavaScript module and pass it to `Terminal`'s `applyAddon` method:

 ```javascript
-import { Terminal } from xterm;
+import { Terminal } from 'xterm';
 import * as fit from 'xterm/lib/addons/fit/fit';

-
 Terminal.applyAddon(fit);

 var xterm = new Terminal();  // Instantiate the terminal
@@ -87,25 +75,16 @@ You will also need to include the addon's CSS file if it has one in the folder.

 #### Importing Addons in TypeScript

-There are currently no typings for addons if they are accessed via extending Terminal prototype, so you will need to upcast if using TypeScript, eg. `(<any>xterm).fit()`.
-
-Alternatively, you can import addon function and enhance the terminal on demand. This would have better typing support and is friendly to treeshaking. E.g.:
+There are currently no typings for addons if they are accessed via extending Terminal prototype, so you will need to upcast if using TypeScript, eg. `(xterm as any).fit()`. Alternatively, you can import the addon function and enhance the terminal on demand. This has better typing support and is friendly to treeshaking.

 ```typescript
 import { Terminal } from 'xterm';
 import { fit } from 'xterm/lib/addons/fit/fit';
 const xterm = new Terminal();

-// Fit the terminal when necessary:
-fit(xterm);
+fit(xterm);  // Fit the terminal when necessary
 ```

-#### Third party addons
-
-There are also the following third party addons available:
-
- [xterm-webfont](https://www.npmjs.com/package/xterm-webfont)
-
 ## Browser Support

 Since xterm.js is typically implemented as a developer tool, only modern browsers are supported officially. Here is a list of the versions we aim to support:
@@ -116,26 +95,28 @@ Since xterm.js is typically implemented as a developer tool, only modern browser
 - Safari latest
 - IE11

-Xterm.js works seamlessly in Electron apps and may even work on earlier versions of the browsers but these are the browsers we strive to keep 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.

 ## API

-The current full API documentation is available in the [TypeScript declaration file on the repository](https://github.com/xtermjs/xterm.js/blob/master/typings/xterm.d.ts), switch the tag (press `w` when viewing the file) to point at the specific version tag you're using.
+The full API for xterm.js is contained within the [TypeScript declaration file](https://github.com/xtermjs/xterm.js/blob/master/typings/xterm.d.ts), use the branch/tag picker in GitHub (`w`) to navigate to the correct version of the API.
+
+Note that some APIs are marked *experimental*, these are added to enable experimentation with new ideas without committing to support it like a normal [semver](https://semver.org/) API. Note that these APIs can change radically between versions so be sure to read release notes if you plan on using experimental APIs.

 ## Real-world uses
 Xterm.js is used in several world-class applications to provide great terminal experiences.

- [**SourceLair**](https://www.sourcelair.com/): In-browser IDE that provides its users with fully-featured Linux terminals based on xterm.js
- [**Microsoft Visual Studio Code**](http://code.visualstudio.com/): Modern, versatile and powerful open source code editor that provides an integrated terminal based on xterm.js
- [**ttyd**](https://github.com/tsl0922/ttyd): A command-line tool for sharing terminal over the web, with fully-featured terminal emulation based on xterm.js
+- [**SourceLair**](https://www.sourcelair.com/): In-browser IDE that provides its users with fully-featured Linux terminals based on xterm.js.
+- [**Microsoft Visual Studio Code**](http://code.visualstudio.com/): Modern, versatile and powerful open source code editor that provides an integrated terminal based on xterm.js.
+- [**ttyd**](https://github.com/tsl0922/ttyd): A command-line tool for sharing terminal over the web, with fully-featured terminal emulation based on xterm.js.
 - [**Katacoda**](https://www.katacoda.com/): Katacoda is an Interactive Learning Platform for software developers, covering the latest Cloud Native technologies.
 - [**Eclipse Che**](http://www.eclipse.org/che): Developer workspace server, cloud IDE, and Eclipse next-generation IDE.
 - [**Codenvy**](http://www.codenvy.com): Cloud workspaces for development teams.
- [**CoderPad**](https://coderpad.io): Online interviewing platform for programmers. Run code in many programming languages, with results displayed by `xterm.js`.
- [**WebSSH2**](https://github.com/billchurch/WebSSH2): A web based SSH2 client using `xterm.js`, socket.io, and ssh2.
+- [**CoderPad**](https://coderpad.io): Online interviewing platform for programmers. Run code in many programming languages, with results displayed by xterm.js.
+- [**WebSSH2**](https://github.com/billchurch/WebSSH2): A web based SSH2 client using xterm.js, socket.io, and ssh2.
 - [**Spyder Terminal**](https://github.com/spyder-ide/spyder-terminal): A full fledged system terminal embedded on Spyder IDE.
 - [**Cloud Commander**](https://cloudcmd.io "Cloud Commander"): Orthodox web file manager with console and editor.
- [**Codevolve**](https://www.codevolve.com "Codevolve"): Online platform for interactive coding and web development courses. Live container-backed terminal uses `xterm.js`.
+- [**Codevolve**](https://www.codevolve.com "Codevolve"): Online platform for interactive coding and web development courses. Live container-backed terminal uses xterm.js.
 - [**RStudio**](https://www.rstudio.com/products/RStudio "RStudio"): RStudio is an integrated development environment (IDE) for R.
 - [**Terminal for Atom**](https://github.com/jsmecham/atom-terminal-tab): A simple terminal for the Atom text editor.
 - [**Eclipse Orion**](https://orionhub.org): A modern, open source software development environment that runs in the cloud. Code, deploy and run in the cloud.
@@ -143,9 +124,8 @@ Xterm.js is used in several world-class applications to provide great terminal e
 - [**Hexlet**](https://en.hexlet.io): Practical programming courses (JavaScript, PHP, Unix, databases, functional programming). A steady path from the first line of code to the first job.
 - [**Selenoid UI**](https://github.com/aerokube/selenoid-ui): Simple UI for the scallable golang implementation of Selenium Hub named Selenoid. We use XTerm for streaming logs over websockets from docker containers.
 - [**Portainer**](https://portainer.io): Simple management UI for Docker.
- [**SSHy**](https://github.com/stuicey/SSHy): HTML5 Based SSHv2 Web Client with E2E encryption utilising `xterm.js`, SJCL & websockets.
- [**JupyterLab**](https://github.com/jupyterlab/jupyterlab): An extensible
-computational environment for Jupyter, supporting interactive data science and scientific computing across all programming languages.
+- [**SSHy**](https://github.com/stuicey/SSHy): HTML5 Based SSHv2 Web Client with E2E encryption utilising xterm.js, SJCL & websockets.
+- [**JupyterLab**](https://github.com/jupyterlab/jupyterlab): An extensible computational environment for Jupyter, supporting interactive data science and scientific computing across all programming languages.
 - [**Theia**](https://github.com/theia-ide/theia): Theia is a cloud & desktop IDE framework implemented in TypeScript.
 - [**Opshell**](https://github.com/ricktbaker/opshell) Ops Helper tool to make life easier working with AWS instances across multiple organizations.
 - [**Proxmox VE**](https://www.proxmox.com/en/proxmox-ve): Proxmox VE is a complete open-source platform for enterprise virtualization. It uses xterm.js for container terminals and the host shell.
@@ -156,21 +136,28 @@ computational environment for Jupyter, supporting interactive data science and s
 - [**Kubebox**](https://github.com/astefanutti/kubebox): Terminal console for Kubernetes clusters.
 - [**Azure Cloud Shell**](https://shell.azure.com): Azure Cloud Shell is a Microsoft-managed admin machine built on Azure, for Azure.
 - [**atom-xterm**](https://atom.io/packages/atom-xterm): Atom plugin for providing terminals inside your Atom workspace.
- [**rtty**](https://github.com/zhaojh329/rtty): A reverse proxy WebTTY. It is composed of the client and the server.
- [**Pisth**](https://github.com/ColdGrub1384/Pisth): An SFTP and SSH client for iOS
+- [**rtty**](https://github.com/zhaojh329/rtty): Access your terminals from anywhere via the web.
+- [**Pisth**](https://github.com/ColdGrub1384/Pisth): An SFTP and SSH client for iOS.
 - [**abstruse**](https://github.com/bleenco/abstruse): Abstruse CI is a continuous integration platform based on Node.JS and Docker.
- [**Microsoft SQL Operations Studio**](https://github.com/Microsoft/sqlopsstudio): A data management tool that enables working with SQL Server, Azure SQL DB and SQL DW from Windows, macOS and Linux
- [**FreeMAN**](https://github.com/matthew-matvei/freeman): A free, cross-platform file manager for power users
+- [**Azure Data Studio**](https://github.com/Microsoft/azuredatastudio): A data management tool that enables working with SQL Server, Azure SQL DB and SQL DW from Windows, macOS and Linux.
+- [**FreeMAN**](https://github.com/matthew-matvei/freeman): A free, cross-platform file manager for power users.
 - [**Fluent Terminal**](https://github.com/felixse/FluentTerminal): A terminal emulator based on UWP and web technologies.
- [**Hyper**](https://hyper.is): A terminal built on web technologies
+- [**Hyper**](https://hyper.is): A terminal built on web technologies.
 - [**Diag**](https://diag.ai): A better way to troubleshoot problems faster. Capture, share and reapply troubleshooting knowledge so you can focus on solving problems that matter.
 - [**GoTTY**](https://github.com/yudai/gotty): A simple command line tool that shares your terminal as a web application based on xterm.js.
 - [**genact**](https://github.com/svenstaro/genact): A nonsense activity generator.
 - [**cPanel & WHM**](https://cpanel.com): The hosting platform of choice.
- [**Nutanix**](https://github.com/nutanix): Nutanix Enterprise Cloud uses xterm in the webssh functionality within Nutanix Calm, and is also looking to move our old noserial (termjs) functionality to xterm.js
+- [**Nutanix**](https://github.com/nutanix): Nutanix Enterprise Cloud uses xterm in the webssh functionality within Nutanix Calm, and is also looking to move our old noserial (termjs) functionality to xterm.js.
 - [**SSH Web Client**](https://github.com/roke22/PHP-SSH2-Web-Client): SSH Web Client with PHP.
 - [**Shellvault**](https://www.shellvault.io): The cloud-based SSH terminal you can access from anywhere.
 - [**Juno**](http://junolab.org/): A flexible Julia IDE, based on Atom.
+- [**webssh**](https://github.com/huashengdun/webssh): Web based ssh client.
+- [**info-beamer hosted**](https://info-beamer.com): Uses xterm.js to manage digital signage devices from the web dashboard.
+- [**Jumpserver**](https://github.com/jumpserver/luna): Jumpserver Luna project, Jumpserver is a bastion server project, Luna use xterm.js for web terminal emulation.
+- [**LxdMosaic**](https://github.com/turtle0x1/LxdMosaic): Uses xterm.js to give terminal access to containers through LXD
+- [**CodeInterview.io**](https://codeinterview.io): A coding interview platform in 25+ languages and many web frameworks. Uses xterm.js to provide shell access.
+- [**Bastillion**](https://www.bastillion.io): Bastillion is an open-source web-based SSH console that centrally manages administrative access to systems.
+- [**PHP App Server**](https://github.com/cubiclesoft/php-app-server/): Create lightweight, installable almost-native applications for desktop OSes.  ExecTerminal (nicely wraps the xterm.js Terminal), TerminalManager, and RunProcessSDK are self-contained, reusable ES5+ compliant Javascript components.

 [And much more...](https://github.com/xtermjs/xterm.js/network/dependents)

@@ -180,7 +167,17 @@ Do you use xterm.js in your application as well? Please [open a Pull Request](ht

 Xterm.js follows a monthly release cycle roughly.

-The existing releases are available at this GitHub repo's [Releases](https://github.com/sourcelair/xterm.js/releases), while the roadmap is available as [Milestones](https://github.com/sourcelair/xterm.js/milestones).
+All current and past releases are available on this repo's [Releases page](https://github.com/sourcelair/xterm.js/releases), you can view the [high-level roadmap on the wiki](https://github.com/xtermjs/xterm.js/wiki/Roadmap) and see what we're working on now by looking through [Milestones](https://github.com/sourcelair/xterm.js/milestones).
+
+### Beta builds
+
+Our CI releases beta builds to npm for every change that goes into master, install the latest beta build with:
+
+```
+npm install -S xterm@beta
+```
+
+These should generally be stable but some bugs may slip in, we recommend using the beta build primarily to test out new features and for verifying bug fixes.

 ## Contributing

@@ -66,3 +66,28 @@ jobs:
  - script: |
      yarn lint
    displayName: 'Lint'
+
+- job: Release
+  dependsOn:
+  - Linux
+  - macOS
+  - Windows
+  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/master'))
+  pool:
+    vmImage: 'ubuntu-16.04'
+  steps:
+  - task: NodeTool@0
+    inputs:
+      versionSpec: '8.x'
+    displayName: 'Install Node.js'
+  - task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+    inputs:
+      versionSpec: "1.9.4"
+    displayName: 'Install Yarn'
+  - script: |
+      yarn
+      BUILD_DIR=dist npm run build
+    displayName: 'Install dependencies and build'
+  - script: |
+      NPM_AUTH_TOKEN="$(NPM_AUTH_TOKEN)" node ./bin/publish.js
+    displayName: 'Publish to npm'
@@ -1,7 +0,0 @@
-#! /usr/bin/env sh
-
-tail --lines=+3 AUTHORS > AUTHORS.tmp
-git log --format='%aN <%aE>' >> AUTHORS.tmp
-echo "List of xterm.js contributors. Updated before every release.\n" > AUTHORS
-sort -u AUTHORS.tmp >> AUTHORS
-rm -f AUTHORS.tmp
@@ -17,9 +17,6 @@ CURRENT_PACKAGE_JSON_VERSION=$(cat package.json \
 export BUILD_DIR=dist
 npm run build

-# Update AUTHORS file
-sh bin/generate-authors
-
 # Update version in package.json
 sed -i "s/\"version\": \"$CURRENT_PACKAGE_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" package.json

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+const cp = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const packageJson = require('../package.json');
+
+// Setup auth
+fs.writeFileSync(`${process.env['HOME']}/.npmrc`, `//registry.npmjs.org/:_authToken=${process.env['NPM_AUTH_TOKEN']}`);
+
+// Determine if this is a stable or beta release
+const publishedVersions = getPublishedVersions();
+const isStableRelease = publishedVersions.indexOf(packageJson.version) === -1;
+
+// Get the next version
+let nextVersion = isStableRelease ? packageJson.version : getNextBetaVersion();
+console.log(`Publishing version: ${nextVersion}`);
+
+// Set the version in package.json
+const packageJsonFile = path.resolve(__dirname, '..', 'package.json');
+packageJson.version = nextVersion;
+fs.writeFileSync(packageJsonFile, JSON.stringify(packageJson, null, 2));
+
+// Publish
+const args = ['publish'];
+if (!isStableRelease) {
+  args.push('--tag', 'beta');
+}
+const result = cp.spawn('npm', args, { stdio: 'inherit' });
+result.on('exit', code => process.exit(code));
+
+function getNextBetaVersion() {
+  if (!/^[0-9]+\.[0-9]+\.[0-9]+$/.exec(packageJson.version)) {
+    console.error('The package.json version must be of the form x.y.z');
+    process.exit(1);
+  }
+  const tag = 'beta';
+  const stableVersion = packageJson.version.split('.');
+  const nextStableVersion = `${stableVersion[0]}.${parseInt(stableVersion[1]) + 1}.${stableVersion[2]}`;
+  const publishedVersions = getPublishedVersions(nextStableVersion, tag);
+  if (publishedVersions.length === 0) {
+    return `${packageJson.version}-${tag}1`;
+  }
+  const latestPublishedVersion = publishedVersions.sort((a, b) => {
+    const aVersion = parseInt(a.substr(a.search(/[0-9]+$/)));
+    const bVersion = parseInt(b.substr(b.search(/[0-9]+$/)));
+    return aVersion > bVersion ? -1 : 1;
+  })[0];
+  const latestTagVersion = parseInt(latestPublishedVersion.substr(latestPublishedVersion.search(/[0-9]+$/)), 10);
+  return `${nextStableVersion}-${tag}${latestTagVersion + 1}`;
+}
+
+function getPublishedVersions(version, tag) {
+  const versionsProcess = cp.spawnSync('npm', ['view', 'xterm', 'versions', '--json']);
+  const versionsJson = JSON.parse(versionsProcess.stdout);
+  if (tag) {
+    return versionsJson.filter(v => !v.search(new RegExp(`${version}-${tag}[0-9]+`)));
+  }
+  return versionsJson;
+}
@@ -13,11 +13,11 @@ import * as fit from '../lib/addons/fit/fit';
 import * as fullscreen from '../lib/addons/fullscreen/fullscreen';
 import * as search from '../lib/addons/search/search';
 import * as webLinks from '../lib/addons/webLinks/webLinks';
-import * as winptyCompat from '../lib/addons/winptyCompat/winptyCompat';
+import { ISearchOptions } from '../lib/addons/search/Interfaces';

 // Pulling in the module's types relies on the <reference> above, it's looks a
 // little weird here as we're importing "this" module
-import { Terminal as TerminalType } from 'xterm';
+import { Terminal as TerminalType, ITerminalOptions } from 'xterm';

 export interface IWindowWithTerminal extends Window {
  term: TerminalType;
@@ -29,7 +29,6 @@ Terminal.applyAddon(fit);
 Terminal.applyAddon(fullscreen);
 Terminal.applyAddon(search);
 Terminal.applyAddon(webLinks);
-Terminal.applyAddon(winptyCompat);


 let term;
@@ -50,6 +49,14 @@ function setPadding(): void {
  term.fit();
 }

+function getSearchOptions(): ISearchOptions {
+  return {
+    regex: (document.getElementById('regex') as HTMLInputElement).checked,
+    wholeWord: (document.getElementById('whole-word') as HTMLInputElement).checked,
+    caseSensitive: (document.getElementById('case-sensitive') as HTMLInputElement).checked
+  };
+}
+
 createTerminal();

 const disposeRecreateButtonHandler = () => {
@@ -74,9 +81,12 @@ function createTerminal(): void {
  while (terminalContainer.children.length) {
    terminalContainer.removeChild(terminalContainer.children[0]);
  }
-  term = new Terminal({});
+  const isWindows = ['Windows', 'Win16', 'Win32', 'WinCE'].indexOf(navigator.platform) >= 0;
+  term = new Terminal({
+    windowsMode: isWindows
+  } as ITerminalOptions);
  window.term = term;  // Expose `term` to window for debugging purposes
-  term.on('resize', (size: { cols: number, rows: number }) => {
+  term.onResize((size: { cols: number, rows: number }) => {
    if (!pid) {
      return;
    }
@@ -90,33 +100,22 @@ function createTerminal(): void {
  socketURL = protocol + location.hostname + ((location.port) ? (':' + location.port) : '') + '/terminals/';

  term.open(terminalContainer);
-  term.winptyCompatInit();
+
  term.webLinksInit();
  term.fit();
  term.focus();

  addDomListener(paddingElement, 'change', setPadding);

-  addDomListener(actionElements.findNext, 'keypress', (e) => {
-    if (e.key === 'Enter') {
-      e.preventDefault();
-      const searchOptions = {
-        regex: (document.getElementById('regex') as HTMLInputElement).checked,
-        wholeWord: (document.getElementById('whole-word') as HTMLInputElement).checked,
-        caseSensitive: (document.getElementById('case-sensitive') as HTMLInputElement).checked
-      };
-      term.findNext(actionElements.findNext.value, searchOptions);
-    }
+  addDomListener(actionElements.findNext, 'keyup', (e) => {
+    const searchOptions = getSearchOptions();
+    searchOptions.incremental = e.key !== `Enter`;
+    term.findNext(actionElements.findNext.value, searchOptions);
  });
-  addDomListener(actionElements.findPrevious, 'keypress', (e) => {
-    if (e.key === 'Enter') {
-      e.preventDefault();
-      const searchOptions = {
-        regex: (document.getElementById('regex') as HTMLInputElement).checked,
-        wholeWord: (document.getElementById('whole-word') as HTMLInputElement).checked,
-        caseSensitive: (document.getElementById('case-sensitive') as HTMLInputElement).checked
-      };
-      term.findPrevious(actionElements.findPrevious.value, searchOptions);
+
+  addDomListener(actionElements.findPrevious, 'keyup', (e) => {
+    if (e.key === `Enter`) {
+      term.findPrevious(actionElements.findPrevious.value, getSearchOptions());
    }
  });

@@ -166,24 +165,21 @@ function runFakeTerminal(): void {
  term.writeln('');
  term.prompt();

-  term._core.register(term.addDisposableListener('key', (key, ev) => {
-    const printable = !ev.altKey && !ev.altGraphKey && !ev.ctrlKey && !ev.metaKey;
+  term.onKey((e: { key: string, domEvent: KeyboardEvent }) => {
+    const ev = e.domEvent;
+    const printable = !ev.altKey && !ev.ctrlKey && !ev.metaKey;

    if (ev.keyCode === 13) {
      term.prompt();
    } else if (ev.keyCode === 8) {
     // Do not delete the prompt
-      if (term.x > 2) {
+      if (term._core.buffer.x > 2) {
        term.write('\b \b');
      }
    } else if (printable) {
-      term.write(key);
+      term.write(e.key);
    }
-  }));
-
-  term._core.register(term.addDisposableListener('paste', (data, ev) => {
-    term.write(data);
-  }));
+  });
 }

 function initOptions(term: TerminalType): void {
@@ -234,7 +230,7 @@ function initOptions(term: TerminalType): void {
  });
  html += '</div><div class="option-group">';
  numberOptions.forEach(o => {
-    html += `<div class="option"><label>${o} <input id="opt-${o}" type="number" value="${term.getOption(o)}"/></label></div>`;
+    html += `<div class="option"><label>${o} <input id="opt-${o}" type="number" value="${term.getOption(o)}" step="${o === 'lineHeight' ? '0.1' : '1'}"/></label></div>`;
  });
  html += '</div><div class="option-group">';
  Object.keys(stringOptions).forEach(o => {
@@ -264,7 +260,7 @@ function initOptions(term: TerminalType): void {
      if (o === 'cols' || o === 'rows') {
        updateTerminalSize();
      } else {
-        term.setOption(o, parseInt(input.value, 10));
+        term.setOption(o, o === 'lineHeight' ? parseFloat(input.value) : parseInt(input.value, 10));
      }
    });
  });
@@ -2,8 +2,8 @@
 <html>
  <head>
    <title>xterm.js demo</title>
-    <link rel="stylesheet" href="/build/xterm.css" />
-    <link rel="stylesheet" href="/build/addons/fullscreen/fullscreen.css" />
+    <link rel="stylesheet" href="/src/xterm.css" />
+    <link rel="stylesheet" href="/src/addons/fullscreen/fullscreen.css" />
    <link rel="stylesheet" href="style.css" />
    <script src="https://cdnjs.cloudflare.com/ajax/libs/es6-promise/4.1.1/es6-promise.auto.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/fetch/1.0.0/fetch.min.js"></script>
@@ -1,84 +1,106 @@
 var express = require('express');
-var app = express();
-var expressWs = require('express-ws')(app);
+var expressWs = require('express-ws');
 var os = require('os');
 var pty = require('node-pty');

-var terminals = {},
-    logs = {};
+function startServer() {
+  var app = express();
+  expressWs(app);

-app.use('/build', express.static(__dirname + '/../build'));
+  var terminals = {},
+      logs = {};

-app.get('/', function(req, res){
-  res.sendFile(__dirname + '/index.html');
-});
+  app.use('/src', express.static(__dirname + '/../src'));

-app.get('/style.css', function(req, res){
-  res.sendFile(__dirname + '/style.css');
-});
-
-app.get('/dist/client-bundle.js', function(req, res){
-  res.sendFile(__dirname + '/dist/client-bundle.js');
-});
-
-app.post('/terminals', function (req, res) {
-  var cols = parseInt(req.query.cols),
-      rows = parseInt(req.query.rows),
-      term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
-        name: 'xterm-color',
-        cols: cols || 80,
-        rows: rows || 24,
-        cwd: process.env.PWD,
-        env: process.env
-      });
-
-  console.log('Created terminal with PID: ' + term.pid);
-  terminals[term.pid] = term;
-  logs[term.pid] = '';
-  term.on('data', function(data) {
-    logs[term.pid] += data;
+  app.get('/', function(req, res){
+    res.sendFile(__dirname + '/index.html');
  });
-  res.send(term.pid.toString());
-  res.end();
-});

-app.post('/terminals/:pid/size', function (req, res) {
-  var pid = parseInt(req.params.pid),
-      cols = parseInt(req.query.cols),
-      rows = parseInt(req.query.rows),
-      term = terminals[pid];
+  app.get('/style.css', function(req, res){
+    res.sendFile(__dirname + '/style.css');
+  });

-  term.resize(cols, rows);
-  console.log('Resized terminal ' + pid + ' to ' + cols + ' cols and ' + rows + ' rows.');
-  res.end();
-});
+  app.get('/dist/client-bundle.js', function(req, res){
+    res.sendFile(__dirname + '/dist/client-bundle.js');
+  });

-app.ws('/terminals/:pid', function (ws, req) {
-  var term = terminals[parseInt(req.params.pid)];
-  console.log('Connected to terminal ' + term.pid);
-  ws.send(logs[term.pid]);
+  app.post('/terminals', function (req, res) {
+    var cols = parseInt(req.query.cols),
+        rows = parseInt(req.query.rows),
+        term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
+          name: 'xterm-color',
+          cols: cols || 80,
+          rows: rows || 24,
+          cwd: process.env.PWD,
+          env: process.env
+        });

-  term.on('data', function(data) {
-    try {
-      ws.send(data);
-    } catch (ex) {
-      // The WebSocket is not open, ignore
+    console.log('Created terminal with PID: ' + term.pid);
+    terminals[term.pid] = term;
+    logs[term.pid] = '';
+    term.on('data', function(data) {
+      logs[term.pid] += data;
+    });
+    res.send(term.pid.toString());
+    res.end();
+  });
+
+  app.post('/terminals/:pid/size', function (req, res) {
+    var pid = parseInt(req.params.pid),
+        cols = parseInt(req.query.cols),
+        rows = parseInt(req.query.rows),
+        term = terminals[pid];
+
+    term.resize(cols, rows);
+    console.log('Resized terminal ' + pid + ' to ' + cols + ' cols and ' + rows + ' rows.');
+    res.end();
+  });
+
+  app.ws('/terminals/:pid', function (ws, req) {
+    var term = terminals[parseInt(req.params.pid)];
+    console.log('Connected to terminal ' + term.pid);
+    ws.send(logs[term.pid]);
+
+    function buffer(socket, timeout) {
+      let s = '';
+      let sender = null;
+      return (data) => {
+        s += data;
+        if (!sender) {
+          sender = setTimeout(() => {
+            socket.send(s);
+            s = '';
+            sender = null;
+          }, timeout);
+        }
+      };
    }
-  });
-  ws.on('message', function(msg) {
-    term.write(msg);
-  });
-  ws.on('close', function () {
-    term.kill();
-    console.log('Closed terminal ' + term.pid);
-    // Clean things up
-    delete terminals[term.pid];
-    delete logs[term.pid];
-  });
-});
+    const send = buffer(ws, 5);

-var port = process.env.PORT || 3000,
-    host = os.platform() === 'win32' ? '127.0.0.1' : '0.0.0.0';
+    term.on('data', function(data) {
+      try {
+        send(data);
+      } catch (ex) {
+        // The WebSocket is not open, ignore
+      }
+    });
+    ws.on('message', function(msg) {
+      term.write(msg);
+    });
+    ws.on('close', function () {
+      term.kill();
+      console.log('Closed terminal ' + term.pid);
+      // Clean things up
+      delete terminals[term.pid];
+      delete logs[term.pid];
+    });
+  });

-console.log('App listening to http://' + host + ':' + port);
-app.listen(port, host);
+  var port = process.env.PORT || 3000,
+      host = os.platform() === 'win32' ? '127.0.0.1' : '0.0.0.0';
+
+  console.log('App listening to http://127.0.0.1:' + port);
+  app.listen(port, host);
+}
+
+module.exports = startServer;
@@ -5,12 +5,11 @@
 * This file is the entry point for browserify.
 */

-const cp = require('child_process');
 const path = require('path');
 const webpack = require('webpack');
+const startServer = require('./server.js');

-// Launch server
-cp.spawn('node', [path.resolve(__dirname, 'server.js')], { stdio: 'inherit' });
+startServer();

 // Build/watch client source
 const clientConfig = {
@@ -22,6 +21,11 @@ const clientConfig = {
        test: /\.tsx?$/,
        use: 'ts-loader',
        exclude: /node_modules/
+      },
+      {
+        test: /\.js$/,
+        use: ["source-map-loader"],
+        enforce: "pre"
      }
    ]
  },
@@ -1,87 +0,0 @@
-var express = require('express');
-var app = express();
-var expressWs = require('express-ws')(app);
-var os = require('os');
-var pty = require('node-pty');
-
-var terminals = {},
-    logs = {};
-
-app.use('/build', express.static(__dirname + '/../../build'));
-app.use('/demo', express.static(__dirname + '/../../demo'));
-app.use('/zmodemjs', express.static(__dirname + '/../../node_modules/zmodem.js/dist'));
-
-app.get('/', function(req, res){
-  res.sendFile(__dirname + '/index.html');
-});
-
-app.get('/style.css', function(req, res){
-  res.sendFile(__dirname + '../style.css');
-});
-
-app.get('/main.js', function(req, res){
-  res.sendFile(__dirname + '/main.js');
-});
-
-app.post('/terminals', function (req, res) {
-  var cols = parseInt(req.query.cols),
-      rows = parseInt(req.query.rows),
-      term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
-        encoding: null,
-        name: 'xterm-color',
-        cols: cols || 80,
-        rows: rows || 24,
-        cwd: process.env.PWD,
-        env: process.env
-      });
-
-  console.log('Created terminal with PID: ' + term.pid);
-  terminals[term.pid] = term;
-  logs[term.pid] = '';
-  term.on('data', function(data) {
-    logs[term.pid] += data;
-  });
-  res.send(term.pid.toString());
-  res.end();
-});
-
-app.post('/terminals/:pid/size', function (req, res) {
-  var pid = parseInt(req.params.pid),
-      cols = parseInt(req.query.cols),
-      rows = parseInt(req.query.rows),
-      term = terminals[pid];
-
-  term.resize(cols, rows);
-  console.log('Resized terminal ' + pid + ' to ' + cols + ' cols and ' + rows + ' rows.');
-  res.end();
-});
-
-app.ws('/terminals/:pid', function (ws, req) {
-  var term = terminals[parseInt(req.params.pid)];
-  console.log('Connected to terminal ' + term.pid);
-  ws.send(logs[term.pid]);
-
-  term.on('data', function(data) {
-    try {
-      ws.send(data);
-    } catch (ex) {
-      // The WebSocket is not open, ignore
-    }
-  });
-  ws.on('message', function(msg) {
-    term.write(msg);
-  });
-  ws.on('close', function () {
-    term.kill();
-    console.log('Closed terminal ' + term.pid);
-    // Clean things up
-    delete terminals[term.pid];
-    delete logs[term.pid];
-  });
-});
-
-var port = process.env.PORT || 3000,
-    host = os.platform() === 'win32' ? '127.0.0.1' : '0.0.0.0';
-
-console.log('App listening to http://' + host + ':' + port);
-app.listen(port, host);
@@ -1,128 +0,0 @@
-<!doctype html>
-<html>
-    <head>
-        <title>xterm.js demo</title>
-        <link rel="stylesheet" href="/build/xterm.css" />
-        <link rel="stylesheet" href="/build/addons/fullscreen/fullscreen.css" />
-        <link rel="stylesheet" href="/demo/style.css" />
-      	<script src="https://cdnjs.cloudflare.com/ajax/libs/es6-promise/4.1.1/es6-promise.auto.min.js"></script>
-      	<script src="https://cdnjs.cloudflare.com/ajax/libs/fetch/1.0.0/fetch.min.js"></script>
-        <script src="/build/xterm.js" ></script>
-
-        <script src="/build/addons/attach/attach.js" ></script>
-        <script src="/zmodemjs/zmodem.js"></script>
-        <script src="/build/addons/zmodem/zmodem.js" ></script>
-
-        <script src="/build/addons/fit/fit.js" ></script>
-        <script src="/build/addons/fullscreen/fullscreen.js" ></script>
-        <script src="/build/addons/search/search.js" ></script>
-    </head>
-    <body>
-        <h1>xterm.js: xterm, in the browser</h1>
-
-        <div id="terminal-container"></div>
-
-        <div id="zmodem_controls">
-            <form id="zm_start" style="display: none" action="javascript:void(0)">
-                ZMODEM detected: Start ZMODEM session?
-                <label><input id="zmstart_yes" name="zmstart" type=radio checked value="1"> Yes</label>
-                &nbsp;
-                <label><input name="zmstart" type=radio value=""> No</label>
-                <button type="submit">Submit</button>
-            </form>
-
-            <form id="zm_offer" style="display: none" action="javascript:void(0)">
-                <p>ZMODEM File offered!</p>
-
-                <label><input id="zmaccept_yes" name="zmaccept" type=radio checked value="1"> Accept</label>
-                &nbsp;
-                <label><input name="zmaccept" type=radio value=""> Skip</label>
-                <button type="submit">Submit</button>
-            </form>
-
-            <div id="zm_file" style="display: none">
-                <div>Name: <span id="name"></span></div>
-                <div>Size: <span id="size"></span></div>
-                <div>Last modified: <span id="mtime"></span></div>
-                <div>Mode: <span id="mode"></span></div>
-                <br>
-                <div>Conversion: <span id="zfile_conversion"></span></div>
-                <div>Management: <span id="zfile_management"></span></div>
-                <div>Transport: <span id="zfile_transport"></span></div>
-                <div>Sparse? <span id="zfile_sparse"></span></div>
-                <br>
-                <div>Files remaining in batch: <span id="files_remaining"></span></div>
-                <div>Bytes remaining in batch: <span id="bytes_remaining"></span></div>
-            </div>
-
-            <form id="zm_progress" style="display: none" action="javascript:void(0)">
-                <div><span id="percent_received"></span>% (<span id="bytes_received"></span> bytes) received</div>
-                <button id="zm_progress_skipper" type="button" onclick="skip_current_file();">Skip File</button>
-            </form>
-
-            <form id="zm_choose" style="display: none" action="javascript:void(0)">
-                <label>Choose file(s): <input id="zm_files" type="file" multiple></label>
-            </form>
-        </div>
-
-        <div>
-          <h2>Actions</h2>
-          <p>
-            <label>Find next <input id="find-next"/></label>
-            <label>Find previous <input id="find-previous"/></label>
-          </p>
-        </div>
-        <div>
-          <h2>Options</h2>
-          <p>
-            <label><input type="checkbox" id="option-cursor-blink"> cursorBlink</label>
-          </p>
-          <p>
-            <label><input type="checkbox" checked id="zmodem-auto"> Accept all ZMODEM prompts<sup>*</sup></label>
-          </p>
-          <p>
-            <label>
-              cursorStyle
-              <select id="option-cursor-style">
-                <option value="block">block</option>
-                <option value="underline">underline</option>
-                <option value="bar">bar</option>
-              </select>
-            </label>
-          </p>
-          <p>
-            <label>
-              bellStyle
-              <select id="option-bell-style">
-                <option value="">none</option>
-                <option value="sound">sound</option>
-                <option value="visual">visual</option>
-                <option value="both">both</option>
-              </select>
-            </label>
-          </p>
-          <p>
-            <label>scrollback <input type="number" id="option-scrollback" value="1000" /></label>
-          </p>
-          <p>
-            <label>tabStopWidth <input type="number" id="option-tabstopwidth" value="8" /></label>
-          </p>
-          <div>
-          	<h3>Size</h3>
-            <div>
-              <div style="display: inline-block; margin-right: 16px;">
-                <label for="cols">Columns</label>
-                <input type="number" id="cols" />
-              </div>
-              <div style="display: inline-block; margin-right: 16px;">
-                <label for="rows">Rows</label>
-                <input type="number" id="rows" />
-              </div>
-            </div>
-          </div>
-        </div>
-        <p><strong>Attention:</strong> The demo is a barebones implementation and is designed for xterm.js evaluation purposes only. Exposing the demo to the public as is would introduce security risks for the host.</p>
-        <p><sup>*</sup> ZMODEM file transfers are supported via an addon. To try it out, install <a href="https://ohse.de/uwe/software/lrzsz.html"><code>lrzsz</code></a> onto the remote peer, then run <code>rz</code> to send from your browser or <code>sz &lt;file&gt;</code> to send from the remote peer.</p>
-        <script src="main.js" defer ></script>
-    </body>
-</html>
@@ -1,388 +0,0 @@
-"use strict";
-
-var term,
-    protocol,
-    socketURL,
-    socket,
-    pid;
-
-Terminal.applyAddon(fit);
-Terminal.applyAddon(attach);
-Terminal.applyAddon(zmodem);
-Terminal.applyAddon(search);
-
-var terminalContainer = document.getElementById('terminal-container'),
-    actionElements = {
-      findNext: document.querySelector('#find-next'),
-      findPrevious: document.querySelector('#find-previous')
-    },
-    optionElements = {
-      cursorBlink: document.querySelector('#option-cursor-blink'),
-      cursorStyle: document.querySelector('#option-cursor-style'),
-      scrollback: document.querySelector('#option-scrollback'),
-      tabstopwidth: document.querySelector('#option-tabstopwidth'),
-      bellStyle: document.querySelector('#option-bell-style')
-    },
-    colsElement = document.getElementById('cols'),
-    rowsElement = document.getElementById('rows');
-
-function setTerminalSize() {
-  var cols = parseInt(colsElement.value, 10);
-  var rows = parseInt(rowsElement.value, 10);
-  var viewportElement = document.querySelector('.xterm-viewport');
-  var scrollBarWidth = viewportElement.offsetWidth - viewportElement.clientWidth;
-  var width = (cols * term.charMeasure.width + 20 /*room for scrollbar*/).toString() + 'px';
-  var height = (rows * term.charMeasure.height).toString() + 'px';
-
-  terminalContainer.style.width = width;
-  terminalContainer.style.height = height;
-  term.resize(cols, rows);
-}
-
-colsElement.addEventListener('change', setTerminalSize);
-rowsElement.addEventListener('change', setTerminalSize);
-
-actionElements.findNext.addEventListener('keypress', function (e) {
-  if (e.key === "Enter") {
-    e.preventDefault();
-    term.findNext(actionElements.findNext.value);
-  }
-});
-actionElements.findPrevious.addEventListener('keypress', function (e) {
-  if (e.key === "Enter") {
-    e.preventDefault();
-    term.findPrevious(actionElements.findPrevious.value);
-  }
-});
-
-optionElements.cursorBlink.addEventListener('change', function () {
-  term.setOption('cursorBlink', optionElements.cursorBlink.checked);
-});
-optionElements.cursorStyle.addEventListener('change', function () {
-  term.setOption('cursorStyle', optionElements.cursorStyle.value);
-});
-optionElements.bellStyle.addEventListener('change', function () {
-  term.setOption('bellStyle', optionElements.bellStyle.value);
-});
-optionElements.scrollback.addEventListener('change', function () {
-  term.setOption('scrollback', parseInt(optionElements.scrollback.value, 10));
-});
-optionElements.tabstopwidth.addEventListener('change', function () {
-  term.setOption('tabStopWidth', parseInt(optionElements.tabstopwidth.value, 10));
-});
-
-createTerminal();
-
-function createTerminal() {
-  // Clean terminal
-  while (terminalContainer.children.length) {
-    terminalContainer.removeChild(terminalContainer.children[0]);
-  }
-  term = new Terminal({
-    cursorBlink: optionElements.cursorBlink.checked,
-    scrollback: parseInt(optionElements.scrollback.value, 10),
-    tabStopWidth: parseInt(optionElements.tabstopwidth.value, 10)
-  });
-  term.on('resize', function (size) {
-    if (!pid) {
-      return;
-    }
-    var cols = size.cols,
-        rows = size.rows,
-        url = '/terminals/' + pid + '/size?cols=' + cols + '&rows=' + rows;
-
-    fetch(url, {method: 'POST'});
-  });
-  protocol = (location.protocol === 'https:') ? 'wss://' : 'ws://';
-  socketURL = protocol + location.hostname + ((location.port) ? (':' + location.port) : '') + '/terminals/';
-
-  term.open(terminalContainer);
-  term.fit();
-
-  // fit is called within a setTimeout, cols and rows need this.
-  setTimeout(function () {
-    colsElement.value = term.cols;
-    rowsElement.value = term.rows;
-
-    // Set terminal size again to set the specific dimensions on the demo
-    setTerminalSize();
-
-    fetch('/terminals?cols=' + term.cols + '&rows=' + term.rows, {method: 'POST'}).then(function (res) {
-
-      res.text().then(function (pid) {
-        window.pid = pid;
-        socketURL += pid;
-        socket = new WebSocket(socketURL);
-        socket.onopen = runRealTerminal;
-        socket.onclose = runFakeTerminal;
-        socket.onerror = runFakeTerminal;
-
-        term.zmodemAttach(socket, {
-            noTerminalWriteOutsideSession: true,
-        } );
-
-        term.on("zmodemRetract", () => {
-            start_form.style.display = "none";
-            start_form.onsubmit = null;
-        });
-
-        term.on("zmodemDetect", (detection) => {
-            function do_zmodem() {
-                term.detach();
-                let zsession = detection.confirm();
-
-                var promise;
-
-                if (zsession.type === "receive") {
-                    promise = _handle_receive_session(zsession);
-                }
-                else {
-                    promise = _handle_send_session(zsession);
-                }
-
-                promise.catch( console.error.bind(console) ).then( () => {
-                    term.attach(socket);
-                } );
-            }
-
-            if (_auto_zmodem()) {
-                do_zmodem();
-            }
-            else {
-                start_form.style.display = "";
-                start_form.onsubmit = function(e) {
-                    start_form.style.display = "none";
-
-                    if (document.getElementById("zmstart_yes").checked) {
-                        do_zmodem();
-                    }
-                    else {
-                        detection.deny();
-                    }
-                };
-            }
-        });
-      });
-    });
-  }, 0);
-}
-
-//----------------------------------------------------------------------
-// UI STUFF
-
-function _show_file_info(xfer) {
-    var file_info = xfer.get_details();
-
-    document.getElementById("name").textContent = file_info.name;
-    document.getElementById("size").textContent = file_info.size;
-    document.getElementById("mtime").textContent = file_info.mtime;
-    document.getElementById("files_remaining").textContent = file_info.files_remaining;
-    document.getElementById("bytes_remaining").textContent = file_info.bytes_remaining;
-
-    document.getElementById("mode").textContent = "0" + file_info.mode.toString(8);
-
-    var xfer_opts = xfer.get_options();
-    ["conversion", "management", "transport", "sparse"].forEach( (lbl) => {
-        document.getElementById(`zfile_${lbl}`).textContent = xfer_opts[lbl];
-    } );
-
-    document.getElementById("zm_file").style.display = "";
-}
-function _hide_file_info() {
-    document.getElementById("zm_file").style.display = "none";
-}
-
-function _save_to_disk(xfer, buffer) {
-    return Zmodem.Browser.save_to_disk(buffer, xfer.get_details().name);
-}
-
-var skipper_button = document.getElementById("zm_progress_skipper");
-var skipper_button_orig_text = skipper_button.textContent;
-
-function _show_progress() {
-    skipper_button.disabled = false;
-    skipper_button.textContent = skipper_button_orig_text;
-
-    document.getElementById("bytes_received").textContent = 0;
-    document.getElementById("percent_received").textContent = 0;
-
-    document.getElementById("zm_progress").style.display = "";
-}
-
-function _update_progress(xfer) {
-    var total_in = xfer.get_offset();
-
-    document.getElementById("bytes_received").textContent = total_in;
-
-    var percent_received = 100 * total_in / xfer.get_details().size;
-    document.getElementById("percent_received").textContent = percent_received.toFixed(2);
-}
-
-function _hide_progress() {
-    document.getElementById("zm_progress").style.display = "none";
-}
-
-var start_form = document.getElementById("zm_start");
-
-function _auto_zmodem() {
-    return document.getElementById("zmodem-auto").checked;
-}
-
-// END UI STUFF
-//----------------------------------------------------------------------
-
-function _handle_receive_session(zsession) {
-    zsession.on("offer", function(xfer) {
-        current_receive_xfer = xfer;
-
-        _show_file_info(xfer);
-
-        var offer_form = document.getElementById("zm_offer");
-
-        function on_form_submit() {
-            offer_form.style.display = "none";
-
-            //START
-            //if (offer_form.zmaccept.value) {
-            if (_auto_zmodem() || document.getElementById("zmaccept_yes").checked) {
-                _show_progress();
-
-                var FILE_BUFFER = [];
-                xfer.on("input", (payload) => {
-                    _update_progress(xfer);
-                    FILE_BUFFER.push( new Uint8Array(payload) );
-                });
-                xfer.accept().then(
-                    () => {
-                        _save_to_disk(xfer, FILE_BUFFER);
-                    },
-                    console.error.bind(console)
-                );
-            }
-            else {
-                xfer.skip();
-            }
-            //END
-        }
-
-        if (_auto_zmodem()) {
-            on_form_submit();
-        }
-        else {
-            offer_form.onsubmit = on_form_submit;
-            offer_form.style.display = "";
-        }
-    } );
-
-    var promise = new Promise( (res) => {
-        zsession.on("session_end", () => {
-            _hide_file_info();
-            _hide_progress();
-            res();
-        } );
-    } );
-
-    zsession.start();
-
-    return promise;
-}
-
-function _handle_send_session(zsession) {
-    var choose_form = document.getElementById("zm_choose");
-    choose_form.style.display = "";
-
-    var file_el = document.getElementById("zm_files");
-
-    var promise = new Promise( (res) => {
-        file_el.onchange = function(e) {
-            choose_form.style.display = "none";
-
-            var files_obj = file_el.files;
-
-            Zmodem.Browser.send_files(
-                zsession,
-                files_obj,
-                {
-                    on_offer_response(obj, xfer) {
-                        if (xfer) _show_progress();
-                        //console.log("offer", xfer ? "accepted" : "skipped");
-                    },
-                    on_progress(obj, xfer) {
-                        _update_progress(xfer);
-                    },
-                    on_file_complete(obj) {
-                        //console.log("COMPLETE", obj);
-                        _hide_progress();
-                    },
-                }
-            ).then(_hide_progress).then(
-                zsession.close.bind(zsession),
-                console.error.bind(console)
-            ).then( () => {
-                _hide_file_info();
-                _hide_progress();
-                res();
-            } );
-        };
-    } );
-
-    return promise;
-}
-
-//This is here to allow canceling of an in-progress ZMODEM transfer.
-var current_receive_xfer;
-
-//Called from HTML directly.
-function skip_current_file() {
-    current_receive_xfer.skip();
-
-    skipper_button.disabled = true;
-    skipper_button.textContent = "Waiting for server to acknowledge skip …";
-}
-
-function runRealTerminal() {
-    term.attach(socket);
-
-    term._initialized = true;
-}
-
-function runFakeTerminal() {
-  if (term._initialized) {
-    return;
-  }
-
-  term._initialized = true;
-
-  var shellprompt = '$ ';
-
-  term.prompt = function () {
-    term.write('\r\n' + shellprompt);
-  };
-
-  term.writeln('Welcome to xterm.js');
-  term.writeln('This is a local terminal emulation, without a real terminal in the back-end.');
-  term.writeln('Type some keys and commands to play around.');
-  term.writeln('');
-  term.prompt();
-
-  term.on('key', function (key, ev) {
-    var printable = (
-      !ev.altKey && !ev.altGraphKey && !ev.ctrlKey && !ev.metaKey
-    );
-
-    if (ev.keyCode == 13) {
-      term.prompt();
-    } else if (ev.keyCode == 8) {
-     // Do not delete the prompt
-      if (term.x > 2) {
-        term.write('\b \b');
-      }
-    } else if (printable) {
-      term.write(key);
-    }
-  });
-
-  term.on('paste', function (data, ev) {
-    term.write(data);
-  });
-}
@@ -7,7 +7,7 @@ services:
    volumes:
      - ./:/usr/src/app
    ports:
-      - ${XTERMJS_PORT:3000}:3000
+      - ${XTERMJS_PORT:-3000}:3000
    command: ["npm", "start"]

  watch:
@@ -4,7 +4,7 @@

 /// <reference path="../../typings/xterm.d.ts" />

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

 namespace constructor {
  {
@@ -119,6 +119,12 @@ namespace methods_core {
    const t: Terminal = new Terminal();
    t.attachCustomKeyEventHandler((e: KeyboardEvent) => true);
    t.attachCustomKeyEventHandler((e: KeyboardEvent) => false);
+    const d1: IDisposable = t.addCsiHandler("x",
+       (params: number[], collect: string): boolean => params[0]===1);
+    d1.dispose();
+    const d2: IDisposable = t.addOscHandler(199,
+       (data: string): boolean => true);
+    d2.dispose();
  }
  namespace options {
    {
@@ -16,9 +16,9 @@ const ts = require('gulp-typescript');
 const util = require('gulp-util');

 const buildDir = process.env.BUILD_DIR || 'build';
-const tsProject = ts.createProject('tsconfig.json');
-let srcDir = tsProject.config.compilerOptions.rootDir;
-let outDir = tsProject.config.compilerOptions.outDir;
+const tsProject = ts.createProject('src/tsconfig.json');
+let srcDir = './src';
+let outDir = './lib';

 const addons = fs.readdirSync(`${__dirname}/src/addons`);

@@ -61,7 +61,7 @@ gulp.task('browserify', function() {
  };
  let bundleStream = browserify(browserifyOptions)
        .bundle()
-        .pipe(source('xterm.js'))
+        .pipe(source(`xterm.js`))
        .pipe(buffer())
        .pipe(sourcemaps.init({loadMaps: true, sourceRoot: '..'}))
        .pipe(sourcemaps.write('./'))
@@ -136,6 +136,6 @@ gulp.task('sorcery-addons', ['browserify-addons'], function () {
  })
 });

-gulp.task('build', ['sorcery', 'sorcery-addons']);
+gulp.task('build', ['css', 'sorcery', 'sorcery-addons']);
 gulp.task('test', ['mocha']);
 gulp.task('default', ['build']);
@@ -1,7 +1,7 @@
 {
  "name": "xterm",
  "description": "Full xterm terminal, in your browser",
-  "version": "3.8.0",
+  "version": "3.13.1",
  "main": "lib/public/Terminal.js",
  "types": "typings/xterm.d.ts",
  "repository": "https://github.com/xtermjs/xterm.js",
@@ -15,7 +15,6 @@
    "@types/webpack": "^4.4.11",
    "browserify": "^13.3.0",
    "chai": "3.5.0",
-    "concurrently": "^3.5.1",
    "coveralls": "^3.0.1",
    "express": "4.13.4",
    "express-ws": "2.0.0-rc.1",
@@ -28,18 +27,17 @@
    "gulp-sourcemaps": "1.9.1",
    "gulp-typescript": "^3.1.3",
    "gulp-util": "3.0.8",
-    "jsdoc": "3.4.3",
    "jsdom": "^11.11.0",
    "merge-stream": "^1.0.1",
    "node-pty": "0.7.6",
    "nodemon": "1.10.2",
    "nyc": "^11.8.0",
    "sorcery": "^0.10.0",
-    "source-map-loader": "^0.2.3",
+    "source-map-loader": "^0.2.4",
    "ts-loader": "^4.5.0",
    "tslint": "^5.9.1",
    "tslint-consistent-codestyle": "^1.13.0",
-    "typescript": "3.0",
+    "typescript": "3.4",
    "vinyl-buffer": "^1.0.0",
    "vinyl-source-stream": "^1.1.0",
    "webpack": "^4.17.1",
@@ -48,6 +46,7 @@
  },
  "scripts": {
    "start": "node demo/start",
+    "start-debug": "node --inspect-brk demo/start",
    "start-zmodem": "node demo/zmodem/app",
    "lint": "tslint 'src/**/*.ts' './demo/**/*.ts'",
    "test": "npm run mocha",
@@ -56,14 +55,10 @@
    "test-suite": "gulp mocha-suite --test",
    "test-coverage": "nyc -x gulpfile.js -x '**/*test*' npm run mocha",
    "mocha": "gulp test",
-    "build:docs": "jsdoc -c jsdoc.json",
-    "tsc": "tsc",
-    "prebuild": "concurrently --kill-others-on-fail --names \"lib,attach,fit,fullscreen,search,terminado,webLinks,winptyCompat,zmodem,css\" \"tsc\" \"tsc -p ./src/addons/attach\" \"tsc -p ./src/addons/fit\" \"tsc -p ./src/addons/fullscreen\" \"tsc -p ./src/addons/search\" \"tsc -p ./src/addons/terminado\" \"tsc -p ./src/addons/webLinks\" \"tsc -p ./src/addons/winptyCompat\" \"tsc -p ./src/addons/zmodem\" \"gulp css\"",
+    "prebuild": "tsc -b ./src/tsconfig.all.json",
    "build": "gulp build",
    "prepublish": "npm run build",
    "coveralls": "nyc report --reporter=text-lcov | coveralls",
-    "webpack": "gulp webpack",
-    "watch": "concurrently --kill-others-on-fail --names \"lib,css\" \"tsc -w\" \"gulp watch-css\"",
-    "watch-addons": "concurrently --kill-others-on-fail --names \"attach,fit,fullscreen,search,terminado,webLinks,winptyCompat,zmodem\" \"tsc -w -p ./src/addons/attach\" \"tsc -w -p ./src/addons/fit\" \"tsc -w -p ./src/addons/fullscreen\" \"tsc -w -p ./src/addons/search\" \"tsc -w -p ./src/addons/terminado\" \"tsc -w -p ./src/addons/webLinks\" \"tsc -w -p ./src/addons/winptyCompat\" \"tsc -w -p ./src/addons/zmodem\""
+    "watch": "tsc -b -w ./src/tsconfig.all.json --preserveWatchOutput"
  }
 }
@@ -5,7 +5,7 @@

 import * as Strings from './Strings';
 import { ITerminal, IBuffer } from './Types';
-import { isMac } from './shared/utils/Browser';
+import { isMac } from './common/Platform';
 import { RenderDebouncer } from './ui/RenderDebouncer';
 import { addDisposableDomListener } from './ui/Lifecycle';
 import { Disposable } from './common/Lifecycle';
@@ -61,7 +61,7 @@ export class AccessibilityManager extends Disposable {
    this._refreshRowsDimensions();
    this._accessibilityTreeRoot.appendChild(this._rowContainer);

-    this._renderRowsDebouncer = new RenderDebouncer(this._terminal, this._renderRows.bind(this));
+    this._renderRowsDebouncer = new RenderDebouncer(this._renderRows.bind(this));
    this._refreshRows();

    this._liveRegion = document.createElement('div');
@@ -72,20 +72,20 @@ export class AccessibilityManager extends Disposable {
    this._terminal.element.insertAdjacentElement('afterbegin', this._accessibilityTreeRoot);

    this.register(this._renderRowsDebouncer);
-    this.register(this._terminal.addDisposableListener('resize', data => this._onResize(data.rows)));
-    this.register(this._terminal.addDisposableListener('refresh', data => this._refreshRows(data.start, data.end)));
-    this.register(this._terminal.addDisposableListener('scroll', data => this._refreshRows()));
+    this.register(this._terminal.onResize(e => this._onResize(e.rows)));
+    this.register(this._terminal.onRender(e => this._refreshRows(e.start, e.end)));
+    this.register(this._terminal.onScroll(() => this._refreshRows()));
    // Line feed is an issue as the prompt won't be read out after a command is run
    this.register(this._terminal.addDisposableListener('a11y.char', (char) => this._onChar(char)));
-    this.register(this._terminal.addDisposableListener('linefeed', () => this._onChar('\n')));
+    this.register(this._terminal.onLineFeed(() => this._onChar('\n')));
    this.register(this._terminal.addDisposableListener('a11y.tab', spaceCount => this._onTab(spaceCount)));
-    this.register(this._terminal.addDisposableListener('key', keyChar => this._onKey(keyChar)));
+    this.register(this._terminal.onKey(e => this._onKey(e.key)));
    this.register(this._terminal.addDisposableListener('blur', () => this._clearLiveRegion()));
    // TODO: Maybe renderer should fire an event on terminal when the characters change and that
    //       should be listened to instead? That would mean that the order of events are always
    //       guarenteed
    this.register(this._terminal.addDisposableListener('dprchange', () => this._refreshRowsDimensions()));
-    this.register(this._terminal.renderer.addDisposableListener('resize', () => this._refreshRowsDimensions()));
+    this.register(this._terminal.renderer.onCanvasResize(() => this._refreshRowsDimensions()));
    // This shouldn't be needed on modern browsers but is present in case the
    // media query that drives the dprchange event isn't supported
    this.register(addDisposableDomListener(window, 'resize', () => this._refreshRowsDimensions()));
@@ -239,7 +239,7 @@ export class AccessibilityManager extends Disposable {
  }

  private _refreshRows(start?: number, end?: number): void {
-    this._renderRowsDebouncer.refresh(start, end);
+    this._renderRowsDebouncer.refresh(start, end, this._terminal.rows);
  }

  private _renderRows(start: number, end: number): void {
@@ -249,9 +249,11 @@ export class AccessibilityManager extends Disposable {
      const lineData = buffer.translateBufferLineToString(buffer.ydisp + i, true);
      const posInSet = (buffer.ydisp + i + 1).toString();
      const element = this._rowElements[i];
-      element.textContent = lineData.length === 0 ? Strings.blankLine : lineData;
-      element.setAttribute('aria-posinset', posInSet);
-      element.setAttribute('aria-setsize', setSize);
+      if (element) {
+        element.textContent = lineData.length === 0 ? Strings.blankLine : lineData;
+        element.setAttribute('aria-posinset', posInSet);
+        element.setAttribute('aria-setsize', setSize);
+      }
    }
  }

@@ -3,22 +3,42 @@
 * @license MIT
 */

-import { CircularList } from './common/CircularList';
-import { CharData, ITerminal, IBuffer, IBufferLine, BufferIndex, IBufferStringIterator, IBufferStringIteratorResult } from './Types';
-import { EventEmitter } from './common/EventEmitter';
+import { CircularList, IInsertEvent } from './common/CircularList';
+import { ITerminal, IBuffer, IBufferLine, BufferIndex, IBufferStringIterator, IBufferStringIteratorResult, ICellData, IAttributeData } from './Types';
 import { IMarker } from 'xterm';
-import { BufferLine } from './BufferLine';
+import { BufferLine, CellData, AttributeData } from './BufferLine';
+import { reflowLargerApplyNewLayout, reflowLargerCreateNewLayout, reflowLargerGetLinesToRemove, reflowSmallerGetNewLineLengths, getWrappedLineTrimmedLength } from './BufferReflow';
+import { DEFAULT_COLOR } from './renderer/atlas/Types';
+import { EventEmitter2, IEvent } from './common/EventEmitter2';
+import { Disposable } from '../lib/common/Lifecycle';
+
+export const DEFAULT_ATTR = (0 << 18) | (DEFAULT_COLOR << 9) | (256 << 0);
+
+export const DEFAULT_ATTR_DATA = new AttributeData();

-export const DEFAULT_ATTR = (0 << 18) | (257 << 9) | (256 << 0);
 export const CHAR_DATA_ATTR_INDEX = 0;
 export const CHAR_DATA_CHAR_INDEX = 1;
 export const CHAR_DATA_WIDTH_INDEX = 2;
 export const CHAR_DATA_CODE_INDEX = 3;
 export const MAX_BUFFER_SIZE = 4294967295; // 2^32 - 1

-export const NULL_CELL_CHAR = ' ';
+/**
+ * Null cell - a real empty cell (containing nothing).
+ * Note that code should always be 0 for a null cell as
+ * several test condition of the buffer line rely on this.
+ */
+export const NULL_CELL_CHAR = '';
 export const NULL_CELL_WIDTH = 1;
-export const NULL_CELL_CODE = 32;
+export const NULL_CELL_CODE = 0;
+
+/**
+ * Whitespace cell.
+ * This is meant as a replacement for empty cells when needed
+ * during rendering lines to preserve correct aligment.
+ */
+export const WHITESPACE_CELL_CHAR = ' ';
+export const WHITESPACE_CELL_WIDTH = 1;
+export const WHITESPACE_CELL_CODE = 32;

 /**
 * This class represents a terminal buffer (an internal state of the terminal), where the
@@ -38,7 +58,12 @@ export class Buffer implements IBuffer {
  public tabs: any;
  public savedY: number;
  public savedX: number;
+  public savedCurAttrData = DEFAULT_ATTR_DATA.clone();
  public markers: Marker[] = [];
+  private _nullCell: ICellData = CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+  private _whitespaceCell: ICellData = CellData.fromCharData([0, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_WIDTH, WHITESPACE_CELL_CODE]);
+  private _cols: number;
+  private _rows: number;

  /**
   * Create a new Buffer.
@@ -50,17 +75,45 @@ export class Buffer implements IBuffer {
    private _terminal: ITerminal,
    private _hasScrollback: boolean
  ) {
+    this._cols = this._terminal.cols;
+    this._rows = this._terminal.rows;
    this.clear();
  }

+  public getNullCell(attr?: IAttributeData): ICellData {
+    if (attr) {
+      this._nullCell.fg = attr.fg;
+      this._nullCell.bg = attr.bg;
+    } else {
+      this._nullCell.fg = 0;
+      this._nullCell.bg = 0;
+    }
+    return this._nullCell;
+  }
+
+  public getWhitespaceCell(attr?: IAttributeData): ICellData {
+    if (attr) {
+      this._whitespaceCell.fg = attr.fg;
+      this._whitespaceCell.bg = attr.bg;
+    } else {
+      this._whitespaceCell.fg = 0;
+      this._whitespaceCell.bg = 0;
+    }
+    return this._whitespaceCell;
+  }
+
+  public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
+    return new BufferLine(this._terminal.cols, this.getNullCell(attr), isWrapped);
+  }
+
  public get hasScrollback(): boolean {
-    return this._hasScrollback && this.lines.maxLength > this._terminal.rows;
+    return this._hasScrollback && this.lines.maxLength > this._rows;
  }

  public get isCursorInViewport(): boolean {
    const absoluteY = this.ybase + this.y;
    const relativeY = absoluteY - this.ydisp;
-    return (relativeY >= 0 && relativeY < this._terminal.rows);
+    return (relativeY >= 0 && relativeY < this._rows);
  }

  /**
@@ -81,11 +134,14 @@ export class Buffer implements IBuffer {
  /**
   * Fills the buffer's viewport with blank lines.
   */
-  public fillViewportRows(): void {
+  public fillViewportRows(fillAttr?: IAttributeData): void {
    if (this.lines.length === 0) {
-      let i = this._terminal.rows;
+      if (fillAttr === undefined) {
+        fillAttr = DEFAULT_ATTR_DATA;
+      }
+      let i = this._rows;
      while (i--) {
-        this.lines.push(BufferLine.blankLine(this._terminal.cols, DEFAULT_ATTR));
+        this.lines.push(this.getBlankLine(fillAttr));
      }
    }
  }
@@ -98,9 +154,9 @@ export class Buffer implements IBuffer {
    this.ybase = 0;
    this.y = 0;
    this.x = 0;
-    this.lines = new CircularList<IBufferLine>(this._getCorrectBufferLength(this._terminal.rows));
+    this.lines = new CircularList<IBufferLine>(this._getCorrectBufferLength(this._rows));
    this.scrollTop = 0;
-    this.scrollBottom = this._terminal.rows - 1;
+    this.scrollBottom = this._rows - 1;
    this.setupTabStops();
  }

@@ -110,6 +166,9 @@ export class Buffer implements IBuffer {
   * @param newRows The new number of rows.
   */
  public resize(newCols: number, newRows: number): void {
+    // store reference to null cell with default attrs
+    const nullCell = this.getNullCell(DEFAULT_ATTR_DATA);
+
    // Increase max length if needed before adjustments to allow space to fill
    // as required.
    const newMaxLength = this._getCorrectBufferLength(newRows);
@@ -120,20 +179,17 @@ export class Buffer implements IBuffer {
    // The following adjustments should only happen if the buffer has been
    // initialized/filled.
    if (this.lines.length > 0) {
-      // Deal with columns increasing (we don't do anything when columns reduce)
-      if (this._terminal.cols < newCols) {
-        const ch: CharData = [DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // does xterm use the default attr?
+      // Deal with columns increasing (reducing needs to happen after reflow)
+      if (this._cols < newCols) {
        for (let i = 0; i < this.lines.length; i++) {
-          while (this.lines.get(i).length < newCols) {
-            this.lines.get(i).push(ch);
-          }
+          this.lines.get(i).resize(newCols, nullCell);
        }
      }

      // Resize rows in both directions as needed
      let addToY = 0;
-      if (this._terminal.rows < newRows) {
-        for (let y = this._terminal.rows; y < newRows; y++) {
+      if (this._rows < newRows) {
+        for (let y = this._rows; y < newRows; y++) {
          if (this.lines.length < newRows + this.ybase) {
            if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) {
              // There is room above the buffer and there are no empty elements below the line,
@@ -147,12 +203,12 @@ export class Buffer implements IBuffer {
            } else {
              // Add a blank line if there is no buffer left at the top to scroll to, or if there
              // are blank lines after the cursor
-              this.lines.push(BufferLine.blankLine(newCols, DEFAULT_ATTR));
+              this.lines.push(new BufferLine(newCols, nullCell));
            }
          }
        }
-      } else { // (this._terminal.rows >= newRows)
-        for (let y = this._terminal.rows; y > newRows; y--) {
+      } else { // (this._rows >= newRows)
+        for (let y = this._rows; y > newRows; y--) {
          if (this.lines.length > newRows + this.ybase) {
            if (this.lines.length > this.ybase + this.y + 1) {
              // The line is a blank line below the cursor, remove it
@@ -192,8 +248,238 @@ export class Buffer implements IBuffer {
    }

    this.scrollBottom = newRows - 1;
+
+    if (this._isReflowEnabled) {
+      this._reflow(newCols, newRows);
+
+      // Trim the end of the line off if cols shrunk
+      if (this._cols > newCols) {
+        for (let i = 0; i < this.lines.length; i++) {
+          this.lines.get(i).resize(newCols, nullCell);
+        }
+      }
+    }
+
+    this._cols = newCols;
+    this._rows = newRows;
  }

+  private get _isReflowEnabled(): boolean {
+    return this._hasScrollback && !this._terminal.options.windowsMode;
+  }
+
+  private _reflow(newCols: number, newRows: number): void {
+    if (this._cols === newCols) {
+      return;
+    }
+
+    // Iterate through rows, ignore the last one as it cannot be wrapped
+    if (newCols > this._cols) {
+      this._reflowLarger(newCols, newRows);
+    } else {
+      this._reflowSmaller(newCols, newRows);
+    }
+  }
+
+  private _reflowLarger(newCols: number, newRows: number): void {
+    const toRemove: number[] = reflowLargerGetLinesToRemove(this.lines, this._cols, newCols, this.ybase + this.y, this.getNullCell(DEFAULT_ATTR_DATA));
+    if (toRemove.length > 0) {
+      const newLayoutResult = reflowLargerCreateNewLayout(this.lines, toRemove);
+      reflowLargerApplyNewLayout(this.lines, newLayoutResult.layout);
+      this._reflowLargerAdjustViewport(newCols, newRows, newLayoutResult.countRemoved);
+    }
+  }
+
+  private _reflowLargerAdjustViewport(newCols: number, newRows: number, countRemoved: number): void {
+    const nullCell = this.getNullCell(DEFAULT_ATTR_DATA);
+    // Adjust viewport based on number of items removed
+    let viewportAdjustments = countRemoved;
+    while (viewportAdjustments-- > 0) {
+      if (this.ybase === 0) {
+        if (this.y > 0) {
+          this.y--;
+        }
+        if (this.lines.length < newRows) {
+          // Add an extra row at the bottom of the viewport
+          this.lines.push(new BufferLine(newCols, nullCell));
+        }
+      } else {
+        if (this.ydisp === this.ybase) {
+          this.ydisp--;
+        }
+        this.ybase--;
+      }
+    }
+  }
+
+  private _reflowSmaller(newCols: number, newRows: number): void {
+    const nullCell = this.getNullCell(DEFAULT_ATTR_DATA);
+    // Gather all BufferLines that need to be inserted into the Buffer here so that they can be
+    // batched up and only committed once
+    const toInsert = [];
+    let countToInsert = 0;
+    // Go backwards as many lines may be trimmed and this will avoid considering them
+    for (let y = this.lines.length - 1; y >= 0; y--) {
+      // Check whether this line is a problem
+      let nextLine = this.lines.get(y) as BufferLine;
+      if (!nextLine.isWrapped && nextLine.getTrimmedLength() <= newCols) {
+        continue;
+      }
+
+      // Gather wrapped lines and adjust y to be the starting line
+      const wrappedLines: BufferLine[] = [nextLine];
+      while (nextLine.isWrapped && y > 0) {
+        nextLine = this.lines.get(--y) as BufferLine;
+        wrappedLines.unshift(nextLine);
+      }
+
+      // If these lines contain the cursor don't touch them, the program will handle fixing up
+      // wrapped lines with the cursor
+      const absoluteY = this.ybase + this.y;
+      if (absoluteY >= y && absoluteY < y + wrappedLines.length) {
+        continue;
+      }
+
+      const lastLineLength = wrappedLines[wrappedLines.length - 1].getTrimmedLength();
+      const destLineLengths = reflowSmallerGetNewLineLengths(wrappedLines, this._cols, newCols);
+      const linesToAdd = destLineLengths.length - wrappedLines.length;
+      let trimmedLines: number;
+      if (this.ybase === 0 && this.y !== this.lines.length - 1) {
+        // If the top section of the buffer is not yet filled
+        trimmedLines = Math.max(0, this.y - this.lines.maxLength + linesToAdd);
+      } else {
+        trimmedLines = Math.max(0, this.lines.length - this.lines.maxLength + linesToAdd);
+      }
+
+      // Add the new lines
+      const newLines: BufferLine[] = [];
+      for (let i = 0; i < linesToAdd; i++) {
+        const newLine = this.getBlankLine(DEFAULT_ATTR_DATA, true) as BufferLine;
+        newLines.push(newLine);
+      }
+      if (newLines.length > 0) {
+        toInsert.push({
+          // countToInsert here gets the actual index, taking into account other inserted items.
+          // using this we can iterate through the list forwards
+          start: y + wrappedLines.length + countToInsert,
+          newLines
+        });
+        countToInsert += newLines.length;
+      }
+      wrappedLines.push(...newLines);
+
+      // Copy buffer data to new locations, this needs to happen backwards to do in-place
+      let destLineIndex = destLineLengths.length - 1; // Math.floor(cellsNeeded / newCols);
+      let destCol = destLineLengths[destLineIndex]; // cellsNeeded % newCols;
+      if (destCol === 0) {
+        destLineIndex--;
+        destCol = destLineLengths[destLineIndex];
+      }
+      let srcLineIndex = wrappedLines.length - linesToAdd - 1;
+      let srcCol = lastLineLength;
+      while (srcLineIndex >= 0) {
+        const cellsToCopy = Math.min(srcCol, destCol);
+        wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[srcLineIndex], srcCol - cellsToCopy, destCol - cellsToCopy, cellsToCopy, true);
+        destCol -= cellsToCopy;
+        if (destCol === 0) {
+          destLineIndex--;
+          destCol = destLineLengths[destLineIndex];
+        }
+        srcCol -= cellsToCopy;
+        if (srcCol === 0) {
+          srcLineIndex--;
+          const wrappedLinesIndex = Math.max(srcLineIndex, 0);
+          srcCol = getWrappedLineTrimmedLength(wrappedLines, wrappedLinesIndex, this._cols);
+        }
+      }
+
+      // Null out the end of the line ends if a wide character wrapped to the following line
+      for (let i = 0; i < wrappedLines.length; i++) {
+        if (destLineLengths[i] < newCols) {
+          wrappedLines[i].setCell(destLineLengths[i], nullCell);
+        }
+      }
+
+      // Adjust viewport as needed
+      let viewportAdjustments = linesToAdd - trimmedLines;
+      while (viewportAdjustments-- > 0) {
+        if (this.ybase === 0) {
+          if (this.y < newRows - 1) {
+            this.y++;
+            this.lines.pop();
+          } else {
+            this.ybase++;
+            this.ydisp++;
+          }
+        } else {
+          // Ensure ybase does not exceed its maximum value
+          if (this.ybase < Math.min(this.lines.maxLength, this.lines.length + countToInsert) - newRows) {
+            if (this.ybase === this.ydisp) {
+              this.ydisp++;
+            }
+            this.ybase++;
+          }
+        }
+      }
+    }
+
+    // Rearrange lines in the buffer if there are any insertions, this is done at the end rather
+    // than earlier so that it's a single O(n) pass through the buffer, instead of O(n^2) from many
+    // costly calls to CircularList.splice.
+    if (toInsert.length > 0) {
+      // Record buffer insert events and then play them back backwards so that the indexes are
+      // correct
+      const insertEvents: IInsertEvent[] = [];
+
+      // Record original lines so they don't get overridden when we rearrange the list
+      const originalLines: BufferLine[] = [];
+      for (let i = 0; i < this.lines.length; i++) {
+        originalLines.push(this.lines.get(i) as BufferLine);
+      }
+      const originalLinesLength = this.lines.length;
+
+      let originalLineIndex = originalLinesLength - 1;
+      let nextToInsertIndex = 0;
+      let nextToInsert = toInsert[nextToInsertIndex];
+      this.lines.length = Math.min(this.lines.maxLength, this.lines.length + countToInsert);
+      let countInsertedSoFar = 0;
+      for (let i = Math.min(this.lines.maxLength - 1, originalLinesLength + countToInsert - 1); i >= 0; i--) {
+        if (nextToInsert && nextToInsert.start > originalLineIndex + countInsertedSoFar) {
+          // Insert extra lines here, adjusting i as needed
+          for (let nextI = nextToInsert.newLines.length - 1; nextI >= 0; nextI--) {
+            this.lines.set(i--, nextToInsert.newLines[nextI]);
+          }
+          i++;
+
+          // Create insert events for later
+          insertEvents.push({
+            index: originalLineIndex + 1,
+            amount: nextToInsert.newLines.length
+          });
+
+          countInsertedSoFar += nextToInsert.newLines.length;
+          nextToInsert = toInsert[++nextToInsertIndex];
+        } else {
+          this.lines.set(i, originalLines[originalLineIndex--]);
+        }
+      }
+
+      // Update markers
+      let insertCountEmitted = 0;
+      for (let i = insertEvents.length - 1; i >= 0; i--) {
+        insertEvents[i].index += insertCountEmitted;
+        this.lines.onInsertEmitter.fire(insertEvents[i]);
+        insertCountEmitted += insertEvents[i].amount;
+      }
+      const amountToTrim = Math.max(0, originalLinesLength + countToInsert - this.lines.maxLength);
+      if (amountToTrim > 0) {
+        this.lines.onTrimEmitter.fire(amountToTrim);
+      }
+    }
+  }
+
+  // private _reflowSmallerGetLinesNeeded()
+
  /**
   * Translates a string index back to a BufferIndex.
   * To get the correct buffer position the string must start at `startCol` 0
@@ -207,14 +493,19 @@ export class Buffer implements IBuffer {
   * @param stringIndex index within the string
   * @param startCol column offset the string was retrieved from
   */
-  public stringIndexToBufferIndex(lineIndex: number, stringIndex: number): BufferIndex {
+  public stringIndexToBufferIndex(lineIndex: number, stringIndex: number, trimRight: boolean = false): BufferIndex {
    while (stringIndex) {
      const line = this.lines.get(lineIndex);
      if (!line) {
-        [-1, -1];
+        return [-1, -1];
      }
-      for (let i = 0; i < line.length; ++i) {
-        stringIndex -= line.get(i)[CHAR_DATA_CHAR_INDEX].length;
+      const length = (trimRight) ? line.getTrimmedLength() : line.length;
+      for (let i = 0; i < length; ++i) {
+        if (line.get(i)[CHAR_DATA_WIDTH_INDEX]) {
+          // empty cells report a string length of 0, but get replaced
+          // with a whitespace in translateToString, thus replace with 1
+          stringIndex -= line.get(i)[CHAR_DATA_CHAR_INDEX].length || 1;
+        }
        if (stringIndex < 0) {
          return [lineIndex, i];
        }
@@ -234,65 +525,12 @@ export class Buffer implements IBuffer {
   * @param startCol The column to start at.
   * @param endCol The column to end at.
   */
-  public translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol: number = 0, endCol: number = null): string {
-    // Get full line
-    let lineString = '';
+  public translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol: number = 0, endCol?: number): string {
    const line = this.lines.get(lineIndex);
    if (!line) {
      return '';
    }
-
-    // Initialize column and index values. Column values represent the actual
-    // cell column, indexes represent the index in the string. Indexes are
-    // needed here because some chars are 0 characters long (eg. after wide
-    // chars) and some chars are longer than 1 characters long (eg. emojis).
-    let startIndex = startCol;
-    // Only set endCol to the line length when it is null. 0 is a valid column.
-    if (endCol === null) {
-      endCol = line.length;
-    }
-    let endIndex = endCol;
-
-    for (let i = 0; i < line.length; i++) {
-      const char = line.get(i);
-      lineString += char[CHAR_DATA_CHAR_INDEX];
-      // Adjust start and end cols for wide characters if they affect their
-      // column indexes
-      if (char[CHAR_DATA_WIDTH_INDEX] === 0) {
-        if (startCol >= i) {
-          startIndex--;
-        }
-        if (endCol > i) {
-          endIndex--;
-        }
-      } else {
-        // Adjust the columns to take glyphs that are represented by multiple
-        // code points into account.
-        if (char[CHAR_DATA_CHAR_INDEX].length > 1) {
-          if (startCol > i) {
-            startIndex += char[CHAR_DATA_CHAR_INDEX].length - 1;
-          }
-          if (endCol > i) {
-            endIndex += char[CHAR_DATA_CHAR_INDEX].length - 1;
-          }
-        }
-      }
-    }
-
-    // Calculate the final end col by trimming whitespace on the right of the
-    // line if needed.
-    if (trimRight) {
-      const rightWhitespaceIndex = lineString.search(/\s+$/);
-      if (rightWhitespaceIndex !== -1) {
-        endIndex = Math.min(endIndex, rightWhitespaceIndex);
-      }
-      // Return the empty string if only trimmed whitespace is selected
-      if (endIndex <= startIndex) {
-        return '';
-      }
-    }
-
-    return lineString.substring(startIndex, endIndex);
+    return line.translateToString(trimRight, startCol, endCol);
  }

  public getWrappedRangeForLine(y: number): { first: number, last: number } {
@@ -323,7 +561,7 @@ export class Buffer implements IBuffer {
      i = 0;
    }

-    for (; i < this._terminal.cols; i += this._terminal.options.tabStopWidth) {
+    for (; i < this._cols; i += this._terminal.options.tabStopWidth) {
      this.tabs[i] = true;
    }
  }
@@ -337,7 +575,7 @@ export class Buffer implements IBuffer {
      x = this.x;
    }
    while (!this.tabs[--x] && x > 0);
-    return x >= this._terminal.cols ? this._terminal.cols - 1 : x < 0 ? 0 : x;
+    return x >= this._cols ? this._cols - 1 : x < 0 ? 0 : x;
  }

  /**
@@ -348,26 +586,41 @@ export class Buffer implements IBuffer {
    if (x === null || x === undefined) {
      x = this.x;
    }
-    while (!this.tabs[++x] && x < this._terminal.cols);
-    return x >= this._terminal.cols ? this._terminal.cols - 1 : x < 0 ? 0 : x;
+    while (!this.tabs[++x] && x < this._cols);
+    return x >= this._cols ? this._cols - 1 : x < 0 ? 0 : x;
  }

  public addMarker(y: number): Marker {
    const marker = new Marker(y);
    this.markers.push(marker);
-    marker.register(this.lines.addDisposableListener('trim', amount => {
+    marker.register(this.lines.onTrim(amount => {
      marker.line -= amount;
      // The marker should be disposed when the line is trimmed from the buffer
      if (marker.line < 0) {
        marker.dispose();
      }
    }));
-    marker.register(marker.addDisposableListener('dispose', () => this._removeMarker(marker)));
+    marker.register(this.lines.onInsert(event => {
+      if (marker.line >= event.index) {
+        marker.line += event.amount;
+      }
+    }));
+    marker.register(this.lines.onDelete(event => {
+      // Delete the marker if it's within the range
+      if (marker.line >= event.index && marker.line < event.index + event.amount) {
+        marker.dispose();
+      }
+
+      // Shift the marker if it's after the deleted range
+      if (marker.line > event.index) {
+        marker.line -= event.amount;
+      }
+    }));
+    marker.register(marker.onDispose(() => this._removeMarker(marker)));
    return marker;
  }

  private _removeMarker(marker: Marker): void {
-    // TODO: This could probably be optimized by relying on sort order and trimming the array using .length
    this.markers.splice(this.markers.indexOf(marker), 1);
  }

@@ -376,7 +629,7 @@ export class Buffer implements IBuffer {
  }
 }

-export class Marker extends EventEmitter implements IMarker {
+export class Marker extends Disposable implements IMarker {
  private static _nextId = 1;

  private _id: number = Marker._nextId++;
@@ -384,6 +637,9 @@ export class Marker extends EventEmitter implements IMarker {

  public get id(): number { return this._id; }

+  private _onDispose = new EventEmitter2<void>();
+  public get onDispose(): IEvent<void> { return this._onDispose.event; }
+
  constructor(
    public line: number
  ) {
@@ -396,8 +652,7 @@ export class Marker extends EventEmitter implements IMarker {
    }
    this.isDisposed = true;
    // Emit before super.dispose such that dispose listeners get a change to react
-    this.emit('dispose');
-    super.dispose();
+    this._onDispose.fire();
  }
 }

@@ -451,8 +706,7 @@ export class BufferStringIterator implements IBufferStringIterator {
    range.last = Math.min(range.last, this._buffer.lines.length);
    let result = '';
    for (let i = range.first; i <= range.last; ++i) {
-      // TODO: always apply trimRight after fixing #1685
-      result += this._buffer.translateBufferLineToString(i, (this._trimRight) ? i === range.last : false);
+      result += this._buffer.translateBufferLineToString(i, this._trimRight);
    }
    this._current = range.last + 1;
    return {range: range, content: result};
@@ -3,95 +3,367 @@
 * @license MIT
 */
 import * as chai from 'chai';
-import { BufferLine } from './BufferLine';
+import { BufferLine, CellData, Content } from './BufferLine';
 import { CharData, IBufferLine } from './Types';
-import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE, CHAR_DATA_ATTR_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, CHAR_DATA_CODE_INDEX } from './Buffer';
+import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE, DEFAULT_ATTR } from './Buffer';


 class TestBufferLine extends BufferLine {
+  public get combined(): {[index: number]: string} {
+    return this._combined;
+  }
+
  public toArray(): CharData[] {
-    return this._data;
+    const result = [];
+    for (let i = 0; i < this.length; ++i) {
+      result.push(this.loadCell(i, new CellData()).getAsCharData());
+    }
+    return result;
  }
 }

+describe('CellData', () => {
+  it('CharData <--> CellData equality', () => {
+    const cell = new CellData();
+    // ASCII
+    cell.setFromCharData([123, 'a', 1, 'a'.charCodeAt(0)]);
+    chai.assert.deepEqual(cell.getAsCharData(), [123, 'a', 1, 'a'.charCodeAt(0)]);
+    chai.assert.equal(cell.isCombined(), 0);
+    // combining
+    cell.setFromCharData([123, 'e\u0301', 1, '\u0301'.charCodeAt(0)]);
+    chai.assert.deepEqual(cell.getAsCharData(), [123, 'e\u0301', 1, '\u0301'.charCodeAt(0)]);
+    chai.assert.equal(cell.isCombined(), Content.IS_COMBINED_MASK);
+    // surrogate
+    cell.setFromCharData([123, '𝄞', 1, 0x1D11E]);
+    chai.assert.deepEqual(cell.getAsCharData(), [123, '𝄞', 1, 0x1D11E]);
+    chai.assert.equal(cell.isCombined(), 0);
+    // surrogate + combining
+    cell.setFromCharData([123, '𓂀\u0301', 1, '𓂀\u0301'.charCodeAt(2)]);
+    chai.assert.deepEqual(cell.getAsCharData(), [123, '𓂀\u0301', 1, '𓂀\u0301'.charCodeAt(2)]);
+    chai.assert.equal(cell.isCombined(), Content.IS_COMBINED_MASK);
+    // wide char
+    cell.setFromCharData([123, '１', 2, '１'.charCodeAt(0)]);
+    chai.assert.deepEqual(cell.getAsCharData(), [123, '１', 2, '１'.charCodeAt(0)]);
+    chai.assert.equal(cell.isCombined(), 0);
+  });
+});
+
 describe('BufferLine', function(): void {
  it('ctor', function(): void {
-    let line: IBufferLine = new TestBufferLine();
+    let line: IBufferLine = new TestBufferLine(0);
    chai.expect(line.length).equals(0);
-    chai.expect(line.pop()).equals(undefined);
    chai.expect(line.isWrapped).equals(false);
    line = new TestBufferLine(10);
    chai.expect(line.length).equals(10);
-    chai.expect(line.pop()).eql([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+    chai.expect(line.loadCell(0, new CellData()).getAsCharData()).eql([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
    chai.expect(line.isWrapped).equals(false);
    line = new TestBufferLine(10, null, true);
    chai.expect(line.length).equals(10);
-    chai.expect(line.pop()).eql([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+    chai.expect(line.loadCell(0, new CellData()).getAsCharData()).eql([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
    chai.expect(line.isWrapped).equals(true);
-    line = new TestBufferLine(10, [123, 'a', 456, 789], true);
+    line = new TestBufferLine(10, CellData.fromCharData([123, 'a', 456, 'a'.charCodeAt(0)]), true);
    chai.expect(line.length).equals(10);
-    chai.expect(line.pop()).eql([123, 'a', 456, 789]);
+    chai.expect(line.loadCell(0, new CellData()).getAsCharData()).eql([123, 'a', 456, 'a'.charCodeAt(0)]);
    chai.expect(line.isWrapped).equals(true);
  });
-  it('splice', function(): void {
-    const line = new TestBufferLine();
-    const data: CharData[] = [
-      [1, 'a', 0, 0],
-      [2, 'b', 0, 0],
-      [3, 'c', 0, 0]
-    ];
-    for (let i = 0; i < data.length; ++i) line.push(data[i]);
-    chai.expect(line.length).equals(data.length);
-    const removed1 = line.splice(1, 1, [4, 'd', 0, 0]);
-    const removed2 = data.splice(1, 1, [4, 'd', 0, 0]);
-    chai.expect(removed1).eql(removed2);
-    chai.expect(line.toArray()).eql(data);
-  });
-  it('TerminalLine.blankLine', function(): void {
-    const line = TestBufferLine.blankLine(5, 123);
-    chai.expect(line.length).equals(5);
-    chai.expect(line.isWrapped).equals(false);
-    const ch = line.get(0);
-    chai.expect(ch[CHAR_DATA_ATTR_INDEX]).equals(123);
-    chai.expect(ch[CHAR_DATA_CHAR_INDEX]).equals(NULL_CELL_CHAR);
-    chai.expect(ch[CHAR_DATA_WIDTH_INDEX]).equals(NULL_CELL_WIDTH);
-    chai.expect(ch[CHAR_DATA_CODE_INDEX]).equals(NULL_CELL_CODE);
-  });
  it('insertCells', function(): void {
-    const line = new TestBufferLine();
-    const data: CharData[] = [
-      [1, 'a', 0, 0],
-      [2, 'b', 0, 0],
-      [3, 'c', 0, 0]
-    ];
-    for (let i = 0; i < data.length; ++i) line.push(data[i]);
-    line.insertCells(1, 3, [4, 'd', 0, 0]);
-    chai.expect(line.toArray()).eql([[1, 'a', 0, 0], [4, 'd', 0, 0], [4, 'd', 0, 0]]);
+    const line = new TestBufferLine(3);
+    line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+    line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)]));
+    line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)]));
+    line.insertCells(1, 3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)]));
+    chai.expect(line.toArray()).eql([
+      [1, 'a', 0, 'a'.charCodeAt(0)],
+      [4, 'd', 0, 'd'.charCodeAt(0)],
+      [4, 'd', 0, 'd'.charCodeAt(0)]
+    ]);
  });
  it('deleteCells', function(): void {
-    const line = new TestBufferLine();
-    const data: CharData[] = [
-      [1, 'a', 0, 0],
-      [2, 'b', 0, 0],
-      [3, 'c', 0, 0],
-      [4, 'd', 0, 0],
-      [5, 'e', 0, 0]
-    ];
-    for (let i = 0; i < data.length; ++i) line.push(data[i]);
-    line.deleteCells(1, 2, [6, 'f', 0, 0]);
-    chai.expect(line.toArray()).eql([[1, 'a', 0, 0], [4, 'd', 0, 0], [5, 'e', 0, 0], [6, 'f', 0, 0], [6, 'f', 0, 0]]);
+    const line = new TestBufferLine(5);
+    line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+    line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)]));
+    line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)]));
+    line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)]));
+    line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)]));
+    line.deleteCells(1, 2, CellData.fromCharData([6, 'f', 0, 'f'.charCodeAt(0)]));
+    chai.expect(line.toArray()).eql([
+      [1, 'a', 0, 'a'.charCodeAt(0)],
+      [4, 'd', 0, 'd'.charCodeAt(0)],
+      [5, 'e', 0, 'e'.charCodeAt(0)],
+      [6, 'f', 0, 'f'.charCodeAt(0)],
+      [6, 'f', 0, 'f'.charCodeAt(0)]
+    ]);
  });
  it('replaceCells', function(): void {
-    const line = new TestBufferLine();
-    const data: CharData[] = [
-      [1, 'a', 0, 0],
-      [2, 'b', 0, 0],
-      [3, 'c', 0, 0],
-      [4, 'd', 0, 0],
-      [5, 'e', 0, 0]
-    ];
-    for (let i = 0; i < data.length; ++i) line.push(data[i]);
-    line.replaceCells(2, 4, [6, 'f', 0, 0]);
-    chai.expect(line.toArray()).eql([[1, 'a', 0, 0], [2, 'b', 0, 0], [6, 'f', 0, 0], [6, 'f', 0, 0], [5, 'e', 0, 0]]);
+    const line = new TestBufferLine(5);
+    line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+    line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)]));
+    line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)]));
+    line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)]));
+    line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)]));
+    line.replaceCells(2, 4, CellData.fromCharData([6, 'f', 0, 'f'.charCodeAt(0)]));
+    chai.expect(line.toArray()).eql([
+      [1, 'a', 0, 'a'.charCodeAt(0)],
+      [2, 'b', 0, 'b'.charCodeAt(0)],
+      [6, 'f', 0, 'f'.charCodeAt(0)],
+      [6, 'f', 0, 'f'.charCodeAt(0)],
+      [5, 'e', 0, 'e'.charCodeAt(0)]
+    ]);
+  });
+  it('fill', function(): void {
+    const line = new TestBufferLine(5);
+    line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+    line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)]));
+    line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)]));
+    line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)]));
+    line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)]));
+    line.fill(CellData.fromCharData([123, 'z', 0, 'z'.charCodeAt(0)]));
+    chai.expect(line.toArray()).eql([
+      [123, 'z', 0, 'z'.charCodeAt(0)],
+      [123, 'z', 0, 'z'.charCodeAt(0)],
+      [123, 'z', 0, 'z'.charCodeAt(0)],
+      [123, 'z', 0, 'z'.charCodeAt(0)],
+      [123, 'z', 0, 'z'.charCodeAt(0)]
+    ]);
+  });
+  it('clone', function(): void {
+    const line = new TestBufferLine(5, null, true);
+    line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+    line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)]));
+    line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)]));
+    line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)]));
+    line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)]));
+    const line2 = line.clone();
+    chai.expect(TestBufferLine.prototype.toArray.apply(line2)).eql(line.toArray());
+    chai.expect(line2.length).equals(line.length);
+    chai.expect(line2.isWrapped).equals(line.isWrapped);
+  });
+  it('copyFrom', function(): void {
+    const line = new TestBufferLine(5);
+    line.setCell(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+    line.setCell(1, CellData.fromCharData([2, 'b', 0, 'b'.charCodeAt(0)]));
+    line.setCell(2, CellData.fromCharData([3, 'c', 0, 'c'.charCodeAt(0)]));
+    line.setCell(3, CellData.fromCharData([4, 'd', 0, 'd'.charCodeAt(0)]));
+    line.setCell(4, CellData.fromCharData([5, 'e', 0, 'e'.charCodeAt(0)]));
+    const line2 = new TestBufferLine(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), true);
+    line2.copyFrom(line);
+    chai.expect(line2.toArray()).eql(line.toArray());
+    chai.expect(line2.length).equals(line.length);
+    chai.expect(line2.isWrapped).equals(line.isWrapped);
+  });
+  it('should support combining chars', function(): void {
+    // CHAR_DATA_CODE_INDEX resembles current behavior in InputHandler.print
+    // --> set code to the last charCodeAt value of the string
+    // Note: needs to be fixed once the string pointer is in place
+    const line = new TestBufferLine(2, CellData.fromCharData([1, 'e\u0301', 0, '\u0301'.charCodeAt(0)]));
+    chai.expect(line.toArray()).eql([[1, 'e\u0301', 0, '\u0301'.charCodeAt(0)], [1, 'e\u0301', 0, '\u0301'.charCodeAt(0)]]);
+    const line2 = new TestBufferLine(5, CellData.fromCharData([1, 'a', 0, '\u0301'.charCodeAt(0)]), true);
+    line2.copyFrom(line);
+    chai.expect(line2.toArray()).eql(line.toArray());
+    const line3 = line.clone();
+    chai.expect(TestBufferLine.prototype.toArray.apply(line3)).eql(line.toArray());
+  });
+  describe('resize', function(): void {
+    it('enlarge(false)', function(): void {
+      const line = new TestBufferLine(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false);
+      line.resize(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+      chai.expect(line.toArray()).eql(Array(10).fill([1, 'a', 0, 'a'.charCodeAt(0)]));
+    });
+    it('enlarge(true)', function(): void {
+      const line = new TestBufferLine(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false);
+      line.resize(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+      chai.expect(line.toArray()).eql(Array(10).fill([1, 'a', 0, 'a'.charCodeAt(0)]));
+    });
+    it('shrink(true) - should apply new size', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false);
+      line.resize(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+      chai.expect(line.toArray()).eql(Array(5).fill([1, 'a', 0, 'a'.charCodeAt(0)]));
+    });
+    it('shrink to 0 length', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false);
+      line.resize(0, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+      chai.expect(line.toArray()).eql(Array(0).fill([1, 'a', 0, 'a'.charCodeAt(0)]));
+    });
+    it('should remove combining data on replaced cells after shrinking then enlarging', () => {
+      const line = new TestBufferLine(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]), false);
+      line.set(2, [ null, '😁', 1, '😁'.charCodeAt(0) ]);
+      line.set(9, [ null, '😁', 1, '😁'.charCodeAt(0) ]);
+      chai.expect(line.translateToString()).eql('aa😁aaaaaa😁');
+      chai.expect(Object.keys(line.combined).length).eql(2);
+      line.resize(5, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+      chai.expect(line.translateToString()).eql('aa😁aa');
+      line.resize(10, CellData.fromCharData([1, 'a', 0, 'a'.charCodeAt(0)]));
+      chai.expect(line.translateToString()).eql('aa😁aaaaaaa');
+      chai.expect(Object.keys(line.combined).length).eql(1);
+    });
+  });
+  describe('getTrimLength', function(): void {
+    it('empty line', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      chai.expect(line.getTrimmedLength()).equal(0);
+    });
+    it('ASCII', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      chai.expect(line.getTrimmedLength()).equal(3);
+    });
+    it('surrogate', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, '𝄞', 1, '𝄞'.charCodeAt(0)]));
+      chai.expect(line.getTrimmedLength()).equal(3);
+    });
+    it('combining', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, 'e\u0301', 1, '\u0301'.charCodeAt(0)]));
+      chai.expect(line.getTrimmedLength()).equal(3);
+    });
+    it('fullwidth', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, '１', 2, '１'.charCodeAt(0)]));
+      line.setCell(3, CellData.fromCharData([0, '', 0, undefined]));
+      chai.expect(line.getTrimmedLength()).equal(4); // also counts null cell after fullwidth
+    });
+  });
+  describe('translateToString with and w\'o trimming', function(): void {
+    it('empty line', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      chai.expect(line.translateToString(false)).equal('          ');
+      chai.expect(line.translateToString(true)).equal('');
+    });
+    it('ASCII', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(4, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(5, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      chai.expect(line.translateToString(false)).equal('a a aa    ');
+      chai.expect(line.translateToString(true)).equal('a a aa');
+      chai.expect(line.translateToString(false, 0, 5)).equal('a a a');
+      chai.expect(line.translateToString(false, 0, 4)).equal('a a ');
+      chai.expect(line.translateToString(false, 0, 3)).equal('a a');
+      chai.expect(line.translateToString(true, 0, 5)).equal('a a a');
+      chai.expect(line.translateToString(true, 0, 4)).equal('a a ');
+      chai.expect(line.translateToString(true, 0, 3)).equal('a a');
+
+    });
+    it('surrogate', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, '𝄞', 1, '𝄞'.charCodeAt(0)]));
+      line.setCell(4, CellData.fromCharData([1, '𝄞', 1, '𝄞'.charCodeAt(0)]));
+      line.setCell(5, CellData.fromCharData([1, '𝄞', 1, '𝄞'.charCodeAt(0)]));
+      chai.expect(line.translateToString(false)).equal('a 𝄞 𝄞𝄞    ');
+      chai.expect(line.translateToString(true)).equal('a 𝄞 𝄞𝄞');
+      chai.expect(line.translateToString(false, 0, 5)).equal('a 𝄞 𝄞');
+      chai.expect(line.translateToString(false, 0, 4)).equal('a 𝄞 ');
+      chai.expect(line.translateToString(false, 0, 3)).equal('a 𝄞');
+      chai.expect(line.translateToString(true, 0, 5)).equal('a 𝄞 𝄞');
+      chai.expect(line.translateToString(true, 0, 4)).equal('a 𝄞 ');
+      chai.expect(line.translateToString(true, 0, 3)).equal('a 𝄞');
+    });
+    it('combining', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, 'e\u0301', 1, '\u0301'.charCodeAt(0)]));
+      line.setCell(4, CellData.fromCharData([1, 'e\u0301', 1, '\u0301'.charCodeAt(0)]));
+      line.setCell(5, CellData.fromCharData([1, 'e\u0301', 1, '\u0301'.charCodeAt(0)]));
+      chai.expect(line.translateToString(false)).equal('a e\u0301 e\u0301e\u0301    ');
+      chai.expect(line.translateToString(true)).equal('a e\u0301 e\u0301e\u0301');
+      chai.expect(line.translateToString(false, 0, 5)).equal('a e\u0301 e\u0301');
+      chai.expect(line.translateToString(false, 0, 4)).equal('a e\u0301 ');
+      chai.expect(line.translateToString(false, 0, 3)).equal('a e\u0301');
+      chai.expect(line.translateToString(true, 0, 5)).equal('a e\u0301 e\u0301');
+      chai.expect(line.translateToString(true, 0, 4)).equal('a e\u0301 ');
+      chai.expect(line.translateToString(true, 0, 3)).equal('a e\u0301');
+    });
+    it('fullwidth', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, '１', 2, '１'.charCodeAt(0)]));
+      line.setCell(3, CellData.fromCharData([0, '', 0, undefined]));
+      line.setCell(5, CellData.fromCharData([1, '１', 2, '１'.charCodeAt(0)]));
+      line.setCell(6, CellData.fromCharData([0, '', 0, undefined]));
+      line.setCell(7, CellData.fromCharData([1, '１', 2, '１'.charCodeAt(0)]));
+      line.setCell(8, CellData.fromCharData([0, '', 0, undefined]));
+      chai.expect(line.translateToString(false)).equal('a １ １１ ');
+      chai.expect(line.translateToString(true)).equal('a １ １１');
+      chai.expect(line.translateToString(false, 0, 7)).equal('a １ １');
+      chai.expect(line.translateToString(false, 0, 6)).equal('a １ １');
+      chai.expect(line.translateToString(false, 0, 5)).equal('a １ ');
+      chai.expect(line.translateToString(false, 0, 4)).equal('a １');
+      chai.expect(line.translateToString(false, 0, 3)).equal('a １');
+      chai.expect(line.translateToString(false, 0, 2)).equal('a ');
+      chai.expect(line.translateToString(true, 0, 7)).equal('a １ １');
+      chai.expect(line.translateToString(true, 0, 6)).equal('a １ １');
+      chai.expect(line.translateToString(true, 0, 5)).equal('a １ ');
+      chai.expect(line.translateToString(true, 0, 4)).equal('a １');
+      chai.expect(line.translateToString(true, 0, 3)).equal('a １');
+      chai.expect(line.translateToString(true, 0, 2)).equal('a ');
+    });
+    it('space at end', function(): void {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(2, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(4, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(5, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      line.setCell(6, CellData.fromCharData([1, ' ', 1, ' '.charCodeAt(0)]));
+      chai.expect(line.translateToString(false)).equal('a a aa    ');
+      chai.expect(line.translateToString(true)).equal('a a aa ');
+    });
+    it('should always return some sane value', function(): void {
+      // sanity check - broken line with invalid out of bound null width cells
+      // this can atm happen with deleting/inserting chars in inputhandler by "breaking"
+      // fullwidth pairs --> needs to be fixed after settling BufferLine impl
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false);
+      chai.expect(line.translateToString(false)).equal('          ');
+      chai.expect(line.translateToString(true)).equal('');
+    });
+    it('should work with endCol=0', () => {
+      const line = new TestBufferLine(10, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, 0, NULL_CELL_CODE]), false);
+      line.setCell(0, CellData.fromCharData([1, 'a', 1, 'a'.charCodeAt(0)]));
+      chai.expect(line.translateToString(true, 0, 0)).equal('');
+    });
+  });
+  describe('addCharToCell', () => {
+    it('should set width to 1 for empty cell', () => {
+      const line = new TestBufferLine(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      line.addCodepointToCell(0, '\u0301'.charCodeAt(0));
+      const cell = line.loadCell(0, new CellData());
+      // chars contains single combining char
+      // width is set to 1
+      chai.assert.deepEqual(cell.getAsCharData(), [DEFAULT_ATTR, '\u0301', 1, 0x0301]);
+      // do not account a single combining char as combined
+      chai.assert.equal(cell.isCombined(), 0);
+    });
+    it('should add char to combining string in cell', () => {
+      const line = new TestBufferLine(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      const cell = line .loadCell(0, new CellData());
+      cell.setFromCharData([123, 'e\u0301', 1, 'e\u0301'.charCodeAt(1)]);
+      line.setCell(0, cell);
+      line.addCodepointToCell(0, '\u0301'.charCodeAt(0));
+      line.loadCell(0, cell);
+      // chars contains 3 chars
+      // width is set to 1
+      chai.assert.deepEqual(cell.getAsCharData(), [123, 'e\u0301\u0301', 1, 0x0301]);
+      // do not account a single combining char as combined
+      chai.assert.equal(cell.isCombined(), Content.IS_COMBINED_MASK);
+    });
+    it('should create combining string on taken cell', () => {
+      const line = new TestBufferLine(3, CellData.fromCharData([DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]), false);
+      const cell = line .loadCell(0, new CellData());
+      cell.setFromCharData([123, 'e', 1, 'e'.charCodeAt(1)]);
+      line.setCell(0, cell);
+      line.addCodepointToCell(0, '\u0301'.charCodeAt(0));
+      line.loadCell(0, cell);
+      // chars contains 2 chars
+      // width is set to 1
+      chai.assert.deepEqual(cell.getAsCharData(), [123, 'e\u0301', 1, 0x0301]);
+      // do not account a single combining char as combined
+      chai.assert.equal(cell.isCombined(), Content.IS_COMBINED_MASK);
+    });
  });
 });
@@ -2,82 +2,640 @@
 * Copyright (c) 2018 The xterm.js authors. All rights reserved.
 * @license MIT
 */
-import { CharData, IBufferLine } from './Types';
-import { NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR } from './Buffer';
+import { CharData, IBufferLine, ICellData, IColorRGB, IAttributeData } from './Types';
+import { NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, WHITESPACE_CELL_CHAR, CHAR_DATA_ATTR_INDEX } from './Buffer';
+import { stringFromCodePoint } from './core/input/TextDecoder';
+

 /**
- * Class representing a terminal line.
+ * buffer memory layout:
+ *
+ *   |             uint32_t             |        uint32_t         |        uint32_t         |
+ *   |             `content`            |          `FG`           |          `BG`           |
+ *   | wcwidth(2) comb(1) codepoint(21) | flags(8) R(8) G(8) B(8) | flags(8) R(8) G(8) B(8) |
 */
-export class BufferLine implements IBufferLine {
-  static blankLine(cols: number, attr: number, isWrapped?: boolean): IBufferLine {
-    const ch: CharData = [attr, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE];
-    return new BufferLine(cols, ch, isWrapped);
-  }
-  protected _data: CharData[];
-  public isWrapped = false;
-  public length: number;

-  constructor(cols?: number, ch?: CharData, isWrapped?: boolean) {
-    this._data = [];
-    this.length = this._data.length;
-    if (cols) {
-      if (!ch) {
-        ch = [0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE];
-      }
-      for (let i = 0; i < cols; i++) {
-        this.push(ch);  // Note: the ctor ch is not cloned (resembles old behavior)
-      }
-    }
-    if (isWrapped) {
-      this.isWrapped = true;
+
+/** typed array slots taken by one cell */
+const CELL_SIZE = 3;
+
+/**
+ * Cell member indices.
+ *
+ * Direct access:
+ *    `content = data[column * CELL_SIZE + Cell.CONTENT];`
+ *    `fg = data[column * CELL_SIZE + Cell.FG];`
+ *    `bg = data[column * CELL_SIZE + Cell.BG];`
+ */
+const enum Cell {
+  CONTENT = 0,
+  FG = 1, // currently simply holds all known attrs
+  BG = 2  // currently unused
+}
+
+/**
+ * Bitmasks for accessing data in `content`.
+ */
+export const enum Content {
+  /**
+   * bit 1..21    codepoint, max allowed in UTF32 is 0x10FFFF (21 bits taken)
+   *              read:   `codepoint = content & Content.codepointMask;`
+   *              write:  `content |= codepoint & Content.codepointMask;`
+   *                      shortcut if precondition `codepoint <= 0x10FFFF` is met:
+   *                      `content |= codepoint;`
+   */
+  CODEPOINT_MASK = 0x1FFFFF,
+
+  /**
+   * bit 22       flag indication whether a cell contains combined content
+   *              read:   `isCombined = content & Content.isCombined;`
+   *              set:    `content |= Content.isCombined;`
+   *              clear:  `content &= ~Content.isCombined;`
+   */
+  IS_COMBINED_MASK = 0x200000,  // 1 << 21
+
+  /**
+   * bit 1..22    mask to check whether a cell contains any string data
+   *              we need to check for codepoint and isCombined bits to see
+   *              whether a cell contains anything
+   *              read:   `isEmpty = !(content & Content.hasContent)`
+   */
+  HAS_CONTENT_MASK = 0x3FFFFF,
+
+  /**
+   * bit 23..24   wcwidth value of cell, takes 2 bits (ranges from 0..2)
+   *              read:   `width = (content & Content.widthMask) >> Content.widthShift;`
+   *                      `hasWidth = content & Content.widthMask;`
+   *                      as long as wcwidth is highest value in `content`:
+   *                      `width = content >> Content.widthShift;`
+   *              write:  `content |= (width << Content.widthShift) & Content.widthMask;`
+   *                      shortcut if precondition `0 <= width <= 3` is met:
+   *                      `content |= width << Content.widthShift;`
+   */
+  WIDTH_MASK = 0xC00000,   // 3 << 22
+  WIDTH_SHIFT = 22
+}
+
+
+export const enum Attributes {
+  /**
+   * bit 1..8     blue in RGB, color in P256 and P16
+   */
+  BLUE_MASK = 0xFF,
+  BLUE_SHIFT = 0,
+  PCOLOR_MASK = 0xFF,
+  PCOLOR_SHIFT = 0,
+
+  /**
+   * bit 9..16    green in RGB
+   */
+  GREEN_MASK = 0xFF00,
+  GREEN_SHIFT = 8,
+
+  /**
+   * bit 17..24   red in RGB
+   */
+  RED_MASK = 0xFF0000,
+  RED_SHIFT = 16,
+
+  /**
+   * bit 25..26   color mode: DEFAULT (0) | P16 (1) | P256 (2) | RGB (3)
+   */
+  CM_MASK = 0x3000000,
+  CM_DEFAULT = 0,
+  CM_P16 = 0x1000000,
+  CM_P256 = 0x2000000,
+  CM_RGB = 0x3000000,
+
+  /**
+   * bit 1..24  RGB room
+   */
+  RGB_MASK = 0xFFFFFF
+}
+
+export const enum FgFlags {
+  /**
+   * bit 27..31 (32th bit unused)
+   */
+  INVERSE = 0x4000000,
+  BOLD = 0x8000000,
+  UNDERLINE = 0x10000000,
+  BLINK = 0x20000000,
+  INVISIBLE = 0x40000000
+}
+
+export const enum BgFlags {
+  /**
+   * bit 27..32 (upper 4 unused)
+   */
+  ITALIC = 0x4000000,
+  DIM = 0x8000000
+}
+
+export class AttributeData implements IAttributeData {
+  static toColorRGB(value: number): IColorRGB {
+    return [
+      value >>> Attributes.RED_SHIFT & 255,
+      value >>> Attributes.GREEN_SHIFT & 255,
+      value & 255
+    ];
+  }
+  static fromColorRGB(value: IColorRGB): number {
+    return (value[0] & 255) << Attributes.RED_SHIFT | (value[1] & 255) << Attributes.GREEN_SHIFT | value[2] & 255;
+  }
+
+  public clone(): IAttributeData {
+    const newObj = new AttributeData();
+    newObj.fg = this.fg;
+    newObj.bg = this.bg;
+    return newObj;
+  }
+
+  // data
+  public fg: number = 0;
+  public bg: number = 0;
+
+  // flags
+  public isInverse(): number   { return this.fg & FgFlags.INVERSE; }
+  public isBold(): number      { return this.fg & FgFlags.BOLD; }
+  public isUnderline(): number { return this.fg & FgFlags.UNDERLINE; }
+  public isBlink(): number     { return this.fg & FgFlags.BLINK; }
+  public isInvisible(): number { return this.fg & FgFlags.INVISIBLE; }
+  public isItalic(): number    { return this.bg & BgFlags.ITALIC; }
+  public isDim(): number       { return this.bg & BgFlags.DIM; }
+
+  // color modes
+  public getFgColorMode(): number { return this.fg & Attributes.CM_MASK; }
+  public getBgColorMode(): number { return this.bg & Attributes.CM_MASK; }
+  public isFgRGB(): boolean       { return (this.fg & Attributes.CM_MASK) === Attributes.CM_RGB; }
+  public isBgRGB(): boolean       { return (this.bg & Attributes.CM_MASK) === Attributes.CM_RGB; }
+  public isFgPalette(): boolean   { return (this.fg & Attributes.CM_MASK) === Attributes.CM_P16 || (this.fg & Attributes.CM_MASK) === Attributes.CM_P256; }
+  public isBgPalette(): boolean   { return (this.bg & Attributes.CM_MASK) === Attributes.CM_P16 || (this.bg & Attributes.CM_MASK) === Attributes.CM_P256; }
+  public isFgDefault(): boolean   { return (this.fg & Attributes.CM_MASK) === 0; }
+  public isBgDefault(): boolean   { return (this.bg & Attributes.CM_MASK) === 0; }
+
+  // colors
+  public getFgColor(): number {
+    switch (this.fg & Attributes.CM_MASK) {
+      case Attributes.CM_P16:
+      case Attributes.CM_P256:  return this.fg & Attributes.PCOLOR_MASK;
+      case Attributes.CM_RGB:   return this.fg & Attributes.RGB_MASK;
+      default:                  return -1;  // CM_DEFAULT defaults to -1
    }
  }
-
-  public get(index: number): CharData {
-    return this._data[index];
-  }
-
-  public set(index: number, data: CharData): void {
-    this._data[index] = data;
-  }
-
-  public pop(): CharData | undefined  {
-    const data = this._data.pop();
-    this.length = this._data.length;
-    return data;
-  }
-
-  public push(data: CharData): void {
-    this._data.push(data);
-    this.length = this._data.length;
-  }
-
-  public splice(start: number, deleteCount: number, ...items: CharData[]): CharData[] {
-    const removed = this._data.splice(start, deleteCount, ...items);
-    this.length = this._data.length;
-    return removed;
-  }
-
-  /** insert n cells ch at pos, right cells are lost (stable length)  */
-  public insertCells(pos: number, n: number, ch: CharData): void {
-    while (n--) {
-      this.splice(pos, 0, ch);
-      this.pop();
-    }
-  }
-
-  /** delete n cells at pos, right side is filled with fill (stable length) */
-  public deleteCells(pos: number, n: number, fill: CharData): void {
-    while (n--) {
-      this.splice(pos, 1);
-      this.push(fill);
-    }
-  }
-
-  /** replace cells from pos to pos + n - 1 with fill */
-  public replaceCells(start: number, end: number, fill: CharData): void {
-    while (start < end  && start < this.length) {
-      this.set(start++, fill);  // Note: fill is not cloned (resembles old behavior)
+  public getBgColor(): number {
+    switch (this.bg & Attributes.CM_MASK) {
+      case Attributes.CM_P16:
+      case Attributes.CM_P256:  return this.bg & Attributes.PCOLOR_MASK;
+      case Attributes.CM_RGB:   return this.bg & Attributes.RGB_MASK;
+      default:                  return -1;  // CM_DEFAULT defaults to -1
    }
  }
 }
+
+/**
+ * CellData - represents a single Cell in the terminal buffer.
+ */
+export class CellData extends AttributeData implements ICellData {
+
+  /** Helper to create CellData from CharData. */
+  public static fromCharData(value: CharData): CellData {
+    const obj = new CellData();
+    obj.setFromCharData(value);
+    return obj;
+  }
+
+  /** Primitives from terminal buffer. */
+  public content: number = 0;
+  public fg: number = 0;
+  public bg: number = 0;
+  public combinedData: string = '';
+
+  /** Whether cell contains a combined string. */
+  public isCombined(): number {
+    return this.content & Content.IS_COMBINED_MASK;
+  }
+
+  /** Width of the cell. */
+  public getWidth(): number {
+    return this.content >> Content.WIDTH_SHIFT;
+  }
+
+  /** JS string of the content. */
+  public getChars(): string {
+    if (this.content & Content.IS_COMBINED_MASK) {
+      return this.combinedData;
+    }
+    if (this.content & Content.CODEPOINT_MASK) {
+      return stringFromCodePoint(this.content & Content.CODEPOINT_MASK);
+    }
+    return '';
+  }
+
+  /**
+   * Codepoint of cell
+   * Note this returns the UTF32 codepoint of single chars,
+   * if content is a combined string it returns the codepoint
+   * of the last char in string to be in line with code in CharData.
+   * */
+  public getCode(): number {
+    return (this.isCombined())
+      ? this.combinedData.charCodeAt(this.combinedData.length - 1)
+      : this.content & Content.CODEPOINT_MASK;
+  }
+
+  /** Set data from CharData */
+  public setFromCharData(value: CharData): void {
+    this.fg = value[CHAR_DATA_ATTR_INDEX];
+    this.bg = 0;
+    let combined = false;
+
+    // surrogates and combined strings need special treatment
+    if (value[CHAR_DATA_CHAR_INDEX].length > 2) {
+      combined = true;
+    } else if (value[CHAR_DATA_CHAR_INDEX].length === 2) {
+      const code = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0);
+      // if the 2-char string is a surrogate create single codepoint
+      // everything else is combined
+      if (0xD800 <= code && code <= 0xDBFF) {
+        const second = value[CHAR_DATA_CHAR_INDEX].charCodeAt(1);
+        if (0xDC00 <= second && second <= 0xDFFF) {
+          this.content = ((code - 0xD800) * 0x400 + second - 0xDC00 + 0x10000) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
+        } else {
+          combined = true;
+        }
+      } else {
+        combined = true;
+      }
+    } else {
+      this.content = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
+    }
+    if (combined) {
+      this.combinedData = value[CHAR_DATA_CHAR_INDEX];
+      this.content = Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
+    }
+  }
+
+  /** Get data as CharData. */
+  public getAsCharData(): CharData {
+    return [this.fg, this.getChars(), this.getWidth(), this.getCode()];
+  }
+}
+
+
+/**
+ * Typed array based bufferline implementation.
+ *
+ * There are 2 ways to insert data into the cell buffer:
+ * - `setCellFromCodepoint` + `addCodepointToCell`
+ *   Use these for data that is already UTF32.
+ *   Used during normal input in `InputHandler` for faster buffer access.
+ * - `setCell`
+ *   This method takes a CellData object and stores the data in the buffer.
+ *   Use `CellData.fromCharData` to create the CellData object (e.g. from JS string).
+ *
+ * To retrieve data from the buffer use either one of the primitive methods
+ * (if only one particular value is needed) or `loadCell`. For `loadCell` in a loop
+ * memory allocs / GC pressure can be greatly reduced by reusing the CellData object.
+ */
+export class BufferLine implements IBufferLine {
+  protected _data: Uint32Array | null = null;
+  protected _combined: {[index: number]: string} = {};
+  public length: number;
+
+  constructor(cols: number, fillCellData?: ICellData, public isWrapped: boolean = false) {
+    if (cols) {
+      this._data = new Uint32Array(cols * CELL_SIZE);
+      const cell = fillCellData || CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+      for (let i = 0; i < cols; ++i) {
+        this.setCell(i, cell);
+      }
+    }
+    this.length = cols;
+  }
+
+  /**
+   * Get cell data CharData.
+   * @deprecated
+   */
+  public get(index: number): CharData {
+    const content = this._data[index * CELL_SIZE + Cell.CONTENT];
+    const cp = content & Content.CODEPOINT_MASK;
+    return [
+      this._data[index * CELL_SIZE + Cell.FG],
+      (content & Content.IS_COMBINED_MASK)
+        ? this._combined[index]
+        : (cp) ? stringFromCodePoint(cp) : '',
+      content >> Content.WIDTH_SHIFT,
+      (content & Content.IS_COMBINED_MASK)
+        ? this._combined[index].charCodeAt(this._combined[index].length - 1)
+        : cp
+    ];
+  }
+
+  /**
+   * Set cell data from CharData.
+   * @deprecated
+   */
+  public set(index: number, value: CharData): void {
+    this._data[index * CELL_SIZE + Cell.FG] = value[CHAR_DATA_ATTR_INDEX];
+    if (value[CHAR_DATA_CHAR_INDEX].length > 1) {
+      this._combined[index] = value[1];
+      this._data[index * CELL_SIZE + Cell.CONTENT] = index | Content.IS_COMBINED_MASK | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
+    } else {
+      this._data[index * CELL_SIZE + Cell.CONTENT] = value[CHAR_DATA_CHAR_INDEX].charCodeAt(0) | (value[CHAR_DATA_WIDTH_INDEX] << Content.WIDTH_SHIFT);
+    }
+  }
+
+  /**
+   * primitive getters
+   * use these when only one value is needed, otherwise use `loadCell`
+   */
+  public getWidth(index: number): number {
+    return this._data[index * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT;
+  }
+
+  /** Test whether content has width. */
+  public hasWidth(index: number): number {
+    return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.WIDTH_MASK;
+  }
+
+  /** Get FG cell component. */
+  public getFg(index: number): number {
+    return this._data[index * CELL_SIZE + Cell.FG];
+  }
+
+  /** Get BG cell component. */
+  public getBg(index: number): number {
+    return this._data[index * CELL_SIZE + Cell.BG];
+  }
+
+  /**
+   * Test whether contains any chars.
+   * Basically an empty has no content, but other cells might differ in FG/BG
+   * from real empty cells.
+   * */
+  public hasContent(index: number): number {
+    return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK;
+  }
+
+  /**
+   * Get codepoint of the cell.
+   * To be in line with `code` in CharData this either returns
+   * a single UTF32 codepoint or the last codepoint of a combined string.
+   */
+  public getCodePoint(index: number): number {
+    const content = this._data[index * CELL_SIZE + Cell.CONTENT];
+    if (content & Content.IS_COMBINED_MASK) {
+      return this._combined[index].charCodeAt(this._combined[index].length - 1);
+    }
+    return content & Content.CODEPOINT_MASK;
+  }
+
+  /** Test whether the cell contains a combined string. */
+  public isCombined(index: number): number {
+    return this._data[index * CELL_SIZE + Cell.CONTENT] & Content.IS_COMBINED_MASK;
+  }
+
+  /** Returns the string content of the cell. */
+  public getString(index: number): string {
+    const content = this._data[index * CELL_SIZE + Cell.CONTENT];
+    if (content & Content.IS_COMBINED_MASK) {
+      return this._combined[index];
+    }
+    if (content & Content.CODEPOINT_MASK) {
+      return stringFromCodePoint(content & Content.CODEPOINT_MASK);
+    }
+    // return empty string for empty cells
+    return '';
+  }
+
+  /**
+   * Load data at `index` into `cell`. This is used to access cells in a way that's more friendly
+   * to GC as it significantly reduced the amount of new objects/references needed.
+   */
+  public loadCell(index: number, cell: ICellData): ICellData {
+    const startIndex = index * CELL_SIZE;
+    cell.content = this._data[startIndex + Cell.CONTENT];
+    cell.fg = this._data[startIndex + Cell.FG];
+    cell.bg = this._data[startIndex + Cell.BG];
+    if (cell.content & Content.IS_COMBINED_MASK) {
+      cell.combinedData = this._combined[index];
+    }
+    return cell;
+  }
+
+  /**
+   * Set data at `index` to `cell`.
+   */
+  public setCell(index: number, cell: ICellData): void {
+    if (cell.content & Content.IS_COMBINED_MASK) {
+      this._combined[index] = cell.combinedData;
+    }
+    this._data[index * CELL_SIZE + Cell.CONTENT] = cell.content;
+    this._data[index * CELL_SIZE + Cell.FG] = cell.fg;
+    this._data[index * CELL_SIZE + Cell.BG] = cell.bg;
+  }
+
+  /**
+   * Set cell data from input handler.
+   * Since the input handler see the incoming chars as UTF32 codepoints,
+   * it gets an optimized access method.
+   */
+  public setCellFromCodePoint(index: number, codePoint: number, width: number, fg: number, bg: number): void {
+    this._data[index * CELL_SIZE + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT);
+    this._data[index * CELL_SIZE + Cell.FG] = fg;
+    this._data[index * CELL_SIZE + Cell.BG] = bg;
+  }
+
+  /**
+   * Add a codepoint to a cell from input handler.
+   * During input stage combining chars with a width of 0 follow and stack
+   * onto a leading char. Since we already set the attrs
+   * by the previous `setDataFromCodePoint` call, we can omit it here.
+   */
+  public addCodepointToCell(index: number, codePoint: number): void {
+    let content = this._data[index * CELL_SIZE + Cell.CONTENT];
+    if (content & Content.IS_COMBINED_MASK) {
+      // we already have a combined string, simply add
+      this._combined[index] += stringFromCodePoint(codePoint);
+    } else {
+      if (content & Content.CODEPOINT_MASK) {
+        // normal case for combining chars:
+        //  - move current leading char + new one into combined string
+        //  - set combined flag
+        this._combined[index] = stringFromCodePoint(content & Content.CODEPOINT_MASK) + stringFromCodePoint(codePoint);
+        content &= ~Content.CODEPOINT_MASK; // set codepoint in buffer to 0
+        content |= Content.IS_COMBINED_MASK;
+      } else {
+        // should not happen - we actually have no data in the cell yet
+        // simply set the data in the cell buffer with a width of 1
+        content = codePoint | (1 << Content.WIDTH_SHIFT);
+      }
+      this._data[index * CELL_SIZE + Cell.CONTENT] = content;
+    }
+  }
+
+  public insertCells(pos: number, n: number, fillCellData: ICellData): void {
+    pos %= this.length;
+    if (n < this.length - pos) {
+      const cell = new CellData();
+      for (let i = this.length - pos - n - 1; i >= 0; --i) {
+        this.setCell(pos + n + i, this.loadCell(pos + i, cell));
+      }
+      for (let i = 0; i < n; ++i) {
+        this.setCell(pos + i, fillCellData);
+      }
+    } else {
+      for (let i = pos; i < this.length; ++i) {
+        this.setCell(i, fillCellData);
+      }
+    }
+  }
+
+  public deleteCells(pos: number, n: number, fillCellData: ICellData): void {
+    pos %= this.length;
+    if (n < this.length - pos) {
+      const cell = new CellData();
+      for (let i = 0; i < this.length - pos - n; ++i) {
+        this.setCell(pos + i, this.loadCell(pos + n + i, cell));
+      }
+      for (let i = this.length - n; i < this.length; ++i) {
+        this.setCell(i, fillCellData);
+      }
+    } else {
+      for (let i = pos; i < this.length; ++i) {
+        this.setCell(i, fillCellData);
+      }
+    }
+  }
+
+  public replaceCells(start: number, end: number, fillCellData: ICellData): void {
+    while (start < end  && start < this.length) {
+      this.setCell(start++, fillCellData);
+    }
+  }
+
+  public resize(cols: number, fillCellData: ICellData): void {
+    if (cols === this.length) {
+      return;
+    }
+    if (cols > this.length) {
+      const data = new Uint32Array(cols * CELL_SIZE);
+      if (this.length) {
+        if (cols * CELL_SIZE < this._data.length) {
+          data.set(this._data.subarray(0, cols * CELL_SIZE));
+        } else {
+          data.set(this._data);
+        }
+      }
+      this._data = data;
+      for (let i = this.length; i < cols; ++i) {
+        this.setCell(i, fillCellData);
+      }
+    } else {
+      if (cols) {
+        const data = new Uint32Array(cols * CELL_SIZE);
+        data.set(this._data.subarray(0, cols * CELL_SIZE));
+        this._data = data;
+        // Remove any cut off combined data
+        const keys = Object.keys(this._combined);
+        for (let i = 0; i < keys.length; i++) {
+          const key = parseInt(keys[i], 10);
+          if (key >= cols) {
+            delete this._combined[key];
+          }
+        }
+      } else {
+        this._data = null;
+        this._combined = {};
+      }
+    }
+    this.length = cols;
+  }
+
+  /** fill a line with fillCharData */
+  public fill(fillCellData: ICellData): void {
+    this._combined = {};
+    for (let i = 0; i < this.length; ++i) {
+      this.setCell(i, fillCellData);
+    }
+  }
+
+  /** alter to a full copy of line  */
+  public copyFrom(line: BufferLine): void {
+    if (this.length !== line.length) {
+      this._data = new Uint32Array(line._data);
+    } else {
+      // use high speed copy if lengths are equal
+      this._data.set(line._data);
+    }
+    this.length = line.length;
+    this._combined = {};
+    for (const el in line._combined) {
+      this._combined[el] = line._combined[el];
+    }
+    this.isWrapped = line.isWrapped;
+  }
+
+  /** create a new clone */
+  public clone(): IBufferLine {
+    const newLine = new BufferLine(0);
+    newLine._data = new Uint32Array(this._data);
+    newLine.length = this.length;
+    for (const el in this._combined) {
+      newLine._combined[el] = this._combined[el];
+    }
+    newLine.isWrapped = this.isWrapped;
+    return newLine;
+  }
+
+  public getTrimmedLength(): number {
+    for (let i = this.length - 1; i >= 0; --i) {
+      if ((this._data[i * CELL_SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK)) {
+        return i + (this._data[i * CELL_SIZE + Cell.CONTENT] >> Content.WIDTH_SHIFT);
+      }
+    }
+    return 0;
+  }
+
+  public copyCellsFrom(src: BufferLine, srcCol: number, destCol: number, length: number, applyInReverse: boolean): void {
+    const srcData = src._data;
+    if (applyInReverse) {
+      for (let cell = length - 1; cell >= 0; cell--) {
+        for (let i = 0; i < CELL_SIZE; i++) {
+          this._data[(destCol + cell) * CELL_SIZE + i] = srcData[(srcCol + cell) * CELL_SIZE + i];
+        }
+      }
+    } else {
+      for (let cell = 0; cell < length; cell++) {
+        for (let i = 0; i < CELL_SIZE; i++) {
+          this._data[(destCol + cell) * CELL_SIZE + i] = srcData[(srcCol + cell) * CELL_SIZE + i];
+        }
+      }
+    }
+
+    // Move any combined data over as needed
+    const srcCombinedKeys = Object.keys(src._combined);
+    for (let i = 0; i < srcCombinedKeys.length; i++) {
+      const key = parseInt(srcCombinedKeys[i], 10);
+      if (key >= srcCol) {
+        this._combined[key - srcCol + destCol] = src._combined[key];
+      }
+    }
+  }
+
+  public translateToString(trimRight: boolean = false, startCol: number = 0, endCol: number = this.length): string {
+    if (trimRight) {
+      endCol = Math.min(endCol, this.getTrimmedLength());
+    }
+    let result = '';
+    while (startCol < endCol) {
+      const content = this._data[startCol * CELL_SIZE + Cell.CONTENT];
+      const cp = content & Content.CODEPOINT_MASK;
+      result += (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR;
+      startCol += (content >> Content.WIDTH_SHIFT) || 1; // always advance by 1
+    }
+    return result;
+  }
+}
@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+import { assert } from 'chai';
+import { BufferLine } from './BufferLine';
+import { reflowSmallerGetNewLineLengths } from './BufferReflow';
+import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE } from './Buffer';
+
+describe('BufferReflow', () => {
+  describe('reflowSmallerGetNewLineLengths', () => {
+    it('should return correct line lengths for a small line with wide characters', () => {
+      const line = new BufferLine(4);
+      line.set(0, [null, '汉', 2, '汉'.charCodeAt(0)]);
+      line.set(1, [null, '', 0, undefined]);
+      line.set(2, [null, '语', 2, '语'.charCodeAt(0)]);
+      line.set(3, [null, '', 0, undefined]);
+      assert.equal(line.translateToString(true), '汉语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 4, 3), [2, 2], 'line: 汉, 语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 4, 2), [2, 2], 'line: 汉, 语');
+    });
+    it('should return correct line lengths for a large line with wide characters', () => {
+      const line = new BufferLine(12);
+      for (let i = 0; i < 12; i += 4) {
+        line.set(i, [null, '汉', 2, '汉'.charCodeAt(0)]);
+        line.set(i + 2, [null, '语', 2, '语'.charCodeAt(0)]);
+      }
+      for (let i = 1; i < 12; i += 2) {
+        line.set(i, [null, '', 0, undefined]);
+        line.set(i, [null, '', 0, undefined]);
+      }
+      assert.equal(line.translateToString(), '汉语汉语汉语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 11), [10, 2], 'line: 汉语汉语汉, 语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 10), [10, 2], 'line: 汉语汉语汉, 语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 9), [8, 4], 'line: 汉语汉语, 汉语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 8), [8, 4], 'line: 汉语汉语, 汉语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 7), [6, 6], 'line: 汉语汉, 语汉语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 6), [6, 6], 'line: 汉语汉, 语汉语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 5), [4, 4, 4], 'line: 汉语, 汉语, 汉语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 4), [4, 4, 4], 'line: 汉语, 汉语, 汉语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 3), [2, 2, 2, 2, 2, 2], 'line: 汉, 语, 汉, 语, 汉, 语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 2), [2, 2, 2, 2, 2, 2], 'line: 汉, 语, 汉, 语, 汉, 语');
+    });
+    it('should return correct line lengths for a string with wide and single characters', () => {
+      const line = new BufferLine(6);
+      line.set(0, [null, 'a', 1, 'a'.charCodeAt(0)]);
+      line.set(1, [null, '汉', 2, '汉'.charCodeAt(0)]);
+      line.set(2, [null, '', 0, undefined]);
+      line.set(3, [null, '语', 2, '语'.charCodeAt(0)]);
+      line.set(4, [null, '', 0, undefined]);
+      line.set(5, [null, 'b', 1, 'b'.charCodeAt(0)]);
+      assert.equal(line.translateToString(), 'a汉语b');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 6, 5), [5, 1], 'line: a汉语b');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 6, 4), [3, 3], 'line: a汉, 语b');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 6, 3), [3, 3], 'line: a汉, 语b');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 6, 2), [1, 2, 2, 1], 'line: a, 汉, 语, b');
+    });
+    it('should return correct line lengths for a wrapped line with wide and single characters', () => {
+      const line1 = new BufferLine(6);
+      line1.set(0, [null, 'a', 1, 'a'.charCodeAt(0)]);
+      line1.set(1, [null, '汉', 2, '汉'.charCodeAt(0)]);
+      line1.set(2, [null, '', 0, undefined]);
+      line1.set(3, [null, '语', 2, '语'.charCodeAt(0)]);
+      line1.set(4, [null, '', 0, undefined]);
+      line1.set(5, [null, 'b', 1, 'b'.charCodeAt(0)]);
+      const line2 = new BufferLine(6, undefined, true);
+      line2.set(0, [null, 'a', 1, 'a'.charCodeAt(0)]);
+      line2.set(1, [null, '汉', 2, '汉'.charCodeAt(0)]);
+      line2.set(2, [null, '', 0, undefined]);
+      line2.set(3, [null, '语', 2, '语'.charCodeAt(0)]);
+      line2.set(4, [null, '', 0, undefined]);
+      line2.set(5, [null, 'b', 1, 'b'.charCodeAt(0)]);
+      assert.equal(line1.translateToString(), 'a汉语b');
+      assert.equal(line2.translateToString(), 'a汉语b');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line1, line2], 6, 5), [5, 4, 3], 'lines: a汉语, ba汉, 语b');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line1, line2], 6, 4), [3, 4, 4, 1], 'lines: a汉, 语ba, 汉语, b');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line1, line2], 6, 3), [3, 3, 3, 3], 'lines: a汉, 语b, a汉, 语b');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line1, line2], 6, 2), [1, 2, 2, 2, 2, 2, 1], 'lines: a, 汉, 语, ba, 汉, 语, b');
+    });
+    it('should work on lines ending in null space', () => {
+      const line = new BufferLine(5);
+      line.set(0, [null, '汉', 2, '汉'.charCodeAt(0)]);
+      line.set(1, [null, '', 0, undefined]);
+      line.set(2, [null, '语', 2, '语'.charCodeAt(0)]);
+      line.set(3, [null, '', 0, undefined]);
+      line.set(4, [null, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+      assert.equal(line.translateToString(true), '汉语');
+      assert.equal(line.translateToString(false), '汉语 ');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 4, 3), [2, 2], 'line: 汉, 语');
+      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 4, 2), [2, 2], 'line: 汉, 语');
+    });
+  });
+});
@@ -0,0 +1,220 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { BufferLine } from './BufferLine';
+import { CircularList } from './common/CircularList';
+import { IBufferLine, ICellData } from './Types';
+
+export interface INewLayoutResult {
+  layout: number[];
+  countRemoved: number;
+}
+
+/**
+ * Evaluates and returns indexes to be removed after a reflow larger occurs. Lines will be removed
+ * when a wrapped line unwraps.
+ * @param lines The buffer lines.
+ * @param newCols The columns after resize.
+ */
+export function reflowLargerGetLinesToRemove(lines: CircularList<IBufferLine>, oldCols: number, newCols: number, bufferAbsoluteY: number, nullCell: ICellData): number[] {
+  // Gather all BufferLines that need to be removed from the Buffer here so that they can be
+  // batched up and only committed once
+  const toRemove: number[] = [];
+
+  for (let y = 0; y < lines.length - 1; y++) {
+    // Check if this row is wrapped
+    let i = y;
+    let nextLine = lines.get(++i) as BufferLine;
+    if (!nextLine.isWrapped) {
+      continue;
+    }
+
+    // Check how many lines it's wrapped for
+    const wrappedLines: BufferLine[] = [lines.get(y) as BufferLine];
+    while (i < lines.length && nextLine.isWrapped) {
+      wrappedLines.push(nextLine);
+      nextLine = lines.get(++i) as BufferLine;
+    }
+
+    // If these lines contain the cursor don't touch them, the program will handle fixing up wrapped
+    // lines with the cursor
+    if (bufferAbsoluteY >= y && bufferAbsoluteY < i) {
+      y += wrappedLines.length - 1;
+      continue;
+    }
+
+    // Copy buffer data to new locations
+    let destLineIndex = 0;
+    let destCol = getWrappedLineTrimmedLength(wrappedLines, destLineIndex, oldCols);
+    let srcLineIndex = 1;
+    let srcCol = 0;
+    while (srcLineIndex < wrappedLines.length) {
+      const srcTrimmedTineLength = getWrappedLineTrimmedLength(wrappedLines, srcLineIndex, oldCols);
+      const srcRemainingCells = srcTrimmedTineLength - srcCol;
+      const destRemainingCells = newCols - destCol;
+      const cellsToCopy = Math.min(srcRemainingCells, destRemainingCells);
+
+      wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[srcLineIndex], srcCol, destCol, cellsToCopy, false);
+
+      destCol += cellsToCopy;
+      if (destCol === newCols) {
+        destLineIndex++;
+        destCol = 0;
+      }
+      srcCol += cellsToCopy;
+      if (srcCol === srcTrimmedTineLength) {
+        srcLineIndex++;
+        srcCol = 0;
+      }
+
+      // Make sure the last cell isn't wide, if it is copy it to the current dest
+      if (destCol === 0 && destLineIndex !== 0) {
+        if (wrappedLines[destLineIndex - 1].getWidth(newCols - 1) === 2) {
+          wrappedLines[destLineIndex].copyCellsFrom(wrappedLines[destLineIndex - 1], newCols - 1, destCol++, 1, false);
+          // Null out the end of the last row
+          wrappedLines[destLineIndex - 1].setCell(newCols - 1, nullCell);
+        }
+      }
+    }
+
+    // Clear out remaining cells or fragments could remain;
+    wrappedLines[destLineIndex].replaceCells(destCol, newCols, nullCell);
+
+    // Work backwards and remove any rows at the end that only contain null cells
+    let countToRemove = 0;
+    for (let i = wrappedLines.length - 1; i > 0; i--) {
+      if (i > destLineIndex || wrappedLines[i].getTrimmedLength() === 0) {
+        countToRemove++;
+      } else {
+        break;
+      }
+    }
+
+    if (countToRemove > 0) {
+      toRemove.push(y + wrappedLines.length - countToRemove); // index
+      toRemove.push(countToRemove);
+    }
+
+    y += wrappedLines.length - 1;
+  }
+  return toRemove;
+}
+
+/**
+ * Creates and return the new layout for lines given an array of indexes to be removed.
+ * @param lines The buffer lines.
+ * @param toRemove The indexes to remove.
+ */
+export function reflowLargerCreateNewLayout(lines: CircularList<IBufferLine>, toRemove: number[]): INewLayoutResult {
+  const layout: number[] = [];
+  // First iterate through the list and get the actual indexes to use for rows
+  let nextToRemoveIndex = 0;
+  let nextToRemoveStart = toRemove[nextToRemoveIndex];
+  let countRemovedSoFar = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (nextToRemoveStart === i) {
+      const countToRemove = toRemove[++nextToRemoveIndex];
+
+      // Tell markers that there was a deletion
+      lines.onDeleteEmitter.fire({
+        index: i - countRemovedSoFar,
+        amount: countToRemove
+      });
+
+      i += countToRemove - 1;
+      countRemovedSoFar += countToRemove;
+      nextToRemoveStart = toRemove[++nextToRemoveIndex];
+    } else {
+      layout.push(i);
+    }
+  }
+  return {
+    layout,
+    countRemoved: countRemovedSoFar
+  };
+}
+
+/**
+ * Applies a new layout to the buffer. This essentially does the same as many splice calls but it's
+ * done all at once in a single iteration through the list since splice is very expensive.
+ * @param lines The buffer lines.
+ * @param newLayout The new layout to apply.
+ */
+export function reflowLargerApplyNewLayout(lines: CircularList<IBufferLine>, newLayout: number[]): void {
+  // Record original lines so they don't get overridden when we rearrange the list
+  const newLayoutLines: BufferLine[] = [];
+  for (let i = 0; i < newLayout.length; i++) {
+    newLayoutLines.push(lines.get(newLayout[i]) as BufferLine);
+  }
+
+  // Rearrange the list
+  for (let i = 0; i < newLayoutLines.length; i++) {
+    lines.set(i, newLayoutLines[i]);
+  }
+  lines.length = newLayout.length;
+}
+
+/**
+ * Gets the new line lengths for a given wrapped line. The purpose of this function it to pre-
+ * compute the wrapping points since wide characters may need to be wrapped onto the following line.
+ * This function will return an array of numbers of where each line wraps to, the resulting array
+ * will only contain the values `newCols` (when the line does not end with a wide character) and
+ * `newCols - 1` (when the line does end with a wide character), except for the last value which
+ * will contain the remaining items to fill the line.
+ *
+ * Calling this with a `newCols` value of `1` will lock up.
+ *
+ * @param wrappedLines The wrapped lines to evaluate.
+ * @param oldCols The columns before resize.
+ * @param newCols The columns after resize.
+ */
+export function reflowSmallerGetNewLineLengths(wrappedLines: BufferLine[], oldCols: number, newCols: number): number[] {
+  const newLineLengths: number[] = [];
+  const cellsNeeded = wrappedLines.map((l, i) => getWrappedLineTrimmedLength(wrappedLines, i, oldCols)).reduce((p, c) => p + c);
+
+  // Use srcCol and srcLine to find the new wrapping point, use that to get the cellsAvailable and
+  // linesNeeded
+  let srcCol = 0;
+  let srcLine = 0;
+  let cellsAvailable = 0;
+  while (cellsAvailable < cellsNeeded) {
+    if (cellsNeeded - cellsAvailable < newCols) {
+      // Add the final line and exit the loop
+      newLineLengths.push(cellsNeeded - cellsAvailable);
+      break;
+    }
+    srcCol += newCols;
+    const oldTrimmedLength = getWrappedLineTrimmedLength(wrappedLines, srcLine, oldCols);
+    if (srcCol > oldTrimmedLength) {
+      srcCol -= oldTrimmedLength;
+      srcLine++;
+    }
+    const endsWithWide = wrappedLines[srcLine].getWidth(srcCol - 1) === 2;
+    if (endsWithWide) {
+      srcCol--;
+    }
+    const lineLength = endsWithWide ? newCols - 1 : newCols;
+    newLineLengths.push(lineLength);
+    cellsAvailable += lineLength;
+  }
+
+  return newLineLengths;
+}
+
+export function getWrappedLineTrimmedLength(lines: BufferLine[], i: number, cols: number): number {
+  // If this is the last row in the wrapped line, get the actual trimmed length
+  if (i === lines.length - 1) {
+    return lines[i].getTrimmedLength();
+  }
+  // Detect whether the following line starts with a wide character and the end of the current line
+  // is null, if so then we can be pretty sure the null character should be excluded from the line
+  // length]
+  const endsInNull = !(lines[i].hasContent(cols - 1)) && lines[i].getWidth(cols - 1) === 1;
+  const followingLineStartsWithWide = lines[i + 1].getWidth(0) === 2;
+  if (endsInNull && followingLineStartsWithWide) {
+    return cols - 1;
+  }
+  return cols;
+}
@@ -7,7 +7,7 @@ import { assert } from 'chai';
 import { ITerminal } from './Types';
 import { BufferSet } from './BufferSet';
 import { Buffer } from './Buffer';
-import { MockTerminal } from './utils/TestUtils.test';
+import { MockTerminal } from './TestUtils.test';

 describe('BufferSet', () => {
  let terminal: ITerminal;
@@ -15,8 +15,8 @@ describe('BufferSet', () => {

  beforeEach(() => {
    terminal = new MockTerminal();
-    terminal.cols = 80;
-    terminal.rows = 24;
+    (terminal as any).cols = 80;
+    (terminal as any).rows = 24;
    terminal.options.scrollback = 1000;
    bufferSet = new BufferSet(terminal);
  });
@@ -48,4 +48,30 @@ describe('BufferSet', () => {
      assert.equal(bufferSet.active, bufferSet.alt);
    });
  });
+
+  describe('cursor handling when swapping buffers', () => {
+    beforeEach(() => {
+      bufferSet.normal.x = 0;
+      bufferSet.normal.y = 0;
+      bufferSet.alt.x = 0;
+      bufferSet.alt.y = 0;
+    });
+
+    it('should keep the cursor stationary when activating alt buffer', () => {
+      bufferSet.activateNormalBuffer();
+      bufferSet.active.x = 30;
+      bufferSet.active.y = 10;
+      bufferSet.activateAltBuffer();
+      assert.equal(bufferSet.active.x, 30);
+      assert.equal(bufferSet.active.y, 10);
+    });
+    it('should keep the cursor stationary when activating normal buffer', () => {
+      bufferSet.activateAltBuffer();
+      bufferSet.active.x = 30;
+      bufferSet.active.y = 10;
+      bufferSet.activateNormalBuffer();
+      assert.equal(bufferSet.active.x, 30);
+      assert.equal(bufferSet.active.y, 10);
+    });
+  });
 });
@@ -3,25 +3,28 @@
 * @license MIT
 */

-import { ITerminal, IBufferSet } from './Types';
+import { ITerminal, IBufferSet, IAttributeData, IBuffer } from './Types';
 import { Buffer } from './Buffer';
-import { EventEmitter } from './common/EventEmitter';
+import { EventEmitter2, IEvent } from './common/EventEmitter2';

 /**
 * The BufferSet represents the set of two buffers used by xterm terminals (normal and alt) and
 * provides also utilities for working with them.
 */
-export class BufferSet extends EventEmitter implements IBufferSet {
+export class BufferSet implements IBufferSet {
  private _normal: Buffer;
  private _alt: Buffer;
  private _activeBuffer: Buffer;

+
+  private _onBufferActivate = new EventEmitter2<{activeBuffer: IBuffer, inactiveBuffer: IBuffer}>();
+  public get onBufferActivate(): IEvent<{activeBuffer: IBuffer, inactiveBuffer: IBuffer}> { return this._onBufferActivate.event; }
+
  /**
   * Create a new BufferSet for the given terminal.
   * @param _terminal - The terminal the BufferSet will belong to
   */
  constructor(private _terminal: ITerminal) {
-    super();
    this._normal = new Buffer(this._terminal, true);
    this._normal.fillViewportRows();

@@ -61,12 +64,14 @@ export class BufferSet extends EventEmitter implements IBufferSet {
    if (this._activeBuffer === this._normal) {
      return;
    }
+    this._normal.x = this._alt.x;
+    this._normal.y = this._alt.y;
    // The alt buffer should always be cleared when we switch to the normal
    // buffer. This frees up memory since the alt buffer should always be new
    // when activated.
    this._alt.clear();
    this._activeBuffer = this._normal;
-    this.emit('activate', {
+    this._onBufferActivate.fire({
      activeBuffer: this._normal,
      inactiveBuffer: this._alt
    });
@@ -75,15 +80,17 @@ export class BufferSet extends EventEmitter implements IBufferSet {
  /**
   * Sets the alt Buffer of the BufferSet as its currently active Buffer
   */
-  public activateAltBuffer(): void {
+  public activateAltBuffer(fillAttr?: IAttributeData): void {
    if (this._activeBuffer === this._alt) {
      return;
    }
    // Since the alt buffer is always cleared when the normal buffer is
    // activated, we want to fill it when switching to it.
-    this._alt.fillViewportRows();
+    this._alt.fillViewportRows(fillAttr);
+    this._alt.x = this._normal.x;
+    this._alt.y = this._normal.y;
    this._activeBuffer = this._alt;
-    this.emit('activate', {
+    this._onBufferActivate.fire({
      activeBuffer: this._alt,
      inactiveBuffer: this._normal
    });
@@ -4,7 +4,7 @@
 */

 import jsdom = require('jsdom');
-import { ICharMeasure } from '../Types';
+import { ICharMeasure } from './Types';
 import { assert } from 'chai';
 import { CharMeasure } from './CharMeasure';

@@ -3,23 +3,25 @@
 * @license MIT
 */

-import { ICharMeasure, ITerminalOptions } from '../Types';
-import { EventEmitter } from '../common/EventEmitter';
+import { ICharMeasure, ITerminalOptions } from './Types';
+import { EventEmitter2, IEvent } from './common/EventEmitter2';

 /**
 * Utility class that measures the size of a character. Measurements are done in
 * the DOM rather than with a canvas context because support for extracting the
 * height of characters is patchy across browsers.
 */
-export class CharMeasure extends EventEmitter implements ICharMeasure {
+export class CharMeasure implements ICharMeasure {
  private _document: Document;
  private _parentElement: HTMLElement;
  private _measureElement: HTMLElement;
  private _width: number;
  private _height: number;

+  private _onCharSizeChanged = new EventEmitter2<void>();
+  public get onCharSizeChanged(): IEvent<void> { return this._onCharSizeChanged.event; }
+
  constructor(document: Document, parentElement: HTMLElement) {
-    super();
    this._document = document;
    this._parentElement = parentElement;
    this._measureElement = this._document.createElement('span');
@@ -38,7 +40,7 @@ export class CharMeasure extends EventEmitter implements ICharMeasure {
  }

  public measure(options: ITerminalOptions): void {
-  this._measureElement.style.fontFamily = options.fontFamily;
+    this._measureElement.style.fontFamily = options.fontFamily;
    this._measureElement.style.fontSize = `${options.fontSize}px`;
    const geometry = this._measureElement.getBoundingClientRect();
    // The element is likely currently display:none, we should retain the
@@ -46,10 +48,11 @@ export class CharMeasure extends EventEmitter implements ICharMeasure {
    if (geometry.width === 0 || geometry.height === 0) {
      return;
    }
-    if (this._width !== geometry.width || this._height !== geometry.height) {
+    const adjustedHeight = Math.ceil(geometry.height);
+    if (this._width !== geometry.width || this._height !== adjustedHeight) {
      this._width = geometry.width;
-      this._height = Math.ceil(geometry.height);
-      this.emit('charsizechanged');
+      this._height = adjustedHeight;
+      this._onCharSizeChanged.fire();
    }
  }
 }
@@ -3,11 +3,12 @@
 * @license MIT
 */

-import { TestTerminal } from './utils/TestUtils.test';
+import { TestTerminal } from './TestUtils.test';
 import { assert } from 'chai';
-import { getStringCellWidth } from './CharWidth';
+import { getStringCellWidth, wcwidth } from './CharWidth';
 import { IBuffer } from './Types';
 import { CHAR_DATA_WIDTH_INDEX, CHAR_DATA_CHAR_INDEX } from './Buffer';
+import { CellData } from './BufferLine';


 describe('getStringCellWidth', function(): void {
@@ -22,7 +23,7 @@ describe('getStringCellWidth', function(): void {
    for (let i = start; i < end; ++i) {
      const line = buffer.lines.get(i);
      for (let j = 0; j < line.length; ++j) { // TODO: change to trimBorder with multiline
-        const ch = line.get(j);
+        const ch = line.loadCell(j, new CellData()).getAsCharData();
        result += ch[CHAR_DATA_WIDTH_INDEX];
        // return on sentinel
        if (ch[CHAR_DATA_CHAR_INDEX] === sentinel) {
@@ -77,3 +78,178 @@ describe('getStringCellWidth', function(): void {
  });
  // TODO: multiline tests once #1685 is resolved
 });
+
+it('wcwidth should match all values from the old implementation', function(): void {
+  // old implementation
+  const wcwidthOld = (function(opts: {nul: number, control: number}): (ucs: number) => number {
+    // extracted from https://www.cl.cam.ac.uk/%7Emgk25/ucs/wcwidth.c
+    // combining characters
+    const COMBINING_BMP = [
+      [0x0300, 0x036F], [0x0483, 0x0486], [0x0488, 0x0489],
+      [0x0591, 0x05BD], [0x05BF, 0x05BF], [0x05C1, 0x05C2],
+      [0x05C4, 0x05C5], [0x05C7, 0x05C7], [0x0600, 0x0603],
+      [0x0610, 0x0615], [0x064B, 0x065E], [0x0670, 0x0670],
+      [0x06D6, 0x06E4], [0x06E7, 0x06E8], [0x06EA, 0x06ED],
+      [0x070F, 0x070F], [0x0711, 0x0711], [0x0730, 0x074A],
+      [0x07A6, 0x07B0], [0x07EB, 0x07F3], [0x0901, 0x0902],
+      [0x093C, 0x093C], [0x0941, 0x0948], [0x094D, 0x094D],
+      [0x0951, 0x0954], [0x0962, 0x0963], [0x0981, 0x0981],
+      [0x09BC, 0x09BC], [0x09C1, 0x09C4], [0x09CD, 0x09CD],
+      [0x09E2, 0x09E3], [0x0A01, 0x0A02], [0x0A3C, 0x0A3C],
+      [0x0A41, 0x0A42], [0x0A47, 0x0A48], [0x0A4B, 0x0A4D],
+      [0x0A70, 0x0A71], [0x0A81, 0x0A82], [0x0ABC, 0x0ABC],
+      [0x0AC1, 0x0AC5], [0x0AC7, 0x0AC8], [0x0ACD, 0x0ACD],
+      [0x0AE2, 0x0AE3], [0x0B01, 0x0B01], [0x0B3C, 0x0B3C],
+      [0x0B3F, 0x0B3F], [0x0B41, 0x0B43], [0x0B4D, 0x0B4D],
+      [0x0B56, 0x0B56], [0x0B82, 0x0B82], [0x0BC0, 0x0BC0],
+      [0x0BCD, 0x0BCD], [0x0C3E, 0x0C40], [0x0C46, 0x0C48],
+      [0x0C4A, 0x0C4D], [0x0C55, 0x0C56], [0x0CBC, 0x0CBC],
+      [0x0CBF, 0x0CBF], [0x0CC6, 0x0CC6], [0x0CCC, 0x0CCD],
+      [0x0CE2, 0x0CE3], [0x0D41, 0x0D43], [0x0D4D, 0x0D4D],
+      [0x0DCA, 0x0DCA], [0x0DD2, 0x0DD4], [0x0DD6, 0x0DD6],
+      [0x0E31, 0x0E31], [0x0E34, 0x0E3A], [0x0E47, 0x0E4E],
+      [0x0EB1, 0x0EB1], [0x0EB4, 0x0EB9], [0x0EBB, 0x0EBC],
+      [0x0EC8, 0x0ECD], [0x0F18, 0x0F19], [0x0F35, 0x0F35],
+      [0x0F37, 0x0F37], [0x0F39, 0x0F39], [0x0F71, 0x0F7E],
+      [0x0F80, 0x0F84], [0x0F86, 0x0F87], [0x0F90, 0x0F97],
+      [0x0F99, 0x0FBC], [0x0FC6, 0x0FC6], [0x102D, 0x1030],
+      [0x1032, 0x1032], [0x1036, 0x1037], [0x1039, 0x1039],
+      [0x1058, 0x1059], [0x1160, 0x11FF], [0x135F, 0x135F],
+      [0x1712, 0x1714], [0x1732, 0x1734], [0x1752, 0x1753],
+      [0x1772, 0x1773], [0x17B4, 0x17B5], [0x17B7, 0x17BD],
+      [0x17C6, 0x17C6], [0x17C9, 0x17D3], [0x17DD, 0x17DD],
+      [0x180B, 0x180D], [0x18A9, 0x18A9], [0x1920, 0x1922],
+      [0x1927, 0x1928], [0x1932, 0x1932], [0x1939, 0x193B],
+      [0x1A17, 0x1A18], [0x1B00, 0x1B03], [0x1B34, 0x1B34],
+      [0x1B36, 0x1B3A], [0x1B3C, 0x1B3C], [0x1B42, 0x1B42],
+      [0x1B6B, 0x1B73], [0x1DC0, 0x1DCA], [0x1DFE, 0x1DFF],
+      [0x200B, 0x200F], [0x202A, 0x202E], [0x2060, 0x2063],
+      [0x206A, 0x206F], [0x20D0, 0x20EF], [0x302A, 0x302F],
+      [0x3099, 0x309A], [0xA806, 0xA806], [0xA80B, 0xA80B],
+      [0xA825, 0xA826], [0xFB1E, 0xFB1E], [0xFE00, 0xFE0F],
+      [0xFE20, 0xFE23], [0xFEFF, 0xFEFF], [0xFFF9, 0xFFFB]
+    ];
+    const COMBINING_HIGH = [
+      [0x10A01, 0x10A03], [0x10A05, 0x10A06], [0x10A0C, 0x10A0F],
+      [0x10A38, 0x10A3A], [0x10A3F, 0x10A3F], [0x1D167, 0x1D169],
+      [0x1D173, 0x1D182], [0x1D185, 0x1D18B], [0x1D1AA, 0x1D1AD],
+      [0x1D242, 0x1D244], [0xE0001, 0xE0001], [0xE0020, 0xE007F],
+      [0xE0100, 0xE01EF]
+    ];
+    // binary search
+    function bisearch(ucs: number, data: number[][]): boolean {
+      let min = 0;
+      let max = data.length - 1;
+      let mid;
+      if (ucs < data[0][0] || ucs > data[max][1]) {
+        return false;
+      }
+      while (max >= min) {
+        mid = (min + max) >> 1;
+        if (ucs > data[mid][1]) {
+          min = mid + 1;
+        } else if (ucs < data[mid][0]) {
+          max = mid - 1;
+        } else {
+          return true;
+        }
+      }
+      return false;
+    }
+    function wcwidthBMP(ucs: number): number {
+      // test for 8-bit control characters
+      if (ucs === 0) {
+        return opts.nul;
+      }
+      if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) {
+        return opts.control;
+      }
+      // binary search in table of non-spacing characters
+      if (bisearch(ucs, COMBINING_BMP)) {
+        return 0;
+      }
+      // if we arrive here, ucs is not a combining or C0/C1 control character
+      if (isWideBMP(ucs)) {
+        return 2;
+      }
+      return 1;
+    }
+    function isWideBMP(ucs: number): boolean {
+      return (
+        ucs >= 0x1100 && (
+        ucs <= 0x115f ||                // Hangul Jamo init. consonants
+        ucs === 0x2329 ||
+        ucs === 0x232a ||
+        (ucs >= 0x2e80 && ucs <= 0xa4cf && ucs !== 0x303f) ||  // CJK..Yi
+        (ucs >= 0xac00 && ucs <= 0xd7a3) ||    // Hangul Syllables
+        (ucs >= 0xf900 && ucs <= 0xfaff) ||    // CJK Compat Ideographs
+        (ucs >= 0xfe10 && ucs <= 0xfe19) ||    // Vertical forms
+        (ucs >= 0xfe30 && ucs <= 0xfe6f) ||    // CJK Compat Forms
+        (ucs >= 0xff00 && ucs <= 0xff60) ||    // Fullwidth Forms
+        (ucs >= 0xffe0 && ucs <= 0xffe6)));
+    }
+    function wcwidthHigh(ucs: number): 0 | 1 | 2 {
+      if (bisearch(ucs, COMBINING_HIGH)) {
+        return 0;
+      }
+      if ((ucs >= 0x20000 && ucs <= 0x2fffd) || (ucs >= 0x30000 && ucs <= 0x3fffd)) {
+        return 2;
+      }
+      return 1;
+    }
+    const control = opts.control | 0;
+    let table: number[] | Uint32Array = null;
+    function initTable(): number[] | Uint32Array {
+      // lookup table for BMP
+      const CODEPOINTS = 65536;  // BMP holds 65536 codepoints
+      const BITWIDTH = 2;        // a codepoint can have a width of 0, 1 or 2
+      const ITEMSIZE = 32;       // using uint32_t
+      const CONTAINERSIZE = CODEPOINTS * BITWIDTH / ITEMSIZE;
+      const CODEPOINTS_PER_ITEM = ITEMSIZE / BITWIDTH;
+      table = (typeof Uint32Array === 'undefined')
+        ? new Array(CONTAINERSIZE)
+        : new Uint32Array(CONTAINERSIZE);
+      for (let i = 0; i < CONTAINERSIZE; ++i) {
+        let num = 0;
+        let pos = CODEPOINTS_PER_ITEM;
+        while (pos--) {
+          num = (num << 2) | wcwidthBMP(CODEPOINTS_PER_ITEM * i + pos);
+        }
+        table[i] = num;
+      }
+      return table;
+    }
+    // get width from lookup table
+    //   position in container   : num / CODEPOINTS_PER_ITEM
+    //     ==> n = table[Math.floor(num / 16)]
+    //     ==> n = table[num >> 4]
+    //   16 codepoints per number:       FFEEDDCCBBAA99887766554433221100
+    //   position in number      : (num % CODEPOINTS_PER_ITEM) * BITWIDTH
+    //     ==> m = (n % 16) * 2
+    //     ==> m = (num & 15) << 1
+    //   right shift to position m
+    //     ==> n = n >> m     e.g. m=12  000000000000FFEEDDCCBBAA99887766
+    //   we are only interested in 2 LSBs, cut off higher bits
+    //     ==> n = n & 3      e.g.       000000000000000000000000000000XX
+    return function (num: number): number {
+      num = num | 0;  // get asm.js like optimization under V8
+      if (num < 32) {
+        return control | 0;
+      }
+      if (num < 127) {
+        return 1;
+      }
+      const t = table || initTable();
+      if (num < 65536) {
+        return t[num >> 4] >> ((num & 15) << 1) & 3;
+      }
+      // do a full search for high codepoints
+      return wcwidthHigh(num);
+    };
+  })({nul: 0, control: 0}); // configurable options
+
+  // test full BMP range old vs new implmenetation
+  for (let i = 0; i < 65536; ++i) {
+    assert.equal(wcwidth(i), wcwidthOld(i), `mismatch for i: ${i}`);
+  }
+});
@@ -3,171 +3,139 @@
 * @license MIT
 */

+import { fill } from './common/TypedArrayUtils';
+
 export const wcwidth = (function(opts: {nul: number, control: number}): (ucs: number) => number {
-    // extracted from https://www.cl.cam.ac.uk/%7Emgk25/ucs/wcwidth.c
-    // combining characters
-    const COMBINING_BMP = [
-      [0x0300, 0x036F], [0x0483, 0x0486], [0x0488, 0x0489],
-      [0x0591, 0x05BD], [0x05BF, 0x05BF], [0x05C1, 0x05C2],
-      [0x05C4, 0x05C5], [0x05C7, 0x05C7], [0x0600, 0x0603],
-      [0x0610, 0x0615], [0x064B, 0x065E], [0x0670, 0x0670],
-      [0x06D6, 0x06E4], [0x06E7, 0x06E8], [0x06EA, 0x06ED],
-      [0x070F, 0x070F], [0x0711, 0x0711], [0x0730, 0x074A],
-      [0x07A6, 0x07B0], [0x07EB, 0x07F3], [0x0901, 0x0902],
-      [0x093C, 0x093C], [0x0941, 0x0948], [0x094D, 0x094D],
-      [0x0951, 0x0954], [0x0962, 0x0963], [0x0981, 0x0981],
-      [0x09BC, 0x09BC], [0x09C1, 0x09C4], [0x09CD, 0x09CD],
-      [0x09E2, 0x09E3], [0x0A01, 0x0A02], [0x0A3C, 0x0A3C],
-      [0x0A41, 0x0A42], [0x0A47, 0x0A48], [0x0A4B, 0x0A4D],
-      [0x0A70, 0x0A71], [0x0A81, 0x0A82], [0x0ABC, 0x0ABC],
-      [0x0AC1, 0x0AC5], [0x0AC7, 0x0AC8], [0x0ACD, 0x0ACD],
-      [0x0AE2, 0x0AE3], [0x0B01, 0x0B01], [0x0B3C, 0x0B3C],
-      [0x0B3F, 0x0B3F], [0x0B41, 0x0B43], [0x0B4D, 0x0B4D],
-      [0x0B56, 0x0B56], [0x0B82, 0x0B82], [0x0BC0, 0x0BC0],
-      [0x0BCD, 0x0BCD], [0x0C3E, 0x0C40], [0x0C46, 0x0C48],
-      [0x0C4A, 0x0C4D], [0x0C55, 0x0C56], [0x0CBC, 0x0CBC],
-      [0x0CBF, 0x0CBF], [0x0CC6, 0x0CC6], [0x0CCC, 0x0CCD],
-      [0x0CE2, 0x0CE3], [0x0D41, 0x0D43], [0x0D4D, 0x0D4D],
-      [0x0DCA, 0x0DCA], [0x0DD2, 0x0DD4], [0x0DD6, 0x0DD6],
-      [0x0E31, 0x0E31], [0x0E34, 0x0E3A], [0x0E47, 0x0E4E],
-      [0x0EB1, 0x0EB1], [0x0EB4, 0x0EB9], [0x0EBB, 0x0EBC],
-      [0x0EC8, 0x0ECD], [0x0F18, 0x0F19], [0x0F35, 0x0F35],
-      [0x0F37, 0x0F37], [0x0F39, 0x0F39], [0x0F71, 0x0F7E],
-      [0x0F80, 0x0F84], [0x0F86, 0x0F87], [0x0F90, 0x0F97],
-      [0x0F99, 0x0FBC], [0x0FC6, 0x0FC6], [0x102D, 0x1030],
-      [0x1032, 0x1032], [0x1036, 0x1037], [0x1039, 0x1039],
-      [0x1058, 0x1059], [0x1160, 0x11FF], [0x135F, 0x135F],
-      [0x1712, 0x1714], [0x1732, 0x1734], [0x1752, 0x1753],
-      [0x1772, 0x1773], [0x17B4, 0x17B5], [0x17B7, 0x17BD],
-      [0x17C6, 0x17C6], [0x17C9, 0x17D3], [0x17DD, 0x17DD],
-      [0x180B, 0x180D], [0x18A9, 0x18A9], [0x1920, 0x1922],
-      [0x1927, 0x1928], [0x1932, 0x1932], [0x1939, 0x193B],
-      [0x1A17, 0x1A18], [0x1B00, 0x1B03], [0x1B34, 0x1B34],
-      [0x1B36, 0x1B3A], [0x1B3C, 0x1B3C], [0x1B42, 0x1B42],
-      [0x1B6B, 0x1B73], [0x1DC0, 0x1DCA], [0x1DFE, 0x1DFF],
-      [0x200B, 0x200F], [0x202A, 0x202E], [0x2060, 0x2063],
-      [0x206A, 0x206F], [0x20D0, 0x20EF], [0x302A, 0x302F],
-      [0x3099, 0x309A], [0xA806, 0xA806], [0xA80B, 0xA80B],
-      [0xA825, 0xA826], [0xFB1E, 0xFB1E], [0xFE00, 0xFE0F],
-      [0xFE20, 0xFE23], [0xFEFF, 0xFEFF], [0xFFF9, 0xFFFB]
-    ];
-    const COMBINING_HIGH = [
-      [0x10A01, 0x10A03], [0x10A05, 0x10A06], [0x10A0C, 0x10A0F],
-      [0x10A38, 0x10A3A], [0x10A3F, 0x10A3F], [0x1D167, 0x1D169],
-      [0x1D173, 0x1D182], [0x1D185, 0x1D18B], [0x1D1AA, 0x1D1AD],
-      [0x1D242, 0x1D244], [0xE0001, 0xE0001], [0xE0020, 0xE007F],
-      [0xE0100, 0xE01EF]
-    ];
-    // binary search
-    function bisearch(ucs: number, data: number[][]): boolean {
-      let min = 0;
-      let max = data.length - 1;
-      let mid;
-      if (ucs < data[0][0] || ucs > data[max][1]) {
-        return false;
-      }
-      while (max >= min) {
-        mid = (min + max) >> 1;
-        if (ucs > data[mid][1]) {
-          min = mid + 1;
-        } else if (ucs < data[mid][0]) {
-          max = mid - 1;
-        } else {
-          return true;
-        }
-      }
+  // extracted from https://www.cl.cam.ac.uk/%7Emgk25/ucs/wcwidth.c
+  // combining characters
+  const COMBINING_BMP = [
+    [0x0300, 0x036F], [0x0483, 0x0486], [0x0488, 0x0489],
+    [0x0591, 0x05BD], [0x05BF, 0x05BF], [0x05C1, 0x05C2],
+    [0x05C4, 0x05C5], [0x05C7, 0x05C7], [0x0600, 0x0603],
+    [0x0610, 0x0615], [0x064B, 0x065E], [0x0670, 0x0670],
+    [0x06D6, 0x06E4], [0x06E7, 0x06E8], [0x06EA, 0x06ED],
+    [0x070F, 0x070F], [0x0711, 0x0711], [0x0730, 0x074A],
+    [0x07A6, 0x07B0], [0x07EB, 0x07F3], [0x0901, 0x0902],
+    [0x093C, 0x093C], [0x0941, 0x0948], [0x094D, 0x094D],
+    [0x0951, 0x0954], [0x0962, 0x0963], [0x0981, 0x0981],
+    [0x09BC, 0x09BC], [0x09C1, 0x09C4], [0x09CD, 0x09CD],
+    [0x09E2, 0x09E3], [0x0A01, 0x0A02], [0x0A3C, 0x0A3C],
+    [0x0A41, 0x0A42], [0x0A47, 0x0A48], [0x0A4B, 0x0A4D],
+    [0x0A70, 0x0A71], [0x0A81, 0x0A82], [0x0ABC, 0x0ABC],
+    [0x0AC1, 0x0AC5], [0x0AC7, 0x0AC8], [0x0ACD, 0x0ACD],
+    [0x0AE2, 0x0AE3], [0x0B01, 0x0B01], [0x0B3C, 0x0B3C],
+    [0x0B3F, 0x0B3F], [0x0B41, 0x0B43], [0x0B4D, 0x0B4D],
+    [0x0B56, 0x0B56], [0x0B82, 0x0B82], [0x0BC0, 0x0BC0],
+    [0x0BCD, 0x0BCD], [0x0C3E, 0x0C40], [0x0C46, 0x0C48],
+    [0x0C4A, 0x0C4D], [0x0C55, 0x0C56], [0x0CBC, 0x0CBC],
+    [0x0CBF, 0x0CBF], [0x0CC6, 0x0CC6], [0x0CCC, 0x0CCD],
+    [0x0CE2, 0x0CE3], [0x0D41, 0x0D43], [0x0D4D, 0x0D4D],
+    [0x0DCA, 0x0DCA], [0x0DD2, 0x0DD4], [0x0DD6, 0x0DD6],
+    [0x0E31, 0x0E31], [0x0E34, 0x0E3A], [0x0E47, 0x0E4E],
+    [0x0EB1, 0x0EB1], [0x0EB4, 0x0EB9], [0x0EBB, 0x0EBC],
+    [0x0EC8, 0x0ECD], [0x0F18, 0x0F19], [0x0F35, 0x0F35],
+    [0x0F37, 0x0F37], [0x0F39, 0x0F39], [0x0F71, 0x0F7E],
+    [0x0F80, 0x0F84], [0x0F86, 0x0F87], [0x0F90, 0x0F97],
+    [0x0F99, 0x0FBC], [0x0FC6, 0x0FC6], [0x102D, 0x1030],
+    [0x1032, 0x1032], [0x1036, 0x1037], [0x1039, 0x1039],
+    [0x1058, 0x1059], [0x1160, 0x11FF], [0x135F, 0x135F],
+    [0x1712, 0x1714], [0x1732, 0x1734], [0x1752, 0x1753],
+    [0x1772, 0x1773], [0x17B4, 0x17B5], [0x17B7, 0x17BD],
+    [0x17C6, 0x17C6], [0x17C9, 0x17D3], [0x17DD, 0x17DD],
+    [0x180B, 0x180D], [0x18A9, 0x18A9], [0x1920, 0x1922],
+    [0x1927, 0x1928], [0x1932, 0x1932], [0x1939, 0x193B],
+    [0x1A17, 0x1A18], [0x1B00, 0x1B03], [0x1B34, 0x1B34],
+    [0x1B36, 0x1B3A], [0x1B3C, 0x1B3C], [0x1B42, 0x1B42],
+    [0x1B6B, 0x1B73], [0x1DC0, 0x1DCA], [0x1DFE, 0x1DFF],
+    [0x200B, 0x200F], [0x202A, 0x202E], [0x2060, 0x2063],
+    [0x206A, 0x206F], [0x20D0, 0x20EF], [0x302A, 0x302F],
+    [0x3099, 0x309A], [0xA806, 0xA806], [0xA80B, 0xA80B],
+    [0xA825, 0xA826], [0xFB1E, 0xFB1E], [0xFE00, 0xFE0F],
+    [0xFE20, 0xFE23], [0xFEFF, 0xFEFF], [0xFFF9, 0xFFFB]
+  ];
+  const COMBINING_HIGH = [
+    [0x10A01, 0x10A03], [0x10A05, 0x10A06], [0x10A0C, 0x10A0F],
+    [0x10A38, 0x10A3A], [0x10A3F, 0x10A3F], [0x1D167, 0x1D169],
+    [0x1D173, 0x1D182], [0x1D185, 0x1D18B], [0x1D1AA, 0x1D1AD],
+    [0x1D242, 0x1D244], [0xE0001, 0xE0001], [0xE0020, 0xE007F],
+    [0xE0100, 0xE01EF]
+  ];
+  // binary search
+  function bisearch(ucs: number, data: number[][]): boolean {
+    let min = 0;
+    let max = data.length - 1;
+    let mid;
+    if (ucs < data[0][0] || ucs > data[max][1]) {
      return false;
    }
-    function wcwidthBMP(ucs: number): number {
-      // test for 8-bit control characters
-      if (ucs === 0) {
-        return opts.nul;
-      }
-      if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) {
-        return opts.control;
-      }
-      // binary search in table of non-spacing characters
-      if (bisearch(ucs, COMBINING_BMP)) {
-        return 0;
-      }
-      // if we arrive here, ucs is not a combining or C0/C1 control character
-      if (isWideBMP(ucs)) {
-        return 2;
+    while (max >= min) {
+      mid = (min + max) >> 1;
+      if (ucs > data[mid][1]) {
+        min = mid + 1;
+      } else if (ucs < data[mid][0]) {
+        max = mid - 1;
+      } else {
+        return true;
      }
+    }
+    return false;
+  }
+  function wcwidthHigh(ucs: number): 0 | 1 | 2 {
+    if (bisearch(ucs, COMBINING_HIGH)) {
+      return 0;
+    }
+    if ((ucs >= 0x20000 && ucs <= 0x2fffd) || (ucs >= 0x30000 && ucs <= 0x3fffd)) {
+      return 2;
+    }
+    return 1;
+  }
+  const control = opts.control | 0;
+
+  // create lookup table for BMP plane
+  const table = new Uint8Array(65536);
+  fill(table, 1);
+  table[0] = opts.nul;
+  // control chars
+  fill(table, opts.control, 1, 32);
+  fill(table, opts.control, 0x7f, 0xa0);
+
+  // apply wide char rules first
+  // wide chars
+  fill(table, 2, 0x1100, 0x1160);
+  table[0x2329] = 2;
+  table[0x232a] = 2;
+  fill(table, 2, 0x2e80, 0xa4d0);
+  table[0x303f] = 1;  // wrongly in last line
+
+  fill(table, 2, 0xac00, 0xd7a4);
+  fill(table, 2, 0xf900, 0xfb00);
+  fill(table, 2, 0xfe10, 0xfe1a);
+  fill(table, 2, 0xfe30, 0xfe70);
+  fill(table, 2, 0xff00, 0xff61);
+  fill(table, 2, 0xffe0, 0xffe7);
+
+  // apply combining last to ensure we overwrite
+  // wrongly wide set chars:
+  //    the original algo evals combining first and falls
+  //    through to wide check so we simply do here the opposite
+  // combining 0
+  for (let r = 0; r < COMBINING_BMP.length; ++r) {
+    fill(table, 0, COMBINING_BMP[r][0], COMBINING_BMP[r][1] + 1);
+  }
+
+  return function (num: number): number {
+    if (num < 32) {
+      return control | 0;
+    }
+    if (num < 127) {
      return 1;
    }
-    function isWideBMP(ucs: number): boolean {
-      return (
-        ucs >= 0x1100 && (
-        ucs <= 0x115f ||                // Hangul Jamo init. consonants
-        ucs === 0x2329 ||
-        ucs === 0x232a ||
-        (ucs >= 0x2e80 && ucs <= 0xa4cf && ucs !== 0x303f) ||  // CJK..Yi
-        (ucs >= 0xac00 && ucs <= 0xd7a3) ||    // Hangul Syllables
-        (ucs >= 0xf900 && ucs <= 0xfaff) ||    // CJK Compat Ideographs
-        (ucs >= 0xfe10 && ucs <= 0xfe19) ||    // Vertical forms
-        (ucs >= 0xfe30 && ucs <= 0xfe6f) ||    // CJK Compat Forms
-        (ucs >= 0xff00 && ucs <= 0xff60) ||    // Fullwidth Forms
-        (ucs >= 0xffe0 && ucs <= 0xffe6)));
+    if (num < 65536) {
+      return table[num];
    }
-    function wcwidthHigh(ucs: number): 0 | 1 | 2 {
-      if (bisearch(ucs, COMBINING_HIGH)) {
-        return 0;
-      }
-      if ((ucs >= 0x20000 && ucs <= 0x2fffd) || (ucs >= 0x30000 && ucs <= 0x3fffd)) {
-        return 2;
-      }
-      return 1;
-    }
-    const control = opts.control | 0;
-    let table: number[] | Uint32Array = null;
-    function initTable(): number[] | Uint32Array {
-      // lookup table for BMP
-      const CODEPOINTS = 65536;  // BMP holds 65536 codepoints
-      const BITWIDTH = 2;        // a codepoint can have a width of 0, 1 or 2
-      const ITEMSIZE = 32;       // using uint32_t
-      const CONTAINERSIZE = CODEPOINTS * BITWIDTH / ITEMSIZE;
-      const CODEPOINTS_PER_ITEM = ITEMSIZE / BITWIDTH;
-      table = (typeof Uint32Array === 'undefined')
-        ? new Array(CONTAINERSIZE)
-        : new Uint32Array(CONTAINERSIZE);
-      for (let i = 0; i < CONTAINERSIZE; ++i) {
-        let num = 0;
-        let pos = CODEPOINTS_PER_ITEM;
-        while (pos--) {
-          num = (num << 2) | wcwidthBMP(CODEPOINTS_PER_ITEM * i + pos);
-        }
-        table[i] = num;
-      }
-      return table;
-    }
-    // get width from lookup table
-    //   position in container   : num / CODEPOINTS_PER_ITEM
-    //     ==> n = table[Math.floor(num / 16)]
-    //     ==> n = table[num >> 4]
-    //   16 codepoints per number:       FFEEDDCCBBAA99887766554433221100
-    //   position in number      : (num % CODEPOINTS_PER_ITEM) * BITWIDTH
-    //     ==> m = (n % 16) * 2
-    //     ==> m = (num & 15) << 1
-    //   right shift to position m
-    //     ==> n = n >> m     e.g. m=12  000000000000FFEEDDCCBBAA99887766
-    //   we are only interested in 2 LSBs, cut off higher bits
-    //     ==> n = n & 3      e.g.       000000000000000000000000000000XX
-    return function (num: number): number {
-      num = num | 0;  // get asm.js like optimization under V8
-      if (num < 32) {
-        return control | 0;
-      }
-      if (num < 127) {
-        return 1;
-      }
-      const t = table || initTable();
-      if (num < 65536) {
-        return t[num >> 4] >> ((num & 15) << 1) & 3;
-      }
-      // do a full search for high codepoints
-      return wcwidthHigh(num);
-    };
+    // do a full search for high codepoints
+    return wcwidthHigh(num);
+  };
 })({nul: 0, control: 0});  // configurable options

 /**
@@ -175,17 +143,27 @@ export const wcwidth = (function(opts: {nul: number, control: number}): (ucs: nu
 */
 export function getStringCellWidth(s: string): number {
  let result = 0;
-  for (let i = 0; i < s.length; ++i) {
+  const length = s.length;
+  for (let i = 0; i < length; ++i) {
    let code = s.charCodeAt(i);
+    // surrogate pair first
    if (0xD800 <= code && code <= 0xDBFF) {
-      const low = s.charCodeAt(i + 1);
-      if (isNaN(low)) {
-        return result;
+      if (++i >= length) {
+        // this should not happen with strings retrieved from
+        // Buffer.translateToString as it converts from UTF-32
+        // and therefore always should contain the second part
+        // for any other string we still have to handle it somehow:
+        // simply treat the lonely surrogate first as a single char (UCS-2 behavior)
+        return result + wcwidth(code);
+      }
+      const second = s.charCodeAt(i);
+      // convert surrogate pair to high codepoint only for valid second part (UTF-16)
+      // otherwise treat them independently (UCS-2 behavior)
+      if (0xDC00 <= second && second <= 0xDFFF) {
+        code = (code - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+      } else {
+        result += wcwidth(second);
      }
-      code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
-    }
-    if (0xDC00 <= code && code <= 0xDFFF) {
-      continue;
    }
    result += wcwidth(code);
  }
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { ITerminal, ISelectionManager } from '../Types';
+import { ITerminal, ISelectionManager } from './Types';

 interface IWindow extends Window {
  clipboardData?: {
@@ -85,26 +85,32 @@ export function pasteHandler(ev: ClipboardEvent, term: ITerminal): void {
 * @param ev The original right click event to be handled.
 * @param textarea The terminal's textarea.
 */
-export function moveTextAreaUnderMouseCursor(ev: MouseEvent, textarea: HTMLTextAreaElement): void {
-  // Bring textarea at the cursor position
-  textarea.style.position = 'fixed';
-  textarea.style.width = '20px';
-  textarea.style.height = '20px';
-  textarea.style.left = (ev.clientX - 10) + 'px';
-  textarea.style.top = (ev.clientY - 10) + 'px';
-  textarea.style.zIndex = '1000';
+export function moveTextAreaUnderMouseCursor(ev: MouseEvent, term: ITerminal): void {

-  textarea.focus();
+  // Calculate textarea position relative to the screen element
+  const pos = term.screenElement.getBoundingClientRect();
+  const left = ev.clientX - pos.left - 10;
+  const top = ev.clientY - pos.top - 10;
+
+  // Bring textarea at the cursor position
+  term.textarea.style.position = 'absolute';
+  term.textarea.style.width = '20px';
+  term.textarea.style.height = '20px';
+  term.textarea.style.left = `${left}px`;
+  term.textarea.style.top = `${top}px`;
+  term.textarea.style.zIndex = '1000';
+
+  term.textarea.focus();

  // Reset the terminal textarea's styling
  // Timeout needs to be long enough for click event to be handled.
  setTimeout(() => {
-    textarea.style.position = null;
-    textarea.style.width = null;
-    textarea.style.height = null;
-    textarea.style.left = null;
-    textarea.style.top = null;
-    textarea.style.zIndex = null;
+    term.textarea.style.position = null;
+    term.textarea.style.width = null;
+    term.textarea.style.height = null;
+    term.textarea.style.left = null;
+    term.textarea.style.top = null;
+    term.textarea.style.zIndex = null;
  }, 200);
 }

@@ -115,14 +121,14 @@ export function moveTextAreaUnderMouseCursor(ev: MouseEvent, textarea: HTMLTextA
 * @param selectionManager The terminal's selection manager.
 * @param shouldSelectWord If true and there is no selection the current word will be selected
 */
-export function rightClickHandler(ev: MouseEvent, textarea: HTMLTextAreaElement, selectionManager: ISelectionManager, shouldSelectWord: boolean): void {
-  moveTextAreaUnderMouseCursor(ev, textarea);
+export function rightClickHandler(ev: MouseEvent, term: ITerminal, selectionManager: ISelectionManager, shouldSelectWord: boolean): void {
+  moveTextAreaUnderMouseCursor(ev, term);

  if (shouldSelectWord && !selectionManager.isClickInSelection(ev)) {
    selectionManager.selectWordAtCursor(ev);
  }

  // Get textarea ready to copy from the context menu
-  textarea.value = selectionManager.selectionText;
-  textarea.select();
+  term.textarea.value = selectionManager.selectionText;
+  term.textarea.select();
 }
@@ -111,17 +111,17 @@ export class CompositionHelper {
  /**
   * Finalizes the composition, resuming regular input actions. This is called when a composition
   * is ending.
-   * @param waitForPropogation Whether to wait for events to propogate before sending
+   * @param waitForPropagation Whether to wait for events to propagate before sending
   *   the input. This should be false if a non-composition keystroke is entered before the
-   *   compositionend event is triggered, such as enter, so that the composition is send before
+   *   compositionend event is triggered, such as enter, so that the composition is sent before
   *   the command is executed.
   */
-  private _finalizeComposition(waitForPropogation: boolean): void {
+  private _finalizeComposition(waitForPropagation: boolean): void {
    this._compositionView.classList.remove('active');
    this._isComposing = false;
    this._clearTextareaPosition();

-    if (!waitForPropogation) {
+    if (!waitForPropagation) {
      // Cancel any delayed composition send requests and send the input immediately.
      this._isSendingComposition = false;
      const input = this._textarea.value.substring(this._compositionPosition.start, this._compositionPosition.end);
@@ -136,8 +136,8 @@ export class CompositionHelper {

      // Since composition* events happen before the changes take place in the textarea on most
      // browsers, use a setTimeout with 0ms time to allow the native compositionend event to
-      // complete. This ensures the correct character is retrieved, this solution was used
-      // because:
+      // complete. This ensures the correct character is retrieved.
+      // This solution was used because:
      // - The compositionend event's data property is unreliable, at least on Chromium
      // - The last compositionupdate event's data property does not always accurately describe
      //   the character, a counter example being Korean where an ending consonsant can move to
@@ -203,6 +203,8 @@ export class CompositionHelper {
      this._compositionView.style.top = cursorTop + 'px';
      this._compositionView.style.height = cellHeight + 'px';
      this._compositionView.style.lineHeight = cellHeight + 'px';
+      this._compositionView.style.fontFamily = this._terminal.options.fontFamily;
+      this._compositionView.style.fontSize = this._terminal.options.fontSize + 'px';
      // Sync the textarea to the exact position of the composition view so the IME knows where the
      // text is.
      const compositionViewBounds = this._compositionView.getBoundingClientRect();
@@ -4,7 +4,16 @@
 */

 import { ParserState, ParserAction, IParsingState, IDcsHandler, IEscapeSequenceParser } from './Types';
+import { IDisposable } from 'xterm';
 import { Disposable } from './common/Lifecycle';
+import { utf32ToString } from './core/input/TextDecoder';
+
+interface IHandlerCollection<T> {
+  [key: string]: T[];
+}
+
+type CsiHandler = (params: number[], collect: string) => boolean | void;
+type OscHandler = (data: string) => boolean | void;

 /**
 * Returns an array filled with numbers between the low and high parameters (right exclusive).
@@ -66,8 +75,9 @@ export class TransitionTable {
 const PRINTABLES = r(0x20, 0x7f);
 const EXECUTABLES = r(0x00, 0x18);
 EXECUTABLES.push(0x19);
-EXECUTABLES.concat(r(0x1c, 0x20));
-const DEFAULT_TRANSITION = ParserAction.ERROR << 4 | ParserState.GROUND;
+EXECUTABLES.push.apply(EXECUTABLES, r(0x1c, 0x20));
+// Pseudo-character placeholder for printable non-ascii characters.
+const NON_ASCII_PRINTABLE = 0xA0;

 /**
 * VT500 compatible transition table.
@@ -79,10 +89,10 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
  const states: number[] = r(ParserState.GROUND, ParserState.DCS_PASSTHROUGH + 1);
  let state: any;

-  // table with default transition [any] --> DEFAULT_TRANSITION
+  // table with default transition
  for (state in states) {
    // NOTE: table lookup is capped at 0xa0 in parse to keep the table small
-    for (let code = 0; code < 160; ++code) {
+    for (let code = 0; code <= NON_ASCII_PRINTABLE; ++code) {
      table.add(code, state, ParserAction.ERROR, ParserState.GROUND);
    }
  }
@@ -125,6 +135,7 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
  table.addMany(PRINTABLES, ParserState.SOS_PM_APC_STRING, ParserAction.IGNORE, ParserState.SOS_PM_APC_STRING);
  table.addMany(EXECUTABLES, ParserState.SOS_PM_APC_STRING, ParserAction.IGNORE, ParserState.SOS_PM_APC_STRING);
  table.add(0x9c, ParserState.SOS_PM_APC_STRING, ParserAction.IGNORE, ParserState.GROUND);
+  table.add(0x7f, ParserState.SOS_PM_APC_STRING, ParserAction.IGNORE, ParserState.SOS_PM_APC_STRING);
  // csi entries
  table.add(0x5b, ParserState.ESCAPE, ParserAction.CLEAR, ParserState.CSI_ENTRY);
  table.addMany(r(0x40, 0x7f), ParserState.CSI_ENTRY, ParserAction.CSI_DISPATCH, ParserState.GROUND);
@@ -184,6 +195,7 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
  table.addMany(PRINTABLES, ParserState.DCS_PASSTHROUGH, ParserAction.DCS_PUT, ParserState.DCS_PASSTHROUGH);
  table.add(0x7f, ParserState.DCS_PASSTHROUGH, ParserAction.IGNORE, ParserState.DCS_PASSTHROUGH);
  table.addMany([0x1b, 0x9c], ParserState.DCS_PASSTHROUGH, ParserAction.DCS_UNHOOK, ParserState.GROUND);
+  table.add(NON_ASCII_PRINTABLE, ParserState.OSC_STRING, ParserAction.OSC_PUT, ParserState.OSC_STRING);
  return table;
 })();

@@ -192,7 +204,7 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
 */
 class DcsDummy implements IDcsHandler {
  hook(collect: string, params: number[], flag: number): void { }
-  put(data: string, start: number, end: number): void { }
+  put(data: Uint32Array, start: number, end: number): void { }
  unhook(): void { }
 }

@@ -218,17 +230,17 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
  protected _collect: string;

  // handler lookup containers
-  protected _printHandler: (data: string, start: number, end: number) => void;
+  protected _printHandler: (data: Uint32Array, start: number, end: number) => void;
  protected _executeHandlers: any;
-  protected _csiHandlers: any;
+  protected _csiHandlers: IHandlerCollection<CsiHandler>;
  protected _escHandlers: any;
-  protected _oscHandlers: any;
+  protected _oscHandlers: IHandlerCollection<OscHandler>;
  protected _dcsHandlers: any;
  protected _activeDcsHandler: IDcsHandler | null;
  protected _errorHandler: (state: IParsingState) => IParsingState;

  // fallback handlers
-  protected _printHandlerFb: (data: string, start: number, end: number) => void;
+  protected _printHandlerFb: (data: Uint32Array, start: number, end: number) => void;
  protected _executeHandlerFb: (code: number) => void;
  protected _csiHandlerFb: (collect: string, params: number[], flag: number) => void;
  protected _escHandlerFb: (collect: string, flag: number) => void;
@@ -261,6 +273,9 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
    this._dcsHandlers = Object.create(null);
    this._activeDcsHandler = null;
    this._errorHandler = this._errorHandlerFb;
+
+    // swallow 7bit ST (ESC+\)
+    this.setEscHandler('\\', () => {});
  }

  public dispose(): void {
@@ -273,15 +288,15 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
    this._errorHandlerFb = null;
    this._printHandler = null;
    this._executeHandlers = null;
-    this._csiHandlers = null;
    this._escHandlers = null;
+    this._csiHandlers = null;
    this._oscHandlers = null;
    this._dcsHandlers = null;
    this._activeDcsHandler = null;
    this._errorHandler = null;
  }

-  setPrintHandler(callback: (data: string, start: number, end: number) => void): void {
+  setPrintHandler(callback: (data: Uint32Array, start: number, end: number) => void): void {
    this._printHandler = callback;
  }
  clearPrintHandler(): void {
@@ -298,8 +313,24 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
    this._executeHandlerFb = callback;
  }

+  addCsiHandler(flag: string, callback: CsiHandler): IDisposable {
+    const index = flag.charCodeAt(0);
+    if (this._csiHandlers[index] === undefined) {
+      this._csiHandlers[index] = [];
+    }
+    const handlerList = this._csiHandlers[index];
+    handlerList.push(callback);
+    return {
+      dispose: () => {
+        const handlerIndex = handlerList.indexOf(callback);
+        if (handlerIndex !== -1) {
+          handlerList.splice(handlerIndex, 1);
+        }
+      }
+    };
+  }
  setCsiHandler(flag: string, callback: (params: number[], collect: string) => void): void {
-    this._csiHandlers[flag.charCodeAt(0)] = callback;
+    this._csiHandlers[flag.charCodeAt(0)] = [callback];
  }
  clearCsiHandler(flag: string): void {
    if (this._csiHandlers[flag.charCodeAt(0)]) delete this._csiHandlers[flag.charCodeAt(0)];
@@ -318,8 +349,23 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
    this._escHandlerFb = callback;
  }

+  addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
+    if (this._oscHandlers[ident] === undefined) {
+      this._oscHandlers[ident] = [];
+    }
+    const handlerList = this._oscHandlers[ident];
+    handlerList.push(callback);
+    return {
+      dispose: () => {
+        const handlerIndex = handlerList.indexOf(callback);
+        if (handlerIndex !== -1) {
+          handlerList.splice(handlerIndex, 1);
+        }
+      }
+    };
+  }
  setOscHandler(ident: number, callback: (data: string) => void): void {
-    this._oscHandlers[ident] = callback;
+    this._oscHandlers[ident] = [callback];
  }
  clearOscHandler(ident: number): void {
    if (this._oscHandlers[ident]) delete this._oscHandlers[ident];
@@ -353,7 +399,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
    this._activeDcsHandler = null;
  }

-  parse(data: string): void {
+  parse(data: Uint32Array, length: number): void {
    let code = 0;
    let transition = 0;
    let error = false;
@@ -368,15 +414,14 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
    let callback: Function | null = null;

    // process input string
-    const l = data.length;
-    for (let i = 0; i < l; ++i) {
-      code = data.charCodeAt(i);
+    for (let i = 0; i < length; ++i) {
+      code = data[i];

      // shortcut for most chars (print action)
      if (currentState === ParserState.GROUND && code > 0x1f && code < 0x80) {
        print = (~print) ? print : i;
        do i++;
-        while (i < l && data.charCodeAt(i) > 0x1f && data.charCodeAt(i) < 0x80);
+        while (i < length && data[i] > 0x1f && data[i] < 0x80);
        i--;
        continue;
      }
@@ -388,7 +433,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
      }

      // normal transition & action lookup
-      transition = (code < 0xa0) ? (table[currentState << 8 | code]) : DEFAULT_TRANSITION;
+      transition = table[currentState << 8 | (code < 0xa0 ? code : NON_ASCII_PRINTABLE)];
      switch (transition >> 4) {
        case ParserAction.PRINT:
          print = (~print) ? print : i;
@@ -420,10 +465,6 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
              case ParserState.GROUND:
                print = (~print) ? print : i;
                break;
-              case ParserState.OSC_STRING:
-                osc += String.fromCharCode(code);
-                transition |= ParserState.OSC_STRING;
-                break;
              case ParserState.CSI_IGNORE:
                transition |= ParserState.CSI_IGNORE;
                break;
@@ -460,9 +501,18 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
          }
          break;
        case ParserAction.CSI_DISPATCH:
-          callback = this._csiHandlers[code];
-          if (callback) callback(params, collect);
-          else this._csiHandlerFb(collect, params, code);
+          // Trigger CSI Handler
+          const handlers = this._csiHandlers[code];
+          let j = handlers ? handlers.length - 1 : -1;
+          for (; j >= 0; j--) {
+            // undefined or true means success and to stop bubbling
+            if (handlers[j](params, collect) !== false) {
+              break;
+            }
+          }
+          if (j < 0) {
+            this._csiHandlerFb(collect, params, code);
+          }
          break;
        case ParserAction.PARAM:
          if (code === 0x3b) params.push(0);
@@ -514,7 +564,15 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
          osc = '';
          break;
        case ParserAction.OSC_PUT:
-          osc += data.charAt(i);
+          for (let j = i + 1; ; j++) {
+            if (j >= length
+                || (code = data[j]) < 0x20
+                || (code > 0x7f && code <= 0x9f)) {
+              osc += utf32ToString(data, i, j);
+              i = j - 1;
+              break;
+            }
+          }
          break;
        case ParserAction.OSC_END:
          if (osc && code !== 0x18 && code !== 0x1a) {
@@ -529,9 +587,18 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
              // or with an explicit NaN OSC handler
              const identifier = parseInt(osc.substring(0, idx));
              const content = osc.substring(idx + 1);
-              callback = this._oscHandlers[identifier];
-              if (callback) callback(content);
-              else this._oscHandlerFb(identifier, content);
+              // Trigger OSC Handler
+              const handlers = this._oscHandlers[identifier];
+              let j = handlers ? handlers.length - 1 : -1;
+              for (; j >= 0; j--) {
+                // undefined or true means success and to stop bubbling
+                if (handlers[j](content) !== false) {
+                  break;
+                }
+              }
+              if (j < 0) {
+                this._oscHandlerFb(identifier, content);
+              }
            }
          }
          if (code === 0x1b) transition |= ParserState.ESCAPE;
@@ -546,9 +613,9 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP

    // push leftover pushable buffers to terminal
    if (currentState === ParserState.GROUND && ~print) {
-      this._printHandler(data, print, data.length);
+      this._printHandler(data, print, length);
    } else if (currentState === ParserState.DCS_PASSTHROUGH && ~dcs && dcsHandler) {
-      dcsHandler.put(data, dcs, data.length);
+      dcsHandler.put(data, dcs, length);
    }

    // save non pushable buffers
@@ -5,122 +5,33 @@

 import { assert, expect } from 'chai';
 import { InputHandler } from './InputHandler';
-import { MockInputHandlingTerminal } from './utils/TestUtils.test';
-import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, CHAR_DATA_CHAR_INDEX } from './Buffer';
+import { MockInputHandlingTerminal, TestTerminal } from './TestUtils.test';
+import { DEFAULT_ATTR_DATA } from './Buffer';
 import { Terminal } from './Terminal';
 import { IBufferLine } from './Types';
-
-
-// TODO: This and the sections related to this object in associated tests can be
-// removed safely after InputHandler refactors are finished
-class OldInputHandler extends InputHandler {
-  public eraseInLine(params: number[]): void {
-    switch (params[0]) {
-      case 0:
-        this.eraseRight(this._terminal.buffer.x, this._terminal.buffer.y);
-        break;
-      case 1:
-        this.eraseLeft(this._terminal.buffer.x, this._terminal.buffer.y);
-        break;
-      case 2:
-        this.eraseLine(this._terminal.buffer.y);
-        break;
-    }
-  }
-
-  public eraseInDisplay(params: number[]): void {
-    let j;
-    switch (params[0]) {
-      case 0:
-        this.eraseRight(this._terminal.buffer.x, this._terminal.buffer.y);
-        j = this._terminal.buffer.y + 1;
-        for (; j < this._terminal.rows; j++) {
-          this.eraseLine(j);
-        }
-        break;
-      case 1:
-        this.eraseLeft(this._terminal.buffer.x, this._terminal.buffer.y);
-        j = this._terminal.buffer.y;
-        while (j--) {
-          this.eraseLine(j);
-        }
-        break;
-      case 2:
-        j = this._terminal.rows;
-        while (j--) this.eraseLine(j);
-        break;
-      case 3:
-        // Clear scrollback (everything not in viewport)
-        const scrollBackSize = this._terminal.buffer.lines.length - this._terminal.rows;
-        if (scrollBackSize > 0) {
-          this._terminal.buffer.lines.trimStart(scrollBackSize);
-          this._terminal.buffer.ybase = Math.max(this._terminal.buffer.ybase - scrollBackSize, 0);
-          this._terminal.buffer.ydisp = Math.max(this._terminal.buffer.ydisp - scrollBackSize, 0);
-          // Force a scroll event to refresh viewport
-          this._terminal.emit('scroll', 0);
-        }
-        break;
-    }
-  }
-
-  /**
-   * Erase in the identified line everything from "x" to the end of the line (right).
-   * @param x The column from which to start erasing to the end of the line.
-   * @param y The line in which to operate.
-   */
-  public eraseRight(x: number, y: number): void {
-    const line = this._terminal.buffer.lines.get(this._terminal.buffer.ybase + y);
-    if (!line) {
-      return;
-    }
-    line.replaceCells(x, this._terminal.cols, [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
-    this._terminal.updateRange(y);
-  }
-
-  /**
-   * Erase in the identified line everything from "x" to the start of the line (left).
-   * @param x The column from which to start erasing to the start of the line.
-   * @param y The line in which to operate.
-   */
-  public eraseLeft(x: number, y: number): void {
-    const line = this._terminal.buffer.lines.get(this._terminal.buffer.ybase + y);
-    if (!line) {
-      return;
-    }
-    line.replaceCells(0, x + 1, [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
-    this._terminal.updateRange(y);
-  }
-
-  /**
-   * Erase all content in the given line
-   * @param y The line to erase all of its contents.
-   */
-  public eraseLine(y: number): void {
-    this.eraseRight(0, y);
-  }
-}
+import { CellData, Attributes, AttributeData } from './BufferLine';

 describe('InputHandler', () => {
  describe('save and restore cursor', () => {
    const terminal = new MockInputHandlingTerminal();
    terminal.buffer.x = 1;
    terminal.buffer.y = 2;
-    terminal.curAttr = 3;
+    terminal.curAttrData.fg = 3;
    const inputHandler = new InputHandler(terminal);
    // Save cursor position
    inputHandler.saveCursor([]);
    assert.equal(terminal.buffer.x, 1);
    assert.equal(terminal.buffer.y, 2);
-    assert.equal(terminal.curAttr, 3);
+    assert.equal(terminal.curAttrData.fg, 3);
    // Change cursor position
    terminal.buffer.x = 10;
    terminal.buffer.y = 20;
-    terminal.curAttr = 30;
+    terminal.curAttrData.fg = 30;
    // Restore cursor position
    inputHandler.restoreCursor([]);
    assert.equal(terminal.buffer.x, 1);
    assert.equal(terminal.buffer.y, 2);
-    assert.equal(terminal.curAttr, 3);
+    assert.equal(terminal.curAttrData.fg, 3);
  });
  describe('setCursorStyle', () => {
    it('should call Terminal.setOption with correct params', () => {
@@ -178,17 +89,9 @@ describe('InputHandler', () => {
    });
  });
  describe('regression tests', function(): void {
-    type CharData = [number, string, number, number];
-
-    function lineContent(line: IBufferLine): string {
-      let content = '';
-      for (let i = 0; i < line.length; ++i) content += line.get(i)[CHAR_DATA_CHAR_INDEX];
-      return content;
-    }
-
-    function termContent(term: Terminal): string[] {
+    function termContent(term: Terminal, trim: boolean): string[] {
      const result = [];
-      for (let i = 0; i < term.rows; ++i) result.push(lineContent(term.buffer.lines.get(i)));
+      for (let i = 0; i < term.rows; ++i) result.push(term.buffer.lines.get(i).translateToString(trim));
      return result;
    }

@@ -196,283 +99,407 @@ describe('InputHandler', () => {
      const term = new Terminal();
      const inputHandler = new InputHandler(term);

-      // old variant of the method
-      function insertChars(params: number[]): void {
-        let param = params[0];
-        if (param < 1) param = 1;
-
-        // make buffer local for faster access
-        const buffer = term.buffer;
-
-        const row = buffer.y + buffer.ybase;
-        let j = buffer.x;
-        const ch: CharData = [term.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
-        while (param-- && j < term.cols) {
-          buffer.lines.get(row).splice(j++, 0, ch);
-          buffer.lines.get(row).pop();
-        }
-      }
-
      // insert some data in first and second line
      inputHandler.parse(Array(term.cols - 9).join('a'));
      inputHandler.parse('1234567890');
      inputHandler.parse(Array(term.cols - 9).join('a'));
      inputHandler.parse('1234567890');
-      const line1: IBufferLine = term.buffer.lines.get(0); // line for old variant
-      const line2: IBufferLine = term.buffer.lines.get(1); // line for new variant
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '1234567890');
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '1234567890');
+      const line1: IBufferLine = term.buffer.lines.get(0);
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '1234567890');

      // insert one char from params = [0]
      term.buffer.y = 0;
      term.buffer.x = 70;
-      insertChars([0]);
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + ' 123456789');
-      term.buffer.y = 1;
-      term.buffer.x = 70;
      inputHandler.insertChars([0]);
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + ' 123456789');
-      expect(lineContent(line2)).equals(lineContent(line1));
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + ' 123456789');

      // insert one char from params = [1]
      term.buffer.y = 0;
      term.buffer.x = 70;
-      insertChars([1]);
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '  12345678');
-      term.buffer.y = 1;
-      term.buffer.x = 70;
      inputHandler.insertChars([1]);
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '  12345678');
-      expect(lineContent(line2)).equals(lineContent(line1));
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '  12345678');

      // insert two chars from params = [2]
      term.buffer.y = 0;
      term.buffer.x = 70;
-      insertChars([2]);
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '    123456');
-      term.buffer.y = 1;
-      term.buffer.x = 70;
      inputHandler.insertChars([2]);
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '    123456');
-      expect(lineContent(line2)).equals(lineContent(line1));
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '    123456');

      // insert 10 chars from params = [10]
      term.buffer.y = 0;
      term.buffer.x = 70;
-      insertChars([10]);
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '          ');
-      term.buffer.y = 1;
-      term.buffer.x = 70;
      inputHandler.insertChars([10]);
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '          ');
-      expect(lineContent(line2)).equals(lineContent(line1));
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '          ');
+      expect(line1.translateToString(true)).equals(Array(term.cols - 9).join('a'));
    });
    it('deleteChars', function(): void {
      const term = new Terminal();
      const inputHandler = new InputHandler(term);

-      // old variant of the method
-      function deleteChars(params: number[]): void {
-        let param: number = params[0];
-        if (param < 1) {
-          param = 1;
-        }
-
-        // make buffer local for faster access
-        const buffer = term.buffer;
-
-        const row = buffer.y + buffer.ybase;
-        const ch: CharData = [term.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]; // xterm
-        while (param--) {
-          buffer.lines.get(row).splice(buffer.x, 1);
-          buffer.lines.get(row).push(ch);
-        }
-        term.updateRange(buffer.y);
-      }
-
      // insert some data in first and second line
      inputHandler.parse(Array(term.cols - 9).join('a'));
      inputHandler.parse('1234567890');
      inputHandler.parse(Array(term.cols - 9).join('a'));
      inputHandler.parse('1234567890');
-      const line1: IBufferLine = term.buffer.lines.get(0); // line for old variant
-      const line2: IBufferLine = term.buffer.lines.get(1); // line for new variant
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '1234567890');
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '1234567890');
+      const line1: IBufferLine = term.buffer.lines.get(0);
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '1234567890');

      // delete one char from params = [0]
      term.buffer.y = 0;
      term.buffer.x = 70;
-      deleteChars([0]);
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '234567890 ');
-      term.buffer.y = 1;
-      term.buffer.x = 70;
      inputHandler.deleteChars([0]);
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '234567890 ');
-      expect(lineContent(line2)).equals(lineContent(line1));
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '234567890 ');
+      expect(line1.translateToString(true)).equals(Array(term.cols - 9).join('a') + '234567890');

      // insert one char from params = [1]
      term.buffer.y = 0;
      term.buffer.x = 70;
-      deleteChars([1]);
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '34567890  ');
-      term.buffer.y = 1;
-      term.buffer.x = 70;
      inputHandler.deleteChars([1]);
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '34567890  ');
-      expect(lineContent(line2)).equals(lineContent(line1));
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '34567890  ');
+      expect(line1.translateToString(true)).equals(Array(term.cols - 9).join('a') + '34567890');

      // insert two chars from params = [2]
      term.buffer.y = 0;
      term.buffer.x = 70;
-      deleteChars([2]);
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '567890    ');
-      term.buffer.y = 1;
-      term.buffer.x = 70;
      inputHandler.deleteChars([2]);
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '567890    ');
-      expect(lineContent(line2)).equals(lineContent(line1));
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '567890    ');
+      expect(line1.translateToString(true)).equals(Array(term.cols - 9).join('a') + '567890');

      // insert 10 chars from params = [10]
      term.buffer.y = 0;
      term.buffer.x = 70;
-      deleteChars([10]);
-      expect(lineContent(line1)).equals(Array(term.cols - 9).join('a') + '          ');
-      term.buffer.y = 1;
-      term.buffer.x = 70;
      inputHandler.deleteChars([10]);
-      expect(lineContent(line2)).equals(Array(term.cols - 9).join('a') + '          ');
-      expect(lineContent(line2)).equals(lineContent(line1));
+      expect(line1.translateToString(false)).equals(Array(term.cols - 9).join('a') + '          ');
+      expect(line1.translateToString(true)).equals(Array(term.cols - 9).join('a'));
    });
    it('eraseInLine', function(): void {
      const term = new Terminal();
      const inputHandler = new InputHandler(term);
-      const oldInputHandler = new OldInputHandler(term);

      // fill 6 lines to test 3 different states
      inputHandler.parse(Array(term.cols + 1).join('a'));
      inputHandler.parse(Array(term.cols + 1).join('a'));
      inputHandler.parse(Array(term.cols + 1).join('a'));
-      inputHandler.parse(Array(term.cols + 1).join('a'));
-      inputHandler.parse(Array(term.cols + 1).join('a'));
-      inputHandler.parse(Array(term.cols + 1).join('a'));

      // params[0] - right erase
      term.buffer.y = 0;
      term.buffer.x = 70;
-      oldInputHandler.eraseInLine([0]);
-      expect(lineContent(term.buffer.lines.get(0))).equals(Array(71).join('a') + '          ');
+      inputHandler.eraseInLine([0]);
+      expect(term.buffer.lines.get(0).translateToString(false)).equals(Array(71).join('a') + '          ');
+
+      // params[1] - left erase
      term.buffer.y = 1;
      term.buffer.x = 70;
-      inputHandler.eraseInLine([0]);
-      expect(lineContent(term.buffer.lines.get(1))).equals(Array(71).join('a') + '          ');
+      inputHandler.eraseInLine([1]);
+      expect(term.buffer.lines.get(1).translateToString(false)).equals(Array(71).join(' ') + ' aaaaaaaaa');

      // params[1] - left erase
      term.buffer.y = 2;
      term.buffer.x = 70;
-      oldInputHandler.eraseInLine([1]);
-      expect(lineContent(term.buffer.lines.get(2))).equals(Array(71).join(' ') + ' aaaaaaaaa');
-      term.buffer.y = 3;
-      term.buffer.x = 70;
-      inputHandler.eraseInLine([1]);
-      expect(lineContent(term.buffer.lines.get(3))).equals(Array(71).join(' ') + ' aaaaaaaaa');
-
-      // params[1] - left erase
-      term.buffer.y = 4;
-      term.buffer.x = 70;
-      oldInputHandler.eraseInLine([2]);
-      expect(lineContent(term.buffer.lines.get(4))).equals(Array(term.cols + 1).join(' '));
-      term.buffer.y = 5;
-      term.buffer.x = 70;
      inputHandler.eraseInLine([2]);
-      expect(lineContent(term.buffer.lines.get(5))).equals(Array(term.cols + 1).join(' '));
+      expect(term.buffer.lines.get(2).translateToString(false)).equals(Array(term.cols + 1).join(' '));

    });
    it('eraseInDisplay', function(): void {
-      const termOld = new Terminal();
-      const inputHandlerOld = new OldInputHandler(termOld);
-      const termNew = new Terminal();
-      const inputHandlerNew = new InputHandler(termNew);
+      const term = new Terminal({cols: 80, rows: 7});
+      const inputHandler = new InputHandler(term);

      // fill display with a's
-      for (let i = 0; i < termOld.rows; ++i) inputHandlerOld.parse(Array(termOld.cols + 1).join('a'));
-      for (let i = 0; i < termNew.rows; ++i) inputHandlerNew.parse(Array(termOld.cols + 1).join('a'));
-      const data = [];
-      for (let i = 0; i < termOld.rows; ++i) data.push(Array(termOld.cols + 1).join('a'));
-      expect(termContent(termOld)).eql(data);
-      expect(termContent(termOld)).eql(termContent(termNew));
+      for (let i = 0; i < term.rows; ++i) inputHandler.parse(Array(term.cols + 1).join('a'));

      // params [0] - right and below erase
-      termOld.buffer.y = 5;
-      termOld.buffer.x = 40;
-      inputHandlerOld.eraseInDisplay([0]);
-      termNew.buffer.y = 5;
-      termNew.buffer.x = 40;
-      inputHandlerNew.eraseInDisplay([0]);
-      expect(termContent(termNew)).eql(termContent(termOld));
+      term.buffer.y = 5;
+      term.buffer.x = 40;
+      inputHandler.eraseInDisplay([0]);
+      expect(termContent(term, false)).eql([
+        Array(term.cols + 1).join('a'),
+        Array(term.cols + 1).join('a'),
+        Array(term.cols + 1).join('a'),
+        Array(term.cols + 1).join('a'),
+        Array(term.cols + 1).join('a'),
+        Array(40 + 1).join('a') + Array(term.cols - 40 + 1).join(' '),
+        Array(term.cols + 1).join(' ')
+      ]);
+      expect(termContent(term, true)).eql([
+        Array(term.cols + 1).join('a'),
+        Array(term.cols + 1).join('a'),
+        Array(term.cols + 1).join('a'),
+        Array(term.cols + 1).join('a'),
+        Array(term.cols + 1).join('a'),
+        Array(40 + 1).join('a'),
+        ''
+      ]);

      // reset
-      termOld.buffer.y = 0;
-      termOld.buffer.x = 0;
-      termNew.buffer.y = 0;
-      termNew.buffer.x = 0;
-      for (let i = 0; i < termOld.rows; ++i) inputHandlerOld.parse(Array(termOld.cols + 1).join('a'));
-      for (let i = 0; i < termNew.rows; ++i) inputHandlerNew.parse(Array(termOld.cols + 1).join('a'));
+      term.buffer.y = 0;
+      term.buffer.x = 0;
+      for (let i = 0; i < term.rows; ++i) inputHandler.parse(Array(term.cols + 1).join('a'));

      // params [1] - left and above
-      termOld.buffer.y = 5;
-      termOld.buffer.x = 40;
-      inputHandlerOld.eraseInDisplay([1]);
-      termNew.buffer.y = 5;
-      termNew.buffer.x = 40;
-      inputHandlerNew.eraseInDisplay([1]);
-      expect(termContent(termNew)).eql(termContent(termOld));
+      term.buffer.y = 5;
+      term.buffer.x = 40;
+      inputHandler.eraseInDisplay([1]);
+      expect(termContent(term, false)).eql([
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(41 + 1).join(' ') + Array(term.cols - 41 + 1).join('a'),
+        Array(term.cols + 1).join('a')
+      ]);
+      expect(termContent(term, true)).eql([
+        '',
+        '',
+        '',
+        '',
+        '',
+        Array(41 + 1).join(' ') + Array(term.cols - 41 + 1).join('a'),
+        Array(term.cols + 1).join('a')
+      ]);

      // reset
-      termOld.buffer.y = 0;
-      termOld.buffer.x = 0;
-      termNew.buffer.y = 0;
-      termNew.buffer.x = 0;
-      for (let i = 0; i < termOld.rows; ++i) inputHandlerOld.parse(Array(termOld.cols + 1).join('a'));
-      for (let i = 0; i < termNew.rows; ++i) inputHandlerNew.parse(Array(termOld.cols + 1).join('a'));
+      term.buffer.y = 0;
+      term.buffer.x = 0;
+      for (let i = 0; i < term.rows; ++i) inputHandler.parse(Array(term.cols + 1).join('a'));

      // params [2] - whole screen
-      termOld.buffer.y = 5;
-      termOld.buffer.x = 40;
-      inputHandlerOld.eraseInDisplay([2]);
-      termNew.buffer.y = 5;
-      termNew.buffer.x = 40;
-      inputHandlerNew.eraseInDisplay([2]);
-      expect(termContent(termNew)).eql(termContent(termOld));
+      term.buffer.y = 5;
+      term.buffer.x = 40;
+      inputHandler.eraseInDisplay([2]);
+      expect(termContent(term, false)).eql([
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' '),
+        Array(term.cols + 1).join(' ')
+      ]);
+      expect(termContent(term, true)).eql([
+        '',
+        '',
+        '',
+        '',
+        '',
+        '',
+        ''
+      ]);
+
+      // reset and add a wrapped line
+      term.buffer.y = 0;
+      term.buffer.x = 0;
+      inputHandler.parse(Array(term.cols + 1).join('a')); // line 0
+      inputHandler.parse(Array(term.cols + 10).join('a')); // line 1 and 2
+      for (let i = 3; i < term.rows; ++i) inputHandler.parse(Array(term.cols + 1).join('a'));
+
+      // params[1] left and above with wrap
+      // confirm precondition that line 2 is wrapped
+      expect(term.buffer.lines.get(2).isWrapped).true;
+      term.buffer.y = 2;
+      term.buffer.x = 40;
+      inputHandler.eraseInDisplay([1]);
+      expect(term.buffer.lines.get(2).isWrapped).false;
+
+      // reset and add a wrapped line
+      term.buffer.y = 0;
+      term.buffer.x = 0;
+      inputHandler.parse(Array(term.cols + 1).join('a')); // line 0
+      inputHandler.parse(Array(term.cols + 10).join('a')); // line 1 and 2
+      for (let i = 3; i < term.rows; ++i) inputHandler.parse(Array(term.cols + 1).join('a'));
+
+      // params[1] left and above with wrap
+      // confirm precondition that line 2 is wrapped
+      expect(term.buffer.lines.get(2).isWrapped).true;
+      term.buffer.y = 1;
+      term.buffer.x = 90; // Cursor is beyond last column
+      inputHandler.eraseInDisplay([1]);
+      expect(term.buffer.lines.get(2).isWrapped).false;
    });
  });
  it('convertEol setting', function(): void {
    // not converting
-    let s = '';
    const termNotConverting = new Terminal({cols: 15, rows: 10});
    (termNotConverting as any)._inputHandler.parse('Hello\nWorld');
-    for (let i = 0; i < termNotConverting.cols; ++i) {
-      s += termNotConverting.buffer.lines.get(0).get(i)[CHAR_DATA_CHAR_INDEX];
-    }
-    expect(s).equals('Hello          ');
-    s = '';
-    for (let i = 0; i < termNotConverting.cols; ++i) {
-      s += termNotConverting.buffer.lines.get(1).get(i)[CHAR_DATA_CHAR_INDEX];
-    }
-    expect(s).equals('     World     ');
+    expect(termNotConverting.buffer.lines.get(0).translateToString(false)).equals('Hello          ');
+    expect(termNotConverting.buffer.lines.get(1).translateToString(false)).equals('     World     ');
+    expect(termNotConverting.buffer.lines.get(0).translateToString(true)).equals('Hello');
+    expect(termNotConverting.buffer.lines.get(1).translateToString(true)).equals('     World');

    // converting
-    s = '';
    const termConverting = new Terminal({cols: 15, rows: 10, convertEol: true});
    (termConverting as any)._inputHandler.parse('Hello\nWorld');
-    for (let i = 0; i < termConverting.cols; ++i) {
-      s += termConverting.buffer.lines.get(0).get(i)[CHAR_DATA_CHAR_INDEX];
-    }
-    expect(s).equals('Hello          ');
-    s = '';
-    for (let i = 0; i < termConverting.cols; ++i) {
-      s += termConverting.buffer.lines.get(1).get(i)[CHAR_DATA_CHAR_INDEX];
-    }
-    expect(s).equals('World          ');
+    expect(termConverting.buffer.lines.get(0).translateToString(false)).equals('Hello          ');
+    expect(termConverting.buffer.lines.get(1).translateToString(false)).equals('World          ');
+    expect(termConverting.buffer.lines.get(0).translateToString(true)).equals('Hello');
+    expect(termConverting.buffer.lines.get(1).translateToString(true)).equals('World');
+  });
+  describe('print', () => {
+    it('should not cause an infinite loop (regression test)', () => {
+      const term = new Terminal();
+      const inputHandler = new InputHandler(term);
+      const container = new Uint32Array(10);
+      container[0] = 0x200B;
+      inputHandler.print(container, 0, 1);
+    });
+  });
+
+  describe('alt screen', () => {
+    let term: Terminal;
+    let handler: InputHandler;
+
+    beforeEach(() => {
+      term = new Terminal();
+      handler = new InputHandler(term);
+    });
+    it('should handle DECSET/DECRST 47 (alt screen buffer)', () => {
+      handler.parse('\x1b[?47h\r\n\x1b[31mJUNK\x1b[?47lTEST');
+      expect(term.buffer.translateBufferLineToString(0, true)).to.equal('');
+      expect(term.buffer.translateBufferLineToString(1, true)).to.equal('    TEST');
+      // Text color of 'TEST' should be red
+      expect((term.buffer.lines.get(1).loadCell(4, new CellData()).getFgColor())).to.equal(1);
+    });
+    it('should handle DECSET/DECRST 1047 (alt screen buffer)', () => {
+      handler.parse('\x1b[?1047h\r\n\x1b[31mJUNK\x1b[?1047lTEST');
+      expect(term.buffer.translateBufferLineToString(0, true)).to.equal('');
+      expect(term.buffer.translateBufferLineToString(1, true)).to.equal('    TEST');
+      // Text color of 'TEST' should be red
+      expect((term.buffer.lines.get(1).loadCell(4, new CellData()).getFgColor())).to.equal(1);
+    });
+    it('should handle DECSET/DECRST 1048 (alt screen cursor)', () => {
+      handler.parse('\x1b[?1048h\r\n\x1b[31mJUNK\x1b[?1048lTEST');
+      expect(term.buffer.translateBufferLineToString(0, true)).to.equal('TEST');
+      expect(term.buffer.translateBufferLineToString(1, true)).to.equal('JUNK');
+      // Text color of 'TEST' should be default
+      expect(term.buffer.lines.get(0).loadCell(0, new CellData()).fg).to.equal(DEFAULT_ATTR_DATA.fg);
+      // Text color of 'JUNK' should be red
+      expect((term.buffer.lines.get(1).loadCell(0, new CellData()).getFgColor())).to.equal(1);
+    });
+    it('should handle DECSET/DECRST 1049 (alt screen buffer+cursor)', () => {
+      handler.parse('\x1b[?1049h\r\n\x1b[31mJUNK\x1b[?1049lTEST');
+      expect(term.buffer.translateBufferLineToString(0, true)).to.equal('TEST');
+      expect(term.buffer.translateBufferLineToString(1, true)).to.equal('');
+      // Text color of 'TEST' should be default
+      expect(term.buffer.lines.get(0).loadCell(0, new CellData()).fg).to.equal(DEFAULT_ATTR_DATA.fg);
+    });
+    it('should handle DECSET/DECRST 1049 - maintains saved cursor for alt buffer', () => {
+      handler.parse('\x1b[?1049h\r\n\x1b[31m\x1b[s\x1b[?1049lTEST');
+      expect(term.buffer.translateBufferLineToString(0, true)).to.equal('TEST');
+      // Text color of 'TEST' should be default
+      expect(term.buffer.lines.get(0).loadCell(0, new CellData()).fg).to.equal(DEFAULT_ATTR_DATA.fg);
+      handler.parse('\x1b[?1049h\x1b[uTEST');
+      expect(term.buffer.translateBufferLineToString(1, true)).to.equal('TEST');
+      // Text color of 'TEST' should be red
+      expect((term.buffer.lines.get(1).loadCell(0, new CellData()).getFgColor())).to.equal(1);
+    });
+    it('should handle DECSET/DECRST 1049 - clears alt buffer with erase attributes', () => {
+      handler.parse('\x1b[42m\x1b[?1049h');
+      // Buffer should be filled with green background
+      expect(term.buffer.lines.get(20).loadCell(10, new CellData()).getBgColor()).to.equal(2);
+    });
+  });
+
+  describe('text attributes', () => {
+    let term: TestTerminal;
+    beforeEach(() => {
+      term = new TestTerminal();
+    });
+    it('bold', () => {
+      term.writeSync('\x1b[1m');
+      assert.equal(!!term.curAttrData.isBold(), true);
+      term.writeSync('\x1b[22m');
+      assert.equal(!!term.curAttrData.isBold(), false);
+    });
+    it('dim', () => {
+      term.writeSync('\x1b[2m');
+      assert.equal(!!term.curAttrData.isDim(), true);
+      term.writeSync('\x1b[22m');
+      assert.equal(!!term.curAttrData.isDim(), false);
+    });
+    it('italic', () => {
+      term.writeSync('\x1b[3m');
+      assert.equal(!!term.curAttrData.isItalic(), true);
+      term.writeSync('\x1b[23m');
+      assert.equal(!!term.curAttrData.isItalic(), false);
+    });
+    it('underline', () => {
+      term.writeSync('\x1b[4m');
+      assert.equal(!!term.curAttrData.isUnderline(), true);
+      term.writeSync('\x1b[24m');
+      assert.equal(!!term.curAttrData.isUnderline(), false);
+    });
+    it('blink', () => {
+      term.writeSync('\x1b[5m');
+      assert.equal(!!term.curAttrData.isBlink(), true);
+      term.writeSync('\x1b[25m');
+      assert.equal(!!term.curAttrData.isBlink(), false);
+    });
+    it('inverse', () => {
+      term.writeSync('\x1b[7m');
+      assert.equal(!!term.curAttrData.isInverse(), true);
+      term.writeSync('\x1b[27m');
+      assert.equal(!!term.curAttrData.isInverse(), false);
+    });
+    it('invisible', () => {
+      term.writeSync('\x1b[8m');
+      assert.equal(!!term.curAttrData.isInvisible(), true);
+      term.writeSync('\x1b[28m');
+      assert.equal(!!term.curAttrData.isInvisible(), false);
+    });
+    it('colormode palette 16', () => {
+      assert.equal(term.curAttrData.getFgColorMode(), 0); // DEFAULT
+      assert.equal(term.curAttrData.getBgColorMode(), 0); // DEFAULT
+      // lower 8 colors
+      for (let i = 0; i < 8; ++i) {
+        term.writeSync(`\x1b[${i + 30};${i + 40}m`);
+        assert.equal(term.curAttrData.getFgColorMode(), Attributes.CM_P16);
+        assert.equal(term.curAttrData.getFgColor(), i);
+        assert.equal(term.curAttrData.getBgColorMode(), Attributes.CM_P16);
+        assert.equal(term.curAttrData.getBgColor(), i);
+      }
+      // reset to DEFAULT
+      term.writeSync(`\x1b[39;49m`);
+      assert.equal(term.curAttrData.getFgColorMode(), 0);
+      assert.equal(term.curAttrData.getBgColorMode(), 0);
+    });
+    it('colormode palette 256', () => {
+      assert.equal(term.curAttrData.getFgColorMode(), 0); // DEFAULT
+      assert.equal(term.curAttrData.getBgColorMode(), 0); // DEFAULT
+      // lower 8 colors
+      for (let i = 0; i < 256; ++i) {
+        term.writeSync(`\x1b[38;5;${i};48;5;${i}m`);
+        assert.equal(term.curAttrData.getFgColorMode(), Attributes.CM_P256);
+        assert.equal(term.curAttrData.getFgColor(), i);
+        assert.equal(term.curAttrData.getBgColorMode(), Attributes.CM_P256);
+        assert.equal(term.curAttrData.getBgColor(), i);
+      }
+      // reset to DEFAULT
+      term.writeSync(`\x1b[39;49m`);
+      assert.equal(term.curAttrData.getFgColorMode(), 0);
+      assert.equal(term.curAttrData.getFgColor(), -1);
+      assert.equal(term.curAttrData.getBgColorMode(), 0);
+      assert.equal(term.curAttrData.getBgColor(), -1);
+    });
+    it('colormode RGB', () => {
+      assert.equal(term.curAttrData.getFgColorMode(), 0); // DEFAULT
+      assert.equal(term.curAttrData.getBgColorMode(), 0); // DEFAULT
+      term.writeSync(`\x1b[38;2;1;2;3;48;2;4;5;6m`);
+      assert.equal(term.curAttrData.getFgColorMode(), Attributes.CM_RGB);
+      assert.equal(term.curAttrData.getFgColor(), 1 << 16 | 2 << 8 | 3);
+      assert.deepEqual(AttributeData.toColorRGB(term.curAttrData.getFgColor()), [1, 2, 3]);
+      assert.equal(term.curAttrData.getBgColorMode(), Attributes.CM_RGB);
+      assert.deepEqual(AttributeData.toColorRGB(term.curAttrData.getBgColor()), [4, 5, 6]);
+      // reset to DEFAULT
+      term.writeSync(`\x1b[39;49m`);
+      assert.equal(term.curAttrData.getFgColorMode(), 0);
+      assert.equal(term.curAttrData.getFgColor(), -1);
+      assert.equal(term.curAttrData.getBgColorMode(), 0);
+      assert.equal(term.curAttrData.getBgColor(), -1);
+    });
+    it('should zero missing RGB values', () => {
+      term.writeSync(`\x1b[38;2;1;2;3m`);
+      term.writeSync(`\x1b[38;2;5m`);
+      assert.deepEqual(AttributeData.toColorRGB(term.curAttrData.getFgColor()), [5, 0, 0]);
+    });
  });
 });
@@ -4,16 +4,18 @@
 * @license MIT
 */

-import { IInputHandler, IDcsHandler, IEscapeSequenceParser, IBuffer, IInputHandlingTerminal } from './Types';
+import { IInputHandler, IDcsHandler, IEscapeSequenceParser, IInputHandlingTerminal } from './Types';
 import { C0, C1 } from './common/data/EscapeSequences';
 import { CHARSETS, DEFAULT_CHARSET } from './core/data/Charsets';
-import { CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, CHAR_DATA_CODE_INDEX, DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE } from './Buffer';
-import { FLAGS } from './renderer/Types';
+import { NULL_CELL_WIDTH, NULL_CELL_CODE, DEFAULT_ATTR_DATA } from './Buffer';
 import { wcwidth } from './CharWidth';
 import { EscapeSequenceParser } from './EscapeSequenceParser';
-import { ICharset } from './core/Types';
+import { IDisposable } from 'xterm';
 import { Disposable } from './common/Lifecycle';
-import { BufferLine } from './BufferLine';
+import { concat } from './common/TypedArrayUtils';
+import { StringToUtf32, stringFromCodePoint, utf32ToString } from './core/input/TextDecoder';
+import { CellData, Attributes, FgFlags, BgFlags, AttributeData } from './BufferLine';
+import { EventEmitter2, IEvent } from './common/EventEmitter2';

 /**
 * Map collect to glevel. Used in `selectCharset`.
@@ -25,26 +27,6 @@ const GLEVEL: {[key: string]: number} = {'(': 0, ')': 1, '*': 2, '+': 3, '-': 1,
 * DCS subparser implementations
 */

- /**
-  * DCS + q Pt ST (xterm)
-  *   Request Terminfo String
-  *   not supported
-  */
-class RequestTerminfo implements IDcsHandler {
-  private _data: string;
-  constructor(private _terminal: any) { }
-  hook(collect: string, params: number[], flag: number): void {
-    this._data = '';
-  }
-  put(data: string, start: number, end: number): void {
-    this._data += data.substring(start, end);
-  }
-  unhook(): void {
-    // invalid: DCS 0 + r Pt ST
-    this._terminal.handler(`${C0.ESC}P0+r${this._data}${C0.ESC}\\`);
-  }
-}
-
 /**
 * DCS $ q Pt ST
 *   DECRQSS (https://vt100.net/docs/vt510-rm/DECRQSS.html)
@@ -52,21 +34,22 @@ class RequestTerminfo implements IDcsHandler {
 *   Response: DECRPSS (https://vt100.net/docs/vt510-rm/DECRPSS.html)
 */
 class DECRQSS implements IDcsHandler {
-  private _data: string;
+  private _data: Uint32Array = new Uint32Array(0);

  constructor(private _terminal: any) { }

  hook(collect: string, params: number[], flag: number): void {
-    // reset data
-    this._data = '';
+    this._data = new Uint32Array(0);
  }

-  put(data: string, start: number, end: number): void {
-    this._data += data.substring(start, end);
+  put(data: Uint32Array, start: number, end: number): void {
+    this._data = concat(this._data, data.subarray(start, end));
  }

  unhook(): void {
-    switch (this._data) {
+    const data = utf32ToString(this._data);
+    this._data = new Uint32Array(0);
+    switch (data) {
      // valid: DCS 1 $ r Pt ST (xterm)
      case '"q': // DECSCA
        return this._terminal.handler(`${C0.ESC}P1$r0"q${C0.ESC}\\`);
@@ -86,8 +69,8 @@ class DECRQSS implements IDcsHandler {
        return this._terminal.handler(`${C0.ESC}P1$r${style} q${C0.ESC}\\`);
      default:
        // invalid: DCS 0 $ r Pt ST (xterm)
-        this._terminal.error('Unknown DCS $q %s', this._data);
-        this._terminal.handler(`${C0.ESC}P0$r${this._data}${C0.ESC}\\`);
+        this._terminal.error('Unknown DCS $q %s', data);
+        this._terminal.handler(`${C0.ESC}P0$r${C0.ESC}\\`);
    }
  }
 }
@@ -98,11 +81,17 @@ class DECRQSS implements IDcsHandler {
 *   not supported
 */

- /**
-  * DCS + p Pt ST (xterm)
-  *   Set Terminfo Data
-  *   not supported
-  */
+/**
+ * DCS + q Pt ST (xterm)
+ *   Request Terminfo String
+ *   not implemented
+ */
+
+/**
+ * DCS + p Pt ST (xterm)
+ *   Set Terminfo Data
+ *   not supported
+ */



@@ -114,7 +103,18 @@ class DECRQSS implements IDcsHandler {
 * each function's header comment.
 */
 export class InputHandler extends Disposable implements IInputHandler {
-  private _surrogateHigh: string;
+  private _parseBuffer: Uint32Array = new Uint32Array(4096);
+  private _stringDecoder: StringToUtf32 = new StringToUtf32();
+  private _workCell: CellData = new CellData();
+
+  private _onCursorMove = new EventEmitter2<void>();
+  public get onCursorMove(): IEvent<void> { return this._onCursorMove.event; }
+  private _onData = new EventEmitter2<string>();
+  public get onData(): IEvent<string> { return this._onData.event; }
+  private _onLineFeed = new EventEmitter2<void>();
+  public get onLineFeed(): IEvent<void> { return this._onLineFeed.event; }
+  private _onScroll = new EventEmitter2<number>();
+  public get onScroll(): IEvent<number> { return this._onScroll.event; }

  constructor(
      protected _terminal: IInputHandlingTerminal,
@@ -124,8 +124,6 @@ export class InputHandler extends Disposable implements IInputHandler {

    this.register(this._parser);

-    this._surrogateHigh = '';
-
    /**
     * custom fallback handlers
     */
@@ -288,7 +286,6 @@ export class InputHandler extends Disposable implements IInputHandler {
     * DCS handler
     */
    this._parser.setDcsHandler('$q', new DECRQSS(this._terminal));
-    this._parser.setDcsHandler('+q', new RequestTerminfo(this._terminal));
  }

  public dispose(): void {
@@ -311,69 +308,49 @@ export class InputHandler extends Disposable implements IInputHandler {
      this._terminal.log('data: ' + data);
    }

-    // apply leftover surrogate high from last write
-    if (this._surrogateHigh) {
-      data = this._surrogateHigh + data;
-      this._surrogateHigh = '';
+    if (this._parseBuffer.length < data.length) {
+      this._parseBuffer = new Uint32Array(data.length);
    }
-
-    this._parser.parse(data);
+    this._parser.parse(this._parseBuffer, this._stringDecoder.decode(data, this._parseBuffer));

    buffer = this._terminal.buffer;
    if (buffer.x !== cursorStartX || buffer.y !== cursorStartY) {
-      this._terminal.emit('cursormove');
+      this._onCursorMove.fire();
    }
  }

-  public print(data: string, start: number, end: number): void {
-    let char: string;
+  public print(data: Uint32Array, start: number, end: number): void {
    let code: number;
-    let low: number;
    let chWidth: number;
-    const buffer: IBuffer = this._terminal.buffer;
-    const charset: ICharset = this._terminal.charset;
-    const screenReaderMode: boolean = this._terminal.options.screenReaderMode;
-    const cols: number = this._terminal.cols;
-    const wraparoundMode: boolean = this._terminal.wraparoundMode;
-    const insertMode: boolean = this._terminal.insertMode;
-    const curAttr: number = this._terminal.curAttr;
+    const buffer = this._terminal.buffer;
+    const charset = this._terminal.charset;
+    const screenReaderMode = this._terminal.options.screenReaderMode;
+    const cols = this._terminal.cols;
+    const wraparoundMode = this._terminal.wraparoundMode;
+    const insertMode = this._terminal.insertMode;
+    const curAttr = this._terminal.curAttrData;
    let bufferRow = buffer.lines.get(buffer.y + buffer.ybase);

    this._terminal.updateRange(buffer.y);
-    for (let stringPosition = start; stringPosition < end; ++stringPosition) {
-      char = data.charAt(stringPosition);
-      code = data.charCodeAt(stringPosition);
-
-      // surrogate pair handling
-      if (0xD800 <= code && code <= 0xDBFF) {
-        // we got a surrogate high
-        // get surrogate low (next 2 bytes)
-        low = data.charCodeAt(stringPosition + 1);
-        if (isNaN(low)) {
-          // end of data stream, save surrogate high
-          this._surrogateHigh = char;
-          continue;
-        }
-        code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
-        char += data.charAt(stringPosition + 1);
-      }
-      // surrogate low - already handled above
-      if (0xDC00 <= code && code <= 0xDFFF) {
-        continue;
-      }
+    for (let pos = start; pos < end; ++pos) {
+      code = data[pos];

      // calculate print space
      // expensive call, therefore we save width in line buffer
      chWidth = wcwidth(code);

      // get charset replacement character
-      if (charset) {
-        char = charset[char] || char;
-        code = char.charCodeAt(0);
+      // charset is only defined for ASCII, therefore we only
+      // search for an replacement char if code < 127
+      if (code < 127 && charset) {
+        const ch = charset[String.fromCharCode(code)];
+        if (ch) {
+          code = ch.charCodeAt(0);
+        }
      }

      if (screenReaderMode) {
-        this._terminal.emit('a11y.char', char);
+        this._terminal.emit('a11y.char', stringFromCodePoint(code));
      }

      // insert combining char at last cursor position
@@ -382,27 +359,22 @@ export class InputHandler extends Disposable implements IInputHandler {
      // since they always follow a cell consuming char
      // therefore we can test for buffer.x to avoid overflow left
      if (!chWidth && buffer.x) {
-        const chMinusOne = bufferRow.get(buffer.x - 1);
-        if (chMinusOne) {
-          if (!chMinusOne[CHAR_DATA_WIDTH_INDEX]) {
-            // found empty cell after fullwidth, need to go 2 cells back
-            // it is save to step 2 cells back here
-            // since an empty cell is only set by fullwidth chars
-            const chMinusTwo = bufferRow.get(buffer.x - 2);
-            if (chMinusTwo) {
-              chMinusTwo[CHAR_DATA_CHAR_INDEX] += char;
-              chMinusTwo[CHAR_DATA_CODE_INDEX] = code;
-            }
-          } else {
-            chMinusOne[CHAR_DATA_CHAR_INDEX] += char;
-            chMinusOne[CHAR_DATA_CODE_INDEX] = code;
-          }
+        if (!bufferRow.getWidth(buffer.x - 1)) {
+          // found empty cell after fullwidth, need to go 2 cells back
+          // it is save to step 2 cells back here
+          // since an empty cell is only set by fullwidth chars
+          bufferRow.addCodepointToCell(buffer.x - 2, code);
+        } else {
+          bufferRow.addCodepointToCell(buffer.x - 1, code);
        }
        continue;
      }

      // goto next line if ch would overflow
      // TODO: needs a global min terminal width of 2
+      // FIXME: additionally ensure chWidth fits into a line
+      //   -->  maybe forbid cols<xy at higher level as it would
+      //        introduce a bad runtime penalty here
      if (buffer.x + chWidth - 1 >= cols) {
        // autowrap - DECAWM
        // automatically wraps to the beginning of the next line
@@ -430,37 +402,47 @@ export class InputHandler extends Disposable implements IInputHandler {
      }

      // insert mode: move characters to right
-      // To achieve insert, we remove cells from the right
-      // and insert empty ones at cursor position
      if (insertMode) {
-        // do this twice for a fullwidth char
-        for (let moves = 0; moves < chWidth; ++moves) {
-          // remove last cell
-          // if it's width is 0, we have to adjust the second last cell as well
-          const removed = bufferRow.pop();
-          const chMinusTwo = bufferRow.get(buffer.x - 2);
-          if (removed[CHAR_DATA_WIDTH_INDEX] === 0
-              && chMinusTwo
-              && chMinusTwo[CHAR_DATA_WIDTH_INDEX] === 2) {
-                bufferRow.set(this._terminal.cols - 2, [curAttr, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
-          }
-
-          // insert empty cell at cursor
-          bufferRow.splice(buffer.x, 0, [curAttr, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
+        // right shift cells according to the width
+        bufferRow.insertCells(buffer.x, chWidth, buffer.getNullCell(curAttr));
+        // test last cell - since the last cell has only room for
+        // a halfwidth char any fullwidth shifted there is lost
+        // and will be set to empty cell
+        if (bufferRow.getWidth(cols - 1) === 2) {
+          bufferRow.setCellFromCodePoint(cols - 1, NULL_CELL_CODE, NULL_CELL_WIDTH, curAttr.fg, curAttr.bg);
        }
      }

      // write current char to buffer and advance cursor
-      bufferRow.set(buffer.x++, [curAttr, char, chWidth, code]);
+      bufferRow.setCellFromCodePoint(buffer.x++, code, chWidth, curAttr.fg, curAttr.bg);

      // fullwidth char - also set next cell to placeholder stub and advance cursor
-      if (chWidth === 2) {
-        bufferRow.set(buffer.x++, [curAttr, '', 0, undefined]);
+      // for graphemes bigger than fullwidth we can simply loop to zero
+      // we already made sure above, that buffer.x + chWidth will not overflow right
+      if (chWidth > 0) {
+        while (--chWidth) {
+          // other than a regular empty cell a cell following a wide char has no width
+          bufferRow.setCellFromCodePoint(buffer.x++, 0, 0, curAttr.fg, curAttr.bg);
+        }
      }
    }
    this._terminal.updateRange(buffer.y);
  }

+  /**
+   * Forward addCsiHandler from parser.
+   */
+  public addCsiHandler(flag: string, callback: (params: number[], collect: string) => boolean): IDisposable {
+    return this._parser.addCsiHandler(flag, callback);
+  }
+
+  /**
+   * Forward addOscHandler from parser.
+   */
+  public addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
+    return this._parser.addOscHandler(ident, callback);
+  }
+
  /**
   * BEL
   * Bell (Ctrl-G).
@@ -489,12 +471,8 @@ export class InputHandler extends Disposable implements IInputHandler {
    if (buffer.x >= this._terminal.cols) {
      buffer.x--;
    }
-    /**
-     * This event is emitted whenever the terminal outputs a LF or NL.
-     *
-     * @event linefeed
-     */
-    this._terminal.emit('linefeed');
+
+    this._onLineFeed.fire();
  }

  /**
@@ -553,7 +531,7 @@ export class InputHandler extends Disposable implements IInputHandler {
    this._terminal.buffer.lines.get(this._terminal.buffer.y + this._terminal.buffer.ybase).insertCells(
      this._terminal.buffer.x,
      params[0] || 1,
-      [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+      this._terminal.buffer.getNullCell(this._terminal.eraseAttrData())
    );
    this._terminal.updateRange(this._terminal.buffer.y);
  }
@@ -722,12 +700,25 @@ export class InputHandler extends Disposable implements IInputHandler {
   * @param start first cell index to be erased
   * @param end   end - 1 is last erased cell
   */
-  private _eraseInBufferLine(y: number, start: number, end: number): void {
-    this._terminal.buffer.lines.get(this._terminal.buffer.ybase + y).replaceCells(
+  private _eraseInBufferLine(y: number, start: number, end: number, clearWrap: boolean = false): void {
+    const line = this._terminal.buffer.lines.get(this._terminal.buffer.ybase + y);
+    line.replaceCells(
      start,
      end,
-      [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+      this._terminal.buffer.getNullCell(this._terminal.eraseAttrData())
    );
+    if (clearWrap) {
+      line.isWrapped = false;
+    }
+  }
+
+  /**
+   * Helper method to reset cells in a terminal row.
+   * The cell gets replaced with the eraseChar of the terminal and the isWrapped property is set to false.
+   * @param y row index
+   */
+  private _resetBufferLine(y: number): void {
+    this._eraseInBufferLine(y, 0, this._terminal.cols, true);
  }

  /**
@@ -748,18 +739,23 @@ export class InputHandler extends Disposable implements IInputHandler {
      case 0:
        j = this._terminal.buffer.y;
        this._terminal.updateRange(j);
-        this._eraseInBufferLine(j++, this._terminal.buffer.x, this._terminal.cols);
+        this._eraseInBufferLine(j++, this._terminal.buffer.x, this._terminal.cols, this._terminal.buffer.x === 0);
        for (; j < this._terminal.rows; j++) {
-          this._eraseInBufferLine(j, 0, this._terminal.cols);
+          this._resetBufferLine(j);
        }
        this._terminal.updateRange(j);
        break;
      case 1:
        j = this._terminal.buffer.y;
        this._terminal.updateRange(j);
-        this._eraseInBufferLine(j, 0, this._terminal.buffer.x + 1);
+        // Deleted front part of line and everything before. This line will no longer be wrapped.
+        this._eraseInBufferLine(j, 0, this._terminal.buffer.x + 1, true);
+        if (this._terminal.buffer.x + 1 >= this._terminal.cols) {
+          // Deleted entire previous line. This next line can no longer be wrapped.
+          this._terminal.buffer.lines.get(j + 1).isWrapped = false;
+        }
        while (j--) {
-          this._eraseInBufferLine(j, 0, this._terminal.cols);
+          this._resetBufferLine(j);
        }
        this._terminal.updateRange(0);
        break;
@@ -767,7 +763,7 @@ export class InputHandler extends Disposable implements IInputHandler {
        j = this._terminal.rows;
        this._terminal.updateRange(j - 1);
        while (j--) {
-          this._eraseInBufferLine(j, 0, this._terminal.cols);
+          this._resetBufferLine(j);
        }
        this._terminal.updateRange(0);
        break;
@@ -779,7 +775,7 @@ export class InputHandler extends Disposable implements IInputHandler {
          this._terminal.buffer.ybase = Math.max(this._terminal.buffer.ybase - scrollBackSize, 0);
          this._terminal.buffer.ydisp = Math.max(this._terminal.buffer.ydisp - scrollBackSize, 0);
          // Force a scroll event to refresh viewport
-          this._terminal.emit('scroll', 0);
+          this._onScroll.fire(0);
        }
        break;
    }
@@ -832,7 +828,7 @@ export class InputHandler extends Disposable implements IInputHandler {
      // test: echo -e '\e[44m\e[1L\e[0m'
      // blankLine(true) - xterm/linux behavior
      buffer.lines.splice(scrollBottomAbsolute - 1, 1);
-      buffer.lines.splice(row, 0, BufferLine.blankLine(this._terminal.cols, this._terminal.eraseAttr()));
+      buffer.lines.splice(row, 0, buffer.getBlankLine(this._terminal.eraseAttrData()));
    }

    // this.maxRange();
@@ -862,7 +858,7 @@ export class InputHandler extends Disposable implements IInputHandler {
      // test: echo -e '\e[44m\e[1M\e[0m'
      // blankLine(true) - xterm/linux behavior
      buffer.lines.splice(row, 1);
-      buffer.lines.splice(j, 0, BufferLine.blankLine(this._terminal.cols, this._terminal.eraseAttr()));
+      buffer.lines.splice(j, 0, buffer.getBlankLine(this._terminal.eraseAttrData()));
    }

    // this.maxRange();
@@ -878,7 +874,7 @@ export class InputHandler extends Disposable implements IInputHandler {
    this._terminal.buffer.lines.get(this._terminal.buffer.y + this._terminal.buffer.ybase).deleteCells(
      this._terminal.buffer.x,
      params[0] || 1,
-      [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+      this._terminal.buffer.getNullCell(this._terminal.eraseAttrData())
    );
    this._terminal.updateRange(this._terminal.buffer.y);
  }
@@ -894,7 +890,7 @@ export class InputHandler extends Disposable implements IInputHandler {

    while (param--) {
      buffer.lines.splice(buffer.ybase + buffer.scrollTop, 1);
-      buffer.lines.splice(buffer.ybase + buffer.scrollBottom, 0, BufferLine.blankLine(this._terminal.cols, DEFAULT_ATTR));
+      buffer.lines.splice(buffer.ybase + buffer.scrollBottom, 0, buffer.getBlankLine(DEFAULT_ATTR_DATA));
    }
    // this.maxRange();
    this._terminal.updateRange(buffer.scrollTop);
@@ -913,7 +909,7 @@ export class InputHandler extends Disposable implements IInputHandler {

      while (param--) {
        buffer.lines.splice(buffer.ybase + buffer.scrollBottom, 1);
-        buffer.lines.splice(buffer.ybase + buffer.scrollBottom, 0, BufferLine.blankLine(this._terminal.cols, DEFAULT_ATTR));
+        buffer.lines.splice(buffer.ybase + buffer.scrollTop, 0, buffer.getBlankLine(DEFAULT_ATTR_DATA));
      }
      // this.maxRange();
      this._terminal.updateRange(buffer.scrollTop);
@@ -929,7 +925,7 @@ export class InputHandler extends Disposable implements IInputHandler {
    this._terminal.buffer.lines.get(this._terminal.buffer.y + this._terminal.buffer.ybase).replaceCells(
      this._terminal.buffer.x,
      this._terminal.buffer.x + (params[0] || 1),
-      [this._terminal.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+      this._terminal.buffer.getNullCell(this._terminal.eraseAttrData())
    );
  }

@@ -985,9 +981,10 @@ export class InputHandler extends Disposable implements IInputHandler {
    // make buffer local for faster access
    const buffer = this._terminal.buffer;
    const line = buffer.lines.get(buffer.ybase + buffer.y);
+    line.loadCell(buffer.x - 1, this._workCell);
    line.replaceCells(buffer.x,
      buffer.x + (params[0] || 1),
-      line.get(buffer.x - 1) || [DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]
+      (this._workCell.content !== undefined) ? this._workCell : buffer.getNullCell(DEFAULT_ATTR_DATA)
    );
    // FIXME: no updateRange here?
  }
@@ -1262,7 +1259,9 @@ export class InputHandler extends Disposable implements IInputHandler {
        case 66:
          this._terminal.log('Serial port requested application keypad.');
          this._terminal.applicationKeypad = true;
-          this._terminal.viewport.syncScrollArea();
+          if (this._terminal.viewport) {
+            this._terminal.viewport.syncScrollArea();
+          }
          break;
        case 9: // X10 Mouse
          // no release, no motion, no wheel, no modifiers.
@@ -1280,8 +1279,12 @@ export class InputHandler extends Disposable implements IInputHandler {
          this._terminal.vt200Mouse = params[0] === 1000;
          this._terminal.normalMouse = params[0] > 1000;
          this._terminal.mouseEvents = true;
-          this._terminal.element.classList.add('enable-mouse-events');
-          this._terminal.selectionManager.disable();
+          if (this._terminal.element) {
+            this._terminal.element.classList.add('enable-mouse-events');
+          }
+          if (this._terminal.selectionManager) {
+            this._terminal.selectionManager.disable();
+          }
          this._terminal.log('Binding to mouse events.');
          break;
        case 1004: // send focusin/focusout events
@@ -1311,14 +1314,19 @@ export class InputHandler extends Disposable implements IInputHandler {
        case 25: // show cursor
          this._terminal.cursorHidden = false;
          break;
+        case 1048: // alt screen cursor
+          this.saveCursor(params);
+          break;
        case 1049: // alt screen buffer cursor
-          // TODO: Not sure if we need to save/restore after switching the buffer
-          // this.saveCursor(params);
+          this.saveCursor(params);
          // FALL-THROUGH
        case 47: // alt screen buffer
        case 1047: // alt screen buffer
-          this._terminal.buffers.activateAltBuffer();
-          this._terminal.viewport.syncScrollArea();
+          this._terminal.buffers.activateAltBuffer(this._terminal.eraseAttrData());
+          this._terminal.refresh(0, this._terminal.rows - 1);
+          if (this._terminal.viewport) {
+            this._terminal.viewport.syncScrollArea();
+          }
          this._terminal.showCursor();
          break;
        case 2004: // bracketed paste mode (https://cirw.in/blog/bracketed-paste)
@@ -1451,7 +1459,9 @@ export class InputHandler extends Disposable implements IInputHandler {
        case 66:
          this._terminal.log('Switching back to normal keypad.');
          this._terminal.applicationKeypad = false;
-          this._terminal.viewport.syncScrollArea();
+          if (this._terminal.viewport) {
+            this._terminal.viewport.syncScrollArea();
+          }
          break;
        case 9: // X10 Mouse
        case 1000: // vt200 mouse
@@ -1461,8 +1471,12 @@ export class InputHandler extends Disposable implements IInputHandler {
          this._terminal.vt200Mouse = false;
          this._terminal.normalMouse = false;
          this._terminal.mouseEvents = false;
-          this._terminal.element.classList.remove('enable-mouse-events');
-          this._terminal.selectionManager.enable();
+          if (this._terminal.element) {
+            this._terminal.element.classList.remove('enable-mouse-events');
+          }
+          if (this._terminal.selectionManager) {
+            this._terminal.selectionManager.enable();
+          }
          break;
        case 1004: // send focusin/focusout events
          this._terminal.sendFocus = false;
@@ -1479,18 +1493,22 @@ export class InputHandler extends Disposable implements IInputHandler {
        case 25: // hide cursor
          this._terminal.cursorHidden = true;
          break;
+        case 1048: // alt screen cursor
+          this.restoreCursor(params);
+          break;
        case 1049: // alt screen buffer cursor
           // FALL-THROUGH
        case 47: // normal screen buffer
        case 1047: // normal screen buffer - clearing it first
          // Ensure the selection manager has the correct buffer
          this._terminal.buffers.activateNormalBuffer();
-          // TODO: Not sure if we need to save/restore after switching the buffer
-          // if (params[0] === 1049) {
-          //   this.restoreCursor(params);
-          // }
+          if (params[0] === 1049) {
+            this.restoreCursor(params);
+          }
          this._terminal.refresh(0, this._terminal.rows - 1);
-          this._terminal.viewport.syncScrollArea();
+          if (this._terminal.viewport) {
+            this._terminal.viewport.syncScrollArea();
+          }
          this._terminal.showCursor();
          break;
        case 2004: // bracketed paste mode (https://cirw.in/blog/bracketed-paste)
@@ -1568,127 +1586,124 @@ export class InputHandler extends Disposable implements IInputHandler {
  public charAttributes(params: number[]): void {
    // Optimize a single SGR0.
    if (params.length === 1 && params[0] === 0) {
-      this._terminal.curAttr = DEFAULT_ATTR;
+      this._terminal.curAttrData.fg = DEFAULT_ATTR_DATA.fg;
+      this._terminal.curAttrData.bg = DEFAULT_ATTR_DATA.bg;
      return;
    }

    const l = params.length;
-    let flags = this._terminal.curAttr >> 18;
-    let fg = (this._terminal.curAttr >> 9) & 0x1ff;
-    let bg = this._terminal.curAttr & 0x1ff;
    let p;
+    const attr = this._terminal.curAttrData;

    for (let i = 0; i < l; i++) {
      p = params[i];
      if (p >= 30 && p <= 37) {
        // fg color 8
-        fg = p - 30;
+        attr.fg &= ~(Attributes.CM_MASK | Attributes.PCOLOR_MASK);
+        attr.fg |= Attributes.CM_P16 | (p - 30);
      } else if (p >= 40 && p <= 47) {
        // bg color 8
-        bg = p - 40;
+        attr.bg &= ~(Attributes.CM_MASK | Attributes.PCOLOR_MASK);
+        attr.bg |= Attributes.CM_P16 | (p - 40);
      } else if (p >= 90 && p <= 97) {
        // fg color 16
-        p += 8;
-        fg = p - 90;
+        attr.fg &= ~(Attributes.CM_MASK | Attributes.PCOLOR_MASK);
+        attr.fg |= Attributes.CM_P16 | (p - 90) | 8;
      } else if (p >= 100 && p <= 107) {
        // bg color 16
-        p += 8;
-        bg = p - 100;
+        attr.bg &= ~(Attributes.CM_MASK | Attributes.PCOLOR_MASK);
+        attr.bg |= Attributes.CM_P16 | (p - 100) | 8;
      } else if (p === 0) {
        // default
-        flags = DEFAULT_ATTR >> 18;
-        fg = (DEFAULT_ATTR >> 9) & 0x1ff;
-        bg = DEFAULT_ATTR & 0x1ff;
-        // flags = 0;
-        // fg = 0x1ff;
-        // bg = 0x1ff;
+        attr.fg = DEFAULT_ATTR_DATA.fg;
+        attr.bg = DEFAULT_ATTR_DATA.bg;
      } else if (p === 1) {
        // bold text
-        flags |= FLAGS.BOLD;
+        attr.fg |= FgFlags.BOLD;
      } else if (p === 3) {
        // italic text
-        flags |= FLAGS.ITALIC;
+        attr.bg |= BgFlags.ITALIC;
      } else if (p === 4) {
        // underlined text
-        flags |= FLAGS.UNDERLINE;
+        attr.fg |= FgFlags.UNDERLINE;
      } else if (p === 5) {
        // blink
-        flags |= FLAGS.BLINK;
+        attr.fg |= FgFlags.BLINK;
      } else if (p === 7) {
        // inverse and positive
        // test with: echo -e '\e[31m\e[42mhello\e[7mworld\e[27mhi\e[m'
-        flags |= FLAGS.INVERSE;
+        attr.fg |= FgFlags.INVERSE;
      } else if (p === 8) {
        // invisible
-        flags |= FLAGS.INVISIBLE;
+        attr.fg |= FgFlags.INVISIBLE;
      } else if (p === 2) {
        // dimmed text
-        flags |= FLAGS.DIM;
+        attr.bg |= BgFlags.DIM;
      } else if (p === 22) {
        // not bold nor faint
-        flags &= ~FLAGS.BOLD;
-        flags &= ~FLAGS.DIM;
+        attr.fg &= ~FgFlags.BOLD;
+        attr.bg &= ~BgFlags.DIM;
      } else if (p === 23) {
        // not italic
-        flags &= ~FLAGS.ITALIC;
+        attr.bg &= ~BgFlags.ITALIC;
      } else if (p === 24) {
        // not underlined
-        flags &= ~FLAGS.UNDERLINE;
+        attr.fg &= ~FgFlags.UNDERLINE;
      } else if (p === 25) {
        // not blink
-        flags &= ~FLAGS.BLINK;
+        attr.fg &= ~FgFlags.BLINK;
      } else if (p === 27) {
        // not inverse
-        flags &= ~FLAGS.INVERSE;
+        attr.fg &= ~FgFlags.INVERSE;
      } else if (p === 28) {
        // not invisible
-        flags &= ~FLAGS.INVISIBLE;
+        attr.fg &= ~FgFlags.INVISIBLE;
      } else if (p === 39) {
        // reset fg
-        fg = (DEFAULT_ATTR >> 9) & 0x1ff;
+        attr.fg &= ~(Attributes.CM_MASK | Attributes.RGB_MASK);
+        attr.fg |= DEFAULT_ATTR_DATA.fg & (Attributes.PCOLOR_MASK | Attributes.RGB_MASK);
      } else if (p === 49) {
        // reset bg
-        bg = DEFAULT_ATTR & 0x1ff;
+        attr.bg &= ~(Attributes.CM_MASK | Attributes.RGB_MASK);
+        attr.bg |= DEFAULT_ATTR_DATA.bg & (Attributes.PCOLOR_MASK | Attributes.RGB_MASK);
      } else if (p === 38) {
        // fg color 256
        if (params[i + 1] === 2) {
          i += 2;
-          fg = this._terminal.matchColor(
-            params[i] & 0xff,
-            params[i + 1] & 0xff,
-            params[i + 2] & 0xff);
-          if (fg === -1) fg = 0x1ff;
+          attr.fg |= Attributes.CM_RGB;
+          attr.fg &= ~Attributes.RGB_MASK;
+          attr.fg |= AttributeData.fromColorRGB([params[i], params[i + 1], params[i + 2]]);
          i += 2;
        } else if (params[i + 1] === 5) {
          i += 2;
          p = params[i] & 0xff;
-          fg = p;
+          attr.fg &= ~Attributes.PCOLOR_MASK;
+          attr.fg |= Attributes.CM_P256 | p;
        }
      } else if (p === 48) {
        // bg color 256
        if (params[i + 1] === 2) {
          i += 2;
-          bg = this._terminal.matchColor(
-            params[i] & 0xff,
-            params[i + 1] & 0xff,
-            params[i + 2] & 0xff);
-          if (bg === -1) bg = 0x1ff;
+          attr.bg |= Attributes.CM_RGB;
+          attr.bg &= ~Attributes.RGB_MASK;
+          attr.bg |= AttributeData.fromColorRGB([params[i], params[i + 1], params[i + 2]]);
          i += 2;
        } else if (params[i + 1] === 5) {
          i += 2;
          p = params[i] & 0xff;
-          bg = p;
+          attr.bg &= ~Attributes.PCOLOR_MASK;
+          attr.bg |= Attributes.CM_P256 | p;
        }
      } else if (p === 100) {
        // reset fg/bg
-        fg = (DEFAULT_ATTR >> 9) & 0x1ff;
-        bg = DEFAULT_ATTR & 0x1ff;
+        attr.fg &= ~(Attributes.CM_MASK | Attributes.RGB_MASK);
+        attr.fg |= DEFAULT_ATTR_DATA.fg & (Attributes.PCOLOR_MASK | Attributes.RGB_MASK);
+        attr.bg &= ~(Attributes.CM_MASK | Attributes.RGB_MASK);
+        attr.bg |= DEFAULT_ATTR_DATA.bg & (Attributes.PCOLOR_MASK | Attributes.RGB_MASK);
      } else {
        this._terminal.error('Unknown SGR attribute: %d.', p);
      }
    }
-
-    this._terminal.curAttr = (flags << 18) | (fg << 9) | bg;
  }

  /**
@@ -1719,13 +1734,13 @@ export class InputHandler extends Disposable implements IInputHandler {
      switch (params[0]) {
        case 5:
          // status report
-          this._terminal.emit('data', `${C0.ESC}[0n`);
+          this._onData.fire(`${C0.ESC}[0n`);
          break;
        case 6:
          // cursor position
          const y = this._terminal.buffer.y + 1;
          const x = this._terminal.buffer.x + 1;
-          this._terminal.emit('data', `${C0.ESC}[${y};${x}R`);
+          this._onData.fire(`${C0.ESC}[${y};${x}R`);
          break;
      }
    } else if (collect === '?') {
@@ -1736,7 +1751,7 @@ export class InputHandler extends Disposable implements IInputHandler {
          // cursor position
          const y = this._terminal.buffer.y + 1;
          const x = this._terminal.buffer.x + 1;
-          this._terminal.emit('data', `${C0.ESC}[?${y};${x}R`);
+          this._onData.fire(`${C0.ESC}[?${y};${x}R`);
          break;
        case 15:
          // no printer
@@ -1769,11 +1784,13 @@ export class InputHandler extends Disposable implements IInputHandler {
      this._terminal.originMode = false;
      this._terminal.wraparoundMode = true;  // defaults: xterm - true, vt100 - false
      this._terminal.applicationKeypad = false; // ?
-      this._terminal.viewport.syncScrollArea();
+      if (this._terminal.viewport) {
+        this._terminal.viewport.syncScrollArea();
+      }
      this._terminal.applicationCursor = false;
      this._terminal.buffer.scrollTop = 0;
      this._terminal.buffer.scrollBottom = this._terminal.rows - 1;
-      this._terminal.curAttr = DEFAULT_ATTR;
+      this._terminal.curAttrData = DEFAULT_ATTR_DATA;
      this._terminal.buffer.x = this._terminal.buffer.y = 0; // ?
      this._terminal.charset = null;
      this._terminal.glevel = 0; // ??
@@ -1820,7 +1837,9 @@ export class InputHandler extends Disposable implements IInputHandler {
   * CSI ? Pm r
   */
  public setScrollRegion(params: number[], collect?: string): void {
-    if (collect) return;
+    if (collect) {
+      return;
+    }
    this._terminal.buffer.scrollTop = (params[0] || 1) - 1;
    this._terminal.buffer.scrollBottom = (params[1] && params[1] <= this._terminal.rows ? params[1] : this._terminal.rows) - 1;
    this._terminal.buffer.x = 0;
@@ -1836,7 +1855,8 @@ export class InputHandler extends Disposable implements IInputHandler {
  public saveCursor(params: number[]): void {
    this._terminal.buffer.savedX = this._terminal.buffer.x;
    this._terminal.buffer.savedY = this._terminal.buffer.y;
-    this._terminal.savedCurAttr = this._terminal.curAttr;
+    this._terminal.buffer.savedCurAttrData.fg = this._terminal.curAttrData.fg;
+    this._terminal.buffer.savedCurAttrData.bg = this._terminal.curAttrData.bg;
  }


@@ -1848,7 +1868,8 @@ export class InputHandler extends Disposable implements IInputHandler {
  public restoreCursor(params: number[]): void {
    this._terminal.buffer.x = this._terminal.buffer.savedX || 0;
    this._terminal.buffer.y = this._terminal.buffer.savedY || 0;
-    this._terminal.curAttr = this._terminal.savedCurAttr || DEFAULT_ATTR;
+    this._terminal.curAttrData.fg = this._terminal.buffer.savedCurAttrData.fg;
+    this._terminal.curAttrData.bg = this._terminal.buffer.savedCurAttrData.bg;
  }


@@ -1926,9 +1947,15 @@ export class InputHandler extends Disposable implements IInputHandler {
   *   Designate G3 Character Set (VT300). C = A  -> ISO Latin-1 Supplemental. - Supported?
   */
  public selectCharset(collectAndFlag: string): void {
-    if (collectAndFlag.length !== 2) return this.selectDefaultCharset();
-    if (collectAndFlag[0] === '/') return;  // TODO: Is this supported?
+    if (collectAndFlag.length !== 2) {
+      this.selectDefaultCharset();
+      return;
+    }
+    if (collectAndFlag[0] === '/') {
+      return;  // TODO: Is this supported?
+    }
    this._terminal.setgCharset(GLEVEL[collectAndFlag[0]], CHARSETS[collectAndFlag[1]] || DEFAULT_CHARSET);
+    return;
  }

  /**
@@ -4,12 +4,11 @@
 */

 import { assert } from 'chai';
-import { IMouseZoneManager, IMouseZone } from './ui/Types';
-import { ILinkMatcher, ITerminal, IBufferLine } from './Types';
+import { IMouseZoneManager, IMouseZone, ILinkMatcher, ITerminal, IBufferLine } from './Types';
 import { Linkifier } from './Linkifier';
-import { MockBuffer, MockTerminal, TestTerminal } from './utils/TestUtils.test';
+import { MockBuffer, MockTerminal, TestTerminal } from './TestUtils.test';
 import { CircularList } from './common/CircularList';
-import { BufferLine } from './BufferLine';
+import { BufferLine, CellData } from './BufferLine';

 class TestLinkifier extends Linkifier {
  constructor(terminal: ITerminal) {
@@ -41,8 +40,8 @@ describe('Linkifier', () => {

  beforeEach(() => {
    terminal = new MockTerminal();
-    terminal.cols = 100;
-    terminal.rows = 10;
+    (terminal as any).cols = 100;
+    (terminal as any).rows = 10;
    terminal.buffer = new MockBuffer();
    (<MockBuffer>terminal.buffer).setLines(new CircularList<IBufferLine>(20));
    terminal.buffer.ydisp = 0;
@@ -51,9 +50,9 @@ describe('Linkifier', () => {
  });

  function stringToRow(text: string): IBufferLine {
-    const result = new BufferLine();
+    const result = new BufferLine(text.length);
    for (let i = 0; i < text.length; i++) {
-      result.push([0, text.charAt(i), 1, text.charCodeAt(i)]);
+      result.setCell(i, CellData.fromCharData([0, text.charAt(i), 1, text.charCodeAt(i)]));
    }
    return result;
  }
@@ -65,7 +64,7 @@ describe('Linkifier', () => {
  function assertLinkifiesRow(rowText: string, linkMatcherRegex: RegExp, links: {x: number, length: number}[], done: MochaDone): void {
    addRow(rowText);
    linkifier.registerLinkMatcher(linkMatcherRegex, () => {});
-    terminal.rows = terminal.buffer.lines.length - 1;
+    (terminal as any).rows = terminal.buffer.lines.length - 1;
    linkifier.linkifyRows();
    // Allow linkify to happen
    setTimeout(() => {
@@ -142,19 +141,19 @@ describe('Linkifier', () => {
      });
      describe('multi-line links', () => {
        it('should match links that start on line 1/2 of a wrapped line and end on the last character of line 1/2', done => {
-          terminal.cols = 4;
+          (terminal as any).cols = 4;
          assertLinkifiesMultiLineLink('12345', /1234/, [{x1: 0, x2: 4, y1: 0, y2: 0}], done);
        });
        it('should match links that start on line 1/2 of a wrapped line and wrap to line 2/2', done => {
-          terminal.cols = 4;
+          (terminal as any).cols = 4;
          assertLinkifiesMultiLineLink('12345', /12345/, [{x1: 0, x2: 1, y1: 0, y2: 1}], done);
        });
        it('should match links that start and end on line 2/2 of a wrapped line', done => {
-          terminal.cols = 4;
+          (terminal as any).cols = 4;
          assertLinkifiesMultiLineLink('12345678', /5678/, [{x1: 0, x2: 4, y1: 1, y2: 1}], done);
        });
        it('should match links that start on line 2/3 of a wrapped line and wrap to line 3/3', done => {
-          terminal.cols = 4;
+          (terminal as any).cols = 4;
          assertLinkifiesMultiLineLink('123456789', /56789/, [{x1: 0, x2: 1, y1: 1, y2: 2}], done);
        });
      });
@@ -3,17 +3,15 @@
 * @license MIT
 */

-import { IMouseZoneManager } from './ui/Types';
-import { ILinkHoverEvent, ILinkMatcher, LinkMatcherHandler, LinkHoverEventTypes, ILinkMatcherOptions, ILinkifier, ITerminal, IBufferStringIteratorResult } from './Types';
-import { MouseZone } from './ui/MouseZoneManager';
-import { EventEmitter } from './common/EventEmitter';
-import { CHAR_DATA_ATTR_INDEX } from './Buffer';
+import { ILinkifierEvent, ILinkMatcher, LinkMatcherHandler, ILinkMatcherOptions, ILinkifier, ITerminal, IBufferStringIteratorResult, IMouseZoneManager } from './Types';
+import { MouseZone } from './MouseZoneManager';
 import { getStringCellWidth } from './CharWidth';
+import { EventEmitter2, IEvent } from './common/EventEmitter2';

 /**
 * The Linkifier applies links to rows shortly after they have been refreshed.
 */
-export class Linkifier extends EventEmitter implements ILinkifier {
+export class Linkifier implements ILinkifier {
  /**
   * The time to wait after a row is changed before it is linkified. This prevents
   * the costly operation of searching every row multiple times, potentially a
@@ -35,10 +33,16 @@ export class Linkifier extends EventEmitter implements ILinkifier {
  private _nextLinkMatcherId = 0;
  private _rowsToLinkify: { start: number, end: number };

+  private _onLinkHover = new EventEmitter2<ILinkifierEvent>();
+  public get onLinkHover(): IEvent<ILinkifierEvent> { return this._onLinkHover.event; }
+  private _onLinkLeave = new EventEmitter2<ILinkifierEvent>();
+  public get onLinkLeave(): IEvent<ILinkifierEvent> { return this._onLinkLeave.event; }
+  private _onLinkTooltip = new EventEmitter2<ILinkifierEvent>();
+  public get onLinkTooltip(): IEvent<ILinkifierEvent> { return this._onLinkTooltip.event; }
+
  constructor(
    protected _terminal: ITerminal
  ) {
-    super();
    this._rowsToLinkify = {
      start: null,
      end: null
@@ -219,15 +223,22 @@ export class Linkifier extends EventEmitter implements ILinkifier {
      // also correct regex and string search offsets for the next loop run
      stringIndex = text.indexOf(uri, stringIndex + 1);
      rex.lastIndex = stringIndex + uri.length;
+      if (stringIndex < 0) {
+        // invalid stringIndex (should not have happened)
+        break;
+      }

      // get the buffer index as [absolute row, col] for the match
      const bufferIndex = this._terminal.buffer.stringIndexToBufferIndex(rowIndex, stringIndex);
+      if (bufferIndex[0] < 0) {
+        // invalid bufferIndex (should not have happened)
+        break;
+      }

      const line = this._terminal.buffer.lines.get(bufferIndex[0]);
-      const char = line.get(bufferIndex[1]);
+      const attr = line.getFg(bufferIndex[1]);
      let fg: number | undefined;
-      if (char) {
-        const attr: number = char[CHAR_DATA_ATTR_INDEX];
+      if (attr) {
        fg = (attr >> 9) & 0x1ff;
      }

@@ -277,18 +288,18 @@ export class Linkifier extends EventEmitter implements ILinkifier {
        }
        window.open(uri, '_blank');
      },
-      e => {
-        this.emit(LinkHoverEventTypes.HOVER, this._createLinkHoverEvent(x1, y1, x2, y2, fg));
+      () => {
+        this._onLinkHover.fire(this._createLinkHoverEvent(x1, y1, x2, y2, fg));
        this._terminal.element.classList.add('xterm-cursor-pointer');
      },
      e => {
-        this.emit(LinkHoverEventTypes.TOOLTIP, this._createLinkHoverEvent(x1, y1, x2, y2, fg));
+        this._onLinkTooltip.fire(this._createLinkHoverEvent(x1, y1, x2, y2, fg));
        if (matcher.hoverTooltipCallback) {
          matcher.hoverTooltipCallback(e, uri);
        }
      },
      () => {
-        this.emit(LinkHoverEventTypes.LEAVE, this._createLinkHoverEvent(x1, y1, x2, y2, fg));
+        this._onLinkLeave.fire(this._createLinkHoverEvent(x1, y1, x2, y2, fg));
        this._terminal.element.classList.remove('xterm-cursor-pointer');
        if (matcher.hoverLeaveCallback) {
          matcher.hoverLeaveCallback();
@@ -303,7 +314,7 @@ export class Linkifier extends EventEmitter implements ILinkifier {
    ));
  }

-  private _createLinkHoverEvent(x1: number, y1: number, x2: number, y2: number, fg: number): ILinkHoverEvent {
+  private _createLinkHoverEvent(x1: number, y1: number, x2: number, y2: number, fg: number): ILinkifierEvent {
    return { x1, y1, x2, y2, cols: this._terminal.cols, fg };
  }
 }
@@ -37,34 +37,28 @@ describe('MouseHelper.getCoords', () => {
  describe('when charMeasure is not initialized', () => {
    it('should return null', () => {
      charMeasure = new MockCharMeasure();
-      assert.equal(mouseHelper.getCoords({ pageX: 0, pageY: 0 }, document.createElement('div'), charMeasure, 1, 10, 10), null);
-    });
-  });
-
-  describe('when pageX/pageY are not supported', () => {
-    it('should return null', () => {
-      assert.equal(mouseHelper.getCoords({ pageX: undefined, pageY: undefined }, document.createElement('div'), charMeasure, 1, 10, 10), null);
+      assert.equal(mouseHelper.getCoords({ clientX: 0, clientY: 0 }, document.createElement('div'), charMeasure, 10, 10), null);
    });
  });

  it('should return the cell that was clicked', () => {
    let coords: [number, number];
-    coords = mouseHelper.getCoords({ pageX: CHAR_WIDTH / 2, pageY: CHAR_HEIGHT / 2 }, document.createElement('div'), charMeasure, 1, 10, 10);
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH / 2, clientY: CHAR_HEIGHT / 2 }, document.createElement('div'), charMeasure, 10, 10);
    assert.deepEqual(coords, [1, 1]);
-    coords = mouseHelper.getCoords({ pageX: CHAR_WIDTH, pageY: CHAR_HEIGHT }, document.createElement('div'), charMeasure, 1, 10, 10);
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH, clientY: CHAR_HEIGHT }, document.createElement('div'), charMeasure, 10, 10);
    assert.deepEqual(coords, [1, 1]);
-    coords = mouseHelper.getCoords({ pageX: CHAR_WIDTH, pageY: CHAR_HEIGHT + 1 }, document.createElement('div'), charMeasure, 1, 10, 10);
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH, clientY: CHAR_HEIGHT + 1 }, document.createElement('div'), charMeasure, 10, 10);
    assert.deepEqual(coords, [1, 2]);
-    coords = mouseHelper.getCoords({ pageX: CHAR_WIDTH + 1, pageY: CHAR_HEIGHT }, document.createElement('div'), charMeasure, 1, 10, 10);
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH + 1, clientY: CHAR_HEIGHT }, document.createElement('div'), charMeasure, 10, 10);
    assert.deepEqual(coords, [2, 1]);
  });

  it('should ensure the coordinates are returned within the terminal bounds', () => {
    let coords: [number, number];
-    coords = mouseHelper.getCoords({ pageX: -1, pageY: -1 }, document.createElement('div'), charMeasure, 1, 10, 10);
+    coords = mouseHelper.getCoords({ clientX: -1, clientY: -1 }, document.createElement('div'), charMeasure, 10, 10);
    assert.deepEqual(coords, [1, 1]);
    // Event are double the cols/rows
-    coords = mouseHelper.getCoords({ pageX: CHAR_WIDTH * 20, pageY: CHAR_HEIGHT * 20 }, document.createElement('div'), charMeasure, 1, 10, 10);
+    coords = mouseHelper.getCoords({ clientX: CHAR_WIDTH * 20, clientY: CHAR_HEIGHT * 20 }, document.createElement('div'), charMeasure, 10, 10);
    assert.deepEqual(coords, [10, 10], 'coordinates should never come back as larger than the terminal');
  });
 });
@@ -3,36 +3,19 @@
 * @license MIT
 */

-import { ICharMeasure } from '../Types';
-import { IRenderer } from '../renderer/Types';
+import { ICharMeasure, IMouseHelper } from './Types';
+import { IRenderer } from './renderer/Types';

-export class MouseHelper {
+export class MouseHelper implements IMouseHelper {
  constructor(private _renderer: IRenderer) {}

-  public static getCoordsRelativeToElement(event: {pageX: number, pageY: number}, element: HTMLElement): [number, number] {
-    // Ignore browsers that don't support MouseEvent.pageX
-    if (event.pageX === null || event.pageX === undefined) {
-      return null;
-    }
+  public setRenderer(renderer: IRenderer): void {
+    this._renderer = renderer;
+  }

-    const originalElement = element;
-    let x = event.pageX;
-    let y = event.pageY;
-
-    // Converts the coordinates from being relative to the document to being
-    // relative to the terminal.
-    while (element) {
-      x -= element.offsetLeft;
-      y -= element.offsetTop;
-      element = <HTMLElement>element.offsetParent;
-    }
-    element = originalElement;
-    while (element && element !== element.ownerDocument.body) {
-      x += element.scrollLeft;
-      y += element.scrollTop;
-      element = <HTMLElement>element.parentElement;
-    }
-    return [x, y];
+  public static getCoordsRelativeToElement(event: {clientX: number, clientY: number}, element: HTMLElement): [number, number] {
+    const rect = element.getBoundingClientRect();
+    return [event.clientX - rect.left, event.clientY - rect.top];
  }

  /**
@@ -48,7 +31,7 @@ export class MouseHelper {
   * apply an offset to the x value such that the left half of the cell will
   * select that cell and the right half will select the next cell.
   */
-  public getCoords(event: {pageX: number, pageY: number}, element: HTMLElement, charMeasure: ICharMeasure, lineHeight: number, colCount: number, rowCount: number, isSelection?: boolean): [number, number] {
+  public getCoords(event: {clientX: number, clientY: number}, element: HTMLElement, charMeasure: ICharMeasure, colCount: number, rowCount: number, isSelection?: boolean): [number, number] {
    // Coordinates cannot be measured if charMeasure has not been initialized
    if (!charMeasure.width || !charMeasure.height) {
      return null;
@@ -81,8 +64,8 @@ export class MouseHelper {
   * @param colCount The number of columns in the terminal.
   * @param rowCount The number of rows in the terminal.
   */
-  public getRawByteCoords(event: MouseEvent, element: HTMLElement, charMeasure: ICharMeasure, lineHeight: number, colCount: number, rowCount: number): { x: number, y: number } {
-    const coords = this.getCoords(event, element, charMeasure, lineHeight, colCount, rowCount);
+  public getRawByteCoords(event: MouseEvent, element: HTMLElement, charMeasure: ICharMeasure, colCount: number, rowCount: number): { x: number, y: number } {
+    const coords = this.getCoords(event, element, charMeasure, colCount, rowCount);
    let x = coords[0];
    let y = coords[1];

@@ -3,10 +3,9 @@
 * @license MIT
 */

-import { ITerminal } from '../Types';
-import { IMouseZoneManager, IMouseZone } from './Types';
-import { Disposable } from '../common/Lifecycle';
-import { addDisposableDomListener } from './Lifecycle';
+import { ITerminal, IMouseZoneManager, IMouseZone } from './Types';
+import { Disposable } from './common/Lifecycle';
+import { addDisposableDomListener } from './ui/Lifecycle';

 const HOVER_DURATION = 500;

@@ -23,11 +22,13 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {

  private _areZonesActive: boolean = false;
  private _mouseMoveListener: (e: MouseEvent) => any;
+  private _mouseLeaveListener: (e: MouseEvent) => any;
  private _clickListener: (e: MouseEvent) => any;

  private _tooltipTimeout: number = null;
  private _currentZone: IMouseZone = null;
  private _lastHoverCoords: [number, number] = [null, null];
+  private _initialSelectionLength: number;

  constructor(
    private _terminal: ITerminal
@@ -38,6 +39,7 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {

    // These events are expensive, only listen to it when mouse zones are active
    this._mouseMoveListener = e => this._onMouseMove(e);
+    this._mouseLeaveListener = e => this._onMouseLeave(e);
    this._clickListener = e => this._onClick(e);
  }

@@ -89,6 +91,7 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {
    if (!this._areZonesActive) {
      this._areZonesActive = true;
      this._terminal.element.addEventListener('mousemove', this._mouseMoveListener);
+      this._terminal.element.addEventListener('mouseleave', this._mouseLeaveListener);
      this._terminal.element.addEventListener('click', this._clickListener);
    }
  }
@@ -97,6 +100,7 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {
    if (this._areZonesActive) {
      this._areZonesActive = false;
      this._terminal.element.removeEventListener('mousemove', this._mouseMoveListener);
+      this._terminal.element.removeEventListener('mouseleave', this._mouseLeaveListener);
      this._terminal.element.removeEventListener('click', this._clickListener);
    }
  }
@@ -153,6 +157,10 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {
  }

  private _onMouseDown(e: MouseEvent): void {
+    // Store current terminal selection length, to check if we're performing
+    // a selection operation
+    this._initialSelectionLength = this._terminal.getSelection().length;
+
    // Ignore the event if there are no zones active
    if (!this._areZonesActive) {
      return;
@@ -169,10 +177,25 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {
    }
  }

+  private _onMouseLeave(e: MouseEvent): void {
+    // Fire the hover end callback and cancel any existing timer if the mouse
+    // leaves the terminal element
+    if (this._currentZone) {
+      this._currentZone.leaveCallback();
+      this._currentZone = null;
+      if (this._tooltipTimeout) {
+        clearTimeout(this._tooltipTimeout);
+      }
+    }
+  }
+
  private _onClick(e: MouseEvent): void {
-    // Find the active zone and click it if found
+    // Find the active zone and click it if found and no selection was
+    // being performed
    const zone = this._findZoneEventAt(e);
-    if (zone) {
+    const currentSelectionLength = this._terminal.getSelection().length;
+
+    if (zone && currentSelectionLength === this._initialSelectionLength) {
      zone.clickCallback(e);
      e.preventDefault();
      e.stopImmediatePropagation();
@@ -180,7 +203,7 @@ export class MouseZoneManager extends Disposable implements IMouseZoneManager {
  }

  private _findZoneEventAt(e: MouseEvent): IMouseZone {
-    const coords = this._terminal.mouseHelper.getCoords(e, this._terminal.screenElement, this._terminal.charMeasure, this._terminal.options.lineHeight, this._terminal.cols, this._terminal.rows);
+    const coords = this._terminal.mouseHelper.getCoords(e, this._terminal.screenElement, this._terminal.charMeasure, this._terminal.cols, this._terminal.rows);
    if (!coords) {
      return null;
    }
@@ -4,13 +4,13 @@
 */

 import { assert } from 'chai';
-import { CharMeasure } from './ui/CharMeasure';
+import { CharMeasure } from './CharMeasure';
 import { SelectionManager, SelectionMode } from './SelectionManager';
 import { SelectionModel } from './SelectionModel';
 import { BufferSet } from './BufferSet';
 import { ITerminal, IBuffer, IBufferLine } from './Types';
-import { MockTerminal } from './utils/TestUtils.test';
-import { BufferLine } from './BufferLine';
+import { MockTerminal } from './TestUtils.test';
+import { BufferLine, CellData } from './BufferLine';

 class TestMockTerminal extends MockTerminal {
  emit(event: string, data: any): void {}
@@ -30,6 +30,7 @@ class TestSelectionManager extends SelectionManager {

  public selectLineAt(line: number): void { this._selectLineAt(line); }
  public selectWordAt(coords: [number, number]): void { this._selectWordAt(coords, true); }
+  public areCoordsInSelection(coords: [number, number], start: [number, number], end: [number, number]): boolean { return this._areCoordsInSelection(coords, start, end); }

  // Disable DOM interaction
  public enable(): void {}
@@ -44,8 +45,8 @@ describe('SelectionManager', () => {

  beforeEach(() => {
    terminal = new TestMockTerminal();
-    terminal.cols = 80;
-    terminal.rows = 2;
+    (terminal as any).cols = 80;
+    (terminal as any).rows = 2;
    terminal.options.scrollback = 100;
    terminal.buffers = new BufferSet(terminal);
    terminal.buffer = terminal.buffers.active;
@@ -54,16 +55,16 @@ describe('SelectionManager', () => {
  });

  function stringToRow(text: string): IBufferLine {
-    const result = new BufferLine();
+    const result = new BufferLine(text.length);
    for (let i = 0; i < text.length; i++) {
-      result.push([0, text.charAt(i), 1, text.charCodeAt(i)]);
+      result.setCell(i, CellData.fromCharData([0, text.charAt(i), 1, text.charCodeAt(i)]));
    }
    return result;
  }

  function stringArrayToRow(chars: string[]): IBufferLine {
-    const line = new BufferLine();
-    chars.map(c => line.push([0, c, 1, c.charCodeAt(0)]));
+    const line = new BufferLine(chars.length);
+    chars.map((c, idx) => line.setCell(idx, CellData.fromCharData([0, c, 1, c.charCodeAt(0)])));
    return line;
  }

@@ -100,7 +101,6 @@ describe('SelectionManager', () => {
    });
    it('should expand selection for wide characters', () => {
      // Wide characters use a special format
-      const line = new BufferLine();
      const data: [number, string, number, number][] = [
        [null, '中', 2, '中'.charCodeAt(0)],
        [null, '', 0, null],
@@ -118,7 +118,8 @@ describe('SelectionManager', () => {
        [null, 'o', 1, 'o'.charCodeAt(0)],
        [null, 'o', 1, 'o'.charCodeAt(0)]
      ];
-      for (let i = 0; i < data.length; ++i) line.push(data[i]);
+      const line = new BufferLine(data.length);
+      for (let i = 0; i < data.length; ++i) line.setCell(i, CellData.fromCharData(data[i]));
      buffer.lines.set(0, line);
      // Ensure wide characters take up 2 columns
      selectionManager.selectWordAt([0, 0]);
@@ -478,5 +479,17 @@ describe('SelectionManager', () => {
      assert.equal(selectionManager.selectionText, 'a\n😁\nc');
    });
  });
+
+  describe('_areCoordsInSelection', () => {
+    it('should return whether coords are in the selection', () => {
+      assert.isFalse(selectionManager.areCoordsInSelection([0, 0], [2, 0], [2, 1]));
+      assert.isFalse(selectionManager.areCoordsInSelection([1, 0], [2, 0], [2, 1]));
+      assert.isTrue(selectionManager.areCoordsInSelection([2, 0], [2, 0], [2, 1]));
+      assert.isTrue(selectionManager.areCoordsInSelection([10, 0], [2, 0], [2, 1]));
+      assert.isTrue(selectionManager.areCoordsInSelection([0, 1], [2, 0], [2, 1]));
+      assert.isTrue(selectionManager.areCoordsInSelection([1, 1], [2, 0], [2, 1]));
+      assert.isFalse(selectionManager.areCoordsInSelection([2, 1], [2, 0], [2, 1]));
+    });
+  });
 });

@@ -3,15 +3,15 @@
 * @license MIT
 */

-import { ITerminal, ISelectionManager, IBuffer, CharData, IBufferLine } from './Types';
-import { XtermListener } from './common/Types';
-import { MouseHelper } from './utils/MouseHelper';
-import * as Browser from './shared/utils/Browser';
-import { CharMeasure } from './ui/CharMeasure';
-import { EventEmitter } from './common/EventEmitter';
+import { ITerminal, ISelectionManager, IBuffer, IBufferLine, ISelectionRedrawRequestEvent } from './Types';
+import { MouseHelper } from './MouseHelper';
+import * as Browser from './common/Platform';
+import { CharMeasure } from './CharMeasure';
 import { SelectionModel } from './SelectionModel';
-import { CHAR_DATA_WIDTH_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_CODE_INDEX } from './Buffer';
 import { AltClickHandler } from './handlers/AltClickHandler';
+import { CellData } from './BufferLine';
+import { IDisposable } from 'xterm';
+import { EventEmitter2, IEvent } from './common/EventEmitter2';

 /**
 * The number of pixels the mouse needs to be above or below the viewport in
@@ -67,10 +67,10 @@ export const enum SelectionMode {
 * SelectionModel, SelectionManager handles with all logic associated with
 * dealing with the selection, including handling mouse interaction, wide
 * characters and fetching the actual text within the selection. Rendering is
- * not handled by the SelectionManager but a 'refresh' event is fired when the
- * selection is ready to be redrawn.
+ * not handled by the SelectionManager but the onRedrawRequest event is fired
+ * when the selection is ready to be redrawn (on an animation frame).
 */
-export class SelectionManager extends EventEmitter implements ISelectionManager {
+export class SelectionManager implements ISelectionManager {
  protected _model: SelectionModel;

  /**
@@ -102,15 +102,22 @@ export class SelectionManager extends EventEmitter implements ISelectionManager

  private _mouseMoveListener: EventListener;
  private _mouseUpListener: EventListener;
-  private _trimListener: XtermListener;
+  private _trimListener: IDisposable;
+  private _workCell: CellData = new CellData();

  private _mouseDownTimeStamp: number;

+  private _onLinuxMouseSelection = new EventEmitter2<string>();
+  public get onLinuxMouseSelection(): IEvent<string> { return this._onLinuxMouseSelection.event; }
+  private _onRedrawRequest = new EventEmitter2<ISelectionRedrawRequestEvent>();
+  public get onRedrawRequest(): IEvent<ISelectionRedrawRequestEvent> { return this._onRedrawRequest.event; }
+  private _onSelectionChange = new EventEmitter2<void>();
+  public get onSelectionChange(): IEvent<void> { return this._onSelectionChange.event; }
+
  constructor(
    private _terminal: ITerminal,
    private _charMeasure: CharMeasure
  ) {
-    super();
    this._initListeners();
    this.enable();

@@ -119,7 +126,6 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
  }

  public dispose(): void {
-    super.dispose();
    this._removeMouseDownListeners();
  }

@@ -133,14 +139,13 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
  private _initListeners(): void {
    this._mouseMoveListener = event => this._onMouseMove(<MouseEvent>event);
    this._mouseUpListener = event => this._onMouseUp(<MouseEvent>event);
-    this._trimListener = (amount: number) => this._onTrim(amount);

    this.initBuffersListeners();
  }

  public initBuffersListeners(): void {
-    this._terminal.buffer.lines.on('trim', this._trimListener);
-    this._terminal.buffers.on('activate', e => this._onBufferActivate(e));
+    this._trimListener = this._terminal.buffer.lines.onTrim(amount => this._onTrim(amount));
+    this._terminal.buffers.onBufferActivate(e => this._onBufferActivate(e));
  }

  /**
@@ -198,7 +203,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
      }
    } else {
      // Get first row
-      const startRowEndCol = start[1] === end[1] ? end[0] : null;
+      const startRowEndCol = start[1] === end[1] ? end[0] : undefined;
      result.push(this._buffer.translateBufferLineToString(start[1], true, start[0], startRowEndCol));

      // Get middle rows
@@ -244,10 +249,10 @@ export class SelectionManager extends EventEmitter implements ISelectionManager

  /**
   * Queues a refresh, redrawing the selection on the next opportunity.
-   * @param isNewSelection Whether the selection should be registered as a new
+   * @param isLinuxMouseSelection Whether the selection should be registered as a new
   * selection on Linux.
   */
-  public refresh(isNewSelection?: boolean): void {
+  public refresh(isLinuxMouseSelection?: boolean): void {
    // Queue the refresh for the renderer
    if (!this._refreshAnimationFrame) {
      this._refreshAnimationFrame = window.requestAnimationFrame(() => this._refresh());
@@ -255,10 +260,10 @@ export class SelectionManager extends EventEmitter implements ISelectionManager

    // If the platform is Linux and the refresh call comes from a mouse event,
    // we need to update the selection for middle click to paste selection.
-    if (Browser.isLinux && isNewSelection) {
+    if (Browser.isLinux && isLinuxMouseSelection) {
      const selectionText = this.selectionText;
      if (selectionText.length) {
-        this.emit('newselection', this.selectionText);
+        this._onLinuxMouseSelection.fire(this.selectionText);
      }
    }
  }
@@ -269,7 +274,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
   */
  private _refresh(): void {
    this._refreshAnimationFrame = null;
-    this.emit('refresh', {
+    this._onRedrawRequest.fire({
      start: this._model.finalSelectionStart,
      end: this._model.finalSelectionEnd,
      columnSelectMode: this._activeSelectionMode === SelectionMode.COLUMN
@@ -289,9 +294,14 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
      return false;
    }

+    return this._areCoordsInSelection(coords, start, end);
+  }
+
+  protected _areCoordsInSelection(coords: [number, number], start: [number, number], end: [number, number]): boolean {
    return (coords[1] > start[1] && coords[1] < end[1]) ||
-        (start[1] === end[1] && coords[1] === start[1] && coords[0] > start[0] && coords[0] < end[0]) ||
-        (start[1] < end[1] && coords[1] === end[1] && coords[0] < end[0]);
+        (start[1] === end[1] && coords[1] === start[1] && coords[0] >= start[0] && coords[0] < end[0]) ||
+        (start[1] < end[1] && coords[1] === end[1] && coords[0] < end[0]) ||
+        (start[1] < end[1] && coords[1] === start[1] && coords[0] >= start[0]);
  }

  /**
@@ -313,7 +323,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
  public selectAll(): void {
    this._model.isSelectAllActive = true;
    this.refresh();
-    this._terminal.emit('selection');
+    this._onSelectionChange.fire();
  }

  public selectLines(start: number, end: number): void {
@@ -323,7 +333,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
    this._model.selectionStart = [0, start];
    this._model.selectionEnd = [this._terminal.cols, end];
    this.refresh();
-    this._terminal.emit('selection');
+    this._onSelectionChange.fire();
  }

  /**
@@ -342,7 +352,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
   * @param event The mouse event.
   */
  private _getMouseBufferCoords(event: MouseEvent): [number, number] {
-    const coords = this._terminal.mouseHelper.getCoords(event, this._terminal.screenElement, this._charMeasure, this._terminal.options.lineHeight, this._terminal.cols, this._terminal.rows, true);
+    const coords = this._terminal.mouseHelper.getCoords(event, this._terminal.screenElement, this._charMeasure, this._terminal.cols, this._terminal.rows, true);
    if (!coords) {
      return null;
    }
@@ -501,8 +511,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager

    // If the mouse is over the second half of a wide character, adjust the
    // selection to cover the whole character
-    const char = line.get(this._model.selectionStart[0]);
-    if (char[CHAR_DATA_WIDTH_INDEX] === 0) {
+    if (line.hasWidth(this._model.selectionStart[0]) === 0) {
      this._model.selectionStart[0]++;
    }
  }
@@ -547,7 +556,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
   */
  private _onMouseMove(event: MouseEvent): void {
    // If the mousemove listener is active it means that a selection is
-    // currently being made, we should stop propogation to prevent mouse events
+    // currently being made, we should stop propagation to prevent mouse events
    // to be sent to the pty.
    event.stopImmediatePropagation();

@@ -591,8 +600,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
    // selection. Note that selections at the very end of the line will never
    // have a character.
    if (this._model.selectionEnd[1] < this._buffer.lines.length) {
-      const char = this._buffer.lines.get(this._model.selectionEnd[1]).get(this._model.selectionEnd[0]);
-      if (char && char[CHAR_DATA_WIDTH_INDEX] === 0) {
+      if (this._buffer.lines.get(this._model.selectionEnd[1]).hasWidth(this._model.selectionEnd[0]) === 0) {
        this._model.selectionEnd[0]++;
      }
    }
@@ -643,7 +651,7 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
    if (this.selectionText.length <= 1 && timeElapsed < ALT_CLICK_MOVE_CURSOR_TIME) {
      (new AltClickHandler(event, this._terminal)).move();
    } else if (this.hasSelection) {
-      this._terminal.emit('selection');
+      this._onSelectionChange.fire();
    }
  }

@@ -653,8 +661,10 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
    // reverseIndex) and delete in a splice is only ever used when the same
    // number of elements was just added. Given this is could actually be
    // beneficial to leave the selection as is for these cases.
-    e.inactiveBuffer.lines.off('trim', this._trimListener);
-    e.activeBuffer.lines.on('trim', this._trimListener);
+    if (this._trimListener) {
+      this._trimListener.dispose();
+    }
+    this._trimListener = e.activeBuffer.lines.onTrim(amount => this._onTrim(amount));
  }

  /**
@@ -665,16 +675,16 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
  private _convertViewportColToCharacterIndex(bufferLine: IBufferLine, coords: [number, number]): number {
    let charIndex = coords[0];
    for (let i = 0; coords[0] >= i; i++) {
-      const char = bufferLine.get(i);
-      if (char[CHAR_DATA_WIDTH_INDEX] === 0) {
+      const length = bufferLine.loadCell(i, this._workCell).getChars().length;
+      if (this._workCell.getWidth() === 0) {
        // Wide characters aren't included in the line string so decrement the
        // index so the index is back on the wide character.
        charIndex--;
-      } else if (char[CHAR_DATA_CHAR_INDEX].length > 1 && coords[0] !== i) {
+      } else if (length > 1 && coords[0] !== i) {
        // Emojis take up multiple characters, so adjust accordingly. For these
        // we don't want ot include the character at the column as we're
        // returning the start index in the string, not the end index.
-        charIndex += char[CHAR_DATA_CHAR_INDEX].length - 1;
+        charIndex += length - 1;
      }
    }
    return charIndex;
@@ -734,48 +744,51 @@ export class SelectionManager extends EventEmitter implements ISelectionManager

      // Consider the initial position, skip it and increment the wide char
      // variable
-      if (bufferLine.get(startCol)[CHAR_DATA_WIDTH_INDEX] === 0) {
+      if (bufferLine.getWidth(startCol) === 0) {
        leftWideCharCount++;
        startCol--;
      }
-      if (bufferLine.get(endCol)[CHAR_DATA_WIDTH_INDEX] === 2) {
+      if (bufferLine.getWidth(endCol) === 2) {
        rightWideCharCount++;
        endCol++;
      }

      // Adjust the end index for characters whose length are > 1 (emojis)
-      if (bufferLine.get(endCol)[CHAR_DATA_CHAR_INDEX].length > 1) {
-        rightLongCharOffset += bufferLine.get(endCol)[CHAR_DATA_CHAR_INDEX].length - 1;
-        endIndex += bufferLine.get(endCol)[CHAR_DATA_CHAR_INDEX].length - 1;
+      const length = bufferLine.getString(endCol).length;
+      if (length > 1) {
+        rightLongCharOffset += length - 1;
+        endIndex += length - 1;
      }

      // Expand the string in both directions until a space is hit
-      while (startCol > 0 && startIndex > 0 && !this._isCharWordSeparator(bufferLine.get(startCol - 1))) {
-        const char = bufferLine.get(startCol - 1);
-        if (char[CHAR_DATA_WIDTH_INDEX] === 0) {
+      while (startCol > 0 && startIndex > 0 && !this._isCharWordSeparator(bufferLine.loadCell(startCol - 1, this._workCell))) {
+        bufferLine.loadCell(startCol - 1, this._workCell);
+        const length = this._workCell.getChars().length;
+        if (this._workCell.getWidth() === 0) {
          // If the next character is a wide char, record it and skip the column
          leftWideCharCount++;
          startCol--;
-        } else if (char[CHAR_DATA_CHAR_INDEX].length > 1) {
+        } else if (length > 1) {
          // If the next character's string is longer than 1 char (eg. emoji),
          // adjust the index
-          leftLongCharOffset += char[CHAR_DATA_CHAR_INDEX].length - 1;
-          startIndex -= char[CHAR_DATA_CHAR_INDEX].length - 1;
+          leftLongCharOffset += length - 1;
+          startIndex -= length - 1;
        }
        startIndex--;
        startCol--;
      }
-      while (endCol < bufferLine.length && endIndex + 1 < line.length && !this._isCharWordSeparator(bufferLine.get(endCol + 1))) {
-        const char = bufferLine.get(endCol + 1);
-        if (char[CHAR_DATA_WIDTH_INDEX] === 2) {
+      while (endCol < bufferLine.length && endIndex + 1 < line.length && !this._isCharWordSeparator(bufferLine.loadCell(endCol + 1, this._workCell))) {
+        bufferLine.loadCell(endCol + 1, this._workCell);
+        const length = this._workCell.getChars().length;
+        if (this._workCell.getWidth() === 2) {
          // If the next character is a wide char, record it and skip the column
          rightWideCharCount++;
          endCol++;
-        } else if (char[CHAR_DATA_CHAR_INDEX].length > 1) {
+        } else if (length > 1) {
          // If the next character's string is longer than 1 char (eg. emoji),
          // adjust the index
-          rightLongCharOffset += char[CHAR_DATA_CHAR_INDEX].length - 1;
-          endIndex += char[CHAR_DATA_CHAR_INDEX].length - 1;
+          rightLongCharOffset += length - 1;
+          endIndex += length - 1;
        }
        endIndex++;
        endCol++;
@@ -809,9 +822,9 @@ export class SelectionManager extends EventEmitter implements ISelectionManager

    // Recurse upwards if the line is wrapped and the word wraps to the above line
    if (followWrappedLinesAbove) {
-      if (start === 0 && bufferLine.get(0)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+      if (start === 0 && bufferLine.getCodePoint(0) !== 32 /*' '*/) {
        const previousBufferLine = this._buffer.lines.get(coords[1] - 1);
-        if (previousBufferLine && bufferLine.isWrapped && previousBufferLine.get(this._terminal.cols - 1)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+        if (previousBufferLine && bufferLine.isWrapped && previousBufferLine.getCodePoint(this._terminal.cols - 1) !== 32 /*' '*/) {
          const previousLineWordPosition = this._getWordAt([this._terminal.cols - 1, coords[1] - 1], false, true, false);
          if (previousLineWordPosition) {
            const offset = this._terminal.cols - previousLineWordPosition.start;
@@ -824,9 +837,9 @@ export class SelectionManager extends EventEmitter implements ISelectionManager

    // Recurse downwards if the line is wrapped and the word wraps to the next line
    if (followWrappedLinesBelow) {
-      if (start + length === this._terminal.cols && bufferLine.get(this._terminal.cols - 1)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+      if (start + length === this._terminal.cols && bufferLine.getCodePoint(this._terminal.cols - 1) !== 32 /*' '*/) {
        const nextBufferLine = this._buffer.lines.get(coords[1] + 1);
-        if (nextBufferLine && nextBufferLine.isWrapped && nextBufferLine.get(0)[CHAR_DATA_CODE_INDEX] !== 32 /*' '*/) {
+        if (nextBufferLine && nextBufferLine.isWrapped && nextBufferLine.getCodePoint(0) !== 32 /*' '*/) {
          const nextLineWordPosition = this._getWordAt([0, coords[1] + 1], false, false, true);
          if (nextLineWordPosition) {
            length += nextLineWordPosition.length;
@@ -889,13 +902,13 @@ export class SelectionManager extends EventEmitter implements ISelectionManager
   * word logic.
   * @param char The character to check.
   */
-  private _isCharWordSeparator(charData: CharData): boolean {
+  private _isCharWordSeparator(cell: CellData): boolean {
    // Zero width characters are never separators as they are always to the
    // right of wide characters
-    if (charData[CHAR_DATA_WIDTH_INDEX] === 0) {
+    if (cell.getWidth() === 0) {
      return false;
    }
-    return WORD_SEPARATORS.indexOf(charData[CHAR_DATA_CHAR_INDEX]) >= 0;
+    return WORD_SEPARATORS.indexOf(cell.getChars()) >= 0;
  }

  /**
@@ -7,7 +7,7 @@ import { assert } from 'chai';
 import { ITerminal } from './Types';
 import { SelectionModel } from './SelectionModel';
 import { BufferSet } from './BufferSet';
-import { MockTerminal } from './utils/TestUtils.test';
+import { MockTerminal } from './TestUtils.test';

 class TestSelectionModel extends SelectionModel {
  constructor(
@@ -23,8 +23,8 @@ describe('SelectionManager', () => {

  beforeEach(() => {
    terminal = new MockTerminal();
-    terminal.cols = 80;
-    terminal.rows = 2;
+    (terminal as any).cols = 80;
+    (terminal as any).rows = 2;
    terminal.options.scrollback = 10;
    terminal.buffers = new BufferSet(terminal);
    terminal.buffer = terminal.buffers.active;
@@ -12,7 +12,19 @@ import { ITerminal, ISoundManager } from './Types';
 export const DEFAULT_BELL_SOUND = 'data:audio/wav;base64,UklGRigBAABXQVZFZm10IBAAAAABAAEARKwAAIhYAQACABAAZGF0YQQBAADpAFgCwAMlBZoG/wdmCcoKRAypDQ8PbRDBEQQTOxRtFYcWlBePGIUZXhoiG88bcBz7HHIdzh0WHlMeZx51HmkeUx4WHs8dah0AHXwc3hs9G4saxRnyGBIYGBcQFv8U4RPAEoYRQBACD70NWwwHC6gJOwjWBloF7gOBAhABkf8b/qv8R/ve+Xf4Ife79W/0JfPZ8Z/wde9N7ijtE+wU6xvqM+lb6H7nw+YX5mrlxuQz5Mzje+Ma49fioeKD4nXiYeJy4pHitOL04j/jn+MN5IPkFOWs5U3mDefM55/ogOl36m7rdOyE7abuyu8D8Unyj/Pg9D/2qfcb+Yn6/vuK/Qj/lAAlAg==';

 export class SoundManager implements ISoundManager {
-  private _audioContext: AudioContext;
+  private static _audioContext: AudioContext;
+
+  static get audioContext(): AudioContext | null {
+    if (!SoundManager._audioContext) {
+      const audioContextCtor: typeof AudioContext = (<any>window).AudioContext || (<any>window).webkitAudioContext;
+      if (!audioContextCtor) {
+        console.warn('Web Audio API is not supported by this browser. Consider upgrading to the latest version');
+        return null;
+      }
+      SoundManager._audioContext = new audioContextCtor();
+    }
+    return SoundManager._audioContext;
+  }

  constructor(
    private _terminal: ITerminal
@@ -20,22 +32,16 @@ export class SoundManager implements ISoundManager {
  }

  public playBellSound(): void {
-    const audioContextCtor: typeof AudioContext = (<any>window).AudioContext || (<any>window).webkitAudioContext;
-    if (!this._audioContext && audioContextCtor) {
-      this._audioContext = new audioContextCtor();
-    }
-
-    if (this._audioContext) {
-      const bellAudioSource = this._audioContext.createBufferSource();
-      const context = this._audioContext;
-      this._audioContext.decodeAudioData(this._base64ToArrayBuffer(this._removeMimeType(this._terminal.options.bellSound)), (buffer) => {
-        bellAudioSource.buffer = buffer;
-        bellAudioSource.connect(context.destination);
-        bellAudioSource.start(0);
-      });
-    } else {
-      console.warn('Sorry, but the Web Audio API is not supported by your browser. Please, consider upgrading to the latest version');
+    const ctx = SoundManager.audioContext;
+    if (!ctx) {
+      return;
    }
+    const bellAudioSource = ctx.createBufferSource();
+    ctx.decodeAudioData(this._base64ToArrayBuffer(this._removeMimeType(this._terminal.options.bellSound)), (buffer) => {
+      bellAudioSource.buffer = buffer;
+      bellAudioSource.connect(ctx.destination);
+      bellAudioSource.start(0);
+    });
  }

  private _base64ToArrayBuffer(base64: string): ArrayBuffer {
@@ -13,8 +13,9 @@ import * as path from 'path';
 import * as pty from 'node-pty';
 import { assert } from 'chai';
 import { Terminal } from './Terminal';
-import { CHAR_DATA_CHAR_INDEX } from './Buffer';
+import { WHITESPACE_CELL_CHAR } from './Buffer';
 import { IViewport } from './Types';
+import { CellData } from './BufferLine';

 class TestTerminal extends Terminal {
  innerWrite(): void { this._innerWrite(); }
@@ -67,7 +68,7 @@ function terminalToString(term: Terminal): string {
  for (let line = term.buffer.ybase; line < term.buffer.ybase + term.rows; line++) {
    lineText = '';
    for (let cell = 0; cell < term.cols; ++cell) {
-      lineText += term.buffer.lines.get(line).get(cell)[CHAR_DATA_CHAR_INDEX];
+      lineText += term.buffer.lines.get(line).loadCell(cell, new CellData()).getChars() || WHITESPACE_CELL_CHAR;
    }
    // rtrim empty cells as xterm does
    lineText = lineText.replace(/\s+$/, '');
@@ -5,9 +5,9 @@

 import { assert, expect } from 'chai';
 import { Terminal } from './Terminal';
-import { MockViewport, MockCompositionHelper, MockRenderer } from './utils/TestUtils.test';
-import { CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, DEFAULT_ATTR } from './Buffer';
-import { BufferLine } from './BufferLine';
+import { MockViewport, MockCompositionHelper, MockRenderer } from './TestUtils.test';
+import { DEFAULT_ATTR_DATA } from './Buffer';
+import { CellData } from './BufferLine';

 const INIT_COLS = 80;
 const INIT_ROWS = 24;
@@ -17,7 +17,7 @@ class TestTerminal extends Terminal {
  public keyPress(ev: any): boolean { return this._keyPress(ev); }
 }

-describe('term.js addons', () => {
+describe('xterm.js', () => {
  let term: TestTerminal;
  const termOptions = {
    cols: INIT_COLS,
@@ -68,6 +68,81 @@ describe('term.js addons', () => {
    });
  });

+  describe('events', () => {
+    it('should fire the onData evnet', (done) => {
+      term.onData(() => done());
+      term.handler('fake');
+    });
+    it('should fire the onCursorMove event', (done) => {
+      term.on('cursormove', () => done());
+      term.write('foo');
+    });
+    it('should fire the onLineFeed event', (done) => {
+      term.on('linefeed', () => done());
+      term.write('\n');
+    });
+    it('should fire a scroll event when scrollback is created', (done) => {
+      term.on('scroll', () => done());
+      term.write('\n'.repeat(INIT_ROWS));
+    });
+    it('should fire a scroll event when scrollback is cleared', (done) => {
+      term.write('\n'.repeat(INIT_ROWS));
+      term.on('scroll', () => done());
+      term.clear();
+    });
+    it('should fire a key event after a keypress DOM event', (done) => {
+      term.onKey(e => {
+        assert.equal(typeof e.key, 'string');
+        expect(e.domEvent).to.be.an.instanceof(Object);
+        done();
+      });
+      const evKeyPress = <KeyboardEvent>{
+        preventDefault: () => { },
+        stopPropagation: () => { },
+        type: 'keypress',
+        keyCode: 13
+      };
+      term.keyPress(evKeyPress);
+    });
+    it('should fire a key event after a keydown DOM event', (done) => {
+      term.onKey(e => {
+        assert.equal(typeof e.key, 'string');
+        expect(e.domEvent).to.be.an.instanceof(Object);
+        done();
+      });
+      const evKeyDown = <KeyboardEvent>{
+        preventDefault: () => { },
+        stopPropagation: () => { },
+        type: 'keydown',
+        keyCode: 13
+      };
+      term.keyDown(evKeyDown);
+    });
+    it('should fire the onResize event', (done) => {
+      term.onResize(e => {
+        expect(e).to.have.keys(['cols', 'rows']);
+        assert.equal(typeof e.cols, 'number');
+        assert.equal(typeof e.rows, 'number');
+        done();
+      });
+      term.resize(1, 1);
+    });
+    it('should fire the onScroll event', (done) => {
+      term.onScroll(e => {
+        assert.equal(typeof e, 'number');
+        done();
+      });
+      term.scroll();
+    });
+    it('should fire the onTitleChange event', (done) => {
+      term.onTitleChange(e => {
+        assert.equal(e, 'title');
+        done();
+      });
+      term.handleTitle('title');
+    });
+  });
+
  describe('on', () => {
    beforeEach(() => {
      term.on('key', () => { });
@@ -85,6 +160,40 @@ describe('term.js addons', () => {
      });
    });

+    describe('cursormove', () => {
+      it('should emit a cursormove event', (done) => {
+        term.on('cursormove', () => {
+          done();
+        });
+        term.write('foo');
+      });
+    });
+
+    describe('linefeed', () => {
+      it('should emit a linefeed event', (done) => {
+        term.on('linefeed', () => {
+          done();
+        });
+        term.write('\n');
+      });
+    });
+
+    describe('scroll', () => {
+      it('should emit a scroll event when scrollback is created', (done) => {
+        term.on('scroll', () => {
+          done();
+        });
+        term.write('\n'.repeat(INIT_ROWS));
+      });
+      it('should emit a scroll event when scrollback is cleared', (done) => {
+        term.write('\n'.repeat(INIT_ROWS));
+        term.on('scroll', () => {
+          done();
+        });
+        term.clear();
+      });
+    });
+
    describe(`keypress (including 'key' event)`, () => {
      it('should receive a string and event object', (done) => {
        let steps = 0;
@@ -228,7 +337,7 @@ describe('term.js addons', () => {
  });

  describe('setOption', () => {
-    it('should set the option correctly', () => {
+    it('should set option correctly', () => {
      term.setOption('cursorBlink', true);
      assert.equal(term.options.cursorBlink, true);
      term.setOption('cursorBlink', false);
@@ -260,7 +369,7 @@ describe('term.js addons', () => {
      assert.equal(term.buffer.lines.length, term.rows);
      assert.deepEqual(term.buffer.lines.get(0), promptLine);
      for (let i = 1; i < term.rows; i++) {
-        assert.deepEqual(term.buffer.lines.get(i), BufferLine.blankLine(term.cols, DEFAULT_ATTR));
+        assert.deepEqual(term.buffer.lines.get(i), term.buffer.getBlankLine(DEFAULT_ATTR_DATA));
      }
    });
    it('should clear a buffer larger than rows', () => {
@@ -277,7 +386,7 @@ describe('term.js addons', () => {
      assert.equal(term.buffer.lines.length, term.rows);
      assert.deepEqual(term.buffer.lines.get(0), promptLine);
      for (let i = 1; i < term.rows; i++) {
-        assert.deepEqual(term.buffer.lines.get(i), BufferLine.blankLine(term.cols, DEFAULT_ATTR));
+        assert.deepEqual(term.buffer.lines.get(i), term.buffer.getBlankLine(DEFAULT_ATTR_DATA));
      }
    });
    it('should not break the prompt when cleared twice', () => {
@@ -290,7 +399,7 @@ describe('term.js addons', () => {
      assert.equal(term.buffer.lines.length, term.rows);
      assert.deepEqual(term.buffer.lines.get(0), promptLine);
      for (let i = 1; i < term.rows; i++) {
-        assert.deepEqual(term.buffer.lines.get(i), BufferLine.blankLine(term.cols, DEFAULT_ATTR));
+        assert.deepEqual(term.buffer.lines.get(i), term.buffer.getBlankLine(DEFAULT_ATTR_DATA));
      }
    });
  });
@@ -456,62 +565,62 @@ describe('term.js addons', () => {
    describe('scroll() function', () => {
      describe('when scrollback > 0', () => {
        it('should create a new line and scroll', () => {
-          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(INIT_ROWS - 1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
+          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(INIT_ROWS - 1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
          term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
          term.scroll();
          assert.equal(term.buffer.lines.length, INIT_ROWS + 1);
-          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 1).get(0)[CHAR_DATA_CHAR_INDEX], 'b');
-          assert.equal(term.buffer.lines.get(INIT_ROWS).get(0)[CHAR_DATA_CHAR_INDEX], ' ');
+          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 1).loadCell(0, new CellData()).getChars(), 'b');
+          assert.equal(term.buffer.lines.get(INIT_ROWS).loadCell(0, new CellData()).getChars(), '');
        });

        it('should properly scroll inside a scroll region (scrollTop set)', () => {
-          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
          term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
          term.buffer.scrollTop = 1;
          term.scroll();
          assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
+          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c');
        });

        it('should properly scroll inside a scroll region (scrollBottom set)', () => {
-          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
-          term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX] = 'd';
-          term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX] = 'e';
+          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(3).setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
+          term.buffer.lines.get(4).setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
          term.buffer.y = 3;
          term.buffer.scrollBottom = 3;
          term.scroll();
          assert.equal(term.buffer.lines.length, INIT_ROWS + 1);
-          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a', '\'a\' should be pushed to the scrollback');
-          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'b');
-          assert.equal(term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
-          assert.equal(term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX], 'd');
-          assert.equal(term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(5).get(0)[CHAR_DATA_CHAR_INDEX], 'e');
+          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a', '\'a\' should be pushed to the scrollback');
+          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'b');
+          assert.equal(term.buffer.lines.get(2).loadCell(0, new CellData()).getChars(), 'c');
+          assert.equal(term.buffer.lines.get(3).loadCell(0, new CellData()).getChars(), 'd');
+          assert.equal(term.buffer.lines.get(4).loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(5).loadCell(0, new CellData()).getChars(), 'e');
        });

        it('should properly scroll inside a scroll region (scrollTop and scrollBottom set)', () => {
-          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
-          term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX] = 'd';
-          term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX] = 'e';
+          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(3).setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
+          term.buffer.lines.get(4).setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
          term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
          term.buffer.scrollTop = 1;
          term.buffer.scrollBottom = 3;
          term.scroll();
          assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c', '\'b\' should be removed from the buffer');
-          assert.equal(term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX], 'd');
-          assert.equal(term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX], 'e');
+          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c', '\'b\' should be removed from the buffer');
+          assert.equal(term.buffer.lines.get(2).loadCell(0, new CellData()).getChars(), 'd');
+          assert.equal(term.buffer.lines.get(3).loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4).loadCell(0, new CellData()).getChars(), 'e');
        });
      });

@@ -522,65 +631,65 @@ describe('term.js addons', () => {
        });

        it('should create a new line and shift everything up', () => {
-          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(INIT_ROWS - 1).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(INIT_ROWS - 1).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
          term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
          assert.equal(term.buffer.lines.length, INIT_ROWS);
          term.scroll();
          assert.equal(term.buffer.lines.length, INIT_ROWS);
          // 'a' gets pushed out of buffer
-          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'b');
-          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], ' ');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 2).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
-          assert.equal(term.buffer.lines.get(INIT_ROWS - 1).get(0)[CHAR_DATA_CHAR_INDEX], ' ');
+          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'b');
+          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), '');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 2).loadCell(0, new CellData()).getChars(), 'c');
+          assert.equal(term.buffer.lines.get(INIT_ROWS - 1).loadCell(0, new CellData()).getChars(), '');
        });

        it('should properly scroll inside a scroll region (scrollTop set)', () => {
-          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
+          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
          term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
          term.buffer.scrollTop = 1;
          term.scroll();
          assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
+          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c');
        });

        it('should properly scroll inside a scroll region (scrollBottom set)', () => {
-          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
-          term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX] = 'd';
-          term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX] = 'e';
+          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(3).setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
+          term.buffer.lines.get(4).setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
          term.buffer.y = 3;
          term.buffer.scrollBottom = 3;
          term.scroll();
          assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'b');
-          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c');
-          assert.equal(term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX], 'd');
-          assert.equal(term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX], 'e');
+          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'b');
+          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c');
+          assert.equal(term.buffer.lines.get(2).loadCell(0, new CellData()).getChars(), 'd');
+          assert.equal(term.buffer.lines.get(3).loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4).loadCell(0, new CellData()).getChars(), 'e');
        });

        it('should properly scroll inside a scroll region (scrollTop and scrollBottom set)', () => {
-          term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX] = 'a';
-          term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX] = 'b';
-          term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX] = 'c';
-          term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX] = 'd';
-          term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX] = 'e';
+          term.buffer.lines.get(0).setCell(0, CellData.fromCharData([0, 'a', 0, 'a'.charCodeAt(0)]));
+          term.buffer.lines.get(1).setCell(0, CellData.fromCharData([0, 'b', 0, 'b'.charCodeAt(0)]));
+          term.buffer.lines.get(2).setCell(0, CellData.fromCharData([0, 'c', 0, 'c'.charCodeAt(0)]));
+          term.buffer.lines.get(3).setCell(0, CellData.fromCharData([0, 'd', 0, 'd'.charCodeAt(0)]));
+          term.buffer.lines.get(4).setCell(0, CellData.fromCharData([0, 'e', 0, 'e'.charCodeAt(0)]));
          term.buffer.y = INIT_ROWS - 1; // Move cursor to last line
          term.buffer.scrollTop = 1;
          term.buffer.scrollBottom = 3;
          term.scroll();
          assert.equal(term.buffer.lines.length, INIT_ROWS);
-          assert.equal(term.buffer.lines.get(0).get(0)[CHAR_DATA_CHAR_INDEX], 'a');
-          assert.equal(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX], 'c', '\'b\' should be removed from the buffer');
-          assert.equal(term.buffer.lines.get(2).get(0)[CHAR_DATA_CHAR_INDEX], 'd');
-          assert.equal(term.buffer.lines.get(3).get(0)[CHAR_DATA_CHAR_INDEX], ' ', 'a blank line should be added at scrollBottom\'s index');
-          assert.equal(term.buffer.lines.get(4).get(0)[CHAR_DATA_CHAR_INDEX], 'e');
+          assert.equal(term.buffer.lines.get(0).loadCell(0, new CellData()).getChars(), 'a');
+          assert.equal(term.buffer.lines.get(1).loadCell(0, new CellData()).getChars(), 'c', '\'b\' should be removed from the buffer');
+          assert.equal(term.buffer.lines.get(2).loadCell(0, new CellData()).getChars(), 'd');
+          assert.equal(term.buffer.lines.get(3).loadCell(0, new CellData()).getChars(), '', 'a blank line should be added at scrollBottom\'s index');
+          assert.equal(term.buffer.lines.get(4).loadCell(0, new CellData()).getChars(), 'e');
        });
      });
    });
@@ -771,116 +880,126 @@ describe('term.js addons', () => {
    it('2 characters per cell', function (): void {
      this.timeout(10000);  // This is needed because istanbul patches code and slows it down
      const high = String.fromCharCode(0xD800);
+      const cell = new CellData();
      for (let i = 0xDC00; i <= 0xDCFF; ++i) {
        term.write(high + String.fromCharCode(i));
-        const tchar = term.buffer.lines.get(0).get(0);
-        expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
-        expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
-        expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-        expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
+        const tchar = term.buffer.lines.get(0).loadCell(0, cell);
+        expect(tchar.getChars()).eql(high + String.fromCharCode(i));
+        expect(tchar.getChars().length).eql(2);
+        expect(tchar.getWidth()).eql(1);
+        expect(term.buffer.lines.get(0).loadCell(1, cell).getChars()).eql('');
        term.reset();
      }
    });
    it('2 characters at last cell', () => {
      const high = String.fromCharCode(0xD800);
+      const cell = new CellData();
      for (let i = 0xDC00; i <= 0xDCFF; ++i) {
        term.buffer.x = term.cols - 1;
        term.write(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0).get(term.buffer.x - 1)[CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0).get(term.buffer.x - 1)[CHAR_DATA_CHAR_INDEX].length).eql(2);
-        expect(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX]).eql(' ');
+        expect(term.buffer.lines.get(0).loadCell(term.buffer.x - 1, cell).getChars()).eql(high + String.fromCharCode(i));
+        expect(term.buffer.lines.get(0).loadCell(term.buffer.x - 1, cell).getChars().length).eql(2);
+        expect(term.buffer.lines.get(1).loadCell(0, cell).getChars()).eql('');
        term.reset();
      }
    });
    it('2 characters per cell over line end with autowrap', () => {
      const high = String.fromCharCode(0xD800);
+      const cell = new CellData();
      for (let i = 0xDC00; i <= 0xDCFF; ++i) {
        term.buffer.x = term.cols - 1;
        term.wraparoundMode = true;
        term.write('a' + high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX]).eql('a');
-        expect(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
-        expect(term.buffer.lines.get(1).get(0)[CHAR_DATA_CHAR_INDEX].length).eql(2);
-        expect(term.buffer.lines.get(1).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
+        expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars()).eql('a');
+        expect(term.buffer.lines.get(1).loadCell(0, cell).getChars()).eql(high + String.fromCharCode(i));
+        expect(term.buffer.lines.get(1).loadCell(0, cell).getChars().length).eql(2);
+        expect(term.buffer.lines.get(1).loadCell(1, cell).getChars()).eql('');
        term.reset();
      }
    });
    it('2 characters per cell over line end without autowrap', () => {
      const high = String.fromCharCode(0xD800);
+      const cell = new CellData();
      for (let i = 0xDC00; i <= 0xDCFF; ++i) {
        term.buffer.x = term.cols - 1;
        term.wraparoundMode = false;
        term.write('a' + high + String.fromCharCode(i));
        // auto wraparound mode should cut off the rest of the line
-        expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX]).eql('a');
-        expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX].length).eql(1);
-        expect(term.buffer.lines.get(1).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
+        expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars()).eql('a');
+        expect(term.buffer.lines.get(0).loadCell(term.cols - 1, cell).getChars().length).eql(1);
+        expect(term.buffer.lines.get(1).loadCell(1, cell).getChars()).eql('');
        term.reset();
      }
    });
    it('splitted surrogates', () => {
      const high = String.fromCharCode(0xD800);
+      const cell = new CellData();
      for (let i = 0xDC00; i <= 0xDCFF; ++i) {
        term.write(high);
        term.write(String.fromCharCode(i));
-        const tchar = term.buffer.lines.get(0).get(0);
-        expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(high + String.fromCharCode(i));
-        expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
-        expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-        expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
+        const tchar = term.buffer.lines.get(0).loadCell(0, cell);
+        expect(tchar.getChars()).eql(high + String.fromCharCode(i));
+        expect(tchar.getChars().length).eql(2);
+        expect(tchar.getWidth()).eql(1);
+        expect(term.buffer.lines.get(0).loadCell(1, cell).getChars()).eql('');
        term.reset();
      }
    });
  });

  describe('unicode - combining characters', () => {
+    const cell = new CellData();
    it('café', () => {
      term.write('cafe\u0301');
-      expect(term.buffer.lines.get(0).get(3)[CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
-      expect(term.buffer.lines.get(0).get(3)[CHAR_DATA_CHAR_INDEX].length).eql(2);
-      expect(term.buffer.lines.get(0).get(3)[CHAR_DATA_WIDTH_INDEX]).eql(1);
+      term.buffer.lines.get(0).loadCell(3, cell);
+      expect(cell.getChars()).eql('e\u0301');
+      expect(cell.getChars().length).eql(2);
+      expect(cell.getWidth()).eql(1);
    });
    it('café - end of line', () => {
      term.buffer.x = term.cols - 1 - 3;
      term.write('cafe\u0301');
-      expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
-      expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_CHAR_INDEX].length).eql(2);
-      expect(term.buffer.lines.get(0).get(term.cols - 1)[CHAR_DATA_WIDTH_INDEX]).eql(1);
-      expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_CHAR_INDEX]).eql(' ');
-      expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_CHAR_INDEX].length).eql(1);
-      expect(term.buffer.lines.get(0).get(1)[CHAR_DATA_WIDTH_INDEX]).eql(1);
+      term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
+      expect(cell.getChars()).eql('e\u0301');
+      expect(cell.getChars().length).eql(2);
+      expect(cell.getWidth()).eql(1);
+      term.buffer.lines.get(0).loadCell(1, cell);
+      expect(cell.getChars()).eql('');
+      expect(cell.getChars().length).eql(0);
+      expect(cell.getWidth()).eql(1);
    });
    it('multiple combined é', () => {
      term.wraparoundMode = true;
      term.write(Array(100).join('e\u0301'));
      for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0).get(i);
-        expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
-        expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
-        expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
+        term.buffer.lines.get(0).loadCell(i, cell);
+        expect(cell.getChars()).eql('e\u0301');
+        expect(cell.getChars().length).eql(2);
+        expect(cell.getWidth()).eql(1);
      }
-      const tchar = term.buffer.lines.get(1).get(0);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('e\u0301');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
+      term.buffer.lines.get(1).loadCell(0, cell);
+      expect(cell.getChars()).eql('e\u0301');
+      expect(cell.getChars().length).eql(2);
+      expect(cell.getWidth()).eql(1);
    });
    it('multiple surrogate with combined', () => {
      term.wraparoundMode = true;
      term.write(Array(100).join('\uD800\uDC00\u0301'));
      for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0).get(i);
-        expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\uD800\uDC00\u0301');
-        expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
-        expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
+        term.buffer.lines.get(0).loadCell(i, cell);
+        expect(cell.getChars()).eql('\uD800\uDC00\u0301');
+        expect(cell.getChars().length).eql(3);
+        expect(cell.getWidth()).eql(1);
      }
-      const tchar = term.buffer.lines.get(1).get(0);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\uD800\uDC00\u0301');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
+      term.buffer.lines.get(1).loadCell(0, cell);
+      expect(cell.getChars()).eql('\uD800\uDC00\u0301');
+      expect(cell.getChars().length).eql(3);
+      expect(cell.getWidth()).eql(1);
    });
  });

  describe('unicode - fullwidth characters', () => {
+    const cell = new CellData();
    it('cursor movement even', () => {
      expect(term.buffer.x).eql(0);
      term.write('￥');
@@ -896,140 +1015,141 @@ describe('term.js addons', () => {
      term.wraparoundMode = true;
      term.write(Array(50).join('￥'));
      for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0).get(i);
+        term.buffer.lines.get(0).loadCell(i, cell);
        if (i % 2) {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(0);
+          expect(cell.getChars()).eql('');
+          expect(cell.getChars().length).eql(0);
+          expect(cell.getWidth()).eql(0);
        } else {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+          expect(cell.getChars()).eql('￥');
+          expect(cell.getChars().length).eql(1);
+          expect(cell.getWidth()).eql(2);
        }
      }
-      const tchar = term.buffer.lines.get(1).get(0);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+      term.buffer.lines.get(1).loadCell(0, cell);
+      expect(cell.getChars()).eql('￥');
+      expect(cell.getChars().length).eql(1);
+      expect(cell.getWidth()).eql(2);
    });
    it('line of ￥ odd', () => {
      term.wraparoundMode = true;
      term.buffer.x = 1;
      term.write(Array(50).join('￥'));
      for (let i = 1; i < term.cols - 1; ++i) {
-        const tchar = term.buffer.lines.get(0).get(i);
+        term.buffer.lines.get(0).loadCell(i, cell);
        if (!(i % 2)) {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(0);
+          expect(cell.getChars()).eql('');
+          expect(cell.getChars().length).eql(0);
+          expect(cell.getWidth()).eql(0);
        } else {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+          expect(cell.getChars()).eql('￥');
+          expect(cell.getChars().length).eql(1);
+          expect(cell.getWidth()).eql(2);
        }
      }
-      let tchar = term.buffer.lines.get(0).get(term.cols - 1);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(' ');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-      tchar = term.buffer.lines.get(1).get(0);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+      term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
+      expect(cell.getChars()).eql('');
+      expect(cell.getChars().length).eql(0);
+      expect(cell.getWidth()).eql(1);
+      term.buffer.lines.get(1).loadCell(0, cell);
+      expect(cell.getChars()).eql('￥');
+      expect(cell.getChars().length).eql(1);
+      expect(cell.getWidth()).eql(2);
    });
    it('line of ￥ with combining odd', () => {
      term.wraparoundMode = true;
      term.buffer.x = 1;
      term.write(Array(50).join('￥\u0301'));
      for (let i = 1; i < term.cols - 1; ++i) {
-        const tchar = term.buffer.lines.get(0).get(i);
+        term.buffer.lines.get(0).loadCell(i, cell);
        if (!(i % 2)) {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(0);
+          expect(cell.getChars()).eql('');
+          expect(cell.getChars().length).eql(0);
+          expect(cell.getWidth()).eql(0);
        } else {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥\u0301');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+          expect(cell.getChars()).eql('￥\u0301');
+          expect(cell.getChars().length).eql(2);
+          expect(cell.getWidth()).eql(2);
        }
      }
-      let tchar = term.buffer.lines.get(0).get(term.cols - 1);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(' ');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-      tchar = term.buffer.lines.get(1).get(0);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥\u0301');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+      term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
+      expect(cell.getChars()).eql('');
+      expect(cell.getChars().length).eql(0);
+      expect(cell.getWidth()).eql(1);
+      term.buffer.lines.get(1).loadCell(0, cell);
+      expect(cell.getChars()).eql('￥\u0301');
+      expect(cell.getChars().length).eql(2);
+      expect(cell.getWidth()).eql(2);
    });
    it('line of ￥ with combining even', () => {
      term.wraparoundMode = true;
      term.write(Array(50).join('￥\u0301'));
      for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0).get(i);
+        term.buffer.lines.get(0).loadCell(i, cell);
        if (i % 2) {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(0);
+          expect(cell.getChars()).eql('');
+          expect(cell.getChars().length).eql(0);
+          expect(cell.getWidth()).eql(0);
        } else {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥\u0301');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+          expect(cell.getChars()).eql('￥\u0301');
+          expect(cell.getChars().length).eql(2);
+          expect(cell.getWidth()).eql(2);
        }
      }
-      const tchar = term.buffer.lines.get(1).get(0);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('￥\u0301');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(2);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+      term.buffer.lines.get(1).loadCell(0, cell);
+      expect(cell.getChars()).eql('￥\u0301');
+      expect(cell.getChars().length).eql(2);
+      expect(cell.getWidth()).eql(2);
    });
    it('line of surrogate fullwidth with combining odd', () => {
      term.wraparoundMode = true;
      term.buffer.x = 1;
      term.write(Array(50).join('\ud843\ude6d\u0301'));
      for (let i = 1; i < term.cols - 1; ++i) {
-        const tchar = term.buffer.lines.get(0).get(i);
+        term.buffer.lines.get(0).loadCell(i, cell);
        if (!(i % 2)) {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(0);
+          expect(cell.getChars()).eql('');
+          expect(cell.getChars().length).eql(0);
+          expect(cell.getWidth()).eql(0);
        } else {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\ud843\ude6d\u0301');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+          expect(cell.getChars()).eql('\ud843\ude6d\u0301');
+          expect(cell.getChars().length).eql(3);
+          expect(cell.getWidth()).eql(2);
        }
      }
-      let tchar = term.buffer.lines.get(0).get(term.cols - 1);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql(' ');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(1);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(1);
-      tchar = term.buffer.lines.get(1).get(0);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\ud843\ude6d\u0301');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+      term.buffer.lines.get(0).loadCell(term.cols - 1, cell);
+      expect(cell.getChars()).eql('');
+      expect(cell.getChars().length).eql(0);
+      expect(cell.getWidth()).eql(1);
+      term.buffer.lines.get(1).loadCell(0, cell);
+      expect(cell.getChars()).eql('\ud843\ude6d\u0301');
+      expect(cell.getChars().length).eql(3);
+      expect(cell.getWidth()).eql(2);
    });
    it('line of surrogate fullwidth with combining even', () => {
      term.wraparoundMode = true;
      term.write(Array(50).join('\ud843\ude6d\u0301'));
      for (let i = 0; i < term.cols; ++i) {
-        const tchar = term.buffer.lines.get(0).get(i);
+        term.buffer.lines.get(0).loadCell(i, cell);
        if (i % 2) {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(0);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(0);
+          expect(cell.getChars()).eql('');
+          expect(cell.getChars().length).eql(0);
+          expect(cell.getWidth()).eql(0);
        } else {
-          expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\ud843\ude6d\u0301');
-          expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
-          expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+          expect(cell.getChars()).eql('\ud843\ude6d\u0301');
+          expect(cell.getChars().length).eql(3);
+          expect(cell.getWidth()).eql(2);
        }
      }
-      const tchar = term.buffer.lines.get(1).get(0);
-      expect(tchar[CHAR_DATA_CHAR_INDEX]).eql('\ud843\ude6d\u0301');
-      expect(tchar[CHAR_DATA_CHAR_INDEX].length).eql(3);
-      expect(tchar[CHAR_DATA_WIDTH_INDEX]).eql(2);
+      term.buffer.lines.get(1).loadCell(0, cell);
+      expect(cell.getChars()).eql('\ud843\ude6d\u0301');
+      expect(cell.getChars().length).eql(3);
+      expect(cell.getWidth()).eql(2);
    });
  });

  describe('insert mode', () => {
+    const cell = new CellData();
    it('halfwidth - all', () => {
      term.write(Array(9).join('0123456789').slice(-80));
      term.buffer.x = 10;
@@ -1037,10 +1157,10 @@ describe('term.js addons', () => {
      term.insertMode = true;
      term.write('abcde');
      expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0).get(10)[CHAR_DATA_CHAR_INDEX]).eql('a');
-      expect(term.buffer.lines.get(0).get(14)[CHAR_DATA_CHAR_INDEX]).eql('e');
-      expect(term.buffer.lines.get(0).get(15)[CHAR_DATA_CHAR_INDEX]).eql('0');
-      expect(term.buffer.lines.get(0).get(79)[CHAR_DATA_CHAR_INDEX]).eql('4');
+      expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('a');
+      expect(term.buffer.lines.get(0).loadCell(14, cell).getChars()).eql('e');
+      expect(term.buffer.lines.get(0).loadCell(15, cell).getChars()).eql('0');
+      expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('4');
    });
    it('fullwidth - insert', () => {
      term.write(Array(9).join('0123456789').slice(-80));
@@ -1049,11 +1169,11 @@ describe('term.js addons', () => {
      term.insertMode = true;
      term.write('￥￥￥');
      expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0).get(10)[CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(term.buffer.lines.get(0).get(11)[CHAR_DATA_CHAR_INDEX]).eql('');
-      expect(term.buffer.lines.get(0).get(14)[CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(term.buffer.lines.get(0).get(15)[CHAR_DATA_CHAR_INDEX]).eql('');
-      expect(term.buffer.lines.get(0).get(79)[CHAR_DATA_CHAR_INDEX]).eql('3');
+      expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('￥');
+      expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('');
+      expect(term.buffer.lines.get(0).loadCell(14, cell).getChars()).eql('￥');
+      expect(term.buffer.lines.get(0).loadCell(15, cell).getChars()).eql('');
+      expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('3');
    });
    it('fullwidth - right border', () => {
      term.write(Array(41).join('￥'));
@@ -1062,14 +1182,14 @@ describe('term.js addons', () => {
      term.insertMode = true;
      term.write('a');
      expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0).get(10)[CHAR_DATA_CHAR_INDEX]).eql('a');
-      expect(term.buffer.lines.get(0).get(11)[CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(term.buffer.lines.get(0).get(79)[CHAR_DATA_CHAR_INDEX]).eql(' ');  // fullwidth char got replaced
+      expect(term.buffer.lines.get(0).loadCell(10, cell).getChars()).eql('a');
+      expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('￥');
+      expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('');  // fullwidth char got replaced
      term.write('b');
      expect(term.buffer.lines.get(0).length).eql(term.cols);
-      expect(term.buffer.lines.get(0).get(11)[CHAR_DATA_CHAR_INDEX]).eql('b');
-      expect(term.buffer.lines.get(0).get(12)[CHAR_DATA_CHAR_INDEX]).eql('￥');
-      expect(term.buffer.lines.get(0).get(79)[CHAR_DATA_CHAR_INDEX]).eql('');  // empty cell after fullwidth
+      expect(term.buffer.lines.get(0).loadCell(11, cell).getChars()).eql('b');
+      expect(term.buffer.lines.get(0).loadCell(12, cell).getChars()).eql('￥');
+      expect(term.buffer.lines.get(0).loadCell(79, cell).getChars()).eql('');  // empty cell after fullwidth
    });
  });
 });
@@ -21,29 +21,26 @@
 *   http://linux.die.net/man/7/urxvt
 */

-import { IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminalOptions, ITerminal, IBrowser, ILinkifier, ILinkMatcherOptions, CustomKeyEventHandler, LinkMatcherHandler, CharData, CharacterJoinerHandler } from './Types';
-import { IMouseZoneManager } from './ui/Types';
+import { IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminalOptions, ITerminal, IBrowser, ILinkifier, ILinkMatcherOptions, CustomKeyEventHandler, LinkMatcherHandler, CharacterJoinerHandler, IBufferLine, IAttributeData, IMouseZoneManager } from './Types';
 import { IRenderer } from './renderer/Types';
 import { BufferSet } from './BufferSet';
-import { Buffer, MAX_BUFFER_SIZE, DEFAULT_ATTR, NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR } from './Buffer';
+import { Buffer, MAX_BUFFER_SIZE, DEFAULT_ATTR_DATA } from './Buffer';
 import { CompositionHelper } from './CompositionHelper';
 import { EventEmitter } from './common/EventEmitter';
 import { Viewport } from './Viewport';
-import { rightClickHandler, moveTextAreaUnderMouseCursor, pasteHandler, copyHandler } from './handlers/Clipboard';
+import { rightClickHandler, moveTextAreaUnderMouseCursor, pasteHandler, copyHandler } from './Clipboard';
 import { C0 } from './common/data/EscapeSequences';
 import { InputHandler } from './InputHandler';
 import { Renderer } from './renderer/Renderer';
 import { Linkifier } from './Linkifier';
 import { SelectionManager } from './SelectionManager';
-import { CharMeasure } from './ui/CharMeasure';
-import * as Browser from './shared/utils/Browser';
+import { CharMeasure } from './CharMeasure';
+import * as Browser from './common/Platform';
 import { addDisposableDomListener } from './ui/Lifecycle';
 import * as Strings from './Strings';
-import { MouseHelper } from './utils/MouseHelper';
-import { clone } from './utils/Clone';
+import { MouseHelper } from './MouseHelper';
 import { DEFAULT_BELL_SOUND, SoundManager } from './SoundManager';
-import { DEFAULT_ANSI_COLORS } from './renderer/ColorManager';
-import { MouseZoneManager } from './ui/MouseZoneManager';
+import { MouseZoneManager } from './MouseZoneManager';
 import { AccessibilityManager } from './AccessibilityManager';
 import { ScreenDprMonitor } from './ui/ScreenDprMonitor';
 import { ITheme, IMarker, IDisposable } from 'xterm';
@@ -52,7 +49,10 @@ import { DomRenderer } from './renderer/dom/DomRenderer';
 import { IKeyboardEvent } from './common/Types';
 import { evaluateKeyboardEvent } from './core/input/Keyboard';
 import { KeyboardResultType, ICharset } from './core/Types';
-import { BufferLine } from './BufferLine';
+import { clone } from './common/Clone';
+import { EventEmitter2, IEvent } from './common/EventEmitter2';
+import { Attributes } from './BufferLine';
+import { applyWindowsMode } from './WindowsMode';

 // Let it work inside Node.js for automated testing purposes.
 const document = (typeof window !== 'undefined') ? window.document : null;
@@ -65,10 +65,15 @@ const document = (typeof window !== 'undefined') ? window.document : null;
 const WRITE_BUFFER_PAUSE_THRESHOLD = 5;

 /**
- * The number of writes to perform in a single batch before allowing the
- * renderer to catch up with a 0ms setTimeout.
+ * The max number of ms to spend on writes before allowing the renderer to
+ * catch up with a 0ms setTimeout. A value of < 33 to keep us close to
+ * 30fps, and a value of < 16 to try to run at 60fps. Of course, the real FPS
+ * depends on the time it takes for the renderer to draw the frame.
 */
-const WRITE_BATCH_SIZE = 300;
+const WRITE_TIMEOUT_MS = 12;
+
+const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
+const MINIMUM_ROWS = 1;

 /**
 * The set of options that only have an effect when set in the Terminal constructor.
@@ -106,7 +111,8 @@ const DEFAULT_OPTIONS: ITerminalOptions = {
  tabStopWidth: 8,
  theme: null,
  rightClickSelectsWord: Browser.isMac,
-  rendererType: 'canvas'
+  rendererType: 'canvas',
+  windowsMode: false
 };

 export class Terminal extends EventEmitter implements ITerminal, IDisposable, IInputHandlingTerminal {
@@ -169,8 +175,8 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
  private _refreshEnd: number;
  public savedCols: number;

-  public curAttr: number;
-  public savedCurAttr: number;
+  public curAttrData: IAttributeData;
+  private _eraseAttrData: IAttributeData;

  public params: (string | number)[];
  public currentParam: string | number;
@@ -207,10 +213,33 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
  private _accessibilityManager: AccessibilityManager;
  private _screenDprMonitor: ScreenDprMonitor;
  private _theme: ITheme;
+  private _windowsMode: IDisposable | undefined;
+
+  // bufferline to clone/copy from for new blank lines
+  private _blankLine: IBufferLine = null;

  public cols: number;
  public rows: number;

+  private _onCursorMove = new EventEmitter2<void>();
+  public get onCursorMove(): IEvent<void> { return this._onCursorMove.event; }
+  private _onData = new EventEmitter2<string>();
+  public get onData(): IEvent<string> { return this._onData.event; }
+  private _onKey = new EventEmitter2<{ key: string, domEvent: KeyboardEvent }>();
+  public get onKey(): IEvent<{ key: string, domEvent: KeyboardEvent }> { return this._onKey.event; }
+  private _onLineFeed = new EventEmitter2<void>();
+  public get onLineFeed(): IEvent<void> { return this._onLineFeed.event; }
+  private _onRender = new EventEmitter2<{ start: number, end: number }>();
+  public get onRender(): IEvent<{ start: number, end: number }> { return this._onRender.event; }
+  private _onResize = new EventEmitter2<{ cols: number, rows: number }>();
+  public get onResize(): IEvent<{ cols: number, rows: number }> { return this._onResize.event; }
+  private _onScroll = new EventEmitter2<number>();
+  public get onScroll(): IEvent<number> { return this._onScroll.event; }
+  private _onSelectionChange = new EventEmitter2<void>();
+  public get onSelectionChange(): IEvent<void> { return this._onSelectionChange.event; }
+  private _onTitleChange = new EventEmitter2<string>();
+  public get onTitleChange(): IEvent<string> { return this._onTitleChange.event; }
+
  /**
   * Creates a new `Terminal` object.
   *
@@ -229,10 +258,26 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    super();
    this.options = clone(options);
    this._setup();
+
+    // TODO: Remove these in v4
+    // Fire old style events from new emitters
+    this.onCursorMove(() => this.emit('cursormove'));
+    this.onData(e => this.emit('data', e));
+    this.onKey(e => this.emit('key', e.key, e.domEvent));
+    this.onLineFeed(() => this.emit('linefeed'));
+    this.onRender(e => this.emit('refresh', e));
+    this.onResize(e => this.emit('resize', e));
+    this.onSelectionChange(() => this.emit('selection'));
+    this.onScroll(e => this.emit('scroll', e));
+    this.onTitleChange(e => this.emit('title', e));
  }

  public dispose(): void {
    super.dispose();
+    if (this._windowsMode) {
+      this._windowsMode.dispose();
+      this._windowsMode = undefined;
+    }
    this._customKeyEventHandler = null;
    removeTerminalFromCache(this);
    this.handler = () => {};
@@ -261,11 +306,11 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    // TODO: WHy not document.body?
    this._parent = document ? document.body : null;

-    this.cols = this.options.cols;
-    this.rows = this.options.rows;
+    this.cols = Math.max(this.options.cols, MINIMUM_COLS);
+    this.rows = Math.max(this.options.rows, MINIMUM_ROWS);

    if (this.options.handler) {
-      this.on('data', this.options.handler);
+      this.onData(this.options.handler);
    }

    this.cursorState = 0;
@@ -287,7 +332,8 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    // TODO: Can this be just []?
    this.charsets = [null];

-    this.curAttr = DEFAULT_ATTR;
+    this.curAttrData = DEFAULT_ATTR_DATA.clone();
+    this._eraseAttrData = DEFAULT_ATTR_DATA.clone();

    this.params = [];
    this.currentParam = 0;
@@ -300,8 +346,12 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    // this._writeStopped = false;
    this._userScrolling = false;

+    // Register input handler and refire/handle events
    this._inputHandler = new InputHandler(this);
+    this._inputHandler.onCursorMove(() => this._onCursorMove.fire());
+    this._inputHandler.onLineFeed(() => this._onLineFeed.fire());
    this.register(this._inputHandler);
+
    // Reuse renderer if the Terminal is being recreated via a reset call.
    this.renderer = this.renderer || null;
    this.selectionManager = this.selectionManager || null;
@@ -315,6 +365,10 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      this.selectionManager.clearSelection();
      this.selectionManager.initBuffersListeners();
    }
+
+    if (this.options.windowsMode) {
+      this._windowsMode = applyWindowsMode(this);
+    }
  }

  /**
@@ -327,9 +381,10 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
  /**
   * back_color_erase feature for xterm.
   */
-  public eraseAttr(): number {
-    // if (this.is('screen')) return DEFAULT_ATTR;
-    return (DEFAULT_ATTR & ~0x1ff) | (this.curAttr & 0x1ff);
+  public eraseAttrData(): IAttributeData {
+    this._eraseAttrData.bg &= ~(Attributes.CM_MASK | 0xFFFFFF);
+    this._eraseAttrData.bg |= this.curAttrData.bg & ~0xFC000000;
+    return this._eraseAttrData;
  }

  /**
@@ -337,12 +392,12 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
   */
  public focus(): void {
    if (this.textarea) {
-      this.textarea.focus();
+      this.textarea.focus({ preventScroll: true });
    }
  }

  public get isFocused(): boolean {
-    return document.activeElement === this.textarea;
+    return document.activeElement === this.textarea && document.hasFocus();
  }

  /**
@@ -462,6 +517,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
          this.renderer.onResize(this.cols, this.rows);
          this.refresh(0, this.rows - 1);
        }
+        break;
      case 'rendererType':
        if (this.renderer) {
          this.unregister(this.renderer);
@@ -473,6 +529,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
        if (this._theme) {
          this.renderer.setTheme(this._theme);
        }
+        this.mouseHelper.setRenderer(this.renderer);
        break;
      case 'scrollback':
        this.buffers.resize(this.cols, this.rows);
@@ -493,6 +550,18 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
        }
        break;
      case 'tabStopWidth': this.buffers.setupTabStops(); break;
+      case 'windowsMode':
+        if (value) {
+          if (!this._windowsMode) {
+            this._windowsMode = applyWindowsMode(this);
+          }
+        } else {
+          if (this._windowsMode) {
+            this._windowsMode.dispose();
+            this._windowsMode = undefined;
+          }
+        }
+        break;
    }
    // Inform renderer of changes
    if (this.renderer) {
@@ -560,12 +629,12 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      // Firefox doesn't appear to fire the contextmenu event on right click
      this.register(addDisposableDomListener(this.element, 'mousedown', (event: MouseEvent) => {
        if (event.button === 2) {
-          rightClickHandler(event, this.textarea, this.selectionManager, this.options.rightClickSelectsWord);
+          rightClickHandler(event, this, this.selectionManager, this.options.rightClickSelectsWord);
        }
      }));
    } else {
      this.register(addDisposableDomListener(this.element, 'contextmenu', (event: MouseEvent) => {
-        rightClickHandler(event, this.textarea, this.selectionManager, this.options.rightClickSelectsWord);
+        rightClickHandler(event, this, this.selectionManager, this.options.rightClickSelectsWord);
      }));
    }

@@ -577,7 +646,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      // that the regular click event doesn't fire for the middle mouse button.
      this.register(addDisposableDomListener(this.element, 'auxclick', (event: MouseEvent) => {
        if (event.button === 1) {
-          moveTextAreaUnderMouseCursor(event, this.textarea);
+          moveTextAreaUnderMouseCursor(event, this);
        }
      }));
    }
@@ -615,8 +684,8 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    this.register(addDisposableDomListener(this.textarea, 'compositionstart', () => this._compositionHelper.compositionstart()));
    this.register(addDisposableDomListener(this.textarea, 'compositionupdate', (e: CompositionEvent) => this._compositionHelper.compositionupdate(e)));
    this.register(addDisposableDomListener(this.textarea, 'compositionend', () => this._compositionHelper.compositionend()));
-    this.register(this.addDisposableListener('refresh', () => this._compositionHelper.updateCompositionElements()));
-    this.register(this.addDisposableListener('refresh', (data) => this._queueLinkification(data.start, data.end)));
+    this.register(this.onRender(() => this._compositionHelper.updateCompositionElements()));
+    this.register(this.onRender(e => this._queueLinkification(e.start, e.end)));
  }

  /**
@@ -668,7 +737,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II

    this._mouseZoneManager = new MouseZoneManager(this);
    this.register(this._mouseZoneManager);
-    this.register(this.addDisposableListener('scroll', () => this._mouseZoneManager.clearAll()));
+    this.register(this.onScroll(() => this._mouseZoneManager.clearAll()));
    this.linkifier.attachToDom(this._mouseZoneManager);

    this.textarea = document.createElement('textarea');
@@ -701,21 +770,22 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    this.viewport.onThemeChanged(this.renderer.colorManager.colors);
    this.register(this.viewport);

-    this.register(this.addDisposableListener('cursormove', () => this.renderer.onCursorMove()));
-    this.register(this.addDisposableListener('resize', () => this.renderer.onResize(this.cols, this.rows)));
+    this.register(this.onCursorMove(() => this.renderer.onCursorMove()));
+    this.register(this.onResize(() => this.renderer.onResize(this.cols, this.rows)));
    this.register(this.addDisposableListener('blur', () => this.renderer.onBlur()));
    this.register(this.addDisposableListener('focus', () => this.renderer.onFocus()));
    this.register(this.addDisposableListener('dprchange', () => this.renderer.onWindowResize(window.devicePixelRatio)));
    // dprchange should handle this case, we need this as well for browsers that don't support the
    // matchMedia query.
    this.register(addDisposableDomListener(window, 'resize', () => this.renderer.onWindowResize(window.devicePixelRatio)));
-    this.register(this.charMeasure.addDisposableListener('charsizechanged', () => this.renderer.onCharSizeChanged()));
-    this.register(this.renderer.addDisposableListener('resize', (dimensions) => this.viewport.syncScrollArea()));
+    this.register(this.charMeasure.onCharSizeChanged(() => this.renderer.onCharSizeChanged()));
+    this.register(this.renderer.onCanvasResize(() => this.viewport.syncScrollArea()));

    this.selectionManager = new SelectionManager(this, this.charMeasure);
+    this.register(this.selectionManager.onSelectionChange(() => this._onSelectionChange.fire()));
    this.register(addDisposableDomListener(this.element, 'mousedown', (e: MouseEvent) => this.selectionManager.onMouseDown(e)));
-    this.register(this.selectionManager.addDisposableListener('refresh', data => this.renderer.onSelectionChanged(data.start, data.end, data.columnSelectMode)));
-    this.register(this.selectionManager.addDisposableListener('newselection', text => {
+    this.register(this.selectionManager.onRedrawRequest(e => this.renderer.onSelectionChanged(e.start, e.end, e.columnSelectMode)));
+    this.register(this.selectionManager.onLinuxMouseSelection(text => {
      // If there's a new selection, put it into the textarea, focus and select it
      // in order to register it as a selection on the OS. This event is fired
      // only on Linux to enable middle click to paste selection.
@@ -723,13 +793,20 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      this.textarea.focus();
      this.textarea.select();
    }));
-    this.register(this.addDisposableListener('scroll', () => {
+    this.register(this.onScroll(() => {
      this.viewport.syncScrollArea();
      this.selectionManager.refresh();
    }));
    this.register(addDisposableDomListener(this._viewportElement, 'scroll', () => this.selectionManager.refresh()));

    this.mouseHelper = new MouseHelper(this.renderer);
+    // apply mouse event classes set by escape codes before terminal was attached
+    this.element.classList.toggle('enable-mouse-events', this.mouseEvents);
+    if (this.mouseEvents) {
+      this.selectionManager.disable();
+    } else {
+      this.selectionManager.enable();
+    }

    if (this.options.screenReaderMode) {
      // Note that this must be done *after* the renderer is created in order to
@@ -758,6 +835,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      case 'dom': this.renderer = new DomRenderer(this, this.options.theme); break;
      default: throw new Error(`Unrecognized rendererType "${this.options.rendererType}"`);
    }
+    this.renderer.onRender(e => this._onRender.fire(e));
    this.register(this.renderer);
  }

@@ -799,7 +877,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      button = getButton(ev);

      // get mouse coordinates
-      pos = self.mouseHelper.getRawByteCoords(ev, self.screenElement, self.charMeasure, self.options.lineHeight, self.cols, self.rows);
+      pos = self.mouseHelper.getRawByteCoords(ev, self.screenElement, self.charMeasure, self.cols, self.rows);
      if (!pos) return;

      sendEvent(button, pos);
@@ -825,7 +903,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    // ^[[M 3<^[[M@4<^[[M@5<^[[M@6<^[[M@7<^[[M#7<
    function sendMove(ev: MouseEvent): void {
      let button = pressed;
-      const pos = self.mouseHelper.getRawByteCoords(ev, self.screenElement, self.charMeasure, self.options.lineHeight, self.cols, self.rows);
+      const pos = self.mouseHelper.getRawByteCoords(ev, self.screenElement, self.charMeasure, self.cols, self.rows);
      if (!pos) return;

      // buttons marked as motions
@@ -846,17 +924,11 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
        if (ch > 127) ch = 127;
        data.push(ch);
      } else {
-        if (ch === 2047) {
-          data.push(0);
+        if (ch > 2047) {
+          data.push(2047);
          return;
        }
-        if (ch < 127) {
-          data.push(ch);
-        } else {
-          if (ch > 2047) ch = 2047;
-          data.push(0xC0 | (ch >> 6));
-          data.push(0x80 | (ch & 0x3F));
-        }
+        data.push(ch);
      }
    }

@@ -980,7 +1052,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
          : 65;
          break;
        case 'wheel':
-          button = (<WheelEvent>ev).wheelDeltaY > 0
+          button = (<WheelEvent>ev).deltaY < 0
            ? 64
          : 65;
          break;
@@ -1149,9 +1221,9 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
   */
  public updateCursorStyle(ev: KeyboardEvent): void {
    if (this.selectionManager && this.selectionManager.shouldColumnSelect(ev)) {
-      this.element.classList.add('xterm-cursor-crosshair');
+      this.element.classList.add('column-select');
    } else {
-      this.element.classList.remove('xterm-cursor-crosshair');
+      this.element.classList.remove('column-select');
    }
  }

@@ -1169,20 +1241,32 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
   * Scroll the terminal down 1 row, creating a blank line.
   * @param isWrapped Whether the new line is wrapped from the previous line.
   */
-  public scroll(isWrapped?: boolean): void {
-    const newLine = BufferLine.blankLine(this.cols, DEFAULT_ATTR, isWrapped);
+  public scroll(isWrapped: boolean = false): void {
+    let newLine: IBufferLine;
+    newLine = this._blankLine;
+    const eraseAttr = this.eraseAttrData();
+    if (!newLine || newLine.length !== this.cols || newLine.getFg(0) !== eraseAttr.fg || newLine.getBg(0) !== eraseAttr.bg) {
+      newLine = this.buffer.getBlankLine(eraseAttr, isWrapped);
+      this._blankLine = newLine;
+    }
+    newLine.isWrapped = isWrapped;
+
    const topRow = this.buffer.ybase + this.buffer.scrollTop;
    const bottomRow = this.buffer.ybase + this.buffer.scrollBottom;

    if (this.buffer.scrollTop === 0) {
      // Determine whether the buffer is going to be trimmed after insertion.
-      const willBufferBeTrimmed = this.buffer.lines.length === this.buffer.lines.maxLength;
+      const willBufferBeTrimmed = this.buffer.lines.isFull;

      // Insert the line using the fastest method
      if (bottomRow === this.buffer.lines.length - 1) {
-        this.buffer.lines.push(newLine);
+        if (willBufferBeTrimmed) {
+          this.buffer.lines.recycle().copyFrom(newLine);
+        } else {
+          this.buffer.lines.push(newLine.clone());
+        }
      } else {
-        this.buffer.lines.splice(bottomRow + 1, 0, newLine);
+        this.buffer.lines.splice(bottomRow + 1, 0, newLine.clone());
      }

      // Only adjust ybase and ydisp when the buffer is not trimmed
@@ -1204,7 +1288,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      // scrollback, instead we can just shift them in-place.
      const scrollRegionHeight = bottomRow - topRow + 1/*as it's zero-based*/;
      this.buffer.lines.shiftElements(topRow + 1, scrollRegionHeight - 1, -1);
-      this.buffer.lines.set(bottomRow, newLine);
+      this.buffer.lines.set(bottomRow, newLine.clone());
    }

    // Move the viewport to the bottom of the buffer unless the user is
@@ -1217,13 +1301,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    this.updateRange(this.buffer.scrollTop);
    this.updateRange(this.buffer.scrollBottom);

-    /**
-     * This event is emitted whenever the terminal is scrolled.
-     * The one parameter passed is the new y display position.
-     *
-     * @event scroll
-     */
-    this.emit('scroll', this.buffer.ydisp);
+    this._onScroll.fire(this.buffer.ydisp);
  }

  /**
@@ -1252,7 +1330,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    }

    if (!suppressScrollEvent) {
-      this.emit('scroll', this.buffer.ydisp);
+      this._onScroll.fire(this.buffer.ydisp);
    }

    this.refresh(0, this.rows - 1);
@@ -1324,19 +1402,20 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    }
  }

-  protected _innerWrite(): void {
+  protected _innerWrite(bufferOffset: number = 0): void {
    // Ensure the terminal isn't disposed
    if (this._isDisposed) {
      this.writeBuffer = [];
    }

-    const writeBatch = this.writeBuffer.splice(0, WRITE_BATCH_SIZE);
-    while (writeBatch.length > 0) {
-      const data = writeBatch.shift();
+    const startTime = Date.now();
+    while (this.writeBuffer.length > bufferOffset) {
+      const data = this.writeBuffer[bufferOffset];
+      bufferOffset++;

      // If XOFF was sent in order to catch up with the pty process, resume it if
-      // the writeBuffer is empty to allow more data to come in.
-      if (this._xoffSentToCatchUp && writeBatch.length === 0 && this.writeBuffer.length === 0) {
+      // we reached the end of the writeBuffer to allow more data to come in.
+      if (this._xoffSentToCatchUp && this.writeBuffer.length === bufferOffset) {
        this.handler(C0.DC1);
        this._xoffSentToCatchUp = false;
      }
@@ -1354,12 +1433,17 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II

      this.updateRange(this.buffer.y);
      this.refresh(this._refreshStart, this._refreshEnd);
+
+      if (Date.now() - startTime >= WRITE_TIMEOUT_MS) {
+        break;
+      }
    }
-    if (this.writeBuffer.length > 0) {
+    if (this.writeBuffer.length > bufferOffset) {
      // Allow renderer to catch up before processing the next batch
-      setTimeout(() => this._innerWrite(), 0);
+      setTimeout(() => this._innerWrite(bufferOffset), 0);
    } else {
      this._writeInProgress = false;
+      this.writeBuffer = [];
    }
  }

@@ -1377,13 +1461,22 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
   * processed by the terminal and what keys should not.
   * @param customKeyEventHandler The custom KeyboardEvent handler to attach.
   * This is a function that takes a KeyboardEvent, allowing consumers to stop
-   * propogation and/or prevent the default action. The function returns whether
+   * propagation and/or prevent the default action. The function returns whether
   * the event should be processed by xterm.js.
   */
  public attachCustomKeyEventHandler(customKeyEventHandler: CustomKeyEventHandler): void {
    this._customKeyEventHandler = customKeyEventHandler;
  }

+  /** Add handler for CSI escape sequence. See xterm.d.ts for details. */
+  public addCsiHandler(flag: string, callback: (params: number[], collect: string) => boolean): IDisposable {
+    return this._inputHandler.addCsiHandler(flag, callback);
+  }
+  /** Add handler for OSC escape sequence. See xterm.d.ts for details. */
+  public addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
+    return this._inputHandler.addOscHandler(ident, callback);
+  }
+
  /**
   * Registers a link matcher, allowing custom link patterns to be matched and
   * handled.
@@ -1526,7 +1619,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    }

    this.emit('keydown', event);
-    this.emit('key', result.key, event);
+    this._onKey.fire({ key: result.key, domEvent: event });
    this.showCursor();
    this.handler(result.key);

@@ -1605,7 +1698,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    key = String.fromCharCode(key);

    this.emit('keypress', key, ev);
-    this.emit('key', key, ev);
+    this._onKey.fire({ key, domEvent: ev });
    this.showCursor();
    this.handler(key);

@@ -1668,8 +1761,8 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      return;
    }

-    if (x < 1) x = 1;
-    if (y < 1) y = 1;
+    if (x < MINIMUM_COLS) x = MINIMUM_COLS;
+    if (y < MINIMUM_ROWS) y = MINIMUM_ROWS;

    this.buffers.resize(x, y);

@@ -1682,7 +1775,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    }

    this.refresh(0, this.rows - 1);
-    this.emit('resize', {cols: x, rows: y});
+    this._onResize.fire({ cols: x, rows: y });
  }

  /**
@@ -1722,21 +1815,10 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    this.buffer.ybase = 0;
    this.buffer.y = 0;
    for (let i = 1; i < this.rows; i++) {
-      this.buffer.lines.push(BufferLine.blankLine(this.cols, DEFAULT_ATTR));
+      this.buffer.lines.push(this.buffer.getBlankLine(DEFAULT_ATTR_DATA));
    }
    this.refresh(0, this.rows - 1);
-    this.emit('scroll', this.buffer.ydisp);
-  }
-
-  /**
-   * If cur return the back color xterm feature attribute. Else return default attribute.
-   * @param cur
-   */
-  public ch(cur?: boolean): CharData {
-    if (cur) {
-      return [this.eraseAttr(), NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE];
-    }
-    return [DEFAULT_ATTR, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE];
+    this._onScroll.fire(this.buffer.ydisp);
  }

  /**
@@ -1748,7 +1830,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
  }

  /**
-   * Emit the 'data' event and populate the given data.
+   * Emit the data event and populate the given data.
   * @param data The data to populate in the event.
   */
  public handler(data: string): void {
@@ -1766,7 +1848,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    if (this.buffer.ybase !== this.buffer.ydisp) {
      this.scrollToBottom();
    }
-    this.emit('data', data);
+    this._onData.fire(data);
  }

  /**
@@ -1774,13 +1856,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
   * @param title The title to populate in the event.
   */
  public handleTitle(title: string): void {
-    /**
-     * This event is emitted when the title of the terminal is changed
-     * from inside the terminal. The parameter is the new title.
-     *
-     * @event title
-     */
-    this.emit('title', title);
+    this._onTitleChange.fire(title);
  }

  /**
@@ -1814,7 +1890,7 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
      // blankLine(true) is xterm/linux behavior
      const scrollRegionHeight = this.buffer.scrollBottom - this.buffer.scrollTop;
      this.buffer.lines.shiftElements(this.buffer.y + this.buffer.ybase, scrollRegionHeight, 1);
-      this.buffer.lines.set(this.buffer.y + this.buffer.ybase, BufferLine.blankLine(this.cols, this.eraseAttr()));
+      this.buffer.lines.set(this.buffer.y + this.buffer.ybase, this.buffer.getBlankLine(this.eraseAttrData()));
      this.updateRange(this.buffer.scrollTop);
      this.updateRange(this.buffer.scrollBottom);
    } else {
@@ -1859,46 +1935,6 @@ export class Terminal extends EventEmitter implements ITerminal, IDisposable, II
    return false;
  }

-  // TODO: Remove when true color is implemented
-  public matchColor(r1: number, g1: number, b1: number): number {
-    const hash = (r1 << 16) | (g1 << 8) | b1;
-
-    if (matchColorCache[hash] !== null && matchColorCache[hash] !== undefined) {
-      return matchColorCache[hash];
-    }
-
-    let ldiff = Infinity;
-    let li = -1;
-    let i = 0;
-    let c: number;
-    let r2: number;
-    let g2: number;
-    let b2: number;
-    let diff: number;
-
-    for (; i < DEFAULT_ANSI_COLORS.length; i++) {
-      c = DEFAULT_ANSI_COLORS[i].rgba;
-      r2 = c >>> 24;
-      g2 = c >>> 16 & 0xFF;
-      b2 = c >>> 8 & 0xFF;
-      // assume that alpha is 0xFF
-
-      diff = matchColorDistance(r1, g1, b1, r2, g2, b2);
-
-      if (diff === 0) {
-        li = i;
-        break;
-      }
-
-      if (diff < ldiff) {
-        ldiff = diff;
-        li = i;
-      }
-    }
-
-    return matchColorCache[hash] = li;
-  }
-
  private _visualBell(): boolean {
    return false;
    // return this.options.bellStyle === 'visual' ||
@@ -1921,19 +1957,3 @@ function wasModifierKeyOnlyEvent(ev: KeyboardEvent): boolean {
    ev.keyCode === 17 || // Ctrl
    ev.keyCode === 18; // Alt
 }
-
-/**
- * TODO:
- * The below color-related code can be removed when true color is implemented.
- * It's only purpose is to match true color requests with the closest matching
- * ANSI color code.
- */
-
-const matchColorCache: {[colorRGBHash: number]: number} = {};
-
-// http://stackoverflow.com/questions/1633828
-function matchColorDistance(r1: number, g1: number, b1: number, r2: number, g2: number, b2: number): number {
-  return Math.pow(30 * (r1 - r2), 2)
-    + Math.pow(59 * (g1 - g2), 2)
-    + Math.pow(11 * (b1 - b2), 2);
-}
@@ -3,13 +3,14 @@
 * @license MIT
 */

-import { IColorSet, IRenderer, IRenderDimensions, IColorManager } from '../renderer/Types';
-import { IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminal, IBuffer, IBufferSet, IBrowser, ICharMeasure, ISelectionManager, ITerminalOptions, ILinkifier, IMouseHelper, ILinkMatcherOptions, CharacterJoinerHandler, IBufferLine, IBufferStringIterator } from '../Types';
-import { ICircularList, XtermListener } from '../common/Types';
-import { Buffer } from '../Buffer';
-import * as Browser from '../shared/utils/Browser';
-import { ITheme, IDisposable, IMarker } from 'xterm';
-import { Terminal } from '../Terminal';
+import { IColorSet, IRenderer, IRenderDimensions, IColorManager } from './renderer/Types';
+import { IInputHandlingTerminal, IViewport, ICompositionHelper, ITerminal, IBuffer, IBufferSet, IBrowser, ICharMeasure, ISelectionManager, ITerminalOptions, ILinkifier, IMouseHelper, ILinkMatcherOptions, CharacterJoinerHandler, IBufferLine, IBufferStringIterator, ICellData, IAttributeData } from './Types';
+import { ICircularList, XtermListener } from './common/Types';
+import { Buffer } from './Buffer';
+import * as Browser from './common/Platform';
+import { ITheme, IDisposable, IMarker, IEvent } from 'xterm';
+import { Terminal } from './Terminal';
+import { AttributeData } from './BufferLine';

 export class TestTerminal extends Terminal {
  writeSync(data: string): void {
@@ -19,6 +20,15 @@ export class TestTerminal extends Terminal {
 }

 export class MockTerminal implements ITerminal {
+  onCursorMove: IEvent<void>;
+  onLineFeed: IEvent<void>;
+  onSelectionChange: IEvent<void>;
+  onData: 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[];
  addMarker(cursorYOffset: number): IMarker {
    throw new Error('Method not implemented.');
@@ -54,6 +64,12 @@ export class MockTerminal implements ITerminal {
  attachCustomKeyEventHandler(customKeyEventHandler: (event: KeyboardEvent) => boolean): void {
    throw new Error('Method not implemented.');
  }
+  addCsiHandler(flag: string, callback: (params: number[], collect: string) => 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.');
  }
@@ -121,7 +137,7 @@ export class MockTerminal implements ITerminal {
  handler(data: string): void {
    throw new Error('Method not implemented.');
  }
-  on(event: string, callback: () => void): void {
+  on(event: string, callback: (...args: any[]) => void): void {
    throw new Error('Method not implemented.');
  }
  off(type: string, listener: XtermListener): void {
@@ -159,6 +175,7 @@ export class MockTerminal implements ITerminal {
 }

 export class MockCharMeasure implements ICharMeasure {
+  onCharSizeChanged: IEvent<void>;
  width: number;
  height: number;
  measure(options: ITerminalOptions): void {
@@ -181,8 +198,7 @@ export class MockInputHandlingTerminal implements IInputHandlingTerminal {
  insertMode: boolean;
  wraparoundMode: boolean;
  bracketedPasteMode: boolean;
-  curAttr: number;
-  savedCurAttr: number;
+  curAttrData = new AttributeData();
  savedCols: number;
  x10Mouse: boolean;
  vt200Mouse: boolean;
@@ -217,7 +233,7 @@ export class MockInputHandlingTerminal implements IInputHandlingTerminal {
  setgLevel(g: number): void {
    throw new Error('Method not implemented.');
  }
-  eraseAttr(): number {
+  eraseAttrData(): IAttributeData {
    throw new Error('Method not implemented.');
  }
  eraseRight(x: number, y: number): void {
@@ -304,6 +320,7 @@ export class MockBuffer implements IBuffer {
  scrollTop: number;
  savedY: number;
  savedX: number;
+  savedCurAttrData = new AttributeData();
  translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string {
    return Buffer.prototype.translateBufferLineToString.apply(this, arguments);
  }
@@ -319,15 +336,26 @@ export class MockBuffer implements IBuffer {
  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 {
+  onCanvasResize: IEvent<{ width: number; height: number; }>;
+  onRender: IEvent<{ start: number; end: number; }>;
  dispose(): void {
    throw new Error('Method not implemented.');
  }
@@ -5,9 +5,9 @@

 import { Terminal as PublicTerminal, ITerminalOptions as IPublicTerminalOptions, IEventEmitter, IDisposable } from 'xterm';
 import { IColorSet, IRenderer } from './renderer/Types';
-import { IMouseZoneManager } from './ui/Types';
 import { ICharset } from './core/Types';
 import { ICircularList } from './common/Types';
+import { IEvent } from './common/EventEmitter2';

 export type CustomKeyEventHandler = (event: KeyboardEvent) => boolean;

@@ -22,12 +22,6 @@ export type CharacterJoinerHandler = (text: string) => [number, number][];
 // BufferIndex denotes a position in the buffer: [rowIndex, colIndex]
 export type BufferIndex = [number, number];

-export const enum LinkHoverEventTypes {
-  HOVER = 'linkhover',
-  TOOLTIP = 'linktooltip',
-  LEAVE = 'linkleave'
-}
-
 /**
 * This interface encapsulates everything needed from the Terminal by the
 * InputHandler. This cleanly separates the large amount of methods needed by
@@ -48,8 +42,7 @@ export interface IInputHandlingTerminal extends IEventEmitter {
  insertMode: boolean;
  wraparoundMode: boolean;
  bracketedPasteMode: boolean;
-  curAttr: number;
-  savedCurAttr: number;
+  curAttrData: IAttributeData;
  savedCols: number;
  x10Mouse: boolean;
  vt200Mouse: boolean;
@@ -71,7 +64,7 @@ export interface IInputHandlingTerminal extends IEventEmitter {
  updateRange(y: number): void;
  scroll(isWrapped?: boolean): void;
  setgLevel(g: number): void;
-  eraseAttr(): number;
+  eraseAttrData(): IAttributeData;
  is(term: string): boolean;
  setgCharset(g: number, charset: ICharset): void;
  resize(x: number, y: number): void;
@@ -79,7 +72,6 @@ export interface IInputHandlingTerminal extends IEventEmitter {
  reset(): void;
  showCursor(): void;
  refresh(start: number, end: number): void;
-  matchColor(r1: number, g1: number, b1: number): number;
  error(text: string, data?: any): void;
  setOption(key: string, value: any): void;
  tabSet(): void;
@@ -112,7 +104,7 @@ export interface ICompositionHelper {
 */
 export interface IInputHandler {
  parse(data: string): void;
-  print(data: string, start: number, end: number): void;
+  print(data: Uint32Array, start: number, end: number): void;

  /** C0 BEL */ bell(): void;
  /** C0 LF */ lineFeed(): void;
@@ -195,7 +187,7 @@ export interface ILinkMatcher {
  willLinkActivate?: (event: MouseEvent, uri: string) => boolean;
 }

-export interface ILinkHoverEvent {
+export interface ILinkifierEvent {
  x1: number;
  y1: number;
  x2: number;
@@ -222,10 +214,6 @@ export interface ITerminal extends PublicTerminal, IElementAccessor, IBufferAcce
  bracketedPasteMode: boolean;
  applicationCursor: boolean;

-  /**
-   * Emit the 'data' event and populate the given data.
-   * @param data The data to populate in the event.
-   */
  handler(data: string): void;
  scrollLines(disp: number, suppressScrollEvent?: boolean): void;
  cancel(ev: Event, force?: boolean): boolean | void;
@@ -238,7 +226,7 @@ export interface IBufferAccessor {
 }

 export interface IElementAccessor {
-  element: HTMLElement;
+  readonly element: HTMLElement;
 }

 export interface ILinkifierAccessor {
@@ -246,13 +234,16 @@ export interface ILinkifierAccessor {
 }

 export interface IMouseHelper {
-  getCoords(event: { pageX: number, pageY: number }, element: HTMLElement, charMeasure: ICharMeasure, lineHeight: number, colCount: number, rowCount: number, isSelection?: boolean): [number, number];
-  getRawByteCoords(event: MouseEvent, element: HTMLElement, charMeasure: ICharMeasure, lineHeight: number, colCount: number, rowCount: number): { x: number, y: number };
+  getCoords(event: { clientX: number, clientY: number }, element: HTMLElement, charMeasure: ICharMeasure, colCount: number, rowCount: number, isSelection?: boolean): [number, number];
+  getRawByteCoords(event: MouseEvent, element: HTMLElement, charMeasure: ICharMeasure, colCount: number, rowCount: number): { x: number, y: number };
 }

 export interface ICharMeasure {
  width: number;
  height: number;
+
+  onCharSizeChanged: IEvent<void>;
+
  measure(options: ITerminalOptions): void;
 }

@@ -290,22 +281,28 @@ export interface IBuffer {
  hasScrollback: boolean;
  savedY: number;
  savedX: number;
+  savedCurAttrData: IAttributeData;
  isCursorInViewport: boolean;
  translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string;
  getWrappedRangeForLine(y: number): { first: number, last: number };
  nextStop(x?: number): number;
  prevStop(x?: number): number;
+  getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine;
  stringIndexToBufferIndex(lineIndex: number, stringIndex: number): number[];
  iterator(trimRight: boolean, startIndex?: number, endIndex?: number, startOverscan?: number, endOverscan?: number): IBufferStringIterator;
+  getNullCell(attr?: IAttributeData): ICellData;
+  getWhitespaceCell(attr?: IAttributeData): ICellData;
 }

-export interface IBufferSet extends IEventEmitter {
+export interface IBufferSet {
  alt: IBuffer;
  normal: IBuffer;
  active: IBuffer;

+  onBufferActivate: IEvent<{ activeBuffer: IBuffer, inactiveBuffer: IBuffer }>;
+
  activateNormalBuffer(): void;
-  activateAltBuffer(): void;
+  activateAltBuffer(fillAttr?: IAttributeData): void;
 }

 export interface ISelectionManager {
@@ -320,7 +317,17 @@ export interface ISelectionManager {
  selectWordAtCursor(event: MouseEvent): void;
 }

-export interface ILinkifier extends IEventEmitter {
+export interface ISelectionRedrawRequestEvent {
+  start: [number, number];
+  end: [number, number];
+  columnSelectMode: boolean;
+}
+
+export interface ILinkifier {
+  onLinkHover: IEvent<ILinkifierEvent>;
+  onLinkLeave: IEvent<ILinkifierEvent>;
+  onLinkTooltip: IEvent<ILinkifierEvent>;
+
  attachToDom(mouseZoneManager: IMouseZoneManager): void;
  linkifyRows(start: number, end: number): void;
  registerLinkMatcher(regex: RegExp, handler: LinkMatcherHandler, options?: ILinkMatcherOptions): number;
@@ -451,18 +458,26 @@ export interface IParsingState {
 * DCS handler signature for EscapeSequenceParser.
 * EscapeSequenceParser handles DCS commands via separate
 * subparsers that get hook/unhooked and can handle
-* arbitrary amount of print data.
+* arbitrary amount of data.
+*
 * On entering a DSC sequence `hook` is called by
 * `EscapeSequenceParser`. Use it to initialize or reset
 * states needed to handle the current DCS sequence.
+* Note: A DCS parser is only instantiated once, therefore
+* you cannot rely on the ctor to reinitialize state.
+*
 * EscapeSequenceParser will call `put` several times if the
-* parsed string got splitted, therefore you might have to collect
-* `data` until `unhook` is called. `unhook` marks the end
-* of the current DCS sequence.
+* parsed data got split, therefore you might have to collect
+* `data` until `unhook` is called.
+* Note: `data` is borrowed, if you cannot process the data
+* in chunks you have to copy it, doing otherwise will lead to
+* data losses or corruption.
+*
+* `unhook` marks the end of the current DCS sequence.
 */
 export interface IDcsHandler {
  hook(collect: string, params: number[], flag: number): void;
-  put(data: string, start: number, end: number): void;
+  put(data: Uint32Array, start: number, end: number): void;
  unhook(): void;
 }

@@ -479,9 +494,9 @@ export interface IEscapeSequenceParser extends IDisposable {
   * Parse string `data`.
   * @param data The data to parse.
   */
-  parse(data: string): void;
+  parse(data: Uint32Array, length: number): void;

-  setPrintHandler(callback: (data: string, start: number, end: number) => void): void;
+  setPrintHandler(callback: (data: Uint32Array, start: number, end: number) => void): void;
  clearPrintHandler(): void;

  setExecuteHandler(flag: string, callback: () => void): void;
@@ -491,6 +506,8 @@ export interface IEscapeSequenceParser extends IDisposable {
  setCsiHandler(flag: string, callback: (params: number[], collect: string) => void): void;
  clearCsiHandler(flag: string): void;
  setCsiHandlerFallback(callback: (collect: string, params: number[], flag: number) => void): void;
+  addCsiHandler(flag: string, callback: (params: number[], collect: string) => boolean): IDisposable;
+  addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable;

  setEscHandler(collectAndFlag: string, callback: () => void): void;
  clearEscHandler(collectAndFlag: string): void;
@@ -508,6 +525,52 @@ export interface IEscapeSequenceParser extends IDisposable {
  clearErrorHandler(): void;
 }

+/** RGB color type */
+export type IColorRGB = [number, number, number];
+
+/** Attribute data */
+export interface IAttributeData {
+  fg: number;
+  bg: number;
+
+  clone(): IAttributeData;
+
+  // flags
+  isInverse(): number;
+  isBold(): number;
+  isUnderline(): number;
+  isBlink(): number;
+  isInvisible(): number;
+  isItalic(): number;
+  isDim(): number;
+
+  // color modes
+  getFgColorMode(): number;
+  getBgColorMode(): number;
+  isFgRGB(): boolean;
+  isBgRGB(): boolean;
+  isFgPalette(): boolean;
+  isBgPalette(): boolean;
+  isFgDefault(): boolean;
+  isBgDefault(): boolean;
+
+  // colors
+  getFgColor(): number;
+  getBgColor(): number;
+}
+
+/** Cell data */
+export interface ICellData extends IAttributeData {
+  content: number;
+  combinedData: string;
+  isCombined(): number;
+  getWidth(): number;
+  getChars(): string;
+  getCode(): number;
+  setFromCharData(value: CharData): void;
+  getAsCharData(): CharData;
+}
+
 /**
 * Interface for a line in the terminal buffer.
 */
@@ -516,10 +579,44 @@ export interface IBufferLine {
  isWrapped: boolean;
  get(index: number): CharData;
  set(index: number, value: CharData): void;
-  pop(): CharData | undefined;
-  push(data: CharData): void;
-  splice(start: number, deleteCount: number, ...items: CharData[]): CharData[];
-  insertCells(pos: number, n: number, ch: CharData): void;
-  deleteCells(pos: number, n: number, fill: CharData): void;
-  replaceCells(start: number, end: number, fill: CharData): void;
+  loadCell(index: number, cell: ICellData): ICellData;
+  setCell(index: number, cell: ICellData): void;
+  setCellFromCodePoint(index: number, codePoint: number, width: number, fg: number, bg: number): void;
+  addCodepointToCell(index: number, codePoint: number): void;
+  insertCells(pos: number, n: number, ch: ICellData): void;
+  deleteCells(pos: number, n: number, fill: ICellData): void;
+  replaceCells(start: number, end: number, fill: ICellData): void;
+  resize(cols: number, fill: ICellData): void;
+  fill(fillCellData: ICellData): void;
+  copyFrom(line: IBufferLine): void;
+  clone(): IBufferLine;
+  getTrimmedLength(): number;
+  translateToString(trimRight?: boolean, startCol?: number, endCol?: number): string;
+
+  /* direct access to cell attrs */
+  getWidth(index: number): number;
+  hasWidth(index: number): number;
+  getFg(index: number): number;
+  getBg(index: number): number;
+  hasContent(index: number): number;
+  getCodePoint(index: number): number;
+  isCombined(index: number): number;
+  getString(index: number): string;
+}
+
+export interface IMouseZoneManager extends IDisposable {
+  add(zone: IMouseZone): void;
+  clearAll(start?: number, end?: number): void;
+}
+
+export interface IMouseZone {
+  x1: number;
+  x2: number;
+  y1: number;
+  y2: number;
+  clickCallback: (e: MouseEvent) => any;
+  hoverCallback: (e: MouseEvent) => any | undefined;
+  tooltipCallback: (e: MouseEvent) => any | undefined;
+  leaveCallback: () => any | undefined;
+  willLinkActivate: (e: MouseEvent) => boolean;
 }
@@ -5,7 +5,7 @@

 import { IColorSet } from './renderer/Types';
 import { ITerminal, IViewport } from './Types';
-import { CharMeasure } from './ui/CharMeasure';
+import { CharMeasure } from './CharMeasure';
 import { Disposable } from './common/Lifecycle';
 import { addDisposableDomListener } from './ui/Lifecycle';

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IDisposable } from 'xterm';
+import { ITerminal } from './Types';
+import { CHAR_DATA_CODE_INDEX, NULL_CELL_CODE, WHITESPACE_CELL_CODE } from './Buffer';
+
+export function applyWindowsMode(terminal: ITerminal): IDisposable {
+  // Winpty does not support wraparound mode which means that lines will never
+  // be marked as wrapped. This causes issues for things like copying a line
+  // retaining the wrapped new line characters or if consumers are listening
+  // in on the data stream.
+  //
+  // The workaround for this is to listen to every incoming line feed and mark
+  // the line as wrapped if the last character in the previous line is not a
+  // space. This is certainly not without its problems, but generally on
+  // Windows when text reaches the end of the terminal it's likely going to be
+  // wrapped.
+  return terminal.onLineFeed(() => {
+    const line = terminal.buffer.lines.get(terminal.buffer.ybase + terminal.buffer.y - 1);
+    const lastChar = line.get(terminal.cols - 1);
+
+    if (lastChar[CHAR_DATA_CODE_INDEX] !== NULL_CELL_CODE && lastChar[CHAR_DATA_CODE_INDEX] !== WHITESPACE_CELL_CODE) {
+      const nextLine = terminal.buffer.lines.get(terminal.buffer.ybase + terminal.buffer.y);
+      nextLine.isWrapped = true;
+    }
+  });
+}
@@ -14,6 +14,7 @@ export interface IAttachAddonTerminal extends Terminal {

  __socket?: WebSocket;
  __attachSocketBuffer?: string;
+  __dataListener?: IDisposable;

  __getMessage?(ev: MessageEvent): void;
  __flushBuffer?(): void;
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { assert, expect } from 'chai';
+import { assert } from 'chai';

 import * as attach from './attach';

@@ -90,7 +90,8 @@ export function attach(term: Terminal, socket: WebSocket, bidirectional: boolean
  addonTerminal._core.register(addSocketListener(socket, 'message', addonTerminal.__getMessage));

  if (bidirectional) {
-    addonTerminal._core.register(addonTerminal.addDisposableListener('data', addonTerminal.__sendData));
+    addonTerminal.__dataListener = addonTerminal.onData(addonTerminal.__sendData);
+    addonTerminal._core.register(addonTerminal.__dataListener);
  }

  addonTerminal._core.register(addSocketListener(socket, 'close', () => detach(addonTerminal, socket)));
@@ -119,7 +120,8 @@ function addSocketListener(socket: WebSocket, type: string, handler: (this: WebS
 */
 export function detach(term: Terminal, socket: WebSocket): void {
  const addonTerminal = <IAttachAddonTerminal>term;
-  addonTerminal.off('data', addonTerminal.__sendData);
+  addonTerminal.__dataListener.dispose();
+  addonTerminal.__dataListener = undefined;

  socket = (typeof socket === 'undefined') ? addonTerminal.__socket : socket;

@@ -10,8 +10,7 @@
    "outDir": "../../../lib/addons/attach/",
    "sourceMap": true,
    "removeComments": true,
-    "declaration": true,
-    "preserveWatchOutput": true
+    "declaration": true
  },
  "include": [
    "**/*.ts",
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { assert, expect } from 'chai';
+import { assert } from 'chai';

 import * as fit from './fit';

@@ -4,14 +4,16 @@
    "target": "es5",
    "lib": [
      "dom",
-      "es6",
+      "es5"
    ],
    "rootDir": ".",
    "outDir": "../../../lib/addons/fit/",
    "sourceMap": true,
    "removeComments": true,
    "declaration": true,
-    "preserveWatchOutput": true
+    "types": [
+      "../../node_modules/@types/mocha"
+    ]
  },
  "include": [
    "**/*.ts",
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { assert, expect } from 'chai';
+import { assert } from 'chai';

 import * as fullscreen from './fullscreen';

@@ -11,17 +11,19 @@ import { Terminal } from 'xterm';
 * @param fullscreen Toggle fullscreen on (true) or off (false)
 */
 export function toggleFullScreen(term: Terminal, fullscreen: boolean): void {
-  let fn: string;
+  let fn: (...tokens: string[]) => void;

  if (typeof fullscreen === 'undefined') {
-    fn = (term.element.classList.contains('fullscreen')) ? 'remove' : 'add';
+    fn = (term.element.classList.contains('fullscreen')) ?
+      term.element.classList.remove : term.element.classList.add;
  } else if (!fullscreen) {
-    fn = 'remove';
+    fn = term.element.classList.remove;
  } else {
-    fn = 'add';
+    fn = term.element.classList.add;
  }

-  term.element.classList[fn]('fullscreen');
+  fn = fn.bind(term.element.classList);
+  fn('fullscreen');
 }

 export function apply(terminalConstructor: typeof Terminal): void {
@@ -4,14 +4,16 @@
    "target": "es5",
    "lib": [
      "dom",
-      "es6",
+      "es5"
    ],
    "rootDir": ".",
    "outDir": "../../../lib/addons/fullscreen/",
    "sourceMap": true,
    "removeComments": true,
    "declaration": true,
-    "preserveWatchOutput": true
+    "types": [
+      "../../node_modules/@types/mocha"
+    ]
  },
  "include": [
    "**/*.ts",
@@ -25,6 +25,11 @@ export interface ISearchOptions {
  regex?: boolean;
  wholeWord?: boolean;
  caseSensitive?: boolean;
+  /**
+   * Use this when you want the selection to expand if it still matches as the
+   * user types. Note that this only affects findNext.
+   */
+  incremental?: boolean;
 }

 export interface ISearchResult {
@@ -4,50 +4,93 @@
 */

 import { ISearchHelper, ISearchAddonTerminal, ISearchOptions, ISearchResult } from './Interfaces';
-const nonWordCharacters = ' ~!@#$%^&*()_+`-=[]{}|\;:"\',./<>?';
+import { IDisposable } from 'xterm';
+
+const NON_WORD_CHARACTERS = ' ~!@#$%^&*()+`-=[]{}|\;:"\',./<>?';
+const LINES_CACHE_TIME_TO_LIVE = 15 * 1000; // 15 secs

 /**
 * A class that knows how to search the terminal and how to display the results.
 */
 export class SearchHelper implements ISearchHelper {
+  /**
+   * translateBufferLineToStringWithWrap is a fairly expensive call.
+   * We memoize the calls into an array that has a time based ttl.
+   * _linesCache is also invalidated when the terminal cursor moves.
+   */
+  private _linesCache: string[] = null;
+  private _linesCacheTimeoutId = 0;
+  private _cursorMoveListener: IDisposable | undefined;
+  private _resizeListener: IDisposable | undefined;
+
  constructor(private _terminal: ISearchAddonTerminal) {
-    // TODO: Search for multiple instances on 1 line
-    // TODO: Don't use the actual selection, instead use a "find selection" so multiple instances can be highlighted
-    // TODO: Highlight other instances in the viewport
+    this._destroyLinesCache = this._destroyLinesCache.bind(this);
  }

  /**
   * Find the next instance of the term, then scroll to and select it. If it
   * doesn't exist, do nothing.
-   * @param term Tne search term.
+   * @param term The search term.
   * @param searchOptions Search options.
   * @return Whether a result was found.
   */
  public findNext(term: string, searchOptions?: ISearchOptions): boolean {
+    const selectionManager = this._terminal._core.selectionManager;
+    const {incremental} = searchOptions;
+    let result: ISearchResult;
+
    if (!term || term.length === 0) {
+      selectionManager.clearSelection();
      return false;
    }

-    let result: ISearchResult;
-
+    let startCol: number = 0;
    let startRow = this._terminal._core.buffer.ydisp;
-    if (this._terminal._core.selectionManager.selectionEnd) {
-      // Start from the selection end if there is a selection
-      startRow = this._terminal._core.selectionManager.selectionEnd[1];
-    }

-    // Search from ydisp + 1 to end
-    for (let y = startRow + 1; y < this._terminal._core.buffer.ybase + this._terminal.rows; y++) {
-      result = this._findInLine(term, y, searchOptions);
-      if (result) {
-        break;
+    if (selectionManager.selectionEnd) {
+      // Start from the selection end if there is a selection
+      // For incremental search, use existing row
+      if (this._terminal.getSelection().length !== 0) {
+        startRow = incremental ? selectionManager.selectionStart[1] : selectionManager.selectionEnd[1];
+        startCol = incremental ? selectionManager.selectionStart[0] : selectionManager.selectionEnd[0];
      }
    }

-    // Search from the top to the current ydisp
+    this._initLinesCache();
+
+    // A row that has isWrapped = false
+    let findingRow = startRow;
+    // index of beginning column that _findInLine need to scan.
+    let cumulativeCols = startCol;
+    // If startRow is wrapped row, scan for unwrapped row above.
+    // So we can start matching on wrapped line from long unwrapped line.
+    while (this._terminal._core.buffer.lines.get(findingRow).isWrapped) {
+      findingRow--;
+      cumulativeCols += this._terminal.cols;
+    }
+
+    // Search startRow
+    result = this._findInLine(term, findingRow, cumulativeCols, searchOptions);
+
+    // Search from startRow + 1 to end
    if (!result) {
-      for (let y = 0; y < startRow; y++) {
-        result = this._findInLine(term, y, searchOptions);
+
+      for (let y = startRow + 1; y < this._terminal._core.buffer.ybase + this._terminal.rows; y++) {
+
+        // If the current line is wrapped line, increase index of column to ignore the previous scan
+        // Otherwise, reset beginning column index to zero with set new unwrapped line index
+        result = this._findInLine(term, y, 0, searchOptions);
+        if (result) {
+          break;
+        }
+      }
+    }
+
+    // Search from the top to the startRow (search the whole startRow again in
+    // case startCol > 0)
+    if (!result) {
+      for (let y = 0; y < findingRow; y++) {
+        result = this._findInLine(term, y, 0, searchOptions);
        if (result) {
          break;
        }
@@ -61,38 +104,74 @@ export class SearchHelper implements ISearchHelper {
  /**
   * Find the previous instance of the term, then scroll to and select it. If it
   * doesn't exist, do nothing.
-   * @param term Tne search term.
+   * @param term The search term.
   * @param searchOptions Search options.
   * @return Whether a result was found.
   */
  public findPrevious(term: string, searchOptions?: ISearchOptions): boolean {
+    const selectionManager = this._terminal._core.selectionManager;
+    let result: ISearchResult;
+
    if (!term || term.length === 0) {
+      selectionManager.clearSelection();
      return false;
    }

-    let result: ISearchResult;
+    const isReverseSearch = true;
+    let startRow = this._terminal._core.buffer.ydisp + this._terminal.rows - 1;
+    let startCol = this._terminal.cols;

-    let startRow = this._terminal._core.buffer.ydisp;
-    if (this._terminal._core.selectionManager.selectionStart) {
-      // Start from the selection end if there is a selection
-      startRow = this._terminal._core.selectionManager.selectionStart[1];
-    }
-
-    // Search from ydisp + 1 to end
-    for (let y = startRow - 1; y >= 0; y--) {
-      result = this._findInLine(term, y, searchOptions);
-      if (result) {
-        break;
+    if (selectionManager.selectionStart) {
+      // Start from the selection start if there is a selection
+      if (this._terminal.getSelection().length !== 0) {
+        startRow = selectionManager.selectionStart[1];
+        startCol = selectionManager.selectionStart[0];
      }
    }

-    // Search from the top to the current ydisp
+    this._initLinesCache();
+
+    // Search startRow
+    result = this._findInLine(term, startRow, startCol, searchOptions, isReverseSearch);
+
+    // Search from startRow - 1 to top
    if (!result) {
-      for (let y = this._terminal._core.buffer.ybase + this._terminal.rows - 1; y > startRow; y--) {
-        result = this._findInLine(term, y, searchOptions);
+      // If the line is wrapped line, increase number of columns that is needed to be scanned
+      // Se we can scan on wrapped line from unwrapped line
+      let cumulativeCols = this._terminal.cols;
+      if (this._terminal._core.buffer.lines.get(startRow).isWrapped) {
+        cumulativeCols += startCol;
+      }
+      for (let y = startRow - 1; y >= 0; y--) {
+        result = this._findInLine(term, y, cumulativeCols, searchOptions, isReverseSearch);
        if (result) {
          break;
        }
+        // If the current line is wrapped line, increase scanning range,
+        // preparing for scanning on unwrapped line
+        if (this._terminal._core.buffer.lines.get(y).isWrapped) {
+          cumulativeCols += this._terminal.cols;
+        } else {
+          cumulativeCols = this._terminal.cols;
+        }
+      }
+    }
+
+    // Search from the bottom to startRow (search the whole startRow again in
+    // case startCol > 0)
+    if (!result) {
+      const searchFrom = this._terminal._core.buffer.ybase + this._terminal.rows - 1;
+      let cumulativeCols = this._terminal.cols;
+      for (let y = searchFrom; y >= startRow; y--) {
+        result = this._findInLine(term, y, cumulativeCols, searchOptions, isReverseSearch);
+        if (result) {
+          break;
+        }
+        if (this._terminal._core.buffer.lines.get(y).isWrapped) {
+          cumulativeCols += this._terminal.cols;
+        } else {
+          cumulativeCols = this._terminal.cols;
+        }
      }
    }

@@ -100,6 +179,36 @@ export class SearchHelper implements ISearchHelper {
    return this._selectResult(result);
  }

+  /**
+   * Sets up a line cache with a ttl
+   */
+  private _initLinesCache(): void {
+    if (!this._linesCache) {
+      this._linesCache = new Array(this._terminal._core.buffer.length);
+      this._cursorMoveListener = this._terminal.onCursorMove(() => this._destroyLinesCache());
+      this._resizeListener = this._terminal.onResize(() => this._destroyLinesCache());
+    }
+
+    window.clearTimeout(this._linesCacheTimeoutId);
+    this._linesCacheTimeoutId = window.setTimeout(() => this._destroyLinesCache(), LINES_CACHE_TIME_TO_LIVE);
+  }
+
+  private _destroyLinesCache(): void {
+    this._linesCache = null;
+    if (this._cursorMoveListener) {
+      this._cursorMoveListener.dispose();
+      this._cursorMoveListener = undefined;
+    }
+    if (this._resizeListener) {
+      this._resizeListener.dispose();
+      this._resizeListener = undefined;
+    }
+    if (this._linesCacheTimeoutId) {
+      window.clearTimeout(this._linesCacheTimeoutId);
+      this._linesCacheTimeoutId = 0;
+    }
+  }
+
  /**
   * A found substring is a whole word if it doesn't have an alphanumeric character directly adjacent to it.
   * @param searchIndex starting indext of the potential whole word substring
@@ -107,8 +216,8 @@ export class SearchHelper implements ISearchHelper {
   * @param term the substring that starts at searchIndex
   */
  private _isWholeWord(searchIndex: number, line: string, term: string): boolean {
-    return (((searchIndex === 0) || (nonWordCharacters.indexOf(line[searchIndex - 1]) !== -1)) &&
-         (((searchIndex + term.length) === line.length) || (nonWordCharacters.indexOf(line[searchIndex + term.length]) !== -1)));
+    return (((searchIndex === 0) || (NON_WORD_CHARACTERS.indexOf(line[searchIndex - 1]) !== -1)) &&
+        (((searchIndex + term.length) === line.length) || (NON_WORD_CHARACTERS.indexOf(line[searchIndex + term.length]) !== -1)));
  }

  /**
@@ -116,66 +225,90 @@ export class SearchHelper implements ISearchHelper {
   * subsequent terminal lines if the text is wrapped. If the provided line number is part of a wrapped text line that
   * started on an earlier line then it is skipped since it will be properly searched when the terminal line that the
   * text starts on is searched.
-   * @param term Tne search term.
-   * @param y The line to search.
+   * @param term The search term.
+   * @param row The line to  start the search from.
+   * @param col The column to start the search from.
   * @param searchOptions Search options.
   * @return The search result if it was found.
   */
-  protected _findInLine(term: string, y: number, searchOptions: ISearchOptions = {}): ISearchResult {
-    if (this._terminal._core.buffer.lines.get(y).isWrapped) {
+  protected _findInLine(term: string, row: number, col: number, searchOptions: ISearchOptions = {}, isReverseSearch: boolean = false): ISearchResult {
+
+    // Ignore wrapped lines, only consider on unwrapped line (first row of command string).
+    if (this._terminal._core.buffer.lines.get(row).isWrapped) {
      return;
    }
-
-    const stringLine = this.translateBufferLineToStringWithWrap(y, true);
-    const searchStringLine = searchOptions.caseSensitive ? stringLine : stringLine.toLowerCase();
-    const searchTerm = searchOptions.caseSensitive ? term : term.toLowerCase();
-    let searchIndex = -1;
-
-    if (searchOptions.regex) {
-      const searchRegex = RegExp(searchTerm, 'g');
-      const foundTerm = searchRegex.exec(searchStringLine);
-      if (foundTerm && foundTerm[0].length > 0) {
-        searchIndex = searchRegex.lastIndex - foundTerm[0].length;
-        term = foundTerm[0];
+    let stringLine = this._linesCache ? this._linesCache[row] : void 0;
+    if (stringLine === void 0) {
+      stringLine = this.translateBufferLineToStringWithWrap(row, true);
+      if (this._linesCache) {
+        this._linesCache[row] = stringLine;
      }
-    } else {
-      searchIndex = searchStringLine.indexOf(searchTerm);
    }

-    if (searchIndex >= 0) {
-      // Adjust the row number and search index if needed since a "line" of text can span multiple rows
-      if (searchIndex >= this._terminal.cols) {
-        y += Math.floor(searchIndex / this._terminal.cols);
-        searchIndex = searchIndex % this._terminal.cols;
+    const searchTerm = searchOptions.caseSensitive ? term : term.toLowerCase();
+    const searchStringLine = searchOptions.caseSensitive ? stringLine : stringLine.toLowerCase();
+
+    let resultIndex = -1;
+    if (searchOptions.regex) {
+      const searchRegex = RegExp(searchTerm, 'g');
+      let foundTerm: RegExpExecArray;
+      if (isReverseSearch) {
+        // This loop will get the resultIndex of the _last_ regex match in the range 0..col
+        while (foundTerm = searchRegex.exec(searchStringLine.slice(0, col))) {
+          resultIndex = searchRegex.lastIndex - foundTerm[0].length;
+          term = foundTerm[0];
+          searchRegex.lastIndex -= (term.length - 1);
+        }
+      } else {
+        foundTerm = searchRegex.exec(searchStringLine.slice(col));
+        if (foundTerm && foundTerm[0].length > 0) {
+          resultIndex = col + (searchRegex.lastIndex - foundTerm[0].length);
+          term = foundTerm[0];
+        }
      }
-      if (searchOptions.wholeWord && !this._isWholeWord(searchIndex, searchStringLine, term)) {
+    } else {
+      if (isReverseSearch) {
+        if (col - searchTerm.length >= 0) {
+          resultIndex = searchStringLine.lastIndexOf(searchTerm, col - searchTerm.length);
+        }
+      } else {
+        resultIndex = searchStringLine.indexOf(searchTerm, col);
+      }
+    }
+
+    if (resultIndex >= 0) {
+      // Adjust the row number and search index if needed since a "line" of text can span multiple rows
+      if (resultIndex >= this._terminal.cols) {
+        row += Math.floor(resultIndex / this._terminal.cols);
+        resultIndex = resultIndex % this._terminal.cols;
+      }
+      if (searchOptions.wholeWord && !this._isWholeWord(resultIndex, searchStringLine, term)) {
        return;
      }

-      const line = this._terminal._core.buffer.lines.get(y);
+      const line = this._terminal._core.buffer.lines.get(row);

-      for (let i = 0; i < searchIndex; i++) {
+      for (let i = 0; i < resultIndex; i++) {
        const charData = line.get(i);
        // Adjust the searchIndex to normalize emoji into single chars
        const char = charData[1/*CHAR_DATA_CHAR_INDEX*/];
        if (char.length > 1) {
-          searchIndex -= char.length - 1;
+          resultIndex -= char.length - 1;
        }
        // Adjust the searchIndex for empty characters following wide unicode
        // chars (eg. CJK)
        const charWidth = charData[2/*CHAR_DATA_WIDTH_INDEX*/];
        if (charWidth === 0) {
-          searchIndex++;
+          resultIndex++;
        }
      }
      return {
        term,
-        col: searchIndex,
-        row: y
+        col: resultIndex,
+        row
      };
    }
  }
-
  /**
   * Translates a buffer line to a string, including subsequent lines if they are wraps.
   * Wide characters will count as two columns in the resulting string. This
@@ -191,7 +324,7 @@ export class SearchHelper implements ISearchHelper {
    do {
      const nextLine = this._terminal._core.buffer.lines.get(lineIndex + 1);
      lineWrapsToNext = nextLine ? nextLine.isWrapped : false;
-      lineString += this._terminal._core.buffer.translateBufferLineToString(lineIndex, !lineWrapsToNext && trimRight);
+      lineString += this._terminal._core.buffer.translateBufferLineToString(lineIndex, !lineWrapsToNext && trimRight).substring(0, this._terminal.cols);
      lineIndex++;
    } while (lineWrapsToNext);

@@ -205,6 +338,7 @@ export class SearchHelper implements ISearchHelper {
   */
  private _selectResult(result: ISearchResult): boolean {
    if (!result) {
+      this._terminal.clearSelection();
      return false;
    }
    this._terminal._core.selectionManager.setSelection(result.col, result.row, result.term.length);
@@ -2,13 +2,13 @@
 * Copyright (c) 2018 The xterm.js authors. All rights reserved.
 * @license MIT
 */
+declare var require: any;

 import { assert, expect } from 'chai';
 import * as search from './search';
 import { SearchHelper } from './SearchHelper';
 import { ISearchOptions, ISearchResult } from './Interfaces';

-
 class MockTerminalPlain {}

 class MockTerminal {
@@ -16,7 +16,7 @@ class MockTerminal {
  public searchHelper: TestSearchHelper;
  public cols: number;
  constructor(options: any) {
-    this._core = new (require('../../../lib/Terminal').Terminal)(options);
+    this._core = new (require('../../../lib/Terminal')).Terminal(options);
    this.searchHelper = new TestSearchHelper(this as any);
    this.cols = options.cols;
  }
@@ -29,8 +29,11 @@ class MockTerminal {
 }

 class TestSearchHelper extends SearchHelper {
-  public findInLine(term: string, y: number, searchOptions?: ISearchOptions): ISearchResult {
-    return this._findInLine(term, y, searchOptions);
+  public findInLine(term: string, rowNumber: number, searchOptions?: ISearchOptions): ISearchResult {
+    return this._findInLine(term, rowNumber, 0, searchOptions);
+  }
+  public findFromIndex(term: string, row: number, col: number, searchOptions?: ISearchOptions, isReverseSearch?: boolean): ISearchResult {
+    return this._findInLine(term, row, col, searchOptions, isReverseSearch);
  }
 }

@@ -82,6 +85,9 @@ describe('search addon', () => {
      expect(hello3).eql(undefined);
      expect(llo).eql(undefined);
      expect(goodbye).eql({col: 0, row: 5, term: 'goodbye'});
+      term.core.resize(9, 5);
+      const hello0Resize = term.searchHelper.findInLine('Hello', 0);
+      expect(hello0Resize).eql({col: 8, row: 0, term: 'Hello'});
    });
    it('should respect search regex', () => {
      search.apply(<any>MockTerminal);
@@ -115,8 +121,6 @@ describe('search addon', () => {
    it('should not select empty lines', () => {
      search.apply(<any>MockTerminal);
      const term = new MockTerminal({cols: 20, rows: 3});
-      term.core.write('    ');
-      term.pushWriteData();
      const line = term.searchHelper.findInLine('^.*$', 0, { regex: true });
      expect(line).eql(undefined);
    });
@@ -244,5 +248,66 @@ describe('search addon', () => {
      expect(hello4).eql(undefined);
      expect(hello5).eql(undefined);
    });
+    it('should find multiple matches in line', function(): void {
+      search.apply(<any>MockTerminal);
+      const term = new MockTerminal({cols: 20, rows: 5});
+      term.core.write('helloooo helloooo\r\naaaAAaaAAA');
+      term.pushWriteData();
+      const searchOptions = {
+        regex: false,
+        wholeWord: false,
+        caseSensitive: false
+      };
+      const find0 = term.searchHelper.findFromIndex('hello', 0, 0, searchOptions);
+      const find1 = term.searchHelper.findFromIndex('hello', 0, find0.col + find0.term.length, searchOptions);
+      const find2 = term.searchHelper.findFromIndex('aaaa', 1, 0, searchOptions);
+      const find3 = term.searchHelper.findFromIndex('aaaa', 1, find2.col + find2.term.length, searchOptions);
+      const find4 = term.searchHelper.findFromIndex('aaaa', 1, find3.col + find3.term.length, searchOptions);
+      expect(find0).eql({col: 0, row: 0, term: 'hello'});
+      expect(find1).eql({col: 9, row: 0, term: 'hello'});
+      expect(find2).eql({col: 0, row: 1, term: 'aaaa'});
+      expect(find3).eql({col: 4, row: 1, term: 'aaaa'});
+      expect(find4).eql(undefined);
+    });
+    it('should find multiple matches in line - reverse search', function(): void {
+      search.apply(<any>MockTerminal);
+      const term = new MockTerminal({cols: 20, rows: 5});
+      term.core.write('it is what it is');
+      term.pushWriteData();
+      const searchOptions = {
+        regex: false,
+        wholeWord: false,
+        caseSensitive: false
+      };
+      const isReverseSearch = true;
+      const find0 = term.searchHelper.findFromIndex('is', 0, 16, searchOptions, isReverseSearch);
+      const find1 = term.searchHelper.findFromIndex('is', 0, find0.col, searchOptions, isReverseSearch);
+      const find2 = term.searchHelper.findFromIndex('it', 0, 16, searchOptions, isReverseSearch);
+      const find3 = term.searchHelper.findFromIndex('it', 0, find2.col, searchOptions, isReverseSearch);
+      expect(find0).eql({col: 14, row: 0, term: 'is'});
+      expect(find1).eql({col: 3, row: 0, term: 'is'});
+      expect(find2).eql({col: 11, row: 0, term: 'it'});
+      expect(find3).eql({col: 0, row: 0, term: 'it'});
+    });
+    it('should find multiple matches in line - reverse search with regex', function(): void {
+      search.apply(<any>MockTerminal);
+      const term = new MockTerminal({cols: 20, rows: 5});
+      term.core.write('zzzABCzzzzABCABC');
+      term.pushWriteData();
+      const searchOptions = {
+        regex: true,
+        wholeWord: false,
+        caseSensitive: true
+      };
+      const isReverseSearch = true;
+      const find0 = term.searchHelper.findFromIndex('[A-Z]{3}', 0, 16, searchOptions, isReverseSearch);
+      const find1 = term.searchHelper.findFromIndex('[A-Z]{3}', 0, find0.col, searchOptions, isReverseSearch);
+      const find2 = term.searchHelper.findFromIndex('[A-Z]{3}', 0, find1.col, searchOptions, isReverseSearch);
+      const find3 = term.searchHelper.findFromIndex('[A-Z]{3}', 0, find2.col, searchOptions, isReverseSearch);
+      expect(find0).eql({col: 13, row: 0, term: 'ABC'});
+      expect(find1).eql({col: 10, row: 0, term: 'ABC'});
+      expect(find2).eql({col: 3, row: 0, term: 'ABC'});
+      expect(find3).eql(undefined);
+    });
  });
 });
@@ -10,7 +10,7 @@ import { ISearchAddonTerminal, ISearchOptions } from './Interfaces';
 /**
 * Find the next instance of the term, then scroll to and select it. If it
 * doesn't exist, do nothing.
- * @param term Tne search term.
+ * @param term The search term.
 * @param searchOptions Search options
 * @return Whether a result was found.
 */
@@ -25,7 +25,7 @@ export function findNext(terminal: Terminal, term: string, searchOptions: ISearc
 /**
 * Find the previous instance of the term, then scroll to and select it. If it
 * doesn't exist, do nothing.
- * @param term Tne search term.
+ * @param term The search term.
 * @param searchOptions Search options
 * @return Whether a result was found.
 */
@@ -4,14 +4,16 @@
    "target": "es5",
    "lib": [
      "dom",
-      "es6",
+      "es5"
    ],
    "rootDir": ".",
    "outDir": "../../../lib/addons/search/",
    "sourceMap": true,
    "removeComments": true,
    "declaration": true,
-    "preserveWatchOutput": true
+    "types": [
+      "../../node_modules/@types/mocha"
+    ]
  },
  "include": [
    "**/*.ts",
@@ -5,11 +5,16 @@
 * Implements the attach method, that attaches the terminal to a WebSocket stream.
 */

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

 export interface ITerminadoAddonTerminal extends Terminal {
+  _core: {
+    register<T extends IDisposable>(d: T): void;
+  };
+
  __socket?: WebSocket;
  __attachSocketBuffer?: string;
+  __dataListener?: IDisposable;

  __getMessage?(ev: MessageEvent): void;
  __flushBuffer?(): void;
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { assert, expect } from 'chai';
+import { assert } from 'chai';

 import * as terminado from './terminado';

@@ -59,9 +59,9 @@ export function terminadoAttach(term: Terminal, socket: WebSocket, bidirectional
  socket.addEventListener('message', addonTerminal.__getMessage);

  if (bidirectional) {
-    addonTerminal.on('data', addonTerminal.__sendData);
+    addonTerminal._core.register(addonTerminal.onData(addonTerminal.__sendData));
  }
-  addonTerminal.on('resize', addonTerminal.__setSize);
+  addonTerminal._core.register(addonTerminal.onResize(addonTerminal.__setSize));

  socket.addEventListener('close', () => terminadoDetach(addonTerminal, socket));
  socket.addEventListener('error', () => terminadoDetach(addonTerminal, socket));
@@ -75,7 +75,8 @@ export function terminadoAttach(term: Terminal, socket: WebSocket, bidirectional
 */
 export function terminadoDetach(term: Terminal, socket: WebSocket): void {
  const addonTerminal = <ITerminadoAddonTerminal>term;
-  addonTerminal.off('data', addonTerminal.__sendData);
+  addonTerminal.__dataListener.dispose();
+  addonTerminal.__dataListener = undefined;

  socket = (typeof socket === 'undefined') ? addonTerminal.__socket : socket;

@@ -3,15 +3,16 @@
    "module": "commonjs",
    "target": "es5",
    "lib": [
-      "dom",
-      "es6",
+      "es5"
    ],
    "rootDir": ".",
    "outDir": "../../../lib/addons/terminado/",
    "sourceMap": true,
    "removeComments": true,
    "declaration": true,
-    "preserveWatchOutput": true
+    "types": [
+      "../../node_modules/@types/mocha"
+    ]
  },
  "include": [
    "**/*.ts",
@@ -4,14 +4,16 @@
    "target": "es5",
    "lib": [
      "dom",
-      "es6",
+      "es5",
    ],
    "rootDir": ".",
    "outDir": "../../../lib/addons/webLinks/",
    "sourceMap": true,
    "removeComments": true,
    "declaration": true,
-    "preserveWatchOutput": true
+    "types": [
+      "../../node_modules/@types/mocha"
+    ]
  },
  "include": [
    "**/*.ts",
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { assert, expect } from 'chai';
+import { assert } from 'chai';

 import * as webLinks from './webLinks';

@@ -28,15 +28,159 @@ describe('webLinks addon', () => {
    });
  });

-  it('should allow ~ character in URI path', () => {
-    const term = new MockTerminal();
-    webLinks.webLinksInit(<any>term);
+  describe('should allow simple URI path', () => {
+    it('foo.com', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);

-    const row = '  http://foo.com/a~b#c~d?e~f  ';
+      const row = '  http://foo.com  ';

-    const match = row.match(term.regex);
-    const uri = match[term.options.matchIndex];
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];

-    assert.equal(uri, 'http://foo.com/a~b#c~d?e~f');
+      assert.equal(uri, 'http://foo.com');
+    });
+
+    it('bar.io', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '  http://bar.io  ';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://bar.io');
+    });
+  });
+
+  describe('should allow ~ character in URI path', () => {
+    it('foo.com', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '  http://foo.com/a~b#c~d?e~f  ';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://foo.com/a~b#c~d?e~f');
+    });
+
+    it('bar.io', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '  http://bar.io/a~b#c~d?e~f  ';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://bar.io/a~b#c~d?e~f');
+    });
+  });
+
+  describe('should allow : character in URI path', () => {
+    it('foo.com', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '  http://foo.com/colon:test  ';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://foo.com/colon:test');
+    });
+
+    it('bar.io', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '  http://bar.io/colon:test  ';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://bar.io/colon:test');
+    });
+  });
+
+  describe('should not allow : character at the end of a URI path', () => {
+    it('foo.com', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '  http://foo.com/colon:test:  ';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://foo.com/colon:test');
+    });
+
+    it('bar.io', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '  http://bar.io/colon:test:  ';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://bar.io/colon:test');
+    });
+  });
+
+  describe('should not allow " character at the end of a URI enclosed with ""', () => {
+    it('foo.com', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '"http://foo.com/"';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://foo.com/');
+    });
+
+    it('bar.io', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '"http://bar.io/"';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://bar.io/');
+    });
+  });
+
+  describe('should not allow \' character at the end of a URI enclosed with \'\'', () => {
+    it('foo.com', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '\'http://foo.com/\'';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://foo.com/');
+    });
+
+    it('bar.io', () => {
+      const term = new MockTerminal();
+      webLinks.webLinksInit(<any>term);
+
+      const row = '\'http://bar.io/\'';
+
+      const match = row.match(term.regex);
+      const uri = match[term.options.matchIndex];
+
+      assert.equal(uri, 'http://bar.io/');
+    });
  });
 });
@@ -14,7 +14,8 @@ 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 pathClause = '(\\/[\\/\\w\\.\\-%~]*)*';
+const pathCharacterSet = '(\\/[\\/\\w\\.\\-%~:]*)*([^:"\'\\s])';
+const pathClause = '(' + pathCharacterSet + ')?';
 const queryStringHashFragmentCharacterSet = '[0-9\\w\\[\\]\\(\\)\\/\\?\\!#@$%&\'*+,:;~\\=\\.\\-]*';
 const queryStringClause = '(\\?' + queryStringHashFragmentCharacterSet + ')?';
 const hashFragmentClause = '(#' + queryStringHashFragmentCharacterSet + ')?';
@@ -1,14 +0,0 @@
-/**
- * Copyright (c) 2018 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { Terminal } from 'xterm';
-
-export interface ITerminalCore {
-  buffer: any;
-}
-
-export interface IWinptyCompatAddonTerminal extends Terminal {
-  _core: ITerminalCore;
-}
@@ -1,5 +0,0 @@
-{
-  "name": "xterm.winptycompat",
-  "main": "winptyCompat.js",
-  "private": true
-}
@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "commonjs",
-    "target": "es5",
-    "lib": [
-      "dom",
-      "es6",
-    ],
-    "rootDir": ".",
-    "outDir": "../../../lib/addons/winptyCompat/",
-    "sourceMap": true,
-    "removeComments": true,
-    "declaration": true,
-    "preserveWatchOutput": true
-  },
-  "include": [
-    "**/*.ts",
-    "../../../typings/xterm.d.ts"
-  ]
-}
@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { assert, expect } from 'chai';
-
-import * as winptyCompat from './winptyCompat';
-
-class MockTerminal {}
-
-describe('winptyCompat addon', () => {
-  describe('apply', () => {
-    it('should do register the `winptyCompatInit` method', () => {
-      winptyCompat.apply(<any>MockTerminal);
-      assert.equal(typeof (<any>MockTerminal).prototype.winptyCompatInit, 'function');
-    });
-  });
-});
@@ -1,46 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { Terminal } from 'xterm';
-import { IWinptyCompatAddonTerminal } from './Interfaces';
-
-const CHAR_DATA_CODE_INDEX = 3;
-const NULL_CELL_CODE = 32;
-
-export function winptyCompatInit(terminal: Terminal): void {
-  const addonTerminal = <IWinptyCompatAddonTerminal>terminal;
-
-  // Don't do anything when the platform is not Windows
-  const isWindows = ['Windows', 'Win16', 'Win32', 'WinCE'].indexOf(navigator.platform) >= 0;
-  if (!isWindows) {
-    return;
-  }
-
-  // Winpty does not support wraparound mode which means that lines will never
-  // be marked as wrapped. This causes issues for things like copying a line
-  // retaining the wrapped new line characters or if consumers are listening
-  // in on the data stream.
-  //
-  // The workaround for this is to listen to every incoming line feed and mark
-  // the line as wrapped if the last character in the previous line is not a
-  // space. This is certainly not without its problems, but generally on
-  // Windows when text reaches the end of the terminal it's likely going to be
-  // wrapped.
-  addonTerminal.on('linefeed', () => {
-    const line = addonTerminal._core.buffer.lines.get(addonTerminal._core.buffer.ybase + addonTerminal._core.buffer.y - 1);
-    const lastChar = line.get(addonTerminal.cols - 1);
-
-    if (lastChar[CHAR_DATA_CODE_INDEX] !== NULL_CELL_CODE) {
-      const nextLine = addonTerminal._core.buffer.lines.get(addonTerminal._core.buffer.ybase + addonTerminal._core.buffer.y);
-      nextLine.isWrapped = true;
-    }
-  });
-}
-
-export function apply(terminalConstructor: typeof Terminal): void {
-  (<any>terminalConstructor.prototype).winptyCompatInit = function (): void {
-    winptyCompatInit(this);
-  };
-}
@@ -3,15 +3,16 @@
    "module": "commonjs",
    "target": "es5",
    "lib": [
-      "dom",
-      "es6",
+      "es5"
    ],
    "rootDir": ".",
    "outDir": "../../../lib/addons/zmodem/",
    "sourceMap": true,
    "removeComments": true,
    "declaration": true,
-    "preserveWatchOutput": true
+    "types": [
+      "../../node_modules/@types/mocha"
+    ]
  },
  "include": [
    "**/*.ts",
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { assert, expect } from 'chai';
+import { assert } from 'chai';

 import * as zmodem from './zmodem';

@@ -34,7 +34,7 @@ import { Terminal } from 'xterm';
 *  via `detach()` and a re-`attach()`.)
 */

-let zmodem;
+let zmodem: any;

 export interface IZmodemOptions {
  noTerminalWriteOutsideSession?: boolean;
@@ -44,7 +44,7 @@ function zmodemAttach(ws: WebSocket, opts: IZmodemOptions = {}): void {
  const term = this;
  const senderFunc = (octets: ArrayLike<number>) => ws.send(new Uint8Array(octets));

-  let zsentry;
+  let zsentry: any;

  function shouldWrite(): boolean {
    return !!zsentry.get_confirmed_session() || !opts.noTerminalWriteOutsideSession;
@@ -3,22 +3,38 @@
 * @license MIT
 */

-import { EventEmitter } from './EventEmitter';
 import { ICircularList } from './Types';
+import { EventEmitter2, IEvent } from './EventEmitter2';
+
+export interface IInsertEvent {
+  index: number;
+  amount: number;
+}
+
+export interface IDeleteEvent {
+  index: number;
+  amount: number;
+}

 /**
 * Represents a circular list; a list with a maximum size that wraps around when push is called,
 * overriding values at the start of the list.
 */
-export class CircularList<T> extends EventEmitter implements ICircularList<T> {
+export class CircularList<T> implements ICircularList<T> {
  protected _array: (T | undefined)[];
  private _startIndex: number;
  private _length: number;

+  public onDeleteEmitter = new EventEmitter2<IDeleteEvent>();
+  public get onDelete(): IEvent<IDeleteEvent> { return this.onDeleteEmitter.event; }
+  public onInsertEmitter = new EventEmitter2<IInsertEvent>();
+  public get onInsert(): IEvent<IInsertEvent> { return this.onInsertEmitter.event; }
+  public onTrimEmitter = new EventEmitter2<number>();
+  public get onTrim(): IEvent<number> { return this.onTrimEmitter.event; }
+
  constructor(
    private _maxLength: number
  ) {
-    super();
    this._array = new Array<T>(this._maxLength);
    this._startIndex = 0;
    this._length = 0;
@@ -90,16 +106,34 @@ export class CircularList<T> extends EventEmitter implements ICircularList<T> {
  public push(value: T): void {
    this._array[this._getCyclicIndex(this._length)] = value;
    if (this._length === this._maxLength) {
-      this._startIndex++;
-      if (this._startIndex === this._maxLength) {
-        this._startIndex = 0;
-      }
-      this.emit('trim', 1);
+      this._startIndex = ++this._startIndex % this._maxLength;
+      this.onTrimEmitter.fire(1);
    } else {
      this._length++;
    }
  }

+  /**
+   * Advance ringbuffer index and return current element for recycling.
+   * Note: The buffer must be full for this method to work.
+   * @throws When the buffer is not full.
+   */
+  public recycle(): T {
+    if (this._length !== this._maxLength) {
+      throw new Error('Can only recycle when the buffer is full');
+    }
+    this._startIndex = ++this._startIndex % this._maxLength;
+    this.onTrimEmitter.fire(1);
+    return this._array[this._getCyclicIndex(this._length - 1)]!;
+  }
+
+  /**
+   * Ringbuffer is at max length.
+   */
+  public get isFull(): boolean {
+    return this._length === this._maxLength;
+  }
+
  /**
   * Removes and returns the last value on the list.
   * @return The popped value.
@@ -126,24 +160,22 @@ export class CircularList<T> extends EventEmitter implements ICircularList<T> {
      this._length -= deleteCount;
    }

-    if (items && items.length) {
-      // Add items
-      for (let i = this._length - 1; i >= start; i--) {
-        this._array[this._getCyclicIndex(i + items.length)] = this._array[this._getCyclicIndex(i)];
-      }
-      for (let i = 0; i < items.length; i++) {
-        this._array[this._getCyclicIndex(start + i)] = items[i];
-      }
+    // Add items
+    for (let i = this._length - 1; i >= start; i--) {
+      this._array[this._getCyclicIndex(i + items.length)] = this._array[this._getCyclicIndex(i)];
+    }
+    for (let i = 0; i < items.length; i++) {
+      this._array[this._getCyclicIndex(start + i)] = items[i];
+    }

-      // Adjust length as needed
-      if (this._length + items.length > this.maxLength) {
-        const countToTrim = (this._length + items.length) - this.maxLength;
-        this._startIndex += countToTrim;
-        this._length = this.maxLength;
-        this.emit('trim', countToTrim);
-      } else {
-        this._length += items.length;
-      }
+    // Adjust length as needed
+    if (this._length + items.length > this._maxLength) {
+      const countToTrim = (this._length + items.length) - this._maxLength;
+      this._startIndex += countToTrim;
+      this._length = this._maxLength;
+      this.onTrimEmitter.fire(countToTrim);
+    } else {
+      this._length += items.length;
    }
  }

@@ -157,7 +189,7 @@ export class CircularList<T> extends EventEmitter implements ICircularList<T> {
    }
    this._startIndex += count;
    this._length -= count;
-    this.emit('trim', count);
+    this.onTrimEmitter.fire(count);
  }

  public shiftElements(start: number, count: number, offset: number): void {
@@ -178,10 +210,10 @@ export class CircularList<T> extends EventEmitter implements ICircularList<T> {
      const expandListBy = (start + count + offset) - this._length;
      if (expandListBy > 0) {
        this._length += expandListBy;
-        while (this._length > this.maxLength) {
+        while (this._length > this._maxLength) {
          this._length--;
          this._startIndex++;
-          this.emit('trim', 1);
+          this.onTrimEmitter.fire(1);
        }
      }
    } else {
@@ -198,6 +230,6 @@ export class CircularList<T> extends EventEmitter implements ICircularList<T> {
   * @returns The cyclic index.
   */
  private _getCyclicIndex(index: number): number {
-    return (this._startIndex + index) % this.maxLength;
+    return (this._startIndex + index) % this._maxLength;
  }
 }
@@ -101,7 +101,7 @@ describe('clone', () => {
    test.a.b.c.d.e.f = 'bar';

    // The values at a greater depth then 5 should not be cloned
-    assert.equal(cloned.a.b.c.d.e.f, 'bar');
+    assert.equal((cloned as any).a.b.c.d.e.f, 'bar');
  });

  it('should allow an optional maximum depth to be set', () => {
@@ -118,7 +118,7 @@ describe('clone', () => {
    test.a.b.c = 'bar';

    // The values at a greater depth then 2 should not be cloned
-    assert.equal(cloned.a.b.c, 'bar');
+    assert.equal((cloned as any).a.b.c, 'bar');
  });

  it('should not throw when cloning a recursive reference', () => {
@@ -6,7 +6,7 @@
 /*
 * A simple utility for cloning values
 */
-export const clone = <T>(val: T, depth: number = 5): T => {
+export function clone<T>(val: T, depth: number = 5): T | null {
  if (typeof val !== 'object') {
    return val;
  }
@@ -25,4 +25,4 @@ export const clone = <T>(val: T, depth: number = 5): T => {
  }

  return clonedObject as T;
-};
+}
@@ -3,8 +3,7 @@
 * @license MIT
 */

-import { XtermListener } from './Types';
-import { IEventEmitter, IDisposable } from 'xterm';
+import { IDisposable, IEventEmitter, XtermListener } from './Types';
 import { Disposable } from './Lifecycle';

 export class EventEmitter extends Disposable implements IEventEmitter, IDisposable {
@@ -14,7 +13,7 @@ export class EventEmitter extends Disposable implements IEventEmitter, IDisposab
    super();
    // Restore the previous events if available, this will happen if the
    // constructor is called multiple times on the same object (terminal reset).
-    this._events = this._events || {};
+    this._events = (<any>this)._events || {};
  }

  public on(type: string, listener: XtermListener): void {
@@ -23,7 +22,7 @@ export class EventEmitter extends Disposable implements IEventEmitter, IDisposab
  }

  /**
-   * Adds a disposabe listener to the EventEmitter, returning the disposable.
+   * Adds a disposable listener to the EventEmitter, returning the disposable.
   * @param type The event type.
   * @param handler The handler for the listener.
   */
@@ -75,6 +74,19 @@ export class EventEmitter extends Disposable implements IEventEmitter, IDisposab
    }
  }

+  public emitMayRemoveListeners(type: string, ...args: any[]): void {
+    if (!this._events[type]) {
+      return;
+    }
+    const obj = this._events[type];
+    let length = obj.length;
+    for (let i = 0; i < obj.length; i++) {
+      obj[i].apply(this, args);
+      i -= length - obj.length;
+      length = obj.length;
+    }
+  }
+
  public listeners(type: string): XtermListener[] {
    return this._events[type] || [];
  }
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { assert } from 'chai';
+import { EventEmitter2 } from './EventEmitter2';
+
+describe('EventEmitter2', () => {
+  it('should fire listeners multiple times', () => {
+    const order: string[] = [];
+    const emitter = new EventEmitter2<number>();
+    emitter.event(data => order.push(data + 'a'));
+    emitter.event(data => order.push(data + 'b'));
+    emitter.fire(1);
+    emitter.fire(2);
+    assert.deepEqual(order, [ '1a', '1b', '2a', '2b' ]);
+  });
+
+  it('should not fire listeners once disposed', () => {
+    const order: string[] = [];
+    const emitter = new EventEmitter2<number>();
+    emitter.event(data => order.push(data + 'a'));
+    const disposeB = emitter.event(data => order.push(data + 'b'));
+    emitter.event(data => order.push(data + 'c'));
+    emitter.fire(1);
+    disposeB.dispose();
+    emitter.fire(2);
+    assert.deepEqual(order, [ '1a', '1b', '1c', '2a', '2c' ]);
+  });
+});
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IDisposable } from './Types';
+
+interface IListener<T> {
+  (e: T): void;
+}
+
+export interface IEvent<T> {
+  (listener: (e: T) => any): IDisposable;
+}
+
+export class EventEmitter2<T> {
+  private _listeners: IListener<T>[] = [];
+  private _event?: IEvent<T>;
+
+  public get event(): IEvent<T> {
+    if (!this._event) {
+      this._event = (listener: (e: T) => any) => {
+        this._listeners.push(listener);
+        const disposable = {
+          dispose: () => {
+            for (let i = 0; i < this._listeners.length; i++) {
+              if (this._listeners[i] === listener) {
+                this._listeners.splice(i, 1);
+                return;
+              }
+            }
+          }
+        };
+        return disposable;
+      };
+    }
+    return this._event;
+  }
+
+  public fire(data: T): void {
+    const queue: IListener<T>[] = [];
+    for (let i = 0; i < this._listeners.length; i++) {
+      queue.push(this._listeners[i]);
+    }
+    for (let i = 0; i < queue.length; i++) {
+      queue[i].call(undefined, data);
+    }
+  }
+}
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { IDisposable } from 'xterm';
+import { IDisposable } from './Types';

 /**
 * A base class that can be extended to provide convenience methods for managing the lifecycle of an
--- a/Show More
+++ b/Show More