@xterm/xterm 6.1.0-beta.301 → 6.1.0-beta.303

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xterm/xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "6.1.0-beta.301",
+  "version": "6.1.0-beta.303",
   "main": "lib/xterm.js",
   "module": "lib/xterm.mjs",
   "style": "css/xterm.css",
@@ -119,5 +119,5 @@
     "ws": "^8.20.0",
     "xterm-benchmark": "^0.3.2"
   },
-  "commit": "8c9b9fdb9ba7b72b677173225f69c2a47f807600"
+  "commit": "d3e32b344dfe7dd6015cff6a9aeaaeaeccdc2789"
 }

package/src/common/Event.ts

@@ -27,11 +27,13 @@ export class Emitter<T> {
       }
 
       const entry = { fn: listener, thisArgs };
+      this._listeners = this._listeners.slice();
       this._listeners.push(entry);
 
       const result = toDisposable(() => {
         const idx = this._listeners.indexOf(entry);
         if (idx !== -1) {
+          this._listeners = this._listeners.slice();
           this._listeners.splice(idx, 1);
         }
       });
@@ -50,23 +52,16 @@ export class Emitter<T> {
   }
 
   public fire(event: T): void {
-    if (this._disposed) {
+    if (this._disposed || !this._listeners.length) {
       return;
     }
-    switch (this._listeners.length) {
-      case 0: return;
-      case 1: {
-        const { fn, thisArgs } = this._listeners[0];
-        fn.call(thisArgs, event);
-        return;
-      }
-      default: {
-        // Snapshot listeners to allow modifications during iteration (2+ listeners)
-        const listeners = this._listeners.slice();
-        for (const { fn, thisArgs } of listeners) {
-          fn.call(thisArgs, event);
-        }
-      }
+    if (this._listeners.length === 1) {
+      this._listeners[0].fn.call(this._listeners[0].thisArgs, event);
+      return;
+    }
+    const listeners = this._listeners;
+    for (let i = 0, len = listeners.length; i < len; ++i) {
+      listeners[i].fn.call(listeners[i].thisArgs, event);
     }
   }
 

package/src/common/InputHandler.ts

@@ -1286,6 +1286,11 @@ export class InputHandler extends Disposable implements IInputHandler {
           this._activeBuffer.lines.trimStart(scrollBackSize);
           this._activeBuffer.ybase = Math.max(this._activeBuffer.ybase - scrollBackSize, 0);
           this._activeBuffer.ydisp = Math.max(this._activeBuffer.ydisp - scrollBackSize, 0);
+          // isUserScrolling tracks the normal buffer's viewport, so ED3 on the alt
+          // screen must not touch it
+          if (this._activeBuffer === this._bufferService.buffers.normal) {
+            this._bufferService.isUserScrolling = false;
+          }
           // Force a scroll event to refresh viewport
           this._onScroll.fire(0);
         }

package/src/common/Version.ts

@@ -6,4 +6,4 @@
 /**
  * The xterm.js version. This is updated by the publish script from package.json.
  */
-export const XTERM_VERSION = '6.1.0-beta.301';
+export const XTERM_VERSION = '6.1.0-beta.303';

package/src/common/buffer/Buffer.ts

@@ -10,7 +10,6 @@ import { ICharset } from '../Types';
 import { IAttributeData, IBuffer, IBufferLine, ICellData } from './Types';
 import { ExtendedAttrs } from './AttributeData';
 import { BufferLine, DEFAULT_ATTR_DATA } from './BufferLine';
-import { BufferLineStringCache } from './BufferLineStringCache';
 import { getWrappedLineTrimmedLength, reflowLargerApplyNewLayout, reflowLargerCreateNewLayout, reflowLargerGetLinesToRemove, reflowSmallerGetNewLineLengths } from './BufferReflow';
 import { CellData } from './CellData';
 import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, WHITESPACE_CELL_WIDTH } from './Constants';
@@ -52,7 +51,6 @@ export class Buffer extends Disposable implements IBuffer {
   private _isClearing: boolean = false;
   private _memoryCleanupQueue: InstanceType<typeof IdleTaskQueue>;
   private _memoryCleanupPosition = 0;
-  private readonly _stringCache: BufferLineStringCache;
 
   constructor(
     private _hasScrollback: boolean,
@@ -70,7 +68,6 @@ export class Buffer extends Disposable implements IBuffer {
     this._memoryCleanupQueue = new IdleTaskQueue(this._logService);
     this._register(toDisposable(() => this._memoryCleanupQueue.clear()));
     this._register(toDisposable(() => this.clearAllMarkers()));
-    this._stringCache = this._register(new BufferLineStringCache());
   }
 
   public getNullCell(attr?: IAttributeData): ICellData {
@@ -100,7 +97,7 @@ export class Buffer extends Disposable implements IBuffer {
   }
 
   public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
-    return new BufferLine(this._stringCache, this._bufferService.cols, this.getNullCell(attr), isWrapped);
+    return new BufferLine(this._bufferService.cols, this.getNullCell(attr), isWrapped);
   }
 
   public get hasScrollback(): boolean {
@@ -145,7 +142,6 @@ export class Buffer extends Disposable implements IBuffer {
    * Clears the buffer to its initial state, discarding all previous data.
    */
   public clear(): void {
-    this._stringCache.clear();
     this.ydisp = 0;
     this.ybase = 0;
     this.y = 0;
@@ -164,7 +160,6 @@ export class Buffer extends Disposable implements IBuffer {
   public resize(newCols: number, newRows: number): void {
     // store reference to null cell with default attrs
     const nullCell = this.getNullCell(DEFAULT_ATTR_DATA);
-    this._stringCache.clear();
 
     // count bufferlines with overly big memory to be cleaned afterwards
     let dirtyMemoryLines = 0;
@@ -199,7 +194,7 @@ export class Buffer extends Disposable implements IBuffer {
             if (this._optionsService.rawOptions.windowsPty.backend !== undefined || this._optionsService.rawOptions.windowsPty.buildNumber !== undefined) {
               // Just add the new missing rows on Windows as conpty reprints the screen with its
               // view of the world. Once a line enters scrollback for conpty it remains there
-              this.lines.push(new BufferLine(this._stringCache, newCols, nullCell, false));
+              this.lines.push(new BufferLine(newCols, nullCell, false));
             } else {
               if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) {
                 // There is room above the buffer and there are no empty elements below the line,
@@ -213,7 +208,7 @@ export class Buffer extends Disposable implements IBuffer {
               } else {
                 // Add a blank line if there is no buffer left at the top to scroll to, or if there
                 // are blank lines after the cursor
-                this.lines.push(new BufferLine(this._stringCache, newCols, nullCell, false));
+                this.lines.push(new BufferLine(newCols, nullCell, false));
               }
             }
           }
@@ -354,7 +349,7 @@ export class Buffer extends Disposable implements IBuffer {
         }
         if (this.lines.length < newRows) {
           // Add an extra row at the bottom of the viewport
-          this.lines.push(new BufferLine(this._stringCache, newCols, nullCell, false));
+          this.lines.push(new BufferLine(newCols, nullCell, false));
         }
       } else {
         if (this.ydisp === this.ybase) {

package/src/common/buffer/BufferLine.ts

@@ -8,7 +8,6 @@ import { AttributeData } from './AttributeData';
 import { CellData } from './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 './Constants';
 import { stringFromCodePoint } from '../input/TextDecoder';
-import { StringBuilder } from '../StringBuilder';
 
 // Buffer memory layout:
 //
@@ -37,24 +36,20 @@ const enum Cell {
   BG = 2  // currently unused
 }
 
+
+interface IExtendedAttrsExt extends IExtendedAttrs {
+  _ext: number;
+  _urlId: number;
+}
+
+
 export const DEFAULT_ATTR_DATA = Object.freeze(new AttributeData());
 
 // Work variables to avoid garbage collection
 let $startIndex = 0;
 const $workCell = new CellData();
-const $translateToStringBuilder = new StringBuilder();
-
-export interface IBufferLineStringCacheEntry {
-  value: string | undefined;
-  isTrimmed: boolean;
-  generation: number;
-}
+const $extended = DEFAULT_ATTR_DATA.extended.clone() as IExtendedAttrsExt;
 
-export interface IBufferLineStringCache {
-  generation: number;
-  allocateEntry(): IBufferLineStringCacheEntry;
-  touch?(): void;
-}
 
 /**
  * Typed array based bufferline implementation.
@@ -77,11 +72,14 @@ export class BufferLine implements IBufferLine {
   protected _combined: {[index: number]: string} = {};
   /** Sparse cache; only read when `HAS_EXTENDED` is set in `_data`. */
   protected _extendedAttrs: {[index: number]: IExtendedAttrs | undefined} = {};
-  protected _stringCacheEntryRef: WeakRef<IBufferLineStringCacheEntry> | undefined;
   public length: number;
 
+  /** line text cache */
+  protected _cacheValid = false;
+  protected _cache: string = '';
+  protected _cacheTrimmed = false;
+
   constructor(
-    protected readonly _stringCache: IBufferLineStringCache,
     cols: number,
     fillCellData?: ICellData,
     public isWrapped: boolean = false
@@ -118,7 +116,7 @@ export class BufferLine implements IBufferLine {
    * @deprecated
    */
   public set(index: number, value: CharData): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     this._data[index * Constants.CELL_INDICIES + Cell.FG] = value[CHAR_DATA_ATTR_INDEX];
     if (value[CHAR_DATA_CHAR_INDEX].length > 1) {
       this._combined[index] = value[1];
@@ -215,7 +213,11 @@ export class BufferLine implements IBufferLine {
     } else {
       // Do not mutate cell.extended in place: it may still reference this line's map entry from a
       // prior loadCell into a reused CellData (e.g. $workCell during insert/delete).
-      cell.extended = DEFAULT_ATTR_DATA.extended.clone();
+      // We use $extended as blueprint and reset the internals
+      // mimicking the ctor to avoid a new allocation.
+      $extended._ext = 0;
+      $extended._urlId = 0;
+      cell.extended = $extended;
     }
     return cell;
   }
@@ -224,7 +226,7 @@ export class BufferLine implements IBufferLine {
    * Set data at `index` to `cell`.
    */
   public setCell(index: number, cell: ICellData): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     if (cell.content & Content.IS_COMBINED_MASK) {
       this._combined[index] = cell.combinedData;
     }
@@ -242,13 +244,14 @@ export class BufferLine implements IBufferLine {
    * it gets an optimized access method.
    */
   public setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     if (attrs.bg & BgFlags.HAS_EXTENDED) {
       this._extendedAttrs[index] = attrs.extended;
     }
-    this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT);
-    this._data[index * Constants.CELL_INDICIES + Cell.FG] = attrs.fg;
-    this._data[index * Constants.CELL_INDICIES + Cell.BG] = attrs.bg;
+    const $idx = index * Constants.CELL_INDICIES;
+    this._data[$idx + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT);
+    this._data[$idx + Cell.FG] = attrs.fg;
+    this._data[$idx + Cell.BG] = attrs.bg;
   }
 
   /**
@@ -258,7 +261,7 @@ export class BufferLine implements IBufferLine {
    * by the previous `setDataFromCodePoint` call, we can omit it here.
    */
   public addCodepointToCell(index: number, codePoint: number, width: number): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     let content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
     if (content & Content.IS_COMBINED_MASK) {
       // we already have a combined string, simply add
@@ -285,7 +288,7 @@ export class BufferLine implements IBufferLine {
   }
 
   public insertCells(pos: number, n: number, fillCellData: ICellData): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     pos %= this.length;
 
     // handle fullwidth at pos: reset cell one to the left if pos is second cell of a wide char
@@ -313,7 +316,7 @@ export class BufferLine implements IBufferLine {
   }
 
   public deleteCells(pos: number, n: number, fillCellData: ICellData): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     pos %= this.length;
     if (n < this.length - pos) {
       for (let i = 0; i < this.length - pos - n; ++i) {
@@ -340,7 +343,7 @@ export class BufferLine implements IBufferLine {
   }
 
   public replaceCells(start: number, end: number, fillCellData: ICellData, respectProtect: boolean = false): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     // 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)) {
@@ -380,7 +383,7 @@ export class BufferLine implements IBufferLine {
    * excess memory (true after shrinking > Constants.CLEANUP_THRESHOLD).
    */
   public resize(cols: number, fillCellData: ICellData): boolean {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     if (cols === this.length) {
       return this._data.length * 4 * Constants.CLEANUP_THRESHOLD < this._data.buffer.byteLength;
     }
@@ -440,7 +443,7 @@ export class BufferLine implements IBufferLine {
 
   /** fill a line with fillCharData */
   public fill(fillCellData: ICellData, respectProtect: boolean = false): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     // full branching on respectProtect==true, hopefully getting fast JIT for standard case
     if (respectProtect) {
       for (let i = 0; i < this.length; ++i) {
@@ -458,8 +461,7 @@ export class BufferLine implements IBufferLine {
   }
 
   /** alter to a full copy of line  */
-  public copyFrom(line: BufferLine): void {
-    this._invalidateStringCache();
+  public copyFrom(line: BufferLine, blank?: boolean): void {
     if (this.length !== line.length) {
       this._data = new Uint32Array(line._data);
     } else {
@@ -467,16 +469,29 @@ export class BufferLine implements IBufferLine {
       this._data.set(line._data);
     }
     this.length = line.length;
-    this._copySparseMapsFrom(line);
+    if (blank) {
+      // a blank line may never hold combined or extended attrs,
+      // thus we can skip handling them
+      this._combined = {};
+      this._extendedAttrs = {};
+    } else {
+      this._copySparseMapsFrom(line);
+    }
+    this._cache = '';
+    this._cacheValid = false;
     this.isWrapped = line.isWrapped;
   }
 
   /** create a new clone */
-  public clone(): IBufferLine {
-    const newLine = new BufferLine(this._stringCache, 0, undefined, false);
+  public clone(blank?: boolean): IBufferLine {
+    const newLine = new BufferLine(0, undefined, false);
     newLine._data = new Uint32Array(this._data);
     newLine.length = this.length;
-    newLine._copySparseMapsFrom(this);
+    if (!blank) {
+      // a blank line may never hold combined or extended attrs,
+      // thus we can skip handling them
+      newLine._copySparseMapsFrom(this);
+    }
     newLine.isWrapped = this.isWrapped;
     return newLine;
   }
@@ -500,7 +515,7 @@ export class BufferLine implements IBufferLine {
   }
 
   public copyCellsFrom(src: BufferLine, srcCol: number, destCol: number, length: number, applyInReverse: boolean): void {
-    this._invalidateStringCache();
+    this._cacheValid = false;
     const srcData = src._data;
     if (applyInReverse) {
       for (let cell = length - 1; cell >= 0; cell--) {
@@ -534,17 +549,13 @@ export class BufferLine implements IBufferLine {
    * returned string, the corresponding entries in `outColumns` will have the same column number.
    */
   public translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string {
-    const isCanonicalRequest = (startCol === undefined || startCol === 0) && endCol === undefined && outColumns === undefined;
-    if (isCanonicalRequest) {
-      this._stringCache.touch?.();
-    }
-    const stringCacheEntry = isCanonicalRequest ? this._getStringCacheEntry(false) : undefined;
-    if (isCanonicalRequest && stringCacheEntry?.value !== undefined) {
+    const isCanonical = (startCol === undefined || startCol === 0) && endCol === undefined && outColumns === undefined;
+    if (isCanonical && this._cacheValid) {
       if (trimRight) {
-        return stringCacheEntry.isTrimmed ? stringCacheEntry.value : stringCacheEntry.value.trimEnd();
+        return this._cacheTrimmed ? this._cache : this._cache.trimEnd();
       }
-      if (!stringCacheEntry.isTrimmed) {
-        return stringCacheEntry.value;
+      if (!this._cacheTrimmed) {
+        return this._cache;
       }
     }
     startCol = startCol ?? 0;
@@ -555,12 +566,12 @@ export class BufferLine implements IBufferLine {
     if (outColumns) {
       outColumns.length = 0;
     }
-    $translateToStringBuilder.reset();
+    const cellContents: string[] = [];
     while (startCol < endCol) {
       const content = this._data[startCol * Constants.CELL_INDICIES + Cell.CONTENT];
       const cp = content & Content.CODEPOINT_MASK;
       const chars = (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR;
-      $translateToStringBuilder.append(chars);
+      cellContents.push(chars);
       if (outColumns) {
         for (let i = 0; i < chars.length; ++i) {
           outColumns.push(startCol);
@@ -571,39 +582,15 @@ export class BufferLine implements IBufferLine {
     if (outColumns) {
       outColumns.push(startCol);
     }
-    const result = $translateToStringBuilder.toString();
-    $translateToStringBuilder.reset();
-    if (isCanonicalRequest) {
-      const cacheEntry = this._getStringCacheEntry(true)!;
-      cacheEntry.value = result;
-      cacheEntry.isTrimmed = !!trimRight;
+    const result = cellContents.join('');
+    if (isCanonical) {
+      this._cache = result;
+      this._cacheValid = true;
+      this._cacheTrimmed = !!trimRight;
     }
     return result;
   }
 
-  protected _getStringCacheEntry(createIfNeeded: boolean): IBufferLineStringCacheEntry | undefined {
-    const cachedEntry = this._stringCacheEntryRef?.deref();
-    if (cachedEntry) {
-      if (cachedEntry.generation === this._stringCache.generation) {
-        return cachedEntry;
-      }
-    }
-    if (!createIfNeeded) {
-      return undefined;
-    }
-    const cacheEntry = this._stringCache.allocateEntry();
-    this._stringCacheEntryRef = new WeakRef(cacheEntry);
-    return cacheEntry;
-  }
-
-  private _invalidateStringCache(): void {
-    const cacheEntry = this._getStringCacheEntry(false);
-    if (cacheEntry) {
-      cacheEntry.value = undefined;
-      cacheEntry.isTrimmed = false;
-    }
-  }
-
   /** Copy sparse map entries for a single cell when `_data` flags require them. */
   private _copyCellMapsFrom(src: BufferLine, srcCol: number, destCol: number): void {
     const srcStart = srcCol * Constants.CELL_INDICIES;

package/src/common/buffer/Types.ts

@@ -131,8 +131,8 @@ export interface IBufferLine {
   resize(cols: number, fill: ICellData): boolean;
   cleanupMemory(): number;
   fill(fillCellData: ICellData, respectProtect?: boolean): void;
-  copyFrom(line: IBufferLine): void;
-  clone(): IBufferLine;
+  copyFrom(line: IBufferLine, blank?: boolean): void;
+  clone(blank?: boolean): IBufferLine;
   getTrimmedLength(): number;
   getNoBgTrimmedLength(): number;
   translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string;

package/src/common/services/BufferService.ts

@@ -86,12 +86,12 @@ export class BufferService extends Disposable implements IBufferService {
       // Insert the line using the fastest method
       if (bottomRow === buffer.lines.length - 1) {
         if (willBufferBeTrimmed) {
-          buffer.lines.recycle().copyFrom(newLine);
+          buffer.lines.recycle().copyFrom(newLine, true);
         } else {
-          buffer.lines.push(newLine.clone());
+          buffer.lines.push(newLine.clone(true));
         }
       } else {
-        buffer.lines.splice(bottomRow + 1, 0, newLine.clone());
+        buffer.lines.splice(bottomRow + 1, 0, newLine.clone(true));
       }
 
       // Only adjust ybase and ydisp when the buffer is not trimmed
@@ -113,7 +113,7 @@ export class BufferService extends Disposable implements IBufferService {
       // scrollback, instead we can just shift them in-place.
       const scrollRegionHeight = bottomRow - topRow + 1 /* as it's zero-based */;
       buffer.lines.shiftElements(topRow + 1, scrollRegionHeight - 1, -1);
-      buffer.lines.set(bottomRow, newLine.clone());
+      buffer.lines.set(bottomRow, newLine.clone(true));
     }
 
     // Move the viewport to the bottom of the buffer unless the user is

package/src/common/services/DecorationService.ts

@@ -214,7 +214,7 @@ export class DecorationLineCache extends Disposable {
   }
 
   private _handleBufferLinesTrim(amount: number): void {
-    if (amount <= 0) {
+    if (amount <= 0 || !this._decorationsByLine.size) {
       return;
     }
     const newMap = new Map<number, IInternalDecoration[]>();

package/src/common/buffer/BufferLineStringCache.ts

@@ -1,69 +0,0 @@
-/**
- * Copyright (c) 2026 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import type { IBufferLineStringCache, IBufferLineStringCacheEntry } from './BufferLine';
-import { disposableTimeout } from '../Async';
-import { Disposable, MutableDisposable, toDisposable, type IDisposable } from '../Lifecycle';
-
-const enum Constants {
-  CACHE_TTL_MS = 15000
-}
-
-export class BufferLineStringCache extends Disposable implements IBufferLineStringCache {
-  public generation: number = 0;
-  public readonly entries: Set<IBufferLineStringCacheEntry> = new Set();
-  private readonly _clearTimeout = this._register(new MutableDisposable<IDisposable>());
-  private _lastAccessTimestamp: number = 0;
-
-  constructor() {
-    super();
-    this._register(toDisposable(() => this.entries.clear()));
-  }
-
-  public touch(): void {
-    this._scheduleClear();
-  }
-
-  public allocateEntry(): IBufferLineStringCacheEntry {
-    const entry: IBufferLineStringCacheEntry = {
-      value: undefined,
-      isTrimmed: false,
-      generation: this.generation
-    };
-    this.entries.add(entry);
-    this._scheduleClear();
-    return entry;
-  }
-
-  public clear(): void {
-    this._clearTimeout.clear();
-    this._lastAccessTimestamp = 0;
-    this.generation++;
-    for (const entry of this.entries) {
-      entry.value = undefined;
-      entry.isTrimmed = false;
-    }
-    this.entries.clear();
-  }
-
-  private _scheduleClear(): void {
-    this._lastAccessTimestamp = Date.now();
-    if (this._clearTimeout.value) {
-      return;
-    }
-    this._scheduleClearTimeout(Constants.CACHE_TTL_MS);
-  }
-
-  private _scheduleClearTimeout(timeoutMs: number): void {
-    this._clearTimeout.value = disposableTimeout(() => {
-      const elapsed = Date.now() - this._lastAccessTimestamp;
-      if (elapsed >= Constants.CACHE_TTL_MS) {
-        this.clear();
-        return;
-      }
-      this._scheduleClearTimeout(Constants.CACHE_TTL_MS - elapsed);
-    }, timeoutMs);
-  }
-}