@xterm/xterm 6.1.0-beta.302 → 6.1.0-beta.304

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xterm/xterm",
   "description": "Full xterm terminal, in your browser",
-  "version": "6.1.0-beta.302",
+  "version": "6.1.0-beta.304",
   "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": "d6cfe3db5dfdbfd2a08c3f9bcfcde8a283aa479d"
+  "commit": "c58ea3637f3968e0e6e79cd92cf9aace7ef89ee2"
 }

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/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.302';
+export const XTERM_VERSION = '6.1.0-beta.304';

package/src/common/buffer/AttributeData.ts

@@ -139,6 +139,7 @@ export class AttributeData implements IAttributeData {
  */
 export class ExtendedAttrs implements IExtendedAttrs {
   private _ext: number = 0;
+  public payload: Object | undefined;
   public get ext(): number {
     if (this._urlId) {
       return (
@@ -207,6 +208,6 @@ export class ExtendedAttrs implements IExtendedAttrs {
    * that needs to be persistant in the buffer.
    */
   public isEmpty(): boolean {
-    return this.underlineStyle === UnderlineStyle.NONE && this._urlId === 0;
+    return this.underlineStyle === UnderlineStyle.NONE && this._urlId === 0 && this.payload === undefined;
   }
 }

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();
+const $extended = DEFAULT_ATTR_DATA.extended.clone() as IExtendedAttrsExt;
 
-export interface IBufferLineStringCacheEntry {
-  value: string | undefined;
-  isTrimmed: boolean;
-  generation: number;
-}
-
-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];
@@ -210,21 +208,30 @@ export class BufferLine implements IBufferLine {
     } else {
       cell.combinedData = '';
     }
-    if (cell.bg & BgFlags.HAS_EXTENDED) {
-      cell.extended = this._extendedAttrs[index]!;
-    } 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();
-    }
+    cell.extended = this.getExtended(index);
     return cell;
   }
 
+  public getExtended(index: number): IExtendedAttrs {
+    $startIndex = index * Constants.CELL_INDICIES;
+    if (this._data[$startIndex + Cell.BG] & BgFlags.HAS_EXTENDED) {
+      return this._extendedAttrs[index]!;
+    }
+    // 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).
+    // We use $extended as blueprint and reset the internals
+    // mimicking the ctor to avoid a new allocation.
+    $extended._ext = 0;
+    $extended._urlId = 0;
+    $extended.payload = undefined;
+    return $extended;
+  }
+
   /**
    * 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 +249,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 +266,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 +293,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 +321,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 +348,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 +388,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 +448,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 +466,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 +474,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 +520,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 +554,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 +571,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 +587,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

@@ -20,6 +20,7 @@ export interface IExtendedAttrs {
   underlineColor: number;
   underlineVariantOffset: number;
   urlId: number;
+  payload: Object | undefined;
   clone(): IExtendedAttrs;
   isEmpty(): boolean;
 }
@@ -131,8 +132,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;
@@ -146,6 +147,7 @@ export interface IBufferLine {
   getCodePoint(index: number): number;
   isCombined(index: number): number;
   getString(index: number): string;
+  getExtended(index: number): IExtendedAttrs;
 }
 
 export interface IMarker extends IDisposable {

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);
-  }
-}