@wendongfly/zihi 1.1.0 → 1.1.2

package/dist/lib/xterm/src/common/parser/Types.ts

@@ -0,0 +1,275 @@
+/**
+ * Copyright (c) 2017 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IDisposable } from 'common/Types';
+import { ParserState } from 'common/parser/Constants';
+
+
+/** sequence params serialized to js arrays */
+export type ParamsArray = (number | number[])[];
+
+/** Params constructor type. */
+export interface IParamsConstructor {
+  new(maxLength: number, maxSubParamsLength: number): IParams;
+
+  /** create params from ParamsArray */
+  fromArray(values: ParamsArray): IParams;
+}
+
+/** Interface of Params storage class. */
+export interface IParams {
+  /** from ctor */
+  maxLength: number;
+  maxSubParamsLength: number;
+
+  /** param values and its length */
+  params: Int32Array;
+  length: number;
+
+  /** methods */
+  clone(): IParams;
+  toArray(): ParamsArray;
+  reset(): void;
+  addParam(value: number): void;
+  addSubParam(value: number): void;
+  hasSubParams(idx: number): boolean;
+  getSubParams(idx: number): Int32Array | null;
+  getSubParamsAll(): {[idx: number]: Int32Array};
+}
+
+/**
+ * Internal state of EscapeSequenceParser.
+ * Used as argument of the error handler to allow
+ * introspection at runtime on parse errors.
+ * Return it with altered values to recover from
+ * faulty states (not yet supported).
+ * Set `abort` to `true` to abort the current parsing.
+ */
+export interface IParsingState {
+  // position in parse string
+  position: number;
+  // actual character code
+  code: number;
+  // current parser state
+  currentState: ParserState;
+  // collect buffer with intermediate characters
+  collect: number;
+  // params buffer
+  params: IParams;
+  // should abort (default: false)
+  abort: boolean;
+}
+
+/**
+ * Command handler interfaces.
+ */
+
+/**
+ * CSI handler types.
+ * Note: `params` is borrowed.
+ */
+export type CsiHandlerType = (params: IParams) => boolean | Promise<boolean>;
+export type CsiFallbackHandlerType = (ident: number, params: IParams) => void;
+
+/**
+ * DCS handler types.
+ */
+export interface IDcsHandler {
+  /**
+   * Called when a DCS command starts.
+   * Prepare needed data structures here.
+   * Note: `params` is borrowed.
+   */
+  hook(params: IParams): void;
+  /**
+   * Incoming payload chunk.
+   * Note: `params` is borrowed.
+   */
+  put(data: Uint32Array, start: number, end: number): void;
+  /**
+   * End of DCS 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.
+   */
+  unhook(success: boolean): boolean | Promise<boolean>;
+}
+export type DcsFallbackHandlerType = (ident: number, action: 'HOOK' | 'PUT' | 'UNHOOK', payload?: any) => void;
+
+/**
+ * ESC handler types.
+ */
+export type EscHandlerType = () => boolean | Promise<boolean>;
+export type EscFallbackHandlerType = (identifier: number) => void;
+
+/**
+ * EXECUTE handler types.
+ */
+export type ExecuteHandlerType = () => boolean;
+export type ExecuteFallbackHandlerType = (ident: number) => void;
+
+/**
+ * OSC handler types.
+ */
+export interface IOscHandler {
+  /**
+   * Announces start of this OSC command.
+   * Prepare needed data structures here.
+   */
+  start(): void;
+  /**
+   * Incoming data chunk.
+   * Note: Data is borrowed.
+   */
+  put(data: Uint32Array, start: number, end: number): void;
+  /**
+   * End of OSC 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 OscFallbackHandlerType = (ident: number, action: 'START' | 'PUT' | 'END', payload?: any) => void;
+
+/**
+ * PRINT handler types.
+ */
+export type PrintHandlerType = (data: Uint32Array, start: number, end: number) => void;
+export type PrintFallbackHandlerType = PrintHandlerType;
+
+
+/**
+ * EscapeSequenceParser interface.
+ */
+export interface IEscapeSequenceParser extends IDisposable {
+  /**
+   * Preceding grapheme-join-state.
+   * Used for joining grapheme clusters across calls to `print`.
+   * Also used by REP to check if repeating a character is allowed.
+   * It gets reset by the parser for any valid sequence besides text.
+   */
+  precedingJoinState: number; // More specifically: UnicodeJoinProperties
+
+  /**
+   * Reset the parser to its initial state (handlers are kept).
+   */
+  reset(): void;
+
+  /**
+   * Parse UTF32 codepoints in `data` up to `length`.
+   * @param data The data to parse.
+   */
+  parse(data: Uint32Array, length: number, promiseResult?: boolean): void | Promise<boolean>;
+
+  /**
+   * Get string from numercial function identifier `ident`.
+   * Useful in fallback handlers which expose the low level
+   * numcerical function identifier for debugging purposes.
+   * Note: A full back translation to `IFunctionIdentifier`
+   * is not implemented.
+   */
+  identToString(ident: number): string;
+
+  setPrintHandler(handler: PrintHandlerType): void;
+  clearPrintHandler(): void;
+
+  registerEscHandler(id: IFunctionIdentifier, handler: EscHandlerType): IDisposable;
+  clearEscHandler(id: IFunctionIdentifier): void;
+  setEscHandlerFallback(handler: EscFallbackHandlerType): void;
+
+  setExecuteHandler(flag: string, handler: ExecuteHandlerType): void;
+  clearExecuteHandler(flag: string): void;
+  setExecuteHandlerFallback(handler: ExecuteFallbackHandlerType): void;
+
+  registerCsiHandler(id: IFunctionIdentifier, handler: CsiHandlerType): IDisposable;
+  clearCsiHandler(id: IFunctionIdentifier): void;
+  setCsiHandlerFallback(callback: CsiFallbackHandlerType): void;
+
+  registerDcsHandler(id: IFunctionIdentifier, handler: IDcsHandler): IDisposable;
+  clearDcsHandler(id: IFunctionIdentifier): void;
+  setDcsHandlerFallback(handler: DcsFallbackHandlerType): void;
+
+  registerOscHandler(ident: number, handler: IOscHandler): IDisposable;
+  clearOscHandler(ident: number): void;
+  setOscHandlerFallback(handler: OscFallbackHandlerType): void;
+
+  setErrorHandler(handler: (state: IParsingState) => IParsingState): void;
+  clearErrorHandler(): void;
+}
+
+/**
+ * Subparser interfaces.
+ * The subparsers are instantiated in `EscapeSequenceParser` and
+ * called during `EscapeSequenceParser.parse`.
+ */
+export interface ISubParser<T, U> extends IDisposable {
+  reset(): void;
+  registerHandler(ident: number, handler: T): IDisposable;
+  clearHandler(ident: number): void;
+  setHandlerFallback(handler: U): void;
+  put(data: Uint32Array, start: number, end: number): void;
+}
+
+export interface IOscParser extends ISubParser<IOscHandler, OscFallbackHandlerType> {
+  start(): void;
+  end(success: boolean, promiseResult?: boolean): void | Promise<boolean>;
+}
+
+export interface IDcsParser extends ISubParser<IDcsHandler, DcsFallbackHandlerType> {
+  hook(ident: number, params: IParams): void;
+  unhook(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
+ * regristation before passed to the subparsers as `ident`.
+ * The integer translation is made to allow a faster handler access
+ * in `EscapeSequenceParser.parse`.
+ */
+export interface IFunctionIdentifier {
+  prefix?: string;
+  intermediates?: string;
+  final: string;
+}
+
+export interface IHandlerCollection<T> {
+  [key: string]: T[];
+}
+
+/**
+ * Types for async parser support.
+ */
+
+// type of saved stack state in parser
+export const enum ParserStackType {
+  NONE = 0,
+  FAIL,
+  RESET,
+  CSI,
+  ESC,
+  OSC,
+  DCS
+}
+
+// aggregate of resumable handler lists
+export type ResumableHandlersType = CsiHandlerType[] | EscHandlerType[];
+
+// saved stack state of the parser
+export interface IParserStackState {
+  state: ParserStackType;
+  handlers: ResumableHandlersType;
+  handlerPos: number;
+  transition: number;
+  chunkPos: number;
+}
+
+// saved stack state of subparser (OSC and DCS)
+export interface ISubParserStackState {
+  paused: boolean;
+  loopPosition: number;
+  fallThrough: boolean;
+}

package/dist/lib/xterm/src/common/public/AddonManager.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { ITerminalAddon, IDisposable, Terminal } from 'xterm';
+import { ITerminalAddon, IDisposable, Terminal } from '@xterm/xterm';
 
 export interface ILoadedAddon {
   instance: ITerminalAddon;

package/dist/lib/xterm/src/common/public/BufferApiView.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { IBuffer as IBufferApi, IBufferLine as IBufferLineApi, IBufferCell as IBufferCellApi } from 'xterm';
+import { IBuffer as IBufferApi, IBufferLine as IBufferLineApi, IBufferCell as IBufferCellApi } from '@xterm/xterm';
 import { IBuffer } from 'common/buffer/Types';
 import { BufferLineApiView } from 'common/public/BufferLineApiView';
 import { CellData } from 'common/buffer/CellData';

package/dist/lib/xterm/src/common/public/BufferLineApiView.ts

@@ -5,7 +5,7 @@
 
 import { CellData } from 'common/buffer/CellData';
 import { IBufferLine, ICellData } from 'common/Types';
-import { IBufferCell as IBufferCellApi, IBufferLine as IBufferLineApi } from 'xterm';
+import { IBufferCell as IBufferCellApi, IBufferLine as IBufferLineApi } from '@xterm/xterm';
 
 export class BufferLineApiView implements IBufferLineApi {
   constructor(private _line: IBufferLine) { }

package/dist/lib/xterm/src/common/public/BufferNamespaceApi.ts

@@ -3,17 +3,17 @@
  * @license MIT
  */
 
-import { IBuffer as IBufferApi, IBufferNamespace as IBufferNamespaceApi } from 'xterm';
+import { IBuffer as IBufferApi, IBufferNamespace as IBufferNamespaceApi } from '@xterm/xterm';
 import { BufferApiView } from 'common/public/BufferApiView';
-import { EventEmitter } from 'common/EventEmitter';
 import { ICoreTerminal } from 'common/Types';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { Emitter } from 'vs/base/common/event';
 
 export class BufferNamespaceApi extends Disposable implements IBufferNamespaceApi {
   private _normal: BufferApiView;
   private _alternate: BufferApiView;
 
-  private readonly _onBufferChange = this.register(new EventEmitter<IBufferApi>());
+  private readonly _onBufferChange = this._register(new Emitter<IBufferApi>());
   public readonly onBufferChange = this._onBufferChange.event;
 
   constructor(private _core: ICoreTerminal) {

package/dist/lib/xterm/src/common/public/ParserApi.ts

@@ -4,7 +4,7 @@
  */
 
 import { IParams } from 'common/parser/Types';
-import { IDisposable, IFunctionIdentifier, IParser } from 'xterm';
+import { IDisposable, IFunctionIdentifier, IParser } from '@xterm/xterm';
 import { ICoreTerminal } from 'common/Types';
 
 export class ParserApi implements IParser {

package/dist/lib/xterm/src/common/public/UnicodeApi.ts

@@ -4,7 +4,7 @@
  */
 
 import { ICoreTerminal } from 'common/Types';
-import { IUnicodeHandling, IUnicodeVersionProvider } from 'xterm';
+import { IUnicodeHandling, IUnicodeVersionProvider } from '@xterm/xterm';
 
 export class UnicodeApi implements IUnicodeHandling {
   constructor(private _core: ICoreTerminal) { }

package/dist/lib/xterm/src/common/services/BufferService.ts

@@ -3,12 +3,12 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable } from 'common/Lifecycle';
-import { IAttributeData, IBufferLine, ScrollSource } from 'common/Types';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { IAttributeData, IBufferLine } from 'common/Types';
 import { BufferSet } from 'common/buffer/BufferSet';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IBufferService, IOptionsService } from 'common/services/Services';
+import { IBufferService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services';
+import { Emitter } from 'vs/base/common/event';
 
 export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
 export const MINIMUM_ROWS = 1;
@@ -22,9 +22,9 @@ export class BufferService extends Disposable implements IBufferService {
   /** Whether the user is scrolling (locks the scroll position) */
   public isUserScrolling: boolean = false;
 
-  private readonly _onResize = this.register(new EventEmitter<{ cols: number, rows: number }>());
+  private readonly _onResize = this._register(new Emitter<IBufferResizeEvent>());
   public readonly onResize = this._onResize.event;
-  private readonly _onScroll = this.register(new EventEmitter<number>());
+  private readonly _onScroll = this._register(new Emitter<number>());
   public readonly onScroll = this._onScroll.event;
 
   public get buffer(): IBuffer { return this.buffers.active; }
@@ -36,16 +36,19 @@ export class BufferService extends Disposable implements IBufferService {
     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.buffers = this._register(new BufferSet(optionsService, this));
+    this._register(this.buffers.onBufferActivate(e => {
+      this._onScroll.fire(e.activeBuffer.ydisp);
+    }));
   }
 
   public resize(cols: number, rows: number): void {
+    const colsChanged = this.cols !== cols;
+    const rowsChanged = this.rows !== rows;
     this.cols = cols;
     this.rows = rows;
     this.buffers.resize(cols, rows);
-    // TODO: This doesn't fire when scrollback changes - add a resize event to BufferSet and forward
-    //       event
-    this._onResize.fire({ cols, rows });
+    this._onResize.fire({ cols, rows, colsChanged, rowsChanged });
   }
 
   public reset(): void {
@@ -125,7 +128,7 @@ export class BufferService extends Disposable implements IBufferService {
    * to avoid unwanted events being handled by the viewport when the event was triggered from the
    * viewport originally.
    */
-  public scrollLines(disp: number, suppressScrollEvent?: boolean, source?: ScrollSource): void {
+  public scrollLines(disp: number, suppressScrollEvent?: boolean): void {
     const buffer = this.buffer;
     if (disp < 0) {
       if (buffer.ydisp === 0) {

package/dist/lib/xterm/src/common/services/CoreMouseService.ts

@@ -2,10 +2,10 @@
  * Copyright (c) 2019 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-import { IBufferService, ICoreService, ICoreMouseService } from 'common/services/Services';
-import { EventEmitter } from 'common/EventEmitter';
+import { IBufferService, ICoreService, ICoreMouseService, IOptionsService } from 'common/services/Services';
 import { ICoreMouseProtocol, ICoreMouseEvent, CoreMouseEncoding, CoreMouseEventType, CoreMouseButton, CoreMouseAction } from 'common/Types';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { Emitter } from 'vs/base/common/event';
 
 /**
  * Supported default protocols.
@@ -167,18 +167,22 @@ const DEFAULT_ENCODINGS: { [key: string]: CoreMouseEncoding } = {
  * To send a mouse event call `triggerMouseEvent`.
  */
 export class CoreMouseService extends Disposable implements ICoreMouseService {
+  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 readonly _onProtocolChange = this.register(new EventEmitter<CoreMouseEventType>());
-  public readonly onProtocolChange =  this._onProtocolChange.event;
+  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
+    @ICoreService private readonly _coreService: ICoreService,
+    @IOptionsService private readonly _optionsService: IOptionsService
   ) {
     super();
     // register default protocols and encodings
@@ -227,6 +231,49 @@ export class CoreMouseService extends Disposable implements ICoreMouseService {
     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;
+  }
+
+  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;
   }
 
   /**

package/dist/lib/xterm/src/common/services/CoreService.ts

@@ -4,10 +4,10 @@
  */
 
 import { clone } from 'common/Clone';
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { IDecPrivateModes, IModes } from 'common/Types';
 import { IBufferService, ICoreService, ILogService, IOptionsService } from 'common/services/Services';
+import { Emitter } from 'vs/base/common/event';
 
 const DEFAULT_MODES: IModes = Object.freeze({
   insertMode: false
@@ -17,9 +17,12 @@ const DEFAULT_DEC_PRIVATE_MODES: IDecPrivateModes = Object.freeze({
   applicationCursorKeys: false,
   applicationKeypad: false,
   bracketedPasteMode: false,
+  cursorBlink: undefined,
+  cursorStyle: undefined,
   origin: false,
   reverseWraparound: false,
   sendFocus: false,
+  synchronizedOutput: false,
   wraparound: true // defaults: xterm - true, vt100 - false
 });
 
@@ -31,13 +34,13 @@ export class CoreService extends Disposable implements ICoreService {
   public modes: IModes;
   public decPrivateModes: IDecPrivateModes;
 
-  private readonly _onData = this.register(new EventEmitter<string>());
+  private readonly _onData = this._register(new Emitter<string>());
   public readonly onData = this._onData.event;
-  private readonly _onUserInput = this.register(new EventEmitter<void>());
+  private readonly _onUserInput = this._register(new Emitter<void>());
   public readonly onUserInput = this._onUserInput.event;
-  private readonly _onBinary = this.register(new EventEmitter<string>());
+  private readonly _onBinary = this._register(new Emitter<string>());
   public readonly onBinary = this._onBinary.event;
-  private readonly _onRequestScrollToBottom = this.register(new EventEmitter<void>());
+  private readonly _onRequestScrollToBottom = this._register(new Emitter<void>());
   public readonly onRequestScrollToBottom = this._onRequestScrollToBottom.event;
 
   constructor(
@@ -73,7 +76,8 @@ export class CoreService extends Disposable implements ICoreService {
     }
 
     // Fire onData API
-    this._logService.debug(`sending data "${data}"`, () => data.split('').map(e => e.charCodeAt(0)));
+    this._logService.debug(`sending data "${data}"`);
+    this._logService.trace(`sending data (codes)`, () => data.split('').map(e => e.charCodeAt(0)));
     this._onData.fire(data);
   }
 
@@ -81,7 +85,8 @@ export class CoreService extends Disposable implements ICoreService {
     if (this._optionsService.rawOptions.disableStdin) {
       return;
     }
-    this._logService.debug(`sending binary "${data}"`, () => data.split('').map(e => e.charCodeAt(0)));
+    this._logService.debug(`sending binary "${data}"`);
+    this._logService.trace(`sending binary (codes)`, () => data.split('').map(e => e.charCodeAt(0)));
     this._onBinary.fire(data);
   }
 }

package/dist/lib/xterm/src/common/services/DecorationService.ts

@@ -4,12 +4,12 @@
  */
 
 import { css } from 'common/Color';
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
 import { IDecorationService, IInternalDecoration } from 'common/services/Services';
 import { SortedList } from 'common/SortedList';
 import { IColor } from 'common/Types';
-import { IDecoration, IDecorationOptions, IMarker } from 'xterm';
+import { IDecoration, IDecorationOptions, IMarker } from '@xterm/xterm';
+import { Emitter } from 'vs/base/common/event';
 
 // Work variables to avoid garbage collection
 let $xmin = 0;
@@ -25,9 +25,9 @@ export class DecorationService extends Disposable implements IDecorationService
    */
   private readonly _decorations: SortedList<IInternalDecoration> = new SortedList(e => e?.marker.line);
 
-  private readonly _onDecorationRegistered = this.register(new EventEmitter<IInternalDecoration>());
+  private readonly _onDecorationRegistered = this._register(new Emitter<IInternalDecoration>());
   public readonly onDecorationRegistered = this._onDecorationRegistered.event;
-  private readonly _onDecorationRemoved = this.register(new EventEmitter<IInternalDecoration>());
+  private readonly _onDecorationRemoved = this._register(new Emitter<IInternalDecoration>());
   public readonly onDecorationRemoved = this._onDecorationRemoved.event;
 
   public get decorations(): IterableIterator<IInternalDecoration> { return this._decorations.values(); }
@@ -35,7 +35,7 @@ export class DecorationService extends Disposable implements IDecorationService
   constructor() {
     super();
 
-    this.register(toDisposable(() => this.reset()));
+    this._register(toDisposable(() => this.reset()));
   }
 
   public registerDecoration(options: IDecorationOptions): IDecoration | undefined {
@@ -45,7 +45,8 @@ export class DecorationService extends Disposable implements IDecorationService
     const decoration = new Decoration(options);
     if (decoration) {
       const markerDispose = decoration.marker.onDispose(() => decoration.dispose());
-      decoration.onDispose(() => {
+      const listener = decoration.onDispose(() => {
+        listener.dispose();
         if (decoration) {
           if (this._decorations.delete(decoration)) {
             this._onDecorationRemoved.fire(decoration);
@@ -89,14 +90,13 @@ export class DecorationService extends Disposable implements IDecorationService
   }
 }
 
-class Decoration extends Disposable implements IInternalDecoration {
+class Decoration extends DisposableStore implements IInternalDecoration {
   public readonly marker: IMarker;
   public element: HTMLElement | undefined;
-  public get isDisposed(): boolean { return this._isDisposed; }
 
-  public readonly onRenderEmitter = this.register(new EventEmitter<HTMLElement>());
+  public readonly onRenderEmitter = this.add(new Emitter<HTMLElement>());
   public readonly onRender = this.onRenderEmitter.event;
-  private readonly _onDispose = this.register(new EventEmitter<void>());
+  private readonly _onDispose = this.add(new Emitter<void>());
   public readonly onDispose = this._onDispose.event;
 
   private _cachedBg: IColor | undefined | null = null;

package/dist/lib/xterm/src/common/services/InstantiationService.ts

@@ -67,7 +67,7 @@ export class InstantiationService implements IInstantiationService {
     for (const dependency of serviceDependencies) {
       const service = this._services.get(dependency.id);
       if (!service) {
-        throw new Error(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`);
+        throw new Error(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id._id}.`);
       }
       serviceArgs.push(service);
     }

package/dist/lib/xterm/src/common/services/LogService.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { ILogService, IOptionsService, LogLevelEnum } from 'common/services/Services';
 
 type LogType = (message?: any, ...optionalParams: any[]) => void;
@@ -42,7 +42,7 @@ export class LogService extends Disposable implements ILogService {
   ) {
     super();
     this._updateLogLevel();
-    this.register(this._optionsService.onSpecificOptionChange('logLevel', () => this._updateLogLevel()));
+    this._register(this._optionsService.onSpecificOptionChange('logLevel', () => this._updateLogLevel()));
 
     // For trace logging, assume the latest created log service is valid
     traceLogger = this;