@xterm/xterm 6.1.0-beta.22 → 6.1.0-beta.220

package/src/common/parser/Types.ts

@@ -32,6 +32,7 @@ export interface IParams {
   clone(): IParams;
   toArray(): ParamsArray;
   reset(): void;
+  resetZdm(): void;
   addParam(value: number): void;
   addSubParam(value: number): void;
   hasSubParams(idx: number): boolean;
@@ -107,7 +108,7 @@ export type EscFallbackHandlerType = (identifier: number) => void;
 /**
  * EXECUTE handler types.
  */
-export type ExecuteHandlerType = () => boolean;
+export type ExecuteHandlerType = (ident?: number) => boolean;
 export type ExecuteFallbackHandlerType = (ident: number) => void;
 
 /**
@@ -134,6 +135,29 @@ export interface IOscHandler {
 }
 export type OscFallbackHandlerType = (ident: number, action: 'START' | 'PUT' | 'END', payload?: any) => void;
 
+/**
+ * APC handler types.
+ */
+export interface IApcHandler {
+  /**
+   * Announces start of this APC command.
+   * Prepare needed data structures here.
+   */
+  start(): void;
+  /**
+   * Incoming data chunk.
+   */
+  put(data: Uint32Array, start: number, end: number): void;
+  /**
+   * End of APC command. `success` indicates whether the
+   * command finished normally or got aborted, thus final
+   * execution of the command should depend on `success`.
+   * To save memory also cleanup data structures here.
+   */
+  end(success: boolean): boolean | Promise<boolean>;
+}
+export type ApcFallbackHandlerType = (ident: number, action: 'START' | 'PUT' | 'END', payload?: any) => void;
+
 /**
  * PRINT handler types.
  */
@@ -196,6 +220,10 @@ export interface IEscapeSequenceParser extends IDisposable {
   clearOscHandler(ident: number): void;
   setOscHandlerFallback(handler: OscFallbackHandlerType): void;
 
+  registerApcHandler(id: IFunctionIdentifier, handler: IApcHandler): IDisposable;
+  clearApcHandler(id: IFunctionIdentifier): void;
+  setApcHandlerFallback(handler: ApcFallbackHandlerType): void;
+
   setErrorHandler(handler: (state: IParsingState) => IParsingState): void;
   clearErrorHandler(): void;
 }
@@ -223,6 +251,11 @@ export interface IDcsParser extends ISubParser<IDcsHandler, DcsFallbackHandlerTy
   unhook(success: boolean, promiseResult?: boolean): void | Promise<boolean>;
 }
 
+export interface IApcParser extends ISubParser<IApcHandler, ApcFallbackHandlerType> {
+  start(ident: number): void;
+  end(success: boolean, promiseResult?: boolean): void | Promise<boolean>;
+}
+
 /**
  * Interface to denote a specific ESC, CSI or DCS handler slot.
  * The values are used to create an integer respresentation during handler
@@ -252,7 +285,8 @@ export const enum ParserStackType {
   CSI,
   ESC,
   OSC,
-  DCS
+  DCS,
+  APC
 }
 
 // aggregate of resumable handler lists

package/src/common/public/BufferLineApiView.ts

@@ -18,10 +18,10 @@ export class BufferLineApiView implements IBufferLineApi {
     }
 
     if (cell) {
-      this._line.loadCell(x, cell as ICellData);
+      this._line.loadCell(x, cell as unknown as ICellData);
       return cell;
     }
-    return this._line.loadCell(x, new CellData());
+    return this._line.loadCell(x, new CellData()) as unknown as IBufferCellApi;
   }
   public translateToString(trimRight?: boolean, startColumn?: number, endColumn?: number): string {
     return this._line.translateToString(trimRight, startColumn, endColumn);

package/src/common/public/BufferNamespaceApi.ts

@@ -6,8 +6,8 @@
 import { IBuffer as IBufferApi, IBufferNamespace as IBufferNamespaceApi } from '@xterm/xterm';
 import { BufferApiView } from 'common/public/BufferApiView';
 import { ICoreTerminal } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 export class BufferNamespaceApi extends Disposable implements IBufferNamespaceApi {
   private _normal: BufferApiView;

package/src/common/public/ParserApi.ts

@@ -34,4 +34,7 @@ export class ParserApi implements IParser {
   public addOscHandler(ident: number, callback: (data: string) => boolean | Promise<boolean>): IDisposable {
     return this.registerOscHandler(ident, callback);
   }
+  public registerApcHandler(id: IFunctionIdentifier, callback: (data: string) => boolean | Promise<boolean>): IDisposable {
+    return this._core.registerApcHandler(id, callback);
+  }
 }

package/src/common/services/BufferService.ts

@@ -3,15 +3,17 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { IAttributeData, IBufferLine } from 'common/Types';
 import { BufferSet } from 'common/buffer/BufferSet';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IBufferService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { IBufferService, ILogService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services';
+import { Emitter } from 'common/Event';
 
-export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
-export const MINIMUM_ROWS = 1;
+export const enum BufferServiceConstants {
+  MINIMUM_COLS = 2, // Less than 2 can mess with wide chars
+  MINIMUM_ROWS = 1
+}
 
 export class BufferService extends Disposable implements IBufferService {
   public serviceBrand: any;
@@ -32,11 +34,14 @@ export class BufferService extends Disposable implements IBufferService {
   /** An IBufferline to clone/copy from for new blank lines */
   private _cachedBlankLine: IBufferLine | undefined;
 
