@xterm/xterm 6.1.0-beta.26 → 6.1.0-beta.261

package/src/common/services/DecorationService.ts

@@ -3,13 +3,15 @@
  * @license MIT
  */
 
-import { css } from 'common/Color';
-import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
-import { IDecorationService, IInternalDecoration } from 'common/services/Services';
-import { SortedList } from 'common/SortedList';
-import { IColor } from 'common/Types';
+import type { ICircularList, IDeleteEvent, IInsertEvent } from '../CircularList';
+import { MicrotaskTimer } from '../Async';
+import { css } from '../Color';
+import { Disposable, DisposableStore, MutableDisposable, toDisposable } from '../Lifecycle';
+import { IBufferService, IDecorationService, IInternalDecoration, ILogService } from './Services';
+import { SortedList } from '../SortedList';
+import { IColor } from '../Types';
 import { IDecoration, IDecorationOptions, IMarker } from '@xterm/xterm';
-import { Emitter } from 'vs/base/common/event';
+import { Emitter } from '../Event';
 
 // Work variables to avoid garbage collection
 let $xmin = 0;
@@ -23,7 +25,9 @@ export class DecorationService extends Disposable implements IDecorationService
    * while marker line values do change, they should all change by the same amount so this should
    * never become out of order.
    */
-  private readonly _decorations: SortedList<IInternalDecoration> = new SortedList(e => e?.marker.line);
+  private readonly _decorations: SortedList<IInternalDecoration>;
+
+  private readonly _lineCache = this._register(new DecorationLineCache());
 
   private readonly _onDecorationRegistered = this._register(new Emitter<IInternalDecoration>());
   public readonly onDecorationRegistered = this._onDecorationRegistered.event;
@@ -32,10 +36,19 @@ export class DecorationService extends Disposable implements IDecorationService
 
   public get decorations(): IterableIterator<IInternalDecoration> { return this._decorations.values(); }
 
-  constructor() {
+  constructor(
+    @ILogService private readonly _logService: ILogService,
+    @IBufferService private readonly _bufferService: IBufferService
+  ) {
     super();
 
+    this._decorations = new SortedList(e => e?.marker.line, this._logService);
+
     this._register(toDisposable(() => this.reset()));
+    this._register(this._bufferService.buffers.onBufferActivate(() => {
+      this._lineCache.attachToBufferLines(this._bufferService.buffer.lines);
+    }));
+    this._lineCache.attachToBufferLines(this._bufferService.buffer.lines);
   }
 
   public registerDecoration(options: IDecorationOptions): IDecoration | undefined {
@@ -49,12 +62,14 @@ export class DecorationService extends Disposable implements IDecorationService
         listener.dispose();
         if (decoration) {
           if (this._decorations.delete(decoration)) {
+            this._lineCache.remove(decoration);
             this._onDecorationRemoved.fire(decoration);
           }
           markerDispose.dispose();
         }
       });
       this._decorations.insert(decoration);
+      this._lineCache.add(decoration);
       this._onDecorationRegistered.fire(decoration);
     }
     return decoration;
@@ -65,35 +80,264 @@ export class DecorationService extends Disposable implements IDecorationService
       d.dispose();
     }
     this._decorations.clear();
