Merge remote-tracking branch 'ups/master' into 1181

2026-08-05 13:43:48 -07:00 · 2018-02-21 14:36:11 -08:00
parent b75f52734d 62cf0936dc
commit 1972bf4bb3
92 changed files with 4622 additions and 2068 deletions
@@ -19,10 +19,6 @@ fixtures/typings-test/*.js
 # Directories needed for code coverage
 /coverage/

-# Keep legacy files out of the repo, this can be removed when we merge v3 into master
+# Keep bundled code out of Git
 dist/
-src/utils/TestUtils.ts
-src/xterm.js
-
-# Keep the demo builds out of Git
 demo/dist/
@@ -1,7 +1,6 @@
 language: node_js
 os:
  - linux
-  - osx
 node_js:
  - 6
 before_install:
@@ -12,6 +11,7 @@ before_install:
  - npm install -g npm@5.1.0
 env:
  matrix:
+    - NPM_COMMAND=tsc
    - NPM_COMMAND=lint
    - NPM_COMMAND=test
 notifications:
@@ -1,12 +1,15 @@
 List of xterm.js contributors. Updated before every release.

+Adrian Labbé <adrilabbelol@gmail.com>
 Aleksandr Andrienko <aandrienko@codenvy.com>
 Aleksandr Andriienko <oandriie@redhat.com>
 Alessandro Nadalin <alessandro.nadalin@gmail.com>
 Alexander Olsson <noseglid@gmail.com>
 Alexey Kontsevoy <alexey@gravitational.com>
+Andres Mejia <amejia004@gmail.com>
 Anish Athalye <me@anishathalye.com>
 Anthony Lapenna <lapenna.anthony@gmail.com>
+Antonin Stefanutti <antonin@stefanutti.fr>
 Antonis Kalipetis <akalipetis@sourcelair.com>
 Anton Skshidlevsky <meefik@gmail.com>
 Anton Yurovskykh <anton.yurovskykh@gmail.com>
@@ -19,6 +22,7 @@ Bill Church <billchurch@users.noreply.github.com>
 Bob Reid <bobreid@Bobs-MacBook-Pro.local>
 bottleofwater <nison.mael+bottleofwater@gmail.com>
 Brian Mock <brian@mockbrian.com>
+Bruno Ribeiro <b.m.fernandes.ribeiro@gmail.com>
 Bruno Ribeito <b.m.fernandes.ribeiro@gmail.com>
 Carson Anderson <carson@betterservers.com>
 CHaBou <chabup@delean.fr>
@@ -26,6 +30,7 @@ Christian Budde Christensen <budde377@gmail.com>
 Christof Marti <chrmarti@microsoft.com>
 Christopher Jeffrey <chjjeffrey@gmail.com>
 coderaiser <mnemonic.enemy@gmail.com>
+Damien Tournoud <damien@platform.sh>
 Dan Brown <jdanbrown@gmail.com>
 Daniel Griffen <daniel@griffen.io>
 Daniel Imms <daimms@microsoft.com>
@@ -46,20 +51,25 @@ imoses <ido@twiggle.com>
 InDieTasten <indietasten@gmail.com>
 irokas <akasidiari@inf.uth.gr>
 Jakob Gillich <jakob@gillich.me>
+Jan Kuri <jkuri88@gmail.com>
 Jean Bruenn <himself@jeanbruenn.info>
 Jeremy Danyow <jedanyow@microsoft.com>
+Jianhui Zhao <jianhuizhao329@gmail.com>
 Joao Moreno <jomo@microsoft.com>
 Joao Moreno <mail@joaomoreno.com>
 Johannes Zellner <johannes@nebulon.de>
 Jon Masters <jon.masters@sky.com>
 Jörg Breitbart <jerch@rockborn.de>
+Justin Luk <jluk@users.noreply.github.com>
 Justin Mecham <justin@mecham.me>
 Kirill Merkushev <lanwen@yandex.ru>
+Krasimir Tsonev <krasimir@outset.ws>
 Luca <LucaT1@users.noreply.github.com>
 Lucian Buzzo <lucian.buzzo@gmail.com>
 Lukas Drgon <lukas.drgon@gmail.com>
 Maël Nison <nison.mael@gmail.com>
 Marc Dumais <marc.dumais@ericsson.com>
+Markus F.X.J. Oberhumer <markus@oberhumer.com>
 Martin Chloride <i@martincl2.me>
 Martin Koppehel <martin.koppehel@st.ovgu.de>
 Martin Wang <jiahaow@ca.ibm.com>
@@ -75,10 +85,12 @@ Paris Kasidiaris <paris@sourcelair.com>
 Peter Baumgarten <me@peterbaumgarten.com>
 Rick Baker <rick@ricktbaker.com>
 runarberg <runar@greenqloud.com>
+Saad Malik <simfox3@gmail.com>
 Samuel Williams <samuel.williams@oriontransfer.co.nz>
 Saswat Das <saswatds@users.noreply.github.com>
 Saul Costa <saul@codevolve.com>
 Shuanglei Tao <tsl0922@gmail.com>
+sitzmar <sitzmar@gmail.com>
 Steven Silvester <steven.silvester@ieee.org>
 stuicey <stuicey@users.noreply.github.com>
 t-amqi <umberos@gmail.com>
@@ -90,3 +102,4 @@ Tyler Jewell <tjewell@codenvy.com>
 Vincent Woo <me@vincentwoo.com>
 yutaka <shigure@refy.net>
 YuviPanda <yuvipanda@gmail.com>
+ZHAO Xudong <zxdong@gmail.com>
@@ -1,4 +1,4 @@
-FROM node:6
+FROM node:8
 MAINTAINER Paris Kasidiaris <paris@sourcelair.com>

 # Set the working directory
@@ -1 +1,2 @@
 web: npm start
+webpack: npm run watch
@@ -24,7 +24,7 @@ It enables applications to provide fully featured terminals to their users and c
 First you need to install the module, we ship exclusively through [npm](https://www.npmjs.com/) so you need that installed and then add xterm.js as a dependency by running:

 ```
-npm install
+npm install xterm
 ```

 To start using xterm.js on your browser, add the `xterm.js` and `xterm.css` to the head of your html page. Then create a `<div id="terminal"></div>` onto which xterm can attach itself.
@@ -110,7 +110,7 @@ Xterm.js is used in several world-class applications to provide great terminal e
 - [**Selenoid UI**](https://github.com/aerokube/selenoid-ui): Simple UI for the scallable golang implementation of Selenium Hub named Selenoid. We use XTerm for streaming logs over websockets from docker containers.
 - [**Portainer**](https://portainer.io): Simple management UI for Docker.
 - [**SSHy**](https://github.com/stuicey/SSHy): HTML5 Based SSHv2 Web Client with E2E encryption utilising `xterm.js`, SJCL & websockets.
- [**JupyterLab**](https://github.com/jupyterlab/jupyterlab): An extensible 
+- [**JupyterLab**](https://github.com/jupyterlab/jupyterlab): An extensible
 computational environment for Jupyter, supporting interactive data science and scientific computing across all programming languages.
 - [**Theia**](https://github.com/theia-ide/theia): Theia is a cloud & desktop IDE framework implemented in TypeScript.
 - [**Opshell**](https://github.com/ricktbaker/opshell) Ops Helper tool to make life easier working with AWS instances across multiple organizations.
@@ -120,32 +120,72 @@ computational environment for Jupyter, supporting interactive data science and s
 - [**VTerm**](https://github.com/vterm/vterm): Extensible terminal emulator based on Electron and React.
 - [**electerm**](http://electerm.html5beta.com): electerm is a terminal/ssh/sftp client(mac, win, linux) based on electron/node-pty/xterm.
 - [**Kubebox**](https://github.com/astefanutti/kubebox): Terminal console for Kubernetes clusters.
+- [**Azure Cloud Shell**](https://shell.azure.com): Azure Cloud Shell is a Microsoft-managed admin machine built on Azure, for Azure.
+- [**atom-xterm**](https://atom.io/packages/atom-xterm): Atom plugin for providing terminals inside your Atom workspace.
+- [**rtty**](https://github.com/zhaojh329/rtty): A reverse proxy WebTTY. It is composed of the client and the server.
+- [**Pisth**](https://github.com/ColdGrub1384/Pisth): An SFTP and SSH client for iOS
+- [**abstruse**](https://github.com/bleenco/abstruse): Abstruse CI is a continuous integration platform based on Node.JS and Docker.
+- [**Microsoft SQL Operations Studio**](https://github.com/Microsoft/sqlopsstudio): A data management tool that enables working with SQL Server, Azure SQL DB and SQL DW from Windows, macOS and Linux
+- [**FreeMAN**](https://github.com/matthew-matvei/freeman): A free, cross-platform file manager for power users

 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.

 ## Demo

-### Linux or macOS
+Xterm.js ships with a barebones demo implementation, designed for the development and evaluation of the library only. Exposing the demo to the public as is would introduce security risks for the host.

-First, be sure that a C++ compiler such as GCC-C++ or Clang is installed, then run these commands:
+Below you can find instructions on how to run the demo on different platforms.
+
+### SourceLair
+
+SourceLair will run the demo and builder in parallel automatically. Just make sure to choose the "Node.js" project type, when cloning the xterm.js repo (or just use this shortcut; https://lair.io/xtermjs/xtermjs).
+
+Then open your project's [Public URL](https://help.sourcelair.com/projects/the-public-url/) to access the demo.
+
+### Docker
+
+First, make sure you have Docker Engine 1.13.0 (or newer) and Docker Compose 1.10.0 (or newer). To run the demo and builder in parallel, run the following command in your terminal:
+
+```
+docker-compose up
+```
+
+Then open http://0.0.0.0:3000 in a web browser to access the demo. If you prefer a different port than `3000` to access the xterm.js demo, then set the `XTERMJS_PORT` environment variable to the desired port.
+
+### Foreman (or other Procfile runner)
+
+First, be sure that a C++ compiler such as GCC-C++ or Clang is installed, then run the following commands in your terminal:

 ```
 npm install
-npm start
+foreman start  # Replace foreman with "honcho", "forego" etc. depending on your runner
 ```

-Then open http://0.0.0.0:3000 in a web browser.
+Then open http://0.0.0.0:3000 in a web browser to access the demo.
+
+### Linux or macOS
+
+First, be sure that a C++ compiler such as GCC-C++ or Clang is installed, then run the following commands in your terminal:
+
+```
+npm install
+npm start      # Run this in its own terminal
+npm run watch  # Run this in its own terminal
+```
+
+Then open http://0.0.0.0:3000 in a web browser to access the demo.

 ### Windows

-First, ensure [node-gyp](https://github.com/nodejs/node-gyp) is installed and configured correctly, then run these commands.
+First, ensure [node-gyp](https://github.com/nodejs/node-gyp) is installed and configured correctly, then run the following commands in your terminal:

 ```
 npm install
-npm start
+npm start      # Run this in its own terminal
+npm run watch  # Run this in its own terminal
 ```

-Then open http://127.0.0.1:3000 in a web browser.
+Then open http://127.0.0.1:3000 in a web browser to access the demo.

 *Note: Do not use ConEmu, as it seems to break the demo for some reason.*

@@ -161,10 +201,14 @@ Xterm.js is maintained by [SourceLair](https://www.sourcelair.com/) and a few ex

 To contribute either code, documentation or issues to xterm.js please read the [Contributing document](CONTRIBUTING.md) beforehand. The development of xterm.js does not require any special tool. All you need is an editor that supports JavaScript/TypeScript and a browser. You will need Node.js installed locally to get all the features working in the demo.

+### Code structure
+
+`src/` is roughly split up into areas of functionality such as `renderer/` that handles all rendering and `utils/` which provides general utility functions. The `shared/` folder contains code that can be used from either the main thread or a web worker thread, all code inside a `shared/` folder should only ever import other code from a `shared/` folder to minimize the amount of code run what launching a web worker.
+
 ## License Agreement

 If you contribute code to this project, you are implicitly allowing your code to be distributed under the MIT license. You are also implicitly verifying that all code is your original work.

+Copyright (c) 2017-2018, [The xterm.js authors](https://github.com/xtermjs/xterm.js/graphs/contributors) (MIT License)
 Copyright (c) 2014-2017, SourceLair, Private Company ([www.sourcelair.com](https://www.sourcelair.com/home)) (MIT License)
-
 Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
@@ -23,6 +23,9 @@
          <p>
            <label><input type="checkbox" id="option-cursor-blink"> cursorBlink</label>
          </p>
+          <p>
+            <label><input type="checkbox" id="option-mac-option-is-meta"> macOptionIsMeta</label>
+          </p>
          <p>
            <label>
              cursorStyle
@@ -61,10 +64,19 @@
                <label for="rows">Rows</label>
                <input type="number" id="rows" />
              </div>
+              <div style="display: inline-block; margin-right: 16px;">
+                <label for="padding">Padding</label>
+                <input type="number" id="padding" />
+              </div>
            </div>
          </div>
+          <div>
+            <h3>Accessibility</h3>
+            <p>
+              <label><input type="checkbox" id="option-screen-reader-mode"> screenReaderMode</label>
+            </p>
        </div>
-        <p><strong>Attention:</strong> The demo is a barebones implementation and is designed for xterm.js evaluation purposes only. Exposing the demo to the public as is would introduce security risks for the host.</p>
+        <p><strong>Attention:</strong> The demo is a barebones implementation and is designed for the development and evaluation of xterm.js only. Exposing the demo to the public as is would introduce security risks for the host.</p>
        <script src="dist/bundle.js" defer ></script>
    </body>
 </html>
@@ -27,28 +27,34 @@ var terminalContainer = document.getElementById('terminal-container'),
    optionElements = {
      cursorBlink: document.querySelector('#option-cursor-blink'),
      cursorStyle: document.querySelector('#option-cursor-style'),
+      macOptionIsMeta: document.querySelector('#option-mac-option-is-meta'),
      scrollback: document.querySelector('#option-scrollback'),
      tabstopwidth: document.querySelector('#option-tabstopwidth'),
-      bellStyle: document.querySelector('#option-bell-style')
+      bellStyle: document.querySelector('#option-bell-style'),
+      screenReaderMode: document.querySelector('#option-screen-reader-mode')
    },
    colsElement = document.getElementById('cols'),
-    rowsElement = document.getElementById('rows');
+    rowsElement = document.getElementById('rows'),
+    paddingElement = document.getElementById('padding');

 function setTerminalSize() {
  var cols = parseInt(colsElement.value, 10);
  var rows = parseInt(rowsElement.value, 10);
-  var viewportElement = document.querySelector('.xterm-viewport');
-  var scrollBarWidth = viewportElement.offsetWidth - viewportElement.clientWidth;
-  var width = (cols * term.renderer.dimensions.actualCellWidth + 20 /*room for scrollbar*/).toString() + 'px';
+  var width = (cols * term.renderer.dimensions.actualCellWidth + term.viewport.scrollBarWidth).toString() + 'px';
  var height = (rows * term.renderer.dimensions.actualCellHeight).toString() + 'px';
