@xterm/xterm 5.6.0-beta.50 → 5.6.0-beta.51

package/src/browser/decorations/OverviewRulerRenderer.ts

@@ -5,7 +5,7 @@
 
 import { ColorZoneStore, IColorZone, IColorZoneStore } from 'browser/decorations/ColorZoneStore';
 import { ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { IBufferService, IDecorationService, IOptionsService } from 'common/services/Services';
 
 const enum Constants {
@@ -63,7 +63,7 @@ export class OverviewRulerRenderer extends Disposable {
     this._canvas.classList.add('xterm-decoration-overview-ruler');
     this._refreshCanvasDimensions();
     this._viewportElement.parentElement?.insertBefore(this._canvas, this._viewportElement);
-    this.register(toDisposable(() => this._canvas?.remove()));
+    this._register(toDisposable(() => this._canvas?.remove()));
 
     const ctx = this._canvas.getContext('2d');
     if (!ctx) {
@@ -72,14 +72,14 @@ export class OverviewRulerRenderer extends Disposable {
       this._ctx = ctx;
     }
 
-    this.register(this._decorationService.onDecorationRegistered(() => this._queueRefresh(undefined, true)));
-    this.register(this._decorationService.onDecorationRemoved(() => this._queueRefresh(undefined, true)));
+    this._register(this._decorationService.onDecorationRegistered(() => this._queueRefresh(undefined, true)));
+    this._register(this._decorationService.onDecorationRemoved(() => this._queueRefresh(undefined, true)));
 
-    this.register(this._renderService.onRenderedViewportChange(() => this._queueRefresh()));
-    this.register(this._bufferService.buffers.onBufferActivate(() => {
+    this._register(this._renderService.onRenderedViewportChange(() => this._queueRefresh()));
+    this._register(this._bufferService.buffers.onBufferActivate(() => {
       this._canvas!.style.display = this._bufferService.buffer === this._bufferService.buffers.alt ? 'none' : 'block';
     }));
-    this.register(this._bufferService.onScroll(() => {
+    this._register(this._bufferService.onScroll(() => {
       if (this._lastKnownBufferLength !== this._bufferService.buffers.normal.lines.length) {
         this._refreshDrawHeightConstants();
         this._refreshColorZonePadding();
@@ -87,16 +87,16 @@ export class OverviewRulerRenderer extends Disposable {
     }));
 
     // Container height changed
-    this.register(this._renderService.onRender((): void => {
+    this._register(this._renderService.onRender((): void => {
       if (!this._containerHeight || this._containerHeight !== this._screenElement.clientHeight) {
         this._queueRefresh(true);
         this._containerHeight = this._screenElement.clientHeight;
       }
     }));
 
-    this.register(this._coreBrowserService.onDprChange(() => this._queueRefresh(true)));
-    this.register(this._optionsService.onSpecificOptionChange('overviewRuler', () => this._queueRefresh(true)));
-    this.register(this._themeService.onChangeColors(() => this._queueRefresh()));
+    this._register(this._coreBrowserService.onDprChange(() => this._queueRefresh(true)));
+    this._register(this._optionsService.onSpecificOptionChange('overviewRuler', () => this._queueRefresh(true)));
+    this._register(this._themeService.onChangeColors(() => this._queueRefresh()));
     this._queueRefresh(true);
   }
 

package/src/browser/public/Terminal.ts

@@ -6,7 +6,7 @@
 import * as Strings from 'browser/LocalizableStrings';
 import { CoreBrowserTerminal as TerminalCore } from 'browser/CoreBrowserTerminal';
 import { IBufferRange, ITerminal } from 'browser/Types';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { ITerminalOptions } from 'common/Types';
 import { AddonManager } from 'common/public/AddonManager';
 import { BufferNamespaceApi } from 'common/public/BufferNamespaceApi';
@@ -32,8 +32,8 @@ export class Terminal extends Disposable implements ITerminalApi {
   constructor(options?: ITerminalOptions & ITerminalInitOnlyOptions) {
     super();
 
-    this._core = this.register(new TerminalCore(options));
-    this._addonManager = this.register(new AddonManager());
+    this._core = this._register(new TerminalCore(options));
+    this._addonManager = this._register(new AddonManager());
 
     this._publicOptions = { ... this._core.options };
     const getter = (propName: string): any => {
@@ -97,7 +97,7 @@ export class Terminal extends Disposable implements ITerminalApi {
   public get cols(): number { return this._core.cols; }
   public get buffer(): IBufferNamespaceApi {
     if (!this._buffer) {
-      this._buffer = this.register(new BufferNamespaceApi(this._core));
+      this._buffer = this._register(new BufferNamespaceApi(this._core));
     }
     return this._buffer;
   }

package/src/browser/renderer/dom/DomRenderer.ts

@@ -12,7 +12,7 @@ import { IRenderDimensions, IRenderer, IRequestRedrawEvent, ISelectionRenderMode
 import { ICharSizeService, ICoreBrowserService, IThemeService } from 'browser/services/Services';
 import { ILinkifier2, ILinkifierEvent, ITerminal, ReadonlyColorSet } from 'browser/Types';
 import { color } from 'common/Color';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { IBufferService, IInstantiationService, IOptionsService } from 'common/services/Services';
 import { Emitter } from 'vs/base/common/event';
 
@@ -45,7 +45,7 @@ export class DomRenderer extends Disposable implements IRenderer {
 
   public dimensions: IRenderDimensions;
 
-  public readonly onRequestRedraw = this.register(new Emitter<IRequestRedrawEvent>()).event;
+  public readonly onRequestRedraw = this._register(new Emitter<IRequestRedrawEvent>()).event;
 
   constructor(
     private readonly _terminal: ITerminal,
@@ -74,9 +74,9 @@ export class DomRenderer extends Disposable implements IRenderer {
 
     this.dimensions = createRenderDimensions();
     this._updateDimensions();
-    this.register(this._optionsService.onOptionChange(() => this._handleOptionsChanged()));
+    this._register(this._optionsService.onOptionChange(() => this._handleOptionsChanged()));
 
-    this.register(this._themeService.onChangeColors(e => this._injectCss(e)));
+    this._register(this._themeService.onChangeColors(e => this._injectCss(e)));
     this._injectCss(this._themeService.colors);
 
     this._rowFactory = instantiationService.createInstance(DomRendererRowFactory, document);
@@ -85,10 +85,10 @@ export class DomRenderer extends Disposable implements IRenderer {
     this._screenElement.appendChild(this._rowContainer);
     this._screenElement.appendChild(this._selectionContainer);
 
-    this.register(this._linkifier2.onShowLinkUnderline(e => this._handleLinkHover(e)));
-    this.register(this._linkifier2.onHideLinkUnderline(e => this._handleLinkLeave(e)));
+    this._register(this._linkifier2.onShowLinkUnderline(e => this._handleLinkHover(e)));
+    this._register(this._linkifier2.onHideLinkUnderline(e => this._handleLinkLeave(e)));
 
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
       this._element.classList.remove(TERMINAL_CLASS_PREFIX + this._terminalClass);
 
       // Outside influences such as React unmounts may manipulate the DOM before our disposal.

package/src/browser/renderer/shared/DevicePixelObserver.ts

@@ -3,8 +3,7 @@
  * @license MIT
  */
 
-import { toDisposable } from 'common/Lifecycle';
-import { IDisposable } from 'common/Types';
+import { toDisposable, IDisposable } from 'vs/base/common/lifecycle';
 
 export function observeDevicePixelDimensions(element: HTMLElement, parentWindow: Window & typeof globalThis, callback: (deviceWidth: number, deviceHeight: number) => void): IDisposable {
   // Observe any resizes to the element and extract the actual pixel size of the element if the

package/src/browser/services/CharSizeService.ts

@@ -5,7 +5,7 @@
 
 import { IOptionsService } from 'common/services/Services';
 import { ICharSizeService } from 'browser/services/Services';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { Emitter } from 'vs/base/common/event';
 
 export class CharSizeService extends Disposable implements ICharSizeService {
@@ -17,7 +17,7 @@ export class CharSizeService extends Disposable implements ICharSizeService {
 
   public get hasValidSize(): boolean { return this.width > 0 && this.height > 0; }
 
-  private readonly _onCharSizeChange = this.register(new Emitter<void>());
+  private readonly _onCharSizeChange = this._register(new Emitter<void>());
   public readonly onCharSizeChange = this._onCharSizeChange.event;
 
   constructor(
@@ -27,11 +27,11 @@ export class CharSizeService extends Disposable implements ICharSizeService {
   ) {
     super();
     try {
-      this._measureStrategy = this.register(new TextMetricsMeasureStrategy(this._optionsService));
+      this._measureStrategy = this._register(new TextMetricsMeasureStrategy(this._optionsService));
     } catch {
-      this._measureStrategy = this.register(new DomMeasureStrategy(document, parentElement, this._optionsService));
+      this._measureStrategy = this._register(new DomMeasureStrategy(document, parentElement, this._optionsService));
     }
-    this.register(this._optionsService.onMultipleOptionChange(['fontFamily', 'fontSize'], () => this.measure()));
+    this._register(this._optionsService.onMultipleOptionChange(['fontFamily', 'fontSize'], () => this.measure()));
   }
 
   public measure(): void {

package/src/browser/services/CoreBrowserService.ts

@@ -3,21 +3,21 @@
  * @license MIT
  */
 
-import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
 import { ICoreBrowserService } from './Services';
-import { addDisposableDomListener } from 'browser/Lifecycle';
 import { Emitter, Event } from 'vs/base/common/event';
+import { addDisposableListener } from 'vs/base/browser/dom';
+import { Disposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
 
 export class CoreBrowserService extends Disposable implements ICoreBrowserService {
   public serviceBrand: undefined;
 
   private _isFocused = false;
   private _cachedIsFocused: boolean | undefined = undefined;
-  private _screenDprMonitor = this.register(new ScreenDprMonitor(this._window));
+  private _screenDprMonitor = this._register(new ScreenDprMonitor(this._window));
 
-  private readonly _onDprChange = this.register(new Emitter<number>());
+  private readonly _onDprChange = this._register(new Emitter<number>());
   public readonly onDprChange = this._onDprChange.event;
-  private readonly _onWindowChange = this.register(new Emitter<Window & typeof globalThis>());
+  private readonly _onWindowChange = this._register(new Emitter<Window & typeof globalThis>());
   public readonly onWindowChange = this._onWindowChange.event;
 
   constructor(
@@ -28,15 +28,11 @@ export class CoreBrowserService extends Disposable implements ICoreBrowserServic
     super();
 
     // Monitor device pixel ratio
-    this.register(this.onWindowChange(w => this._screenDprMonitor.setWindow(w)));
-    this.register(Event.forward(this._screenDprMonitor.onDprChange, this._onDprChange));
-
-    this.register(
-      addDisposableDomListener(this._textarea, 'focus', () => (this._isFocused = true))
-    );
-    this.register(
-      addDisposableDomListener(this._textarea, 'blur', () => (this._isFocused = false))
-    );
+    this._register(this.onWindowChange(w => this._screenDprMonitor.setWindow(w)));
+    this._register(Event.forward(this._screenDprMonitor.onDprChange, this._onDprChange));
+
+    this._register(addDisposableListener(this._textarea, 'focus', () => this._isFocused = true));
+    this._register(addDisposableListener(this._textarea, 'blur', () => this._isFocused = false));
   }
 
   public get window(): Window & typeof globalThis {
@@ -69,7 +65,7 @@ export class CoreBrowserService extends Disposable implements ICoreBrowserServic
  * window.devicePixelRatio value changes. This is done not with polling but with
  * the use of window.matchMedia to watch media queries. When the event fires,
  * the listener will be reattached using a different media query to ensure that
- * any further changes will register.
+ * any further changes will _register.
  *
  * The listener should fire on both window zoom changes and switching to a
  * monitor with a different DPI.
@@ -78,9 +74,9 @@ class ScreenDprMonitor extends Disposable {
   private _currentDevicePixelRatio: number;
   private _outerListener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | undefined;
   private _resolutionMediaMatchList: MediaQueryList | undefined;
-  private _windowResizeListener = this.register(new MutableDisposable());
+  private _windowResizeListener = this._register(new MutableDisposable());
 
-  private readonly _onDprChange = this.register(new Emitter<number>());
+  private readonly _onDprChange = this._register(new Emitter<number>());
   public readonly onDprChange = this._onDprChange.event;
 
   constructor(private _parentWindow: Window) {
@@ -95,7 +91,7 @@ class ScreenDprMonitor extends Disposable {
     this._setWindowResizeListener();
 
     // Setup additional disposables
-    this.register(toDisposable(() => this.clearListener()));
+    this._register(toDisposable(() => this.clearListener()));
   }
 
 
@@ -106,7 +102,7 @@ class ScreenDprMonitor extends Disposable {
   }
 
   private _setWindowResizeListener(): void {
-    this._windowResizeListener.value = addDisposableDomListener(this._parentWindow, 'resize', () => this._setDprAndFireIfDiffers());
+    this._windowResizeListener.value = addDisposableListener(this._parentWindow, 'resize', () => this._setDprAndFireIfDiffers());
   }
 
   private _setDprAndFireIfDiffers(): void {

package/src/browser/services/LinkProviderService.ts

@@ -1,5 +1,5 @@
 import { ILinkProvider, ILinkProviderService } from 'browser/services/Services';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { IDisposable } from 'common/Types';
 
 export class LinkProviderService extends Disposable implements ILinkProviderService {
@@ -9,7 +9,7 @@ export class LinkProviderService extends Disposable implements ILinkProviderServ
 
   constructor() {
     super();
-    this.register(toDisposable(() => this.linkProviders.length = 0));
+    this._register(toDisposable(() => this.linkProviders.length = 0));
   }
 
   public registerLinkProvider(linkProvider: ILinkProvider): IDisposable {

package/src/browser/services/RenderService.ts

@@ -7,7 +7,7 @@ import { RenderDebouncer } from 'browser/RenderDebouncer';
 import { IRenderDebouncerWithCallback } from 'browser/Types';
 import { IRenderDimensions, IRenderer } from 'browser/renderer/shared/Types';
 import { ICharSizeService, ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
-import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { DebouncedIdleTask } from 'common/TaskQueue';
 import { IBufferService, IDecorationService, IOptionsService } from 'common/services/Services';
 import { Emitter } from 'vs/base/common/event';
@@ -21,10 +21,10 @@ interface ISelectionState {
 export class RenderService extends Disposable implements IRenderService {
   public serviceBrand: undefined;
 
-  private _renderer: MutableDisposable<IRenderer> = this.register(new MutableDisposable());
+  private _renderer: MutableDisposable<IRenderer> = this._register(new MutableDisposable());
   private _renderDebouncer: IRenderDebouncerWithCallback;
   private _pausedResizeTask = new DebouncedIdleTask();
-  private _observerDisposable = this.register(new MutableDisposable());
+  private _observerDisposable = this._register(new MutableDisposable());
 
   private _isPaused: boolean = false;
   private _needsFullRefresh: boolean = false;
@@ -38,13 +38,13 @@ export class RenderService extends Disposable implements IRenderService {
     columnSelectMode: false
   };
 
-  private readonly _onDimensionsChange = this.register(new Emitter<IRenderDimensions>());
+  private readonly _onDimensionsChange = this._register(new Emitter<IRenderDimensions>());
   public readonly onDimensionsChange = this._onDimensionsChange.event;
-  private readonly _onRenderedViewportChange = this.register(new Emitter<{ start: number, end: number }>());
+  private readonly _onRenderedViewportChange = this._register(new Emitter<{ start: number, end: number }>());
   public readonly onRenderedViewportChange = this._onRenderedViewportChange.event;
-  private readonly _onRender = this.register(new Emitter<{ start: number, end: number }>());
+  private readonly _onRender = this._register(new Emitter<{ start: number, end: number }>());
   public readonly onRender = this._onRender.event;
-  private readonly _onRefreshRequest = this.register(new Emitter<{ start: number, end: number }>());
+  private readonly _onRefreshRequest = this._register(new Emitter<{ start: number, end: number }>());
   public readonly onRefreshRequest = this._onRefreshRequest.event;
 
   public get dimensions(): IRenderDimensions { return this._renderer.value!.dimensions; }
@@ -62,23 +62,23 @@ export class RenderService extends Disposable implements IRenderService {
     super();
 
     this._renderDebouncer = new RenderDebouncer((start, end) => this._renderRows(start, end), coreBrowserService);
-    this.register(this._renderDebouncer);
+    this._register(this._renderDebouncer);
 
-    this.register(coreBrowserService.onDprChange(() => this.handleDevicePixelRatioChange()));
+    this._register(coreBrowserService.onDprChange(() => this.handleDevicePixelRatioChange()));
 
-    this.register(bufferService.onResize(() => this._fullRefresh()));
-    this.register(bufferService.buffers.onBufferActivate(() => this._renderer.value?.clear()));
-    this.register(optionsService.onOptionChange(() => this._handleOptionsChanged()));
-    this.register(this._charSizeService.onCharSizeChange(() => this.handleCharSizeChanged()));
+    this._register(bufferService.onResize(() => this._fullRefresh()));
+    this._register(bufferService.buffers.onBufferActivate(() => this._renderer.value?.clear()));
+    this._register(optionsService.onOptionChange(() => this._handleOptionsChanged()));
+    this._register(this._charSizeService.onCharSizeChange(() => this.handleCharSizeChanged()));
 
     // Do a full refresh whenever any decoration is added or removed. This may not actually result
     // in changes but since decorations should be used sparingly or added/removed all in the same
     // frame this should have minimal performance impact.
-    this.register(decorationService.onDecorationRegistered(() => this._fullRefresh()));
-    this.register(decorationService.onDecorationRemoved(() => this._fullRefresh()));
+    this._register(decorationService.onDecorationRegistered(() => this._fullRefresh()));
+    this._register(decorationService.onDecorationRemoved(() => this._fullRefresh()));
 
     // Clear the renderer when the a change that could affect glyphs occurs
-    this.register(optionsService.onMultipleOptionChange([
+    this._register(optionsService.onMultipleOptionChange([
       'customGlyphs',
       'drawBoldTextInBrightColors',
       'letterSpacing',
@@ -96,15 +96,15 @@ export class RenderService extends Disposable implements IRenderService {
     }));
 
     // Refresh the cursor line when the cursor changes
-    this.register(optionsService.onMultipleOptionChange([
+    this._register(optionsService.onMultipleOptionChange([
       'cursorBlink',
       'cursorStyle'
     ], () => this.refreshRows(bufferService.buffer.y, bufferService.buffer.y, true)));
 
-    this.register(themeService.onChangeColors(() => this._fullRefresh()));
+    this._register(themeService.onChangeColors(() => this._fullRefresh()));
 
     this._registerIntersectionObserver(coreBrowserService.window, screenElement);
-    this.register(coreBrowserService.onWindowChange((w) => this._registerIntersectionObserver(w, screenElement)));
+    this._register(coreBrowserService.onWindowChange((w) => this._registerIntersectionObserver(w, screenElement)));
   }
 
   private _registerIntersectionObserver(w: Window & typeof globalThis, screenElement: HTMLElement): void {

package/src/browser/services/SelectionService.ts

@@ -9,7 +9,7 @@ import { moveToCellSequence } from 'browser/input/MoveToCell';
 import { SelectionModel } from 'browser/selection/SelectionModel';
 import { ISelectionRedrawRequestEvent, ISelectionRequestScrollLinesEvent } from 'browser/selection/Types';
 import { ICoreBrowserService, IMouseService, IRenderService, ISelectionService } from 'browser/services/Services';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import * as Browser from 'common/Platform';
 import { IBufferLine, IDisposable } from 'common/Types';
 import { getRangeLength } from 'common/buffer/BufferRange';
@@ -111,13 +111,13 @@ export class SelectionService extends Disposable implements ISelectionService {
   private _oldSelectionStart: [number, number] | undefined = undefined;
   private _oldSelectionEnd: [number, number] | undefined = undefined;
 
-  private readonly _onLinuxMouseSelection = this.register(new Emitter<string>());
+  private readonly _onLinuxMouseSelection = this._register(new Emitter<string>());
   public readonly onLinuxMouseSelection = this._onLinuxMouseSelection.event;
-  private readonly _onRedrawRequest = this.register(new Emitter<ISelectionRedrawRequestEvent>());
+  private readonly _onRedrawRequest = this._register(new Emitter<ISelectionRedrawRequestEvent>());
   public readonly onRequestRedraw = this._onRedrawRequest.event;
-  private readonly _onSelectionChange = this.register(new Emitter<void>());
+  private readonly _onSelectionChange = this._register(new Emitter<void>());
   public readonly onSelectionChange = this._onSelectionChange.event;
-  private readonly _onRequestScrollLines = this.register(new Emitter<ISelectionRequestScrollLinesEvent>());
+  private readonly _onRequestScrollLines = this._register(new Emitter<ISelectionRequestScrollLinesEvent>());
   public readonly onRequestScrollLines = this._onRequestScrollLines.event;
 
   constructor(
@@ -142,14 +142,14 @@ export class SelectionService extends Disposable implements ISelectionService {
       }
     });
     this._trimListener = this._bufferService.buffer.lines.onTrim(amount => this._handleTrim(amount));
-    this.register(this._bufferService.buffers.onBufferActivate(e => this._handleBufferActivate(e)));
+    this._register(this._bufferService.buffers.onBufferActivate(e => this._handleBufferActivate(e)));
 
     this.enable();
 
     this._model = new SelectionModel(this._bufferService);
     this._activeSelectionMode = SelectionMode.NORMAL;
 
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
       this._removeMouseDownListeners();
     }));
   }

package/src/browser/services/ThemeService.ts

@@ -7,7 +7,7 @@ import { ColorContrastCache } from 'browser/ColorContrastCache';
 import { IThemeService } from 'browser/services/Services';
 import { DEFAULT_ANSI_COLORS, IColorContrastCache, IColorSet, ReadonlyColorSet } from 'browser/Types';
 import { color, css, NULL_COLOR } from 'common/Color';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { IOptionsService, ITheme } from 'common/services/Services';
 import { AllColorIndex, IColor, SpecialColorIndex } from 'common/Types';
 import { Emitter } from 'vs/base/common/event';
@@ -40,7 +40,7 @@ export class ThemeService extends Disposable implements IThemeService {
 
   public get colors(): ReadonlyColorSet { return this._colors; }
 
-  private readonly _onChangeColors = this.register(new Emitter<ReadonlyColorSet>());
+  private readonly _onChangeColors = this._register(new Emitter<ReadonlyColorSet>());
   public readonly onChangeColors = this._onChangeColors.event;
 
   constructor(
@@ -69,8 +69,8 @@ export class ThemeService extends Disposable implements IThemeService {
     this._updateRestoreColors();
     this._setTheme(this._optionsService.rawOptions.theme);
 
-    this.register(this._optionsService.onSpecificOptionChange('minimumContrastRatio', () => this._contrastCache.clear()));
-    this.register(this._optionsService.onSpecificOptionChange('theme', () => this._setTheme(this._optionsService.rawOptions.theme)));
+    this._register(this._optionsService.onSpecificOptionChange('minimumContrastRatio', () => this._contrastCache.clear()));
+    this._register(this._optionsService.onSpecificOptionChange('theme', () => this._setTheme(this._optionsService.rawOptions.theme)));
   }
 
   /**

package/src/common/CircularList.ts

@@ -4,7 +4,7 @@
  */
 
 import { ICircularList } from 'common/Types';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { Emitter } from 'vs/base/common/event';
 
 export interface IInsertEvent {
@@ -26,11 +26,11 @@ export class CircularList<T> extends Disposable implements ICircularList<T> {
   private _startIndex: number;
   private _length: number;
 
-  public readonly onDeleteEmitter = this.register(new Emitter<IDeleteEvent>());
+  public readonly onDeleteEmitter = this._register(new Emitter<IDeleteEvent>());
   public readonly onDelete = this.onDeleteEmitter.event;
-  public readonly onInsertEmitter = this.register(new Emitter<IInsertEvent>());
+  public readonly onInsertEmitter = this._register(new Emitter<IInsertEvent>());
   public readonly onInsert = this.onInsertEmitter.event;
-  public readonly onTrimEmitter = this.register(new Emitter<number>());
+  public readonly onTrimEmitter = this._register(new Emitter<number>());
   public readonly onTrim = this.onTrimEmitter.event;
 
   constructor(

package/src/common/CoreTerminal.ts

@@ -21,7 +21,6 @@
  *   http://linux.die.net/man/7/urxvt
  */
 
-import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
 import { IInstantiationService, IOptionsService, IBufferService, ILogService, ICharsetService, ICoreService, ICoreMouseService, IUnicodeService, LogLevelEnum, ITerminalOptions, IOscLinkService } from 'common/services/Services';
 import { InstantiationService } from 'common/services/InstantiationService';
 import { LogService } from 'common/services/LogService';
@@ -39,6 +38,7 @@ import { InputHandler } from 'common/InputHandler';
 import { WriteBuffer } from 'common/input/WriteBuffer';
 import { OscLinkService } from 'common/services/OscLinkService';
 import { Emitter, Event } from 'vs/base/common/event';
+import { Disposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
 
 // Only trigger this warning a single time per session
 let hasWriteSyncWarnHappened = false;
@@ -57,17 +57,17 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
 
   protected _inputHandler: InputHandler;
   private _writeBuffer: WriteBuffer;
-  private _windowsWrappingHeuristics = this.register(new MutableDisposable());
+  private _windowsWrappingHeuristics = this._register(new MutableDisposable());
 
-  private readonly _onBinary = this.register(new Emitter<string>());
+  private readonly _onBinary = this._register(new Emitter<string>());
   public readonly onBinary = this._onBinary.event;
-  private readonly _onData = this.register(new Emitter<string>());
+  private readonly _onData = this._register(new Emitter<string>());
   public readonly onData = this._onData.event;
-  protected _onLineFeed = this.register(new Emitter<void>());
+  protected _onLineFeed = this._register(new Emitter<void>());
   public readonly onLineFeed = this._onLineFeed.event;
-  private readonly _onResize = this.register(new Emitter<{ cols: number, rows: number }>());
+  private readonly _onResize = this._register(new Emitter<{ cols: number, rows: number }>());
   public readonly onResize = this._onResize.event;
-  protected readonly _onWriteParsed = this.register(new Emitter<void>());
+  protected readonly _onWriteParsed = this._register(new Emitter<void>());
   public readonly onWriteParsed = this._onWriteParsed.event;
 
   /**
@@ -75,10 +75,10 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
    * it's filtered out.
    */
   protected _onScrollApi?: Emitter<number>;
-  protected _onScroll = this.register(new Emitter<IScrollEvent>());
+  protected _onScroll = this._register(new Emitter<IScrollEvent>());
   public get onScroll(): Event<number> {
     if (!this._onScrollApi) {
-      this._onScrollApi = this.register(new Emitter<number>());
+      this._onScrollApi = this._register(new Emitter<number>());
       this._onScroll.event(ev => {
         this._onScrollApi?.fire(ev.position);
       });
@@ -103,17 +103,17 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
 
     // Setup and initialize services
     this._instantiationService = new InstantiationService();
-    this.optionsService = this.register(new OptionsService(options));
+    this.optionsService = this._register(new OptionsService(options));
     this._instantiationService.setService(IOptionsService, this.optionsService);
-    this._bufferService = this.register(this._instantiationService.createInstance(BufferService));
+    this._bufferService = this._register(this._instantiationService.createInstance(BufferService));
     this._instantiationService.setService(IBufferService, this._bufferService);
-    this._logService = this.register(this._instantiationService.createInstance(LogService));
+    this._logService = this._register(this._instantiationService.createInstance(LogService));
     this._instantiationService.setService(ILogService, this._logService);
-    this.coreService = this.register(this._instantiationService.createInstance(CoreService));
+    this.coreService = this._register(this._instantiationService.createInstance(CoreService));
     this._instantiationService.setService(ICoreService, this.coreService);
-    this.coreMouseService = this.register(this._instantiationService.createInstance(CoreMouseService));
+    this.coreMouseService = this._register(this._instantiationService.createInstance(CoreMouseService));
     this._instantiationService.setService(ICoreMouseService, this.coreMouseService);
-    this.unicodeService = this.register(this._instantiationService.createInstance(UnicodeService));
+    this.unicodeService = this._register(this._instantiationService.createInstance(UnicodeService));
     this._instantiationService.setService(IUnicodeService, this.unicodeService);
     this._charsetService = this._instantiationService.createInstance(CharsetService);
     this._instantiationService.setService(ICharsetService, this._charsetService);
@@ -122,24 +122,24 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
 
 
     // Register input handler and handle/forward events
-    this._inputHandler = this.register(new InputHandler(this._bufferService, this._charsetService, this.coreService, this._logService, this.optionsService, this._oscLinkService, this.coreMouseService, this.unicodeService));
-    this.register(Event.forward(this._inputHandler.onLineFeed, this._onLineFeed));
-    this.register(this._inputHandler);
+    this._inputHandler = this._register(new InputHandler(this._bufferService, this._charsetService, this.coreService, this._logService, this.optionsService, this._oscLinkService, this.coreMouseService, this.unicodeService));
+    this._register(Event.forward(this._inputHandler.onLineFeed, this._onLineFeed));
+    this._register(this._inputHandler);
 
     // Setup listeners
-    this.register(Event.forward(this._bufferService.onResize, this._onResize));
-    this.register(Event.forward(this.coreService.onData, this._onData));
-    this.register(Event.forward(this.coreService.onBinary, this._onBinary));
-    this.register(this.coreService.onRequestScrollToBottom(() => this.scrollToBottom(true)));
-    this.register(this.coreService.onUserInput(() =>  this._writeBuffer.handleUserInput()));
-    this.register(this.optionsService.onMultipleOptionChange(['windowsMode', 'windowsPty'], () => this._handleWindowsPtyOptionChange()));
-    this.register(this._bufferService.onScroll(() => {
+    this._register(Event.forward(this._bufferService.onResize, this._onResize));
+    this._register(Event.forward(this.coreService.onData, this._onData));
+    this._register(Event.forward(this.coreService.onBinary, this._onBinary));
+    this._register(this.coreService.onRequestScrollToBottom(() => this.scrollToBottom(true)));
+    this._register(this.coreService.onUserInput(() =>  this._writeBuffer.handleUserInput()));
+    this._register(this.optionsService.onMultipleOptionChange(['windowsMode', 'windowsPty'], () => this._handleWindowsPtyOptionChange()));
+    this._register(this._bufferService.onScroll(() => {
       this._onScroll.fire({ position: this._bufferService.buffer.ydisp });
       this._inputHandler.markRangeDirty(this._bufferService.buffer.scrollTop, this._bufferService.buffer.scrollBottom);
     }));
     // Setup WriteBuffer
-    this._writeBuffer = this.register(new WriteBuffer((data, promiseResult) => this._inputHandler.parse(data, promiseResult)));
-    this.register(Event.forward(this._writeBuffer.onWriteParsed, this._onWriteParsed));
+    this._writeBuffer = this._register(new WriteBuffer((data, promiseResult) => this._inputHandler.parse(data, promiseResult)));
+    this._register(Event.forward(this._writeBuffer.onWriteParsed, this._onWriteParsed));
   }
 
   public write(data: string | Uint8Array, callback?: () => void): void {