@xterm/xterm 5.6.0-beta.6 → 5.6.0-beta.61

package/src/common/InputHandler.ts

@@ -8,10 +8,9 @@ import { IInputHandler, IAttributeData, IDisposable, IWindowOptions, IColorEvent
 import { C0, C1 } from 'common/data/EscapeSequences';
 import { CHARSETS, DEFAULT_CHARSET } from 'common/data/Charsets';
 import { EscapeSequenceParser } from 'common/parser/EscapeSequenceParser';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { StringToUtf32, stringFromCodePoint, Utf8ToUtf32 } from 'common/input/TextDecoder';
 import { BufferLine, DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine';
-import { EventEmitter } from 'common/EventEmitter';
 import { IParsingState, IEscapeSequenceParser, IParams, IFunctionIdentifier } from 'common/parser/Types';
 import { NULL_CELL_CODE, NULL_CELL_WIDTH, Attributes, FgFlags, BgFlags, Content, UnderlineStyle } from 'common/buffer/Constants';
 import { CellData } from 'common/buffer/CellData';
@@ -22,6 +21,7 @@ import { OscHandler } from 'common/parser/OscParser';
 import { DcsHandler } from 'common/parser/DcsParser';
 import { IBuffer } from 'common/buffer/Types';
 import { parseColor } from 'common/input/XParseColor';
+import { Emitter } from 'vs/base/common/event';
 
 /**
  * Map collect to glevel. Used in `selectCharset`.
@@ -119,7 +119,6 @@ export class InputHandler extends Disposable implements IInputHandler {
   private _parseBuffer: Uint32Array = new Uint32Array(4096);
   private _stringDecoder: StringToUtf32 = new StringToUtf32();
   private _utf8Decoder: Utf8ToUtf32 = new Utf8ToUtf32();
-  private _workCell: CellData = new CellData();
   private _windowTitle = '';
   private _iconName = '';
   private _dirtyRowTracker: IDirtyRowTracker;
@@ -132,32 +131,32 @@ export class InputHandler extends Disposable implements IInputHandler {
 
   private _activeBuffer: IBuffer;
 
-  private readonly _onRequestBell = this.register(new EventEmitter<void>());
+  private readonly _onRequestBell = this._register(new Emitter<void>());
   public readonly onRequestBell = this._onRequestBell.event;
-  private readonly _onRequestRefreshRows = this.register(new EventEmitter<number, number>());
+  private readonly _onRequestRefreshRows = this._register(new Emitter<{ start: number, end: number } | undefined>());
   public readonly onRequestRefreshRows = this._onRequestRefreshRows.event;
-  private readonly _onRequestReset = this.register(new EventEmitter<void>());
+  private readonly _onRequestReset = this._register(new Emitter<void>());
   public readonly onRequestReset = this._onRequestReset.event;
-  private readonly _onRequestSendFocus = this.register(new EventEmitter<void>());
+  private readonly _onRequestSendFocus = this._register(new Emitter<void>());
   public readonly onRequestSendFocus = this._onRequestSendFocus.event;
-  private readonly _onRequestSyncScrollBar = this.register(new EventEmitter<void>());
+  private readonly _onRequestSyncScrollBar = this._register(new Emitter<void>());
   public readonly onRequestSyncScrollBar = this._onRequestSyncScrollBar.event;
-  private readonly _onRequestWindowsOptionsReport = this.register(new EventEmitter<WindowsOptionsReportType>());
+  private readonly _onRequestWindowsOptionsReport = this._register(new Emitter<WindowsOptionsReportType>());
   public readonly onRequestWindowsOptionsReport = this._onRequestWindowsOptionsReport.event;
 
-  private readonly _onA11yChar = this.register(new EventEmitter<string>());
+  private readonly _onA11yChar = this._register(new Emitter<string>());
   public readonly onA11yChar = this._onA11yChar.event;
-  private readonly _onA11yTab = this.register(new EventEmitter<number>());
+  private readonly _onA11yTab = this._register(new Emitter<number>());
   public readonly onA11yTab = this._onA11yTab.event;
-  private readonly _onCursorMove = this.register(new EventEmitter<void>());
+  private readonly _onCursorMove = this._register(new Emitter<void>());
   public readonly onCursorMove = this._onCursorMove.event;
-  private readonly _onLineFeed = this.register(new EventEmitter<void>());
+  private readonly _onLineFeed = this._register(new Emitter<void>());
   public readonly onLineFeed = this._onLineFeed.event;
-  private readonly _onScroll = this.register(new EventEmitter<number>());
+  private readonly _onScroll = this._register(new Emitter<number>());
   public readonly onScroll = this._onScroll.event;
-  private readonly _onTitleChange = this.register(new EventEmitter<string>());
+  private readonly _onTitleChange = this._register(new Emitter<string>());
   public readonly onTitleChange = this._onTitleChange.event;
-  private readonly _onColor = this.register(new EventEmitter<IColorEvent>());
+  private readonly _onColor = this._register(new Emitter<IColorEvent>());
   public readonly onColor = this._onColor.event;
 
   private _parseStack: IParseStack = {
@@ -180,12 +179,12 @@ export class InputHandler extends Disposable implements IInputHandler {
     private readonly _parser: IEscapeSequenceParser = new EscapeSequenceParser()
   ) {
     super();
-    this.register(this._parser);
+    this._register(this._parser);
     this._dirtyRowTracker = new DirtyRowTracker(this._bufferService);
 
     // Track properties used in performance critical code manually to avoid using slow getters
     this._activeBuffer = this._bufferService.buffer;
-    this.register(this._bufferService.buffers.onBufferActivate(e => this._activeBuffer = e.activeBuffer));
+    this._register(this._bufferService.buffers.onBufferActivate(e => this._activeBuffer = e.activeBuffer));
 
     /**
      * custom fallback handlers
@@ -500,7 +499,10 @@ export class InputHandler extends Disposable implements IInputHandler {
     const viewportEnd = this._dirtyRowTracker.end + (this._bufferService.buffer.ybase - this._bufferService.buffer.ydisp);
     const viewportStart = this._dirtyRowTracker.start + (this._bufferService.buffer.ybase - this._bufferService.buffer.ydisp);
     if (viewportStart < this._bufferService.rows) {
-      this._onRequestRefreshRows.fire(Math.min(viewportStart, this._bufferService.rows - 1), Math.min(viewportEnd, this._bufferService.rows - 1));
+      this._onRequestRefreshRows.fire({
+        start: Math.min(viewportStart, this._bufferService.rows - 1),
+        end: Math.min(viewportEnd, this._bufferService.rows - 1)
+      });
     }
   }
 
@@ -1943,7 +1945,7 @@ export class InputHandler extends Disposable implements IInputHandler {
         case 1047: // alt screen buffer
           this._bufferService.buffers.activateAltBuffer(this._eraseAttrData());
           this._coreService.isCursorInitialized = true;
-          this._onRequestRefreshRows.fire(0, this._bufferService.rows - 1);
+          this._onRequestRefreshRows.fire(undefined);
           this._onRequestSyncScrollBar.fire();
           break;
         case 2004: // bracketed paste mode (https://cirw.in/blog/bracketed-paste)
@@ -2171,7 +2173,7 @@ export class InputHandler extends Disposable implements IInputHandler {
             this.restoreCursor();
           }
           this._coreService.isCursorInitialized = true;
-          this._onRequestRefreshRows.fire(0, this._bufferService.rows - 1);
+          this._onRequestRefreshRows.fire(undefined);
           this._onRequestSyncScrollBar.fire();
           break;
         case 2004: // bracketed paste mode (https://cirw.in/blog/bracketed-paste)
@@ -2972,14 +2974,18 @@ export class InputHandler extends Disposable implements IInputHandler {
    * feedback. Use `OSC 8 ; ; BEL` to finish the current hyperlink.
    */
   public setHyperlink(data: string): boolean {
-    const args = data.split(';');
-    if (args.length < 2) {
-      return false;
+    // Arg parsing is special cases to support unencoded semi-colons in the URIs (#4944)
+    const idx = data.indexOf(';');
+    if (idx === -1) {
+      // malformed sequence, just return as handled
+      return true;
     }
-    if (args[1]) {
-      return this._createHyperlink(args[0], args[1]);
+    const id = data.slice(0, idx).trim();
+    const uri = data.slice(idx + 1);
+    if (uri) {
+      return this._createHyperlink(id, uri);
     }
-    if (args[0].trim()) {
+    if (id.trim()) {
       return false;
     }
     return this._finishHyperlink();
@@ -3452,6 +3458,6 @@ class DirtyRowTracker implements IDirtyRowTracker {
   }
 }
 
-function isValidColorIndex(value: number): value is ColorIndex {
+export function isValidColorIndex(value: number): value is ColorIndex {
   return 0 <= value && value < 256;
 }

package/src/common/{Types.d.ts → Types.ts}

@@ -4,12 +4,12 @@
  */
 
 import { IDeleteEvent, IInsertEvent } from 'common/CircularList';
-import { IEvent, IEventEmitter } from 'common/EventEmitter';
 import { Attributes, UnderlineStyle } from 'common/buffer/Constants'; // eslint-disable-line no-unused-vars
 import { IBufferSet } from 'common/buffer/Types';
 import { IParams } from 'common/parser/Types';
 import { ICoreMouseService, ICoreService, IOptionsService, IUnicodeService } from 'common/services/Services';
 import { IFunctionIdentifier, ITerminalOptions as IPublicTerminalOptions } from '@xterm/xterm';
+import type { Emitter, Event } from 'vs/base/common/event';
 
 export interface ICoreTerminal {
   coreMouseService: ICoreMouseService;
@@ -60,12 +60,6 @@ export interface IKeyboardEvent {
 
 export interface IScrollEvent {
   position: number;
-  source: ScrollSource;
-}
-
-export const enum ScrollSource {
-  TERMINAL,
-  VIEWPORT,
 }
 
 export interface ICircularList<T> {
@@ -73,12 +67,12 @@ export interface ICircularList<T> {
   maxLength: number;
   isFull: boolean;
 
-  onDeleteEmitter: IEventEmitter<IDeleteEvent>;
-  onDelete: IEvent<IDeleteEvent>;
-  onInsertEmitter: IEventEmitter<IInsertEvent>;
-  onInsert: IEvent<IInsertEvent>;
-  onTrimEmitter: IEventEmitter<number>;
-  onTrim: IEvent<number>;
+  onDeleteEmitter: Emitter<IDeleteEvent>;
+  onDelete: Event<IDeleteEvent>;
+  onInsertEmitter: Emitter<IInsertEvent>;
+  onInsert: Event<IInsertEvent>;
+  onTrimEmitter: Emitter<number>;
+  onTrim: Event<number>;
 
   get(index: number): T | undefined;
   set(index: number, value: T): void;
@@ -264,7 +258,7 @@ export interface IMarker extends IDisposable {
   readonly id: number;
   readonly isDisposed: boolean;
   readonly line: number;
-  onDispose: IEvent<void>;
+  onDispose: Event<void>;
 }
 export interface IModes {
   insertMode: boolean;
@@ -425,8 +419,8 @@ type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] exte
   : Enumerate<N, [...Acc, Acc['length']]>;
 type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
 
-type ColorIndex = IntRange<0, 256>; // number from 0 to 255
-type AllColorIndex = ColorIndex | SpecialColorIndex;
+export type ColorIndex = IntRange<0, 256>; // number from 0 to 255
+export type AllColorIndex = ColorIndex | SpecialColorIndex;
 export const enum SpecialColorIndex {
   FOREGROUND = 256,
   BACKGROUND = 257,
@@ -452,7 +446,7 @@ export type IColorEvent = (IColorReportRequest | IColorSetRequest | IColorRestor
  * Calls the parser and handles actions generated by the parser.
  */
 export interface IInputHandler {
-  onTitleChange: IEvent<string>;
+  onTitleChange: Event<string>;
 
   parse(data: string | Uint8Array, promiseResult?: boolean): void | Promise<boolean>;
   print(data: Uint32Array, start: number, end: number): void;

package/src/common/buffer/Buffer.ts

@@ -161,6 +161,10 @@ export class Buffer implements IBuffer {
       this.lines.maxLength = newMaxLength;
     }
 
+    // if (this._cols > newCols) {
+    //   console.log('increase!');
+    // }
+
     // The following adjustments should only happen if the buffer has been
     // initialized/filled.
     if (this.lines.length > 0) {
@@ -611,8 +615,8 @@ export class Buffer implements IBuffer {
     this._isClearing = true;
     for (let i = 0; i < this.markers.length; i++) {
       this.markers[i].dispose();
-      this.markers.splice(i--, 1);
     }
+    this.markers.length = 0;
     this._isClearing = false;
   }
 

package/src/common/buffer/BufferSet.ts

@@ -3,12 +3,12 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { IAttributeData } from 'common/Types';
 import { Buffer } from 'common/buffer/Buffer';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
 import { IBufferService, IOptionsService } from 'common/services/Services';
+import { Emitter } from 'vs/base/common/event';
 
 /**
  * The BufferSet represents the set of two buffers used by xterm terminals (normal and alt) and
@@ -19,7 +19,7 @@ export class BufferSet extends Disposable implements IBufferSet {
   private _alt!: Buffer;
   private _activeBuffer!: Buffer;
 
-  private readonly _onBufferActivate = this.register(new EventEmitter<{activeBuffer: IBuffer, inactiveBuffer: IBuffer}>());
+  private readonly _onBufferActivate = this._register(new Emitter<{ activeBuffer: IBuffer, inactiveBuffer: IBuffer }>());
   public readonly onBufferActivate = this._onBufferActivate.event;
 
   /**
@@ -31,8 +31,8 @@ export class BufferSet extends Disposable implements IBufferSet {
   ) {
     super();
     this.reset();
-    this.register(this._optionsService.onSpecificOptionChange('scrollback', () => this.resize(this._bufferService.cols, this._bufferService.rows)));
-    this.register(this._optionsService.onSpecificOptionChange('tabStopWidth', () => this.setupTabStops()));
+    this._register(this._optionsService.onSpecificOptionChange('scrollback', () => this.resize(this._bufferService.cols, this._bufferService.rows)));
+    this._register(this._optionsService.onSpecificOptionChange('tabStopWidth', () => this.setupTabStops()));
   }
 
   public reset(): void {

package/src/common/buffer/Marker.ts

@@ -3,9 +3,9 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
-import { disposeArray } from 'common/Lifecycle';
 import { IDisposable, IMarker } from 'common/Types';
+import { Emitter } from 'vs/base/common/event';
+import { dispose } from 'vs/base/common/lifecycle';
 
 export class Marker implements IMarker {
   private static _nextId = 1;
@@ -16,7 +16,7 @@ export class Marker implements IMarker {
   private readonly _id: number = Marker._nextId++;
   public get id(): number { return this._id; }
 
-  private readonly _onDispose = this.register(new EventEmitter<void>());
+  private readonly _onDispose = this.register(new Emitter<void>());
   public readonly onDispose = this._onDispose.event;
 
   constructor(
@@ -32,7 +32,7 @@ export class Marker implements IMarker {
     this.line = -1;
     // Emit before super.dispose such that dispose listeners get a change to react
     this._onDispose.fire();
-    disposeArray(this._disposables);
+    dispose(this._disposables);
     this._disposables.length = 0;
   }
 

package/src/common/buffer/{Types.d.ts → Types.ts}

@@ -4,7 +4,7 @@
  */
 
 import { IAttributeData, ICircularList, IBufferLine, ICellData, IMarker, ICharset, IDisposable } from 'common/Types';
-import { IEvent } from 'common/EventEmitter';
+import type { Event } from 'vs/base/common/event';
 
 // BufferIndex denotes a position in the buffer: [rowIndex, colIndex]
 export type BufferIndex = [number, number];
@@ -42,7 +42,7 @@ export interface IBufferSet extends IDisposable {
   normal: IBuffer;
   active: IBuffer;
 
-  onBufferActivate: IEvent<{ activeBuffer: IBuffer, inactiveBuffer: IBuffer }>;
+  onBufferActivate: Event<{ activeBuffer: IBuffer, inactiveBuffer: IBuffer }>;
 
   activateNormalBuffer(): void;
   activateAltBuffer(fillAttr?: IAttributeData): void;

package/src/common/input/WriteBuffer.ts

@@ -4,8 +4,8 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
+import { Emitter } from 'vs/base/common/event';
 
 declare const setTimeout: (handler: () => void, timeout?: number) => void;
 
@@ -43,7 +43,7 @@ export class WriteBuffer extends Disposable {
   private _syncCalls = 0;
   private _didUserInput = false;
 
-  private readonly _onWriteParsed = this.register(new EventEmitter<void>());
+  private readonly _onWriteParsed = this._register(new Emitter<void>());
   public readonly onWriteParsed = this._onWriteParsed.event;
 
   constructor(private _action: (data: string | Uint8Array, promiseResult?: boolean) => void | Promise<boolean>) {

package/src/common/parser/EscapeSequenceParser.ts

@@ -5,7 +5,7 @@
 
 import { IParsingState, IDcsHandler, IEscapeSequenceParser, IParams, IOscHandler, IHandlerCollection, CsiHandlerType, OscFallbackHandlerType, IOscParser, EscHandlerType, IDcsParser, DcsFallbackHandlerType, IFunctionIdentifier, ExecuteFallbackHandlerType, CsiFallbackHandlerType, EscFallbackHandlerType, PrintHandlerType, PrintFallbackHandlerType, ExecuteHandlerType, IParserStackState, ParserStackType, ResumableHandlersType } from 'common/parser/Types';
 import { ParserState, ParserAction } from 'common/parser/Constants';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { IDisposable } from 'common/Types';
 import { Params } from 'common/parser/Params';
 import { OscParser } from 'common/parser/OscParser';
@@ -283,13 +283,13 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     this._executeHandlers = Object.create(null);
     this._csiHandlers = Object.create(null);
     this._escHandlers = Object.create(null);
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
       this._csiHandlers = Object.create(null);
       this._executeHandlers = Object.create(null);
       this._escHandlers = Object.create(null);
     }));
-    this._oscParser = this.register(new OscParser());
-    this._dcsParser = this.register(new DcsParser());
+    this._oscParser = this._register(new OscParser());
+    this._dcsParser = this._register(new DcsParser());
     this._errorHandler = this._errorHandlerFb;
 
     // swallow 7bit ST (ESC+\)

package/src/common/public/BufferNamespaceApi.ts

@@ -5,15 +5,15 @@
 
 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/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 { 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<{ cols: number, rows: number }>());
   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,7 +36,7 @@ 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));
   }
 
   public resize(cols: number, rows: number): void {
@@ -125,7 +125,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/src/common/services/CoreMouseService.ts

@@ -3,9 +3,9 @@
  * @license MIT
  */
 import { IBufferService, ICoreService, ICoreMouseService } from 'common/services/Services';
-import { EventEmitter } from 'common/EventEmitter';
 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,13 +167,15 @@ 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 readonly _onProtocolChange = this.register(new EventEmitter<CoreMouseEventType>());
+  private readonly _onProtocolChange = this._register(new Emitter<CoreMouseEventType>());
   public readonly onProtocolChange =  this._onProtocolChange.event;
 
   constructor(

package/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
@@ -31,13 +31,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(

package/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/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 {
@@ -90,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/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;

package/src/common/services/OptionsService.ts

@@ -3,11 +3,11 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/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';
 
 export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   cols: 80,
@@ -54,7 +54,7 @@ export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   convertEol: false,
   termName: 'xterm',
   cancelEvents: false,
-  overviewRulerWidth: 0
+  overviewRuler: {}
 };
 
 const FONT_WEIGHT_OPTIONS: Extract<FontWeight, string>[] = ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'];
@@ -65,7 +65,7 @@ export class OptionsService extends Disposable implements IOptionsService {
   public readonly rawOptions: Required<ITerminalOptions>;
   public options: Required<ITerminalOptions>;
 
-  private readonly _onOptionChange = this.register(new EventEmitter<keyof ITerminalOptions>());
+  private readonly _onOptionChange = this._register(new Emitter<keyof ITerminalOptions>());
   public readonly onOptionChange = this._onOptionChange.event;
 
   constructor(options: Partial<ITerminalOptions>) {
@@ -90,7 +90,7 @@ export class OptionsService extends Disposable implements IOptionsService {
 
     // Clear out options that could link outside xterm.js as they could easily cause an embedder
     // memory leak
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
       this.rawOptions.linkHandler = null;
       this.rawOptions.documentOverride = null;
     }));