Merge pull request #5632 from Tyriar/5631

Remove vs dependency in common

addons/addon-webgl/src/DevicePixelObserver.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { toDisposable, IDisposable } from 'vs/base/common/lifecycle';
+import { toDisposable, IDisposable } from '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

addons/addon-webgl/src/GlyphRenderer.ts

@@ -5,7 +5,7 @@
 import { TextureAtlas } from './TextureAtlas';
 import { IRenderDimensions } from 'browser/renderer/shared/Types';
 import { NULL_CELL_CODE } from 'common/buffer/Constants';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { Terminal } from '@xterm/xterm';
 import { IRenderModel, IWebGL2RenderingContext, IWebGLVertexArrayObject, type IRasterizedGlyph, type ITextureAtlas } from './Types';
 import { createProgram, GLTexture, PROJECTION_MATRIX } from './WebglUtils';

addons/addon-webgl/src/RectangleRenderer.ts

@@ -7,7 +7,7 @@ import { IRenderDimensions } from 'browser/renderer/shared/Types';
 import { IThemeService } from 'browser/services/Services';
 import { ReadonlyColorSet } from 'browser/Types';
 import { Attributes, FgFlags } from 'common/buffer/Constants';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { IColor } from 'common/Types';
 import { Terminal } from '@xterm/xterm';
 import { RENDER_MODEL_BG_OFFSET, RENDER_MODEL_FG_OFFSET, RENDER_MODEL_INDICIES_PER_CELL } from './RenderModel';

addons/addon-webgl/src/TextureAtlas.ts

@@ -15,7 +15,7 @@ import { IColor } from 'common/Types';
 import { AttributeData } from 'common/buffer/AttributeData';
 import { Attributes, DEFAULT_COLOR, DEFAULT_EXT, UnderlineStyle } from 'common/buffer/Constants';
 import { IUnicodeService } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 /**
  * A shared object which is used to draw nothing for a particular cell.

addons/addon-webgl/src/Types.ts

@@ -7,7 +7,7 @@ import { FontWeight } from '@xterm/xterm';
 import { IColorSet } from 'browser/Types';
 import { ISelectionRenderModel } from 'browser/renderer/shared/Types';
 import { CursorInactiveStyle, CursorStyle, type IDisposable } from 'common/Types';
-import type { Event } from 'vs/base/common/event';
+import type { IEvent } from 'common/Event';
 
 export interface IRenderModel {
   cells: Uint32Array;
@@ -58,8 +58,8 @@ export interface ICharAtlasConfig {
 export interface ITextureAtlas extends IDisposable {
   readonly pages: { canvas: HTMLCanvasElement, version: number }[];
 
-  onAddTextureAtlasCanvas: Event<HTMLCanvasElement>;
-  onRemoveTextureAtlasCanvas: Event<HTMLCanvasElement>;
+  onAddTextureAtlasCanvas: IEvent<HTMLCanvasElement>;
+  onRemoveTextureAtlasCanvas: IEvent<HTMLCanvasElement>;
 
   /**
    * Warm up the texture atlas, adding common glyphs to avoid slowing early frame.

addons/addon-webgl/src/WebglAddon.ts

@@ -7,13 +7,13 @@ import type { ITerminalAddon, Terminal } from '@xterm/xterm';
 import type { IWebglAddonOptions, WebglAddon as IWebglApi } from '@xterm/addon-webgl';
 import { ICharacterJoinerService, ICharSizeService, ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
 import { ITerminal } from 'browser/Types';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { getSafariVersion, isSafari } from 'common/Platform';
 import { ICoreService, IDecorationService, ILogService, IOptionsService } from 'common/services/Services';
 import { IWebGL2RenderingContext } from './Types';
 import { WebglRenderer } from './WebglRenderer';
 import { setTraceLogger } from 'common/services/LogService';
-import { Emitter, Event } from 'vs/base/common/event';
+import { Emitter, EventUtils } from 'common/Event';
 
 export class WebglAddon extends Disposable implements ITerminalAddon , IWebglApi {
   private _terminal?: Terminal;
@@ -85,10 +85,10 @@ export class WebglAddon extends Disposable implements ITerminalAddon , IWebglApi
       this._customGlyphs,
       this._preserveDrawingBuffer
     ));
-    this._register(Event.forward(this._renderer.onContextLoss, this._onContextLoss));
-    this._register(Event.forward(this._renderer.onChangeTextureAtlas, this._onChangeTextureAtlas));
-    this._register(Event.forward(this._renderer.onAddTextureAtlasCanvas, this._onAddTextureAtlasCanvas));
-    this._register(Event.forward(this._renderer.onRemoveTextureAtlasCanvas, this._onRemoveTextureAtlasCanvas));
+    this._register(EventUtils.forward(this._renderer.onContextLoss, this._onContextLoss));
+    this._register(EventUtils.forward(this._renderer.onChangeTextureAtlas, this._onChangeTextureAtlas));
+    this._register(EventUtils.forward(this._renderer.onAddTextureAtlasCanvas, this._onAddTextureAtlasCanvas));
+    this._register(EventUtils.forward(this._renderer.onRemoveTextureAtlasCanvas, this._onRemoveTextureAtlasCanvas));
     renderService.setRenderer(this._renderer);
 
     this._register(toDisposable(() => {

addons/addon-webgl/src/WebglRenderer.ts

@@ -22,9 +22,9 @@ import { COMBINED_CHAR_BIT_MASK, RENDER_MODEL_BG_OFFSET, RENDER_MODEL_EXT_OFFSET
 import { IWebGL2RenderingContext, type ITextureAtlas } from './Types';
 import { LinkRenderLayer } from './renderLayer/LinkRenderLayer';
 import { IRenderLayer } from './renderLayer/Types';
-import { Emitter, Event } from 'vs/base/common/event';
+import { Emitter, EventUtils } from 'common/Event';
 import { addDisposableListener } from 'vs/base/browser/dom';
-import { combinedDisposable, Disposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { combinedDisposable, Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
 import { createRenderDimensions } from 'browser/renderer/shared/RendererUtils';
 
 export class WebglRenderer extends Disposable implements IRenderer {
@@ -290,8 +290,8 @@ export class WebglRenderer extends Disposable implements IRenderer {
     if (this._charAtlas !== atlas) {
       this._onChangeTextureAtlas.fire(atlas.pages[0].canvas);
       this._charAtlasDisposable.value = combinedDisposable(
-        Event.forward(atlas.onAddTextureAtlasCanvas, this._onAddTextureAtlasCanvas),
-        Event.forward(atlas.onRemoveTextureAtlasCanvas, this._onRemoveTextureAtlasCanvas)
+        EventUtils.forward(atlas.onAddTextureAtlasCanvas, this._onAddTextureAtlasCanvas),
+        EventUtils.forward(atlas.onRemoveTextureAtlasCanvas, this._onRemoveTextureAtlasCanvas)
       );
     }
     this._charAtlas = atlas;

addons/addon-webgl/src/renderLayer/BaseRenderLayer.ts

@@ -7,7 +7,7 @@ import { ReadonlyColorSet } from 'browser/Types';
 import { acquireTextureAtlas } from '../CharAtlasCache';
 import { IRenderDimensions } from 'browser/renderer/shared/Types';
 import { ICoreBrowserService, IThemeService } from 'browser/services/Services';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { CellData } from 'common/buffer/CellData';
 import { IOptionsService } from 'common/services/Services';
 import { Terminal } from '@xterm/xterm';

headless/package.json

@@ -1,7 +1,7 @@
 {
  "name": "@xterm/headless",
  "description": "A headless terminal component that runs in Node.js",
- "version": "5.5.0",
+ "version": "6.0.0",
  "main": "lib-headless/xterm-headless.js",
  "module": "lib-headless/xterm-headless.mjs",
  "types": "typings/xterm-headless.d.ts",

src/browser/AccessibilityManager.ts

@@ -6,7 +6,7 @@
 import * as Strings from 'browser/LocalizableStrings';
 import { ITerminal, IRenderDebouncer } from 'browser/Types';
 import { TimeBasedDebouncer } from 'browser/TimeBasedDebouncer';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { ICoreBrowserService, IRenderService } from 'browser/services/Services';
 import { IBuffer } from 'common/buffer/Types';
 import { IInstantiationService } from 'common/services/Services';

src/browser/CoreBrowserTerminal.ts

@@ -55,9 +55,9 @@ import { IDecorationService } from 'common/services/Services';
 import { WindowsOptionsReportType } from '../common/InputHandler';
 import { AccessibilityManager } from './AccessibilityManager';
 import { Linkifier } from './Linkifier';
-import { Emitter, Event } from 'vs/base/common/event';
+import { Emitter, EventUtils, type IEvent } from 'common/Event';
 import { addDisposableListener } from 'vs/base/browser/dom';
-import { MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { MutableDisposable, toDisposable } from 'common/Lifecycle';
 
 export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
   public textarea: HTMLTextAreaElement | undefined;
@@ -135,15 +135,15 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
   public readonly onBell = this._onBell.event;
 
   private _onFocus = this._register(new Emitter<void>());
-  public get onFocus(): Event<void> { return this._onFocus.event; }
+  public get onFocus(): IEvent<void> { return this._onFocus.event; }
   private _onBlur = this._register(new Emitter<void>());
-  public get onBlur(): Event<void> { return this._onBlur.event; }
+  public get onBlur(): IEvent<void> { return this._onBlur.event; }
   private _onA11yCharEmitter = this._register(new Emitter<string>());
-  public get onA11yChar(): Event<string> { return this._onA11yCharEmitter.event; }
+  public get onA11yChar(): IEvent<string> { return this._onA11yCharEmitter.event; }
   private _onA11yTabEmitter = this._register(new Emitter<number>());
-  public get onA11yTab(): Event<number> { return this._onA11yTabEmitter.event; }
+  public get onA11yTab(): IEvent<number> { return this._onA11yTabEmitter.event; }
   private _onWillOpen = this._register(new Emitter<HTMLElement>());
-  public get onWillOpen(): Event<HTMLElement> { return this._onWillOpen.event; }
+  public get onWillOpen(): IEvent<HTMLElement> { return this._onWillOpen.event; }
   private readonly _onDimensionsChange = this._register(new Emitter<IRenderDimensionsApi>());
   public readonly onDimensionsChange = this._onDimensionsChange.event;
 
@@ -187,10 +187,10 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
     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(EventUtils.forward(this._inputHandler.onCursorMove, this._onCursorMove));
+    this._register(EventUtils.forward(this._inputHandler.onTitleChange, this._onTitleChange));
+    this._register(EventUtils.forward(this._inputHandler.onA11yChar, this._onA11yCharEmitter));
+    this._register(EventUtils.forward(this._inputHandler.onA11yTab, this._onA11yTabEmitter));
 
     // Setup listeners
     this._register(this._bufferService.onResize(e => this._afterResize(e.cols, e.rows)));
@@ -566,7 +566,7 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
       this.textarea!.focus();
       this.textarea!.select();
     }));
-    this._register(Event.any(
+    this._register(EventUtils.any(
       this._onScroll.event,
       this._inputHandler.onScroll
     )(() => {

src/browser/Linkifier.ts

@@ -4,11 +4,11 @@
  */
 
 import { IBufferCellPosition, ILink, ILinkDecorations, ILinkWithState, ILinkifier2, ILinkifierEvent } from 'browser/Types';
