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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xterm/xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "5.6.0-beta.50",
+  "version": "5.6.0-beta.52",
   "main": "lib/xterm.js",
   "module": "lib/xterm.mjs",
   "style": "css/xterm.css",

package/src/browser/AccessibilityManager.ts

@@ -6,11 +6,11 @@
 import * as Strings from 'browser/LocalizableStrings';
 import { ITerminal, IRenderDebouncer } from 'browser/Types';
 import { TimeBasedDebouncer } from 'browser/TimeBasedDebouncer';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { ICoreBrowserService, IRenderService } from 'browser/services/Services';
 import { IBuffer } from 'common/buffer/Types';
 import { IInstantiationService } from 'common/services/Services';
-import { addDisposableDomListener } from 'browser/Lifecycle';
+import { addDisposableListener } from 'vs/base/browser/dom';
 
 const MAX_ROWS_TO_READ = 20;
 
@@ -82,7 +82,7 @@ export class AccessibilityManager extends Disposable {
     this._liveRegion.classList.add('live-region');
     this._liveRegion.setAttribute('aria-live', 'assertive');
     this._accessibilityContainer.appendChild(this._liveRegion);
-    this._liveRegionDebouncer = this.register(new TimeBasedDebouncer(this._renderRows.bind(this)));
+    this._liveRegionDebouncer = this._register(new TimeBasedDebouncer(this._renderRows.bind(this)));
 
     if (!this._terminal.element) {
       throw new Error('Cannot enable accessibility before Terminal.open');
@@ -105,22 +105,22 @@ export class AccessibilityManager extends Disposable {
       this._terminal.element.insertAdjacentElement('afterbegin', this._accessibilityContainer);
     }
 
-    this.register(this._terminal.onResize(e => this._handleResize(e.rows)));
-    this.register(this._terminal.onRender(e => this._refreshRows(e.start, e.end)));
-    this.register(this._terminal.onScroll(() => this._refreshRows()));
+    this._register(this._terminal.onResize(e => this._handleResize(e.rows)));
+    this._register(this._terminal.onRender(e => this._refreshRows(e.start, e.end)));
+    this._register(this._terminal.onScroll(() => this._refreshRows()));
     // Line feed is an issue as the prompt won't be read out after a command is run
-    this.register(this._terminal.onA11yChar(char => this._handleChar(char)));
-    this.register(this._terminal.onLineFeed(() => this._handleChar('\n')));
-    this.register(this._terminal.onA11yTab(spaceCount => this._handleTab(spaceCount)));
-    this.register(this._terminal.onKey(e => this._handleKey(e.key)));
-    this.register(this._terminal.onBlur(() => this._clearLiveRegion()));
-    this.register(this._renderService.onDimensionsChange(() => this._refreshRowsDimensions()));
-    this.register(addDisposableDomListener(doc, 'selectionchange', () => this._handleSelectionChange()));
-    this.register(this._coreBrowserService.onDprChange(() => this._refreshRowsDimensions()));
+    this._register(this._terminal.onA11yChar(char => this._handleChar(char)));
+    this._register(this._terminal.onLineFeed(() => this._handleChar('\n')));
+    this._register(this._terminal.onA11yTab(spaceCount => this._handleTab(spaceCount)));
+    this._register(this._terminal.onKey(e => this._handleKey(e.key)));
+    this._register(this._terminal.onBlur(() => this._clearLiveRegion()));
+    this._register(this._renderService.onDimensionsChange(() => this._refreshRowsDimensions()));
+    this._register(addDisposableListener(doc, 'selectionchange', () => this._handleSelectionChange()));
+    this._register(this._coreBrowserService.onDprChange(() => this._refreshRowsDimensions()));
 
     this._refreshRowsDimensions();
     this._refreshRows();
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
       if (DEBUG) {
         this._debugRootContainer!.remove();
       } else {

package/src/browser/CoreBrowserTerminal.ts

@@ -23,7 +23,6 @@
 
 import { IDecoration, IDecorationOptions, IDisposable, ILinkProvider, IMarker } from '@xterm/xterm';
 import { copyHandler, handlePasteEvent, moveTextAreaUnderMouseCursor, paste, rightClickHandler } from 'browser/Clipboard';
-import { addDisposableDomListener } from 'browser/Lifecycle';
 import * as Strings from 'browser/LocalizableStrings';
 import { OscLinkProvider } from 'browser/OscLinkProvider';
 import { CharacterJoinerHandler, CustomKeyEventHandler, CustomWheelEventHandler, IBrowser, IBufferRange, ICompositionHelper, ILinkifier2, ITerminal } from 'browser/Types';
@@ -44,7 +43,6 @@ import { ICharSizeService, ICharacterJoinerService, ICoreBrowserService, ILinkPr
 import { ThemeService } from 'browser/services/ThemeService';
 import { channels, color } from 'common/Color';
 import { CoreTerminal } from 'common/CoreTerminal';
-import { MutableDisposable, toDisposable } from 'common/Lifecycle';
 import * as Browser from 'common/Platform';
 import { ColorRequestType, CoreMouseAction, CoreMouseButton, CoreMouseEventType, IColorEvent, ITerminalOptions, KeyboardResultType, SpecialColorIndex } from 'common/Types';
 import { DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine';
@@ -58,6 +56,8 @@ import { WindowsOptionsReportType } from '../common/InputHandler';
 import { AccessibilityManager } from './AccessibilityManager';
 import { Linkifier } from './Linkifier';
 import { Emitter, Event } from 'vs/base/common/event';
+import { addDisposableListener } from 'vs/base/browser/dom';
+import { MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
 
 export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
   public textarea: HTMLTextAreaElement | undefined;
@@ -119,30 +119,30 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
   private _unprocessedDeadKey: boolean = false;
 
   private _compositionHelper: ICompositionHelper | undefined;
-  private _accessibilityManager: MutableDisposable<AccessibilityManager> = this.register(new MutableDisposable());
+  private _accessibilityManager: MutableDisposable<AccessibilityManager> = this._register(new MutableDisposable());
 
-  private readonly _onCursorMove = this.register(new Emitter<void>());
+  private readonly _onCursorMove = this._register(new Emitter<void>());
   public readonly onCursorMove = this._onCursorMove.event;
-  private readonly _onKey = this.register(new Emitter<{ key: string, domEvent: KeyboardEvent }>());
+  private readonly _onKey = this._register(new Emitter<{ key: string, domEvent: KeyboardEvent }>());
   public readonly onKey = this._onKey.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 _onSelectionChange = this.register(new Emitter<void>());
+  private readonly _onSelectionChange = this._register(new Emitter<void>());
   public readonly onSelectionChange = this._onSelectionChange.event;
-  private readonly _onTitleChange = this.register(new Emitter<string>());
+  private readonly _onTitleChange = this._register(new Emitter<string>());
   public readonly onTitleChange = this._onTitleChange.event;
-  private readonly _onBell = this.register(new Emitter<void>());
+  private readonly _onBell = this._register(new Emitter<void>());
   public readonly onBell = this._onBell.event;
 
-  private _onFocus = this.register(new Emitter<void>());
+  private _onFocus = this._register(new Emitter<void>());
   public get onFocus(): Event<void> { return this._onFocus.event; }
-  private _onBlur = this.register(new Emitter<void>());
+  private _onBlur = this._register(new Emitter<void>());
   public get onBlur(): Event<void> { return this._onBlur.event; }
-  private _onA11yCharEmitter = this.register(new Emitter<string>());
+  private _onA11yCharEmitter = this._register(new Emitter<string>());
   public get onA11yChar(): Event<string> { return this._onA11yCharEmitter.event; }
-  private _onA11yTabEmitter = this.register(new Emitter<number>());
+  private _onA11yTabEmitter = this._register(new Emitter<number>());
   public get onA11yTab(): Event<number> { return this._onA11yTabEmitter.event; }
-  private _onWillOpen = this.register(new Emitter<HTMLElement>());
+  private _onWillOpen = this._register(new Emitter<HTMLElement>());
   public get onWillOpen(): Event<HTMLElement> { return this._onWillOpen.event; }
 
   constructor(
@@ -159,21 +159,21 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
     this._linkProviderService.registerLinkProvider(this._instantiationService.createInstance(OscLinkProvider));
 
     // Setup InputHandler listeners
-    this.register(this._inputHandler.onRequestBell(() => this._onBell.fire()));
-    this.register(this._inputHandler.onRequestRefreshRows((e) => this.refresh(e?.start ?? 0, e?.end ?? (this.rows - 1))));
-    this.register(this._inputHandler.onRequestSendFocus(() => this._reportFocus()));
-    this.register(this._inputHandler.onRequestReset(() => this.reset()));
-    this.register(this._inputHandler.onRequestWindowsOptionsReport(type => this._reportWindowsOptions(type)));
-    this.register(this._inputHandler.onColor((event) => this._handleColorEvent(event)));
-    this.register(Event.forward(this._inputHandler.onCursorMove, this._onCursorMove));
-    this.register(Event.forward(this._inputHandler.onTitleChange, this._onTitleChange));
-    this.register(Event.forward(this._inputHandler.onA11yChar, this._onA11yCharEmitter));
-    this.register(Event.forward(this._inputHandler.onA11yTab, this._onA11yTabEmitter));
+    this._register(this._inputHandler.onRequestBell(() => this._onBell.fire()));
+    this._register(this._inputHandler.onRequestRefreshRows((e) => this.refresh(e?.start ?? 0, e?.end ?? (this.rows - 1))));
+    this._register(this._inputHandler.onRequestSendFocus(() => this._reportFocus()));
+    this._register(this._inputHandler.onRequestReset(() => this.reset()));
+    this._register(this._inputHandler.onRequestWindowsOptionsReport(type => this._reportWindowsOptions(type)));
+    this._register(this._inputHandler.onColor((event) => this._handleColorEvent(event)));
+    this._register(Event.forward(this._inputHandler.onCursorMove, this._onCursorMove));
+    this._register(Event.forward(this._inputHandler.onTitleChange, this._onTitleChange));
+    this._register(Event.forward(this._inputHandler.onA11yChar, this._onA11yCharEmitter));
+    this._register(Event.forward(this._inputHandler.onA11yTab, this._onA11yTabEmitter));
 
     // Setup listeners
-    this.register(this._bufferService.onResize(e => this._afterResize(e.cols, e.rows)));
+    this._register(this._bufferService.onResize(e => this._afterResize(e.cols, e.rows)));
 
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
       this._customKeyEventHandler = undefined;
       this.element?.parentNode?.removeChild(this.element);
     }));
@@ -330,7 +330,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
     this._bindKeys();
 
     // Bind clipboard functionality
-    this.register(addDisposableDomListener(this.element!, 'copy', (event: ClipboardEvent) => {
+    this._register(addDisposableListener(this.element!, 'copy', (event: ClipboardEvent) => {
       // If mouse events are active it means the selection manager is disabled and
       // copy should be handled by the host program.
       if (!this.hasSelection()) {
@@ -339,19 +339,19 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
       copyHandler(event, this._selectionService!);
     }));
     const pasteHandlerWrapper = (event: ClipboardEvent): void => handlePasteEvent(event, this.textarea!, this.coreService, this.optionsService);
-    this.register(addDisposableDomListener(this.textarea!, 'paste', pasteHandlerWrapper));
-    this.register(addDisposableDomListener(this.element!, 'paste', pasteHandlerWrapper));
+    this._register(addDisposableListener(this.textarea!, 'paste', pasteHandlerWrapper));
+    this._register(addDisposableListener(this.element!, 'paste', pasteHandlerWrapper));
 
     // Handle right click context menus
     if (Browser.isFirefox) {
       // Firefox doesn't appear to fire the contextmenu event on right click
-      this.register(addDisposableDomListener(this.element!, 'mousedown', (event: MouseEvent) => {
+      this._register(addDisposableListener(this.element!, 'mousedown', (event: MouseEvent) => {
         if (event.button === 2) {
           rightClickHandler(event, this.textarea!, this.screenElement!, this._selectionService!, this.options.rightClickSelectsWord);
         }
       }));
     } else {
-      this.register(addDisposableDomListener(this.element!, 'contextmenu', (event: MouseEvent) => {
+      this._register(addDisposableListener(this.element!, 'contextmenu', (event: MouseEvent) => {
         rightClickHandler(event, this.textarea!, this.screenElement!, this._selectionService!, this.options.rightClickSelectsWord);
       }));
     }
@@ -362,7 +362,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
     if (Browser.isLinux) {
       // Use auxclick event over mousedown the latter doesn't seem to work. Note
       // that the regular click event doesn't fire for the middle mouse button.
-      this.register(addDisposableDomListener(this.element!, 'auxclick', (event: MouseEvent) => {
+      this._register(addDisposableListener(this.element!, 'auxclick', (event: MouseEvent) => {
         if (event.button === 1) {
           moveTextAreaUnderMouseCursor(event, this.textarea!, this.screenElement!);
         }
@@ -374,14 +374,14 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
    * Apply key handling to the terminal
    */
   private _bindKeys(): void {
-    this.register(addDisposableDomListener(this.textarea!, 'keyup', (ev: KeyboardEvent) => this._keyUp(ev), true));
-    this.register(addDisposableDomListener(this.textarea!, 'keydown', (ev: KeyboardEvent) => this._keyDown(ev), true));
-    this.register(addDisposableDomListener(this.textarea!, 'keypress', (ev: KeyboardEvent) => this._keyPress(ev), true));
-    this.register(addDisposableDomListener(this.textarea!, 'compositionstart', () => this._compositionHelper!.compositionstart()));
-    this.register(addDisposableDomListener(this.textarea!, 'compositionupdate', (e: CompositionEvent) => this._compositionHelper!.compositionupdate(e)));
-    this.register(addDisposableDomListener(this.textarea!, 'compositionend', () => this._compositionHelper!.compositionend()));
-    this.register(addDisposableDomListener(this.textarea!, 'input', (ev: InputEvent) => this._inputEvent(ev), true));
-    this.register(this.onRender(() => this._compositionHelper!.updateCompositionElements()));
+    this._register(addDisposableListener(this.textarea!, 'keyup', (ev: KeyboardEvent) => this._keyUp(ev), true));
+    this._register(addDisposableListener(this.textarea!, 'keydown', (ev: KeyboardEvent) => this._keyDown(ev), true));
+    this._register(addDisposableListener(this.textarea!, 'keypress', (ev: KeyboardEvent) => this._keyPress(ev), true));
+    this._register(addDisposableListener(this.textarea!, 'compositionstart', () => this._compositionHelper!.compositionstart()));
+    this._register(addDisposableListener(this.textarea!, 'compositionupdate', (e: CompositionEvent) => this._compositionHelper!.compositionupdate(e)));
+    this._register(addDisposableListener(this.textarea!, 'compositionend', () => this._compositionHelper!.compositionend()));
+    this._register(addDisposableListener(this.textarea!, 'input', (ev: InputEvent) => this._inputEvent(ev), true));
+    this._register(this.onRender(() => this._compositionHelper!.updateCompositionElements()));
   }
 
   /**
@@ -428,7 +428,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
 
     this.screenElement = this._document.createElement('div');
     this.screenElement.classList.add('xterm-screen');
-    this.register(addDisposableDomListener(this.screenElement, 'mousemove', (ev: MouseEvent) => this.updateCursorStyle(ev)));
+    this._register(addDisposableListener(this.screenElement, 'mousemove', (ev: MouseEvent) => this.updateCursorStyle(ev)));
     // Create the container that will hold helpers like the textarea for
     // capturing DOM Events. Then produce the helpers.
     this._helperContainer = this._document.createElement('div');
@@ -451,7 +451,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
 
     // Register the core browser service before the generic textarea handlers are registered so it
     // handles them first. Otherwise the renderers may use the wrong focus state.
-    this._coreBrowserService = this.register(this._instantiationService.createInstance(CoreBrowserService,
+    this._coreBrowserService = this._register(this._instantiationService.createInstance(CoreBrowserService,
       this.textarea,
       parent.ownerDocument.defaultView ?? window,
       // Force unsafe null in node.js environment for tests
@@ -459,8 +459,8 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
     ));
     this._instantiationService.setService(ICoreBrowserService, this._coreBrowserService);
 
-    this.register(addDisposableDomListener(this.textarea, 'focus', (ev: FocusEvent) => this._handleTextAreaFocus(ev)));
-    this.register(addDisposableDomListener(this.textarea, 'blur', () => this._handleTextAreaBlur()));
+    this._register(addDisposableListener(this.textarea, 'focus', (ev: FocusEvent) => this._handleTextAreaFocus(ev)));
+    this._register(addDisposableListener(this.textarea, 'blur', () => this._handleTextAreaBlur()));
     this._helperContainer.appendChild(this.textarea);
 
     this._charSizeService = this._instantiationService.createInstance(CharSizeService, this._document, this._helperContainer);
@@ -472,9 +472,9 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
     this._characterJoinerService = this._instantiationService.createInstance(CharacterJoinerService);
     this._instantiationService.setService(ICharacterJoinerService, this._characterJoinerService);
 
-    this._renderService = this.register(this._instantiationService.createInstance(RenderService, this.rows, this.screenElement));
+    this._renderService = this._register(this._instantiationService.createInstance(RenderService, this.rows, this.screenElement));
     this._instantiationService.setService(IRenderService, this._renderService);
-    this.register(this._renderService.onRenderedViewportChange(e => this._onRender.fire(e)));
+    this._register(this._renderService.onRenderedViewportChange(e => this._onRender.fire(e)));
     this.onResize(e => this._renderService!.resize(e.cols, e.rows));
 
     this._compositionView = this._document.createElement('div');
@@ -485,7 +485,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
     this._mouseService = this._instantiationService.createInstance(MouseService);
     this._instantiationService.setService(IMouseService, this._mouseService);
 
-    this.linkifier = this.register(this._instantiationService.createInstance(Linkifier, this.screenElement));
+    this.linkifier = this._register(this._instantiationService.createInstance(Linkifier, this.screenElement));
 
     // Performance: Add viewport and helper elements from the fragment
     this.element.appendChild(fragment);
@@ -498,30 +498,30 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
       this._renderService.setRenderer(this._createRenderer());
     }
 
-    this.register(this.onCursorMove(() => {
+    this._register(this.onCursorMove(() => {
       this._renderService!.handleCursorMove();
       this._syncTextArea();
     }));
-    this.register(this.onResize(() => this._renderService!.handleResize(this.cols, this.rows)));
-    this.register(this.onBlur(() => this._renderService!.handleBlur()));
-    this.register(this.onFocus(() => this._renderService!.handleFocus()));
+    this._register(this.onResize(() => this._renderService!.handleResize(this.cols, this.rows)));
+    this._register(this.onBlur(() => this._renderService!.handleBlur()));
+    this._register(this.onFocus(() => this._renderService!.handleFocus()));
 
-    this._viewport = this.register(this._instantiationService.createInstance(Viewport, this.element, this.screenElement));
-    this.register(this._viewport.onRequestScrollLines(e => {
+    this._viewport = this._register(this._instantiationService.createInstance(Viewport, this.element, this.screenElement));
+    this._register(this._viewport.onRequestScrollLines(e => {
       super.scrollLines(e, false);
       this.refresh(0, this.rows - 1);
     }));
 
-    this._selectionService = this.register(this._instantiationService.createInstance(SelectionService,
+    this._selectionService = this._register(this._instantiationService.createInstance(SelectionService,
       this.element,
       this.screenElement,
       this.linkifier
     ));
     this._instantiationService.setService(ISelectionService, this._selectionService);
-    this.register(this._selectionService.onRequestScrollLines(e => this.scrollLines(e.amount, e.suppressScrollEvent)));
-    this.register(this._selectionService.onSelectionChange(() => this._onSelectionChange.fire()));
-    this.register(this._selectionService.onRequestRedraw(e => this._renderService!.handleSelectionChanged(e.start, e.end, e.columnSelectMode)));
-    this.register(this._selectionService.onLinuxMouseSelection(text => {
+    this._register(this._selectionService.onRequestScrollLines(e => this.scrollLines(e.amount, e.suppressScrollEvent)));
+    this._register(this._selectionService.onSelectionChange(() => this._onSelectionChange.fire()));
+    this._register(this._selectionService.onRequestRedraw(e => this._renderService!.handleSelectionChanged(e.start, e.end, e.columnSelectMode)));
+    this._register(this._selectionService.onLinuxMouseSelection(text => {
       // If there's a new selection, put it into the textarea, focus and select it
       // in order to register it as a selection on the OS. This event is fired
       // only on Linux to enable middle click to paste selection.
@@ -529,10 +529,10 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
       this.textarea!.focus();
       this.textarea!.select();
     }));
-    this.register(this._onScroll.event(() => this._selectionService!.refresh()));
+    this._register(this._onScroll.event(() => this._selectionService!.refresh()));
 
-    this.register(this._instantiationService.createInstance(BufferDecorationRenderer, this.screenElement));
-    this.register(addDisposableDomListener(this.element, 'mousedown', (e: MouseEvent) => this._selectionService!.handleMouseDown(e)));
+    this._register(this._instantiationService.createInstance(BufferDecorationRenderer, this.screenElement));
+    this._register(addDisposableListener(this.element, 'mousedown', (e: MouseEvent) => this._selectionService!.handleMouseDown(e)));
 
     // apply mouse event classes set by escape codes before terminal was attached
     if (this.coreMouseService.areMouseEventsActive) {
@@ -547,14 +547,14 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
       // ensure the correct order of the dprchange event
       this._accessibilityManager.value = this._instantiationService.createInstance(AccessibilityManager, this);
     }
-    this.register(this.optionsService.onSpecificOptionChange('screenReaderMode', e => this._handleScreenReaderModeOptionChange(e)));
+    this._register(this.optionsService.onSpecificOptionChange('screenReaderMode', e => this._handleScreenReaderModeOptionChange(e)));
 
     if (this.options.overviewRuler.width) {
-      this._overviewRulerRenderer = this.register(this._instantiationService.createInstance(OverviewRulerRenderer, this._viewportElement, this.screenElement));
+      this._overviewRulerRenderer = this._register(this._instantiationService.createInstance(OverviewRulerRenderer, this._viewportElement, this.screenElement));
     }
     this.optionsService.onSpecificOptionChange('overviewRuler', value => {
-      if (!this._overviewRulerRenderer && value.width && this._viewportElement && this.screenElement) {
-        this._overviewRulerRenderer = this.register(this._instantiationService.createInstance(OverviewRulerRenderer, this._viewportElement, this.screenElement));
+      if (!this._overviewRulerRenderer && value && this._viewportElement && this.screenElement) {
+        this._overviewRulerRenderer = this._register(this._instantiationService.createInstance(OverviewRulerRenderer, this._viewportElement, this.screenElement));
       }
     });
     // Measure the character size
@@ -707,7 +707,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
         }
       }
     };
-    this.register(this.coreMouseService.onProtocolChange(events => {
+    this._register(this.coreMouseService.onProtocolChange(events => {
       // apply global changes on events
       if (events) {
         if (this.optionsService.rawOptions.logLevel === 'debug') {
@@ -759,7 +759,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
     /**
      * "Always on" event listeners.
      */
-    this.register(addDisposableDomListener(el, 'mousedown', (ev: MouseEvent) => {
+    this._register(addDisposableListener(el, 'mousedown', (ev: MouseEvent) => {
       ev.preventDefault();
       this.focus();
 
@@ -786,7 +786,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
       return this.cancel(ev);
     }));
 
-    this.register(addDisposableDomListener(el, 'wheel', (ev: WheelEvent) => {
+    this._register(addDisposableListener(el, 'wheel', (ev: WheelEvent) => {
       // do nothing, if app side handles wheel itself
       if (requestedEvents.wheel) return;
 

package/src/browser/Linkifier.ts

@@ -3,13 +3,13 @@
  * @license MIT
  */
 
-import { addDisposableDomListener } from 'browser/Lifecycle';
 import { IBufferCellPosition, ILink, ILinkDecorations, ILinkWithState, ILinkifier2, ILinkifierEvent } from 'browser/Types';
-import { Disposable, disposeArray, getDisposeArrayDisposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, dispose, toDisposable } from 'vs/base/common/lifecycle';
 import { IDisposable } from 'common/Types';
 import { IBufferService } from 'common/services/Services';
 import { ILinkProviderService, IMouseService, IRenderService } from './services/Services';
 import { Emitter } from 'vs/base/common/event';
+import { addDisposableListener } from 'vs/base/browser/dom';
 
 export class Linkifier extends Disposable implements ILinkifier2 {
   public get currentLink(): ILinkWithState | undefined { return this._currentLink; }
@@ -23,9 +23,9 @@ export class Linkifier extends Disposable implements ILinkifier2 {
   private _activeProviderReplies: Map<Number, ILinkWithState[] | undefined> | undefined;
   private _activeLine: number = -1;
 
-  private readonly _onShowLinkUnderline = this.register(new Emitter<ILinkifierEvent>());
+  private readonly _onShowLinkUnderline = this._register(new Emitter<ILinkifierEvent>());
   public readonly onShowLinkUnderline = this._onShowLinkUnderline.event;
-  private readonly _onHideLinkUnderline = this.register(new Emitter<ILinkifierEvent>());
+  private readonly _onHideLinkUnderline = this._register(new Emitter<ILinkifierEvent>());
   public readonly onHideLinkUnderline = this._onHideLinkUnderline.event;
 
   constructor(
@@ -36,24 +36,25 @@ export class Linkifier extends Disposable implements ILinkifier2 {
     @ILinkProviderService private readonly _linkProviderService: ILinkProviderService
   ) {
     super();
-    this.register(getDisposeArrayDisposable(this._linkCacheDisposables));
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
+      dispose(this._linkCacheDisposables);
+      this._linkCacheDisposables.length = 0;
       this._lastMouseEvent = undefined;
       // Clear out link providers as they could easily cause an embedder memory leak
       this._activeProviderReplies?.clear();
     }));
     // Listen to resize to catch the case where it's resized and the cursor is out of the viewport.
-    this.register(this._bufferService.onResize(() => {
+    this._register(this._bufferService.onResize(() => {
       this._clearCurrentLink();
       this._wasResized = true;
     }));
-    this.register(addDisposableDomListener(this._element, 'mouseleave', () => {
+    this._register(addDisposableListener(this._element, 'mouseleave', () => {
       this._isMouseOut = true;
       this._clearCurrentLink();
     }));
-    this.register(addDisposableDomListener(this._element, 'mousemove', this._handleMouseMove.bind(this)));
-    this.register(addDisposableDomListener(this._element, 'mousedown', this._handleMouseDown.bind(this)));
-    this.register(addDisposableDomListener(this._element, 'mouseup', this._handleMouseUp.bind(this)));
+    this._register(addDisposableListener(this._element, 'mousemove', this._handleMouseMove.bind(this)));
+    this._register(addDisposableListener(this._element, 'mousedown', this._handleMouseDown.bind(this)));
+    this._register(addDisposableListener(this._element, 'mouseup', this._handleMouseUp.bind(this)));
   }
 
   private _handleMouseMove(event: MouseEvent): void {
@@ -240,7 +241,8 @@ export class Linkifier extends Disposable implements ILinkifier2 {
     if (!startRow || !endRow || (this._currentLink.link.range.start.y >= startRow && this._currentLink.link.range.end.y <= endRow)) {
       this._linkLeave(this._element, this._currentLink.link, this._lastMouseEvent);
       this._currentLink = undefined;
-      disposeArray(this._linkCacheDisposables);
+      dispose(this._linkCacheDisposables);
+      this._linkCacheDisposables.length = 0;
     }
   }
 

package/src/browser/Viewport.ts

@@ -5,7 +5,7 @@
 
 import { ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
 import { ViewportConstants } from 'browser/shared/Constants';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { IBufferService, ICoreMouseService, IOptionsService } from 'common/services/Services';
 import { CoreMouseEventType } from 'common/Types';
 import { scheduleAtNextAnimationFrame } from 'vs/base/browser/dom';
@@ -16,7 +16,7 @@ import { Scrollable, ScrollbarVisibility, type ScrollEvent } from 'vs/base/commo
 
 export class Viewport extends Disposable {
 
-  protected _onRequestScrollLines = this.register(new Emitter<number>());
+  protected _onRequestScrollLines = this._register(new Emitter<number>());
   public readonly onRequestScrollLines = this._onRequestScrollLines.event;
 
   private _scrollableElement: SmoothScrollableElement;
@@ -40,46 +40,46 @@ export class Viewport extends Disposable {
   ) {
     super();
 
-    const scrollable = this.register(new Scrollable({
+    const scrollable = this._register(new Scrollable({
       forceIntegerValues: false,
       smoothScrollDuration: this._optionsService.rawOptions.smoothScrollDuration,
       // This is used over `IRenderService.addRefreshCallback` since it can be canceled
       scheduleAtNextAnimationFrame: cb => scheduleAtNextAnimationFrame(coreBrowserService.window, cb)
     }));
-    this.register(this._optionsService.onSpecificOptionChange('smoothScrollDuration', () => {
+    this._register(this._optionsService.onSpecificOptionChange('smoothScrollDuration', () => {
       scrollable.setSmoothScrollDuration(this._optionsService.rawOptions.smoothScrollDuration);
     }));
 
-    this._scrollableElement = this.register(new SmoothScrollableElement(screenElement, {
+    this._scrollableElement = this._register(new SmoothScrollableElement(screenElement, {
       vertical: ScrollbarVisibility.Auto,
       horizontal: ScrollbarVisibility.Hidden,
       useShadows: false,
       mouseWheelSmoothScroll: true,
       ...this._getChangeOptions()
     }, scrollable));
-    this.register(this._optionsService.onMultipleOptionChange([
+    this._register(this._optionsService.onMultipleOptionChange([
       'scrollSensitivity',
       'fastScrollSensitivity',
       'overviewRuler'
     ], () => this._scrollableElement.updateOptions(this._getChangeOptions())));
     // Don't handle mouse wheel if wheel events are supported by the current mouse prototcol
-    this.register(coreMouseService.onProtocolChange(type => {
+    this._register(coreMouseService.onProtocolChange(type => {
       this._scrollableElement.updateOptions({
         handleMouseWheel: !(type & CoreMouseEventType.WHEEL)
       });
     }));
 
     this._scrollableElement.setScrollDimensions({ height: 0, scrollHeight: 0 });
-    this.register(Event.runAndSubscribe(themeService.onChangeColors, () => {
+    this._register(Event.runAndSubscribe(themeService.onChangeColors, () => {
       this._scrollableElement.getDomNode().style.backgroundColor = themeService.colors.background.css;
     }));
     element.appendChild(this._scrollableElement.getDomNode());
-    this.register(toDisposable(() => this._scrollableElement.getDomNode().remove()));
+    this._register(toDisposable(() => this._scrollableElement.getDomNode().remove()));
 
-    this._styleElement = coreBrowserService.window.document.createElement('style');
+    this._styleElement = coreBrowserService.mainDocument.createElement('style');
     screenElement.appendChild(this._styleElement);
-    this.register(toDisposable(() => this._styleElement.remove()));
-    this.register(Event.runAndSubscribe(themeService.onChangeColors, () => {
+    this._register(toDisposable(() => this._styleElement.remove()));
+    this._register(Event.runAndSubscribe(themeService.onChangeColors, () => {
       this._styleElement.textContent = [
         `.xterm .xterm-scrollable-element > .scrollbar > .slider {`,
         `  background: ${themeService.colors.scrollbarSliderBackground.css};`,
@@ -93,10 +93,10 @@ export class Viewport extends Disposable {
       ].join('\n');
     }));
 
-    this.register(this._bufferService.onResize(() => this._queueSync()));
-    this.register(this._bufferService.onScroll(() => this._sync()));
+    this._register(this._bufferService.onResize(() => this._queueSync()));
+    this._register(this._bufferService.onScroll(() => this._sync()));
 
-    this.register(this._scrollableElement.onScroll(e => this._handleScroll(e)));
+    this._register(this._scrollableElement.onScroll(e => this._handleScroll(e)));
   }
 
   public scrollLines(disp: number): void {

package/src/browser/decorations/BufferDecorationRenderer.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ICoreBrowserService, IRenderService } from 'browser/services/Services';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { IBufferService, IDecorationService, IInternalDecoration } from 'common/services/Services';
 
 export class BufferDecorationRenderer extends Disposable {
@@ -28,18 +28,18 @@ export class BufferDecorationRenderer extends Disposable {
     this._container.classList.add('xterm-decoration-container');
     this._screenElement.appendChild(this._container);
 
-    this.register(this._renderService.onRenderedViewportChange(() => this._doRefreshDecorations()));
-    this.register(this._renderService.onDimensionsChange(() => {
+    this._register(this._renderService.onRenderedViewportChange(() => this._doRefreshDecorations()));
+    this._register(this._renderService.onDimensionsChange(() => {
       this._dimensionsChanged = true;
       this._queueRefresh();
     }));
-    this.register(this._coreBrowserService.onDprChange(() => this._queueRefresh()));
-    this.register(this._bufferService.buffers.onBufferActivate(() => {
+    this._register(this._coreBrowserService.onDprChange(() => this._queueRefresh()));
+    this._register(this._bufferService.buffers.onBufferActivate(() => {
       this._altBufferIsActive = this._bufferService.buffer === this._bufferService.buffers.alt;
     }));
-    this.register(this._decorationService.onDecorationRegistered(() => this._queueRefresh()));
-    this.register(this._decorationService.onDecorationRemoved(decoration => this._removeDecoration(decoration)));
-    this.register(toDisposable(() => {
+    this._register(this._decorationService.onDecorationRegistered(() => this._queueRefresh()));
+    this._register(this._decorationService.onDecorationRemoved(decoration => this._removeDecoration(decoration)));
+    this._register(toDisposable(() => {
       this._container.remove();
       this._decorationElements.clear();
     }));