(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Terminal = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
-/**
- * @license MIT
- */
"use strict";
-/**
- * Encapsulates the logic for handling compositionstart, compositionupdate and compositionend
- * events, displaying the in-progress composition to the UI and forwarding the final composition
- * to the handler.
- */
+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['='] = {
+ '#': 'ù',
+ '@': 'à',
+ '[': 'é',
+ '\\': 'ç',
+ ']': 'ê',
+ '^': 'î',
+ '_': 'è',
+ '`': 'ô',
+ '{': 'ä',
+ '|': 'ö',
+ '}': 'ü',
+ '~': 'û'
+};
+
+
+
+},{}],2:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
var CompositionHelper = (function () {
- /**
- * Creates a new CompositionHelper.
- * @param textarea The textarea that xterm uses for input.
- * @param compositionView The element to display the in-progress composition in.
- * @param terminal The Terminal to forward the finished composition to.
- */
function CompositionHelper(textarea, compositionView, terminal) {
this.textarea = textarea;
this.compositionView = compositionView;
this.isSendingComposition = false;
this.compositionPosition = { start: null, end: null };
}
- ;
- /**
- * Handles the compositionstart event, activating the composition view.
- */
CompositionHelper.prototype.compositionstart = function () {
this.isComposing = true;
this.compositionPosition.start = this.textarea.value.length;
this.compositionView.textContent = '';
this.compositionView.classList.add('active');
};
- /**
- * Handles the compositionupdate event, updating the composition view.
- * @param {CompositionEvent} ev The event.
- */
CompositionHelper.prototype.compositionupdate = function (ev) {
+ var _this = this;
this.compositionView.textContent = ev.data;
this.updateCompositionElements();
- var self = this;
setTimeout(function () {
- self.compositionPosition.end = self.textarea.value.length;
+ _this.compositionPosition.end = _this.textarea.value.length;
}, 0);
};
- /**
- * Handles the compositionend event, hiding the composition view and sending the composition to
- * the handler.
- */
CompositionHelper.prototype.compositionend = function () {
this.finalizeComposition(true);
};
- /**
- * Handles the keydown event, routing any necessary events to the CompositionHelper functions.
- * @param ev The keydown event.
- * @return Whether the Terminal should continue processing the keydown event.
- */
CompositionHelper.prototype.keydown = function (ev) {
if (this.isComposing || this.isSendingComposition) {
if (ev.keyCode === 229) {
- // Continue composing if the keyCode is the "composition character"
return false;
}
else if (ev.keyCode === 16 || ev.keyCode === 17 || ev.keyCode === 18) {
- // Continue composing if the keyCode is a modifier key
return false;
}
else {
- // Finish composition immediately. This is mainly here for the case where enter is
- // pressed and the handler needs to be triggered before the command is executed.
this.finalizeComposition(false);
}
}
if (ev.keyCode === 229) {
- // If the "composition character" is used but gets to this point it means a non-composition
- // character (eg. numbers and punctuation) was pressed when the IME was active.
this.handleAnyTextareaChanges();
return false;
}
return true;
};
- /**
- * Finalizes the composition, resuming regular input actions. This is called when a composition
- * is ending.
- * @param waitForPropogation Whether to wait for events to propogate before sending
- * the input. This should be false if a non-composition keystroke is entered before the
- * compositionend event is triggered, such as enter, so that the composition is send before
- * the command is executed.
- */
CompositionHelper.prototype.finalizeComposition = function (waitForPropogation) {
+ var _this = this;
this.compositionView.classList.remove('active');
this.isComposing = false;
this.clearTextareaPosition();
if (!waitForPropogation) {
- // Cancel any delayed composition send requests and send the input immediately.
this.isSendingComposition = false;
var input = this.textarea.value.substring(this.compositionPosition.start, this.compositionPosition.end);
this.terminal.handler(input);
}
else {
- // Make a deep copy of the composition position here as a new compositionstart event may
- // fire before the setTimeout executes.
- var currentCompositionPosition = {
+ var currentCompositionPosition_1 = {
start: this.compositionPosition.start,
end: this.compositionPosition.end,
};
- // Since composition* events happen before the changes take place in the textarea on most
- // browsers, use a setTimeout with 0ms time to allow the native compositionend event to
- // complete. This ensures the correct character is retrieved, this solution was used
- // because:
- // - The compositionend event's data property is unreliable, at least on Chromium
- // - The last compositionupdate event's data property does not always accurately describe
- // the character, a counter example being Korean where an ending consonsant can move to
- // the following character if the following input is a vowel.
- var self = this;
this.isSendingComposition = true;
setTimeout(function () {
- // Ensure that the input has not already been sent
- if (self.isSendingComposition) {
- self.isSendingComposition = false;
- var input;
- if (self.isComposing) {
- // Use the end position to get the string if a new composition has started.
- input = self.textarea.value.substring(currentCompositionPosition.start, currentCompositionPosition.end);
+ 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 {
- // Don't use the end position here in order to pick up any characters after the
- // composition has finished, for example when typing a non-composition character
- // (eg. 2) after a composition character.
- input = self.textarea.value.substring(currentCompositionPosition.start);
+ input = _this.textarea.value.substring(currentCompositionPosition_1.start);
}
- self.terminal.handler(input);
+ _this.terminal.handler(input);
}
}, 0);
}
};
- /**
- * Apply any changes made to the textarea after the current event chain is allowed to complete.
- * This should be called when not currently composing but a keydown event with the "composition
- * character" (229) is triggered, in order to allow non-composition text to be entered when an
- * IME is active.
- */
CompositionHelper.prototype.handleAnyTextareaChanges = function () {
+ var _this = this;
var oldValue = this.textarea.value;
- var self = this;
setTimeout(function () {
- // Ignore if a composition has started since the timeout
- if (!self.isComposing) {
- var newValue = self.textarea.value;
+ if (!_this.isComposing) {
+ var newValue = _this.textarea.value;
var diff = newValue.replace(oldValue, '');
if (diff.length > 0) {
- self.terminal.handler(diff);
+ _this.terminal.handler(diff);
}
}
}, 0);
};
- /**
- * Positions the composition view on top of the cursor and the textarea just below it (so the
- * IME helper dialog is positioned correctly).
- * @param dontRecurse Whether to use setTimeout to recursively trigger another update, this is
- * necessary as the IME events across browsers are not consistently triggered.
- */
CompositionHelper.prototype.updateCompositionElements = function (dontRecurse) {
+ var _this = this;
if (!this.isComposing) {
return;
}
var cursor = this.terminal.element.querySelector('.terminal-cursor');
if (cursor) {
- // Take .xterm-rows offsetTop into account as well in case it's positioned absolutely within
- // the .xterm element.
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';
- // Sync the textarea to the exact position of the composition view so the IME knows where the
- // text is.
var compositionViewBounds = this.compositionView.getBoundingClientRect();
this.textarea.style.left = cursor.offsetLeft + 'px';
this.textarea.style.top = cursorTop + 'px';
this.textarea.style.lineHeight = compositionViewBounds.height + 'px';
}
if (!dontRecurse) {
- setTimeout(this.updateCompositionElements.bind(this, true), 0);
+ setTimeout(function () { return _this.updateCompositionElements(true); }, 0);
}
};
;
- /**
- * Clears the textarea's position so that the cursor does not blink on IE.
- * @private
- */
CompositionHelper.prototype.clearTextareaPosition = function () {
this.textarea.style.left = '';
this.textarea.style.top = '';
}());
exports.CompositionHelper = CompositionHelper;
-},{}],2:[function(require,module,exports){
-/**
- * @license MIT
- */
+
+
+},{}],3:[function(require,module,exports){
"use strict";
-function EventEmitter() {
- this._events = this._events || {};
-}
-exports.EventEmitter = EventEmitter;
-EventEmitter.prototype.addListener = function (type, listener) {
- this._events[type] = this._events[type] || [];
- this._events[type].push(listener);
-};
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-EventEmitter.prototype.removeListener = function (type, listener) {
- if (!this._events[type])
- return;
- var obj = this._events[type], i = obj.length;
- while (i--) {
- if (obj[i] === listener || obj[i].listener === listener) {
- obj.splice(i, 1);
+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 = {}));
+;
+
+
+
+},{}],4:[function(require,module,exports){
+"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;
}
- }
-};
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-EventEmitter.prototype.removeAllListeners = function (type) {
- if (this._events[type])
- delete this._events[type];
-};
-EventEmitter.prototype.once = function (type, listener) {
- var self = this;
- function on() {
- var args = Array.prototype.slice.call(arguments);
- this.removeListener(type, on);
- return listener.apply(this, args);
- }
- on.listener = listener;
- return this.on(type, on);
-};
-EventEmitter.prototype.emit = function (type) {
- if (!this._events[type])
- return;
- var args = Array.prototype.slice.call(arguments, 1), obj = this._events[type], l = obj.length, i = 0;
- for (; i < l; i++) {
- obj[i].apply(this, args);
- }
-};
-EventEmitter.prototype.listeners = function (type) {
- return this._events[type] = this._events[type] || [];
-};
+ 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;
-},{}],3:[function(require,module,exports){
-/**
- * @license MIT
- */
+
+
+},{}],5:[function(require,module,exports){
"use strict";
-/**
- * Represents the viewport of a terminal, the visible area within the larger buffer of output.
- * Logic for the virtual scroll bar is included in this object.
- */
-var Viewport = (function () {
- /**
- * Creates a new Viewport.
- * @param terminal The terminal this viewport belongs to.
- * @param viewportElement The DOM element acting as the viewport.
- * @param scrollArea The DOM element acting as the scroll area.
- * @param charMeasureElement A DOM element used to measure the character size of. the terminal.
- */
- function Viewport(terminal, viewportElement, scrollArea, charMeasureElement) {
- this.terminal = terminal;
- this.viewportElement = viewportElement;
- this.scrollArea = scrollArea;
- this.charMeasureElement = charMeasureElement;
- 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));
- this.syncScrollArea();
- }
- /**
- * Refreshes row height, setting line-height, viewport height and scroll area height if
- * necessary.
- * @param charSize A character size measurement bounding rect object, if it doesn't exist it will
- * be created.
- */
- Viewport.prototype.refresh = function (charSize) {
- var size = charSize || this.charMeasureElement.getBoundingClientRect();
- if (size.height > 0) {
- var rowHeightChanged = size.height !== this.currentRowHeight;
- if (rowHeightChanged) {
- this.currentRowHeight = size.height;
- this.viewportElement.style.lineHeight = size.height + 'px';
- this.terminal.rowContainer.style.lineHeight = size.height + 'px';
+Object.defineProperty(exports, "__esModule", { value: true });
+var EscapeSequences_1 = require("./EscapeSequences");
+var Charsets_1 = require("./Charsets");
+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 viewportHeightChanged = this.lastRecordedViewportHeight !== this.terminal.rows;
- if (rowHeightChanged || viewportHeightChanged) {
- this.lastRecordedViewportHeight = this.terminal.rows;
- this.viewportElement.style.height = size.height * this.terminal.rows + 'px';
+ 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++;
}
- this.scrollArea.style.height = (size.height * this.lastRecordedBufferLength) + 'px';
}
};
- /**
- * Updates dimensions and synchronizes the scroll area if necessary.
- */
- Viewport.prototype.syncScrollArea = function () {
- if (this.lastRecordedBufferLength !== this.terminal.lines.length) {
- // If buffer height changed
- this.lastRecordedBufferLength = this.terminal.lines.length;
- this.refresh();
+ InputHandler.prototype.bell = function () {
+ var _this = this;
+ if (!this._terminal.visualBell) {
+ return;
}
- else if (this.lastRecordedViewportHeight !== this.terminal.rows) {
- // If viewport height changed
- this.refresh();
+ this._terminal.element.style.borderColor = 'white';
+ setTimeout(function () { return _this._terminal.element.style.borderColor = ''; }, 10);
+ if (this._terminal.popOnBell) {
+ this._terminal.focus();
}
- else {
- // If size has changed, refresh viewport
- var size = this.charMeasureElement.getBoundingClientRect();
- if (size.height !== this.currentRowHeight) {
- this.refresh(size);
- }
+ };
+ InputHandler.prototype.lineFeed = function () {
+ if (this._terminal.convertEol) {
+ this._terminal.x = 0;
}
- // Sync scrollTop
- var scrollTop = this.terminal.ydisp * this.currentRowHeight;
- if (this.viewportElement.scrollTop !== scrollTop) {
- this.viewportElement.scrollTop = scrollTop;
+ 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--;
}
};
- /**
- * Handles scroll events on the viewport, calculating the new viewport and requesting the
- * terminal to scroll to it.
- * @param ev The scroll event.
- */
- 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);
+ InputHandler.prototype.carriageReturn = function () {
+ this._terminal.x = 0;
};
- /**
- * Handles mouse wheel events by adjusting the viewport's scrollTop and delegating the actual
- * scrolling to `onScroll`, this event needs to be attached manually by the consumer of
- * `Viewport`.
- * @param ev The mouse wheel event.
- */
- Viewport.prototype.onWheel = function (ev) {
- if (ev.deltaY === 0) {
- // Do nothing if it's not a vertical scroll event
- return;
+ InputHandler.prototype.backspace = function () {
+ if (this._terminal.x > 0) {
+ this._terminal.x--;
}
- // Fallback to WheelEvent.DOM_DELTA_PIXEL
- var multiplier = 1;
- if (ev.deltaMode === WheelEvent.DOM_DELTA_LINE) {
- multiplier = this.currentRowHeight;
+ };
+ 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();
}
- else if (ev.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
- multiplier = this.currentRowHeight * this.terminal.rows;
+ };
+ 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;
}
- this.viewportElement.scrollTop += ev.deltaY * multiplier;
- // Prevent the page from scrolling when the terminal scrolls
- ev.preventDefault();
+ };
+ 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;
};
;
- return Viewport;
-}());
-exports.Viewport = Viewport;
-
-},{}],4:[function(require,module,exports){
-/**
- * Clipboard handler module: exports methods for handling all clipboard-related events in the
- * terminal.
- * @module xterm/handlers/Clipboard
- * @license MIT
- */
-"use strict";
-/**
- * Prepares text copied from terminal selection, to be saved in the clipboard by:
- * 1. stripping all trailing white spaces
- * 2. converting all non-breaking spaces to regular spaces
- * @param {string} text The copied text that needs processing for storing in clipboard
- * @returns {string}
- */
-function prepareTextForClipboard(text) {
- var space = String.fromCharCode(32), nonBreakingSpace = String.fromCharCode(160), allNonBreakingSpaces = new RegExp(nonBreakingSpace, 'g'), processedText = text.split('\n').map(function (line) {
- // Strip all trailing white spaces and convert all non-breaking spaces
- // to regular spaces.
- var processedLine = line.replace(/\s+$/g, '').replace(allNonBreakingSpaces, space);
- return processedLine;
- }).join('\n');
- return processedText;
-}
-exports.prepareTextForClipboard = prepareTextForClipboard;
-/**
- * Binds copy functionality to the given terminal.
- * @param {ClipboardEvent} ev The original copy event to be handled
- */
-function copyHandler(ev, term) {
- // We cast `window` to `any` type, because TypeScript has not declared the `clipboardData`
- // property that we use below for Internet Explorer.
- var copiedText = window.getSelection().toString(), text = prepareTextForClipboard(copiedText);
- if (term.browser.isMSIE) {
- window.clipboardData.setData('Text', text);
- }
- else {
- ev.clipboardData.setData('text/plain', text);
- }
- ev.preventDefault(); // Prevent or the original text will be copied.
-}
-exports.copyHandler = copyHandler;
-/**
- * Redirect the clipboard's data to the terminal's input handler.
- * @param {ClipboardEvent} ev The original paste event to be handled
- * @param {Terminal} term The terminal on which to apply the handled paste event
- */
-function pasteHandler(ev, term) {
- ev.stopPropagation();
- var text;
- var dispatchPaste = function (text) {
- term.handler(text);
- term.textarea.value = '';
- return term.cancel(ev);
+ 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;
};
- if (term.browser.isMSIE) {
- if (window.clipboardData) {
- text = window.clipboardData.getData('Text');
- dispatchPaste(text);
+ ;
+ InputHandler.prototype.cursorCharAbsolute = function (params) {
+ var param = params[0];
+ if (param < 1) {
+ param = 1;
}
- }
- else {
- if (ev.clipboardData) {
- text = ev.clipboardData.getData('text/plain');
- dispatchPaste(text);
+ 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;
}
- }
-}
-exports.pasteHandler = pasteHandler;
-/**
- * Bind to right-click event and allow right-click copy and paste.
- *
- * **Logic**
- * If text is selected and right-click happens on selected text, then
- * do nothing to allow seamless copying.
- * If no text is selected or right-click is outside of the selection
- * area, then bring the terminal's input below the cursor, in order to
- * trigger the event on the textarea and allow-right click paste, without
- * caring about disappearing selection.
- * @param {MouseEvent} ev The original right click event to be handled
- * @param {Terminal} term The terminal on which to apply the handled paste event
- */
-function rightClickHandler(ev, term) {
- var s = document.getSelection(), selectedText = prepareTextForClipboard(s.toString()), clickIsOnSelection = false, x = ev.clientX, y = ev.clientY;
- if (s.rangeCount) {
- var r = s.getRangeAt(0), cr = r.getClientRects();
- for (var i = 0; i < cr.length; i++) {
- var rect = cr[i];
- clickIsOnSelection = ((x > rect.left) && (x < rect.right) &&
- (y > rect.top) && (y < rect.bottom));
- if (clickIsOnSelection) {
+ 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);
}
- // If we clicked on selection and selection is not a single space,
- // then mark the right click as copy-only. We check for the single
- // space selection, as this can happen when clicking on an
- // and there is not much pointing in copying a single space.
- if (selectedText.match(/^\s$/) || !selectedText.length) {
- clickIsOnSelection = false;
- }
- }
- // Bring textarea at the cursor position
- if (!clickIsOnSelection) {
- term.textarea.style.position = 'fixed';
- term.textarea.style.width = '20px';
- term.textarea.style.height = '20px';
- term.textarea.style.left = (x - 10) + 'px';
- term.textarea.style.top = (y - 10) + 'px';
- term.textarea.style.zIndex = '1000';
- term.textarea.focus();
- // Reset the terminal textarea's styling
- setTimeout(function () {
- term.textarea.style.position = null;
- term.textarea.style.width = null;
- term.textarea.style.height = null;
- term.textarea.style.left = null;
- term.textarea.style.top = null;
- term.textarea.style.zIndex = null;
- }, 4);
- }
-}
-exports.rightClickHandler = rightClickHandler;
-
-},{}],5:[function(require,module,exports){
-/**
- * Attributes and methods to help with identifying the current browser and platform.
- * @module xterm/utils/Browser
- * @license MIT
- */
-"use strict";
-var Generic_js_1 = require('./Generic.js');
-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');
-// Find the users platform. We use this to interpret the meta key
-// and ISO third level shifts.
-// http://stackoverflow.com/q/19877924/577598
-exports.isMac = Generic_js_1.contains(['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'], platform);
-exports.isIpad = platform === 'iPad';
-exports.isIphone = platform === 'iPhone';
-exports.isMSWindows = Generic_js_1.contains(['Windows', 'Win16', 'Win32', 'WinCE'], platform);
-
-},{"./Generic.js":6}],6:[function(require,module,exports){
-/**
- * Generic utilities module with methods that can be helpful at different parts of the code base.
- * @module xterm/utils/Generic
- * @license MIT
- */
-"use strict";
-/**
- * Return if the given array contains the given element
- * @param {Array} array The array to search for the given element.
- * @param {Object} el The element to look for into the array
- */
-exports.contains = function (arr, el) {
- return arr.indexOf(el) >= 0;
+ 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 });
+
+
+
+},{"./Charsets":1,"./EscapeSequences":3}],6:[function(require,module,exports){
+"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;
+
+
+
+},{}],7:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var EscapeSequences_1 = require("./EscapeSequences");
+var Charsets_1 = require("./Charsets");
+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;
+
+
+
+},{"./Charsets":1,"./EscapeSequences":3}],8:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var DomElementObjectPool_1 = require("./utils/DomElementObjectPool");
+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 += '&';
+ break;
+ case '<':
+ innerHTML += '<';
+ break;
+ case '>':
+ innerHTML += '>';
+ break;
+ default:
+ if (ch <= ' ') {
+ innerHTML += ' ';
+ }
+ 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;
+}
+
+
+
+},{"./utils/DomElementObjectPool":16}],9:[function(require,module,exports){
+"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 = require("./utils/Mouse");
+var Browser = require("./utils/Browser");
+var EventEmitter_1 = require("./EventEmitter");
+var SelectionModel_1 = require("./SelectionModel");
+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;
-},{}],7:[function(require,module,exports){
-/**
- * xterm.js: xterm, in the browser
- * Originally forked from (with the author's permission):
- * Fabrice Bellard's javascript vt100 for jslinux:
- * http://bellard.org/jslinux/
- * Copyright (c) 2011 Fabrice Bellard
- * The original design remains. The terminal itself
- * has been extended to include xterm CSI codes, among
- * other features.
- * @license MIT
- */
+
+
+},{"./EventEmitter":4,"./SelectionModel":10,"./utils/Browser":13,"./utils/Mouse":18}],10:[function(require,module,exports){
+"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;
+
+
+
+},{}],11:[function(require,module,exports){
+"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;
+
+
+
+},{}],12:[function(require,module,exports){
+"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;
+
+
+
+},{}],13:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Generic_1 = require("./Generic");
+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;
+
+
+
+},{"./Generic":17}],14:[function(require,module,exports){
+"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 = require("../EventEmitter.js");
+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;
+
+
+
+},{"../EventEmitter.js":4}],15:[function(require,module,exports){
+"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 = require("../EventEmitter");
+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;
+
+
+
+},{"../EventEmitter":4}],16:[function(require,module,exports){
+"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;
+
+
+
+},{}],17:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function contains(arr, el) {
+ return arr.indexOf(el) >= 0;
+}
+exports.contains = contains;
+;
+
+
+
+},{}],18:[function(require,module,exports){
+"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;
+
+
+
+},{}],19:[function(require,module,exports){
"use strict";
-var CompositionHelper_js_1 = require('./CompositionHelper.js');
-var EventEmitter_js_1 = require('./EventEmitter.js');
-var Viewport_js_1 = require('./Viewport.js');
-var Clipboard_js_1 = require('./handlers/Clipboard.js');
-var Browser = require('./utils/Browser');
-/**
- * Terminal Emulation References:
- * http://vt100.net/
- * http://invisible-island.net/xterm/ctlseqs/ctlseqs.txt
- * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
- * http://invisible-island.net/vttest/
- * http://www.inwap.com/pdp10/ansicode.txt
- * http://linux.die.net/man/4/console_codes
- * http://linux.die.net/man/7/urxvt
- */
-// Let it work inside Node.js for automated testing purposes.
+Object.defineProperty(exports, "__esModule", { value: true });
+var CompositionHelper_1 = require("./CompositionHelper");
+var EventEmitter_1 = require("./EventEmitter");
+var Viewport_1 = require("./Viewport");
+var Clipboard_1 = require("./handlers/Clipboard");
+var CircularList_1 = require("./utils/CircularList");
+var EscapeSequences_1 = require("./EscapeSequences");
+var InputHandler_1 = require("./InputHandler");
+var Parser_1 = require("./Parser");
+var Renderer_1 = require("./Renderer");
+var Linkifier_1 = require("./Linkifier");
+var SelectionManager_1 = require("./SelectionManager");
+var CharMeasure_1 = require("./utils/CharMeasure");
+var Browser = require("./utils/Browser");
+var Mouse_1 = require("./utils/Mouse");
var document = (typeof window != 'undefined') ? window.document : null;
-/**
- * States
- */
-var normal = 0, escaped = 1, csi = 2, osc = 3, charset = 4, dcs = 5, ignore = 6;
-/**
- * Terminal
- */
-/**
- * Creates a new `Terminal` object.
- *
- * @param {object} options An object containing a set of options, the available options are:
- * - `cursorBlink` (boolean): Whether the terminal cursor blinks
- * - `cols` (number): The number of columns of the terminal (horizontal size)
- * - `rows` (number): The number of rows of the terminal (vertical size)
- *
- * @public
- * @class Xterm Xterm
- * @alias module:xterm/src/xterm
- */
+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)) {
}
self.browser = Browser;
self.cancel = Terminal.cancel;
- EventEmitter_js_1.EventEmitter.call(this);
+ EventEmitter_1.EventEmitter.call(this);
if (typeof options === 'number') {
options = {
cols: arguments[0],
}
this.colors = options.colors;
this.options = options;
- // this.context = options.context || window;
- // this.document = options.document || document;
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];
if (options.handler) {
this.on('data', options.handler);
}
- /**
- * The scroll position of the y cursor, ie. ybase + y = the y position within the entire
- * buffer
- */
this.ybase = 0;
- /**
- * The scroll position of the viewport
- */
this.ydisp = 0;
- /**
- * The cursor's x position after ybase
- */
this.x = 0;
- /**
- * The cursor's y position after ybase
- */
this.y = 0;
- /**
- * Used to debounce the refresh function
- */
- this.isRefreshing = false;
- /**
- * Whether there is a full terminal refresh queued
- */
this.cursorState = 0;
this.cursorHidden = false;
this.convertEol;
- this.state = 0;
this.queue = '';
this.scrollTop = 0;
this.scrollBottom = this.rows - 1;
- this.customKeydownHandler = null;
- // modes
+ this.customKeyEventHandler = null;
+ this.cursorBlinkInterval = null;
this.applicationKeypad = false;
this.applicationCursor = false;
this.originMode = false;
this.insertMode = false;
- this.wraparoundMode = true; // defaults: xterm - true, vt100 - false
+ this.wraparoundMode = true;
this.normal = null;
- // charset
this.charset = null;
this.gcharset = null;
this.glevel = 0;
this.charsets = [null];
- // mouse properties
this.decLocator;
this.x10Mouse;
this.vt200Mouse;
this.utfMouse;
this.sgrMouse;
this.urxvtMouse;
- // misc
this.element;
this.children;
this.refreshStart;
this.savedX;
this.savedY;
this.savedCols;
- // stream
this.readable = true;
this.writable = true;
this.defAttr = (0 << 18) | (257 << 9) | (256 << 0);
this.currentParam = 0;
this.prefix = '';
this.postfix = '';
- // leftover surrogate high from previous write invocation
+ 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 = '';
- /**
- * An array of all lines in the entire buffer, including the prompt. The lines are array of
- * characters which are 2-length arrays where [0] is an attribute and [1] is the character.
- */
- this.lines = [];
+ 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();
- // Store if user went browsing history in scrollback
this.userScrolling = false;
}
-inherits(Terminal, EventEmitter_js_1.EventEmitter);
-/**
- * back_color_erase feature for xterm.
- */
+inherits(Terminal, EventEmitter_1.EventEmitter);
Terminal.prototype.eraseAttr = function () {
- // if (this.is('screen')) return this.defAttr;
return (this.defAttr & ~0x1ff) | (this.curAttr & 0x1ff);
};
-/**
- * Colors
- */
-// Colors 0-15
Terminal.tangoColors = [
- // dark:
'#2e3436',
'#cc0000',
'#4e9a06',
'#75507b',
'#06989a',
'#d3d7cf',
- // bright:
'#555753',
'#ef2929',
'#8ae234',
'#34e2e2',
'#eeeeec'
];
-// Colors 0-15 + 16-255
-// Much thanks to TooTallNate for writing this.
Terminal.colors = (function () {
var colors = Terminal.tangoColors.slice(), r = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff], i;
- // 16-231
i = 0;
for (; i < 216; i++) {
out(r[(i / 36) % 6 | 0], r[(i / 6) % 6 | 0], r[i % 6]);
}
- // 232-255 (grey)
i = 0;
for (; i < 24; i++) {
r = 8 + i * 10;
}
return out;
})();
-/**
- * Options
- */
Terminal.defaults = {
colors: Terminal.colors,
theme: 'default',
termName: 'xterm',
geometry: [80, 24],
cursorBlink: false,
+ cursorStyle: 'block',
visualBell: false,
popOnBell: false,
scrollback: 1000,
screenKeys: false,
debug: false,
- cancelEvents: false
+ cancelEvents: false,
+ disableStdin: false,
+ useFlowControl: false,
+ tabStopWidth: 8
};
Terminal.options = {};
Terminal.focus = null;
Terminal[key] = Terminal.defaults[key];
Terminal.options[key] = Terminal.defaults[key];
});
-/**
- * Focus the terminal. Delegates focus handling to the terminal's DOM element.
- */
Terminal.prototype.focus = function () {
return this.textarea.focus();
};
-/**
- * Retrieves an option's value from the terminal.
- * @param {string} key The option key.
- */
Terminal.prototype.getOption = function (key, value) {
if (!(key in Terminal.defaults)) {
throw new Error('No option with key "' + key + '"');
}
return this[key];
};
-/**
- * Sets an option on the terminal.
- * @param {string} key The option key.
- * @param {string} value The option value.
- */
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;
+ }
};
-/**
- * Binds the desired focus behavior on a given terminal object.
- *
- * @static
- */
Terminal.bindFocus = function (term) {
on(term.textarea, 'focus', function (ev) {
if (term.sendFocus) {
- term.send('\x1b[I');
+ 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 });
});
};
-/**
- * Blur the terminal. Delegates blur handling to the terminal's DOM element.
- */
Terminal.prototype.blur = function () {
return this.textarea.blur();
};
-/**
- * Binds the desired blur behavior on a given terminal object.
- *
- * @static
- */
Terminal.bindBlur = function (term) {
on(term.textarea, 'blur', function (ev) {
term.refresh(term.y, term.y);
if (term.sendFocus) {
- term.send('\x1b[O');
+ term.send(EscapeSequences_1.C0.ESC + '[O');
}
term.element.classList.remove('focus');
+ term.clearCursorBlinkingInterval.apply(term);
Terminal.focus = null;
term.emit('blur', { terminal: term });
});
};
-/**
- * Initialize default behavior
- */
Terminal.prototype.initGlobal = function () {
+ var _this = this;
var term = this;
Terminal.bindKeys(this);
Terminal.bindFocus(this);
Terminal.bindBlur(this);
- // Bind clipboard functionality
- on(this.element, 'copy', function (ev) {
- Clipboard_js_1.copyHandler.call(this, ev, term);
- });
- on(this.textarea, 'paste', function (ev) {
- Clipboard_js_1.pasteHandler.call(this, ev, term);
- });
- on(this.element, 'paste', function (ev) {
- Clipboard_js_1.pasteHandler.call(this, ev, term);
+ on(this.element, 'copy', function (event) {
+ if (_this.mouseEvents) {
+ return;
+ }
+ Clipboard_1.copyHandler(event, term, _this.selectionManager);
});
- function rightClickHandlerWrapper(ev) {
- Clipboard_js_1.rightClickHandler.call(this, ev, term);
- }
+ 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 (ev) {
- if (ev.button == 2) {
- rightClickHandlerWrapper(ev);
+ on(this.element, 'mousedown', function (event) {
+ if (event.button == 2) {
+ Clipboard_1.rightClickHandler(event, _this.textarea, _this.selectionManager);
}
});
}
else {
- on(this.element, 'contextmenu', rightClickHandlerWrapper);
+ 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);
+ }
+ });
}
};
-/**
- * Apply key handling to the terminal
- */
Terminal.bindKeys = function (term) {
on(term.element, 'keydown', function (ev) {
if (document.activeElement != this) {
}
term.keyPress(ev);
}, true);
- on(term.element, 'keyup', term.focus.bind(term));
+ 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);
- // Truncate the textarea's value, since it is not needed
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);
+ });
};
-/**
- * Insert the given row to the terminal or produce a new one
- * if no row argument is passed. Return the inserted row.
- * @param {HTMLElement} row (optional) The row to append to the terminal.
- */
Terminal.prototype.insertRow = function (row) {
if (typeof row != 'object') {
row = document.createElement('div');
this.children.push(row);
return row;
};
-/**
- * Opens the terminal within an element.
- *
- * @param {HTMLElement} parent The element to create the terminal within.
- */
-Terminal.prototype.open = function (parent) {
+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.');
}
- // Grab global elements
this.context = this.parent.ownerDocument.defaultView;
this.document = this.parent.ownerDocument;
this.body = this.document.getElementsByTagName('body')[0];
- //Create main element container
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.element.style.height;
+ this.setCursorBlinking(this.options.cursorBlink);
this.element.setAttribute('tabindex', 0);
this.viewportElement = document.createElement('div');
this.viewportElement.classList.add('xterm-viewport');
this.viewportScrollArea = document.createElement('div');
this.viewportScrollArea.classList.add('xterm-scroll-area');
this.viewportElement.appendChild(this.viewportScrollArea);
- // Create the container that will hold the lines of the terminal and then
- // produce the lines the lines.
+ 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 = [];
- // Create the container that will hold helpers like the textarea for
- // capturing DOM Events. Then produce the helpers.
+ this.linkifier.attachToDom(document, this.children);
this.helperContainer = document.createElement('div');
this.helperContainer.classList.add('xterm-helpers');
- // TODO: This should probably be inserted once it's filled to prevent an additional layout
this.element.appendChild(this.helperContainer);
this.textarea = document.createElement('textarea');
this.textarea.classList.add('xterm-helper-textarea');
this.helperContainer.appendChild(this.textarea);
this.compositionView = document.createElement('div');
this.compositionView.classList.add('composition-view');
- this.compositionHelper = new CompositionHelper_js_1.CompositionHelper(this.textarea, this.compositionView, this);
+ this.compositionHelper = new CompositionHelper_1.CompositionHelper(this.textarea, this.compositionView, this);
this.helperContainer.appendChild(this.compositionView);
- this.charMeasureElement = document.createElement('div');
- this.charMeasureElement.classList.add('xterm-char-measure-element');
- this.charMeasureElement.innerHTML = 'W';
- this.helperContainer.appendChild(this.charMeasureElement);
+ this.charSizeStyleElement = document.createElement('style');
+ this.helperContainer.appendChild(this.charSizeStyleElement);
for (; i < this.rows; i++) {
this.insertRow();
}
this.parent.appendChild(this.element);
- this.viewport = new Viewport_js_1.Viewport(this, this.viewportElement, this.viewportScrollArea, this.charMeasureElement);
- // Draw the screen.
+ 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);
- // Initialize global actions that
- // need to be taken on the document.
this.initGlobal();
- // Ensure there is a Terminal.focus.
- this.focus();
+ 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();
}
});
- // Listen for mouse events and translate
- // them into terminal mouse protocols.
this.bindMouse();
- // Figure out whether boldness affects
- // the character width of monospace fonts.
- if (Terminal.brokenBold == null) {
- Terminal.brokenBold = isBoldBroken(this.document);
- }
- /**
- * This event is emitted when terminal has completed opening.
- *
- * @event open
- */
this.emit('open');
};
-/**
- * Attempts to load an add-on using CommonJS or RequireJS (whichever is available).
- * @param {string} addon The name of the addon to load
- * @static
- */
Terminal.loadAddon = function (addon, callback) {
if (typeof exports === 'object' && typeof module === 'object') {
- // CommonJS
return require('./addons/' + addon + '/' + addon);
}
else if (typeof define == 'function') {
- // RequireJS
return require(['./addons/' + addon + '/' + addon], callback);
}
else {
return false;
}
};
-/**
- * XTerm mouse events
- * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
- * To better understand these
- * the xterm code is very helpful:
- * Relevant files:
- * button.c, charproc.c, misc.c
- * Relevant functions in xterm/button.c:
- * BtnCode, EmitButtonCode, EditorButton, SendMousePosition
- */
+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;
- // mouseup, mousedown, wheel
- // left click: ^[[M 3<^[[M#3<
- // wheel up: ^[[M`3>
function sendButton(ev) {
var button, pos;
- // get the xterm-style button
button = getButton(ev);
- // get mouse coordinates
- pos = getCoords(ev);
+ pos = Mouse_1.getRawByteCoords(ev, self.rowContainer, self.charMeasure, self.cols, self.rows);
if (!pos)
return;
sendEvent(button, pos);
pressed = button;
break;
case 'mouseup':
- // keep it at the left
- // button, just in case.
pressed = 32;
break;
case 'wheel':
- // nothing. don't
- // interfere with
- // `pressed`.
break;
}
}
- // motion example of a left click:
- // ^[[M 3<^[[M@4<^[[M@5<^[[M@6<^[[M@7<^[[M#7<
function sendMove(ev) {
var button = pressed, pos;
- pos = getCoords(ev);
+ pos = Mouse_1.getRawByteCoords(ev, self.rowContainer, self.charMeasure, self.cols, self.rows);
if (!pos)
return;
- // buttons marked as motions
- // are incremented by 32
button += 32;
sendEvent(button, pos);
}
- // encode button and
- // position to characters
function encode(data, ch) {
if (!self.utfMouse) {
if (ch === 255)
}
}
}
- // send a mouse event:
- // regular/utf8: ^[[M Cb Cx Cy
- // urxvt: ^[[ Cb ; Cx ; Cy M
- // sgr: ^[[ Cb ; Cx ; Cy M/m
- // vt300: ^[[ 24(1/3/5)~ [ Cx , Cy ] \r
- // locator: CSI P e ; P b ; P r ; P c ; P p & w
function sendEvent(button, pos) {
- // self.emit('mouse', {
- // x: pos.x - 32,
- // y: pos.x - 32,
- // button: button
- // });
if (self.vt300Mouse) {
- // NOTE: Unstable.
- // http://www.vt100.net/docs/vt3xx-gp/chapter15.html
button &= 3;
pos.x -= 32;
pos.y -= 32;
- var data = '\x1b[24';
+ var data = EscapeSequences_1.C0.ESC + '[24';
if (button === 0)
data += '1';
else if (button === 1)
return;
}
if (self.decLocator) {
- // NOTE: Unstable.
button &= 3;
pos.x -= 32;
pos.y -= 32;
button = 6;
else if (button === 3)
button = 3;
- self.send('\x1b['
+ self.send(EscapeSequences_1.C0.ESC + '['
+ button
+ ';'
+ (button === 3 ? 4 : 0)
pos.y -= 32;
pos.x++;
pos.y++;
- self.send('\x1b[' + button + ';' + pos.x + ';' + pos.y + 'M');
+ self.send(EscapeSequences_1.C0.ESC + '[' + button + ';' + pos.x + ';' + pos.y + 'M');
return;
}
if (self.sgrMouse) {
pos.x -= 32;
pos.y -= 32;
- self.send('\x1b[<'
+ self.send(EscapeSequences_1.C0.ESC + '[<'
+ (((button & 3) === 3 ? button & ~3 : button) - 32)
+ ';'
+ pos.x
encode(data, button);
encode(data, pos.x);
encode(data, pos.y);
- self.send('\x1b[M' + String.fromCharCode.apply(String, data));
+ self.send(EscapeSequences_1.C0.ESC + '[M' + String.fromCharCode.apply(String, data));
}
function getButton(ev) {
var button, shift, meta, ctrl, mod;
- // two low bits:
- // 0 = left
- // 1 = middle
- // 2 = right
- // 3 = release
- // wheel up/down:
- // 1, and 2 - with 64 added
switch (ev.overrideType || ev.type) {
case 'mousedown':
button = ev.button != null
: 65;
break;
}
- // next three bits are the modifiers:
- // 4 = shift, 8 = meta, 16 = control
shift = ev.shiftKey ? 4 : 0;
meta = ev.metaKey ? 8 : 0;
ctrl = ev.ctrlKey ? 16 : 0;
mod = shift | meta | ctrl;
- // no mods
if (self.vt200Mouse) {
- // ctrl only
mod &= ctrl;
}
else if (!self.normalMouse) {
mod = 0;
}
- // increment to SP
button = (32 + (mod << 2)) + button;
return button;
}
- // mouse coordinates measured in cols/rows
- function getCoords(ev) {
- var x, y, w, h, el;
- // ignore browsers without pageX for now
- if (ev.pageX == null)
- return;
- x = ev.pageX;
- y = ev.pageY;
- el = self.element;
- // should probably check offsetParent
- // but this is more portable
- while (el && el !== self.document.documentElement) {
- x -= el.offsetLeft;
- y -= el.offsetTop;
- el = 'offsetParent' in el
- ? el.offsetParent
- : el.parentNode;
- }
- // convert to cols/rows
- w = self.element.clientWidth;
- h = self.element.clientHeight;
- x = Math.ceil((x / w) * self.cols);
- y = Math.ceil((y / h) * self.rows);
- // be sure to avoid sending
- // bad positions to the program
- if (x < 0)
- x = 0;
- if (x > self.cols)
- x = self.cols;
- if (y < 0)
- y = 0;
- if (y > self.rows)
- y = self.rows;
- // xterm sends raw bytes and
- // starts at 32 (SP) for each.
- x += 32;
- y += 32;
- return {
- x: x,
- y: y,
- type: 'wheel'
- };
- }
on(el, 'mousedown', function (ev) {
if (!self.mouseEvents)
return;
- // send the button
sendButton(ev);
- // ensure focus
self.focus();
- // fix for odd bug
- //if (self.vt200Mouse && !self.normalMouse) {
if (self.vt200Mouse) {
ev.overrideType = 'mouseup';
sendButton(ev);
return self.cancel(ev);
}
- // bind events
if (self.normalMouse)
on(self.document, 'mousemove', sendMove);
- // x10 compatibility mode can't send button releases
if (!self.x10Mouse) {
on(self.document, 'mouseup', function up(ev) {
sendButton(ev);
}
return self.cancel(ev);
});
- //if (self.normalMouse) {
- // on(self.document, 'mousemove', sendMove);
- //}
on(el, 'wheel', function (ev) {
if (!self.mouseEvents)
return;
sendButton(ev);
return self.cancel(ev);
});
- // allow wheel scrolling in
- // the shell for example
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);
+ });
};
-/**
- * Destroys the terminal.
- */
Terminal.prototype.destroy = function () {
this.readable = false;
this.writable = false;
this._events = {};
this.handler = function () { };
this.write = function () { };
- if (this.element.parentNode) {
+ if (this.element && this.element.parentNode) {
this.element.parentNode.removeChild(this.element);
}
- //this.emit('close');
};
-/**
- * Flags used to render terminal text properly
- */
-Terminal.flags = {
- BOLD: 1,
- UNDERLINE: 2,
- BLINK: 4,
- INVERSE: 8,
- INVISIBLE: 16
-};
-/**
- * Refreshes (re-renders) terminal content within two rows (inclusive)
- *
- * Rendering Engine:
- *
- * In the screen buffer, each character is stored as a an array with a character
- * and a 32-bit integer:
- * - First value: a utf-16 character.
- * - Second value:
- * - Next 9 bits: background color (0-511).
- * - Next 9 bits: foreground color (0-511).
- * - Next 14 bits: a mask for misc. flags:
- * - 1=bold
- * - 2=underline
- * - 4=blink
- * - 8=inverse
- * - 16=invisible
- *
- * @param {number} start The row to start from (between 0 and terminal's height terminal - 1)
- * @param {number} end The row to end at (between fromRow and terminal's height terminal - 1)
- * @param {boolean} queue Whether the refresh should ran right now or be queued
- */
-Terminal.prototype.refresh = function (start, end, queue) {
- var self = this;
- // queue defaults to true
- queue = (typeof queue == 'undefined') ? true : queue;
- /**
- * The refresh queue allows refresh to execute only approximately 30 times a second. For
- * commands that pass a significant amount of output to the write function, this prevents the
- * terminal from maxing out the CPU and making the UI unresponsive. While commands can still
- * run beyond what they do on the terminal, it is far better with a debounce in place as
- * every single terminal manipulation does not need to be constructed in the DOM.
- *
- * A side-effect of this is that it makes ^C to interrupt a process seem more responsive.
- */
- if (queue) {
- // If refresh should be queued, order the refresh and return.
- if (this._refreshIsQueued) {
- // If a refresh has already been queued, just order a full refresh next
- this._fullRefreshNext = true;
- }
- else {
- setTimeout(function () {
- self.refresh(start, end, false);
- }, 34);
- this._refreshIsQueued = true;
- }
- return;
- }
- // If refresh should be run right now (not be queued), release the lock
- this._refreshIsQueued = false;
- // If multiple refreshes were requested, make a full refresh.
- if (this._fullRefreshNext) {
- start = 0;
- end = this.rows - 1;
- this._fullRefreshNext = false; // reset lock
- }
- var x, y, i, line, out, ch, ch_width, width, data, attr, bg, fg, flags, row, parent, focused = document.activeElement;
- // If this is a big refresh, remove the terminal rows from the DOM for faster calculations
- if (end - start >= this.rows / 2) {
- parent = this.element.parentNode;
- if (parent) {
- this.element.removeChild(this.rowContainer);
- }
+Terminal.prototype.refresh = function (start, end) {
+ if (this.renderer) {
+ this.renderer.queueRefresh(start, end);
}
- width = this.cols;
- y = start;
- if (end >= this.rows.length) {
- this.log('`end` is too large. Most likely a bad CSR.');
- end = this.rows.length - 1;
- }
- for (; y <= end; y++) {
- row = y + this.ydisp;
- line = this.lines[row];
- out = '';
- if (this.y === y - (this.ybase - this.ydisp)
- && this.cursorState
- && !this.cursorHidden) {
- x = this.x;
- }
- else {
- x = -1;
- }
- attr = this.defAttr;
- i = 0;
- for (; i < width; i++) {
- data = line[i][0];
- ch = line[i][1];
- ch_width = line[i][2];
- if (!ch_width)
- continue;
- if (i === x)
- data = -1;
- if (data !== attr) {
- if (attr !== this.defAttr) {
- out += '</span>';
- }
- if (data !== this.defAttr) {
- if (data === -1) {
- out += '<span class="reverse-video terminal-cursor';
- if (this.cursorBlink) {
- out += ' blinking';
- }
- out += '">';
- }
- else {
- var classNames = [];
- bg = data & 0x1ff;
- fg = (data >> 9) & 0x1ff;
- flags = data >> 18;
- if (flags & Terminal.flags.BOLD) {
- if (!Terminal.brokenBold) {
- classNames.push('xterm-bold');
- }
- // See: XTerm*boldColors
- if (fg < 8)
- fg += 8;
- }
- if (flags & Terminal.flags.UNDERLINE) {
- classNames.push('xterm-underline');
- }
- if (flags & Terminal.flags.BLINK) {
- classNames.push('xterm-blink');
- }
- // If inverse flag is on, then swap the foreground and background variables.
- if (flags & Terminal.flags.INVERSE) {
- /* One-line variable swap in JavaScript: http://stackoverflow.com/a/16201730 */
- bg = [fg, fg = bg][0];
- // Should inverse just be before the
- // above boldColors effect instead?
- if ((flags & 1) && fg < 8)
- fg += 8;
- }
- if (flags & Terminal.flags.INVISIBLE) {
- classNames.push('xterm-hidden');
- }
- /**
- * Weird situation: Invert flag used black foreground and white background results
- * in invalid background color, positioned at the 256 index of the 256 terminal
- * color map. Pin the colors manually in such a case.
- *
- * Source: https://github.com/sourcelair/xterm.js/issues/57
- */
- if (flags & Terminal.flags.INVERSE) {
- if (bg == 257) {
- bg = 15;
- }
- if (fg == 256) {
- fg = 0;
- }
- }
- if (bg < 256) {
- classNames.push('xterm-bg-color-' + bg);
- }
- if (fg < 256) {
- classNames.push('xterm-color-' + fg);
- }
- out += '<span';
- if (classNames.length) {
- out += ' class="' + classNames.join(' ') + '"';
- }
- out += '>';
- }
- }
- }
- switch (ch) {
- case '&':
- out += '&';
- break;
- case '<':
- out += '<';
- break;
- case '>':
- out += '>';
- break;
- default:
- if (ch <= ' ') {
- out += ' ';
- }
- else {
- out += ch;
- }
- break;
- }
- attr = data;
- }
- if (attr !== this.defAttr) {
- out += '</span>';
+};
+Terminal.prototype.queueLinkification = function (start, end) {
+ if (this.linkifier) {
+ for (var i = start; i <= end; i++) {
+ this.linkifier.linkifyRow(i);
}
- this.children[y].innerHTML = out;
- }
- if (parent) {
- this.element.appendChild(this.rowContainer);
}
- this.emit('refresh', { element: this.element, start: start, end: end });
};
-/**
- * Display the cursor element
- */
Terminal.prototype.showCursor = function () {
if (!this.cursorState) {
this.cursorState = 1;
this.refresh(this.y, this.y);
}
};
-/**
- * Scroll the terminal
- */
-Terminal.prototype.scroll = function () {
+Terminal.prototype.scroll = function (isWrapped) {
var row;
- if (++this.ybase === this.scrollback) {
- this.ybase = this.ybase / 2 | 0;
- this.lines = this.lines.slice(-(this.ybase + this.rows) + 1);
+ 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;
}
- // last line
row = this.ybase + this.rows - 1;
- // subtract the bottom scroll region
row -= this.rows - 1 - this.scrollBottom;
if (row === this.lines.length) {
- // potential optimization:
- // pushing is faster than splicing
- // when they amount to the same
- // behavior.
- this.lines.push(this.blankLine());
+ this.lines.push(this.blankLine(undefined, isWrapped));
}
else {
- // add our new line
- this.lines.splice(row, 0, this.blankLine());
+ this.lines.splice(row, 0, this.blankLine(undefined, isWrapped));
}
if (this.scrollTop !== 0) {
if (this.ybase !== 0) {
}
this.lines.splice(this.ybase + this.scrollTop, 1);
}
- // this.maxRange();
this.updateRange(this.scrollTop);
this.updateRange(this.scrollBottom);
- /**
- * This event is emitted whenever the terminal is scrolled.
- * The one parameter passed is the new y display position.
- *
- * @event scroll
- */
this.emit('scroll', this.ydisp);
};
-/**
- * Scroll the display of the terminal
- * @param {number} disp The number of lines to scroll down (negatives scroll up).
- * @param {boolean} suppressScrollEvent Don't emit the scroll event as scrollDisp. This is used
- * to avoid unwanted events being handled by the veiwport when the event was triggered from the
- * viewport originally.
- */
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.refresh(0, this.rows - 1);
};
-/**
- * Scroll the display of the terminal by a number of pages.
- * @param {number} pageCount The number of pages to scroll (negative scrolls up).
- */
Terminal.prototype.scrollPages = function (pageCount) {
this.scrollDisp(pageCount * (this.rows - 1));
-};
-/**
- * Scrolls the display of the terminal to the top.
- */
-Terminal.prototype.scrollToTop = function () {
- this.scrollDisp(-this.ydisp);
-};
-/**
- * Scrolls the display of the terminal to the bottom.
- */
-Terminal.prototype.scrollToBottom = function () {
- this.scrollDisp(this.ybase - this.ydisp);
-};
-/**
- * Writes text to the terminal.
- * @param {string} text The text to write to the terminal.
- */
-Terminal.prototype.write = function (data) {
- var l = data.length, i = 0, j, cs, ch, code, low, ch_width, row;
- this.refreshStart = this.y;
- this.refreshEnd = this.y;
- // apply leftover surrogate high from last write
- if (this.surrogate_high) {
- data = this.surrogate_high + data;
- this.surrogate_high = '';
- }
- for (; i < l; i++) {
- ch = data[i];
- // FIXME: higher chars than 0xa0 are not allowed in escape sequences
- // --> maybe move to default
- code = data.charCodeAt(i);
- if (0xD800 <= code && code <= 0xDBFF) {
- // we got a surrogate high
- // get surrogate low (next 2 bytes)
- low = data.charCodeAt(i + 1);
- if (isNaN(low)) {
- // end of data stream, save surrogate high
- this.surrogate_high = ch;
- continue;
- }
- code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
- ch += data.charAt(i + 1);
- }
- // surrogate low - already handled above
- if (0xDC00 <= code && code <= 0xDFFF)
- continue;
- switch (this.state) {
- case normal:
- switch (ch) {
- case '\x07':
- this.bell();
- break;
- // '\n', '\v', '\f'
- case '\n':
- case '\x0b':
- case '\x0c':
- if (this.convertEol) {
- this.x = 0;
- }
- this.y++;
- if (this.y > this.scrollBottom) {
- this.y--;
- this.scroll();
- }
- break;
- // '\r'
- case '\r':
- this.x = 0;
- break;
- // '\b'
- case '\x08':
- if (this.x > 0) {
- this.x--;
- }
- break;
- // '\t'
- case '\t':
- this.x = this.nextStop();
- break;
- // shift out
- case '\x0e':
- this.setgLevel(1);
- break;
- // shift in
- case '\x0f':
- this.setgLevel(0);
- break;
- // '\e'
- case '\x1b':
- this.state = escaped;
- break;
- default:
- // ' '
- // calculate print space
- // expensive call, therefore we save width in line buffer
- ch_width = wcwidth(code);
- if (ch >= ' ') {
- if (this.charset && this.charset[ch]) {
- ch = this.charset[ch];
- }
- row = this.y + this.ybase;
- // insert combining char in last cell
- // FIXME: needs handling after cursor jumps
- if (!ch_width && this.x) {
- // dont overflow left
- if (this.lines[row][this.x - 1]) {
- if (!this.lines[row][this.x - 1][2]) {
- // found empty cell after fullwidth, need to go 2 cells back
- if (this.lines[row][this.x - 2])
- this.lines[row][this.x - 2][1] += ch;
- }
- else {
- this.lines[row][this.x - 1][1] += ch;
- }
- this.updateRange(this.y);
- }
- break;
- }
- // goto next line if ch would overflow
- // TODO: needs a global min terminal width of 2
- if (this.x + ch_width - 1 >= this.cols) {
- // autowrap - DECAWM
- if (this.wraparoundMode) {
- this.x = 0;
- this.y++;
- if (this.y > this.scrollBottom) {
- this.y--;
- this.scroll();
- }
- }
- else {
- this.x = this.cols - 1;
- if (ch_width === 2)
- continue;
- }
- }
- row = this.y + this.ybase;
- // insert mode: move characters to right
- if (this.insertMode) {
- // do this twice for a fullwidth char
- for (var moves = 0; moves < ch_width; ++moves) {
- // remove last cell, if it's width is 0
- // we have to adjust the second last cell as well
- var removed = this.lines[this.y + this.ybase].pop();
- if (removed[2] === 0
- && this.lines[row][this.cols - 2]
- && this.lines[row][this.cols - 2][2] === 2)
- this.lines[row][this.cols - 2] = [this.curAttr, ' ', 1];
- // insert empty cell at cursor
- this.lines[row].splice(this.x, 0, [this.curAttr, ' ', 1]);
- }
- }
- this.lines[row][this.x] = [this.curAttr, ch, ch_width];
- this.x++;
- this.updateRange(this.y);
- // fullwidth char - set next cell width to zero and advance cursor
- if (ch_width === 2) {
- this.lines[row][this.x] = [this.curAttr, '', 0];
- this.x++;
- }
- }
- break;
- }
- break;
- case escaped:
- switch (ch) {
- // ESC [ Control Sequence Introducer ( CSI is 0x9b).
- case '[':
- this.params = [];
- this.currentParam = 0;
- this.state = csi;
- break;
- // ESC ] Operating System Command ( OSC is 0x9d).
- case ']':
- this.params = [];
- this.currentParam = 0;
- this.state = osc;
- break;
- // ESC P Device Control String ( DCS is 0x90).
- case 'P':
- this.params = [];
- this.currentParam = 0;
- this.state = dcs;
- break;
- // ESC _ Application Program Command ( APC is 0x9f).
- case '_':
- this.state = ignore;
- break;
- // ESC ^ Privacy Message ( PM is 0x9e).
- case '^':
- this.state = ignore;
- break;
- // ESC c Full Reset (RIS).
- case 'c':
- this.reset();
- break;
- // ESC E Next Line ( NEL is 0x85).
- // ESC D Index ( IND is 0x84).
- case 'E':
- this.x = 0;
- ;
- case 'D':
- this.index();
- break;
- // ESC M Reverse Index ( RI is 0x8d).
- case 'M':
- this.reverseIndex();
- break;
- // ESC % Select default/utf-8 character set.
- // @ = default, G = utf-8
- case '%':
- //this.charset = null;
- this.setgLevel(0);
- this.setgCharset(0, Terminal.charsets.US);
- this.state = normal;
- i++;
- break;
- // ESC (,),*,+,-,. Designate G0-G2 Character Set.
- case '(': // <-- this seems to get all the attention
- case ')':
- case '*':
- case '+':
- case '-':
- case '.':
- switch (ch) {
- case '(':
- this.gcharset = 0;
- break;
- case ')':
- this.gcharset = 1;
- break;
- case '*':
- this.gcharset = 2;
- break;
- case '+':
- this.gcharset = 3;
- break;
- case '-':
- this.gcharset = 1;
- break;
- case '.':
- this.gcharset = 2;
- break;
- }
- this.state = charset;
- break;
- // Designate G3 Character Set (VT300).
- // A = ISO Latin-1 Supplemental.
- // Not implemented.
- case '/':
- this.gcharset = 3;
- this.state = charset;
- i--;
- break;
- // ESC N
- // Single Shift Select of G2 Character Set
- // ( SS2 is 0x8e). This affects next character only.
- case 'N':
- break;
- // ESC O
- // Single Shift Select of G3 Character Set
- // ( SS3 is 0x8f). This affects next character only.
- case 'O':
- break;
- // ESC n
- // Invoke the G2 Character Set as GL (LS2).
- case 'n':
- this.setgLevel(2);
- break;
- // ESC o
- // Invoke the G3 Character Set as GL (LS3).
- case 'o':
- this.setgLevel(3);
- break;
- // ESC |
- // Invoke the G3 Character Set as GR (LS3R).
- case '|':
- this.setgLevel(3);
- break;
- // ESC }
- // Invoke the G2 Character Set as GR (LS2R).
- case '}':
- this.setgLevel(2);
- break;
- // ESC ~
- // Invoke the G1 Character Set as GR (LS1R).
- case '~':
- this.setgLevel(1);
- break;
- // ESC 7 Save Cursor (DECSC).
- case '7':
- this.saveCursor();
- this.state = normal;
- break;
- // ESC 8 Restore Cursor (DECRC).
- case '8':
- this.restoreCursor();
- this.state = normal;
- break;
- // ESC # 3 DEC line height/width
- case '#':
- this.state = normal;
- i++;
- break;
- // ESC H Tab Set (HTS is 0x88).
- case 'H':
- this.tabSet();
- break;
- // ESC = Application Keypad (DECKPAM).
- case '=':
- this.log('Serial port requested application keypad.');
- this.applicationKeypad = true;
- this.viewport.syncScrollArea();
- this.state = normal;
- break;
- // ESC > Normal Keypad (DECKPNM).
- case '>':
- this.log('Switching back to normal keypad.');
- this.applicationKeypad = false;
- this.viewport.syncScrollArea();
- this.state = normal;
- break;
- default:
- this.state = normal;
- this.error('Unknown ESC control: %s.', ch);
- break;
- }
- break;
- case charset:
- switch (ch) {
- case '0':
- cs = Terminal.charsets.SCLD;
- break;
- case 'A':
- cs = Terminal.charsets.UK;
- break;
- case 'B':
- cs = Terminal.charsets.US;
- break;
- case '4':
- cs = Terminal.charsets.Dutch;
- break;
- case 'C': // Finnish
- case '5':
- cs = Terminal.charsets.Finnish;
- break;
- case 'R':
- cs = Terminal.charsets.French;
- break;
- case 'Q':
- cs = Terminal.charsets.FrenchCanadian;
- break;
- case 'K':
- cs = Terminal.charsets.German;
- break;
- case 'Y':
- cs = Terminal.charsets.Italian;
- break;
- case 'E': // NorwegianDanish
- case '6':
- cs = Terminal.charsets.NorwegianDanish;
- break;
- case 'Z':
- cs = Terminal.charsets.Spanish;
- break;
- case 'H': // Swedish
- case '7':
- cs = Terminal.charsets.Swedish;
- break;
- case '=':
- cs = Terminal.charsets.Swiss;
- break;
- case '/':
- cs = Terminal.charsets.ISOLatin;
- i++;
- break;
- default:
- cs = Terminal.charsets.US;
- break;
- }
- this.setgCharset(this.gcharset, cs);
- this.gcharset = null;
- this.state = normal;
- break;
- case osc:
- // OSC Ps ; Pt ST
- // OSC Ps ; Pt BEL
- // Set Text Parameters.
- if (ch === '\x1b' || ch === '\x07') {
- if (ch === '\x1b')
- i++;
- this.params.push(this.currentParam);
- switch (this.params[0]) {
- case 0:
- case 1:
- case 2:
- if (this.params[1]) {
- this.title = this.params[1];
- this.handleTitle(this.title);
- }
- break;
- case 3:
- // set X property
- break;
- case 4:
- case 5:
- // change dynamic colors
- break;
- case 10:
- case 11:
- case 12:
- case 13:
- case 14:
- case 15:
- case 16:
- case 17:
- case 18:
- case 19:
- // change dynamic ui colors
- break;
- case 46:
- // change log file
- break;
- case 50:
- // dynamic font
- break;
- case 51:
- // emacs shell
- break;
- case 52:
- // manipulate selection data
- break;
- case 104:
- case 105:
- case 110:
- case 111:
- case 112:
- case 113:
- case 114:
- case 115:
- case 116:
- case 117:
- case 118:
- // reset colors
- break;
- }
- this.params = [];
- this.currentParam = 0;
- this.state = normal;
- }
- else {
- if (!this.params.length) {
- if (ch >= '0' && ch <= '9') {
- this.currentParam =
- this.currentParam * 10 + ch.charCodeAt(0) - 48;
- }
- else if (ch === ';') {
- this.params.push(this.currentParam);
- this.currentParam = '';
- }
- }
- else {
- this.currentParam += ch;
- }
- }
- break;
- case csi:
- // '?', '>', '!'
- if (ch === '?' || ch === '>' || ch === '!') {
- this.prefix = ch;
- break;
- }
- // 0 - 9
- if (ch >= '0' && ch <= '9') {
- this.currentParam = this.currentParam * 10 + ch.charCodeAt(0) - 48;
- break;
- }
- // '$', '"', ' ', '\''
- if (ch === '$' || ch === '"' || ch === ' ' || ch === '\'') {
- this.postfix = ch;
- break;
- }
- this.params.push(this.currentParam);
- this.currentParam = 0;
- // ';'
- if (ch === ';')
- break;
- this.state = normal;
- switch (ch) {
- // CSI Ps A
- // Cursor Up Ps Times (default = 1) (CUU).
- case 'A':
- this.cursorUp(this.params);
- break;
- // CSI Ps B
- // Cursor Down Ps Times (default = 1) (CUD).
- case 'B':
- this.cursorDown(this.params);
- break;
- // CSI Ps C
- // Cursor Forward Ps Times (default = 1) (CUF).
- case 'C':
- this.cursorForward(this.params);
- break;
- // CSI Ps D
- // Cursor Backward Ps Times (default = 1) (CUB).
- case 'D':
- this.cursorBackward(this.params);
- break;
- // CSI Ps ; Ps H
- // Cursor Position [row;column] (default = [1,1]) (CUP).
- case 'H':
- this.cursorPos(this.params);
- break;
- // CSI Ps J Erase in Display (ED).
- case 'J':
- this.eraseInDisplay(this.params);
- break;
- // CSI Ps K Erase in Line (EL).
- case 'K':
- this.eraseInLine(this.params);
- break;
- // CSI Pm m Character Attributes (SGR).
- case 'm':
- if (!this.prefix) {
- this.charAttributes(this.params);
- }
- break;
- // CSI Ps n Device Status Report (DSR).
- case 'n':
- if (!this.prefix) {
- this.deviceStatus(this.params);
- }
- break;
- /**
- * Additions
- */
- // CSI Ps @
- // Insert Ps (Blank) Character(s) (default = 1) (ICH).
- case '@':
- this.insertChars(this.params);
- break;
- // CSI Ps E
- // Cursor Next Line Ps Times (default = 1) (CNL).
- case 'E':
- this.cursorNextLine(this.params);
- break;
- // CSI Ps F
- // Cursor Preceding Line Ps Times (default = 1) (CNL).
- case 'F':
- this.cursorPrecedingLine(this.params);
- break;
- // CSI Ps G
- // Cursor Character Absolute [column] (default = [row,1]) (CHA).
- case 'G':
- this.cursorCharAbsolute(this.params);
- break;
- // CSI Ps L
- // Insert Ps Line(s) (default = 1) (IL).
- case 'L':
- this.insertLines(this.params);
- break;
- // CSI Ps M
- // Delete Ps Line(s) (default = 1) (DL).
- case 'M':
- this.deleteLines(this.params);
- break;
- // CSI Ps P
- // Delete Ps Character(s) (default = 1) (DCH).
- case 'P':
- this.deleteChars(this.params);
- break;
- // CSI Ps X
- // Erase Ps Character(s) (default = 1) (ECH).
- case 'X':
- this.eraseChars(this.params);
- break;
- // CSI Pm ` Character Position Absolute
- // [column] (default = [row,1]) (HPA).
- case '`':
- this.charPosAbsolute(this.params);
- break;
- // 141 61 a * HPR -
- // Horizontal Position Relative
- case 'a':
- this.HPositionRelative(this.params);
- break;
- // CSI P s c
- // Send Device Attributes (Primary DA).
- // CSI > P s c
- // Send Device Attributes (Secondary DA)
- case 'c':
- this.sendDeviceAttributes(this.params);
- break;
- // CSI Pm d
- // Line Position Absolute [row] (default = [1,column]) (VPA).
- case 'd':
- this.linePosAbsolute(this.params);
- break;
- // 145 65 e * VPR - Vertical Position Relative
- case 'e':
- this.VPositionRelative(this.params);
- break;
- // CSI Ps ; Ps f
- // Horizontal and Vertical Position [row;column] (default =
- // [1,1]) (HVP).
- case 'f':
- this.HVPosition(this.params);
- break;
- // CSI Pm h Set Mode (SM).
- // CSI ? Pm h - mouse escape codes, cursor escape codes
- case 'h':
- this.setMode(this.params);
- break;
- // CSI Pm l Reset Mode (RM).
- // CSI ? Pm l
- case 'l':
- this.resetMode(this.params);
- break;
- // CSI Ps ; Ps r
- // Set Scrolling Region [top;bottom] (default = full size of win-
- // dow) (DECSTBM).
- // CSI ? Pm r
- case 'r':
- this.setScrollRegion(this.params);
- break;
- // CSI s
- // Save cursor (ANSI.SYS).
- case 's':
- this.saveCursor(this.params);
- break;
- // CSI u
- // Restore cursor (ANSI.SYS).
- case 'u':
- this.restoreCursor(this.params);
- break;
- /**
- * Lesser Used
- */
- // CSI Ps I
- // Cursor Forward Tabulation Ps tab stops (default = 1) (CHT).
- case 'I':
- this.cursorForwardTab(this.params);
- break;
- // CSI Ps S Scroll up Ps lines (default = 1) (SU).
- case 'S':
- this.scrollUp(this.params);
- break;
- // CSI Ps T Scroll down Ps lines (default = 1) (SD).
- // CSI Ps ; Ps ; Ps ; Ps ; Ps T
- // CSI > Ps; Ps T
- case 'T':
- // if (this.prefix === '>') {
- // this.resetTitleModes(this.params);
- // break;
- // }
- // if (this.params.length > 2) {
- // this.initMouseTracking(this.params);
- // break;
- // }
- if (this.params.length < 2 && !this.prefix) {
- this.scrollDown(this.params);
- }
- break;
- // CSI Ps Z
- // Cursor Backward Tabulation Ps tab stops (default = 1) (CBT).
- case 'Z':
- this.cursorBackwardTab(this.params);
- break;
- // CSI Ps b Repeat the preceding graphic character Ps times (REP).
- case 'b':
- this.repeatPrecedingCharacter(this.params);
- break;
- // CSI Ps g Tab Clear (TBC).
- case 'g':
- this.tabClear(this.params);
- break;
- // CSI Pm i Media Copy (MC).
- // CSI ? Pm i
- // case 'i':
- // this.mediaCopy(this.params);
- // break;
- // CSI Pm m Character Attributes (SGR).
- // CSI > Ps; Ps m
- // case 'm': // duplicate
- // if (this.prefix === '>') {
- // this.setResources(this.params);
- // } else {
- // this.charAttributes(this.params);
- // }
- // break;
- // CSI Ps n Device Status Report (DSR).
- // CSI > Ps n
- // case 'n': // duplicate
- // if (this.prefix === '>') {
- // this.disableModifiers(this.params);
- // } else {
- // this.deviceStatus(this.params);
- // }
- // break;
- // CSI > Ps p Set pointer mode.
- // CSI ! p Soft terminal reset (DECSTR).
- // CSI Ps$ p
- // Request ANSI mode (DECRQM).
- // CSI ? Ps$ p
- // Request DEC private mode (DECRQM).
- // CSI Ps ; Ps " p
- case 'p':
- switch (this.prefix) {
- // case '>':
- // this.setPointerMode(this.params);
- // break;
- case '!':
- this.softReset(this.params);
- break;
- }
- break;
- // CSI Ps q Load LEDs (DECLL).
- // CSI Ps SP q
- // CSI Ps " q
- // case 'q':
- // if (this.postfix === ' ') {
- // this.setCursorStyle(this.params);
- // break;
- // }
- // if (this.postfix === '"') {
- // this.setCharProtectionAttr(this.params);
- // break;
- // }
- // this.loadLEDs(this.params);
- // break;
- // CSI Ps ; Ps r
- // Set Scrolling Region [top;bottom] (default = full size of win-
- // dow) (DECSTBM).
- // CSI ? Pm r
- // CSI Pt; Pl; Pb; Pr; Ps$ r
- // case 'r': // duplicate
- // if (this.prefix === '?') {
- // this.restorePrivateValues(this.params);
- // } else if (this.postfix === '$') {
- // this.setAttrInRectangle(this.params);
- // } else {
- // this.setScrollRegion(this.params);
- // }
- // break;
- // CSI s Save cursor (ANSI.SYS).
- // CSI ? Pm s
- // case 's': // duplicate
- // if (this.prefix === '?') {
- // this.savePrivateValues(this.params);
- // } else {
- // this.saveCursor(this.params);
- // }
- // break;
- // CSI Ps ; Ps ; Ps t
- // CSI Pt; Pl; Pb; Pr; Ps$ t
- // CSI > Ps; Ps t
- // CSI Ps SP t
- // case 't':
- // if (this.postfix === '$') {
- // this.reverseAttrInRectangle(this.params);
- // } else if (this.postfix === ' ') {
- // this.setWarningBellVolume(this.params);
- // } else {
- // if (this.prefix === '>') {
- // this.setTitleModeFeature(this.params);
- // } else {
- // this.manipulateWindow(this.params);
- // }
- // }
- // break;
- // CSI u Restore cursor (ANSI.SYS).
- // CSI Ps SP u
- // case 'u': // duplicate
- // if (this.postfix === ' ') {
- // this.setMarginBellVolume(this.params);
- // } else {
- // this.restoreCursor(this.params);
- // }
- // break;
- // CSI Pt; Pl; Pb; Pr; Pp; Pt; Pl; Pp$ v
- // case 'v':
- // if (this.postfix === '$') {
- // this.copyRectagle(this.params);
- // }
- // break;
- // CSI Pt ; Pl ; Pb ; Pr ' w
- // case 'w':
- // if (this.postfix === '\'') {
- // this.enableFilterRectangle(this.params);
- // }
- // break;
- // CSI Ps x Request Terminal Parameters (DECREQTPARM).
- // CSI Ps x Select Attribute Change Extent (DECSACE).
- // CSI Pc; Pt; Pl; Pb; Pr$ x
- // case 'x':
- // if (this.postfix === '$') {
- // this.fillRectangle(this.params);
- // } else {
- // this.requestParameters(this.params);
- // //this.__(this.params);
- // }
- // break;
- // CSI Ps ; Pu ' z
- // CSI Pt; Pl; Pb; Pr$ z
- // case 'z':
- // if (this.postfix === '\'') {
- // this.enableLocatorReporting(this.params);
- // } else if (this.postfix === '$') {
- // this.eraseRectangle(this.params);
- // }
- // break;
- // CSI Pm ' {
- // CSI Pt; Pl; Pb; Pr$ {
- // case '{':
- // if (this.postfix === '\'') {
- // this.setLocatorEvents(this.params);
- // } else if (this.postfix === '$') {
- // this.selectiveEraseRectangle(this.params);
- // }
- // break;
- // CSI Ps ' |
- // case '|':
- // if (this.postfix === '\'') {
- // this.requestLocatorPosition(this.params);
- // }
- // break;
- // CSI P m SP }
- // Insert P s Column(s) (default = 1) (DECIC), VT420 and up.
- // case '}':
- // if (this.postfix === ' ') {
- // this.insertColumns(this.params);
- // }
- // break;
- // CSI P m SP ~
- // Delete P s Column(s) (default = 1) (DECDC), VT420 and up
- // case '~':
- // if (this.postfix === ' ') {
- // this.deleteColumns(this.params);
- // }
- // break;
- default:
- this.error('Unknown CSI code: %s.', ch);
- break;
- }
- this.prefix = '';
- this.postfix = '';
- break;
- case dcs:
- if (ch === '\x1b' || ch === '\x07') {
- if (ch === '\x1b')
- i++;
- switch (this.prefix) {
- // User-Defined Keys (DECUDK).
- case '':
- break;
- // Request Status String (DECRQSS).
- // test: echo -e '\eP$q"p\e\\'
- case '$q':
- var pt = this.currentParam, valid = false;
- switch (pt) {
- // DECSCA
- case '"q':
- pt = '0"q';
- break;
- // DECSCL
- case '"p':
- pt = '61"p';
- break;
- // DECSTBM
- case 'r':
- pt = ''
- + (this.scrollTop + 1)
- + ';'
- + (this.scrollBottom + 1)
- + 'r';
- break;
- // SGR
- case 'm':
- pt = '0m';
- break;
- default:
- this.error('Unknown DCS Pt: %s.', pt);
- pt = '';
- break;
- }
- this.send('\x1bP' + +valid + '$r' + pt + '\x1b\\');
- break;
- // Set Termcap/Terminfo Data (xterm, experimental).
- case '+p':
- break;
- // Request Termcap/Terminfo String (xterm, experimental)
- // Regular xterm does not even respond to this sequence.
- // This can cause a small glitch in vim.
- // test: echo -ne '\eP+q6b64\e\\'
- case '+q':
- var pt = this.currentParam, valid = false;
- this.send('\x1bP' + +valid + '+r' + pt + '\x1b\\');
- break;
- default:
- this.error('Unknown DCS prefix: %s.', this.prefix);
- break;
- }
- this.currentParam = 0;
- this.prefix = '';
- this.state = normal;
- }
- else if (!this.currentParam) {
- if (!this.prefix && ch !== '$' && ch !== '+') {
- this.currentParam = ch;
- }
- else if (this.prefix.length === 2) {
- this.currentParam = ch;
- }
- else {
- this.prefix += ch;
- }
- }
- else {
- this.currentParam += ch;
- }
- break;
- case ignore:
- // For PM and APC.
- if (ch === '\x1b' || ch === '\x07') {
- if (ch === '\x1b')
- i++;
- this.state = normal;
- }
- break;
+};
+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;
}
- this.updateRange(this.y);
- this.refresh(this.refreshStart, this.refreshEnd);
};
-/**
- * Writes text to the terminal, followed by a break line character (\n).
- * @param {string} text The text to write to the terminal.
- */
Terminal.prototype.writeln = function (data) {
this.write(data + '\r\n');
};
-/**
- * Attaches a custom keydown handler which is run before keys are processed, giving consumers of
- * xterm.js ultimate control as to what keys should be processed by the terminal and what keys
- * should not.
- * @param {function} customKeydownHandler The custom KeyboardEvent handler to attach. This is a
- * function that takes a KeyboardEvent, allowing consumers to stop propogation and/or prevent
- * the default action. The function returns whether the event should be processed by xterm.js.
- */
Terminal.prototype.attachCustomKeydownHandler = function (customKeydownHandler) {
- this.customKeydownHandler = 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();
};
-/**
- * Handle a keydown event
- * Key Resources:
- * - https://developer.mozilla.org/en-US/docs/DOM/KeyboardEvent
- * @param {KeyboardEvent} ev The keydown event to be handled.
- */
Terminal.prototype.keyDown = function (ev) {
- if (this.customKeydownHandler && this.customKeydownHandler(ev) === false) {
+ 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();
}
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);
return true;
}
if (result.cancel) {
- // The event is canceled at the end already, is this necessary?
this.cancel(ev, true);
}
if (!result.key) {
this.handler(result.key);
return this.cancel(ev, true);
};
-/**
- * Returns an object that determines how a KeyboardEvent should be handled. The key of the
- * returned value is the new key code to pass to the PTY.
- *
- * Reference: http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
- * @param {KeyboardEvent} ev The keyboard event to be translated to key escape sequence.
- */
Terminal.prototype.evaluateKeyEscapeSequence = function (ev) {
var result = {
- // Whether to cancel event propogation (NOTE: this may not be needed since the event is
- // canceled at the end of keyDown
cancel: false,
- // The new key even to emit
key: undefined,
- // The number of characters to scroll, if this is defined it will cancel the event
scrollDisp: undefined
};
var modifiers = ev.shiftKey << 0 | ev.altKey << 1 | ev.ctrlKey << 2 | ev.metaKey << 3;
switch (ev.keyCode) {
case 8:
- // backspace
if (ev.shiftKey) {
- result.key = '\x08'; // ^H
+ result.key = EscapeSequences_1.C0.BS;
break;
}
- result.key = '\x7f'; // ^?
+ result.key = EscapeSequences_1.C0.DEL;
break;
case 9:
- // tab
if (ev.shiftKey) {
- result.key = '\x1b[Z';
+ result.key = EscapeSequences_1.C0.ESC + '[Z';
break;
}
- result.key = '\t';
+ result.key = EscapeSequences_1.C0.HT;
result.cancel = true;
break;
case 13:
- // return/enter
- result.key = '\r';
+ result.key = EscapeSequences_1.C0.CR;
result.cancel = true;
break;
case 27:
- // escape
- result.key = '\x1b';
+ result.key = EscapeSequences_1.C0.ESC;
result.cancel = true;
break;
case 37:
- // left-arrow
if (modifiers) {
- result.key = '\x1b[1;' + (modifiers + 1) + 'D';
- // HACK: Make Alt + left-arrow behave like Ctrl + left-arrow: move one word backwards
- // http://unix.stackexchange.com/a/108106
- if (result.key == '\x1b[1;3D') {
- result.key = '\x1b[1;5D';
+ 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 = '\x1bOD';
+ result.key = EscapeSequences_1.C0.ESC + 'OD';
}
else {
- result.key = '\x1b[D';
+ result.key = EscapeSequences_1.C0.ESC + '[D';
}
break;
case 39:
- // right-arrow
if (modifiers) {
- result.key = '\x1b[1;' + (modifiers + 1) + 'C';
- // HACK: Make Alt + right-arrow behave like Ctrl + right-arrow: move one word forward
- // http://unix.stackexchange.com/a/108106
- if (result.key == '\x1b[1;3C') {
- result.key = '\x1b[1;5C';
+ 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 = '\x1bOC';
+ result.key = EscapeSequences_1.C0.ESC + 'OC';
}
else {
- result.key = '\x1b[C';
+ result.key = EscapeSequences_1.C0.ESC + '[C';
}
break;
case 38:
- // up-arrow
if (modifiers) {
- result.key = '\x1b[1;' + (modifiers + 1) + 'A';
- // HACK: Make Alt + up-arrow behave like Ctrl + up-arrow
- // http://unix.stackexchange.com/a/108106
- if (result.key == '\x1b[1;3A') {
- result.key = '\x1b[1;5A';
+ 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 = '\x1bOA';
+ result.key = EscapeSequences_1.C0.ESC + 'OA';
}
else {
- result.key = '\x1b[A';
+ result.key = EscapeSequences_1.C0.ESC + '[A';
}
break;
case 40:
- // down-arrow
if (modifiers) {
- result.key = '\x1b[1;' + (modifiers + 1) + 'B';
- // HACK: Make Alt + down-arrow behave like Ctrl + down-arrow
- // http://unix.stackexchange.com/a/108106
- if (result.key == '\x1b[1;3B') {
- result.key = '\x1b[1;5B';
+ 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 = '\x1bOB';
+ result.key = EscapeSequences_1.C0.ESC + 'OB';
}
else {
- result.key = '\x1b[B';
+ result.key = EscapeSequences_1.C0.ESC + '[B';
}
break;
case 45:
- // insert
if (!ev.shiftKey && !ev.ctrlKey) {
- // <Ctrl> or <Shift> + <Insert> are used to
- // copy-paste on some systems.
- result.key = '\x1b[2~';
+ result.key = EscapeSequences_1.C0.ESC + '[2~';
}
break;
case 46:
- // delete
if (modifiers) {
- result.key = '\x1b[3;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[3;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[3~';
+ result.key = EscapeSequences_1.C0.ESC + '[3~';
}
break;
case 36:
- // home
if (modifiers)
- result.key = '\x1b[1;' + (modifiers + 1) + 'H';
+ result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'H';
else if (this.applicationCursor)
- result.key = '\x1bOH';
+ result.key = EscapeSequences_1.C0.ESC + 'OH';
else
- result.key = '\x1b[H';
+ result.key = EscapeSequences_1.C0.ESC + '[H';
break;
case 35:
- // end
if (modifiers)
- result.key = '\x1b[1;' + (modifiers + 1) + 'F';
+ result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'F';
else if (this.applicationCursor)
- result.key = '\x1bOF';
+ result.key = EscapeSequences_1.C0.ESC + 'OF';
else
- result.key = '\x1b[F';
+ result.key = EscapeSequences_1.C0.ESC + '[F';
break;
case 33:
- // page up
if (ev.shiftKey) {
result.scrollDisp = -(this.rows - 1);
}
else {
- result.key = '\x1b[5~';
+ result.key = EscapeSequences_1.C0.ESC + '[5~';
}
break;
case 34:
- // page down
if (ev.shiftKey) {
result.scrollDisp = this.rows - 1;
}
else {
- result.key = '\x1b[6~';
+ result.key = EscapeSequences_1.C0.ESC + '[6~';
}
break;
case 112:
- // F1-F12
if (modifiers) {
- result.key = '\x1b[1;' + (modifiers + 1) + 'P';
+ result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'P';
}
else {
- result.key = '\x1bOP';
+ result.key = EscapeSequences_1.C0.ESC + 'OP';
}
break;
case 113:
if (modifiers) {
- result.key = '\x1b[1;' + (modifiers + 1) + 'Q';
+ result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'Q';
}
else {
- result.key = '\x1bOQ';
+ result.key = EscapeSequences_1.C0.ESC + 'OQ';
}
break;
case 114:
if (modifiers) {
- result.key = '\x1b[1;' + (modifiers + 1) + 'R';
+ result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'R';
}
else {
- result.key = '\x1bOR';
+ result.key = EscapeSequences_1.C0.ESC + 'OR';
}
break;
case 115:
if (modifiers) {
- result.key = '\x1b[1;' + (modifiers + 1) + 'S';
+ result.key = EscapeSequences_1.C0.ESC + '[1;' + (modifiers + 1) + 'S';
}
else {
- result.key = '\x1bOS';
+ result.key = EscapeSequences_1.C0.ESC + 'OS';
}
break;
case 116:
if (modifiers) {
- result.key = '\x1b[15;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[15;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[15~';
+ result.key = EscapeSequences_1.C0.ESC + '[15~';
}
break;
case 117:
if (modifiers) {
- result.key = '\x1b[17;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[17;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[17~';
+ result.key = EscapeSequences_1.C0.ESC + '[17~';
}
break;
case 118:
if (modifiers) {
- result.key = '\x1b[18;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[18;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[18~';
+ result.key = EscapeSequences_1.C0.ESC + '[18~';
}
break;
case 119:
if (modifiers) {
- result.key = '\x1b[19;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[19;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[19~';
+ result.key = EscapeSequences_1.C0.ESC + '[19~';
}
break;
case 120:
if (modifiers) {
- result.key = '\x1b[20;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[20;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[20~';
+ result.key = EscapeSequences_1.C0.ESC + '[20~';
}
break;
case 121:
if (modifiers) {
- result.key = '\x1b[21;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[21;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[21~';
+ result.key = EscapeSequences_1.C0.ESC + '[21~';
}
break;
case 122:
if (modifiers) {
- result.key = '\x1b[23;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[23;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[23~';
+ result.key = EscapeSequences_1.C0.ESC + '[23~';
}
break;
case 123:
if (modifiers) {
- result.key = '\x1b[24;' + (modifiers + 1) + '~';
+ result.key = EscapeSequences_1.C0.ESC + '[24;' + (modifiers + 1) + '~';
}
else {
- result.key = '\x1b[24~';
+ result.key = EscapeSequences_1.C0.ESC + '[24~';
}
break;
default:
- // a-z and space
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) {
- // NUL
result.key = String.fromCharCode(0);
}
else if (ev.keyCode >= 51 && ev.keyCode <= 55) {
- // escape, file sep, group sep, record sep, unit sep
result.key = String.fromCharCode(ev.keyCode - 51 + 27);
}
else if (ev.keyCode === 56) {
- // delete
result.key = String.fromCharCode(127);
}
else if (ev.keyCode === 219) {
- // ^[ - Control Sequence Introducer (CSI)
result.key = String.fromCharCode(27);
}
else if (ev.keyCode === 220) {
- // ^\ - String Terminator (ST)
result.key = String.fromCharCode(28);
}
else if (ev.keyCode === 221) {
- // ^] - Operating System Command (OSC)
result.key = String.fromCharCode(29);
}
}
else if (!this.browser.isMac && ev.altKey && !ev.ctrlKey && !ev.metaKey) {
- // On Mac this is a third level shift. Use <Esc> instead.
if (ev.keyCode >= 65 && ev.keyCode <= 90) {
- result.key = '\x1b' + String.fromCharCode(ev.keyCode + 32);
+ result.key = EscapeSequences_1.C0.ESC + String.fromCharCode(ev.keyCode + 32);
}
else if (ev.keyCode === 192) {
- result.key = '\x1b`';
+ result.key = EscapeSequences_1.C0.ESC + '`';
}
else if (ev.keyCode >= 48 && ev.keyCode <= 57) {
- result.key = '\x1b' + (ev.keyCode - 48);
+ 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;
};
-/**
- * Set the G level of the terminal
- * @param g
- */
Terminal.prototype.setgLevel = function (g) {
this.glevel = g;
this.charset = this.charsets[g];
};
-/**
- * Set the charset for the given G level of the terminal
- * @param g
- * @param charset
- */
Terminal.prototype.setgCharset = function (g, charset) {
this.charsets[g] = charset;
if (this.glevel === g) {
this.charset = charset;
}
};
-/**
- * Handle a keypress event.
- * Key Resources:
- * - https://developer.mozilla.org/en-US/docs/DOM/KeyboardEvent
- * @param {KeyboardEvent} ev The keypress event to be handled.
- */
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;
this.emit('key', key, ev);
this.showCursor();
this.handler(key);
- return false;
+ return true;
};
-/**
- * Send data for handling to the terminal
- * @param {string} data
- */
Terminal.prototype.send = function (data) {
var self = this;
if (!this.queue) {
}
this.queue += data;
};
-/**
- * Ring the bell.
- * Note: We could do sweet things with webaudio here
- */
Terminal.prototype.bell = function () {
if (!this.visualBell)
return;
if (this.popOnBell)
this.focus();
};
-/**
- * Log the current state to the console.
- */
Terminal.prototype.log = function () {
if (!this.debug)
return;
var args = Array.prototype.slice.call(arguments);
this.context.console.log.apply(this.context.console, args);
};
-/**
- * Log the current state as error to the console.
- */
Terminal.prototype.error = function () {
if (!this.debug)
return;
var args = Array.prototype.slice.call(arguments);
this.context.console.error.apply(this.context.console, args);
};
-/**
- * Resizes the terminal.
- *
- * @param {number} x The number of columns to resize to.
- * @param {number} y The number of rows to resize to.
- */
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;
x = 1;
if (y < 1)
y = 1;
- // resize cols
j = this.cols;
if (j < x) {
- ch = [this.defAttr, ' ', 1]; // does xterm use the default attr?
- i = this.lines.length;
- while (i--) {
- while (this.lines[i].length < x) {
- this.lines[i].push(ch);
- }
- }
- }
- else {
+ ch = [this.defAttr, ' ', 1];
i = this.lines.length;
while (i--) {
- while (this.lines[i].length > x) {
- this.lines[i].pop();
+ while (this.lines.get(i).length < x) {
+ this.lines.get(i).push(ch);
}
}
}
- this.setupStops(j);
this.cols = x;
- // resize rows
+ this.setupStops(this.cols);
j = this.rows;
addToY = 0;
if (j < y) {
el = this.element;
while (j++ < y) {
- // y is rows, not this.y
if (this.lines.length < y + this.ybase) {
if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) {
- // There is room above the buffer and there are no empty elements below the line,
- // scroll up
this.ybase--;
addToY++;
if (this.ydisp > 0) {
- // Viewport is at the top of the buffer, must increase downwards
this.ydisp--;
}
}
else {
- // Add a blank line if there is no buffer left at the top to scroll to, or if there
- // are blank lines after the cursor
this.lines.push(this.blankLine());
}
}
while (j-- > y) {
if (this.lines.length > y + this.ybase) {
if (this.lines.length > this.ybase + this.y + 1) {
- // The line is a blank line below the cursor, remove it
this.lines.pop();
}
else {
- // The line is the cursor, scroll down
this.ybase++;
this.ydisp++;
}
}
}
this.rows = y;
- // Make sure that the cursor stays on screen
if (this.y >= y) {
this.y = y - 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 });
};
-/**
- * Updates the range of rows to refresh
- * @param {number} y The number of rows to refresh next.
- */
Terminal.prototype.updateRange = function (y) {
if (y < this.refreshStart)
this.refreshStart = y;
if (y > this.refreshEnd)
this.refreshEnd = y;
- // if (y > this.refreshEnd) {
- // this.refreshEnd = y;
- // if (y > this.rows - 1) {
- // this.refreshEnd = this.rows - 1;
- // }
- // }
};
-/**
- * Set the range of refreshing to the maximum value
- */
Terminal.prototype.maxRange = function () {
this.refreshStart = 0;
this.refreshEnd = this.rows - 1;
};
-/**
- * Setup the tab stops.
- * @param {number} i
- */
Terminal.prototype.setupStops = function (i) {
if (i != null) {
if (!this.tabs[i]) {
this.tabs = {};
i = 0;
}
- for (; i < this.cols; i += 8) {
+ for (; i < this.cols; i += this.getOption('tabStopWidth')) {
this.tabs[i] = true;
}
};
-/**
- * Move the cursor to the previous tab stop from the given position (default is current).
- * @param {number} x The position to move the cursor to the previous tab stop.
- */
Terminal.prototype.prevStop = function (x) {
if (x == null)
x = this.x;
? this.cols - 1
: x < 0 ? 0 : x;
};
-/**
- * Move the cursor one tab stop forward from the given position (default is current).
- * @param {number} x The position to move the cursor one tab stop forward.
- */
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;
-};
-/**
- * Erase in the identified line everything from "x" to the end of the line (right).
- * @param {number} x The column from which to start erasing to the end of the line.
- * @param {number} y The line in which to operate.
- */
-Terminal.prototype.eraseRight = function (x, y) {
- var line = this.lines[this.ybase + y], ch = [this.eraseAttr(), ' ', 1]; // xterm
- for (; x < this.cols; x++) {
- line[x] = ch;
- }
- this.updateRange(y);
-};
-/**
- * Erase in the identified line everything from "x" to the start of the line (left).
- * @param {number} x The column from which to start erasing to the start of the line.
- * @param {number} y The line in which to operate.
- */
-Terminal.prototype.eraseLeft = function (x, y) {
- var line = this.lines[this.ybase + y], ch = [this.eraseAttr(), ' ', 1]; // xterm
- x++;
- while (x--)
- line[x] = ch;
- this.updateRange(y);
-};
-/**
- * Clears the entire buffer, making the prompt line the new first line.
- */
-Terminal.prototype.clear = function () {
- if (this.ybase === 0 && this.y === 0) {
- // Don't clear if it's already clear
- return;
- }
- this.lines = [this.lines[this.ybase + this.y]];
- 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);
-};
-/**
- * Erase all content in the given line
- * @param {number} y The line to erase all of its contents.
- */
-Terminal.prototype.eraseLine = function (y) {
- this.eraseRight(0, y);
-};
-/**
- * Return the data array of a blank line/
- * @param {number} cur First bunch of data for each "blank" character.
- */
-Terminal.prototype.blankLine = function (cur) {
- var attr = cur
- ? this.eraseAttr()
- : this.defAttr;
- var ch = [attr, ' ', 1] // width defaults to 1 halfwidth character
- , line = [], i = 0;
- for (; i < this.cols; i++) {
- line[i] = ch;
- }
- return line;
-};
-/**
- * If cur return the back color xterm feature attribute. Else return defAttr.
- * @param {object} cur
- */
-Terminal.prototype.ch = function (cur) {
- return cur
- ? [this.eraseAttr(), ' ', 1]
- : [this.defAttr, ' ', 1];
-};
-/**
- * Evaluate if the current erminal is the given argument.
- * @param {object} term The terminal to evaluate
- */
-Terminal.prototype.is = function (term) {
- var name = this.termName;
- return (name + '').indexOf(term) === 0;
-};
-/**
- * Emit the 'data' event and populate the given data.
- * @param {string} data The data to populate in the event.
- */
-Terminal.prototype.handler = function (data) {
- // Input is being sent to the terminal, the terminal should focus the prompt.
- if (this.ybase !== this.ydisp) {
- this.scrollToBottom();
- }
- this.emit('data', data);
-};
-/**
- * Emit the 'title' event and populate the given title.
- * @param {string} title The title to populate in the event.
- */
-Terminal.prototype.handleTitle = function (title) {
- /**
- * This event is emitted when the title of the terminal is changed
- * from inside the terminal. The parameter is the new title.
- *
- * @event title
- */
- this.emit('title', title);
-};
-/**
- * ESC
- */
-/**
- * ESC D Index (IND is 0x84).
- */
-Terminal.prototype.index = function () {
- this.y++;
- if (this.y > this.scrollBottom) {
- this.y--;
- this.scroll();
- }
- this.state = normal;
-};
-/**
- * ESC M Reverse Index (RI is 0x8d).
- */
-Terminal.prototype.reverseIndex = function () {
- var j;
- this.y--;
- if (this.y < this.scrollTop) {
- this.y++;
- // possibly move the code below to term.reverseScroll();
- // test: echo -ne '\e[1;1H\e[44m\eM\e[0m'
- // blankLine(true) is xterm/linux behavior
- this.lines.splice(this.y + this.ybase, 0, this.blankLine(true));
- j = this.rows - 1 - this.scrollBottom;
- this.lines.splice(this.rows - 1 + this.ybase - j + 1, 1);
- // this.maxRange();
- this.updateRange(this.scrollTop);
- this.updateRange(this.scrollBottom);
- }
- this.state = normal;
-};
-/**
- * ESC c Full Reset (RIS).
- */
-Terminal.prototype.reset = function () {
- this.options.rows = this.rows;
- this.options.cols = this.cols;
- var customKeydownHandler = this.customKeydownHandler;
- Terminal.call(this, this.options);
- this.customKeydownHandler = customKeydownHandler;
- this.refresh(0, this.rows - 1);
- this.viewport.syncScrollArea();
-};
-/**
- * ESC H Tab Set (HTS is 0x88).
- */
-Terminal.prototype.tabSet = function () {
- this.tabs[this.x] = true;
- this.state = normal;
-};
-/**
- * CSI
- */
-/**
- * CSI Ps A
- * Cursor Up Ps Times (default = 1) (CUU).
- */
-Terminal.prototype.cursorUp = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.y -= param;
- if (this.y < 0)
- this.y = 0;
-};
-/**
- * CSI Ps B
- * Cursor Down Ps Times (default = 1) (CUD).
- */
-Terminal.prototype.cursorDown = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.y += param;
- if (this.y >= this.rows) {
- this.y = this.rows - 1;
- }
-};
-/**
- * CSI Ps C
- * Cursor Forward Ps Times (default = 1) (CUF).
- */
-Terminal.prototype.cursorForward = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.x += param;
- if (this.x >= this.cols) {
- this.x = this.cols - 1;
- }
-};
-/**
- * CSI Ps D
- * Cursor Backward Ps Times (default = 1) (CUB).
- */
-Terminal.prototype.cursorBackward = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.x -= param;
- if (this.x < 0)
- this.x = 0;
-};
-/**
- * CSI Ps ; Ps H
- * Cursor Position [row;column] (default = [1,1]) (CUP).
- */
-Terminal.prototype.cursorPos = 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.rows) {
- row = this.rows - 1;
- }
- if (col < 0) {
- col = 0;
- }
- else if (col >= this.cols) {
- col = this.cols - 1;
- }
- this.x = col;
- this.y = row;
-};
-/**
- * CSI Ps J Erase in Display (ED).
- * Ps = 0 -> Erase Below (default).
- * Ps = 1 -> Erase Above.
- * Ps = 2 -> Erase All.
- * Ps = 3 -> Erase Saved Lines (xterm).
- * CSI ? Ps J
- * Erase in Display (DECSED).
- * Ps = 0 -> Selective Erase Below (default).
- * Ps = 1 -> Selective Erase Above.
- * Ps = 2 -> Selective Erase All.
- */
-Terminal.prototype.eraseInDisplay = function (params) {
- var j;
- switch (params[0]) {
- case 0:
- this.eraseRight(this.x, this.y);
- j = this.y + 1;
- for (; j < this.rows; j++) {
- this.eraseLine(j);
- }
- break;
- case 1:
- this.eraseLeft(this.x, this.y);
- j = this.y;
- while (j--) {
- this.eraseLine(j);
- }
- break;
- case 2:
- j = this.rows;
- while (j--)
- this.eraseLine(j);
- break;
- case 3:
- ; // no saved lines
- break;
- }
-};
-/**
- * CSI Ps K Erase in Line (EL).
- * Ps = 0 -> Erase to Right (default).
- * Ps = 1 -> Erase to Left.
- * Ps = 2 -> Erase All.
- * CSI ? Ps K
- * Erase in Line (DECSEL).
- * Ps = 0 -> Selective Erase to Right (default).
- * Ps = 1 -> Selective Erase to Left.
- * Ps = 2 -> Selective Erase All.
- */
-Terminal.prototype.eraseInLine = function (params) {
- switch (params[0]) {
- case 0:
- this.eraseRight(this.x, this.y);
- break;
- case 1:
- this.eraseLeft(this.x, this.y);
- break;
- case 2:
- this.eraseLine(this.y);
- break;
- }
-};
-/**
- * CSI Pm m Character Attributes (SGR).
- * Ps = 0 -> Normal (default).
- * Ps = 1 -> Bold.
- * Ps = 4 -> Underlined.
- * Ps = 5 -> Blink (appears as Bold).
- * Ps = 7 -> Inverse.
- * Ps = 8 -> Invisible, i.e., hidden (VT300).
- * Ps = 2 2 -> Normal (neither bold nor faint).
- * Ps = 2 4 -> Not underlined.
- * Ps = 2 5 -> Steady (not blinking).
- * Ps = 2 7 -> Positive (not inverse).
- * Ps = 2 8 -> Visible, i.e., not hidden (VT300).
- * Ps = 3 0 -> Set foreground color to Black.
- * Ps = 3 1 -> Set foreground color to Red.
- * Ps = 3 2 -> Set foreground color to Green.
- * Ps = 3 3 -> Set foreground color to Yellow.
- * Ps = 3 4 -> Set foreground color to Blue.
- * Ps = 3 5 -> Set foreground color to Magenta.
- * Ps = 3 6 -> Set foreground color to Cyan.
- * Ps = 3 7 -> Set foreground color to White.
- * Ps = 3 9 -> Set foreground color to default (original).
- * Ps = 4 0 -> Set background color to Black.
- * Ps = 4 1 -> Set background color to Red.
- * Ps = 4 2 -> Set background color to Green.
- * Ps = 4 3 -> Set background color to Yellow.
- * Ps = 4 4 -> Set background color to Blue.
- * Ps = 4 5 -> Set background color to Magenta.
- * Ps = 4 6 -> Set background color to Cyan.
- * Ps = 4 7 -> Set background color to White.
- * Ps = 4 9 -> Set background color to default (original).
- *
- * If 16-color support is compiled, the following apply. Assume
- * that xterm's resources are set so that the ISO color codes are
- * the first 8 of a set of 16. Then the aixterm colors are the
- * bright versions of the ISO colors:
- * Ps = 9 0 -> Set foreground color to Black.
- * Ps = 9 1 -> Set foreground color to Red.
- * Ps = 9 2 -> Set foreground color to Green.
- * Ps = 9 3 -> Set foreground color to Yellow.
- * Ps = 9 4 -> Set foreground color to Blue.
- * Ps = 9 5 -> Set foreground color to Magenta.
- * Ps = 9 6 -> Set foreground color to Cyan.
- * Ps = 9 7 -> Set foreground color to White.
- * Ps = 1 0 0 -> Set background color to Black.
- * Ps = 1 0 1 -> Set background color to Red.
- * Ps = 1 0 2 -> Set background color to Green.
- * Ps = 1 0 3 -> Set background color to Yellow.
- * Ps = 1 0 4 -> Set background color to Blue.
- * Ps = 1 0 5 -> Set background color to Magenta.
- * Ps = 1 0 6 -> Set background color to Cyan.
- * Ps = 1 0 7 -> Set background color to White.
- *
- * If xterm is compiled with the 16-color support disabled, it
- * supports the following, from rxvt:
- * Ps = 1 0 0 -> Set foreground and background color to
- * default.
- *
- * If 88- or 256-color support is compiled, the following apply.
- * Ps = 3 8 ; 5 ; Ps -> Set foreground color to the second
- * Ps.
- * Ps = 4 8 ; 5 ; Ps -> Set background color to the second
- * Ps.
- */
-Terminal.prototype.charAttributes = function (params) {
- // Optimize a single SGR0.
- if (params.length === 1 && params[0] === 0) {
- this.curAttr = this.defAttr;
- return;
- }
- var l = params.length, i = 0, flags = this.curAttr >> 18, fg = (this.curAttr >> 9) & 0x1ff, bg = this.curAttr & 0x1ff, p;
- for (; i < l; i++) {
- p = params[i];
- if (p >= 30 && p <= 37) {
- // fg color 8
- fg = p - 30;
- }
- else if (p >= 40 && p <= 47) {
- // bg color 8
- bg = p - 40;
- }
- else if (p >= 90 && p <= 97) {
- // fg color 16
- p += 8;
- fg = p - 90;
- }
- else if (p >= 100 && p <= 107) {
- // bg color 16
- p += 8;
- bg = p - 100;
- }
- else if (p === 0) {
- // default
- flags = this.defAttr >> 18;
- fg = (this.defAttr >> 9) & 0x1ff;
- bg = this.defAttr & 0x1ff;
- }
- else if (p === 1) {
- // bold text
- flags |= 1;
- }
- else if (p === 4) {
- // underlined text
- flags |= 2;
- }
- else if (p === 5) {
- // blink
- flags |= 4;
- }
- else if (p === 7) {
- // inverse and positive
- // test with: echo -e '\e[31m\e[42mhello\e[7mworld\e[27mhi\e[m'
- flags |= 8;
- }
- else if (p === 8) {
- // invisible
- flags |= 16;
- }
- else if (p === 22) {
- // not bold
- flags &= ~1;
- }
- else if (p === 24) {
- // not underlined
- flags &= ~2;
- }
- else if (p === 25) {
- // not blink
- flags &= ~4;
- }
- else if (p === 27) {
- // not inverse
- flags &= ~8;
- }
- else if (p === 28) {
- // not invisible
- flags &= ~16;
- }
- else if (p === 39) {
- // reset fg
- fg = (this.defAttr >> 9) & 0x1ff;
- }
- else if (p === 49) {
- // reset bg
- bg = this.defAttr & 0x1ff;
- }
- else if (p === 38) {
- // fg color 256
- if (params[i + 1] === 2) {
- i += 2;
- fg = 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) {
- // bg color 256
- if (params[i + 1] === 2) {
- i += 2;
- bg = 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) {
- // reset fg/bg
- fg = (this.defAttr >> 9) & 0x1ff;
- bg = this.defAttr & 0x1ff;
- }
- else {
- this.error('Unknown SGR attribute: %d.', p);
- }
- }
- this.curAttr = (flags << 18) | (fg << 9) | bg;
-};
-/**
- * CSI Ps n Device Status Report (DSR).
- * Ps = 5 -> Status Report. Result (``OK'') is
- * CSI 0 n
- * Ps = 6 -> Report Cursor Position (CPR) [row;column].
- * Result is
- * CSI r ; c R
- * CSI ? Ps n
- * Device Status Report (DSR, DEC-specific).
- * Ps = 6 -> Report Cursor Position (CPR) [row;column] as CSI
- * ? r ; c R (assumes page is zero).
- * Ps = 1 5 -> Report Printer status as CSI ? 1 0 n (ready).
- * or CSI ? 1 1 n (not ready).
- * Ps = 2 5 -> Report UDK status as CSI ? 2 0 n (unlocked)
- * or CSI ? 2 1 n (locked).
- * Ps = 2 6 -> Report Keyboard status as
- * CSI ? 2 7 ; 1 ; 0 ; 0 n (North American).
- * The last two parameters apply to VT400 & up, and denote key-
- * board ready and LK01 respectively.
- * Ps = 5 3 -> Report Locator status as
- * CSI ? 5 3 n Locator available, if compiled-in, or
- * CSI ? 5 0 n No Locator, if not.
- */
-Terminal.prototype.deviceStatus = function (params) {
- if (!this.prefix) {
- switch (params[0]) {
- case 5:
- // status report
- this.send('\x1b[0n');
- break;
- case 6:
- // cursor position
- this.send('\x1b['
- + (this.y + 1)
- + ';'
- + (this.x + 1)
- + 'R');
- break;
- }
- }
- else if (this.prefix === '?') {
- // modern xterm doesnt seem to
- // respond to any of these except ?6, 6, and 5
- switch (params[0]) {
- case 6:
- // cursor position
- this.send('\x1b[?'
- + (this.y + 1)
- + ';'
- + (this.x + 1)
- + 'R');
- break;
- case 15:
- // no printer
- // this.send('\x1b[?11n');
- break;
- case 25:
- // dont support user defined keys
- // this.send('\x1b[?21n');
- break;
- case 26:
- // north american keyboard
- // this.send('\x1b[?27;1;0;0n');
- break;
- case 53:
- // no dec locator/mouse
- // this.send('\x1b[?50n');
- break;
- }
- }
-};
-/**
- * Additions
- */
-/**
- * CSI Ps @
- * Insert Ps (Blank) Character(s) (default = 1) (ICH).
- */
-Terminal.prototype.insertChars = function (params) {
- var param, row, j, ch;
- param = params[0];
- if (param < 1)
- param = 1;
- row = this.y + this.ybase;
- j = this.x;
- ch = [this.eraseAttr(), ' ', 1]; // xterm
- while (param-- && j < this.cols) {
- this.lines[row].splice(j++, 0, ch);
- this.lines[row].pop();
- }
-};
-/**
- * CSI Ps E
- * Cursor Next Line Ps Times (default = 1) (CNL).
- * same as CSI Ps B ?
- */
-Terminal.prototype.cursorNextLine = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.y += param;
- if (this.y >= this.rows) {
- this.y = this.rows - 1;
- }
- this.x = 0;
-};
-/**
- * CSI Ps F
- * Cursor Preceding Line Ps Times (default = 1) (CNL).
- * reuse CSI Ps A ?
- */
-Terminal.prototype.cursorPrecedingLine = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.y -= param;
- if (this.y < 0)
- this.y = 0;
- this.x = 0;
-};
-/**
- * CSI Ps G
- * Cursor Character Absolute [column] (default = [row,1]) (CHA).
- */
-Terminal.prototype.cursorCharAbsolute = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.x = param - 1;
-};
-/**
- * CSI Ps L
- * Insert Ps Line(s) (default = 1) (IL).
- */
-Terminal.prototype.insertLines = function (params) {
- var param, row, j;
- param = params[0];
- if (param < 1)
- param = 1;
- row = this.y + this.ybase;
- j = this.rows - 1 - this.scrollBottom;
- j = this.rows - 1 + this.ybase - j + 1;
- while (param--) {
- // test: echo -e '\e[44m\e[1L\e[0m'
- // blankLine(true) - xterm/linux behavior
- this.lines.splice(row, 0, this.blankLine(true));
- this.lines.splice(j, 1);
- }
- // this.maxRange();
- this.updateRange(this.y);
- this.updateRange(this.scrollBottom);
-};
-/**
- * CSI Ps M
- * Delete Ps Line(s) (default = 1) (DL).
- */
-Terminal.prototype.deleteLines = function (params) {
- var param, row, j;
- param = params[0];
- if (param < 1)
- param = 1;
- row = this.y + this.ybase;
- j = this.rows - 1 - this.scrollBottom;
- j = this.rows - 1 + this.ybase - j;
- while (param--) {
- // test: echo -e '\e[44m\e[1M\e[0m'
- // blankLine(true) - xterm/linux behavior
- this.lines.splice(j + 1, 0, this.blankLine(true));
- this.lines.splice(row, 1);
- }
- // this.maxRange();
- this.updateRange(this.y);
- this.updateRange(this.scrollBottom);
-};
-/**
- * CSI Ps P
- * Delete Ps Character(s) (default = 1) (DCH).
- */
-Terminal.prototype.deleteChars = function (params) {
- var param, row, ch;
- param = params[0];
- if (param < 1)
- param = 1;
- row = this.y + this.ybase;
- ch = [this.eraseAttr(), ' ', 1]; // xterm
- while (param--) {
- this.lines[row].splice(this.x, 1);
- this.lines[row].push(ch);
- }
-};
-/**
- * CSI Ps X
- * Erase Ps Character(s) (default = 1) (ECH).
- */
-Terminal.prototype.eraseChars = function (params) {
- var param, row, j, ch;
- param = params[0];
- if (param < 1)
- param = 1;
- row = this.y + this.ybase;
- j = this.x;
- ch = [this.eraseAttr(), ' ', 1]; // xterm
- while (param-- && j < this.cols) {
- this.lines[row][j++] = ch;
- }
-};
-/**
- * CSI Pm ` Character Position Absolute
- * [column] (default = [row,1]) (HPA).
- */
-Terminal.prototype.charPosAbsolute = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.x = param - 1;
- if (this.x >= this.cols) {
- this.x = this.cols - 1;
- }
-};
-/**
- * 141 61 a * HPR -
- * Horizontal Position Relative
- * reuse CSI Ps C ?
- */
-Terminal.prototype.HPositionRelative = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.x += param;
- if (this.x >= this.cols) {
- this.x = this.cols - 1;
- }
-};
-/**
- * CSI Ps c Send Device Attributes (Primary DA).
- * Ps = 0 or omitted -> request attributes from terminal. The
- * response depends on the decTerminalID resource setting.
- * -> CSI ? 1 ; 2 c (``VT100 with Advanced Video Option'')
- * -> CSI ? 1 ; 0 c (``VT101 with No Options'')
- * -> CSI ? 6 c (``VT102'')
- * -> CSI ? 6 0 ; 1 ; 2 ; 6 ; 8 ; 9 ; 1 5 ; c (``VT220'')
- * The VT100-style response parameters do not mean anything by
- * themselves. VT220 parameters do, telling the host what fea-
- * tures the terminal supports:
- * Ps = 1 -> 132-columns.
- * Ps = 2 -> Printer.
- * Ps = 6 -> Selective erase.
- * Ps = 8 -> User-defined keys.
- * Ps = 9 -> National replacement character sets.
- * Ps = 1 5 -> Technical characters.
- * Ps = 2 2 -> ANSI color, e.g., VT525.
- * Ps = 2 9 -> ANSI text locator (i.e., DEC Locator mode).
- * CSI > Ps c
- * Send Device Attributes (Secondary DA).
- * Ps = 0 or omitted -> request the terminal's identification
- * code. The response depends on the decTerminalID resource set-
- * ting. It should apply only to VT220 and up, but xterm extends
- * this to VT100.
- * -> CSI > Pp ; Pv ; Pc c
- * where Pp denotes the terminal type
- * Pp = 0 -> ``VT100''.
- * Pp = 1 -> ``VT220''.
- * and Pv is the firmware version (for xterm, this was originally
- * the XFree86 patch number, starting with 95). In a DEC termi-
- * nal, Pc indicates the ROM cartridge registration number and is
- * always zero.
- * More information:
- * xterm/charproc.c - line 2012, for more information.
- * vim responds with ^[[?0c or ^[[?1c after the terminal's response (?)
- */
-Terminal.prototype.sendDeviceAttributes = function (params) {
- if (params[0] > 0)
- return;
- if (!this.prefix) {
- if (this.is('xterm')
- || this.is('rxvt-unicode')
- || this.is('screen')) {
- this.send('\x1b[?1;2c');
- }
- else if (this.is('linux')) {
- this.send('\x1b[?6c');
- }
- }
- else if (this.prefix === '>') {
- // xterm and urxvt
- // seem to spit this
- // out around ~370 times (?).
- if (this.is('xterm')) {
- this.send('\x1b[>0;276;0c');
- }
- else if (this.is('rxvt-unicode')) {
- this.send('\x1b[>85;95;0c');
- }
- else if (this.is('linux')) {
- // not supported by linux console.
- // linux console echoes parameters.
- this.send(params[0] + 'c');
- }
- else if (this.is('screen')) {
- this.send('\x1b[>83;40003;0c');
- }
- }
-};
-/**
- * CSI Pm d
- * Line Position Absolute [row] (default = [1,column]) (VPA).
- */
-Terminal.prototype.linePosAbsolute = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.y = param - 1;
- if (this.y >= this.rows) {
- this.y = this.rows - 1;
- }
-};
-/**
- * 145 65 e * VPR - Vertical Position Relative
- * reuse CSI Ps B ?
- */
-Terminal.prototype.VPositionRelative = function (params) {
- var param = params[0];
- if (param < 1)
- param = 1;
- this.y += param;
- if (this.y >= this.rows) {
- this.y = this.rows - 1;
- }
-};
-/**
- * CSI Ps ; Ps f
- * Horizontal and Vertical Position [row;column] (default =
- * [1,1]) (HVP).
- */
-Terminal.prototype.HVPosition = function (params) {
- if (params[0] < 1)
- params[0] = 1;
- if (params[1] < 1)
- params[1] = 1;
- this.y = params[0] - 1;
- if (this.y >= this.rows) {
- this.y = this.rows - 1;
- }
- this.x = params[1] - 1;
- if (this.x >= this.cols) {
- this.x = this.cols - 1;
- }
-};
-/**
- * CSI Pm h Set Mode (SM).
- * Ps = 2 -> Keyboard Action Mode (AM).
- * Ps = 4 -> Insert Mode (IRM).
- * Ps = 1 2 -> Send/receive (SRM).
- * Ps = 2 0 -> Automatic Newline (LNM).
- * CSI ? Pm h
- * DEC Private Mode Set (DECSET).
- * Ps = 1 -> Application Cursor Keys (DECCKM).
- * Ps = 2 -> Designate USASCII for character sets G0-G3
- * (DECANM), and set VT100 mode.
- * Ps = 3 -> 132 Column Mode (DECCOLM).
- * Ps = 4 -> Smooth (Slow) Scroll (DECSCLM).
- * Ps = 5 -> Reverse Video (DECSCNM).
- * Ps = 6 -> Origin Mode (DECOM).
- * Ps = 7 -> Wraparound Mode (DECAWM).
- * Ps = 8 -> Auto-repeat Keys (DECARM).
- * Ps = 9 -> Send Mouse X & Y on button press. See the sec-
- * tion Mouse Tracking.
- * Ps = 1 0 -> Show toolbar (rxvt).
- * Ps = 1 2 -> Start Blinking Cursor (att610).
- * Ps = 1 8 -> Print form feed (DECPFF).
- * Ps = 1 9 -> Set print extent to full screen (DECPEX).
- * Ps = 2 5 -> Show Cursor (DECTCEM).
- * Ps = 3 0 -> Show scrollbar (rxvt).
- * Ps = 3 5 -> Enable font-shifting functions (rxvt).
- * Ps = 3 8 -> Enter Tektronix Mode (DECTEK).
- * Ps = 4 0 -> Allow 80 -> 132 Mode.
- * Ps = 4 1 -> more(1) fix (see curses resource).
- * Ps = 4 2 -> Enable Nation Replacement Character sets (DECN-
- * RCM).
- * Ps = 4 4 -> Turn On Margin Bell.
- * Ps = 4 5 -> Reverse-wraparound Mode.
- * Ps = 4 6 -> Start Logging. This is normally disabled by a
- * compile-time option.
- * Ps = 4 7 -> Use Alternate Screen Buffer. (This may be dis-
- * abled by the titeInhibit resource).
- * Ps = 6 6 -> Application keypad (DECNKM).
- * Ps = 6 7 -> Backarrow key sends backspace (DECBKM).
- * Ps = 1 0 0 0 -> Send Mouse X & Y on button press and
- * release. See the section Mouse Tracking.
- * Ps = 1 0 0 1 -> Use Hilite Mouse Tracking.
- * Ps = 1 0 0 2 -> Use Cell Motion Mouse Tracking.
- * Ps = 1 0 0 3 -> Use All Motion Mouse Tracking.
- * Ps = 1 0 0 4 -> Send FocusIn/FocusOut events.
- * Ps = 1 0 0 5 -> Enable Extended Mouse Mode.
- * Ps = 1 0 1 0 -> Scroll to bottom on tty output (rxvt).
- * Ps = 1 0 1 1 -> Scroll to bottom on key press (rxvt).
- * Ps = 1 0 3 4 -> Interpret "meta" key, sets eighth bit.
- * (enables the eightBitInput resource).
- * Ps = 1 0 3 5 -> Enable special modifiers for Alt and Num-
- * Lock keys. (This enables the numLock resource).
- * Ps = 1 0 3 6 -> Send ESC when Meta modifies a key. (This
- * enables the metaSendsEscape resource).
- * Ps = 1 0 3 7 -> Send DEL from the editing-keypad Delete
- * key.
- * Ps = 1 0 3 9 -> Send ESC when Alt modifies a key. (This
- * enables the altSendsEscape resource).
- * Ps = 1 0 4 0 -> Keep selection even if not highlighted.
- * (This enables the keepSelection resource).
- * Ps = 1 0 4 1 -> Use the CLIPBOARD selection. (This enables
- * the selectToClipboard resource).
- * Ps = 1 0 4 2 -> Enable Urgency window manager hint when
- * Control-G is received. (This enables the bellIsUrgent
- * resource).
- * Ps = 1 0 4 3 -> Enable raising of the window when Control-G
- * is received. (enables the popOnBell resource).
- * Ps = 1 0 4 7 -> Use Alternate Screen Buffer. (This may be
- * disabled by the titeInhibit resource).
- * Ps = 1 0 4 8 -> Save cursor as in DECSC. (This may be dis-
- * abled by the titeInhibit resource).
- * Ps = 1 0 4 9 -> Save cursor as in DECSC and use Alternate
- * Screen Buffer, clearing it first. (This may be disabled by
- * the titeInhibit resource). This combines the effects of the 1
- * 0 4 7 and 1 0 4 8 modes. Use this with terminfo-based
- * applications rather than the 4 7 mode.
- * Ps = 1 0 5 0 -> Set terminfo/termcap function-key mode.
- * Ps = 1 0 5 1 -> Set Sun function-key mode.
- * Ps = 1 0 5 2 -> Set HP function-key mode.
- * Ps = 1 0 5 3 -> Set SCO function-key mode.
- * Ps = 1 0 6 0 -> Set legacy keyboard emulation (X11R6).
- * Ps = 1 0 6 1 -> Set VT220 keyboard emulation.
- * Ps = 2 0 0 4 -> Set bracketed paste mode.
- * Modes:
- * http: *vt100.net/docs/vt220-rm/chapter4.html
- */
-Terminal.prototype.setMode = function (params) {
- if (typeof params === 'object') {
- var l = params.length, i = 0;
- for (; i < l; i++) {
- this.setMode(params[i]);
- }
- return;
- }
- if (!this.prefix) {
- switch (params) {
- case 4:
- this.insertMode = true;
- break;
- case 20:
- //this.convertEol = true;
- break;
- }
- }
- else if (this.prefix === '?') {
- switch (params) {
- case 1:
- this.applicationCursor = true;
- break;
- case 2:
- this.setgCharset(0, Terminal.charsets.US);
- this.setgCharset(1, Terminal.charsets.US);
- this.setgCharset(2, Terminal.charsets.US);
- this.setgCharset(3, Terminal.charsets.US);
- // set VT100 mode here
- break;
- case 3:
- this.savedCols = this.cols;
- this.resize(132, this.rows);
- break;
- case 6:
- this.originMode = true;
- break;
- case 7:
- this.wraparoundMode = true;
- break;
- case 12:
- // this.cursorBlink = true;
- break;
- case 66:
- this.log('Serial port requested application keypad.');
- this.applicationKeypad = true;
- this.viewport.syncScrollArea();
- break;
- case 9: // X10 Mouse
- // no release, no motion, no wheel, no modifiers.
- case 1000: // vt200 mouse
- // no motion.
- // no modifiers, except control on the wheel.
- case 1002: // button event mouse
- case 1003:
- // any event - sends motion events,
- // even if there is no button held down.
- this.x10Mouse = params === 9;
- this.vt200Mouse = params === 1000;
- this.normalMouse = params > 1000;
- this.mouseEvents = true;
- this.element.style.cursor = 'default';
- this.log('Binding to mouse events.');
- break;
- case 1004:
- // focusin: ^[[I
- // focusout: ^[[O
- this.sendFocus = true;
- break;
- case 1005:
- this.utfMouse = true;
- // for wide terminals
- // simply encodes large values as utf8 characters
- break;
- case 1006:
- this.sgrMouse = true;
- // for wide terminals
- // does not add 32 to fields
- // press: ^[[<b;x;yM
- // release: ^[[<b;x;ym
- break;
- case 1015:
- this.urxvtMouse = true;
- // for wide terminals
- // numbers for fields
- // press: ^[[b;x;yM
- // motion: ^[[b;x;yT
- break;
- case 25:
- this.cursorHidden = false;
- break;
- case 1049:
- //this.saveCursor();
- ; // FALL-THROUGH
- case 47: // alt screen buffer
- case 1047:
- if (!this.normal) {
- var normal = {
- lines: this.lines,
- ybase: this.ybase,
- ydisp: this.ydisp,
- x: this.x,
- y: this.y,
- scrollTop: this.scrollTop,
- scrollBottom: this.scrollBottom,
- tabs: this.tabs
- };
- this.reset();
- this.normal = normal;
- this.showCursor();
- }
- break;
- }
- }
+ ;
+ return x >= this.cols
+ ? this.cols - 1
+ : x < 0 ? 0 : x;
};
-/**
- * CSI Pm l Reset Mode (RM).
- * Ps = 2 -> Keyboard Action Mode (AM).
- * Ps = 4 -> Replace Mode (IRM).
- * Ps = 1 2 -> Send/receive (SRM).
- * Ps = 2 0 -> Normal Linefeed (LNM).
- * CSI ? Pm l
- * DEC Private Mode Reset (DECRST).
- * Ps = 1 -> Normal Cursor Keys (DECCKM).
- * Ps = 2 -> Designate VT52 mode (DECANM).
- * Ps = 3 -> 80 Column Mode (DECCOLM).
- * Ps = 4 -> Jump (Fast) Scroll (DECSCLM).
- * Ps = 5 -> Normal Video (DECSCNM).
- * Ps = 6 -> Normal Cursor Mode (DECOM).
- * Ps = 7 -> No Wraparound Mode (DECAWM).
- * Ps = 8 -> No Auto-repeat Keys (DECARM).
- * Ps = 9 -> Don't send Mouse X & Y on button press.
- * Ps = 1 0 -> Hide toolbar (rxvt).
- * Ps = 1 2 -> Stop Blinking Cursor (att610).
- * Ps = 1 8 -> Don't print form feed (DECPFF).
- * Ps = 1 9 -> Limit print to scrolling region (DECPEX).
- * Ps = 2 5 -> Hide Cursor (DECTCEM).
- * Ps = 3 0 -> Don't show scrollbar (rxvt).
- * Ps = 3 5 -> Disable font-shifting functions (rxvt).
- * Ps = 4 0 -> Disallow 80 -> 132 Mode.
- * Ps = 4 1 -> No more(1) fix (see curses resource).
- * Ps = 4 2 -> Disable Nation Replacement Character sets (DEC-
- * NRCM).
- * Ps = 4 4 -> Turn Off Margin Bell.
- * Ps = 4 5 -> No Reverse-wraparound Mode.
- * Ps = 4 6 -> Stop Logging. (This is normally disabled by a
- * compile-time option).
- * Ps = 4 7 -> Use Normal Screen Buffer.
- * Ps = 6 6 -> Numeric keypad (DECNKM).
- * Ps = 6 7 -> Backarrow key sends delete (DECBKM).
- * Ps = 1 0 0 0 -> Don't send Mouse X & Y on button press and
- * release. See the section Mouse Tracking.
- * Ps = 1 0 0 1 -> Don't use Hilite Mouse Tracking.
- * Ps = 1 0 0 2 -> Don't use Cell Motion Mouse Tracking.
- * Ps = 1 0 0 3 -> Don't use All Motion Mouse Tracking.
- * Ps = 1 0 0 4 -> Don't send FocusIn/FocusOut events.
- * Ps = 1 0 0 5 -> Disable Extended Mouse Mode.
- * Ps = 1 0 1 0 -> Don't scroll to bottom on tty output
- * (rxvt).
- * Ps = 1 0 1 1 -> Don't scroll to bottom on key press (rxvt).
- * Ps = 1 0 3 4 -> Don't interpret "meta" key. (This disables
- * the eightBitInput resource).
- * Ps = 1 0 3 5 -> Disable special modifiers for Alt and Num-
- * Lock keys. (This disables the numLock resource).
- * Ps = 1 0 3 6 -> Don't send ESC when Meta modifies a key.
- * (This disables the metaSendsEscape resource).
- * Ps = 1 0 3 7 -> Send VT220 Remove from the editing-keypad
- * Delete key.
- * Ps = 1 0 3 9 -> Don't send ESC when Alt modifies a key.
- * (This disables the altSendsEscape resource).
- * Ps = 1 0 4 0 -> Do not keep selection when not highlighted.
- * (This disables the keepSelection resource).
- * Ps = 1 0 4 1 -> Use the PRIMARY selection. (This disables
- * the selectToClipboard resource).
- * Ps = 1 0 4 2 -> Disable Urgency window manager hint when
- * Control-G is received. (This disables the bellIsUrgent
- * resource).
- * Ps = 1 0 4 3 -> Disable raising of the window when Control-
- * G is received. (This disables the popOnBell resource).
- * Ps = 1 0 4 7 -> Use Normal Screen Buffer, clearing screen
- * first if in the Alternate Screen. (This may be disabled by
- * the titeInhibit resource).
- * Ps = 1 0 4 8 -> Restore cursor as in DECRC. (This may be
- * disabled by the titeInhibit resource).
- * Ps = 1 0 4 9 -> Use Normal Screen Buffer and restore cursor
- * as in DECRC. (This may be disabled by the titeInhibit
- * resource). This combines the effects of the 1 0 4 7 and 1 0
- * 4 8 modes. Use this with terminfo-based applications rather
- * than the 4 7 mode.
- * Ps = 1 0 5 0 -> Reset terminfo/termcap function-key mode.
- * Ps = 1 0 5 1 -> Reset Sun function-key mode.
- * Ps = 1 0 5 2 -> Reset HP function-key mode.
- * Ps = 1 0 5 3 -> Reset SCO function-key mode.
- * Ps = 1 0 6 0 -> Reset legacy keyboard emulation (X11R6).
- * Ps = 1 0 6 1 -> Reset keyboard emulation to Sun/PC style.
- * Ps = 2 0 0 4 -> Reset bracketed paste mode.
- */
-Terminal.prototype.resetMode = function (params) {
- if (typeof params === 'object') {
- var l = params.length, i = 0;
- for (; i < l; i++) {
- this.resetMode(params[i]);
- }
+Terminal.prototype.eraseRight = function (x, y) {
+ var line = this.lines.get(this.ybase + y);
+ if (!line) {
return;
}
- if (!this.prefix) {
- switch (params) {
- case 4:
- this.insertMode = false;
- break;
- case 20:
- //this.convertEol = false;
- break;
- }
+ var ch = [this.eraseAttr(), ' ', 1];
+ for (; x < this.cols; x++) {
+ line[x] = ch;
}
- else if (this.prefix === '?') {
- switch (params) {
- case 1:
- this.applicationCursor = false;
- break;
- case 3:
- if (this.cols === 132 && this.savedCols) {
- this.resize(this.savedCols, this.rows);
- }
- delete this.savedCols;
- break;
- case 6:
- this.originMode = false;
- break;
- case 7:
- this.wraparoundMode = false;
- break;
- case 12:
- // this.cursorBlink = false;
- break;
- case 66:
- this.log('Switching back to normal keypad.');
- this.applicationKeypad = false;
- this.viewport.syncScrollArea();
- break;
- case 9: // X10 Mouse
- case 1000: // vt200 mouse
- case 1002: // button event mouse
- case 1003:
- this.x10Mouse = false;
- this.vt200Mouse = false;
- this.normalMouse = false;
- this.mouseEvents = false;
- this.element.style.cursor = '';
- break;
- case 1004:
- this.sendFocus = false;
- break;
- case 1005:
- this.utfMouse = false;
- break;
- case 1006:
- this.sgrMouse = false;
- break;
- case 1015:
- this.urxvtMouse = false;
- break;
- case 25:
- this.cursorHidden = true;
- break;
- case 1049:
- ; // FALL-THROUGH
- case 47: // normal screen buffer
- case 1047:
- if (this.normal) {
- this.lines = this.normal.lines;
- this.ybase = this.normal.ybase;
- this.ydisp = this.normal.ydisp;
- this.x = this.normal.x;
- this.y = this.normal.y;
- this.scrollTop = this.normal.scrollTop;
- this.scrollBottom = this.normal.scrollBottom;
- this.tabs = this.normal.tabs;
- this.normal = null;
- // if (params === 1049) {
- // this.x = this.savedX;
- // this.y = this.savedY;
- // }
- this.refresh(0, this.rows - 1);
- this.showCursor();
- }
- break;
- }
+ 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);
};
-/**
- * CSI Ps ; Ps r
- * Set Scrolling Region [top;bottom] (default = full size of win-
- * dow) (DECSTBM).
- * CSI ? Pm r
- */
-Terminal.prototype.setScrollRegion = function (params) {
- if (this.prefix)
+Terminal.prototype.clear = function () {
+ if (this.ybase === 0 && this.y === 0) {
return;
- this.scrollTop = (params[0] || 1) - 1;
- this.scrollBottom = (params[1] || this.rows) - 1;
- this.x = 0;
+ }
+ 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);
};
-/**
- * CSI s
- * Save cursor (ANSI.SYS).
- */
-Terminal.prototype.saveCursor = function (params) {
- this.savedX = this.x;
- this.savedY = this.y;
-};
-/**
- * CSI u
- * Restore cursor (ANSI.SYS).
- */
-Terminal.prototype.restoreCursor = function (params) {
- this.x = this.savedX || 0;
- this.y = this.savedY || 0;
+Terminal.prototype.eraseLine = function (y) {
+ this.eraseRight(0, y);
};
-/**
- * Lesser Used
- */
-/**
- * CSI Ps I
- * Cursor Forward Tabulation Ps tab stops (default = 1) (CHT).
- */
-Terminal.prototype.cursorForwardTab = function (params) {
- var param = params[0] || 1;
- while (param--) {
- this.x = this.nextStop();
+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;
}
-};
-/**
- * CSI Ps S Scroll up Ps lines (default = 1) (SU).
- */
-Terminal.prototype.scrollUp = function (params) {
- var param = params[0] || 1;
- while (param--) {
- this.lines.splice(this.ybase + this.scrollTop, 1);
- this.lines.splice(this.ybase + this.scrollBottom, 0, this.blankLine());
+ for (; i < this.cols; i++) {
+ line[i] = ch;
}
- // this.maxRange();
- this.updateRange(this.scrollTop);
- this.updateRange(this.scrollBottom);
-};
-/**
- * CSI Ps T Scroll down Ps lines (default = 1) (SD).
- */
-Terminal.prototype.scrollDown = function (params) {
- var param = params[0] || 1;
- while (param--) {
- this.lines.splice(this.ybase + this.scrollBottom, 1);
- this.lines.splice(this.ybase + this.scrollTop, 0, this.blankLine());
- }
- // this.maxRange();
- this.updateRange(this.scrollTop);
- this.updateRange(this.scrollBottom);
+ return line;
};
-/**
- * CSI Ps ; Ps ; Ps ; Ps ; Ps T
- * Initiate highlight mouse tracking. Parameters are
- * [func;startx;starty;firstrow;lastrow]. See the section Mouse
- * Tracking.
- */
-Terminal.prototype.initMouseTracking = function (params) {
- // Relevant: DECSET 1001
+Terminal.prototype.ch = function (cur) {
+ return cur
+ ? [this.eraseAttr(), ' ', 1]
+ : [this.defAttr, ' ', 1];
};
-/**
- * CSI > Ps; Ps T
- * Reset one or more features of the title modes to the default
- * value. Normally, "reset" disables the feature. It is possi-
- * ble to disable the ability to reset features by compiling a
- * different default for the title modes into xterm.
- * Ps = 0 -> Do not set window/icon labels using hexadecimal.
- * Ps = 1 -> Do not query window/icon labels using hexadeci-
- * mal.
- * Ps = 2 -> Do not set window/icon labels using UTF-8.
- * Ps = 3 -> Do not query window/icon labels using UTF-8.
- * (See discussion of "Title Modes").
- */
-Terminal.prototype.resetTitleModes = function (params) {
- ;
+Terminal.prototype.is = function (term) {
+ var name = this.termName;
+ return (name + '').indexOf(term) === 0;
};
-/**
- * CSI Ps Z Cursor Backward Tabulation Ps tab stops (default = 1) (CBT).
- */
-Terminal.prototype.cursorBackwardTab = function (params) {
- var param = params[0] || 1;
- while (param--) {
- this.x = this.prevStop();
+Terminal.prototype.handler = function (data) {
+ if (this.options.disableStdin) {
+ return;
}
-};
-/**
- * CSI Ps b Repeat the preceding graphic character Ps times (REP).
- */
-Terminal.prototype.repeatPrecedingCharacter = function (params) {
- var param = params[0] || 1, line = this.lines[this.ybase + this.y], ch = line[this.x - 1] || [this.defAttr, ' ', 1];
- while (param--)
- line[this.x++] = ch;
-};
-/**
- * CSI Ps g Tab Clear (TBC).
- * Ps = 0 -> Clear Current Column (default).
- * Ps = 3 -> Clear All.
- * Potentially:
- * Ps = 2 -> Clear Stops on Line.
- * http://vt100.net/annarbor/aaa-ug/section6.html
- */
-Terminal.prototype.tabClear = function (params) {
- var param = params[0];
- if (param <= 0) {
- delete this.tabs[this.x];
- }
- else if (param === 3) {
- this.tabs = {};
+ if (this.ybase !== this.ydisp) {
+ this.scrollToBottom();
}
+ this.emit('data', data);
};
-/**
- * CSI Pm i Media Copy (MC).
- * Ps = 0 -> Print screen (default).
- * Ps = 4 -> Turn off printer controller mode.
- * Ps = 5 -> Turn on printer controller mode.
- * CSI ? Pm i
- * Media Copy (MC, DEC-specific).
- * Ps = 1 -> Print line containing cursor.
- * Ps = 4 -> Turn off autoprint mode.
- * Ps = 5 -> Turn on autoprint mode.
- * Ps = 1 0 -> Print composed display, ignores DECPEX.
- * Ps = 1 1 -> Print all pages.
- */
-Terminal.prototype.mediaCopy = function (params) {
- ;
-};
-/**
- * CSI > Ps; Ps m
- * Set or reset resource-values used by xterm to decide whether
- * to construct escape sequences holding information about the
- * modifiers pressed with a given key. The first parameter iden-
- * tifies the resource to set/reset. The second parameter is the
- * value to assign to the resource. If the second parameter is
- * omitted, the resource is reset to its initial value.
- * Ps = 1 -> modifyCursorKeys.
- * Ps = 2 -> modifyFunctionKeys.
- * Ps = 4 -> modifyOtherKeys.
- * If no parameters are given, all resources are reset to their
- * initial values.
- */
-Terminal.prototype.setResources = function (params) {
- ;
+Terminal.prototype.handleTitle = function (title) {
+ this.emit('title', title);
};
-/**
- * CSI > Ps n
- * Disable modifiers which may be enabled via the CSI > Ps; Ps m
- * sequence. This corresponds to a resource value of "-1", which
- * cannot be set with the other sequence. The parameter identi-
- * fies the resource to be disabled:
- * Ps = 1 -> modifyCursorKeys.
- * Ps = 2 -> modifyFunctionKeys.
- * Ps = 4 -> modifyOtherKeys.
- * If the parameter is omitted, modifyFunctionKeys is disabled.
- * When modifyFunctionKeys is disabled, xterm uses the modifier
- * keys to make an extended sequence of functions rather than
- * adding a parameter to each function key to denote the modi-
- * fiers.
- */
-Terminal.prototype.disableModifiers = function (params) {
- ;
+Terminal.prototype.index = function () {
+ this.y++;
+ if (this.y > this.scrollBottom) {
+ this.y--;
+ this.scroll();
+ }
+ if (this.x >= this.cols) {
+ this.x--;
+ }
};
-/**
- * CSI > Ps p
- * Set resource value pointerMode. This is used by xterm to
- * decide whether to hide the pointer cursor as the user types.
- * Valid values for the parameter:
- * Ps = 0 -> never hide the pointer.
- * Ps = 1 -> hide if the mouse tracking mode is not enabled.
- * Ps = 2 -> always hide the pointer. If no parameter is
- * given, xterm uses the default, which is 1 .
- */
-Terminal.prototype.setPointerMode = function (params) {
- ;
+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--;
+ }
};
-/**
- * CSI ! p Soft terminal reset (DECSTR).
- * http://vt100.net/docs/vt220-rm/table4-10.html
- */
-Terminal.prototype.softReset = function (params) {
- this.cursorHidden = false;
- this.insertMode = false;
- this.originMode = false;
- this.wraparoundMode = false; // autowrap
- this.applicationKeypad = false; // ?
+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();
- this.applicationCursor = false;
- this.scrollTop = 0;
- this.scrollBottom = this.rows - 1;
- this.curAttr = this.defAttr;
- this.x = this.y = 0; // ?
- this.charset = null;
- this.glevel = 0; // ??
- this.charsets = [null]; // ??
-};
-/**
- * CSI Ps$ p
- * Request ANSI mode (DECRQM). For VT300 and up, reply is
- * CSI Ps; Pm$ y
- * where Ps is the mode number as in RM, and Pm is the mode
- * value:
- * 0 - not recognized
- * 1 - set
- * 2 - reset
- * 3 - permanently set
- * 4 - permanently reset
- */
-Terminal.prototype.requestAnsiMode = function (params) {
- ;
-};
-/**
- * CSI ? Ps$ p
- * Request DEC private mode (DECRQM). For VT300 and up, reply is
- * CSI ? Ps; Pm$ p
- * where Ps is the mode number as in DECSET, Pm is the mode value
- * as in the ANSI DECRQM.
- */
-Terminal.prototype.requestPrivateMode = function (params) {
- ;
-};
-/**
- * CSI Ps ; Ps " p
- * Set conformance level (DECSCL). Valid values for the first
- * parameter:
- * Ps = 6 1 -> VT100.
- * Ps = 6 2 -> VT200.
- * Ps = 6 3 -> VT300.
- * Valid values for the second parameter:
- * Ps = 0 -> 8-bit controls.
- * Ps = 1 -> 7-bit controls (always set for VT100).
- * Ps = 2 -> 8-bit controls.
- */
-Terminal.prototype.setConformanceLevel = function (params) {
- ;
-};
-/**
- * CSI Ps q Load LEDs (DECLL).
- * Ps = 0 -> Clear all LEDS (default).
- * Ps = 1 -> Light Num Lock.
- * Ps = 2 -> Light Caps Lock.
- * Ps = 3 -> Light Scroll Lock.
- * Ps = 2 1 -> Extinguish Num Lock.
- * Ps = 2 2 -> Extinguish Caps Lock.
- * Ps = 2 3 -> Extinguish Scroll Lock.
- */
-Terminal.prototype.loadLEDs = function (params) {
- ;
};
-/**
- * CSI Ps SP q
- * Set cursor style (DECSCUSR, VT520).
- * Ps = 0 -> blinking block.
- * Ps = 1 -> blinking block (default).
- * Ps = 2 -> steady block.
- * Ps = 3 -> blinking underline.
- * Ps = 4 -> steady underline.
- */
-Terminal.prototype.setCursorStyle = function (params) {
- ;
-};
-/**
- * CSI Ps " q
- * Select character protection attribute (DECSCA). Valid values
- * for the parameter:
- * Ps = 0 -> DECSED and DECSEL can erase (default).
- * Ps = 1 -> DECSED and DECSEL cannot erase.
- * Ps = 2 -> DECSED and DECSEL can erase.
- */
-Terminal.prototype.setCharProtectionAttr = function (params) {
- ;
-};
-/**
- * CSI ? Pm r
- * Restore DEC Private Mode Values. The value of Ps previously
- * saved is restored. Ps values are the same as for DECSET.
- */
-Terminal.prototype.restorePrivateValues = function (params) {
- ;
-};
-/**
- * CSI Pt; Pl; Pb; Pr; Ps$ r
- * Change Attributes in Rectangular Area (DECCARA), VT400 and up.
- * Pt; Pl; Pb; Pr denotes the rectangle.
- * Ps denotes the SGR attributes to change: 0, 1, 4, 5, 7.
- * NOTE: xterm doesn't enable this code by default.
- */
-Terminal.prototype.setAttrInRectangle = function (params) {
- var t = params[0], l = params[1], b = params[2], r = params[3], attr = params[4];
- var line, i;
- for (; t < b + 1; t++) {
- line = this.lines[this.ybase + t];
- for (i = l; i < r; i++) {
- line[i] = [attr, line[i][1]];
- }
- }
- // this.maxRange();
- this.updateRange(params[0]);
- this.updateRange(params[2]);
-};
-/**
- * CSI Pc; Pt; Pl; Pb; Pr$ x
- * Fill Rectangular Area (DECFRA), VT420 and up.
- * Pc is the character to use.
- * Pt; Pl; Pb; Pr denotes the rectangle.
- * NOTE: xterm doesn't enable this code by default.
- */
-Terminal.prototype.fillRectangle = function (params) {
- var ch = params[0], t = params[1], l = params[2], b = params[3], r = params[4];
- var line, i;
- for (; t < b + 1; t++) {
- line = this.lines[this.ybase + t];
- for (i = l; i < r; i++) {
- line[i] = [line[i][0], String.fromCharCode(ch)];
- }
- }
- // this.maxRange();
- this.updateRange(params[1]);
- this.updateRange(params[3]);
-};
-/**
- * CSI Ps ; Pu ' z
- * Enable Locator Reporting (DECELR).
- * Valid values for the first parameter:
- * Ps = 0 -> Locator disabled (default).
- * Ps = 1 -> Locator enabled.
- * Ps = 2 -> Locator enabled for one report, then disabled.
- * The second parameter specifies the coordinate unit for locator
- * reports.
- * Valid values for the second parameter:
- * Pu = 0 <- or omitted -> default to character cells.
- * Pu = 1 <- device physical pixels.
- * Pu = 2 <- character cells.
- */
-Terminal.prototype.enableLocatorReporting = function (params) {
- var val = params[0] > 0;
- //this.mouseEvents = val;
- //this.decLocator = val;
-};
-/**
- * CSI Pt; Pl; Pb; Pr$ z
- * Erase Rectangular Area (DECERA), VT400 and up.
- * Pt; Pl; Pb; Pr denotes the rectangle.
- * NOTE: xterm doesn't enable this code by default.
- */
-Terminal.prototype.eraseRectangle = function (params) {
- var t = params[0], l = params[1], b = params[2], r = params[3];
- var line, i, ch;
- ch = [this.eraseAttr(), ' ', 1]; // xterm?
- for (; t < b + 1; t++) {
- line = this.lines[this.ybase + t];
- for (i = l; i < r; i++) {
- line[i] = ch;
- }
- }
- // this.maxRange();
- this.updateRange(params[0]);
- this.updateRange(params[2]);
-};
-/**
- * CSI P m SP }
- * Insert P s Column(s) (default = 1) (DECIC), VT420 and up.
- * NOTE: xterm doesn't enable this code by default.
- */
-Terminal.prototype.insertColumns = function () {
- var param = params[0], l = this.ybase + this.rows, ch = [this.eraseAttr(), ' ', 1] // xterm?
- , i;
- while (param--) {
- for (i = this.ybase; i < l; i++) {
- this.lines[i].splice(this.x + 1, 0, ch);
- this.lines[i].pop();
- }
- }
- this.maxRange();
-};
-/**
- * CSI P m SP ~
- * Delete P s Column(s) (default = 1) (DECDC), VT420 and up
- * NOTE: xterm doesn't enable this code by default.
- */
-Terminal.prototype.deleteColumns = function () {
- var param = params[0], l = this.ybase + this.rows, ch = [this.eraseAttr(), ' ', 1] // xterm?
- , i;
- while (param--) {
- for (i = this.ybase; i < l; i++) {
- this.lines[i].splice(this.x, 1);
- this.lines[i].push(ch);
- }
- }
- this.maxRange();
-};
-/**
- * Character Sets
- */
-Terminal.charsets = {};
-// DEC Special Character and Line Drawing Set.
-// http://vt100.net/docs/vt102-ug/table5-13.html
-// A lot of curses apps use this if they see TERM=xterm.
-// testing: echo -e '\e(0a\e(B'
-// The xterm output sometimes seems to conflict with the
-// reference above. xterm seems in line with the reference
-// when running vttest however.
-// The table below now uses xterm's output from vttest.
-Terminal.charsets.SCLD = {
- '`': '\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' // '·'
+Terminal.prototype.tabSet = function () {
+ this.tabs[this.x] = true;
};
-Terminal.charsets.UK = null; // (A
-Terminal.charsets.US = null; // (B (USASCII)
-Terminal.charsets.Dutch = null; // (4
-Terminal.charsets.Finnish = null; // (C or (5
-Terminal.charsets.French = null; // (R
-Terminal.charsets.FrenchCanadian = null; // (Q
-Terminal.charsets.German = null; // (K
-Terminal.charsets.Italian = null; // (Y
-Terminal.charsets.NorwegianDanish = null; // (E or (6
-Terminal.charsets.Spanish = null; // (Z
-Terminal.charsets.Swedish = null; // (H or (7
-Terminal.charsets.Swiss = null; // (=
-Terminal.charsets.ISOLatin = null; // /A
-/**
- * Helpers
- */
function on(el, type, handler, capture) {
if (!Array.isArray(el)) {
el = [el];
f.prototype = parent.prototype;
child.prototype = new f;
}
-// if bold is broken, we can't
-// use it in the terminal.
-function isBoldBroken(document) {
- var body = document.getElementsByTagName('body')[0];
- var el = document.createElement('span');
- el.innerHTML = 'hello world';
- body.appendChild(el);
- var w1 = el.scrollWidth;
- el.style.fontWeight = 'bold';
- var w2 = el.scrollWidth;
- body.removeChild(el);
- return w1 !== w2;
-}
function indexOf(obj, el) {
var i = obj.length;
while (i--) {
if (ev.type == 'keypress') {
return thirdLevelKey;
}
- // Don't invoke for arrows, pageDown, home, backspace, etc. (on non-keypress events)
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] = li;
}
matchColor._cache = {};
-// http://stackoverflow.com/questions/1633828
matchColor.distance = function (r1, g1, b1, r2, g2, b2) {
return Math.pow(30 * (r1 - r2), 2)
+ Math.pow(59 * (g1 - g2), 2)
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);
}
return keys;
}
-var wcwidth = (function (opts) {
- // extracted from https://www.cl.cam.ac.uk/%7Emgk25/ucs/wcwidth.c
- // combining characters
- 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]
- ];
- // binary search
- 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) {
- // test for 8-bit control characters
- if (ucs === 0)
- return opts.nul;
- if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
- return opts.control;
- // binary search in table of non-spacing characters
- if (bisearch(ucs))
- return 0;
- // if we arrive here, ucs is not a combining or C0/C1 control character
- return 1 +
- (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 }); // configurable options
-/**
- * Expose
- */
-Terminal.EventEmitter = EventEmitter_js_1.EventEmitter;
+Terminal.EventEmitter = EventEmitter_1.EventEmitter;
Terminal.inherits = inherits;
-/**
- * Adds an event listener to the terminal.
- *
- * @param {string} event The name of the event. TODO: Document all event types
- * @param {function} callback The function to call when the event is triggered.
- */
Terminal.on = on;
Terminal.off = off;
Terminal.cancel = cancel;
module.exports = Terminal;
-},{"./CompositionHelper.js":1,"./EventEmitter.js":2,"./Viewport.js":3,"./handlers/Clipboard.js":4,"./utils/Browser":5}]},{},[7])(7)
+
+
+},{"./CompositionHelper":2,"./EscapeSequences":3,"./EventEmitter":4,"./InputHandler":5,"./Linkifier":6,"./Parser":7,"./Renderer":8,"./SelectionManager":9,"./Viewport":11,"./handlers/Clipboard":12,"./utils/Browser":13,"./utils/CharMeasure":14,"./utils/CircularList":15,"./utils/Mouse":18}]},{},[19])(19)
});
//# sourceMappingURL=xterm.js.map
projects / mirror_xterm.js.git / blobdiff