v3.10.0

Fix text being top aligned in latest Chrome and Firefox

.gitattributes

@@ -0,0 +1 @@
+* text=auto

.github/ISSUE_TEMPLATE.md

@@ -1,11 +0,0 @@
-<!-- Enter your issue description here -->
-
-## Details
-- Browser and browser version: 
-- OS version: 
-- xterm.js version: 
-
-### Steps to reproduce
-
-1. 
-2. 

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,17 @@
+---
+name: Bug report
+about: Create a bug report
+---
+
+<!-- ⚠️ Please search existing issues to avoid creating duplicates. ⚠️ -->
+<!-- Describe the bug here. -->
+
+## Details
+- Browser and browser version: 
+- OS version: 
+- xterm.js version: 
+
+### Steps to reproduce
+
+1. 
+2. 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,7 @@
+---
+name: Feature request
+about: Suggest a feature or enhancement
+---
+
+<!-- ⚠️ Please search existing issues to avoid creating duplicates. ⚠️ -->
+<!-- Describe the enhancement here. -->

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,8 @@
+---
+name: Question
+about: The issue tracker is not for questions. Please ask questions on https://stackoverflow.com/questions/tagged/xtermjs
+---
+
+🛑 The issue tracker is not for questions 🛑
+
+If you have a question, please ask it on https://stackoverflow.com/questions/tagged/xtermjs.

.gitignore

@@ -12,7 +12,14 @@ npm-debug.log
 /.idea/
 .env
 build/
-.vscode/
+.DS_Store
+fixtures/typings-test/*.js
+package-lock.json
 
 # Directories needed for code coverage
-/coverage/
+coverage/
+.nyc_output/
+
+# Keep bundled code out of Git
+dist/
+demo/dist/

.npmignore

@@ -1,16 +1,48 @@
-node_modules/
-*.swp
-.lock-wscript
-lib/*.test.js
-lib/*.test.js.map
+# Blacklist - exclude everything except npm defaults such as LICENSE, etc
+*
+!*/
+
+# Whitelist - entries to be included must be negated with "!"
+!*.js
+!*.json
+
+# Whitelist - dist/
+!dist/**/*.js
+!dist/**/*.js.map
+
+!dist/**/*.css
+
+# Whitelist - lib/
+!lib/**/*.d.ts
+
+!lib/**/*.js
+!lib/**/*.js.map
+
+!lib/**/*.css
+
+# Whitelist - src/
+!src/**/*.ts
+!src/**/*.d.ts
+
+!src/**/*.js
+!src/**/*.js.map
+
+!src/**/*.css
+
+# Whitelist - typings/
+!typings/*.d.ts
+
+# Blacklist - (normal behavior) these will override any whitelist
+*.test.ts
+*.test.d.ts
+*.test.js
+*.test.js.map
 lib/test/
-Makefile.gyp
-*.Makefile
-*.target.gyp.mk
-*.node
-example/*.log
+
 docs/
-npm-debug.log
 /.idea/
-.env
+.vscode/
 build/
+fixtures/
+coverage/
+demo/

.npmrc

@@ -0,0 +1 @@
+package-lock=false

.travis.yml

@@ -1,19 +0,0 @@
-language: node_js
-node_js:
-  - 6
-env:
-  global:
-    - CXX=g++-4.8
-  matrix:
-    - NPM_COMMAND=lint
-    - NPM_COMMAND=test
-addons:
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-    packages:
-      - g++-4.8
-notifications:
-  email: false
-script: npm run $NPM_COMMAND
-after_success: npm run coveralls

.vscode/launch.json

@@ -4,7 +4,7 @@
     {
       "type": "node",
       "request": "launch",
-      "name": "Mocha Tests",
+      "name": "Unit Tests",
       "cwd": "${workspaceRoot}",
       "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/mocha",
       "windows": {
@@ -18,6 +18,27 @@
       "sourceMaps": true,
       "outFiles": [ "${workspaceRoot}/lib/**/*.js" ],
       "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "type": "chrome",
+      "request": "launch",
+      "name": "Demo Client",
+      "url": "http://0.0.0.0:3000",
+      "windows": {
+        "url": "http://127.0.0.1:3000"
+      },
+      "webRoot": "${workspaceFolder}/"
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Demo Server",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": [
+        "run",
+        "start-debug"
+      ],
+      "port": 9229
     }
   ]
 }

AUTHORS

@@ -1,54 +0,0 @@
-List of xterm.js contributors. Updated before every release.
-
-Aleksandr Andrienko <aandrienko@codenvy.com>
-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>
-Ben Hall <ben@benhall.me.uk>
-Benjamin Fischer <benjamin.fischer@rwth-aachen.de>
-Bill Church <billchurch@users.noreply.github.com>
-Bob Reid <bobreid@Bobs-MacBook-Pro.local>
-bottleofwater <nison.mael+bottleofwater@gmail.com>
-Brian Mock <brian@mockbrian.com>
-Carson Anderson <carson@betterservers.com>
-Christian Budde Christensen <budde377@gmail.com>
-Christopher Jeffrey <chjjeffrey@gmail.com>
-coderaiser <mnemonic.enemy@gmail.com>
-Daniel Imms <daimms@microsoft.com>
-Daniel Risacher <drisacher@gmail.com>
-Dan Kaplun <dbkaplun@twitch.tv>
-Darin Morrison <freebroccolo@users.noreply.github.com>
-Edgar Andrés Margffoy Tuay <andfoy@gmail.com>
-Elliot Saba <staticfloat@gmail.com>
-Gary Ritchie <gary@rstudio.com>
-hiro-su <h.sugipon@gmail.com>
-Ian Lewis <ianlewis@google.com>
-imoses <ido@twiggle.com>
-InDieTasten <indietasten@gmail.com>
-Jean Bruenn <himself@jeanbruenn.info>
-Jörg Breitbart <jerch@rockborn.de>
-Justin Mecham <justin@mecham.me>
-Lucian Buzzo <lucian.buzzo@gmail.com>
-Maël Nison <nison.mael@gmail.com>
-Martin Chloride <i@martincl2.me>
-Martin Wang <jiahaow@ca.ibm.com>
-Michael Irwin <mikesir87@gmail.com>
-Mikko Karvonen <mikko.karvonen@arm.com>
-Nicolas Ramz <nicolas.ramz@gmail.com>
-Paris Kasidiaris <pariskasidiaris@gmail.com>
-Paris Kasidiaris <paris@sourcelair.com>
-runarberg <runar@greenqloud.com>
-Saswat Das <saswatds@users.noreply.github.com>
-Saul Costa <saul@codevolve.com>
-Shuanglei Tao <tsl0922@gmail.com>
-Steven Silvester <steven.silvester@ieee.org>
-Thanasis Daglis <thanasis@sourcelair.com>
-Tine Jozelj <tine.jozelj@outlook.com>
-Tyler Jewell <tjewell@codenvy.com>
-Vincent Woo <me@vincentwoo.com>
-yutaka <shigure@refy.net>
-YuviPanda <yuvipanda@gmail.com>

CODE_OF_CONDUCT.md

