Bump version to 2.3.1

Signed-off-by: Paris Kasidiaris <paris@sourcelair.com>

.dockerignore

@@ -0,0 +1,16 @@
+node_modules/
+*.swp
+.lock-wscript
+lib/
+Makefile.gyp
+*.Makefile
+*.target.gyp.mk
+*.node
+example/*.log
+docs/
+npm-debug.log
+/.idea/
+.env
+build/
+.vscode/
+.git/

.editorconfig

@@ -5,6 +5,7 @@ indent_style = space
 indent_size = 2
 insert_final_newline = true
 trim_trailing_whitespace = true
+end_of_line = lf
 
 [*.{j,t}s]
 max_line_length = 100

.gitignore

@@ -12,3 +12,4 @@ npm-debug.log
 /.idea/
 .env
 build/
+.vscode/

.vscode/launch.json

@@ -0,0 +1,23 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Mocha 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"
+    }
+  ]
+}

AUTHORS

@@ -7,7 +7,10 @@ Anton Skshidlevsky <meefik@gmail.com>
 Anton Yurovskykh <anton.yurovskykh@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>
+Bill Church <billchurch@users.noreply.github.com>
+Bob Reid <bobreid@Bobs-MacBook-Pro.local>
 bottleofwater <nison.mael+bottleofwater@gmail.com>
 Carson Anderson <carson@betterservers.com>
 Christian Budde Christensen <budde377@gmail.com>
@@ -22,13 +25,17 @@ Ian Lewis <ianlewis@google.com>
 imoses <ido@twiggle.com>
 Jean Bruenn <himself@jeanbruenn.info>
 Jörg Breitbart <jerch@rockborn.de>
+Lucian Buzzo <lucian.buzzo@gmail.com>
 Maël Nison <nison.mael@gmail.com>
 Mikko Karvonen <mikko.karvonen@arm.com>
 Paris Kasidiaris <pariskasidiaris@gmail.com>
 Paris Kasidiaris <paris@sourcelair.com>
 runarberg <runar@greenqloud.com>
+Saswat Das <saswatds@users.noreply.github.com>
 Shuanglei Tao <tsl0922@gmail.com>
 Steven Silvester <steven.silvester@ieee.org>
 Thanasis Daglis <thanasis@sourcelair.com>
 Tine Jozelj <tine.jozelj@outlook.com>
+Tyler Jewell <tjewell@codenvy.com>
+Vincent Woo <me@vincentwoo.com>
 YuviPanda <yuvipanda@gmail.com>

Dockerfile

@@ -1,4 +1,19 @@
-FROM node:4-onbuild
+FROM node:6.9
 MAINTAINER Paris Kasidiaris <paris@sourcelair.com>
 
-EXPOSE 3000
+# Set the working directory
+WORKDIR /usr/src/app
+
+# Set an entrypoint, to automatically install node modules
+ENTRYPOINT ["/bin/bash", "-c", "if [[ ! -d node_modules ]]; then npm install; fi; exec \"${@:0}\";"]
+CMD ["npm", "run", "dev"]
+
+# First, install dependencies to improve layer caching
+COPY package.json /usr/src/app/
+RUN npm install
+
+# Add the code
+COPY . /usr/src/app
+
+# Run the tests and build, to make sure everything is working nicely
+RUN npm run build && npm run test

Procfile

@@ -0,0 +1 @@
+web: npm start

Procfile.dev

@@ -1 +1 @@
-web: npm start
+web: npm run dev

README.md

@@ -25,6 +25,11 @@ Xterm.js is used in several world-class applications to provide great terminal e
 - [**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.
 
 Do you use xterm.js in your application as well? Please [open a Pull Request](https://github.com/sourcelair/xterm.js/pulls) to include it here. We would love to have it in our list.
 
@@ -52,6 +57,28 @@ npm start
 
 Then open http://0.0.0.0:3000 in a web browser (use http://127.0.0.1:3000 if running under Windows).
 
+## Getting Started
+
+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.
+```html
+<!doctype html>
+  <html>
+    <head>
+      <link rel="stylesheet" href="bower_components/xterm.js/dist/xterm.css" />
+      <script src="bower_components/xterm.js/dist/xterm.js"></script>
+    </head>
+    <body>
+      <div id="terminal"></div>
+      <script>
+      	var term = new Terminal();
+        term.open(document.getElementById('#terminal'));
+        term.write('Hello from \033[1;3;31mxterm.js\033[0m $ ')
+      </script>
+    </body>
+  </html>
+```
+Finally instantiate the `Terminal` object and then call the `open` function with the DOM object of the `div`.  
+
 ## Addons
 
 Addons are JavaScript modules that attach functions to the `Terminal` prototype to extend its functionality. There are a handful available in the main repository in the `dist/addons` directory, you can even write your own (though they may break when the internals of xterm.js change across versions).
@@ -93,6 +120,14 @@ Visit https://lair.io/sourcelair/xterm and follow the instructions. All developm
 
 [Download Visual Studio Code](http://code.visualstudio.com/Download), clone xterm.js and you are all set.
 
+#### [Eclipse Che](http://www.eclipse.org/che)
+
+You can start Eclipse Che with `docker run eclipse/che start`.
+
+#### [Codenvy](http://www.codenvy.io)
+
+You can create a trial account or install an enterprise version with `docker run codenvy/cli start`.
+
 ## License Agreement
 
 If you contribute code to this project, you are implicitly allowing your code to be distributed under the MIT license. You are also implicitly verifying that all code is your original work.

bin/build

@@ -1,36 +0,0 @@
-#! /usr/bin/env bash
-
-set -e
-
-# $BUILD_DIR should default to "build"
-BUILD_DIR=${BUILD_DIR:=build}
-
-# Create the build directory
-mkdir -p $BUILD_DIR
-
-
-# Clean lib/* to prevent confusion if files were deleted in src/
-rm -rf lib/*
-
-# Build all TypeScript files (including tests) to lib/
-tsc
-
-# Concat all xterm.js files into a single file and output as a UMD to $BUILD_DIR/xterm.js
-browserify ./lib/xterm.js --standalone Terminal --debug --outfile ./$BUILD_DIR/xterm.js
-cat ./$BUILD_DIR/xterm.js | exorcist ./$BUILD_DIR/xterm.js.map -b ./$BUILD_DIR > ./$BUILD_DIR/xterm.temp.js
-rm ./$BUILD_DIR/xterm.js
-mv ./$BUILD_DIR/xterm.temp.js ./$BUILD_DIR/xterm.js
-
-# Resolve the chain of sourcemaps so that ./$BUILD_DIR/xterm.js.map points at ./src
-sorcery -i $BUILD_DIR/xterm.js
-
-# Copy all CSS files from src/ to $BUILD_DIR/ and lib/
-cd src
-find . -name '*.css' | cpio -pdm ../$BUILD_DIR
-find . -name '*.css' | cpio -pdm ../lib
-cd ..
-
-# Copy addons from lib/ to $BUILD_DIR/
-cd lib/addons
-find . -name '*.js' | cpio -pdm ../../$BUILD_DIR/addons
-cd ../..

bin/prepare-release

@@ -21,7 +21,7 @@ CURRENT_BOWER_JSON_VERSION=$(cat bower.json \
 
 # Build xterm.js into `dist`
 export BUILD_DIR=dist
-./bin/build
+npm run build
 
 # Update AUTHORS file
 sh bin/generate-authors

bower.json

@@ -1,6 +1,6 @@
 {
   "name": "xterm.js",
-  "version": "2.2.3",
+  "version": "2.3.1",
   "ignore": ["demo", "test", ".gitignore"],
   "main": [
     "dist/xterm.js",

demo/app.js

@@ -2,7 +2,7 @@ var express = require('express');
 var app = express();
 var expressWs = require('express-ws')(app);
 var os = require('os');
-var pty = require('pty.js');
+var pty = require('node-pty');
 
 var terminals = {},
     logs = {};

demo/index.html

@@ -16,7 +16,15 @@
         <div id="terminal-container"></div>
         <div>
           <h2>Options</h2>
-          <label><input type="checkbox" id="option-cursor-blink"> cursorBlink</label>
+          <p>
+            <label><input type="checkbox" id="option-cursor-blink"> cursorBlink</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>

demo/main.js

@@ -8,14 +8,16 @@ var term,
 
 var terminalContainer = document.getElementById('terminal-container'),
     optionElements = {
-      cursorBlink: document.querySelector('#option-cursor-blink')
+      cursorBlink: document.querySelector('#option-cursor-blink'),
+      scrollback: document.querySelector('#option-scrollback'),
+      tabstopwidth: document.querySelector('#option-tabstopwidth')
     },
     colsElement = document.getElementById('cols'),
     rowsElement = document.getElementById('rows');
 
 function setTerminalSize () {
-  var cols = parseInt(colsElement.value),
-      rows = parseInt(rowsElement.value),
+  var cols = parseInt(colsElement.value, 10),
+      rows = parseInt(rowsElement.value, 10),
       width = (cols * charWidth).toString() + 'px',
       height = (rows * charHeight).toString() + 'px';
 
@@ -27,7 +29,15 @@ function setTerminalSize () {
 colsElement.addEventListener('change', setTerminalSize);
 rowsElement.addEventListener('change', setTerminalSize);
 
-optionElements.cursorBlink.addEventListener('change', createTerminal);
+optionElements.cursorBlink.addEventListener('change', function () {
+  term.setOption('cursorBlink', optionElements.cursorBlink.checked);
+});
+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();
 
@@ -37,7 +47,9 @@ function createTerminal() {
     terminalContainer.removeChild(terminalContainer.children[0]);
   }
   term = new Terminal({
-    cursorBlink: optionElements.cursorBlink.checked
+    cursorBlink: optionElements.cursorBlink.checked,
+    scrollback: parseInt(optionElements.scrollback.value, 10),
+    tabStopWidth: parseInt(optionElements.tabstopwidth.value, 10)
   });
   term.on('resize', function (size) {
     if (!pid) {
@@ -78,7 +90,6 @@ function createTerminal() {
   });
 }
 
-
 function runRealTerminal() {
   term.attach(socket);
   term._initialized = true;

demo/style.css

@@ -20,7 +20,3 @@ h1 {
     color: #fafafa;
     padding: 2px;
 }
-
-#terminal-container .terminal:focus .terminal-cursor {
-    background-color: #fafafa;
-}

dist/addons/attach/attach.js

@@ -3,112 +3,124 @@
  * @module xterm/addons/attach/attach
  * @license MIT
  */
+
 (function (attach) {
-    if (typeof exports === 'object' && typeof module === 'object') {
-        /*
-         * CommonJS environment
-         */
-        module.exports = attach(require('../../xterm'));
-    }
-    else if (typeof define == 'function') {
-        /*
-         * Require.js is available
-         */
-        define(['../../xterm'], attach);
-    }
-    else {
-        /*
-         * Plain browser environment
-         */
-        attach(window.Terminal);
-    }
+  if (typeof exports === 'object' && typeof module === 'object') {
+    /*
+     * CommonJS environment
+     */
+    module.exports = attach(require('../../xterm'));
+  } else if (typeof define == 'function') {
+    /*
+     * Require.js is available
+     */
+    define(['../../xterm'], attach);
+  } else {
+    /*
+     * Plain browser environment
+     */
+    attach(window.Terminal);
+  }
 })(function (Xterm) {
-    'use strict';
-    var exports = {};
-    /**
-     * Attaches the given terminal to the given socket.
-     *
-     * @param {Xterm} term - The terminal to be attached to the given socket.
-     * @param {WebSocket} socket - The socket to attach the current terminal.
-     * @param {boolean} bidirectional - Whether the terminal should send data
-     *                                  to the socket as well.
-     * @param {boolean} buffered - Whether the rendering of incoming data
-     *                             should happen instantly or at a maximum
-     *                             frequency of 1 rendering per 10ms.
-     */
-    exports.attach = function (term, socket, bidirectional, buffered) {
-        bidirectional = (typeof bidirectional == 'undefined') ? true : bidirectional;
-        term.socket = socket;
-        term._flushBuffer = function () {
-            term.write(term._attachSocketBuffer);
-            term._attachSocketBuffer = null;
-            clearTimeout(term._attachSocketBufferTimer);
-            term._attachSocketBufferTimer = null;
-        };
-        term._pushToBuffer = function (data) {
-            if (term._attachSocketBuffer) {
-                term._attachSocketBuffer += data;
-            }
-            else {
-                term._attachSocketBuffer = data;
-                setTimeout(term._flushBuffer, 10);
-            }
-        };
-        term._getMessage = function (ev) {
-            if (buffered) {
-                term._pushToBuffer(ev.data);
-            }
-            else {
-                term.write(ev.data);
-            }
-        };
-        term._sendData = function (data) {
-            socket.send(data);
-        };
-        socket.addEventListener('message', term._getMessage);
-        if (bidirectional) {
-            term.on('data', term._sendData);
-        }
-        socket.addEventListener('close', term.detach.bind(term, socket));
-        socket.addEventListener('error', term.detach.bind(term, socket));
+  'use strict';
+
+  var exports = {};
+
+  /**
+   * Attaches the given terminal to the given socket.
+   *
+   * @param {Xterm} term - The terminal to be attached to the given socket.
+   * @param {WebSocket} socket - The socket to attach the current terminal.
+   * @param {boolean} bidirectional - Whether the terminal should send data
+   *                                  to the socket as well.
+   * @param {boolean} buffered - Whether the rendering of incoming data
+   *                             should happen instantly or at a maximum
+   *                             frequency of 1 rendering per 10ms.
+   */
+  exports.attach = function (term, socket, bidirectional, buffered) {
+    bidirectional = (typeof bidirectional == 'undefined') ? true : bidirectional;
+    term.socket = socket;
+
+    term._flushBuffer = function () {
+      term.write(term._attachSocketBuffer);
+      term._attachSocketBuffer = null;
+      clearTimeout(term._attachSocketBufferTimer);
+      term._attachSocketBufferTimer = null;
     };
-    /**
-     * Detaches the given terminal from the given socket
-     *
-     * @param {Xterm} term - The terminal to be detached from the given socket.
-     * @param {WebSocket} socket - The socket from which to detach the current
-     *                             terminal.
-     */
-    exports.detach = function (term, socket) {
-        term.off('data', term._sendData);
-        socket = (typeof socket == 'undefined') ? term.socket : socket;
-        if (socket) {
-            socket.removeEventListener('message', term._getMessage);
-        }
-        delete term.socket;
+
+    term._pushToBuffer = function (data) {
+      if (term._attachSocketBuffer) {
+        term._attachSocketBuffer += data;
+      } else {
+        term._attachSocketBuffer = data;
+        setTimeout(term._flushBuffer, 10);
+      }
     };
-    /**
-     * Attaches the current terminal to the given socket
-     *
-     * @param {WebSocket} socket - The socket to attach the current terminal.
-     * @param {boolean} bidirectional - Whether the terminal should send data
-     *                                  to the socket as well.
-     * @param {boolean} buffered - Whether the rendering of incoming data
-     *                             should happen instantly or at a maximum
-     *                             frequency of 1 rendering per 10ms.
-     */
-    Xterm.prototype.attach = function (socket, bidirectional, buffered) {
-        return exports.attach(this, socket, bidirectional, buffered);
+
+    term._getMessage = function (ev) {
+      if (buffered) {
+        term._pushToBuffer(ev.data);
+      } else {
+        term.write(ev.data);
+      }
     };
-    /**
-     * Detaches the current terminal from the given socket.
-     *
-     * @param {WebSocket} socket - The socket from which to detach the current
-     *                             terminal.
-     */
-    Xterm.prototype.detach = function (socket) {
-        return exports.detach(this, socket);
+
+    term._sendData = function (data) {
+      socket.send(data);
     };
-    return exports;
+
+    socket.addEventListener('message', term._getMessage);
+
+    if (bidirectional) {
+      term.on('data', term._sendData);
+    }
+
+    socket.addEventListener('close', term.detach.bind(term, socket));
+    socket.addEventListener('error', term.detach.bind(term, socket));
+  };
+
+  /**
+   * Detaches the given terminal from the given socket
+   *
+   * @param {Xterm} term - The terminal to be detached from the given socket.
+   * @param {WebSocket} socket - The socket from which to detach the current
+   *                             terminal.
+   */
+  exports.detach = function (term, socket) {
+    term.off('data', term._sendData);
+
+    socket = (typeof socket == 'undefined') ? term.socket : socket;
+
+    if (socket) {
+      socket.removeEventListener('message', term._getMessage);
+    }
+
+    delete term.socket;
+  };
+
+  /**
+   * Attaches the current terminal to the given socket
+   *
+   * @param {WebSocket} socket - The socket to attach the current terminal.
+   * @param {boolean} bidirectional - Whether the terminal should send data
+   *                                  to the socket as well.
+   * @param {boolean} buffered - Whether the rendering of incoming data
+   *                             should happen instantly or at a maximum
+   *                             frequency of 1 rendering per 10ms.
+   */
+  Xterm.prototype.attach = function (socket, bidirectional, buffered) {
+    return exports.attach(this, socket, bidirectional, buffered);
+  };
+
+  /**
+   * Detaches the current terminal from the given socket.
+   *
+   * @param {WebSocket} socket - The socket from which to detach the current
+   *                             terminal.
+   */
+  Xterm.prototype.detach = function (socket) {
+    return exports.detach(this, socket);
+  };
+
+  return exports;
 });
-//# sourceMappingURL=attach.js.map

dist/addons/fit/fit.js

@@ -10,50 +10,72 @@
  * @module xterm/addons/fit/fit
  * @license MIT
  */
+
 (function (fit) {
-    if (typeof exports === 'object' && typeof module === 'object') {
-        /*
-         * CommonJS environment
-         */
-        module.exports = fit(require('../../xterm'));
-    }
-    else if (typeof define == 'function') {
-        /*
-         * Require.js is available
-         */
-        define(['../../xterm'], fit);
-    }
-    else {
-        /*
-         * Plain browser environment
-         */
-        fit(window.Terminal);
-    }
+  if (typeof exports === 'object' && typeof module === 'object') {
+    /*
+     * CommonJS environment
+     */
+    module.exports = fit(require('../../xterm'));
+  } else if (typeof define == 'function') {
+    /*
+     * Require.js is available
+     */
+    define(['../../xterm'], fit);
+  } else {
+    /*
+     * Plain browser environment
+     */
+    fit(window.Terminal);
+  }
 })(function (Xterm) {
-    var exports = {};
-    exports.proposeGeometry = function (term) {
-        var parentElementStyle = window.getComputedStyle(term.element.parentElement), parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height')), parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')) - 17), elementStyle = window.getComputedStyle(term.element), elementPaddingVer = parseInt(elementStyle.getPropertyValue('padding-top')) + parseInt(elementStyle.getPropertyValue('padding-bottom')), elementPaddingHor = parseInt(elementStyle.getPropertyValue('padding-right')) + parseInt(elementStyle.getPropertyValue('padding-left')), availableHeight = parentElementHeight - elementPaddingVer, availableWidth = parentElementWidth - elementPaddingHor, container = term.rowContainer, subjectRow = term.rowContainer.firstElementChild, contentBuffer = subjectRow.innerHTML, characterHeight, rows, characterWidth, cols, geometry;
-        subjectRow.style.display = 'inline';
-        subjectRow.innerHTML = 'W'; // Common character for measuring width, although on monospace
-        characterWidth = subjectRow.getBoundingClientRect().width;
-        subjectRow.style.display = ''; // Revert style before calculating height, since they differ.
-        characterHeight = parseInt(subjectRow.offsetHeight);
-        subjectRow.innerHTML = contentBuffer;
-        rows = parseInt(availableHeight / characterHeight);
-        cols = parseInt(availableWidth / characterWidth);
-        geometry = { cols: cols, rows: rows };
-        return geometry;
-    };
-    exports.fit = function (term) {
-        var geometry = exports.proposeGeometry(term);
-        term.resize(geometry.cols, geometry.rows);
-    };
-    Xterm.prototype.proposeGeometry = function () {
-        return exports.proposeGeometry(this);
-    };
-    Xterm.prototype.fit = function () {
-        return exports.fit(this);
-    };
-    return exports;
+  var exports = {};
+
+  exports.proposeGeometry = function (term) {
+    var parentElementStyle = window.getComputedStyle(term.element.parentElement),
+        parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height')),
+        parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')) - 17),
+        elementStyle = window.getComputedStyle(term.element),
+        elementPaddingVer = parseInt(elementStyle.getPropertyValue('padding-top')) + parseInt(elementStyle.getPropertyValue('padding-bottom')),
+        elementPaddingHor = parseInt(elementStyle.getPropertyValue('padding-right')) + parseInt(elementStyle.getPropertyValue('padding-left')),
+        availableHeight = parentElementHeight - elementPaddingVer,
+        availableWidth = parentElementWidth - elementPaddingHor,
+        container = term.rowContainer,
+        subjectRow = term.rowContainer.firstElementChild,
+        contentBuffer = subjectRow.innerHTML,
+        characterHeight,
+        rows,
+        characterWidth,
+        cols,
+        geometry;
+
+    subjectRow.style.display = 'inline';
+    subjectRow.innerHTML = 'W'; // Common character for measuring width, although on monospace
+    characterWidth = subjectRow.getBoundingClientRect().width;
+    subjectRow.style.display = ''; // Revert style before calculating height, since they differ.
+    characterHeight = parseInt(subjectRow.offsetHeight);
+    subjectRow.innerHTML = contentBuffer;
+
+    rows = parseInt(availableHeight / characterHeight);
+    cols = parseInt(availableWidth / characterWidth);
+
+    geometry = {cols: cols, rows: rows};
+    return geometry;
+  };
+
+  exports.fit = function (term) {
+    var geometry = exports.proposeGeometry(term);
+
+    term.resize(geometry.cols, geometry.rows);
+  };
+
+  Xterm.prototype.proposeGeometry = function () {
+    return exports.proposeGeometry(this);
+  };
+
+  Xterm.prototype.fit = function () {
+    return exports.fit(this);
+  };
+
+  return exports;
 });
-//# sourceMappingURL=fit.js.map

dist/addons/fullscreen/fullscreen.js

@@ -4,47 +4,47 @@
  * @license MIT
  */
 (function (fullscreen) {
-    if (typeof exports === 'object' && typeof module === 'object') {
-        /*
-         * CommonJS environment
-         */
-        module.exports = fullscreen(require('../../xterm'));
-    }
-    else if (typeof define == 'function') {
-        /*
-         * Require.js is available
-         */
-        define(['../../xterm'], fullscreen);
-    }
-    else {
-        /*
-         * Plain browser environment
-         */
-        fullscreen(window.Terminal);
-    }
-})(function (Xterm) {
-    var exports = {};
-    /**
-     * Toggle the given terminal's fullscreen mode.
-     * @param {Xterm} term - The terminal to toggle full screen mode
-     * @param {boolean} fullscreen - Toggle fullscreen on (true) or off (false)
+  if (typeof exports === 'object' && typeof module === 'object') {
+    /*
+     * CommonJS environment
      */
-    exports.toggleFullScreen = function (term, fullscreen) {
-        var fn;
-        if (typeof fullscreen == 'undefined') {
-            fn = (term.element.classList.contains('fullscreen')) ? 'remove' : 'add';
-        }
-        else if (!fullscreen) {
-            fn = 'remove';
-        }
-        else {
-            fn = 'add';
-        }
-        term.element.classList[fn]('fullscreen');
-    };
-    Xterm.prototype.toggleFullscreen = function (fullscreen) {
-        exports.toggleFullScreen(this, fullscreen);
-    };
-    return exports;
+    module.exports = fullscreen(require('../../xterm'));
+  } else if (typeof define == 'function') {
+    /*
+     * Require.js is available
+     */
+    define(['../../xterm'], fullscreen);
+  } else {
+    /*
+     * Plain browser environment
+     */
+    fullscreen(window.Terminal);
+  }
+})(function (Xterm) {
+  var exports = {};
+
+  /**
+   * Toggle the given terminal's fullscreen mode.
+   * @param {Xterm} term - The terminal to toggle full screen mode
+   * @param {boolean} fullscreen - Toggle fullscreen on (true) or off (false)
+   */
+  exports.toggleFullScreen = function (term, fullscreen) {
+    var fn;
+
+    if (typeof fullscreen == 'undefined') {
+      fn = (term.element.classList.contains('fullscreen')) ? 'remove' : 'add';
+    } else if (!fullscreen) {
+      fn = 'remove';
+    } else {
+      fn = 'add';
+    }
+
+    term.element.classList[fn]('fullscreen');
+  };
+
+  Xterm.prototype.toggleFullscreen = function (fullscreen) {
+    exports.toggleFullScreen(this, fullscreen);
+  };
+
+  return exports;
 });
