Bump version to 2.4.0

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

.gitignore

@@ -13,3 +13,6 @@ npm-debug.log
 .env
 build/
 .vscode/
+
+# Directories needed for code coverage
+/coverage/

.travis.yml

@@ -16,3 +16,4 @@ addons:
 notifications:
   email: false
 script: npm run $NPM_COMMAND
+after_success: npm run coveralls

AUTHORS

@@ -1,5 +1,6 @@
 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>
@@ -12,9 +13,11 @@ 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>
@@ -27,6 +30,7 @@ Jean Bruenn <himself@jeanbruenn.info>
 Jörg Breitbart <jerch@rockborn.de>
 Lucian Buzzo <lucian.buzzo@gmail.com>
 Maël Nison <nison.mael@gmail.com>
+Martin Wang <jiahaow@ca.ibm.com>
 Mikko Karvonen <mikko.karvonen@arm.com>
 Paris Kasidiaris <pariskasidiaris@gmail.com>
 Paris Kasidiaris <paris@sourcelair.com>

README.md

@@ -1,6 +1,6 @@
 # xterm.js
 
-[![xterm.js build status](https://api.travis-ci.org/sourcelair/xterm.js.svg)](https://travis-ci.org/sourcelair/xterm.js) [![Gitter](https://badges.gitter.im/sourcelair/xterm.js.svg)](https://gitter.im/sourcelair/xterm.js?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![xterm.js 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)
 
 Xterm.js is a terminal front-end component written in JavaScript that works in the browser.
 
@@ -48,14 +48,29 @@ Xterm.js works seamlessly in Electron apps and may even work on earlier versions
 
 ## Demo
 
-To launch the demo simply run:
+### Linux or macOS
+
+Run the following commands:
 
 ```
-npm install
-npm start
+$ npm install
+$ npm start
 ```
 
-Then open http://0.0.0.0:3000 in a web browser (use http://127.0.0.1:3000 if running under Windows).
+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
 
@@ -77,7 +92,7 @@ To start using xterm.js on your browser, add the `xterm.js` and `xterm.css` to t
     </body>
   </html>
 ```
-Finally instantiate the `Terminal` object and then call the `open` function with the DOM object of the `div`.  
+Finally instantiate the `Terminal` object and then call the `open` function with the DOM object of the `div`.
 
 ## Addons
 

bower.json

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

demo/app.js

@@ -69,7 +69,7 @@ app.ws('/terminals/:pid', function (ws, req) {
     term.write(msg);
   });
   ws.on('close', function () {
-    process.kill(term.pid);
+    term.kill();
     console.log('Closed terminal ' + term.pid);
     // Clean things up
     delete terminals[term.pid];

dist/addons/fit/fit.js

@@ -32,6 +32,9 @@
   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),
@@ -66,7 +69,9 @@
   exports.fit = function (term) {
     var geometry = exports.proposeGeometry(term);
 
-    term.resize(geometry.cols, geometry.rows);
+    if (geometry) {
+      term.resize(geometry.cols, geometry.rows);
+    }
   };
 
   Xterm.prototype.proposeGeometry = function () {

dist/xterm.css

@@ -71,6 +71,21 @@
     resize: none;
 }
 
+.terminal a {
+    color: inherit;
+    text-decoration: none;
+}
+
+.terminal a:hover {
+    cursor: pointer;
+    text-decoration: underline;
+}
+
+.terminal a.xterm-invalid-link:hover {
+    cursor: text;
+    text-decoration: none;
+}
+
 .terminal:not(.xterm-cursor-style-underline):not(.xterm-cursor-style-bar) .terminal-cursor {
     background-color: #fff;
     color: #000;
@@ -87,13 +102,10 @@
 }
 
 @keyframes xterm-cursor-blink {
-    0% {
-        background-color: #fff;
-        color: #000;
-    }
+    0% { }
     50% {
         background-color: transparent;
-        color: #FFF;
+        color: inherit;
     }
 }
 

dist/xterm.js

@@ -158,6 +158,8 @@ exports.CHARSETS['='] = {
     '~': 'û'
 };
 
+
+
 },{}],2:[function(require,module,exports){
 "use strict";
 var CompositionHelper = (function () {
@@ -282,6 +284,8 @@ var CompositionHelper = (function () {
 }());
 exports.CompositionHelper = CompositionHelper;
 
+
+
 },{}],3:[function(require,module,exports){
 "use strict";
 var C0;
@@ -323,6 +327,8 @@ var C0;
 })(C0 = exports.C0 || (exports.C0 = {}));
 ;
 
+
+
 },{}],4:[function(require,module,exports){
 "use strict";
 ;
@@ -378,6 +384,8 @@ var EventEmitter = (function () {
 }());
 exports.EventEmitter = EventEmitter;
 
+
+
 },{}],5:[function(require,module,exports){
 "use strict";
 var EscapeSequences_1 = require("./EscapeSequences");
@@ -1155,7 +1163,7 @@ var InputHandler = (function () {
         this._terminal.cursorHidden = false;
         this._terminal.insertMode = false;
         this._terminal.originMode = false;
-        this._terminal.wraparoundMode = false;
+        this._terminal.wraparoundMode = true;
         this._terminal.applicationKeypad = false;
         this._terminal.viewport.syncScrollArea();
         this._terminal.applicationCursor = false;
@@ -1302,8 +1310,218 @@ var wcwidth = (function (opts) {
     return wcwidth;
 })({ nul: 0, control: 0 });
 
+
+
 },{"./Charsets":1,"./EscapeSequences":3}],6:[function(require,module,exports){
 "use strict";
+var INVALID_LINK_CLASS = 'xterm-invalid-link';
+var protocolClause = '(https?:\\/\\/)';
+var domainCharacterSet = '[\\da-z\\.-]+';
+var negatedDomainCharacterSet = '[^\\da-z\\.-]+';
+var domainBodyClause = '(' + domainCharacterSet + ')';
+var tldClause = '([a-z\\.]{2,6})';
+var ipClause = '((\\d{1,3}\\.){3}\\d{1,3})';
+var localHostClause = '(localhost)';
+var portClause = '(:\\d{1,5})';
+var hostClause = '((' + domainBodyClause + '\\.' + tldClause + ')|' + ipClause + '|' + localHostClause + ')' + portClause + '?';
+var pathClause = '(\\/[\\/\\w\\.\\-%]*)*';
+var queryStringHashFragmentCharacterSet = '[0-9\\w\\[\\]\\(\\)\\/\\?\\!#@$%&\'*+,:;\\=\\.\\-]*';
+var queryStringClause = '(\\?' + queryStringHashFragmentCharacterSet + ')?';
+var hashFragmentClause = '(#' + queryStringHashFragmentCharacterSet + ')?';
+var negatedPathCharacterSet = '[^\\/\\w\\.\\-%]+';
+var bodyClause = hostClause + pathClause + queryStringClause + hashFragmentClause;
+var start = '(?:^|' + negatedDomainCharacterSet + ')(';
+var end = ')($|' + negatedPathCharacterSet + ')';
+var strictUrlRegex = new RegExp(start + protocolClause + bodyClause + end);
+var HYPERTEXT_LINK_MATCHER_ID = 0;
+var Linkifier = (function () {
+    function Linkifier(document, rows) {
+        this._nextLinkMatcherId = HYPERTEXT_LINK_MATCHER_ID;
+        this._document = document;
+        this._rows = rows;
+        this._rowTimeoutIds = [];
+        this._linkMatchers = [];
+        this.registerLinkMatcher(strictUrlRegex, null, { matchIndex: 1 });
+    }
+    Linkifier.prototype.linkifyRow = function (rowIndex) {
+        var timeoutId = this._rowTimeoutIds[rowIndex];
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        this._rowTimeoutIds[rowIndex] = setTimeout(this._linkifyRow.bind(this, rowIndex), Linkifier.TIME_BEFORE_LINKIFY);
+    };
+    Linkifier.prototype.attachHypertextLinkHandler = function (handler) {
+        this._linkMatchers[HYPERTEXT_LINK_MATCHER_ID].handler = handler;
+    };
+    Linkifier.prototype.registerLinkMatcher = function (regex, handler, options) {
+        if (options === void 0) { options = {}; }
+        if (this._nextLinkMatcherId !== HYPERTEXT_LINK_MATCHER_ID && !handler) {
+            throw new Error('handler must be defined');
+        }
+        var matcher = {
+            id: this._nextLinkMatcherId++,
+            regex: regex,
+            handler: handler,
+            matchIndex: options.matchIndex,
+            validationCallback: options.validationCallback,
+            priority: options.priority || 0
+        };
+        this._addLinkMatcherToList(matcher);
+        return matcher.id;
+    };
+    Linkifier.prototype._addLinkMatcherToList = function (matcher) {
+        if (this._linkMatchers.length === 0) {
+            this._linkMatchers.push(matcher);
+            return;
+        }
+        for (var i = this._linkMatchers.length - 1; i >= 0; i--) {
+            if (matcher.priority <= this._linkMatchers[i].priority) {
+                this._linkMatchers.splice(i + 1, 0, matcher);
+                return;
+            }
+        }
+        this._linkMatchers.splice(0, 0, matcher);
+    };
+    Linkifier.prototype.deregisterLinkMatcher = function (matcherId) {
+        for (var i = 1; i < this._linkMatchers.length; i++) {
+            if (this._linkMatchers[i].id === matcherId) {
+                this._linkMatchers.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+    };
+    Linkifier.prototype._linkifyRow = function (rowIndex) {
+        var row = this._rows[rowIndex];
+        if (!row) {
+            return;
+        }
+        var text = row.textContent;
+        var _loop_1 = function (i) {
+            var matcher = this_1._linkMatchers[i];
+            var uri = this_1._findLinkMatch(text, matcher.regex, matcher.matchIndex);
+            if (uri) {
+                var linkElement_1 = this_1._doLinkifyRow(rowIndex, uri, matcher.handler, matcher.id === HYPERTEXT_LINK_MATCHER_ID);
+                if (linkElement_1 && matcher.validationCallback) {
+                    matcher.validationCallback(uri, function (isValid) {
+                        if (!isValid) {
+                            linkElement_1.classList.add(INVALID_LINK_CLASS);
+                        }
+                    });
+                }
+                return { value: void 0 };
+            }
+        };
+        var this_1 = this;
+        for (var i = 0; i < this._linkMatchers.length; i++) {
+            var state_1 = _loop_1(i);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+    };
+    Linkifier.prototype._doLinkifyRow = function (rowIndex, uri, handler, isHttpLinkMatcher) {
+        var nodes = this._rows[rowIndex].childNodes;
+        for (var i = 0; i < nodes.length; i++) {
+            var node = nodes[i];
+            var searchIndex = node.textContent.indexOf(uri);
+            if (searchIndex >= 0) {
+                var linkElement = this._createAnchorElement(uri, handler, isHttpLinkMatcher);
+                if (node.textContent.length === uri.length) {
+                    if (node.nodeType === 3) {
+                        this._replaceNode(node, linkElement);
+                    }
+                    else {
+                        var element = node;
+                        if (element.nodeName === 'A') {
+                            return;
+                        }
+                        element.innerHTML = '';
+                        element.appendChild(linkElement);
+                    }
+                }
+                else {
+                    this._replaceNodeSubstringWithNode(node, linkElement, uri, searchIndex);
+                }
+                return linkElement;
+            }
+        }
+    };
+    Linkifier.prototype._findLinkMatch = function (text, regex, matchIndex) {
+        var match = text.match(regex);
+        if (!match || match.length === 0) {
+            return null;
+        }
+        return match[typeof matchIndex !== 'number' ? 0 : matchIndex];
+    };
+    Linkifier.prototype._createAnchorElement = function (uri, handler, isHypertextLinkHandler) {
+        var element = this._document.createElement('a');
+        element.textContent = uri;
+        if (isHypertextLinkHandler) {
+            element.href = uri;
+            element.target = '_blank';
+            element.addEventListener('click', function (event) {
+                if (handler) {
+                    return handler(event, uri);
+                }
+            });
+        }
+        else {
+            element.addEventListener('click', function (event) {
+                if (element.classList.contains(INVALID_LINK_CLASS)) {
+                    return;
+                }
+                return handler(event, uri);
+            });
+        }
+        return element;
+    };
+    Linkifier.prototype._replaceNode = function (oldNode) {
+        var newNodes = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            newNodes[_i - 1] = arguments[_i];
+        }
+        var parent = oldNode.parentNode;
+        for (var i = 0; i < newNodes.length; i++) {
+            parent.insertBefore(newNodes[i], oldNode);
+        }
+        parent.removeChild(oldNode);
+    };
+    Linkifier.prototype._replaceNodeSubstringWithNode = function (targetNode, newNode, substring, substringIndex) {
+        var node = targetNode;
+        if (node.nodeType !== 3) {
+            node = node.childNodes[0];
+        }
+        if (node.childNodes.length === 0 && node.nodeType !== Node.TEXT_NODE) {
+            throw new Error('targetNode must be a text node or only contain a single text node');
+        }
+        var fullText = node.textContent;
+        if (substringIndex === 0) {
+            var rightText = fullText.substring(substring.length);
+            var rightTextNode = this._document.createTextNode(rightText);
+            this._replaceNode(node, newNode, rightTextNode);
+        }
+        else if (substringIndex === targetNode.textContent.length - substring.length) {
+            var leftText = fullText.substring(0, substringIndex);
+            var leftTextNode = this._document.createTextNode(leftText);
+            this._replaceNode(node, leftTextNode, newNode);
+        }
+        else {
+            var leftText = fullText.substring(0, substringIndex);
+            var leftTextNode = this._document.createTextNode(leftText);
+            var rightText = fullText.substring(substringIndex + substring.length);
+            var rightTextNode = this._document.createTextNode(rightText);
+            this._replaceNode(node, leftTextNode, newNode, rightTextNode);
+        }
+    };
+    return Linkifier;
+}());
+Linkifier.TIME_BEFORE_LINKIFY = 200;
+exports.Linkifier = Linkifier;
+
+
+
+},{}],7:[function(require,module,exports){
+"use strict";
 var EscapeSequences_1 = require("./EscapeSequences");
 var Charsets_1 = require("./Charsets");
 var normalStateHandler = {};
@@ -1775,7 +1993,9 @@ var Parser = (function () {
 }());
 exports.Parser = Parser;
 
-},{"./Charsets":1,"./EscapeSequences":3}],7:[function(require,module,exports){
+
+
+},{"./Charsets":1,"./EscapeSequences":3}],8:[function(require,module,exports){
 "use strict";
 var MAX_REFRESH_FRAME_SKIP = 5;
 var FLAGS;
@@ -1984,10 +2204,13 @@ function checkBoldBroken(document) {
     return w1 !== w2;
 }
 
-},{}],8:[function(require,module,exports){
+
+
+},{}],9:[function(require,module,exports){
 "use strict";
 var Viewport = (function () {
     function Viewport(terminal, viewportElement, scrollArea, charMeasure) {
+        var _this = this;
         this.terminal = terminal;
         this.viewportElement = viewportElement;
         this.scrollArea = scrollArea;
@@ -1998,7 +2221,7 @@ var Viewport = (function () {
         this.terminal.on('scroll', this.syncScrollArea.bind(this));
         this.terminal.on('resize', this.syncScrollArea.bind(this));
         this.viewportElement.addEventListener('scroll', this.onScroll.bind(this));
-        this.syncScrollArea();
+        setTimeout(function () { return _this.syncScrollArea(); }, 0);
     }
     Viewport.prototype.refresh = function () {
         if (this.charMeasure.height > 0) {
@@ -2058,7 +2281,9 @@ var Viewport = (function () {
 }());
 exports.Viewport = Viewport;
 
-},{}],9:[function(require,module,exports){
+
+
+},{}],10:[function(require,module,exports){
 "use strict";
 function prepareTextForClipboard(text) {
     var space = String.fromCharCode(32), nonBreakingSpace = String.fromCharCode(160), allNonBreakingSpaces = new RegExp(nonBreakingSpace, 'g'), processedText = text.split('\n').map(function (line) {
@@ -2137,7 +2362,9 @@ function rightClickHandler(ev, term) {
 }
 exports.rightClickHandler = rightClickHandler;
 
-},{}],10:[function(require,module,exports){
+
+
+},{}],11:[function(require,module,exports){
 "use strict";
 var Generic_1 = require("./Generic");
 var isNode = (typeof navigator === 'undefined') ? true : false;
@@ -2150,20 +2377,21 @@ exports.isIpad = platform === 'iPad';
 exports.isIphone = platform === 'iPhone';
 exports.isMSWindows = Generic_1.contains(['Windows', 'Win16', 'Win32', 'WinCE'], platform);
 
-},{"./Generic":13}],11:[function(require,module,exports){
+
+
+},{"./Generic":14}],12:[function(require,module,exports){
 "use strict";
 var __extends = (this && this.__extends) || function (d, b) {
-    for (var p in b)
-        if (b.hasOwnProperty(p))
-            d[p] = b[p];
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
 var EventEmitter_js_1 = require("../EventEmitter.js");
 var CharMeasure = (function (_super) {
     __extends(CharMeasure, _super);
-    function CharMeasure(parentElement) {
+    function CharMeasure(document, parentElement) {
         var _this = _super.call(this) || this;
+        _this._document = document;
         _this._parentElement = parentElement;
         return _this;
     }
@@ -2184,11 +2412,12 @@ var CharMeasure = (function (_super) {
     CharMeasure.prototype.measure = function () {
         var _this = this;
         if (!this._measureElement) {
-            this._measureElement = document.createElement('span');
+            this._measureElement = this._document.createElement('span');
             this._measureElement.style.position = 'absolute';
             this._measureElement.style.top = '0';
             this._measureElement.style.left = '-9999em';
             this._measureElement.textContent = 'W';
+            this._measureElement.setAttribute('aria-hidden', 'true');
             this._parentElement.appendChild(this._measureElement);
             setTimeout(function () { return _this._doMeasure(); }, 0);
         }
@@ -2211,7 +2440,9 @@ var CharMeasure = (function (_super) {
 }(EventEmitter_js_1.EventEmitter));
 exports.CharMeasure = CharMeasure;
 
-},{"../EventEmitter.js":4}],12:[function(require,module,exports){
+
+
+},{"../EventEmitter.js":4}],13:[function(require,module,exports){
 "use strict";
 var CircularList = (function () {
     function CircularList(maxLength) {
@@ -2347,7 +2578,9 @@ var CircularList = (function () {
 }());
 exports.CircularList = CircularList;
 
-},{}],13:[function(require,module,exports){
+
+
+},{}],14:[function(require,module,exports){
 "use strict";
 function contains(arr, el) {
     return arr.indexOf(el) >= 0;
@@ -2355,7 +2588,9 @@ function contains(arr, el) {
 exports.contains = contains;
 ;
 
-},{}],14:[function(require,module,exports){
+
+
+},{}],15:[function(require,module,exports){
 "use strict";
 var CompositionHelper_1 = require("./CompositionHelper");
 var EventEmitter_1 = require("./EventEmitter");
@@ -2366,6 +2601,7 @@ var EscapeSequences_1 = require("./EscapeSequences");
 var InputHandler_1 = require("./InputHandler");
 var Parser_1 = require("./Parser");
 var Renderer_1 = require("./Renderer");
+var Linkifier_1 = require("./Linkifier");
 var CharMeasure_1 = require("./utils/CharMeasure");
 var Browser = require("./utils/Browser");
 var document = (typeof window != 'undefined') ? window.document : null;
@@ -2466,6 +2702,8 @@ function Terminal(options) {
     this.inputHandler = new InputHandler_1.InputHandler(this);
     this.parser = new Parser_1.Parser(this.inputHandler, this);
     this.renderer = this.renderer || null;
+    this.linkifier = this.linkifier || null;
+    ;
     this.writeBuffer = [];
     this.writeInProgress = false;
     this.xoffSentToCatchUp = false;
@@ -2690,6 +2928,9 @@ Terminal.bindKeys = function (term) {
     on(term.textarea, 'compositionupdate', term.compositionHelper.compositionupdate.bind(term.compositionHelper));
     on(term.textarea, 'compositionend', term.compositionHelper.compositionend.bind(term.compositionHelper));
     term.on('refresh', term.compositionHelper.updateCompositionElements.bind(term.compositionHelper));
+    term.on('refresh', function (data) {
+        term.queueLinkification(data.start, data.end);
+    });
 };
 Terminal.prototype.insertRow = function (row) {
     if (typeof row != 'object') {
@@ -2725,6 +2966,7 @@ Terminal.prototype.open = function (parent) {
     this.rowContainer.classList.add('xterm-rows');
     this.element.appendChild(this.rowContainer);
     this.children = [];
+    this.linkifier = new Linkifier_1.Linkifier(document, this.children);
     this.helperContainer = document.createElement('div');
     this.helperContainer.classList.add('xterm-helpers');
     this.element.appendChild(this.helperContainer);
@@ -2751,7 +2993,7 @@ Terminal.prototype.open = function (parent) {
         this.insertRow();
     }
     this.parent.appendChild(this.element);
-    this.charMeasure = new CharMeasure_1.CharMeasure(this.helperContainer);
+    this.charMeasure = new CharMeasure_1.CharMeasure(document, this.helperContainer);
     this.charMeasure.on('charsizechanged', function () {
         self.updateCharSizeCSS();
     });
@@ -2960,10 +3202,8 @@ Terminal.prototype.bindMouse = function () {
                 ? el.offsetParent
                 : el.parentNode;
         }
-        w = self.element.clientWidth;
-        h = self.element.clientHeight;
-        x = Math.ceil((x / w) * self.cols);
-        y = Math.ceil((y / h) * self.rows);
+        x = Math.ceil(x / self.charMeasure.width);
+        y = Math.ceil(y / self.charMeasure.height);
         if (x < 0)
             x = 0;
         if (x > self.cols)
@@ -3035,6 +3275,13 @@ Terminal.prototype.refresh = function (start, end) {
         this.renderer.queueRefresh(start, end);
     }
 };
+Terminal.prototype.queueLinkification = function (start, end) {
+    if (this.linkifier) {
+        for (var i = start; i <= end; i++) {
+            this.linkifier.linkifyRow(i);
+        }
+    }
+};
 Terminal.prototype.showCursor = function () {
     if (!this.cursorState) {
         this.cursorState = 1;
@@ -3148,6 +3395,27 @@ Terminal.prototype.writeln = function (data) {
 Terminal.prototype.attachCustomKeydownHandler = function (customKeydownHandler) {
     this.customKeydownHandler = customKeydownHandler;
 };
+Terminal.prototype.attachHypertextLinkHandler = function (handler) {
+    if (!this.linkifier) {
+        throw new Error('Cannot attach a hypertext link handler before Terminal.open is called');
+    }
+    this.linkifier.attachHypertextLinkHandler(handler);
+    this.refresh(0, this.rows - 1);
+};
+Terminal.prototype.registerLinkMatcher = function (regex, handler, options) {
+    if (this.linkifier) {
+        var matcherId = this.linkifier.registerLinkMatcher(regex, handler, options);
+        this.refresh(0, this.rows - 1);
+        return matcherId;
+    }
+};
+Terminal.prototype.deregisterLinkMatcher = function (matcherId) {
+    if (this.linkifier) {
+        if (this.linkifier.deregisterLinkMatcher(matcherId)) {
+            this.refresh(0, this.rows - 1);
+        }
+    }
+};
 Terminal.prototype.keyDown = function (ev) {
     if (this.customKeydownHandler && this.customKeydownHandler(ev) === false) {
         return false;
@@ -3865,6 +4133,8 @@ Terminal.off = off;
 Terminal.cancel = cancel;
 module.exports = Terminal;
 
-},{"./CompositionHelper":2,"./EscapeSequences":3,"./EventEmitter":4,"./InputHandler":5,"./Parser":6,"./Renderer":7,"./Viewport":8,"./handlers/Clipboard":9,"./utils/Browser":10,"./utils/CharMeasure":11,"./utils/CircularList":12}]},{},[14])(14)
+
+
+},{"./CompositionHelper":2,"./EscapeSequences":3,"./EventEmitter":4,"./InputHandler":5,"./Linkifier":6,"./Parser":7,"./Renderer":8,"./Viewport":9,"./handlers/Clipboard":10,"./utils/Browser":11,"./utils/CharMeasure":12,"./utils/CircularList":13}]},{},[15])(15)
 });
 //# sourceMappingURL=xterm.js.map

gulpfile.js

@@ -1,13 +1,15 @@
 const browserify = require('browserify');
 const buffer = require('vinyl-buffer');
+const coveralls = require('gulp-coveralls');
 const fs = require('fs-extra');
 const gulp = require('gulp');
+const istanbul = require('gulp-istanbul');
 const merge = require('merge-stream');
+const mocha = require('gulp-mocha');
 const sorcery = require('sorcery');
 const source = require('vinyl-source-stream');
 const sourcemaps = require('gulp-sourcemaps');
 const ts = require('gulp-typescript');
-const tsify = require('tsify');
 
 
 let buildDir = process.env.BUILD_DIR || 'build';
@@ -53,7 +55,6 @@ gulp.task('browserify', ['tsc'], function() {
     packageCache: {}
   };
   let bundleStream = browserify(browserifyOptions)
-        .plugin(tsify)
         .bundle()
         .pipe(source('xterm.js'))
         .pipe(buffer())
@@ -70,6 +71,19 @@ gulp.task('browserify', ['tsc'], function() {
   return merge(bundleStream, copyAddons, copyStylesheets);
 });
 
+gulp.task('instrument-test', function () {
+  return gulp.src(['lib/**/*.js'])
+    // Covering files
+    .pipe(istanbul())
+    // Force `require` to return covered files
+    .pipe(istanbul.hookRequire());
+});
+
+gulp.task('mocha', ['instrument-test'], function () {
+  return gulp.src(['lib/*test.js', 'lib/**/*test.js'], {read: false})
+      .pipe(mocha())
+      .pipe(istanbul.writeReports());
+});
 
 /**
  * Use `sorcery` to resolve the source map chain and point back to the TypeScript files.
@@ -82,6 +96,14 @@ gulp.task('sorcery', ['browserify'], function () {
   chain.writeSync();
 });
 
-gulp.task('build', ['sorcery']);
+/**
+ * Submit coverage results to coveralls.io
+ */
+gulp.task('coveralls', function () {
+  gulp.src('coverage/**/lcov.info')
+    .pipe(coveralls());
+});
 
+gulp.task('build', ['sorcery']);
+gulp.task('test', ['mocha']);
 gulp.task('default', ['build']);

package.json

@@ -1,7 +1,7 @@
 {
   "name": "xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "ignore": [
     "demo",
     "test",
@@ -36,6 +36,7 @@
   ],
   "devDependencies": {
     "@types/chai": "^3.4.34",
+    "@types/jsdom": "^2.0.30",
     "@types/mocha": "^2.2.33",
     "@types/node": "^6.0.41",
     "browserify": "^13.1.0",
@@ -47,18 +48,20 @@
     "glob": "^7.0.5",
     "gulp": "^3.9.1",
     "gulp-cli": "^1.2.2",
+    "gulp-coveralls": "^0.1.4",
+    "gulp-istanbul": "^1.1.1",
+    "gulp-mocha": "^3.0.1",
     "gulp-sourcemaps": "1.9.1",
     "gulp-typescript": "^3.1.3",
     "jsdoc": "3.4.3",
+    "jsdom": "^9.11.0",
     "merge-stream": "^1.0.1",
-    "mocha": "2.5.3",
     "node-pty": "^0.4.1",
     "nodemon": "1.10.2",
     "sleep": "^3.0.1",
     "sorcery": "^0.10.0",
-    "tsify": "^3.0.0",
     "tslint": "^4.0.2",
-    "typescript": "^2.0.3",
+    "typescript": "~2.2.0",
     "vinyl-buffer": "^1.0.0",
     "vinyl-source-stream": "^1.1.0"
   },
@@ -67,9 +70,10 @@
     "start": "node demo/app",
     "dev": "nodemon -e js,ts --watch src --watch demo --exec npm start",
     "lint": "tslint src/*.ts src/**/*.ts",
-    "test": "mocha --recursive ./lib",
+    "test": "gulp test",
     "build:docs": "jsdoc -c jsdoc.json",
     "build": "gulp build",
-    "prepublish": "npm run build"
+    "prepublish": "npm run build",
+    "coveralls": "gulp coveralls"
   }
 }

src/EscapeSequences.ts

@@ -1,3 +1,7 @@
+/**
+ * @license MIT
+ */
+
 /**
  * C0 control codes
  * See = https://en.wikipedia.org/wiki/C0_and_C1_control_codes

src/InputHandler.ts

@@ -1394,7 +1394,7 @@ export class InputHandler implements IInputHandler {
     this._terminal.cursorHidden = false;
     this._terminal.insertMode = false;
     this._terminal.originMode = false;
-    this._terminal.wraparoundMode = false; // autowrap
+    this._terminal.wraparoundMode = true;  // defaults: xterm - true, vt100 - false
     this._terminal.applicationKeypad = false; // ?
     this._terminal.viewport.syncScrollArea();
     this._terminal.applicationCursor = false;

src/Interfaces.ts

@@ -2,6 +2,9 @@
  * @license MIT
  */
 
+import { LinkMatcherOptions } from './Interfaces';
+import { LinkMatcherHandler, LinkMatcherValidationCallback } from './Types';
+
 export interface IBrowser {
   isNode: boolean;
   userAgent: string;
@@ -44,6 +47,19 @@ export interface ITerminal {
   emit(event: string, data: any);
 }
 
+export interface ICharMeasure {
+  width: number;
+  height: number;
+  measure(): void;
+}
+
+export interface ILinkifier {
+  linkifyRow(rowIndex: number): void;
+  attachHypertextLinkHandler(handler: LinkMatcherHandler): void;
+  registerLinkMatcher(regex: RegExp, handler: LinkMatcherHandler, options?: LinkMatcherOptions): number;
+  deregisterLinkMatcher(matcherId: number): boolean;
+}
+
 interface ICircularList<T> {
   length: number;
   maxLength: number;
@@ -58,6 +74,25 @@ interface ICircularList<T> {
   shiftElements(start: number, count: number, offset: number): void;
 }
 
+export interface LinkMatcherOptions {
+  /**
+   * The index of the link from the regex.match(text) call. This defaults to 0
+   * (for regular expressions without capture groups).
+   */
+  matchIndex?: number;
+  /**
+   * A callback that validates an individual link, returning true if valid and
+   * false if invalid.
+   */
+  validationCallback?: LinkMatcherValidationCallback;
+  /**
+   * The priority of the link matcher, this defines the order in which the link
+   * matcher is evaluated relative to others, from highest to lowest. The
+   * default value is 0.
+   */
+  priority?: number;
+}
+
 /**
  * Handles actions generated by the parser.
  */

src/Linkifier.test.ts

@@ -0,0 +1,99 @@
+/**
+ * @license MIT
+ */
+import jsdom = require('jsdom');
+import { assert } from 'chai';
+import { ITerminal, ILinkifier } from './Interfaces';
+import { Linkifier } from './Linkifier';
+import { LinkMatcher } from './Types';
+
+class TestLinkifier extends Linkifier {
+  constructor(document: Document, rows: HTMLElement[]) {
+    Linkifier.TIME_BEFORE_LINKIFY = 0;
+    super(document, rows);
+  }
+
+  public get linkMatchers(): LinkMatcher[] { return this._linkMatchers; }
+}
+
+describe('Linkifier', () => {
+  let window: Window;
+  let document: Document;
+
+  let container: HTMLElement;
+  let rows: HTMLElement[];
+  let linkifier: TestLinkifier;
+
+  beforeEach(done => {
+    rows = [];
+    jsdom.env('', (err, w) => {
+      window = w;
+      document = window.document;
+      linkifier = new TestLinkifier(document, rows);
+      container = document.createElement('div');
+      document.body.appendChild(container);
+      done();
+    });
+  });
+
+  function addRow(text: string) {
+    const element = document.createElement('div');
+    element.textContent = text;
+    container.appendChild(element);
+    rows.push(element);
+  }
+
+  function clickElement(element: Node) {
+    const event = document.createEvent('MouseEvent');
+    event.initMouseEvent('click', true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
+    element.dispatchEvent(event);
+  }
+
+  describe('validationCallback', () => {
+    it('should enable link if true', done => {
+      addRow('test');
+      linkifier.registerLinkMatcher(/test/, () => done(), {
+        validationCallback: (url, cb) => {
+          cb(true);
+          assert.equal((<HTMLElement>rows[0].firstChild).tagName, 'A');
+          setTimeout(() => clickElement(rows[0].firstChild), 0);
+        }
+      });
+      linkifier.linkifyRow(0);
+    });
+
+    it('should disable link if false', done => {
+      addRow('test');
+      linkifier.registerLinkMatcher(/test/, () => assert.fail(), {
+        validationCallback: (url, cb) => {
+          cb(false);
+          assert.equal((<HTMLElement>rows[0].firstChild).tagName, 'A');
+          setTimeout(() => clickElement(rows[0].firstChild), 0);
+        }
+      });
+      linkifier.linkifyRow(0);
+      // Allow time for the click to be performed
+      setTimeout(() => done(), 10);
+    });
+  });
+
+  describe('priority', () => {
+    it('should order the list from highest priority to lowest #1', () => {
+      const aId = linkifier.registerLinkMatcher(/a/, () => {}, { priority: 1 });
+      const bId = linkifier.registerLinkMatcher(/b/, () => {}, { priority: -1 });
+      assert.deepEqual(linkifier.linkMatchers.map(lm => lm.id), [aId, 0, bId]);
+    });
+
+    it('should order the list from highest priority to lowest #2', () => {
+      const aId = linkifier.registerLinkMatcher(/a/, () => {}, { priority: -1 });
+      const bId = linkifier.registerLinkMatcher(/b/, () => {}, { priority: 1 });
+      assert.deepEqual(linkifier.linkMatchers.map(lm => lm.id), [bId, 0, aId]);
+    });
+
+    it('should order items of equal priority in the order they are added', () => {
+      const aId = linkifier.registerLinkMatcher(/a/, () => {}, { priority: 0 });
+      const bId = linkifier.registerLinkMatcher(/b/, () => {}, { priority: 0 });
+      assert.deepEqual(linkifier.linkMatchers.map(lm => lm.id), [0, aId, bId]);
+    });
+  });
+});

src/Linkifier.ts

@@ -0,0 +1,311 @@
+/**
+ * @license MIT
+ */
+
+import { LinkMatcherOptions } from './Interfaces';
+import { LinkMatcher, LinkMatcherHandler, LinkMatcherValidationCallback } from './Types';
+
+const INVALID_LINK_CLASS = 'xterm-invalid-link';
+
+const protocolClause = '(https?:\\/\\/)';
+const domainCharacterSet = '[\\da-z\\.-]+';
+const negatedDomainCharacterSet = '[^\\da-z\\.-]+';
+const domainBodyClause = '(' + domainCharacterSet + ')';
+const tldClause = '([a-z\\.]{2,6})';
+const ipClause = '((\\d{1,3}\\.){3}\\d{1,3})';
+const localHostClause = '(localhost)';
+const portClause = '(:\\d{1,5})';
+const hostClause = '((' + domainBodyClause + '\\.' + tldClause + ')|' + ipClause + '|' + localHostClause + ')' + portClause + '?';
+const pathClause = '(\\/[\\/\\w\\.\\-%]*)*';
+const queryStringHashFragmentCharacterSet = '[0-9\\w\\[\\]\\(\\)\\/\\?\\!#@$%&\'*+,:;\\=\\.\\-]*';
+const queryStringClause = '(\\?' + queryStringHashFragmentCharacterSet + ')?';
+const hashFragmentClause = '(#' + queryStringHashFragmentCharacterSet + ')?';
+const negatedPathCharacterSet = '[^\\/\\w\\.\\-%]+';
+const bodyClause = hostClause + pathClause + queryStringClause + hashFragmentClause;
+const start = '(?:^|' + negatedDomainCharacterSet + ')(';
+const end = ')($|' + negatedPathCharacterSet + ')';
+const strictUrlRegex = new RegExp(start + protocolClause + bodyClause + end);
+
+/**
+ * The ID of the built in http(s) link matcher.
+ */
+const HYPERTEXT_LINK_MATCHER_ID = 0;
+
+/**
+ * The Linkifier applies links to rows shortly after they have been refreshed.
+ */
+export class Linkifier {
+  /**
+   * The time to wait after a row is changed before it is linkified. This prevents
+   * the costly operation of searching every row multiple times, pntentially a
+   * huge aount of times.
+   */
+  protected static TIME_BEFORE_LINKIFY = 200;
+
+  protected _linkMatchers: LinkMatcher[];
+
+  private _document: Document;
+  private _rows: HTMLElement[];
+  private _rowTimeoutIds: number[];
+  private _nextLinkMatcherId = HYPERTEXT_LINK_MATCHER_ID;
+
+  constructor(document: Document, rows: HTMLElement[]) {
+    this._document = document;
+    this._rows = rows;
+    this._rowTimeoutIds = [];
+    this._linkMatchers = [];
+    this.registerLinkMatcher(strictUrlRegex, null, { matchIndex: 1 });
+  }
+
+  /**
+   * Queues a row for linkification.
+   * @param {number} rowIndex The index of the row to linkify.
+   */
+  public linkifyRow(rowIndex: number): void {
+    const timeoutId = this._rowTimeoutIds[rowIndex];
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    this._rowTimeoutIds[rowIndex] = setTimeout(this._linkifyRow.bind(this, rowIndex), Linkifier.TIME_BEFORE_LINKIFY);
+  }
+
+  /**
+   * Attaches a handler for hypertext links, overriding default <a> behavior
+   * for standard http(s) links.
+   * @param {LinkHandler} handler The handler to use, this can be cleared with
+   * null.
+   */
+  public attachHypertextLinkHandler(handler: LinkMatcherHandler): void {
+    this._linkMatchers[HYPERTEXT_LINK_MATCHER_ID].handler = handler;
+  }
+
+  /**
+   * Registers a link matcher, allowing custom link patterns to be matched and
+   * handled.
+   * @param {RegExp} regex The regular expression to search for, specifically
+   * this searches the textContent of the rows. You will want to use \s to match
+   * a space ' ' character for example.
+   * @param {LinkHandler} handler The callback when the link is called.
+   * @param {LinkMatcherOptions} [options] Options for the link matcher.
+   * @return {number} The ID of the new matcher, this can be used to deregister.
+   */
+  public registerLinkMatcher(regex: RegExp, handler: LinkMatcherHandler, options: LinkMatcherOptions = {}): number {
+    if (this._nextLinkMatcherId !== HYPERTEXT_LINK_MATCHER_ID && !handler) {
+      throw new Error('handler must be defined');
+    }
+    const matcher: LinkMatcher = {
+      id: this._nextLinkMatcherId++,
+      regex,
+      handler,
+      matchIndex: options.matchIndex,
+      validationCallback: options.validationCallback,
+      priority: options.priority || 0
+    };
+    this._addLinkMatcherToList(matcher);
+    return matcher.id;
+  }
+
+  /**
+   * Inserts a link matcher to the list in the correct position based on the
+   * priority of each link matcher. New link matchers of equal priority are
+   * considered after older link matchers.
+   * @param matcher The link matcher to be added.
+   */
+  private _addLinkMatcherToList(matcher: LinkMatcher): void {
+    if (this._linkMatchers.length === 0) {
+      this._linkMatchers.push(matcher);
+      return;
+    }
+
+    for (let i = this._linkMatchers.length - 1; i >= 0; i--) {
+      if (matcher.priority <= this._linkMatchers[i].priority) {
+        this._linkMatchers.splice(i + 1, 0, matcher);
+        return;
+      }
+    }
+
+    this._linkMatchers.splice(0, 0, matcher);
+  }
+
+  /**
+   * Deregisters a link matcher if it has been registered.
+   * @param {number} matcherId The link matcher's ID (returned after register)
+   * @return {boolean} Whether a link matcher was found and deregistered.
+   */
+  public deregisterLinkMatcher(matcherId: number): boolean {
+    // ID 0 is the hypertext link matcher which cannot be deregistered
+    for (let i = 1; i < this._linkMatchers.length; i++) {
+      if (this._linkMatchers[i].id === matcherId) {
+        this._linkMatchers.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Linkifies a row.
+   * @param {number} rowIndex The index of the row to linkify.
+   */
+  private _linkifyRow(rowIndex: number): void {
+    const row = this._rows[rowIndex];
+    if (!row) {
+      return;
+    }
+    const text = row.textContent;
+    for (let i = 0; i < this._linkMatchers.length; i++) {
+      const matcher = this._linkMatchers[i];
+      const uri = this._findLinkMatch(text, matcher.regex, matcher.matchIndex);
+      if (uri) {
+        const linkElement = this._doLinkifyRow(rowIndex, uri, matcher.handler, matcher.id === HYPERTEXT_LINK_MATCHER_ID);
+        // Fire validation callback
+        if (linkElement && matcher.validationCallback) {
+          matcher.validationCallback(uri, isValid => {
+            if (!isValid) {
+              linkElement.classList.add(INVALID_LINK_CLASS);
+            }
+          });
+        }
+        // Only allow a single LinkMatcher to trigger on any given row.
+        return;
+      }
+    }
+  }
+
+  /**
+   * Linkifies a row given a specific handler.
+   * @param {number} rowIndex The index of the row to linkify.
+   * @param {string} uri The uri that has been found.
+   * @param {handler} handler The handler to trigger when the link is triggered.
+   * @return The link element if it was added, otherwise undefined.
+   */
+  private _doLinkifyRow(rowIndex: number, uri: string, handler: LinkMatcherHandler, isHttpLinkMatcher: boolean): HTMLElement {
+    // Iterate over nodes as we want to consider text nodes
+    const nodes = this._rows[rowIndex].childNodes;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const searchIndex = node.textContent.indexOf(uri);
+      if (searchIndex >= 0) {
+        const linkElement = this._createAnchorElement(uri, handler, isHttpLinkMatcher);
+        if (node.textContent.length === uri.length) {
+          // Matches entire string
+
+          if (node.nodeType === 3 /*Node.TEXT_NODE*/) {
+            this._replaceNode(node, linkElement);
+          } else {
+            const element = (<HTMLElement>node);
+            if (element.nodeName === 'A') {
+              // This row has already been linkified
+              return;
+            }
+            element.innerHTML = '';
+            element.appendChild(linkElement);
+          }
+        } else {
+          // Matches part of string
+          this._replaceNodeSubstringWithNode(node, linkElement, uri, searchIndex);
+        }
+        return linkElement;
+      }
+    }
+  }
+
+  /**
+   * Finds a link match in a piece of text.
+   * @param {string} text The text to search.
+   * @param {number} matchIndex The regex match index of the link.
+   * @return {string} The matching URI or null if not found.
+   */
+  private _findLinkMatch(text: string, regex: RegExp, matchIndex?: number): string {
+    const match = text.match(regex);
+    if (!match || match.length === 0) {
+      return null;
+    }
+    return match[typeof matchIndex !== 'number' ? 0 : matchIndex];
+  }
+
+  /**
+   * Creates a link anchor element.
+   * @param {string} uri The uri of the link.
+   * @return {HTMLAnchorElement} The link.
+   */
+  private _createAnchorElement(uri: string, handler: LinkMatcherHandler, isHypertextLinkHandler: boolean): HTMLAnchorElement {
+    const element = this._document.createElement('a');
+    element.textContent = uri;
+    if (isHypertextLinkHandler) {
+      element.href = uri;
+      // Force link on another tab so work is not lost
+      element.target = '_blank';
+      element.addEventListener('click', (event: MouseEvent) => {
+        if (handler) {
+          return handler(event, uri);
+        }
+      });
+    } else {
+      element.addEventListener('click', (event: MouseEvent) => {
+        // Don't execute the handler if the link is flagged as invalid
+        if (element.classList.contains(INVALID_LINK_CLASS)) {
+          return;
+        }
+        return handler(event, uri);
+      });
+    }
+    return element;
+  }
+
+  /**
+   * Replace a node with 1 or more other nodes.
+   * @param {Node} oldNode The node to replace.
+   * @param {Node[]} newNodes The new nodes to insert in order.
+   */
+  private _replaceNode(oldNode: Node, ...newNodes: Node[]): void {
+    const parent = oldNode.parentNode;
+    for (let i = 0; i < newNodes.length; i++) {
+      parent.insertBefore(newNodes[i], oldNode);
+    }
+    parent.removeChild(oldNode);
+  }
+
+  /**
+   * Replace a substring within a node with a new node.
+   * @param {Node} targetNode The target node; either a text node or a <span>
+   * containing a single text node.
+   * @param {Node} newNode The new node to insert.
+   * @param {string} substring The substring to replace.
+   * @param {number} substringIndex The index of the substring within the string.
+   */
+  private _replaceNodeSubstringWithNode(targetNode: Node, newNode: Node, substring: string, substringIndex: number): void {
+    let node = targetNode;
+    if (node.nodeType !== 3/*Node.TEXT_NODE*/) {
+      node = node.childNodes[0];
+    }
+
+    // The targetNode will be either a text node or a <span>. The text node
+    // (targetNode or its only-child) needs to be replaced with newNode plus new
+    // text nodes potentially on either side.
+    if (node.childNodes.length === 0 && node.nodeType !== Node.TEXT_NODE) {
+      throw new Error('targetNode must be a text node or only contain a single text node');
+    }
+
+    const fullText = node.textContent;
+
+    if (substringIndex === 0) {
+      // Replace with <newNode><textnode>
+      const rightText = fullText.substring(substring.length);
+      const rightTextNode = this._document.createTextNode(rightText);
+      this._replaceNode(node, newNode, rightTextNode);
+    } else if (substringIndex === targetNode.textContent.length - substring.length) {
+      // Replace with <textnode><newNode>
+      const leftText = fullText.substring(0, substringIndex);
+      const leftTextNode = this._document.createTextNode(leftText);
+      this._replaceNode(node, leftTextNode, newNode);
+    } else {
+      // Replace with <textnode><newNode><textnode>
+      const leftText = fullText.substring(0, substringIndex);
+      const leftTextNode = this._document.createTextNode(leftText);
+      const rightText = fullText.substring(substringIndex + substring.length);
+      const rightTextNode = this._document.createTextNode(rightText);
+      this._replaceNode(node, leftTextNode, newNode, rightTextNode);
+    }
+  }
+}

src/Types.ts

@@ -0,0 +1,14 @@
+/**
+ * @license MIT
+ */
+
+export type LinkMatcher = {
+  id: number,
+  regex: RegExp,
+  handler: LinkMatcherHandler,
+  matchIndex?: number,
+  validationCallback?: LinkMatcherValidationCallback,
+  priority?: number
+};
+export type LinkMatcherHandler = (event: MouseEvent, uri: string) => boolean | void;
+export type LinkMatcherValidationCallback = (uri: string, callback: (isValid: boolean) => void) => void;

src/Viewport.test.ts

@@ -41,13 +41,17 @@ describe('Viewport', () => {
   });
 
   describe('refresh', () => {
-    it('should set the line-height of the terminal', () => {
-      assert.equal(viewportElement.style.lineHeight, CHARACTER_HEIGHT + 'px');
-      assert.equal(terminal.rowContainer.style.lineHeight, CHARACTER_HEIGHT + 'px');
-      charMeasure.height = 1;
-      viewport.refresh();
-      assert.equal(viewportElement.style.lineHeight, '1px');
-      assert.equal(terminal.rowContainer.style.lineHeight, '1px');
+    it('should set the line-height of the terminal', done => {
+      // Allow CharMeasure to be initialized
+      setTimeout(() => {
+        assert.equal(viewportElement.style.lineHeight, CHARACTER_HEIGHT + 'px');
+        assert.equal(terminal.rowContainer.style.lineHeight, CHARACTER_HEIGHT + 'px');
+        charMeasure.height = 1;
+        viewport.refresh();
+        assert.equal(viewportElement.style.lineHeight, '1px');
+        assert.equal(terminal.rowContainer.style.lineHeight, '1px');
+        done();
+      }, 0);
     });
     it('should set the height of the viewport when the line-height changed', () => {
       terminal.lines.push('');
@@ -62,17 +66,21 @@ describe('Viewport', () => {
   });
 
   describe('syncScrollArea', () => {
-    it('should sync the scroll area', () => {
-      terminal.lines.push('');
-      terminal.rows = 1;
-      assert.equal(scrollAreaElement.style.height, 0 * CHARACTER_HEIGHT + 'px');
-      viewport.syncScrollArea();
-      assert.equal(viewportElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
-      assert.equal(scrollAreaElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
-      terminal.lines.push('');
-      viewport.syncScrollArea();
-      assert.equal(viewportElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
-      assert.equal(scrollAreaElement.style.height, 2 * CHARACTER_HEIGHT + 'px');
+    it('should sync the scroll area', done => {
+      // Allow CharMeasure to be initialized
+      setTimeout(() => {
+        terminal.lines.push('');
+        terminal.rows = 1;
+        assert.equal(scrollAreaElement.style.height, 0 * CHARACTER_HEIGHT + 'px');
+        viewport.syncScrollArea();
+        assert.equal(viewportElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
+        assert.equal(scrollAreaElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
+        terminal.lines.push('');
+        viewport.syncScrollArea();
+        assert.equal(viewportElement.style.height, 1 * CHARACTER_HEIGHT + 'px');
+        assert.equal(scrollAreaElement.style.height, 2 * CHARACTER_HEIGHT + 'px');
+        done();
+      }, 0);
     });
   });
 });

src/Viewport.ts

@@ -35,7 +35,8 @@ export class Viewport {
     this.terminal.on('resize', this.syncScrollArea.bind(this));
     this.viewportElement.addEventListener('scroll', this.onScroll.bind(this));
 
-    this.syncScrollArea();
+    // Perform this async to ensure the CharMeasure is ready.
+    setTimeout(() => this.syncScrollArea(), 0);
   }
 
   /**

src/addons/fit/fit.js

@@ -32,6 +32,9 @@
   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),
@@ -66,7 +69,9 @@
   exports.fit = function (term) {
     var geometry = exports.proposeGeometry(term);
 
-    term.resize(geometry.cols, geometry.rows);
+    if (geometry) {
+      term.resize(geometry.cols, geometry.rows);
+    }
   };
 
   Xterm.prototype.proposeGeometry = function () {

src/addons/linkify/index.html

@@ -1,36 +0,0 @@
-<!doctype html>
-<html>
-    <head>
-        <link rel="stylesheet" href="../../src/xterm.css" />
-        <link rel="stylesheet" href="../../demo/style.css" />
-        <script src="../../src/xterm.js"></script>
-        <script src="linkify.js"></script>
-        <style>
-            body {
-                color: #111;
-            }
-
-            #terminal-container {
-                max-width: 900px;
-                margin: 0 auto;
-            }
-
-            #terminal-container a {
-				color: #fff;
-            }
-        </style>
-    </head>
-    <body>
-        <div id="terminal-container"></div>
-        <script>
-            var term = new Terminal(),
-                container = document.getElementById('terminal-container');
-
-            term.open(container);
-            term.writeln('Hello, welcome to xterm.js');
-            term.writeln('');
-            term.writeln('Check it out at github.com/sourcelair/xterm.js');
-            term.linkify();
-        </script>
-    </body>
-</html>

src/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;
-});

src/addons/linkify/package.json

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

src/test/addons/linkify-test.js

@@ -1,48 +0,0 @@
-var assert = require('chai').assert;
-var Terminal = require('../../xterm');
-var linkify = require('../../addons/linkify/linkify');
-
-describe('linkify addon', function () {
-  var xterm;
-
-  describe('API', function () {
-    it('should define Terminal.prototype.linkify', function () {
-      assert.isDefined(Terminal.prototype.linkify);
-    });
-    it('should define Terminal.prototype.linkifyTerminalLine', function () {
-      assert.isDefined(Terminal.prototype.linkifyTerminalLine);
-    });
-  });
-
-  describe('findUrlMatchOnLine', function () {
-    describe('strict regex', function () {
-      it('should match when the entire text is a match', function () {
-        assert.equal(linkify.findLinkMatch('http://github.com', false), 'http://github.com');
-        assert.equal(linkify.findLinkMatch('http://127.0.0.1', false), 'http://127.0.0.1');
-      });
-      it('should match simple domains', function () {
-        assert.equal(linkify.findLinkMatch('foo http://github.com bar', false), 'http://github.com');
-        assert.equal(linkify.findLinkMatch('foo http://www.github.com bar', false), 'http://www.github.com');
-        assert.equal(linkify.findLinkMatch('foo https://github.com bar', false), 'https://github.com');
-        assert.equal(linkify.findLinkMatch('foo https://www.github.com bar', false), 'https://www.github.com');
-      });
-      it('should match web addresses with alpha paths', function () {
-        assert.equal(linkify.findLinkMatch('foo http://github.com/a/b/c bar', false), 'http://github.com/a/b/c');
-        assert.equal(linkify.findLinkMatch('foo http://www.github.com/a/b/c bar', false), 'http://www.github.com/a/b/c');
-      });
-      it('should not include whitespace surrounding a match', function () {
-        assert.equal(linkify.findLinkMatch(' http://github.com', false), 'http://github.com');
-        assert.equal(linkify.findLinkMatch('http://github.com ', false), 'http://github.com');
-        assert.equal(linkify.findLinkMatch('  http://github.com  ', false), 'http://github.com');
-      });
-      it('should match IP addresses', function () {
-        assert.equal(linkify.findLinkMatch('foo http://127.0.0.1 bar', false), 'http://127.0.0.1');
-        assert.equal(linkify.findLinkMatch('foo https://127.0.0.1 bar', false), 'https://127.0.0.1');
-      });
-      it('should match ports on both domains and IP addresses', function () {
-        assert.equal(linkify.findLinkMatch('foo http://127.0.0.1:8080 bar', false), 'http://127.0.0.1:8080');
-        assert.equal(linkify.findLinkMatch('foo http://www.github.com:8080 bar', false), 'http://www.github.com:8080');
-      });
-    });
-  });
-});

src/test/test.js

@@ -550,6 +550,7 @@ describe('xterm.js', function() {
 
   describe('unicode - surrogates', function() {
     it('2 characters per cell', function () {
+      this.timeout(10000);  // This is needed because istanbul patches code and slows it down
       var high = String.fromCharCode(0xD800);
       for (var i=0xDC00; i<=0xDCFF; ++i) {
         xterm.write(high + String.fromCharCode(i));

src/utils/CharMeasure.test.ts

@@ -0,0 +1,77 @@
+/**
+ * @license MIT
+ */
+import jsdom = require('jsdom');
+import { assert } from 'chai';
+import { ICharMeasure, ITerminal } from '../Interfaces';
+import { CharMeasure } from './CharMeasure';
+
+describe('CharMeasure', () => {
+  let window: Window;
+  let document: Document;
+
+  let container: HTMLElement;
+  let charMeasure: ICharMeasure;
+
+  beforeEach(done => {
+    jsdom.env('', (err, w) => {
+      window = w;
+      document = window.document;
+      container = document.createElement('div');
+      document.body.appendChild(container);
+      charMeasure = new CharMeasure(document, container);
+      done();
+    });
+  });
+
+  describe('measure', () => {
+    it('should set _measureElement on first call', () => {
+      charMeasure.measure();
+      assert.isDefined((<any>charMeasure)._measureElement, 'CharMeasure.measure should have created _measureElement');
+    });
+
+    it('should be performed async on first call', done => {
+      assert.equal(charMeasure.width, null);
+      charMeasure.measure();
+      // Mock getBoundingClientRect since jsdom doesn't have a layout engine
+      (<any>charMeasure)._measureElement.getBoundingClientRect = () => {
+        return { width: 1, height: 1 };
+      };
+      assert.equal(charMeasure.width, null);
+      setTimeout(() => {
+        assert.equal(charMeasure.width, 1);
+        done();
+      }, 0);
+    });
+
+    it('should be performed sync on successive calls', done => {
+      charMeasure.measure();
+      // Mock getBoundingClientRect since jsdom doesn't have a layout engine
+      (<any>charMeasure)._measureElement.getBoundingClientRect = () => {
+        return { width: 1, height: 1 };
+      };
+      setTimeout(() => {
+        const firstWidth = charMeasure.width;
+        // Mock getBoundingClientRect since jsdom doesn't have a layout engine
+        (<any>charMeasure)._measureElement.getBoundingClientRect = () => {
+          return { width: 2, height: 2 };
+        };
+        charMeasure.measure();
+        assert.equal(charMeasure.width, firstWidth * 2);
+        done();
+      }, 0);
+    });
+
+    it('should NOT do a measure when the parent is hidden', done => {
+      charMeasure.measure();
+      setTimeout(() => {
+        const firstWidth = charMeasure.width;
+        container.style.display = 'none';
+        container.style.fontSize = '2em';
+        charMeasure.measure();
+        assert.equal(charMeasure.width, firstWidth);
+        done();
+      }, 0);
+    });
+  });
+});

src/utils/CharMeasure.ts

@@ -9,13 +9,15 @@ import { EventEmitter } from '../EventEmitter.js';
  * Utility class that measures the size of a character.
  */
 export class CharMeasure extends EventEmitter {
+  private _document: Document;
   private _parentElement: HTMLElement;
   private _measureElement: HTMLElement;
   private _width: number;
   private _height: number;
 
-  constructor(parentElement: HTMLElement) {
+  constructor(document: Document, parentElement: HTMLElement) {
     super();
+    this._document = document;
     this._parentElement = parentElement;
   }
 
@@ -29,11 +31,12 @@ export class CharMeasure extends EventEmitter {
 
   public measure(): void {
     if (!this._measureElement) {
-      this._measureElement = document.createElement('span');
+      this._measureElement = this._document.createElement('span');
       this._measureElement.style.position = 'absolute';
       this._measureElement.style.top = '0';
       this._measureElement.style.left = '-9999em';
       this._measureElement.textContent = 'W';
+      this._measureElement.setAttribute('aria-hidden', 'true');
       this._parentElement.appendChild(this._measureElement);
       // Perform _doMeasure async if the element was just attached as sometimes
       // getBoundingClientRect does not return accurate values without this.

src/xterm.css

@@ -71,6 +71,21 @@
     resize: none;
 }
 
+.terminal a {
+    color: inherit;
+    text-decoration: none;
+}
+
+.terminal a:hover {
+    cursor: pointer;
+    text-decoration: underline;
+}
+
+.terminal a.xterm-invalid-link:hover {
+    cursor: text;
+    text-decoration: none;
+}
+
 .terminal:not(.xterm-cursor-style-underline):not(.xterm-cursor-style-bar) .terminal-cursor {
     background-color: #fff;
     color: #000;
@@ -87,13 +102,10 @@
 }
 
 @keyframes xterm-cursor-blink {
-    0% {
-        background-color: #fff;
-        color: #000;
-    }
+    0% { }
     50% {
         background-color: transparent;
-        color: #FFF;
+        color: inherit;
     }
 }
 

src/xterm.js

@@ -19,6 +19,7 @@ import { C0 } from './EscapeSequences';
 import { InputHandler } from './InputHandler';
 import { Parser } from './Parser';
 import { Renderer } from './Renderer';
+import { Linkifier } from './Linkifier';
 import { CharMeasure } from './utils/CharMeasure';
 import * as Browser from './utils/Browser';
 import * as Keyboard from './utils/Keyboard';
@@ -210,6 +211,7 @@ function Terminal(options) {
   this.parser = new Parser(this.inputHandler, this);
   // Reuse renderer if the Terminal is being recreated via a Terminal.reset call.
   this.renderer = this.renderer || null;
+  this.linkifier = this.linkifier || null;;
 
   // user input states
   this.writeBuffer = [];
@@ -546,6 +548,9 @@ Terminal.bindKeys = function(term) {
   on(term.textarea, 'compositionupdate', term.compositionHelper.compositionupdate.bind(term.compositionHelper));
   on(term.textarea, 'compositionend', term.compositionHelper.compositionend.bind(term.compositionHelper));
   term.on('refresh', term.compositionHelper.updateCompositionElements.bind(term.compositionHelper));
+  term.on('refresh', function (data) {
+    term.queueLinkification(data.start, data.end)
+  });
 };
 
 
@@ -607,6 +612,7 @@ Terminal.prototype.open = function(parent) {
   this.rowContainer.classList.add('xterm-rows');
   this.element.appendChild(this.rowContainer);
   this.children = [];
+  this.linkifier = new Linkifier(document, this.children);
 
   // Create the container that will hold helpers like the textarea for
   // capturing DOM Events. Then produce the helpers.
@@ -641,7 +647,7 @@ Terminal.prototype.open = function(parent) {
   }
   this.parent.appendChild(this.element);
 
-  this.charMeasure = new CharMeasure(this.helperContainer);
+  this.charMeasure = new CharMeasure(document, this.helperContainer);
   this.charMeasure.on('charsizechanged', function () {
     self.updateCharSizeCSS();
   });
@@ -957,10 +963,8 @@ Terminal.prototype.bindMouse = function() {
     }
 
     // convert to cols/rows
-    w = self.element.clientWidth;
-    h = self.element.clientHeight;
-    x = Math.ceil((x / w) * self.cols);
-    y = Math.ceil((y / h) * self.rows);
+    x = Math.ceil(x / self.charMeasure.width);
+    y = Math.ceil(y / self.charMeasure.height);
 
     // be sure to avoid sending
     // bad positions to the program
@@ -1054,8 +1058,8 @@ Terminal.prototype.destroy = function() {
 /**
  * Tells the renderer to refresh terminal content between two rows (inclusive) at the next
  * opportunity.
- * @param {number} start The row to start from (between 0 and terminal's height terminal - 1)
- * @param {number} end The row to end at (between fromRow and terminal's height terminal - 1)
+ * @param {number} start The row to start from (between 0 and this.rows - 1).
+ * @param {number} end The row to end at (between start and this.rows - 1).
  */
 Terminal.prototype.refresh = function(start, end) {
   if (this.renderer) {
@@ -1063,6 +1067,19 @@ Terminal.prototype.refresh = function(start, end) {
   }
 };
 
+/**
+ * Queues linkification for the specified rows.
+ * @param {number} start The row to start from (between 0 and this.rows - 1).
+ * @param {number} end The row to end at (between start and this.rows - 1).
+ */
+Terminal.prototype.queueLinkification = function(start, end) {
+  if (this.linkifier) {
+    for (let i = start; i <= end; i++) {
+      this.linkifier.linkifyRow(i);
+    }
+  }
+}
+
 /**
  * Display the cursor element
  */
@@ -1263,6 +1280,51 @@ Terminal.prototype.attachCustomKeydownHandler = function(customKeydownHandler) {
   this.customKeydownHandler = customKeydownHandler;
 }
 
+/**
+ * Attaches a http(s) link handler, forcing web links to behave differently to
+ * regular <a> tags. This will trigger a refresh as links potentially need to be
+ * reconstructed. Calling this with null will remove the handler.
+ * @param {LinkHandler} handler The handler callback function.
+ */
+Terminal.prototype.attachHypertextLinkHandler = function(handler) {
+  if (!this.linkifier) {
+    throw new Error('Cannot attach a hypertext link handler before Terminal.open is called');
+  }
+  this.linkifier.attachHypertextLinkHandler(handler);
+  // Refresh to force links to refresh
+  this.refresh(0, this.rows - 1);
+}
+
+/**
+   * Registers a link matcher, allowing custom link patterns to be matched and
+   * handled.
+   * @param {RegExp} regex The regular expression to search for, specifically
+   * this searches the textContent of the rows. You will want to use \s to match
+   * a space ' ' character for example.
+   * @param {LinkHandler} handler The callback when the link is called.
+   * @param {LinkMatcherOptions} [options] Options for the link matcher.
+   * @return {number} The ID of the new matcher, this can be used to deregister.
+ */
+Terminal.prototype.registerLinkMatcher = function(regex, handler, options) {
+  if (this.linkifier) {
+    var matcherId = this.linkifier.registerLinkMatcher(regex, handler, options);
+    this.refresh(0, this.rows - 1);
+    return matcherId;
+  }
+}
+
+/**
+ * Deregisters a link matcher if it has been registered.
+ * @param {number} matcherId The link matcher's ID (returned after register)
+ */
+Terminal.prototype.deregisterLinkMatcher = function(matcherId) {
+  if (this.linkifier) {
+    if (this.linkifier.deregisterLinkMatcher(matcherId)) {
+      this.refresh(0, this.rows - 1);
+    }
+  }
+}
+
 /**
  * Handle a keydown event
  * Key Resources: