Merge branch 'master' into pr/jerch/2751

src/common/CoreTerminal.ts

@@ -0,0 +1,336 @@
+/**
+ * Copyright (c) 2014-2020 The xterm.js authors. All rights reserved.
+ * Copyright (c) 2012-2013, Christopher Jeffrey (MIT License)
+ * @license MIT
+ *
+ * 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.
+ *
+ * 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
+ */
+
+import { Disposable } from 'common/Lifecycle';
+import { IInstantiationService, IOptionsService, IBufferService, ILogService, ICharsetService, ICoreService, ICoreMouseService, IUnicodeService, IDirtyRowService } from 'common/services/Services';
+import { InstantiationService } from 'common/services/InstantiationService';
+import { LogService } from 'common/services/LogService';
+import { BufferService, MINIMUM_COLS, MINIMUM_ROWS } from 'common/services/BufferService';
+import { OptionsService } from 'common/services/OptionsService';
+import { ITerminalOptions, IDisposable, IBufferLine, IAttributeData, ICoreTerminal } from 'common/Types';
+import { CoreService } from 'common/services/CoreService';
+import { EventEmitter, IEvent, forwardEvent } from 'common/EventEmitter';
+import { CoreMouseService } from 'common/services/CoreMouseService';
+import { DirtyRowService } from 'common/services/DirtyRowService';
+import { UnicodeService } from 'common/services/UnicodeService';
+import { CharsetService } from 'common/services/CharsetService';
+import { updateWindowsModeWrappedState } from 'common/WindowsMode';
+import { IFunctionIdentifier, IParams } from 'common/parser/Types';
+import { IBufferSet } from 'common/buffer/Types';
+import { InputHandler } from 'common/InputHandler';
+import { WriteBuffer } from 'common/input/WriteBuffer';
+
+export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
+  protected readonly _instantiationService: IInstantiationService;
+  protected readonly _bufferService: IBufferService;
+  protected readonly _logService: ILogService;
+  protected readonly _coreService: ICoreService;
+  protected readonly _charsetService: ICharsetService;
+  protected readonly _coreMouseService: ICoreMouseService;
+  protected readonly _dirtyRowService: IDirtyRowService;
+
+  public readonly unicodeService: IUnicodeService;
+  public readonly optionsService: IOptionsService;
+
+  protected _inputHandler: InputHandler;
+  private _writeBuffer: WriteBuffer;
+  private _windowsMode: IDisposable | undefined;
+  /** An IBufferline to clone/copy from for new blank lines */
+  private _cachedBlankLine: IBufferLine | undefined;
+
+  private _onBinary = new EventEmitter<string>();
+  public get onBinary(): IEvent<string> { return this._onBinary.event; }
+  private _onData = new EventEmitter<string>();
+  public get onData(): IEvent<string> { return this._onData.event; }
+  protected _onLineFeed = new EventEmitter<void>();
+  public get onLineFeed(): IEvent<void> { return this._onLineFeed.event; }
+  private _onResize = new EventEmitter<{ cols: number, rows: number }>();
+  public get onResize(): IEvent<{ cols: number, rows: number }> { return this._onResize.event; }
+  protected _onScroll = new EventEmitter<number>();
+  public get onScroll(): IEvent<number> { return this._onScroll.event; }
+
+  public get cols(): number { return this._bufferService.cols; }
+  public get rows(): number { return this._bufferService.rows; }
+  public get buffers(): IBufferSet { return this._bufferService.buffers; }
+
+  constructor(
+    options: ITerminalOptions
+  ) {
+    super();
+
+    // Setup and initialize services
+    this._instantiationService = new InstantiationService();
+    this.optionsService = new OptionsService(options);
+    this._instantiationService.setService(IOptionsService, this.optionsService);
+    this._bufferService = this._instantiationService.createInstance(BufferService);
+    this._instantiationService.setService(IBufferService, this._bufferService);
+    this._logService = this._instantiationService.createInstance(LogService);
+    this._instantiationService.setService(ILogService, this._logService);
+    this._coreService = this._instantiationService.createInstance(CoreService, () => this.scrollToBottom());
+    this._instantiationService.setService(ICoreService, this._coreService);
+    this._coreMouseService = this._instantiationService.createInstance(CoreMouseService);
+    this._instantiationService.setService(ICoreMouseService, this._coreMouseService);
+    this._dirtyRowService = this._instantiationService.createInstance(DirtyRowService);
+    this._instantiationService.setService(IDirtyRowService, this._dirtyRowService);
+    this.unicodeService = this._instantiationService.createInstance(UnicodeService);
+    this._instantiationService.setService(IUnicodeService, this.unicodeService);
+    this._charsetService = this._instantiationService.createInstance(CharsetService);
+    this._instantiationService.setService(ICharsetService, this._charsetService);
+
+    // Register input handler and handle/forward events
+    this._inputHandler = new InputHandler(this._bufferService, this._charsetService, this._coreService, this._dirtyRowService, this._logService, this.optionsService, this._coreMouseService, this.unicodeService);
+    this.register(forwardEvent(this._inputHandler.onLineFeed, this._onLineFeed));
+    this.register(this._inputHandler);
+
+    // Setup listeners
+    this.register(forwardEvent(this._bufferService.onResize, this._onResize));
+    this.register(forwardEvent(this._coreService.onData, this._onData));
+    this.register(forwardEvent(this._coreService.onBinary, this._onBinary));
+    this.register(this.optionsService.onOptionChange(key => this._updateOptions(key)));
+
+    // Setup WriteBuffer
+    this._writeBuffer = new WriteBuffer(data => this._inputHandler.parse(data));
+  }
+
+  public dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    super.dispose();
+    this._windowsMode?.dispose();
+    this._windowsMode = undefined;
+  }
+
+  public write(data: string | Uint8Array, callback?: () => void): void {
+    this._writeBuffer.write(data, callback);
+  }
+
+  public writeSync(data: string | Uint8Array): void {
+    this._writeBuffer.writeSync(data);
+  }
+
+  public resize(x: number, y: number): void {
+    if (isNaN(x) || isNaN(y)) {
+      return;
+    }
+
+    x = Math.max(x, MINIMUM_COLS);
+    y = Math.max(y, MINIMUM_ROWS);
+
+    this._bufferService.resize(x, y);
+  }
+
+  /**
+   * Scroll the terminal down 1 row, creating a blank line.
+   * @param isWrapped Whether the new line is wrapped from the previous line.
+   */
+  public scroll(eraseAttr: IAttributeData, isWrapped: boolean = false): void {
+    const buffer = this._bufferService.buffer;
+
+    let newLine: IBufferLine | undefined;
+    newLine = this._cachedBlankLine;
+    if (!newLine || newLine.length !== this.cols || newLine.getFg(0) !== eraseAttr.fg || newLine.getBg(0) !== eraseAttr.bg) {
+      newLine = buffer.getBlankLine(eraseAttr, isWrapped);
+      this._cachedBlankLine = newLine;
+    }
+    newLine.isWrapped = isWrapped;
+
+    const topRow = buffer.ybase + buffer.scrollTop;
+    const bottomRow = buffer.ybase + buffer.scrollBottom;
+
+    if (buffer.scrollTop === 0) {
+      // Determine whether the buffer is going to be trimmed after insertion.
+      const willBufferBeTrimmed = buffer.lines.isFull;
+
+      // Insert the line using the fastest method
+      if (bottomRow === buffer.lines.length - 1) {
+        if (willBufferBeTrimmed) {
+          buffer.lines.recycle().copyFrom(newLine);
+        } else {
+          buffer.lines.push(newLine.clone());
+        }
+      } else {
+        buffer.lines.splice(bottomRow + 1, 0, newLine.clone());
+      }
+
+      // Only adjust ybase and ydisp when the buffer is not trimmed
+      if (!willBufferBeTrimmed) {
+        buffer.ybase++;
+        // Only scroll the ydisp with ybase if the user has not scrolled up
+        if (!this._bufferService.isUserScrolling) {
+          buffer.ydisp++;
+        }
+      } else {
+        // When the buffer is full and the user has scrolled up, keep the text
+        // stable unless ydisp is right at the top
+        if (this._bufferService.isUserScrolling) {
+          buffer.ydisp = Math.max(buffer.ydisp - 1, 0);
+        }
+      }
+    } else {
+      // scrollTop is non-zero which means no line will be going to the
+      // scrollback, instead we can just shift them in-place.
+      const scrollRegionHeight = bottomRow - topRow + 1 /* as it's zero-based */;
+      buffer.lines.shiftElements(topRow + 1, scrollRegionHeight - 1, -1);
+      buffer.lines.set(bottomRow, newLine.clone());
+    }
+
+    // Move the viewport to the bottom of the buffer unless the user is
+    // scrolling.
+    if (!this._bufferService.isUserScrolling) {
+      buffer.ydisp = buffer.ybase;
+    }
+
+    // Flag rows that need updating
+    this._dirtyRowService.markRangeDirty(buffer.scrollTop, buffer.scrollBottom);
+
+    this._onScroll.fire(buffer.ydisp);
+  }
+
+  /**
+   * Scroll the display of the terminal
+   * @param disp The number of lines to scroll down (negative scroll up).
+   * @param suppressScrollEvent Don't emit the scroll event as scrollLines. This is used
+   * to avoid unwanted events being handled by the viewport when the event was triggered from the
+   * viewport originally.
+   */
+  public scrollLines(disp: number, suppressScrollEvent?: boolean): void {
+    const buffer = this._bufferService.buffer;
+    if (disp < 0) {
+      if (buffer.ydisp === 0) {
+        return;
+      }
+      this._bufferService.isUserScrolling = true;
+    } else if (disp + buffer.ydisp >= buffer.ybase) {
+      this._bufferService.isUserScrolling = false;
+    }
+
+    const oldYdisp = buffer.ydisp;
+    buffer.ydisp = Math.max(Math.min(buffer.ydisp + disp, buffer.ybase), 0);
+
+    // No change occurred, don't trigger scroll/refresh
+    if (oldYdisp === buffer.ydisp) {
+      return;
+    }
+
+    if (!suppressScrollEvent) {
+      this._onScroll.fire(buffer.ydisp);
+    }
+  }
+
+  /**
+   * Scroll the display of the terminal by a number of pages.
+   * @param pageCount The number of pages to scroll (negative scrolls up).
+   */
+  public scrollPages(pageCount: number): void {
+    this.scrollLines(pageCount * (this.rows - 1));
+  }
+
+  /**
+   * Scrolls the display of the terminal to the top.
+   */
+  public scrollToTop(): void {
+    this.scrollLines(-this._bufferService.buffer.ydisp);
+  }
+
+  /**
+   * Scrolls the display of the terminal to the bottom.
+   */
+  public scrollToBottom(): void {
+    this.scrollLines(this._bufferService.buffer.ybase - this._bufferService.buffer.ydisp);
+  }
+
+  public scrollToLine(line: number): void {
+    const scrollAmount = line - this._bufferService.buffer.ydisp;
+    if (scrollAmount !== 0) {
+      this.scrollLines(scrollAmount);
+    }
+  }
+
+  /** Add handler for ESC escape sequence. See xterm.d.ts for details. */
+  public addEscHandler(id: IFunctionIdentifier, callback: () => boolean): IDisposable {
+    return this._inputHandler.addEscHandler(id, callback);
+  }
+
+  /** Add handler for DCS escape sequence. See xterm.d.ts for details. */
+  public addDcsHandler(id: IFunctionIdentifier, callback: (data: string, param: IParams) => boolean): IDisposable {
+    return this._inputHandler.addDcsHandler(id, callback);
+  }
+
+  /** Add handler for CSI escape sequence. See xterm.d.ts for details. */
+  public addCsiHandler(id: IFunctionIdentifier, callback: (params: IParams) => boolean): IDisposable {
+    return this._inputHandler.addCsiHandler(id, callback);
+  }
+
+  /** Add handler for OSC escape sequence. See xterm.d.ts for details. */
+  public addOscHandler(ident: number, callback: (data: string) => boolean): IDisposable {
+    return this._inputHandler.addOscHandler(ident, callback);
+  }
+
+  protected _setup(): void {
+    if (this.optionsService.options.windowsMode) {
+      this._enableWindowsMode();
+    }
+  }
+
+  public reset(): void {
+    this._inputHandler.reset();
+    this._bufferService.reset();
+    this._charsetService.reset();
+    this._coreService.reset();
+    this._coreMouseService.reset();
+  }
+
+  protected _updateOptions(key: string): void {
+    // TODO: These listeners should be owned by individual components
+    switch (key) {
+      case 'scrollback':
+        this.buffers.resize(this.cols, this.rows);
+        break;
+      case 'windowsMode':
+        if (this.optionsService.options.windowsMode) {
+          this._enableWindowsMode();
+        } else {
+          this._windowsMode?.dispose();
+          this._windowsMode = undefined;
+        }
+        break;
+    }
+  }
+
+  protected _enableWindowsMode(): void {
+    if (!this._windowsMode) {
+      const disposables: IDisposable[] = [];
+      disposables.push(this.onLineFeed(updateWindowsModeWrappedState.bind(null, this._bufferService)));
+      disposables.push(this.addCsiHandler({ final: 'H' }, () => {
+        updateWindowsModeWrappedState(this._bufferService);
+        return false;
+      }));
+      this._windowsMode = {
+        dispose: () => {
+          disposables.forEach(d => d.dispose());
+        }
+      };
+    }
+  }
+}