+    this._lineCache.clear();
   }
 
   public *getDecorationsAtCell(x: number, line: number, layer?: 'bottom' | 'top'): IterableIterator<IInternalDecoration> {
-    let xmin = 0;
-    let xmax = 0;
-    for (const d of this._decorations.getKeyIterator(line)) {
-      xmin = d.options.x ?? 0;
-      xmax = xmin + (d.options.width ?? 1);
-      if (x >= xmin && x < xmax && (!layer || (d.options.layer ?? 'bottom') === layer)) {
+    const bucket = this._lineCache.getDecorationsOnLine(line);
+    if (!bucket) {
+      return;
+    }
+    for (const d of bucket) {
+      $xmin = d.options.x ?? 0;
+      $xmax = $xmin + (d.options.width ?? 1);
+      if (x >= $xmin && x < $xmax && (!layer || (d.options.layer ?? 'bottom') === layer)) {
         yield d;
       }
     }
   }
 
   public forEachDecorationAtCell(x: number, line: number, layer: 'bottom' | 'top' | undefined, callback: (decoration: IInternalDecoration) => void): void {
-    this._decorations.forEachByKey(line, d => {
+    const bucket = this._lineCache.getDecorationsOnLine(line);
+    if (!bucket) {
+      return;
+    }
+    for (const d of bucket) {
       $xmin = d.options.x ?? 0;
       $xmax = $xmin + (d.options.width ?? 1);
       if (x >= $xmin && x < $xmax && (!layer || (d.options.layer ?? 'bottom') === layer)) {
         callback(d);
       }
+    }
+  }
+}
+
+/**
+ * Per-logical-line index of decorations for fast cell lookup.
+ *
+ * Keys are marker.line coordinates (logical buffer lines), not CircularList ring slots.
+ * Multi-line decorations appear in every line bucket they span. The index is kept aligned
+ * with marker.line updates via buffer line trim/insert/delete events.
+ */
+export class DecorationLineCache extends Disposable {
+  private readonly _decorationsByLine: Map<number, IInternalDecoration[]> = new Map();
+  private readonly _decorations = new Set<IInternalDecoration>();
+  private readonly _bufferLineListeners = this._register(new MutableDisposable<DisposableStore>());
+  private readonly _lineIndexSyncTimer = this._register(new MicrotaskTimer());
+  private _lineIndexSyncCallbacks: (() => void)[] = [];
+
+  public clear(): void {
+    this._lineIndexSyncCallbacks.length = 0;
+    this._lineIndexSyncTimer.cancel();
+    this._decorationsByLine.clear();
+    this._decorations.clear();
+  }
+
+  public add(decoration: IInternalDecoration): void {
+    this._decorations.add(decoration);
+    this._addToLineBuckets(decoration);
+  }
+
+  public remove(decoration: IInternalDecoration): void {
+    this._decorations.delete(decoration);
+    this._removeFromLineBuckets(decoration);
+  }
+
+  public getDecorationsOnLine(line: number): ReadonlyArray<IInternalDecoration> | undefined {
+    return this._decorationsByLine.get(line);
+  }
+
+  public attachToBufferLines(lines: ICircularList<unknown>): void {
+    const store = new DisposableStore();
+    this._bufferLineListeners.value = store;
+    store.add(lines.onTrim(amount => this._handleBufferLinesTrim(amount)));
+    store.add(lines.onInsert(event => this._handleBufferLinesInsert(event)));
+    store.add(lines.onDelete(event => this._handleBufferLinesDelete(event)));
+  }
+
+  private _getDecorationHeight(decoration: IInternalDecoration): number {
+    return decoration.options.height ?? 1;
+  }
+
+  private _addToLineBuckets(decoration: IInternalDecoration): void {
+    const start = decoration.marker.line;
+    if (start < 0) {
+      return;
+    }
+    decoration._indexedStartLine = start;
+    const height = this._getDecorationHeight(decoration);
+    for (let line = start; line < start + height; line++) {
+      let bucket = this._decorationsByLine.get(line);
+      if (!bucket) {
+        bucket = [];
+        this._decorationsByLine.set(line, bucket);
+      }
+      bucket.push(decoration);
+    }
+  }
+
+  private _removeFromLineBuckets(decoration: IInternalDecoration): void {
+    const start = decoration._indexedStartLine;
+    const height = this._getDecorationHeight(decoration);
+    for (let line = start; line < start + height; line++) {
+      const bucket = this._decorationsByLine.get(line);
+      if (!bucket) {
+        continue;
+      }
+      const index = bucket.indexOf(decoration);
+      if (index !== -1) {
+        bucket.splice(index, 1);
+      }
+      if (bucket.length === 0) {
+        this._decorationsByLine.delete(line);
+      }
+    }
+  }
+
+  private _reindexDecoration(decoration: IInternalDecoration): void {
+    this._removeFromLineBuckets(decoration);
+    if (!decoration.marker.isDisposed && decoration.marker.line >= 0) {
+      this._addToLineBuckets(decoration);
+    }
+  }
+
+  /** Re-index after marker line updates (buffer listeners may run before markers). */
+  private _scheduleLineIndexSync(callback: () => void): void {
+    this._lineIndexSyncCallbacks.push(callback);
+    this._lineIndexSyncTimer.set(() => {
+      const callbacks = this._lineIndexSyncCallbacks;
+      this._lineIndexSyncCallbacks = [];
+      for (const cb of callbacks) {
+        cb();
+      }
     });
   }
+
+  private _handleBufferLinesTrim(amount: number): void {
+    if (amount <= 0) {
+      return;
+    }
+    const newMap = new Map<number, IInternalDecoration[]>();
+    for (const [line, bucket] of this._decorationsByLine) {
+      const newLine = line - amount;
+      if (newLine < 0) {
+        continue;
+      }
+      this._mergeLineBucket(newMap, newLine, bucket);
+    }
+    this._decorationsByLine.clear();
+    for (const [line, bucket] of newMap) {
+      this._decorationsByLine.set(line, bucket);
+    }
+    for (const d of this._decorations) {
+      if (!d.marker.isDisposed) {
+        d._indexedStartLine -= amount;
+      }
+    }
+  }
+
+  private _handleBufferLinesInsert(event: IInsertEvent): void {
+    this._scheduleLineIndexSync(() => this._applyBufferLinesInsert(event));
+  }
+
+  private _handleBufferLinesDelete(event: IDeleteEvent): void {
+    this._scheduleLineIndexSync(() => this._applyBufferLinesDelete(event));
+  }
+
+  private _mergeLineBucket(newMap: Map<number, IInternalDecoration[]>, line: number, bucket: IInternalDecoration[]): void {
+    const existing = newMap.get(line);
+    if (existing) {
+      for (let i = 0, len = bucket.length; i < len; i++) {
+        existing.push(bucket[i]);
+      }
+    } else {
+      newMap.set(line, bucket.slice());
+    }
+  }
+
+  /**
+   * Shift indexed line keys and sync start lines. O(unique indexed lines), not O(decoration count).
+   * Decorations that span the insert point are re-indexed individually (rare vs single-line hits).
+   */
+  private _applyBufferLinesInsert(event: IInsertEvent): void {
+    const { index, amount } = event;
+    const spanCrossers: IInternalDecoration[] = [];
+    for (const d of this._decorations) {
+      if (d.marker.isDisposed) {
+        continue;
+      }
+      const start = d._indexedStartLine;
+      if (start < index && start + this._getDecorationHeight(d) > index) {
+        spanCrossers.push(d);
+        this._removeFromLineBuckets(d);
+      }
+    }
+    const newMap = new Map<number, IInternalDecoration[]>();
+    for (const [line, bucket] of this._decorationsByLine) {
+      const newLine = line >= index ? line + amount : line;
+      this._mergeLineBucket(newMap, newLine, bucket);
+    }
+    this._decorationsByLine.clear();
+    for (const [line, bucket] of newMap) {
+      this._decorationsByLine.set(line, bucket);
+    }
+    for (const d of this._decorations) {
+      if (d.marker.isDisposed) {
+        continue;
+      }
+      if (d._indexedStartLine >= index) {
+        d._indexedStartLine = d.marker.line;
+      }
+    }
+    for (const d of spanCrossers) {
+      this._addToLineBuckets(d);
+    }
+  }
+
+  /**
+   * Drop deleted line keys, shift keys below, sync start lines. Full re-index only when a
+   * multi-line decoration spans across the deleted range but survives.
+   */
+  private _applyBufferLinesDelete(event: IDeleteEvent): void {
+    const deleteEnd = event.index + event.amount;
+    const newMap = new Map<number, IInternalDecoration[]>();
+    for (const [line, bucket] of this._decorationsByLine) {
+      if (line >= event.index && line < deleteEnd) {
+        continue;
+      }
+      const newLine = line >= deleteEnd ? line - event.amount : line;
+      this._mergeLineBucket(newMap, newLine, bucket);
+    }
+    this._decorationsByLine.clear();
+    for (const [line, bucket] of newMap) {
+      this._decorationsByLine.set(line, bucket);
+    }
+    const toReindex: IInternalDecoration[] = [];
+    for (const d of this._decorations) {
+      if (d.marker.isDisposed) {
+        continue;
+      }
+      const start = d._indexedStartLine;
+      const height = this._getDecorationHeight(d);
+      if (start >= deleteEnd) {
+        d._indexedStartLine = d.marker.line;
+      } else if (start < event.index && start + height > deleteEnd) {
+        toReindex.push(d);
+      }
+    }
+    for (const d of toReindex) {
+      this._reindexDecoration(d);
+    }
+  }
 }
 
 class Decoration extends DisposableStore implements IInternalDecoration {
   public readonly marker: IMarker;
   public element: HTMLElement | undefined;
 
+  /** Start line used for line-index removal when marker.line is cleared on dispose. */
+  public _indexedStartLine: number;
+
   public readonly onRenderEmitter = this.add(new Emitter<HTMLElement>());
   public readonly onRender = this.onRenderEmitter.event;
   private readonly _onDispose = this.add(new Emitter<void>());
@@ -128,6 +372,7 @@ class Decoration extends DisposableStore implements IInternalDecoration {
   ) {
     super();
     this.marker = options.marker;
+    this._indexedStartLine = options.marker.line;
     if (this.options.overviewRulerOptions && !this.options.overviewRulerOptions.position) {
       this.options.overviewRulerOptions.position = 'full';
     }

package/src/common/services/InstantiationService.ts

@@ -9,8 +9,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IInstantiationService, IServiceIdentifier } from 'common/services/Services';
-import { getServiceDependencies } from 'common/services/ServiceRegistry';
+import { IInstantiationService } from './Services';
+import { IServiceIdentifier, getServiceDependencies } from './ServiceRegistry';
 
 export class ServiceCollection {
 

package/src/common/services/LogService.ts

@@ -3,8 +3,8 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
-import { ILogService, IOptionsService, LogLevelEnum } from 'common/services/Services';
+import { Disposable } from '../Lifecycle';
+import { ILogService, IOptionsService, LogLevelEnum } from './Services';
 
 type LogType = (message?: any, ...optionalParams: any[]) => void;
 
@@ -43,9 +43,6 @@ export class LogService extends Disposable implements ILogService {
     super();
     this._updateLogLevel();
     this._register(this._optionsService.onSpecificOptionChange('logLevel', () => this._updateLogLevel()));
-
-    // For trace logging, assume the latest created log service is valid
-    traceLogger = this;
   }
 
   private _updateLogLevel(): void {
@@ -95,30 +92,3 @@ export class LogService extends Disposable implements ILogService {
     }
   }
 }
-
-let traceLogger: ILogService;
-export function setTraceLogger(logger: ILogService): void {
-  traceLogger = logger;
-}
-
-/**
- * A decorator that can be used to automatically log trace calls to the decorated function.
- */
-export function traceCall(_target: any, key: string, descriptor: any): any {
-  if (typeof descriptor.value !== 'function') {
-    throw new Error('not supported');
-  }
-  const fnKey = 'value';
-  const fn = descriptor.value;
-  descriptor[fnKey] = function (...args: any[]) {
-    // Early exit
-    if (traceLogger.logLevel !== LogLevelEnum.TRACE) {
-      return fn.apply(this, args);
-    }
-
-    traceLogger.trace(`GlyphRenderer#${fn.name}(${args.map(e => JSON.stringify(e)).join(', ')})`);
-    const result = fn.apply(this, args);
-    traceLogger.trace(`GlyphRenderer#${fn.name} return`, result);
-    return result;
-  };
-}

package/src/common/services/{CoreMouseService.ts → MouseStateService.ts}

@@ -2,10 +2,10 @@
  * Copyright (c) 2019 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-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 { IMouseStateService } from './Services';
+import { ICoreMouseProtocol, ICoreMouseEvent, CoreMouseEncoding, CoreMouseEventType, CoreMouseButton, CoreMouseAction } from '../Types';
+import { Disposable } from '../Lifecycle';
+import { Emitter } from '../Event';
 
 /**
  * Supported default protocols.
@@ -151,7 +151,7 @@ const DEFAULT_ENCODINGS: { [key: string]: CoreMouseEncoding } = {
 };
 
 /**
- * CoreMouseService
+ * MouseStateService
  *
  * Provides mouse tracking reports with different protocols and encodings.
  *  - protocols: NONE (default), X10, VT200, DRAG, ANY
@@ -166,25 +166,21 @@ const DEFAULT_ENCODINGS: { [key: string]: CoreMouseEncoding } = {
  * a tracking report to the backend based on protocol and encoding limitations.
  * To send a mouse event call `triggerMouseEvent`.
  */
-export class CoreMouseService extends Disposable implements ICoreMouseService {
+export class MouseStateService extends Disposable implements IMouseStateService {
   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 _wheelPartialScroll: number = 0;
+  private _customWheelEventHandler: ((event: WheelEvent) => boolean) | undefined;
 
   private readonly _onProtocolChange = this._register(new Emitter<CoreMouseEventType>());
   public readonly onProtocolChange = this._onProtocolChange.event;
 
-  constructor(
-    @IBufferService private readonly _bufferService: IBufferService,
-    @ICoreService private readonly _coreService: ICoreService,
-    @IOptionsService private readonly _optionsService: IOptionsService
-  ) {
+  constructor() {
     super();
+
     // register default protocols and encodings
     for (const name of Object.keys(DEFAULT_PROTOCOLS)) this.addProtocol(name, DEFAULT_PROTOCOLS[name]);
     for (const name of Object.keys(DEFAULT_ENCODINGS)) this.addEncoding(name, DEFAULT_ENCODINGS[name]);
@@ -230,136 +226,29 @@ export class CoreMouseService extends Disposable implements ICoreMouseService {
   public reset(): void {
     this.activeProtocol = 'NONE';
     this.activeEncoding = 'DEFAULT';
-    this._lastEvent = null;
-    this._wheelPartialScroll = 0;
   }
 
-  /**
-   * Processes a wheel event, accounting for partial scrolls for trackpad, mouse scrolls.
-   * This prevents hyper-sensitive scrolling in alt buffer.
-   */
-  public consumeWheelEvent(ev: WheelEvent, cellHeight?: number, dpr?: number): number {
-    // Do nothing if it's not a vertical scroll event
-    if (ev.deltaY === 0 || ev.shiftKey) {
-      return 0;
-    }
-
-    if (cellHeight === undefined || dpr === undefined) {
-      return 0;
-    }
-
-    const targetWheelEventPixels = cellHeight / dpr;
-    let amount = this._applyScrollModifier(ev.deltaY, ev);
-
-    if (ev.deltaMode === WheelEvent.DOM_DELTA_PIXEL) {
-      amount /= (targetWheelEventPixels + 0.0); // Prevent integer division
-
-      const isLikelyTrackpad = Math.abs(ev.deltaY) < 50;
-      if (isLikelyTrackpad) {
-        amount *= 0.3;
-      }
-
-      this._wheelPartialScroll += amount;
-      amount = Math.floor(Math.abs(this._wheelPartialScroll)) * (this._wheelPartialScroll > 0 ? 1 : -1);
-      this._wheelPartialScroll %= 1;
-    } else if (ev.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
-      amount *= this._bufferService.rows;
-    }
-    return amount;
+  public setCustomWheelEventHandler(customWheelEventHandler: ((event: WheelEvent) => boolean) | undefined): void {
+    this._customWheelEventHandler = customWheelEventHandler;
   }
 
-  private _applyScrollModifier(amount: number, ev: WheelEvent): number {
-    // Multiply the scroll speed when the modifier key is pressed
-    if (ev.altKey || ev.ctrlKey || ev.shiftKey) {
-      return amount * this._optionsService.rawOptions.fastScrollSensitivity * this._optionsService.rawOptions.scrollSensitivity;
-    }
-    return amount * this._optionsService.rawOptions.scrollSensitivity;
+  public allowCustomWheelEvent(ev: WheelEvent): boolean {
+    return this._customWheelEventHandler ? this._customWheelEventHandler(ev) !== false : true;
   }
 
-  /**
-   * Triggers a mouse event to be sent.
-   *
-   * Returns true if the event passed all protocol restrictions and a report
-   * was sent, otherwise false. The return value may be used to decide whether
-   * the default event action in the bowser component should be omitted.
-   *
-   * Note: The method will change values of the given event object
-   * to fullfill protocol and encoding restrictions.
-   */
-  public triggerMouseEvent(e: ICoreMouseEvent): boolean {
-    // range check for col/row
-    if (e.col < 0 || e.col >= this._bufferService.cols
-      || e.row < 0 || e.row >= this._bufferService.rows) {
-      return false;
-    }
-
-    // filter nonsense combinations of button + action
-    if (e.button === CoreMouseButton.WHEEL && e.action === CoreMouseAction.MOVE) {
-      return false;
-    }
-    if (e.button === CoreMouseButton.NONE && e.action !== CoreMouseAction.MOVE) {
-      return false;
-    }
-    if (e.button !== CoreMouseButton.WHEEL && (e.action === CoreMouseAction.LEFT || e.action === CoreMouseAction.RIGHT)) {
-      return false;
-    }
-
-    // report 1-based coords
-    e.col++;
-    e.row++;
-
-    // debounce move events at grid or pixel level
-    if (e.action === CoreMouseAction.MOVE
-      && this._lastEvent
-      && this._equalEvents(this._lastEvent, e, this._activeEncoding === 'SGR_PIXELS')
-    ) {
-      return false;
-    }
-
-    // apply protocol restrictions
-    if (!this._protocols[this._activeProtocol].restrict(e)) {
-      return false;
-    }
-
-    // encode report and send
-    const report = this._encodings[this._activeEncoding](e);
-    if (report) {
-      // always send DEFAULT as binary data
-      if (this._activeEncoding === 'DEFAULT') {
-        this._coreService.triggerBinaryEvent(report);
-      } else {
-        this._coreService.triggerDataEvent(report, true);
-      }
-    }
-
-    this._lastEvent = e;
+  public restrictMouseEvent(e: ICoreMouseEvent): boolean {
+    return this._protocols[this._activeProtocol].restrict(e);
+  }
 
-    return true;
+  public encodeMouseEvent(e: ICoreMouseEvent): string {
+    return this._encodings[this._activeEncoding](e);
   }
 
-  public explainEvents(events: CoreMouseEventType): { [event: string]: boolean } {
-    return {
-      down: !!(events & CoreMouseEventType.DOWN),
-      up: !!(events & CoreMouseEventType.UP),
-      drag: !!(events & CoreMouseEventType.DRAG),
-      move: !!(events & CoreMouseEventType.MOVE),
-      wheel: !!(events & CoreMouseEventType.WHEEL)
-    };
+  public get isDefaultEncoding(): boolean {
+    return this._activeEncoding === 'DEFAULT';
   }
 
-  private _equalEvents(e1: ICoreMouseEvent, e2: ICoreMouseEvent, pixels: boolean): boolean {
-    if (pixels) {
-      if (e1.x !== e2.x) return false;
-      if (e1.y !== e2.y) return false;
-    } else {
-      if (e1.col !== e2.col) return false;
-      if (e1.row !== e2.row) return false;
-    }
-    if (e1.button !== e2.button) return false;
-    if (e1.action !== e2.action) return false;
-    if (e1.ctrl !== e2.ctrl) return false;
-    if (e1.alt !== e2.alt) return false;
-    if (e1.shift !== e2.shift) return false;
-    return true;
+  public get isPixelEncoding(): boolean {
+    return this._activeEncoding === 'SGR_PIXELS';
   }
 }

package/src/common/services/OptionsService.ts

@@ -3,16 +3,18 @@
  * @license MIT
  */
 
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
-import { isMac } from 'common/Platform';
-import { CursorStyle, IDisposable } from 'common/Types';
-import { FontWeight, IOptionsService, ITerminalOptions } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { Disposable, toDisposable } from '../Lifecycle';
+import { isMac } from '../Platform';
+import { CursorStyle, IDisposable } from '../Types';
+import { FontWeight, IOptionsService, ITerminalOptions } from './Services';
+import { Emitter } from '../Event';
 
 export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   cols: 80,
   rows: 24,
+  showCursorImmediately: false,
   cursorBlink: false,
+  blinkIntervalDuration: 0,
   cursorStyle: 'block',
   cursorWidth: 1,
   cursorInactiveStyle: 'outline',
@@ -30,6 +32,7 @@ export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   logLevel: 'info',
   logger: null,
   scrollback: 1000,
+  scrollbar: { showScrollbar: true },
   scrollOnEraseInDisplay: false,
   scrollOnUserInput: true,
   scrollSensitivity: 1,
@@ -38,6 +41,7 @@ export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   macOptionIsMeta: false,
   macOptionClickForcesSelection: false,
   minimumContrastRatio: 1,
+  mouseEventsRequireAlt: false,
   disableStdin: false,
   allowProposedApi: false,
   allowTransparency: false,
@@ -52,8 +56,8 @@ export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   altClickMovesCursor: true,
   convertEol: false,
   termName: 'xterm',
-  cancelEvents: false,
-  overviewRuler: {}
+  quirks: {},
+  vtExtensions: {}
 };
 
 const FONT_WEIGHT_OPTIONS: Extract<FontWeight, string>[] = ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'];
@@ -166,6 +170,12 @@ export class OptionsService extends Disposable implements IOptionsService {
         }
         value = FONT_WEIGHT_OPTIONS.includes(value) ? value : DEFAULT_OPTIONS[key];
         break;
+      case 'blinkIntervalDuration':
+        value = Math.floor(value);
+        if (value < 0) {
+          throw new Error(`${key} cannot be less than 0, value: ${value}`);
+        }
+        break;
       case 'cursorWidth':
         value = Math.floor(value);
         // Fall through for bounds check

package/src/common/services/OscLinkService.ts

@@ -2,8 +2,9 @@
  * Copyright (c) 2022 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-import { IBufferService, IOscLinkService } from 'common/services/Services';
-import { IMarker, IOscLinkData } from 'common/Types';
+import { IBufferService, IOscLinkService } from './Services';
+import { IOscLinkData } from '../Types';
+import { IMarker } from '../buffer/Types';
 
 export class OscLinkService implements IOscLinkService {
   public serviceBrand: any;