-import { Disposable, dispose, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, dispose, toDisposable } from '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 { Emitter } from 'common/Event';
 import { addDisposableListener } from 'vs/base/browser/dom';
 
 export class Linkifier extends Disposable implements ILinkifier2 {

src/browser/TestUtils.test.ts

@@ -18,7 +18,7 @@ import { AttributeData } from 'common/buffer/AttributeData';
 import { ISelectionRedrawRequestEvent, ISelectionRequestScrollLinesEvent } from 'browser/selection/Types';
 import { css } from 'common/Color';
 import { createRenderDimensions } from 'browser/renderer/shared/RendererUtils';
-import { Emitter, type Event } from 'vs/base/common/event';
+import { Emitter, type IEvent } from 'common/Event';
 
 export class TestTerminal extends CoreBrowserTerminal {
   public get curAttrData(): IAttributeData { return (this as any)._inputHandler._curAttrData; }
@@ -30,24 +30,24 @@ export class TestTerminal extends CoreBrowserTerminal {
 }
 
 export class MockTerminal implements ITerminal {
-  public onBlur!: Event<void>;
-  public onFocus!: Event<void>;
-  public onA11yChar!: Event<string>;
-  public onWriteParsed!: Event<void>;
-  public onA11yTab!: Event<number>;
-  public onCursorMove!: Event<void>;
-  public onLineFeed!: Event<void>;
-  public onSelectionChange!: Event<void>;
-  public onData!: Event<string>;
-  public onBinary!: Event<string>;
-  public onTitleChange!: Event<string>;
-  public onBell!: Event<void>;
-  public onScroll!: Event<number>;
-  public onWillOpen!: Event<HTMLElement>;
-  public onKey!: Event<{ key: string, domEvent: KeyboardEvent }>;
-  public onRender!: Event<{ start: number, end: number }>;
-  public onResize!: Event<{ cols: number, rows: number }>;
-  public onDimensionsChange!: Event<IRenderDimensionsApi>;
+  public onBlur!: IEvent<void>;
+  public onFocus!: IEvent<void>;
+  public onA11yChar!: IEvent<string>;
+  public onWriteParsed!: IEvent<void>;
+  public onA11yTab!: IEvent<number>;
+  public onCursorMove!: IEvent<void>;
+  public onLineFeed!: IEvent<void>;
+  public onSelectionChange!: IEvent<void>;
+  public onData!: IEvent<string>;
+  public onBinary!: IEvent<string>;
+  public onTitleChange!: IEvent<string>;
+  public onBell!: IEvent<void>;
+  public onScroll!: IEvent<number>;
+  public onWillOpen!: IEvent<HTMLElement>;
+  public onKey!: IEvent<{ key: string, domEvent: KeyboardEvent }>;
+  public onRender!: IEvent<{ start: number, end: number }>;
+  public onResize!: IEvent<{ cols: number, rows: number }>;
+  public onDimensionsChange!: IEvent<IRenderDimensionsApi>;
   public dimensions: IRenderDimensionsApi | undefined;
   public markers!: IMarker[];
   public linkifier: ILinkifier2 | undefined;
@@ -276,9 +276,9 @@ export class MockBuffer implements IBuffer {
 }
 
 export class MockRenderer implements IRenderer {
-  public onRequestRedraw!: Event<IRequestRedrawEvent>;
-  public onCanvasResize!: Event<{ width: number, height: number }>;
-  public onRender!: Event<{ start: number, end: number }>;
+  public onRequestRedraw!: IEvent<IRequestRedrawEvent>;
+  public onCanvasResize!: IEvent<{ width: number, height: number }>;
+  public onRender!: IEvent<{ start: number, end: number }>;
   public dispose(): void {
     throw new Error('Method not implemented.');
   }
@@ -381,7 +381,7 @@ export class MockCoreBrowserService implements ICoreBrowserService {
 export class MockCharSizeService implements ICharSizeService {
   public serviceBrand: undefined;
   public get hasValidSize(): boolean { return this.width > 0 && this.height > 0; }
-  public onCharSizeChange: Event<void> = new Emitter<void>().event;
+  public onCharSizeChange: IEvent<void> = new Emitter<void>().event;
   constructor(public width: number, public height: number) {}
   public measure(): void {}
 }
@@ -399,10 +399,10 @@ export class MockMouseService implements IMouseService {
 
 export class MockRenderService implements IRenderService {
   public serviceBrand: undefined;
-  public onDimensionsChange: Event<IRenderDimensions> = new Emitter<IRenderDimensions>().event;
-  public onRenderedViewportChange: Event<{ start: number, end: number }> = new Emitter<{ start: number, end: number }>().event;
-  public onRender: Event<{ start: number, end: number }> = new Emitter<{ start: number, end: number }>().event;
-  public onRefreshRequest: Event<{ start: number, end: number}> = new Emitter<{ start: number, end: number }>().event;
+  public onDimensionsChange: IEvent<IRenderDimensions> = new Emitter<IRenderDimensions>().event;
+  public onRenderedViewportChange: IEvent<{ start: number, end: number }> = new Emitter<{ start: number, end: number }>().event;
+  public onRender: IEvent<{ start: number, end: number }> = new Emitter<{ start: number, end: number }>().event;
+  public onRefreshRequest: IEvent<{ start: number, end: number}> = new Emitter<{ start: number, end: number }>().event;
   public dimensions: IRenderDimensions = createRenderDimensions();
   public refreshRows(start: number, end: number): void {
     throw new Error('Method not implemented.');

src/browser/Types.ts

@@ -7,7 +7,7 @@ import { CharData, IColor, ICoreTerminal, ITerminalOptions } from 'common/Types'
 import { IBuffer } from 'common/buffer/Types';
 import { IDisposable, IRenderDimensions as IRenderDimensionsApi, Terminal as ITerminalApi } from '@xterm/xterm';
 import { channels, css } from 'common/Color';
-import type { Event } from 'vs/base/common/event';
+import type { IEvent } from 'common/Event';
 
 /**
  * A portion of the public API that are implemented identially internally and simply passed through.
@@ -23,12 +23,12 @@ export interface ITerminal extends InternalPassthroughApis, ICoreTerminal {
 
   readonly dimensions: IRenderDimensionsApi | undefined;
 
-  onBlur: Event<void>;
-  onFocus: Event<void>;
-  onDimensionsChange: Event<IRenderDimensionsApi>;
-  onA11yChar: Event<string>;
-  onA11yTab: Event<number>;
-  onWillOpen: Event<HTMLElement>;
+  onBlur: IEvent<void>;
+  onFocus: IEvent<void>;
+  onDimensionsChange: IEvent<IRenderDimensionsApi>;
+  onA11yChar: IEvent<string>;
+  onA11yTab: IEvent<number>;
+  onWillOpen: IEvent<HTMLElement>;
 
   cancel(ev: MouseEvent | WheelEvent | KeyboardEvent | InputEvent, force?: boolean): boolean | void;
 }
@@ -101,7 +101,7 @@ export interface IPartialColorSet {
 
 export interface IViewport extends IDisposable {
   scrollBarWidth: number;
-  readonly onRequestScrollLines: Event<{ amount: number, suppressScrollEvent: boolean }>;
+  readonly onRequestScrollLines: IEvent<{ amount: number, suppressScrollEvent: boolean }>;
   syncScrollArea(immediate?: boolean, force?: boolean): void;
   getLinesScrolled(ev: WheelEvent): number;
   getBufferElements(startLine: number, endLine?: number): { bufferElements: HTMLElement[], cursorElement?: HTMLElement };
@@ -131,8 +131,8 @@ export interface ILinkWithState {
 }
 
 export interface ILinkifier2 extends IDisposable {
-  onShowLinkUnderline: Event<ILinkifierEvent>;
-  onHideLinkUnderline: Event<ILinkifierEvent>;
+  onShowLinkUnderline: IEvent<ILinkifierEvent>;
+  onHideLinkUnderline: IEvent<ILinkifierEvent>;
   readonly currentLink: ILinkWithState | undefined;
 }
 

src/browser/Viewport.ts

@@ -5,13 +5,13 @@
 
 import { ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
 import { ViewportConstants } from 'browser/shared/Constants';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { IBufferService, ICoreMouseService, IOptionsService } from 'common/services/Services';
 import { CoreMouseEventType } from 'common/Types';
 import { addDisposableListener, scheduleAtNextAnimationFrame } from 'vs/base/browser/dom';
 import { SmoothScrollableElement } from 'vs/base/browser/ui/scrollbar/scrollableElement';
 import type { ScrollableElementChangeOptions } from 'vs/base/browser/ui/scrollbar/scrollableElementOptions';
-import { Emitter, Event } from 'vs/base/common/event';
+import { Emitter, EventUtils } from 'common/Event';
 import { Scrollable, ScrollbarVisibility, type ScrollEvent } from 'vs/base/common/scrollable';
 import { Gesture, EventType as GestureEventType, type GestureEvent } from 'vs/base/browser/touch';
 
@@ -71,7 +71,7 @@ export class Viewport extends Disposable {
     }));
 
     this._scrollableElement.setScrollDimensions({ height: 0, scrollHeight: 0 });
-    this._register(Event.runAndSubscribe(themeService.onChangeColors, () => {
+    this._register(EventUtils.runAndSubscribe(themeService.onChangeColors, () => {
       element.style.backgroundColor = themeService.colors.background.css;
       this._scrollableElement.getDomNode().style.backgroundColor = themeService.colors.background.css;
     }));
@@ -81,7 +81,7 @@ export class Viewport extends Disposable {
     this._styleElement = coreBrowserService.mainDocument.createElement('style');
     screenElement.appendChild(this._styleElement);
     this._register(toDisposable(() => this._styleElement.remove()));
-    this._register(Event.runAndSubscribe(themeService.onChangeColors, () => {
+    this._register(EventUtils.runAndSubscribe(themeService.onChangeColors, () => {
       this._styleElement.textContent = [
         `.xterm .xterm-scrollable-element > .scrollbar > .slider {`,
         `  background: ${themeService.colors.scrollbarSliderBackground.css};`,

src/browser/decorations/BufferDecorationRenderer.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ICoreBrowserService, IRenderService } from 'browser/services/Services';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { IBufferService, IDecorationService, IInternalDecoration } from 'common/services/Services';
 
 export class BufferDecorationRenderer extends Disposable {

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 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { IBufferService, IDecorationService, IOptionsService } from 'common/services/Services';
 
 const enum Constants {

src/browser/public/Terminal.ts

@@ -6,14 +6,14 @@
 import * as Strings from 'browser/LocalizableStrings';
 import { CoreBrowserTerminal as TerminalCore } from 'browser/CoreBrowserTerminal';
 import { IBufferRange, ITerminal } from 'browser/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { ITerminalOptions } from 'common/Types';
 import { AddonManager } from 'common/public/AddonManager';
 import { BufferNamespaceApi } from 'common/public/BufferNamespaceApi';
 import { ParserApi } from 'common/public/ParserApi';
 import { UnicodeApi } from 'common/public/UnicodeApi';
 import { IBufferNamespace as IBufferNamespaceApi, IDecoration, IDecorationOptions, IDisposable, ILinkProvider, ILocalizableStrings, IMarker, IModes, IParser, IRenderDimensions, ITerminalAddon, Terminal as ITerminalApi, ITerminalInitOnlyOptions, IUnicodeHandling } from '@xterm/xterm';
-import type { Event } from 'vs/base/common/event';
+import type { IEvent } from 'common/Event';
 
 /**
  * The set of options that only have an effect when set in the Terminal constructor.
@@ -68,19 +68,19 @@ export class Terminal extends Disposable implements ITerminalApi {
     }
   }
 
-  public get onBell(): Event<void> { return this._core.onBell; }
-  public get onBinary(): Event<string> { return this._core.onBinary; }
-  public get onCursorMove(): Event<void> { return this._core.onCursorMove; }
-  public get onData(): Event<string> { return this._core.onData; }
-  public get onKey(): Event<{ key: string, domEvent: KeyboardEvent }> { return this._core.onKey; }
-  public get onLineFeed(): Event<void> { return this._core.onLineFeed; }
-  public get onRender(): Event<{ start: number, end: number }> { return this._core.onRender; }
-  public get onResize(): Event<{ cols: number, rows: number }> { return this._core.onResize; }
-  public get onScroll(): Event<number> { return this._core.onScroll; }
-  public get onSelectionChange(): Event<void> { return this._core.onSelectionChange; }
-  public get onTitleChange(): Event<string> { return this._core.onTitleChange; }
-  public get onWriteParsed(): Event<void> { return this._core.onWriteParsed; }
-  public get onDimensionsChange(): Event<IRenderDimensions> { return this._core.onDimensionsChange; }
+  public get onBell(): IEvent<void> { return this._core.onBell; }
+  public get onBinary(): IEvent<string> { return this._core.onBinary; }
+  public get onCursorMove(): IEvent<void> { return this._core.onCursorMove; }
+  public get onData(): IEvent<string> { return this._core.onData; }
+  public get onKey(): IEvent<{ key: string, domEvent: KeyboardEvent }> { return this._core.onKey; }
+  public get onLineFeed(): IEvent<void> { return this._core.onLineFeed; }
+  public get onRender(): IEvent<{ start: number, end: number }> { return this._core.onRender; }
+  public get onResize(): IEvent<{ cols: number, rows: number }> { return this._core.onResize; }
+  public get onScroll(): IEvent<number> { return this._core.onScroll; }
+  public get onSelectionChange(): IEvent<void> { return this._core.onSelectionChange; }
+  public get onTitleChange(): IEvent<string> { return this._core.onTitleChange; }
+  public get onWriteParsed(): IEvent<void> { return this._core.onWriteParsed; }
+  public get onDimensionsChange(): IEvent<IRenderDimensions> { return this._core.onDimensionsChange; }
 
   public get element(): HTMLElement | undefined { return this._core.element; }
   public get parser(): IParser {

src/browser/renderer/dom/DomRenderer.ts

@@ -12,9 +12,9 @@ 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 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { IBufferService, ICoreService, IInstantiationService, IOptionsService } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 import { addDisposableListener } from 'vs/base/browser/dom';
 
 

src/browser/renderer/shared/Types.ts

@@ -6,7 +6,7 @@
 import { Terminal } from '@xterm/xterm';
 import { ITerminal } from 'browser/Types';
 import { IDisposable } from 'common/Types';
-import type { Event } from 'vs/base/common/event';
+import type { IEvent } from 'common/Event';
 
 export interface IDimensions {
   width: number;
@@ -57,7 +57,7 @@ export interface IRenderer extends IDisposable {
    * Fires when the renderer is requesting to be redrawn on the next animation
    * frame but is _not_ a result of content changing (eg. selection changes).
    */
-  readonly onRequestRedraw: Event<IRequestRedrawEvent>;
+  readonly onRequestRedraw: IEvent<IRequestRedrawEvent>;
 
   dispose(): void;
   handleDevicePixelRatioChange(): void;

src/browser/services/CharSizeService.ts

@@ -5,8 +5,8 @@
 
 import { IOptionsService } from 'common/services/Services';
 import { ICharSizeService } from 'browser/services/Services';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 export class CharSizeService extends Disposable implements ICharSizeService {
   public serviceBrand: undefined;

src/browser/services/CoreBrowserService.ts

@@ -4,9 +4,9 @@
  */
 
 import { ICoreBrowserService } from './Services';
-import { Emitter, Event } from 'vs/base/common/event';
+import { Emitter, EventUtils } from 'common/Event';
 import { addDisposableListener } from 'vs/base/browser/dom';
-import { Disposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
 
 export class CoreBrowserService extends Disposable implements ICoreBrowserService {
   public serviceBrand: undefined;
@@ -29,7 +29,7 @@ export class CoreBrowserService extends Disposable implements ICoreBrowserServic
 
     // Monitor device pixel ratio
     this._register(this.onWindowChange(w => this._screenDprMonitor.setWindow(w)));
-    this._register(Event.forward(this._screenDprMonitor.onDprChange, this._onDprChange));
+    this._register(EventUtils.forward(this._screenDprMonitor.onDprChange, this._onDprChange));
 
     this._register(addDisposableListener(this._textarea, 'focus', () => this._isFocused = true));
     this._register(addDisposableListener(this._textarea, 'blur', () => this._isFocused = false));

src/browser/services/LinkProviderService.ts

@@ -1,5 +1,5 @@
 import { ILinkProvider, ILinkProviderService } from 'browser/services/Services';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { IDisposable } from 'common/Types';
 
 export class LinkProviderService extends Disposable implements ILinkProviderService {

src/browser/services/RenderService.ts

@@ -7,10 +7,10 @@ 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 'vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
 import { DebouncedIdleTask } from 'common/TaskQueue';
 import { IBufferService, ICoreService, IDecorationService, IOptionsService } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 interface ISelectionState {
   start: [number, number] | undefined;

src/browser/services/SelectionService.ts

@@ -9,14 +9,14 @@ 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 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import * as Browser from 'common/Platform';
 import { IBufferLine, IDisposable } from 'common/Types';
 import { getRangeLength } from 'common/buffer/BufferRange';
 import { CellData } from 'common/buffer/CellData';
 import { IBuffer } from 'common/buffer/Types';
 import { IBufferService, ICoreService, IOptionsService } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 /**
  * The number of pixels the mouse needs to be above or below the viewport in

src/browser/services/Services.ts

@@ -8,7 +8,7 @@ import { IColorSet, ILink, ReadonlyColorSet } from 'browser/Types';
 import { ISelectionRedrawRequestEvent as ISelectionRequestRedrawEvent, ISelectionRequestScrollLinesEvent } from 'browser/selection/Types';
 import { createDecorator } from 'common/services/ServiceRegistry';
 import { AllColorIndex, IDisposable, IKeyboardResult } from 'common/Types';
-import type { Event } from 'vs/base/common/event';
+import type { IEvent } from 'common/Event';
 
 export const ICharSizeService = createDecorator<ICharSizeService>('CharSizeService');
 export interface ICharSizeService {
@@ -18,7 +18,7 @@ export interface ICharSizeService {
   readonly height: number;
   readonly hasValidSize: boolean;
 
-  readonly onCharSizeChange: Event<void>;
+  readonly onCharSizeChange: IEvent<void>;
 
   measure(): void;
 }
@@ -29,8 +29,8 @@ export interface ICoreBrowserService {
 
   readonly isFocused: boolean;
 
-  readonly onDprChange: Event<number>;
-  readonly onWindowChange: Event<Window & typeof globalThis>;
+  readonly onDprChange: IEvent<number>;
+  readonly onWindowChange: IEvent<Window & typeof globalThis>;
 
   /**
    * Gets or sets the parent window that the terminal is rendered into. DOM and rendering APIs (e.g.
@@ -61,17 +61,17 @@ export const IRenderService = createDecorator<IRenderService>('RenderService');
 export interface IRenderService extends IDisposable {
   serviceBrand: undefined;
 
-  onDimensionsChange: Event<IRenderDimensions>;
+  onDimensionsChange: IEvent<IRenderDimensions>;
   /**
    * Fires when buffer changes are rendered. This does not fire when only cursor
    * or selections are rendered.
    */
-  onRenderedViewportChange: Event<{ start: number, end: number }>;
+  onRenderedViewportChange: IEvent<{ start: number, end: number }>;
   /**
    * Fires on render
    */
-  onRender: Event<{ start: number, end: number }>;
-  onRefreshRequest: Event<{ start: number, end: number }>;
+  onRender: IEvent<{ start: number, end: number }>;
+  onRefreshRequest: IEvent<{ start: number, end: number }>;
 
   dimensions: IRenderDimensions;
 
@@ -101,10 +101,10 @@ export interface ISelectionService {
   readonly selectionStart: [number, number] | undefined;
   readonly selectionEnd: [number, number] | undefined;
 
-  readonly onLinuxMouseSelection: Event<string>;
-  readonly onRequestRedraw: Event<ISelectionRequestRedrawEvent>;
-  readonly onRequestScrollLines: Event<ISelectionRequestScrollLinesEvent>;
-  readonly onSelectionChange: Event<void>;
+  readonly onLinuxMouseSelection: IEvent<string>;
+  readonly onRequestRedraw: IEvent<ISelectionRequestRedrawEvent>;
+  readonly onRequestScrollLines: IEvent<ISelectionRequestScrollLinesEvent>;
+  readonly onSelectionChange: IEvent<void>;
 
   disable(): void;
   enable(): void;
@@ -136,7 +136,7 @@ export interface IThemeService {
 
   readonly colors: ReadonlyColorSet;
 
-  readonly onChangeColors: Event<ReadonlyColorSet>;
+  readonly onChangeColors: IEvent<ReadonlyColorSet>;
 
   restoreColor(slot?: AllColorIndex): void;
   /**

src/browser/services/ThemeService.ts

@@ -7,10 +7,10 @@ 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 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { IOptionsService, ITheme } from 'common/services/Services';
 import { AllColorIndex, IColor, SpecialColorIndex } from 'common/Types';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 interface IRestoreColorSet {
   foreground: IColor;

src/common/CircularList.ts

@@ -4,8 +4,8 @@
  */
 
 import { ICircularList } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 export interface IInsertEvent {
   index: number;

src/common/CoreTerminal.ts

@@ -37,8 +37,8 @@ import { IBufferSet } from 'common/buffer/Types';
 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';
+import { Emitter, EventUtils, type IEvent } from 'common/Event';
+import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
 
 // Only trigger this warning a single time per session
 let hasWriteSyncWarnHappened = false;
@@ -78,7 +78,7 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
    */
   protected _onScrollApi?: Emitter<number>;
   protected _onScroll = this._register(new Emitter<IScrollEvent>());
-  public get onScroll(): Event<number> {
+  public get onScroll(): IEvent<number> {
     if (!this._onScrollApi) {
       this._onScrollApi = this._register(new Emitter<number>());
       this._onScroll.event(ev => {
@@ -125,12 +125,12 @@ 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(EventUtils.forward(this._inputHandler.onLineFeed, this._onLineFeed));
 
     // 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(EventUtils.forward(this._bufferService.onResize, this._onResize));
+    this._register(EventUtils.forward(this.coreService.onData, this._onData));
+    this._register(EventUtils.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(['windowsPty'], () => this._handleWindowsPtyOptionChange()));
@@ -140,7 +140,7 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
     }));
     // 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._register(EventUtils.forward(this._writeBuffer.onWriteParsed, this._onWriteParsed));
   }
 
   public write(data: string | Uint8Array, callback?: () => void): void {

src/common/Event.ts

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2024-2026 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * Minimal event utilities for xterm.js core.
+ * Simplified from VS Code's event.ts - no leak detection/profiling.
+ */
+
+import { IDisposable, DisposableStore, toDisposable } from 'common/Lifecycle';
+
+export interface IEvent<T> {
+  (listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
+}
+
+export class Emitter<T> {
+  private _listeners: { fn: (e: T) => any, thisArgs: any }[] = [];
+  private _disposed = false;
+  private _event: IEvent<T> | undefined;
+
+  public get event(): IEvent<T> {
+    if (!this._event) {
+      this._event = (listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore) => {
+        if (this._disposed) {
+          return toDisposable(() => {});
+        }
+
+        const entry = { fn: listener, thisArgs };
+        this._listeners.push(entry);
+
+        const result = toDisposable(() => {
+          const idx = this._listeners.indexOf(entry);
+          if (idx !== -1) {
+            this._listeners.splice(idx, 1);
+          }
+        });
+
+        if (disposables) {
+          if (Array.isArray(disposables)) {
+            disposables.push(result);
+          } else {
+            disposables.add(result);
+          }
+        }
+
+        return result;
+      };
+    }
+    return this._event;
+  }
+
+  public fire(event: T): void {
+    if (this._disposed) {
+      return;
+    }
+    // Snapshot listeners to allow modifications during iteration
+    const listeners = this._listeners.slice();
+    for (const { fn, thisArgs } of listeners) {
+      fn.call(thisArgs, event);
+    }
+  }
+
+  public dispose(): void {
+    if (this._disposed) {
+      return;
+    }
+    this._disposed = true;
+    this._listeners.length = 0;
+  }
+}
+
+export namespace EventUtils {
+  export function forward<T>(from: IEvent<T>, to: Emitter<T>): IDisposable {
+    return from(e => to.fire(e));
+  }
+
+  export function map<I, O>(event: IEvent<I>, map: (i: I) => O): IEvent<O> {
+    return (listener: (e: O) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore) => {
+      return event(i => listener.call(thisArgs, map(i)), undefined, disposables);
+    };
+  }
+
+  export function any<T>(...events: IEvent<T>[]): IEvent<T>;
+  export function any(...events: IEvent<any>[]): IEvent<void>;
+  export function any<T>(...events: IEvent<T>[]): IEvent<T> {
+    return (listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore) => {
+      const store = new DisposableStore();
+      for (const event of events) {
+        store.add(event(e => listener.call(thisArgs, e)));
+      }
+      if (disposables) {
+        if (Array.isArray(disposables)) {
+          disposables.push(store);
+        } else {
+          disposables.add(store);
+        }
+      }
+      return store;
+    };
+  }
+
+  export function runAndSubscribe<T>(event: IEvent<T>, handler: (e: T | undefined) => void): IDisposable {
+    handler(undefined);
+    return event(e => handler(e));
+  }
+}

src/common/InputHandler.ts

@@ -8,7 +8,7 @@ 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 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { StringToUtf32, stringFromCodePoint, Utf8ToUtf32 } from 'common/input/TextDecoder';
 import { BufferLine, DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine';
 import { IParsingState, IEscapeSequenceParser, IParams, IFunctionIdentifier } from 'common/parser/Types';
@@ -22,7 +22,7 @@ import { DcsHandler } from 'common/parser/DcsParser';
 import { ApcHandler } from 'common/parser/ApcParser';
 import { IBuffer } from 'common/buffer/Types';
 import { parseColor } from 'common/input/XParseColor';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 import { XTERM_VERSION } from 'common/Version';
 
 /**

src/common/Lifecycle.ts

@@ -0,0 +1,100 @@
+/**
+ * Copyright (c) 2024-2026 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * Minimal lifecycle utilities for xterm.js core.
+ * Simplified from VS Code's lifecycle.ts - no tracking/leak detection.
+ */
+
+export interface IDisposable {
+  dispose(): void;
+}
+
+export function toDisposable(fn: () => void): IDisposable {
+  return { dispose: fn };
+}
+
+export function dispose<T extends IDisposable>(disposables: T | T[] | undefined): void {
+  if (!disposables) {
+    return;
+  }
+  if (Array.isArray(disposables)) {
+    for (const d of disposables) {
+      d.dispose();
+    }
+  } else {
+    disposables.dispose();
+  }
+}
+
+export function combinedDisposable(...disposables: IDisposable[]): IDisposable {
+  return toDisposable(() => dispose(disposables));
+}
+
+export class DisposableStore implements IDisposable {
+  private readonly _disposables = new Set<IDisposable>();
+  private _isDisposed = false;
+
+  public get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  public add<T extends IDisposable>(o: T): T {
+    if (this._isDisposed) {
+      o.dispose();
+    } else {
+      this._disposables.add(o);
+    }
+    return o;
+  }
+
+  public dispose(): void {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
+    for (const d of this._disposables) {
+      d.dispose();
+    }
+    this._disposables.clear();
+  }
+}
+
+export abstract class Disposable implements IDisposable {
+  protected readonly _store = new DisposableStore();
+
+  public dispose(): void {
+    this._store.dispose();
+  }
+
+  protected _register<T extends IDisposable>(o: T): T {
+    return this._store.add(o);
+  }
+}
+
+export class MutableDisposable<T extends IDisposable> implements IDisposable {
+  private _value: T | undefined;
+  private _isDisposed = false;
+
+  public get value(): T | undefined {
+    return this._isDisposed ? undefined : this._value;
+  }
+
+  public set value(value: T | undefined) {
+    if (this._isDisposed || value === this._value) {
+      return;
+    }
+    this._value?.dispose();
+    this._value = value;
+  }
+
+  public clear(): void {
+    this.value = undefined;
+  }
+
+  public dispose(): void {
+    this._isDisposed = true;
+    this._value?.dispose();
+    this._value = undefined;
+  }
+}

src/common/TestUtils.test.ts

@@ -12,14 +12,14 @@ import { BufferSet } from 'common/buffer/BufferSet';
 import { IDecPrivateModes, ICoreMouseEvent, CoreMouseEventType, ICharset, IModes, IAttributeData, IOscLinkData, IDisposable } from 'common/Types';
 import { UnicodeV6 } from 'common/input/UnicodeV6';
 import { IDecorationOptions, IDecoration } from '@xterm/xterm';
-import { Emitter, type Event } from 'vs/base/common/event';
+import { Emitter, type IEvent } from 'common/Event';
 
 export class MockBufferService implements IBufferService {
   public serviceBrand: any;
   public get buffer(): IBuffer { return this.buffers.active; }
   public buffers: IBufferSet = {} as any;
-  public onResize: Event<IBufferResizeEvent> = new Emitter<IBufferResizeEvent>().event;
-  public onScroll: Event<number> = new Emitter<number>().event;
+  public onResize: IEvent<IBufferResizeEvent> = new Emitter<IBufferResizeEvent>().event;
+  public onScroll: IEvent<number> = new Emitter<number>().event;
   private readonly _onScroll = new Emitter<number>();
   public isUserScrolling: boolean = false;
   constructor(
@@ -67,7 +67,7 @@ export class MockCoreMouseService implements ICoreMouseService {
   public addProtocol(name: string): void { }
   public reset(): void { }
   public triggerMouseEvent(event: ICoreMouseEvent): boolean { return false; }
-  public onProtocolChange: Event<CoreMouseEventType> = new Emitter<CoreMouseEventType>().event;
+  public onProtocolChange: IEvent<CoreMouseEventType> = new Emitter<CoreMouseEventType>().event;
   public explainEvents(events: CoreMouseEventType): { [event: string]: boolean } {
     throw new Error('Method not implemented.');
   }
@@ -122,10 +122,10 @@ export class MockCoreService implements ICoreService {
     mainStack: [] as number[],
     altStack: [] as number[]
   };
-  public onData: Event<string> = new Emitter<string>().event;
-  public onUserInput: Event<void> = new Emitter<void>().event;
-  public onBinary: Event<string> = new Emitter<string>().event;
-  public onRequestScrollToBottom: Event<void> = new Emitter<void>().event;
+  public onData: IEvent<string> = new Emitter<string>().event;
+  public onUserInput: IEvent<void> = new Emitter<void>().event;
+  public onBinary: IEvent<string> = new Emitter<string>().event;
+  public onRequestScrollToBottom: IEvent<void> = new Emitter<void>().event;
   public reset(): void { }
   public triggerDataEvent(data: string, wasUserInput?: boolean): void { }
   public triggerBinaryEvent(data: string): void { }
@@ -145,7 +145,7 @@ export class MockOptionsService implements IOptionsService {
   public serviceBrand: any;
   public readonly rawOptions: Required<ITerminalOptions> = clone(DEFAULT_OPTIONS);
   public options: Required<ITerminalOptions> = this.rawOptions;
-  public onOptionChange: Event<keyof ITerminalOptions> = new Emitter<keyof ITerminalOptions>().event;
+  public onOptionChange: IEvent<keyof ITerminalOptions> = new Emitter<keyof ITerminalOptions>().event;
   constructor(testOptions?: Partial<ITerminalOptions>) {
     if (testOptions) {
       for (const key of Object.keys(testOptions)) {
@@ -197,7 +197,7 @@ export class MockUnicodeService implements IUnicodeService {
   }
   public versions: string[] = [];
   public activeVersion: string = '';
-  public onChange: Event<string> = new Emitter<string>().event;
+  public onChange: IEvent<string> = new Emitter<string>().event;
   public wcwidth = (codepoint: number): UnicodeCharWidth => this._provider.wcwidth(codepoint);
   public charProperties(codepoint: number, preceding: UnicodeCharProperties): UnicodeCharProperties {
     let width = this.wcwidth(codepoint);

src/common/Types.ts

@@ -9,7 +9,7 @@ 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';
+import type { Emitter, IEvent } from 'common/Event';
 
 export interface ICoreTerminal {
   coreMouseService: ICoreMouseService;
@@ -69,11 +69,11 @@ export interface ICircularList<T> {
   isFull: boolean;
 
   onDeleteEmitter: Emitter<IDeleteEvent>;
-  onDelete: Event<IDeleteEvent>;
+  onDelete: IEvent<IDeleteEvent>;
   onInsertEmitter: Emitter<IInsertEvent>;
-  onInsert: Event<IInsertEvent>;
+  onInsert: IEvent<IInsertEvent>;
   onTrimEmitter: Emitter<number>;
-  onTrim: Event<number>;
+  onTrim: IEvent<number>;
 
   get(index: number): T | undefined;
   set(index: number, value: T): void;
@@ -259,7 +259,7 @@ export interface IMarker extends IDisposable {
   readonly id: number;
   readonly isDisposed: boolean;
   readonly line: number;
-  onDispose: Event<void>;
+  onDispose: IEvent<void>;
 }
 export interface IModes {
   insertMode: boolean;
@@ -468,7 +468,7 @@ export type IColorEvent = (IColorReportRequest | IColorSetRequest | IColorRestor
  * Calls the parser and handles actions generated by the parser.
  */
 export interface IInputHandler {
-  onTitleChange: Event<string>;
+  onTitleChange: IEvent<string>;
 
   parse(data: string | Uint8Array, promiseResult?: boolean): void | Promise<boolean>;
   print(data: Uint32Array, start: number, end: number): void;

src/common/buffer/BufferSet.ts

@@ -3,12 +3,12 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from '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';
+import { Emitter } from 'common/Event';
 
 /**
  * The BufferSet represents the set of two buffers used by xterm terminals (normal and alt) and

src/common/buffer/Marker.ts

@@ -4,8 +4,8 @@
  */
 
 import { IDisposable, IMarker } from 'common/Types';
-import { Emitter } from 'vs/base/common/event';
-import { dispose } from 'vs/base/common/lifecycle';
+import { Emitter } from 'common/Event';
+import { dispose } from 'common/Lifecycle';
 
 export class Marker implements IMarker {
   private static _nextId = 1;

src/common/buffer/Types.ts

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

src/common/input/WriteBuffer.ts

@@ -4,8 +4,8 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 declare const setTimeout: (handler: () => void, timeout?: number) => void;
 

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, IApcHandler, IApcParser, ApcFallbackHandlerType } from 'common/parser/Types';
 import { ParserState, ParserAction } from 'common/parser/Constants';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { IDisposable } from 'common/Types';
 import { Params } from 'common/parser/Params';
 import { OscParser } from 'common/parser/OscParser';

src/common/public/BufferNamespaceApi.ts

@@ -6,8 +6,8 @@
 import { IBuffer as IBufferApi, IBufferNamespace as IBufferNamespaceApi } from '@xterm/xterm';
 import { BufferApiView } from 'common/public/BufferApiView';
 import { ICoreTerminal } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 export class BufferNamespaceApi extends Disposable implements IBufferNamespaceApi {
   private _normal: BufferApiView;

src/common/services/BufferService.ts

@@ -3,12 +3,12 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { IAttributeData, IBufferLine } from 'common/Types';
 import { BufferSet } from 'common/buffer/BufferSet';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
 import { IBufferService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
 export const MINIMUM_ROWS = 1;

src/common/services/CoreMouseService.ts

@@ -4,8 +4,8 @@
  */
 import { IBufferService, ICoreService, ICoreMouseService, IOptionsService } from 'common/services/Services';
 import { ICoreMouseProtocol, ICoreMouseEvent, CoreMouseEncoding, CoreMouseEventType, CoreMouseButton, CoreMouseAction } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 /**
  * Supported default protocols.

src/common/services/CoreService.ts

@@ -4,10 +4,10 @@
  */
 
 import { clone } from 'common/Clone';
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { IDecPrivateModes, IKittyKeyboardState, IModes } from 'common/Types';
 import { IBufferService, ICoreService, ILogService, IOptionsService } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 const DEFAULT_MODES: IModes = Object.freeze({
   insertMode: false

src/common/services/DecorationService.test.ts

@@ -6,8 +6,8 @@
 import { assert } from 'chai';
 import { DecorationService } from './DecorationService';
 import { IMarker } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'common/Event';
 
 function createFakeMarker(line: number): IMarker {
   return Object.freeze(new class extends Disposable {

src/common/services/DecorationService.ts

@@ -4,12 +4,12 @@
  */
 
 import { css } from 'common/Color';
-import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, DisposableStore, toDisposable } from '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';
+import { Emitter } from 'common/Event';
 
 // Work variables to avoid garbage collection
 let $xmin = 0;

src/common/services/LogService.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
+import { Disposable } from 'common/Lifecycle';
 import { ILogService, IOptionsService, LogLevelEnum } from 'common/services/Services';
 
 type LogType = (message?: any, ...optionalParams: any[]) => void;

src/common/services/OptionsService.ts

@@ -3,11 +3,11 @@
  * @license MIT
  */
 
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Disposable, toDisposable } from 'common/Lifecycle';
 import { isMac } from 'common/Platform';
 import { CursorStyle, IDisposable } from 'common/Types';
 import { FontWeight, IOptionsService, ITerminalOptions } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from 'common/Event';
 
 export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   cols: 80,

src/common/services/Services.ts

@@ -7,7 +7,7 @@ import { IDecoration, IDecorationOptions, ILinkHandler, ILogger, IWindowsPty, ty
 import { CoreMouseEncoding, CoreMouseEventType, CursorInactiveStyle, CursorStyle, IAttributeData, ICharset, IColor, ICoreMouseEvent, ICoreMouseProtocol, IDecPrivateModes, IDisposable, IKittyKeyboardState, IModes, IOscLinkData, IWindowOptions } from 'common/Types';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
 import { createDecorator } from 'common/services/ServiceRegistry';
-import type { Emitter, Event } from 'vs/base/common/event';
+import type { Emitter, IEvent } from 'common/Event';
 
 export const IBufferService = createDecorator<IBufferService>('BufferService');
 export interface IBufferService {
@@ -18,8 +18,8 @@ export interface IBufferService {
   readonly buffer: IBuffer;
   readonly buffers: IBufferSet;
   isUserScrolling: boolean;
-  onResize: Event<IBufferResizeEvent>;
-  onScroll: Event<number>;
+  onResize: IEvent<IBufferResizeEvent>;
+  onScroll: IEvent<number>;
   scroll(eraseAttr: IAttributeData, isWrapped?: boolean): void;
   scrollLines(disp: number, suppressScrollEvent?: boolean): void;
   resize(cols: number, rows: number): void;
@@ -59,7 +59,7 @@ export interface ICoreMouseService {
   /**
    * Event to announce changes in mouse tracking.
    */
-  onProtocolChange: Event<CoreMouseEventType>;
+  onProtocolChange: IEvent<CoreMouseEventType>;
 
   /**
    * Human readable version of mouse events.
@@ -87,10 +87,10 @@ export interface ICoreService {
   readonly decPrivateModes: IDecPrivateModes;
   readonly kittyKeyboard: IKittyKeyboardState;
 
-  readonly onData: Event<string>;
-  readonly onUserInput: Event<void>;
-  readonly onBinary: Event<string>;
-  readonly onRequestScrollToBottom: Event<void>;
+  readonly onData: IEvent<string>;
+  readonly onUserInput: IEvent<void>;
+  readonly onBinary: IEvent<string>;
+  readonly onRequestScrollToBottom: IEvent<void>;
 
   reset(): void;
 
@@ -201,7 +201,7 @@ export interface IOptionsService {
   /**
    * Adds an event listener for when any option changes.
    */
-  readonly onOptionChange: Event<keyof ITerminalOptions>;
+  readonly onOptionChange: IEvent<keyof ITerminalOptions>;
 
   /**
    * Adds an event listener for when a specific option changes, this is a convenience method that is
@@ -364,7 +364,7 @@ export interface IUnicodeService {
   /** Currently active version. */
   activeVersion: string;
   /** Event triggered, when activate version changed. */
-  readonly onChange: Event<string>;
+  readonly onChange: IEvent<string>;
 
   /**
    * Unicode version dependent
@@ -389,8 +389,8 @@ export const IDecorationService = createDecorator<IDecorationService>('Decoratio
 export interface IDecorationService extends IDisposable {
   serviceBrand: undefined;
   readonly decorations: IterableIterator<IInternalDecoration>;
-  readonly onDecorationRegistered: Event<IInternalDecoration>;
-  readonly onDecorationRemoved: Event<IInternalDecoration>;
+  readonly onDecorationRegistered: IEvent<IInternalDecoration>;
+  readonly onDecorationRemoved: IEvent<IInternalDecoration>;
   registerDecoration(decorationOptions: IDecorationOptions): IDecoration | undefined;
   reset(): void;
   /**

src/common/services/UnicodeService.ts

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

src/common/tsconfig.json

@@ -11,14 +11,11 @@
     ],
     "baseUrl": "..",
     "paths": {
-      "vs/*": [ "./vs/*" ]
+      "common/*": [ "./common/*" ]
     }
   },
   "include": [
     "./**/*",
     "../../typings/xterm.d.ts"
-  ],
-  "references": [
-    { "path": "../vs" }
   ]
 }

src/headless/Terminal.ts

@@ -25,7 +25,7 @@ import { DEFAULT_ATTR_DATA } from 'common/buffer/BufferLine';
 import { IBuffer } from 'common/buffer/Types';
 import { CoreTerminal } from 'common/CoreTerminal';
 import { IMarker, ITerminalOptions } from 'common/Types';
-import { Emitter, Event } from 'vs/base/common/event';
+import { Emitter, EventUtils } from 'common/Event';
 
 export class Terminal extends CoreTerminal {
   private readonly _onBell = this._register(new Emitter<void>());
@@ -49,11 +49,11 @@ export class Terminal extends CoreTerminal {
     // Setup InputHandler listeners
     this._register(this._inputHandler.onRequestBell(() => this.bell()));
     this._register(this._inputHandler.onRequestReset(() => this.reset()));
-    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(Event.forward(Event.map(this._inputHandler.onRequestRefreshRows, e => ({ start: e?.start ?? 0, end: e?.end ?? this.rows - 1 })), this._onRender));
+    this._register(EventUtils.forward(this._inputHandler.onCursorMove, this._onCursorMove));
+    this._register(EventUtils.forward(this._inputHandler.onTitleChange, this._onTitleChange));
+    this._register(EventUtils.forward(this._inputHandler.onA11yChar, this._onA11yCharEmitter));
+    this._register(EventUtils.forward(this._inputHandler.onA11yTab, this._onA11yTabEmitter));
+    this._register(EventUtils.forward(EventUtils.map(this._inputHandler.onRequestRefreshRows, e => ({ start: e?.start ?? 0, end: e?.end ?? this.rows - 1 })), this._onRender));
   }
 
   /**

src/headless/public/Terminal.ts

@@ -10,8 +10,8 @@ import { IBufferNamespace as IBufferNamespaceApi, IMarker, IModes, IParser, ITer
 import { Terminal as TerminalCore } from 'headless/Terminal';
 import { AddonManager } from 'common/public/AddonManager';
 import { ITerminalOptions } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import type { Event } from 'vs/base/common/event';
+import { Disposable } from 'common/Lifecycle';
+import type { IEvent } from 'common/Event';
 /**
  * The set of options that only have an effect when set in the Terminal constructor.
  */
@@ -72,16 +72,16 @@ export class Terminal extends Disposable implements ITerminalApi {
     }
   }
 
-  public get onBell(): Event<void> { return this._core.onBell; }
-  public get onBinary(): Event<string> { return this._core.onBinary; }
-  public get onCursorMove(): Event<void> { return this._core.onCursorMove; }
-  public get onData(): Event<string> { return this._core.onData; }
-  public get onLineFeed(): Event<void> { return this._core.onLineFeed; }
-  public get onRender(): Event<{ start: number, end: number }> { return this._core.onRender; }
-  public get onResize(): Event<{ cols: number, rows: number }> { return this._core.onResize; }
-  public get onScroll(): Event<number> { return this._core.onScroll; }
-  public get onTitleChange(): Event<string> { return this._core.onTitleChange; }
-  public get onWriteParsed(): Event<void> { return this._core.onWriteParsed; }
+  public get onBell(): IEvent<void> { return this._core.onBell; }
+  public get onBinary(): IEvent<string> { return this._core.onBinary; }
+  public get onCursorMove(): IEvent<void> { return this._core.onCursorMove; }
+  public get onData(): IEvent<string> { return this._core.onData; }
+  public get onLineFeed(): IEvent<void> { return this._core.onLineFeed; }
+  public get onRender(): IEvent<{ start: number, end: number }> { return this._core.onRender; }
+  public get onResize(): IEvent<{ cols: number, rows: number }> { return this._core.onResize; }
+  public get onScroll(): IEvent<number> { return this._core.onScroll; }
+  public get onTitleChange(): IEvent<string> { return this._core.onTitleChange; }
+  public get onWriteParsed(): IEvent<void> { return this._core.onWriteParsed; }
 
   public get parser(): IParser {
     if (!this._parser) {