@xterm/xterm 5.6.0-beta.4 → 5.6.0-beta.41

package/src/common/InputHandler.ts

@@ -2972,14 +2972,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 +3456,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/SortedList.ts

@@ -3,16 +3,27 @@
  * @license MIT
  */
 
+import { IdleTaskQueue } from 'common/TaskQueue';
+
 // Work variables to avoid garbage collection.
 let i = 0;
 
 /**
- * A generic list that is maintained in sorted order and allows values with duplicate keys. This
- * list is based on binary search and as such locating a key will take O(log n) amortized, this
- * includes the by key iterator.
+ * A generic list that is maintained in sorted order and allows values with duplicate keys. Deferred
+ * batch insertion and deletion is used to significantly reduce the time it takes to insert and
+ * delete a large amount of items in succession. This list is based on binary search and as such
+ * locating a key will take O(log n) amortized, this includes the by key iterator.
  */
 export class SortedList<T> {
-  private readonly _array: T[] = [];
+  private _array: T[] = [];
+
+  private readonly _insertedValues: T[] = [];
+  private readonly _flushInsertedTask = new IdleTaskQueue();
+  private _isFlushingInserted = false;
+
+  private readonly _deletedIndices: number[] = [];
+  private readonly _flushDeletedTask = new IdleTaskQueue();
+  private _isFlushingDeleted = false;
 
   constructor(
     private readonly _getKey: (value: T) => number
@@ -21,18 +32,50 @@ export class SortedList<T> {
 
   public clear(): void {
     this._array.length = 0;
+    this._insertedValues.length = 0;
+    this._flushInsertedTask.clear();
+    this._isFlushingInserted = false;
+    this._deletedIndices.length = 0;
+    this._flushDeletedTask.clear();
+    this._isFlushingDeleted = false;
   }
 
   public insert(value: T): void {
-    if (this._array.length === 0) {
-      this._array.push(value);
-      return;
+    this._flushCleanupDeleted();
+    if (this._insertedValues.length === 0) {
+      this._flushInsertedTask.enqueue(() => this._flushInserted());
+    }
+    this._insertedValues.push(value);
+  }
+
+  private _flushInserted(): void {
+    const sortedAddedValues = this._insertedValues.sort((a, b) => this._getKey(a) - this._getKey(b));
+    let sortedAddedValuesIndex = 0;
+    let arrayIndex = 0;
+
+    const newArray = new Array(this._array.length + this._insertedValues.length);
+
+    for (let newArrayIndex = 0; newArrayIndex < newArray.length; newArrayIndex++) {
+      if (arrayIndex >= this._array.length || this._getKey(sortedAddedValues[sortedAddedValuesIndex]) <= this._getKey(this._array[arrayIndex])) {
+        newArray[newArrayIndex] = sortedAddedValues[sortedAddedValuesIndex];
+        sortedAddedValuesIndex++;
+      } else {
+        newArray[newArrayIndex] = this._array[arrayIndex++];
+      }
+    }
+
+    this._array = newArray;
+    this._insertedValues.length = 0;
+  }
+
+  private _flushCleanupInserted(): void {
+    if (!this._isFlushingInserted && this._insertedValues.length > 0) {
+      this._flushInsertedTask.flush();
     }
-    i = this._search(this._getKey(value));
-    this._array.splice(i, 0, value);
   }
 
   public delete(value: T): boolean {
+    this._flushCleanupInserted();
     if (this._array.length === 0) {
       return false;
     }
@@ -49,14 +92,43 @@ export class SortedList<T> {
     }
     do {
       if (this._array[i] === value) {
-        this._array.splice(i, 1);
+        if (this._deletedIndices.length === 0) {
+          this._flushDeletedTask.enqueue(() => this._flushDeleted());
+        }
+        this._deletedIndices.push(i);
         return true;
       }
     } while (++i < this._array.length && this._getKey(this._array[i]) === key);
     return false;
   }
 
+  private _flushDeleted(): void {
+    this._isFlushingDeleted = true;
+    const sortedDeletedIndices = this._deletedIndices.sort((a, b) => a - b);
+    let sortedDeletedIndicesIndex = 0;
+    const newArray = new Array(this._array.length - sortedDeletedIndices.length);
+    let newArrayIndex = 0;
+    for (let i = 0; i < this._array.length; i++) {
+      if (sortedDeletedIndices[sortedDeletedIndicesIndex] === i) {
+        sortedDeletedIndicesIndex++;
+      } else {
+        newArray[newArrayIndex++] = this._array[i];
+      }
+    }
+    this._array = newArray;
+    this._deletedIndices.length = 0;
+    this._isFlushingDeleted = false;
+  }
+
+  private _flushCleanupDeleted(): void {
+    if (!this._isFlushingDeleted && this._deletedIndices.length > 0) {
+      this._flushDeletedTask.flush();
+    }
+  }
+
   public *getKeyIterator(key: number): IterableIterator<T> {
+    this._flushCleanupInserted();
+    this._flushCleanupDeleted();
     if (this._array.length === 0) {
       return;
     }
@@ -73,6 +145,8 @@ export class SortedList<T> {
   }
 
   public forEachByKey(key: number, callback: (value: T) => void): void {
+    this._flushCleanupInserted();
+    this._flushCleanupDeleted();
     if (this._array.length === 0) {
       return;
     }
@@ -89,6 +163,8 @@ export class SortedList<T> {
   }
 
   public values(): IterableIterator<T> {
+    this._flushCleanupInserted();
+    this._flushCleanupDeleted();
     // Duplicate the array to avoid issues when _array changes while iterating
     return [...this._array].values();
   }

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

@@ -425,8 +425,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,

package/src/common/buffer/Buffer.ts

@@ -611,8 +611,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/services/DecorationService.ts

@@ -45,7 +45,8 @@ export class DecorationService extends Disposable implements IDecorationService
     const decoration = new Decoration(options);
     if (decoration) {
       const markerDispose = decoration.marker.onDispose(() => decoration.dispose());
-      decoration.onDispose(() => {
+      const listener = decoration.onDispose(() => {
+        listener.dispose();
         if (decoration) {
           if (this._decorations.delete(decoration)) {
             this._onDecorationRemoved.fire(decoration);

package/typings/xterm.d.ts

@@ -47,11 +47,13 @@ declare module '@xterm/xterm' {
 
     /**
      * When enabled the cursor will be set to the beginning of the next line
-     * with every new line. This is equivalent to sending '\r\n' for each '\n'.
-     * Normally the termios settings of the underlying PTY deals with the
-     * translation of '\n' to '\r\n' and this setting should not be used. If you
+     * with every new line. This is equivalent to sending `\r\n` for each `\n`.
+     * Normally the settings of the underlying PTY (`termios`) deal with the
+     * translation of `\n` to `\r\n` and this setting should not be used. If you
      * deal with data from a non-PTY related source, this settings might be
      * useful.
+     *
+     * @see https://pubs.opengroup.org/onlinepubs/007904975/basedefs/termios.h.html
      */
     convertEol?: boolean;