@xterm/xterm 6.1.0-beta.21 → 6.1.0-beta.210

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/Services.ts

@@ -3,11 +3,11 @@
  * @license MIT
  */
 
-import { IDecoration, IDecorationOptions, ILinkHandler, ILogger, IWindowsPty, type IOverviewRulerOptions } from '@xterm/xterm';
-import { CoreMouseEncoding, CoreMouseEventType, CursorInactiveStyle, CursorStyle, IAttributeData, ICharset, IColor, ICoreMouseEvent, ICoreMouseProtocol, IDecPrivateModes, IDisposable, IModes, IOscLinkData, IWindowOptions } from 'common/Types';
+import type { IDecoration, IDecorationOptions, ILinkHandler, ILogger, IWindowsPty, IOverviewRulerOptions } from '@xterm/xterm';
+import { CoreMouseEncoding, CoreMouseEventType, CursorInactiveStyle, CursorStyle, IAttributeData, ICharset, IColor, ICoreMouseEvent, ICoreMouseProtocol, IDecPrivateModes, IDisposable, IKittyKeyboardState, IModes, IOscLinkData, IWindowOptions } from 'common/Types';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
 import { createDecorator } from 'common/services/ServiceRegistry';
-import type { Emitter, Event } from 'vs/base/common/event';
+import type { Emitter, IEvent } from 'common/Event';
 
 export const IBufferService = createDecorator<IBufferService>('BufferService');
 export interface IBufferService {
@@ -18,8 +18,8 @@ export interface IBufferService {
   readonly buffer: IBuffer;
   readonly buffers: IBufferSet;
   isUserScrolling: boolean;
-  onResize: Event<IBufferResizeEvent>;
-  onScroll: Event<number>;
+  onResize: IEvent<IBufferResizeEvent>;
+  onScroll: IEvent<number>;
   scroll(eraseAttr: IAttributeData, isWrapped?: boolean): void;
   scrollLines(disp: number, suppressScrollEvent?: boolean): void;
   resize(cols: number, rows: number): void;
@@ -33,8 +33,8 @@ export interface IBufferResizeEvent {
   rowsChanged: boolean;
 }
 
-export const ICoreMouseService = createDecorator<ICoreMouseService>('CoreMouseService');
-export interface ICoreMouseService {
+export const IMouseStateService = createDecorator<IMouseStateService>('MouseStateService');
+export interface IMouseStateService {
   serviceBrand: undefined;
 
   activeProtocol: string;
@@ -43,33 +43,17 @@ export interface ICoreMouseService {
   addProtocol(name: string, protocol: ICoreMouseProtocol): void;
   addEncoding(name: string, encoding: CoreMouseEncoding): void;
   reset(): void;
-
-  /**
-   * 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.
-   */
-  triggerMouseEvent(event: ICoreMouseEvent): boolean;
+  setCustomWheelEventHandler(customWheelEventHandler: ((event: WheelEvent) => boolean) | undefined): void;
+  allowCustomWheelEvent(ev: WheelEvent): boolean;
 
   /**
    * Event to announce changes in mouse tracking.
    */
-  onProtocolChange: Event<CoreMouseEventType>;
-
-  /**
-   * Human readable version of mouse events.
-   */
-  explainEvents(events: CoreMouseEventType): { [event: string]: boolean };
-
-  /**
-   * Process wheel event taking partial scroll into account.
-   */
-  consumeWheelEvent(ev: WheelEvent, cellHeight?: number, dpr?: number): number;
+  onProtocolChange: IEvent<CoreMouseEventType>;
+  restrictMouseEvent(event: ICoreMouseEvent): boolean;
+  encodeMouseEvent(event: ICoreMouseEvent): string;
+  readonly isDefaultEncoding: boolean;
+  readonly isPixelEncoding: boolean;
 }
 
 export const ICoreService = createDecorator<ICoreService>('CoreService');
@@ -85,11 +69,12 @@ export interface ICoreService {
 
   readonly modes: IModes;
   readonly decPrivateModes: IDecPrivateModes;
+  readonly kittyKeyboard: IKittyKeyboardState;
 
-  readonly onData: Event<string>;
-  readonly onUserInput: Event<void>;
-  readonly onBinary: Event<string>;
-  readonly onRequestScrollToBottom: Event<void>;
+  readonly onData: IEvent<string>;
+  readonly onUserInput: IEvent<void>;
+  readonly onBinary: IEvent<string>;
+  readonly onRequestScrollToBottom: IEvent<void>;
 
   reset(): void;
 
@@ -116,6 +101,7 @@ export interface ICharsetService {
 
   charset: ICharset | undefined;
   readonly glevel: number;
+  readonly charsets: (ICharset | undefined)[];
 
   reset(): void;
 
@@ -199,7 +185,7 @@ export interface IOptionsService {
   /**
    * Adds an event listener for when any option changes.
    */
-  readonly onOptionChange: Event<keyof ITerminalOptions>;
+  readonly onOptionChange: IEvent<keyof ITerminalOptions>;
 
   /**
    * Adds an event listener for when a specific option changes, this is a convenience method that is
@@ -227,6 +213,7 @@ export interface ITerminalOptions {
   cols?: number;
   convertEol?: boolean;
   cursorBlink?: boolean;
+  blinkIntervalDuration?: number;
   cursorStyle?: CursorStyle;
   cursorWidth?: number;
   cursorInactiveStyle?: CursorInactiveStyle;
@@ -251,6 +238,7 @@ export interface ITerminalOptions {
   rescaleOverlappingGlyphs?: boolean;
   rightClickSelectsWord?: boolean;
   rows?: number;
+  showCursorImmediately?: boolean;
   screenReaderMode?: boolean;
   scrollback?: number;
   scrollOnUserInput?: boolean;
@@ -261,11 +249,12 @@ export interface ITerminalOptions {
   windowsPty?: IWindowsPty;
   windowOptions?: IWindowOptions;
   wordSeparator?: string;
-  overviewRuler?: IOverviewRulerOptions;
+  quirks?: ITerminalQuirks;
+  scrollbar?: IScrollbarOptions;
   scrollOnEraseInDisplay?: boolean;
+  vtExtensions?: IVtExtensions;
 
   [key: string]: any;
-  cancelEvents: boolean;
   termName: string;
 }
 
@@ -300,6 +289,24 @@ export interface ITheme {
   extendedAnsi?: string[];
 }
 
+export interface ITerminalQuirks {
+  allowSetCursorBlink?: boolean;
+}
+
+export interface IScrollbarOptions {
+  showScrollbar?: boolean;
+  showArrows?: boolean;
+  width?: number;
+  overviewRuler?: IOverviewRulerOptions;
+}
+
+export interface IVtExtensions {
+  kittyKeyboard?: boolean;
+  kittySgrBoldFaintControl?: boolean;
+  win32InputMode?: boolean;
+  colorSchemeQuery?: boolean;
+}
+
 export const IOscLinkService = createDecorator<IOscLinkService>('OscLinkService');
 export interface IOscLinkService {
   serviceBrand: undefined;
@@ -349,7 +356,7 @@ export interface IUnicodeService {
   /** Currently active version. */
   activeVersion: string;
   /** Event triggered, when activate version changed. */
-  readonly onChange: Event<string>;
+  readonly onChange: IEvent<string>;
 
   /**
    * Unicode version dependent
@@ -374,8 +381,8 @@ export const IDecorationService = createDecorator<IDecorationService>('Decoratio
 export interface IDecorationService extends IDisposable {
   serviceBrand: undefined;
   readonly decorations: IterableIterator<IInternalDecoration>;
-  readonly onDecorationRegistered: Event<IInternalDecoration>;
-  readonly onDecorationRemoved: Event<IInternalDecoration>;
+  readonly onDecorationRegistered: IEvent<IInternalDecoration>;
+  readonly onDecorationRemoved: IEvent<IInternalDecoration>;
   registerDecoration(decorationOptions: IDecorationOptions): IDecoration | undefined;
   reset(): void;
   /**

package/src/common/services/UnicodeService.ts

@@ -5,7 +5,7 @@
 
 import { UnicodeV6 } from 'common/input/UnicodeV6';
 import { IUnicodeService, IUnicodeVersionProvider, UnicodeCharProperties, UnicodeCharWidth } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 export class UnicodeService implements IUnicodeService {
   public serviceBrand: any;