-//# sourceMappingURL=fullscreen.js.map

dist/addons/linkify/linkify.js

@@ -3,163 +3,205 @@
  * @module xterm/addons/linkify/linkify
  * @license MIT
  */
+
 (function (linkify) {
-    if (typeof exports === 'object' && typeof module === 'object') {
-        /*
-         * CommonJS environment
-         */
-        module.exports = linkify(require('../../xterm'));
-    }
-    else if (typeof define == 'function') {
-        /*
-         * Require.js is available
-         */
-        define(['../../xterm'], linkify);
-    }
-    else {
-        /*
-         * Plain browser environment
-         */
-        linkify(window.Terminal);
-    }
+  if (typeof exports === 'object' && typeof module === 'object') {
+    /*
+     * CommonJS environment
+     */
+    module.exports = linkify(require('../../xterm'));
+  } else if (typeof define == 'function') {
+    /*
+     * Require.js is available
+     */
+    define(['../../xterm'], linkify);
+  } else {
+    /*
+     * Plain browser environment
+     */
+    linkify(window.Terminal);
+  }
 })(function (Xterm) {
-    'use strict';
-    var exports = {}, protocolClause = '(https?:\\/\\/)', domainCharacterSet = '[\\da-z\\.-]+', negatedDomainCharacterSet = '[^\\da-z\\.-]+', domainBodyClause = '(' + domainCharacterSet + ')', tldClause = '([a-z\\.]{2,6})', ipClause = '((\\d{1,3}\\.){3}\\d{1,3})', portClause = '(:\\d{1,5})', hostClause = '((' + domainBodyClause + '\\.' + tldClause + ')|' + ipClause + ')' + portClause + '?', pathClause = '(\\/[\\/\\w\\.-]*)*', negatedPathCharacterSet = '[^\\/\\w\\.-]+', bodyClause = hostClause + pathClause, start = '(?:^|' + negatedDomainCharacterSet + ')(', end = ')($|' + negatedPathCharacterSet + ')', lenientUrlClause = start + protocolClause + '?' + bodyClause + end, strictUrlClause = start + protocolClause + bodyClause + end, lenientUrlRegex = new RegExp(lenientUrlClause), strictUrlRegex = new RegExp(strictUrlClause);
+  'use strict';
+
+  var exports = {},
+      protocolClause = '(https?:\\/\\/)',
+      domainCharacterSet = '[\\da-z\\.-]+',
+      negatedDomainCharacterSet = '[^\\da-z\\.-]+',
+      domainBodyClause = '(' + domainCharacterSet + ')',
+      tldClause = '([a-z\\.]{2,6})',
+      ipClause = '((\\d{1,3}\\.){3}\\d{1,3})',
+      portClause = '(:\\d{1,5})',
+      hostClause = '((' + domainBodyClause + '\\.' + tldClause + ')|' + ipClause + ')' + portClause + '?',
+      pathClause = '(\\/[\\/\\w\\.-]*)*',
+      negatedPathCharacterSet = '[^\\/\\w\\.-]+',
+      bodyClause = hostClause + pathClause,
+      start = '(?:^|' + negatedDomainCharacterSet + ')(',
+      end = ')($|' + negatedPathCharacterSet + ')',
+      lenientUrlClause = start + protocolClause + '?' + bodyClause + end,
+      strictUrlClause = start + protocolClause + bodyClause + end,
+      lenientUrlRegex = new RegExp(lenientUrlClause),
+      strictUrlRegex = new RegExp(strictUrlClause);
+
+  /**
+   * Converts all valid URLs found in the given terminal line into
+   * hyperlinks. The terminal line can be either the HTML element itself
+   * or the index of the termina line in the children of the terminal
+   * rows container.
+   *
+   * @param {Xterm} terminal - The terminal that owns the given line.
+   * @param {number|HTMLDivElement} line - The terminal line that should get
+   *								  		 "linkified".
+   * @param {boolean} lenient - The regex type that will be used to identify links. If lenient is
+   *                            false, the regex requires a protocol clause. Defaults to true.
+   * @param {string} target -  Sets target="" attribute with value provided to links.
+   *                           Default doesn't set target attribute
+   * @emits linkify
+   * @emits linkify:line
+   */
+  exports.linkifyTerminalLine = function (terminal, line, lenient, target) {
+    if (typeof line == 'number') {
+      line = terminal.rowContainer.children[line];
+    } else if (! (line instanceof HTMLDivElement)) {
+      var message = 'The "line" argument should be either a number';
+      message += ' or an HTMLDivElement';
+
+      throw new TypeError(message);
+    }
+
+    if (typeof target === 'undefined') {
+      target = '';
+    } else {
+      target = 'target="' + target + '"';
+    }
+
+    var buffer = document.createElement('span'),
+        nodes = line.childNodes;
+
+    for (var j=0; j<nodes.length; j++) {
+      var node = nodes[j],
+          match;
+
+      /**
+       * Since we cannot access the TextNode's HTML representation
+       * from the instance itself, we assign its data as textContent
+       * to a dummy buffer span, in order to retrieve the TextNode's
+       * HTML representation from the buffer's innerHTML.
+       */
+      buffer.textContent = node.data;
+
+      var nodeHTML = buffer.innerHTML;
+
+      /**
+       * Apply function only on TextNodes
+       */
+      if (node.nodeType != node.TEXT_NODE) {
+        continue;
+      }
+
+      var url = exports.findLinkMatch(node.data, lenient);
+
+      if (!url) {
+        continue;
+      }
+
+      var startsWithProtocol = new RegExp('^' + protocolClause),
+          urlHasProtocol = url.match(startsWithProtocol),
+          href = (urlHasProtocol) ? url : 'http://' + url,
+          link = '<a href="' +  href + '" ' + target + '>' + url + '</a>',
+          newHTML = nodeHTML.replace(url, link);
+
+      line.innerHTML = line.innerHTML.replace(nodeHTML, newHTML);
+    }
+
     /**
-     * Converts all valid URLs found in the given terminal line into
-     * hyperlinks. The terminal line can be either the HTML element itself
-     * or the index of the termina line in the children of the terminal
-     * rows container.
+     * This event gets emitted when conversion of all URL susbtrings
+     * to HTML anchor elements (links) has finished, for a specific
+     * line of the current Xterm instance.
      *
-     * @param {Xterm} terminal - The terminal that owns the given line.
-     * @param {number|HTMLDivElement} line - The terminal line that should get
-     *								  		 "linkified".
-     * @param {boolean} lenient - The regex type that will be used to identify links. If lenient is
-     *                            false, the regex requires a protocol clause. Defaults to true.
-     * @param {string} target -  Sets target="" attribute with value provided to links.
-     *                           Default doesn't set target attribute
-     * @emits linkify
-     * @emits linkify:line
+     * @event linkify:line
      */
-    exports.linkifyTerminalLine = function (terminal, line, lenient, target) {
-        if (typeof line == 'number') {
-            line = terminal.rowContainer.children[line];
-        }
-        else if (!(line instanceof HTMLDivElement)) {
-            var message = 'The "line" argument should be either a number';
-            message += ' or an HTMLDivElement';
-            throw new TypeError(message);
-        }
-        if (typeof target === 'undefined') {
-            target = '';
-        }
-        else {
-            target = 'target="' + target + '"';
-        }
-        var buffer = document.createElement('span'), nodes = line.childNodes;
-        for (var j = 0; j < nodes.length; j++) {
-            var node = nodes[j], match;
-            /**
-             * Since we cannot access the TextNode's HTML representation
-             * from the instance itself, we assign its data as textContent
-             * to a dummy buffer span, in order to retrieve the TextNode's
-             * HTML representation from the buffer's innerHTML.
-             */
-            buffer.textContent = node.data;
-            var nodeHTML = buffer.innerHTML;
-            /**
-             * Apply function only on TextNodes
-             */
-            if (node.nodeType != node.TEXT_NODE) {
-                continue;
-            }
-            var url = exports.findLinkMatch(node.data, lenient);
-            if (!url) {
-                continue;
-            }
-            var startsWithProtocol = new RegExp('^' + protocolClause), urlHasProtocol = url.match(startsWithProtocol), href = (urlHasProtocol) ? url : 'http://' + url, link = '<a href="' + href + '" ' + target + '>' + url + '</a>', newHTML = nodeHTML.replace(url, link);
-            line.innerHTML = line.innerHTML.replace(nodeHTML, newHTML);
-        }
-        /**
-         * This event gets emitted when conversion of all URL susbtrings
-         * to HTML anchor elements (links) has finished, for a specific
-         * line of the current Xterm instance.
-         *
-         * @event linkify:line
-         */
-        terminal.emit('linkify:line', line);
-    };
+    terminal.emit('linkify:line', line);
+  };
+
+  /**
+   * Finds a link within a block of text.
+   *
+   * @param {string} text - The text to search .
+   * @param {boolean} lenient - Whether to use the lenient search.
+   * @return {string} A URL.
+   */
+  exports.findLinkMatch = function (text, lenient) {
+    var match = text.match(lenient ? lenientUrlRegex : strictUrlRegex);
+    if (!match || match.length === 0) {
+      return null;
+    }
+    return match[1];
+  }
+
+  /**
+   * Converts all valid URLs found in the terminal view into hyperlinks.
+   *
+   * @param {Xterm} terminal - The terminal that should get "linkified".
+   * @param {boolean} lenient - The regex type that will be used to identify links. If lenient is
+   *                            false, the regex requires a protocol clause. Defaults to true.
+   * @param {string} target -  Sets target="" attribute with value provided to links.
+   *                           Default doesn't set target attribute
+   * @emits linkify
+   * @emits linkify:line
+   */
+  exports.linkify = function (terminal, lenient, target) {
+    var rows = terminal.rowContainer.children;
+
+    lenient = (typeof lenient == "boolean") ? lenient : true;
+    for (var i=0; i<rows.length; i++) {
+      var line = rows[i];
+
+      exports.linkifyTerminalLine(terminal, line, lenient, target);
+    }
+
     /**
-     * Finds a link within a block of text.
+     * This event gets emitted when conversion of  all URL substrings to
+     * HTML anchor elements (links) has finished for the current Xterm
+     * instance's view.
      *
-     * @param {string} text - The text to search .
-     * @param {boolean} lenient - Whether to use the lenient search.
-     * @return {string} A URL.
+     * @event linkify
      */
-    exports.findLinkMatch = function (text, lenient) {
-        var match = text.match(lenient ? lenientUrlRegex : strictUrlRegex);
-        if (!match || match.length === 0) {
-            return null;
-        }
-        return match[1];
-    };
-    /**
-     * Converts all valid URLs found in the terminal view into hyperlinks.
-     *
-     * @param {Xterm} terminal - The terminal that should get "linkified".
-     * @param {boolean} lenient - The regex type that will be used to identify links. If lenient is
-     *                            false, the regex requires a protocol clause. Defaults to true.
-     * @param {string} target -  Sets target="" attribute with value provided to links.
-     *                           Default doesn't set target attribute
-     * @emits linkify
-     * @emits linkify:line
-     */
-    exports.linkify = function (terminal, lenient, target) {
-        var rows = terminal.rowContainer.children;
-        lenient = (typeof lenient == "boolean") ? lenient : true;
-        for (var i = 0; i < rows.length; i++) {
-            var line = rows[i];
-            exports.linkifyTerminalLine(terminal, line, lenient, target);
-        }
-        /**
-         * This event gets emitted when conversion of  all URL substrings to
-         * HTML anchor elements (links) has finished for the current Xterm
-         * instance's view.
-         *
-         * @event linkify
-         */
-        terminal.emit('linkify');
-    };
-    /**
-     * Extend Xterm prototype.
-     */
-    /**
-     * Converts all valid URLs found in the current terminal linte into
-     * hyperlinks.
-     *
-     * @memberof Xterm
-     * @param {number|HTMLDivElement} line - The terminal line that should get
-     *								  		 "linkified".
-     * @param {boolean} lenient - The regex type that will be used to identify links. If lenient is
-     *                            false, the regex requires a protocol clause. Defaults to true.
-     * @param {string} target -  Sets target="" attribute with value provided to links.
-     *                           Default doesn't set target attribute
-     */
-    Xterm.prototype.linkifyTerminalLine = function (line, lenient, target) {
-        return exports.linkifyTerminalLine(this, line, lenient, target);
-    };
-    /**
-     * Converts all valid URLs found in the current terminal into hyperlinks.
-     *
-     * @memberof Xterm
-     * @param {boolean} lenient - The regex type that will be used to identify links. If lenient is
-     *                            false, the regex requires a protocol clause. Defaults to true.
-     * @param {string} target -  Sets target="" attribute with value provided to links.
-     *                           Default doesn't set target attribute
-     */
-    Xterm.prototype.linkify = function (lenient, target) {
-        return exports.linkify(this, lenient, target);
-    };
-    return exports;
+    terminal.emit('linkify');
+  };
+
+  /**
+   * Extend Xterm prototype.
+   */
+
+  /**
+   * Converts all valid URLs found in the current terminal linte into
+   * hyperlinks.
+   *
+   * @memberof Xterm
+   * @param {number|HTMLDivElement} line - The terminal line that should get
+   *								  		 "linkified".
+   * @param {boolean} lenient - The regex type that will be used to identify links. If lenient is
+   *                            false, the regex requires a protocol clause. Defaults to true.
+   * @param {string} target -  Sets target="" attribute with value provided to links.
+   *                           Default doesn't set target attribute
+   */
+  Xterm.prototype.linkifyTerminalLine = function (line, lenient, target) {
+    return exports.linkifyTerminalLine(this, line, lenient, target);
+  };
+
+  /**
+   * Converts all valid URLs found in the current terminal into hyperlinks.
+   *
+   * @memberof Xterm
+   * @param {boolean} lenient - The regex type that will be used to identify links. If lenient is
+   *                            false, the regex requires a protocol clause. Defaults to true.
+   * @param {string} target -  Sets target="" attribute with value provided to links.
+   *                           Default doesn't set target attribute
+   */
+  Xterm.prototype.linkify = function (lenient, target) {
+    return exports.linkify(this, lenient, target);
+  };
+
+  return exports;
 });
-//# sourceMappingURL=linkify.js.map

dist/addons/terminado/terminado.js

@@ -4,119 +4,132 @@
  * @module xterm/addons/terminado/terminado
  * @license MIT
  */
