Bump version to 2.2.3

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

.gitignore

@@ -1,7 +1,7 @@
 node_modules/
 *.swp
 .lock-wscript
-out/
+lib/
 Makefile.gyp
 *.Makefile
 *.target.gyp.mk

.npmignore

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

.travis.yml

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

AUTHORS

@@ -8,7 +8,9 @@ Anton Yurovskykh <anton.yurovskykh@gmail.com>
 Austin Robertson <austinrobertson@gmail.com>
 ayapi <colors.aya@gmail.com>
 Benjamin Fischer <benjamin.fischer@rwth-aachen.de>
+bottleofwater <nison.mael+bottleofwater@gmail.com>
 Carson Anderson <carson@betterservers.com>
+Christian Budde Christensen <budde377@gmail.com>
 Christopher Jeffrey <chjjeffrey@gmail.com>
 Daniel Imms <daimms@microsoft.com>
 Daniel Risacher <drisacher@gmail.com>
@@ -20,6 +22,7 @@ Ian Lewis <ianlewis@google.com>
 imoses <ido@twiggle.com>
 Jean Bruenn <himself@jeanbruenn.info>
 Jörg Breitbart <jerch@rockborn.de>
+Maël Nison <nison.mael@gmail.com>
 Mikko Karvonen <mikko.karvonen@arm.com>
 Paris Kasidiaris <pariskasidiaris@gmail.com>
 Paris Kasidiaris <paris@sourcelair.com>

bin/build

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

bower.json

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

dist/addons/attach/attach.js

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

dist/addons/fit/fit.js

@@ -0,0 +1,59 @@
+/**
+ * Fit terminal columns and rows to the dimensions of its DOM element.
+ *
+ * ## Approach
+ * - Rows: Truncate the division of the terminal parent element height by the terminal row height.
+ *
+ * - Columns: Truncate the division of the terminal parent element width by the terminal character
+ * width (apply display: inline at the terminal row and truncate its width with the current
+ * number of columns).
+ * @module xterm/addons/fit/fit
+ * @license MIT
+ */
+(function (fit) {
+    if (typeof exports === 'object' && typeof module === 'object') {
+        /*
+         * CommonJS environment
+         */
+        module.exports = fit(require('../../xterm'));
+    }
+    else if (typeof define == 'function') {
+        /*
+         * Require.js is available
+         */
+        define(['../../xterm'], fit);
+    }
+    else {
+        /*
+         * Plain browser environment
+         */
+        fit(window.Terminal);
+    }
+})(function (Xterm) {
+    var exports = {};
+    exports.proposeGeometry = function (term) {
+        var parentElementStyle = window.getComputedStyle(term.element.parentElement), parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height')), parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')) - 17), elementStyle = window.getComputedStyle(term.element), elementPaddingVer = parseInt(elementStyle.getPropertyValue('padding-top')) + parseInt(elementStyle.getPropertyValue('padding-bottom')), elementPaddingHor = parseInt(elementStyle.getPropertyValue('padding-right')) + parseInt(elementStyle.getPropertyValue('padding-left')), availableHeight = parentElementHeight - elementPaddingVer, availableWidth = parentElementWidth - elementPaddingHor, container = term.rowContainer, subjectRow = term.rowContainer.firstElementChild, contentBuffer = subjectRow.innerHTML, characterHeight, rows, characterWidth, cols, geometry;
+        subjectRow.style.display = 'inline';
+        subjectRow.innerHTML = 'W'; // Common character for measuring width, although on monospace
+        characterWidth = subjectRow.getBoundingClientRect().width;
+        subjectRow.style.display = ''; // Revert style before calculating height, since they differ.
+        characterHeight = parseInt(subjectRow.offsetHeight);
+        subjectRow.innerHTML = contentBuffer;
+        rows = parseInt(availableHeight / characterHeight);
+        cols = parseInt(availableWidth / characterWidth);
+        geometry = { cols: cols, rows: rows };
+        return geometry;
+    };
+    exports.fit = function (term) {
+        var geometry = exports.proposeGeometry(term);
+        term.resize(geometry.cols, geometry.rows);
+    };
+    Xterm.prototype.proposeGeometry = function () {
+        return exports.proposeGeometry(this);
+    };
+    Xterm.prototype.fit = function () {
+        return exports.fit(this);
+    };
+    return exports;
+});
+//# sourceMappingURL=fit.js.map

dist/addons/fullscreen/fullscreen.css

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

dist/addons/fullscreen/fullscreen.js

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

dist/addons/linkify/linkify.js

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

dist/addons/terminado/terminado.js

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

dist/xterm.js

@@ -451,15 +451,15 @@ exports.pasteHandler = pasteHandler;
  * area, then bring the terminal's input below the cursor, in order to
  * trigger the event on the textarea and allow-right click paste, without
  * caring about disappearing selection.
