Bump version to 2.2.3

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

.editorconfig

@@ -6,7 +6,7 @@ indent_size = 2
 insert_final_newline = true
 trim_trailing_whitespace = true
 
-[*.js]
+[*.{j,t}s]
 max_line_length = 100
 
 [*.css]

.gitignore

@@ -1,8 +1,7 @@
 node_modules/
 *.swp
-build/*
 .lock-wscript
-out/
+lib/
 Makefile.gyp
 *.Makefile
 *.target.gyp.mk
@@ -10,3 +9,6 @@ Makefile.gyp
 example/*.log
 docs/
 npm-debug.log
+/.idea/
+.env
+build/

.npmignore

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

.travis.yml

@@ -1,8 +1,12 @@
 language: node_js
 node_js:
-  - 4
+  - 6
 env:
-  - CXX=g++-4.8
+  global:
+    - CXX=g++-4.8
+  matrix:
+    - NPM_COMMAND=lint
+    - NPM_COMMAND=test
 addons:
   apt:
     sources:
@@ -11,3 +15,4 @@ addons:
       - g++-4.8
 notifications:
   email: false
+script: npm run $NPM_COMMAND

AUTHORS

@@ -1,19 +1,34 @@
 List of xterm.js contributors. Updated before every release.
 
+Alessandro Nadalin <alessandro.nadalin@gmail.com>
 Alexander Olsson <noseglid@gmail.com>
 Antonis Kalipetis <akalipetis@sourcelair.com>
+Anton Skshidlevsky <meefik@gmail.com>
+Anton Yurovskykh <anton.yurovskykh@gmail.com>
 Austin Robertson <austinrobertson@gmail.com>
+ayapi <colors.aya@gmail.com>
 Benjamin Fischer <benjamin.fischer@rwth-aachen.de>
+bottleofwater <nison.mael+bottleofwater@gmail.com>
 Carson Anderson <carson@betterservers.com>
+Christian Budde Christensen <budde377@gmail.com>
 Christopher Jeffrey <chjjeffrey@gmail.com>
 Daniel Imms <daimms@microsoft.com>
 Daniel Risacher <drisacher@gmail.com>
 Dan Kaplun <dbkaplun@twitch.tv>
 Darin Morrison <freebroccolo@users.noreply.github.com>
+Elliot Saba <staticfloat@gmail.com>
+hiro-su <h.sugipon@gmail.com>
+Ian Lewis <ianlewis@google.com>
+imoses <ido@twiggle.com>
 Jean Bruenn <himself@jeanbruenn.info>
 Jörg Breitbart <jerch@rockborn.de>
+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>
+Shuanglei Tao <tsl0922@gmail.com>
 Steven Silvester <steven.silvester@ieee.org>
 Thanasis Daglis <thanasis@sourcelair.com>
+Tine Jozelj <tine.jozelj@outlook.com>
+YuviPanda <yuvipanda@gmail.com>

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014, sourceLair Limited (https://github.com/sourcelair/)
+Copyright (c) 2014-2016, SourceLair Private Company (https://www.sourcelair.com)
 Copyright (c) 2012-2013, Christopher Jeffrey (https://github.com/chjj/)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

README.md

@@ -1,18 +1,36 @@
 # xterm.js
 
-![xterm.js build status](https://api.travis-ci.org/sourcelair/xterm.js.svg)
+[![xterm.js build status](https://api.travis-ci.org/sourcelair/xterm.js.svg)](https://travis-ci.org/sourcelair/xterm.js) [![Gitter](https://badges.gitter.im/sourcelair/xterm.js.svg)](https://gitter.im/sourcelair/xterm.js?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
-Xterm.js is a full xterm clone, written in JavaScript.
+Xterm.js is a terminal front-end component written in JavaScript that works in the browser.
 
-It is used at [SourceLair](https://www.sourcelair.com/home) to help people develop their applications in their browsers.
+It enables applications to provide fully featured terminals to their users and create great development experiences.
 
-Xterm.js supplies a modular, event-based interface that lets developers build addons and themes on top of it.
+## Features
+- **Text-based application support**: Use xterm.js to work with applications like `bash`, `git` etc.
+- **Curses-based application support**: Use xterm.js to work with applications like `vim`, `tmux` etc.
+- **Mouse events support**: Xterm.js captures mouse events like click and scroll and passes them to the terminal's back-end controlling process
+- **CJK (Chinese, Japanese, Korean) character support**: Xterm.js renders CJK characters seamlessly
+- **IME support**: Insert international (including CJK) characters using IME input with your keyboard
+- **Self-contained library**: Xterm.js works on its own. It does not require any external libraries like jQuery or React to work
+- **Modular, event-based API**: Lets you build addons and themes with ease
 
-![xterm.js screenshot](xtermjs.png)
+## What xterm.js is not
+- Xterm.js is not a terminal application that you can download and use on your computer
+- Xterm.js is not `bash`. Xterm.js can be connected to processes like `bash` and let you interact with them (provide input, receive output)
+
+## Real-world uses
+Xterm.js is used in several world-class applications to provide great terminal experiences.
+
+- [**SourceLair**](https://www.sourcelair.com/): In-browser IDE that provides its users with fully-featured Linux terminals based on xterm.js
+- [**Microsoft Visual Studio Code**](http://code.visualstudio.com/): Modern, versatile and powerful open source code editor that provides an integrated terminal based on xterm.js
+- [**ttyd**](https://github.com/tsl0922/ttyd): A command-line tool for sharing terminal over the web, with fully-featured terminal emulation based on xterm.js
+
+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.
 
 ## Browser Support
 
-Since xterm.js is typically implemented as a developer tool, only modern browsers are supported officially. Here is a list of the versions we aim to support: 
+Since xterm.js is typically implemented as a developer tool, only modern browsers are supported officially. Here is a list of the versions we aim to support:
 
 - Chrome 48+
 - Edge 13+
@@ -21,7 +39,7 @@ Since xterm.js is typically implemented as a developer tool, only modern browser
 - Opera 35+
 - Safari 8+
 
-xterm.js may work on earlier versions of the browsers but these are the browsers we strive to keep working.
+Xterm.js works seamlessly in Electron apps and may even work on earlier versions of the browsers but these are the browsers we strive to keep working.
 
 ## Demo
 
@@ -32,17 +50,17 @@ npm install
 npm start
 ```
 
-Then open http://0.0.0.0:3000 in a web browser (use http://127.0.0.1:3000 is running under Windows).
+Then open http://0.0.0.0:3000 in a web browser (use http://127.0.0.1:3000 if running under Windows).
 
 ## 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 `addons` directory, you can even write your own (though they may break when the internals of xterm.js change across versions).
+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).
 
 To use an addon, just include the JavaScript file after xterm.js and before the `Terminal` object has been instantiated. The function should then be exposed on the `Terminal` object:
 
 ```html
-<script src="node_modules/src/xterm.js"></script>
-<script src="node_modules/addons/fit/fit.js"></script>
+<script src="node_modules/dist/xterm.js"></script>
+<script src="node_modules/dist/addons/fit/fit.js"></script>
 ```
 
 ```js
@@ -51,8 +69,16 @@ var xterm = new Terminal();
 xterm.fit();
 ```
 
+## Releases
+
+Xterm.js follows a monthly release cycle roughly.
+
+The existing releases are available at this GitHub repo's [Releases](https://github.com/sourcelair/xterm.js/releases), while the roadmap is available as [Milestones](https://github.com/sourcelair/xterm.js/milestones).
+
 ## Development and Contribution
 
+Xterm.js is maintained by [SourceLair](https://www.sourcelair.com/) and a few external contributors, but we would love to receive contributions from everyone!
+
 To contribute either code, documentation or issues to xterm.js please read the [Contributing document](CONTRIBUTING.md) before.
 
 The development of xterm.js does not require any special tool. All you need is an editor that supports JavaScript and a browser (if you would like to run the demo you will need Node.js to get all features).

bin/build

@@ -0,0 +1,36 @@
+#! /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

@@ -3,6 +3,8 @@
 # Usage: ./bin/prepare-release x.y.z
 # x.y.z should be semver (e.g. 1.0.0)
 
+set -e
+
 NEW_VERSION=$1
 CURRENT_PACKAGE_JSON_VERSION=$(cat package.json \
   | grep version \
@@ -17,11 +19,16 @@ CURRENT_BOWER_JSON_VERSION=$(cat bower.json \
   | sed 's/[",]//g' \
   | tr -d '[[:space:]]')
 
-# Update version in package.json and bower.json
-sed -i "s/\"version\": \"$CURRENT_PACKAGE_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" package.json
-sed -i "s/\"version\": \"$CURRENT_BOWER_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" bower.json
+# Build xterm.js into `dist`
+export BUILD_DIR=dist
+./bin/build
 
 # Update AUTHORS file
 sh bin/generate-authors
 
-git commit -a -m "Bump version to $NEW_VERSION"
+# Update version in package.json and bower.json
+sed -i "s/\"version\": \"$CURRENT_PACKAGE_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" package.json
+sed -i "s/\"version\": \"$CURRENT_BOWER_JSON_VERSION\"/\"version\": \"$NEW_VERSION\"/g" bower.json
+
+git commit -S -s -a -m "Bump version to $NEW_VERSION"
+git tag $NEW_VERSION

bin/release

@@ -0,0 +1,22 @@
+#! /usr/bin/env sh
+
+# Usage: ./bin/release x.y.z
+# x.y.z should be semver (e.g. 1.0.0)
+
+set -e
+
+if [ -z "$1" ];
+  then
+    echo "No version supplied. Please a version argument\n"
+    echo "Usage: $0 VERSION\n"
+    echo "Example: $0 1.0.0"
+    exit
+fi
+
+NEW_VERSION=$1
+
+./bin/prepare-release $NEW_VERSION
+
+git push && \
+git push --tags && \
+npm publish

bower.json

@@ -1,5 +1,9 @@
 {
   "name": "xterm.js",
-  "version": "1.0.0",
-  "ignore": ["demo", "test", ".gitignore"]
+  "version": "2.2.3",
+  "ignore": ["demo", "test", ".gitignore"],
+  "main": [
+    "dist/xterm.js",
+    "dist/xterm.css"
+  ]
 }

demo/app.js

@@ -4,8 +4,10 @@ var expressWs = require('express-ws')(app);
 var os = require('os');
 var pty = require('pty.js');
 
-app.use('/src', express.static(__dirname + '/../src'));
-app.use('/addons', express.static(__dirname + '/../addons'));
+var terminals = {},
+    logs = {};
+
+app.use('/build', express.static(__dirname + '/../build'));
 
 app.get('/', function(req, res){
   res.sendFile(__dirname + '/index.html');
@@ -19,17 +21,43 @@ app.get('/main.js', function(req, res){
   res.sendFile(__dirname + '/main.js');
 });
 
-app.ws('/bash', function(ws, req) {
-  /**
-   * Open bash terminal and attach it
-   */
-  var term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
-    name: 'xterm-color',
-    cols: 80,
-    rows: 24,
-    cwd: process.env.PWD,
-    env: process.env
+app.post('/terminals', function (req, res) {
+  var cols = parseInt(req.query.cols),
+      rows = parseInt(req.query.rows),
+      term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
+        name: 'xterm-color',
+        cols: cols || 80,
+        rows: rows || 24,
+        cwd: process.env.PWD,
+        env: process.env
+      });
+
+  console.log('Created terminal with PID: ' + term.pid);
+  terminals[term.pid] = term;
+  logs[term.pid] = '';
+  term.on('data', function(data) {
+    logs[term.pid] += data;
   });