@@ -0,0 +1,73 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting [@Tyriar](https://twitter.com/Tyriar) or [@pariskasid](https://twitter.com/pariskasid) on Twitter. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org

CONTRIBUTING.md

@@ -23,16 +23,18 @@ opening an issue, read these pointers.
 - Mention precisely what went wrong. What did you expect to happen? What happened instead? Describe the
   exact steps a maintainer has to take to make the problem occur.
 
-- If the problem can not be reproduced in the [demo of xterm.js](README.md#demo), please provide an HTML document that demonstrates the problem.
+- If the problem can not be reproduced in the [demo of xterm.js](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo), please provide an HTML document that demonstrates the problem.
 
 - Be polite. Issues with an indignant or belligerent tone tend to be moved to the
   bottom of the pile.
 
 ## Contributing code
 
-- Make sure you have a [GitHub account](https://github.com/join)
+You can find issues to work on by looking at the [help wanted](https://github.com/xtermjs/xterm.js/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) or [good first issue](https://github.com/xtermjs/xterm.js/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) issues. It's a good idea to comment on the issue saying that you're taking it, just in case someone else comes along and you duplicate work. Once you have your issue, here are the steps to contribute:
+
 - Fork [xterm.js](https://github.com/sourcelair/xterm.js/)
   ([how to fork a repo](https://help.github.com/articles/fork-a-repo))
+- Get the [xterm.js demo](https://github.com/xtermjs/xterm.js/wiki/Contributing#running-the-demo) running
 - Make your changes
 - If your changes are easy to test or likely to regress, add tests. Tests go into `test`, directory.
 - Follow the general code style of the rest of the project (see below).

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:6.9
+FROM node:8
 MAINTAINER Paris Kasidiaris <paris@sourcelair.com>
 
 # Set the working directory
@@ -6,7 +6,7 @@ WORKDIR /usr/src/app
 
 # Set an entrypoint, to automatically install node modules
 ENTRYPOINT ["/bin/bash", "-c", "if [[ ! -d node_modules ]]; then npm install; fi; exec \"${@:0}\";"]
-CMD ["npm", "run", "dev"]
+CMD ["npm", "run", "start"]
 
 # First, install dependencies to improve layer caching
 COPY package.json /usr/src/app/

LICENSE

@@ -1,3 +1,4 @@
+Copyright (c) 2017-2018, The xterm.js authors (https://github.com/xtermjs/xterm.js)
 Copyright (c) 2014-2016, SourceLair Private Company (https://www.sourcelair.com)
 Copyright (c) 2012-2013, Christopher Jeffrey (https://github.com/chjj/)
 

Procfile

@@ -1 +1,2 @@
 web: npm start
+webpack: npm run watch

Procfile.dev

@@ -1 +0,0 @@
-web: npm run dev

README.md

@@ -1,24 +1,108 @@
-# [![xterm.js logo](logo.png)](https://xtermjs.org)
+# [![xterm.js logo](logo-full.png)](https://xtermjs.org)
 
-[![xterm.js build status](https://api.travis-ci.org/sourcelair/xterm.js.svg)](https://travis-ci.org/sourcelair/xterm.js) [![Coverage Status](https://coveralls.io/repos/github/sourcelair/xterm.js/badge.svg)](https://coveralls.io/github/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)
+[![Build Status](https://dev.azure.com/xtermjs/xterm.js/_apis/build/status/xtermjs.xterm.js)](https://dev.azure.com/xtermjs/xterm.js/_build/latest?definitionId=3)
+[![Coverage Status](https://coveralls.io/repos/github/xtermjs/xterm.js/badge.svg?branch=master)](https://coveralls.io/github/xtermjs/xterm.js?branch=master)
 
-Xterm.js is a terminal front-end component written in JavaScript that works in the browser.
-
-It enables applications to provide fully featured terminals to their users and create great development experiences.
+Xterm.js is a front-end component written in TypeScript that lets applications bring fully-featured terminals to their users in the browser. It's used by popular projects such as VS Code, Hyper and Theia.
 
 ## Features
-- **Text-based application support**: Use xterm.js to work with applications like `bash`, `git` etc.
-- **Curses-based application support**: Use xterm.js to work with applications like `vim`, `tmux` etc.
-- **Mouse events support**: Xterm.js captures mouse events like click and scroll and passes them to the terminal's back-end controlling process
-- **CJK (Chinese, Japanese, Korean) character support**: Xterm.js renders CJK characters seamlessly
-- **IME support**: Insert international (including CJK) characters using IME input with your keyboard
-- **Self-contained library**: Xterm.js works on its own. It does not require any external libraries like jQuery or React to work
-- **Modular, event-based API**: Lets you build addons and themes with ease
+
+- **Terminal apps just work**: Xterm.js works with most terminal apps such as `bash`, `vim` and `tmux`, this includes support for curses-based apps and mouse event support
+- **Perfomant**: Xterm.js is *really* fast, it even includes a GPU-accelerated renderer
+- **Rich unicode support**: Supports CJK, emojis and IMEs
+- **Self-contained**: Requires zero dependencies to work
+- **Accessible**: Screen reader support can be turned on using the `screenReaderMode` option
+- **And much more**: Links, theming, addons, well documented API, etc.
 
 ## What xterm.js is not
+
 - Xterm.js is not a terminal application that you can download and use on your computer
 - Xterm.js is not `bash`. Xterm.js can be connected to processes like `bash` and let you interact with them (provide input, receive output)
 
+## Getting Started
+
+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 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. Finally instantiate the `Terminal` object and then call the `open` function with the DOM object of the `div`.
+
+```html
+<!doctype html>
+  <html>
+    <head>
+      <link rel="stylesheet" href="node_modules/xterm/dist/xterm.css" />
+      <script src="node_modules/xterm/dist/xterm.js"></script>
+    </head>
+    <body>
+      <div id="terminal"></div>
+      <script>
+        var term = new Terminal();
+        term.open(document.getElementById('terminal'));
+        term.write('Hello from \x1B[1;3;31mxterm.js\x1B[0m $ ')
+      </script>
+    </body>
+  </html>
+```
+
+### Importing
+
+The recommended way to load xterm.js is via the ES6 module syntax:
+
+```javascript
+import { Terminal } from 'xterm';
+```
+
+### Addons
+
+Addons are JavaScript modules that extend the `Terminal` prototype with new methods and attributes to provide additional functionality. There are a handful available in the main repository in the `src/addons` directory and you can even write your own by using the [public API](https://github.com/xtermjs/xterm.js/blob/master/typings/xterm.d.ts).
+
+To use an addon, just import the JavaScript module and pass it to `Terminal`'s `applyAddon` method:
+
+```javascript
+import { Terminal } from 'xterm';
+import * as fit from 'xterm/lib/addons/fit/fit';
+
+Terminal.applyAddon(fit);
+
+var xterm = new Terminal();  // Instantiate the terminal
+xterm.fit();                 // Use the `fit` method, provided by the `fit` addon
+```
+
+You will also need to include the addon's CSS file if it has one in the folder.
+
+#### Importing Addons in TypeScript
+
+There are currently no typings for addons if they are accessed via extending Terminal prototype, so you will need to upcast if using TypeScript, eg. `(xterm as any).fit()`. Alternatively, you can import the addon function and enhance the terminal on demand. This has better typing support and is friendly to treeshaking.
+
+```typescript
+import { Terminal } from 'xterm';
+import { fit } from 'xterm/lib/addons/fit/fit';
+const xterm = new Terminal();
+
+fit(xterm);  // Fit the terminal when necessary
+```
+
+## 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:
+
+- Chrome latest
+- Edge latest
+- Firefox latest
+- Safari latest
+- IE11
+
+Xterm.js works seamlessly in [Electron](https://electronjs.org/) apps and may even work on earlier versions of the browsers, these are the versions we strive to keep working.
+
+## API
+
+The full API for xterm.js is contained within the [TypeScript declaration file](https://github.com/xtermjs/xterm.js/blob/master/typings/xterm.d.ts), use the branch/tag picker in GitHub (`w`) to navigate to the correct version of the API.
+
+Note that some APIs are marked *experimental*, these are added to enable experimentation with new ideas without committing to support it like a normal [semver](https://semver.org/) API. Note that these APIs can change radically between versions so be sure to read release notes if you plan on using experimental APIs.
+
 ## Real-world uses
 Xterm.js is used in several world-class applications to provide great terminal experiences.
 
@@ -30,109 +114,65 @@ Xterm.js is used in several world-class applications to provide great terminal e
 - [**Codenvy**](http://www.codenvy.com): Cloud workspaces for development teams.
 - [**CoderPad**](https://coderpad.io): Online interviewing platform for programmers. Run code in many programming languages, with results displayed by `xterm.js`.
 - [**WebSSH2**](https://github.com/billchurch/WebSSH2): A web based SSH2 client using `xterm.js`, socket.io, and ssh2.
-- [**Spyder Terminal**](https://github.com/spyder-ide/spyder-terminal): A full fledged system terminal embedded on Spyder IDE. 
+- [**Spyder Terminal**](https://github.com/spyder-ide/spyder-terminal): A full fledged system terminal embedded on Spyder IDE.
 - [**Cloud Commander**](https://cloudcmd.io "Cloud Commander"): Orthodox web file manager with console and editor.
 - [**Codevolve**](https://www.codevolve.com "Codevolve"): Online platform for interactive coding and web development courses. Live container-backed terminal uses `xterm.js`.
 - [**RStudio**](https://www.rstudio.com/products/RStudio "RStudio"): RStudio is an integrated development environment (IDE) for R.
 - [**Terminal for Atom**](https://github.com/jsmecham/atom-terminal-tab): A simple terminal for the Atom text editor.
 - [**Eclipse Orion**](https://orionhub.org): A modern, open source software development environment that runs in the cloud. Code, deploy and run in the cloud.
+- [**Gravitational Teleport**](https://github.com/gravitational/teleport): Gravitational Teleport is a modern SSH server for remotely accessing clusters of Linux servers via SSH or HTTPS.
+- [**Hexlet**](https://en.hexlet.io): Practical programming courses (JavaScript, PHP, Unix, databases, functional programming). A steady path from the first line of code to the first job.
+- [**Selenoid UI**](https://github.com/aerokube/selenoid-ui): Simple UI for the scallable golang implementation of Selenium Hub named Selenoid. We use XTerm for streaming logs over websockets from docker containers.
+- [**Portainer**](https://portainer.io): Simple management UI for Docker.
+- [**SSHy**](https://github.com/stuicey/SSHy): HTML5 Based SSHv2 Web Client with E2E encryption utilising `xterm.js`, SJCL & websockets.
+- [**JupyterLab**](https://github.com/jupyterlab/jupyterlab): An extensible
+computational environment for Jupyter, supporting interactive data science and scientific computing across all programming languages.
+- [**Theia**](https://github.com/theia-ide/theia): Theia is a cloud & desktop IDE framework implemented in TypeScript.
+- [**Opshell**](https://github.com/ricktbaker/opshell) Ops Helper tool to make life easier working with AWS instances across multiple organizations.
+- [**Proxmox VE**](https://www.proxmox.com/en/proxmox-ve): Proxmox VE is a complete open-source platform for enterprise virtualization. It uses xterm.js for container terminals and the host shell.
+- [**Script Runner**](https://github.com/ioquatix/script-runner): Run scripts (or a shell) in Atom.
+- [**Whack Whack Terminal**](https://github.com/Microsoft/WhackWhackTerminal): Terminal emulator for Visual Studio 2017.
+- [**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.
+- [**Azure Data Studio**](https://github.com/Microsoft/azuredatastudio): A data management tool that enables working with SQL Server, Azure SQL DB and SQL DW from Windows, macOS and Linux.
+- [**FreeMAN**](https://github.com/matthew-matvei/freeman): A free, cross-platform file manager for power users
+- [**Fluent Terminal**](https://github.com/felixse/FluentTerminal): A terminal emulator based on UWP and web technologies.
+- [**Hyper**](https://hyper.is): A terminal built on web technologies
+- [**Diag**](https://diag.ai): A better way to troubleshoot problems faster. Capture, share and reapply troubleshooting knowledge so you can focus on solving problems that matter.
+- [**GoTTY**](https://github.com/yudai/gotty): A simple command line tool that shares your terminal as a web application based on xterm.js.
+- [**genact**](https://github.com/svenstaro/genact): A nonsense activity generator.
+- [**cPanel & WHM**](https://cpanel.com): The hosting platform of choice.
+- [**Nutanix**](https://github.com/nutanix): Nutanix Enterprise Cloud uses xterm in the webssh functionality within Nutanix Calm, and is also looking to move our old noserial (termjs) functionality to xterm.js
+- [**SSH Web Client**](https://github.com/roke22/PHP-SSH2-Web-Client): SSH Web Client with PHP.
+- [**Shellvault**](https://www.shellvault.io): The cloud-based SSH terminal you can access from anywhere.
+- [**Juno**](http://junolab.org/): A flexible Julia IDE, based on Atom.
+- [**webssh**](https://github.com/huashengdun/webssh): Web based ssh client.
+- [**info-beamer hosted**](https://info-beamer.com): Uses Xterm.js to manage digital signage devices from the web dashboard.
 
-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.
+[And much more...](https://github.com/xtermjs/xterm.js/network/dependents)
 
-## 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:
-
-- Chrome 48+
-- Edge 13+
-- Firefox 44+
-- Internet Explorer 11+
-- Opera 35+
-- Safari 8+
-
-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
-
-### Linux or macOS
-
-Run the following commands:
-
-```
-$ npm install
-$ npm start
-```
-
-Then open http://0.0.0.0:3000 in a web browser.
-
-### Windows
-
-First, ensure [node-gyp](https://github.com/nodejs/node-gyp) is installed and configured correctly, then run these commands.
-
-Note: Do not use ConEmu, as it seems to break the demo for some reason.
-
-```
-> npm install
-> npm start
-```
-
-Then open http://127.0.0.1:3000 in a web browser.
-
-## Getting Started
-
-To start using xterm.js on your browser, add the `xterm.js` and `xterm.css` to the head of your html page. Then create a `<div id="terminal"></div>` onto which xterm can attach itself.
-```html
-<!doctype html>
-  <html>
-    <head>
-      <link rel="stylesheet" href="bower_components/xterm.js/dist/xterm.css" />
-      <script src="bower_components/xterm.js/dist/xterm.js"></script>
-    </head>
-    <body>
-      <div id="terminal"></div>
-      <script>
-      	var term = new Terminal();
-        term.open(document.getElementById('terminal'));
-        term.write('Hello from \033[1;3;31mxterm.js\033[0m $ ')
-      </script>
-    </body>
-  </html>
-```
-Finally instantiate the `Terminal` object and then call the `open` function with the DOM object of the `div`.
-
-## Addons
-
-Addons are JavaScript modules that attach functions to the `Terminal` prototype to extend its functionality. There are a handful available in the main repository in the `dist/addons` directory, you can even write your own (though they may break when the internals of xterm.js change across versions).
-
-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/dist/xterm.js"></script>
-<script src="node_modules/dist/addons/fit/fit.js"></script>
-```
-
-```js
-var xterm = new Terminal();
-// init code...
-xterm.fit();
-```
+Do you use xterm.js in your application as well? Please [open a Pull Request](https://github.com/sourcelair/xterm.js/pulls) to include it here. We would love to have it in our list. Note: Please add any new contributions to the end of the list only.
 
 ## 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).
+All current and past releases are available on this repo's [Releases page](https://github.com/sourcelair/xterm.js/releases), while a rough roadmap is available by looking through [Milestones](https://github.com/sourcelair/xterm.js/milestones).
 
-## Development and Contribution
+## Contributing
 
-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) 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.
+You can read the [guide on the wiki](https://github.com/xtermjs/xterm.js/wiki/Contributing) to learn how to contribute and setup xterm.js for development.
 
 ## 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) 2014-2016, SourceLair, Private Company ([www.sourcelair.com](https://www.sourcelair.com/home)) (MIT License)
-
+Copyright (c) 2017-2018, [The xterm.js authors](https://github.com/xtermjs/xterm.js/graphs/contributors) (MIT License)<br>
+Copyright (c) 2014-2017, SourceLair, Private Company ([www.sourcelair.com](https://www.sourcelair.com/home)) (MIT License)<br>
 Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)

azure-pipelines.yml

@@ -0,0 +1,68 @@
+# Node.js
+# Build a general Node.js application with npm.
+# Add steps that analyze code, save build artifacts, deploy, and more:
+# https://docs.microsoft.com/vsts/pipelines/languages/javascript
+
+jobs:
+- job: Linux
+  pool:
+    vmImage: 'ubuntu-16.04'
+  steps:
+  - task: NodeTool@0
+    inputs:
+      versionSpec: '8.x'
+    displayName: 'Install Node.js'
+  - task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+    inputs:
+      versionSpec: "1.9.4"
+    displayName: 'Install Yarn'
+  - script: |
+      yarn
+    displayName: 'Install dependencies and build'
+  - script: |
+      yarn mocha
+    displayName: 'Test'
+  - script: |
+      yarn lint
+    displayName: 'Lint'
+
+- job: macOS
+  pool:
+    vmImage: 'xcode9-macos10.13'
+  steps:
+  - task: NodeTool@0
+    inputs:
+      versionSpec: '8.x'
+    displayName: 'Install Node.js'
+  - script: |
+      yarn
+    displayName: 'Install dependencies and build'
+  - script: |
+      yarn mocha
+    displayName: 'Test'
+  - script: |
+      yarn lint
+    displayName: 'Lint'
+  - script: |
+      yarn test-coverage
+      export COVERALLS_GIT_BRANCH=$BUILD_SOURCEBRANCH
+      yarn coveralls
+    displayName: 'Generate and publish coverage'
+
+- job: Windows
+  pool:
+    vmImage: 'vs2017-win2016'
+  steps:
+  - task: NodeTool@0
+    inputs:
+      versionSpec: '8.x'
+    displayName: 'Install Node.js'
+  - script: |
+      yarn
+    displayName: 'Install dependencies and build'
+  - script: |
+      yarn mocha
+    displayName: 'Test'
+  - script: |
+      yarn lint
+    displayName: 'Lint'

bin/generate-authors

@@ -1,7 +0,0 @@
-#! /usr/bin/env sh
-
-tail --lines=+3 AUTHORS > AUTHORS.tmp
-git log --format='%aN <%aE>' >> AUTHORS.tmp
-echo "List of xterm.js contributors. Updated before every release.\n" > AUTHORS
-sort -u AUTHORS.tmp >> AUTHORS
-rm -f AUTHORS.tmp

bin/prepare-release

@@ -12,23 +12,13 @@ CURRENT_PACKAGE_JSON_VERSION=$(cat package.json \
   | awk -F: '{ print $2 }' \
   | sed 's/[",]//g' \
   | tr -d '[[:space:]]')
-CURRENT_BOWER_JSON_VERSION=$(cat bower.json \
-  | grep version \
-  | head -1 \
-  | awk -F: '{ print $2 }' \
-  | sed 's/[",]//g' \
-  | tr -d '[[:space:]]')
 
 # Build xterm.js into `dist`
 export BUILD_DIR=dist
 npm run build
 
-# Update AUTHORS file
-sh bin/generate-authors
-
-# Update version in package.json and bower.json
+# Update version in package.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

bower.json

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

demo/client.ts

@@ -0,0 +1,292 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * This file is the entry point for browserify.
+ */
+
+/// <reference path="../typings/xterm.d.ts"/>
+
+import { Terminal } from '../lib/public/Terminal';
+import * as attach from '../lib/addons/attach/attach';
+import * as fit from '../lib/addons/fit/fit';
+import * as fullscreen from '../lib/addons/fullscreen/fullscreen';
+import * as search from '../lib/addons/search/search';
+import * as webLinks from '../lib/addons/webLinks/webLinks';
+import * as winptyCompat from '../lib/addons/winptyCompat/winptyCompat';
+import { ISearchOptions } from '../lib/addons/search/Interfaces';
+
+// Pulling in the module's types relies on the <reference> above, it's looks a
+// little weird here as we're importing "this" module
+import { Terminal as TerminalType } from 'xterm';
+
+export interface IWindowWithTerminal extends Window {
+  term: TerminalType;
+}
+declare let window: IWindowWithTerminal;
+
+Terminal.applyAddon(attach);
+Terminal.applyAddon(fit);
+Terminal.applyAddon(fullscreen);
+Terminal.applyAddon(search);
+Terminal.applyAddon(webLinks);
+Terminal.applyAddon(winptyCompat);
+
+
+let term;
+let protocol;
+let socketURL;
+let socket;
+let pid;
+
+const terminalContainer = document.getElementById('terminal-container');
+const actionElements = {
+  findNext: <HTMLInputElement>document.querySelector('#find-next'),
+  findPrevious: <HTMLInputElement>document.querySelector('#find-previous')
+};
+const paddingElement = <HTMLInputElement>document.getElementById('padding');
+
+function setPadding(): void {
+  term.element.style.padding = parseInt(paddingElement.value, 10).toString() + 'px';
+  term.fit();
+}
+
+function getSearchOptions(): ISearchOptions {
+  return {
+    regex: (document.getElementById('regex') as HTMLInputElement).checked,
+    wholeWord: (document.getElementById('whole-word') as HTMLInputElement).checked,
+    caseSensitive: (document.getElementById('case-sensitive') as HTMLInputElement).checked
+  };
+}
+
+createTerminal();
+
+const disposeRecreateButtonHandler = () => {
+  // If the terminal exists dispose of it, otherwise recreate it
+  if (term) {
+    term.dispose();
+    term = null;
+    window.term = null;
+    socket = null;
+    document.getElementById('dispose').innerHTML = 'Recreate Terminal';
+  }
+  else {
+    createTerminal();
+    document.getElementById('dispose').innerHTML = 'Dispose terminal';
+  }
+};
+
+document.getElementById('dispose').addEventListener('click', disposeRecreateButtonHandler);
+
+function createTerminal(): void {
+  // Clean terminal
+  while (terminalContainer.children.length) {
+    terminalContainer.removeChild(terminalContainer.children[0]);
+  }
+  term = new Terminal({});
+  window.term = term;  // Expose `term` to window for debugging purposes
+  term.on('resize', (size: { cols: number, rows: number }) => {
+    if (!pid) {
+      return;
+    }
+    const cols = size.cols;
+    const rows = size.rows;
+    const url = '/terminals/' + pid + '/size?cols=' + cols + '&rows=' + rows;
+
+    fetch(url, {method: 'POST'});
+  });
+  protocol = (location.protocol === 'https:') ? 'wss://' : 'ws://';
+  socketURL = protocol + location.hostname + ((location.port) ? (':' + location.port) : '') + '/terminals/';
+
+  term.open(terminalContainer);
+  term.winptyCompatInit();
+  term.webLinksInit();
+  term.fit();
+  term.focus();
+
+  addDomListener(paddingElement, 'change', setPadding);
+
+  addDomListener(actionElements.findNext, 'keyup', (e) => {
+    const searchOptions = getSearchOptions();
+    searchOptions.incremental = e.key !== `Enter`;
+    term.findNext(actionElements.findNext.value, searchOptions);
+  });
+
+  addDomListener(actionElements.findPrevious, 'keyup', (e) => {
+    if (e.key === `Enter`) {
+      term.findPrevious(actionElements.findPrevious.value, getSearchOptions());
+    }
+  });
+
+  // fit is called within a setTimeout, cols and rows need this.
+  setTimeout(() => {
+    initOptions(term);
+    // TODO: Clean this up, opt-cols/rows doesn't exist anymore
+    (<HTMLInputElement>document.getElementById(`opt-cols`)).value = term.cols;
+    (<HTMLInputElement>document.getElementById(`opt-rows`)).value = term.rows;
+    paddingElement.value = '0';
+
+    // Set terminal size again to set the specific dimensions on the demo
+    updateTerminalSize();
+
+    fetch('/terminals?cols=' + term.cols + '&rows=' + term.rows, {method: 'POST'}).then((res) => {
+      res.text().then((processId) => {
+        pid = processId;
+        socketURL += processId;
+        socket = new WebSocket(socketURL);
+        socket.onopen = runRealTerminal;
+        socket.onclose = runFakeTerminal;
+        socket.onerror = runFakeTerminal;
+      });
+    });
+  }, 0);
+}
+
+function runRealTerminal(): void {
+  term.attach(socket);
+  term._initialized = true;
+}
+
+function runFakeTerminal(): void {
+  if (term._initialized) {
+    return;
+  }
+
+  term._initialized = true;
+
+  term.prompt = () => {
+    term.write('\r\n$ ');
+  };
+
+  term.writeln('Welcome to xterm.js');
+  term.writeln('This is a local terminal emulation, without a real terminal in the back-end.');
+  term.writeln('Type some keys and commands to play around.');
+  term.writeln('');
+  term.prompt();
+
+  term._core.register(term.addDisposableListener('key', (key, ev) => {
+    const printable = !ev.altKey && !ev.altGraphKey && !ev.ctrlKey && !ev.metaKey;
+
+    if (ev.keyCode === 13) {
+      term.prompt();
+    } else if (ev.keyCode === 8) {
+     // Do not delete the prompt
+      if (term.x > 2) {
+        term.write('\b \b');
+      }
+    } else if (printable) {
+      term.write(key);
+    }
+  }));
+
+  term._core.register(term.addDisposableListener('paste', (data, ev) => {
+    term.write(data);
+  }));
+}
+
+function initOptions(term: TerminalType): void {
+  const blacklistedOptions = [
+    // Internal only options
+    'cancelEvents',
+    'convertEol',
+    'debug',
+    'handler',
+    'screenKeys',
+    'termName',
+    'useFlowControl',
+    // Complex option
+    'theme'
+  ];
+  const stringOptions = {
+    bellSound: null,
+    bellStyle: ['none', 'sound'],
+    cursorStyle: ['block', 'underline', 'bar'],
+    experimentalCharAtlas: ['none', 'static', 'dynamic'],
+    fontFamily: null,
+    fontWeight: ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'],
+    fontWeightBold: ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'],
+    rendererType: ['dom', 'canvas'],
+    experimentalBufferLineImpl: ['JsArray', 'TypedArray']
+  };
+  const options = Object.keys((<any>term)._core.options);
+  const booleanOptions = [];
+  const numberOptions = [];
+  options.filter(o => blacklistedOptions.indexOf(o) === -1).forEach(o => {
+    switch (typeof term.getOption(o)) {
+      case 'boolean':
+        booleanOptions.push(o);
+        break;
+      case 'number':
+        numberOptions.push(o);
+        break;
+      default:
+        if (Object.keys(stringOptions).indexOf(o) === -1) {
+          console.warn(`Unrecognized option: "${o}"`);
+        }
+    }
+  });
+
+  let html = '';
+  html += '<div class="option-group">';
+  booleanOptions.forEach(o => {
+    html += `<div class="option"><label><input id="opt-${o}" type="checkbox" ${term.getOption(o) ? 'checked' : ''}/> ${o}</label></div>`;
+  });
+  html += '</div><div class="option-group">';
+  numberOptions.forEach(o => {
+    html += `<div class="option"><label>${o} <input id="opt-${o}" type="number" value="${term.getOption(o)}" step="${o === 'lineHeight' ? '0.1' : '1'}"/></label></div>`;
+  });
+  html += '</div><div class="option-group">';
+  Object.keys(stringOptions).forEach(o => {
+    if (stringOptions[o]) {
+      html += `<div class="option"><label>${o} <select id="opt-${o}">${stringOptions[o].map(v => `<option ${term.getOption(o) === v ? 'selected' : ''}>${v}</option>`).join('')}</select></label></div>`;
+    } else {
+      html += `<div class="option"><label>${o} <input id="opt-${o}" type="text" value="${term.getOption(o)}"/></label></div>`;
+    }
+  });
+  html += '</div>';
+
+  const container = document.getElementById('options-container');
+  container.innerHTML = html;
+
+  // Attach listeners
+  booleanOptions.forEach(o => {
+    const input = <HTMLInputElement>document.getElementById(`opt-${o}`);
+    addDomListener(input, 'change', () => {
+      console.log('change', o, input.checked);
+      term.setOption(o, input.checked);
+    });
+  });
+  numberOptions.forEach(o => {
+    const input = <HTMLInputElement>document.getElementById(`opt-${o}`);
+    addDomListener(input, 'change', () => {
+      console.log('change', o, input.value);
+      if (o === 'cols' || o === 'rows') {
+        updateTerminalSize();
+      } else {
+        term.setOption(o, o === 'lineHeight' ? parseFloat(input.value) : parseInt(input.value, 10));
+      }
+    });
+  });
+  Object.keys(stringOptions).forEach(o => {
+    const input = <HTMLInputElement>document.getElementById(`opt-${o}`);
+    addDomListener(input, 'change', () => {
+      console.log('change', o, input.value);
+      term.setOption(o, input.value);
+    });
+  });
+}
+
+function addDomListener(element: HTMLElement, type: string, handler: (...args: any[]) => any): void {
+  element.addEventListener(type, handler);
+  term._core.register({ dispose: () => element.removeEventListener(type, handler) });
+}
+
+function updateTerminalSize(): void {
+  const cols = parseInt((<HTMLInputElement>document.getElementById(`opt-cols`)).value, 10);
+  const rows = parseInt((<HTMLInputElement>document.getElementById(`opt-rows`)).value, 10);
+  const width = (cols * term._core.renderer.dimensions.actualCellWidth + term._core.viewport.scrollBarWidth).toString() + 'px';
+  const height = (rows * term._core.renderer.dimensions.actualCellHeight).toString() + 'px';
+  terminalContainer.style.width = width;
+  terminalContainer.style.height = height;
+  term.fit();
+}

demo/index.html

@@ -1,55 +1,41 @@
 <!doctype html>
 <html>
-    <head>
-        <title>xterm.js demo</title>
-        <link rel="stylesheet" href="/build/xterm.css" />
-        <link rel="stylesheet" href="/build/addons/fullscreen/fullscreen.css" />
-        <link rel="stylesheet" href="style.css" />
-      	<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>
-        <div id="terminal-container"></div>
-        <div>
-          <h2>Options</h2>
-          <p>
-            <label><input type="checkbox" id="option-cursor-blink"> cursorBlink</label>
-          </p>
-          <p>
-            <label>
-              cursorStyle
-              <select id="option-cursor-style">
-                <option value="block">block</option>
-                <option value="underline">underline</option>
-                <option value="bar">bar</option>
-              </select>
-            </label>
-          </p>
-          <p>
-            <label>scrollback <input type="number" id="option-scrollback" value="1000" /></label>
-          </p>
-          <p>
-            <label>tabStopWidth <input type="number" id="option-tabstopwidth" value="8" /></label>
-          </p>
-          <div>
-          	<h3>Size</h3>
-            <div>
-              <div style="display: inline-block; margin-right: 16px;">
-                <label for="cols">Columns</label>
-                <input type="number" id="cols" />
-              </div>
-              <div style="display: inline-block; margin-right: 16px;">
-                <label for="rows">Rows</label>
-                <input type="number" id="rows" />
-              </div>
-            </div>
-          </div>
-        </div>
-        <p><strong>Attention:</strong> The demo is a barebones implementation and is designed for xterm.js evaluation purposes only. Exposing the demo to the public as is would introduce security risks for the host.</p>
-        <script src="main.js" defer ></script>
-    </body>
+  <head>
+    <title>xterm.js demo</title>
+    <link rel="stylesheet" href="/build/xterm.css" />
+    <link rel="stylesheet" href="/build/addons/fullscreen/fullscreen.css" />
+    <link rel="stylesheet" href="style.css" />
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/es6-promise/4.1.1/es6-promise.auto.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/fetch/1.0.0/fetch.min.js"></script>
+  </head>
+  <body>
+    <h1 style="color: #2D2E2C">xterm.js: A terminal for the <em style="color: #5DA5D5">web</em></h1>
+    <div id="terminal-container"></div>
+    <div>
+      <h3>Actions</h3>
+      <p>
+        <label>Find next <input id="find-next"/></label>
+        <label>Find previous <input id="find-previous"/></label>
+        <label>Use regex<input type="checkbox" id="regex"/></label> 
+        <label>Case sensitive<input type="checkbox" id="case-sensitive"/></label>
+        <label>Whole word<input type="checkbox" id="whole-word"/></label>
+      </p>
+    </div>
+    <div>
+      <h3>Options</h3>
+      <p>These options can be set in the <code>Terminal</code> constructor or using the <code>Terminal.setOption</code> function.</p>
+      <div id="options-container"></div>
+    </div>
+    <div>
+      <h3>Style</h3>
+      <div style="display: inline-block; margin-right: 16px;">
+        <label for="padding">Padding</label>
+        <input type="number" id="padding" />
+      </div>
+    </div>
+    <hr/>
+    <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>
+    <button id="dispose" title="This is used to testing memory leaks">Dispose terminal</button>
+    <script src="dist/client-bundle.js" defer ></script>
+  </body>
 </html>

demo/main.js

@@ -1,141 +0,0 @@
-var term,
-    protocol,
-    socketURL,
-    socket,
-    pid,
-    charWidth,
-    charHeight;
-
-var terminalContainer = document.getElementById('terminal-container'),
-    optionElements = {
-      cursorBlink: document.querySelector('#option-cursor-blink'),
-      cursorStyle: document.querySelector('#option-cursor-style'),
-      scrollback: document.querySelector('#option-scrollback'),
-      tabstopwidth: document.querySelector('#option-tabstopwidth')
-    },
-    colsElement = document.getElementById('cols'),
-    rowsElement = document.getElementById('rows');
-
-function setTerminalSize () {
-  var cols = parseInt(colsElement.value, 10),
-      rows = parseInt(rowsElement.value, 10),
-      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', function () {
-  term.setOption('cursorBlink', optionElements.cursorBlink.checked);
-});
-optionElements.cursorStyle.addEventListener('change', function () {
-  term.setOption('cursorStyle', optionElements.cursorStyle.value);
-});
-optionElements.scrollback.addEventListener('change', function () {
-  term.setOption('scrollback', parseInt(optionElements.scrollback.value, 10));
-});
-optionElements.tabstopwidth.addEventListener('change', function () {
-  term.setOption('tabStopWidth', parseInt(optionElements.tabstopwidth.value, 10));
-});
-
-createTerminal();
-
-function createTerminal() {
-  // Clean terminal
-  while (terminalContainer.children.length) {
-    terminalContainer.removeChild(terminalContainer.children[0]);
-  }
-  term = new Terminal({
-    cursorBlink: optionElements.cursorBlink.checked,
-    scrollback: parseInt(optionElements.scrollback.value, 10),
-    tabStopWidth: parseInt(optionElements.tabstopwidth.value, 10)
-  });
-  term.on('resize', function (size) {
-    if (!pid) {
-      return;
-    }
-    var cols = size.cols,
-        rows = size.rows,
-        url = '/terminals/' + pid + '/size?cols=' + cols + '&rows=' + rows;
-
-    fetch(url, {method: 'POST'});
-  });
-  protocol = (location.protocol === 'https:') ? 'wss://' : 'ws://';
-  socketURL = protocol + location.hostname + ((location.port) ? (':' + location.port) : '') + '/terminals/';
-
-  term.open(terminalContainer);
-  term.fit();
-
-  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;
-    });
-  });
-}
-
-function runRealTerminal() {
-  term.attach(socket);
-  term._initialized = true;
-}
-
-function runFakeTerminal() {
-  if (term._initialized) {
-    return;
-  }
-
-  term._initialized = true;
-
-  var shellprompt = '$ ';
-
-  term.prompt = function () {
-    term.write('\r\n' + shellprompt);
-  };
-
-  term.writeln('Welcome to xterm.js');
-  term.writeln('This is a local terminal emulation, without a real terminal in the back-end.');
-  term.writeln('Type some keys and commands to play around.');
-  term.writeln('');
-  term.prompt();
-
-  term.on('key', function (key, ev) {
-    var printable = (
-      !ev.altKey && !ev.altGraphKey && !ev.ctrlKey && !ev.metaKey
-    );
-
-    if (ev.keyCode == 13) {
-      term.prompt();
-    } else if (ev.keyCode == 8) {
-     // Do not delete the prompt
-      if (term.x > 2) {
-        term.write('\b \b');
-      }
-    } else if (printable) {
-      term.write(key);
-    }
-  });
-
-  term.on('paste', function (data, ev) {
-    term.write(data);
-  });
-}

demo/server.js

@@ -0,0 +1,106 @@
+var express = require('express');
+var expressWs = require('express-ws');
+var os = require('os');
+var pty = require('node-pty');
+
+function startServer() {
+  var app = express();
+  expressWs(app);
+
+  var terminals = {},
+      logs = {};
+
+  app.use('/build', express.static(__dirname + '/../build'));
+
+  app.get('/', function(req, res){
+    res.sendFile(__dirname + '/index.html');
+  });
+
+  app.get('/style.css', function(req, res){
+    res.sendFile(__dirname + '/style.css');
+  });
+
+  app.get('/dist/client-bundle.js', function(req, res){
+    res.sendFile(__dirname + '/dist/client-bundle.js');
+  });
+
+  app.post('/terminals', function (req, res) {
+    var cols = parseInt(req.query.cols),
+        rows = parseInt(req.query.rows),
+        term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
+          name: 'xterm-color',
+          cols: cols || 80,
+          rows: rows || 24,
+          cwd: process.env.PWD,
+          env: process.env
+        });
+
+    console.log('Created terminal with PID: ' + term.pid);
+    terminals[term.pid] = term;
+    logs[term.pid] = '';
+    term.on('data', function(data) {
+      logs[term.pid] += data;
+    });
+    res.send(term.pid.toString());
+    res.end();
+  });
+
+  app.post('/terminals/:pid/size', function (req, res) {
+    var pid = parseInt(req.params.pid),
+        cols = parseInt(req.query.cols),
+        rows = parseInt(req.query.rows),
+        term = terminals[pid];
+
+    term.resize(cols, rows);
+    console.log('Resized terminal ' + pid + ' to ' + cols + ' cols and ' + rows + ' rows.');
+    res.end();
+  });
+
+  app.ws('/terminals/:pid', function (ws, req) {
+    var term = terminals[parseInt(req.params.pid)];
+    console.log('Connected to terminal ' + term.pid);
+    ws.send(logs[term.pid]);
+
+    function buffer(socket, timeout) {
+      let s = '';
+      let sender = null;
+      return (data) => {
+        s += data;
+        if (!sender) {
+          sender = setTimeout(() => {
+            socket.send(s);
+            s = '';
+            sender = null;
+          }, timeout);
+        }
+      };
+    }
+    const send = buffer(ws, 5);
+
+    term.on('data', function(data) {
+      try {
+        send(data);
+      } catch (ex) {
+        // The WebSocket is not open, ignore
+      }
+    });
+    ws.on('message', function(msg) {
+      term.write(msg);
+    });
+    ws.on('close', function () {
+      term.kill();
+      console.log('Closed terminal ' + term.pid);
+      // Clean things up
+      delete terminals[term.pid];
+      delete logs[term.pid];
+    });
+  });
+
+  var port = process.env.PORT || 3000,
+      host = os.platform() === 'win32' ? '127.0.0.1' : '0.0.0.0';
+
+  console.log('App listening to http://' + host + ':' + port);
+  app.listen(port, host);
+}
+
+module.exports = startServer;

demo/start.js

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * This file is the entry point for browserify.
+ */
+
+const cp = require('child_process');
+const path = require('path');
+const webpack = require('webpack');
+const startServer = require('./server.js');
+
+startServer();
+
+// Build/watch client source
+const clientConfig = {
+  entry: path.resolve(__dirname, 'client.ts'),
+  devtool: 'inline-source-map',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/
+      },
+      {
+        test: /\.js$/,
+        use: ["source-map-loader"],
+        enforce: "pre"
+      }
+    ]
+  },
+  resolve: {
+    extensions: [ '.tsx', '.ts', '.js' ]
+  },
+  output: {
+    filename: 'client-bundle.js',
+    path: path.resolve(__dirname, 'dist')
+  },
+  mode: 'development',
+  watch: true
+};
+const compiler = webpack(clientConfig);
+
+compiler.watch({
+  // Example watchOptions
+  aggregateTimeout: 300,
+  poll: undefined
+}, (err, stats) => {
+  // Print watch/build result here...
+  console.log(stats.toString({
+    colors: true
+  }));
+});

demo/style.css

@@ -15,8 +15,18 @@ h1 {
     padding: 2px;
 }
 
-#terminal-container .terminal {
-    background-color: #111;
-    color: #fafafa;
-    padding: 2px;
+p {
+    font-size: 0.9em;
+    font-style: italic
+}
+
+#option-container {
+    display: flex;
+    justify-content: center;
+}
+
+.option-group {
+    display: inline-block;
+    padding-left: 20px;
+    vertical-align: top;
 }

demo/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "rootDir": ".",
+    "sourceMap": true
+  },
+  "include": [
+    "client.ts",
+    "../typings/xterm.d.ts"
+  ]
+}

demo/zmodem/app.js

@@ -7,14 +7,16 @@ var pty = require('node-pty');
 var terminals = {},
     logs = {};
 
-app.use('/build', express.static(__dirname + '/../build'));
+app.use('/build', express.static(__dirname + '/../../build'));
+app.use('/demo', express.static(__dirname + '/../../demo'));
+app.use('/zmodemjs', express.static(__dirname + '/../../node_modules/zmodem.js/dist'));
 
 app.get('/', function(req, res){
   res.sendFile(__dirname + '/index.html');
 });
 
 app.get('/style.css', function(req, res){
-  res.sendFile(__dirname + '/style.css');
+  res.sendFile(__dirname + '../style.css');
 });
 
 app.get('/main.js', function(req, res){
@@ -25,6 +27,7 @@ app.post('/terminals', function (req, res) {
   var cols = parseInt(req.query.cols),
       rows = parseInt(req.query.rows),
       term = pty.spawn(process.platform === 'win32' ? 'cmd.exe' : 'bash', [], {
+        encoding: null,
         name: 'xterm-color',
         cols: cols || 80,
         rows: rows || 24,

demo/zmodem/index.html

@@ -0,0 +1,128 @@
+<!doctype html>
+<html>
+    <head>
+        <title>xterm.js demo</title>
+        <link rel="stylesheet" href="/build/xterm.css" />
+        <link rel="stylesheet" href="/build/addons/fullscreen/fullscreen.css" />
+        <link rel="stylesheet" href="/demo/style.css" />
+      	<script src="https://cdnjs.cloudflare.com/ajax/libs/es6-promise/4.1.1/es6-promise.auto.min.js"></script>
+      	<script src="https://cdnjs.cloudflare.com/ajax/libs/fetch/1.0.0/fetch.min.js"></script>
+        <script src="/build/xterm.js" ></script>
+
+        <script src="/build/addons/attach/attach.js" ></script>
+        <script src="/zmodemjs/zmodem.js"></script>
+        <script src="/build/addons/zmodem/zmodem.js" ></script>
+
+        <script src="/build/addons/fit/fit.js" ></script>
+        <script src="/build/addons/fullscreen/fullscreen.js" ></script>
+        <script src="/build/addons/search/search.js" ></script>
+    </head>
+    <body>
+        <h1>xterm.js: xterm, in the browser</h1>
+
+        <div id="terminal-container"></div>
+
+        <div id="zmodem_controls">
+            <form id="zm_start" style="display: none" action="javascript:void(0)">
+                ZMODEM detected: Start ZMODEM session?
+                <label><input id="zmstart_yes" name="zmstart" type=radio checked value="1"> Yes</label>
+                &nbsp;
+                <label><input name="zmstart" type=radio value=""> No</label>
+                <button type="submit">Submit</button>
+            </form>
+
+            <form id="zm_offer" style="display: none" action="javascript:void(0)">
+                <p>ZMODEM File offered!</p>
+
+                <label><input id="zmaccept_yes" name="zmaccept" type=radio checked value="1"> Accept</label>
+                &nbsp;
+                <label><input name="zmaccept" type=radio value=""> Skip</label>
+                <button type="submit">Submit</button>
+            </form>
+
+            <div id="zm_file" style="display: none">
+                <div>Name: <span id="name"></span></div>
+                <div>Size: <span id="size"></span></div>
+                <div>Last modified: <span id="mtime"></span></div>
+                <div>Mode: <span id="mode"></span></div>
+                <br>
+                <div>Conversion: <span id="zfile_conversion"></span></div>
+                <div>Management: <span id="zfile_management"></span></div>
+                <div>Transport: <span id="zfile_transport"></span></div>
+                <div>Sparse? <span id="zfile_sparse"></span></div>
+                <br>
+                <div>Files remaining in batch: <span id="files_remaining"></span></div>
+                <div>Bytes remaining in batch: <span id="bytes_remaining"></span></div>
+            </div>
+
+            <form id="zm_progress" style="display: none" action="javascript:void(0)">
+                <div><span id="percent_received"></span>% (<span id="bytes_received"></span> bytes) received</div>
+                <button id="zm_progress_skipper" type="button" onclick="skip_current_file();">Skip File</button>
+            </form>
+
+            <form id="zm_choose" style="display: none" action="javascript:void(0)">
+                <label>Choose file(s): <input id="zm_files" type="file" multiple></label>
+            </form>
+        </div>
+
+        <div>
+          <h2>Actions</h2>
+          <p>
+            <label>Find next <input id="find-next"/></label>
+            <label>Find previous <input id="find-previous"/></label>
+          </p>
+        </div>
+        <div>
+          <h2>Options</h2>
+          <p>
+            <label><input type="checkbox" id="option-cursor-blink"> cursorBlink</label>
+          </p>
+          <p>
+            <label><input type="checkbox" checked id="zmodem-auto"> Accept all ZMODEM prompts<sup>*</sup></label>
+          </p>
+          <p>
+            <label>
+              cursorStyle
+              <select id="option-cursor-style">
+                <option value="block">block</option>
+                <option value="underline">underline</option>
+                <option value="bar">bar</option>
+              </select>
+            </label>
+          </p>
+          <p>
+            <label>
+              bellStyle
+              <select id="option-bell-style">
+                <option value="">none</option>
+                <option value="sound">sound</option>
+                <option value="visual">visual</option>
+                <option value="both">both</option>
+              </select>
+            </label>
+          </p>
+          <p>
+            <label>scrollback <input type="number" id="option-scrollback" value="1000" /></label>
+          </p>
+          <p>
+            <label>tabStopWidth <input type="number" id="option-tabstopwidth" value="8" /></label>
+          </p>
+          <div>
+          	<h3>Size</h3>
+            <div>
+              <div style="display: inline-block; margin-right: 16px;">
+                <label for="cols">Columns</label>
+                <input type="number" id="cols" />
+              </div>
+              <div style="display: inline-block; margin-right: 16px;">
+                <label for="rows">Rows</label>
+                <input type="number" id="rows" />
+              </div>
+            </div>
+          </div>
+        </div>
+        <p><strong>Attention:</strong> The demo is a barebones implementation and is designed for xterm.js evaluation purposes only. Exposing the demo to the public as is would introduce security risks for the host.</p>
+        <p><sup>*</sup> ZMODEM file transfers are supported via an addon. To try it out, install <a href="https://ohse.de/uwe/software/lrzsz.html"><code>lrzsz</code></a> onto the remote peer, then run <code>rz</code> to send from your browser or <code>sz &lt;file&gt;</code> to send from the remote peer.</p>
+        <script src="main.js" defer ></script>
+    </body>
+</html>

demo/zmodem/main.js

@@ -0,0 +1,388 @@
+"use strict";
+
+var term,
+    protocol,
+    socketURL,
+    socket,
+    pid;
+
+Terminal.applyAddon(fit);
+Terminal.applyAddon(attach);
+Terminal.applyAddon(zmodem);
+Terminal.applyAddon(search);
+
+var terminalContainer = document.getElementById('terminal-container'),
+    actionElements = {
+      findNext: document.querySelector('#find-next'),
+      findPrevious: document.querySelector('#find-previous')
+    },
+    optionElements = {
+      cursorBlink: document.querySelector('#option-cursor-blink'),
+      cursorStyle: document.querySelector('#option-cursor-style'),
+      scrollback: document.querySelector('#option-scrollback'),
+      tabstopwidth: document.querySelector('#option-tabstopwidth'),
+      bellStyle: document.querySelector('#option-bell-style')
+    },
+    colsElement = document.getElementById('cols'),
+    rowsElement = document.getElementById('rows');
+
+function setTerminalSize() {
+  var cols = parseInt(colsElement.value, 10);
+  var rows = parseInt(rowsElement.value, 10);
+  var viewportElement = document.querySelector('.xterm-viewport');
+  var scrollBarWidth = viewportElement.offsetWidth - viewportElement.clientWidth;
+  var width = (cols * term.charMeasure.width + 20 /*room for scrollbar*/).toString() + 'px';
+  var height = (rows * term.charMeasure.height).toString() + 'px';
+
+  terminalContainer.style.width = width;
+  terminalContainer.style.height = height;
+  term.resize(cols, rows);
+}
+
+colsElement.addEventListener('change', setTerminalSize);
+rowsElement.addEventListener('change', setTerminalSize);
+
+actionElements.findNext.addEventListener('keypress', function (e) {
+  if (e.key === "Enter") {
+    e.preventDefault();
+    term.findNext(actionElements.findNext.value);
+  }
+});
+actionElements.findPrevious.addEventListener('keypress', function (e) {
+  if (e.key === "Enter") {
+    e.preventDefault();
+    term.findPrevious(actionElements.findPrevious.value);
+  }
+});
+
+optionElements.cursorBlink.addEventListener('change', function () {
+  term.setOption('cursorBlink', optionElements.cursorBlink.checked);
+});
+optionElements.cursorStyle.addEventListener('change', function () {
+  term.setOption('cursorStyle', optionElements.cursorStyle.value);
+});
+optionElements.bellStyle.addEventListener('change', function () {
+  term.setOption('bellStyle', optionElements.bellStyle.value);
+});
+optionElements.scrollback.addEventListener('change', function () {
+  term.setOption('scrollback', parseInt(optionElements.scrollback.value, 10));
+});
+optionElements.tabstopwidth.addEventListener('change', function () {
+  term.setOption('tabStopWidth', parseInt(optionElements.tabstopwidth.value, 10));
+});
+
+createTerminal();
+
+function createTerminal() {
+  // Clean terminal
+  while (terminalContainer.children.length) {
+    terminalContainer.removeChild(terminalContainer.children[0]);
+  }
+  term = new Terminal({
+    cursorBlink: optionElements.cursorBlink.checked,
+    scrollback: parseInt(optionElements.scrollback.value, 10),
+    tabStopWidth: parseInt(optionElements.tabstopwidth.value, 10)
+  });
+  term.on('resize', function (size) {
+    if (!pid) {
+      return;
+    }
+    var cols = size.cols,
+        rows = size.rows,
+        url = '/terminals/' + pid + '/size?cols=' + cols + '&rows=' + rows;
+
+    fetch(url, {method: 'POST'});
+  });
+  protocol = (location.protocol === 'https:') ? 'wss://' : 'ws://';
+  socketURL = protocol + location.hostname + ((location.port) ? (':' + location.port) : '') + '/terminals/';
+
+  term.open(terminalContainer);
+  term.fit();
+
+  // fit is called within a setTimeout, cols and rows need this.
+  setTimeout(function () {
+    colsElement.value = term.cols;
+    rowsElement.value = term.rows;
+
+    // Set terminal size again to set the specific dimensions on the demo
+    setTerminalSize();
+
+    fetch('/terminals?cols=' + term.cols + '&rows=' + term.rows, {method: 'POST'}).then(function (res) {
+
+      res.text().then(function (pid) {
+        window.pid = pid;
+        socketURL += pid;
+        socket = new WebSocket(socketURL);
+        socket.onopen = runRealTerminal;
+        socket.onclose = runFakeTerminal;
+        socket.onerror = runFakeTerminal;
+
+        term.zmodemAttach(socket, {
+            noTerminalWriteOutsideSession: true,
+        } );
+
+        term.on("zmodemRetract", () => {
+            start_form.style.display = "none";
+            start_form.onsubmit = null;
+        });
+
+        term.on("zmodemDetect", (detection) => {
+            function do_zmodem() {
+                term.detach();
+                let zsession = detection.confirm();
+
+                var promise;
+
+                if (zsession.type === "receive") {
+                    promise = _handle_receive_session(zsession);
+                }
+                else {
+                    promise = _handle_send_session(zsession);
+                }
+
+                promise.catch( console.error.bind(console) ).then( () => {
+                    term.attach(socket);
+                } );
+            }
+
+            if (_auto_zmodem()) {
+                do_zmodem();
+            }
+            else {
+                start_form.style.display = "";
+                start_form.onsubmit = function(e) {
+                    start_form.style.display = "none";
+
+                    if (document.getElementById("zmstart_yes").checked) {
+                        do_zmodem();
+                    }
+                    else {
+                        detection.deny();
+                    }
+                };
+            }
+        });
+      });
+    });
+  }, 0);
+}
+
+//----------------------------------------------------------------------
+// UI STUFF
+
+function _show_file_info(xfer) {
+    var file_info = xfer.get_details();
+
+    document.getElementById("name").textContent = file_info.name;
+    document.getElementById("size").textContent = file_info.size;
+    document.getElementById("mtime").textContent = file_info.mtime;
+    document.getElementById("files_remaining").textContent = file_info.files_remaining;
+    document.getElementById("bytes_remaining").textContent = file_info.bytes_remaining;
+
+    document.getElementById("mode").textContent = "0" + file_info.mode.toString(8);
+
+    var xfer_opts = xfer.get_options();
+    ["conversion", "management", "transport", "sparse"].forEach( (lbl) => {
+        document.getElementById(`zfile_${lbl}`).textContent = xfer_opts[lbl];
+    } );
+
+    document.getElementById("zm_file").style.display = "";
+}
+function _hide_file_info() {
+    document.getElementById("zm_file").style.display = "none";
+}
+
+function _save_to_disk(xfer, buffer) {
+    return Zmodem.Browser.save_to_disk(buffer, xfer.get_details().name);
+}
+
+var skipper_button = document.getElementById("zm_progress_skipper");
+var skipper_button_orig_text = skipper_button.textContent;
+
+function _show_progress() {
+    skipper_button.disabled = false;
+    skipper_button.textContent = skipper_button_orig_text;
+
+    document.getElementById("bytes_received").textContent = 0;
+    document.getElementById("percent_received").textContent = 0;
+
+    document.getElementById("zm_progress").style.display = "";
+}
+
+function _update_progress(xfer) {
+    var total_in = xfer.get_offset();
+
+    document.getElementById("bytes_received").textContent = total_in;
+
+    var percent_received = 100 * total_in / xfer.get_details().size;
+    document.getElementById("percent_received").textContent = percent_received.toFixed(2);
+}
+
+function _hide_progress() {
+    document.getElementById("zm_progress").style.display = "none";
+}
+
+var start_form = document.getElementById("zm_start");
+
+function _auto_zmodem() {
+    return document.getElementById("zmodem-auto").checked;
+}
+
+// END UI STUFF
+//----------------------------------------------------------------------
+
+function _handle_receive_session(zsession) {
+    zsession.on("offer", function(xfer) {
+        current_receive_xfer = xfer;
+
+        _show_file_info(xfer);
+
+        var offer_form = document.getElementById("zm_offer");
+
+        function on_form_submit() {
+            offer_form.style.display = "none";
+
+            //START
+            //if (offer_form.zmaccept.value) {
+            if (_auto_zmodem() || document.getElementById("zmaccept_yes").checked) {
+                _show_progress();
+
+                var FILE_BUFFER = [];
+                xfer.on("input", (payload) => {
+                    _update_progress(xfer);
+                    FILE_BUFFER.push( new Uint8Array(payload) );
+                });
+                xfer.accept().then(
+                    () => {
+                        _save_to_disk(xfer, FILE_BUFFER);
+                    },
+                    console.error.bind(console)
+                );
+            }
+            else {
+                xfer.skip();
+            }
+            //END
+        }
+
+        if (_auto_zmodem()) {
+            on_form_submit();
+        }
+        else {
+            offer_form.onsubmit = on_form_submit;
+            offer_form.style.display = "";
+        }
+    } );
+
+    var promise = new Promise( (res) => {
+        zsession.on("session_end", () => {
+            _hide_file_info();
+            _hide_progress();
+            res();
+        } );
+    } );
+
+    zsession.start();
+
+    return promise;
+}
+
+function _handle_send_session(zsession) {
+    var choose_form = document.getElementById("zm_choose");
+    choose_form.style.display = "";
+
+    var file_el = document.getElementById("zm_files");
+
+    var promise = new Promise( (res) => {
+        file_el.onchange = function(e) {
+            choose_form.style.display = "none";
+
+            var files_obj = file_el.files;
+
+            Zmodem.Browser.send_files(
+                zsession,
+                files_obj,
+                {
+                    on_offer_response(obj, xfer) {
+                        if (xfer) _show_progress();
+                        //console.log("offer", xfer ? "accepted" : "skipped");
+                    },
+                    on_progress(obj, xfer) {
+                        _update_progress(xfer);
+                    },
+                    on_file_complete(obj) {
+                        //console.log("COMPLETE", obj);
+                        _hide_progress();
+                    },
+                }
+            ).then(_hide_progress).then(
+                zsession.close.bind(zsession),
+                console.error.bind(console)
+            ).then( () => {
+                _hide_file_info();
+                _hide_progress();
+                res();
+            } );
+        };
+    } );
+
+    return promise;
+}
+
+//This is here to allow canceling of an in-progress ZMODEM transfer.
+var current_receive_xfer;
+
+//Called from HTML directly.
+function skip_current_file() {
+    current_receive_xfer.skip();
+
+    skipper_button.disabled = true;
+    skipper_button.textContent = "Waiting for server to acknowledge skip …";
+}
+
+function runRealTerminal() {
+    term.attach(socket);
+
+    term._initialized = true;
+}
+
+function runFakeTerminal() {
+  if (term._initialized) {
+    return;
+  }
+
+  term._initialized = true;
+
+  var shellprompt = '$ ';
+
+  term.prompt = function () {
+    term.write('\r\n' + shellprompt);
+  };
+
+  term.writeln('Welcome to xterm.js');
+  term.writeln('This is a local terminal emulation, without a real terminal in the back-end.');
+  term.writeln('Type some keys and commands to play around.');
+  term.writeln('');
+  term.prompt();
+
+  term.on('key', function (key, ev) {
+    var printable = (
+      !ev.altKey && !ev.altGraphKey && !ev.ctrlKey && !ev.metaKey
+    );
+
+    if (ev.keyCode == 13) {
+      term.prompt();
+    } else if (ev.keyCode == 8) {
+     // Do not delete the prompt
+      if (term.x > 2) {
+        term.write('\b \b');
+      }
+    } else if (printable) {
+      term.write(key);
+    }
+  });
+
+  term.on('paste', function (data, ev) {
+    term.write(data);
+  });
+}

dist/addons/attach/attach.js

@@ -1,126 +0,0 @@
-/**
- * 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;
-});

dist/addons/fit/fit.js

@@ -1,86 +0,0 @@
-/**
- * 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) {
-    if (!term.element.parentElement) {
-      return null;
-    }
-    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 = subjectRow.getBoundingClientRect().height;
-    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);
-
-    if (geometry) {
-      term.resize(geometry.cols, geometry.rows);
-    }
-  };
-
-  Xterm.prototype.proposeGeometry = function () {
-    return exports.proposeGeometry(this);
-  };
-
-  Xterm.prototype.fit = function () {
-    return exports.fit(this);
-  };
-
-  return exports;
-});

dist/addons/fullscreen/fullscreen.css

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

dist/addons/fullscreen/fullscreen.js

@@ -1,50 +0,0 @@
-/**
- * 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;
-});

dist/addons/linkify/linkify.js

@@ -1,207 +0,0 @@
-/**
- * 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;
-});

dist/addons/terminado/terminado.js

@@ -1,135 +0,0 @@
-/**
- * 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;
-});

docker-compose.yaml

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

docker-compose.yml

@@ -0,0 +1,17 @@
+version: "3"
+
+services:
+  web:
+    image: xtermjs/xterm.js:latest
+    build: .
+    volumes:
+      - ./:/usr/src/app
+    ports:
+      - ${XTERMJS_PORT:3000}:3000
+    command: ["npm", "start"]
+
+  watch:
+    build: .
+    volumes:
+      - ./:/usr/src/app
+    command: ["npm", "run", "watch"]