- * @param {ClipboardEvent} ev The original paste event to be handled
+ * @param {MouseEvent} ev The original right click event to be handled
  * @param {Terminal} term The terminal on which to apply the handled paste event
  */
 function rightClickHandler(ev, term) {
     var s = document.getSelection(), selectedText = prepareTextForClipboard(s.toString()), clickIsOnSelection = false, x = ev.clientX, y = ev.clientY;
     if (s.rangeCount) {
-        var r = s.getRangeAt(0), cr = r.getClientRects(), i = void 0, rect = void 0;
-        for (i = 0; i < cr.length; i++) {
-            rect = cr[i];
+        var r = s.getRangeAt(0), cr = r.getClientRects();
+        for (var i = 0; i < cr.length; i++) {
+            var rect = cr[i];
             clickIsOnSelection = ((x > rect.left) && (x < rect.right) &&
                 (y > rect.top) && (y < rect.bottom));
             if (clickIsOnSelection) {
@@ -894,6 +894,9 @@ Terminal.prototype.initGlobal = function () {
     on(this.textarea, 'paste', function (ev) {
         Clipboard_js_1.pasteHandler.call(this, ev, term);
     });
+    on(this.element, 'paste', function (ev) {
+        Clipboard_js_1.pasteHandler.call(this, ev, term);
+    });
     function rightClickHandlerWrapper(ev) {
         Clipboard_js_1.rightClickHandler.call(this, ev, term);
     }
@@ -1211,7 +1214,7 @@ Terminal.prototype.bindMouse = function () {
             pos.x -= 32;
             pos.y -= 32;
             self.send('\x1b[<'
-                + ((button & 3) === 3 ? button & ~3 : button)
+                + (((button & 3) === 3 ? button & ~3 : button) - 32)
                 + ';'
                 + pos.x
                 + ';'

package.json

@@ -1,14 +1,36 @@
 {
   "name": "xterm",
-  "version": "2.2.0",
+  "version": "2.2.3",
   "ignore": [
     "demo",
     "test",
     ".gitignore"
   ],
-  "main": "dist/xterm.js",
+  "main": "lib/xterm.js",
   "repository": "https://github.com/sourcelair/xterm.js",
   "license": "MIT",
+  "files": [
+    "dist/*.css",
+    "dist/**/*.css",
+    "dist/*.js",
+    "dist/*.js.map",
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "lib/*.css",
+    "lib/**/*.css",
+    "lib/*.js",
+    "lib/*.js.map",
+    "lib/**/*.js",
+    "lib/**/*.js.map",
+    "src/*.css",
+    "src/**/*.css",
+    "src/*.js",
+    "src/*.js.map",
+    "src/*.ts",
+    "src/**/*.js",
+    "src/**/*.js.map",
+    "src/**/*.ts"
+  ],
   "devDependencies": {
     "@types/chai": "^3.4.34",
     "@types/mocha": "^2.2.33",
@@ -26,12 +48,15 @@
     "pty.js": "0.3.1",
     "sleep": "^3.0.1",
     "sorcery": "^0.10.0",
+    "tslint": "^4.0.2",
     "typescript": "^2.0.3"
   },
   "scripts": {
     "start": "nodemon --watch src --watch addons --watch demo --exec bash -c './bin/build && node demo/app'",
-    "test": "./bin/build && mocha --recursive ./out",
+    "lint": "tslint src/**/*.ts",
+    "test": "mocha --recursive ./lib",
     "build:docs": "jsdoc -c jsdoc.json",
-    "build": "./bin/build"
+    "build": "./bin/build",
+    "prepublish": "tsc"
   }
 }

src/addons/fit/fit.js

@@ -34,7 +34,7 @@
   exports.proposeGeometry = function (term) {
     var parentElementStyle = window.getComputedStyle(term.element.parentElement),
         parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height')),
-        parentElementWidth = parseInt(parentElementStyle.getPropertyValue('width')),
+        parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')) - 17),
         elementStyle = window.getComputedStyle(term.element),
         elementPaddingVer = parseInt(elementStyle.getPropertyValue('padding-top')) + parseInt(elementStyle.getPropertyValue('padding-bottom')),
         elementPaddingHor = parseInt(elementStyle.getPropertyValue('padding-right')) + parseInt(elementStyle.getPropertyValue('padding-left')),
@@ -57,7 +57,7 @@
     subjectRow.innerHTML = contentBuffer;
 
     rows = parseInt(availableHeight / characterHeight);
-    cols = parseInt(availableWidth / characterWidth) - 1;
+    cols = parseInt(availableWidth / characterWidth);
 
     geometry = {cols: cols, rows: rows};
     return geometry;

src/handlers/Clipboard.test.ts

@@ -5,7 +5,7 @@ import * as Clipboard from './Clipboard';
 
 describe('evaluateCopiedTextProcessing', function () {
   it('should strip trailing whitespaces and replace nbsps with spaces', function () {
-    var nonBreakingSpace = String.fromCharCode(160),
+    let nonBreakingSpace = String.fromCharCode(160),
         copiedText = 'echo' + nonBreakingSpace + 'hello' + nonBreakingSpace,
         processedText = Clipboard.prepareTextForClipboard(copiedText);
 

src/handlers/Clipboard.ts

@@ -7,13 +7,6 @@
 
 import { ITerminal } from '../Interfaces';
 
-// We are extending the ClipboardEvent interface, since TypeScript has not declared the
-// clientX and clientY properties that we use.
-interface IClipboardEvent extends ClipboardEvent {
-  clientX: number;
-  clientY: number;
-}
-
 interface IWindow extends Window {
   clipboardData?: {
     getData(format: string): string;
@@ -49,7 +42,7 @@ export function prepareTextForClipboard(text: string): string {
  * Binds copy functionality to the given terminal.
  * @param {ClipboardEvent} ev The original copy event to be handled
  */
-export function copyHandler(ev: IClipboardEvent, term: ITerminal) {
+export function copyHandler(ev: ClipboardEvent, term: ITerminal) {
   // We cast `window` to `any` type, because TypeScript has not declared the `clipboardData`
   // property that we use below for Internet Explorer.
   let copiedText = window.getSelection().toString(),
@@ -69,7 +62,7 @@ export function copyHandler(ev: IClipboardEvent, term: ITerminal) {
  * @param {ClipboardEvent} ev The original paste event to be handled
  * @param {Terminal} term The terminal on which to apply the handled paste event
  */
-export function pasteHandler(ev: IClipboardEvent, term: ITerminal) {
+export function pasteHandler(ev: ClipboardEvent, term: ITerminal) {
   ev.stopPropagation();
 
   let text: string;
@@ -103,10 +96,10 @@ export function pasteHandler(ev: IClipboardEvent, term: ITerminal) {
  * area, then bring the terminal's input below the cursor, in order to
  * trigger the event on the textarea and allow-right click paste, without
  * caring about disappearing selection.
- * @param {ClipboardEvent} ev The original paste event to be handled
+ * @param {MouseEvent} ev The original right click event to be handled
  * @param {Terminal} term The terminal on which to apply the handled paste event
  */
-export function rightClickHandler(ev: IClipboardEvent, term: ITerminal) {
+export function rightClickHandler(ev: MouseEvent, term: ITerminal) {
   let s = document.getSelection(),
       selectedText = prepareTextForClipboard(s.toString()),
       clickIsOnSelection = false,
@@ -115,11 +108,11 @@ export function rightClickHandler(ev: IClipboardEvent, term: ITerminal) {
 
   if (s.rangeCount) {
     let r = s.getRangeAt(0),
-        cr = r.getClientRects(),
-        i, rect;
+        cr = r.getClientRects();
+
+    for (let i = 0; i < cr.length; i++) {
+      let rect = cr[i];
 
-    for (i=0; i<cr.length; i++) {
-      rect = cr[i];
       clickIsOnSelection = (
         (x > rect.left) && (x < rect.right) &&
         (y > rect.top) && (y < rect.bottom)

src/xterm.js

@@ -433,6 +433,9 @@ Terminal.prototype.initGlobal = function() {
   on(this.textarea, 'paste', function (ev) {
     pasteHandler.call(this, ev, term);
   });
+  on(this.element, 'paste', function (ev) {
+    pasteHandler.call(this, ev, term);
+  });
 
   function rightClickHandlerWrapper (ev) {
     rightClickHandler.call(this, ev, term);
@@ -785,7 +788,7 @@ Terminal.prototype.bindMouse = function() {
       pos.x -= 32;
       pos.y -= 32;
       self.send('\x1b[<'
-                + ((button & 3) === 3 ? button & ~3 : button)
+                + (((button & 3) === 3 ? button & ~3 : button) - 32)
                 + ';'
                 + pos.x
                 + ';'

tsconfig.json

@@ -4,7 +4,7 @@
     "target": "es5",
     "rootDir": "src",
     "allowJs": true,
-    "outDir": "out",
+    "outDir": "lib",
     "sourceMap": true
   },
   "exclude": [

tslint.json

@@ -0,0 +1,53 @@
+{
+  "rules": {
+    "class-name": true,
+    "comment-format": [
+      true,
+      "check-space"
+    ],
+    "indent": [
+      true,
+      "spaces"
+    ],
+    "eofline": true,
+    "no-eval": true,
+    "no-internal-module": true,
+    "no-trailing-whitespace": true,
+    "no-unsafe-finally": true,
+    "no-var-keyword": true,
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "semicolon": [
+      true,
+      "always"
+    ],
+    "triple-equals": [
+      true,
+      "allow-null-check"
+    ],
+    "typedef-whitespace": [
+      true,
+      {
+        "call-signature": "nospace",
+        "index-signature": "nospace",
+        "parameter": "nospace",
+        "property-declaration": "nospace",
+        "variable-declaration": "nospace"
+      }
+    ],
+    "variable-name": [
+      true,
+      "ban-keywords"
+    ],
+    "whitespace": [
+      true,
+      "check-branch",
+      "check-decl",
+      "check-operator",
+      "check-separator",
+      "check-type"
+    ]
+  }
+}