-  constructor(@IOptionsService optionsService: IOptionsService) {
+  constructor(
+    @IOptionsService optionsService: IOptionsService,
+    @ILogService logService: ILogService
+  ) {
     super();
-    this.cols = Math.max(optionsService.rawOptions.cols || 0, MINIMUM_COLS);
-    this.rows = Math.max(optionsService.rawOptions.rows || 0, MINIMUM_ROWS);
-    this.buffers = this._register(new BufferSet(optionsService, this));
+    this.cols = Math.max(optionsService.rawOptions.cols || 0, BufferServiceConstants.MINIMUM_COLS);
+    this.rows = Math.max(optionsService.rawOptions.rows || 0, BufferServiceConstants.MINIMUM_ROWS);
+    this.buffers = this._register(new BufferSet(optionsService, this, logService));
     this._register(this.buffers.onBufferActivate(e => {
       this._onScroll.fire(e.activeBuffer.ydisp);
     }));

package/src/common/services/CharsetService.ts

@@ -14,6 +14,10 @@ export class CharsetService implements ICharsetService {
 
   private _charsets: (ICharset | undefined)[] = [];
 
+  public get charsets(): (ICharset | undefined)[] {
+    return this._charsets;
+  }
+
   public reset(): void {
     this.charset = undefined;
     this._charsets = [];

package/src/common/services/CoreService.ts

@@ -4,10 +4,10 @@
  */
 
 import { clone } from 'common/Clone';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { IDecPrivateModes, IModes } from 'common/Types';
+import { Disposable } from 'common/Lifecycle';
+import { IDecPrivateModes, IKittyKeyboardState, IModes } from 'common/Types';
 import { IBufferService, ICoreService, ILogService, IOptionsService } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 const DEFAULT_MODES: IModes = Object.freeze({
   insertMode: false
@@ -17,22 +17,33 @@ const DEFAULT_DEC_PRIVATE_MODES: IDecPrivateModes = Object.freeze({
   applicationCursorKeys: false,
   applicationKeypad: false,
   bracketedPasteMode: false,
+  colorSchemeUpdates: false,
   cursorBlink: undefined,
   cursorStyle: undefined,
   origin: false,
   reverseWraparound: false,
   sendFocus: false,
   synchronizedOutput: false,
+  win32InputMode: false,
   wraparound: true // defaults: xterm - true, vt100 - false
 });
 
+const DEFAULT_KITTY_KEYBOARD_STATE = (): IKittyKeyboardState => ({
+  flags: 0,
+  mainFlags: 0,
+  altFlags: 0,
+  mainStack: [],
+  altStack: []
+});
+
 export class CoreService extends Disposable implements ICoreService {
   public serviceBrand: any;
 
-  public isCursorInitialized: boolean = false;
+  public isCursorInitialized: boolean;
   public isCursorHidden: boolean = false;
   public modes: IModes;
   public decPrivateModes: IDecPrivateModes;
+  public kittyKeyboard: IKittyKeyboardState;
 
   private readonly _onData = this._register(new Emitter<string>());
   public readonly onData = this._onData.event;
@@ -49,13 +60,16 @@ export class CoreService extends Disposable implements ICoreService {
     @IOptionsService private readonly _optionsService: IOptionsService
   ) {
     super();
+    this.isCursorInitialized = _optionsService.rawOptions.showCursorImmediately ?? false;
     this.modes = clone(DEFAULT_MODES);
     this.decPrivateModes = clone(DEFAULT_DEC_PRIVATE_MODES);
+    this.kittyKeyboard = DEFAULT_KITTY_KEYBOARD_STATE();
   }
 
   public reset(): void {
     this.modes = clone(DEFAULT_MODES);
     this.decPrivateModes = clone(DEFAULT_DEC_PRIVATE_MODES);
+    this.kittyKeyboard = DEFAULT_KITTY_KEYBOARD_STATE();
   }
 
   public triggerDataEvent(data: string, wasUserInput: boolean = false): void {

package/src/common/services/DecorationService.ts

@@ -4,16 +4,18 @@
  */
 
 import { css } from 'common/Color';
-import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
-import { IDecorationService, IInternalDecoration } from 'common/services/Services';
+import { Disposable, DisposableStore, toDisposable } from 'common/Lifecycle';
+import { IDecorationService, IInternalDecoration, ILogService } from 'common/services/Services';
 import { SortedList } from 'common/SortedList';
 import { IColor } from 'common/Types';
 import { IDecoration, IDecorationOptions, IMarker } from '@xterm/xterm';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 // Work variables to avoid garbage collection
 let $xmin = 0;
 let $xmax = 0;
+let $ymin = 0;
+let $ymax = 0;
 
 export class DecorationService extends Disposable implements IDecorationService {
   public serviceBrand: any;
@@ -23,7 +25,7 @@ export class DecorationService extends Disposable implements IDecorationService
    * while marker line values do change, they should all change by the same amount so this should
    * never become out of order.
    */
-  private readonly _decorations: SortedList<IInternalDecoration> = new SortedList(e => e?.marker.line);
+  private readonly _decorations: SortedList<IInternalDecoration>;
 
   private readonly _onDecorationRegistered = this._register(new Emitter<IInternalDecoration>());
   public readonly onDecorationRegistered = this._onDecorationRegistered.event;
@@ -32,9 +34,11 @@ export class DecorationService extends Disposable implements IDecorationService
 
   public get decorations(): IterableIterator<IInternalDecoration> { return this._decorations.values(); }
 
-  constructor() {
+  constructor(@ILogService private readonly _logService: ILogService) {
     super();
 
+    this._decorations = new SortedList(e => e?.marker.line, this._logService);
+
     this._register(toDisposable(() => this.reset()));
   }
 
@@ -70,7 +74,14 @@ export class DecorationService extends Disposable implements IDecorationService
   public *getDecorationsAtCell(x: number, line: number, layer?: 'bottom' | 'top'): IterableIterator<IInternalDecoration> {
     let xmin = 0;
     let xmax = 0;
-    for (const d of this._decorations.getKeyIterator(line)) {
+    let ymin = 0;
+    let ymax = 0;
+    for (const d of this._decorations.values()) {
+      ymin = d.marker.line;
+      ymax = ymin + (d.options.height ?? 1);
+      if (line < ymin || line >= ymax) {
+        continue;
+      }
       xmin = d.options.x ?? 0;
       xmax = xmin + (d.options.width ?? 1);
       if (x >= xmin && x < xmax && (!layer || (d.options.layer ?? 'bottom') === layer)) {
@@ -80,13 +91,18 @@ export class DecorationService extends Disposable implements IDecorationService
   }
 
   public forEachDecorationAtCell(x: number, line: number, layer: 'bottom' | 'top' | undefined, callback: (decoration: IInternalDecoration) => void): void {
-    this._decorations.forEachByKey(line, d => {
+    for (const d of this._decorations.values()) {
+      $ymin = d.marker.line;
+      $ymax = $ymin + (d.options.height ?? 1);
+      if (line < $ymin || line >= $ymax) {
+        continue;
+      }
       $xmin = d.options.x ?? 0;
       $xmax = $xmin + (d.options.width ?? 1);
       if (x >= $xmin && x < $xmax && (!layer || (d.options.layer ?? 'bottom') === layer)) {
         callback(d);
       }
-    });
+    }
   }
 }
 

package/src/common/services/LogService.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { ILogService, IOptionsService, LogLevelEnum } from 'common/services/Services';
 
 type LogType = (message?: any, ...optionalParams: any[]) => void;
@@ -43,9 +43,6 @@ export class LogService extends Disposable implements ILogService {
     super();
     this._updateLogLevel();
     this._register(this._optionsService.onSpecificOptionChange('logLevel', () => this._updateLogLevel()));
-
-    // For trace logging, assume the latest created log service is valid
-    traceLogger = this;
   }
 
   private _updateLogLevel(): void {
@@ -95,30 +92,3 @@ export class LogService extends Disposable implements ILogService {
     }
   }
 }
-
-let traceLogger: ILogService;
-export function setTraceLogger(logger: ILogService): void {
-  traceLogger = logger;
-}
-
-/**
- * A decorator that can be used to automatically log trace calls to the decorated function.
- */
-export function traceCall(_target: any, key: string, descriptor: any): any {
-  if (typeof descriptor.value !== 'function') {
-    throw new Error('not supported');
-  }
-  const fnKey = 'value';
-  const fn = descriptor.value;
-  descriptor[fnKey] = function (...args: any[]) {
-    // Early exit
-    if (traceLogger.logLevel !== LogLevelEnum.TRACE) {
-      return fn.apply(this, args);
-    }
-
-    traceLogger.trace(`GlyphRenderer#${fn.name}(${args.map(e => JSON.stringify(e)).join(', ')})`);
-    const result = fn.apply(this, args);
-    traceLogger.trace(`GlyphRenderer#${fn.name} return`, result);
-    return result;
-  };
-}

package/src/common/services/{CoreMouseService.ts → MouseStateService.ts}

@@ -2,10 +2,10 @@
  * Copyright (c) 2019 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-import { IBufferService, ICoreService, ICoreMouseService, IOptionsService } from 'common/services/Services';
+import { IMouseStateService } from 'common/services/Services';
 import { ICoreMouseProtocol, ICoreMouseEvent, CoreMouseEncoding, CoreMouseEventType, CoreMouseButton, CoreMouseAction } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 /**
  * Supported default protocols.
@@ -151,7 +151,7 @@ const DEFAULT_ENCODINGS: { [key: string]: CoreMouseEncoding } = {
 };
 
 /**
- * CoreMouseService
+ * MouseStateService
  *
  * Provides mouse tracking reports with different protocols and encodings.
  *  - protocols: NONE (default), X10, VT200, DRAG, ANY
@@ -166,25 +166,21 @@ const DEFAULT_ENCODINGS: { [key: string]: CoreMouseEncoding } = {
  * a tracking report to the backend based on protocol and encoding limitations.
  * To send a mouse event call `triggerMouseEvent`.
  */
-export class CoreMouseService extends Disposable implements ICoreMouseService {
+export class MouseStateService extends Disposable implements IMouseStateService {
   public serviceBrand: any;
 
   private _protocols: { [name: string]: ICoreMouseProtocol } = {};
   private _encodings: { [name: string]: CoreMouseEncoding } = {};
   private _activeProtocol: string = '';
   private _activeEncoding: string = '';
-  private _lastEvent: ICoreMouseEvent | null = null;
-  private _wheelPartialScroll: number = 0;
+  private _customWheelEventHandler: ((event: WheelEvent) => boolean) | undefined;
 
   private readonly _onProtocolChange = this._register(new Emitter<CoreMouseEventType>());
   public readonly onProtocolChange = this._onProtocolChange.event;
 
-  constructor(
-    @IBufferService private readonly _bufferService: IBufferService,
-    @ICoreService private readonly _coreService: ICoreService,
-    @IOptionsService private readonly _optionsService: IOptionsService
-  ) {
+  constructor() {
     super();
+
     // register default protocols and encodings
     for (const name of Object.keys(DEFAULT_PROTOCOLS)) this.addProtocol(name, DEFAULT_PROTOCOLS[name]);
     for (const name of Object.keys(DEFAULT_ENCODINGS)) this.addEncoding(name, DEFAULT_ENCODINGS[name]);
@@ -230,136 +226,29 @@ export class CoreMouseService extends Disposable implements ICoreMouseService {
   public reset(): void {
     this.activeProtocol = 'NONE';
     this.activeEncoding = 'DEFAULT';
-    this._lastEvent = null;
-    this._wheelPartialScroll = 0;
   }
 
-  /**
-   * Processes a wheel event, accounting for partial scrolls for trackpad, mouse scrolls.
-   * This prevents hyper-sensitive scrolling in alt buffer.
-   */
-  public consumeWheelEvent(ev: WheelEvent, cellHeight?: number, dpr?: number): number {
-    // Do nothing if it's not a vertical scroll event
-    if (ev.deltaY === 0 || ev.shiftKey) {
-      return 0;
-    }
-
-    if (cellHeight === undefined || dpr === undefined) {
-      return 0;
-    }
-
-    const targetWheelEventPixels = cellHeight / dpr;
-    let amount = this._applyScrollModifier(ev.deltaY, ev);
-
-    if (ev.deltaMode === WheelEvent.DOM_DELTA_PIXEL) {
-      amount /= (targetWheelEventPixels + 0.0); // Prevent integer division
-
-      const isLikelyTrackpad = Math.abs(ev.deltaY) < 50;
-      if (isLikelyTrackpad) {
-        amount *= 0.3;
-      }
-
-      this._wheelPartialScroll += amount;
-      amount = Math.floor(Math.abs(this._wheelPartialScroll)) * (this._wheelPartialScroll > 0 ? 1 : -1);
-      this._wheelPartialScroll %= 1;
-    } else if (ev.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
-      amount *= this._bufferService.rows;
-    }
-    return amount;
+  public setCustomWheelEventHandler(customWheelEventHandler: ((event: WheelEvent) => boolean) | undefined): void {
+    this._customWheelEventHandler = customWheelEventHandler;
   }
 
-  private _applyScrollModifier(amount: number, ev: WheelEvent): number {
-    // Multiply the scroll speed when the modifier key is pressed
-    if (ev.altKey || ev.ctrlKey || ev.shiftKey) {
-      return amount * this._optionsService.rawOptions.fastScrollSensitivity * this._optionsService.rawOptions.scrollSensitivity;
-    }
-    return amount * this._optionsService.rawOptions.scrollSensitivity;
+  public allowCustomWheelEvent(ev: WheelEvent): boolean {
+    return this._customWheelEventHandler ? this._customWheelEventHandler(ev) !== false : true;
   }
 
-  /**
-   * Triggers a mouse event to be sent.
-   *
-   * Returns true if the event passed all protocol restrictions and a report
-   * was sent, otherwise false. The return value may be used to decide whether
-   * the default event action in the bowser component should be omitted.
-   *
-   * Note: The method will change values of the given event object
-   * to fullfill protocol and encoding restrictions.
-   */
-  public triggerMouseEvent(e: ICoreMouseEvent): boolean {
-    // range check for col/row
-    if (e.col < 0 || e.col >= this._bufferService.cols
-      || e.row < 0 || e.row >= this._bufferService.rows) {
-      return false;
-    }
-
-    // filter nonsense combinations of button + action
-    if (e.button === CoreMouseButton.WHEEL && e.action === CoreMouseAction.MOVE) {
-      return false;
-    }
-    if (e.button === CoreMouseButton.NONE && e.action !== CoreMouseAction.MOVE) {
-      return false;
-    }
-    if (e.button !== CoreMouseButton.WHEEL && (e.action === CoreMouseAction.LEFT || e.action === CoreMouseAction.RIGHT)) {
-      return false;
-    }
-
-    // report 1-based coords
-    e.col++;
-    e.row++;
-
-    // debounce move events at grid or pixel level
-    if (e.action === CoreMouseAction.MOVE
-      && this._lastEvent
-      && this._equalEvents(this._lastEvent, e, this._activeEncoding === 'SGR_PIXELS')
-    ) {
-      return false;
-    }
-
-    // apply protocol restrictions
-    if (!this._protocols[this._activeProtocol].restrict(e)) {
-      return false;
-    }
-
-    // encode report and send
-    const report = this._encodings[this._activeEncoding](e);
-    if (report) {
-      // always send DEFAULT as binary data
-      if (this._activeEncoding === 'DEFAULT') {
-        this._coreService.triggerBinaryEvent(report);
-      } else {
-        this._coreService.triggerDataEvent(report, true);
-      }
-    }
-
-    this._lastEvent = e;
+  public restrictMouseEvent(e: ICoreMouseEvent): boolean {
+    return this._protocols[this._activeProtocol].restrict(e);
+  }
 
-    return true;
+  public encodeMouseEvent(e: ICoreMouseEvent): string {
+    return this._encodings[this._activeEncoding](e);
   }
 
-  public explainEvents(events: CoreMouseEventType): { [event: string]: boolean } {
-    return {
-      down: !!(events & CoreMouseEventType.DOWN),
-      up: !!(events & CoreMouseEventType.UP),
-      drag: !!(events & CoreMouseEventType.DRAG),
-      move: !!(events & CoreMouseEventType.MOVE),
-      wheel: !!(events & CoreMouseEventType.WHEEL)
-    };
+  public get isDefaultEncoding(): boolean {
+    return this._activeEncoding === 'DEFAULT';
   }
 
-  private _equalEvents(e1: ICoreMouseEvent, e2: ICoreMouseEvent, pixels: boolean): boolean {
-    if (pixels) {
-      if (e1.x !== e2.x) return false;
-      if (e1.y !== e2.y) return false;
-    } else {
-      if (e1.col !== e2.col) return false;
-      if (e1.row !== e2.row) return false;
-    }
-    if (e1.button !== e2.button) return false;
-    if (e1.action !== e2.action) return false;
-    if (e1.ctrl !== e2.ctrl) return false;
-    if (e1.alt !== e2.alt) return false;
-    if (e1.shift !== e2.shift) return false;
-    return true;
+  public get isPixelEncoding(): boolean {
+    return this._activeEncoding === 'SGR_PIXELS';
   }
 }

package/src/common/services/OptionsService.ts

@@ -3,16 +3,18 @@
  * @license MIT
  */
 
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { isMac } from 'common/Platform';
 import { CursorStyle, IDisposable } from 'common/Types';
 import { FontWeight, IOptionsService, ITerminalOptions } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   cols: 80,
   rows: 24,
+  showCursorImmediately: false,
   cursorBlink: false,
+  blinkIntervalDuration: 0,
   cursorStyle: 'block',
   cursorWidth: 1,
   cursorInactiveStyle: 'outline',
@@ -30,6 +32,7 @@ export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   logLevel: 'info',
   logger: null,
   scrollback: 1000,
+  scrollbar: { showScrollbar: true },
   scrollOnEraseInDisplay: false,
   scrollOnUserInput: true,
   scrollSensitivity: 1,
@@ -52,8 +55,8 @@ export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   altClickMovesCursor: true,
   convertEol: false,
   termName: 'xterm',
-  cancelEvents: false,
-  overviewRuler: {}
+  quirks: {},
+  vtExtensions: {}
 };
 
 const FONT_WEIGHT_OPTIONS: Extract<FontWeight, string>[] = ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'];
@@ -166,6 +169,12 @@ export class OptionsService extends Disposable implements IOptionsService {
         }
         value = FONT_WEIGHT_OPTIONS.includes(value) ? value : DEFAULT_OPTIONS[key];
         break;
+      case 'blinkIntervalDuration':
+        value = Math.floor(value);
+        if (value < 0) {
+          throw new Error(`${key} cannot be less than 0, value: ${value}`);
+        }
+        break;
       case 'cursorWidth':
         value = Math.floor(value);
         // Fall through for bounds check

package/src/common/services/ServiceRegistry.ts

@@ -11,13 +11,15 @@
 
 import { IServiceIdentifier } from 'common/services/Services';
 
-const DI_TARGET = 'di$target';
-const DI_DEPENDENCIES = 'di$dependencies';
+const enum Constants {
+  DI_TARGET = 'di$target',
+  DI_DEPENDENCIES = 'di$dependencies'
+}
 
 export const serviceRegistry: Map<string, IServiceIdentifier<any>> = new Map();
 
 export function getServiceDependencies(ctor: any): { id: IServiceIdentifier<any>, index: number, optional: boolean }[] {
-  return ctor[DI_DEPENDENCIES] || [];
+  return ctor[Constants.DI_DEPENDENCIES] || [];
 }
 
 export function createDecorator<T>(id: string): IServiceIdentifier<T> {
@@ -40,10 +42,10 @@ export function createDecorator<T>(id: string): IServiceIdentifier<T> {
 }
 
 function storeServiceDependency(id: Function, target: Function, index: number): void {
-  if ((target as any)[DI_TARGET] === target) {
-    (target as any)[DI_DEPENDENCIES].push({ id, index });
+  if ((target as any)[Constants.DI_TARGET] === target) {
+    (target as any)[Constants.DI_DEPENDENCIES].push({ id, index });
   } else {
-    (target as any)[DI_DEPENDENCIES] = [{ id, index }];
-    (target as any)[DI_TARGET] = target;
+    (target as any)[Constants.DI_DEPENDENCIES] = [{ id, index }];
+    (target as any)[Constants.DI_TARGET] = target;
   }
 }