@wendongfly/zihi 1.1.0 → 1.1.2

package/dist/lib/xterm/src/common/buffer/BufferLine.ts

@@ -4,7 +4,7 @@
  */
 
 import { CharData, IAttributeData, IBufferLine, ICellData, IExtendedAttrs } from 'common/Types';
-import { AttributeData, ExtendedAttrs } from 'common/buffer/AttributeData';
+import { AttributeData } from 'common/buffer/AttributeData';
 import { CellData } from 'common/buffer/CellData';
 import { Attributes, BgFlags, CHAR_DATA_ATTR_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, Content, NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR } from 'common/buffer/Constants';
 import { stringFromCodePoint } from 'common/input/TextDecoder';
@@ -212,13 +212,13 @@ export class BufferLine implements IBufferLine {
    * Since the input handler see the incoming chars as UTF32 codepoints,
    * it gets an optimized access method.
    */
-  public setCellFromCodePoint(index: number, codePoint: number, width: number, fg: number, bg: number, eAttrs: IExtendedAttrs): void {
-    if (bg & BgFlags.HAS_EXTENDED) {
-      this._extendedAttrs[index] = eAttrs;
+  public setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void {
+    if (attrs.bg & BgFlags.HAS_EXTENDED) {
+      this._extendedAttrs[index] = attrs.extended;
     }
     this._data[index * CELL_SIZE + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT);
-    this._data[index * CELL_SIZE + Cell.FG] = fg;
-    this._data[index * CELL_SIZE + Cell.BG] = bg;
+    this._data[index * CELL_SIZE + Cell.FG] = attrs.fg;
+    this._data[index * CELL_SIZE + Cell.BG] = attrs.bg;
   }
 
   /**
@@ -227,7 +227,7 @@ export class BufferLine implements IBufferLine {
    * onto a leading char. Since we already set the attrs
    * by the previous `setDataFromCodePoint` call, we can omit it here.
    */
-  public addCodepointToCell(index: number, codePoint: number): void {
+  public addCodepointToCell(index: number, codePoint: number, width: number): void {
     let content = this._data[index * CELL_SIZE + Cell.CONTENT];
     if (content & Content.IS_COMBINED_MASK) {
       // we already have a combined string, simply add
@@ -245,16 +245,20 @@ export class BufferLine implements IBufferLine {
         // simply set the data in the cell buffer with a width of 1
         content = codePoint | (1 << Content.WIDTH_SHIFT);
       }
-      this._data[index * CELL_SIZE + Cell.CONTENT] = content;
     }
+    if (width) {
+      content &= ~Content.WIDTH_MASK;
+      content |= width << Content.WIDTH_SHIFT;
+    }
+    this._data[index * CELL_SIZE + Cell.CONTENT] = content;
   }
 
-  public insertCells(pos: number, n: number, fillCellData: ICellData, eraseAttr?: IAttributeData): void {
+  public insertCells(pos: number, n: number, fillCellData: ICellData): void {
     pos %= this.length;
 
     // handle fullwidth at pos: reset cell one to the left if pos is second cell of a wide char
     if (pos && this.getWidth(pos - 1) === 2) {
-      this.setCellFromCodePoint(pos - 1, 0, 1, eraseAttr?.fg || 0, eraseAttr?.bg || 0, eraseAttr?.extended || new ExtendedAttrs());
+      this.setCellFromCodepoint(pos - 1, 0, 1, fillCellData);
     }
 
     if (n < this.length - pos) {
@@ -273,11 +277,11 @@ export class BufferLine implements IBufferLine {
 
     // handle fullwidth at line end: reset last cell if it is first cell of a wide char
     if (this.getWidth(this.length - 1) === 2) {
-      this.setCellFromCodePoint(this.length - 1, 0, 1, eraseAttr?.fg || 0, eraseAttr?.bg || 0, eraseAttr?.extended || new ExtendedAttrs());
+      this.setCellFromCodepoint(this.length - 1, 0, 1, fillCellData);
     }
   }
 
-  public deleteCells(pos: number, n: number, fillCellData: ICellData, eraseAttr?: IAttributeData): void {
+  public deleteCells(pos: number, n: number, fillCellData: ICellData): void {
     pos %= this.length;
     if (n < this.length - pos) {
       const cell = new CellData();
@@ -297,21 +301,21 @@ export class BufferLine implements IBufferLine {
     // - reset pos-1 if wide char
     // - reset pos if width==0 (previous second cell of a wide char)
     if (pos && this.getWidth(pos - 1) === 2) {
-      this.setCellFromCodePoint(pos - 1, 0, 1, eraseAttr?.fg || 0, eraseAttr?.bg || 0, eraseAttr?.extended || new ExtendedAttrs());
+      this.setCellFromCodepoint(pos - 1, 0, 1, fillCellData);
     }
     if (this.getWidth(pos) === 0 && !this.hasContent(pos)) {
-      this.setCellFromCodePoint(pos, 0, 1, eraseAttr?.fg || 0, eraseAttr?.bg || 0, eraseAttr?.extended || new ExtendedAttrs());
+      this.setCellFromCodepoint(pos, 0, 1, fillCellData);
     }
   }
 
-  public replaceCells(start: number, end: number, fillCellData: ICellData, eraseAttr?: IAttributeData, respectProtect: boolean = false): void {
+  public replaceCells(start: number, end: number, fillCellData: ICellData, respectProtect: boolean = false): void {
     // full branching on respectProtect==true, hopefully getting fast JIT for standard case
     if (respectProtect) {
       if (start && this.getWidth(start - 1) === 2 && !this.isProtected(start - 1)) {
-        this.setCellFromCodePoint(start - 1, 0, 1, eraseAttr?.fg || 0, eraseAttr?.bg || 0, eraseAttr?.extended || new ExtendedAttrs());
+        this.setCellFromCodepoint(start - 1, 0, 1, fillCellData);
       }
       if (end < this.length && this.getWidth(end - 1) === 2 && !this.isProtected(end)) {
-        this.setCellFromCodePoint(end, 0, 1, eraseAttr?.fg || 0, eraseAttr?.bg || 0, eraseAttr?.extended || new ExtendedAttrs());
+        this.setCellFromCodepoint(end, 0, 1, fillCellData);
       }
       while (start < end  && start < this.length) {
         if (!this.isProtected(start)) {
@@ -324,11 +328,11 @@ export class BufferLine implements IBufferLine {
 
     // handle fullwidth at start: reset cell one to the left if start is second cell of a wide char
     if (start && this.getWidth(start - 1) === 2) {
-      this.setCellFromCodePoint(start - 1, 0, 1, eraseAttr?.fg || 0, eraseAttr?.bg || 0, eraseAttr?.extended || new ExtendedAttrs());
+      this.setCellFromCodepoint(start - 1, 0, 1, fillCellData);
     }
     // handle fullwidth at last cell + 1: reset to empty cell if it is second part of a wide char
     if (end < this.length && this.getWidth(end - 1) === 2) {
-      this.setCellFromCodePoint(end, 0, 1, eraseAttr?.fg || 0, eraseAttr?.bg || 0, eraseAttr?.extended || new ExtendedAttrs());
+      this.setCellFromCodepoint(end, 0, 1, fillCellData);
     }
 
     while (start < end  && start < this.length) {
@@ -504,16 +508,43 @@ export class BufferLine implements IBufferLine {
     }
   }
 
-  public translateToString(trimRight: boolean = false, startCol: number = 0, endCol: number = this.length): string {
+  /**
+   * Translates the buffer line to a string.
+   *
+   * @param trimRight Whether to trim any empty cells on the right.
+   * @param startCol The column to start the string (0-based inclusive).
+   * @param endCol The column to end the string (0-based exclusive).
+   * @param outColumns if specified, this array will be filled with column numbers such that
+   * `returnedString[i]` is displayed at `outColumns[i]` column. `outColumns[returnedString.length]`
+   * is where the character following `returnedString` will be displayed.
+   *
+   * When a single cell is translated to multiple UTF-16 code units (e.g. surrogate pair) in the
+   * returned string, the corresponding entries in `outColumns` will have the same column number.
+   */
+  public translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string {
+    startCol = startCol ?? 0;
+    endCol = endCol ?? this.length;
     if (trimRight) {
       endCol = Math.min(endCol, this.getTrimmedLength());
     }
+    if (outColumns) {
+      outColumns.length = 0;
+    }
     let result = '';
     while (startCol < endCol) {
       const content = this._data[startCol * CELL_SIZE + Cell.CONTENT];
       const cp = content & Content.CODEPOINT_MASK;
-      result += (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR;
-      startCol += (content >> Content.WIDTH_SHIFT) || 1; // always advance by 1
+      const chars = (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR;
+      result += chars;
+      if (outColumns) {
+        for (let i = 0; i < chars.length; ++i) {
+          outColumns.push(startCol);
+        }
+      }
+      startCol += (content >> Content.WIDTH_SHIFT) || 1; // always advance by at least 1
+    }
+    if (outColumns) {
+      outColumns.push(startCol);
     }
     return result;
   }

package/dist/lib/xterm/src/common/buffer/BufferRange.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { IBufferRange } from 'xterm';
+import { IBufferRange } from '@xterm/xterm';
 
 export function getRangeLength(range: IBufferRange, bufferCols: number): number {
   if (range.start.y > range.end.y) {

package/dist/lib/xterm/src/common/buffer/BufferReflow.ts

@@ -20,8 +20,9 @@ export interface INewLayoutResult {
  * @param newCols The columns after resize.
  * @param bufferAbsoluteY The absolute y position of the cursor (baseY + cursorY).
  * @param nullCell The cell data to use when filling in empty cells.
+ * @param reflowCursorLine Whether to reflow the line containing the cursor.
  */
-export function reflowLargerGetLinesToRemove(lines: CircularList<IBufferLine>, oldCols: number, newCols: number, bufferAbsoluteY: number, nullCell: ICellData): number[] {
+export function reflowLargerGetLinesToRemove(lines: CircularList<IBufferLine>, oldCols: number, newCols: number, bufferAbsoluteY: number, nullCell: ICellData, reflowCursorLine: boolean): number[] {
   // Gather all BufferLines that need to be removed from the Buffer here so that they can be
   // batched up and only committed once
   const toRemove: number[] = [];
@@ -41,11 +42,13 @@ export function reflowLargerGetLinesToRemove(lines: CircularList<IBufferLine>, o
       nextLine = lines.get(++i) as BufferLine;
     }
 
-    // If these lines contain the cursor don't touch them, the program will handle fixing up wrapped
-    // lines with the cursor
-    if (bufferAbsoluteY >= y && bufferAbsoluteY < i) {
-      y += wrappedLines.length - 1;
-      continue;
+    if (!reflowCursorLine) {
+      // If these lines contain the cursor don't touch them, the program will handle fixing up
+      // wrapped lines with the cursor
+      if (bufferAbsoluteY >= y && bufferAbsoluteY < i) {
+        y += wrappedLines.length - 1;
+        continue;
+      }
     }
 
     // Copy buffer data to new locations

package/dist/lib/xterm/src/common/buffer/BufferSet.ts

@@ -3,12 +3,12 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/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;
 
   /**
@@ -31,8 +31,8 @@ export class BufferSet extends Disposable implements IBufferSet {
   ) {
     super();
     this.reset();
-    this.register(this._optionsService.onSpecificOptionChange('scrollback', () => this.resize(this._bufferService.cols, this._bufferService.rows)));
-    this.register(this._optionsService.onSpecificOptionChange('tabStopWidth', () => this.setupTabStops()));
+    this._register(this._optionsService.onSpecificOptionChange('scrollback', () => this.resize(this._bufferService.cols, this._bufferService.rows)));
+    this._register(this._optionsService.onSpecificOptionChange('tabStopWidth', () => this.setupTabStops()));
   }
 
   public reset(): void {

package/dist/lib/xterm/src/common/buffer/Constants.ts

@@ -134,9 +134,17 @@ export const enum BgFlags {
 
 export const enum ExtFlags {
   /**
-   * bit 27..32 (upper 3 unused)
+   * bit 27..29
    */
-  UNDERLINE_STYLE = 0x1C000000
+  UNDERLINE_STYLE = 0x1C000000,
+
+  /**
+   * bit 30..32
+   *
+   * An optional variant for the glyph, this can be used for example to offset underlines by a
+   * number of pixels to create a perfect pattern.
+   */
+  VARIANT_OFFSET = 0xE0000000
 }
 
 export const enum UnderlineStyle {

package/dist/lib/xterm/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';
+import { dispose } from 'vs/base/common/lifecycle';
 
 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(
@@ -32,7 +32,7 @@ export class Marker implements IMarker {
     this.line = -1;
     // Emit before super.dispose such that dispose listeners get a change to react
     this._onDispose.fire();
-    disposeArray(this._disposables);
+    dispose(this._disposables);
     this._disposables.length = 0;
   }
 

package/dist/lib/xterm/src/common/buffer/Types.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IAttributeData, ICircularList, IBufferLine, ICellData, IMarker, ICharset, IDisposable } from 'common/Types';
+import type { Event } from 'vs/base/common/event';
+
+// BufferIndex denotes a position in the buffer: [rowIndex, colIndex]
+export type BufferIndex = [number, number];
+
+export interface IBuffer {
+  readonly lines: ICircularList<IBufferLine>;
+  ydisp: number;
+  ybase: number;
+  y: number;
+  x: number;
+  tabs: any;
+  scrollBottom: number;
+  scrollTop: number;
+  hasScrollback: boolean;
+  savedY: number;
+  savedX: number;
+  savedCharset: ICharset | undefined;
+  savedCurAttrData: IAttributeData;
+  isCursorInViewport: boolean;
+  markers: IMarker[];
+  translateBufferLineToString(lineIndex: number, trimRight: boolean, startCol?: number, endCol?: number): string;
+  getWrappedRangeForLine(y: number): { first: number, last: number };
+  nextStop(x?: number): number;
+  prevStop(x?: number): number;
+  getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine;
+  getNullCell(attr?: IAttributeData): ICellData;
+  getWhitespaceCell(attr?: IAttributeData): ICellData;
+  addMarker(y: number): IMarker;
+  clearMarkers(y: number): void;
+  clearAllMarkers(): void;
+}
+
+export interface IBufferSet extends IDisposable {
+  alt: IBuffer;
+  normal: IBuffer;
+  active: IBuffer;
+
+  onBufferActivate: Event<{ activeBuffer: IBuffer, inactiveBuffer: IBuffer }>;
+
+  activateNormalBuffer(): void;
+  activateAltBuffer(fillAttr?: IAttributeData): void;
+  reset(): void;
+  resize(newCols: number, newRows: number): void;
+  setupTabStops(i?: number): void;
+}

package/dist/lib/xterm/src/common/input/Keyboard.ts

@@ -83,11 +83,10 @@ export function evaluateKeyboardEvent(
       break;
     case 8:
       // backspace
+      result.key = ev.ctrlKey ? '\b' : C0.DEL; // ^H or ^?
       if (ev.altKey) {
-        result.key = C0.ESC + C0.DEL; // \e ^?
-        break;
+        result.key = C0.ESC + result.key;
       }
-      result.key = C0.DEL; // ^?
       break;
     case 9:
       // tab
@@ -118,12 +117,6 @@ export function evaluateKeyboardEvent(
       }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'D';
-        // HACK: Make Alt + left-arrow behave like Ctrl + left-arrow: move one word backwards
-        // http://unix.stackexchange.com/a/108106
-        // macOS uses different escape sequences than linux
-        if (result.key === C0.ESC + '[1;3D') {
-          result.key = C0.ESC + (isMac ? 'b' : '[1;5D');
-        }
       } else if (applicationCursorMode) {
         result.key = C0.ESC + 'OD';
       } else {
@@ -137,12 +130,6 @@ export function evaluateKeyboardEvent(
       }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'C';
-        // HACK: Make Alt + right-arrow behave like Ctrl + right-arrow: move one word forward
-        // http://unix.stackexchange.com/a/108106
-        // macOS uses different escape sequences than linux
-        if (result.key === C0.ESC + '[1;3C') {
-          result.key = C0.ESC + (isMac ? 'f' : '[1;5C');
-        }
       } else if (applicationCursorMode) {
         result.key = C0.ESC + 'OC';
       } else {
@@ -156,12 +143,6 @@ export function evaluateKeyboardEvent(
       }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'A';
-        // HACK: Make Alt + up-arrow behave like Ctrl + up-arrow
-        // http://unix.stackexchange.com/a/108106
-        // macOS uses different escape sequences than linux
-        if (!isMac && result.key === C0.ESC + '[1;3A') {
-          result.key = C0.ESC + '[1;5A';
-        }
       } else if (applicationCursorMode) {
         result.key = C0.ESC + 'OA';
       } else {
@@ -175,12 +156,6 @@ export function evaluateKeyboardEvent(
       }
       if (modifiers) {
         result.key = C0.ESC + '[1;' + (modifiers + 1) + 'B';
-        // HACK: Make Alt + down-arrow behave like Ctrl + down-arrow
-        // http://unix.stackexchange.com/a/108106
-        // macOS uses different escape sequences than linux
-        if (!isMac && result.key === C0.ESC + '[1;3B') {
-          result.key = C0.ESC + '[1;5B';
-        }
       } else if (applicationCursorMode) {
         result.key = C0.ESC + 'OB';
       } else {

package/dist/lib/xterm/src/common/input/UnicodeV6.ts

@@ -2,9 +2,8 @@
  * Copyright (c) 2019 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-import { IUnicodeVersionProvider } from 'common/services/Services';
-
-type CharWidth = 0 | 1 | 2;
+import { IUnicodeVersionProvider, UnicodeCharProperties, UnicodeCharWidth } from 'common/services/Services';
+import { UnicodeService } from 'common/services/UnicodeService';
 
 const BMP_COMBINING = [
   [0x0300, 0x036F], [0x0483, 0x0486], [0x0488, 0x0489],
@@ -121,12 +120,26 @@ export class UnicodeV6 implements IUnicodeVersionProvider {
     }
   }
 
-  public wcwidth(num: number): CharWidth {
+  public wcwidth(num: number): UnicodeCharWidth {
     if (num < 32) return 0;
     if (num < 127) return 1;
-    if (num < 65536) return table[num] as CharWidth;
+    if (num < 65536) return table[num] as UnicodeCharWidth;
     if (bisearch(num, HIGH_COMBINING)) return 0;
     if ((num >= 0x20000 && num <= 0x2fffd) || (num >= 0x30000 && num <= 0x3fffd)) return 2;
     return 1;
   }
+
+  public charProperties(codepoint: number, preceding: UnicodeCharProperties): UnicodeCharProperties {
+    let width = this.wcwidth(codepoint);
+    let shouldJoin = width === 0 && preceding !== 0;
+    if (shouldJoin) {
+      const oldWidth = UnicodeService.extractWidth(preceding);
+      if (oldWidth === 0) {
+        shouldJoin = false;
+      } else if (oldWidth > width) {
+        width = oldWidth;
+      }
+    }
+    return UnicodeService.createPropertyValue(0, width, shouldJoin);
+  }
 }

package/dist/lib/xterm/src/common/input/WriteBuffer.ts

@@ -4,8 +4,8 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/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>) {
@@ -137,7 +137,7 @@ export class WriteBuffer extends Disposable {
    * effectively lowering the redrawing needs, schematically:
    *
    *   macroTask _innerWrite:
-   *     if (Date.now() - (lastTime | 0) < WRITE_TIMEOUT_MS):
+   *     if (performance.now() - (lastTime | 0) < WRITE_TIMEOUT_MS):
    *        schedule microTask _innerWrite(lastTime)
    *     else:
    *        schedule macroTask _innerWrite(0)
@@ -158,7 +158,7 @@ export class WriteBuffer extends Disposable {
    * Note, for pure sync code `lastTime` and `promiseResult` have no meaning.
    */
   protected _innerWrite(lastTime: number = 0, promiseResult: boolean = true): void {
-    const startTime = lastTime || Date.now();
+    const startTime = lastTime || performance.now();
     while (this._writeBuffer.length > this._bufferOffset) {
       const data = this._writeBuffer[this._bufferOffset];
       const result = this._action(data, promiseResult);
@@ -186,7 +186,7 @@ export class WriteBuffer extends Disposable {
          * responsibility to slice hard work), but we can at least schedule a screen update as we
          * gain control.
          */
-        const continuation: (r: boolean) => void = (r: boolean) => Date.now() - startTime >= WRITE_TIMEOUT_MS
+        const continuation: (r: boolean) => void = (r: boolean) => performance.now() - startTime >= WRITE_TIMEOUT_MS
           ? setTimeout(() => this._innerWrite(0, r))
           : this._innerWrite(startTime, r);
 
@@ -202,7 +202,8 @@ export class WriteBuffer extends Disposable {
          * throughput by eval'ing `startTime` upfront pulling at least one more chunk into the
          * current microtask queue (executed before setTimeout).
          */
-        // const continuation: (r: boolean) => void = Date.now() - startTime >= WRITE_TIMEOUT_MS
+        // const continuation: (r: boolean) => void = performance.now() - startTime >=
+        //     WRITE_TIMEOUT_MS
         //   ? r => setTimeout(() => this._innerWrite(0, r))
         //   : r => this._innerWrite(startTime, r);
 
@@ -222,7 +223,7 @@ export class WriteBuffer extends Disposable {
       this._bufferOffset++;
       this._pendingData -= data.length;
 
-      if (Date.now() - startTime >= WRITE_TIMEOUT_MS) {
+      if (performance.now() - startTime >= WRITE_TIMEOUT_MS) {
         break;
       }
     }

package/dist/lib/xterm/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 } from 'common/parser/Types';
 import { ParserState, ParserAction } from 'common/parser/Constants';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { IDisposable } from 'common/Types';
 import { Params } from 'common/parser/Params';
 import { OscParser } from 'common/parser/OscParser';
@@ -230,7 +230,7 @@ export const VT500_TRANSITION_TABLE = (function (): TransitionTable {
 export class EscapeSequenceParser extends Disposable implements IEscapeSequenceParser {
   public initialState: number;
   public currentState: number;
-  public precedingCodepoint: number;
+  public precedingJoinState: number; // UnicodeJoinProperties
 
   // buffers over several parse calls
   protected _params: Params;
@@ -271,7 +271,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     this._params = new Params(); // defaults to 32 storable params/subparams
     this._params.addParam(0);    // ZDM
     this._collect = 0;
-    this.precedingCodepoint = 0;
+    this.precedingJoinState = 0;
 
     // set default fallback handlers and handler lookup containers
     this._printHandlerFb = (data, start, end): void => { };
@@ -283,13 +283,13 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     this._executeHandlers = Object.create(null);
     this._csiHandlers = Object.create(null);
     this._escHandlers = Object.create(null);
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
       this._csiHandlers = Object.create(null);
       this._executeHandlers = Object.create(null);
       this._escHandlers = Object.create(null);
     }));
-    this._oscParser = this.register(new OscParser());
-    this._dcsParser = this.register(new DcsParser());
+    this._oscParser = this._register(new OscParser());
+    this._dcsParser = this._register(new DcsParser());
     this._errorHandler = this._errorHandlerFb;
 
     // swallow 7bit ST (ESC+\)
@@ -448,7 +448,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
     this._params.reset();
     this._params.addParam(0); // ZDM
     this._collect = 0;
-    this.precedingCodepoint = 0;
+    this.precedingJoinState = 0;
     // abort pending continuation from async handler
     // Here the RESET type indicates, that the next parse call will
     // ignore any saved stack, instead continues sync with next codepoint from GROUND
@@ -610,7 +610,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
         // cleanup before continuing with the main sync loop
         this._parseStack.state = ParserStackType.NONE;
         start = this._parseStack.chunkPos + 1;
-        this.precedingCodepoint = 0;
+        this.precedingJoinState = 0;
         this.currentState = this._parseStack.transition & TableAccess.TRANSITION_STATE_MASK;
       }
     }
@@ -653,7 +653,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
         case ParserAction.EXECUTE:
           if (this._executeHandlers[code]) this._executeHandlers[code]();
           else this._executeHandlerFb(code);
-          this.precedingCodepoint = 0;
+          this.precedingJoinState = 0;
           break;
         case ParserAction.IGNORE:
           break;
@@ -688,7 +688,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
           if (j < 0) {
             this._csiHandlerFb(this._collect << 8 | code, this._params);
           }
-          this.precedingCodepoint = 0;
+          this.precedingJoinState = 0;
           break;
         case ParserAction.PARAM:
           // inner loop: digits (0x30 - 0x39) and ; (0x3b) and : (0x3a)
@@ -727,7 +727,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
           if (jj < 0) {
             this._escHandlerFb(this._collect << 8 | code);
           }
-          this.precedingCodepoint = 0;
+          this.precedingJoinState = 0;
           break;
         case ParserAction.CLEAR:
           this._params.reset();
@@ -758,7 +758,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
           this._params.reset();
           this._params.addParam(0); // ZDM
           this._collect = 0;
-          this.precedingCodepoint = 0;
+          this.precedingJoinState = 0;
           break;
         case ParserAction.OSC_START:
           this._oscParser.start();
@@ -783,7 +783,7 @@ export class EscapeSequenceParser extends Disposable implements IEscapeSequenceP
           this._params.reset();
           this._params.addParam(0); // ZDM
           this._collect = 0;
-          this.precedingCodepoint = 0;
+          this.precedingJoinState = 0;
           break;
       }
       this.currentState = transition & TableAccess.TRANSITION_STATE_MASK;