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

package/src/browser/services/ThemeService.ts

@@ -5,12 +5,12 @@
 
 import { ColorContrastCache } from 'browser/ColorContrastCache';
 import { IThemeService } from 'browser/services/Services';
-import { IColorContrastCache, IColorSet, ReadonlyColorSet } from 'browser/Types';
-import { channels, color, css, NULL_COLOR } from 'common/Color';
-import { EventEmitter } from 'common/EventEmitter';
+import { DEFAULT_ANSI_COLORS, IColorContrastCache, IColorSet, ReadonlyColorSet } from 'browser/Types';
+import { color, css, NULL_COLOR } from 'common/Color';
 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';
 
 interface IRestoreColorSet {
   foreground: IColor;
@@ -23,59 +23,12 @@ interface IRestoreColorSet {
 const DEFAULT_FOREGROUND = css.toColor('#ffffff');
 const DEFAULT_BACKGROUND = css.toColor('#000000');
 const DEFAULT_CURSOR = css.toColor('#ffffff');
-const DEFAULT_CURSOR_ACCENT = css.toColor('#000000');
+const DEFAULT_CURSOR_ACCENT = DEFAULT_BACKGROUND;
 const DEFAULT_SELECTION = {
   css: 'rgba(255, 255, 255, 0.3)',
   rgba: 0xFFFFFF4D
 };
-
-// An IIFE to generate DEFAULT_ANSI_COLORS.
-export const DEFAULT_ANSI_COLORS = Object.freeze((() => {
-  const colors = [
-    // dark:
-    css.toColor('#2e3436'),
-    css.toColor('#cc0000'),
-    css.toColor('#4e9a06'),
-    css.toColor('#c4a000'),
-    css.toColor('#3465a4'),
-    css.toColor('#75507b'),
-    css.toColor('#06989a'),
-    css.toColor('#d3d7cf'),
-    // bright:
-    css.toColor('#555753'),
-    css.toColor('#ef2929'),
-    css.toColor('#8ae234'),
-    css.toColor('#fce94f'),
-    css.toColor('#729fcf'),
-    css.toColor('#ad7fa8'),
-    css.toColor('#34e2e2'),
-    css.toColor('#eeeeec')
-  ];
-
-  // Fill in the remaining 240 ANSI colors.
-  // Generate colors (16-231)
-  const v = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff];
-  for (let i = 0; i < 216; i++) {
-    const r = v[(i / 36) % 6 | 0];
-    const g = v[(i / 6) % 6 | 0];
-    const b = v[i % 6];
-    colors.push({
-      css: channels.toCss(r, g, b),
-      rgba: channels.toRgba(r, g, b)
-    });
-  }
-
-  // Generate greys (232-255)
-  for (let i = 0; i < 24; i++) {
-    const c = 8 + i * 10;
-    colors.push({
-      css: channels.toCss(c, c, c),
-      rgba: channels.toRgba(c, c, c)
-    });
-  }
-
-  return colors;
-})());
+const DEFAULT_OVERVIEW_RULER_BORDER = DEFAULT_FOREGROUND;
 
 export class ThemeService extends Disposable implements IThemeService {
   public serviceBrand: undefined;
@@ -87,7 +40,7 @@ export class ThemeService extends Disposable implements IThemeService {
 
   public get colors(): ReadonlyColorSet { return this._colors; }
 
-  private readonly _onChangeColors = this.register(new EventEmitter<ReadonlyColorSet>());
+  private readonly _onChangeColors = this.register(new Emitter<ReadonlyColorSet>());
   public readonly onChangeColors = this._onChangeColors.event;
 
   constructor(
@@ -105,6 +58,10 @@ export class ThemeService extends Disposable implements IThemeService {
       selectionBackgroundOpaque: color.blend(DEFAULT_BACKGROUND, DEFAULT_SELECTION),
       selectionInactiveBackgroundTransparent: DEFAULT_SELECTION,
       selectionInactiveBackgroundOpaque: color.blend(DEFAULT_BACKGROUND, DEFAULT_SELECTION),
+      scrollbarSliderBackground: color.opacity(DEFAULT_FOREGROUND, 0.2),
+      scrollbarSliderHoverBackground: color.opacity(DEFAULT_FOREGROUND, 0.4),
+      scrollbarSliderActiveBackground: color.opacity(DEFAULT_FOREGROUND, 0.5),
+      overviewRulerBorder: DEFAULT_FOREGROUND,
       ansi: DEFAULT_ANSI_COLORS.slice(),
       contrastCache: this._contrastCache,
       halfContrastCache: this._halfContrastCache
@@ -148,6 +105,10 @@ export class ThemeService extends Disposable implements IThemeService {
       const opacity = 0.3;
       colors.selectionInactiveBackgroundTransparent = color.opacity(colors.selectionInactiveBackgroundTransparent, opacity);
     }
+    colors.scrollbarSliderBackground = parseColor(theme.scrollbarSliderBackground, color.opacity(colors.foreground, 0.2));
+    colors.scrollbarSliderHoverBackground = parseColor(theme.scrollbarSliderHoverBackground, color.opacity(colors.foreground, 0.4));
+    colors.scrollbarSliderActiveBackground = parseColor(theme.scrollbarSliderActiveBackground, color.opacity(colors.foreground, 0.5));
+    colors.overviewRulerBorder = parseColor(theme.overviewRulerBorder, DEFAULT_OVERVIEW_RULER_BORDER);
     colors.ansi = DEFAULT_ANSI_COLORS.slice();
     colors.ansi[0] = parseColor(theme.black, DEFAULT_ANSI_COLORS[0]);
     colors.ansi[1] = parseColor(theme.red, DEFAULT_ANSI_COLORS[1]);

package/src/browser/shared/Constants.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) 2024 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+export const enum ViewportConstants {
+  DEFAULT_SCROLL_BAR_WIDTH = 14
+}

package/src/common/CircularList.ts

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

package/src/common/CoreTerminal.ts

@@ -27,9 +27,8 @@ import { InstantiationService } from 'common/services/InstantiationService';
 import { LogService } from 'common/services/LogService';
 import { BufferService, MINIMUM_COLS, MINIMUM_ROWS } from 'common/services/BufferService';
 import { OptionsService } from 'common/services/OptionsService';
-import { IDisposable, IAttributeData, ICoreTerminal, IScrollEvent, ScrollSource } from 'common/Types';
+import { IDisposable, IAttributeData, ICoreTerminal, IScrollEvent } from 'common/Types';
 import { CoreService } from 'common/services/CoreService';
-import { EventEmitter, IEvent, forwardEvent } from 'common/EventEmitter';
 import { CoreMouseService } from 'common/services/CoreMouseService';
 import { UnicodeService } from 'common/services/UnicodeService';
 import { CharsetService } from 'common/services/CharsetService';
@@ -39,6 +38,7 @@ 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';
 
 // Only trigger this warning a single time per session
 let hasWriteSyncWarnHappened = false;
@@ -59,26 +59,26 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
   private _writeBuffer: WriteBuffer;
   private _windowsWrappingHeuristics = this.register(new MutableDisposable());
 
-  private readonly _onBinary = this.register(new EventEmitter<string>());
+  private readonly _onBinary = this.register(new Emitter<string>());
   public readonly onBinary = this._onBinary.event;
-  private readonly _onData = this.register(new EventEmitter<string>());
+  private readonly _onData = this.register(new Emitter<string>());
   public readonly onData = this._onData.event;
-  protected _onLineFeed = this.register(new EventEmitter<void>());
+  protected _onLineFeed = this.register(new Emitter<void>());
   public readonly onLineFeed = this._onLineFeed.event;
-  private readonly _onResize = this.register(new EventEmitter<{ cols: number, rows: number }>());
+  private readonly _onResize = this.register(new Emitter<{ cols: number, rows: number }>());
   public readonly onResize = this._onResize.event;
-  protected readonly _onWriteParsed = this.register(new EventEmitter<void>());
+  protected readonly _onWriteParsed = this.register(new Emitter<void>());
   public readonly onWriteParsed = this._onWriteParsed.event;
 
   /**
    * Internally we track the source of the scroll but this is meaningless outside the library so
    * it's filtered out.
    */
-  protected _onScrollApi?: EventEmitter<number, void>;
-  protected _onScroll = this.register(new EventEmitter<IScrollEvent, void>());
-  public get onScroll(): IEvent<number, void> {
+  protected _onScrollApi?: Emitter<number>;
+  protected _onScroll = this.register(new Emitter<IScrollEvent>());
+  public get onScroll(): Event<number> {
     if (!this._onScrollApi) {
-      this._onScrollApi = this.register(new EventEmitter<number, void>());
+      this._onScrollApi = this.register(new Emitter<number>());
       this._onScroll.event(ev => {
         this._onScrollApi?.fire(ev.position);
       });
@@ -123,28 +123,23 @@ 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(forwardEvent(this._inputHandler.onLineFeed, this._onLineFeed));
+    this.register(Event.forward(this._inputHandler.onLineFeed, this._onLineFeed));
     this.register(this._inputHandler);
 
     // Setup listeners
-    this.register(forwardEvent(this._bufferService.onResize, this._onResize));
-    this.register(forwardEvent(this.coreService.onData, this._onData));
-    this.register(forwardEvent(this.coreService.onBinary, this._onBinary));
-    this.register(this.coreService.onRequestScrollToBottom(() => this.scrollToBottom()));
+    this.register(Event.forward(this._bufferService.onResize, this._onResize));
+    this.register(Event.forward(this.coreService.onData, this._onData));
+    this.register(Event.forward(this.coreService.onBinary, this._onBinary));
+    this.register(this.coreService.onRequestScrollToBottom(() => this.scrollToBottom(true)));
     this.register(this.coreService.onUserInput(() =>  this._writeBuffer.handleUserInput()));
     this.register(this.optionsService.onMultipleOptionChange(['windowsMode', 'windowsPty'], () => this._handleWindowsPtyOptionChange()));
-    this.register(this._bufferService.onScroll(event => {
-      this._onScroll.fire({ position: this._bufferService.buffer.ydisp, source: ScrollSource.TERMINAL });
+    this.register(this._bufferService.onScroll(() => {
+      this._onScroll.fire({ position: this._bufferService.buffer.ydisp });
       this._inputHandler.markRangeDirty(this._bufferService.buffer.scrollTop, this._bufferService.buffer.scrollBottom);
     }));
-    this.register(this._inputHandler.onScroll(event => {
-      this._onScroll.fire({ position: this._bufferService.buffer.ydisp, source: ScrollSource.TERMINAL });
-      this._inputHandler.markRangeDirty(this._bufferService.buffer.scrollTop, this._bufferService.buffer.scrollBottom);
-    }));
-
     // Setup WriteBuffer
     this._writeBuffer = this.register(new WriteBuffer((data, promiseResult) => this._inputHandler.parse(data, promiseResult)));
-    this.register(forwardEvent(this._writeBuffer.onWriteParsed, this._onWriteParsed));
+    this.register(Event.forward(this._writeBuffer.onWriteParsed, this._onWriteParsed));
   }
 
   public write(data: string | Uint8Array, callback?: () => void): void {
@@ -198,10 +193,9 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
    * @param suppressScrollEvent Don't emit the scroll event as scrollLines. This is used to avoid
    * unwanted events being handled by the viewport when the event was triggered from the viewport
    * originally.
-   * @param source Which component the event came from.
    */
-  public scrollLines(disp: number, suppressScrollEvent?: boolean, source?: ScrollSource): void {
-    this._bufferService.scrollLines(disp, suppressScrollEvent, source);
+  public scrollLines(disp: number, suppressScrollEvent?: boolean): void {
+    this._bufferService.scrollLines(disp, suppressScrollEvent);
   }
 
   public scrollPages(pageCount: number): void {
@@ -212,7 +206,7 @@ export abstract class CoreTerminal extends Disposable implements ICoreTerminal {
     this.scrollLines(-this._bufferService.buffer.ydisp);
   }
 
-  public scrollToBottom(): void {
+  public scrollToBottom(disableSmoothScroll?: boolean): void {
     this.scrollLines(this._bufferService.buffer.ybase - this._bufferService.buffer.ydisp);
   }
 

package/src/common/InputHandler.ts

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

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

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

package/src/common/buffer/Buffer.ts

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

package/src/common/buffer/BufferSet.ts

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

package/src/common/buffer/Marker.ts

@@ -3,9 +3,9 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
 import { disposeArray } from 'common/Lifecycle';
 import { IDisposable, IMarker } from 'common/Types';
+import { Emitter } from 'vs/base/common/event';
 
 export class Marker implements IMarker {
   private static _nextId = 1;
@@ -16,7 +16,7 @@ export class Marker implements IMarker {
   private readonly _id: number = Marker._nextId++;
   public get id(): number { return this._id; }
 
-  private readonly _onDispose = this.register(new EventEmitter<void>());
+  private readonly _onDispose = this.register(new Emitter<void>());
   public readonly onDispose = this._onDispose.event;
 
   constructor(

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

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

package/src/common/input/WriteBuffer.ts

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

package/src/common/public/BufferNamespaceApi.ts

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

package/src/common/services/BufferService.ts

@@ -3,12 +3,12 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
 import { Disposable } from 'common/Lifecycle';
-import { IAttributeData, IBufferLine, ScrollSource } from 'common/Types';
+import { IAttributeData, IBufferLine } from 'common/Types';
 import { BufferSet } from 'common/buffer/BufferSet';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
 import { IBufferService, IOptionsService } from 'common/services/Services';
+import { Emitter } from 'vs/base/common/event';
 
 export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
 export const MINIMUM_ROWS = 1;
@@ -22,9 +22,9 @@ export class BufferService extends Disposable implements IBufferService {
   /** Whether the user is scrolling (locks the scroll position) */
   public isUserScrolling: boolean = false;
 
-  private readonly _onResize = this.register(new EventEmitter<{ cols: number, rows: number }>());
+  private readonly _onResize = this.register(new Emitter<{ cols: number, rows: number }>());
   public readonly onResize = this._onResize.event;
-  private readonly _onScroll = this.register(new EventEmitter<number>());
+  private readonly _onScroll = this.register(new Emitter<number>());
   public readonly onScroll = this._onScroll.event;
 
   public get buffer(): IBuffer { return this.buffers.active; }
@@ -125,7 +125,7 @@ export class BufferService extends Disposable implements IBufferService {
    * to avoid unwanted events being handled by the viewport when the event was triggered from the
    * viewport originally.
    */
-  public scrollLines(disp: number, suppressScrollEvent?: boolean, source?: ScrollSource): void {
+  public scrollLines(disp: number, suppressScrollEvent?: boolean): void {
     const buffer = this.buffer;
     if (disp < 0) {
       if (buffer.ydisp === 0) {

package/src/common/services/CoreMouseService.ts

@@ -3,9 +3,9 @@
  * @license MIT
  */
 import { IBufferService, ICoreService, ICoreMouseService } from 'common/services/Services';
-import { EventEmitter } from 'common/EventEmitter';
 import { ICoreMouseProtocol, ICoreMouseEvent, CoreMouseEncoding, CoreMouseEventType, CoreMouseButton, CoreMouseAction } from 'common/Types';
 import { Disposable } from 'common/Lifecycle';
+import { Emitter } from 'vs/base/common/event';
 
 /**
  * Supported default protocols.
@@ -167,13 +167,15 @@ const DEFAULT_ENCODINGS: { [key: string]: CoreMouseEncoding } = {
  * To send a mouse event call `triggerMouseEvent`.
  */
 export class CoreMouseService extends Disposable implements ICoreMouseService {
+  public serviceBrand: any;
+
   private _protocols: { [name: string]: ICoreMouseProtocol } = {};
   private _encodings: { [name: string]: CoreMouseEncoding } = {};
   private _activeProtocol: string = '';
   private _activeEncoding: string = '';
   private _lastEvent: ICoreMouseEvent | null = null;
 
-  private readonly _onProtocolChange = this.register(new EventEmitter<CoreMouseEventType>());
+  private readonly _onProtocolChange = this.register(new Emitter<CoreMouseEventType>());
   public readonly onProtocolChange =  this._onProtocolChange.event;
 
   constructor(