maride/gotty
1
0
Fork 0
mirror of https://github.com/sorenisanerd/gotty.git synced 2024-11-09 23:34:26 +00:00
Code Issues Packages Projects Releases Wiki Activity
8803721f3d
gotty/js/dist/bundle.js
Iwasaki Yudai 8803721f3d Add xterm itegration 
* Move to TypeScript from legacy JavaScript
* Add support of xterm.js
* Hterm is still available for backward compatibility
2017-08-21 16:38:28 +09:00

6008 lines
210 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // identity function for calling harmony imports with the correct context
/******/ __webpack_require__.i = function(value) { return value; };
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 14);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var CompositionHelper_1 = __webpack_require__(15);
var EventEmitter_1 = __webpack_require__(1);
var Viewport_1 = __webpack_require__(22);
var Clipboard_1 = __webpack_require__(29);
var CircularList_1 = __webpack_require__(31);
var EscapeSequences_1 = __webpack_require__(2);
var InputHandler_1 = __webpack_require__(16);
var Parser_1 = __webpack_require__(18);
var Renderer_1 = __webpack_require__(19);
var Linkifier_1 = __webpack_require__(17);
var SelectionManager_1 = __webpack_require__(20);
var CharMeasure_1 = __webpack_require__(30);
var Browser = __webpack_require__(8);
var Mouse_1 = __webpack_require__(9);
var document = (typeof window != 'undefined') ? window.document : null;
var WRITE_BUFFER_PAUSE_THRESHOLD = 5;
var WRITE_BATCH_SIZE = 300;
var CURSOR_BLINK_INTERVAL = 600;
function Terminal(options) {
var self = this;
if (!(this instanceof Terminal)) {
return new Terminal(arguments[0], arguments[1], arguments[2]);
}
self.browser = Browser;
self.cancel = Terminal.cancel;
EventEmitter_1.EventEmitter.call(this);
if (typeof options === 'number') {
options = {
cols: arguments[0],
rows: arguments[1],
handler: arguments[2]
};
}
options = options || {};
Object.keys(Terminal.defaults).forEach(function (key) {
if (options[key] == null) {
options[key] = Terminal.options[key];
if (Terminal[key] !== Terminal.defaults[key]) {
options[key] = Terminal[key];
}
}
self[key] = options[key];
});
if (options.colors.length === 8) {
options.colors = options.colors.concat(Terminal._colors.slice(8));
}
else if (options.colors.length === 16) {
options.colors = options.colors.concat(Terminal._colors.slice(16));
}
else if (options.colors.length === 10) {
options.colors = options.colors.slice(0, -2).concat(Terminal._colors.slice(8, -2), options.colors.slice(-2));
}
else if (options.colors.length === 18) {
options.colors = options.colors.concat(Terminal._colors.slice(16, -2), options.colors.slice(-2));
}
this.colors = options.colors;
this.options = options;
this.parent = options.body || options.parent || (document ? document.getElementsByTagName('body')[0] : null);
this.cols = options.cols || options.geometry[0];
this.rows = options.rows || options.geometry[1];
this.geometry = [this.cols, this.rows];
if (options.handler) {
this.on('data', options.handler);
}
this.ybase = 0;
this.ydisp = 0;
this.x = 0;
this.y = 0;
this.cursorState = 0;
this.cursorHidden = false;
this.convertEol;
this.queue = '';
this.scrollTop = 0;
this.scrollBottom = this.rows - 1;
this.customKeyEventHandler = null;
this.cursorBlinkInterval = null;
this.applicationKeypad = false;
this.applicationCursor = false;
this.originMode = false;
this.insertMode = false;
this.wraparoundMode = true;
this.normal = null;
this.charset = null;
this.gcharset = null;
this.glevel = 0;
this.charsets = [null];
this.decLocator;
this.x10Mouse;
this.vt200Mouse;
this.vt300Mouse;
this.normalMouse;
this.mouseEvents;
this.sendFocus;
this.utfMouse;
this.sgrMouse;
this.urxvtMouse;
this.element;
this.children;
this.refreshStart;
this.refreshEnd;
this.savedX;
this.savedY;
this.savedCols;
this.readable = true;
this.writable = true;
this.defAttr = (0 << 18) | (257 << 9) | (256 << 0);
this.curAttr = this.defAttr;
this.params = [];
this.currentParam = 0;
this.prefix = '';
this.postfix = '';
this.inputHandler = new InputHandler_1.InputHandler(this);
this.parser = new Parser_1.Parser(this.inputHandler, this);
this.renderer = this.renderer || null;
this.selectionManager = this.selectionManager || null;
this.linkifier = this.linkifier || new Linkifier_1.Linkifier();
this.writeBuffer = [];
this.writeInProgress = false;
this.xoffSentToCatchUp = false;
this.writeStopped = false;
this.surrogate_high = '';
this.lines = new CircularList_1.CircularList(this.scrollback);
var i = this.rows;
while (i--) {
this.lines.push(this.blankLine());
}
if (this.selectionManager) {
this.selectionManager.setBuffer(this.lines);
}
this.tabs;
this.setupStops();
this.userScrolling = false;
}
inherits(Terminal, EventEmitter_1.EventEmitter);
Terminal.prototype.eraseAttr = function () {
return (this.defAttr & ~0x1ff) | (this.curAttr & 0x1ff);
};
Terminal.tangoColors = [
'#2e3436',
'#cc0000',
'#4e9a06',
'#c4a000',
'#3465a4',
'#75507b',
'#06989a',
'#d3d7cf',
'#555753',
'#ef2929',
'#8ae234',
'#fce94f',
'#729fcf',
'#ad7fa8',
'#34e2e2',
'#eeeeec'
];
Terminal.colors = (function () {
var colors = Terminal.tangoColors.slice(), r = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff], i;
i = 0;
for (; i < 216; i++) {
out(r[(i / 36) % 6 | 0], r[(i / 6) % 6 | 0], r[i % 6]);
}
i = 0;
for (; i < 24; i++) {
r = 8 + i * 10;
out(r, r, r);
}
function out(r, g, b) {
colors.push('#' + hex(r) + hex(g) + hex(b));
}
function hex(c) {
c = c.toString(16);
return c.length < 2 ? '0' + c : c;
}
return colors;
})();
Terminal._colors = Terminal.colors.slice();
Terminal.vcolors = (function () {
var out = [], colors = Terminal.colors, i = 0, color;
for (; i < 256; i++) {
color = parseInt(colors[i].substring(1), 16);
out.push([
(color >> 16) & 0xff,
(color >> 8) & 0xff,
color & 0xff
]);
}
return out;
})();
Terminal.defaults = {
colors: Terminal.colors,
theme: 'default',
convertEol: false,
termName: 'xterm',
geometry: [80, 24],
cursorBlink: false,
cursorStyle: 'block',
visualBell: false,
popOnBell: false,
scrollback: 1000,
screenKeys: false,
debug: false,
cancelEvents: false,
disableStdin: false,
useFlowControl: false,
tabStopWidth: 8
};
Terminal.options = {};
Terminal.focus = null;
each(keys(Terminal.defaults), function (key) {
Terminal[key] = Terminal.defaults[key];
Terminal.options[key] = Terminal.defaults[key];
});
Terminal.prototype.focus = function () {
return this.textarea.focus();
};
Terminal.prototype.getOption = function (key, value) {
if (!(key in Terminal.defaults)) {
throw new Error('No option with key "' + key + '"');
}
if (typeof this.options[key] !== 'undefined') {
return this.options[key];
}
return this[key];
};
Terminal.prototype.setOption = function (key, value) {
if (!(key in Terminal.defaults)) {
throw new Error('No option with key "' + key + '"');
}
switch (key) {
case 'scrollback':
if (value < this.rows) {
var msg = 'Setting the scrollback value less than the number of rows ';
msg += "(" + this.rows + ") is not allowed.";
console.warn(msg);
return false;
}
if (this.options[key] !== value) {
if (this.lines.length > value) {
var amountToTrim = this.lines.length - value;
var needsRefresh = (this.ydisp - amountToTrim < 0);
this.lines.trimStart(amountToTrim);
this.ybase = Math.max(this.ybase - amountToTrim, 0);
this.ydisp = Math.max(this.ydisp - amountToTrim, 0);
if (needsRefresh) {
this.refresh(0, this.rows - 1);
}
}
this.lines.maxLength = value;
this.viewport.syncScrollArea();
}
break;
}
this[key] = value;
this.options[key] = value;
switch (key) {
case 'cursorBlink':
this.setCursorBlinking(value);
break;
case 'cursorStyle':
this.element.classList.toggle("xterm-cursor-style-underline", value === 'underline');
this.element.classList.toggle("xterm-cursor-style-bar", value === 'bar');
break;
case 'tabStopWidth':
this.setupStops();
break;
}
};
Terminal.prototype.restartCursorBlinking = function () {
this.setCursorBlinking(this.options.cursorBlink);
};
Terminal.prototype.setCursorBlinking = function (enabled) {
this.element.classList.toggle('xterm-cursor-blink', enabled);
this.clearCursorBlinkingInterval();
if (enabled) {
var self = this;
this.cursorBlinkInterval = setInterval(function () {
self.element.classList.toggle('xterm-cursor-blink-on');
}, CURSOR_BLINK_INTERVAL);
}
};
Terminal.prototype.clearCursorBlinkingInterval = function () {
this.element.classList.remove('xterm-cursor-blink-on');
if (this.cursorBlinkInterval) {
clearInterval(this.cursorBlinkInterval);
this.cursorBlinkInterval = null;
}
};
Terminal.bindFocus = function (term) {
on(term.textarea, 'focus', function (ev) {
if (term.sendFocus) {
term.send(EscapeSequences_1.C0.ESC + '[I');
}
term.element.classList.add('focus');
term.showCursor();
term.restartCursorBlinking.apply(term);
Terminal.focus = term;
term.emit('focus', { terminal: term });
});
};
Terminal.prototype.blur = function () {
return this.textarea.blur();
};
Terminal.bindBlur = function (term) {
on(term.textarea, 'blur', function (ev) {
term.refresh(term.y, term.y);
if (term.sendFocus) {
term.send(EscapeSequences_1.C0.ESC + '[O');
}
term.element.classList.remove('focus');
term.clearCursorBlinkingInterval.apply(term);
Terminal.focus = null;
term.emit('blur', { terminal: term });
});
};
Terminal.prototype.initGlobal = function () {
var _this = this;
var term = this;
Terminal.bindKeys(this);
Terminal.bindFocus(this);
Terminal.bindBlur(this);
on(this.element, 'copy', function (event) {
if (_this.mouseEvents) {
return;
}
Clipboard_1.copyHandler(event, term, _this.selectionManager);
});
var pasteHandlerWrapper = function (event) { return Clipboard_1.pasteHandler(event, term); };
on(this.textarea, 'paste', pasteHandlerWrapper);
on(this.element, 'paste', pasteHandlerWrapper);
if (term.browser.isFirefox) {
on(this.element, 'mousedown', function (event) {
if (event.button == 2) {
Clipboard_1.rightClickHandler(event, _this.textarea, _this.selectionManager);
}
});
}
else {
on(this.element, 'contextmenu', function (event) {
Clipboard_1.rightClickHandler(event, _this.textarea, _this.selectionManager);
});
}
if (term.browser.isLinux) {
on(this.element, 'auxclick', function (event) {
if (event.button === 1) {
Clipboard_1.moveTextAreaUnderMouseCursor(event, _this.textarea, _this.selectionManager);
}
});
}
};
Terminal.bindKeys = function (term) {
on(term.element, 'keydown', function (ev) {
if (document.activeElement != this) {
return;
}
term.keyDown(ev);
}, true);
on(term.element, 'keypress', function (ev) {
if (document.activeElement != this) {
return;
}
term.keyPress(ev);
}, true);
on(term.element, 'keyup', function (ev) {
if (!wasMondifierKeyOnlyEvent(ev)) {
term.focus(term);
}
}, true);
on(term.textarea, 'keydown', function (ev) {
term.keyDown(ev);
}, true);
on(term.textarea, 'keypress', function (ev) {
term.keyPress(ev);
this.value = '';
}, true);
on(term.textarea, 'compositionstart', term.compositionHelper.compositionstart.bind(term.compositionHelper));
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') {
row = document.createElement('div');
}
this.rowContainer.appendChild(row);
this.children.push(row);
return row;
};
Terminal.prototype.open = function (parent, focus) {
var _this = this;
var self = this, i = 0, div;
this.parent = parent || this.parent;
if (!this.parent) {
throw new Error('Terminal requires a parent element.');
}
this.context = this.parent.ownerDocument.defaultView;
this.document = this.parent.ownerDocument;
this.body = this.document.getElementsByTagName('body')[0];
this.element = this.document.createElement('div');
this.element.classList.add('terminal');
this.element.classList.add('xterm');
this.element.classList.add('xterm-theme-' + this.theme);
this.setCursorBlinking(this.options.cursorBlink);
this.element.setAttribute('tabindex', 0);
this.viewportElement = document.createElement('div');
this.viewportElement.classList.add('xterm-viewport');
this.element.appendChild(this.viewportElement);
this.viewportScrollArea = document.createElement('div');
this.viewportScrollArea.classList.add('xterm-scroll-area');
this.viewportElement.appendChild(this.viewportScrollArea);
this.selectionContainer = document.createElement('div');
this.selectionContainer.classList.add('xterm-selection');
this.element.appendChild(this.selectionContainer);
this.rowContainer = document.createElement('div');
this.rowContainer.classList.add('xterm-rows');
this.element.appendChild(this.rowContainer);
this.children = [];
this.linkifier.attachToDom(document, this.children);
this.helperContainer = document.createElement('div');
this.helperContainer.classList.add('xterm-helpers');
this.element.appendChild(this.helperContainer);
this.textarea = document.createElement('textarea');
this.textarea.classList.add('xterm-helper-textarea');
this.textarea.setAttribute('autocorrect', 'off');
this.textarea.setAttribute('autocapitalize', 'off');
this.textarea.setAttribute('spellcheck', 'false');
this.textarea.tabIndex = 0;
this.textarea.addEventListener('focus', function () {
self.emit('focus', { terminal: self });
});
this.textarea.addEventListener('blur', function () {
self.emit('blur', { terminal: self });
});
this.helperContainer.appendChild(this.textarea);
this.compositionView = document.createElement('div');
this.compositionView.classList.add('composition-view');
this.compositionHelper = new CompositionHelper_1.CompositionHelper(this.textarea, this.compositionView, this);
this.helperContainer.appendChild(this.compositionView);
this.charSizeStyleElement = document.createElement('style');
this.helperContainer.appendChild(this.charSizeStyleElement);
for (; i < this.rows; i++) {
this.insertRow();
}
this.parent.appendChild(this.element);
this.charMeasure = new CharMeasure_1.CharMeasure(document, this.helperContainer);
this.charMeasure.on('charsizechanged', function () {
self.updateCharSizeStyles();
});
this.charMeasure.measure();
this.viewport = new Viewport_1.Viewport(this, this.viewportElement, this.viewportScrollArea, this.charMeasure);
this.renderer = new Renderer_1.Renderer(this);
this.selectionManager = new SelectionManager_1.SelectionManager(this, this.lines, this.rowContainer, this.charMeasure);
this.selectionManager.on('refresh', function (data) {
_this.renderer.refreshSelection(data.start, data.end);
});
this.selectionManager.on('newselection', function (text) {
_this.textarea.value = text;
_this.textarea.focus();
_this.textarea.select();
});
this.on('scroll', function () { return _this.selectionManager.refresh(); });
this.viewportElement.addEventListener('scroll', function () { return _this.selectionManager.refresh(); });
this.refresh(0, this.rows - 1);
this.initGlobal();
if (typeof focus == 'undefined') {
var message = 'You did not pass the `focus` argument in `Terminal.prototype.open()`.\n';
message += 'The `focus` argument now defaults to `true` but starting with xterm.js 3.0 ';
message += 'it will default to `false`.';
console.warn(message);
focus = true;
}
if (focus) {
this.focus();
}
on(this.element, 'click', function () {
var selection = document.getSelection(), collapsed = selection.isCollapsed, isRange = typeof collapsed == 'boolean' ? !collapsed : selection.type == 'Range';
if (!isRange) {
self.focus();
}
});
this.bindMouse();
this.emit('open');
};
Terminal.loadAddon = function (addon, callback) {
if (true) {
return __webpack_require__(23)("./" + addon + '/' + addon);
}
else if (typeof define == 'function') {
return require(['./addons/' + addon + '/' + addon], callback);
}
else {
console.error('Cannot load a module without a CommonJS or RequireJS environment.');
return false;
}
};
Terminal.prototype.updateCharSizeStyles = function () {
this.charSizeStyleElement.textContent =
".xterm-wide-char{width:" + this.charMeasure.width * 2 + "px;}" +
(".xterm-normal-char{width:" + this.charMeasure.width + "px;}") +
(".xterm-rows > div{height:" + this.charMeasure.height + "px;}");
};
Terminal.prototype.bindMouse = function () {
var el = this.element, self = this, pressed = 32;
function sendButton(ev) {
var button, pos;
button = getButton(ev);
pos = Mouse_1.getRawByteCoords(ev, self.rowContainer, self.charMeasure, self.cols, self.rows);
if (!pos)
return;
sendEvent(button, pos);
switch (ev.overrideType || ev.type) {
case 'mousedown':
pressed = button;
break;
case 'mouseup':
pressed = 32;
break;
case 'wheel':
break;
}
}
function sendMove(ev) {
var button = pressed, pos;
pos = Mouse_1.getRawByteCoords(ev, self.rowContainer, self.charMeasure, self.cols, self.rows);
if (!pos)
return;
button += 32;
sendEvent(button, pos);
}
function encode(data, ch) {
if (!self.utfMouse) {
if (ch === 255)
return data.push(0);
if (ch > 127)
ch = 127;
data.push(ch);
}
else {
if (ch === 2047)
return data.push(0);
if (ch < 127) {
data.push(ch);
}
else {
if (ch > 2047)
ch = 2047;
data.push(0xC0 | (ch >> 6));
data.push(0x80 | (ch & 0x3F));
}
}
}
function sendEvent(button, pos) {
if (self.vt300Mouse) {
button &= 3;
pos.x -= 32;
pos.y -= 32;
var data = EscapeSequences_1.C0.ESC + '[24';
if (button === 0)
data += '1';
else if (button === 1)
data += '3';
else if (button === 2)
data += '5';
else if (button === 3)
return;
else
data += '0';
data += '~[' + pos.x + ',' + pos.y + ']\r';
self.send(data);
return;
}
if (self.decLocator) {
button &= 3;
pos.x -= 32;
pos.y -= 32;
if (button === 0)
button = 2;
else if (button === 1)
button = 4;
else if (button === 2)
button = 6;
else if (button === 3)
button = 3;
self.send(EscapeSequences_1.C0.ESC + '['
+ button
+ ';'
+ (button === 3 ? 4 : 0)
+ ';'
+ pos.y
+ ';'
+ pos.x
+ ';'
+ (pos.page || 0)
+ '&w');
return;
}
if (self.urxvtMouse) {
pos.x -= 32;
pos.y -= 32;
pos.x++;
pos.y++;
self.send(EscapeSequences_1.C0.ESC + '[' + button + ';' + pos.x + ';' + pos.y + 'M');
return;
}
if (self.sgrMouse) {
pos.x -= 32;
pos.y -= 32;
self.send(EscapeSequences_1.C0.ESC + '[<'
+ (((button & 3) === 3 ? button & ~3 : button) - 32)
+ ';'
+ pos.x
+ ';'
+ pos.y
+ ((button & 3) === 3 ? 'm' : 'M'));
return;
}
var data = [];
encode(data, button);
encode(data, pos.x);
encode(data, pos.y);
self.send(EscapeSequences_1.C0.ESC + '[M' + String.fromCharCode.apply(String, data));
}
function getButton(ev) {
var button, shift, meta, ctrl, mod;
switch (ev.overrideType || ev.type) {
case 'mousedown':
button = ev.button != null
? +ev.button
: ev.which != null
? ev.which - 1
: null;
if (self.browser.isMSIE) {
button = button === 1 ? 0 : button === 4 ? 1 : button;
}
break;
case 'mouseup':
button = 3;
break;
case 'DOMMouseScroll':
button = ev.detail < 0
? 64
: 65;
break;
case 'wheel':
button = ev.wheelDeltaY > 0
? 64
: 65;
break;
}
shift = ev.shiftKey ? 4 : 0;
meta = ev.metaKey ? 8 : 0;
ctrl = ev.ctrlKey ? 16 : 0;
mod = shift | meta | ctrl;
if (self.vt200Mouse) {
mod &= ctrl;
}
else if (!self.normalMouse) {
mod = 0;
}
button = (32 + (mod << 2)) + button;
return button;
}
on(el, 'mousedown', function (ev) {
if (!self.mouseEvents)
return;
sendButton(ev);
self.focus();
if (self.vt200Mouse) {
ev.overrideType = 'mouseup';
sendButton(ev);
return self.cancel(ev);
}
if (self.normalMouse)
on(self.document, 'mousemove', sendMove);
if (!self.x10Mouse) {
on(self.document, 'mouseup', function up(ev) {
sendButton(ev);
if (self.normalMouse)
off(self.document, 'mousemove', sendMove);
off(self.document, 'mouseup', up);
return self.cancel(ev);
});
}
return self.cancel(ev);
});
on(el, 'wheel', function (ev) {
if (!self.mouseEvents)
return;
if (self.x10Mouse
|| self.vt300Mouse
|| self.decLocator)
return;
sendButton(ev);
return self.cancel(ev);
});
on(el, 'wheel', function (ev) {
if (self.mouseEvents)
return;
self.viewport.onWheel(ev);
return self.cancel(ev);
});
on(el, 'touchstart', function (ev) {
if (self.mouseEvents)
return;
self.viewport.onTouchStart(ev);
return self.cancel(ev);
});
on(el, 'touchmove', function (ev) {
if (self.mouseEvents)
return;
self.viewport.onTouchMove(ev);
return self.cancel(ev);
});
};
Terminal.prototype.destroy = function () {
this.readable = false;
this.writable = false;
this._events = {};
this.handler = function () { };
this.write = function () { };
if (this.element && this.element.parentNode) {
this.element.parentNode.removeChild(this.element);
}
};
Terminal.prototype.refresh = function (start, end) {
if (this.renderer) {
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;
this.refresh(this.y, this.y);
}
};
Terminal.prototype.scroll = function (isWrapped) {
var row;
if (this.lines.length === this.lines.maxLength) {
this.lines.trimStart(1);
this.ybase--;
if (this.ydisp !== 0) {
this.ydisp--;
}
}
this.ybase++;
if (!this.userScrolling) {
this.ydisp = this.ybase;
}
row = this.ybase + this.rows - 1;
row -= this.rows - 1 - this.scrollBottom;
if (row === this.lines.length) {
this.lines.push(this.blankLine(undefined, isWrapped));
}
else {
this.lines.splice(row, 0, this.blankLine(undefined, isWrapped));
}
if (this.scrollTop !== 0) {
if (this.ybase !== 0) {
this.ybase--;
if (!this.userScrolling) {
this.ydisp = this.ybase;
}
}
this.lines.splice(this.ybase + this.scrollTop, 1);
}
this.updateRange(this.scrollTop);
this.updateRange(this.scrollBottom);
this.emit('scroll', this.ydisp);
};
Terminal.prototype.scrollDisp = function (disp, suppressScrollEvent) {
if (disp < 0) {
if (this.ydisp === 0) {
return;
}
this.userScrolling = true;
}
else if (disp + this.ydisp >= this.ybase) {
this.userScrolling = false;
}
this.ydisp += disp;
if (this.ydisp > this.ybase) {
this.ydisp = this.ybase;
}
else if (this.ydisp < 0) {
this.ydisp = 0;
}
if (!suppressScrollEvent) {
this.emit('scroll', this.ydisp);
}
this.refresh(0, this.rows - 1);
};
Terminal.prototype.scrollPages = function (pageCount) {
this.scrollDisp(pageCount * (this.rows - 1));
};
Terminal.prototype.scrollToTop = function () {
this.scrollDisp(-this.ydisp);
};
Terminal.prototype.scrollToBottom = function () {
this.scrollDisp(this.ybase - this.ydisp);
};
Terminal.prototype.write = function (data) {
this.writeBuffer.push(data);
if (this.options.useFlowControl && !this.xoffSentToCatchUp && this.writeBuffer.length >= WRITE_BUFFER_PAUSE_THRESHOLD) {
this.send(EscapeSequences_1.C0.DC3);
this.xoffSentToCatchUp = true;
}
if (!this.writeInProgress && this.writeBuffer.length > 0) {
this.writeInProgress = true;
var self = this;
setTimeout(function () {
self.innerWrite();
});
}
};
Terminal.prototype.innerWrite = function () {
var writeBatch = this.writeBuffer.splice(0, WRITE_BATCH_SIZE);
while (writeBatch.length > 0) {
var data = writeBatch.shift();
var l = data.length, i = 0, j, cs, ch, code, low, ch_width, row;
if (this.xoffSentToCatchUp && writeBatch.length === 0 && this.writeBuffer.length === 0) {
this.send(EscapeSequences_1.C0.DC1);
this.xoffSentToCatchUp = false;
}
this.refreshStart = this.y;
this.refreshEnd = this.y;
var state = this.parser.parse(data);
this.parser.setState(state);
this.updateRange(this.y);
this.refresh(this.refreshStart, this.refreshEnd);
}
if (this.writeBuffer.length > 0) {
var self = this;
setTimeout(function () {
self.innerWrite();
}, 0);
}
else {
this.writeInProgress = false;
}
};
Terminal.prototype.writeln = function (data) {
this.write(data + '\r\n');
};
Terminal.prototype.attachCustomKeydownHandler = function (customKeydownHandler) {
var message = 'attachCustomKeydownHandler() is DEPRECATED and will be removed soon. Please use attachCustomKeyEventHandler() instead.';
console.warn(message);
this.attachCustomKeyEventHandler(customKeydownHandler);
};
Terminal.prototype.attachCustomKeyEventHandler = function (customKeyEventHandler) {
this.customKeyEventHandler = customKeyEventHandler;
};
Terminal.prototype.setHypertextLinkHandler = function (handler) {
if (!this.linkifier) {
throw new Error('Cannot attach a hypertext link handler before Terminal.open is called');
}
this.linkifier.setHypertextLinkHandler(handler);
this.refresh(0, this.rows - 1);
};
Terminal.prototype.setHypertextValidationCallback = function (callback) {
if (!this.linkifier) {
throw new Error('Cannot attach a hypertext validation callback before Terminal.open is called');
}
this.linkifier.setHypertextValidationCallback(callback);
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.hasSelection = function () {
return this.selectionManager.hasSelection;
};
Terminal.prototype.getSelection = function () {
return this.selectionManager.selectionText;
};
Terminal.prototype.clearSelection = function () {
this.selectionManager.clearSelection();
};
Terminal.prototype.selectAll = function () {
this.selectionManager.selectAll();
};
Terminal.prototype.keyDown = function (ev) {
if (this.customKeyEventHandler && this.customKeyEventHandler(ev) === false) {
return false;
}
this.restartCursorBlinking();
if (!this.compositionHelper.keydown.bind(this.compositionHelper)(ev)) {
if (this.ybase !== this.ydisp) {
this.scrollToBottom();
}
return false;
}
var self = this;
var result = this.evaluateKeyEscapeSequence(ev);
if (result.key === EscapeSequences_1.C0.DC3) {
this.writeStopped = true;
}
else if (result.key === EscapeSequences_1.C0.DC1) {
this.writeStopped = false;
}
if (result.scrollDisp) {
this.scrollDisp(result.scrollDisp);
return this.cancel(ev, true);
}
if (isThirdLevelShift(this, ev)) {
return true;
}
if (result.cancel) {
this.cancel(ev, true);
}
if (!result.key) {
return true;
}
this.emit('keydown', ev);
this.emit('key', result.key, ev);
this.showCursor();
this.handler(result.key);
return this.cancel(ev, true);
};
Terminal.prototype.evaluateKeyEscapeSequence = function (ev) {
var result = {
cancel: false,
key: undefined,
scrollDisp: undefined
};
var modifiers = ev.shiftKey << 0 | ev.altKey << 1 | ev.ctrlKey << 2 | ev.metaKey << 3;
switch (ev.keyCode) {
case 8:
if (ev.shiftKey) {
result.key = EscapeSequences_1.C0.BS;
break;
}
result.key = EscapeSequences_1.C0.DEL;
break;
case 9:
if (ev.shiftKey) {
result.key = EscapeSequences_1.C0.ESC + '[Z';
break;
}
result.key = EscapeSequences_1.C0.HT;
result.cancel = true;
break;
case 13:
result.key = EscapeSequences_1.C0.CR;
result.cancel = true;
break;
case 27:
result.key = EscapeSequences_1.C0.ESC;
result.cancel = true;
break;
case 37:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'D';
if (result.key == EscapeSequences_1.C0.ESC + '[1;3D') {
result.key = (this.browser.isMac) ? EscapeSequences_1.C0.ESC + 'b' : EscapeSequences_1.C0.ESC + '[1;5D';
}
}
else if (this.applicationCursor) {
result.key = EscapeSequences_1.C0.ESC + 'OD';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[D';
}
break;
case 39:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'C';
if (result.key == EscapeSequences_1.C0.ESC + '[1;3C') {
result.key = (this.browser.isMac) ? EscapeSequences_1.C0.ESC + 'f' : EscapeSequences_1.C0.ESC + '[1;5C';
}
}
else if (this.applicationCursor) {
result.key = EscapeSequences_1.C0.ESC + 'OC';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[C';
}
break;
case 38:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'A';
if (result.key == EscapeSequences_1.C0.ESC + '[1;3A') {
result.key = EscapeSequences_1.C0.ESC + '[1;5A';
}
}
else if (this.applicationCursor) {
result.key = EscapeSequences_1.C0.ESC + 'OA';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[A';
}
break;
case 40:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'B';
if (result.key == EscapeSequences_1.C0.ESC + '[1;3B') {
result.key = EscapeSequences_1.C0.ESC + '[1;5B';
}
}
else if (this.applicationCursor) {
result.key = EscapeSequences_1.C0.ESC + 'OB';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[B';
}
break;
case 45:
if (!ev.shiftKey && !ev.ctrlKey) {
result.key = EscapeSequences_1.C0.ESC + '[2~';
}
break;
case 46:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[3;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[3~';
}
break;
case 36:
if (modifiers)
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'H';
else if (this.applicationCursor)
result.key = EscapeSequences_1.C0.ESC + 'OH';
else
result.key = EscapeSequences_1.C0.ESC + '[H';
break;
case 35:
if (modifiers)
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'F';
else if (this.applicationCursor)
result.key = EscapeSequences_1.C0.ESC + 'OF';
else
result.key = EscapeSequences_1.C0.ESC + '[F';
break;
case 33:
if (ev.shiftKey) {
result.scrollDisp = -(this.rows - 1);
}
else {
result.key = EscapeSequences_1.C0.ESC + '[5~';
}
break;
case 34:
if (ev.shiftKey) {
result.scrollDisp = this.rows - 1;
}
else {
result.key = EscapeSequences_1.C0.ESC + '[6~';
}
break;
case 112:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'P';
}
else {
result.key = EscapeSequences_1.C0.ESC + 'OP';
}
break;
case 113:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'Q';
}
else {
result.key = EscapeSequences_1.C0.ESC + 'OQ';
}
break;
case 114:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'R';
}
else {
result.key = EscapeSequences_1.C0.ESC + 'OR';
}
break;
case 115:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'S';
}
else {
result.key = EscapeSequences_1.C0.ESC + 'OS';
}
break;
case 116:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[15;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[15~';
}
break;
case 117:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[17;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[17~';
}
break;
case 118:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[18;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[18~';
}
break;
case 119:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[19;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[19~';
}
break;
case 120:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[20;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[20~';
}
break;
case 121:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[21;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[21~';
}
break;
case 122:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[23;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[23~';
}
break;
case 123:
if (modifiers) {
result.key = EscapeSequences_1.C0.ESC + '[24;' + (modifiers + 1) + '~';
}
else {
result.key = EscapeSequences_1.C0.ESC + '[24~';
}
break;
default:
if (ev.ctrlKey && !ev.shiftKey && !ev.altKey && !ev.metaKey) {
if (ev.keyCode >= 65 && ev.keyCode <= 90) {
result.key = String.fromCharCode(ev.keyCode - 64);
}
else if (ev.keyCode === 32) {
result.key = String.fromCharCode(0);
}
else if (ev.keyCode >= 51 && ev.keyCode <= 55) {
result.key = String.fromCharCode(ev.keyCode - 51 + 27);
}
else if (ev.keyCode === 56) {
result.key = String.fromCharCode(127);
}
else if (ev.keyCode === 219) {
result.key = String.fromCharCode(27);
}
else if (ev.keyCode === 220) {
result.key = String.fromCharCode(28);
}
else if (ev.keyCode === 221) {
result.key = String.fromCharCode(29);
}
}
else if (!this.browser.isMac && ev.altKey && !ev.ctrlKey && !ev.metaKey) {
if (ev.keyCode >= 65 && ev.keyCode <= 90) {
result.key = EscapeSequences_1.C0.ESC + String.fromCharCode(ev.keyCode + 32);
}
else if (ev.keyCode === 192) {
result.key = EscapeSequences_1.C0.ESC + '`';
}
else if (ev.keyCode >= 48 && ev.keyCode <= 57) {
result.key = EscapeSequences_1.C0.ESC + (ev.keyCode - 48);
}
}
else if (this.browser.isMac && !ev.altKey && !ev.ctrlKey && ev.metaKey) {
if (ev.keyCode === 65) {
this.selectAll();
}
}
break;
}
return result;
};
Terminal.prototype.setgLevel = function (g) {
this.glevel = g;
this.charset = this.charsets[g];
};
Terminal.prototype.setgCharset = function (g, charset) {
this.charsets[g] = charset;
if (this.glevel === g) {
this.charset = charset;
}
};
Terminal.prototype.keyPress = function (ev) {
var key;
if (this.customKeyEventHandler && this.customKeyEventHandler(ev) === false) {
return false;
}
this.cancel(ev);
if (ev.charCode) {
key = ev.charCode;
}
else if (ev.which == null) {
key = ev.keyCode;
}
else if (ev.which !== 0 && ev.charCode !== 0) {
key = ev.which;
}
else {
return false;
}
if (!key || ((ev.altKey || ev.ctrlKey || ev.metaKey) && !isThirdLevelShift(this, ev))) {
return false;
}
key = String.fromCharCode(key);
this.emit('keypress', key, ev);
this.emit('key', key, ev);
this.showCursor();
this.handler(key);
return true;
};
Terminal.prototype.send = function (data) {
var self = this;
if (!this.queue) {
setTimeout(function () {
self.handler(self.queue);
self.queue = '';
}, 1);
}
this.queue += data;
};
Terminal.prototype.bell = function () {
if (!this.visualBell)
return;
var self = this;
this.element.style.borderColor = 'white';
setTimeout(function () {
self.element.style.borderColor = '';
}, 10);
if (this.popOnBell)
this.focus();
};
Terminal.prototype.log = function () {
if (!this.debug)
return;
if (!this.context.console || !this.context.console.log)
return;
var args = Array.prototype.slice.call(arguments);
this.context.console.log.apply(this.context.console, args);
};
Terminal.prototype.error = function () {
if (!this.debug)
return;
if (!this.context.console || !this.context.console.error)
return;
var args = Array.prototype.slice.call(arguments);
this.context.console.error.apply(this.context.console, args);
};
Terminal.prototype.resize = function (x, y) {
if (isNaN(x) || isNaN(y)) {
return;
}
if (y > this.getOption('scrollback')) {
this.setOption('scrollback', y);
}
var line, el, i, j, ch, addToY;
if (x === this.cols && y === this.rows) {
return;
}
if (x < 1)
x = 1;
if (y < 1)
y = 1;
j = this.cols;
if (j < x) {
ch = [this.defAttr, ' ', 1];
i = this.lines.length;
while (i--) {
while (this.lines.get(i).length < x) {
this.lines.get(i).push(ch);
}
}
}
this.cols = x;
this.setupStops(this.cols);
j = this.rows;
addToY = 0;
if (j < y) {
el = this.element;
while (j++ < y) {
if (this.lines.length < y + this.ybase) {
if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) {
this.ybase--;
addToY++;
if (this.ydisp > 0) {
this.ydisp--;
}
}
else {
this.lines.push(this.blankLine());
}
}
if (this.children.length < y) {
this.insertRow();
}
}
}
else {
while (j-- > y) {
if (this.lines.length > y + this.ybase) {
if (this.lines.length > this.ybase + this.y + 1) {
this.lines.pop();
}
else {
this.ybase++;
this.ydisp++;
}
}
if (this.children.length > y) {
el = this.children.shift();
if (!el)
continue;
el.parentNode.removeChild(el);
}
}
}
this.rows = y;
if (this.y >= y) {
this.y = y - 1;
}
if (addToY) {
this.y += addToY;
}
if (this.x >= x) {
this.x = x - 1;
}
this.scrollTop = 0;
this.scrollBottom = y - 1;
this.charMeasure.measure();
this.refresh(0, this.rows - 1);
this.normal = null;
this.geometry = [this.cols, this.rows];
this.emit('resize', { terminal: this, cols: x, rows: y });
};
Terminal.prototype.updateRange = function (y) {
if (y < this.refreshStart)
this.refreshStart = y;
if (y > this.refreshEnd)
this.refreshEnd = y;
};
Terminal.prototype.maxRange = function () {
this.refreshStart = 0;
this.refreshEnd = this.rows - 1;
};
Terminal.prototype.setupStops = function (i) {
if (i != null) {
if (!this.tabs[i]) {
i = this.prevStop(i);
}
}
else {
this.tabs = {};
i = 0;
}
for (; i < this.cols; i += this.getOption('tabStopWidth')) {
this.tabs[i] = true;
}
};
Terminal.prototype.prevStop = function (x) {
if (x == null)
x = this.x;
while (!this.tabs[--x] && x > 0)
;
return x >= this.cols
? this.cols - 1
: x < 0 ? 0 : x;
};
Terminal.prototype.nextStop = function (x) {
if (x == null)
x = this.x;
while (!this.tabs[++x] && x < this.cols)
;
return x >= this.cols
? this.cols - 1
: x < 0 ? 0 : x;
};
Terminal.prototype.eraseRight = function (x, y) {
var line = this.lines.get(this.ybase + y);
if (!line) {
return;
}
var ch = [this.eraseAttr(), ' ', 1];
for (; x < this.cols; x++) {
line[x] = ch;
}
this.updateRange(y);
};
Terminal.prototype.eraseLeft = function (x, y) {
var line = this.lines.get(this.ybase + y);
if (!line) {
return;
}
var ch = [this.eraseAttr(), ' ', 1];
x++;
while (x--) {
line[x] = ch;
}
this.updateRange(y);
};
Terminal.prototype.clear = function () {
if (this.ybase === 0 && this.y === 0) {
return;
}
this.lines.set(0, this.lines.get(this.ybase + this.y));
this.lines.length = 1;
this.ydisp = 0;
this.ybase = 0;
this.y = 0;
for (var i = 1; i < this.rows; i++) {
this.lines.push(this.blankLine());
}
this.refresh(0, this.rows - 1);
this.emit('scroll', this.ydisp);
};
Terminal.prototype.eraseLine = function (y) {
this.eraseRight(0, y);
};
Terminal.prototype.blankLine = function (cur, isWrapped) {
var attr = cur
? this.eraseAttr()
: this.defAttr;
var ch = [attr, ' ', 1], line = [], i = 0;
if (isWrapped) {
line.isWrapped = isWrapped;
}
for (; i < this.cols; i++) {
line[i] = ch;
}
return line;
};
Terminal.prototype.ch = function (cur) {
return cur
? [this.eraseAttr(), ' ', 1]
: [this.defAttr, ' ', 1];
};
Terminal.prototype.is = function (term) {
var name = this.termName;
return (name + '').indexOf(term) === 0;
};
Terminal.prototype.handler = function (data) {
if (this.options.disableStdin) {
return;
}
if (this.ybase !== this.ydisp) {
this.scrollToBottom();
}
this.emit('data', data);
};
Terminal.prototype.handleTitle = function (title) {
this.emit('title', title);
};
Terminal.prototype.index = function () {
this.y++;
if (this.y > this.scrollBottom) {
this.y--;
this.scroll();
}
if (this.x >= this.cols) {
this.x--;
}
};
Terminal.prototype.reverseIndex = function () {
var j;
if (this.y === this.scrollTop) {
this.lines.shiftElements(this.y + this.ybase, this.rows - 1, 1);
this.lines.set(this.y + this.ybase, this.blankLine(true));
this.updateRange(this.scrollTop);
this.updateRange(this.scrollBottom);
}
else {
this.y--;
}
};
Terminal.prototype.reset = function () {
this.options.rows = this.rows;
this.options.cols = this.cols;
var customKeyEventHandler = this.customKeyEventHandler;
var cursorBlinkInterval = this.cursorBlinkInterval;
Terminal.call(this, this.options);
this.customKeyEventHandler = customKeyEventHandler;
this.cursorBlinkInterval = cursorBlinkInterval;
this.refresh(0, this.rows - 1);
this.viewport.syncScrollArea();
};
Terminal.prototype.tabSet = function () {
this.tabs[this.x] = true;
};
function on(el, type, handler, capture) {
if (!Array.isArray(el)) {
el = [el];
}
el.forEach(function (element) {
element.addEventListener(type, handler, capture || false);
});
}
function off(el, type, handler, capture) {
el.removeEventListener(type, handler, capture || false);
}
function cancel(ev, force) {
if (!this.cancelEvents && !force) {
return;
}
ev.preventDefault();
ev.stopPropagation();
return false;
}
function inherits(child, parent) {
function f() {
this.constructor = child;
}
f.prototype = parent.prototype;
child.prototype = new f;
}
function indexOf(obj, el) {
var i = obj.length;
while (i--) {
if (obj[i] === el)
return i;
}
return -1;
}
function isThirdLevelShift(term, ev) {
var thirdLevelKey = (term.browser.isMac && ev.altKey && !ev.ctrlKey && !ev.metaKey) ||
(term.browser.isMSWindows && ev.altKey && ev.ctrlKey && !ev.metaKey);
if (ev.type == 'keypress') {
return thirdLevelKey;
}
return thirdLevelKey && (!ev.keyCode || ev.keyCode > 47);
}
Terminal.prototype.matchColor = matchColor;
function matchColor(r1, g1, b1) {
var hash = (r1 << 16) | (g1 << 8) | b1;
if (matchColor._cache[hash] != null) {
return matchColor._cache[hash];
}
var ldiff = Infinity, li = -1, i = 0, c, r2, g2, b2, diff;
for (; i < Terminal.vcolors.length; i++) {
c = Terminal.vcolors[i];
r2 = c[0];
g2 = c[1];
b2 = c[2];
diff = matchColor.distance(r1, g1, b1, r2, g2, b2);
if (diff === 0) {
li = i;
break;
}
if (diff < ldiff) {
ldiff = diff;
li = i;
}
}
return matchColor._cache[hash] = li;
}
matchColor._cache = {};
matchColor.distance = function (r1, g1, b1, r2, g2, b2) {
return Math.pow(30 * (r1 - r2), 2)
+ Math.pow(59 * (g1 - g2), 2)
+ Math.pow(11 * (b1 - b2), 2);
};
function each(obj, iter, con) {
if (obj.forEach)
return obj.forEach(iter, con);
for (var i = 0; i < obj.length; i++) {
iter.call(con, obj[i], i, obj);
}
}
function wasMondifierKeyOnlyEvent(ev) {
return ev.keyCode === 16 ||
ev.keyCode === 17 ||
ev.keyCode === 18;
}
function keys(obj) {
if (Object.keys)
return Object.keys(obj);
var key, keys = [];
for (key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
keys.push(key);
}
}
return keys;
}
Terminal.EventEmitter = EventEmitter_1.EventEmitter;
Terminal.inherits = inherits;
Terminal.on = on;
Terminal.off = off;
Terminal.cancel = cancel;
module.exports = Terminal;
//# sourceMappingURL=xterm.js.map
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
;
var EventEmitter = (function () {
function EventEmitter() {
this._events = this._events || {};
}
EventEmitter.prototype.on = function (type, listener) {
this._events[type] = this._events[type] || [];
this._events[type].push(listener);
};
EventEmitter.prototype.off = function (type, listener) {
if (!this._events[type]) {
return;
}
var obj = this._events[type];
var i = obj.length;
while (i--) {
if (obj[i] === listener || obj[i].listener === listener) {
obj.splice(i, 1);
return;
}
}
};
EventEmitter.prototype.removeAllListeners = function (type) {
if (this._events[type]) {
delete this._events[type];
}
};
EventEmitter.prototype.once = function (type, listener) {
function on() {
var args = Array.prototype.slice.call(arguments);
this.off(type, on);
return listener.apply(this, args);
}
on.listener = listener;
return this.on(type, on);
};
EventEmitter.prototype.emit = function (type) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
if (!this._events[type]) {
return;
}
var obj = this._events[type];
for (var i = 0; i < obj.length; i++) {
obj[i].apply(this, args);
}
};
EventEmitter.prototype.listeners = function (type) {
return this._events[type] || [];
};
return EventEmitter;
}());
exports.EventEmitter = EventEmitter;
//# sourceMappingURL=EventEmitter.js.map
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var C0;
(function (C0) {
C0.NUL = '\x00';
C0.SOH = '\x01';
C0.STX = '\x02';
C0.ETX = '\x03';
C0.EOT = '\x04';
C0.ENQ = '\x05';
C0.ACK = '\x06';
C0.BEL = '\x07';
C0.BS = '\x08';
C0.HT = '\x09';
C0.LF = '\x0a';
C0.VT = '\x0b';
C0.FF = '\x0c';
C0.CR = '\x0d';
C0.SO = '\x0e';
C0.SI = '\x0f';
C0.DLE = '\x10';
C0.DC1 = '\x11';
C0.DC2 = '\x12';
C0.DC3 = '\x13';
C0.DC4 = '\x14';
C0.NAK = '\x15';
C0.SYN = '\x16';
C0.ETB = '\x17';
C0.CAN = '\x18';
C0.EM = '\x19';
C0.SUB = '\x1a';
C0.ESC = '\x1b';
C0.FS = '\x1c';
C0.GS = '\x1d';
C0.RS = '\x1e';
C0.US = '\x1f';
C0.SP = '\x20';
C0.DEL = '\x7f';
})(C0 = exports.C0 || (exports.C0 = {}));
;
//# sourceMappingURL=EscapeSequences.js.map
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CHARSETS = {};
exports.DEFAULT_CHARSET = exports.CHARSETS['B'];
exports.CHARSETS['0'] = {
'`': '\u25c6',
'a': '\u2592',
'b': '\u0009',
'c': '\u000c',
'd': '\u000d',
'e': '\u000a',
'f': '\u00b0',
'g': '\u00b1',
'h': '\u2424',
'i': '\u000b',
'j': '\u2518',
'k': '\u2510',
'l': '\u250c',
'm': '\u2514',
'n': '\u253c',
'o': '\u23ba',
'p': '\u23bb',
'q': '\u2500',
'r': '\u23bc',
's': '\u23bd',
't': '\u251c',
'u': '\u2524',
'v': '\u2534',
'w': '\u252c',
'x': '\u2502',
'y': '\u2264',
'z': '\u2265',
'{': '\u03c0',
'|': '\u2260',
'}': '\u00a3',
'~': '\u00b7'
};
exports.CHARSETS['A'] = {
'#': '£'
};
exports.CHARSETS['B'] = null;
exports.CHARSETS['4'] = {
'#': '£',
'@': '¾',
'[': 'ij',
'\\': '½',
']': '|',
'{': '¨',
'|': 'f',
'}': '¼',
'~': '´'
};
exports.CHARSETS['C'] =
exports.CHARSETS['5'] = {
'[': 'Ä',
'\\': 'Ö',
']': 'Å',
'^': 'Ü',
'`': 'é',
'{': 'ä',
'|': 'ö',
'}': 'å',
'~': 'ü'
};
exports.CHARSETS['R'] = {
'#': '£',
'@': 'à',
'[': '°',
'\\': 'ç',
']': '§',
'{': 'é',
'|': 'ù',
'}': 'è',
'~': '¨'
};
exports.CHARSETS['Q'] = {
'@': 'à',
'[': 'â',
'\\': 'ç',
']': 'ê',
'^': 'î',
'`': 'ô',
'{': 'é',
'|': 'ù',
'}': 'è',
'~': 'û'
};
exports.CHARSETS['K'] = {
'@': '§',
'[': 'Ä',
'\\': 'Ö',
']': 'Ü',
'{': 'ä',
'|': 'ö',
'}': 'ü',
'~': 'ß'
};
exports.CHARSETS['Y'] = {
'#': '£',
'@': '§',
'[': '°',
'\\': 'ç',
']': 'é',
'`': 'ù',
'{': 'à',
'|': 'ò',
'}': 'è',
'~': 'ì'
};
exports.CHARSETS['E'] =
exports.CHARSETS['6'] = {
'@': 'Ä',
'[': 'Æ',
'\\': 'Ø',
']': 'Å',
'^': 'Ü',
'`': 'ä',
'{': 'æ',
'|': 'ø',
'}': 'å',
'~': 'ü'
};
exports.CHARSETS['Z'] = {
'#': '£',
'@': '§',
'[': '¡',
'\\': 'Ñ',
']': '¿',
'{': '°',
'|': 'ñ',
'}': 'ç'
};
exports.CHARSETS['H'] =
exports.CHARSETS['7'] = {
'@': 'É',
'[': 'Ä',
'\\': 'Ö',
']': 'Å',
'^': 'Ü',
'`': 'é',
'{': 'ä',
'|': 'ö',
'}': 'å',
'~': 'ü'
};
exports.CHARSETS['='] = {
'#': 'ù',
'@': 'à',
'[': 'é',
'\\': 'ç',
']': 'ê',
'^': 'î',
'_': 'è',
'`': 'ô',
'{': 'ä',
'|': 'ö',
'}': 'ü',
'~': 'û'
};
//# sourceMappingURL=Charsets.js.map
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
/**
* Implements the attach method, that attaches the terminal to a WebSocket stream.
* @module xterm/addons/attach/attach
* @license MIT
*/
(function (attach) {
if (true) {
/*
* CommonJS environment
*/
module.exports = attach(__webpack_require__(0));
} 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;
});
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
/**
* 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 (true) {
/*
* CommonJS environment
*/
module.exports = fit(__webpack_require__(0));
} else if (typeof define == 'function') {
/*
* Require.js is available
*/
define(['../../xterm'], fit);
} else {
/*
* Plain browser environment
*/
fit(window.Terminal);
}
})(function (Xterm) {
var exports = {};
exports.proposeGeometry = function (term) {
if (!term.element.parentElement) {
return null;
}
var parentElementStyle = window.getComputedStyle(term.element.parentElement),
parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height')),
parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')) - 17),
elementStyle = window.getComputedStyle(term.element),
elementPaddingVer = parseInt(elementStyle.getPropertyValue('padding-top')) + parseInt(elementStyle.getPropertyValue('padding-bottom')),
elementPaddingHor = parseInt(elementStyle.getPropertyValue('padding-right')) + parseInt(elementStyle.getPropertyValue('padding-left')),
availableHeight = parentElementHeight - elementPaddingVer,
availableWidth = parentElementWidth - elementPaddingHor,
container = term.rowContainer,
subjectRow = term.rowContainer.firstElementChild,
contentBuffer = subjectRow.innerHTML,
characterHeight,
rows,
characterWidth,
cols,
geometry;
subjectRow.style.display = 'inline';
subjectRow.innerHTML = 'W'; // Common character for measuring width, although on monospace
characterWidth = subjectRow.getBoundingClientRect().width;
subjectRow.style.display = ''; // Revert style before calculating height, since they differ.
characterHeight = subjectRow.getBoundingClientRect().height;
subjectRow.innerHTML = contentBuffer;
rows = parseInt(availableHeight / characterHeight);
cols = parseInt(availableWidth / characterWidth);
geometry = {cols: cols, rows: rows};
return geometry;
};
exports.fit = function (term) {
var geometry = exports.proposeGeometry(term);
if (geometry) {
term.resize(geometry.cols, geometry.rows);
}
};
Xterm.prototype.proposeGeometry = function () {
return exports.proposeGeometry(this);
};
Xterm.prototype.fit = function () {
return exports.fit(this);
};
return exports;
});
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
/**
* Fullscreen addon for xterm.js
* @module xterm/addons/fullscreen/fullscreen
* @license MIT
*/
(function (fullscreen) {
if (true) {
/*
* CommonJS environment
*/
module.exports = fullscreen(__webpack_require__(0));
} 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;
});
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
/**
* This module provides methods for attaching a terminal to a terminado WebSocket stream.
*
* @module xterm/addons/terminado/terminado
* @license MIT
*/
(function (attach) {
if (true) {
/*
* CommonJS environment
*/
module.exports = attach(__webpack_require__(0));
} 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;
});
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Generic_1 = __webpack_require__(33);
var isNode = (typeof navigator === 'undefined') ? true : false;
var userAgent = (isNode) ? 'node' : navigator.userAgent;
var platform = (isNode) ? 'node' : navigator.platform;
exports.isFirefox = !!~userAgent.indexOf('Firefox');
exports.isMSIE = !!~userAgent.indexOf('MSIE') || !!~userAgent.indexOf('Trident');
exports.isMac = Generic_1.contains(['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'], platform);
exports.isIpad = platform === 'iPad';
exports.isIphone = platform === 'iPhone';
exports.isMSWindows = Generic_1.contains(['Windows', 'Win16', 'Win32', 'WinCE'], platform);
exports.isLinux = platform.indexOf('Linux') >= 0;
//# sourceMappingURL=Browser.js.map
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function getCoordsRelativeToElement(event, element) {
if (event.pageX == null) {
return null;
}
var x = event.pageX;
var y = event.pageY;
while (element && element !== self.document.documentElement) {
x -= element.offsetLeft;
y -= element.offsetTop;
element = 'offsetParent' in element ? element.offsetParent : element.parentElement;
}
return [x, y];
}
exports.getCoordsRelativeToElement = getCoordsRelativeToElement;
function getCoords(event, rowContainer, charMeasure, colCount, rowCount, isSelection) {
var coords = getCoordsRelativeToElement(event, rowContainer);
coords[0] = Math.ceil((coords[0] + (isSelection ? charMeasure.width / 2 : 0)) / charMeasure.width);
coords[1] = Math.ceil(coords[1] / charMeasure.height);
coords[0] = Math.min(Math.max(coords[0], 1), colCount + 1);
coords[1] = Math.min(Math.max(coords[1], 1), rowCount + 1);
return coords;
}
exports.getCoords = getCoords;
function getRawByteCoords(event, rowContainer, charMeasure, colCount, rowCount) {
var coords = getCoords(event, rowContainer, charMeasure, colCount, rowCount);
var x = coords[0];
var y = coords[1];
x += 32;
y += 32;
return { x: x, y: y };
}
exports.getRawByteCoords = getRawByteCoords;
//# sourceMappingURL=Mouse.js.map
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var bare = __webpack_require__(34);
var bareLib = __webpack_require__(35);
var TermHterm = (function () {
function TermHterm(elem) {
this.elem = elem;
hterm.defaultStorage = new bareLib.Storage.Memory();
this.term = new bare.Terminal();
this.term.getPrefs().set("send-encoding", "raw");
this.term.decorate(this.elem);
this.io = this.term.io.push();
this.term.installKeyboard();
}
;
TermHterm.prototype.info = function () {
return { columns: this.columns, rows: this.rows };
};
;
TermHterm.prototype.output = function (data) {
if (this.term.io != null) {
this.term.io.writeUTF16(data);
}
};
;
TermHterm.prototype.showMessage = function (message, timeout) {
this.message = message;
if (timeout > 0) {
this.term.io.showOverlay(message, timeout);
}
else {
this.term.io.showOverlay(message, null);
}
};
;
TermHterm.prototype.removeMessage = function () {
// there is no hideOverlay(), so show the same message with 0 sec
this.term.io.showOverlay(this.message, 0);
};
TermHterm.prototype.setWindowTitle = function (title) {
this.term.setWindowTitle(title);
};
;
TermHterm.prototype.setPreferences = function (value) {
var _this = this;
Object.keys(value).forEach(function (key) {
_this.term.getPrefs().set(key, value[key]);
});
};
;
TermHterm.prototype.onInput = function (callback) {
this.io.onVTKeystroke = function (data) {
callback(data);
};
this.io.sendString = function (data) {
callback(data);
};
};
;
TermHterm.prototype.onResize = function (callback) {
var _this = this;
this.io.onTerminalResize = function (columns, rows) {
_this.columns = columns;
_this.rows = rows;
callback(columns, rows);
};
};
;
TermHterm.prototype.deactivate = function () {
this.io.onVTKeystroke = null;
this.io.sendString = null;
this.io.onTerminalResize = null;
this.term.uninstallKeyboard();
};
TermHterm.prototype.reset = function () {
this.removeMessage();
this.term.installKeyboard();
};
TermHterm.prototype.close = function () {
this.term.uninstallKeyboard();
};
return TermHterm;
}());
exports.TermHterm = TermHterm;
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var ConnectionFactory = (function () {
function ConnectionFactory(url, protocols) {
this.url = url;
this.protocols = protocols;
}
;
ConnectionFactory.prototype.create = function () {
return new Connection(this.url, this.protocols);
};
;
return ConnectionFactory;
}());
exports.ConnectionFactory = ConnectionFactory;
var Connection = (function () {
function Connection(url, protocols) {
this.bare = new WebSocket(url, protocols);
}
Connection.prototype.open = function () {
// nothing todo for websocket
};
;
Connection.prototype.close = function () {
this.bare.close();
};
;
Connection.prototype.send = function (data) {
this.bare.send(data);
};
;
Connection.prototype.isOpen = function () {
if (this.bare.readyState == WebSocket.CONNECTING ||
this.bare.readyState == WebSocket.OPEN) {
return true;
}
return false;
};
Connection.prototype.onOpen = function (callback) {
this.bare.onopen = function (event) {
callback();
};
};
;
Connection.prototype.onReceive = function (callback) {
this.bare.onmessage = function (event) {
callback(event.data);
};
};
;
Connection.prototype.onClose = function (callback) {
this.bare.onclose = function (event) {
callback();
};
};
;
return Connection;
}());
exports.Connection = Connection;
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.protocols = ["webtty"];
exports.msgInputUnknown = '0';
exports.msgInput = '1';
exports.msgPing = '2';
exports.msgResizeTerminal = '3';
exports.msgUnknownOutput = '0';
exports.msgOutput = '1';
exports.msgPong = '2';
exports.msgSetWindowTitle = '3';
exports.msgSetPreferences = '4';
exports.msgSetReconnect = '5';
var WebTTY = (function () {
function WebTTY(term, connectionFactory, args, authToken) {
this.term = term;
this.connectionFactory = connectionFactory;
this.args = args;
this.authToken = authToken;
this.reconnect = -1;
}
;
WebTTY.prototype.open = function () {
var _this = this;
var connection = this.connectionFactory.create();
var pingTimer;
var reconnectTimeout;
var setup = function () {
connection.onOpen(function () {
var termInfo = _this.term.info();
connection.send(JSON.stringify({
Arguments: _this.args,
AuthToken: _this.authToken,
}));
var resizeHandler = function (colmuns, rows) {
connection.send(exports.msgResizeTerminal + JSON.stringify({
columns: colmuns,
rows: rows
}));
};
_this.term.onResize(resizeHandler);
resizeHandler(termInfo.columns, termInfo.rows);
_this.term.onInput(function (input) {
connection.send(exports.msgInput + input);
});
pingTimer = setInterval(function () {
connection.send(exports.msgPing);
}, 30 * 1000);
});
connection.onReceive(function (data) {
var payload = data.slice(1);
switch (data[0]) {
case exports.msgOutput:
_this.term.output(decodeURIComponent(Array.prototype.map.call(atob(payload), function (c) {
return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
}).join('')));
break;
case exports.msgPong:
break;
case exports.msgSetWindowTitle:
_this.term.setWindowTitle(payload);
break;
case exports.msgSetPreferences:
var preferences = JSON.parse(payload);
_this.term.setPreferences(preferences);
break;
case exports.msgSetReconnect:
var autoReconnect = JSON.parse(payload);
console.log("Enabling reconnect: " + autoReconnect + " seconds");
_this.reconnect = autoReconnect;
break;
}
});
connection.onClose(function () {
clearInterval(pingTimer);
_this.term.deactivate();
_this.term.showMessage("Connection Closed", 0);
if (_this.reconnect > 0) {
reconnectTimeout = setTimeout(function () {
connection = _this.connectionFactory.create();
_this.term.reset();
setup();
}, _this.reconnect * 1000);
}
});
connection.open();
};
setup();
return function () {
clearTimeout(reconnectTimeout);
connection.close();
};
};
;
return WebTTY;
}());
exports.WebTTY = WebTTY;
;
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var bare = __webpack_require__(0);
bare.loadAddon("fit");
var TermXterm = (function () {
function TermXterm(elem) {
var _this = this;
this.elem = elem;
this.term = new bare();
this.message = elem.ownerDocument.createElement("div");
this.message.className = "xterm-overlay";
this.messageTimeout = 2000;
this.resizeListener = function () {
_this.term.fit();
_this.term.scrollToBottom();
_this.showMessage(String(_this.term.cols) + "x" + String(_this.term.rows), _this.messageTimeout);
};
this.term.on("open", function () {
_this.resizeListener();
window.addEventListener("resize", function () { _this.resizeListener(); });
});
this.term.open(elem, true);
}
;
TermXterm.prototype.info = function () {
return { columns: this.term.cols, rows: this.term.rows };
};
;
TermXterm.prototype.output = function (data) {
this.term.write(data);
};
;
TermXterm.prototype.showMessage = function (message, timeout) {
var _this = this;
this.message.textContent = message;
this.elem.appendChild(this.message);
if (this.messageTimer) {
clearTimeout(this.messageTimer);
}
if (timeout > 0) {
this.messageTimer = setTimeout(function () {
_this.elem.removeChild(_this.message);
}, timeout);
}
};
;
TermXterm.prototype.removeMessage = function () {
if (this.message.parentNode == this.elem) {
this.elem.removeChild(this.message);
}
};
TermXterm.prototype.setWindowTitle = function (title) {
document.title = title;
};
;
TermXterm.prototype.setPreferences = function (value) {
};
;
TermXterm.prototype.onInput = function (callback) {
this.term.on("data", function (data) {
callback(data);
});
};
;
TermXterm.prototype.onResize = function (callback) {
this.term.on("resize", function (data) {
callback(data.cols, data.rows);
});
};
;
TermXterm.prototype.deactivate = function () {
this.term.off("data");
this.term.off("resize");
this.term.blur();
};
TermXterm.prototype.reset = function () {
this.removeMessage();
this.term.clear();
};
TermXterm.prototype.close = function () {
window.removeEventListener("resize", this.resizeListener);
this.term.destroy();
};
return TermXterm;
}());
exports.TermXterm = TermXterm;
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var hterm_1 = __webpack_require__(10);
var xterm_1 = __webpack_require__(13);
var webtty_1 = __webpack_require__(12);
var websocket_1 = __webpack_require__(11);
var elem = document.getElementById("terminal");
if (elem !== null) {
var term;
if (gotty_term == "hterm") {
term = new hterm_1.TermHterm(elem);
}
else {
term = new xterm_1.TermXterm(elem);
}
var httpsEnabled = window.location.protocol == "https:";
var url = (httpsEnabled ? 'wss://' : 'ws://') + window.location.host + window.location.pathname + 'ws';
var args = window.location.search;
var factory = new websocket_1.ConnectionFactory(url, webtty_1.protocols);
var wt = new webtty_1.WebTTY(term, factory, args, gotty_auth_token);
var closer_1 = wt.open();
window.addEventListener("unload", function () {
closer_1();
term.close();
});
}
;
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var CompositionHelper = (function () {
function CompositionHelper(textarea, compositionView, terminal) {
this.textarea = textarea;
this.compositionView = compositionView;
this.terminal = terminal;
this.isComposing = false;
this.isSendingComposition = false;
this.compositionPosition = { start: null, end: null };
}
CompositionHelper.prototype.compositionstart = function () {
this.isComposing = true;
this.compositionPosition.start = this.textarea.value.length;
this.compositionView.textContent = '';
this.compositionView.classList.add('active');
};
CompositionHelper.prototype.compositionupdate = function (ev) {
var _this = this;
this.compositionView.textContent = ev.data;
this.updateCompositionElements();
setTimeout(function () {
_this.compositionPosition.end = _this.textarea.value.length;
}, 0);
};
CompositionHelper.prototype.compositionend = function () {
this.finalizeComposition(true);
};
CompositionHelper.prototype.keydown = function (ev) {
if (this.isComposing || this.isSendingComposition) {
if (ev.keyCode === 229) {
return false;
}
else if (ev.keyCode === 16 || ev.keyCode === 17 || ev.keyCode === 18) {
return false;
}
else {
this.finalizeComposition(false);
}
}
if (ev.keyCode === 229) {
this.handleAnyTextareaChanges();
return false;
}
return true;
};
CompositionHelper.prototype.finalizeComposition = function (waitForPropogation) {
var _this = this;
this.compositionView.classList.remove('active');
this.isComposing = false;
this.clearTextareaPosition();
if (!waitForPropogation) {
this.isSendingComposition = false;
var input = this.textarea.value.substring(this.compositionPosition.start, this.compositionPosition.end);
this.terminal.handler(input);
}
else {
var currentCompositionPosition_1 = {
start: this.compositionPosition.start,
end: this.compositionPosition.end,
};
this.isSendingComposition = true;
setTimeout(function () {
if (_this.isSendingComposition) {
_this.isSendingComposition = false;
var input = void 0;
if (_this.isComposing) {
input = _this.textarea.value.substring(currentCompositionPosition_1.start, currentCompositionPosition_1.end);
}
else {
input = _this.textarea.value.substring(currentCompositionPosition_1.start);
}
_this.terminal.handler(input);
}
}, 0);
}
};
CompositionHelper.prototype.handleAnyTextareaChanges = function () {
var _this = this;
var oldValue = this.textarea.value;
setTimeout(function () {
if (!_this.isComposing) {
var newValue = _this.textarea.value;
var diff = newValue.replace(oldValue, '');
if (diff.length > 0) {
_this.terminal.handler(diff);
}
}
}, 0);
};
CompositionHelper.prototype.updateCompositionElements = function (dontRecurse) {
var _this = this;
if (!this.isComposing) {
return;
}
var cursor = this.terminal.element.querySelector('.terminal-cursor');
if (cursor) {
var xtermRows = this.terminal.element.querySelector('.xterm-rows');
var cursorTop = xtermRows.offsetTop + cursor.offsetTop;
this.compositionView.style.left = cursor.offsetLeft + 'px';
this.compositionView.style.top = cursorTop + 'px';
this.compositionView.style.height = cursor.offsetHeight + 'px';
this.compositionView.style.lineHeight = cursor.offsetHeight + 'px';
var compositionViewBounds = this.compositionView.getBoundingClientRect();
this.textarea.style.left = cursor.offsetLeft + 'px';
this.textarea.style.top = cursorTop + 'px';
this.textarea.style.width = compositionViewBounds.width + 'px';
this.textarea.style.height = compositionViewBounds.height + 'px';
this.textarea.style.lineHeight = compositionViewBounds.height + 'px';
}
if (!dontRecurse) {
setTimeout(function () { return _this.updateCompositionElements(true); }, 0);
}
};
;
CompositionHelper.prototype.clearTextareaPosition = function () {
this.textarea.style.left = '';
this.textarea.style.top = '';
};
;
return CompositionHelper;
}());
exports.CompositionHelper = CompositionHelper;
//# sourceMappingURL=CompositionHelper.js.map
/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var EscapeSequences_1 = __webpack_require__(2);
var Charsets_1 = __webpack_require__(3);
var InputHandler = (function () {
function InputHandler(_terminal) {
this._terminal = _terminal;
}
InputHandler.prototype.addChar = function (char, code) {
if (char >= ' ') {
var ch_width = wcwidth(code);
if (this._terminal.charset && this._terminal.charset[char]) {
char = this._terminal.charset[char];
}
var row = this._terminal.y + this._terminal.ybase;
if (!ch_width && this._terminal.x) {
if (this._terminal.lines.get(row)[this._terminal.x - 1]) {
if (!this._terminal.lines.get(row)[this._terminal.x - 1][2]) {
if (this._terminal.lines.get(row)[this._terminal.x - 2])
this._terminal.lines.get(row)[this._terminal.x - 2][1] += char;
}
else {
this._terminal.lines.get(row)[this._terminal.x - 1][1] += char;
}
this._terminal.updateRange(this._terminal.y);
}
return;
}
if (this._terminal.x + ch_width - 1 >= this._terminal.cols) {
if (this._terminal.wraparoundMode) {
this._terminal.x = 0;
this._terminal.y++;
if (this._terminal.y > this._terminal.scrollBottom) {
this._terminal.y--;
this._terminal.scroll(true);
}
else {
this._terminal.lines.get(this._terminal.y).isWrapped = true;
}
}
else {
if (ch_width === 2)
return;
}
}
row = this._terminal.y + this._terminal.ybase;
if (this._terminal.insertMode) {
for (var moves = 0; moves < ch_width; ++moves) {
var removed = this._terminal.lines.get(this._terminal.y + this._terminal.ybase).pop();
if (removed[2] === 0
&& this._terminal.lines.get(row)[this._terminal.cols - 2]
&& this._terminal.lines.get(row)[this._terminal.cols - 2][2] === 2) {
this._terminal.lines.get(row)[this._terminal.cols - 2] = [this._terminal.curAttr, ' ', 1];
}
this._terminal.lines.get(row).splice(this._terminal.x, 0, [this._terminal.curAttr, ' ', 1]);
}
}
this._terminal.lines.get(row)[this._terminal.x] = [this._terminal.curAttr, char, ch_width];
this._terminal.x++;
this._terminal.updateRange(this._terminal.y);
if (ch_width === 2) {
this._terminal.lines.get(row)[this._terminal.x] = [this._terminal.curAttr, '', 0];
this._terminal.x++;
}
}
};
InputHandler.prototype.bell = function () {
var _this = this;
if (!this._terminal.visualBell) {
return;
}
this._terminal.element.style.borderColor = 'white';
setTimeout(function () { return _this._terminal.element.style.borderColor = ''; }, 10);
if (this._terminal.popOnBell) {
this._terminal.focus();
}
};
InputHandler.prototype.lineFeed = function () {
if (this._terminal.convertEol) {
this._terminal.x = 0;
}
this._terminal.y++;
if (this._terminal.y > this._terminal.scrollBottom) {
this._terminal.y--;
this._terminal.scroll();
}
if (this._terminal.x >= this._terminal.cols) {
this._terminal.x--;
}
};
InputHandler.prototype.carriageReturn = function () {
this._terminal.x = 0;
};
InputHandler.prototype.backspace = function () {
if (this._terminal.x > 0) {
this._terminal.x--;
}
};
InputHandler.prototype.tab = function () {
this._terminal.x = this._terminal.nextStop();
};
InputHandler.prototype.shiftOut = function () {
this._terminal.setgLevel(1);
};
InputHandler.prototype.shiftIn = function () {
this._terminal.setgLevel(0);
};
InputHandler.prototype.insertChars = function (params) {
var param, row, j, ch;
param = params[0];
if (param < 1)
param = 1;
row = this._terminal.y + this._terminal.ybase;
j = this._terminal.x;
ch = [this._terminal.eraseAttr(), ' ', 1];
while (param-- && j < this._terminal.cols) {
this._terminal.lines.get(row).splice(j++, 0, ch);
this._terminal.lines.get(row).pop();
}
};
InputHandler.prototype.cursorUp = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.y -= param;
if (this._terminal.y < 0) {
this._terminal.y = 0;
}
};
InputHandler.prototype.cursorDown = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.y += param;
if (this._terminal.y >= this._terminal.rows) {
this._terminal.y = this._terminal.rows - 1;
}
if (this._terminal.x >= this._terminal.cols) {
this._terminal.x--;
}
};
InputHandler.prototype.cursorForward = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.x += param;
if (this._terminal.x >= this._terminal.cols) {
this._terminal.x = this._terminal.cols - 1;
}
};
InputHandler.prototype.cursorBackward = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
if (this._terminal.x >= this._terminal.cols) {
this._terminal.x--;
}
this._terminal.x -= param;
if (this._terminal.x < 0) {
this._terminal.x = 0;
}
};
InputHandler.prototype.cursorNextLine = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.y += param;
if (this._terminal.y >= this._terminal.rows) {
this._terminal.y = this._terminal.rows - 1;
}
this._terminal.x = 0;
};
;
InputHandler.prototype.cursorPrecedingLine = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.y -= param;
if (this._terminal.y < 0) {
this._terminal.y = 0;
}
this._terminal.x = 0;
};
;
InputHandler.prototype.cursorCharAbsolute = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.x = param - 1;
};
InputHandler.prototype.cursorPosition = function (params) {
var row, col;
row = params[0] - 1;
if (params.length >= 2) {
col = params[1] - 1;
}
else {
col = 0;
}
if (row < 0) {
row = 0;
}
else if (row >= this._terminal.rows) {
row = this._terminal.rows - 1;
}
if (col < 0) {
col = 0;
}
else if (col >= this._terminal.cols) {
col = this._terminal.cols - 1;
}
this._terminal.x = col;
this._terminal.y = row;
};
InputHandler.prototype.cursorForwardTab = function (params) {
var param = params[0] || 1;
while (param--) {
this._terminal.x = this._terminal.nextStop();
}
};
InputHandler.prototype.eraseInDisplay = function (params) {
var j;
switch (params[0]) {
case 0:
this._terminal.eraseRight(this._terminal.x, this._terminal.y);
j = this._terminal.y + 1;
for (; j < this._terminal.rows; j++) {
this._terminal.eraseLine(j);
}
break;
case 1:
this._terminal.eraseLeft(this._terminal.x, this._terminal.y);
j = this._terminal.y;
while (j--) {
this._terminal.eraseLine(j);
}
break;
case 2:
j = this._terminal.rows;
while (j--)
this._terminal.eraseLine(j);
break;
case 3:
var scrollBackSize = this._terminal.lines.length - this._terminal.rows;
if (scrollBackSize > 0) {
this._terminal.lines.trimStart(scrollBackSize);
this._terminal.ybase = Math.max(this._terminal.ybase - scrollBackSize, 0);
this._terminal.ydisp = Math.max(this._terminal.ydisp - scrollBackSize, 0);
}
break;
}
};
InputHandler.prototype.eraseInLine = function (params) {
switch (params[0]) {
case 0:
this._terminal.eraseRight(this._terminal.x, this._terminal.y);
break;
case 1:
this._terminal.eraseLeft(this._terminal.x, this._terminal.y);
break;
case 2:
this._terminal.eraseLine(this._terminal.y);
break;
}
};
InputHandler.prototype.insertLines = function (params) {
var param, row, j;
param = params[0];
if (param < 1) {
param = 1;
}
row = this._terminal.y + this._terminal.ybase;
j = this._terminal.rows - 1 - this._terminal.scrollBottom;
j = this._terminal.rows - 1 + this._terminal.ybase - j + 1;
while (param--) {
if (this._terminal.lines.length === this._terminal.lines.maxLength) {
this._terminal.lines.trimStart(1);
this._terminal.ybase--;
this._terminal.ydisp--;
row--;
j--;
}
this._terminal.lines.splice(row, 0, this._terminal.blankLine(true));
this._terminal.lines.splice(j, 1);
}
this._terminal.updateRange(this._terminal.y);
this._terminal.updateRange(this._terminal.scrollBottom);
};
InputHandler.prototype.deleteLines = function (params) {
var param, row, j;
param = params[0];
if (param < 1) {
param = 1;
}
row = this._terminal.y + this._terminal.ybase;
j = this._terminal.rows - 1 - this._terminal.scrollBottom;
j = this._terminal.rows - 1 + this._terminal.ybase - j;
while (param--) {
if (this._terminal.lines.length === this._terminal.lines.maxLength) {
this._terminal.lines.trimStart(1);
this._terminal.ybase -= 1;
this._terminal.ydisp -= 1;
}
this._terminal.lines.splice(j + 1, 0, this._terminal.blankLine(true));
this._terminal.lines.splice(row, 1);
}
this._terminal.updateRange(this._terminal.y);
this._terminal.updateRange(this._terminal.scrollBottom);
};
InputHandler.prototype.deleteChars = function (params) {
var param, row, ch;
param = params[0];
if (param < 1) {
param = 1;
}
row = this._terminal.y + this._terminal.ybase;
ch = [this._terminal.eraseAttr(), ' ', 1];
while (param--) {
this._terminal.lines.get(row).splice(this._terminal.x, 1);
this._terminal.lines.get(row).push(ch);
}
};
InputHandler.prototype.scrollUp = function (params) {
var param = params[0] || 1;
while (param--) {
this._terminal.lines.splice(this._terminal.ybase + this._terminal.scrollTop, 1);
this._terminal.lines.splice(this._terminal.ybase + this._terminal.scrollBottom, 0, this._terminal.blankLine());
}
this._terminal.updateRange(this._terminal.scrollTop);
this._terminal.updateRange(this._terminal.scrollBottom);
};
InputHandler.prototype.scrollDown = function (params) {
var param = params[0] || 1;
while (param--) {
this._terminal.lines.splice(this._terminal.ybase + this._terminal.scrollBottom, 1);
this._terminal.lines.splice(this._terminal.ybase + this._terminal.scrollTop, 0, this._terminal.blankLine());
}
this._terminal.updateRange(this._terminal.scrollTop);
this._terminal.updateRange(this._terminal.scrollBottom);
};
InputHandler.prototype.eraseChars = function (params) {
var param, row, j, ch;
param = params[0];
if (param < 1) {
param = 1;
}
row = this._terminal.y + this._terminal.ybase;
j = this._terminal.x;
ch = [this._terminal.eraseAttr(), ' ', 1];
while (param-- && j < this._terminal.cols) {
this._terminal.lines.get(row)[j++] = ch;
}
};
InputHandler.prototype.cursorBackwardTab = function (params) {
var param = params[0] || 1;
while (param--) {
this._terminal.x = this._terminal.prevStop();
}
};
InputHandler.prototype.charPosAbsolute = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.x = param - 1;
if (this._terminal.x >= this._terminal.cols) {
this._terminal.x = this._terminal.cols - 1;
}
};
InputHandler.prototype.HPositionRelative = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.x += param;
if (this._terminal.x >= this._terminal.cols) {
this._terminal.x = this._terminal.cols - 1;
}
};
InputHandler.prototype.repeatPrecedingCharacter = function (params) {
var param = params[0] || 1, line = this._terminal.lines.get(this._terminal.ybase + this._terminal.y), ch = line[this._terminal.x - 1] || [this._terminal.defAttr, ' ', 1];
while (param--) {
line[this._terminal.x++] = ch;
}
};
InputHandler.prototype.sendDeviceAttributes = function (params) {
if (params[0] > 0) {
return;
}
if (!this._terminal.prefix) {
if (this._terminal.is('xterm') || this._terminal.is('rxvt-unicode') || this._terminal.is('screen')) {
this._terminal.send(EscapeSequences_1.C0.ESC + '[?1;2c');
}
else if (this._terminal.is('linux')) {
this._terminal.send(EscapeSequences_1.C0.ESC + '[?6c');
}
}
else if (this._terminal.prefix === '>') {
if (this._terminal.is('xterm')) {
this._terminal.send(EscapeSequences_1.C0.ESC + '[>0;276;0c');
}
else if (this._terminal.is('rxvt-unicode')) {
this._terminal.send(EscapeSequences_1.C0.ESC + '[>85;95;0c');
}
else if (this._terminal.is('linux')) {
this._terminal.send(params[0] + 'c');
}
else if (this._terminal.is('screen')) {
this._terminal.send(EscapeSequences_1.C0.ESC + '[>83;40003;0c');
}
}
};
InputHandler.prototype.linePosAbsolute = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.y = param - 1;
if (this._terminal.y >= this._terminal.rows) {
this._terminal.y = this._terminal.rows - 1;
}
};
InputHandler.prototype.VPositionRelative = function (params) {
var param = params[0];
if (param < 1) {
param = 1;
}
this._terminal.y += param;
if (this._terminal.y >= this._terminal.rows) {
this._terminal.y = this._terminal.rows - 1;
}
if (this._terminal.x >= this._terminal.cols) {
this._terminal.x--;
}
};
InputHandler.prototype.HVPosition = function (params) {
if (params[0] < 1)
params[0] = 1;
if (params[1] < 1)
params[1] = 1;
this._terminal.y = params[0] - 1;
if (this._terminal.y >= this._terminal.rows) {
this._terminal.y = this._terminal.rows - 1;
}
this._terminal.x = params[1] - 1;
if (this._terminal.x >= this._terminal.cols) {
this._terminal.x = this._terminal.cols - 1;
}
};
InputHandler.prototype.tabClear = function (params) {
var param = params[0];
if (param <= 0) {
delete this._terminal.tabs[this._terminal.x];
}
else if (param === 3) {
this._terminal.tabs = {};
}
};
InputHandler.prototype.setMode = function (params) {
if (params.length > 1) {
for (var i = 0; i < params.length; i++) {
this.setMode([params[i]]);
}
return;
}
if (!this._terminal.prefix) {
switch (params[0]) {
case 4:
this._terminal.insertMode = true;
break;
case 20:
break;
}
}
else if (this._terminal.prefix === '?') {
switch (params[0]) {
case 1:
this._terminal.applicationCursor = true;
break;
case 2:
this._terminal.setgCharset(0, Charsets_1.DEFAULT_CHARSET);
this._terminal.setgCharset(1, Charsets_1.DEFAULT_CHARSET);
this._terminal.setgCharset(2, Charsets_1.DEFAULT_CHARSET);
this._terminal.setgCharset(3, Charsets_1.DEFAULT_CHARSET);
break;
case 3:
this._terminal.savedCols = this._terminal.cols;
this._terminal.resize(132, this._terminal.rows);
break;
case 6:
this._terminal.originMode = true;
break;
case 7:
this._terminal.wraparoundMode = true;
break;
case 12:
break;
case 66:
this._terminal.log('Serial port requested application keypad.');
this._terminal.applicationKeypad = true;
this._terminal.viewport.syncScrollArea();
break;
case 9:
case 1000:
case 1002:
case 1003:
this._terminal.x10Mouse = params[0] === 9;
this._terminal.vt200Mouse = params[0] === 1000;
this._terminal.normalMouse = params[0] > 1000;
this._terminal.mouseEvents = true;
this._terminal.element.classList.add('enable-mouse-events');
this._terminal.selectionManager.disable();
this._terminal.log('Binding to mouse events.');
break;
case 1004:
this._terminal.sendFocus = true;
break;
case 1005:
this._terminal.utfMouse = true;
break;
case 1006:
this._terminal.sgrMouse = true;
break;
case 1015:
this._terminal.urxvtMouse = true;
break;
case 25:
this._terminal.cursorHidden = false;
break;
case 1049:
;
case 47:
case 1047:
if (!this._terminal.normal) {
var normal = {
lines: this._terminal.lines,
ybase: this._terminal.ybase,
ydisp: this._terminal.ydisp,
x: this._terminal.x,
y: this._terminal.y,
scrollTop: this._terminal.scrollTop,
scrollBottom: this._terminal.scrollBottom,
tabs: this._terminal.tabs
};
this._terminal.reset();
this._terminal.viewport.syncScrollArea();
this._terminal.normal = normal;
this._terminal.showCursor();
}
break;
}
}
};
InputHandler.prototype.resetMode = function (params) {
if (params.length > 1) {
for (var i = 0; i < params.length; i++) {
this.resetMode([params[i]]);
}
return;
}
if (!this._terminal.prefix) {
switch (params[0]) {
case 4:
this._terminal.insertMode = false;
break;
case 20:
break;
}
}
else if (this._terminal.prefix === '?') {
switch (params[0]) {
case 1:
this._terminal.applicationCursor = false;
break;
case 3:
if (this._terminal.cols === 132 && this._terminal.savedCols) {
this._terminal.resize(this._terminal.savedCols, this._terminal.rows);
}
delete this._terminal.savedCols;
break;
case 6:
this._terminal.originMode = false;
break;
case 7:
this._terminal.wraparoundMode = false;
break;
case 12:
break;
case 66:
this._terminal.log('Switching back to normal keypad.');
this._terminal.applicationKeypad = false;
this._terminal.viewport.syncScrollArea();
break;
case 9:
case 1000:
case 1002:
case 1003:
this._terminal.x10Mouse = false;
this._terminal.vt200Mouse = false;
this._terminal.normalMouse = false;
this._terminal.mouseEvents = false;
this._terminal.element.classList.remove('enable-mouse-events');
this._terminal.selectionManager.enable();
break;
case 1004:
this._terminal.sendFocus = false;
break;
case 1005:
this._terminal.utfMouse = false;
break;
case 1006:
this._terminal.sgrMouse = false;
break;
case 1015:
this._terminal.urxvtMouse = false;
break;
case 25:
this._terminal.cursorHidden = true;
break;
case 1049:
;
case 47:
case 1047:
if (this._terminal.normal) {
this._terminal.lines = this._terminal.normal.lines;
this._terminal.ybase = this._terminal.normal.ybase;
this._terminal.ydisp = this._terminal.normal.ydisp;
this._terminal.x = this._terminal.normal.x;
this._terminal.y = this._terminal.normal.y;
this._terminal.scrollTop = this._terminal.normal.scrollTop;
this._terminal.scrollBottom = this._terminal.normal.scrollBottom;
this._terminal.tabs = this._terminal.normal.tabs;
this._terminal.normal = null;
this._terminal.selectionManager.setBuffer(this._terminal.lines);
this._terminal.refresh(0, this._terminal.rows - 1);
this._terminal.viewport.syncScrollArea();
this._terminal.showCursor();
}
break;
}
}
};
InputHandler.prototype.charAttributes = function (params) {
if (params.length === 1 && params[0] === 0) {
this._terminal.curAttr = this._terminal.defAttr;
return;
}
var l = params.length, i = 0, flags = this._terminal.curAttr >> 18, fg = (this._terminal.curAttr >> 9) & 0x1ff, bg = this._terminal.curAttr & 0x1ff, p;
for (; i < l; i++) {
p = params[i];
if (p >= 30 && p <= 37) {
fg = p - 30;
}
else if (p >= 40 && p <= 47) {
bg = p - 40;
}
else if (p >= 90 && p <= 97) {
p += 8;
fg = p - 90;
}
else if (p >= 100 && p <= 107) {
p += 8;
bg = p - 100;
}
else if (p === 0) {
flags = this._terminal.defAttr >> 18;
fg = (this._terminal.defAttr >> 9) & 0x1ff;
bg = this._terminal.defAttr & 0x1ff;
}
else if (p === 1) {
flags |= 1;
}
else if (p === 4) {
flags |= 2;
}
else if (p === 5) {
flags |= 4;
}
else if (p === 7) {
flags |= 8;
}
else if (p === 8) {
flags |= 16;
}
else if (p === 22) {
flags &= ~1;
}
else if (p === 24) {
flags &= ~2;
}
else if (p === 25) {
flags &= ~4;
}
else if (p === 27) {
flags &= ~8;
}
else if (p === 28) {
flags &= ~16;
}
else if (p === 39) {
fg = (this._terminal.defAttr >> 9) & 0x1ff;
}
else if (p === 49) {
bg = this._terminal.defAttr & 0x1ff;
}
else if (p === 38) {
if (params[i + 1] === 2) {
i += 2;
fg = this._terminal.matchColor(params[i] & 0xff, params[i + 1] & 0xff, params[i + 2] & 0xff);
if (fg === -1)
fg = 0x1ff;
i += 2;
}
else if (params[i + 1] === 5) {
i += 2;
p = params[i] & 0xff;
fg = p;
}
}
else if (p === 48) {
if (params[i + 1] === 2) {
i += 2;
bg = this._terminal.matchColor(params[i] & 0xff, params[i + 1] & 0xff, params[i + 2] & 0xff);
if (bg === -1)
bg = 0x1ff;
i += 2;
}
else if (params[i + 1] === 5) {
i += 2;
p = params[i] & 0xff;
bg = p;
}
}
else if (p === 100) {
fg = (this._terminal.defAttr >> 9) & 0x1ff;
bg = this._terminal.defAttr & 0x1ff;
}
else {
this._terminal.error('Unknown SGR attribute: %d.', p);
}
}
this._terminal.curAttr = (flags << 18) | (fg << 9) | bg;
};
InputHandler.prototype.deviceStatus = function (params) {
if (!this._terminal.prefix) {
switch (params[0]) {
case 5:
this._terminal.send(EscapeSequences_1.C0.ESC + '[0n');
break;
case 6:
this._terminal.send(EscapeSequences_1.C0.ESC + '['
+ (this._terminal.y + 1)
+ ';'
+ (this._terminal.x + 1)
+ 'R');
break;
}
}
else if (this._terminal.prefix === '?') {
switch (params[0]) {
case 6:
this._terminal.send(EscapeSequences_1.C0.ESC + '[?'
+ (this._terminal.y + 1)
+ ';'
+ (this._terminal.x + 1)
+ 'R');
break;
case 15:
break;
case 25:
break;
case 26:
break;
case 53:
break;
}
}
};
InputHandler.prototype.softReset = function (params) {
this._terminal.cursorHidden = false;
this._terminal.insertMode = false;
this._terminal.originMode = false;
this._terminal.wraparoundMode = true;
this._terminal.applicationKeypad = false;
this._terminal.viewport.syncScrollArea();
this._terminal.applicationCursor = false;
this._terminal.scrollTop = 0;
this._terminal.scrollBottom = this._terminal.rows - 1;
this._terminal.curAttr = this._terminal.defAttr;
this._terminal.x = this._terminal.y = 0;
this._terminal.charset = null;
this._terminal.glevel = 0;
this._terminal.charsets = [null];
};
InputHandler.prototype.setCursorStyle = function (params) {
var param = params[0] < 1 ? 1 : params[0];
switch (param) {
case 1:
case 2:
this._terminal.setOption('cursorStyle', 'block');
break;
case 3:
case 4:
this._terminal.setOption('cursorStyle', 'underline');
break;
case 5:
case 6:
this._terminal.setOption('cursorStyle', 'bar');
break;
}
var isBlinking = param % 2 === 1;
this._terminal.setOption('cursorBlink', isBlinking);
};
InputHandler.prototype.setScrollRegion = function (params) {
if (this._terminal.prefix)
return;
this._terminal.scrollTop = (params[0] || 1) - 1;
this._terminal.scrollBottom = (params[1] && params[1] <= this._terminal.rows ? params[1] : this._terminal.rows) - 1;
this._terminal.x = 0;
this._terminal.y = 0;
};
InputHandler.prototype.saveCursor = function (params) {
this._terminal.savedX = this._terminal.x;
this._terminal.savedY = this._terminal.y;
};
InputHandler.prototype.restoreCursor = function (params) {
this._terminal.x = this._terminal.savedX || 0;
this._terminal.y = this._terminal.savedY || 0;
};
return InputHandler;
}());
exports.InputHandler = InputHandler;
var wcwidth = (function (opts) {
var COMBINING = [
[0x0300, 0x036F], [0x0483, 0x0486], [0x0488, 0x0489],
[0x0591, 0x05BD], [0x05BF, 0x05BF], [0x05C1, 0x05C2],
[0x05C4, 0x05C5], [0x05C7, 0x05C7], [0x0600, 0x0603],
[0x0610, 0x0615], [0x064B, 0x065E], [0x0670, 0x0670],
[0x06D6, 0x06E4], [0x06E7, 0x06E8], [0x06EA, 0x06ED],
[0x070F, 0x070F], [0x0711, 0x0711], [0x0730, 0x074A],
[0x07A6, 0x07B0], [0x07EB, 0x07F3], [0x0901, 0x0902],
[0x093C, 0x093C], [0x0941, 0x0948], [0x094D, 0x094D],
[0x0951, 0x0954], [0x0962, 0x0963], [0x0981, 0x0981],
[0x09BC, 0x09BC], [0x09C1, 0x09C4], [0x09CD, 0x09CD],
[0x09E2, 0x09E3], [0x0A01, 0x0A02], [0x0A3C, 0x0A3C],
[0x0A41, 0x0A42], [0x0A47, 0x0A48], [0x0A4B, 0x0A4D],
[0x0A70, 0x0A71], [0x0A81, 0x0A82], [0x0ABC, 0x0ABC],
[0x0AC1, 0x0AC5], [0x0AC7, 0x0AC8], [0x0ACD, 0x0ACD],
[0x0AE2, 0x0AE3], [0x0B01, 0x0B01], [0x0B3C, 0x0B3C],
[0x0B3F, 0x0B3F], [0x0B41, 0x0B43], [0x0B4D, 0x0B4D],
[0x0B56, 0x0B56], [0x0B82, 0x0B82], [0x0BC0, 0x0BC0],
[0x0BCD, 0x0BCD], [0x0C3E, 0x0C40], [0x0C46, 0x0C48],
[0x0C4A, 0x0C4D], [0x0C55, 0x0C56], [0x0CBC, 0x0CBC],
[0x0CBF, 0x0CBF], [0x0CC6, 0x0CC6], [0x0CCC, 0x0CCD],
[0x0CE2, 0x0CE3], [0x0D41, 0x0D43], [0x0D4D, 0x0D4D],
[0x0DCA, 0x0DCA], [0x0DD2, 0x0DD4], [0x0DD6, 0x0DD6],
[0x0E31, 0x0E31], [0x0E34, 0x0E3A], [0x0E47, 0x0E4E],
[0x0EB1, 0x0EB1], [0x0EB4, 0x0EB9], [0x0EBB, 0x0EBC],
[0x0EC8, 0x0ECD], [0x0F18, 0x0F19], [0x0F35, 0x0F35],
[0x0F37, 0x0F37], [0x0F39, 0x0F39], [0x0F71, 0x0F7E],
[0x0F80, 0x0F84], [0x0F86, 0x0F87], [0x0F90, 0x0F97],
[0x0F99, 0x0FBC], [0x0FC6, 0x0FC6], [0x102D, 0x1030],
[0x1032, 0x1032], [0x1036, 0x1037], [0x1039, 0x1039],
[0x1058, 0x1059], [0x1160, 0x11FF], [0x135F, 0x135F],
[0x1712, 0x1714], [0x1732, 0x1734], [0x1752, 0x1753],
[0x1772, 0x1773], [0x17B4, 0x17B5], [0x17B7, 0x17BD],
[0x17C6, 0x17C6], [0x17C9, 0x17D3], [0x17DD, 0x17DD],
[0x180B, 0x180D], [0x18A9, 0x18A9], [0x1920, 0x1922],
[0x1927, 0x1928], [0x1932, 0x1932], [0x1939, 0x193B],
[0x1A17, 0x1A18], [0x1B00, 0x1B03], [0x1B34, 0x1B34],
[0x1B36, 0x1B3A], [0x1B3C, 0x1B3C], [0x1B42, 0x1B42],
[0x1B6B, 0x1B73], [0x1DC0, 0x1DCA], [0x1DFE, 0x1DFF],
[0x200B, 0x200F], [0x202A, 0x202E], [0x2060, 0x2063],
[0x206A, 0x206F], [0x20D0, 0x20EF], [0x302A, 0x302F],
[0x3099, 0x309A], [0xA806, 0xA806], [0xA80B, 0xA80B],
[0xA825, 0xA826], [0xFB1E, 0xFB1E], [0xFE00, 0xFE0F],
[0xFE20, 0xFE23], [0xFEFF, 0xFEFF], [0xFFF9, 0xFFFB],
[0x10A01, 0x10A03], [0x10A05, 0x10A06], [0x10A0C, 0x10A0F],
[0x10A38, 0x10A3A], [0x10A3F, 0x10A3F], [0x1D167, 0x1D169],
[0x1D173, 0x1D182], [0x1D185, 0x1D18B], [0x1D1AA, 0x1D1AD],
[0x1D242, 0x1D244], [0xE0001, 0xE0001], [0xE0020, 0xE007F],
[0xE0100, 0xE01EF]
];
function bisearch(ucs) {
var min = 0;
var max = COMBINING.length - 1;
var mid;
if (ucs < COMBINING[0][0] || ucs > COMBINING[max][1])
return false;
while (max >= min) {
mid = Math.floor((min + max) / 2);
if (ucs > COMBINING[mid][1])
min = mid + 1;
else if (ucs < COMBINING[mid][0])
max = mid - 1;
else
return true;
}
return false;
}
function wcwidth(ucs) {
if (ucs === 0)
return opts.nul;
if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
return opts.control;
if (bisearch(ucs))
return 0;
if (isWide(ucs)) {
return 2;
}
return 1;
}
function isWide(ucs) {
return (ucs >= 0x1100 && (ucs <= 0x115f ||
ucs === 0x2329 ||
ucs === 0x232a ||
(ucs >= 0x2e80 && ucs <= 0xa4cf && ucs !== 0x303f) ||
(ucs >= 0xac00 && ucs <= 0xd7a3) ||
(ucs >= 0xf900 && ucs <= 0xfaff) ||
(ucs >= 0xfe10 && ucs <= 0xfe19) ||
(ucs >= 0xfe30 && ucs <= 0xfe6f) ||
(ucs >= 0xff00 && ucs <= 0xff60) ||
(ucs >= 0xffe0 && ucs <= 0xffe6) ||
(ucs >= 0x20000 && ucs <= 0x2fffd) ||
(ucs >= 0x30000 && ucs <= 0x3fffd)));
}
return wcwidth;
})({ nul: 0, control: 0 });
//# sourceMappingURL=InputHandler.js.map
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
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() {
this._nextLinkMatcherId = HYPERTEXT_LINK_MATCHER_ID;
this._rowTimeoutIds = [];
this._linkMatchers = [];
this.registerLinkMatcher(strictUrlRegex, null, { matchIndex: 1 });
}
Linkifier.prototype.attachToDom = function (document, rows) {
this._document = document;
this._rows = rows;
};
Linkifier.prototype.linkifyRow = function (rowIndex) {
if (!this._document) {
return;
}
var timeoutId = this._rowTimeoutIds[rowIndex];
if (timeoutId) {
clearTimeout(timeoutId);
}
this._rowTimeoutIds[rowIndex] = setTimeout(this._linkifyRow.bind(this, rowIndex), Linkifier.TIME_BEFORE_LINKIFY);
};
Linkifier.prototype.setHypertextLinkHandler = function (handler) {
this._linkMatchers[HYPERTEXT_LINK_MATCHER_ID].handler = handler;
};
Linkifier.prototype.setHypertextValidationCallback = function (callback) {
this._linkMatchers[HYPERTEXT_LINK_MATCHER_ID].validationCallback = callback;
};
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;
for (var i = 0; i < this._linkMatchers.length; i++) {
var matcher = this._linkMatchers[i];
var linkElements = this._doLinkifyRow(row, matcher);
if (linkElements.length > 0) {
if (matcher.validationCallback) {
var _loop_1 = function (j) {
var element = linkElements[j];
matcher.validationCallback(element.textContent, element, function (isValid) {
if (!isValid) {
element.classList.add(INVALID_LINK_CLASS);
}
});
};
for (var j = 0; j < linkElements.length; j++) {
_loop_1(j);
}
}
return;
}
}
};
Linkifier.prototype._doLinkifyRow = function (row, matcher) {
var result = [];
var isHttpLinkMatcher = matcher.id === HYPERTEXT_LINK_MATCHER_ID;
var nodes = row.childNodes;
var match = row.textContent.match(matcher.regex);
if (!match || match.length === 0) {
return result;
}
var uri = match[typeof matcher.matchIndex !== 'number' ? 0 : matcher.matchIndex];
var rowStartIndex = match.index + uri.length;
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, matcher.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 result;
}
element.innerHTML = '';
element.appendChild(linkElement);
}
}
else if (node.childNodes.length > 1) {
for (var j = 0; j < node.childNodes.length; j++) {
var childNode = node.childNodes[j];
var childSearchIndex = childNode.textContent.indexOf(uri);
if (childSearchIndex !== -1) {
this._replaceNodeSubstringWithNode(childNode, linkElement, uri, childSearchIndex);
break;
}
}
}
else {
var nodesAdded = this._replaceNodeSubstringWithNode(node, linkElement, uri, searchIndex);
i += nodesAdded;
}
result.push(linkElement);
match = row.textContent.substring(rowStartIndex).match(matcher.regex);
if (!match || match.length === 0) {
return result;
}
uri = match[typeof matcher.matchIndex !== 'number' ? 0 : matcher.matchIndex];
rowStartIndex += match.index + uri.length;
}
}
return result;
};
Linkifier.prototype._createAnchorElement = function (uri, handler, isHypertextLinkHandler) {
var element = this._document.createElement('a');
element.textContent = uri;
element.draggable = false;
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) {
if (targetNode.childNodes.length === 1) {
targetNode = targetNode.childNodes[0];
}
if (targetNode.nodeType !== 3) {
throw new Error('targetNode must be a text node or only contain a single text node');
}
var fullText = targetNode.textContent;
if (substringIndex === 0) {
var rightText_1 = fullText.substring(substring.length);
var rightTextNode_1 = this._document.createTextNode(rightText_1);
this._replaceNode(targetNode, newNode, rightTextNode_1);
return 0;
}
if (substringIndex === targetNode.textContent.length - substring.length) {
var leftText_1 = fullText.substring(0, substringIndex);
var leftTextNode_1 = this._document.createTextNode(leftText_1);
this._replaceNode(targetNode, leftTextNode_1, newNode);
return 0;
}
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(targetNode, leftTextNode, newNode, rightTextNode);
return 1;
};
return Linkifier;
}());
Linkifier.TIME_BEFORE_LINKIFY = 200;
exports.Linkifier = Linkifier;
//# sourceMappingURL=Linkifier.js.map
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var EscapeSequences_1 = __webpack_require__(2);
var Charsets_1 = __webpack_require__(3);
var normalStateHandler = {};
normalStateHandler[EscapeSequences_1.C0.BEL] = function (parser, handler) { return handler.bell(); };
normalStateHandler[EscapeSequences_1.C0.LF] = function (parser, handler) { return handler.lineFeed(); };
normalStateHandler[EscapeSequences_1.C0.VT] = normalStateHandler[EscapeSequences_1.C0.LF];
normalStateHandler[EscapeSequences_1.C0.FF] = normalStateHandler[EscapeSequences_1.C0.LF];
normalStateHandler[EscapeSequences_1.C0.CR] = function (parser, handler) { return handler.carriageReturn(); };
normalStateHandler[EscapeSequences_1.C0.BS] = function (parser, handler) { return handler.backspace(); };
normalStateHandler[EscapeSequences_1.C0.HT] = function (parser, handler) { return handler.tab(); };
normalStateHandler[EscapeSequences_1.C0.SO] = function (parser, handler) { return handler.shiftOut(); };
normalStateHandler[EscapeSequences_1.C0.SI] = function (parser, handler) { return handler.shiftIn(); };
normalStateHandler[EscapeSequences_1.C0.ESC] = function (parser, handler) { return parser.setState(ParserState.ESCAPED); };
var escapedStateHandler = {};
escapedStateHandler['['] = function (parser, terminal) {
terminal.params = [];
terminal.currentParam = 0;
parser.setState(ParserState.CSI_PARAM);
};
escapedStateHandler[']'] = function (parser, terminal) {
terminal.params = [];
terminal.currentParam = 0;
parser.setState(ParserState.OSC);
};
escapedStateHandler['P'] = function (parser, terminal) {
terminal.params = [];
terminal.currentParam = 0;
parser.setState(ParserState.DCS);
};
escapedStateHandler['_'] = function (parser, terminal) {
parser.setState(ParserState.IGNORE);
};
escapedStateHandler['^'] = function (parser, terminal) {
parser.setState(ParserState.IGNORE);
};
escapedStateHandler['c'] = function (parser, terminal) {
terminal.reset();
};
escapedStateHandler['E'] = function (parser, terminal) {
terminal.x = 0;
terminal.index();
parser.setState(ParserState.NORMAL);
};
escapedStateHandler['D'] = function (parser, terminal) {
terminal.index();
parser.setState(ParserState.NORMAL);
};
escapedStateHandler['M'] = function (parser, terminal) {
terminal.reverseIndex();
parser.setState(ParserState.NORMAL);
};
escapedStateHandler['%'] = function (parser, terminal) {
terminal.setgLevel(0);
terminal.setgCharset(0, Charsets_1.DEFAULT_CHARSET);
parser.setState(ParserState.NORMAL);
parser.skipNextChar();
};
escapedStateHandler[EscapeSequences_1.C0.CAN] = function (parser) { return parser.setState(ParserState.NORMAL); };
var csiParamStateHandler = {};
csiParamStateHandler['?'] = function (parser) { return parser.setPrefix('?'); };
csiParamStateHandler['>'] = function (parser) { return parser.setPrefix('>'); };
csiParamStateHandler['!'] = function (parser) { return parser.setPrefix('!'); };
csiParamStateHandler['0'] = function (parser) { return parser.setParam(parser.getParam() * 10); };
csiParamStateHandler['1'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 1); };
csiParamStateHandler['2'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 2); };
csiParamStateHandler['3'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 3); };
csiParamStateHandler['4'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 4); };
csiParamStateHandler['5'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 5); };
csiParamStateHandler['6'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 6); };
csiParamStateHandler['7'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 7); };
csiParamStateHandler['8'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 8); };
csiParamStateHandler['9'] = function (parser) { return parser.setParam(parser.getParam() * 10 + 9); };
csiParamStateHandler['$'] = function (parser) { return parser.setPostfix('$'); };
csiParamStateHandler['"'] = function (parser) { return parser.setPostfix('"'); };
csiParamStateHandler[' '] = function (parser) { return parser.setPostfix(' '); };
csiParamStateHandler['\''] = function (parser) { return parser.setPostfix('\''); };
csiParamStateHandler[';'] = function (parser) { return parser.finalizeParam(); };
csiParamStateHandler[EscapeSequences_1.C0.CAN] = function (parser) { return parser.setState(ParserState.NORMAL); };
var csiStateHandler = {};
csiStateHandler['@'] = function (handler, params, prefix) { return handler.insertChars(params); };
csiStateHandler['A'] = function (handler, params, prefix) { return handler.cursorUp(params); };
csiStateHandler['B'] = function (handler, params, prefix) { return handler.cursorDown(params); };
csiStateHandler['C'] = function (handler, params, prefix) { return handler.cursorForward(params); };
csiStateHandler['D'] = function (handler, params, prefix) { return handler.cursorBackward(params); };
csiStateHandler['E'] = function (handler, params, prefix) { return handler.cursorNextLine(params); };
csiStateHandler['F'] = function (handler, params, prefix) { return handler.cursorPrecedingLine(params); };
csiStateHandler['G'] = function (handler, params, prefix) { return handler.cursorCharAbsolute(params); };
csiStateHandler['H'] = function (handler, params, prefix) { return handler.cursorPosition(params); };
csiStateHandler['I'] = function (handler, params, prefix) { return handler.cursorForwardTab(params); };
csiStateHandler['J'] = function (handler, params, prefix) { return handler.eraseInDisplay(params); };
csiStateHandler['K'] = function (handler, params, prefix) { return handler.eraseInLine(params); };
csiStateHandler['L'] = function (handler, params, prefix) { return handler.insertLines(params); };
csiStateHandler['M'] = function (handler, params, prefix) { return handler.deleteLines(params); };
csiStateHandler['P'] = function (handler, params, prefix) { return handler.deleteChars(params); };
csiStateHandler['S'] = function (handler, params, prefix) { return handler.scrollUp(params); };
csiStateHandler['T'] = function (handler, params, prefix) {
if (params.length < 2 && !prefix) {
handler.scrollDown(params);
}
};
csiStateHandler['X'] = function (handler, params, prefix) { return handler.eraseChars(params); };
csiStateHandler['Z'] = function (handler, params, prefix) { return handler.cursorBackwardTab(params); };
csiStateHandler['`'] = function (handler, params, prefix) { return handler.charPosAbsolute(params); };
csiStateHandler['a'] = function (handler, params, prefix) { return handler.HPositionRelative(params); };
csiStateHandler['b'] = function (handler, params, prefix) { return handler.repeatPrecedingCharacter(params); };
csiStateHandler['c'] = function (handler, params, prefix) { return handler.sendDeviceAttributes(params); };
csiStateHandler['d'] = function (handler, params, prefix) { return handler.linePosAbsolute(params); };
csiStateHandler['e'] = function (handler, params, prefix) { return handler.VPositionRelative(params); };
csiStateHandler['f'] = function (handler, params, prefix) { return handler.HVPosition(params); };
csiStateHandler['g'] = function (handler, params, prefix) { return handler.tabClear(params); };
csiStateHandler['h'] = function (handler, params, prefix) { return handler.setMode(params); };
csiStateHandler['l'] = function (handler, params, prefix) { return handler.resetMode(params); };
csiStateHandler['m'] = function (handler, params, prefix) { return handler.charAttributes(params); };
csiStateHandler['n'] = function (handler, params, prefix) { return handler.deviceStatus(params); };
csiStateHandler['p'] = function (handler, params, prefix) {
switch (prefix) {
case '!':
handler.softReset(params);
break;
}
};
csiStateHandler['q'] = function (handler, params, prefix, postfix) {
if (postfix === ' ') {
handler.setCursorStyle(params);
}
};
csiStateHandler['r'] = function (handler, params) { return handler.setScrollRegion(params); };
csiStateHandler['s'] = function (handler, params) { return handler.saveCursor(params); };
csiStateHandler['u'] = function (handler, params) { return handler.restoreCursor(params); };
csiStateHandler[EscapeSequences_1.C0.CAN] = function (handler, params, prefix, postfix, parser) { return parser.setState(ParserState.NORMAL); };
var ParserState;
(function (ParserState) {
ParserState[ParserState["NORMAL"] = 0] = "NORMAL";
ParserState[ParserState["ESCAPED"] = 1] = "ESCAPED";
ParserState[ParserState["CSI_PARAM"] = 2] = "CSI_PARAM";
ParserState[ParserState["CSI"] = 3] = "CSI";
ParserState[ParserState["OSC"] = 4] = "OSC";
ParserState[ParserState["CHARSET"] = 5] = "CHARSET";
ParserState[ParserState["DCS"] = 6] = "DCS";
ParserState[ParserState["IGNORE"] = 7] = "IGNORE";
})(ParserState || (ParserState = {}));
var Parser = (function () {
function Parser(_inputHandler, _terminal) {
this._inputHandler = _inputHandler;
this._terminal = _terminal;
this._state = ParserState.NORMAL;
}
Parser.prototype.parse = function (data) {
var l = data.length, j, cs, ch, code, low;
this._position = 0;
if (this._terminal.surrogate_high) {
data = this._terminal.surrogate_high + data;
this._terminal.surrogate_high = '';
}
for (; this._position < l; this._position++) {
ch = data[this._position];
code = data.charCodeAt(this._position);
if (0xD800 <= code && code <= 0xDBFF) {
low = data.charCodeAt(this._position + 1);
if (isNaN(low)) {
this._terminal.surrogate_high = ch;
continue;
}
code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
ch += data.charAt(this._position + 1);
}
if (0xDC00 <= code && code <= 0xDFFF)
continue;
switch (this._state) {
case ParserState.NORMAL:
if (ch in normalStateHandler) {
normalStateHandler[ch](this, this._inputHandler);
}
else {
this._inputHandler.addChar(ch, code);
}
break;
case ParserState.ESCAPED:
if (ch in escapedStateHandler) {
escapedStateHandler[ch](this, this._terminal);
break;
}
switch (ch) {
case '(':
case ')':
case '*':
case '+':
case '-':
case '.':
switch (ch) {
case '(':
this._terminal.gcharset = 0;
break;
case ')':
this._terminal.gcharset = 1;
break;
case '*':
this._terminal.gcharset = 2;
break;
case '+':
this._terminal.gcharset = 3;
break;
case '-':
this._terminal.gcharset = 1;
break;
case '.':
this._terminal.gcharset = 2;
break;
}
this._state = ParserState.CHARSET;
break;
case '/':
this._terminal.gcharset = 3;
this._state = ParserState.CHARSET;
this._position--;
break;
case 'N':
break;
case 'O':
break;
case 'n':
this._terminal.setgLevel(2);
break;
case 'o':
this._terminal.setgLevel(3);
break;
case '|':
this._terminal.setgLevel(3);
break;
case '}':
this._terminal.setgLevel(2);
break;
case '~':
this._terminal.setgLevel(1);
break;
case '7':
this._inputHandler.saveCursor();
this._state = ParserState.NORMAL;
break;
case '8':
this._inputHandler.restoreCursor();
this._state = ParserState.NORMAL;
break;
case '#':
this._state = ParserState.NORMAL;
this._position++;
break;
case 'H':
this._terminal.tabSet();
this._state = ParserState.NORMAL;
break;
case '=':
this._terminal.log('Serial port requested application keypad.');
this._terminal.applicationKeypad = true;
this._terminal.viewport.syncScrollArea();
this._state = ParserState.NORMAL;
break;
case '>':
this._terminal.log('Switching back to normal keypad.');
this._terminal.applicationKeypad = false;
this._terminal.viewport.syncScrollArea();
this._state = ParserState.NORMAL;
break;
default:
this._state = ParserState.NORMAL;
this._terminal.error('Unknown ESC control: %s.', ch);
break;
}
break;
case ParserState.CHARSET:
if (ch in Charsets_1.CHARSETS) {
cs = Charsets_1.CHARSETS[ch];
if (ch === '/') {
this.skipNextChar();
}
}
else {
cs = Charsets_1.DEFAULT_CHARSET;
}
this._terminal.setgCharset(this._terminal.gcharset, cs);
this._terminal.gcharset = null;
this._state = ParserState.NORMAL;
break;
case ParserState.OSC:
if (ch === EscapeSequences_1.C0.ESC || ch === EscapeSequences_1.C0.BEL) {
if (ch === EscapeSequences_1.C0.ESC)
this._position++;
this._terminal.params.push(this._terminal.currentParam);
switch (this._terminal.params[0]) {
case 0:
case 1:
case 2:
if (this._terminal.params[1]) {
this._terminal.title = this._terminal.params[1];
this._terminal.handleTitle(this._terminal.title);
}
break;
case 3:
break;
case 4:
case 5:
break;
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
break;
case 46:
break;
case 50:
break;
case 51:
break;
case 52:
break;
case 104:
case 105:
case 110:
case 111:
case 112:
case 113:
case 114:
case 115:
case 116:
case 117:
case 118:
break;
}
this._terminal.params = [];
this._terminal.currentParam = 0;
this._state = ParserState.NORMAL;
}
else {
if (!this._terminal.params.length) {
if (ch >= '0' && ch <= '9') {
this._terminal.currentParam =
this._terminal.currentParam * 10 + ch.charCodeAt(0) - 48;
}
else if (ch === ';') {
this._terminal.params.push(this._terminal.currentParam);
this._terminal.currentParam = '';
}
}
else {
this._terminal.currentParam += ch;
}
}
break;
case ParserState.CSI_PARAM:
if (ch in csiParamStateHandler) {
csiParamStateHandler[ch](this);
break;
}
this.finalizeParam();
this._state = ParserState.CSI;
case ParserState.CSI:
if (ch in csiStateHandler) {
csiStateHandler[ch](this._inputHandler, this._terminal.params, this._terminal.prefix, this._terminal.postfix, this);
}
else {
this._terminal.error('Unknown CSI code: %s.', ch);
}
this._state = ParserState.NORMAL;
this._terminal.prefix = '';
this._terminal.postfix = '';
break;
case ParserState.DCS:
if (ch === EscapeSequences_1.C0.ESC || ch === EscapeSequences_1.C0.BEL) {
if (ch === EscapeSequences_1.C0.ESC)
this._position++;
var pt = void 0;
var valid = void 0;
switch (this._terminal.prefix) {
case '':
break;
case '$q':
pt = this._terminal.currentParam;
valid = false;
switch (pt) {
case '"q':
pt = '0"q';
break;
case '"p':
pt = '61"p';
break;
case 'r':
pt = ''
+ (this._terminal.scrollTop + 1)
+ ';'
+ (this._terminal.scrollBottom + 1)
+ 'r';
break;
case 'm':
pt = '0m';
break;
default:
this._terminal.error('Unknown DCS Pt: %s.', pt);
pt = '';
break;
}
this._terminal.send(EscapeSequences_1.C0.ESC + 'P' + +valid + '$r' + pt + EscapeSequences_1.C0.ESC + '\\');
break;
case '+p':
break;
case '+q':
pt = this._terminal.currentParam;
valid = false;
this._terminal.send(EscapeSequences_1.C0.ESC + 'P' + +valid + '+r' + pt + EscapeSequences_1.C0.ESC + '\\');
break;
default:
this._terminal.error('Unknown DCS prefix: %s.', this._terminal.prefix);
break;
}
this._terminal.currentParam = 0;
this._terminal.prefix = '';
this._state = ParserState.NORMAL;
}
else if (!this._terminal.currentParam) {
if (!this._terminal.prefix && ch !== '$' && ch !== '+') {
this._terminal.currentParam = ch;
}
else if (this._terminal.prefix.length === 2) {
this._terminal.currentParam = ch;
}
else {
this._terminal.prefix += ch;
}
}
else {
this._terminal.currentParam += ch;
}
break;
case ParserState.IGNORE:
if (ch === EscapeSequences_1.C0.ESC || ch === EscapeSequences_1.C0.BEL) {
if (ch === EscapeSequences_1.C0.ESC)
this._position++;
this._state = ParserState.NORMAL;
}
break;
}
}
return this._state;
};
Parser.prototype.setState = function (state) {
this._state = state;
};
Parser.prototype.setPrefix = function (prefix) {
this._terminal.prefix = prefix;
};
Parser.prototype.setPostfix = function (postfix) {
this._terminal.postfix = postfix;
};
Parser.prototype.setParam = function (param) {
this._terminal.currentParam = param;
};
Parser.prototype.getParam = function () {
return this._terminal.currentParam;
};
Parser.prototype.finalizeParam = function () {
this._terminal.params.push(this._terminal.currentParam);
this._terminal.currentParam = 0;
};
Parser.prototype.skipNextChar = function () {
this._position++;
};
return Parser;
}());
exports.Parser = Parser;
//# sourceMappingURL=Parser.js.map
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var DomElementObjectPool_1 = __webpack_require__(32);
var MAX_REFRESH_FRAME_SKIP = 5;
var FLAGS;
(function (FLAGS) {
FLAGS[FLAGS["BOLD"] = 1] = "BOLD";
FLAGS[FLAGS["UNDERLINE"] = 2] = "UNDERLINE";
FLAGS[FLAGS["BLINK"] = 4] = "BLINK";
FLAGS[FLAGS["INVERSE"] = 8] = "INVERSE";
FLAGS[FLAGS["INVISIBLE"] = 16] = "INVISIBLE";
})(FLAGS || (FLAGS = {}));
;
var brokenBold = null;
var Renderer = (function () {
function Renderer(_terminal) {
this._terminal = _terminal;
this._refreshRowsQueue = [];
this._refreshFramesSkipped = 0;
this._refreshAnimationFrame = null;
this._spanElementObjectPool = new DomElementObjectPool_1.DomElementObjectPool('span');
if (brokenBold === null) {
brokenBold = checkBoldBroken(this._terminal.element);
}
this._spanElementObjectPool = new DomElementObjectPool_1.DomElementObjectPool('span');
}
Renderer.prototype.queueRefresh = function (start, end) {
this._refreshRowsQueue.push({ start: start, end: end });
if (!this._refreshAnimationFrame) {
this._refreshAnimationFrame = window.requestAnimationFrame(this._refreshLoop.bind(this));
}
};
Renderer.prototype._refreshLoop = function () {
var skipFrame = this._terminal.writeBuffer.length > 0 && this._refreshFramesSkipped++ <= MAX_REFRESH_FRAME_SKIP;
if (skipFrame) {
this._refreshAnimationFrame = window.requestAnimationFrame(this._refreshLoop.bind(this));
return;
}
this._refreshFramesSkipped = 0;
var start;
var end;
if (this._refreshRowsQueue.length > 4) {
start = 0;
end = this._terminal.rows - 1;
}
else {
start = this._refreshRowsQueue[0].start;
end = this._refreshRowsQueue[0].end;
for (var i = 1; i < this._refreshRowsQueue.length; i++) {
if (this._refreshRowsQueue[i].start < start) {
start = this._refreshRowsQueue[i].start;
}
if (this._refreshRowsQueue[i].end > end) {
end = this._refreshRowsQueue[i].end;
}
}
}
this._refreshRowsQueue = [];
this._refreshAnimationFrame = null;
this._refresh(start, end);
};
Renderer.prototype._refresh = function (start, end) {
var parent;
if (end - start >= this._terminal.rows / 2) {
parent = this._terminal.element.parentNode;
if (parent) {
this._terminal.element.removeChild(this._terminal.rowContainer);
}
}
var width = this._terminal.cols;
var y = start;
if (end >= this._terminal.rows) {
this._terminal.log('`end` is too large. Most likely a bad CSR.');
end = this._terminal.rows - 1;
}
for (; y <= end; y++) {
var row = y + this._terminal.ydisp;
var line = this._terminal.lines.get(row);
var x = void 0;
if (this._terminal.y === y - (this._terminal.ybase - this._terminal.ydisp) &&
this._terminal.cursorState &&
!this._terminal.cursorHidden) {
x = this._terminal.x;
}
else {
x = -1;
}
var attr = this._terminal.defAttr;
var documentFragment = document.createDocumentFragment();
var innerHTML = '';
var currentElement = void 0;
while (this._terminal.children[y].children.length) {
var child = this._terminal.children[y].children[0];
this._terminal.children[y].removeChild(child);
this._spanElementObjectPool.release(child);
}
for (var i = 0; i < width; i++) {
var data = line[i][0];
var ch = line[i][1];
var ch_width = line[i][2];
if (!ch_width) {
continue;
}
if (i === x) {
data = -1;
}
if (data !== attr) {
if (attr !== this._terminal.defAttr) {
if (innerHTML) {
currentElement.innerHTML = innerHTML;
innerHTML = '';
}
documentFragment.appendChild(currentElement);
currentElement = null;
}
if (data !== this._terminal.defAttr) {
if (innerHTML && !currentElement) {
currentElement = this._spanElementObjectPool.acquire();
}
if (currentElement) {
if (innerHTML) {
currentElement.innerHTML = innerHTML;
innerHTML = '';
}
documentFragment.appendChild(currentElement);
}
currentElement = this._spanElementObjectPool.acquire();
if (data === -1) {
currentElement.classList.add('reverse-video');
currentElement.classList.add('terminal-cursor');
}
else {
var bg = data & 0x1ff;
var fg = (data >> 9) & 0x1ff;
var flags = data >> 18;
if (flags & FLAGS.BOLD) {
if (!brokenBold) {
currentElement.classList.add('xterm-bold');
}
if (fg < 8) {
fg += 8;
}
}
if (flags & FLAGS.UNDERLINE) {
currentElement.classList.add('xterm-underline');
}
if (flags & FLAGS.BLINK) {
currentElement.classList.add('xterm-blink');
}
if (flags & FLAGS.INVERSE) {
var temp = bg;
bg = fg;
fg = temp;
if ((flags & 1) && fg < 8) {
fg += 8;
}
}
if (flags & FLAGS.INVISIBLE) {
currentElement.classList.add('xterm-hidden');
}
if (flags & FLAGS.INVERSE) {
if (bg === 257) {
bg = 15;
}
if (fg === 256) {
fg = 0;
}
}
if (bg < 256) {
currentElement.classList.add("xterm-bg-color-" + bg);
}
if (fg < 256) {
currentElement.classList.add("xterm-color-" + fg);
}
}
}
}
if (ch_width === 2) {
innerHTML += "<span class=\"xterm-wide-char\">" + ch + "</span>";
}
else if (ch.charCodeAt(0) > 255) {
innerHTML += "<span class=\"xterm-normal-char\">" + ch + "</span>";
}
else {
switch (ch) {
case '&':
innerHTML += '&amp;';
break;
case '<':
innerHTML += '&lt;';
break;
case '>':
innerHTML += '&gt;';
break;
default:
if (ch <= ' ') {
innerHTML += '&nbsp;';
}
else {
innerHTML += ch;
}
break;
}
}
attr = data;
}
if (innerHTML && !currentElement) {
currentElement = this._spanElementObjectPool.acquire();
}
if (currentElement) {
if (innerHTML) {
currentElement.innerHTML = innerHTML;
innerHTML = '';
}
documentFragment.appendChild(currentElement);
currentElement = null;
}
this._terminal.children[y].appendChild(documentFragment);
}
if (parent) {
this._terminal.element.appendChild(this._terminal.rowContainer);
}
this._terminal.emit('refresh', { element: this._terminal.element, start: start, end: end });
};
;
Renderer.prototype.refreshSelection = function (start, end) {
while (this._terminal.selectionContainer.children.length) {
this._terminal.selectionContainer.removeChild(this._terminal.selectionContainer.children[0]);
}
if (!start || !end) {
return;
}
var viewportStartRow = start[1] - this._terminal.ydisp;
var viewportEndRow = end[1] - this._terminal.ydisp;
var viewportCappedStartRow = Math.max(viewportStartRow, 0);
var viewportCappedEndRow = Math.min(viewportEndRow, this._terminal.rows - 1);
if (viewportCappedStartRow >= this._terminal.rows || viewportCappedEndRow < 0) {
return;
}
var documentFragment = document.createDocumentFragment();
var startCol = viewportStartRow === viewportCappedStartRow ? start[0] : 0;
var endCol = viewportCappedStartRow === viewportCappedEndRow ? end[0] : this._terminal.cols;
documentFragment.appendChild(this._createSelectionElement(viewportCappedStartRow, startCol, endCol));
var middleRowsCount = viewportCappedEndRow - viewportCappedStartRow - 1;
documentFragment.appendChild(this._createSelectionElement(viewportCappedStartRow + 1, 0, this._terminal.cols, middleRowsCount));
if (viewportCappedStartRow !== viewportCappedEndRow) {
var endCol_1 = viewportEndRow === viewportCappedEndRow ? end[0] : this._terminal.cols;
documentFragment.appendChild(this._createSelectionElement(viewportCappedEndRow, 0, endCol_1));
}
this._terminal.selectionContainer.appendChild(documentFragment);
};
Renderer.prototype._createSelectionElement = function (row, colStart, colEnd, rowCount) {
if (rowCount === void 0) { rowCount = 1; }
var element = document.createElement('div');
element.style.height = rowCount * this._terminal.charMeasure.height + "px";
element.style.top = row * this._terminal.charMeasure.height + "px";
element.style.left = colStart * this._terminal.charMeasure.width + "px";
element.style.width = this._terminal.charMeasure.width * (colEnd - colStart) + "px";
return element;
};
return Renderer;
}());
exports.Renderer = Renderer;
function checkBoldBroken(terminal) {
var document = terminal.ownerDocument;
var el = document.createElement('span');
el.innerHTML = 'hello world';
terminal.appendChild(el);
var w1 = el.offsetWidth;
var h1 = el.offsetHeight;
el.style.fontWeight = 'bold';
var w2 = el.offsetWidth;
var h2 = el.offsetHeight;
terminal.removeChild(el);
return w1 !== w2 || h1 !== h2;
}
//# sourceMappingURL=Renderer.js.map
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var Mouse = __webpack_require__(9);
var Browser = __webpack_require__(8);
var EventEmitter_1 = __webpack_require__(1);
var SelectionModel_1 = __webpack_require__(21);
var DRAG_SCROLL_MAX_THRESHOLD = 50;
var DRAG_SCROLL_MAX_SPEED = 15;
var DRAG_SCROLL_INTERVAL = 50;
var CLEAR_MOUSE_DOWN_TIME = 400;
var CLEAR_MOUSE_DISTANCE = 10;
var WORD_SEPARATORS = ' ()[]{}\'"';
var LINE_DATA_CHAR_INDEX = 1;
var LINE_DATA_WIDTH_INDEX = 2;
var NON_BREAKING_SPACE_CHAR = String.fromCharCode(160);
var ALL_NON_BREAKING_SPACE_REGEX = new RegExp(NON_BREAKING_SPACE_CHAR, 'g');
var SelectionMode;
(function (SelectionMode) {
SelectionMode[SelectionMode["NORMAL"] = 0] = "NORMAL";
SelectionMode[SelectionMode["WORD"] = 1] = "WORD";
SelectionMode[SelectionMode["LINE"] = 2] = "LINE";
})(SelectionMode || (SelectionMode = {}));
var SelectionManager = (function (_super) {
__extends(SelectionManager, _super);
function SelectionManager(_terminal, _buffer, _rowContainer, _charMeasure) {
var _this = _super.call(this) || this;
_this._terminal = _terminal;
_this._buffer = _buffer;
_this._rowContainer = _rowContainer;
_this._charMeasure = _charMeasure;
_this._initListeners();
_this.enable();
_this._model = new SelectionModel_1.SelectionModel(_terminal);
_this._lastMouseDownTime = 0;
_this._activeSelectionMode = SelectionMode.NORMAL;
return _this;
}
SelectionManager.prototype._initListeners = function () {
var _this = this;
this._bufferTrimListener = function (amount) { return _this._onTrim(amount); };
this._mouseMoveListener = function (event) { return _this._onMouseMove(event); };
this._mouseDownListener = function (event) { return _this._onMouseDown(event); };
this._mouseUpListener = function (event) { return _this._onMouseUp(event); };
};
SelectionManager.prototype.disable = function () {
this.clearSelection();
this._buffer.off('trim', this._bufferTrimListener);
this._rowContainer.removeEventListener('mousedown', this._mouseDownListener);
};
SelectionManager.prototype.enable = function () {
this._buffer.on('trim', this._bufferTrimListener);
this._rowContainer.addEventListener('mousedown', this._mouseDownListener);
};
SelectionManager.prototype.setBuffer = function (buffer) {
this._buffer = buffer;
this.clearSelection();
};
Object.defineProperty(SelectionManager.prototype, "hasSelection", {
get: function () {
var start = this._model.finalSelectionStart;
var end = this._model.finalSelectionEnd;
if (!start || !end) {
return false;
}
return start[0] !== end[0] || start[1] !== end[1];
},
enumerable: true,
configurable: true
});
Object.defineProperty(SelectionManager.prototype, "selectionText", {
get: function () {
var start = this._model.finalSelectionStart;
var end = this._model.finalSelectionEnd;
if (!start || !end) {
return '';
}
var startRowEndCol = start[1] === end[1] ? end[0] : null;
var result = [];
result.push(this._translateBufferLineToString(this._buffer.get(start[1]), true, start[0], startRowEndCol));
for (var i = start[1] + 1; i <= end[1] - 1; i++) {
var bufferLine = this._buffer.get(i);
var lineText = this._translateBufferLineToString(bufferLine, true);
if (bufferLine.isWrapped) {
result[result.length - 1] += lineText;
}
else {
result.push(lineText);
}
}
if (start[1] !== end[1]) {
var bufferLine = this._buffer.get(end[1]);
var lineText = this._translateBufferLineToString(bufferLine, true, 0, end[0]);
if (bufferLine.isWrapped) {
result[result.length - 1] += lineText;
}
else {
result.push(lineText);
}
}
var formattedResult = result.map(function (line) {
return line.replace(ALL_NON_BREAKING_SPACE_REGEX, ' ');
}).join(Browser.isMSWindows ? '\r\n' : '\n');
return formattedResult;
},
enumerable: true,
configurable: true
});
SelectionManager.prototype.clearSelection = function () {
this._model.clearSelection();
this._removeMouseDownListeners();
this.refresh();
};
SelectionManager.prototype._translateBufferLineToString = function (line, trimRight, startCol, endCol) {
if (startCol === void 0) { startCol = 0; }
if (endCol === void 0) { endCol = null; }
var lineString = '';
var widthAdjustedStartCol = startCol;
var widthAdjustedEndCol = endCol;
for (var i = 0; i < line.length; i++) {
var char = line[i];
lineString += char[LINE_DATA_CHAR_INDEX];
if (char[LINE_DATA_WIDTH_INDEX] === 0) {
if (startCol >= i) {
widthAdjustedStartCol--;
}
if (endCol >= i) {
widthAdjustedEndCol--;
}
}
}
var finalEndCol = widthAdjustedEndCol || line.length;
if (trimRight) {
var rightWhitespaceIndex = lineString.search(/\s+$/);
if (rightWhitespaceIndex !== -1) {
finalEndCol = Math.min(finalEndCol, rightWhitespaceIndex);
}
if (finalEndCol <= widthAdjustedStartCol) {
return '';
}
}
return lineString.substring(widthAdjustedStartCol, finalEndCol);
};
SelectionManager.prototype.refresh = function (isNewSelection) {
var _this = this;
if (!this._refreshAnimationFrame) {
this._refreshAnimationFrame = window.requestAnimationFrame(function () { return _this._refresh(); });
}
if (Browser.isLinux && isNewSelection) {
var selectionText = this.selectionText;
if (selectionText.length) {
this.emit('newselection', this.selectionText);
}
}
};
SelectionManager.prototype._refresh = function () {
this._refreshAnimationFrame = null;
this.emit('refresh', { start: this._model.finalSelectionStart, end: this._model.finalSelectionEnd });
};
SelectionManager.prototype.selectAll = function () {
this._model.isSelectAllActive = true;
this.refresh();
};
SelectionManager.prototype._onTrim = function (amount) {
var needsRefresh = this._model.onTrim(amount);
if (needsRefresh) {
this.refresh();
}
};
SelectionManager.prototype._getMouseBufferCoords = function (event) {
var coords = Mouse.getCoords(event, this._rowContainer, this._charMeasure, this._terminal.cols, this._terminal.rows, true);
coords[0]--;
coords[1]--;
coords[1] += this._terminal.ydisp;
return coords;
};
SelectionManager.prototype._getMouseEventScrollAmount = function (event) {
var offset = Mouse.getCoordsRelativeToElement(event, this._rowContainer)[1];
var terminalHeight = this._terminal.rows * this._charMeasure.height;
if (offset >= 0 && offset <= terminalHeight) {
return 0;
}
if (offset > terminalHeight) {
offset -= terminalHeight;
}
offset = Math.min(Math.max(offset, -DRAG_SCROLL_MAX_THRESHOLD), DRAG_SCROLL_MAX_THRESHOLD);
offset /= DRAG_SCROLL_MAX_THRESHOLD;
return (offset / Math.abs(offset)) + Math.round(offset * (DRAG_SCROLL_MAX_SPEED - 1));
};
SelectionManager.prototype._onMouseDown = function (event) {
if (event.button !== 0) {
return;
}
event.preventDefault();
this._dragScrollAmount = 0;
this._setMouseClickCount(event);
if (event.shiftKey) {
this._onShiftClick(event);
}
else {
if (this._clickCount === 1) {
this._onSingleClick(event);
}
else if (this._clickCount === 2) {
this._onDoubleClick(event);
}
else if (this._clickCount === 3) {
this._onTripleClick(event);
}
}
this._addMouseDownListeners();
this.refresh(true);
};
SelectionManager.prototype._addMouseDownListeners = function () {
var _this = this;
this._rowContainer.ownerDocument.addEventListener('mousemove', this._mouseMoveListener);
this._rowContainer.ownerDocument.addEventListener('mouseup', this._mouseUpListener);
this._dragScrollIntervalTimer = setInterval(function () { return _this._dragScroll(); }, DRAG_SCROLL_INTERVAL);
};
SelectionManager.prototype._removeMouseDownListeners = function () {
this._rowContainer.ownerDocument.removeEventListener('mousemove', this._mouseMoveListener);
this._rowContainer.ownerDocument.removeEventListener('mouseup', this._mouseUpListener);
clearInterval(this._dragScrollIntervalTimer);
this._dragScrollIntervalTimer = null;
};
SelectionManager.prototype._onShiftClick = function (event) {
if (this._model.selectionStart) {
this._model.selectionEnd = this._getMouseBufferCoords(event);
}
};
SelectionManager.prototype._onSingleClick = function (event) {
this._model.selectionStartLength = 0;
this._model.isSelectAllActive = false;
this._activeSelectionMode = SelectionMode.NORMAL;
this._model.selectionStart = this._getMouseBufferCoords(event);
if (this._model.selectionStart) {
this._model.selectionEnd = null;
var char = this._buffer.get(this._model.selectionStart[1])[this._model.selectionStart[0]];
if (char[LINE_DATA_WIDTH_INDEX] === 0) {
this._model.selectionStart[0]++;
}
}
};
SelectionManager.prototype._onDoubleClick = function (event) {
var coords = this._getMouseBufferCoords(event);
if (coords) {
this._activeSelectionMode = SelectionMode.WORD;
this._selectWordAt(coords);
}
};
SelectionManager.prototype._onTripleClick = function (event) {
var coords = this._getMouseBufferCoords(event);
if (coords) {
this._activeSelectionMode = SelectionMode.LINE;
this._selectLineAt(coords[1]);
}
};
SelectionManager.prototype._setMouseClickCount = function (event) {
var currentTime = (new Date()).getTime();
if (currentTime - this._lastMouseDownTime > CLEAR_MOUSE_DOWN_TIME || this._distanceFromLastMousePosition(event) > CLEAR_MOUSE_DISTANCE) {
this._clickCount = 0;
}
this._lastMouseDownTime = currentTime;
this._lastMousePosition = [event.pageX, event.pageY];
this._clickCount++;
};
SelectionManager.prototype._distanceFromLastMousePosition = function (event) {
var result = Math.max(Math.abs(this._lastMousePosition[0] - event.pageX), Math.abs(this._lastMousePosition[1] - event.pageY));
return result;
};
SelectionManager.prototype._onMouseMove = function (event) {
var previousSelectionEnd = this._model.selectionEnd ? [this._model.selectionEnd[0], this._model.selectionEnd[1]] : null;
this._model.selectionEnd = this._getMouseBufferCoords(event);
if (this._activeSelectionMode === SelectionMode.LINE) {
if (this._model.selectionEnd[1] < this._model.selectionStart[1]) {
this._model.selectionEnd[0] = 0;
}
else {
this._model.selectionEnd[0] = this._terminal.cols;
}
}
else if (this._activeSelectionMode === SelectionMode.WORD) {
this._selectToWordAt(this._model.selectionEnd);
}
this._dragScrollAmount = this._getMouseEventScrollAmount(event);
if (this._dragScrollAmount > 0) {
this._model.selectionEnd[0] = this._terminal.cols - 1;
}
else if (this._dragScrollAmount < 0) {
this._model.selectionEnd[0] = 0;
}
if (this._model.selectionEnd[1] < this._buffer.length) {
var char = this._buffer.get(this._model.selectionEnd[1])[this._model.selectionEnd[0]];
if (char && char[2] === 0) {
this._model.selectionEnd[0]++;
}
}
if (!previousSelectionEnd ||
previousSelectionEnd[0] !== this._model.selectionEnd[0] ||
previousSelectionEnd[1] !== this._model.selectionEnd[1]) {
this.refresh(true);
}
};
SelectionManager.prototype._dragScroll = function () {
if (this._dragScrollAmount) {
this._terminal.scrollDisp(this._dragScrollAmount, false);
if (this._dragScrollAmount > 0) {
this._model.selectionEnd = [this._terminal.cols - 1, this._terminal.ydisp + this._terminal.rows];
}
else {
this._model.selectionEnd = [0, this._terminal.ydisp];
}
this.refresh();
}
};
SelectionManager.prototype._onMouseUp = function (event) {
this._removeMouseDownListeners();
};
SelectionManager.prototype._convertViewportColToCharacterIndex = function (bufferLine, coords) {
var charIndex = coords[0];
for (var i = 0; coords[0] >= i; i++) {
var char = bufferLine[i];
if (char[LINE_DATA_WIDTH_INDEX] === 0) {
charIndex--;
}
}
return charIndex;
};
SelectionManager.prototype._getWordAt = function (coords) {
var bufferLine = this._buffer.get(coords[1]);
var line = this._translateBufferLineToString(bufferLine, false);
var endIndex = this._convertViewportColToCharacterIndex(bufferLine, coords);
var startIndex = endIndex;
var charOffset = coords[0] - startIndex;
var leftWideCharCount = 0;
var rightWideCharCount = 0;
if (line.charAt(startIndex) === ' ') {
while (startIndex > 0 && line.charAt(startIndex - 1) === ' ') {
startIndex--;
}
while (endIndex < line.length && line.charAt(endIndex + 1) === ' ') {
endIndex++;
}
}
else {
var startCol = coords[0];
var endCol = coords[0];
if (bufferLine[startCol][LINE_DATA_WIDTH_INDEX] === 0) {
leftWideCharCount++;
startCol--;
}
if (bufferLine[endCol][LINE_DATA_WIDTH_INDEX] === 2) {
rightWideCharCount++;
endCol++;
}
while (startIndex > 0 && !this._isCharWordSeparator(line.charAt(startIndex - 1))) {
if (bufferLine[startCol - 1][LINE_DATA_WIDTH_INDEX] === 0) {
leftWideCharCount++;
startCol--;
}
startIndex--;
startCol--;
}
while (endIndex + 1 < line.length && !this._isCharWordSeparator(line.charAt(endIndex + 1))) {
if (bufferLine[endCol + 1][LINE_DATA_WIDTH_INDEX] === 2) {
rightWideCharCount++;
endCol++;
}
endIndex++;
endCol++;
}
}
var start = startIndex + charOffset - leftWideCharCount;
var length = Math.min(endIndex - startIndex + leftWideCharCount + rightWideCharCount + 1, this._terminal.cols);
return { start: start, length: length };
};
SelectionManager.prototype._selectWordAt = function (coords) {
var wordPosition = this._getWordAt(coords);
this._model.selectionStart = [wordPosition.start, coords[1]];
this._model.selectionStartLength = wordPosition.length;
};
SelectionManager.prototype._selectToWordAt = function (coords) {
var wordPosition = this._getWordAt(coords);
this._model.selectionEnd = [this._model.areSelectionValuesReversed() ? wordPosition.start : (wordPosition.start + wordPosition.length), coords[1]];
};
SelectionManager.prototype._isCharWordSeparator = function (char) {
return WORD_SEPARATORS.indexOf(char) >= 0;
};
SelectionManager.prototype._selectLineAt = function (line) {
this._model.selectionStart = [0, line];
this._model.selectionStartLength = this._terminal.cols;
};
return SelectionManager;
}(EventEmitter_1.EventEmitter));
exports.SelectionManager = SelectionManager;
//# sourceMappingURL=SelectionManager.js.map
/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var SelectionModel = (function () {
function SelectionModel(_terminal) {
this._terminal = _terminal;
this.clearSelection();
}
SelectionModel.prototype.clearSelection = function () {
this.selectionStart = null;
this.selectionEnd = null;
this.isSelectAllActive = false;
this.selectionStartLength = 0;
};
Object.defineProperty(SelectionModel.prototype, "finalSelectionStart", {
get: function () {
if (this.isSelectAllActive) {
return [0, 0];
}
if (!this.selectionEnd || !this.selectionStart) {
return this.selectionStart;
}
return this.areSelectionValuesReversed() ? this.selectionEnd : this.selectionStart;
},
enumerable: true,
configurable: true
});
Object.defineProperty(SelectionModel.prototype, "finalSelectionEnd", {
get: function () {
if (this.isSelectAllActive) {
return [this._terminal.cols, this._terminal.ybase + this._terminal.rows - 1];
}
if (!this.selectionStart) {
return null;
}
if (!this.selectionEnd || this.areSelectionValuesReversed()) {
return [this.selectionStart[0] + this.selectionStartLength, this.selectionStart[1]];
}
if (this.selectionStartLength) {
if (this.selectionEnd[1] === this.selectionStart[1]) {
return [Math.max(this.selectionStart[0] + this.selectionStartLength, this.selectionEnd[0]), this.selectionEnd[1]];
}
}
return this.selectionEnd;
},
enumerable: true,
configurable: true
});
SelectionModel.prototype.areSelectionValuesReversed = function () {
var start = this.selectionStart;
var end = this.selectionEnd;
return start[1] > end[1] || (start[1] === end[1] && start[0] > end[0]);
};
SelectionModel.prototype.onTrim = function (amount) {
if (this.selectionStart) {
this.selectionStart[1] -= amount;
}
if (this.selectionEnd) {
this.selectionEnd[1] -= amount;
}
if (this.selectionEnd && this.selectionEnd[1] < 0) {
this.clearSelection();
return true;
}
if (this.selectionStart && this.selectionStart[1] < 0) {
this.selectionStart[1] = 0;
}
return false;
};
return SelectionModel;
}());
exports.SelectionModel = SelectionModel;
//# sourceMappingURL=SelectionModel.js.map
/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Viewport = (function () {
function Viewport(terminal, viewportElement, scrollArea, charMeasure) {
var _this = this;
this.terminal = terminal;
this.viewportElement = viewportElement;
this.scrollArea = scrollArea;
this.charMeasure = charMeasure;
this.currentRowHeight = 0;
this.lastRecordedBufferLength = 0;
this.lastRecordedViewportHeight = 0;
this.terminal.on('scroll', this.syncScrollArea.bind(this));
this.terminal.on('resize', this.syncScrollArea.bind(this));
this.viewportElement.addEventListener('scroll', this.onScroll.bind(this));
setTimeout(function () { return _this.syncScrollArea(); }, 0);
}
Viewport.prototype.refresh = function () {
if (this.charMeasure.height > 0) {
var rowHeightChanged = this.charMeasure.height !== this.currentRowHeight;
if (rowHeightChanged) {
this.currentRowHeight = this.charMeasure.height;
this.viewportElement.style.lineHeight = this.charMeasure.height + 'px';
this.terminal.rowContainer.style.lineHeight = this.charMeasure.height + 'px';
}
var viewportHeightChanged = this.lastRecordedViewportHeight !== this.terminal.rows;
if (rowHeightChanged || viewportHeightChanged) {
this.lastRecordedViewportHeight = this.terminal.rows;
this.viewportElement.style.height = this.charMeasure.height * this.terminal.rows + 'px';
this.terminal.selectionContainer.style.height = this.viewportElement.style.height;
}
this.scrollArea.style.height = (this.charMeasure.height * this.lastRecordedBufferLength) + 'px';
}
};
Viewport.prototype.syncScrollArea = function () {
if (this.lastRecordedBufferLength !== this.terminal.lines.length) {
this.lastRecordedBufferLength = this.terminal.lines.length;
this.refresh();
}
else if (this.lastRecordedViewportHeight !== this.terminal.rows) {
this.refresh();
}
else {
if (this.charMeasure.height !== this.currentRowHeight) {
this.refresh();
}
}
var scrollTop = this.terminal.ydisp * this.currentRowHeight;
if (this.viewportElement.scrollTop !== scrollTop) {
this.viewportElement.scrollTop = scrollTop;
}
};
Viewport.prototype.onScroll = function (ev) {
var newRow = Math.round(this.viewportElement.scrollTop / this.currentRowHeight);
var diff = newRow - this.terminal.ydisp;
this.terminal.scrollDisp(diff, true);
};
Viewport.prototype.onWheel = function (ev) {
if (ev.deltaY === 0) {
return;
}
var multiplier = 1;
if (ev.deltaMode === WheelEvent.DOM_DELTA_LINE) {
multiplier = this.currentRowHeight;
}
else if (ev.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
multiplier = this.currentRowHeight * this.terminal.rows;
}
this.viewportElement.scrollTop += ev.deltaY * multiplier;
ev.preventDefault();
};
;
Viewport.prototype.onTouchStart = function (ev) {
this.lastTouchY = ev.touches[0].pageY;
};
;
Viewport.prototype.onTouchMove = function (ev) {
var deltaY = this.lastTouchY - ev.touches[0].pageY;
this.lastTouchY = ev.touches[0].pageY;
if (deltaY === 0) {
return;
}
this.viewportElement.scrollTop += deltaY;
ev.preventDefault();
};
;
return Viewport;
}());
exports.Viewport = Viewport;
//# sourceMappingURL=Viewport.js.map
/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
var map = {
"./attach/attach": 4,
"./attach/attach.js": 4,
"./attach/package.json": 24,
"./fit/fit": 5,
"./fit/fit.js": 5,
"./fit/package.json": 25,
"./fullscreen/fullscreen": 6,
"./fullscreen/fullscreen.css": 26,
"./fullscreen/fullscreen.js": 6,
"./fullscreen/package.json": 27,
"./terminado/package.json": 28,
"./terminado/terminado": 7,
"./terminado/terminado.js": 7
};
function webpackContext(req) {
return __webpack_require__(webpackContextResolve(req));
};
function webpackContextResolve(req) {
var id = map[req];
if(!(id + 1)) // check for number or string
throw new Error("Cannot find module '" + req + "'.");
return id;
};
webpackContext.keys = function webpackContextKeys() {
return Object.keys(map);
};
webpackContext.resolve = webpackContextResolve;
module.exports = webpackContext;
webpackContext.id = 23;
/***/ }),
/* 24 */
/***/ (function(module, exports) {
module.exports = {"name":"xterm.attach","main":"attach.js","private":true}
/***/ }),
/* 25 */
/***/ (function(module, exports) {
module.exports = {"name":"xterm.fit","main":"fit.js","private":true}
/***/ }),
/* 26 */
/***/ (function(module, exports) {
throw new Error("Module parse failed: /home/yudai/archive/products/2015/gotty/src/github.com/yudai/gotty/js/node_modules/xterm/lib/addons/fullscreen/fullscreen.css Unexpected token (1:0)\nYou may need an appropriate loader to handle this file type.\n| .xterm.fullscreen {\n| position: fixed;\n| top: 0;");
/***/ }),
/* 27 */
/***/ (function(module, exports) {
module.exports = {"name":"xterm.fullscreen","main":"fullscreen.js","private":true}
/***/ }),
/* 28 */
/***/ (function(module, exports) {
module.exports = {"name":"xterm.terminado","main":"terminado.js","private":true}
/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function prepareTextForTerminal(text, isMSWindows) {
if (isMSWindows) {
return text.replace(/\r?\n/g, '\r');
}
return text;
}
exports.prepareTextForTerminal = prepareTextForTerminal;
function copyHandler(ev, term, selectionManager) {
if (term.browser.isMSIE) {
window.clipboardData.setData('Text', selectionManager.selectionText);
}
else {
ev.clipboardData.setData('text/plain', selectionManager.selectionText);
}
ev.preventDefault();
}
exports.copyHandler = copyHandler;
function pasteHandler(ev, term) {
ev.stopPropagation();
var text;
var dispatchPaste = function (text) {
text = prepareTextForTerminal(text, term.browser.isMSWindows);
term.handler(text);
term.textarea.value = '';
term.emit('paste', text);
return term.cancel(ev);
};
if (term.browser.isMSIE) {
if (window.clipboardData) {
text = window.clipboardData.getData('Text');
dispatchPaste(text);
}
}
else {
if (ev.clipboardData) {
text = ev.clipboardData.getData('text/plain');
dispatchPaste(text);
}
}
}
exports.pasteHandler = pasteHandler;
function moveTextAreaUnderMouseCursor(ev, textarea) {
textarea.style.position = 'fixed';
textarea.style.width = '20px';
textarea.style.height = '20px';
textarea.style.left = (ev.clientX - 10) + 'px';
textarea.style.top = (ev.clientY - 10) + 'px';
textarea.style.zIndex = '1000';
textarea.focus();
setTimeout(function () {
textarea.style.position = null;
textarea.style.width = null;
textarea.style.height = null;
textarea.style.left = null;
textarea.style.top = null;
textarea.style.zIndex = null;
}, 4);
}
exports.moveTextAreaUnderMouseCursor = moveTextAreaUnderMouseCursor;
function rightClickHandler(ev, textarea, selectionManager) {
moveTextAreaUnderMouseCursor(ev, textarea);
textarea.value = selectionManager.selectionText;
textarea.select();
}
exports.rightClickHandler = rightClickHandler;
//# sourceMappingURL=Clipboard.js.map
/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var EventEmitter_js_1 = __webpack_require__(1);
var CharMeasure = (function (_super) {
__extends(CharMeasure, _super);
function CharMeasure(document, parentElement) {
var _this = _super.call(this) || this;
_this._document = document;
_this._parentElement = parentElement;
return _this;
}
Object.defineProperty(CharMeasure.prototype, "width", {
get: function () {
return this._width;
},
enumerable: true,
configurable: true
});
Object.defineProperty(CharMeasure.prototype, "height", {
get: function () {
return this._height;
},
enumerable: true,
configurable: true
});
CharMeasure.prototype.measure = function () {
var _this = this;
if (!this._measureElement) {
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);
}
else {
this._doMeasure();
}
};
CharMeasure.prototype._doMeasure = function () {
var geometry = this._measureElement.getBoundingClientRect();
if (geometry.width === 0 || geometry.height === 0) {
return;
}
if (this._width !== geometry.width || this._height !== geometry.height) {
this._width = geometry.width;
this._height = geometry.height;
this.emit('charsizechanged');
}
};
return CharMeasure;
}(EventEmitter_js_1.EventEmitter));
exports.CharMeasure = CharMeasure;
//# sourceMappingURL=CharMeasure.js.map
/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
var EventEmitter_1 = __webpack_require__(1);
var CircularList = (function (_super) {
__extends(CircularList, _super);
function CircularList(maxLength) {
var _this = _super.call(this) || this;
_this._array = new Array(maxLength);
_this._startIndex = 0;
_this._length = 0;
return _this;
}
Object.defineProperty(CircularList.prototype, "maxLength", {
get: function () {
return this._array.length;
},
set: function (newMaxLength) {
var newArray = new Array(newMaxLength);
for (var i = 0; i < Math.min(newMaxLength, this.length); i++) {
newArray[i] = this._array[this._getCyclicIndex(i)];
}
this._array = newArray;
this._startIndex = 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(CircularList.prototype, "length", {
get: function () {
return this._length;
},
set: function (newLength) {
if (newLength > this._length) {
for (var i = this._length; i < newLength; i++) {
this._array[i] = undefined;
}
}
this._length = newLength;
},
enumerable: true,
configurable: true
});
Object.defineProperty(CircularList.prototype, "forEach", {
get: function () {
var _this = this;
return function (callbackfn) {
var i = 0;
var length = _this.length;
for (var i_1 = 0; i_1 < length; i_1++) {
callbackfn(_this.get(i_1), i_1);
}
};
},
enumerable: true,
configurable: true
});
CircularList.prototype.get = function (index) {
return this._array[this._getCyclicIndex(index)];
};
CircularList.prototype.set = function (index, value) {
this._array[this._getCyclicIndex(index)] = value;
};
CircularList.prototype.push = function (value) {
this._array[this._getCyclicIndex(this._length)] = value;
if (this._length === this.maxLength) {
this._startIndex++;
if (this._startIndex === this.maxLength) {
this._startIndex = 0;
}
this.emit('trim', 1);
}
else {
this._length++;
}
};
CircularList.prototype.pop = function () {
return this._array[this._getCyclicIndex(this._length-- - 1)];
};
CircularList.prototype.splice = function (start, deleteCount) {
var items = [];
for (var _i = 2; _i < arguments.length; _i++) {
items[_i - 2] = arguments[_i];
}
if (deleteCount) {
for (var i = start; i < this._length - deleteCount; i++) {
this._array[this._getCyclicIndex(i)] = this._array[this._getCyclicIndex(i + deleteCount)];
}
this._length -= deleteCount;
}
if (items && items.length) {
for (var i = this._length - 1; i >= start; i--) {
this._array[this._getCyclicIndex(i + items.length)] = this._array[this._getCyclicIndex(i)];
}
for (var i = 0; i < items.length; i++) {
this._array[this._getCyclicIndex(start + i)] = items[i];
}
if (this._length + items.length > this.maxLength) {
var countToTrim = (this._length + items.length) - this.maxLength;
this._startIndex += countToTrim;
this._length = this.maxLength;
this.emit('trim', countToTrim);
}
else {
this._length += items.length;
}
}
};
CircularList.prototype.trimStart = function (count) {
if (count > this._length) {
count = this._length;
}
this._startIndex += count;
this._length -= count;
this.emit('trim', count);
};
CircularList.prototype.shiftElements = function (start, count, offset) {
if (count <= 0) {
return;
}
if (start < 0 || start >= this._length) {
throw new Error('start argument out of range');
}
if (start + offset < 0) {
throw new Error('Cannot shift elements in list beyond index 0');
}
if (offset > 0) {
for (var i = count - 1; i >= 0; i--) {
this.set(start + i + offset, this.get(start + i));
}
var expandListBy = (start + count + offset) - this._length;
if (expandListBy > 0) {
this._length += expandListBy;
while (this._length > this.maxLength) {
this._length--;
this._startIndex++;
this.emit('trim', 1);
}
}
}
else {
for (var i = 0; i < count; i++) {
this.set(start + i + offset, this.get(start + i));
}
}
};
CircularList.prototype._getCyclicIndex = function (index) {
return (this._startIndex + index) % this.maxLength;
};
return CircularList;
}(EventEmitter_1.EventEmitter));
exports.CircularList = CircularList;
//# sourceMappingURL=CircularList.js.map
/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var DomElementObjectPool = (function () {
function DomElementObjectPool(type) {
this.type = type;
this._type = type;
this._pool = [];
this._inUse = {};
}
DomElementObjectPool.prototype.acquire = function () {
var element;
if (this._pool.length === 0) {
element = this._createNew();
}
else {
element = this._pool.pop();
}
this._inUse[element.getAttribute(DomElementObjectPool.OBJECT_ID_ATTRIBUTE)] = element;
return element;
};
DomElementObjectPool.prototype.release = function (element) {
if (!this._inUse[element.getAttribute(DomElementObjectPool.OBJECT_ID_ATTRIBUTE)]) {
throw new Error('Could not release an element not yet acquired');
}
delete this._inUse[element.getAttribute(DomElementObjectPool.OBJECT_ID_ATTRIBUTE)];
this._cleanElement(element);
this._pool.push(element);
};
DomElementObjectPool.prototype._createNew = function () {
var element = document.createElement(this._type);
var id = DomElementObjectPool._objectCount++;
element.setAttribute(DomElementObjectPool.OBJECT_ID_ATTRIBUTE, id.toString(10));
return element;
};
DomElementObjectPool.prototype._cleanElement = function (element) {
element.className = '';
element.innerHTML = '';
};
return DomElementObjectPool;
}());
DomElementObjectPool.OBJECT_ID_ATTRIBUTE = 'data-obj-id';
DomElementObjectPool._objectCount = 0;
exports.DomElementObjectPool = DomElementObjectPool;
//# sourceMappingURL=DomElementObjectPool.js.map
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function contains(arr, el) {
return arr.indexOf(el) >= 0;
}
exports.contains = contains;
;
//# sourceMappingURL=Generic.js.map
/***/ }),
/* 34 */
/***/ (function(module, exports) {
module.exports = hterm;
/***/ }),
/* 35 */
/***/ (function(module, exports) {
module.exports = lib;
/***/ })
/******/ ]);
//# sourceMappingURL=bundle.js.map
Reference in New Issue View Git Blame Copy Permalink