src/common/EventEmitter.ts

@@ -63,3 +63,7 @@ export class EventEmitter<T, U = void> implements IEventEmitter<T, U> {
     this._disposed = true;
   }
 }
+
+export function forwardEvent<T>(from: IEvent<T>, to: IEventEmitter<T>): IDisposable {
+  return from(e => to.fire(e));
+}

src/common/TestUtils.test.ts

@@ -9,13 +9,15 @@ import { clone } from 'common/Clone';
 import { DEFAULT_OPTIONS } from 'common/services/OptionsService';
 import { IBufferSet, IBuffer } from 'common/buffer/Types';
 import { BufferSet } from 'common/buffer/BufferSet';
-import { IDecPrivateModes, ICoreMouseEvent, CoreMouseEventType, ICharset } from 'common/Types';
+import { IDecPrivateModes, ICoreMouseEvent, CoreMouseEventType, ICharset, IModes } from 'common/Types';
 import { UnicodeV6 } from 'common/input/UnicodeV6';
 
 export class MockBufferService implements IBufferService {
-  serviceBrand: any;
+  public serviceBrand: any;
   public get buffer(): IBuffer { return this.buffers.active; }
   public buffers: IBufferSet = {} as any;
+  public onResize: IEvent<{ cols: number, rows: number }> = new EventEmitter<{ cols: number, rows: number }>().event;
+  public isUserScrolling: boolean = false;
   constructor(
     public cols: number,
     public rows: number,
@@ -23,101 +25,108 @@ export class MockBufferService implements IBufferService {
   ) {
     this.buffers = new BufferSet(optionsService, this);
   }
-  resize(cols: number, rows: number): void {
+  public resize(cols: number, rows: number): void {
     this.cols = cols;
     this.rows = rows;
   }
-  reset(): void {}
+  public reset(): void {}
 }
 
 export class MockCoreMouseService implements ICoreMouseService {
-  activeEncoding: string = '';
-  activeProtocol: string = '';
-  addEncoding(name: string): void {}
-  addProtocol(name: string): void {}
-  reset(): void {}
-  triggerMouseEvent(event: ICoreMouseEvent): boolean { return false; }
-  onProtocolChange: IEvent<CoreMouseEventType> = new EventEmitter<CoreMouseEventType>().event;
-  explainEvents(events: CoreMouseEventType): {[event: string]: boolean} {
+  public areMouseEventsActive: boolean = false;
+  public activeEncoding: string = '';
+  public activeProtocol: string = '';
+  public addEncoding(name: string): void {}
+  public addProtocol(name: string): void {}
+  public reset(): void {}
+  public triggerMouseEvent(event: ICoreMouseEvent): boolean { return false; }
+  public onProtocolChange: IEvent<CoreMouseEventType> = new EventEmitter<CoreMouseEventType>().event;
+  public explainEvents(events: CoreMouseEventType): {[event: string]: boolean} {
     throw new Error('Method not implemented.');
   }
 }
 
 export class MockCharsetService implements ICharsetService {
-  serviceBrand: any;
-  charset: ICharset | undefined;
-  glevel: number = 0;
-  charsets: ReadonlyArray<ICharset> = [];
-  reset(): void {}
-  setgLevel(g: number): void {}
-  setgCharset(g: number, charset: ICharset): void {}
+  public serviceBrand: any;
+  public charset: ICharset | undefined;
+  public glevel: number = 0;
+  public reset(): void {}
+  public setgLevel(g: number): void {}
+  public setgCharset(g: number, charset: ICharset): void {}
 }
 
 export class MockCoreService implements ICoreService {
-  serviceBrand: any;
-  isCursorInitialized: boolean = false;
-  isCursorHidden: boolean = false;
-  isFocused: boolean = false;
-  decPrivateModes: IDecPrivateModes = {
+  public serviceBrand: any;
+  public isCursorInitialized: boolean = false;
+  public isCursorHidden: boolean = false;
+  public isFocused: boolean = false;
+  public modes: IModes = {
+    insertMode: false
+  };
+  public decPrivateModes: IDecPrivateModes = {
     applicationCursorKeys: false,
     applicationKeypad: false,
+    bracketedPasteMode: false,
     origin: false,
+    reverseWraparound: false,
+    sendFocus: false,
     wraparound: true
   };
-  onData: IEvent<string> = new EventEmitter<string>().event;
-  onUserInput: IEvent<void> = new EventEmitter<void>().event;
-  onBinary: IEvent<string> = new EventEmitter<string>().event;
-  reset(): void {}
-  triggerDataEvent(data: string, wasUserInput?: boolean): void {}
-  triggerBinaryEvent(data: string): void {}
+  public onData: IEvent<string> = new EventEmitter<string>().event;
+  public onUserInput: IEvent<void> = new EventEmitter<void>().event;
+  public onBinary: IEvent<string> = new EventEmitter<string>().event;
+  public reset(): void {}
+  public triggerDataEvent(data: string, wasUserInput?: boolean): void {}
+  public triggerBinaryEvent(data: string): void {}
 }
 
 export class MockDirtyRowService implements IDirtyRowService {
-  serviceBrand: any;
-  start: number = 0;
-  end: number = 0;
-  clearRange(): void {}
-  markDirty(y: number): void {}
-  markRangeDirty(y1: number, y2: number): void {}
-  markAllDirty(): void {}
+  public serviceBrand: any;
+  public start: number = 0;
+  public end: number = 0;
+  public clearRange(): void {}
+  public markDirty(y: number): void {}
+  public markRangeDirty(y1: number, y2: number): void {}
+  public markAllDirty(): void {}
 }
 
 export class MockLogService implements ILogService {
-  serviceBrand: any;
-  debug(message: any, ...optionalParams: any[]): void {}
-  info(message: any, ...optionalParams: any[]): void {}
-  warn(message: any, ...optionalParams: any[]): void {}
-  error(message: any, ...optionalParams: any[]): void {}
+  public serviceBrand: any;
+  public debug(message: any, ...optionalParams: any[]): void {}
+  public info(message: any, ...optionalParams: any[]): void {}
+  public warn(message: any, ...optionalParams: any[]): void {}
+  public error(message: any, ...optionalParams: any[]): void {}
 }
 
 export class MockOptionsService implements IOptionsService {
-  serviceBrand: any;
-  options: ITerminalOptions = clone(DEFAULT_OPTIONS);
-  onOptionChange: IEvent<string> = new EventEmitter<string>().event;
+  public serviceBrand: any;
+  public options: ITerminalOptions = clone(DEFAULT_OPTIONS);
+  public onOptionChange: IEvent<string> = new EventEmitter<string>().event;
   constructor(testOptions?: IPartialTerminalOptions) {
     if (testOptions) {
       Object.keys(testOptions).forEach(key => this.options[key] = (<any>testOptions)[key]);
     }
   }
-  setOption<T>(key: string, value: T): void {
+  public setOption<T>(key: string, value: T): void {
     throw new Error('Method not implemented.');
   }
-  getOption<T>(key: string): T {
+  public getOption<T>(key: string): T {
     throw new Error('Method not implemented.');
   }
 }
 
 // defaults to V6 always to keep tests passing
 export class MockUnicodeService implements IUnicodeService {
+  public serviceBrand: any;
   private _provider = new UnicodeV6();
-  register(provider: IUnicodeVersionProvider): void {
+  public register(provider: IUnicodeVersionProvider): void {
     throw new Error('Method not implemented.');
   }
-  versions: string[] = [];
-  activeVersion: string = '';
-  onChange: IEvent<string> = new EventEmitter<string>().event;
-  wcwidth = (codepoint: number): number => this._provider.wcwidth(codepoint);
-  getStringCellWidth(s: string): number {
+  public versions: string[] = [];
+  public activeVersion: string = '';
+  public onChange: IEvent<string> = new EventEmitter<string>().event;
+  public wcwidth = (codepoint: number): number => this._provider.wcwidth(codepoint);
+  public getStringCellWidth(s: string): number {
     throw new Error('Method not implemented.');
   }
 }

src/common/Types.d.ts

@@ -3,13 +3,29 @@
  * @license MIT
  */
 
+import { ITerminalOptions as IPublicTerminalOptions } from 'xterm';
 import { IEvent, IEventEmitter } from 'common/EventEmitter';
 import { IDeleteEvent, IInsertEvent } from 'common/CircularList';
+import { IParams } from 'common/parser/Types';
+import { IOptionsService, IUnicodeService } from 'common/services/Services';
+
+export interface ICoreTerminal {
+  optionsService: IOptionsService;
+  unicodeService: IUnicodeService;
+}
 
 export interface IDisposable {
   dispose(): void;
 }
 
+// TODO: The options that are not in the public API should be reviewed
+export interface ITerminalOptions extends IPublicTerminalOptions {
+  [key: string]: any;
+  cancelEvents?: boolean;
+  convertEol?: boolean;
+  termName?: string;
+}
+
 export type XtermListener = (...args: any[]) => void;
 
 /**
@@ -41,7 +57,7 @@ export interface ICircularList<T> {
   get(index: number): T | undefined;
   set(index: number, value: T): void;
   push(value: T): void;
-  recycle(): T | undefined;
+  recycle(): T;
   pop(): T | undefined;
   splice(start: number, deleteCount: number, ...items: T[]): void;
   trimStart(count: number): void;
@@ -168,11 +184,17 @@ export interface IMarker extends IDisposable {
   readonly isDisposed: boolean;
   readonly line: number;
 }
+export interface IModes {
+  insertMode: boolean;
+}
 
 export interface IDecPrivateModes {
   applicationCursorKeys: boolean;
   applicationKeypad: boolean;
+  bracketedPasteMode: boolean;
   origin: boolean;
+  reverseWraparound: boolean;
+  sendFocus: boolean;
   wraparound: boolean; // defaults: xterm - true, vt100 - false
 }
 
@@ -304,3 +326,88 @@ export interface IWindowOptions {
   popTitle?: boolean;
   setWinLines?: boolean;
 }
+
+/**
+ * Calls the parser and handles actions generated by the parser.
+ */
+export interface IInputHandler {
+  onTitleChange: IEvent<string>;
+  onRequestScroll: IEvent<IAttributeData, boolean | void>;
+
+  parse(data: string | Uint8Array): void;
+  print(data: Uint32Array, start: number, end: number): void;
+
+  /** C0 BEL */ bell(): void;
+  /** C0 LF */ lineFeed(): void;
+  /** C0 CR */ carriageReturn(): void;
+  /** C0 BS */ backspace(): void;
+  /** C0 HT */ tab(): void;
+  /** C0 SO */ shiftOut(): void;
+  /** C0 SI */ shiftIn(): void;
+
+  /** CSI @ */ insertChars(params: IParams): void;
+  /** CSI SP @ */ scrollLeft(params: IParams): void;
+  /** CSI A */ cursorUp(params: IParams): void;
+  /** CSI SP A */ scrollRight(params: IParams): void;
+  /** CSI B */ cursorDown(params: IParams): void;
+  /** CSI C */ cursorForward(params: IParams): void;
+  /** CSI D */ cursorBackward(params: IParams): void;
+  /** CSI E */ cursorNextLine(params: IParams): void;
+  /** CSI F */ cursorPrecedingLine(params: IParams): void;
+  /** CSI G */ cursorCharAbsolute(params: IParams): void;
+  /** CSI H */ cursorPosition(params: IParams): void;
+  /** CSI I */ cursorForwardTab(params: IParams): void;
+  /** CSI J */ eraseInDisplay(params: IParams): void;
+  /** CSI K */ eraseInLine(params: IParams): void;
+  /** CSI L */ insertLines(params: IParams): void;
+  /** CSI M */ deleteLines(params: IParams): void;
+  /** CSI P */ deleteChars(params: IParams): void;
+  /** CSI S */ scrollUp(params: IParams): void;
+  /** CSI T */ scrollDown(params: IParams, collect?: string): void;
+  /** CSI X */ eraseChars(params: IParams): void;
+  /** CSI Z */ cursorBackwardTab(params: IParams): void;
+  /** CSI ` */ charPosAbsolute(params: IParams): void;
+  /** CSI a */ hPositionRelative(params: IParams): void;
+  /** CSI b */ repeatPrecedingCharacter(params: IParams): void;
+  /** CSI c */ sendDeviceAttributesPrimary(params: IParams): void;
+  /** CSI > c */ sendDeviceAttributesSecondary(params: IParams): void;
+  /** CSI d */ linePosAbsolute(params: IParams): void;
+  /** CSI e */ vPositionRelative(params: IParams): void;
+  /** CSI f */ hVPosition(params: IParams): void;
+  /** CSI g */ tabClear(params: IParams): void;
+  /** CSI h */ setMode(params: IParams, collect?: string): void;
+  /** CSI l */ resetMode(params: IParams, collect?: string): void;
+  /** CSI m */ charAttributes(params: IParams): void;
+  /** CSI n */ deviceStatus(params: IParams, collect?: string): void;
+  /** CSI p */ softReset(params: IParams, collect?: string): void;
+  /** CSI q */ setCursorStyle(params: IParams, collect?: string): void;
+  /** CSI r */ setScrollRegion(params: IParams, collect?: string): void;
+  /** CSI s */ saveCursor(params: IParams): void;
+  /** CSI u */ restoreCursor(params: IParams): void;
+  /** CSI ' } */ insertColumns(params: IParams): void;
+  /** CSI ' ~ */ deleteColumns(params: IParams): void;
+  /** OSC 0
+      OSC 2 */ setTitle(data: string): void;
+  /** ESC E */ nextLine(): void;
+  /** ESC = */ keypadApplicationMode(): void;
+  /** ESC > */ keypadNumericMode(): void;
+  /** ESC % G
+      ESC % @ */ selectDefaultCharset(): void;
+  /** ESC ( C
+      ESC ) C
+      ESC * C
+      ESC + C
+      ESC - C
+      ESC . C
+      ESC / C */ selectCharset(collectAndFlag: string): void;
+  /** ESC D */ index(): void;
+  /** ESC H */ tabSet(): void;
+  /** ESC M */ reverseIndex(): void;
+  /** ESC c */ fullReset(): void;
+  /** ESC n
+      ESC o
+      ESC |
+      ESC }
+      ESC ~ */ setgLevel(level: number): void;
+  /** ESC # 8 */ screenAlignmentPattern(): void;
+}

src/common/buffer/AttributeData.ts

@@ -7,14 +7,15 @@ import { IAttributeData, IColorRGB, IExtendedAttrs } from 'common/Types';
 import { Attributes, FgFlags, BgFlags, UnderlineStyle } from 'common/buffer/Constants';
 
 export class AttributeData implements IAttributeData {
-  static toColorRGB(value: number): IColorRGB {
+  public static toColorRGB(value: number): IColorRGB {
     return [
       value >>> Attributes.RED_SHIFT & 255,
       value >>> Attributes.GREEN_SHIFT & 255,
       value & 255
     ];
   }
-  static fromColorRGB(value: IColorRGB): number {
+
+  public static fromColorRGB(value: IColorRGB): number {
     return (value[0] & 255) << Attributes.RED_SHIFT | (value[1] & 255) << Attributes.GREEN_SHIFT | value[2] & 255;
   }
 

src/common/buffer/Buffer.ts

@@ -37,7 +37,7 @@ export class Buffer implements IBuffer {
   public savedY: number = 0;
   public savedX: number = 0;
   public savedCurAttrData = DEFAULT_ATTR_DATA.clone();
-  public savedCharset: ICharset | null = DEFAULT_CHARSET;
+  public savedCharset: ICharset | undefined = DEFAULT_CHARSET;
   public markers: Marker[] = [];
   private _nullCell: ICellData = CellData.fromCharData([0, NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE]);
   private _whitespaceCell: ICellData = CellData.fromCharData([0, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_WIDTH, WHITESPACE_CELL_CODE]);

src/common/buffer/BufferSet.ts

@@ -27,8 +27,8 @@ export class BufferSet implements IBufferSet {
    * @param _terminal - The terminal the BufferSet will belong to
    */
   constructor(
-    readonly optionsService: IOptionsService,
-    readonly bufferService: IBufferService
+    optionsService: IOptionsService,
+    bufferService: IBufferService
   ) {
     this._normal = new Buffer(true, optionsService, bufferService);
     this._normal.fillViewportRows();

src/common/buffer/Types.d.ts

@@ -31,7 +31,7 @@ export interface IBuffer {
   hasScrollback: boolean;
   savedY: number;
   savedX: number;
-  savedCharset: ICharset | null;
+  savedCharset: ICharset | undefined;
   savedCurAttrData: IAttributeData;
   isCursorInViewport: boolean;
   markers: IMarker[];

src/common/data/Charsets.ts

@@ -10,12 +10,12 @@ import { ICharset } from 'common/Types';
  * to be represented within the terminal with only 8-bit encoding. See ISO 2022
  * for a discussion on character sets. Only VT100 character sets are supported.
  */
-export const CHARSETS: { [key: string]: ICharset | null } = {};
+export const CHARSETS: { [key: string]: ICharset | undefined } = {};
 
 /**
  * The default character set, US.
  */
-export const DEFAULT_CHARSET: ICharset | null = CHARSETS['B'];
+export const DEFAULT_CHARSET: ICharset | undefined = CHARSETS['B'];
 
 /**
  * DEC Special Character and Line Drawing Set.
@@ -74,7 +74,7 @@ CHARSETS['A'] = {
  * United States character set
  * ESC (B
  */
-CHARSETS['B'] = null;
+CHARSETS['B'] = undefined;
 
 /**
  * Dutch character set

src/common/input/Keyboard.test.ts

@@ -86,6 +86,12 @@ describe('Keyboard', () => {
     it('should return \\x1b[3;3~ for alt+delete', () => {
       assert.equal(testEvaluateKeyboardEvent({ altKey: true, keyCode: 46 }).key, '\x1b[3;3~');
     });
+    it('should return \\x1b\\r for alt+enter', () => {
+      assert.equal(testEvaluateKeyboardEvent({ altKey: true, keyCode: 13 }).key, '\x1b\r');
+    });
+    it('should return \\x1b\\x1b for alt+esc', () => {
+      assert.equal(testEvaluateKeyboardEvent({ altKey: true, keyCode: 27 }).key, '\x1b\x1b');
+    });
     it('should return \\x1b[5D for ctrl+left', () => {
       assert.equal(testEvaluateKeyboardEvent({ ctrlKey: true, keyCode: 37 }).key, '\x1b[1;5D'); // CSI 5 D
     });
@@ -141,6 +147,10 @@ describe('Keyboard', () => {
       it('should return \\x1ba for alt+a', () => {
         assert.equal(testEvaluateKeyboardEvent({ altKey: true, keyCode: 65 }, { isMac: true, macOptionIsMeta: true }).key, '\x1ba');
       });
+
+      it('should return \\x1b\\x1b for alt+enter', () => {
+        assert.equal(testEvaluateKeyboardEvent({ altKey: true, keyCode: 13 }, { isMac: true, macOptionIsMeta: true }).key, '\x1b\r');
+      });
     });
 
     it('should return \\x1b[5A for alt+up', () => {

src/common/input/Keyboard.ts

@@ -103,12 +103,15 @@ export function evaluateKeyboardEvent(
       break;
     case 13:
       // return/enter
-      result.key = C0.CR;
+      result.key = ev.altKey ? C0.ESC + C0.CR : C0.CR;
       result.cancel = true;
       break;
     case 27:
       // escape
       result.key = C0.ESC;
+      if (ev.altKey) {
+        result.key = C0.ESC + C0.ESC;
+      }
       result.cancel = true;
       break;
     case 37:

src/common/input/TextDecoder.ts

@@ -64,7 +64,7 @@ export class StringToUtf32 {
    * the provided input data does not exceed the size of `target`.
    * Returns the number of written codepoints in `target`.
    */
-  decode(input: string, target: Uint32Array): number {
+  public decode(input: string, target: Uint32Array): number {
     const length = input.length;
 
     if (!length) {
@@ -132,7 +132,7 @@ export class Utf8ToUtf32 {
    * the provided data chunk does not exceed the size of `target`.
    * Returns the number of written codepoints in `target`.
    */
-  decode(input: Uint8Array, target: Uint32Array): number {
+  public decode(input: Uint8Array, target: Uint32Array): number {
     const length = input.length;
 
     if (!length) {

src/common/parser/DcsParser.test.ts

@@ -55,13 +55,13 @@ function identifier(id: IFunctionIdentifier): number {
 
 class TestHandler implements IDcsHandler {
   constructor(public output: any[], public msg: string, public returnFalse: boolean = false) {}
-  hook(params: IParams): void {
+  public hook(params: IParams): void {
     this.output.push([this.msg, 'HOOK', params.toArray()]);
   }
-  put(data: Uint32Array, start: number, end: number): void {
+  public put(data: Uint32Array, start: number, end: number): void {
     this.output.push([this.msg, 'PUT', utf32ToString(data, start, end)]);
   }
-  unhook(success: boolean): void | boolean {
+  public unhook(success: boolean): void | boolean {
     this.output.push([this.msg, 'UNHOOK', success]);
     if (this.returnFalse) {
       return false;

src/common/parser/EscapeSequenceParser.test.ts

@@ -41,16 +41,16 @@ class MockOscPutParser implements IOscParser {
       this._fallback(id, 'END', this.data.slice(this.data.indexOf(';') + 1));
     }
   }
-  addHandler(ident: number, handler: IOscHandler): IDisposable {
+  public addHandler(ident: number, handler: IOscHandler): IDisposable {
     throw new Error('not implemented');
   }
-  setHandler(ident: number, handler: IOscHandler): void {
+  public setHandler(ident: number, handler: IOscHandler): void {
     throw new Error('not implemented');
   }
-  clearHandler(ident: number): void {
+  public clearHandler(ident: number): void {
     throw new Error('not implemented');
   }
-  setHandlerFallback(handler: OscFallbackHandlerType): void {
+  public setHandlerFallback(handler: OscFallbackHandlerType): void {
     this._fallback = handler;
   }
 }

src/common/parser/OscParser.test.ts

@@ -17,13 +17,13 @@ function toUtf32(s: string): Uint32Array {
 
 class TestHandler implements IOscHandler {
   constructor(public id: number, public output: any[], public msg: string, public returnFalse: boolean = false) {}
-  start(): void {
+  public start(): void {
     this.output.push([this.msg, this.id, 'START']);
   }
-  put(data: Uint32Array, start: number, end: number): void {
+  public put(data: Uint32Array, start: number, end: number): void {
     this.output.push([this.msg, this.id, 'PUT', utf32ToString(data, start, end)]);
   }
-  end(success: boolean): void | boolean {
+  public end(success: boolean): void | boolean {
     this.output.push([this.msg, this.id, 'END', success]);
     if (this.returnFalse) {
       return false;

src/common/services/BufferService.ts

@@ -6,16 +6,22 @@
 import { IBufferService, IOptionsService } from 'common/services/Services';
 import { BufferSet } from 'common/buffer/BufferSet';
 import { IBufferSet, IBuffer } from 'common/buffer/Types';
+import { EventEmitter, IEvent } from 'common/EventEmitter';
 
 export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
 export const MINIMUM_ROWS = 1;
 
 export class BufferService implements IBufferService {
-  serviceBrand: any;
+  public serviceBrand: any;
 
   public cols: number;
   public rows: number;
   public buffers: IBufferSet;
+  /** Whether the user is scrolling (locks the scroll position) */
+  public isUserScrolling: boolean = false;
+
+  private _onResize = new EventEmitter<{ cols: number, rows: number }>();
+  public get onResize(): IEvent<{ cols: number, rows: number }> { return this._onResize.event; }
 
   public get buffer(): IBuffer { return this.buffers.active; }
 
@@ -30,9 +36,13 @@ export class BufferService implements IBufferService {
   public resize(cols: number, rows: number): void {
     this.cols = cols;
     this.rows = rows;
+    this.buffers.resize(cols, rows);
+    this.buffers.setupTabStops(this.cols);
+    this._onResize.fire({ cols, rows });
   }
 
   public reset(): void {
     this.buffers = new BufferSet(this._optionsService, this);
+    this.isUserScrolling = false;
   }
 }

src/common/services/CharsetService.ts

@@ -7,25 +7,26 @@ import { ICharsetService } from 'common/services/Services';
 import { ICharset } from 'common/Types';
 
 export class CharsetService implements ICharsetService {
-  serviceBrand: any;
+  public serviceBrand: any;
 
   public charset: ICharset | undefined;
-  public charsets: ICharset[] = [];
   public glevel: number = 0;
 
+  private _charsets: (ICharset | undefined)[] = [];
+
   public reset(): void {
     this.charset = undefined;
-    this.charsets = [];
+    this._charsets = [];
     this.glevel = 0;
   }
 
   public setgLevel(g: number): void {
     this.glevel = g;
-    this.charset = this.charsets[g];
+    this.charset = this._charsets[g];
   }
 
-  public setgCharset(g: number, charset: ICharset): void {
-    this.charsets[g] = charset;
+  public setgCharset(g: number, charset: ICharset | undefined): void {
+    this._charsets[g] = charset;
     if (this.glevel === g) {
       this.charset = charset;
     }

src/common/services/CoreMouseService.ts

@@ -192,6 +192,10 @@ export class CoreMouseService implements ICoreMouseService {
     return this._activeProtocol;
   }
 
+  public get areMouseEventsActive(): boolean {
+    return this._protocols[this._activeProtocol].events !== 0;
+  }
+
   public set activeProtocol(name: string) {
     if (!this._protocols[name]) {
       throw new Error(`unknown protocol "${name}"`);

src/common/services/CoreService.ts

@@ -5,21 +5,29 @@
 
 import { ICoreService, ILogService, IOptionsService, IBufferService } from 'common/services/Services';
 import { EventEmitter, IEvent } from 'common/EventEmitter';
-import { IDecPrivateModes, ICharset } from 'common/Types';
+import { IDecPrivateModes, IModes } from 'common/Types';
 import { clone } from 'common/Clone';
 
+const DEFAULT_MODES: IModes = Object.freeze({
+  insertMode: false
+});
+
 const DEFAULT_DEC_PRIVATE_MODES: IDecPrivateModes = Object.freeze({
   applicationCursorKeys: false,
   applicationKeypad: false,
+  bracketedPasteMode: false,
   origin: false,
+  reverseWraparound: false,
+  sendFocus: false,
   wraparound: true // defaults: xterm - true, vt100 - false
 });
 
 export class CoreService implements ICoreService {
-  serviceBrand: any;
+  public serviceBrand: any;
 
   public isCursorInitialized: boolean = false;
   public isCursorHidden: boolean = false;
+  public modes: IModes;
   public decPrivateModes: IDecPrivateModes;
 
   private _onData = new EventEmitter<string>();
@@ -36,10 +44,12 @@ export class CoreService implements ICoreService {
     @ILogService private readonly _logService: ILogService,
     @IOptionsService private readonly _optionsService: IOptionsService
   ) {
+    this.modes = clone(DEFAULT_MODES);
     this.decPrivateModes = clone(DEFAULT_DEC_PRIVATE_MODES);
   }
 
   public reset(): void {
+    this.modes = clone(DEFAULT_MODES);
     this.decPrivateModes = clone(DEFAULT_DEC_PRIVATE_MODES);
   }
 

src/common/services/DirtyRowService.ts

@@ -6,7 +6,7 @@
 import { IBufferService, IDirtyRowService } from 'common/services/Services';
 
 export class DirtyRowService implements IDirtyRowService {
-  serviceBrand: any;
+  public serviceBrand: any;
 
   private _start!: number;
   private _end!: number;

src/common/services/InstantiationService.ts

@@ -22,21 +22,21 @@ export class ServiceCollection {
     }
   }
 
-  set<T>(id: IServiceIdentifier<T>, instance: T): T {
+  public set<T>(id: IServiceIdentifier<T>, instance: T): T {
     const result = this._entries.get(id);
     this._entries.set(id, instance);
     return result;
   }
 
-  forEach(callback: (id: IServiceIdentifier<any>, instance: any) => any): void {
+  public forEach(callback: (id: IServiceIdentifier<any>, instance: any) => any): void {
     this._entries.forEach((value, key) => callback(key, value));
   }
 
-  has(id: IServiceIdentifier<any>): boolean {
+  public has(id: IServiceIdentifier<any>): boolean {
     return this._entries.has(id);
   }
 
-  get<T>(id: IServiceIdentifier<T>): T | undefined {
+  public get<T>(id: IServiceIdentifier<T>): T | undefined {
     return this._entries.get(id);
   }
 }

src/common/services/LogService.ts

@@ -39,7 +39,7 @@ const optionsKeyToLogLevel: { [key: string]: LogLevel } = {
 const LOG_PREFIX = 'xterm.js: ';
 
 export class LogService implements ILogService {
-  serviceBrand: any;
+  public serviceBrand: any;
 
   private _logLevel!: LogLevel;
 
@@ -71,25 +71,25 @@ export class LogService implements ILogService {
     type.call(console, LOG_PREFIX + message, ...optionalParams);
   }
 
-  debug(message: string, ...optionalParams: any[]): void {
+  public debug(message: string, ...optionalParams: any[]): void {
     if (this._logLevel <= LogLevel.DEBUG) {
       this._log(console.log, message, optionalParams);
     }
   }
 
-  info(message: string, ...optionalParams: any[]): void {
+  public info(message: string, ...optionalParams: any[]): void {
     if (this._logLevel <= LogLevel.INFO) {
       this._log(console.info, message, optionalParams);
     }
   }
 
-  warn(message: string, ...optionalParams: any[]): void {
+  public warn(message: string, ...optionalParams: any[]): void {
     if (this._logLevel <= LogLevel.WARN) {
       this._log(console.warn, message, optionalParams);
     }
   }
 
-  error(message: string, ...optionalParams: any[]): void {
+  public error(message: string, ...optionalParams: any[]): void {
     if (this._logLevel <= LogLevel.ERROR) {
       this._log(console.error, message, optionalParams);
     }

src/common/services/OptionsService.ts

@@ -31,6 +31,7 @@ export const DEFAULT_OPTIONS: ITerminalOptions = Object.freeze({
   fontWeight: 'normal',
   fontWeightBold: 'bold',
   lineHeight: 1.0,
+  linkTooltipHoverDuration: 500,
   letterSpacing: 0,
   logLevel: 'info',
   scrollback: 1000,
@@ -60,7 +61,7 @@ export const DEFAULT_OPTIONS: ITerminalOptions = Object.freeze({
 const CONSTRUCTOR_ONLY_OPTIONS = ['cols', 'rows'];
 
 export class OptionsService implements IOptionsService {
-  serviceBrand: any;
+  public serviceBrand: any;
 
   public options: ITerminalOptions;
 

src/common/services/Services.ts

@@ -5,19 +5,20 @@
 
 import { IEvent } from 'common/EventEmitter';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IDecPrivateModes, ICoreMouseEvent, CoreMouseEncoding, ICoreMouseProtocol, CoreMouseEventType, ICharset, IWindowOptions } from 'common/Types';
+import { IDecPrivateModes, ICoreMouseEvent, CoreMouseEncoding, ICoreMouseProtocol, CoreMouseEventType, ICharset, IWindowOptions, IModes } from 'common/Types';
 import { createDecorator } from 'common/services/ServiceRegistry';
 
 export const IBufferService = createDecorator<IBufferService>('BufferService');
 export interface IBufferService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   readonly cols: number;
   readonly rows: number;
   readonly buffer: IBuffer;
   readonly buffers: IBufferSet;
+  isUserScrolling: boolean;
 
-  // TODO: Move resize event here
+  onResize: IEvent<{ cols: number, rows: number }>;
 
   resize(cols: number, rows: number): void;
   reset(): void;
@@ -27,6 +28,7 @@ export const ICoreMouseService = createDecorator<ICoreMouseService>('CoreMouseSe
 export interface ICoreMouseService {
   activeProtocol: string;
   activeEncoding: string;
+  areMouseEventsActive: boolean;
   addProtocol(name: string, protocol: ICoreMouseProtocol): void;
   addEncoding(name: string, encoding: CoreMouseEncoding): void;
   reset(): void;
@@ -51,12 +53,12 @@ export interface ICoreMouseService {
   /**
    * Human readable version of mouse events.
    */
-  explainEvents(events: CoreMouseEventType): {[event: string]: boolean};
+  explainEvents(events: CoreMouseEventType): { [event: string]: boolean };
 }
 
 export const ICoreService = createDecorator<ICoreService>('CoreService');
 export interface ICoreService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   /**
    * Initially the cursor will not be visible until the first time the terminal
@@ -65,6 +67,7 @@ export interface ICoreService {
   isCursorInitialized: boolean;
   isCursorHidden: boolean;
 
+  readonly modes: IModes;
   readonly decPrivateModes: IDecPrivateModes;
 
   readonly onData: IEvent<string>;
@@ -92,11 +95,10 @@ export interface ICoreService {
 
 export const ICharsetService = createDecorator<ICharsetService>('CharsetService');
 export interface ICharsetService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   charset: ICharset | undefined;
   readonly glevel: number;
-  readonly charsets: ReadonlyArray<ICharset>;
 
   reset(): void;
 
@@ -111,12 +113,12 @@ export interface ICharsetService {
    * @param g
    * @param charset
    */
-  setgCharset(g: number, charset: ICharset): void;
+  setgCharset(g: number, charset: ICharset | undefined): void;
 }
 
 export const IDirtyRowService = createDecorator<IDirtyRowService>('DirtyRowService');
 export interface IDirtyRowService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   readonly start: number;
   readonly end: number;
@@ -132,61 +134,32 @@ export interface IServiceIdentifier<T> {
   type: T;
 }
 
-export interface IConstructorSignature0<T> {
-  new(...services: { serviceBrand: any }[]): T;
-}
+export interface IBrandedService {
+  serviceBrand: undefined;
+};
 
-export interface IConstructorSignature1<A1, T> {
-  new(first: A1, ...services: { serviceBrand: any }[]): T;
-}
-
-export interface IConstructorSignature2<A1, A2, T> {
-  new(first: A1, second: A2, ...services: { serviceBrand: any }[]): T;
-}
-
-export interface IConstructorSignature3<A1, A2, A3, T> {
-  new(first: A1, second: A2, third: A3, ...services: { serviceBrand: any }[]): T;
-}
-
-export interface IConstructorSignature4<A1, A2, A3, A4, T> {
-  new(first: A1, second: A2, third: A3, fourth: A4, ...services: { serviceBrand: any }[]): T;
-}
-
-export interface IConstructorSignature5<A1, A2, A3, A4, A5, T> {
-  new(first: A1, second: A2, third: A3, fourth: A4, fifth: A5, ...services: { serviceBrand: any }[]): T;
-}
-
-export interface IConstructorSignature6<A1, A2, A3, A4, A5, A6, T> {
-  new(first: A1, second: A2, third: A3, fourth: A4, fifth: A5, sixth: A6, ...services: { serviceBrand: any }[]): T;
-}
-
-export interface IConstructorSignature7<A1, A2, A3, A4, A5, A6, A7, T> {
-  new(first: A1, second: A2, third: A3, fourth: A4, fifth: A5, sixth: A6, seventh: A7, ...services: { serviceBrand: any }[]): T;
-}
-
-export interface IConstructorSignature8<A1, A2, A3, A4, A5, A6, A7, A8, T> {
-  new(first: A1, second: A2, third: A3, fourth: A4, fifth: A5, sixth: A6, seventh: A7, eigth: A8, ...services: { serviceBrand: any }[]): T;
-}
+type GetLeadingNonServiceArgs<Args> =
+  Args extends [...IBrandedService[]] ? []
+    : Args extends [infer A1, ...IBrandedService[]] ? [A1]
+      : Args extends [infer A1, infer A2, ...IBrandedService[]] ? [A1, A2]
+        : Args extends [infer A1, infer A2, infer A3, ...IBrandedService[]] ? [A1, A2, A3]
+          : Args extends [infer A1, infer A2, infer A3, infer A4, ...IBrandedService[]] ? [A1, A2, A3, A4]
+            : Args extends [infer A1, infer A2, infer A3, infer A4, infer A5, ...IBrandedService[]] ? [A1, A2, A3, A4, A5]
+              : Args extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, ...IBrandedService[]] ? [A1, A2, A3, A4, A5, A6]
+                : Args extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, infer A7, ...IBrandedService[]] ? [A1, A2, A3, A4, A5, A6, A7]
+                  : Args extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, infer A7, infer A8, ...IBrandedService[]] ? [A1, A2, A3, A4, A5, A6, A7, A8]
+                    : never;
 
 export const IInstantiationService = createDecorator<IInstantiationService>('InstantiationService');
 export interface IInstantiationService {
   setService<T>(id: IServiceIdentifier<T>, instance: T): void;
   getService<T>(id: IServiceIdentifier<T>): T | undefined;
-
-  createInstance<T>(ctor: IConstructorSignature0<T>): T;
-  createInstance<A1, T>(ctor: IConstructorSignature1<A1, T>, first: A1): T;
-  createInstance<A1, A2, T>(ctor: IConstructorSignature2<A1, A2, T>, first: A1, second: A2): T;
-  createInstance<A1, A2, A3, T>(ctor: IConstructorSignature3<A1, A2, A3, T>, first: A1, second: A2, third: A3): T;
-  createInstance<A1, A2, A3, A4, T>(ctor: IConstructorSignature4<A1, A2, A3, A4, T>, first: A1, second: A2, third: A3, fourth: A4): T;
-  createInstance<A1, A2, A3, A4, A5, T>(ctor: IConstructorSignature5<A1, A2, A3, A4, A5, T>, first: A1, second: A2, third: A3, fourth: A4, fifth: A5): T;
-  createInstance<A1, A2, A3, A4, A5, A6, T>(ctor: IConstructorSignature6<A1, A2, A3, A4, A5, A6, T>, first: A1, second: A2, third: A3, fourth: A4, fifth: A5, sixth: A6): T;
-  createInstance<A1, A2, A3, A4, A5, A6, A7, T>(ctor: IConstructorSignature7<A1, A2, A3, A4, A5, A6, A7, T>, first: A1, second: A2, third: A3, fourth: A4, fifth: A5, sixth: A6, seventh: A7): T;
-  createInstance<A1, A2, A3, A4, A5, A6, A7, A8, T>(ctor: IConstructorSignature8<A1, A2, A3, A4, A5, A6, A7, A8, T>, first: A1, second: A2, third: A3, fourth: A4, fifth: A5, sixth: A6, seventh: A7, eigth: A8): T;
+  createInstance<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(t: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
 }
 
 export const ILogService = createDecorator<ILogService>('LogService');
 export interface ILogService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   debug(message: any, ...optionalParams: any[]): void;
   info(message: any, ...optionalParams: any[]): void;
@@ -196,7 +169,7 @@ export interface ILogService {
 
 export const IOptionsService = createDecorator<IOptionsService>('OptionsService');
 export interface IOptionsService {
-  serviceBrand: any;
+  serviceBrand: undefined;
 
   readonly options: ITerminalOptions;
 
@@ -262,6 +235,7 @@ export interface ITerminalOptions {
   fontWeightBold: FontWeight;
   letterSpacing: number;
   lineHeight: number;
+  linkTooltipHoverDuration: number;
   logLevel: LogLevel;
   macOptionIsMeta: boolean;
   macOptionClickForcesSelection: boolean;
@@ -310,6 +284,7 @@ export interface ITheme {
 
 export const IUnicodeService = createDecorator<IUnicodeService>('UnicodeService');
 export interface IUnicodeService {
+  serviceBrand: undefined;
   /** Register an Unicode version provider. */
   register(provider: IUnicodeVersionProvider): void;
   /** Registered Unicode versions. */

src/common/services/UnicodeService.test.ts

@@ -8,8 +8,8 @@ import { UnicodeService } from 'common/services/UnicodeService';
 import { IUnicodeVersionProvider } from 'common/services/Services';
 
 class DummyProvider implements IUnicodeVersionProvider {
-  version = '123';
-  wcwidth(n: number): 0 | 1 | 2 {
+  public version = '123';
+  public wcwidth(n: number): 0 | 1 | 2 {
     return 2;
   }
 }

src/common/services/UnicodeService.ts

@@ -8,6 +8,8 @@ import { UnicodeV6 } from 'common/input/UnicodeV6';
 
 
 export class UnicodeService implements IUnicodeService {
+  public serviceBrand: any;
+
   private _providers: {[key: string]: IUnicodeVersionProvider} = Object.create(null);
   private _active: string = '';
   private _activeProvider: IUnicodeVersionProvider;

src/common/tsconfig.json

@@ -10,5 +10,8 @@
     ],
     "baseUrl": ".."
   },
-  "include": [ "./**/*" ]
+  "include": [
+    "./**/*",
+    "../../typings/xterm.d.ts"
+  ]
 }