+  res.send(term.pid.toString());
+  res.end();
+});
+
+app.post('/terminals/:pid/size', function (req, res) {
+  var pid = parseInt(req.params.pid),
+      cols = parseInt(req.query.cols),
+      rows = parseInt(req.query.rows),
+      term = terminals[pid];
+
+  term.resize(cols, rows);
+  console.log('Resized terminal ' + pid + ' to ' + cols + ' cols and ' + rows + ' rows.');
+  res.end();
+});
+
+app.ws('/terminals/:pid', function (ws, req) {
+  var term = terminals[parseInt(req.params.pid)];
+  console.log('Connected to terminal ' + term.pid);
+  ws.send(logs[term.pid]);
+
   term.on('data', function(data) {
     try {
       ws.send(data);
@@ -41,8 +69,11 @@ app.ws('/bash', function(ws, req) {
     term.write(msg);
   });
   ws.on('close', function () {
-    console.log('close');
     process.kill(term.pid);
+    console.log('Closed terminal ' + term.pid);
+    // Clean things up
+    delete terminals[term.pid];
+    delete logs[term.pid];
   });
 });
 

demo/index.html

@@ -2,23 +2,36 @@
 <html>
     <head>
         <title>xterm.js demo</title>
-        <link rel="stylesheet" href="../src/xterm.css" />
-        <link rel="stylesheet" href="../addons/fullscreen/fullscreen.css" />
+        <link rel="stylesheet" href="/build/xterm.css" />
+        <link rel="stylesheet" href="/build/addons/fullscreen/fullscreen.css" />
         <link rel="stylesheet" href="style.css" />
-        <script src="../src/xterm.js" ></script>
-        <script src="../addons/attach/attach.js" ></script>
-        <script src="../addons/fit/fit.js" ></script>
-        <script src="../addons/fullscreen/fullscreen.js" ></script>
+      	<script src="https://cdnjs.cloudflare.com/ajax/libs/fetch/1.0.0/fetch.min.js"></script>
+        <script src="/build/xterm.js" ></script>
+        <script src="/build/addons/attach/attach.js" ></script>
+        <script src="/build/addons/fit/fit.js" ></script>
+        <script src="/build/addons/fullscreen/fullscreen.js" ></script>
     </head>
     <body>
-        <h1>
-            xterm.js: xterm, in the browser
-        </h1>
+        <h1>xterm.js: xterm, in the browser</h1>
         <div id="terminal-container"></div>
         <div>
           <h2>Options</h2>
           <label><input type="checkbox" id="option-cursor-blink"> cursorBlink</label>
+          <div>
+          	<h3>Size</h3>
+            <div>
+              <div style="display: inline-block; margin-right: 16px;">
+                <label for="cols">Columns</label>
+                <input type="number" id="cols" />
+              </div>
+              <div style="display: inline-block; margin-right: 16px;">
+                <label for="rows">Rows</label>
+                <input type="number" id="rows" />
+              </div>
+            </div>
+          </div>
         </div>
+        <p><strong>Attention:</strong> The demo is a barebones implementation and is designed for xterm.js evaluation purposes only. Exposing the demo to the public as is would introduce security risks for the host.</p>
         <script src="main.js" defer ></script>
     </body>
 </html>

demo/main.js

@@ -1,34 +1,81 @@
 var term,
     protocol,
     socketURL,
-    socket;
+    socket,
+    pid,
+    charWidth,
+    charHeight;
 
-var terminalContainer = document.getElementById('terminal-container');
-var optionElements = {
-  cursorBlink: document.querySelector('#option-cursor-blink')
-};
+var terminalContainer = document.getElementById('terminal-container'),
+    optionElements = {
+      cursorBlink: document.querySelector('#option-cursor-blink')
+    },
+    colsElement = document.getElementById('cols'),
+    rowsElement = document.getElementById('rows');
+
+function setTerminalSize () {
+  var cols = parseInt(colsElement.value),
+      rows = parseInt(rowsElement.value),
+      width = (cols * charWidth).toString() + 'px',
+      height = (rows * charHeight).toString() + 'px';
+
+  terminalContainer.style.width = width;
+  terminalContainer.style.height = height;
+  term.resize(cols, rows);
+}
+
+colsElement.addEventListener('change', setTerminalSize);
+rowsElement.addEventListener('change', setTerminalSize);
 
 optionElements.cursorBlink.addEventListener('change', createTerminal);
 
 createTerminal();
 
 function createTerminal() {
+  // Clean terminal
   while (terminalContainer.children.length) {
     terminalContainer.removeChild(terminalContainer.children[0]);
   }
   term = new Terminal({
     cursorBlink: optionElements.cursorBlink.checked
   });
+  term.on('resize', function (size) {
+    if (!pid) {
+      return;
+    }
+    var cols = size.cols,
+        rows = size.rows,
+        url = '/terminals/' + pid + '/size?cols=' + cols + '&rows=' + rows;
+
+    fetch(url, {method: 'POST'});
+  });
   protocol = (location.protocol === 'https:') ? 'wss://' : 'ws://';
-  socketURL = protocol + location.hostname + ((location.port) ? (':' + location.port) : '') + '/bash';
-  socket = new WebSocket(socketURL);
+  socketURL = protocol + location.hostname + ((location.port) ? (':' + location.port) : '') + '/terminals/';
 
   term.open(terminalContainer);
   term.fit();
 
-  socket.onopen = runRealTerminal;
-  socket.onclose = runFakeTerminal;
-  socket.onerror = runFakeTerminal;
+  var initialGeometry = term.proposeGeometry(),
+      cols = initialGeometry.cols,
+      rows = initialGeometry.rows;
+
+  colsElement.value = cols;
+  rowsElement.value = rows;
+
+  fetch('/terminals?cols=' + cols + '&rows=' + rows, {method: 'POST'}).then(function (res) {
+
+    charWidth = Math.ceil(term.element.offsetWidth / cols);
+    charHeight = Math.ceil(term.element.offsetHeight / rows);
+
+    res.text().then(function (pid) {
+      window.pid = pid;
+      socketURL += pid;
+      socket = new WebSocket(socketURL);
+      socket.onopen = runRealTerminal;
+      socket.onclose = runFakeTerminal;
+      socket.onerror = runFakeTerminal;
+    });
+  });
 }
 
 
@@ -64,9 +111,7 @@ function runFakeTerminal() {
     if (ev.keyCode == 13) {
       term.prompt();
     } else if (ev.keyCode == 8) {
-      /*
-     * Do not delete the prompt
-     */
+     // Do not delete the prompt
       if (term.x > 2) {
         term.write('\b \b');
       }

demo/style.css

@@ -9,8 +9,8 @@ h1 {
 }
 
 #terminal-container {
-    width: 960px;
-    height: 600px;
+    width: 800px;
+    height: 450px;
     margin: 0 auto;
     padding: 2px;
 }

dist/addons/attach/attach.js

@@ -0,0 +1,114 @@
+/**
+ * Implements the attach method, that attaches the terminal to a WebSocket stream.
+ * @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);
+    }
+})(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));
+    };
+    /**
+     * 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

@@ -0,0 +1,59 @@
+/**
+ * Fit terminal columns and rows to the dimensions of its DOM element.
+ *
+ * ## Approach
+ * - Rows: Truncate the division of the terminal parent element height by the terminal row height.
+ *
+ * - Columns: Truncate the division of the terminal parent element width by the terminal character
+ * width (apply display: inline at the terminal row and truncate its width with the current
+ * number of columns).
+ * @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);
+    }
+})(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;
+});
+//# sourceMappingURL=fit.js.map

dist/addons/fullscreen/fullscreen.js

@@ -0,0 +1,50 @@
+/**
+ * Fullscreen addon for xterm.js
+ * @module xterm/addons/fullscreen/fullscreen
+ * @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)
+     */
+    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

@@ -0,0 +1,165 @@
+/**
+ * Methods for turning URL subscrings in the terminal's content into links (`a` DOM elements).
+ * @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);
+    }
+})(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);
+    /**
+     * 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);
+        }
+        /**
+         * 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);
+    };
+    /**
+     * 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);
+        }
+        /**
+         * 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;
+});
+//# sourceMappingURL=linkify.js.map

dist/addons/terminado/terminado.js

@@ -0,0 +1,122 @@
+/**
+ * This module provides methods for attaching a terminal to a terminado WebSocket stream.
+ *
+ * @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);
+    }
+})(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);
+        }
+        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

jsdoc.json

@@ -1,12 +1,12 @@
 {
   "source": {
     "include": [
-      "src/xterm.js",
-      "addons/attach/attach.js",
-      "addons/fit/fit.js",
-      "addons/fullscreen/fullscreen.js",
-      "addons/linkify/linkify.js"
-    ]
+      "src/"
+    ],
+    "exclude": [
+      "src/test/"
+    ],
+    "excludePattern": "src/.+\\.test\\.(js|ts)$"
   },
   "opts": {
     "readme": "README.md",

package.json

@@ -1,28 +1,62 @@
 {
   "name": "xterm",
-  "version": "1.0.0",
+  "version": "2.2.3",
   "ignore": [
     "demo",
     "test",
     ".gitignore"
   ],
-  "main": "src/xterm.js",
+  "main": "lib/xterm.js",
   "repository": "https://github.com/sourcelair/xterm.js",
   "license": "MIT",
+  "files": [
+    "dist/*.css",
+    "dist/**/*.css",
+    "dist/*.js",
+    "dist/*.js.map",
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "lib/*.css",
+    "lib/**/*.css",
+    "lib/*.js",
+    "lib/*.js.map",
+    "lib/**/*.js",
+    "lib/**/*.js.map",
+    "src/*.css",
+    "src/**/*.css",
+    "src/*.js",
+    "src/*.js.map",
+    "src/*.ts",
+    "src/**/*.js",
+    "src/**/*.js.map",
+    "src/**/*.ts"
+  ],
   "devDependencies": {
+    "@types/chai": "^3.4.34",
+    "@types/mocha": "^2.2.33",
+    "@types/node": "^6.0.41",
+    "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",
     "glob": "^7.0.5",
-    "jsdoc": "3.4.0",
+    "jsdoc": "3.4.3",
     "mocha": "2.5.3",
-    "pty.js": "0.3.0",
-    "sleep": "^3.0.1"
+    "nodemon": "1.10.2",
+    "pty.js": "0.3.1",
+    "sleep": "^3.0.1",
+    "sorcery": "^0.10.0",
+    "tslint": "^4.0.2",
+    "typescript": "^2.0.3"
   },
   "scripts": {
-    "start": "node demo/app",
-    "test": "mocha --recursive",
-    "build:docs": "node_modules/.bin/jsdoc -c jsdoc.json"
+    "start": "nodemon --watch src --watch addons --watch demo --exec bash -c './bin/build && node demo/app'",
+    "lint": "tslint src/**/*.ts",
+    "test": "mocha --recursive ./lib",
+    "build:docs": "jsdoc -c jsdoc.json",
+    "build": "./bin/build",
+    "prepublish": "tsc"
   }
 }

src/CompositionHelper.test.ts

@@ -0,0 +1,236 @@
+import { assert } from 'chai';
+import { CompositionHelper } from './CompositionHelper';
+
+describe('CompositionHelper', () => {
+  var terminal;
+  var compositionHelper;
+  var compositionView;
+  var textarea;
+  var handledText;
+
+  beforeEach(() => {
+    compositionView = {
+      classList: {
+        add: () => {},
+        remove: () => {},
+      },
+      getBoundingClientRect: () => {
+        return { width: 0 };
+      },
+      style: {
+        left: 0,
+        top: 0
+      },
+      textContent: ''
+    };
+    textarea = {
+      value: '',
+      style: {
+        left: 0,
+        top: 0
+      }
+    };
+    terminal = {
+      element: {
+        querySelector: () => {
+          return { offsetLeft: 0, offsetTop: 0 };
+        }
+      },
+      handler: function (text) {
+        handledText += text;
+      }
+    };
+    handledText = '';
+    compositionHelper = new CompositionHelper(textarea, compositionView, terminal);
+  });
+
+  describe('Input', () => {
+    it('Should insert simple characters', function (done) {
+      // First character 'ㅇ'
+      compositionHelper.compositionstart();
+      compositionHelper.compositionupdate({ data: 'ㅇ' });
+      textarea.value = 'ㅇ';
+      setTimeout(() => { // wait for any textarea updates
+        compositionHelper.compositionend();
+        setTimeout(() => { // wait for any textarea updates
+          assert.equal(handledText, 'ㅇ');
+          // Second character 'ㅇ'
+          compositionHelper.compositionstart();
+          compositionHelper.compositionupdate({ data: 'ㅇ' });
+          textarea.value = 'ㅇㅇ';
+          setTimeout(() => { // wait for any textarea updates
+            compositionHelper.compositionend();
+            setTimeout(() => { // wait for any textarea updates
+              assert.equal(handledText, 'ㅇㅇ');
+              done();
+            }, 0);
+          }, 0);
+        }, 0);
+      }, 0);
+    });
+
+    it('Should insert complex characters', function (done) {
+      // First character '앙'
+      compositionHelper.compositionstart();
+      compositionHelper.compositionupdate({ data: 'ㅇ' });
+      textarea.value = 'ㅇ';
+      setTimeout(() => { // wait for any textarea updates
+        compositionHelper.compositionupdate({ data: '아' });
+        textarea.value = '아';
+        setTimeout(() => { // wait for any textarea updates
+          compositionHelper.compositionupdate({ data: '앙' });
+          textarea.value = '앙';
+          setTimeout(() => { // wait for any textarea updates
+            compositionHelper.compositionend();
+            setTimeout(() => { // wait for any textarea updates
+              assert.equal(handledText, '앙');
+              // Second character '앙'
+              compositionHelper.compositionstart();
+              compositionHelper.compositionupdate({ data: 'ㅇ' });
+              textarea.value = '앙ㅇ';
+              setTimeout(() => { // wait for any textarea updates
+                compositionHelper.compositionupdate({ data: '아' });
+                textarea.value = '앙아';
+                setTimeout(() => { // wait for any textarea updates
+                  compositionHelper.compositionupdate({ data: '앙' });
+                  textarea.value = '앙앙';
+                  setTimeout(() => { // wait for any textarea updates
+                    compositionHelper.compositionend();
+                    setTimeout(() => { // wait for any textarea updates
+                      assert.equal(handledText, '앙앙');
+                      done();
+                    }, 0);
+                  }, 0);
+                }, 0);
+              }, 0);
+            }, 0);
+          }, 0);
+        }, 0);
+      }, 0);
+    });
+
+    it('Should insert complex characters that change with following character', function (done) {
+      // First character '아'
+      compositionHelper.compositionstart();
+      compositionHelper.compositionupdate({ data: 'ㅇ' });
+      textarea.value = 'ㅇ';
+      setTimeout(() => { // wait for any textarea updates
+        compositionHelper.compositionupdate({ data: '아' });
+        textarea.value = '아';
+        setTimeout(() => { // wait for any textarea updates
+          // Start second character '아' in first character
+          compositionHelper.compositionupdate({ data: '앙' });
+          textarea.value = '앙';
+          setTimeout(() => { // wait for any textarea updates
+            compositionHelper.compositionend();
+            compositionHelper.compositionstart();
+            compositionHelper.compositionupdate({ data: '아' });
+            textarea.value = '아아'
+            setTimeout(() => { // wait for any textarea updates
+              compositionHelper.compositionend();
+              setTimeout(() => { // wait for any textarea updates
+                assert.equal(handledText, '아아');
+                done();
+              }, 0);
+            }, 0);
+          }, 0);
+        }, 0);
+      }, 0);
+    });
+
+    it('Should insert multi-characters compositions', function (done) {
+      // First character 'だ'
+      compositionHelper.compositionstart();
+      compositionHelper.compositionupdate({ data: 'd' });
+      textarea.value = 'd';
+      setTimeout(() => { // wait for any textarea updates
+        compositionHelper.compositionupdate({ data: 'だ' });
+        textarea.value = 'だ';
+        setTimeout(() => { // wait for any textarea updates
+          // Second character 'あ'
+          compositionHelper.compositionupdate({ data: 'だあ' });
+          textarea.value = 'だあ';
+          setTimeout(() => { // wait for any textarea updates
+            compositionHelper.compositionend();
+            setTimeout(() => { // wait for any textarea updates
+              assert.equal(handledText, 'だあ');
+              done();
+            }, 0);
+          }, 0);
+        }, 0);
+      }, 0);
+    });
+
+    it('Should insert multi-character compositions that are converted to other characters with the same length', function (done) {
+      // First character 'だ'
+      compositionHelper.compositionstart();
+      compositionHelper.compositionupdate({ data: 'd' });
+      textarea.value = 'd';
+      setTimeout(() => { // wait for any textarea updates
+        compositionHelper.compositionupdate({ data: 'だ' });
+        textarea.value = 'だ';
+        setTimeout(() => { // wait for any textarea updates
+          // Second character 'ー'
+          compositionHelper.compositionupdate({ data: 'だー' });
+          textarea.value = 'だー';
+          setTimeout(() => { // wait for any textarea updates
+            // Convert to katakana 'ダー'
+            compositionHelper.compositionupdate({ data: 'ダー' });
+            textarea.value = 'ダー';
+            setTimeout(() => { // wait for any textarea updates
+              compositionHelper.compositionend();
+              setTimeout(() => { // wait for any textarea updates
+                assert.equal(handledText, 'ダー');
+                done();
+              }, 0);
+            }, 0);
+          }, 0);
+        }, 0);
+      }, 0);
+    })
+
+    it('Should insert multi-character compositions that are converted to other characters with different lengths', function (done) {
+      // First character 'い'
+      compositionHelper.compositionstart();
+      compositionHelper.compositionupdate({ data: 'い' });
+      textarea.value = 'い';
+      setTimeout(() => { // wait for any textarea updates
+        // Second character 'ま'
+        compositionHelper.compositionupdate({ data: 'いm' });
+        textarea.value = 'いm';
+        setTimeout(() => { // wait for any textarea updates
+          compositionHelper.compositionupdate({ data: 'いま' });
+          textarea.value = 'いま';
+          setTimeout(() => { // wait for any textarea updates
+            // Convert to kanji '今'
+            compositionHelper.compositionupdate({ data: '今' });
+            textarea.value = '今';
+            setTimeout(() => { // wait for any textarea updates
+              compositionHelper.compositionend();
+              setTimeout(() => { // wait for any textarea updates
+                assert.equal(handledText, '今');
+                done();
+              }, 0);
+            }, 0);
+          }, 0);
+        }, 0);
+      }, 0);
+    });
+
+    it('Should insert non-composition characters input immediately after composition characters', function (done) {
+      // First character 'ㅇ'
+      compositionHelper.compositionstart();
+      compositionHelper.compositionupdate({ data: 'ㅇ' });
+      textarea.value = 'ㅇ';
+      setTimeout(() => { // wait for any textarea updates
+        compositionHelper.compositionend();
+        // Second character '1' (a non-composition character)
+        textarea.value = 'ㅇ1';
+        setTimeout(() => { // wait for any textarea updates
+          assert.equal(handledText, 'ㅇ1');
+          done();
+        }, 0);
+      }, 0);
+    });
+  });
+});

src/CompositionHelper.ts

@@ -0,0 +1,232 @@
+/**
+ * @license MIT
+ */
+
+import { ITerminal } from './Interfaces';
+
+interface IPosition {
+  start: number;
+  end: number;
+}
+
+/**
+ * Encapsulates the logic for handling compositionstart, compositionupdate and compositionend
+ * events, displaying the in-progress composition to the UI and forwarding the final composition
+ * to the handler.
+ */
+export class CompositionHelper {
+  /**
+   * Whether input composition is currently happening, eg. via a mobile keyboard, speech input or
+   * IME. This variable determines whether the compositionText should be displayed on the UI.
+   */
+  private isComposing: boolean;
+
+  /**
+   * The position within the input textarea's value of the current composition.
+   */
+  private compositionPosition: IPosition;;
+
+  /**
+   * Whether a composition is in the process of being sent, setting this to false will cancel any
+   * in-progress composition.
+   */
+  private isSendingComposition: boolean;
+
+  /**
+   * Creates a new CompositionHelper.
+   * @param textarea The textarea that xterm uses for input.
+   * @param compositionView The element to display the in-progress composition in.
+   * @param terminal The Terminal to forward the finished composition to.
+   */
+  constructor(
+    private textarea: HTMLTextAreaElement,
+    private compositionView: HTMLElement,
+    private terminal: ITerminal
+  ) {
+    this.isComposing = false;
+    this.isSendingComposition = false;
+    this.compositionPosition = { start: null, end: null };
+  }
+
+  /**
+   * Handles the compositionstart event, activating the composition view.
+   */
+  public compositionstart() {
+    this.isComposing = true;
+    this.compositionPosition.start = this.textarea.value.length;
+    this.compositionView.textContent = '';
+    this.compositionView.classList.add('active');
+  }
+
+  /**
+   * Handles the compositionupdate event, updating the composition view.
+   * @param {CompositionEvent} ev The event.
+   */
+  public compositionupdate(ev: CompositionEvent) {
+    this.compositionView.textContent = ev.data;
+    this.updateCompositionElements();
+    var self = this;
+    setTimeout(function() {
+      self.compositionPosition.end = self.textarea.value.length;
+    }, 0);
+  }
+
+  /**
+   * Handles the compositionend event, hiding the composition view and sending the composition to
+   * the handler.
+   */
+  public compositionend() {
+    this.finalizeComposition(true);
+  }
+
+  /**
+   * Handles the keydown event, routing any necessary events to the CompositionHelper functions.
+   * @param ev The keydown event.
+   * @return Whether the Terminal should continue processing the keydown event.
+   */
+  public keydown(ev: KeyboardEvent) {
+    if (this.isComposing || this.isSendingComposition) {
+      if (ev.keyCode === 229) {
+        // Continue composing if the keyCode is the "composition character"
+        return false;
+      } else if (ev.keyCode === 16 || ev.keyCode === 17 || ev.keyCode === 18) {
+        // Continue composing if the keyCode is a modifier key
+        return false;
+      } else {
+        // Finish composition immediately. This is mainly here for the case where enter is
+        // pressed and the handler needs to be triggered before the command is executed.
+        this.finalizeComposition(false);
+      }
+    }
+
+    if (ev.keyCode === 229) {
+      // If the "composition character" is used but gets to this point it means a non-composition
+      // character (eg. numbers and punctuation) was pressed when the IME was active.
+      this.handleAnyTextareaChanges();
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Finalizes the composition, resuming regular input actions. This is called when a composition
+   * is ending.
+   * @param waitForPropogation Whether to wait for events to propogate before sending
+   *   the input. This should be false if a non-composition keystroke is entered before the
+   *   compositionend event is triggered, such as enter, so that the composition is send before
+   *   the command is executed.
+   */
+  private finalizeComposition(waitForPropogation: boolean) {
+    this.compositionView.classList.remove('active');
+    this.isComposing = false;
+    this.clearTextareaPosition();
+
+    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);
+      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 = {
+        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
+      // complete. This ensures the correct character is retrieved, this solution was used
+      // because:
+      // - The compositionend event's data property is unreliable, at least on Chromium
+      // - The last compositionupdate event's data property does not always accurately describe
+      //   the character, a counter example being Korean where an ending consonsant can move to
+      //   the following character if the following input is a vowel.
+      var self = this;
+      this.isSendingComposition = true;
+      setTimeout(function () {
+        // Ensure that the input has not already been sent
+        if (self.isSendingComposition) {
+          self.isSendingComposition = false;
+          var input;
+          if (self.isComposing) {
+            // Use the end position to get the string if a new composition has started.
+            input = self.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);
+          }
+          self.terminal.handler(input);
+        }
+      }, 0);
+    }
+  }
+
+  /**
+   * Apply any changes made to the textarea after the current event chain is allowed to complete.
+   * This should be called when not currently composing but a keydown event with the "composition
+   * character" (229) is triggered, in order to allow non-composition text to be entered when an
+   * IME is active.
+   */
+  private handleAnyTextareaChanges() {
+    var oldValue = this.textarea.value;
+    var self = this;
+    setTimeout(function() {
+      // Ignore if a composition has started since the timeout
+      if (!self.isComposing) {
+        var newValue = self.textarea.value;
+        var diff = newValue.replace(oldValue, '');
+        if (diff.length > 0) {
+          self.terminal.handler(diff);
+        }
+      }
+    }, 0);
+  }
+
+  /**
+   * Positions the composition view on top of the cursor and the textarea just below it (so the
+   * IME helper dialog is positioned correctly).
+   * @param dontRecurse Whether to use setTimeout to recursively trigger another update, this is
+   *   necessary as the IME events across browsers are not consistently triggered.
+   */
+  public updateCompositionElements(dontRecurse?: boolean) {
+    if (!this.isComposing) {
+      return;
+    }
+    var 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;
+
+      this.compositionView.style.left = cursor.offsetLeft + 'px';
+      this.compositionView.style.top = cursorTop + 'px';
+      this.compositionView.style.height = cursor.offsetHeight + 'px';
+      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();
+      this.textarea.style.left = cursor.offsetLeft + 'px';
+      this.textarea.style.top = cursorTop + 'px';
+      this.textarea.style.width = compositionViewBounds.width + 'px';
+      this.textarea.style.height = compositionViewBounds.height + 'px';
+      this.textarea.style.lineHeight = compositionViewBounds.height + 'px';
+    }
+    if (!dontRecurse) {
+      setTimeout(this.updateCompositionElements.bind(this, true), 0);
+    }
+  };
+
+  /**
+   * Clears the textarea's position so that the cursor does not blink on IE.
+   * @private
+   */
+  private clearTextareaPosition() {
+    this.textarea.style.left = '';
+    this.textarea.style.top = '';
+  };
+}

src/EventEmitter.js

@@ -0,0 +1,64 @@
+/**
+ * @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/Interfaces.ts

@@ -0,0 +1,34 @@
+/**
+ * @license MIT
+ */
+
+export interface IBrowser {
+  isNode: boolean;
+  userAgent: string;
+  platform: string;
+  isFirefox: boolean;
+  isMSIE: boolean;
+  isMac: boolean;
+  isIpad: boolean;
+  isIphone: boolean;
+  isMSWindows: boolean;
+}
+
+export interface ITerminal {
+  element: HTMLElement;
+  rowContainer: HTMLElement;
+  textarea: HTMLTextAreaElement;
+  ydisp: number;
+  lines: string[];
+  rows: number;
+  browser: IBrowser;
+
+  /**
+   * Emit the 'data' event and populate the given data.
+   * @param data The data to populate in the event.
+   */
+  handler(data: string);
+  on(event: string, callback: () => void);
+  scrollDisp(disp: number, suppressScrollEvent: boolean);
+  cancel(ev: Event, force?: boolean);
+}

src/Viewport.test.ts

@@ -0,0 +1,84 @@
+import { assert } from 'chai';
+import { Viewport } from './Viewport';
+
+describe('Viewport', () => {
+  var terminal;
+  var viewportElement;
+  var charMeasureElement;
+  var viewport;
+  var scrollAreaElement;
+
+  const CHARACTER_HEIGHT = 10;
+
+  beforeEach(() => {
+    terminal = {
+      lines: [],
+      rows: 0,
+      ydisp: 0,
+      on: () => {},
+      rowContainer: {
+        style: {
+          lineHeight: 0
+        }
+      }
+    };
+    viewportElement = {
+      addEventListener: () => {},
+      style: {
+        height: 0,
+        lineHeight: 0
+      }
+    };
+    scrollAreaElement = {
+      style: {
+        height: 0
+      }
+    };
+    charMeasureElement = {
+      getBoundingClientRect: () => {
+        return { width: null, height: CHARACTER_HEIGHT };
+      }
+    };
+    viewport = new Viewport(terminal, viewportElement, scrollAreaElement, charMeasureElement);
+  });
+
+  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 };
+      };
+      viewport.refresh();
+      assert.equal(viewportElement.style.lineHeight, '1px');
+      assert.equal(terminal.rowContainer.style.lineHeight, '1px');
+    });
+    it('should set the height of the viewport when the line-height changed', () => {
+      terminal.lines.push('');
+      terminal.lines.push('');
+      terminal.rows = 1;
+      viewport.refresh();
+      assert.equal(viewportElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
+      charMeasureElement.getBoundingClientRect = () => {
+        return { width: null, height: 20 };
+      };
+      viewport.refresh();
+      assert.equal(viewportElement.style.height, 20 + 'px');
+    });
+  });
+
+  describe('syncScrollArea', () => {
+    it('should sync the scroll area', () => {
+      terminal.lines.push('');
+      terminal.rows = 1;
+      assert.equal(scrollAreaElement.style.height, 0 * CHARACTER_HEIGHT + 'px');
+      viewport.syncScrollArea();
+      assert.equal(viewportElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
+      assert.equal(scrollAreaElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
+      terminal.lines.push('');
+      viewport.syncScrollArea();
+      assert.equal(viewportElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
+      assert.equal(scrollAreaElement.style.height, 2 * CHARACTER_HEIGHT + 'px');
+    });
+  });
+});

src/Viewport.ts

@@ -0,0 +1,123 @@
+/**
+ * @license MIT
+ */
+
+import { ITerminal } from './Interfaces';
+
+/**
+ * Represents the viewport of a terminal, the visible area within the larger buffer of output.
+ * Logic for the virtual scroll bar is included in this object.
+ */
+export class Viewport {
+  private currentRowHeight: number;
+  private lastRecordedBufferLength: number;
+  private lastRecordedViewportHeight: number;
+
+  /**
+   * Creates a new Viewport.
+   * @param terminal The terminal this viewport belongs to.
+   * @param viewportElement The DOM element acting as the viewport.
+   * @param scrollArea The DOM element acting as the scroll area.
+   * @param charMeasureElement A DOM element used to measure the character size of. the terminal.
+   */
+  constructor(
+    private terminal: ITerminal,
+    private viewportElement: HTMLElement,
+    private scrollArea: HTMLElement,
+    private charMeasureElement: HTMLElement
+  ) {
+    this.currentRowHeight = 0;
+    this.lastRecordedBufferLength = 0;
+    this.lastRecordedViewportHeight = 0;
+
+    this.terminal.on('scroll', this.syncScrollArea.bind(this));
+    this.terminal.on('resize', this.syncScrollArea.bind(this));
+    this.viewportElement.addEventListener('scroll', this.onScroll.bind(this));
+
+    this.syncScrollArea();
+  }
+
+  /**
+   * Refreshes row height, setting line-height, viewport height and scroll area height if
+   * necessary.
+   * @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;
+      if (rowHeightChanged) {
+        this.currentRowHeight = size.height;
+        this.viewportElement.style.lineHeight = size.height + 'px';
+        this.terminal.rowContainer.style.lineHeight = size.height + 'px';
+      }
+      var 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.scrollArea.style.height = (size.height * this.lastRecordedBufferLength) + 'px';
+    }
+  }
+
+  /**
+   * Updates dimensions and synchronizes the scroll area if necessary.
+   */
+  public syncScrollArea(): void {
+    if (this.lastRecordedBufferLength !== this.terminal.lines.length) {
+      // If buffer height changed
+      this.lastRecordedBufferLength = this.terminal.lines.length;
+      this.refresh();
+    } else if (this.lastRecordedViewportHeight !== this.terminal.rows) {
+      // If viewport height changed
+      this.refresh();
+    } else {
+      // If size has changed, refresh viewport
+      var size = this.charMeasureElement.getBoundingClientRect();
+      if (size.height !== this.currentRowHeight) {
+        this.refresh(size);
+      }
+    }
+
+    // Sync scrollTop
+    var scrollTop = this.terminal.ydisp * this.currentRowHeight;
+    if (this.viewportElement.scrollTop !== scrollTop) {
+      this.viewportElement.scrollTop = scrollTop;
+    }
+  }
+
+  /**
+   * Handles scroll events on the viewport, calculating the new viewport and requesting the
+   * terminal to scroll to it.
+   * @param ev The scroll event.
+   */
+  private onScroll(ev: Event) {
+    var newRow = Math.round(this.viewportElement.scrollTop / this.currentRowHeight);
+    var diff = newRow - this.terminal.ydisp;
+    this.terminal.scrollDisp(diff, true);
+  }
+
+  /**
+   * Handles mouse wheel events by adjusting the viewport's scrollTop and delegating the actual
+   * scrolling to `onScroll`, this event needs to be attached manually by the consumer of
+   * `Viewport`.
+   * @param ev The mouse wheel event.
+   */
+  public onWheel(ev: WheelEvent) {
+    if (ev.deltaY === 0) {
+      // Do nothing if it's not a vertical scroll event
+      return;
+    }
+    // Fallback to WheelEvent.DOM_DELTA_PIXEL
+    var multiplier = 1;
+    if (ev.deltaMode === WheelEvent.DOM_DELTA_LINE) {
+      multiplier = this.currentRowHeight;
+    } else if (ev.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
+      multiplier = this.currentRowHeight * this.terminal.rows;
+    }
+    this.viewportElement.scrollTop += ev.deltaY * multiplier;
+    // Prevent the page from scrolling when the terminal scrolls
+    ev.preventDefault();
+  };
+}

src/addons/attach/attach.js

@@ -1,9 +1,7 @@
-/*
- * Implements the attach method, that
- * attaches the terminal to a WebSocket stream.
- *
- * The bidirectional argument indicates, whether the terminal should
- * send data to the socket as well and is true, by default.
+/**
+ * Implements the attach method, that attaches the terminal to a WebSocket stream.
+ * @module xterm/addons/attach/attach
+ * @license MIT
  */
 
 (function (attach) {
@@ -11,27 +9,21 @@
     /*
      * CommonJS environment
      */
-    module.exports = attach(require('../../src/xterm'));
+    module.exports = attach(require('../../xterm'));
   } else if (typeof define == 'function') {
     /*
      * Require.js is available
      */
-    define(['../../src/xterm'], attach);
+    define(['../../xterm'], attach);
   } else {
     /*
      * Plain browser environment
      */
-    attach(this.Xterm);
+    attach(window.Terminal);
   }
 })(function (Xterm) {
   'use strict';
 
-  /**
-   * This module provides methods for attaching a terminal to a WebSocket
-   * stream.
-   *
-   * @module xterm/addons/attach/attach
-   */
   var exports = {};
 
   /**

src/addons/fit/fit.js

@@ -1,45 +1,40 @@
-/*
- *  Fit terminal columns and rows to the dimensions of its
- *  DOM element.
+/**
+ * Fit terminal columns and rows to the dimensions of its DOM element.
  *
- *  Approach:
- *    - Rows: Truncate the division of the terminal parent element height
- *            by the terminal row height
+ * ## Approach
+ * - Rows: Truncate the division of the terminal parent element height by the terminal row height.
  *
- *    - Columns: Truncate the division of the terminal parent element width by
- *               the terminal character width (apply display: inline at the
- *               terminal row and truncate its width with the current number
- *               of columns)
+ * - Columns: Truncate the division of the terminal parent element width by the terminal character
+ * width (apply display: inline at the terminal row and truncate its width with the current
+ * number of columns).
+ * @module xterm/addons/fit/fit
+ * @license MIT
  */
+
 (function (fit) {
   if (typeof exports === 'object' && typeof module === 'object') {
     /*
      * CommonJS environment
      */
-    module.exports = fit(require('../../src/xterm'));
+    module.exports = fit(require('../../xterm'));
   } else if (typeof define == 'function') {
     /*
      * Require.js is available
      */
-    define(['../../src/xterm'], fit);
+    define(['../../xterm'], fit);
   } else {
     /*
      * Plain browser environment
      */
-    fit(this.Xterm);
+    fit(window.Terminal);
   }
 })(function (Xterm) {
-  /**
-   * This module provides methods for fitting a terminal's size to a parent container.
-   *
-   * @module xterm/addons/fit/fit
-   */
   var exports = {};
 
   exports.proposeGeometry = function (term) {
     var parentElementStyle = window.getComputedStyle(term.element.parentElement),
         parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height')),
-        parentElementWidth = parseInt(parentElementStyle.getPropertyValue('width')),
+        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')),
@@ -62,7 +57,7 @@
     subjectRow.innerHTML = contentBuffer;
 
     rows = parseInt(availableHeight / characterHeight);
-    cols = parseInt(availableWidth / characterWidth) - 1;
+    cols = parseInt(availableWidth / characterWidth);
 
     geometry = {cols: cols, rows: rows};
     return geometry;

src/addons/fullscreen/fullscreen.css

@@ -0,0 +1,10 @@
+.xterm.fullscreen {
+    position: fixed;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    width: auto;
+    height: auto;
+    z-index: 255;
+}

src/addons/fullscreen/fullscreen.js

@@ -1,35 +1,33 @@
-/*
+/**
  * Fullscreen addon for xterm.js
- *
- * Implements the toggleFullscreen function.
- *
- * If the `fullscreen` argument has been supplied, then
- * if it is true, the fullscreen mode gets turned on,
- * if it is false or null, the fullscreen mode gets turned off.
- *
- * If the `fullscreen` argument has not been supplied, the
- * fullscreen mode is being toggled.
+ * @module xterm/addons/fullscreen/fullscreen
+ * @license MIT
  */
 (function (fullscreen) {
   if (typeof exports === 'object' && typeof module === 'object') {
     /*
      * CommonJS environment
      */
-    module.exports = fullscreen(require('../../src/xterm'));
+    module.exports = fullscreen(require('../../xterm'));
   } else if (typeof define == 'function') {
     /*
      * Require.js is available
      */
-    define(['../../src/xterm'], fullscreen);
+    define(['../../xterm'], fullscreen);
   } else {
     /*
      * Plain browser environment
      */
-    fullscreen(this.Xterm);
+    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;
 

src/addons/linkify/linkify.js

@@ -1,29 +1,29 @@
+/**
+ * Methods for turning URL subscrings in the terminal's content into links (`a` DOM elements).
+ * @module xterm/addons/linkify/linkify
+ * @license MIT
+ */
+
 (function (linkify) {
   if (typeof exports === 'object' && typeof module === 'object') {
     /*
      * CommonJS environment
      */
-    module.exports = linkify(require('../../src/xterm'));
+    module.exports = linkify(require('../../xterm'));
   } else if (typeof define == 'function') {
     /*
      * Require.js is available
      */
-    define(['../../src/xterm'], linkify);
+    define(['../../xterm'], linkify);
   } else {
     /*
      * Plain browser environment
      */
-    linkify(this.Xterm);
+    linkify(window.Terminal);
   }
 })(function (Xterm) {
   'use strict';
 
-  /**
-   * This module provides methods for convertings valid URL substrings
-   * into HTML anchor elements (links), inside a terminal view.
-   *
-   * @module xterm/addons/linkify/linkify
-   */
   var exports = {},
       protocolClause = '(https?:\\/\\/)',
       domainCharacterSet = '[\\da-z\\.-]+',
@@ -54,10 +54,12 @@
    *								  		 "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) {
+  exports.linkifyTerminalLine = function (terminal, line, lenient, target) {
     if (typeof line == 'number') {
       line = terminal.rowContainer.children[line];
     } else if (! (line instanceof HTMLDivElement)) {
@@ -67,6 +69,12 @@
       throw new TypeError(message);
     }
 
+    if (typeof target === 'undefined') {
+      target = '';
+    } else {
+      target = 'target="' + target + '"';
+    }
+
     var buffer = document.createElement('span'),
         nodes = line.childNodes;
 
@@ -100,7 +108,7 @@
       var startsWithProtocol = new RegExp('^' + protocolClause),
           urlHasProtocol = url.match(startsWithProtocol),
           href = (urlHasProtocol) ? url : 'http://' + url,
-          link = '<a href="' +  href + '" >' + url + '</a>',
+          link = '<a href="' +  href + '" ' + target + '>' + url + '</a>',
           newHTML = nodeHTML.replace(url, link);
 
       line.innerHTML = line.innerHTML.replace(nodeHTML, newHTML);
@@ -137,17 +145,19 @@
    * @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) {
+  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);
+      exports.linkifyTerminalLine(terminal, line, lenient, target);
     }
 
     /**
@@ -173,9 +183,11 @@
    *								  		 "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) {
-    return exports.linkifyTerminalLine(this, line, lenient);
+  Xterm.prototype.linkifyTerminalLine = function (line, lenient, target) {
+    return exports.linkifyTerminalLine(this, line, lenient, target);
   };
 
   /**
@@ -184,9 +196,11 @@
    * @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) {
-    return exports.linkify(this, lenient);
+  Xterm.prototype.linkify = function (lenient, target) {
+    return exports.linkify(this, lenient, target);
   };
 
   return exports;

src/addons/terminado/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "xterm.terminado",
+  "main": "terminado.js",
+  "private": true
+}

src/addons/terminado/terminado.js

@@ -0,0 +1,135 @@
+/**
+ * This module provides methods for attaching a terminal to a terminado WebSocket stream.
+ *
+ * @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);
+  }
+})(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);
+    }
+    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;
+});

src/handlers/Clipboard.test.ts

@@ -0,0 +1,18 @@
+import { assert } from 'chai';
+import * as Terminal from '../xterm';
+import * as Clipboard from './Clipboard';
+
+
+describe('evaluateCopiedTextProcessing', function () {
+  it('should strip trailing whitespaces and replace nbsps with spaces', function () {
+    let nonBreakingSpace = String.fromCharCode(160),
+        copiedText = 'echo' + nonBreakingSpace + 'hello' + nonBreakingSpace,
+        processedText = Clipboard.prepareTextForClipboard(copiedText);
+
+    // No trailing spaces
+    assert.equal(processedText.match(/\s+$/), null);
+
+    // No non-breaking space
+    assert.equal(processedText.indexOf(nonBreakingSpace), -1);
+  });
+});

src/handlers/Clipboard.ts

@@ -0,0 +1,154 @@
+/**
+ * Clipboard handler module: exports methods for handling all clipboard-related events in the
+ * terminal.
+ * @module xterm/handlers/Clipboard
+ * @license MIT
+ */
+
+import { ITerminal } from '../Interfaces';
+
+interface IWindow extends Window {
+  clipboardData?: {
+    getData(format: string): string;
+    setData(format: string, data: string);
+  };
+}
+
+declare var window: IWindow;
+
+/**
+ * Prepares text copied from terminal selection, to be saved in the clipboard by:
+ *   1. stripping all trailing white spaces
+ *   2. converting all non-breaking spaces to regular spaces
+ * @param {string} text The copied text that needs processing for storing in clipboard
+ * @returns {string}
+ */
+export function prepareTextForClipboard(text: string): string {
+  let space = String.fromCharCode(32),
+      nonBreakingSpace = String.fromCharCode(160),
+      allNonBreakingSpaces = new RegExp(nonBreakingSpace, 'g'),
+      processedText = text.split('\n').map(function (line) {
+        // Strip all trailing white spaces and convert all non-breaking spaces
+        // to regular spaces.
+        let processedLine = line.replace(/\s+$/g, '').replace(allNonBreakingSpaces, space);
+
+        return processedLine;
+      }).join('\n');
+
+  return processedText;
+}
+
+/**
+ * Binds copy functionality to the given terminal.
+ * @param {ClipboardEvent} ev The original copy event to be handled
+ */
+export function copyHandler(ev: ClipboardEvent, term: ITerminal) {
+  // We cast `window` to `any` type, because TypeScript has not declared the `clipboardData`
+  // property that we use below for Internet Explorer.
+  let copiedText = window.getSelection().toString(),
+      text = prepareTextForClipboard(copiedText);
+
+  if (term.browser.isMSIE) {
+    window.clipboardData.setData('Text', text);
+  } else {
+    ev.clipboardData.setData('text/plain', text);
+  }
+
+  ev.preventDefault(); // Prevent or the original text will be copied.
+}
+
+/**
+ * Redirect the clipboard's data to the terminal's input handler.
+ * @param {ClipboardEvent} ev The original paste event to be handled
+ * @param {Terminal} term The terminal on which to apply the handled paste event
+ */
+export function pasteHandler(ev: ClipboardEvent, term: ITerminal) {
+  ev.stopPropagation();
+
+  let text: string;
+
+  let dispatchPaste = function(text) {
+    term.handler(text);
+    term.textarea.value = '';
+    return term.cancel(ev);
+  };
+
+  if (term.browser.isMSIE) {
+    if (window.clipboardData) {
+      text = window.clipboardData.getData('Text');
+      dispatchPaste(text);
+    }
+  } else {
+    if (ev.clipboardData) {
+      text = ev.clipboardData.getData('text/plain');
+      dispatchPaste(text);
+    }
+  }
+}
+
+/**
+ * Bind to right-click event and allow right-click copy and paste.
+ *
+ * **Logic**
+ * If text is selected and right-click happens on selected text, then
+ * do nothing to allow seamless copying.
+ * If no text is selected or right-click is outside of the selection
+ * area, then bring the terminal's input below the cursor, in order to
+ * trigger the event on the textarea and allow-right click paste, without
+ * caring about disappearing selection.
+ * @param {MouseEvent} ev The original right click event to be handled
+ * @param {Terminal} term The terminal on which to apply the handled paste event
+ */
+export function rightClickHandler(ev: MouseEvent, term: ITerminal) {
+  let s = document.getSelection(),
+      selectedText = prepareTextForClipboard(s.toString()),
+      clickIsOnSelection = false,
+      x = ev.clientX,
+      y = ev.clientY;
+
+  if (s.rangeCount) {
+    let r = s.getRangeAt(0),
+        cr = r.getClientRects();
+
+    for (let i = 0; i < cr.length; i++) {
+      let rect = cr[i];
+
+      clickIsOnSelection = (
+        (x > rect.left) && (x < rect.right) &&
+        (y > rect.top) && (y < rect.bottom)
+      );
+
+      if (clickIsOnSelection) {
+        break;
+      }
+    }
+    // If we clicked on selection and selection is not a single space,
+    // then mark the right click as copy-only. We check for the single
+    // space selection, as this can happen when clicking on an &nbsp;
+    // and there is not much pointing in copying a single space.
+    if (selectedText.match(/^\s$/) || !selectedText.length) {
+      clickIsOnSelection = false;
+    }
+  }
+
+  // Bring textarea at the cursor position
+  if (!clickIsOnSelection) {
+    term.textarea.style.position = 'fixed';
+    term.textarea.style.width = '20px';
+    term.textarea.style.height = '20px';
+    term.textarea.style.left = (x - 10) + 'px';
+    term.textarea.style.top = (y - 10) + 'px';
+    term.textarea.style.zIndex = '1000';
+    term.textarea.focus();
+
+    // Reset the terminal textarea's styling
+    setTimeout(function () {
+      term.textarea.style.position = null;
+      term.textarea.style.width = null;
+      term.textarea.style.height = null;
+      term.textarea.style.left = null;
+      term.textarea.style.top = null;
+      term.textarea.style.zIndex = null;
+    }, 4);
+  }
+}

src/test/addons/linkify-test.js

@@ -1,5 +1,5 @@
 var assert = require('chai').assert;
-var Terminal = require('../../src/xterm');
+var Terminal = require('../../xterm');
 var linkify = require('../../addons/linkify/linkify');
 
 describe('linkify addon', function () {

src/test/addons/test.js

@@ -1,10 +1,10 @@
 var assert = require('chai').assert;
-var Terminal = require('../../src/xterm');
+var Terminal = require('../../xterm');
 
 describe('xterm.js addons', function() {
   it('should load addons with Terminal.loadAddon', function () {
     Terminal.loadAddon('attach');
-    // Test that function was loaded successfully
+    // Test that addon was loaded successfully
     assert.equal(typeof Terminal.prototype.attach, 'function');
   });
 });

src/test/escape-sequences-test.js

@@ -2,7 +2,7 @@ var glob = require('glob');
 var fs = require('fs');
 var pty = require('pty.js');
 var sleep = require('sleep');
-var Terminal = require('../src/xterm');
+var Terminal = require('../xterm');
 
 var CONSOLE_LOG = console.log;
 
@@ -27,7 +27,7 @@ function pty_write_read(s) {
   return b.toString('utf8', 0, bytes);
 }
 
-// make sure raw pty is at x=0 and has no pending data 
+// make sure raw pty is at x=0 and has no pending data
 function pty_reset() {
     pty_write_read('\r\n');
 }
@@ -80,9 +80,10 @@ describe('xterm output comparison', function() {
 
   // omit stack trace for escape sequence files
   Error.stackTraceLimit = 0;
-  var files = glob.sync('test/escape_sequence_files/*.in');
+  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){