+
 (function (attach) {
-    if (typeof exports === 'object' && typeof module === 'object') {
-        /*
-         * CommonJS environment
-         */
-        module.exports = attach(require('../../xterm'));
-    }
-    else if (typeof define == 'function') {
-        /*
-         * Require.js is available
-         */
-        define(['../../xterm'], attach);
-    }
-    else {
-        /*
-         * Plain browser environment
-         */
-        attach(window.Terminal);
-    }
+  if (typeof exports === 'object' && typeof module === 'object') {
+    /*
+     * CommonJS environment
+     */
+    module.exports = attach(require('../../xterm'));
+  } else if (typeof define == 'function') {
+    /*
+     * Require.js is available
+     */
+    define(['../../xterm'], attach);
+  } else {
+    /*
+     * Plain browser environment
+     */
+    attach(window.Terminal);
+  }
 })(function (Xterm) {
-    'use strict';
-    var exports = {};
-    /**
-     * Attaches the given terminal to the given socket.
-     *
-     * @param {Xterm} term - The terminal to be attached to the given socket.
-     * @param {WebSocket} socket - The socket to attach the current terminal.
-     * @param {boolean} bidirectional - Whether the terminal should send data
-     *                                  to the socket as well.
-     * @param {boolean} buffered - Whether the rendering of incoming data
-     *                             should happen instantly or at a maximum
-     *                             frequency of 1 rendering per 10ms.
-     */
-    exports.terminadoAttach = function (term, socket, bidirectional, buffered) {
-        bidirectional = (typeof bidirectional == 'undefined') ? true : bidirectional;
-        term.socket = socket;
-        term._flushBuffer = function () {
-            term.write(term._attachSocketBuffer);
-            term._attachSocketBuffer = null;
-            clearTimeout(term._attachSocketBufferTimer);
-            term._attachSocketBufferTimer = null;
-        };
-        term._pushToBuffer = function (data) {
-            if (term._attachSocketBuffer) {
-                term._attachSocketBuffer += data;
-            }
-            else {
-                term._attachSocketBuffer = data;
-                setTimeout(term._flushBuffer, 10);
-            }
-        };
-        term._getMessage = function (ev) {
-            var data = JSON.parse(ev.data);
-            if (data[0] == "stdout") {
-                if (buffered) {
-                    term._pushToBuffer(data[1]);
-                }
-                else {
-                    term.write(data[1]);
-                }
-            }
-        };
-        term._sendData = function (data) {
-            socket.send(JSON.stringify(['stdin', data]));
-        };
-        term._setSize = function (size) {
-            socket.send(JSON.stringify(['set_size', size.rows, size.cols]));
-        };
-        socket.addEventListener('message', term._getMessage);
-        if (bidirectional) {
-            term.on('data', term._sendData);
+  'use strict';
+
+  var exports = {};
+
+  /**
+   * Attaches the given terminal to the given socket.
+   *
+   * @param {Xterm} term - The terminal to be attached to the given socket.
+   * @param {WebSocket} socket - The socket to attach the current terminal.
+   * @param {boolean} bidirectional - Whether the terminal should send data
+   *                                  to the socket as well.
+   * @param {boolean} buffered - Whether the rendering of incoming data
+   *                             should happen instantly or at a maximum
+   *                             frequency of 1 rendering per 10ms.
+   */
+  exports.terminadoAttach = function (term, socket, bidirectional, buffered) {
+    bidirectional = (typeof bidirectional == 'undefined') ? true : bidirectional;
+    term.socket = socket;
+
+    term._flushBuffer = function () {
+      term.write(term._attachSocketBuffer);
+      term._attachSocketBuffer = null;
+      clearTimeout(term._attachSocketBufferTimer);
+      term._attachSocketBufferTimer = null;
+    };
+
+    term._pushToBuffer = function (data) {
+      if (term._attachSocketBuffer) {
+        term._attachSocketBuffer += data;
+      } else {
+        term._attachSocketBuffer = data;
+        setTimeout(term._flushBuffer, 10);
+      }
+    };
+
+    term._getMessage = function (ev) {
+      var data = JSON.parse(ev.data)
+      if( data[0] == "stdout" ) {
+        if (buffered) {
+          term._pushToBuffer(data[1]);
+        } else {
+          term.write(data[1]);
         }
-        term.on('resize', term._setSize);
-        socket.addEventListener('close', term.terminadoDetach.bind(term, socket));
-        socket.addEventListener('error', term.terminadoDetach.bind(term, socket));
+      }
     };
-    /**
-     * Detaches the given terminal from the given socket
-     *
-     * @param {Xterm} term - The terminal to be detached from the given socket.
-     * @param {WebSocket} socket - The socket from which to detach the current
-     *                             terminal.
-     */
-    exports.terminadoDetach = function (term, socket) {
-        term.off('data', term._sendData);
-        socket = (typeof socket == 'undefined') ? term.socket : socket;
-        if (socket) {
-            socket.removeEventListener('message', term._getMessage);
-        }
-        delete term.socket;
+
+    term._sendData = function (data) {
+      socket.send(JSON.stringify(['stdin', data]));
     };
-    /**
-     * Attaches the current terminal to the given socket
-     *
-     * @param {WebSocket} socket - The socket to attach the current terminal.
-     * @param {boolean} bidirectional - Whether the terminal should send data
-     *                                  to the socket as well.
-     * @param {boolean} buffered - Whether the rendering of incoming data
-     *                             should happen instantly or at a maximum
-     *                             frequency of 1 rendering per 10ms.
-     */
-    Xterm.prototype.terminadoAttach = function (socket, bidirectional, buffered) {
-        return exports.terminadoAttach(this, socket, bidirectional, buffered);
+
+    term._setSize = function (size) {
+      socket.send(JSON.stringify(['set_size', size.rows, size.cols]));
     };
-    /**
-     * Detaches the current terminal from the given socket.
-     *
-     * @param {WebSocket} socket - The socket from which to detach the current
-     *                             terminal.
-     */
-    Xterm.prototype.terminadoDetach = function (socket) {
-        return exports.terminadoDetach(this, socket);
-    };
-    return exports;
+
+    socket.addEventListener('message', term._getMessage);
+
+    if (bidirectional) {
+      term.on('data', term._sendData);
+    }
+    term.on('resize', term._setSize);
+
+    socket.addEventListener('close', term.terminadoDetach.bind(term, socket));
+    socket.addEventListener('error', term.terminadoDetach.bind(term, socket));
+  };
+
+  /**
+   * Detaches the given terminal from the given socket
+   *
+   * @param {Xterm} term - The terminal to be detached from the given socket.
+   * @param {WebSocket} socket - The socket from which to detach the current
+   *                             terminal.
+   */
+  exports.terminadoDetach = function (term, socket) {
+    term.off('data', term._sendData);
+
+    socket = (typeof socket == 'undefined') ? term.socket : socket;
+
+    if (socket) {
+      socket.removeEventListener('message', term._getMessage);
+    }
+
+    delete term.socket;
+  };
+
+  /**
+   * Attaches the current terminal to the given socket
+   *
+   * @param {WebSocket} socket - The socket to attach the current terminal.
+   * @param {boolean} bidirectional - Whether the terminal should send data
+   *                                  to the socket as well.
+   * @param {boolean} buffered - Whether the rendering of incoming data
+   *                             should happen instantly or at a maximum
+   *                             frequency of 1 rendering per 10ms.
+   */
+  Xterm.prototype.terminadoAttach = function (socket, bidirectional, buffered) {
+    return exports.terminadoAttach(this, socket, bidirectional, buffered);
+  };
+
+  /**
+   * Detaches the current terminal from the given socket.
+   *
+   * @param {WebSocket} socket - The socket from which to detach the current
+   *                             terminal.
+   */
+  Xterm.prototype.terminadoDetach = function (socket) {
+    return exports.terminadoDetach(this, socket);
+  };
+
+  return exports;
 });
-//# sourceMappingURL=terminado.js.map

dist/xterm.css

@@ -71,7 +71,7 @@
     resize: none;
 }
 
-.terminal .terminal-cursor {
+.terminal:not(.xterm-cursor-style-underline):not(.xterm-cursor-style-bar) .terminal-cursor {
     background-color: #fff;
     color: #000;
 }
@@ -82,11 +82,11 @@
     background-color: transparent;
 }
 
-.terminal.focus .terminal-cursor.blinking {
-    animation: blink-cursor 1.2s infinite step-end;
+.terminal:not(.xterm-cursor-style-underline):not(.xterm-cursor-style-bar).focus.xterm-cursor-blink .terminal-cursor {
+    animation: xterm-cursor-blink 1.2s infinite step-end;
 }
 
-@keyframes blink-cursor {
+@keyframes xterm-cursor-blink {
     0% {
         background-color: #fff;
         color: #000;
@@ -97,6 +97,38 @@
     }
 }
 
+.terminal.xterm-cursor-style-bar .terminal-cursor,
+.terminal.xterm-cursor-style-underline .terminal-cursor {
+    position: relative;
+}
+.terminal.xterm-cursor-style-bar .terminal-cursor::before,
+.terminal.xterm-cursor-style-underline .terminal-cursor::before {
+    content: "";
+    display: block;
+    position: absolute;
+    background-color: #fff;
+}
+.terminal.xterm-cursor-style-bar .terminal-cursor::before {
+    top: 0;
+    bottom: 0;
+    left: 0;
+    width: 1px;
+}
+.terminal.xterm-cursor-style-underline .terminal-cursor::before {
+    bottom: 0;
+    left: 0;
+    right: 0;
+    height: 1px;
+}
+.terminal.xterm-cursor-style-bar.focus.xterm-cursor-blink .terminal-cursor::before,
+.terminal.xterm-cursor-style-underline.focus.xterm-cursor-blink .terminal-cursor::before {
+    animation: xterm-cursor-non-bar-blink 1.2s infinite step-end;
+}
+@keyframes xterm-cursor-non-bar-blink {
+    0% { background-color: #fff; }
+    50% { background-color: transparent; }
+}
+
 .terminal .composition-view {
     background: #000;
     color: #FFF;
@@ -116,6 +148,10 @@
     overflow-y: scroll;
 }
 
+.terminal .xterm-wide-char {
+    display: inline-block;
+}
+
 .terminal .xterm-rows {
     position: absolute;
     left: 0;

docker-compose.yaml

@@ -0,0 +1,9 @@
+version: '2'
+
+services:
+  web:
+    build: ./
+    volumes:
+     - ./:/usr/src/app
+    ports:
+      - 3000:3000

gulpfile.js

@@ -0,0 +1,87 @@
+const browserify = require('browserify');
+const buffer = require('vinyl-buffer');
+const fs = require('fs-extra');
+const gulp = require('gulp');
+const merge = require('merge-stream');
+const sorcery = require('sorcery');
+const source = require('vinyl-source-stream');
+const sourcemaps = require('gulp-sourcemaps');
+const ts = require('gulp-typescript');
+const tsify = require('tsify');
+
+
+let buildDir = process.env.BUILD_DIR || 'build';
+
+
+/**
+ * Compile TypeScript sources to JavaScript files and create a source map file for each TypeScript
+ * file compiled.
+ */
+gulp.task('tsc', function () {
+  // Remove the lib/ directory to prevent confusion if files were deleted in src/
+  fs.emptyDirSync('lib');
+
+  // Build all TypeScript files (including tests) to lib/, based on the configuration defined in
+  // `tsconfig.json`.
+  let tsProject = ts.createProject('tsconfig.json');
+  let tsResult = tsProject.src().pipe(sourcemaps.init()).pipe(tsProject());
+  let tsc = tsResult.js.pipe(sourcemaps.write('.', {includeContent: false, sourceRoot: ''})).pipe(gulp.dest('lib'));
+
+  // Copy all addons from src/ to lib/
+  let copyAddons = gulp.src('src/addons/**/*').pipe(gulp.dest('lib/addons'));
+
+  // Copy stylesheets from src/ to lib/
+  let copyStylesheets = gulp.src('src/**/*.css').pipe(gulp.dest('lib'));
+
+  return merge(tsc, copyAddons, copyStylesheets);
+});
+
+/**
+ * Bundle JavaScript files produced by the `tsc` task, into a single file named `xterm.js` with
+ * Browserify.
+ */
+gulp.task('browserify', ['tsc'], function() {
+  // Ensure that the build directory exists
+  fs.ensureDirSync(buildDir);
+
+  let browserifyOptions = {
+    basedir: buildDir,
+    debug: true,
+    entries: ['../lib/xterm.js'],
+    standalone: 'Terminal',
+    cache: {},
+    packageCache: {}
+  };
+  let bundleStream = browserify(browserifyOptions)
+        .plugin(tsify)
+        .bundle()
+        .pipe(source('xterm.js'))
+        .pipe(buffer())
+        .pipe(sourcemaps.init({loadMaps: true, sourceRoot: '..'}))
+        .pipe(sourcemaps.write('./'))
+        .pipe(gulp.dest(buildDir));
+
+  // Copy all add-ons from lib/ to buildDir
+  let copyAddons = gulp.src('lib/addons/**/*').pipe(gulp.dest(`${buildDir}/addons`));
+
+  // Copy stylesheets from src/ to lib/
+  let copyStylesheets = gulp.src('lib/**/*.css').pipe(gulp.dest(buildDir));
+
+  return merge(bundleStream, copyAddons, copyStylesheets);
+});
+
+
+/**
+ * Use `sorcery` to resolve the source map chain and point back to the TypeScript files.
+ * (Without this task the source maps produced for the JavaScript bundle points into the
+ * compiled JavaScript files in lib/).
+ */
+gulp.task('sorcery', ['browserify'], function () {
+  var chain = sorcery.loadSync(`${buildDir}/xterm.js`);
+  var map = chain.apply();
+  chain.writeSync();
+});
+
+gulp.task('build', ['sorcery']);
+
+gulp.task('default', ['build']);

package.json

@@ -1,6 +1,7 @@
 {
   "name": "xterm",
-  "version": "2.2.3",
+  "description": "Full xterm terminal, in your browser",
+  "version": "2.3.1",
   "ignore": [
     "demo",
     "test",
@@ -10,6 +11,8 @@
   "repository": "https://github.com/sourcelair/xterm.js",
   "license": "MIT",
   "files": [
+    "*.js",
+    "*.json",
     "dist/*.css",
     "dist/**/*.css",
     "dist/*.js",
@@ -38,25 +41,35 @@
     "browserify": "^13.1.0",
     "chai": "3.5.0",
     "docdash": "0.4.0",
-    "exorcist": "^0.4.0",
     "express": "4.13.4",
     "express-ws": "2.0.0-rc.1",
+    "fs-extra": "^1.0.0",
     "glob": "^7.0.5",
+    "gulp": "^3.9.1",
+    "gulp-cli": "^1.2.2",
+    "gulp-sourcemaps": "1.9.1",
+    "gulp-typescript": "^3.1.3",
     "jsdoc": "3.4.3",
+    "merge-stream": "^1.0.1",
     "mocha": "2.5.3",
+    "node-pty": "^0.4.1",
     "nodemon": "1.10.2",
-    "pty.js": "0.3.1",
     "sleep": "^3.0.1",
     "sorcery": "^0.10.0",
+    "tsify": "^3.0.0",
     "tslint": "^4.0.2",
-    "typescript": "^2.0.3"
+    "typescript": "^2.0.3",
+    "vinyl-buffer": "^1.0.0",
+    "vinyl-source-stream": "^1.1.0"
   },
   "scripts": {
-    "start": "nodemon --watch src --watch addons --watch demo --exec bash -c './bin/build && node demo/app'",
-    "lint": "tslint src/**/*.ts",
+    "prestart": "npm run build",
+    "start": "node demo/app",
+    "dev": "nodemon -e js,ts --watch src --watch demo --exec npm start",
+    "lint": "tslint src/*.ts src/**/*.ts",
     "test": "mocha --recursive ./lib",
     "build:docs": "jsdoc -c jsdoc.json",
-    "build": "./bin/build",
-    "prepublish": "tsc"
+    "build": "gulp build",
+    "prepublish": "npm run build"
   }
 }

src/Charsets.ts

@@ -0,0 +1,252 @@
+/**
+ * @license MIT
+ */
+
+/**
+ * The character sets supported by the terminal. These enable several languages
+ * to be represented within the terminal with only 8-bit encoding. See ISO 2022
+ * for a discussion on character sets. Only VT100 character sets are supported.
+ */
+export const CHARSETS: {[key: string]: {[key: string]: string}} = {};
+
+/**
+ * The default character set, US.
+ */
+export const DEFAULT_CHARSET = CHARSETS['B'];
+
+/**
+ * DEC Special Character and Line Drawing Set.
+ * Reference: http://vt100.net/docs/vt102-ug/table5-13.html
+ * A lot of curses apps use this if they see TERM=xterm.
+ * testing: echo -e '\e(0a\e(B'
+ * The xterm output sometimes seems to conflict with the
+ * reference above. xterm seems in line with the reference
+ * when running vttest however.
+ * The table below now uses xterm's output from vttest.
+ */
+CHARSETS['0'] = {
+  '`': '\u25c6', // '◆'
+  'a': '\u2592', // '▒'
+  'b': '\u0009', // '\t'
+  'c': '\u000c', // '\f'
+  'd': '\u000d', // '\r'
+  'e': '\u000a', // '\n'
+  'f': '\u00b0', // '°'
+  'g': '\u00b1', // '±'
+  'h': '\u2424', // '\u2424' (NL)
+  'i': '\u000b', // '\v'
+  'j': '\u2518', // '┘'
+  'k': '\u2510', // '┐'
+  'l': '\u250c', // '┌'
+  'm': '\u2514', // '└'
+  'n': '\u253c', // '┼'
+  'o': '\u23ba', // '⎺'
+  'p': '\u23bb', // '⎻'
+  'q': '\u2500', // '─'
+  'r': '\u23bc', // '⎼'
+  's': '\u23bd', // '⎽'
+  't': '\u251c', // '├'
+  'u': '\u2524', // '┤'
+  'v': '\u2534', // '┴'
+  'w': '\u252c', // '┬'
+  'x': '\u2502', // '│'
+  'y': '\u2264', // '≤'
+  'z': '\u2265', // '≥'
+  '{': '\u03c0', // 'π'
+  '|': '\u2260', // '≠'
+  '}': '\u00a3', // '£'
+  '~': '\u00b7'  // '·'
+};
+
+/**
+ * British character set
+ * ESC (A
+ * Reference: http://vt100.net/docs/vt220-rm/table2-5.html
+ */
+CHARSETS['A'] = {
+  '#': '£'
+};
+
+/**
+ * United States character set
+ * ESC (B
+ */
+CHARSETS['B'] = null;
+
+/**
+ * Dutch character set
+ * ESC (4
+ * Reference: http://vt100.net/docs/vt220-rm/table2-6.html
+ */
+CHARSETS['4'] = {
+  '#': '£',
+  '@': '¾',
+  '[': 'ij',
+  '\\': '½',
+  ']': '|',
+  '{': '¨',
+  '|': 'f',
+  '}': '¼',
+  '~': '´'
+};
+
+/**
+ * Finnish character set
+ * ESC (C or ESC (5
+ * Reference: http://vt100.net/docs/vt220-rm/table2-7.html
+ */
+CHARSETS['C'] =
+CHARSETS['5'] = {
+  '[': 'Ä',
+  '\\': 'Ö',
+  ']': 'Å',
+  '^': 'Ü',
+  '`': 'é',
+  '{': 'ä',
+  '|': 'ö',
+  '}': 'å',
+  '~': 'ü'
+};
+
+/**
+ * French character set
+ * ESC (R
+ * Reference: http://vt100.net/docs/vt220-rm/table2-8.html
+ */
+CHARSETS['R'] = {
+  '#': '£',
+  '@': 'à',
+  '[': '°',
+  '\\': 'ç',
+  ']': '§',
+  '{': 'é',
+  '|': 'ù',
+  '}': 'è',
+  '~': '¨'
+};
+
+/**
+ * French Canadian character set
+ * ESC (Q
+ * Reference: http://vt100.net/docs/vt220-rm/table2-9.html
+ */
+CHARSETS['Q'] = {
+  '@': 'à',
+  '[': 'â',
+  '\\': 'ç',
+  ']': 'ê',
+  '^': 'î',
+  '`': 'ô',
+  '{': 'é',
+  '|': 'ù',
+  '}': 'è',
+  '~': 'û'
+};
+
+/**
+ * German character set
+ * ESC (K
+ * Reference: http://vt100.net/docs/vt220-rm/table2-10.html
+ */
+CHARSETS['K'] = {
+  '@': '§',
+  '[': 'Ä',
+  '\\': 'Ö',
+  ']': 'Ü',
+  '{': 'ä',
+  '|': 'ö',
+  '}': 'ü',
+  '~': 'ß'
+};
+
+/**
+ * Italian character set
+ * ESC (Y
+ * Reference: http://vt100.net/docs/vt220-rm/table2-11.html
+ */
+CHARSETS['Y'] = {
+  '#': '£',
+  '@': '§',
+  '[': '°',
+  '\\': 'ç',
+  ']': 'é',
+  '`': 'ù',
+  '{': 'à',
+  '|': 'ò',
+  '}': 'è',
+  '~': 'ì'
+};
+
+/**
+ * Norwegian/Danish character set
+ * ESC (E or ESC (6
+ * Reference: http://vt100.net/docs/vt220-rm/table2-12.html
+ */
+CHARSETS['E'] =
+CHARSETS['6'] = {
+  '@': 'Ä',
+  '[': 'Æ',
+  '\\': 'Ø',
+  ']': 'Å',
+  '^': 'Ü',
+  '`': 'ä',
+  '{': 'æ',
+  '|': 'ø',
+  '}': 'å',
+  '~': 'ü'
+};
+
+/**
+ * Spanish character set
+ * ESC (Z
+ * Reference: http://vt100.net/docs/vt220-rm/table2-13.html
+ */
+CHARSETS['Z'] = {
+  '#': '£',
+  '@': '§',
+  '[': '¡',
+  '\\': 'Ñ',
+  ']': '¿',
+  '{': '°',
+  '|': 'ñ',
+  '}': 'ç'
+};
+
+/**
+ * Swedish character set
+ * ESC (H or ESC (7
+ * Reference: http://vt100.net/docs/vt220-rm/table2-14.html
+ */
+CHARSETS['H'] =
+CHARSETS['7'] = {
+  '@': 'É',
+  '[': 'Ä',
+  '\\': 'Ö',
+  ']': 'Å',
+  '^': 'Ü',
+  '`': 'é',
+  '{': 'ä',
+  '|': 'ö',
+  '}': 'å',
+  '~': 'ü'
+};
+
+/**
+ * Swiss character set
+ * ESC (=
+ * Reference: http://vt100.net/docs/vt220-rm/table2-15.html
+ */
+CHARSETS['='] = {
+  '#': 'ù',
+  '@': 'à',
+  '[': 'é',
+  '\\': 'ç',
+  ']': 'ê',
+  '^': 'î',
+  '_': 'è',
+  '`': 'ô',
+  '{': 'ä',
+  '|': 'ö',
+  '}': 'ü',
+  '~': 'û'
+};

src/CompositionHelper.test.ts

@@ -2,11 +2,11 @@ import { assert } from 'chai';
 import { CompositionHelper } from './CompositionHelper';
 
 describe('CompositionHelper', () => {
-  var terminal;
-  var compositionHelper;
-  var compositionView;
-  var textarea;
-  var handledText;
+  let terminal;
+  let compositionHelper;
+  let compositionView;
+  let textarea;
+  let handledText;
 
   beforeEach(() => {
     compositionView = {
@@ -125,7 +125,7 @@ describe('CompositionHelper', () => {
             compositionHelper.compositionend();
             compositionHelper.compositionstart();
             compositionHelper.compositionupdate({ data: '아' });
-            textarea.value = '아아'
+            textarea.value = '아아';
             setTimeout(() => { // wait for any textarea updates
               compositionHelper.compositionend();
               setTimeout(() => { // wait for any textarea updates
@@ -187,7 +187,7 @@ describe('CompositionHelper', () => {
           }, 0);
         }, 0);
       }, 0);
-    })
+    });
 
     it('Should insert multi-character compositions that are converted to other characters with different lengths', function (done) {
       // First character 'い'

src/CompositionHelper.ts

@@ -24,7 +24,7 @@ export class CompositionHelper {
   /**
    * The position within the input textarea's value of the current composition.
    */
-  private compositionPosition: IPosition;;
+  private compositionPosition: IPosition;
 
   /**
    * Whether a composition is in the process of being sent, setting this to false will cancel any
@@ -65,9 +65,8 @@ export class CompositionHelper {
   public compositionupdate(ev: CompositionEvent) {
     this.compositionView.textContent = ev.data;
     this.updateCompositionElements();
-    var self = this;
-    setTimeout(function() {
-      self.compositionPosition.end = self.textarea.value.length;
+    setTimeout(() => {
+      this.compositionPosition.end = this.textarea.value.length;
     }, 0);
   }
 
@@ -125,15 +124,15 @@ export class CompositionHelper {
     if (!waitForPropogation) {
       // Cancel any delayed composition send requests and send the input immediately.
       this.isSendingComposition = false;
-      var input = this.textarea.value.substring(this.compositionPosition.start, this.compositionPosition.end);
+      const input = this.textarea.value.substring(this.compositionPosition.start, this.compositionPosition.end);
       this.terminal.handler(input);
     } else {
       // Make a deep copy of the composition position here as a new compositionstart event may
       // fire before the setTimeout executes.
-      var currentCompositionPosition = {
+      const currentCompositionPosition = {
         start: this.compositionPosition.start,
         end: this.compositionPosition.end,
-      }
+      };
 
       // 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
@@ -143,23 +142,22 @@ export class CompositionHelper {
       // - 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
       //   the following character if the following input is a vowel.
-      var self = this;
       this.isSendingComposition = true;
-      setTimeout(function () {
+      setTimeout(() => {
         // Ensure that the input has not already been sent
-        if (self.isSendingComposition) {
-          self.isSendingComposition = false;
-          var input;
-          if (self.isComposing) {
+        if (this.isSendingComposition) {
+          this.isSendingComposition = false;
+          let input;
+          if (this.isComposing) {
             // Use the end position to get the string if a new composition has started.
-            input = self.textarea.value.substring(currentCompositionPosition.start, currentCompositionPosition.end);
+            input = this.textarea.value.substring(currentCompositionPosition.start, currentCompositionPosition.end);
           } else {
             // Don't use the end position here in order to pick up any characters after the
             // composition has finished, for example when typing a non-composition character
             // (eg. 2) after a composition character.
-            input = self.textarea.value.substring(currentCompositionPosition.start);
+            input = this.textarea.value.substring(currentCompositionPosition.start);
           }
-          self.terminal.handler(input);
+          this.terminal.handler(input);
         }
       }, 0);
     }
@@ -172,15 +170,14 @@ export class CompositionHelper {
    * IME is active.
    */
   private handleAnyTextareaChanges() {
-    var oldValue = this.textarea.value;
-    var self = this;
-    setTimeout(function() {
+    const oldValue = this.textarea.value;
+    setTimeout(() => {
       // Ignore if a composition has started since the timeout
-      if (!self.isComposing) {
-        var newValue = self.textarea.value;
-        var diff = newValue.replace(oldValue, '');
+      if (!this.isComposing) {
+        const newValue = this.textarea.value;
+        const diff = newValue.replace(oldValue, '');
         if (diff.length > 0) {
-          self.terminal.handler(diff);
+          this.terminal.handler(diff);
         }
       }
     }, 0);
@@ -196,12 +193,12 @@ export class CompositionHelper {
     if (!this.isComposing) {
       return;
     }
-    var cursor = <HTMLElement>this.terminal.element.querySelector('.terminal-cursor');
+    const cursor = <HTMLElement>this.terminal.element.querySelector('.terminal-cursor');
     if (cursor) {
       // Take .xterm-rows offsetTop into account as well in case it's positioned absolutely within
       // the .xterm element.
-      var xtermRows = <HTMLElement>this.terminal.element.querySelector('.xterm-rows');
-      var cursorTop = xtermRows.offsetTop + cursor.offsetTop;
+      const xtermRows = <HTMLElement>this.terminal.element.querySelector('.xterm-rows');
+      const cursorTop = xtermRows.offsetTop + cursor.offsetTop;
 
       this.compositionView.style.left = cursor.offsetLeft + 'px';
       this.compositionView.style.top = cursorTop + 'px';
@@ -209,7 +206,7 @@ export class CompositionHelper {
       this.compositionView.style.lineHeight = cursor.offsetHeight + 'px';
       // Sync the textarea to the exact position of the composition view so the IME knows where the
       // text is.
-      var compositionViewBounds = this.compositionView.getBoundingClientRect();
+      const compositionViewBounds = this.compositionView.getBoundingClientRect();
       this.textarea.style.left = cursor.offsetLeft + 'px';
       this.textarea.style.top = cursorTop + 'px';
       this.textarea.style.width = compositionViewBounds.width + 'px';
@@ -217,7 +214,7 @@ export class CompositionHelper {
       this.textarea.style.lineHeight = compositionViewBounds.height + 'px';
     }
     if (!dontRecurse) {
-      setTimeout(this.updateCompositionElements.bind(this, true), 0);
+      setTimeout(() => this.updateCompositionElements(true), 0);
     }
   };
 

src/EscapeSequences.ts

@@ -0,0 +1,74 @@
+/**
+ * C0 control codes
+ * See = https://en.wikipedia.org/wiki/C0_and_C1_control_codes
+ */
+export namespace C0 {
+  /** Null (Caret = ^@, C = \0) */
+  export const NUL = '\x00';
+  /** Start of Heading (Caret = ^A) */
+  export const SOH = '\x01';
+  /** Start of Text (Caret = ^B) */
+  export const STX = '\x02';
+  /** End of Text (Caret = ^C) */
+  export const ETX = '\x03';
+  /** End of Transmission (Caret = ^D) */
+  export const EOT = '\x04';
+  /** Enquiry (Caret = ^E) */
+  export const ENQ = '\x05';
+  /** Acknowledge (Caret = ^F) */
+  export const ACK = '\x06';
+  /** Bell (Caret = ^G, C = \a) */
+  export const BEL = '\x07';
+  /** Backspace (Caret = ^H, C = \b) */
+  export const BS  = '\x08';
+  /** Character Tabulation, Horizontal Tabulation (Caret = ^I, C = \t) */
+  export const HT  = '\x09';
+  /** Line Feed (Caret = ^J, C = \n) */
+  export const LF  = '\x0a';
+  /** Line Tabulation, Vertical Tabulation (Caret = ^K, C = \v) */
+  export const VT  = '\x0b';
+  /** Form Feed (Caret = ^L, C = \f) */
+  export const FF  = '\x0c';
+  /** Carriage Return (Caret = ^M, C = \r) */
+  export const CR  = '\x0d';
+  /** Shift Out (Caret = ^N) */
+  export const SO  = '\x0e';
+  /** Shift In (Caret = ^O) */
+  export const SI  = '\x0f';
+  /** Data Link Escape (Caret = ^P) */
+  export const DLE = '\x10';
+  /** Device Control One (XON) (Caret = ^Q) */
+  export const DC1 = '\x11';
+  /** Device Control Two (Caret = ^R) */
+  export const DC2 = '\x12';
+  /** Device Control Three (XOFF) (Caret = ^S) */
+  export const DC3 = '\x13';
+  /** Device Control Four (Caret = ^T) */
+  export const DC4 = '\x14';
+  /** Negative Acknowledge (Caret = ^U) */
+  export const NAK = '\x15';
+  /** Synchronous Idle (Caret = ^V) */
+  export const SYN = '\x16';
+  /** End of Transmission Block (Caret = ^W) */
+  export const ETB = '\x17';
+  /** Cancel (Caret = ^X) */
+  export const CAN = '\x18';
+  /** End of Medium (Caret = ^Y) */
+  export const EM  = '\x19';
+  /** Substitute (Caret = ^Z) */
+  export const SUB = '\x1a';
+  /** Escape (Caret = ^[, C = \e) */
+  export const ESC = '\x1b';
+  /** File Separator (Caret = ^\) */
+  export const FS  = '\x1c';
+  /** Group Separator (Caret = ^]) */
+  export const GS  = '\x1d';
+  /** Record Separator (Caret = ^^) */
+  export const RS  = '\x1e';
+  /** Unit Separator (Caret = ^_) */
+  export const US  = '\x1f';
+  /** Space */
+  export const SP  = '\x20';
+  /** Delete (Caret = ^?) */
+  export const DEL = '\x7f';
+};

src/EventEmitter.js

@@ -1,64 +0,0 @@
-/**
- * @license MIT
- */
-
-function EventEmitter() {
-  this._events = this._events || {};
-}
-
-EventEmitter.prototype.addListener = function(type, listener) {
-  this._events[type] = this._events[type] || [];
-  this._events[type].push(listener);
-};
-
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-EventEmitter.prototype.removeListener = function(type, listener) {
-  if (!this._events[type]) return;
-
-  var obj = this._events[type]
-  , i = obj.length;
-
-  while (i--) {
-    if (obj[i] === listener || obj[i].listener === listener) {
-      obj.splice(i, 1);
-      return;
-    }
-  }
-};
-
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-
-EventEmitter.prototype.removeAllListeners = function(type) {
-  if (this._events[type]) delete this._events[type];
-};
-
-EventEmitter.prototype.once = function(type, listener) {
-  var self = this;
-  function on() {
-    var args = Array.prototype.slice.call(arguments);
-    this.removeListener(type, on);
-    return listener.apply(this, args);
-  }
-  on.listener = listener;
-  return this.on(type, on);
-};
-
-EventEmitter.prototype.emit = function(type) {
-  if (!this._events[type]) return;
-
-  var args = Array.prototype.slice.call(arguments, 1)
-  , obj = this._events[type]
-  , l = obj.length
-  , i = 0;
-
-  for (; i < l; i++) {
-    obj[i].apply(this, args);
-  }
-};
-
-EventEmitter.prototype.listeners = function(type) {
-  return this._events[type] = this._events[type] || [];
-};
-
-export { EventEmitter };

src/EventEmitter.test.ts

@@ -0,0 +1,84 @@
+import { assert } from 'chai';
+import { EventEmitter } from './EventEmitter';
+
+describe('EventEmitter', () => {
+  let eventEmitter: EventEmitter;
+
+  beforeEach(() => {
+    eventEmitter = new EventEmitter();
+  });
+
+  describe('once', () => {
+    it('should trigger the listener only once', () => {
+      let count = 0;
+      const listener = () => count++;
+      eventEmitter.once('test', listener);
+      eventEmitter.emit('test');
+      assert.equal(count, 1);
+      eventEmitter.emit('test');
+      assert.equal(count, 1);
+    });
+  });
+
+  describe('emit', () => {
+    it('should emit events to listeners', () => {
+      let count1 = 0;
+      let count2 = 0;
+      const listener1 = () => count1++;
+      const listener2 = () => count2++;
+      eventEmitter.on('test', listener1);
+      eventEmitter.on('test', listener2);
+      eventEmitter.emit('test');
+      assert.equal(count1, 1);
+      assert.equal(count2, 1);
+      eventEmitter.emit('test');
+      assert.equal(count1, 2);
+      assert.equal(count2, 2);
+    });
+
+    it('should manage multiple listener types', () => {
+      let count1 = 0;
+      let count2 = 0;
+      const listener1 = () => count1++;
+      const listener2 = () => count2++;
+      eventEmitter.on('test', listener1);
+      eventEmitter.on('foo', listener2);
+      eventEmitter.emit('test');
+      assert.equal(count1, 1);
+      assert.equal(count2, 0);
+      eventEmitter.emit('foo');
+      assert.equal(count1, 1);
+      assert.equal(count2, 1);
+    });
+  });
+
+  describe('listeners', () => {
+    it('should return listeners for the type requested', () => {
+      assert.equal(eventEmitter.listeners('test').length, 0);
+      const listener = () => {};
+      eventEmitter.on('test', listener);
+      assert.deepEqual(eventEmitter.listeners('test'), [listener]);
+    });
+  });
+
+  describe('off', () => {
+    it('should remove the specific listener', () => {
+      const listener1 = () => {};
+      const listener2 = () => {};
+      eventEmitter.on('foo', listener1);
+      eventEmitter.on('foo', listener2);
+      assert.equal(eventEmitter.listeners('foo').length, 2);
+      eventEmitter.off('foo', listener1);
+      assert.deepEqual(eventEmitter.listeners('foo'), [listener2]);
+    });
+  });
+
+  describe('removeAllListeners', () => {
+    it('should clear all listeners', () => {
+      eventEmitter.on('foo', () => {});
+      assert.equal(eventEmitter.listeners('foo').length, 1);
+      eventEmitter.removeAllListeners('foo');
+      assert.equal(eventEmitter.listeners('foo').length, 0);
+    });
+  });
+});

src/EventEmitter.ts

@@ -0,0 +1,72 @@
+/**
+ * @license MIT
+ */
+
+interface ListenerType {
+    (): void;
+    listener?: () => void;
+};
+
+export class EventEmitter {
+  private _events: {[type: string]: ListenerType[]};
+
+  constructor() {
+    // 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 || {};
+  }
+
+  public on(type, listener): void {
+    this._events[type] = this._events[type] || [];
+    this._events[type].push(listener);
+  }
+
+  public off(type, listener): void {
+    if (!this._events[type]) {
+      return;
+    }
+
+    let obj = this._events[type];
+    let i = obj.length;
+
+    while (i--) {
+      if (obj[i] === listener || obj[i].listener === listener) {
+        obj.splice(i, 1);
+        return;
+      }
+    }
+  }
+
+  public removeAllListeners(type): void {
+    if (this._events[type]) {
+       delete this._events[type];
+    }
+  }
+
+  public once(type, listener): any {
+    function on() {
+      let args = Array.prototype.slice.call(arguments);
+      this.off(type, on);
+      return listener.apply(this, args);
+    }
+    (<any>on).listener = listener;
+    return this.on(type, on);
+  }
+
+  public emit(type): void {
+    if (!this._events[type]) {
+      return;
+    }
+
+    let args = Array.prototype.slice.call(arguments, 1);
+    let obj = this._events[type];
+
+    for (let i = 0; i < obj.length; i++) {
+      obj[i].apply(this, args);
+    }
+  }
+
+  public listeners(type): ListenerType[] {
+    return this._events[type] || [];
+  }
+}

src/InputHandler.test.ts

@@ -0,0 +1,49 @@
+import { assert } from 'chai';
+import { InputHandler } from './InputHandler';
+
+describe('InputHandler', () => {
+  describe('setCursorStyle', () => {
+    it('should call Terminal.setOption with correct params', () => {
+      let options = {};
+      let terminal = {
+        setOption: (option, value) => options[option] = value
+      };
+      let inputHandler = new InputHandler(terminal);
+
+      inputHandler.setCursorStyle([0]);
+      assert.equal(options['cursorStyle'], 'block');
+      assert.equal(options['cursorBlink'], true);
+
+      options = {};
+      inputHandler.setCursorStyle([1]);
+      assert.equal(options['cursorStyle'], 'block');
+      assert.equal(options['cursorBlink'], true);
+
+      options = {};
+      inputHandler.setCursorStyle([2]);
+      assert.equal(options['cursorStyle'], 'block');
+      assert.equal(options['cursorBlink'], false);
+
+      options = {};
+      inputHandler.setCursorStyle([3]);
+      assert.equal(options['cursorStyle'], 'underline');
+      assert.equal(options['cursorBlink'], true);
+
+      options = {};
+      inputHandler.setCursorStyle([4]);
+      assert.equal(options['cursorStyle'], 'underline');
+      assert.equal(options['cursorBlink'], false);
+
+      options = {};
+      inputHandler.setCursorStyle([5]);
+      assert.equal(options['cursorStyle'], 'bar');
+      assert.equal(options['cursorBlink'], true);
+
+      options = {};
+      inputHandler.setCursorStyle([6]);
+      assert.equal(options['cursorStyle'], 'bar');
+      assert.equal(options['cursorBlink'], false);
+
+    });
+  });
+});

src/Interfaces.ts

@@ -18,10 +18,19 @@ export interface ITerminal {
   element: HTMLElement;
   rowContainer: HTMLElement;
   textarea: HTMLTextAreaElement;
+  ybase: number;
   ydisp: number;
-  lines: string[];
+  lines: ICircularList<string>;
   rows: number;
+  cols: number;
   browser: IBrowser;
+  writeBuffer: string[];
+  children: HTMLElement[];
+  cursorHidden: boolean;
+  cursorState: number;
+  x: number;
+  y: number;
+  defAttr: number;
 
   /**
    * Emit the 'data' event and populate the given data.
@@ -31,4 +40,72 @@ export interface ITerminal {
   on(event: string, callback: () => void);
   scrollDisp(disp: number, suppressScrollEvent: boolean);
   cancel(ev: Event, force?: boolean);
+  log(text: string): void;
+  emit(event: string, data: any);
+}
+
+interface ICircularList<T> {
+  length: number;
+  maxLength: number;
+
+  forEach(callbackfn: (value: T, index: number, array: T[]) => void): void;
+  get(index: number): T;
+  set(index: number, value: T): void;
+  push(value: T): void;
+  pop(): T;
+  splice(start: number, deleteCount: number, ...items: T[]): void;
+  trimStart(count: number): void;
+  shiftElements(start: number, count: number, offset: number): void;
+}
+
+/**
+ * Handles actions generated by the parser.
+ */
+export interface IInputHandler {
+  addChar(char: string, code: number): void;
+
+  /** C0 BEL */ bell(): void;
+  /** C0 LF */ lineFeed(): void;
+  /** C0 CR */ carriageReturn(): void;
+  /** C0 BS */ backspace(): void;
+  /** C0 HT */ tab(): void;
+  /** C0 SO */ shiftOut(): void;
+  /** C0 SI */ shiftIn(): void;
+
+  /** CSI @ */ insertChars(params?: number[]): void;
+  /** CSI A */ cursorUp(params?: number[]): void;
+  /** CSI B */ cursorDown(params?: number[]): void;
+  /** CSI C */ cursorForward(params?: number[]): void;
+  /** CSI D */ cursorBackward(params?: number[]): void;
+  /** CSI E */ cursorNextLine(params?: number[]): void;
+  /** CSI F */ cursorPrecedingLine(params?: number[]): void;
+  /** CSI G */ cursorCharAbsolute(params?: number[]): void;
+  /** CSI H */ cursorPosition(params?: number[]): void;
+  /** CSI I */ cursorForwardTab(params?: number[]): void;
+  /** CSI J */ eraseInDisplay(params?: number[]): void;
+  /** CSI K */ eraseInLine(params?: number[]): void;
+  /** CSI L */ insertLines(params?: number[]): void;
+  /** CSI M */ deleteLines(params?: number[]): void;
+  /** CSI P */ deleteChars(params?: number[]): void;
+  /** CSI S */ scrollUp(params?: number[]): void;
+  /** CSI T */ scrollDown(params?: number[]): void;
+  /** CSI X */ eraseChars(params?: number[]): void;
+  /** CSI Z */ cursorBackwardTab(params?: number[]): void;
+  /** CSI ` */ charPosAbsolute(params?: number[]): void;
+  /** CSI a */ HPositionRelative(params?: number[]): void;
+  /** CSI b */ repeatPrecedingCharacter(params?: number[]): void;
+  /** CSI c */ sendDeviceAttributes(params?: number[]): void;
+  /** CSI d */ linePosAbsolute(params?: number[]): void;
+  /** CSI e */ VPositionRelative(params?: number[]): void;
+  /** CSI f */ HVPosition(params?: number[]): void;
+  /** CSI g */ tabClear(params?: number[]): void;
+  /** CSI h */ setMode(params?: number[]): void;
+  /** CSI l */ resetMode(params?: number[]): void;
+  /** CSI m */ charAttributes(params?: number[]): void;
+  /** CSI n */ deviceStatus(params?: number[]): void;
+  /** CSI p */ softReset(params?: number[]): void;
+  /** CSI q */ setCursorStyle(params?: number[]): void;
+  /** CSI r */ setScrollRegion(params?: number[]): void;
+  /** CSI s */ saveCursor(params?: number[]): void;
+  /** CSI u */ restoreCursor(params?: number[]): void;
 }

src/Parser.ts

@@ -0,0 +1,636 @@
+/**
+ * @license MIT
+ */
+
+import { C0 } from './EscapeSequences';
+import { IInputHandler } from './Interfaces';
+import { CHARSETS, DEFAULT_CHARSET } from './Charsets';
+
+const normalStateHandler: {[key: string]: (parser: Parser, handler: IInputHandler) => void} = {};
+normalStateHandler[C0.BEL] = (parser, handler) => handler.bell();
+normalStateHandler[C0.LF] = (parser, handler) => handler.lineFeed();
+normalStateHandler[C0.VT] = normalStateHandler[C0.LF];
+normalStateHandler[C0.FF] = normalStateHandler[C0.LF];
+normalStateHandler[C0.CR] = (parser, handler) => handler.carriageReturn();
+normalStateHandler[C0.BS] = (parser, handler) => handler.backspace();
+normalStateHandler[C0.HT] = (parser, handler) => handler.tab();
+normalStateHandler[C0.SO] = (parser, handler) => handler.shiftOut();
+normalStateHandler[C0.SI] = (parser, handler) => handler.shiftIn();
+normalStateHandler[C0.ESC] = (parser, handler) => parser.setState(ParserState.ESCAPED);
+
+// TODO: Remove terminal when parser owns params and currentParam
+const escapedStateHandler: {[key: string]: (parser: Parser, terminal: any) => void} = {};
+escapedStateHandler['['] = (parser, terminal) => {
+  // ESC [ Control Sequence Introducer (CSI  is 0x9b)
+  terminal.params = [];
+  terminal.currentParam = 0;
+  parser.setState(ParserState.CSI_PARAM);
+};
+escapedStateHandler[']'] = (parser, terminal) => {
+  // ESC ] Operating System Command (OSC is 0x9d)
+  terminal.params = [];
+  terminal.currentParam = 0;
+  parser.setState(ParserState.OSC);
+};
+escapedStateHandler['P'] = (parser, terminal) => {
+  // ESC P Device Control String (DCS is 0x90)
+  terminal.params = [];
+  terminal.currentParam = 0;
+  parser.setState(ParserState.DCS);
+};
+escapedStateHandler['_'] = (parser, terminal) => {
+  // ESC _ Application Program Command ( APC is 0x9f).
+  parser.setState(ParserState.IGNORE);
+};
+escapedStateHandler['^'] = (parser, terminal) => {
+  // ESC ^ Privacy Message ( PM is 0x9e).
+  parser.setState(ParserState.IGNORE);
+};
+escapedStateHandler['c'] = (parser, terminal) => {
+  // ESC c Full Reset (RIS).
+  terminal.reset();
+};
+escapedStateHandler['E'] = (parser, terminal) => {
+  // ESC E Next Line ( NEL is 0x85).
+  terminal.x = 0;
+  terminal.index();
+  parser.setState(ParserState.NORMAL);
+};
+escapedStateHandler['D'] = (parser, terminal) => {
+  // ESC D Index ( IND is 0x84).
+  terminal.index();
+  parser.setState(ParserState.NORMAL);
+};
+escapedStateHandler['M'] = (parser, terminal) => {
+  // ESC M Reverse Index ( RI is 0x8d).
+  terminal.reverseIndex();
+  parser.setState(ParserState.NORMAL);
+};
+escapedStateHandler['%'] = (parser, terminal) => {
+  // ESC % Select default/utf-8 character set.
+  // @ = default, G = utf-8
+  terminal.setgLevel(0);
+  terminal.setgCharset(0, DEFAULT_CHARSET); // US (default)
+  parser.setState(ParserState.NORMAL);
+  parser.skipNextChar();
+};
+escapedStateHandler[C0.CAN] = (parser) => parser.setState(ParserState.NORMAL);
+
+const csiParamStateHandler: {[key: string]: (parser: Parser) => void} = {};
+csiParamStateHandler['?'] = (parser) => parser.setPrefix('?');
+csiParamStateHandler['>'] = (parser) => parser.setPrefix('>');
+csiParamStateHandler['!'] = (parser) => parser.setPrefix('!');
+csiParamStateHandler['0'] = (parser) => parser.setParam(parser.getParam() * 10);
+csiParamStateHandler['1'] = (parser) => parser.setParam(parser.getParam() * 10 + 1);
+csiParamStateHandler['2'] = (parser) => parser.setParam(parser.getParam() * 10 + 2);
+csiParamStateHandler['3'] = (parser) => parser.setParam(parser.getParam() * 10 + 3);
+csiParamStateHandler['4'] = (parser) => parser.setParam(parser.getParam() * 10 + 4);
+csiParamStateHandler['5'] = (parser) => parser.setParam(parser.getParam() * 10 + 5);
+csiParamStateHandler['6'] = (parser) => parser.setParam(parser.getParam() * 10 + 6);
+csiParamStateHandler['7'] = (parser) => parser.setParam(parser.getParam() * 10 + 7);
+csiParamStateHandler['8'] = (parser) => parser.setParam(parser.getParam() * 10 + 8);
+csiParamStateHandler['9'] = (parser) => parser.setParam(parser.getParam() * 10 + 9);
+csiParamStateHandler['$'] = (parser) => parser.setPostfix('$');
+csiParamStateHandler['"'] = (parser) => parser.setPostfix('"');
+csiParamStateHandler[' '] = (parser) => parser.setPostfix(' ');
+csiParamStateHandler['\''] = (parser) => parser.setPostfix('\'');
+csiParamStateHandler[';'] = (parser) => parser.finalizeParam();
+csiParamStateHandler[C0.CAN] = (parser) => parser.setState(ParserState.NORMAL);
+
+const csiStateHandler: {[key: string]: (handler: IInputHandler, params: number[], prefix: string, postfix: string, parser: Parser) => void} = {};
+csiStateHandler['@'] = (handler, params, prefix) => handler.insertChars(params);
+csiStateHandler['A'] = (handler, params, prefix) => handler.cursorUp(params);
+csiStateHandler['B'] = (handler, params, prefix) => handler.cursorDown(params);
+csiStateHandler['C'] = (handler, params, prefix) => handler.cursorForward(params);
+csiStateHandler['D'] = (handler, params, prefix) => handler.cursorBackward(params);
+csiStateHandler['E'] = (handler, params, prefix) => handler.cursorNextLine(params);
+csiStateHandler['F'] = (handler, params, prefix) => handler.cursorPrecedingLine(params);
+csiStateHandler['G'] = (handler, params, prefix) => handler.cursorCharAbsolute(params);
+csiStateHandler['H'] = (handler, params, prefix) => handler.cursorPosition(params);
+csiStateHandler['I'] = (handler, params, prefix) => handler.cursorForwardTab(params);
+csiStateHandler['J'] = (handler, params, prefix) => handler.eraseInDisplay(params);
+csiStateHandler['K'] = (handler, params, prefix) => handler.eraseInLine(params);
+csiStateHandler['L'] = (handler, params, prefix) => handler.insertLines(params);
+csiStateHandler['M'] = (handler, params, prefix) => handler.deleteLines(params);
+csiStateHandler['P'] = (handler, params, prefix) => handler.deleteChars(params);
+csiStateHandler['S'] = (handler, params, prefix) => handler.scrollUp(params);
+csiStateHandler['T'] = (handler, params, prefix) => {
+  if (params.length < 2 && !prefix) {
+    handler.scrollDown(params);
+  }
+};
+csiStateHandler['X'] = (handler, params, prefix) => handler.eraseChars(params);
+csiStateHandler['Z'] = (handler, params, prefix) => handler.cursorBackwardTab(params);
+csiStateHandler['`'] = (handler, params, prefix) => handler.charPosAbsolute(params);
+csiStateHandler['a'] = (handler, params, prefix) => handler.HPositionRelative(params);
+csiStateHandler['b'] = (handler, params, prefix) => handler.repeatPrecedingCharacter(params);
+csiStateHandler['c'] = (handler, params, prefix) => handler.sendDeviceAttributes(params);
+csiStateHandler['d'] = (handler, params, prefix) => handler.linePosAbsolute(params);
+csiStateHandler['e'] = (handler, params, prefix) => handler.VPositionRelative(params);
+csiStateHandler['f'] = (handler, params, prefix) => handler.HVPosition(params);
+csiStateHandler['g'] = (handler, params, prefix) => handler.tabClear(params);
+csiStateHandler['h'] = (handler, params, prefix) => handler.setMode(params);
+csiStateHandler['l'] = (handler, params, prefix) => handler.resetMode(params);
+csiStateHandler['m'] = (handler, params, prefix) => handler.charAttributes(params);
+csiStateHandler['n'] = (handler, params, prefix) => handler.deviceStatus(params);
+csiStateHandler['p'] = (handler, params, prefix) => {
+  switch (prefix) {
+    case '!': handler.softReset(params); break;
+  }
+};
+csiStateHandler['q'] = (handler, params, prefix, postfix) => {
+  if (postfix === ' ') {
+    handler.setCursorStyle(params);
+  }
+};
+csiStateHandler['r'] = (handler, params) => handler.setScrollRegion(params);
+csiStateHandler['s'] = (handler, params) => handler.saveCursor(params);
+csiStateHandler['u'] = (handler, params) => handler.restoreCursor(params);
+csiStateHandler[C0.CAN] = (handler, params, prefix, postfix, parser) => parser.setState(ParserState.NORMAL);
+
+enum ParserState {
+  NORMAL = 0,
+  ESCAPED = 1,
+  CSI_PARAM = 2,
+  CSI = 3,
+  OSC = 4,
+  CHARSET = 5,
+  DCS = 6,
+  IGNORE = 7
+}
+
+/**
+ * The terminal's parser, all input into the terminal goes through the parser
+ * which parses and defers the actual input handling the the IInputHandler
+ * specified in the constructor.
+ */
+export class Parser {
+  private _state: ParserState;
+  private _position: number;
+
+  // TODO: Remove terminal when handler can do everything
+  constructor(
+    private _inputHandler: IInputHandler,
+    private _terminal: any
+  ) {
+    this._state = ParserState.NORMAL;
+  }
+
+  /**
+   * Parse and handle data.
+   *
+   * @param data The data to parse.
+   */
+  public parse(data: string) {
+    let l = data.length, j, cs, ch, code, low;
+
+    this._position = 0;
+    // apply leftover surrogate high from last write
+    if (this._terminal.surrogate_high) {
+      data = this._terminal.surrogate_high + data;
+      this._terminal.surrogate_high = '';
+    }
+
+    for (; this._position < l; this._position++) {
+      ch = data[this._position];
+
+      // FIXME: higher chars than 0xa0 are not allowed in escape sequences
+      //        --> maybe move to default
+      code = data.charCodeAt(this._position);
+      if (0xD800 <= code && code <= 0xDBFF) {
+        // we got a surrogate high
+        // get surrogate low (next 2 bytes)
+        low = data.charCodeAt(this._position + 1);
+        if (isNaN(low)) {
+          // end of data stream, save surrogate high
+          this._terminal.surrogate_high = ch;
+          continue;
+        }
+        code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
+        ch += data.charAt(this._position + 1);
+      }
+      // surrogate low - already handled above
+      if (0xDC00 <= code && code <= 0xDFFF)
+        continue;
+
+      switch (this._state) {
+        case ParserState.NORMAL:
+          if (ch in normalStateHandler) {
+            normalStateHandler[ch](this, this._inputHandler);
+          } else {
+            this._inputHandler.addChar(ch, code);
+          }
+          break;
+        case ParserState.ESCAPED:
+          if (ch in escapedStateHandler) {
+            escapedStateHandler[ch](this, this._terminal);
+            // Skip switch as it was just handled
+            break;
+          }
+          switch (ch) {
+
+            // ESC (,),*,+,-,. Designate G0-G2 Character Set.
+            case '(': // <-- this seems to get all the attention
+            case ')':
+            case '*':
+            case '+':
+            case '-':
+            case '.':
+              switch (ch) {
+                case '(':
+                  this._terminal.gcharset = 0;
+                  break;
+                case ')':
+                  this._terminal.gcharset = 1;
+                  break;
+                case '*':
+                  this._terminal.gcharset = 2;
+                  break;
+                case '+':
+                  this._terminal.gcharset = 3;
+                  break;
+                case '-':
+                  this._terminal.gcharset = 1;
+                  break;
+                case '.':
+                  this._terminal.gcharset = 2;
+                  break;
+              }
+              this._state = ParserState.CHARSET;
+              break;
+
+            // Designate G3 Character Set (VT300).
+            // A = ISO Latin-1 Supplemental.
+            // Not implemented.
+            case '/':
+              this._terminal.gcharset = 3;
+              this._state = ParserState.CHARSET;
+              this._position--;
+              break;
+
+            // ESC N
+            // Single Shift Select of G2 Character Set
+            // ( SS2 is 0x8e). This affects next character only.
+            case 'N':
+              break;
+            // ESC O
+            // Single Shift Select of G3 Character Set
+            // ( SS3 is 0x8f). This affects next character only.
+            case 'O':
+              break;
+            // ESC n
+            // Invoke the G2 Character Set as GL (LS2).
+            case 'n':
+              this._terminal.setgLevel(2);
+              break;
+            // ESC o
+            // Invoke the G3 Character Set as GL (LS3).
+            case 'o':
+              this._terminal.setgLevel(3);
+              break;
+            // ESC |
+            // Invoke the G3 Character Set as GR (LS3R).
+            case '|':
+              this._terminal.setgLevel(3);
+              break;
+            // ESC }
+            // Invoke the G2 Character Set as GR (LS2R).
+            case '}':
+              this._terminal.setgLevel(2);
+              break;
+            // ESC ~
+            // Invoke the G1 Character Set as GR (LS1R).
+            case '~':
+              this._terminal.setgLevel(1);
+              break;
+
+            // ESC 7 Save Cursor (DECSC).
+            case '7':
+              this._inputHandler.saveCursor();
+              this._state = ParserState.NORMAL;
+              break;
+
+            // ESC 8 Restore Cursor (DECRC).
+            case '8':
+              this._inputHandler.restoreCursor();
+              this._state = ParserState.NORMAL;
+              break;
+
+            // ESC # 3 DEC line height/width
+            case '#':
+              this._state = ParserState.NORMAL;
+              this._position++;
+              break;
+
+            // ESC H Tab Set (HTS is 0x88).
+            case 'H':
+              this._terminal.tabSet();
+              this._state = ParserState.NORMAL;
+              break;
+
+            // ESC = Application Keypad (DECKPAM).
+            case '=':
+              this._terminal.log('Serial port requested application keypad.');
+              this._terminal.applicationKeypad = true;
+              this._terminal.viewport.syncScrollArea();
+              this._state = ParserState.NORMAL;
+              break;
+
+            // ESC > Normal Keypad (DECKPNM).
+            case '>':
+              this._terminal.log('Switching back to normal keypad.');
+              this._terminal.applicationKeypad = false;
+              this._terminal.viewport.syncScrollArea();
+              this._state = ParserState.NORMAL;
+              break;
+
+            default:
+              this._state = ParserState.NORMAL;
+              this._terminal.error('Unknown ESC control: %s.', ch);
+              break;
+          }
+          break;
+
+        case ParserState.CHARSET:
+          if (ch in CHARSETS) {
+            cs = CHARSETS[ch];
+            if (ch === '/') { // ISOLatin is actually /A
+              this.skipNextChar();
+            }
+          } else {
+            cs = DEFAULT_CHARSET;
+          }
+          this._terminal.setgCharset(this._terminal.gcharset, cs);
+          this._terminal.gcharset = null;
+          this._state = ParserState.NORMAL;
+          break;
+
+        case ParserState.OSC:
+          // OSC Ps ; Pt ST
+          // OSC Ps ; Pt BEL
+          //   Set Text Parameters.
+          if (ch === C0.ESC || ch === C0.BEL) {
+            if (ch === C0.ESC) this._position++;
+
+            this._terminal.params.push(this._terminal.currentParam);
+
+            switch (this._terminal.params[0]) {
+              case 0:
+              case 1:
+              case 2:
+                if (this._terminal.params[1]) {
+                  this._terminal.title = this._terminal.params[1];
+                  this._terminal.handleTitle(this._terminal.title);
+                }
+                break;
+              case 3:
+                // set X property
+                break;
+              case 4:
+              case 5:
+                // change dynamic colors
+                break;
+              case 10:
+              case 11:
+              case 12:
+              case 13:
+              case 14:
+              case 15:
+              case 16:
+              case 17:
+              case 18:
+              case 19:
+                // change dynamic ui colors
+                break;
+              case 46:
+                // change log file
+                break;
+              case 50:
+                // dynamic font
+                break;
+              case 51:
+                // emacs shell
+                break;
+              case 52:
+                // manipulate selection data
+                break;
+              case 104:
+              case 105:
+              case 110:
+              case 111:
+              case 112:
+              case 113:
+              case 114:
+              case 115:
+              case 116:
+              case 117:
+              case 118:
+                // reset colors
+                break;
+            }
+
+            this._terminal.params = [];
+            this._terminal.currentParam = 0;
+            this._state = ParserState.NORMAL;
+          } else {
+            if (!this._terminal.params.length) {
+              if (ch >= '0' && ch <= '9') {
+                this._terminal.currentParam =
+                  this._terminal.currentParam * 10 + ch.charCodeAt(0) - 48;
+              } else if (ch === ';') {
+                this._terminal.params.push(this._terminal.currentParam);
+                this._terminal.currentParam = '';
+              }
+            } else {
+              this._terminal.currentParam += ch;
+            }
+          }
+          break;
+
+        case ParserState.CSI_PARAM:
+          if (ch in csiParamStateHandler) {
+            csiParamStateHandler[ch](this);
+            break;
+          }
+          this.finalizeParam();
+          // Fall through the CSI as this character should be the CSI code.
+          this._state = ParserState.CSI;
+
+        case ParserState.CSI:
+          if (ch in csiStateHandler) {
+            csiStateHandler[ch](this._inputHandler, this._terminal.params, this._terminal.prefix, this._terminal.postfix, this);
+          } else {
+            this._terminal.error('Unknown CSI code: %s.', ch);
+          }
+
+          this._state = ParserState.NORMAL;
+          this._terminal.prefix = '';
+          this._terminal.postfix = '';
+          break;
+
+        case ParserState.DCS:
+          if (ch === C0.ESC || ch === C0.BEL) {
+            if (ch === C0.ESC) this._position++;
+
+            switch (this._terminal.prefix) {
+              // User-Defined Keys (DECUDK).
+              case '':
+                break;
+
+              // Request Status String (DECRQSS).
+              // test: echo -e '\eP$q"p\e\\'
+              case '$q':
+                let pt = this._terminal.currentParam
+                , valid = false;
+
+                switch (pt) {
+                  // DECSCA
+                  case '"q':
+                    pt = '0"q';
+                    break;
+
+                  // DECSCL
+                  case '"p':
+                    pt = '61"p';
+                    break;
+
+                  // DECSTBM
+                  case 'r':
+                    pt = ''
+                      + (this._terminal.scrollTop + 1)
+                      + ';'
+                      + (this._terminal.scrollBottom + 1)
+                      + 'r';
+                    break;
+
+                  // SGR
+                  case 'm':
+                    pt = '0m';
+                    break;
+
+                  default:
+                    this._terminal.error('Unknown DCS Pt: %s.', pt);
+                    pt = '';
+                    break;
+                }
+
+                this._terminal.send(C0.ESC + 'P' + +valid + '$r' + pt + C0.ESC + '\\');
+                break;
+
+              // Set Termcap/Terminfo Data (xterm, experimental).
+              case '+p':
+                break;
+
+              // Request Termcap/Terminfo String (xterm, experimental)
+              // Regular xterm does not even respond to this sequence.
+              // This can cause a small glitch in vim.
+              // test: echo -ne '\eP+q6b64\e\\'
+              case '+q':
+                // TODO: Don't declare pt twice
+                /*let*/ pt = this._terminal.currentParam
+                , valid = false;
+
+                this._terminal.send(C0.ESC + 'P' + +valid + '+r' + pt + C0.ESC + '\\');
+                break;
+
+              default:
+                this._terminal.error('Unknown DCS prefix: %s.', this._terminal.prefix);
+                break;
+            }
+
+            this._terminal.currentParam = 0;
+            this._terminal.prefix = '';
+            this._state = ParserState.NORMAL;
+          } else if (!this._terminal.currentParam) {
+            if (!this._terminal.prefix && ch !== '$' && ch !== '+') {
+              this._terminal.currentParam = ch;
+            } else if (this._terminal.prefix.length === 2) {
+              this._terminal.currentParam = ch;
+            } else {
+              this._terminal.prefix += ch;
+            }
+          } else {
+            this._terminal.currentParam += ch;
+          }
+          break;
+
+        case ParserState.IGNORE:
+          // For PM and APC.
+          if (ch === C0.ESC || ch === C0.BEL) {
+            if (ch === C0.ESC) this._position++;
+            this._state = ParserState.NORMAL;
+          }
+          break;
+      }
+    }
+  }
+
+  /**
+   * Set the parser's current parsing state.
+   *
+   * @param state The new state.
+   */
+  public setState(state: ParserState): void {
+    this._state = state;
+  }
+
+  /**
+   * Sets the parsier's current prefix. CSI codes can have prefixes of '?', '>'
+   * or '!'.
+   *
+   * @param prefix The prefix.
+   */
+  public setPrefix(prefix: string): void {
+    this._terminal.prefix = prefix;
+  }
+
+  /**
+   * Sets the parsier's current prefix. CSI codes can have postfixes of '$',
+   * '"', ' ', '\''.
+   *
+   * @param postfix The postfix.
+   */
+  public setPostfix(postfix: string): void {
+    this._terminal.postfix = postfix;
+  }
+
+  /**
+   * Sets the parser's current parameter.
+   *
+   * @param param the parameter.
+   */
+  public setParam(param: number) {
+    this._terminal.currentParam = param;
+  }
+
+  /**
+   * Gets the parser's current parameter.
+   */
+  public getParam(): number {
+    return this._terminal.currentParam;
+  }
+
+  /**
+   * Finalizes the parser's current parameter, adding it to the list of
+   * parameters and setting the new current parameter to 0.
+   */
+  public finalizeParam(): void {
+    this._terminal.params.push(this._terminal.currentParam);
+    this._terminal.currentParam = 0;
+  }
+
+  /**
+   * Tell the parser to skip the next character.
+   */
+  public skipNextChar(): void {
+    this._position++;
+  }
+
+  /**
+   * Tell the parser to repeat parsing the current character (for example if it
+   * needs parsing using a different state.
+   */
+  // public repeatChar(): void {
+  //   this._position--;
+  // }
+}

src/Renderer.ts

@@ -0,0 +1,304 @@
+/**
+ * @license MIT
+ */
+
+import { ITerminal } from './Interfaces';
+
+/**
+ * The maximum number of refresh frames to skip when the write buffer is non-
+ * empty. Note that these frames may be intermingled with frames that are
+ * skipped via requestAnimationFrame's mechanism.
+ */
+const MAX_REFRESH_FRAME_SKIP = 5;
+
+/**
+ * Flags used to render terminal text properly.
+ */
+enum FLAGS {
+  BOLD = 1,
+  UNDERLINE = 2,
+  BLINK = 4,
+  INVERSE = 8,
+  INVISIBLE = 16
+};
+
+let brokenBold: boolean = null;
+
+export class Renderer {
+  /** A queue of the rows to be refreshed */
+  private _refreshRowsQueue: {start: number, end: number}[] = [];
+  private _refreshFramesSkipped = 0;
+  private _refreshAnimationFrame = null;
+
+  constructor(private _terminal: ITerminal) {
+    // Figure out whether boldness affects
+    // the character width of monospace fonts.
+    if (brokenBold === null) {
+      brokenBold = checkBoldBroken((<any>this._terminal).document);
+    }
+
+    // TODO: Pull more DOM interactions into Renderer.constructor, element for
+    // example should be owned by Renderer (and also exposed by Terminal due to
+    // to established public API).
+  }
+
+  /**
+   * Queues a refresh between two rows (inclusive), to be done on next animation
+   * frame.
+   * @param {number} start The start row.
+   * @param {number} end The end row.
+   */
+  public queueRefresh(start: number, end: number): void {
+    this._refreshRowsQueue.push({ start: start, end: end });
+    if (!this._refreshAnimationFrame) {
+      this._refreshAnimationFrame = window.requestAnimationFrame(this._refreshLoop.bind(this));
+    }
+  }
+
+  /**
+   * Performs the refresh loop callback, calling refresh only if a refresh is
+   * necessary before queueing up the next one.
+   */
+  private _refreshLoop(): void {
+    // Skip MAX_REFRESH_FRAME_SKIP frames if the writeBuffer is non-empty as it
+    // will need to be immediately refreshed anyway. This saves a lot of
+    // rendering time as the viewport DOM does not need to be refreshed, no
+    // scroll events, no layouts, etc.
+    const skipFrame = this._terminal.writeBuffer.length > 0 && this._refreshFramesSkipped++ <= MAX_REFRESH_FRAME_SKIP;
+    if (skipFrame) {
+      this._refreshAnimationFrame = window.requestAnimationFrame(this._refreshLoop.bind(this));
+      return;
+    }
+
+    this._refreshFramesSkipped = 0;
+    let start;
+    let end;
+    if (this._refreshRowsQueue.length > 4) {
+      // Just do a full refresh when 5+ refreshes are queued
+      start = 0;
+      end = this._terminal.rows - 1;
+    } else {
+      // Get start and end rows that need refreshing
+      start = this._refreshRowsQueue[0].start;
+      end = this._refreshRowsQueue[0].end;
+      for (let i = 1; i < this._refreshRowsQueue.length; i++) {
+        if (this._refreshRowsQueue[i].start < start) {
+          start = this._refreshRowsQueue[i].start;
+        }
+        if (this._refreshRowsQueue[i].end > end) {
+          end = this._refreshRowsQueue[i].end;
+        }
+      }
+    }
+    this._refreshRowsQueue = [];
+    this._refreshAnimationFrame = null;
+    this._refresh(start, end);
+  }
+
+  /**
+   * Refreshes (re-renders) terminal content within two rows (inclusive)
+   *
+   * Rendering Engine:
+   *
+   * In the screen buffer, each character is stored as a an array with a character
+   * and a 32-bit integer:
+   *   - First value: a utf-16 character.
+   *   - Second value:
+   *   - Next 9 bits: background color (0-511).
+   *   - Next 9 bits: foreground color (0-511).
+   *   - Next 14 bits: a mask for misc. flags:
+   *     - 1=bold
+   *     - 2=underline
+   *     - 4=blink
+   *     - 8=inverse
+   *     - 16=invisible
+   *
+   * @param {number} start The row to start from (between 0 and terminal's height terminal - 1)
+   * @param {number} end The row to end at (between fromRow and terminal's height terminal - 1)
+   */
+  private _refresh(start: number, end: number): void {
+    let x, y, i, line, out, ch, ch_width, width, data, attr, bg, fg, flags, row, parent, focused = document.activeElement;
+
+    // If this is a big refresh, remove the terminal rows from the DOM for faster calculations
+    if (end - start >= this._terminal.rows / 2) {
+      parent = this._terminal.element.parentNode;
+      if (parent) {
+        this._terminal.element.removeChild(this._terminal.rowContainer);
+      }
+    }
+
+    width = this._terminal.cols;
+    y = start;
+
+    if (end >= this._terminal.rows) {
+      this._terminal.log('`end` is too large. Most likely a bad CSR.');
+      end = this._terminal.rows - 1;
+    }
+
+    for (; y <= end; y++) {
+      row = y + this._terminal.ydisp;
+
+      line = this._terminal.lines.get(row);
+      if (!line || !this._terminal.children[y]) {
+        // Continue if the line is not available, this means a resize is currently in progress
+        continue;
+      }
+      out = '';
+
+      if (this._terminal.y === y - (this._terminal.ybase - this._terminal.ydisp)
+          && this._terminal.cursorState
+          && !this._terminal.cursorHidden) {
+        x = this._terminal.x;
+      } else {
+        x = -1;
+      }
+
+      attr = this._terminal.defAttr;
+      i = 0;
+
+      for (; i < width; i++) {
+        if (!line[i]) {
+          // Continue if the character is not available, this means a resize is currently in progress
+          continue;
+        }
+        data = line[i][0];
+        ch = line[i][1];
+        ch_width = line[i][2];
+        if (!ch_width)
+          continue;
+
+        if (i === x) data = -1;
+
+        if (data !== attr) {
+          if (attr !== this._terminal.defAttr) {
+            out += '</span>';
+          }
+          if (data !== this._terminal.defAttr) {
+            if (data === -1) {
+              out += '<span class="reverse-video terminal-cursor">';
+            } else {
+              let classNames = [];
+
+              bg = data & 0x1ff;
+              fg = (data >> 9) & 0x1ff;
+              flags = data >> 18;
+
+              if (flags & FLAGS.BOLD) {
+                if (!brokenBold) {
+                  classNames.push('xterm-bold');
+                }
+                // See: XTerm*boldColors
+                if (fg < 8) fg += 8;
+              }
+
+              if (flags & FLAGS.UNDERLINE) {
+                classNames.push('xterm-underline');
+              }
+
+              if (flags & FLAGS.BLINK) {
+                classNames.push('xterm-blink');
+              }
+
+              // If inverse flag is on, then swap the foreground and background variables.
+              if (flags & FLAGS.INVERSE) {
+                /* One-line variable swap in JavaScript: http://stackoverflow.com/a/16201730 */
+                bg = [fg, fg = bg][0];
+                // Should inverse just be before the
+                // above boldColors effect instead?
+                if ((flags & 1) && fg < 8) fg += 8;
+              }
+
+              if (flags & FLAGS.INVISIBLE) {
+                classNames.push('xterm-hidden');
+              }
+
+              /**
+               * Weird situation: Invert flag used black foreground and white background results
+               * in invalid background color, positioned at the 256 index of the 256 terminal
+               * color map. Pin the colors manually in such a case.
+               *
+               * Source: https://github.com/sourcelair/xterm.js/issues/57
+               */
+              if (flags & FLAGS.INVERSE) {
+                if (bg === 257) {
+                  bg = 15;
+                }
+                if (fg === 256) {
+                  fg = 0;
+                }
+              }
+
+              if (bg < 256) {
+                classNames.push('xterm-bg-color-' + bg);
+              }
+
+              if (fg < 256) {
+                classNames.push('xterm-color-' + fg);
+              }
+
+              out += '<span';
+              if (classNames.length) {
+                out += ' class="' + classNames.join(' ') + '"';
+              }
+              out += '>';
+            }
+          }
+        }
+
+        if (ch_width === 2) {
+          out += '<span class="xterm-wide-char">';
+        }
+        switch (ch) {
+          case '&':
+            out += '&amp;';
+            break;
+          case '<':
+            out += '&lt;';
+            break;
+          case '>':
+            out += '&gt;';
+            break;
+          default:
+            if (ch <= ' ') {
+              out += '&nbsp;';
+            } else {
+              out += ch;
+            }
+            break;
+        }
+        if (ch_width === 2) {
+          out += '</span>';
+        }
+
+        attr = data;
+      }
+
+      if (attr !== this._terminal.defAttr) {
+        out += '</span>';
+      }
+
+      this._terminal.children[y].innerHTML = out;
+    }
+
+    if (parent) {
+      this._terminal.element.appendChild(this._terminal.rowContainer);
+    }
+
+    this._terminal.emit('refresh', {element: this._terminal.element, start: start, end: end});
+  };
+}
+
+
+// if bold is broken, we can't
+// use it in the terminal.
+function checkBoldBroken(document) {
+  const body = document.getElementsByTagName('body')[0];
+  const el = document.createElement('span');
+  el.innerHTML = 'hello world';
+  body.appendChild(el);
+  const w1 = el.scrollWidth;
+  el.style.fontWeight = 'bold';
+  const w2 = el.scrollWidth;
+  body.removeChild(el);
+  return w1 !== w2;
+}

src/Viewport.test.ts

@@ -2,11 +2,11 @@ import { assert } from 'chai';
 import { Viewport } from './Viewport';
 
 describe('Viewport', () => {
-  var terminal;
-  var viewportElement;
-  var charMeasureElement;
-  var viewport;
-  var scrollAreaElement;
+  let terminal;
+  let viewportElement;
+  let charMeasure;
+  let viewport;
+  let scrollAreaElement;
 
   const CHARACTER_HEIGHT = 10;
 
@@ -34,21 +34,17 @@ describe('Viewport', () => {
         height: 0
       }
     };
-    charMeasureElement = {
-      getBoundingClientRect: () => {
-        return { width: null, height: CHARACTER_HEIGHT };
-      }
+    charMeasure = {
+      height: CHARACTER_HEIGHT
     };
-    viewport = new Viewport(terminal, viewportElement, scrollAreaElement, charMeasureElement);
+    viewport = new Viewport(terminal, viewportElement, scrollAreaElement, charMeasure);
   });
 
   describe('refresh', () => {
     it('should set the line-height of the terminal', () => {
       assert.equal(viewportElement.style.lineHeight, CHARACTER_HEIGHT + 'px');
       assert.equal(terminal.rowContainer.style.lineHeight, CHARACTER_HEIGHT + 'px');
-      charMeasureElement.getBoundingClientRect = () => {
-        return { width: null, height: 1 };
-      };
+      charMeasure.height = 1;
       viewport.refresh();
       assert.equal(viewportElement.style.lineHeight, '1px');
       assert.equal(terminal.rowContainer.style.lineHeight, '1px');
@@ -59,9 +55,7 @@ describe('Viewport', () => {
       terminal.rows = 1;
       viewport.refresh();
       assert.equal(viewportElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
-      charMeasureElement.getBoundingClientRect = () => {
-        return { width: null, height: 20 };
-      };
+      charMeasure.height = 20;
       viewport.refresh();
       assert.equal(viewportElement.style.height, 20 + 'px');
     });

src/Viewport.ts

@@ -3,6 +3,7 @@
  */
 
 import { ITerminal } from './Interfaces';
+import { CharMeasure } from './utils/CharMeasure';
 
 /**
  * Represents the viewport of a terminal, the visible area within the larger buffer of output.
@@ -24,7 +25,7 @@ export class Viewport {
     private terminal: ITerminal,
     private viewportElement: HTMLElement,
     private scrollArea: HTMLElement,
-    private charMeasureElement: HTMLElement
+    private charMeasure: CharMeasure
   ) {
     this.currentRowHeight = 0;
     this.lastRecordedBufferLength = 0;
@@ -43,21 +44,20 @@ export class Viewport {
    * @param charSize A character size measurement bounding rect object, if it doesn't exist it will
    *   be created.
    */
-  private refresh(charSize?: ClientRect): void {
-    var size = charSize || this.charMeasureElement.getBoundingClientRect();
-    if (size.height > 0) {
-      var rowHeightChanged = size.height !== this.currentRowHeight;
+  private refresh(): void {
+    if (this.charMeasure.height > 0) {
+      const rowHeightChanged = this.charMeasure.height !== this.currentRowHeight;
       if (rowHeightChanged) {
-        this.currentRowHeight = size.height;
-        this.viewportElement.style.lineHeight = size.height + 'px';
-        this.terminal.rowContainer.style.lineHeight = size.height + 'px';
+        this.currentRowHeight = this.charMeasure.height;
+        this.viewportElement.style.lineHeight = this.charMeasure.height + 'px';
+        this.terminal.rowContainer.style.lineHeight = this.charMeasure.height + 'px';
       }
-      var viewportHeightChanged = this.lastRecordedViewportHeight !== this.terminal.rows;
+      const viewportHeightChanged = this.lastRecordedViewportHeight !== this.terminal.rows;
       if (rowHeightChanged || viewportHeightChanged) {
         this.lastRecordedViewportHeight = this.terminal.rows;
-        this.viewportElement.style.height = size.height * this.terminal.rows + 'px';
+        this.viewportElement.style.height = this.charMeasure.height * this.terminal.rows + 'px';
       }
-      this.scrollArea.style.height = (size.height * this.lastRecordedBufferLength) + 'px';
+      this.scrollArea.style.height = (this.charMeasure.height * this.lastRecordedBufferLength) + 'px';
     }
   }
 
@@ -74,14 +74,13 @@ export class Viewport {
       this.refresh();
     } else {
       // If size has changed, refresh viewport
-      var size = this.charMeasureElement.getBoundingClientRect();
-      if (size.height !== this.currentRowHeight) {
-        this.refresh(size);
+      if (this.charMeasure.height !== this.currentRowHeight) {
+        this.refresh();
       }
     }
 
     // Sync scrollTop
-    var scrollTop = this.terminal.ydisp * this.currentRowHeight;
+    const scrollTop = this.terminal.ydisp * this.currentRowHeight;
     if (this.viewportElement.scrollTop !== scrollTop) {
       this.viewportElement.scrollTop = scrollTop;
     }
@@ -93,8 +92,8 @@ export class Viewport {
    * @param ev The scroll event.
    */
   private onScroll(ev: Event) {
-    var newRow = Math.round(this.viewportElement.scrollTop / this.currentRowHeight);
-    var diff = newRow - this.terminal.ydisp;
+    const newRow = Math.round(this.viewportElement.scrollTop / this.currentRowHeight);
+    const diff = newRow - this.terminal.ydisp;
     this.terminal.scrollDisp(diff, true);
   }
 
@@ -110,7 +109,7 @@ export class Viewport {
       return;
     }
     // Fallback to WheelEvent.DOM_DELTA_PIXEL
-    var multiplier = 1;
+    let multiplier = 1;
     if (ev.deltaMode === WheelEvent.DOM_DELTA_LINE) {
       multiplier = this.currentRowHeight;
     } else if (ev.deltaMode === WheelEvent.DOM_DELTA_PAGE) {

src/test/escape-sequences-test.js

@@ -1,9 +1,15 @@
 var glob = require('glob');
 var fs = require('fs');
-var pty = require('pty.js');
+var os = require('os');
+var pty = require('node-pty');
 var sleep = require('sleep');
 var Terminal = require('../xterm');
 
+if (os.platform() === 'win32') {
+  // Skip tests on Windows since pty.open isn't supported
+  return;
+}
+
 var CONSOLE_LOG = console.log;
 
 // expect files need terminal at 80x25!
@@ -56,10 +62,10 @@ function formatError(in_, out_, expected) {
 function terminalToString(term) {
   var result = '';
   var line_s = '';
-  for (var line=0; line<term.rows; ++line) {
+  for (var line = term.ybase; line < term.ybase + term.rows; line++) {
     line_s = '';
     for (var cell=0; cell<term.cols; ++cell) {
-      line_s += term.lines[line][cell][1];
+      line_s += term.lines.get(line)[cell][1];
     }
     // rtrim empty cells as xterm does
     line_s = line_s.replace(/\s+$/, '');
@@ -76,31 +82,49 @@ describe('xterm output comparison', function() {
   beforeEach(function () {
     xterm = new Terminal(COLS, ROWS);
     xterm.refresh = function() {};
+    xterm.viewport = {
+      syncScrollArea: function() {}
+    };
   });
 
   // omit stack trace for escape sequence files
   Error.stackTraceLimit = 0;
   var files = glob.sync('**/escape_sequence_files/*.in');
   // only successful tests for now
-  var successful = [0, 2, 6, 12, 13, 18, 20, 22, 27, 28];
-  console.log(files);
-  for (var a in successful) {
-    var i = successful[a];
-    (function(filename){
+  var skip = [
+    10, 16, 17, 19, 32, 33, 34, 35, 36, 39,
+    40, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+    51, 52, 54, 55, 56, 57, 58, 59, 60, 61,
+    63, 68
+  ];
+  for (var i = 0; i < files.length; i++) {
+    if (skip.indexOf(i) >= 0) {
+      continue;
+    }
+    (function(filename) {
       it(filename.split('/').slice(-1)[0], function () {
         pty_reset();
         var in_file = fs.readFileSync(filename, 'utf8');
         var from_pty = pty_write_read(in_file);
         // uncomment this to get log from terminal
-        console.log = function(){};
-        xterm.write(from_pty);
+        //console.log = function(){};
+
+        // Perform a synchronous .write(data)
+        xterm.writeBuffer.push(from_pty);
+        xterm.innerWrite();
+
         var from_emulator = terminalToString(xterm);
         console.log = CONSOLE_LOG;
         var expected = fs.readFileSync(filename.split('.')[0] + '.text', 'utf8');
-        if (from_emulator != expected) {
+        // Some of the tests have whitespace on the right of lines, we trim all the linex
+        // from xterm.js so ignore this for now at least.
+        var expectedRightTrimmed = expected.split('\n').map(function (l) {
+          return l.replace(/\s+$/, '');
+        }).join('\n');
+        if (from_emulator != expectedRightTrimmed) {
           // uncomment to get noisy output
-          //throw new Error(formatError(in_file, from_emulator, expected));
-          throw new Error('mismatch');
+          throw new Error(formatError(in_file, from_emulator, expected));
+        //   throw new Error('mismatch');
         }
       });
     })(files[i]);

src/test/test.js

@@ -14,6 +14,16 @@ describe('xterm.js', function() {
     xterm.compositionHelper = {
       keydown: function(){ return true; }
     };
+    // Force synchronous writes
+    xterm.write = function(data) {
+      xterm.writeBuffer.push(data);
+      xterm.innerWrite();
+    };
+    xterm.element = {
+      classList: {
+        toggle: function(){}
+      }
+    };
   });
 
   describe('getOption', function() {
@@ -48,15 +58,15 @@ describe('xterm.js', function() {
 
   describe('clear', function() {
     it('should clear a buffer equal to rows', function() {
-      var promptLine = xterm.lines[xterm.ybase + xterm.y];
+      var promptLine = xterm.lines.get(xterm.ybase + xterm.y);
       xterm.clear();
       assert.equal(xterm.y, 0);
       assert.equal(xterm.ybase, 0);
       assert.equal(xterm.ydisp, 0);
       assert.equal(xterm.lines.length, xterm.rows);
-      assert.deepEqual(xterm.lines[0], promptLine);
+      assert.deepEqual(xterm.lines.get(0), promptLine);
       for (var i = 1; i < xterm.rows; i++) {
-        assert.deepEqual(xterm.lines[0], xterm.blankLine());
+        assert.deepEqual(xterm.lines.get(i), xterm.blankLine());
       }
     });
     it('should clear a buffer larger than rows', function() {
@@ -65,28 +75,28 @@ describe('xterm.js', function() {
         xterm.write('test\n');
       }
 
-      var promptLine = xterm.lines[xterm.ybase + xterm.y];
+      var promptLine = xterm.lines.get(xterm.ybase + xterm.y);
       xterm.clear();
       assert.equal(xterm.y, 0);
       assert.equal(xterm.ybase, 0);
       assert.equal(xterm.ydisp, 0);
       assert.equal(xterm.lines.length, xterm.rows);
-      assert.deepEqual(xterm.lines[0], promptLine);
+      assert.deepEqual(xterm.lines.get(0), promptLine);
       for (var i = 1; i < xterm.rows; i++) {
-        assert.deepEqual(xterm.lines[i], xterm.blankLine());
+        assert.deepEqual(xterm.lines.get(i), xterm.blankLine());
       }
     });
     it('should not break the prompt when cleared twice', function() {
-      var promptLine = xterm.lines[xterm.ybase + xterm.y];
+      var promptLine = xterm.lines.get(xterm.ybase + xterm.y);
       xterm.clear();
       xterm.clear();
       assert.equal(xterm.y, 0);
       assert.equal(xterm.ybase, 0);
       assert.equal(xterm.ydisp, 0);
       assert.equal(xterm.lines.length, xterm.rows);
-      assert.deepEqual(xterm.lines[0], promptLine);
+      assert.deepEqual(xterm.lines.get(0), promptLine);
       for (var i = 1; i < xterm.rows; i++) {
-        assert.deepEqual(xterm.lines[i], xterm.blankLine());
+        assert.deepEqual(xterm.lines.get(i), xterm.blankLine());
       }
     });
   });
@@ -286,14 +296,33 @@ describe('xterm.js', function() {
     it('should return \\x1b[5B for ctrl+down', function() {
       assert.equal(xterm.evaluateKeyEscapeSequence({ ctrlKey: true, keyCode: 40 }).key, '\x1b[1;5B'); // CSI 5 B
     });
-    // Evalueate alt + arrow key movement, which is a feature of terminal emulators but not VT100
-    // http://unix.stackexchange.com/a/108106
-    it('should return \\x1b[5D for alt+left', function() {
-      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 37 }).key, '\x1b[1;5D'); // CSI 5 D
+
+    describe('On non-macOS platforms', function() {
+      beforeEach(function() {
+        xterm.browser.isMac = false;
+      });
+      // Evalueate alt + arrow key movement, which is a feature of terminal emulators but not VT100
+      // http://unix.stackexchange.com/a/108106
+      it('should return \\x1b[5D for alt+left', function() {
+        assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 37 }).key, '\x1b[1;5D'); // CSI 5 D
+      });
+      it('should return \\x1b[5C for alt+right', function() {
+        assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 39 }).key, '\x1b[1;5C'); // CSI 5 C
+      });
     });
-    it('should return \\x1b[5C for alt+right', function() {
-      assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 39 }).key, '\x1b[1;5C'); // CSI 5 C
+
+    describe('On macOS platforms', function() {
+      beforeEach(function() {
+        xterm.browser.isMac = true;
+      });
+      it('should return \\x1bb for alt+left', function() {
+        assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 37 }).key, '\x1bb'); // CSI 5 D
+      });
+      it('should return \\x1bf for alt+right', function() {
+        assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 39 }).key, '\x1bf'); // CSI 5 C
+      });
     });
+
     it('should return \\x1b[5A for alt+up', function() {
       assert.equal(xterm.evaluateKeyEscapeSequence({ altKey: true, keyCode: 38 }).key, '\x1b[1;5A'); // CSI 5 A
     });
@@ -524,11 +553,11 @@ describe('xterm.js', function() {
       var high = String.fromCharCode(0xD800);
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.write(high + String.fromCharCode(i));
-        var tchar = xterm.lines[0][0];
+        var tchar = xterm.lines.get(0)[0];
         expect(tchar[1]).eql(high + String.fromCharCode(i));
         expect(tchar[1].length).eql(2);
         expect(tchar[2]).eql(1);
-        expect(xterm.lines[0][1][1]).eql(' ');
+        expect(xterm.lines.get(0)[1][1]).eql(' ');
         xterm.reset();
       }
     });
@@ -537,9 +566,9 @@ describe('xterm.js', function() {
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.x = xterm.cols - 1;
         xterm.write(high + String.fromCharCode(i));
-        expect(xterm.lines[0][xterm.x-1][1]).eql(high + String.fromCharCode(i));
-        expect(xterm.lines[0][xterm.x-1][1].length).eql(2);
-        expect(xterm.lines[1][0][1]).eql(' ');
+        expect(xterm.lines.get(0)[xterm.x-1][1]).eql(high + String.fromCharCode(i));
+        expect(xterm.lines.get(0)[xterm.x-1][1].length).eql(2);
+        expect(xterm.lines.get(1)[0][1]).eql(' ');
         xterm.reset();
       }
     });
@@ -549,10 +578,10 @@ describe('xterm.js', function() {
         xterm.x = xterm.cols - 1;
         xterm.wraparoundMode = true;
         xterm.write('a' + high + String.fromCharCode(i));
-        expect(xterm.lines[0][xterm.cols-1][1]).eql('a');
-        expect(xterm.lines[1][0][1]).eql(high + String.fromCharCode(i));
-        expect(xterm.lines[1][0][1].length).eql(2);
-        expect(xterm.lines[1][1][1]).eql(' ');
+        expect(xterm.lines.get(0)[xterm.cols-1][1]).eql('a');
+        expect(xterm.lines.get(1)[0][1]).eql(high + String.fromCharCode(i));
+        expect(xterm.lines.get(1)[0][1].length).eql(2);
+        expect(xterm.lines.get(1)[1][1]).eql(' ');
         xterm.reset();
       }
     });
@@ -562,9 +591,10 @@ describe('xterm.js', function() {
         xterm.x = xterm.cols - 1;
         xterm.wraparoundMode = false;
         xterm.write('a' + high + String.fromCharCode(i));
-        expect(xterm.lines[0][xterm.cols-1][1]).eql(high + String.fromCharCode(i));
-        expect(xterm.lines[0][xterm.cols-1][1].length).eql(2);
-        expect(xterm.lines[1][1][1]).eql(' ');
+        // auto wraparound mode should cut off the rest of the line
+        expect(xterm.lines.get(0)[xterm.cols-1][1]).eql('a');
+        expect(xterm.lines.get(0)[xterm.cols-1][1].length).eql(1);
+        expect(xterm.lines.get(1)[1][1]).eql(' ');
         xterm.reset();
       }
     });
@@ -573,11 +603,11 @@ describe('xterm.js', function() {
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.write(high);
         xterm.write(String.fromCharCode(i));
-        var tchar = xterm.lines[0][0];
+        var tchar = xterm.lines.get(0)[0];
         expect(tchar[1]).eql(high + String.fromCharCode(i));
         expect(tchar[1].length).eql(2);
         expect(tchar[2]).eql(1);
-        expect(xterm.lines[0][1][1]).eql(' ');
+        expect(xterm.lines.get(0)[1][1]).eql(' ');
         xterm.reset();
       }
     });
@@ -586,30 +616,30 @@ describe('xterm.js', function() {
   describe('unicode - combining characters', function() {
     it('café', function () {
       xterm.write('cafe\u0301');
-      expect(xterm.lines[0][3][1]).eql('e\u0301');
-      expect(xterm.lines[0][3][1].length).eql(2);
-      expect(xterm.lines[0][3][2]).eql(1);
+      expect(xterm.lines.get(0)[3][1]).eql('e\u0301');
+      expect(xterm.lines.get(0)[3][1].length).eql(2);
+      expect(xterm.lines.get(0)[3][2]).eql(1);
     });
     it('café - end of line', function() {
       xterm.x = xterm.cols - 1 - 3;
       xterm.write('cafe\u0301');
-      expect(xterm.lines[0][xterm.cols-1][1]).eql('e\u0301');
-      expect(xterm.lines[0][xterm.cols-1][1].length).eql(2);
-      expect(xterm.lines[0][xterm.cols-1][2]).eql(1);
-      expect(xterm.lines[0][1][1]).eql(' ');
-      expect(xterm.lines[0][1][1].length).eql(1);
-      expect(xterm.lines[0][1][2]).eql(1);
+      expect(xterm.lines.get(0)[xterm.cols-1][1]).eql('e\u0301');
+      expect(xterm.lines.get(0)[xterm.cols-1][1].length).eql(2);
+      expect(xterm.lines.get(0)[xterm.cols-1][2]).eql(1);
+      expect(xterm.lines.get(0)[1][1]).eql(' ');
+      expect(xterm.lines.get(0)[1][1].length).eql(1);
+      expect(xterm.lines.get(0)[1][2]).eql(1);
     });
     it('multiple combined é', function() {
       xterm.wraparoundMode = true;
       xterm.write(Array(100).join('e\u0301'));
       for (var i=0; i<xterm.cols; ++i) {
-        var tchar = xterm.lines[0][i];
+        var tchar = xterm.lines.get(0)[i];
         expect(tchar[1]).eql('e\u0301');
         expect(tchar[1].length).eql(2);
         expect(tchar[2]).eql(1);
       }
-      tchar = xterm.lines[1][0];
+      tchar = xterm.lines.get(1)[0];
       expect(tchar[1]).eql('e\u0301');
       expect(tchar[1].length).eql(2);
       expect(tchar[2]).eql(1);
@@ -618,12 +648,12 @@ describe('xterm.js', function() {
       xterm.wraparoundMode = true;
       xterm.write(Array(100).join('\uD800\uDC00\u0301'));
       for (var i=0; i<xterm.cols; ++i) {
-        var tchar = xterm.lines[0][i];
+        var tchar = xterm.lines.get(0)[i];
         expect(tchar[1]).eql('\uD800\uDC00\u0301');
         expect(tchar[1].length).eql(3);
         expect(tchar[2]).eql(1);
       }
-      tchar = xterm.lines[1][0];
+      tchar = xterm.lines.get(1)[0];
       expect(tchar[1]).eql('\uD800\uDC00\u0301');
       expect(tchar[1].length).eql(3);
       expect(tchar[2]).eql(1);
@@ -646,7 +676,7 @@ describe('xterm.js', function() {
       xterm.wraparoundMode = true;
       xterm.write(Array(50).join('￥'));
       for (var i=0; i<xterm.cols; ++i) {
-        var tchar = xterm.lines[0][i];
+        var tchar = xterm.lines.get(0)[i];
         if (i % 2) {
           expect(tchar[1]).eql('');
           expect(tchar[1].length).eql(0);
@@ -657,7 +687,7 @@ describe('xterm.js', function() {
           expect(tchar[2]).eql(2);
         }
       }
-      tchar = xterm.lines[1][0];
+      tchar = xterm.lines.get(1)[0];
       expect(tchar[1]).eql('￥');
       expect(tchar[1].length).eql(1);
       expect(tchar[2]).eql(2);
@@ -667,7 +697,7 @@ describe('xterm.js', function() {
       xterm.x = 1;
       xterm.write(Array(50).join('￥'));
       for (var i=1; i<xterm.cols-1; ++i) {
-        var tchar = xterm.lines[0][i];
+        var tchar = xterm.lines.get(0)[i];
         if (!(i % 2)) {
           expect(tchar[1]).eql('');
           expect(tchar[1].length).eql(0);
@@ -678,11 +708,11 @@ describe('xterm.js', function() {
           expect(tchar[2]).eql(2);
         }
       }
-      tchar = xterm.lines[0][xterm.cols-1];
+      tchar = xterm.lines.get(0)[xterm.cols-1];
       expect(tchar[1]).eql(' ');
       expect(tchar[1].length).eql(1);
       expect(tchar[2]).eql(1);
-      tchar = xterm.lines[1][0];
+      tchar = xterm.lines.get(1)[0];
       expect(tchar[1]).eql('￥');
       expect(tchar[1].length).eql(1);
       expect(tchar[2]).eql(2);
@@ -692,7 +722,7 @@ describe('xterm.js', function() {
       xterm.x = 1;
       xterm.write(Array(50).join('￥\u0301'));
       for (var i=1; i<xterm.cols-1; ++i) {
-        var tchar = xterm.lines[0][i];
+        var tchar = xterm.lines.get(0)[i];
         if (!(i % 2)) {
           expect(tchar[1]).eql('');
           expect(tchar[1].length).eql(0);
@@ -703,11 +733,11 @@ describe('xterm.js', function() {
           expect(tchar[2]).eql(2);
         }
       }
-      tchar = xterm.lines[0][xterm.cols-1];
+      tchar = xterm.lines.get(0)[xterm.cols-1];
       expect(tchar[1]).eql(' ');
       expect(tchar[1].length).eql(1);
       expect(tchar[2]).eql(1);
-      tchar = xterm.lines[1][0];
+      tchar = xterm.lines.get(1)[0];
       expect(tchar[1]).eql('￥\u0301');
       expect(tchar[1].length).eql(2);
       expect(tchar[2]).eql(2);
@@ -716,7 +746,7 @@ describe('xterm.js', function() {
       xterm.wraparoundMode = true;
       xterm.write(Array(50).join('￥\u0301'));
       for (var i=0; i<xterm.cols; ++i) {
-        var tchar = xterm.lines[0][i];
+        var tchar = xterm.lines.get(0)[i];
         if (i % 2) {
           expect(tchar[1]).eql('');
           expect(tchar[1].length).eql(0);
@@ -727,7 +757,7 @@ describe('xterm.js', function() {
           expect(tchar[2]).eql(2);
         }
       }
-      tchar = xterm.lines[1][0];
+      tchar = xterm.lines.get(1)[0];
       expect(tchar[1]).eql('￥\u0301');
       expect(tchar[1].length).eql(2);
       expect(tchar[2]).eql(2);
@@ -737,7 +767,7 @@ describe('xterm.js', function() {
       xterm.x = 1;
       xterm.write(Array(50).join('\ud843\ude6d\u0301'));
       for (var i=1; i<xterm.cols-1; ++i) {
-        var tchar = xterm.lines[0][i];
+        var tchar = xterm.lines.get(0)[i];
         if (!(i % 2)) {
           expect(tchar[1]).eql('');
           expect(tchar[1].length).eql(0);
@@ -748,11 +778,11 @@ describe('xterm.js', function() {
           expect(tchar[2]).eql(2);
         }
       }
-      tchar = xterm.lines[0][xterm.cols-1];
+    tchar = xterm.lines.get(0)[xterm.cols-1];
       expect(tchar[1]).eql(' ');
       expect(tchar[1].length).eql(1);
       expect(tchar[2]).eql(1);
-      tchar = xterm.lines[1][0];
+      tchar = xterm.lines.get(1)[0];
       expect(tchar[1]).eql('\ud843\ude6d\u0301');
       expect(tchar[1].length).eql(3);
       expect(tchar[2]).eql(2);
@@ -761,7 +791,7 @@ describe('xterm.js', function() {
       xterm.wraparoundMode = true;
       xterm.write(Array(50).join('\ud843\ude6d\u0301'));
       for (var i=0; i<xterm.cols; ++i) {
-        var tchar = xterm.lines[0][i];
+        var tchar = xterm.lines.get(0)[i];
         if (i % 2) {
           expect(tchar[1]).eql('');
           expect(tchar[1].length).eql(0);
@@ -772,7 +802,7 @@ describe('xterm.js', function() {
           expect(tchar[2]).eql(2);
         }
       }
-      tchar = xterm.lines[1][0];
+      tchar = xterm.lines.get(1)[0];
       expect(tchar[1]).eql('\ud843\ude6d\u0301');
       expect(tchar[1].length).eql(3);
       expect(tchar[2]).eql(2);
@@ -786,11 +816,11 @@ describe('xterm.js', function() {
       xterm.y = 0;
       xterm.insertMode = true;
       xterm.write('abcde');
-      expect(xterm.lines[0].length).eql(xterm.cols);
-      expect(xterm.lines[0][10][1]).eql('a');
-      expect(xterm.lines[0][14][1]).eql('e');
-      expect(xterm.lines[0][15][1]).eql('0');
-      expect(xterm.lines[0][79][1]).eql('4');
+      expect(xterm.lines.get(0).length).eql(xterm.cols);
+      expect(xterm.lines.get(0)[10][1]).eql('a');
+      expect(xterm.lines.get(0)[14][1]).eql('e');
+      expect(xterm.lines.get(0)[15][1]).eql('0');
+      expect(xterm.lines.get(0)[79][1]).eql('4');
     });
     it('fullwidth - insert', function() {
       xterm.write(Array(9).join('0123456789').slice(-80));
@@ -798,12 +828,12 @@ describe('xterm.js', function() {
       xterm.y = 0;
       xterm.insertMode = true;
       xterm.write('￥￥￥');
-      expect(xterm.lines[0].length).eql(xterm.cols);
-      expect(xterm.lines[0][10][1]).eql('￥');
-      expect(xterm.lines[0][11][1]).eql('');
-      expect(xterm.lines[0][14][1]).eql('￥');
-      expect(xterm.lines[0][15][1]).eql('');
-      expect(xterm.lines[0][79][1]).eql('3');
+      expect(xterm.lines.get(0).length).eql(xterm.cols);
+      expect(xterm.lines.get(0)[10][1]).eql('￥');
+      expect(xterm.lines.get(0)[11][1]).eql('');
+      expect(xterm.lines.get(0)[14][1]).eql('￥');
+      expect(xterm.lines.get(0)[15][1]).eql('');
+      expect(xterm.lines.get(0)[79][1]).eql('3');
     });
     it('fullwidth - right border', function() {
       xterm.write(Array(41).join('￥'));
@@ -811,15 +841,15 @@ describe('xterm.js', function() {
       xterm.y = 0;
       xterm.insertMode = true;
       xterm.write('a');
-      expect(xterm.lines[0].length).eql(xterm.cols);
-      expect(xterm.lines[0][10][1]).eql('a');
-      expect(xterm.lines[0][11][1]).eql('￥');
-      expect(xterm.lines[0][79][1]).eql(' ');  // fullwidth char got replaced
+      expect(xterm.lines.get(0).length).eql(xterm.cols);
+      expect(xterm.lines.get(0)[10][1]).eql('a');
+      expect(xterm.lines.get(0)[11][1]).eql('￥');
+      expect(xterm.lines.get(0)[79][1]).eql(' ');  // fullwidth char got replaced
       xterm.write('b');
-      expect(xterm.lines[0].length).eql(xterm.cols);
-      expect(xterm.lines[0][11][1]).eql('b');
-      expect(xterm.lines[0][12][1]).eql('￥');
-      expect(xterm.lines[0][79][1]).eql('');  // empty cell after fullwidth
+      expect(xterm.lines.get(0).length).eql(xterm.cols);
+      expect(xterm.lines.get(0)[11][1]).eql('b');
+      expect(xterm.lines.get(0)[12][1]).eql('￥');
+      expect(xterm.lines.get(0)[79][1]).eql('');  // empty cell after fullwidth
     });
   });
 });

src/utils/Browser.js

@@ -1,22 +0,0 @@
-/**
- * Attributes and methods to help with identifying the current browser and platform.
- * @module xterm/utils/Browser
- * @license MIT
- */
-
-import { contains } from './Generic.js';
-
-let isNode = (typeof navigator == 'undefined') ? true : false;
-let userAgent = (isNode) ? 'node' : navigator.userAgent;
-let platform = (isNode) ? 'node' : navigator.platform;
-
-export let isFirefox = !!~userAgent.indexOf('Firefox');
-export let isMSIE = !!~userAgent.indexOf('MSIE') || !!~userAgent.indexOf('Trident');
-
-// Find the users platform. We use this to interpret the meta key
-// and ISO third level shifts.
-// http://stackoverflow.com/q/19877924/577598
-export let isMac = contains(['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'], platform);
-export let isIpad = platform === 'iPad';
-export let isIphone = platform === 'iPhone';
-export let isMSWindows = contains(['Windows', 'Win16', 'Win32', 'WinCE'], platform);

src/utils/Browser.ts

@@ -0,0 +1,22 @@
+/**
+ * Attributes and methods to help with identifying the current browser and platform.
+ * @module xterm/utils/Browser
+ * @license MIT
+ */
+
+import { contains } from './Generic';
+
+const isNode = (typeof navigator === 'undefined') ? true : false;
+const userAgent = (isNode) ? 'node' : navigator.userAgent;
+const platform = (isNode) ? 'node' : navigator.platform;
+
+export const isFirefox = !!~userAgent.indexOf('Firefox');
+export const isMSIE = !!~userAgent.indexOf('MSIE') || !!~userAgent.indexOf('Trident');
+
+// Find the users platform. We use this to interpret the meta key
+// and ISO third level shifts.
+// http://stackoverflow.com/q/19877924/577598
+export const isMac = contains(['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'], platform);
+export const isIpad = platform === 'iPad';
+export const isIphone = platform === 'iPhone';
+export const isMSWindows = contains(['Windows', 'Win16', 'Win32', 'WinCE'], platform);

src/utils/CharMeasure.ts

@@ -0,0 +1,59 @@
+/**
+ * @module xterm/utils/CharMeasure
+ * @license MIT
+ */
+
+import { EventEmitter } from '../EventEmitter.js';
+
+/**
+ * Utility class that measures the size of a character.
+ */
+export class CharMeasure extends EventEmitter {
+  private _parentElement: HTMLElement;
+  private _measureElement: HTMLElement;
+  private _width: number;
+  private _height: number;
+
+  constructor(parentElement: HTMLElement) {
+    super();
+    this._parentElement = parentElement;
+  }
+
+  public get width(): number {
+    return this._width;
+  }
+
+  public get height(): number {
+    return this._height;
+  }
+
+  public measure(): void {
+    if (!this._measureElement) {
+      this._measureElement = document.createElement('span');
+      this._measureElement.style.position = 'absolute';
+      this._measureElement.style.top = '0';
+      this._measureElement.style.left = '-9999em';
+      this._measureElement.textContent = 'W';
+      this._parentElement.appendChild(this._measureElement);
+      // Perform _doMeasure async if the element was just attached as sometimes
+      // getBoundingClientRect does not return accurate values without this.
+      setTimeout(() => this._doMeasure(), 0);
+    } else {
+      this._doMeasure();
+    }
+  }
+
+  private _doMeasure(): void {
+    const geometry = this._measureElement.getBoundingClientRect();
+    // The element is likely currently display:none, we should retain the
+    // previous value.
+    if (geometry.width === 0 || geometry.height === 0) {
+      return;
+    }
+    if (this._width !== geometry.width || this._height !== geometry.height) {
+      this._width = geometry.width;
+      this._height = geometry.height;
+      this.emit('charsizechanged');
+    }
+  }
+}

src/utils/CircularList.test.ts

@@ -0,0 +1,255 @@
+import { assert } from 'chai';
+import { CircularList } from './CircularList';
+
+describe('CircularList', () => {
+  describe('push', () => {
+    it('should push values onto the array', () => {
+      const list = new CircularList<string>(5);
+      list.push('1');
+      list.push('2');
+      list.push('3');
+      list.push('4');
+      list.push('5');
+      assert.equal(list.get(0), '1');
+      assert.equal(list.get(1), '2');
+      assert.equal(list.get(2), '3');
+      assert.equal(list.get(3), '4');
+      assert.equal(list.get(4), '5');
+    });
+
+    it('should push old values from the start out of the array when max length is reached', () => {
+      const list = new CircularList<string>(2);
+      list.push('1');
+      list.push('2');
+      assert.equal(list.get(0), '1');
+      assert.equal(list.get(1), '2');
+      list.push('3');
+      assert.equal(list.get(0), '2');
+      assert.equal(list.get(1), '3');
+      list.push('4');
+      assert.equal(list.get(0), '3');
+      assert.equal(list.get(1), '4');
+    });
+  });
+
+  describe('maxLength', () => {
+    it('should increase the size of the list', () => {
+      const list = new CircularList<string>(2);
+      list.push('1');
+      list.push('2');
+      assert.equal(list.get(0), '1');
+      assert.equal(list.get(1), '2');
+      list.maxLength = 4;
+      list.push('3');
+      list.push('4');
+      assert.equal(list.get(0), '1');
+      assert.equal(list.get(1), '2');
+      assert.equal(list.get(2), '3');
+      assert.equal(list.get(3), '4');
+      list.push('wrapped');
+      assert.equal(list.get(0), '2');
+      assert.equal(list.get(1), '3');
+      assert.equal(list.get(2), '4');
+      assert.equal(list.get(3), 'wrapped');
+    });
+
+    it('should return the maximum length of the list', () => {
+      const list = new CircularList<string>(2);
+      assert.equal(list.maxLength, 2);
+      list.push('1');
+      list.push('2');
+      assert.equal(list.maxLength, 2);
+      list.push('3');
+      assert.equal(list.maxLength, 2);
+      list.maxLength = 4;
+      assert.equal(list.maxLength, 4);
+    });
+  });
+
+  describe('length', () => {
+    it('should return the current length of the list, capped at the maximum length', () => {
+      const list = new CircularList<string>(2);
+      assert.equal(list.length, 0);
+      list.push('1');
+      assert.equal(list.length, 1);
+      list.push('2');
+      assert.equal(list.length, 2);
+      list.push('3');
+      assert.equal(list.length, 2);
+    });
+  });
+
+  describe('splice', () => {
+    it('should delete items', () => {
+      const list = new CircularList<string>(2);
+      list.push('1');
+      list.push('2');
+      list.splice(0, 1);
+      assert.equal(list.length, 1);
+      assert.equal(list.get(0), '2');
+      list.push('3');
+      list.splice(1, 1);
+      assert.equal(list.length, 1);
+      assert.equal(list.get(0), '2');
+    });
+
+    it('should insert items', () => {
+      const list = new CircularList<string>(2);
+      list.push('1');
+      list.splice(0, 0, '2');
+      assert.equal(list.length, 2);
+      assert.equal(list.get(0), '2');
+      assert.equal(list.get(1), '1');
+      list.splice(1, 0, '3');
+      assert.equal(list.length, 2);
+      assert.equal(list.get(0), '3');
+      assert.equal(list.get(1), '1');
+    });
+
+    it('should delete items then insert items', () => {
+      const list = new CircularList<string>(3);
+      list.push('1');
+      list.push('2');
+      list.splice(0, 1, '3', '4');
+      assert.equal(list.length, 3);
+      assert.equal(list.get(0), '3');
+      assert.equal(list.get(1), '4');
+      assert.equal(list.get(2), '2');
+    });
+
+    it('should wrap the array correctly when more items are inserted than deleted', () => {
+      const list = new CircularList<string>(3);
+      list.push('1');
+      list.push('2');
+      list.splice(1, 0, '3', '4');
+      assert.equal(list.length, 3);
+      assert.equal(list.get(0), '3');
+      assert.equal(list.get(1), '4');
+      assert.equal(list.get(2), '2');
+    });
+  });
+
+  describe('trimStart', () => {
+    it('should remove items from the beginning of the list', () => {
+      const list = new CircularList<string>(5);
+      list.push('1');
+      list.push('2');
+      list.push('3');
+      list.push('4');
+      list.push('5');
+      list.trimStart(1);
+      assert.equal(list.length, 4);
+      assert.deepEqual(list.get(0), '2');
+      assert.deepEqual(list.get(1), '3');
+      assert.deepEqual(list.get(2), '4');
+      assert.deepEqual(list.get(3), '5');
+      list.trimStart(2);
+      assert.equal(list.length, 2);
+      assert.deepEqual(list.get(0), '4');
+      assert.deepEqual(list.get(1), '5');
+    });
+
+    it('should remove all items if the requested trim amount is larger than the list\'s length', () => {
+      const list = new CircularList<string>(5);
+      list.push('1');
+      list.trimStart(2);
+      assert.equal(list.length, 0);
+    });
+  });
+
+  describe('shiftElements', () => {
+    it('should not mutate the list when count is 0', () => {
+      const list = new CircularList<number>(5);
+      list.push(1);
+      list.push(2);
+      list.shiftElements(0, 0, 1);
+      assert.equal(list.length, 2);
+      assert.equal(list.get(0), 1);
+      assert.equal(list.get(1), 2);
+    });
+
+    it('should throw for invalid args', () => {
+      const list = new CircularList<number>(5);
+      list.push(1);
+      assert.throws(() => list.shiftElements(-1, 1, 1), 'start argument out of range');
+      assert.throws(() => list.shiftElements(1, 1, 1), 'start argument out of range');
+      assert.throws(() => list.shiftElements(0, 1, -1), 'Cannot shift elements in list beyond index 0');
+    });
+
+    it('should shift an element forward', () => {
+      const list = new CircularList<number>(5);
+      list.push(1);
+      list.push(2);
+      list.shiftElements(0, 1, 1);
+      assert.equal(list.length, 2);
+      assert.equal(list.get(0), 1);
+      assert.equal(list.get(1), 1);
+    });
+
+    it('should shift elements forward', () => {
+      const list = new CircularList<number>(5);
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      list.push(4);
+      list.shiftElements(0, 2, 2);
+      assert.equal(list.length, 4);
+      assert.equal(list.get(0), 1);
+      assert.equal(list.get(1), 2);
+      assert.equal(list.get(2), 1);
+      assert.equal(list.get(3), 2);
+    });
+
+    it('should shift elements forward, expanding the list if needed', () => {
+      const list = new CircularList<number>(5);
+      list.push(1);
+      list.push(2);
+      list.shiftElements(0, 2, 2);
+      assert.equal(list.length, 4);
+      assert.equal(list.get(0), 1);
+      assert.equal(list.get(1), 2);
+      assert.equal(list.get(2), 1);
+      assert.equal(list.get(3), 2);
+    });
+
+    it('should shift elements forward, wrapping the list if needed', () => {
+      const list = new CircularList<number>(5);
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      list.push(4);
+      list.push(5);
+      list.shiftElements(2, 2, 3);
+      assert.equal(list.length, 5);
+      assert.equal(list.get(0), 3);
+      assert.equal(list.get(1), 4);
+      assert.equal(list.get(2), 5);
+      assert.equal(list.get(3), 3);
+      assert.equal(list.get(4), 4);
+    });
+
+    it('should shift an element backwards', () => {
+      const list = new CircularList<number>(5);
+      list.push(1);
+      list.push(2);
+      list.shiftElements(1, 1, -1);
+      assert.equal(list.length, 2);
+      assert.equal(list.get(0), 2);
+      assert.equal(list.get(1), 2);
+    });
+
+    it('should shift elements backwards', () => {
+      const list = new CircularList<number>(5);
+      list.push(1);
+      list.push(2);
+      list.push(3);
+      list.push(4);
+      list.shiftElements(2, 2, -2);
+      assert.equal(list.length, 4);
+      assert.equal(list.get(0), 3);
+      assert.equal(list.get(1), 4);
+      assert.equal(list.get(2), 3);
+      assert.equal(list.get(3), 4);
+    });
+  });
+});

src/utils/CircularList.ts

@@ -0,0 +1,183 @@
+/**
+ * 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.
+ * @module xterm/utils/CircularList
+ * @license MIT
+ */
+export class CircularList<T> {
+  private _array: T[];
+  private _startIndex: number;
+  private _length: number;
+
+  constructor(maxLength: number) {
+    this._array = new Array<T>(maxLength);
+    this._startIndex = 0;
+    this._length = 0;
+  }
+
+  public get maxLength(): number {
+    return this._array.length;
+  }
+
+  public set maxLength(newMaxLength: number) {
+    // Reconstruct array, starting at index 0. Only transfer values from the
+    // indexes 0 to length.
+    let newArray = new Array<T>(newMaxLength);
+    for (let i = 0; i < Math.min(newMaxLength, this.length); i++) {
+      newArray[i] = this._array[this._getCyclicIndex(i)];
+    }
+    this._array = newArray;
+    this._startIndex = 0;
+  }
+
+  public get length(): number {
+    return this._length;
+  }
+
+  public set length(newLength: number) {
+    if (newLength > this._length) {
+      for (let i = this._length; i < newLength; i++) {
+        this._array[i] = undefined;
+      }
+    }
+    this._length = newLength;
+  }
+
+  public get forEach(): (callbackfn: (value: T, index: number, array: T[]) => void) => void {
+    return this._array.forEach;
+  }
+
+  /**
+   * Gets the value at an index.
+   *
+   * Note that for performance reasons there is no bounds checking here, the index reference is
+   * circular so this should always return a value and never throw.
+   * @param index The index of the value to get.
+   * @return The value corresponding to the index.
+   */
+  public get(index: number): T {
+    return this._array[this._getCyclicIndex(index)];
+  }
+
+  /**
+   * Sets the value at an index.
+   *
+   * Note that for performance reasons there is no bounds checking here, the index reference is
+   * circular so this should always return a value and never throw.
+   * @param index The index to set.
+   * @param value The value to set.
+   */
+  public set(index: number, value: T): void {
+    this._array[this._getCyclicIndex(index)] = value;
+  }
+
+  /**
+   * Pushes a new value onto the list, wrapping around to the start of the array, overriding index 0
+   * if the maximum length is reached.
+   * @param value The value to push onto the list.
+   */
+  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;
+      }
+    } else {
+      this._length++;
+    }
+  }
+
+  /**
+   * Removes and returns the last value on the list.
+   * @return The popped value.
+   */
+  public pop(): T {
+    return this._array[this._getCyclicIndex(this._length-- - 1)];
+  }
+
+  /**
+   * Deletes and/or inserts items at a particular index (in that order). Unlike
+   * Array.prototype.splice, this operation does not return the deleted items as a new array in
+   * order to save creating a new array. Note that this operation may shift all values in the list
+   * in the worst case.
+   * @param start The index to delete and/or insert.
+   * @param deleteCount The number of elements to delete.
+   * @param items The items to insert.
+   */
+  public splice(start: number, deleteCount: number, ...items: T[]): void {
+    if (deleteCount) {
+      for (let i = start; i < this._length - deleteCount; i++) {
+        this._array[this._getCyclicIndex(i)] = this._array[this._getCyclicIndex(i + deleteCount)];
+      }
+      this._length -= deleteCount;
+    }
+    if (items && items.length) {
+      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];
+      }
+
+      if (this._length + items.length > this.maxLength) {
+        this._startIndex += (this._length + items.length) - this.maxLength;
+        this._length = this.maxLength;
+      } else {
+        this._length += items.length;
+      }
+    }
+  }
+
+  /**
+   * Trims a number of items from the start of the list.
+   * @param count The number of items to remove.
+   */
+  public trimStart(count: number): void {
+    if (count > this._length) {
+      count = this._length;
+    }
+    this._startIndex += count;
+    this._length -= count;
+  }
+
+  public shiftElements(start: number, count: number, offset: number): void {
+    if (count <= 0) {
+      return;
+    }
+    if (start < 0 || start >= this._length) {
+      throw new Error('start argument out of range');
+    }
+    if (start + offset < 0) {
+      throw new Error('Cannot shift elements in list beyond index 0');
+    }
+
+    if (offset > 0) {
+      for (let i = count - 1; i >= 0; i--) {
+        this.set(start + i + offset, this.get(start + i));
+      }
+      const expandListBy = (start + count + offset) - this._length;
+      if (expandListBy > 0) {
+        this._length += expandListBy;
+        while (this._length > this.maxLength) {
+          this._length--;
+          this._startIndex++;
+        }
+      }
+    } else {
+      for (let i = 0; i < count; i++) {
+        this.set(start + i + offset, this.get(start + i));
+      }
+    }
+  }
+
+  /**
+   * Gets the cyclic index for the specified regular index. The cyclic index can then be used on the
+   * backing array to get the element associated with the regular index.
+   * @param index The regular index.
+   * @returns The cyclic index.
+   */
+  private _getCyclicIndex(index: number): number {
+    return (this._startIndex + index) % this.maxLength;
+  }
+}

src/utils/Generic.ts

@@ -9,6 +9,6 @@
  * @param {Array} array The array to search for the given element.
  * @param {Object} el The element to look for into the array
  */
-export let contains = function(arr, el) {
+export function contains(arr: any[], el: any) {
   return arr.indexOf(el) >= 0;
 };

src/xterm.css

@@ -71,7 +71,7 @@
     resize: none;
 }
 
-.terminal .terminal-cursor {
+.terminal:not(.xterm-cursor-style-underline):not(.xterm-cursor-style-bar) .terminal-cursor {
     background-color: #fff;
     color: #000;
 }
@@ -82,11 +82,11 @@
     background-color: transparent;
 }
 
-.terminal.focus .terminal-cursor.blinking {
-    animation: blink-cursor 1.2s infinite step-end;
+.terminal:not(.xterm-cursor-style-underline):not(.xterm-cursor-style-bar).focus.xterm-cursor-blink .terminal-cursor {
+    animation: xterm-cursor-blink 1.2s infinite step-end;
 }
 
-@keyframes blink-cursor {
+@keyframes xterm-cursor-blink {
     0% {
         background-color: #fff;
         color: #000;
@@ -97,6 +97,38 @@
     }
 }
 
+.terminal.xterm-cursor-style-bar .terminal-cursor,
+.terminal.xterm-cursor-style-underline .terminal-cursor {
+    position: relative;
+}
+.terminal.xterm-cursor-style-bar .terminal-cursor::before,
+.terminal.xterm-cursor-style-underline .terminal-cursor::before {
+    content: "";
+    display: block;
+    position: absolute;
+    background-color: #fff;
+}
+.terminal.xterm-cursor-style-bar .terminal-cursor::before {
+    top: 0;
+    bottom: 0;
+    left: 0;
+    width: 1px;
+}
+.terminal.xterm-cursor-style-underline .terminal-cursor::before {
+    bottom: 0;
+    left: 0;
+    right: 0;
+    height: 1px;
+}
+.terminal.xterm-cursor-style-bar.focus.xterm-cursor-blink .terminal-cursor::before,
+.terminal.xterm-cursor-style-underline.focus.xterm-cursor-blink .terminal-cursor::before {
+    animation: xterm-cursor-non-bar-blink 1.2s infinite step-end;
+}
+@keyframes xterm-cursor-non-bar-blink {
+    0% { background-color: #fff; }
+    50% { background-color: transparent; }
+}
+
 .terminal .composition-view {
     background: #000;
     color: #FFF;
@@ -116,6 +148,10 @@
     overflow-y: scroll;
 }
 
+.terminal .xterm-wide-char {
+    display: inline-block;
+}
+
 .terminal .xterm-rows {
     position: absolute;
     left: 0;

tsconfig.json

@@ -5,15 +5,20 @@
     "rootDir": "src",
     "allowJs": true,
     "outDir": "lib",
-    "sourceMap": true
+    "sourceMap": true,
+    "removeComments": true
   },
+  "include": [
+    "src/**/*"
+  ],
   "exclude": [
-    "addons",
+    "src/addons/**/*",
     "build",
     "demo",
     "dist",
     "out",
     "test",
-    "node_modules"
+    "node_modules",
+    "docs"
   ]
 }