]> git.proxmox.com Git - mirror_xterm.js.git/blob - src/xterm.js
Little code clean up.
[mirror_xterm.js.git] / src / xterm.js
1 /**
2 * xterm.js: xterm, in the browser
3 * Originally forked from (with the author's permission):
4 * Fabrice Bellard's javascript vt100 for jslinux:
5 * http://bellard.org/jslinux/
6 * Copyright (c) 2011 Fabrice Bellard
7 * The original design remains. The terminal itself
8 * has been extended to include xterm CSI codes, among
9 * other features.
10 * @license MIT
11 */
12
13 import { CompositionHelper } from './CompositionHelper';
14 import { EventEmitter } from './EventEmitter';
15 import { Viewport } from './Viewport';
16 import { rightClickHandler, moveTextAreaUnderMouseCursor, pasteHandler, copyHandler } from './handlers/Clipboard';
17 import { CircularList } from './utils/CircularList';
18 import { C0 } from './EscapeSequences';
19 import { InputHandler } from './InputHandler';
20 import { Parser } from './Parser';
21 import { Renderer } from './Renderer';
22 import { Linkifier } from './Linkifier';
23 import { SelectionManager } from './SelectionManager';
24 import { CharMeasure } from './utils/CharMeasure';
25 import * as Browser from './utils/Browser';
26 import * as Mouse from './utils/Mouse';
27 import { CHARSETS } from './Charsets';
28 import { getRawByteCoords } from './utils/Mouse';
29
30 /**
31 * Terminal Emulation References:
32 * http://vt100.net/
33 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.txt
34 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
35 * http://invisible-island.net/vttest/
36 * http://www.inwap.com/pdp10/ansicode.txt
37 * http://linux.die.net/man/4/console_codes
38 * http://linux.die.net/man/7/urxvt
39 */
40
41 // Let it work inside Node.js for automated testing purposes.
42 var document = (typeof window != 'undefined') ? window.document : null;
43
44 /**
45 * The amount of write requests to queue before sending an XOFF signal to the
46 * pty process. This number must be small in order for ^C and similar sequences
47 * to be responsive.
48 */
49 var WRITE_BUFFER_PAUSE_THRESHOLD = 5;
50
51 /**
52 * The number of writes to perform in a single batch before allowing the
53 * renderer to catch up with a 0ms setTimeout.
54 */
55 var WRITE_BATCH_SIZE = 300;
56
57 /**
58 * The time between cursor blinks. This is driven by JS rather than a CSS
59 * animation due to a bug in Chromium that causes it to use excessive CPU time.
60 * See https://github.com/Microsoft/vscode/issues/22900
61 */
62 var CURSOR_BLINK_INTERVAL = 600;
63
64 /**
65 * Terminal
66 */
67
68 /**
69 * Creates a new `Terminal` object.
70 *
71 * @param {object} options An object containing a set of options, the available options are:
72 * - `cursorBlink` (boolean): Whether the terminal cursor blinks
73 * - `cols` (number): The number of columns of the terminal (horizontal size)
74 * - `rows` (number): The number of rows of the terminal (vertical size)
75 *
76 * @public
77 * @class Xterm Xterm
78 * @alias module:xterm/src/xterm
79 */
80 function Terminal(options) {
81 var self = this;
82
83 if (!(this instanceof Terminal)) {
84 return new Terminal(arguments[0], arguments[1], arguments[2]);
85 }
86
87 self.browser = Browser;
88 self.cancel = Terminal.cancel;
89
90 EventEmitter.call(this);
91
92 if (typeof options === 'number') {
93 options = {
94 cols: arguments[0],
95 rows: arguments[1],
96 handler: arguments[2]
97 };
98 }
99
100 options = options || {};
101
102
103 Object.keys(Terminal.defaults).forEach(function(key) {
104 if (options[key] == null) {
105 options[key] = Terminal.options[key];
106
107 if (Terminal[key] !== Terminal.defaults[key]) {
108 options[key] = Terminal[key];
109 }
110 }
111 self[key] = options[key];
112 });
113
114 if (options.colors.length === 8) {
115 options.colors = options.colors.concat(Terminal._colors.slice(8));
116 } else if (options.colors.length === 16) {
117 options.colors = options.colors.concat(Terminal._colors.slice(16));
118 } else if (options.colors.length === 10) {
119 options.colors = options.colors.slice(0, -2).concat(
120 Terminal._colors.slice(8, -2), options.colors.slice(-2));
121 } else if (options.colors.length === 18) {
122 options.colors = options.colors.concat(
123 Terminal._colors.slice(16, -2), options.colors.slice(-2));
124 }
125 this.colors = options.colors;
126
127 this.options = options;
128
129 // this.context = options.context || window;
130 // this.document = options.document || document;
131 this.parent = options.body || options.parent || (
132 document ? document.getElementsByTagName('body')[0] : null
133 );
134
135 this.cols = options.cols || options.geometry[0];
136 this.rows = options.rows || options.geometry[1];
137 this.geometry = [this.cols, this.rows];
138
139 if (options.handler) {
140 this.on('data', options.handler);
141 }
142
143 /**
144 * The scroll position of the y cursor, ie. ybase + y = the y position within the entire
145 * buffer
146 */
147 this.ybase = 0;
148
149 /**
150 * The scroll position of the viewport
151 */
152 this.ydisp = 0;
153
154 /**
155 * The cursor's x position after ybase
156 */
157 this.x = 0;
158
159 /**
160 * The cursor's y position after ybase
161 */
162 this.y = 0;
163
164 this.cursorState = 0;
165 this.cursorHidden = false;
166 this.convertEol;
167 this.queue = '';
168 this.scrollTop = 0;
169 this.scrollBottom = this.rows - 1;
170 this.customKeyEventHandler = null;
171 this.cursorBlinkInterval = null;
172
173 // modes
174 this.applicationKeypad = false;
175 this.applicationCursor = false;
176 this.originMode = false;
177 this.insertMode = false;
178 this.wraparoundMode = true; // defaults: xterm - true, vt100 - false
179 this.normal = null;
180
181 // charset
182 this.charset = null;
183 this.gcharset = null;
184 this.glevel = 0;
185 this.charsets = [null];
186
187 // mouse properties
188 this.decLocator;
189 this.x10Mouse;
190 this.vt200Mouse;
191 this.vt300Mouse;
192 this.normalMouse;
193 this.mouseEvents;
194 this.sendFocus;
195 this.utfMouse;
196 this.sgrMouse;
197 this.urxvtMouse;
198
199 // misc
200 this.element;
201 this.children;
202 this.refreshStart;
203 this.refreshEnd;
204 this.savedX;
205 this.savedY;
206 this.savedCols;
207
208 // stream
209 this.readable = true;
210 this.writable = true;
211
212 this.defAttr = (0 << 18) | (257 << 9) | (256 << 0);
213 this.curAttr = this.defAttr;
214
215 this.params = [];
216 this.currentParam = 0;
217 this.prefix = '';
218 this.postfix = '';
219
220 this.inputHandler = new InputHandler(this);
221 this.parser = new Parser(this.inputHandler, this);
222 // Reuse renderer if the Terminal is being recreated via a Terminal.reset call.
223 this.renderer = this.renderer || null;
224 this.selectionManager = this.selectionManager || null;
225 this.linkifier = this.linkifier || new Linkifier();
226
227 // user input states
228 this.writeBuffer = [];
229 this.writeInProgress = false;
230
231 /**
232 * Whether _xterm.js_ sent XOFF in order to catch up with the pty process.
233 * This is a distinct state from writeStopped so that if the user requested
234 * XOFF via ^S that it will not automatically resume when the writeBuffer goes
235 * below threshold.
236 */
237 this.xoffSentToCatchUp = false;
238
239 /** Whether writing has been stopped as a result of XOFF */
240 this.writeStopped = false;
241
242 // leftover surrogate high from previous write invocation
243 this.surrogate_high = '';
244
245 /**
246 * An array of all lines in the entire buffer, including the prompt. The lines are array of
247 * characters which are 2-length arrays where [0] is an attribute and [1] is the character.
248 */
249 this.lines = new CircularList(this.scrollback);
250 var i = this.rows;
251 while (i--) {
252 this.lines.push(this.blankLine());
253 }
254 // Ensure the selection manager has the correct buffer
255 if (this.selectionManager) {
256 this.selectionManager.setBuffer(this.lines);
257 }
258
259 this.tabs;
260 this.setupStops();
261
262 // Store if user went browsing history in scrollback
263 this.userScrolling = false;
264 }
265
266 inherits(Terminal, EventEmitter);
267
268 /**
269 * back_color_erase feature for xterm.
270 */
271 Terminal.prototype.eraseAttr = function() {
272 // if (this.is('screen')) return this.defAttr;
273 return (this.defAttr & ~0x1ff) | (this.curAttr & 0x1ff);
274 };
275
276 /**
277 * Colors
278 */
279
280 // Colors 0-15
281 Terminal.tangoColors = [
282 // dark:
283 '#2e3436',
284 '#cc0000',
285 '#4e9a06',
286 '#c4a000',
287 '#3465a4',
288 '#75507b',
289 '#06989a',
290 '#d3d7cf',
291 // bright:
292 '#555753',
293 '#ef2929',
294 '#8ae234',
295 '#fce94f',
296 '#729fcf',
297 '#ad7fa8',
298 '#34e2e2',
299 '#eeeeec'
300 ];
301
302 // Colors 0-15 + 16-255
303 // Much thanks to TooTallNate for writing this.
304 Terminal.colors = (function() {
305 var colors = Terminal.tangoColors.slice()
306 , r = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff]
307 , i;
308
309 // 16-231
310 i = 0;
311 for (; i < 216; i++) {
312 out(r[(i / 36) % 6 | 0], r[(i / 6) % 6 | 0], r[i % 6]);
313 }
314
315 // 232-255 (grey)
316 i = 0;
317 for (; i < 24; i++) {
318 r = 8 + i * 10;
319 out(r, r, r);
320 }
321
322 function out(r, g, b) {
323 colors.push('#' + hex(r) + hex(g) + hex(b));
324 }
325
326 function hex(c) {
327 c = c.toString(16);
328 return c.length < 2 ? '0' + c : c;
329 }
330
331 return colors;
332 })();
333
334 Terminal._colors = Terminal.colors.slice();
335
336 Terminal.vcolors = (function() {
337 var out = []
338 , colors = Terminal.colors
339 , i = 0
340 , color;
341
342 for (; i < 256; i++) {
343 color = parseInt(colors[i].substring(1), 16);
344 out.push([
345 (color >> 16) & 0xff,
346 (color >> 8) & 0xff,
347 color & 0xff
348 ]);
349 }
350
351 return out;
352 })();
353
354 /**
355 * Options
356 */
357
358 Terminal.defaults = {
359 colors: Terminal.colors,
360 theme: 'default',
361 convertEol: false,
362 termName: 'xterm',
363 geometry: [80, 24],
364 cursorBlink: false,
365 cursorStyle: 'block',
366 visualBell: false,
367 popOnBell: false,
368 scrollback: 1000,
369 screenKeys: false,
370 debug: false,
371 cancelEvents: false,
372 disableStdin: false,
373 useFlowControl: false,
374 tabStopWidth: 8
375 // programFeatures: false,
376 // focusKeys: false,
377 };
378
379 Terminal.options = {};
380
381 Terminal.focus = null;
382
383 each(keys(Terminal.defaults), function(key) {
384 Terminal[key] = Terminal.defaults[key];
385 Terminal.options[key] = Terminal.defaults[key];
386 });
387
388 /**
389 * Focus the terminal. Delegates focus handling to the terminal's DOM element.
390 */
391 Terminal.prototype.focus = function() {
392 return this.textarea.focus();
393 };
394
395 /**
396 * Retrieves an option's value from the terminal.
397 * @param {string} key The option key.
398 */
399 Terminal.prototype.getOption = function(key, value) {
400 if (!(key in Terminal.defaults)) {
401 throw new Error('No option with key "' + key + '"');
402 }
403
404 if (typeof this.options[key] !== 'undefined') {
405 return this.options[key];
406 }
407
408 return this[key];
409 };
410
411 /**
412 * Sets an option on the terminal.
413 * @param {string} key The option key.
414 * @param {string} value The option value.
415 */
416 Terminal.prototype.setOption = function(key, value) {
417 if (!(key in Terminal.defaults)) {
418 throw new Error('No option with key "' + key + '"');
419 }
420 switch (key) {
421 case 'scrollback':
422 if (this.options[key] !== value) {
423 if (this.lines.length > value) {
424 const amountToTrim = this.lines.length - value;
425 const needsRefresh = (this.ydisp - amountToTrim < 0);
426 this.lines.trimStart(amountToTrim);
427 this.ybase = Math.max(this.ybase - amountToTrim, 0);
428 this.ydisp = Math.max(this.ydisp - amountToTrim, 0);
429 if (needsRefresh) {
430 this.refresh(0, this.rows - 1);
431 }
432 }
433 this.lines.maxLength = value;
434 this.viewport.syncScrollArea();
435 }
436 break;
437 }
438 this[key] = value;
439 this.options[key] = value;
440 switch (key) {
441 case 'cursorBlink': this.setCursorBlinking(value); break;
442 case 'cursorStyle':
443 // Style 'block' applies with no class
444 this.element.classList.toggle(`xterm-cursor-style-underline`, value === 'underline');
445 this.element.classList.toggle(`xterm-cursor-style-bar`, value === 'bar');
446 break;
447 case 'tabStopWidth': this.setupStops(); break;
448 }
449 };
450
451 Terminal.prototype.restartCursorBlinking = function () {
452 this.setCursorBlinking(this.options.cursorBlink);
453 };
454
455 Terminal.prototype.setCursorBlinking = function (enabled) {
456 this.element.classList.toggle('xterm-cursor-blink', enabled);
457 this.clearCursorBlinkingInterval();
458 if (enabled) {
459 var self = this;
460 this.cursorBlinkInterval = setInterval(function () {
461 self.element.classList.toggle('xterm-cursor-blink-on');
462 }, CURSOR_BLINK_INTERVAL);
463 }
464 };
465
466 Terminal.prototype.clearCursorBlinkingInterval = function () {
467 this.element.classList.remove('xterm-cursor-blink-on');
468 if (this.cursorBlinkInterval) {
469 clearInterval(this.cursorBlinkInterval);
470 this.cursorBlinkInterval = null;
471 }
472 };
473
474 /**
475 * Binds the desired focus behavior on a given terminal object.
476 *
477 * @static
478 */
479 Terminal.bindFocus = function (term) {
480 on(term.textarea, 'focus', function (ev) {
481 if (term.sendFocus) {
482 term.send(C0.ESC + '[I');
483 }
484 term.element.classList.add('focus');
485 term.showCursor();
486 term.restartCursorBlinking.apply(term);
487 Terminal.focus = term;
488 term.emit('focus', {terminal: term});
489 });
490 };
491
492 /**
493 * Blur the terminal. Delegates blur handling to the terminal's DOM element.
494 */
495 Terminal.prototype.blur = function() {
496 return this.textarea.blur();
497 };
498
499 /**
500 * Binds the desired blur behavior on a given terminal object.
501 *
502 * @static
503 */
504 Terminal.bindBlur = function (term) {
505 on(term.textarea, 'blur', function (ev) {
506 term.refresh(term.y, term.y);
507 if (term.sendFocus) {
508 term.send(C0.ESC + '[O');
509 }
510 term.element.classList.remove('focus');
511 term.clearCursorBlinkingInterval.apply(term);
512 Terminal.focus = null;
513 term.emit('blur', {terminal: term});
514 });
515 };
516
517 /**
518 * Initialize default behavior
519 */
520 Terminal.prototype.initGlobal = function() {
521 var term = this;
522
523 Terminal.bindKeys(this);
524 Terminal.bindFocus(this);
525 Terminal.bindBlur(this);
526
527 // Bind clipboard functionality
528 on(this.element, 'copy', event => {
529 // If mouse events are active it means the selection manager is disabled and
530 // copy should be handled by the host program.
531 if (this.mouseEvents) {
532 return;
533 }
534 copyHandler(event, term, this.selectionManager);
535 });
536 const pasteHandlerWrapper = event => pasteHandler(event, term);
537 on(this.textarea, 'paste', pasteHandlerWrapper);
538 on(this.element, 'paste', pasteHandlerWrapper);
539
540 // Handle right click context menus
541 if (term.browser.isFirefox) {
542 // Firefox doesn't appear to fire the contextmenu event on right click
543 on(this.element, 'mousedown', event => {
544 if (event.button == 2) {
545 rightClickHandler(event, this.textarea, this.selectionManager);
546 }
547 });
548 } else {
549 on(this.element, 'contextmenu', event => {
550 rightClickHandler(event, this.textarea, this.selectionManager);
551 });
552 }
553
554 // Move the textarea under the cursor when middle clicking on Linux to ensure
555 // middle click to paste selection works. This only appears to work in Chrome
556 // at the time is writing.
557 if (term.browser.isLinux) {
558 // Use auxclick event over mousedown the latter doesn't seem to work. Note
559 // that the regular click event doesn't fire for the middle mouse button.
560 on(this.element, 'auxclick', event => {
561 if (event.button === 1) {
562 moveTextAreaUnderMouseCursor(event, this.textarea, this.selectionManager);
563 }
564 });
565 }
566 };
567
568 /**
569 * Apply key handling to the terminal
570 */
571 Terminal.bindKeys = function(term) {
572 on(term.element, 'keydown', function(ev) {
573 if (document.activeElement != this) {
574 return;
575 }
576 term.keyDown(ev);
577 }, true);
578
579 on(term.element, 'keypress', function(ev) {
580 if (document.activeElement != this) {
581 return;
582 }
583 term.keyPress(ev);
584 }, true);
585
586 on(term.element, 'keyup', function(ev) {
587 if (!wasMondifierKeyOnlyEvent(ev)) {
588 term.focus(term);
589 }
590 }, true);
591
592 on(term.textarea, 'keydown', function(ev) {
593 term.keyDown(ev);
594 }, true);
595
596 on(term.textarea, 'keypress', function(ev) {
597 term.keyPress(ev);
598 // Truncate the textarea's value, since it is not needed
599 this.value = '';
600 }, true);
601
602 on(term.textarea, 'compositionstart', term.compositionHelper.compositionstart.bind(term.compositionHelper));
603 on(term.textarea, 'compositionupdate', term.compositionHelper.compositionupdate.bind(term.compositionHelper));
604 on(term.textarea, 'compositionend', term.compositionHelper.compositionend.bind(term.compositionHelper));
605 term.on('refresh', term.compositionHelper.updateCompositionElements.bind(term.compositionHelper));
606 term.on('refresh', function (data) {
607 term.queueLinkification(data.start, data.end)
608 });
609 };
610
611
612 /**
613 * Insert the given row to the terminal or produce a new one
614 * if no row argument is passed. Return the inserted row.
615 * @param {HTMLElement} row (optional) The row to append to the terminal.
616 */
617 Terminal.prototype.insertRow = function (row) {
618 if (typeof row != 'object') {
619 row = document.createElement('div');
620 }
621
622 this.rowContainer.appendChild(row);
623 this.children.push(row);
624
625 return row;
626 };
627
628 /**
629 * Opens the terminal within an element.
630 *
631 * @param {HTMLElement} parent The element to create the terminal within.
632 * @param {boolean} focus Focus the terminal, after it gets instantiated in the DOM
633 */
634 Terminal.prototype.open = function(parent, focus) {
635 var self=this, i=0, div;
636
637 this.parent = parent || this.parent;
638
639 if (!this.parent) {
640 throw new Error('Terminal requires a parent element.');
641 }
642
643 // Grab global elements
644 this.context = this.parent.ownerDocument.defaultView;
645 this.document = this.parent.ownerDocument;
646 this.body = this.document.getElementsByTagName('body')[0];
647
648 //Create main element container
649 this.element = this.document.createElement('div');
650 this.element.classList.add('terminal');
651 this.element.classList.add('xterm');
652 this.element.classList.add('xterm-theme-' + this.theme);
653 this.setCursorBlinking(this.options.cursorBlink);
654
655 this.element.setAttribute('tabindex', 0);
656
657 this.viewportElement = document.createElement('div');
658 this.viewportElement.classList.add('xterm-viewport');
659 this.element.appendChild(this.viewportElement);
660 this.viewportScrollArea = document.createElement('div');
661 this.viewportScrollArea.classList.add('xterm-scroll-area');
662 this.viewportElement.appendChild(this.viewportScrollArea);
663
664 // Create the selection container.
665 this.selectionContainer = document.createElement('div');
666 this.selectionContainer.classList.add('xterm-selection');
667 this.element.appendChild(this.selectionContainer);
668
669 // Create the container that will hold the lines of the terminal and then
670 // produce the lines the lines.
671 this.rowContainer = document.createElement('div');
672 this.rowContainer.classList.add('xterm-rows');
673 this.element.appendChild(this.rowContainer);
674 this.children = [];
675 this.linkifier.attachToDom(document, this.children);
676
677 // Create the container that will hold helpers like the textarea for
678 // capturing DOM Events. Then produce the helpers.
679 this.helperContainer = document.createElement('div');
680 this.helperContainer.classList.add('xterm-helpers');
681 // TODO: This should probably be inserted once it's filled to prevent an additional layout
682 this.element.appendChild(this.helperContainer);
683 this.textarea = document.createElement('textarea');
684 this.textarea.classList.add('xterm-helper-textarea');
685 this.textarea.setAttribute('autocorrect', 'off');
686 this.textarea.setAttribute('autocapitalize', 'off');
687 this.textarea.setAttribute('spellcheck', 'false');
688 this.textarea.tabIndex = 0;
689 this.textarea.addEventListener('focus', function() {
690 self.emit('focus', {terminal: self});
691 });
692 this.textarea.addEventListener('blur', function() {
693 self.emit('blur', {terminal: self});
694 });
695 this.helperContainer.appendChild(this.textarea);
696
697 this.compositionView = document.createElement('div');
698 this.compositionView.classList.add('composition-view');
699 this.compositionHelper = new CompositionHelper(this.textarea, this.compositionView, this);
700 this.helperContainer.appendChild(this.compositionView);
701
702 this.charSizeStyleElement = document.createElement('style');
703 this.helperContainer.appendChild(this.charSizeStyleElement);
704
705 for (; i < this.rows; i++) {
706 this.insertRow();
707 }
708 this.parent.appendChild(this.element);
709
710 this.charMeasure = new CharMeasure(document, this.helperContainer);
711 this.charMeasure.on('charsizechanged', function () {
712 self.updateCharSizeStyles();
713 });
714 this.charMeasure.measure();
715
716 this.viewport = new Viewport(this, this.viewportElement, this.viewportScrollArea, this.charMeasure);
717 this.renderer = new Renderer(this);
718 this.selectionManager = new SelectionManager(this, this.lines, this.rowContainer, this.charMeasure);
719 this.selectionManager.on('refresh', data => {
720 this.renderer.refreshSelection(data.start, data.end);
721 });
722 this.selectionManager.on('newselection', text => {
723 // If there's a new selection, put it into the textarea, focus and select it
724 // in order to register it as a selection on the OS. This event is fired
725 // only on Linux to enable middle click to paste selection.
726 this.textarea.value = text;
727 this.textarea.focus();
728 this.textarea.select();
729 });
730 this.on('scroll', () => this.selectionManager.refresh());
731 this.viewportElement.addEventListener('scroll', () => this.selectionManager.refresh());
732
733 // Setup loop that draws to screen
734 this.refresh(0, this.rows - 1);
735
736 // Initialize global actions that
737 // need to be taken on the document.
738 this.initGlobal();
739
740 /**
741 * Automatic focus functionality.
742 * TODO: Default to `false` starting with xterm.js 3.0.
743 */
744 if (typeof focus == 'undefined') {
745 let message = 'You did not pass the `focus` argument in `Terminal.prototype.open()`.\n';
746
747 message += 'The `focus` argument now defaults to `true` but starting with xterm.js 3.0 ';
748 message += 'it will default to `false`.';
749
750 console.warn(message);
751 focus = true;
752 }
753
754 if (focus) {
755 this.focus();
756 }
757
758 on(this.element, 'click', function() {
759 var selection = document.getSelection(),
760 collapsed = selection.isCollapsed,
761 isRange = typeof collapsed == 'boolean' ? !collapsed : selection.type == 'Range';
762 if (!isRange) {
763 self.focus();
764 }
765 });
766
767 // Listen for mouse events and translate
768 // them into terminal mouse protocols.
769 this.bindMouse();
770
771 /**
772 * This event is emitted when terminal has completed opening.
773 *
774 * @event open
775 */
776 this.emit('open');
777 };
778
779
780 /**
781 * Attempts to load an add-on using CommonJS or RequireJS (whichever is available).
782 * @param {string} addon The name of the addon to load
783 * @static
784 */
785 Terminal.loadAddon = function(addon, callback) {
786 if (typeof exports === 'object' && typeof module === 'object') {
787 // CommonJS
788 return require('./addons/' + addon + '/' + addon);
789 } else if (typeof define == 'function') {
790 // RequireJS
791 return require(['./addons/' + addon + '/' + addon], callback);
792 } else {
793 console.error('Cannot load a module without a CommonJS or RequireJS environment.');
794 return false;
795 }
796 };
797
798 /**
799 * Updates the helper CSS class with any changes necessary after the terminal's
800 * character width has been changed.
801 */
802 Terminal.prototype.updateCharSizeStyles = function() {
803 this.charSizeStyleElement.textContent =
804 `.xterm-wide-char{width:${this.charMeasure.width * 2}px;}` +
805 `.xterm-normal-char{width:${this.charMeasure.width}px;}` +
806 `.xterm-rows > div{height:${this.charMeasure.height}px;}`;
807 }
808
809 /**
810 * XTerm mouse events
811 * http://invisible-island.net/xterm/ctlseqs/ctlseqs.html#Mouse%20Tracking
812 * To better understand these
813 * the xterm code is very helpful:
814 * Relevant files:
815 * button.c, charproc.c, misc.c
816 * Relevant functions in xterm/button.c:
817 * BtnCode, EmitButtonCode, EditorButton, SendMousePosition
818 */
819 Terminal.prototype.bindMouse = function() {
820 var el = this.element, self = this, pressed = 32;
821
822 // mouseup, mousedown, wheel
823 // left click: ^[[M 3<^[[M#3<
824 // wheel up: ^[[M`3>
825 function sendButton(ev) {
826 var button
827 , pos;
828
829 // get the xterm-style button
830 button = getButton(ev);
831
832 // get mouse coordinates
833 pos = getRawByteCoords(ev, self.rowContainer, self.charMeasure, self.cols, self.rows);
834 if (!pos) return;
835
836 sendEvent(button, pos);
837
838 switch (ev.overrideType || ev.type) {
839 case 'mousedown':
840 pressed = button;
841 break;
842 case 'mouseup':
843 // keep it at the left
844 // button, just in case.
845 pressed = 32;
846 break;
847 case 'wheel':
848 // nothing. don't
849 // interfere with
850 // `pressed`.
851 break;
852 }
853 }
854
855 // motion example of a left click:
856 // ^[[M 3<^[[M@4<^[[M@5<^[[M@6<^[[M@7<^[[M#7<
857 function sendMove(ev) {
858 var button = pressed
859 , pos;
860
861 pos = getRawByteCoords(ev, self.rowContainer, self.charMeasure, self.cols, self.rows);
862 if (!pos) return;
863
864 // buttons marked as motions
865 // are incremented by 32
866 button += 32;
867
868 sendEvent(button, pos);
869 }
870
871 // encode button and
872 // position to characters
873 function encode(data, ch) {
874 if (!self.utfMouse) {
875 if (ch === 255) return data.push(0);
876 if (ch > 127) ch = 127;
877 data.push(ch);
878 } else {
879 if (ch === 2047) return data.push(0);
880 if (ch < 127) {
881 data.push(ch);
882 } else {
883 if (ch > 2047) ch = 2047;
884 data.push(0xC0 | (ch >> 6));
885 data.push(0x80 | (ch & 0x3F));
886 }
887 }
888 }
889
890 // send a mouse event:
891 // regular/utf8: ^[[M Cb Cx Cy
892 // urxvt: ^[[ Cb ; Cx ; Cy M
893 // sgr: ^[[ Cb ; Cx ; Cy M/m
894 // vt300: ^[[ 24(1/3/5)~ [ Cx , Cy ] \r
895 // locator: CSI P e ; P b ; P r ; P c ; P p & w
896 function sendEvent(button, pos) {
897 // self.emit('mouse', {
898 // x: pos.x - 32,
899 // y: pos.x - 32,
900 // button: button
901 // });
902
903 if (self.vt300Mouse) {
904 // NOTE: Unstable.
905 // http://www.vt100.net/docs/vt3xx-gp/chapter15.html
906 button &= 3;
907 pos.x -= 32;
908 pos.y -= 32;
909 var data = C0.ESC + '[24';
910 if (button === 0) data += '1';
911 else if (button === 1) data += '3';
912 else if (button === 2) data += '5';
913 else if (button === 3) return;
914 else data += '0';
915 data += '~[' + pos.x + ',' + pos.y + ']\r';
916 self.send(data);
917 return;
918 }
919
920 if (self.decLocator) {
921 // NOTE: Unstable.
922 button &= 3;
923 pos.x -= 32;
924 pos.y -= 32;
925 if (button === 0) button = 2;
926 else if (button === 1) button = 4;
927 else if (button === 2) button = 6;
928 else if (button === 3) button = 3;
929 self.send(C0.ESC + '['
930 + button
931 + ';'
932 + (button === 3 ? 4 : 0)
933 + ';'
934 + pos.y
935 + ';'
936 + pos.x
937 + ';'
938 + (pos.page || 0)
939 + '&w');
940 return;
941 }
942
943 if (self.urxvtMouse) {
944 pos.x -= 32;
945 pos.y -= 32;
946 pos.x++;
947 pos.y++;
948 self.send(C0.ESC + '[' + button + ';' + pos.x + ';' + pos.y + 'M');
949 return;
950 }
951
952 if (self.sgrMouse) {
953 pos.x -= 32;
954 pos.y -= 32;
955 self.send(C0.ESC + '[<'
956 + (((button & 3) === 3 ? button & ~3 : button) - 32)
957 + ';'
958 + pos.x
959 + ';'
960 + pos.y
961 + ((button & 3) === 3 ? 'm' : 'M'));
962 return;
963 }
964
965 var data = [];
966
967 encode(data, button);
968 encode(data, pos.x);
969 encode(data, pos.y);
970
971 self.send(C0.ESC + '[M' + String.fromCharCode.apply(String, data));
972 }
973
974 function getButton(ev) {
975 var button
976 , shift
977 , meta
978 , ctrl
979 , mod;
980
981 // two low bits:
982 // 0 = left
983 // 1 = middle
984 // 2 = right
985 // 3 = release
986 // wheel up/down:
987 // 1, and 2 - with 64 added
988 switch (ev.overrideType || ev.type) {
989 case 'mousedown':
990 button = ev.button != null
991 ? +ev.button
992 : ev.which != null
993 ? ev.which - 1
994 : null;
995
996 if (self.browser.isMSIE) {
997 button = button === 1 ? 0 : button === 4 ? 1 : button;
998 }
999 break;
1000 case 'mouseup':
1001 button = 3;
1002 break;
1003 case 'DOMMouseScroll':
1004 button = ev.detail < 0
1005 ? 64
1006 : 65;
1007 break;
1008 case 'wheel':
1009 button = ev.wheelDeltaY > 0
1010 ? 64
1011 : 65;
1012 break;
1013 }
1014
1015 // next three bits are the modifiers:
1016 // 4 = shift, 8 = meta, 16 = control
1017 shift = ev.shiftKey ? 4 : 0;
1018 meta = ev.metaKey ? 8 : 0;
1019 ctrl = ev.ctrlKey ? 16 : 0;
1020 mod = shift | meta | ctrl;
1021
1022 // no mods
1023 if (self.vt200Mouse) {
1024 // ctrl only
1025 mod &= ctrl;
1026 } else if (!self.normalMouse) {
1027 mod = 0;
1028 }
1029
1030 // increment to SP
1031 button = (32 + (mod << 2)) + button;
1032
1033 return button;
1034 }
1035
1036 on(el, 'mousedown', function(ev) {
1037 if (!self.mouseEvents) return;
1038
1039 // send the button
1040 sendButton(ev);
1041
1042 // ensure focus
1043 self.focus();
1044
1045 // fix for odd bug
1046 //if (self.vt200Mouse && !self.normalMouse) {
1047 if (self.vt200Mouse) {
1048 ev.overrideType = 'mouseup';
1049 sendButton(ev);
1050 return self.cancel(ev);
1051 }
1052
1053 // bind events
1054 if (self.normalMouse) on(self.document, 'mousemove', sendMove);
1055
1056 // x10 compatibility mode can't send button releases
1057 if (!self.x10Mouse) {
1058 on(self.document, 'mouseup', function up(ev) {
1059 sendButton(ev);
1060 if (self.normalMouse) off(self.document, 'mousemove', sendMove);
1061 off(self.document, 'mouseup', up);
1062 return self.cancel(ev);
1063 });
1064 }
1065
1066 return self.cancel(ev);
1067 });
1068
1069 //if (self.normalMouse) {
1070 // on(self.document, 'mousemove', sendMove);
1071 //}
1072
1073 on(el, 'wheel', function(ev) {
1074 if (!self.mouseEvents) return;
1075 if (self.x10Mouse
1076 || self.vt300Mouse
1077 || self.decLocator) return;
1078 sendButton(ev);
1079 return self.cancel(ev);
1080 });
1081
1082 // allow wheel scrolling in
1083 // the shell for example
1084 on(el, 'wheel', function(ev) {
1085 if (self.mouseEvents) return;
1086 self.viewport.onWheel(ev);
1087 return self.cancel(ev);
1088 });
1089 };
1090
1091 /**
1092 * Destroys the terminal.
1093 */
1094 Terminal.prototype.destroy = function() {
1095 this.readable = false;
1096 this.writable = false;
1097 this._events = {};
1098 this.handler = function() {};
1099 this.write = function() {};
1100 if (this.element && this.element.parentNode) {
1101 this.element.parentNode.removeChild(this.element);
1102 }
1103 //this.emit('close');
1104 };
1105
1106 /**
1107 * Tells the renderer to refresh terminal content between two rows (inclusive) at the next
1108 * opportunity.
1109 * @param {number} start The row to start from (between 0 and this.rows - 1).
1110 * @param {number} end The row to end at (between start and this.rows - 1).
1111 */
1112 Terminal.prototype.refresh = function(start, end) {
1113 if (this.renderer) {
1114 this.renderer.queueRefresh(start, end);
1115 }
1116 };
1117
1118 /**
1119 * Queues linkification for the specified rows.
1120 * @param {number} start The row to start from (between 0 and this.rows - 1).
1121 * @param {number} end The row to end at (between start and this.rows - 1).
1122 */
1123 Terminal.prototype.queueLinkification = function(start, end) {
1124 if (this.linkifier) {
1125 for (let i = start; i <= end; i++) {
1126 this.linkifier.linkifyRow(i);
1127 }
1128 }
1129 };
1130
1131 /**
1132 * Display the cursor element
1133 */
1134 Terminal.prototype.showCursor = function() {
1135 if (!this.cursorState) {
1136 this.cursorState = 1;
1137 this.refresh(this.y, this.y);
1138 }
1139 };
1140
1141 /**
1142 * Scroll the terminal down 1 row, creating a blank line.
1143 * @param {boolean} isWrapped Whether the new line is wrapped from the previous
1144 * line.
1145 */
1146 Terminal.prototype.scroll = function(isWrapped) {
1147 var row;
1148
1149 // Make room for the new row in lines
1150 if (this.lines.length === this.lines.maxLength) {
1151 this.lines.trimStart(1);
1152 this.ybase--;
1153 if (this.ydisp !== 0) {
1154 this.ydisp--;
1155 }
1156 }
1157
1158 this.ybase++;
1159
1160 // TODO: Why is this done twice?
1161 if (!this.userScrolling) {
1162 this.ydisp = this.ybase;
1163 }
1164
1165 // last line
1166 row = this.ybase + this.rows - 1;
1167
1168 // subtract the bottom scroll region
1169 row -= this.rows - 1 - this.scrollBottom;
1170
1171 if (row === this.lines.length) {
1172 // Optimization: pushing is faster than splicing when they amount to the same behavior
1173 this.lines.push(this.blankLine(undefined, isWrapped));
1174 } else {
1175 // add our new line
1176 this.lines.splice(row, 0, this.blankLine(undefined, isWrapped));
1177 }
1178
1179 if (this.scrollTop !== 0) {
1180 if (this.ybase !== 0) {
1181 this.ybase--;
1182 if (!this.userScrolling) {
1183 this.ydisp = this.ybase;
1184 }
1185 }
1186 this.lines.splice(this.ybase + this.scrollTop, 1);
1187 }
1188
1189 // this.maxRange();
1190 this.updateRange(this.scrollTop);
1191 this.updateRange(this.scrollBottom);
1192
1193 /**
1194 * This event is emitted whenever the terminal is scrolled.
1195 * The one parameter passed is the new y display position.
1196 *
1197 * @event scroll
1198 */
1199 this.emit('scroll', this.ydisp);
1200 };
1201
1202 /**
1203 * Scroll the display of the terminal
1204 * @param {number} disp The number of lines to scroll down (negatives scroll up).
1205 * @param {boolean} suppressScrollEvent Don't emit the scroll event as scrollDisp. This is used
1206 * to avoid unwanted events being handled by the veiwport when the event was triggered from the
1207 * viewport originally.
1208 */
1209 Terminal.prototype.scrollDisp = function(disp, suppressScrollEvent) {
1210 if (disp < 0) {
1211 if (this.ydisp === 0) {
1212 return;
1213 }
1214 this.userScrolling = true;
1215 } else if (disp + this.ydisp >= this.ybase) {
1216 this.userScrolling = false;
1217 }
1218
1219 this.ydisp += disp;
1220
1221 if (this.ydisp > this.ybase) {
1222 this.ydisp = this.ybase;
1223 } else if (this.ydisp < 0) {
1224 this.ydisp = 0;
1225 }
1226
1227 if (!suppressScrollEvent) {
1228 this.emit('scroll', this.ydisp);
1229 }
1230
1231 this.refresh(0, this.rows - 1);
1232 };
1233
1234 /**
1235 * Scroll the display of the terminal by a number of pages.
1236 * @param {number} pageCount The number of pages to scroll (negative scrolls up).
1237 */
1238 Terminal.prototype.scrollPages = function(pageCount) {
1239 this.scrollDisp(pageCount * (this.rows - 1));
1240 };
1241
1242 /**
1243 * Scrolls the display of the terminal to the top.
1244 */
1245 Terminal.prototype.scrollToTop = function() {
1246 this.scrollDisp(-this.ydisp);
1247 };
1248
1249 /**
1250 * Scrolls the display of the terminal to the bottom.
1251 */
1252 Terminal.prototype.scrollToBottom = function() {
1253 this.scrollDisp(this.ybase - this.ydisp);
1254 };
1255
1256 /**
1257 * Writes text to the terminal.
1258 * @param {string} data The text to write to the terminal.
1259 */
1260 Terminal.prototype.write = function(data) {
1261 this.writeBuffer.push(data);
1262
1263 // Send XOFF to pause the pty process if the write buffer becomes too large so
1264 // xterm.js can catch up before more data is sent. This is necessary in order
1265 // to keep signals such as ^C responsive.
1266 if (this.options.useFlowControl && !this.xoffSentToCatchUp && this.writeBuffer.length >= WRITE_BUFFER_PAUSE_THRESHOLD) {
1267 // XOFF - stop pty pipe
1268 // XON will be triggered by emulator before processing data chunk
1269 this.send(C0.DC3);
1270 this.xoffSentToCatchUp = true;
1271 }
1272
1273 if (!this.writeInProgress && this.writeBuffer.length > 0) {
1274 // Kick off a write which will write all data in sequence recursively
1275 this.writeInProgress = true;
1276 // Kick off an async innerWrite so more writes can come in while processing data
1277 var self = this;
1278 setTimeout(function () {
1279 self.innerWrite();
1280 });
1281 }
1282 };
1283
1284 Terminal.prototype.innerWrite = function() {
1285 var writeBatch = this.writeBuffer.splice(0, WRITE_BATCH_SIZE);
1286 while (writeBatch.length > 0) {
1287 var data = writeBatch.shift();
1288 var l = data.length, i = 0, j, cs, ch, code, low, ch_width, row;
1289
1290 // If XOFF was sent in order to catch up with the pty process, resume it if
1291 // the writeBuffer is empty to allow more data to come in.
1292 if (this.xoffSentToCatchUp && writeBatch.length === 0 && this.writeBuffer.length === 0) {
1293 this.send(C0.DC1);
1294 this.xoffSentToCatchUp = false;
1295 }
1296
1297 this.refreshStart = this.y;
1298 this.refreshEnd = this.y;
1299
1300 // HACK: Set the parser state based on it's state at the time of return.
1301 // This works around the bug #662 which saw the parser state reset in the
1302 // middle of parsing escape sequence in two chunks. For some reason the
1303 // state of the parser resets to 0 after exiting parser.parse. This change
1304 // just sets the state back based on the correct return statement.
1305 var state = this.parser.parse(data);
1306 this.parser.setState(state);
1307
1308 this.updateRange(this.y);
1309 this.refresh(this.refreshStart, this.refreshEnd);
1310 }
1311 if (this.writeBuffer.length > 0) {
1312 // Allow renderer to catch up before processing the next batch
1313 var self = this;
1314 setTimeout(function () {
1315 self.innerWrite();
1316 }, 0);
1317 } else {
1318 this.writeInProgress = false;
1319 }
1320 };
1321
1322 /**
1323 * Writes text to the terminal, followed by a break line character (\n).
1324 * @param {string} data The text to write to the terminal.
1325 */
1326 Terminal.prototype.writeln = function(data) {
1327 this.write(data + '\r\n');
1328 };
1329
1330 /**
1331 * DEPRECATED: only for backward compatibility. Please use attachCustomKeyEventHandler() instead.
1332 * @param {function} customKeydownHandler The custom KeyboardEvent handler to attach. This is a
1333 * function that takes a KeyboardEvent, allowing consumers to stop propogation and/or prevent
1334 * the default action. The function returns whether the event should be processed by xterm.js.
1335 */
1336 Terminal.prototype.attachCustomKeydownHandler = function(customKeydownHandler) {
1337 let message = 'attachCustomKeydownHandler() is DEPRECATED and will be removed soon. Please use attachCustomKeyEventHandler() instead.';
1338 console.warn(message);
1339 this.attachCustomKeyEventHandler(customKeydownHandler);
1340 };
1341
1342 /**
1343 * Attaches a custom key event handler which is run before keys are processed, giving consumers of
1344 * xterm.js ultimate control as to what keys should be processed by the terminal and what keys
1345 * should not.
1346 * @param {function} customKeyEventHandler The custom KeyboardEvent handler to attach. This is a
1347 * function that takes a KeyboardEvent, allowing consumers to stop propogation and/or prevent
1348 * the default action. The function returns whether the event should be processed by xterm.js.
1349 */
1350 Terminal.prototype.attachCustomKeyEventHandler = function(customKeyEventHandler) {
1351 this.customKeyEventHandler = customKeyEventHandler;
1352 };
1353
1354 /**
1355 * Attaches a http(s) link handler, forcing web links to behave differently to
1356 * regular <a> tags. This will trigger a refresh as links potentially need to be
1357 * reconstructed. Calling this with null will remove the handler.
1358 * @param {handler} handler The handler callback function.
1359 */
1360 Terminal.prototype.setHypertextLinkHandler = function(handler) {
1361 if (!this.linkifier) {
1362 throw new Error('Cannot attach a hypertext link handler before Terminal.open is called');
1363 }
1364 this.linkifier.setHypertextLinkHandler(handler);
1365 // Refresh to force links to refresh
1366 this.refresh(0, this.rows - 1);
1367 };
1368
1369 /**
1370 * Attaches a validation callback for hypertext links. This is useful to use
1371 * validation logic or to do something with the link's element and url.
1372 * @param {LinkMatcherValidationCallback} handler The callback to use, this can
1373 * be cleared with null.
1374 */
1375 Terminal.prototype.setHypertextValidationCallback = function(handler) {
1376 if (!this.linkifier) {
1377 throw new Error('Cannot attach a hypertext validation callback before Terminal.open is called');
1378 }
1379 this.linkifier.setHypertextValidationCallback(handler);
1380 // Refresh to force links to refresh
1381 this.refresh(0, this.rows - 1);
1382 };
1383
1384 /**
1385 * Registers a link matcher, allowing custom link patterns to be matched and
1386 * handled.
1387 * @param {RegExp} regex The regular expression to search for, specifically
1388 * this searches the textContent of the rows. You will want to use \s to match
1389 * a space ' ' character for example.
1390 * @param {handler} handler The callback when the link is called.
1391 * @param {LinkMatcherOptions} [options] Options for the link matcher.
1392 * @return {number} The ID of the new matcher, this can be used to deregister.
1393 */
1394 Terminal.prototype.registerLinkMatcher = function(regex, handler, options) {
1395 if (this.linkifier) {
1396 var matcherId = this.linkifier.registerLinkMatcher(regex, handler, options);
1397 this.refresh(0, this.rows - 1);
1398 return matcherId;
1399 }
1400 };
1401
1402 /**
1403 * Deregisters a link matcher if it has been registered.
1404 * @param {number} matcherId The link matcher's ID (returned after register)
1405 */
1406 Terminal.prototype.deregisterLinkMatcher = function(matcherId) {
1407 if (this.linkifier) {
1408 if (this.linkifier.deregisterLinkMatcher(matcherId)) {
1409 this.refresh(0, this.rows - 1);
1410 }
1411 }
1412 };
1413
1414 /**
1415 * Gets whether the terminal has an active selection.
1416 */
1417 Terminal.prototype.hasSelection = function() {
1418 return this.selectionManager.hasSelection;
1419 };
1420
1421 /**
1422 * Gets the terminal's current selection, this is useful for implementing copy
1423 * behavior outside of xterm.js.
1424 */
1425 Terminal.prototype.getSelection = function() {
1426 return this.selectionManager.selectionText;
1427 };
1428
1429 /**
1430 * Clears the current terminal selection.
1431 */
1432 Terminal.prototype.clearSelection = function() {
1433 this.selectionManager.clearSelection();
1434 };
1435
1436 /**
1437 * Selects all text within the terminal.
1438 */
1439 Terminal.prototype.selectAll = function() {
1440 this.selectionManager.selectAll();
1441 };
1442
1443 /**
1444 * Handle a keydown event
1445 * Key Resources:
1446 * - https://developer.mozilla.org/en-US/docs/DOM/KeyboardEvent
1447 * @param {KeyboardEvent} ev The keydown event to be handled.
1448 */
1449 Terminal.prototype.keyDown = function(ev) {
1450 if (this.customKeyEventHandler && this.customKeyEventHandler(ev) === false) {
1451 return false;
1452 }
1453
1454 this.restartCursorBlinking();
1455
1456 if (!this.compositionHelper.keydown.bind(this.compositionHelper)(ev)) {
1457 if (this.ybase !== this.ydisp) {
1458 this.scrollToBottom();
1459 }
1460 return false;
1461 }
1462
1463 var self = this;
1464 var result = this.evaluateKeyEscapeSequence(ev);
1465
1466 if (result.key === C0.DC3) { // XOFF
1467 this.writeStopped = true;
1468 } else if (result.key === C0.DC1) { // XON
1469 this.writeStopped = false;
1470 }
1471
1472 if (result.scrollDisp) {
1473 this.scrollDisp(result.scrollDisp);
1474 return this.cancel(ev, true);
1475 }
1476
1477 if (isThirdLevelShift(this, ev)) {
1478 return true;
1479 }
1480
1481 if (result.cancel) {
1482 // The event is canceled at the end already, is this necessary?
1483 this.cancel(ev, true);
1484 }
1485
1486 if (!result.key) {
1487 return true;
1488 }
1489
1490 this.emit('keydown', ev);
1491 this.emit('key', result.key, ev);
1492 this.showCursor();
1493 this.handler(result.key);
1494
1495 return this.cancel(ev, true);
1496 };
1497
1498 /**
1499 * Returns an object that determines how a KeyboardEvent should be handled. The key of the
1500 * returned value is the new key code to pass to the PTY.
1501 *
1502 * Reference: http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
1503 * @param {KeyboardEvent} ev The keyboard event to be translated to key escape sequence.
1504 */
1505 Terminal.prototype.evaluateKeyEscapeSequence = function(ev) {
1506 var result = {
1507 // Whether to cancel event propogation (NOTE: this may not be needed since the event is
1508 // canceled at the end of keyDown
1509 cancel: false,
1510 // The new key even to emit
1511 key: undefined,
1512 // The number of characters to scroll, if this is defined it will cancel the event
1513 scrollDisp: undefined
1514 };
1515 var modifiers = ev.shiftKey << 0 | ev.altKey << 1 | ev.ctrlKey << 2 | ev.metaKey << 3;
1516 switch (ev.keyCode) {
1517 case 8:
1518 // backspace
1519 if (ev.shiftKey) {
1520 result.key = C0.BS; // ^H
1521 break;
1522 }
1523 result.key = C0.DEL; // ^?
1524 break;
1525 case 9:
1526 // tab
1527 if (ev.shiftKey) {
1528 result.key = C0.ESC + '[Z';
1529 break;
1530 }
1531 result.key = C0.HT;
1532 result.cancel = true;
1533 break;
1534 case 13:
1535 // return/enter
1536 result.key = C0.CR;
1537 result.cancel = true;
1538 break;
1539 case 27:
1540 // escape
1541 result.key = C0.ESC;
1542 result.cancel = true;
1543 break;
1544 case 37:
1545 // left-arrow
1546 if (modifiers) {
1547 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'D';
1548 // HACK: Make Alt + left-arrow behave like Ctrl + left-arrow: move one word backwards
1549 // http://unix.stackexchange.com/a/108106
1550 // macOS uses different escape sequences than linux
1551 if (result.key == C0.ESC + '[1;3D') {
1552 result.key = (this.browser.isMac) ? C0.ESC + 'b' : C0.ESC + '[1;5D';
1553 }
1554 } else if (this.applicationCursor) {
1555 result.key = C0.ESC + 'OD';
1556 } else {
1557 result.key = C0.ESC + '[D';
1558 }
1559 break;
1560 case 39:
1561 // right-arrow
1562 if (modifiers) {
1563 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'C';
1564 // HACK: Make Alt + right-arrow behave like Ctrl + right-arrow: move one word forward
1565 // http://unix.stackexchange.com/a/108106
1566 // macOS uses different escape sequences than linux
1567 if (result.key == C0.ESC + '[1;3C') {
1568 result.key = (this.browser.isMac) ? C0.ESC + 'f' : C0.ESC + '[1;5C';
1569 }
1570 } else if (this.applicationCursor) {
1571 result.key = C0.ESC + 'OC';
1572 } else {
1573 result.key = C0.ESC + '[C';
1574 }
1575 break;
1576 case 38:
1577 // up-arrow
1578 if (modifiers) {
1579 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'A';
1580 // HACK: Make Alt + up-arrow behave like Ctrl + up-arrow
1581 // http://unix.stackexchange.com/a/108106
1582 if (result.key == C0.ESC + '[1;3A') {
1583 result.key = C0.ESC + '[1;5A';
1584 }
1585 } else if (this.applicationCursor) {
1586 result.key = C0.ESC + 'OA';
1587 } else {
1588 result.key = C0.ESC + '[A';
1589 }
1590 break;
1591 case 40:
1592 // down-arrow
1593 if (modifiers) {
1594 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'B';
1595 // HACK: Make Alt + down-arrow behave like Ctrl + down-arrow
1596 // http://unix.stackexchange.com/a/108106
1597 if (result.key == C0.ESC + '[1;3B') {
1598 result.key = C0.ESC + '[1;5B';
1599 }
1600 } else if (this.applicationCursor) {
1601 result.key = C0.ESC + 'OB';
1602 } else {
1603 result.key = C0.ESC + '[B';
1604 }
1605 break;
1606 case 45:
1607 // insert
1608 if (!ev.shiftKey && !ev.ctrlKey) {
1609 // <Ctrl> or <Shift> + <Insert> are used to
1610 // copy-paste on some systems.
1611 result.key = C0.ESC + '[2~';
1612 }
1613 break;
1614 case 46:
1615 // delete
1616 if (modifiers) {
1617 result.key = C0.ESC + '[3;' + (modifiers + 1) + '~';
1618 } else {
1619 result.key = C0.ESC + '[3~';
1620 }
1621 break;
1622 case 36:
1623 // home
1624 if (modifiers)
1625 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'H';
1626 else if (this.applicationCursor)
1627 result.key = C0.ESC + 'OH';
1628 else
1629 result.key = C0.ESC + '[H';
1630 break;
1631 case 35:
1632 // end
1633 if (modifiers)
1634 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'F';
1635 else if (this.applicationCursor)
1636 result.key = C0.ESC + 'OF';
1637 else
1638 result.key = C0.ESC + '[F';
1639 break;
1640 case 33:
1641 // page up
1642 if (ev.shiftKey) {
1643 result.scrollDisp = -(this.rows - 1);
1644 } else {
1645 result.key = C0.ESC + '[5~';
1646 }
1647 break;
1648 case 34:
1649 // page down
1650 if (ev.shiftKey) {
1651 result.scrollDisp = this.rows - 1;
1652 } else {
1653 result.key = C0.ESC + '[6~';
1654 }
1655 break;
1656 case 112:
1657 // F1-F12
1658 if (modifiers) {
1659 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'P';
1660 } else {
1661 result.key = C0.ESC + 'OP';
1662 }
1663 break;
1664 case 113:
1665 if (modifiers) {
1666 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'Q';
1667 } else {
1668 result.key = C0.ESC + 'OQ';
1669 }
1670 break;
1671 case 114:
1672 if (modifiers) {
1673 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'R';
1674 } else {
1675 result.key = C0.ESC + 'OR';
1676 }
1677 break;
1678 case 115:
1679 if (modifiers) {
1680 result.key = C0.ESC + '[1;' + (modifiers + 1) + 'S';
1681 } else {
1682 result.key = C0.ESC + 'OS';
1683 }
1684 break;
1685 case 116:
1686 if (modifiers) {
1687 result.key = C0.ESC + '[15;' + (modifiers + 1) + '~';
1688 } else {
1689 result.key = C0.ESC + '[15~';
1690 }
1691 break;
1692 case 117:
1693 if (modifiers) {
1694 result.key = C0.ESC + '[17;' + (modifiers + 1) + '~';
1695 } else {
1696 result.key = C0.ESC + '[17~';
1697 }
1698 break;
1699 case 118:
1700 if (modifiers) {
1701 result.key = C0.ESC + '[18;' + (modifiers + 1) + '~';
1702 } else {
1703 result.key = C0.ESC + '[18~';
1704 }
1705 break;
1706 case 119:
1707 if (modifiers) {
1708 result.key = C0.ESC + '[19;' + (modifiers + 1) + '~';
1709 } else {
1710 result.key = C0.ESC + '[19~';
1711 }
1712 break;
1713 case 120:
1714 if (modifiers) {
1715 result.key = C0.ESC + '[20;' + (modifiers + 1) + '~';
1716 } else {
1717 result.key = C0.ESC + '[20~';
1718 }
1719 break;
1720 case 121:
1721 if (modifiers) {
1722 result.key = C0.ESC + '[21;' + (modifiers + 1) + '~';
1723 } else {
1724 result.key = C0.ESC + '[21~';
1725 }
1726 break;
1727 case 122:
1728 if (modifiers) {
1729 result.key = C0.ESC + '[23;' + (modifiers + 1) + '~';
1730 } else {
1731 result.key = C0.ESC + '[23~';
1732 }
1733 break;
1734 case 123:
1735 if (modifiers) {
1736 result.key = C0.ESC + '[24;' + (modifiers + 1) + '~';
1737 } else {
1738 result.key = C0.ESC + '[24~';
1739 }
1740 break;
1741 default:
1742 // a-z and space
1743 if (ev.ctrlKey && !ev.shiftKey && !ev.altKey && !ev.metaKey) {
1744 if (ev.keyCode >= 65 && ev.keyCode <= 90) {
1745 result.key = String.fromCharCode(ev.keyCode - 64);
1746 } else if (ev.keyCode === 32) {
1747 // NUL
1748 result.key = String.fromCharCode(0);
1749 } else if (ev.keyCode >= 51 && ev.keyCode <= 55) {
1750 // escape, file sep, group sep, record sep, unit sep
1751 result.key = String.fromCharCode(ev.keyCode - 51 + 27);
1752 } else if (ev.keyCode === 56) {
1753 // delete
1754 result.key = String.fromCharCode(127);
1755 } else if (ev.keyCode === 219) {
1756 // ^[ - Control Sequence Introducer (CSI)
1757 result.key = String.fromCharCode(27);
1758 } else if (ev.keyCode === 220) {
1759 // ^\ - String Terminator (ST)
1760 result.key = String.fromCharCode(28);
1761 } else if (ev.keyCode === 221) {
1762 // ^] - Operating System Command (OSC)
1763 result.key = String.fromCharCode(29);
1764 }
1765 } else if (!this.browser.isMac && ev.altKey && !ev.ctrlKey && !ev.metaKey) {
1766 // On Mac this is a third level shift. Use <Esc> instead.
1767 if (ev.keyCode >= 65 && ev.keyCode <= 90) {
1768 result.key = C0.ESC + String.fromCharCode(ev.keyCode + 32);
1769 } else if (ev.keyCode === 192) {
1770 result.key = C0.ESC + '`';
1771 } else if (ev.keyCode >= 48 && ev.keyCode <= 57) {
1772 result.key = C0.ESC + (ev.keyCode - 48);
1773 }
1774 } else if (this.browser.isMac && !ev.altKey && !ev.ctrlKey && ev.metaKey) {
1775 if (ev.keyCode === 65) { // cmd + a
1776 this.selectAll();
1777 }
1778 }
1779 break;
1780 }
1781
1782 return result;
1783 };
1784
1785 /**
1786 * Set the G level of the terminal
1787 * @param g
1788 */
1789 Terminal.prototype.setgLevel = function(g) {
1790 this.glevel = g;
1791 this.charset = this.charsets[g];
1792 };
1793
1794 /**
1795 * Set the charset for the given G level of the terminal
1796 * @param g
1797 * @param charset
1798 */
1799 Terminal.prototype.setgCharset = function(g, charset) {
1800 this.charsets[g] = charset;
1801 if (this.glevel === g) {
1802 this.charset = charset;
1803 }
1804 };
1805
1806 /**
1807 * Handle a keypress event.
1808 * Key Resources:
1809 * - https://developer.mozilla.org/en-US/docs/DOM/KeyboardEvent
1810 * @param {KeyboardEvent} ev The keypress event to be handled.
1811 */
1812 Terminal.prototype.keyPress = function(ev) {
1813 var key;
1814
1815 if (this.customKeyEventHandler && this.customKeyEventHandler(ev) === false) {
1816 return false;
1817 }
1818
1819 this.cancel(ev);
1820
1821 if (ev.charCode) {
1822 key = ev.charCode;
1823 } else if (ev.which == null) {
1824 key = ev.keyCode;
1825 } else if (ev.which !== 0 && ev.charCode !== 0) {
1826 key = ev.which;
1827 } else {
1828 return false;
1829 }
1830
1831 if (!key || (
1832 (ev.altKey || ev.ctrlKey || ev.metaKey) && !isThirdLevelShift(this, ev)
1833 )) {
1834 return false;
1835 }
1836
1837 key = String.fromCharCode(key);
1838
1839 this.emit('keypress', key, ev);
1840 this.emit('key', key, ev);
1841 this.showCursor();
1842 this.handler(key);
1843
1844 return true;
1845 };
1846
1847 /**
1848 * Send data for handling to the terminal
1849 * @param {string} data
1850 */
1851 Terminal.prototype.send = function(data) {
1852 var self = this;
1853
1854 if (!this.queue) {
1855 setTimeout(function() {
1856 self.handler(self.queue);
1857 self.queue = '';
1858 }, 1);
1859 }
1860
1861 this.queue += data;
1862 };
1863
1864 /**
1865 * Ring the bell.
1866 * Note: We could do sweet things with webaudio here
1867 */
1868 Terminal.prototype.bell = function() {
1869 if (!this.visualBell) return;
1870 var self = this;
1871 this.element.style.borderColor = 'white';
1872 setTimeout(function() {
1873 self.element.style.borderColor = '';
1874 }, 10);
1875 if (this.popOnBell) this.focus();
1876 };
1877
1878 /**
1879 * Log the current state to the console.
1880 */
1881 Terminal.prototype.log = function() {
1882 if (!this.debug) return;
1883 if (!this.context.console || !this.context.console.log) return;
1884 var args = Array.prototype.slice.call(arguments);
1885 this.context.console.log.apply(this.context.console, args);
1886 };
1887
1888 /**
1889 * Log the current state as error to the console.
1890 */
1891 Terminal.prototype.error = function() {
1892 if (!this.debug) return;
1893 if (!this.context.console || !this.context.console.error) return;
1894 var args = Array.prototype.slice.call(arguments);
1895 this.context.console.error.apply(this.context.console, args);
1896 };
1897
1898 /**
1899 * Resizes the terminal.
1900 *
1901 * @param {number} x The number of columns to resize to.
1902 * @param {number} y The number of rows to resize to.
1903 */
1904 Terminal.prototype.resize = function(x, y) {
1905 if (isNaN(x) || isNaN(y)) {
1906 return;
1907 }
1908
1909 var line
1910 , el
1911 , i
1912 , j
1913 , ch
1914 , addToY;
1915
1916 if (x === this.cols && y === this.rows) {
1917 return;
1918 }
1919
1920 if (x < 1) x = 1;
1921 if (y < 1) y = 1;
1922
1923 // resize cols
1924 j = this.cols;
1925 if (j < x) {
1926 ch = [this.defAttr, ' ', 1]; // does xterm use the default attr?
1927 i = this.lines.length;
1928 while (i--) {
1929 while (this.lines.get(i).length < x) {
1930 this.lines.get(i).push(ch);
1931 }
1932 }
1933 }
1934
1935 this.cols = x;
1936 this.setupStops(this.cols);
1937
1938 // resize rows
1939 j = this.rows;
1940 addToY = 0;
1941 if (j < y) {
1942 el = this.element;
1943 while (j++ < y) {
1944 // y is rows, not this.y
1945 if (this.lines.length < y + this.ybase) {
1946 if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) {
1947 // There is room above the buffer and there are no empty elements below the line,
1948 // scroll up
1949 this.ybase--;
1950 addToY++;
1951 if (this.ydisp > 0) {
1952 // Viewport is at the top of the buffer, must increase downwards
1953 this.ydisp--;
1954 }
1955 } else {
1956 // Add a blank line if there is no buffer left at the top to scroll to, or if there
1957 // are blank lines after the cursor
1958 this.lines.push(this.blankLine());
1959 }
1960 }
1961 if (this.children.length < y) {
1962 this.insertRow();
1963 }
1964 }
1965 } else { // (j > y)
1966 while (j-- > y) {
1967 if (this.lines.length > y + this.ybase) {
1968 if (this.lines.length > this.ybase + this.y + 1) {
1969 // The line is a blank line below the cursor, remove it
1970 this.lines.pop();
1971 } else {
1972 // The line is the cursor, scroll down
1973 this.ybase++;
1974 this.ydisp++;
1975 }
1976 }
1977 if (this.children.length > y) {
1978 el = this.children.shift();
1979 if (!el) continue;
1980 el.parentNode.removeChild(el);
1981 }
1982 }
1983 }
1984 this.rows = y;
1985
1986 // Make sure that the cursor stays on screen
1987 if (this.y >= y) {
1988 this.y = y - 1;
1989 }
1990 if (addToY) {
1991 this.y += addToY;
1992 }
1993
1994 if (this.x >= x) {
1995 this.x = x - 1;
1996 }
1997
1998 this.scrollTop = 0;
1999 this.scrollBottom = y - 1;
2000
2001 this.charMeasure.measure();
2002
2003 this.refresh(0, this.rows - 1);
2004
2005 this.normal = null;
2006
2007 this.geometry = [this.cols, this.rows];
2008 this.emit('resize', {terminal: this, cols: x, rows: y});
2009 };
2010
2011 /**
2012 * Updates the range of rows to refresh
2013 * @param {number} y The number of rows to refresh next.
2014 */
2015 Terminal.prototype.updateRange = function(y) {
2016 if (y < this.refreshStart) this.refreshStart = y;
2017 if (y > this.refreshEnd) this.refreshEnd = y;
2018 // if (y > this.refreshEnd) {
2019 // this.refreshEnd = y;
2020 // if (y > this.rows - 1) {
2021 // this.refreshEnd = this.rows - 1;
2022 // }
2023 // }
2024 };
2025
2026 /**
2027 * Set the range of refreshing to the maximum value
2028 */
2029 Terminal.prototype.maxRange = function() {
2030 this.refreshStart = 0;
2031 this.refreshEnd = this.rows - 1;
2032 };
2033
2034
2035
2036 /**
2037 * Setup the tab stops.
2038 * @param {number} i
2039 */
2040 Terminal.prototype.setupStops = function(i) {
2041 if (i != null) {
2042 if (!this.tabs[i]) {
2043 i = this.prevStop(i);
2044 }
2045 } else {
2046 this.tabs = {};
2047 i = 0;
2048 }
2049
2050 for (; i < this.cols; i += this.getOption('tabStopWidth')) {
2051 this.tabs[i] = true;
2052 }
2053 };
2054
2055
2056 /**
2057 * Move the cursor to the previous tab stop from the given position (default is current).
2058 * @param {number} x The position to move the cursor to the previous tab stop.
2059 */
2060 Terminal.prototype.prevStop = function(x) {
2061 if (x == null) x = this.x;
2062 while (!this.tabs[--x] && x > 0);
2063 return x >= this.cols
2064 ? this.cols - 1
2065 : x < 0 ? 0 : x;
2066 };
2067
2068
2069 /**
2070 * Move the cursor one tab stop forward from the given position (default is current).
2071 * @param {number} x The position to move the cursor one tab stop forward.
2072 */
2073 Terminal.prototype.nextStop = function(x) {
2074 if (x == null) x = this.x;
2075 while (!this.tabs[++x] && x < this.cols);
2076 return x >= this.cols
2077 ? this.cols - 1
2078 : x < 0 ? 0 : x;
2079 };
2080
2081
2082 /**
2083 * Erase in the identified line everything from "x" to the end of the line (right).
2084 * @param {number} x The column from which to start erasing to the end of the line.
2085 * @param {number} y The line in which to operate.
2086 */
2087 Terminal.prototype.eraseRight = function(x, y) {
2088 var line = this.lines.get(this.ybase + y);
2089 if (!line) {
2090 return;
2091 }
2092 var ch = [this.eraseAttr(), ' ', 1]; // xterm
2093 for (; x < this.cols; x++) {
2094 line[x] = ch;
2095 }
2096 this.updateRange(y);
2097 };
2098
2099
2100
2101 /**
2102 * Erase in the identified line everything from "x" to the start of the line (left).
2103 * @param {number} x The column from which to start erasing to the start of the line.
2104 * @param {number} y The line in which to operate.
2105 */
2106 Terminal.prototype.eraseLeft = function(x, y) {
2107 var line = this.lines.get(this.ybase + y);
2108 if (!line) {
2109 return;
2110 }
2111 var ch = [this.eraseAttr(), ' ', 1]; // xterm
2112 x++;
2113 while (x--) {
2114 line[x] = ch;
2115 }
2116 this.updateRange(y);
2117 };
2118
2119 /**
2120 * Clears the entire buffer, making the prompt line the new first line.
2121 */
2122 Terminal.prototype.clear = function() {
2123 if (this.ybase === 0 && this.y === 0) {
2124 // Don't clear if it's already clear
2125 return;
2126 }
2127 this.lines.set(0, this.lines.get(this.ybase + this.y));
2128 this.lines.length = 1;
2129 this.ydisp = 0;
2130 this.ybase = 0;
2131 this.y = 0;
2132 for (var i = 1; i < this.rows; i++) {
2133 this.lines.push(this.blankLine());
2134 }
2135 this.refresh(0, this.rows - 1);
2136 this.emit('scroll', this.ydisp);
2137 };
2138
2139 /**
2140 * Erase all content in the given line
2141 * @param {number} y The line to erase all of its contents.
2142 */
2143 Terminal.prototype.eraseLine = function(y) {
2144 this.eraseRight(0, y);
2145 };
2146
2147
2148 /**
2149 * Return the data array of a blank line
2150 * @param {number} cur First bunch of data for each "blank" character.
2151 * @param {boolean} isWrapped Whether the new line is wrapped from the previous line.
2152 */
2153 Terminal.prototype.blankLine = function(cur, isWrapped) {
2154 var attr = cur
2155 ? this.eraseAttr()
2156 : this.defAttr;
2157
2158 var ch = [attr, ' ', 1] // width defaults to 1 halfwidth character
2159 , line = []
2160 , i = 0;
2161
2162 // TODO: It is not ideal that this is a property on an array, a buffer line
2163 // class should be added that will hold this data and other useful functions.
2164 if (isWrapped) {
2165 line.isWrapped = isWrapped;
2166 }
2167
2168 for (; i < this.cols; i++) {
2169 line[i] = ch;
2170 }
2171
2172 return line;
2173 };
2174
2175
2176 /**
2177 * If cur return the back color xterm feature attribute. Else return defAttr.
2178 * @param {object} cur
2179 */
2180 Terminal.prototype.ch = function(cur) {
2181 return cur
2182 ? [this.eraseAttr(), ' ', 1]
2183 : [this.defAttr, ' ', 1];
2184 };
2185
2186
2187 /**
2188 * Evaluate if the current erminal is the given argument.
2189 * @param {object} term The terminal to evaluate
2190 */
2191 Terminal.prototype.is = function(term) {
2192 var name = this.termName;
2193 return (name + '').indexOf(term) === 0;
2194 };
2195
2196
2197 /**
2198 * Emit the 'data' event and populate the given data.
2199 * @param {string} data The data to populate in the event.
2200 */
2201 Terminal.prototype.handler = function(data) {
2202 // Prevents all events to pty process if stdin is disabled
2203 if (this.options.disableStdin) {
2204 return;
2205 }
2206
2207 // Input is being sent to the terminal, the terminal should focus the prompt.
2208 if (this.ybase !== this.ydisp) {
2209 this.scrollToBottom();
2210 }
2211 this.emit('data', data);
2212 };
2213
2214
2215 /**
2216 * Emit the 'title' event and populate the given title.
2217 * @param {string} title The title to populate in the event.
2218 */
2219 Terminal.prototype.handleTitle = function(title) {
2220 /**
2221 * This event is emitted when the title of the terminal is changed
2222 * from inside the terminal. The parameter is the new title.
2223 *
2224 * @event title
2225 */
2226 this.emit('title', title);
2227 };
2228
2229
2230 /**
2231 * ESC
2232 */
2233
2234 /**
2235 * ESC D Index (IND is 0x84).
2236 */
2237 Terminal.prototype.index = function() {
2238 this.y++;
2239 if (this.y > this.scrollBottom) {
2240 this.y--;
2241 this.scroll();
2242 }
2243 // If the end of the line is hit, prevent this action from wrapping around to the next line.
2244 if (this.x >= this.cols) {
2245 this.x--;
2246 }
2247 };
2248
2249
2250 /**
2251 * ESC M Reverse Index (RI is 0x8d).
2252 *
2253 * Move the cursor up one row, inserting a new blank line if necessary.
2254 */
2255 Terminal.prototype.reverseIndex = function() {
2256 var j;
2257 if (this.y === this.scrollTop) {
2258 // possibly move the code below to term.reverseScroll();
2259 // test: echo -ne '\e[1;1H\e[44m\eM\e[0m'
2260 // blankLine(true) is xterm/linux behavior
2261 this.lines.shiftElements(this.y + this.ybase, this.rows - 1, 1);
2262 this.lines.set(this.y + this.ybase, this.blankLine(true));
2263 this.updateRange(this.scrollTop);
2264 this.updateRange(this.scrollBottom);
2265 } else {
2266 this.y--;
2267 }
2268 };
2269
2270
2271 /**
2272 * ESC c Full Reset (RIS).
2273 */
2274 Terminal.prototype.reset = function() {
2275 this.options.rows = this.rows;
2276 this.options.cols = this.cols;
2277 var customKeyEventHandler = this.customKeyEventHandler;
2278 var cursorBlinkInterval = this.cursorBlinkInterval;
2279 Terminal.call(this, this.options);
2280 this.customKeyEventHandler = customKeyEventHandler;
2281 this.cursorBlinkInterval = cursorBlinkInterval;
2282 this.refresh(0, this.rows - 1);
2283 this.viewport.syncScrollArea();
2284 };
2285
2286
2287 /**
2288 * ESC H Tab Set (HTS is 0x88).
2289 */
2290 Terminal.prototype.tabSet = function() {
2291 this.tabs[this.x] = true;
2292 };
2293
2294 /**
2295 * Helpers
2296 */
2297
2298 function on(el, type, handler, capture) {
2299 if (!Array.isArray(el)) {
2300 el = [el];
2301 }
2302 el.forEach(function (element) {
2303 element.addEventListener(type, handler, capture || false);
2304 });
2305 }
2306
2307 function off(el, type, handler, capture) {
2308 el.removeEventListener(type, handler, capture || false);
2309 }
2310
2311 function cancel(ev, force) {
2312 if (!this.cancelEvents && !force) {
2313 return;
2314 }
2315 ev.preventDefault();
2316 ev.stopPropagation();
2317 return false;
2318 }
2319
2320 function inherits(child, parent) {
2321 function f() {
2322 this.constructor = child;
2323 }
2324 f.prototype = parent.prototype;
2325 child.prototype = new f;
2326 }
2327
2328 function indexOf(obj, el) {
2329 var i = obj.length;
2330 while (i--) {
2331 if (obj[i] === el) return i;
2332 }
2333 return -1;
2334 }
2335
2336 function isThirdLevelShift(term, ev) {
2337 var thirdLevelKey =
2338 (term.browser.isMac && ev.altKey && !ev.ctrlKey && !ev.metaKey) ||
2339 (term.browser.isMSWindows && ev.altKey && ev.ctrlKey && !ev.metaKey);
2340
2341 if (ev.type == 'keypress') {
2342 return thirdLevelKey;
2343 }
2344
2345 // Don't invoke for arrows, pageDown, home, backspace, etc. (on non-keypress events)
2346 return thirdLevelKey && (!ev.keyCode || ev.keyCode > 47);
2347 }
2348
2349 // Expose to InputHandler (temporary)
2350 Terminal.prototype.matchColor = matchColor;
2351
2352 function matchColor(r1, g1, b1) {
2353 var hash = (r1 << 16) | (g1 << 8) | b1;
2354
2355 if (matchColor._cache[hash] != null) {
2356 return matchColor._cache[hash];
2357 }
2358
2359 var ldiff = Infinity
2360 , li = -1
2361 , i = 0
2362 , c
2363 , r2
2364 , g2
2365 , b2
2366 , diff;
2367
2368 for (; i < Terminal.vcolors.length; i++) {
2369 c = Terminal.vcolors[i];
2370 r2 = c[0];
2371 g2 = c[1];
2372 b2 = c[2];
2373
2374 diff = matchColor.distance(r1, g1, b1, r2, g2, b2);
2375
2376 if (diff === 0) {
2377 li = i;
2378 break;
2379 }
2380
2381 if (diff < ldiff) {
2382 ldiff = diff;
2383 li = i;
2384 }
2385 }
2386
2387 return matchColor._cache[hash] = li;
2388 }
2389
2390 matchColor._cache = {};
2391
2392 // http://stackoverflow.com/questions/1633828
2393 matchColor.distance = function(r1, g1, b1, r2, g2, b2) {
2394 return Math.pow(30 * (r1 - r2), 2)
2395 + Math.pow(59 * (g1 - g2), 2)
2396 + Math.pow(11 * (b1 - b2), 2);
2397 };
2398
2399 function each(obj, iter, con) {
2400 if (obj.forEach) return obj.forEach(iter, con);
2401 for (var i = 0; i < obj.length; i++) {
2402 iter.call(con, obj[i], i, obj);
2403 }
2404 }
2405
2406 function wasMondifierKeyOnlyEvent(ev) {
2407 return ev.keyCode === 16 || // Shift
2408 ev.keyCode === 17 || // Ctrl
2409 ev.keyCode === 18; // Alt
2410 }
2411
2412 function keys(obj) {
2413 if (Object.keys) return Object.keys(obj);
2414 var key, keys = [];
2415 for (key in obj) {
2416 if (Object.prototype.hasOwnProperty.call(obj, key)) {
2417 keys.push(key);
2418 }
2419 }
2420 return keys;
2421 }
2422
2423 /**
2424 * Expose
2425 */
2426
2427 Terminal.EventEmitter = EventEmitter;
2428 Terminal.inherits = inherits;
2429
2430 /**
2431 * Adds an event listener to the terminal.
2432 *
2433 * @param {string} event The name of the event. TODO: Document all event types
2434 * @param {function} callback The function to call when the event is triggered.
2435 */
2436 Terminal.on = on;
2437 Terminal.off = off;
2438 Terminal.cancel = cancel;
2439
2440 module.exports = Terminal;