-
  terminalContainer.style.width = width;
  terminalContainer.style.height = height;
-  term.resize(cols, rows);
+  term.fit();
+}
+
+function setPadding() {
+  term.element.style.padding = parseInt(paddingElement.value, 10).toString() + 'px';
+  term.fit();
 }

 colsElement.addEventListener('change', setTerminalSize);
 rowsElement.addEventListener('change', setTerminalSize);
+paddingElement.addEventListener('change', setPadding);

 actionElements.findNext.addEventListener('keypress', function (e) {
  if (e.key === "Enter") {
@@ -72,12 +78,18 @@ optionElements.cursorStyle.addEventListener('change', function () {
 optionElements.bellStyle.addEventListener('change', function () {
  term.setOption('bellStyle', optionElements.bellStyle.value);
 });
+optionElements.macOptionIsMeta.addEventListener('change', function () {
+  term.setOption('macOptionIsMeta', optionElements.macOptionIsMeta.checked);
+});
 optionElements.scrollback.addEventListener('change', function () {
  term.setOption('scrollback', parseInt(optionElements.scrollback.value, 10));
 });
 optionElements.tabstopwidth.addEventListener('change', function () {
  term.setOption('tabStopWidth', parseInt(optionElements.tabstopwidth.value, 10));
 });
+optionElements.screenReaderMode.addEventListener('change', function () {
+  term.setOption('screenReaderMode', optionElements.screenReaderMode.checked);
+});

 createTerminal();

@@ -87,9 +99,11 @@ function createTerminal() {
    terminalContainer.removeChild(terminalContainer.children[0]);
  }
  term = new Terminal({
+    macOptionIsMeta: optionElements.macOptionIsMeta.enabled,
    cursorBlink: optionElements.cursorBlink.checked,
    scrollback: parseInt(optionElements.scrollback.value, 10),
-    tabStopWidth: parseInt(optionElements.tabstopwidth.value, 10)
+    tabStopWidth: parseInt(optionElements.tabstopwidth.value, 10),
+    screenReaderMode: optionElements.screenReaderMode.checked
  });
  window.term = term;  // Expose `term` to window for debugging purposes
  term.on('resize', function (size) {
@@ -114,6 +128,7 @@ function createTerminal() {
  setTimeout(function () {
    colsElement.value = term.cols;
    rowsElement.value = term.rows;
+    paddingElement.value = 0;

    // Set terminal size again to set the specific dimensions on the demo
    setTerminalSize();
@@ -7,3 +7,10 @@ services:
      - ./:/usr/src/app
    ports:
      - ${XTERMJS_PORT:3000}:3000
+    command: ["npm", "start"]
+
+  watch:
+    build: .
+    volumes:
+      - ./:/usr/src/app
+    command: ["npm", "run", "watch"]
@@ -144,6 +144,11 @@ namespace methods_core {
      const r20: string = t.getOption('bellStyle');
      const r21: boolean = t.getOption('enableBold');
      const r22: number = t.getOption('letterSpacing');
+      const r23: boolean = t.getOption('macOptionIsMeta');
+      const r24: string = t.getOption('fontWeight');
+      const r25: string = t.getOption('fontWeightBold');
+      const r26: boolean = t.getOption('allowTransparency');
+      const r27: boolean = t.getOption('rightClickSelectsWord');
    }
    {
      const t: Terminal = new Terminal();
@@ -157,9 +162,14 @@ namespace methods_core {
      t.setOption('debug', true);
      t.setOption('disableStdin', true);
      t.setOption('enableBold', true);
+      t.setOption('fontWeight', 'normal');
+      t.setOption('fontWeight', 'bold');
+      t.setOption('fontWeightBold', 'normal');
+      t.setOption('fontWeightBold', 'bold');
      t.setOption('popOnBell', true);
      t.setOption('screenKeys', true);
      t.setOption('useFlowControl', true);
+      t.setOption('allowTransparency', true);
      t.setOption('visualBell', true);
      t.setOption('colors', ['a', 'b']);
      t.setOption('letterSpacing', 1);
@@ -177,6 +187,8 @@ namespace methods_core {
      t.setOption('lineHeight', 1);
      t.setOption('fontFamily', 'foo');
      t.setOption('theme', {background: '#ff0000'});
+      t.setOption('macOptionIsMeta', true);
+      t.setOption('rightClickSelectsWord', false);
    }
  }
  namespace scrolling {
@@ -18,11 +18,13 @@ const ts = require('gulp-typescript');
 const util = require('gulp-util');
 const webpack = require('webpack-stream');

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

+const addons = ['attach', 'fit', 'fullscreen', 'search', 'terminado', 'winptyCompat', 'zmodem'];
+
 // Under some environments like TravisCI, this comes out at absolute which can
 // break the build. This ensures that the outDir is absolute.
 if (path.normalize(outDir).indexOf(__dirname) !== 0) {
@@ -45,15 +47,19 @@ gulp.task('tsc', function () {
    tsResult.dts.pipe(sourcemaps.write('.', {includeContent: false, sourceRoot: ''})).pipe(gulp.dest(outDir))
  );

-  let addons = ['attach', 'fit', 'fullscreen', 'search', 'terminado', 'winptyCompat', 'zmodem'];
  let addonStreams = addons.map(function(addon) {
    fs.emptyDirSync(`${outDir}/addons/${addon}`);

    let tsProjectAddon = ts.createProject(`./src/addons/${addon}/tsconfig.json`);
    let tsResultAddon = tsProjectAddon.src().pipe(sourcemaps.init()).pipe(tsProjectAddon());
-    let tscAddon = tsResultAddon.js
-      .pipe(sourcemaps.write('.', {includeContent: false, sourceRoot: ''}))
-      .pipe(gulp.dest(`${outDir}/addons/${addon}`));
+    let tscAddon = merge(
+      tsResultAddon.js
+        .pipe(sourcemaps.write('.', {includeContent: false, sourceRoot: ''}))
+        .pipe(gulp.dest(`${outDir}/addons/${addon}`)),
+      tsResultAddon.dts
+        .pipe(sourcemaps.write('.', {includeContent: false, sourceRoot: ''}))
+        .pipe(gulp.dest(`${outDir}/addons/${addon}`))
+    )

    return tscAddon;
  });
@@ -103,45 +109,29 @@ gulp.task('browserify', ['tsc'], function() {
 });

 gulp.task('browserify-addons', ['tsc'], function() {
-  let searchOptions = {
-    basedir: `${buildDir}/addons/search`,
-    debug: true,
-    entries: [`${outDir}/addons/search/search.js`],
-    cache: {},
-    packageCache: {}
-  };
-  let searchBundle = browserify(searchOptions)
-        .external(path.join(outDir, 'Terminal.js'))
-        .bundle()
-        .pipe(source('./addons/search/search.js'))
-        .pipe(buffer())
-        .pipe(sourcemaps.init({loadMaps: true, sourceRoot: ''}))
-        .pipe(sourcemaps.write('./'))
-        .pipe(gulp.dest(buildDir));
+  const bundles = addons.map((addon) => {
+    const addonOptions = {
+      basedir: `${buildDir}/addons/${addon}`,
+      debug: true,
+      entries: [`${outDir}/addons/${addon}/${addon}.js`],
+      standalone: addon,
+      cache: {},
+      packageCache: {}
+    };

-  let winptyCompatOptions = {
-    basedir: `${buildDir}/addons/winptyCompat`,
-    debug: true,
-    entries: [`${outDir}/addons/winptyCompat/winptyCompat.js`],
-    cache: {},
-    packageCache: {}
-  };
-  let winptyCompatBundle = browserify(winptyCompatOptions)
-        .external(path.join(outDir, 'Terminal.js'))
-        .bundle()
-        .pipe(source('./addons/winptyCompat/winptyCompat.js'))
-        .pipe(buffer())
-        .pipe(sourcemaps.init({loadMaps: true, sourceRoot: ''}))
-        .pipe(sourcemaps.write('./'))
-        .pipe(gulp.dest(buildDir));
+    const addonBundle = browserify(addonOptions)
+      .external(path.join(outDir, 'Terminal.js'))
+      .bundle()
+      .pipe(source(`./addons/${addon}/${addon}.js`))
+      .pipe(buffer())
+      .pipe(sourcemaps.init({loadMaps: true, sourceRoot: ''}))
+      .pipe(sourcemaps.write('./'))
+      .pipe(gulp.dest(buildDir));

-  // Copy all add-ons from outDir to buildDir
-  let copyAddons = gulp.src([
-    // Copy JS addons
-    `${outDir}/addons/**/*`
-  ]).pipe(gulp.dest(`${buildDir}/addons`));
+    return addonBundle;
+  });

-  return merge(searchBundle, winptyCompatBundle, copyAddons);
+  return merge(...bundles);
 });

 gulp.task('instrument-test', function () {
@@ -189,9 +179,11 @@ gulp.task('sorcery', ['browserify'], function () {
 });

 gulp.task('sorcery-addons', ['browserify-addons'], function () {
-  var chain = sorcery.loadSync(`${buildDir}/addons/search/search.js`);
-  chain.apply();
-  chain.writeSync();
+  addons.forEach((addon) => {
+    const chain = sorcery.loadSync(`${buildDir}/addons/${addon}/${addon}.js`);
+    chain.apply();
+    chain.writeSync();
+  })
 });

 gulp.task('webpack', ['build'], function() {
@@ -200,6 +192,10 @@ gulp.task('webpack', ['build'], function() {
    .pipe(gulp.dest('demo/dist/'));
 });

+gulp.task('watch', ['webpack'], () => {
+  gulp.watch(['./src/*', './src/**/*'], ['webpack']);
+});
+
 /**
 * Submit coverage results to coveralls.io
 */
@@ -1,7 +1,7 @@
 {
  "name": "xterm",
  "description": "Full xterm terminal, in your browser",
-  "version": "3.0.0",
+  "version": "3.1.0",
  "ignore": [
    "demo",
    "test",
@@ -66,8 +66,8 @@
    "node-pty": "^0.7.2",
    "nodemon": "1.10.2",
    "sorcery": "^0.10.0",
-    "tslint": "^4.0.2",
-    "typescript": "~2.4.0",
+    "tslint": "^5.9.1",
+    "typescript": "~2.7.1",
    "vinyl-buffer": "^1.0.0",
    "vinyl-source-stream": "^1.1.0",
    "webpack": "^3.10.0",
@@ -75,17 +75,18 @@
    "zmodem.js": "^0.1.5"
  },
  "scripts": {
-    "prestart": "gulp webpack",
    "start": "node demo/app",
    "prestart-zmodem": "npm run build",
    "start-zmodem": "node build/addons/zmodem/demo/app",
    "lint": "tslint src/*.ts src/**/*.ts",
    "test": "gulp test",
    "build:docs": "jsdoc -c jsdoc.json",
+    "tsc": "tsc",
    "build": "gulp build",
    "prepublish": "npm run build",
    "coveralls": "gulp coveralls",
-    "webpack": "gulp webpack"
+    "webpack": "gulp webpack",
+    "watch": "gulp watch"
  },
  "dependencies": {}
 }
@@ -0,0 +1,287 @@
+/**
+ * Copyright (c) 2017 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import * as Strings from './Strings';
+import { ITerminal, IBuffer } from './Types';
+import { isMac } from './shared/utils/Browser';
+import { RenderDebouncer } from './utils/RenderDebouncer';
+import { addDisposableListener } from './utils/Dom';
+import { IDisposable } from 'xterm';
+
+const MAX_ROWS_TO_READ = 20;
+const ACTIVE_ITEM_ID_PREFIX = 'xterm-active-item-';
+
+enum BoundaryPosition {
+  Top,
+  Bottom
+}
+
+export class AccessibilityManager implements IDisposable {
+  private _accessibilityTreeRoot: HTMLElement;
+  private _rowContainer: HTMLElement;
+  private _rowElements: HTMLElement[] = [];
+  private _liveRegion: HTMLElement;
+  private _liveRegionLineCount: number = 0;
+
+  private _renderRowsDebouncer: RenderDebouncer;
+
+  private _topBoundaryFocusListener: (e: FocusEvent) => void;
+  private _bottomBoundaryFocusListener: (e: FocusEvent) => void;
+
+  private _disposables: IDisposable[] = [];
+
+  /**
+   * This queue has a character pushed to it for keys that are pressed, if the
+   * next character added to the terminal is equal to the key char then it is
+   * not announced (added to live region) because it has already been announced
+   * by the textarea event (which cannot be canceled). There are some race
+   * condition cases if there is typing while data is streaming, but this covers
+   * the main case of typing into the prompt and inputting the answer to a
+   * question (Y/N, etc.).
+   */
+  private _charsToConsume: string[] = [];
+
+  constructor(private _terminal: ITerminal) {
+    this._accessibilityTreeRoot = document.createElement('div');
+    this._accessibilityTreeRoot.classList.add('xterm-accessibility');
+
+    this._rowContainer = document.createElement('div');
+    this._rowContainer.classList.add('xterm-accessibility-tree');
+    for (let i = 0; i < this._terminal.rows; i++) {
+      this._rowElements[i] = this._createAccessibilityTreeNode();
+      this._rowContainer.appendChild(this._rowElements[i]);
+    }
+
+    this._topBoundaryFocusListener = e => this._onBoundaryFocus(e, BoundaryPosition.Top);
+    this._bottomBoundaryFocusListener = e => this._onBoundaryFocus(e, BoundaryPosition.Bottom);
+    this._rowElements[0].addEventListener('focus', this._topBoundaryFocusListener);
+    this._rowElements[this._rowElements.length - 1].addEventListener('focus', this._bottomBoundaryFocusListener);
+
+    this._refreshRowsDimensions();
+    this._accessibilityTreeRoot.appendChild(this._rowContainer);
+
+    this._renderRowsDebouncer = new RenderDebouncer(this._terminal, this._renderRows.bind(this));
+    this._refreshRows();
+
+    this._liveRegion = document.createElement('div');
+    this._liveRegion.classList.add('live-region');
+    this._liveRegion.setAttribute('aria-live', 'assertive');
+    this._accessibilityTreeRoot.appendChild(this._liveRegion);
+
+    this._terminal.element.insertAdjacentElement('afterbegin', this._accessibilityTreeRoot);
+
+    this._disposables.push(this._renderRowsDebouncer);
+    this._disposables.push(this._terminal.addDisposableListener('resize', data => this._onResize(data.cols, data.rows)));
+    this._disposables.push(this._terminal.addDisposableListener('refresh', data => this._refreshRows(data.start, data.end)));
+    this._disposables.push(this._terminal.addDisposableListener('scroll', data => this._refreshRows()));
+    // Line feed is an issue as the prompt won't be read out after a command is run
+    this._disposables.push(this._terminal.addDisposableListener('a11y.char', (char) => this._onChar(char)));
+    this._disposables.push(this._terminal.addDisposableListener('linefeed', () => this._onChar('\n')));
+    this._disposables.push(this._terminal.addDisposableListener('a11y.tab', spaceCount => this._onTab(spaceCount)));
+    this._disposables.push(this._terminal.addDisposableListener('key', keyChar => this._onKey(keyChar)));
+    this._disposables.push(this._terminal.addDisposableListener('blur', () => this._clearLiveRegion()));
+    // TODO: Maybe renderer should fire an event on terminal when the characters change and that
+    //       should be listened to instead? That would mean that the order of events are always
+    //       guarenteed
+    this._disposables.push(this._terminal.addDisposableListener('dprchange', () => this._refreshRowsDimensions()));
+    this._disposables.push(this._terminal.renderer.addDisposableListener('resize', () => this._refreshRowsDimensions()));
+    // This shouldn't be needed on modern browsers but is present in case the
+    // media query that drives the dprchange event isn't supported
+    this._disposables.push(addDisposableListener(window, 'resize', () => this._refreshRowsDimensions()));
+  }
+
+  public dispose(): void {
+    this._terminal.element.removeChild(this._accessibilityTreeRoot);
+    this._disposables.forEach(d => d.dispose());
+    this._disposables = null;
+    this._accessibilityTreeRoot = null;
+    this._rowContainer = null;
+    this._liveRegion = null;
+    this._rowContainer = null;
+    this._rowElements = null;
+  }
+
+  private _onBoundaryFocus(e: FocusEvent, position: BoundaryPosition): void {
+    const boundaryElement = <HTMLElement>e.target;
+    const beforeBoundaryElement = this._rowElements[position === BoundaryPosition.Top ? 1 : this._rowElements.length - 2];
+
+    // Don't scroll if the buffer top has reached the end in that direction
+    const posInSet = boundaryElement.getAttribute('aria-posinset');
+    const lastRowPos = position === BoundaryPosition.Top ? '1' : `${this._terminal.buffer.lines.length}`;
+    if (posInSet === lastRowPos) {
+      return;
+    }
+
+    // Don't scroll when the last focused item was not the second row (focus is going the other
+    // direction)
+    if (e.relatedTarget !== beforeBoundaryElement) {
+      return;
+    }
+
+    // Remove old boundary element from array
+    let topBoundaryElement: HTMLElement;
+    let bottomBoundaryElement: HTMLElement;
+    if (position === BoundaryPosition.Top) {
+      topBoundaryElement = boundaryElement;
+      bottomBoundaryElement = this._rowElements.pop();
+      this._rowContainer.removeChild(bottomBoundaryElement);
+    } else {
+      topBoundaryElement = this._rowElements.shift();
+      bottomBoundaryElement = boundaryElement;
+      this._rowContainer.removeChild(topBoundaryElement);
+    }
+
+    // Remove listeners from old boundary elements
+    topBoundaryElement.removeEventListener('focus', this._topBoundaryFocusListener);
+    bottomBoundaryElement.removeEventListener('focus', this._bottomBoundaryFocusListener);
+
+    // Add new element to array/DOM
+    if (position === BoundaryPosition.Top) {
+      const newElement = this._createAccessibilityTreeNode();
+      this._rowElements.unshift(newElement);
+      this._rowContainer.insertAdjacentElement('afterbegin', newElement);
+    } else {
+      const newElement = this._createAccessibilityTreeNode();
+      this._rowElements.push(newElement);
+      this._rowContainer.appendChild(newElement);
+    }
+
+    // Add listeners to new boundary elements
+    this._rowElements[0].addEventListener('focus', this._topBoundaryFocusListener);
+    this._rowElements[this._rowElements.length - 1].addEventListener('focus', this._bottomBoundaryFocusListener);
+
+    // Scroll up
+    this._terminal.scrollLines(position === BoundaryPosition.Top ? -1 : 1);
+
+    // Focus new boundary before element
+    this._rowElements[position === BoundaryPosition.Top ? 1 : this._rowElements.length - 2].focus();
+
+    // Prevent the standard behavior
+    e.preventDefault();
+    e.stopImmediatePropagation();
+  }
+
+  private _onResize(cols: number, rows: number): void {
+    // Remove bottom boundary listener
+    this._rowElements[this._rowElements.length - 1].removeEventListener('focus', this._bottomBoundaryFocusListener);
+
+    // Grow rows as required
+    for (let i = this._rowContainer.children.length; i < this._terminal.rows; i++) {
+      this._rowElements[i] = this._createAccessibilityTreeNode();
+      this._rowContainer.appendChild(this._rowElements[i]);
+    }
+    // Shrink rows as required
+    while (this._rowElements.length > rows) {
+      this._rowContainer.removeChild(this._rowElements.pop());
+    }
+
+    // Add bottom boundary listener
+    this._rowElements[this._rowElements.length - 1].addEventListener('focus', this._bottomBoundaryFocusListener);
+
+    this._refreshRowsDimensions();
+  }
+
+  public _createAccessibilityTreeNode(): HTMLElement {
+    const element = document.createElement('div');
+    element.setAttribute('role', 'listitem');
+    element.tabIndex = -1;
+    this._refreshRowDimensions(element);
+    return element;
+  }
+
+  private _onTab(spaceCount: number): void {
+    for (let i = 0; i < spaceCount; i++) {
+      this._onChar(' ');
+    }
+  }
+
+  private _onChar(char: string): void {
+    if (this._liveRegionLineCount < MAX_ROWS_TO_READ + 1) {
+      if (this._charsToConsume.length > 0) {
+        // Have the screen reader ignore the char if it was just input
+        const shiftedChar = this._charsToConsume.shift();
+        if (shiftedChar !== char) {
+          this._announceCharacter(char);
+        }
+      } else {
+        this._announceCharacter(char);
+      }
+
+      if (char === '\n') {
+        this._liveRegionLineCount++;
+        if (this._liveRegionLineCount === MAX_ROWS_TO_READ + 1) {
+          this._liveRegion.textContent += Strings.tooMuchOutput;
+        }
+      }
+
+      // Only detach/attach on mac as otherwise messages can go unaccounced
+      if (isMac) {
+        if (this._liveRegion.textContent.length > 0 && !this._liveRegion.parentNode) {
+          setTimeout(() => {
+            this._accessibilityTreeRoot.appendChild(this._liveRegion);
+          }, 0);
+        }
+      }
+    }
+  }
+
+  private _clearLiveRegion(): void {
+    this._liveRegion.textContent = '';
+    this._liveRegionLineCount = 0;
+
+    // Only detach/attach on mac as otherwise messages can go unaccounced
+    if (isMac) {
+      if (this._liveRegion.parentNode) {
+        this._accessibilityTreeRoot.removeChild(this._liveRegion);
+      }
+    }
+  }
+
+  private _onKey(keyChar: string): void {
+    this._clearLiveRegion();
+    this._charsToConsume.push(keyChar);
+  }
+
+  private _refreshRows(start?: number, end?: number): void {
+    this._renderRowsDebouncer.refresh(start, end);
+  }
+
+  private _renderRows(start: number, end: number): void {
+    const buffer: IBuffer = this._terminal.buffer;
+    const setSize = buffer.lines.length.toString();
+    for (let i = start; i <= end; i++) {
+      const lineData = buffer.translateBufferLineToString(buffer.ydisp + i, true);
+      const posInSet = (buffer.ydisp + i + 1).toString();
+      const element = this._rowElements[i];
+      element.textContent = lineData.length === 0 ? Strings.blankLine : lineData;
+      element.setAttribute('aria-posinset', posInSet);
+      element.setAttribute('aria-setsize', setSize);
+    }
+  }
+
+  private _refreshRowsDimensions(): void {
+    if (!this._terminal.renderer.dimensions.actualCellHeight) {
+      return;
+    }
+    const buffer: IBuffer = this._terminal.buffer;
+    for (let i = 0; i < this._terminal.rows; i++) {
+      this._refreshRowDimensions(this._rowElements[i]);
+    }
+  }
+
+  private _refreshRowDimensions(element: HTMLElement): void {
+    element.style.height = `${this._terminal.renderer.dimensions.actualCellHeight}px`;
+  }
+
+  private _announceCharacter(char: string): void {
+    if (char === ' ') {
+      // Always use nbsp for spaces in order to preserve the space between characters in
+      // voiceover's caption window
+      this._liveRegion.innerHTML += '&nbsp;';
+    } else {
+      this._liveRegion.textContent += char;
+    }
+  }
+}
@@ -4,7 +4,7 @@
 */

 import { assert } from 'chai';
-import { ITerminal } from './Interfaces';
+import { ITerminal } from './Types';
 import { Buffer } from './Buffer';
 import { CircularList } from './utils/CircularList';
 import { MockTerminal } from './utils/TestUtils.test';
@@ -3,9 +3,8 @@
 * @license MIT
 */

-import { ITerminal, IBuffer } from './Interfaces';
 import { CircularList } from './utils/CircularList';
-import { LineData, CharData } from './Types';
+import { LineData, CharData, ITerminal, IBuffer } from './Types';

 export const CHAR_DATA_ATTR_INDEX = 0;
 export const CHAR_DATA_CHAR_INDEX = 1;
@@ -121,11 +120,6 @@ export class Buffer implements IBuffer {
      if (this._terminal.cols < newCols) {
        const ch: CharData = [this._terminal.defAttr, ' ', 1, 32]; // does xterm use the default attr?
        for (let i = 0; i < this._lines.length; i++) {
-          // TODO: This should be removed, with tests setup for the case that was
-          // causing the underlying bug, see https://github.com/sourcelair/xterm.js/issues/824
-          if (this._lines.get(i) === undefined) {
-            this._lines.set(i, this._terminal.blankLine(undefined, undefined, newCols));
-          }
          while (this._lines.get(i).length < newCols) {
            this._lines.get(i).push(ch);
          }
@@ -182,16 +176,13 @@ export class Buffer implements IBuffer {
      }

      // Make sure that the cursor stays on screen
-      if (this.y >= newRows) {
-        this.y = newRows - 1;
-      }
+      this.x = Math.min(this.x, newCols - 1);
+      this.y = Math.min(this.y, newRows - 1);
      if (addToY) {
        this.y += addToY;
      }
-
-      if (this.x >= newCols) {
-        this.x = newCols - 1;
-      }
+      this.savedY = Math.min(this.savedY, newRows - 1);
+      this.savedX = Math.min(this.savedX, newCols - 1);

      this.scrollTop = 0;
    }
@@ -222,7 +213,10 @@ export class Buffer implements IBuffer {
    // needed here because some chars are 0 characters long (eg. after wide
    // chars) and some chars are longer than 1 characters long (eg. emojis).
    let startIndex = startCol;
-    endCol = endCol || line.length;
+    // Only set endCol to the line length when it is null. 0 is a valid column.
+    if (endCol === null) {
+      endCol = line.length;
+    }
    let endIndex = endCol;

    for (let i = 0; i < line.length; i++) {
@@ -4,7 +4,7 @@
 */

 import { assert } from 'chai';
-import { ITerminal } from './Interfaces';
+import { ITerminal } from './Types';
 import { BufferSet } from './BufferSet';
 import { Buffer } from './Buffer';
 import { MockTerminal } from './utils/TestUtils.test';
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { ITerminal, IBufferSet } from './Interfaces';
+import { ITerminal, IBufferSet } from './Types';
 import { Buffer } from './Buffer';
 import { EventEmitter } from './EventEmitter';

@@ -61,24 +61,35 @@ export class BufferSet extends EventEmitter implements IBufferSet {
   * Sets the normal Buffer of the BufferSet as its currently active Buffer
   */
  public activateNormalBuffer(): void {
+    if (this._activeBuffer === this._normal) {
+      return;
+    }
    // The alt buffer should always be cleared when we switch to the normal
    // buffer. This frees up memory since the alt buffer should always be new
    // when activated.
    this._alt.clear();
-
    this._activeBuffer = this._normal;
-    this.emit('activate', this._normal);
+    this.emit('activate', {
+      activeBuffer: this._normal,
+      inactiveBuffer: this._alt
+    });
  }

  /**
   * Sets the alt Buffer of the BufferSet as its currently active Buffer
   */
  public activateAltBuffer(): void {
+    if (this._activeBuffer === this._alt) {
+      return;
+    }
    // Since the alt buffer is always cleared when the normal buffer is
    // activated, we want to fill it when switching to it.
    this._alt.fillViewportRows();
    this._activeBuffer = this._alt;
-    this.emit('activate', this._alt);
+    this.emit('activate', {
+      activeBuffer: this._alt,
+      inactiveBuffer: this._normal
+    });
  }

  /**
@@ -63,28 +63,33 @@ export const wcwidth = (function(opts: {nul: number, control: number}): (ucs: nu
      let min = 0;
      let max = data.length - 1;
      let mid;
-      if (ucs < data[0][0] || ucs > data[max][1])
+      if (ucs < data[0][0] || ucs > data[max][1]) {
        return false;
+      }
      while (max >= min) {
        mid = (min + max) >> 1;
-        if (ucs > data[mid][1])
+        if (ucs > data[mid][1]) {
          min = mid + 1;
-        else if (ucs < data[mid][0])
+        } else if (ucs < data[mid][0]) {
          max = mid - 1;
-        else
+        } else {
          return true;
+        }
      }
      return false;
    }
    function wcwidthBMP(ucs: number): number {
      // test for 8-bit control characters
-      if (ucs === 0)
+      if (ucs === 0) {
        return opts.nul;
-      if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
+      }
+      if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) {
        return opts.control;
+      }
      // binary search in table of non-spacing characters
-      if (bisearch(ucs, COMBINING_BMP))
+      if (bisearch(ucs, COMBINING_BMP)) {
        return 0;
+      }
      // if we arrive here, ucs is not a combining or C0/C1 control character
      if (isWideBMP(ucs)) {
        return 2;
@@ -106,8 +111,9 @@ export const wcwidth = (function(opts: {nul: number, control: number}): (ucs: nu
        (ucs >= 0xffe0 && ucs <= 0xffe6)));
    }
    function wcwidthHigh(ucs: number): 0 | 1 | 2 {
-      if (bisearch(ucs, COMBINING_HIGH))
+      if (bisearch(ucs, COMBINING_HIGH)) {
        return 0;
+      }
      if ((ucs >= 0x20000 && ucs <= 0x2fffd) || (ucs >= 0x30000 && ucs <= 0x3fffd)) {
        return 2;
      }
@@ -128,8 +134,9 @@ export const wcwidth = (function(opts: {nul: number, control: number}): (ucs: nu
      for (let i = 0; i < CONTAINERSIZE; ++i) {
        let num = 0;
        let pos = CODEPOINTS_PER_ITEM;
-        while (pos--)
+        while (pos--) {
          num = (num << 2) | wcwidthBMP(CODEPOINTS_PER_ITEM * i + pos);
+        }
        table[i] = num;
      }
      return table;
@@ -148,13 +155,16 @@ export const wcwidth = (function(opts: {nul: number, control: number}): (ucs: nu
    //     ==> n = n & 3      e.g.       000000000000000000000000000000XX
    return function (num: number): number {
      num = num | 0;  // get asm.js like optimization under V8
-      if (num < 32)
+      if (num < 32) {
        return control | 0;
-      if (num < 127)
+      }
+      if (num < 127) {
        return 1;
+      }
      let t = table || init_table();
-      if (num < 65536)
+      if (num < 65536) {
        return t[num >> 4] >> ((num & 15) << 1) & 3;
+      }
      // do a full search for high codepoints
      return wcwidthHigh(num);
    };
@@ -3,19 +3,19 @@
 * @license MIT
 */

-import { Charset } from './Types';
+import { ICharset } from './Types';

 /**
 * The character sets supported by the terminal. These enable several languages
 * to be represented within the terminal with only 8-bit encoding. See ISO 2022
 * for a discussion on character sets. Only VT100 character sets are supported.
 */
-export const CHARSETS: { [key: string]: Charset } = {};
+export const CHARSETS: { [key: string]: ICharset } = {};

 /**
 * The default character set, US.
 */
-export const DEFAULT_CHARSET: Charset = CHARSETS['B'];
+export const DEFAULT_CHARSET: ICharset = CHARSETS['B'];

 /**
 * DEC Special Character and Line Drawing Set.
--- a/Show More
+++ b/Show More