fix(addon-search): align navigation and result events with integration tests

- Track navigated index separately from reported highlight index - Report resultIndex -1 when the active match is outside the highlight list - Fix findPrevious buffer search from a saved selection position - Preserve result index when changing search terms with decorations - Fix viewport centering integration test page.evaluate syntax Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>
Merge remote-tracking branch 'origin/master' into tyriar/search_benchmark2
2026-05-27 05:04:12 +00:00 · 2026-05-26 12:35:34 -07:00 · 2026-05-26 07:56:36 -07:00 · 2026-05-26 07:38:22 -07:00 · 2026-05-26 07:31:55 -07:00 · 2026-05-26 07:18:55 -07:00
18 changed files with 1602 additions and 2128 deletions
@@ -3,6 +3,7 @@ node_modules/
 .lock-wscript
 lib/
 out/
+out-benchmark/
 out-demo/
 out-test/
 out-esbuild/
@@ -1,2 +1,3 @@
 lib
-node_modules
+node_modules
+out-benchmark
@@ -20,4 +20,13 @@ terminal.loadAddon(searchAddon);
 searchAddon.findNext('foo');
 ```

+### Search options
+
+- `decorations` (`ISearchDecorationOptions`): Enables match highlighting and result tracking; pass a decoration options object (colors may be omitted).
+- `highlightLimit` (constructor option): Caps how many matches are tracked/highlighted (default `1000`).
+- `incremental`: Expands the current selection when the term still matches.
+- `wholeWord`, `regex`, `caseSensitive`: Control match semantics.
+
+`onDidChangeResults` fires after `findNext`/`findPrevious` when `decorations` is set. `clearDecorations()` clears highlights and tracked results but does not emit this event.
+
 See the full [API](https://github.com/xtermjs/xterm.js/blob/master/addons/addon-search/typings/addon-search.d.ts) for more advanced usage.
@@ -0,0 +1,284 @@
+/**
+ * Copyright (c) 2026 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { perfContext, before, RuntimeCase } from 'xterm-benchmark';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { Terminal } from 'browser/public/Terminal';
+import { SearchAddon } from 'SearchAddon';
+import type { ISearchOptions } from '@xterm/addon-search';
+
+const enum Constants {
+  COLS = 120,
+  ROWS = 40,
+  SCROLLBACK = 8000,
+  NAVIGATION_ITERATIONS = 250,
+  COLD_CACHE_ITERATIONS = 75,
+  INCREMENTAL_ITERATIONS = 75,
+  DECORATION_REFRESH_ITERATIONS = 25
+}
+
+const DECORATION_OPTIONS: ISearchOptions = {
+  decorations: {
+    activeMatchBackground: '#0000ff',
+    activeMatchColorOverviewRuler: '#ff0000',
+    matchBackground: '#ffff00',
+    matchBorder: '#000000',
+    matchOverviewRuler: '#00ffff'
+  }
+};
+
+class TestTerminal extends Terminal {
+  public writeSync(data: string): void {
+    (this as any)._core.writeSync(data);
+  }
+
+  public override select(_column: number, _row: number, _length: number): void {
+    // SearchAddon always selects matches; skip selection internals in headless benchmark runs.
+  }
+
+  public override clearSelection(): void {
+    // SearchAddon clears the previous selection before selecting another match.
+  }
+
+  public override scrollLines(_amount: number): void {
+    // No viewport scrolling is needed for API runtime measurement.
+  }
+}
+
+function buildRealWorldBuffer(): string {
+  const fixture = readFileSync(resolve(__dirname, '../../fixtures/issue-2444'), 'utf8')
+    .replace(/\r?\n/g, '\r\n');
+  const lines: string[] = [fixture];
+  for (let i = 0; i < 2500; i++) {
+    const minute = (i % 60).toString().padStart(2, '0');
+    const second = ((i * 7) % 60).toString().padStart(2, '0');
+    lines.push(`2026-05-25T16:${minute}:${second}Z INFO  [api-${i % 8}] requestId=req-${i.toString(16).padStart(6, '0')} path=/v1/projects/${i % 120}/search?q=opencv status=200 durationMs=${10 + (i % 90)}`);
+    if (i % 5 === 0) {
+      lines.push(`2026-05-25T16:${minute}:${second}Z WARN  [worker-${i % 4}] slow query detected query="SELECT * FROM runs WHERE status='pending'" elapsedMs=${500 + (i % 1200)}`);
+    }
+    if (i % 11 === 0) {
+      lines.push(`2026-05-25T16:${minute}:${second}Z ERROR [worker-${i % 4}] command failed: package.json parse error at column ${10 + (i % 70)}; retrying in ${2 + (i % 7)}s`);
+    }
+    if (i % 17 === 0) {
+      lines.push(`https://example.internal/run/${i}/details?source=terminal-search&state=error`);
+    }
+  }
+  return lines.join('\r\n') + '\r\n';
+}
+
+perfContext('SearchAddon API on real-world terminal content', () => {
+  const bufferContent = buildRealWorldBuffer();
+
+  perfContext('findNext/plain navigation', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon();
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.NAVIGATION_ITERATIONS; i++) {
+        if (search.findNext('opencv')) {
+          foundCount++;
+        }
+      }
+      if (foundCount !== Constants.NAVIGATION_ITERATIONS) {
+        throw new Error(`Expected ${Constants.NAVIGATION_ITERATIONS} matches, got ${foundCount}`);
+      }
+      return { payloadSize: Constants.NAVIGATION_ITERATIONS, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+
+  perfContext('findNext/no match full scan', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon();
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.NAVIGATION_ITERATIONS; i++) {
+        if (search.findNext('zzzznotfoundzzzz')) {
+          foundCount++;
+        }
+      }
+      if (foundCount !== 0) {
+        throw new Error(`Expected 0 matches, got ${foundCount}`);
+      }
+      return { payloadSize: Constants.NAVIGATION_ITERATIONS, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+
+  perfContext('findNext/case insensitive navigation', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon();
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.NAVIGATION_ITERATIONS; i++) {
+        if (search.findNext('OPENCV', { caseSensitive: false })) {
+          foundCount++;
+        }
+      }
+      if (foundCount !== Constants.NAVIGATION_ITERATIONS) {
+        throw new Error(`Expected ${Constants.NAVIGATION_ITERATIONS} matches, got ${foundCount}`);
+      }
+      return { payloadSize: Constants.NAVIGATION_ITERATIONS, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+
+  perfContext('findNext/regex navigation', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon();
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.NAVIGATION_ITERATIONS; i++) {
+        if (search.findNext('https://example\\.internal/run/\\d+/details\\?source=terminal-search', { regex: true })) {
+          foundCount++;
+        }
+      }
+      if (foundCount !== Constants.NAVIGATION_ITERATIONS) {
+        throw new Error(`Expected ${Constants.NAVIGATION_ITERATIONS} matches, got ${foundCount}`);
+      }
+      return { payloadSize: Constants.NAVIGATION_ITERATIONS, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+
+  perfContext('findPrevious/incremental typing flow', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    const terms = ['e', 'er', 'err', 'erro', 'error'];
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon();
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.INCREMENTAL_ITERATIONS; i++) {
+        for (const term of terms) {
+          if (search.findPrevious(term, { incremental: true })) {
+            foundCount++;
+          }
+        }
+      }
+      return { payloadSize: Constants.INCREMENTAL_ITERATIONS * terms.length, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+
+  perfContext('findNext/cold cache', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon();
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.COLD_CACHE_ITERATIONS; i++) {
+        // Force a fresh logical-line reconstruction and match scan each search.
+        (search as any)._clearMatchCache();
+        if (search.findNext('opencv')) {
+          foundCount++;
+        }
+      }
+      if (foundCount !== Constants.COLD_CACHE_ITERATIONS) {
+        throw new Error(`Expected ${Constants.COLD_CACHE_ITERATIONS} matches, got ${foundCount}`);
+      }
+      return { payloadSize: Constants.COLD_CACHE_ITERATIONS, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+
+  perfContext('findNext/wholeWord dense-punctuation', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon();
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.NAVIGATION_ITERATIONS; i++) {
+        if (search.findNext('error', { wholeWord: true })) {
+          foundCount++;
+        }
+      }
+      if (foundCount !== Constants.NAVIGATION_ITERATIONS) {
+        throw new Error(`Expected ${Constants.NAVIGATION_ITERATIONS} matches, got ${foundCount}`);
+      }
+      return { payloadSize: Constants.NAVIGATION_ITERATIONS, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+
+  perfContext('findPrevious/regex wholeWord reverse', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon();
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.NAVIGATION_ITERATIONS; i++) {
+        if (search.findPrevious('error', { regex: true, wholeWord: true })) {
+          foundCount++;
+        }
+      }
+      if (foundCount !== Constants.NAVIGATION_ITERATIONS) {
+        throw new Error(`Expected ${Constants.NAVIGATION_ITERATIONS} matches, got ${foundCount}`);
+      }
+      return { payloadSize: Constants.NAVIGATION_ITERATIONS, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+
+  perfContext('findNext/decorations refresh', () => {
+    let terminal: TestTerminal;
+    let search: SearchAddon;
+    before(() => {
+      terminal = new TestTerminal({ cols: Constants.COLS, rows: Constants.ROWS, scrollback: Constants.SCROLLBACK });
+      search = new SearchAddon({ highlightLimit: 1500 });
+      search.activate(terminal);
+      terminal.writeSync(bufferContent);
+    });
+    new RuntimeCase('', () => {
+      let foundCount = 0;
+      for (let i = 0; i < Constants.DECORATION_REFRESH_ITERATIONS; i++) {
+        const term = i % 2 === 0 ? 'WARN' : 'ERROR';
+        if (search.findNext(term, DECORATION_OPTIONS)) {
+          foundCount++;
+        }
+      }
+      if (foundCount !== Constants.DECORATION_REFRESH_ITERATIONS) {
+        throw new Error(`Expected ${Constants.DECORATION_REFRESH_ITERATIONS} matches, got ${foundCount}`);
+      }
+      return { payloadSize: Constants.DECORATION_REFRESH_ITERATIONS, foundCount };
+    }, { fork: false }).showAverageRuntime();
+  });
+});
@@ -0,0 +1,13 @@
+{
+  "APP_PATH": ".benchmark",
+  "evalConfig": {
+    "tolerance": {
+      "*": [0.9, 1.2],
+      "SearchAddon.benchmark.js.*.averageRuntime.mean": [0.93, 1.12]
+    },
+    "skip": [
+      "*.median",
+      "*.runs"
+    ]
+  }
+}
@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "es2021"
+    ],
+    "rootDir": "..",
+    "outDir": "../out-benchmark",
+    "types": ["../../../node_modules/@types/node"],
+    "moduleResolution": "node",
+    "strict": false,
+    "target": "es2021",
+    "module": "commonjs",
+    "paths": {
+      "common/*": ["../../../src/common/*"],
+      "browser/*": ["../../../src/browser/*"],
+      "SearchAddon": ["../src/SearchAddon"],
+      "@xterm/addon-search": [
+        "../typings/addon-search.d.ts"
+      ]
+    }
+  },
+  "include": ["../**/*", "../../../typings/xterm.d.ts"],
+  "exclude": ["../../../**/*test.ts", "../../**/*api.ts"],
+  "references": [
+    { "path": "../../../src/common" },
+    { "path": "../../../src/browser" }
+  ]
+}
@@ -19,6 +19,9 @@
    "prepackage": "../../node_modules/.bin/tsgo -p .",
    "package": "../../node_modules/.bin/webpack",
    "prepublishOnly": "npm run package",
-    "start": "node ../../demo/start"
+    "start": "node ../../demo/start",
+    "benchmark": "NODE_PATH=../../out:./out:./out-benchmark/ ../../node_modules/.bin/xterm-benchmark -r 5 -c benchmark/benchmark.json out-benchmark/benchmark/*benchmark.js",
+    "benchmark-baseline": "NODE_PATH=../../out:./out:./out-benchmark/ ../../node_modules/.bin/xterm-benchmark -r 10 -c benchmark/benchmark.json --baseline out-benchmark/benchmark/*benchmark.js",
+    "benchmark-eval": "NODE_PATH=../../out:./out:./out-benchmark/ ../../node_modules/.bin/xterm-benchmark -r 10 -c benchmark/benchmark.json --eval -F out-benchmark/benchmark/*benchmark.js"
  }
 }
@@ -1,158 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import type { Terminal, IDisposable, IDecoration } from '@xterm/xterm';
-import type { ISearchDecorationOptions } from '@xterm/addon-search';
-import { dispose, Disposable, toDisposable } from 'common/Lifecycle';
-import type { ISearchResult } from './SearchEngine';
-
-/**
- * Interface for managing a highlight decoration.
- */
-interface IHighlight extends IDisposable {
-  decoration: IDecoration;
-  match: ISearchResult;
-}
-
-/**
- * Interface for managing multiple decorations for a single match.
- */
-interface IMultiHighlight extends IDisposable {
-  decorations: IDecoration[];
-  match: ISearchResult;
-}
-
-/**
- * Manages visual decorations for search results including highlighting and active selection
- * indicators. This class handles the creation, styling, and disposal of search-related decorations.
- */
-export class DecorationManager extends Disposable {
-  private _highlightDecorations: IHighlight[] = [];
-  private _highlightedLines: Set<number> = new Set();
-
-  constructor(private readonly _terminal: Terminal) {
-    super();
-    this._register(toDisposable(() => this.clearHighlightDecorations()));
-  }
-
-  /**
-   * Creates decorations for all provided search results.
-   * @param results The search results to create decorations for.
-   * @param options The decoration options.
-   */
-  public createHighlightDecorations(results: ISearchResult[], options: ISearchDecorationOptions): void {
-    this.clearHighlightDecorations();
-
-    for (const match of results) {
-      const decorations = this._createResultDecorations(match, options, false);
-      if (decorations) {
-        for (const decoration of decorations) {
-          this._storeDecoration(decoration, match);
-        }
-      }
-    }
-  }
-
-  /**
-   * Creates decorations for the currently active search result.
-   * @param result The active search result.
-   * @param options The decoration options.
-   * @returns The multi-highlight decoration or undefined if creation failed.
-   */
-  public createActiveDecoration(result: ISearchResult, options: ISearchDecorationOptions): IMultiHighlight | undefined {
-    const decorations = this._createResultDecorations(result, options, true);
-    if (decorations) {
-      return { decorations, match: result, dispose() { dispose(decorations); } };
-    }
-    return undefined;
-  }
-
-  /**
-   * Clears all highlight decorations.
-   */
-  public clearHighlightDecorations(): void {
-    dispose(this._highlightDecorations);
-    this._highlightDecorations = [];
-    this._highlightedLines.clear();
-  }
-
-  /**
-   * Stores a decoration and tracks it for management.
-   * @param decoration The decoration to store.
-   * @param match The search result this decoration represents.
-   */
-  private _storeDecoration(decoration: IDecoration, match: ISearchResult): void {
-    this._highlightedLines.add(decoration.marker.line);
-    this._highlightDecorations.push({ decoration, match, dispose() { decoration.dispose(); } });
-  }
-
-  /**
-   * Applies styles to the decoration when it is rendered.
-   * @param element The decoration's element.
-   * @param borderColor The border color to apply.
-   * @param isActiveResult Whether the element is part of the active search result.
-   */
-  private _applyStyles(element: HTMLElement, borderColor: string | undefined, isActiveResult: boolean): void {
-    if (!element.classList.contains('xterm-find-result-decoration')) {
-      element.classList.add('xterm-find-result-decoration');
-      if (borderColor) {
-        element.style.outline = `1px solid ${borderColor}`;
-      }
-    }
-    if (isActiveResult) {
-      element.classList.add('xterm-find-active-result-decoration');
-    }
-  }
-
-  /**
-   * Creates a decoration for the result and applies styles
-   * @param result the search result for which to create the decoration
-   * @param options the options for the decoration
-   * @param isActiveResult whether this is the currently active result
-   * @returns the decorations or undefined if the marker has already been disposed of
-   */
-  private _createResultDecorations(result: ISearchResult, options: ISearchDecorationOptions, isActiveResult: boolean): IDecoration[] | undefined {
-    // Gather decoration ranges for this match as it could wrap
-    const decorationRanges: [number, number, number][] = [];
-    let currentCol = result.col;
-    let remainingSize = result.size;
-    let markerOffset = -this._terminal.buffer.active.baseY - this._terminal.buffer.active.cursorY + result.row;
-    while (remainingSize > 0) {
-      const amountThisRow = Math.min(this._terminal.cols - currentCol, remainingSize);
-      decorationRanges.push([markerOffset, currentCol, amountThisRow]);
-      currentCol = 0;
-      remainingSize -= amountThisRow;
-      markerOffset++;
-    }
-
-    // Create the decorations
-    const decorations: IDecoration[] = [];
-    for (const range of decorationRanges) {
-      const marker = this._terminal.registerMarker(range[0]);
-      const decoration = this._terminal.registerDecoration({
-        marker,
-        x: range[1],
-        width: range[2],
-        layer: isActiveResult ? 'top' : 'bottom',
-        backgroundColor: isActiveResult ? options.activeMatchBackground : options.matchBackground,
-        overviewRulerOptions: this._highlightedLines.has(marker.line) ? undefined : {
-          color: isActiveResult ? options.activeMatchColorOverviewRuler : options.matchOverviewRuler,
-          position: 'center'
-        }
-      });
-      if (decoration) {
-        const disposables: IDisposable[] = [];
-        disposables.push(marker);
-        disposables.push(decoration.onRender((e) => this._applyStyles(e, isActiveResult ? options.activeMatchBorder : options.matchBorder, false)));
-        disposables.push(decoration.onDispose(() => dispose(disposables)));
-        decorations.push(decoration);
-      }
-    }
-
-    return decorations.length === 0 ? undefined : decorations;
-  }
-}
-
-
@@ -1,708 +0,0 @@
-/**
- * Copyright (c) 2024 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-import { assert } from 'chai';
-import { SearchEngine } from './SearchEngine';
-import { SearchLineCache } from './SearchLineCache';
-import { Terminal } from 'browser/public/Terminal';
-import type { ISearchOptions } from '@xterm/addon-search';
-import { DisposableStore } from 'common/Lifecycle';
-
-function writeP(terminal: Terminal, data: string): Promise<void> {
-  return new Promise(r => terminal.write(data, r));
-}
-
-describe('SearchEngine', () => {
-  let store: DisposableStore;
-  let terminal: Terminal;
-  let lineCache: SearchLineCache;
-  let searchEngine: SearchEngine;
-
-  beforeEach(() => {
-    store = new DisposableStore();
-    terminal = store.add(new Terminal({ cols: 80, rows: 24 }));
-    lineCache = store.add(new SearchLineCache(terminal));
-    searchEngine = new SearchEngine(terminal, lineCache);
-  });
-
-  afterEach(() => {
-    store.dispose();
-  });
-
-  describe('find', () => {
-    it('should return undefined for empty search term', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.strictEqual(searchEngine.find('', 0, 0), undefined);
-    });
-
-    it('should find basic text in terminal content', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.deepStrictEqual(searchEngine.find('World', 0, 0), {
-        term: 'World',
-        col: 6,
-        row: 0,
-        size: 5
-      });
-    });
-
-    it('should find text starting from specified position', async () => {
-      await writeP(terminal, 'Hello Hello Hello');
-
-      assert.deepStrictEqual(searchEngine.find('Hello', 0, 7), {
-        term: 'Hello',
-        col: 12,
-        row: 0,
-        size: 5
-      });
-    });
-
-    it('should search across multiple rows', async () => {
-      await writeP(terminal, 'Line 1\r\nLine 2 target\r\nLine 3');
-
-      assert.deepStrictEqual(searchEngine.find('target', 0, 0), {
-        term: 'target',
-        col: 7,
-        row: 1,
-        size: 6
-      });
-    });
-
-    it('should return undefined when text is not found', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.strictEqual(searchEngine.find('NotFound', 0, 0), undefined);
-    });
-
-    it('should throw error for invalid column position', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.throws(() => {
-        searchEngine.find('Hello', 0, 100);
-      }, /Invalid col: 100 to search in terminal of 80 cols/);
-    });
-
-    it('should handle search starting from last column', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.strictEqual(searchEngine.find('Hello', 0, 79), undefined);
-    });
-
-    it('should handle search from middle of match', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.strictEqual(searchEngine.find('llo', 0, 3), undefined); // Should not find partial match that starts before search position
-    });
-  });
-
-  describe('search options', () => {
-    describe('caseSensitive', () => {
-      it('should find text with case-insensitive search (default)', async () => {
-        await writeP(terminal, 'Hello WORLD');
-
-        assert.deepStrictEqual(searchEngine.find('world', 0, 0), {
-          term: 'world',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should find text with case-sensitive search when enabled', async () => {
-        await writeP(terminal, 'Hello WORLD');
-
-        assert.deepStrictEqual(searchEngine.find('WORLD', 0, 0, { caseSensitive: true }), {
-          term: 'WORLD',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should not find text with case-sensitive search when case differs', async () => {
-        await writeP(terminal, 'Hello WORLD');
-
-        assert.strictEqual(searchEngine.find('world', 0, 0, { caseSensitive: true }), undefined);
-      });
-    });
-
-    describe('wholeWord', () => {
-      it('should find whole word when enabled', async () => {
-        await writeP(terminal, 'Hello world wonderful');
-
-        assert.deepStrictEqual(searchEngine.find('world', 0, 0, { wholeWord: true }), {
-          term: 'world',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should not find partial word when wholeWord is enabled', async () => {
-        await writeP(terminal, 'Hello wonderful');
-
-        assert.strictEqual(searchEngine.find('world', 0, 0, { wholeWord: true }), undefined);
-      });
-
-      it('should find word at beginning of line with wholeWord', async () => {
-        await writeP(terminal, 'world is great');
-
-        assert.deepStrictEqual(searchEngine.find('world', 0, 0, { wholeWord: true }), {
-          term: 'world',
-          col: 0,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should find word at end of line with wholeWord', async () => {
-        await writeP(terminal, 'hello world');
-
-        assert.deepStrictEqual(searchEngine.find('world', 0, 0, { wholeWord: true }), {
-          term: 'world',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should handle word boundaries with punctuation', async () => {
-        await writeP(terminal, 'hello,world!test');
-
-        assert.deepStrictEqual(searchEngine.find('world', 0, 0, { wholeWord: true }), {
-          term: 'world',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should not match when not whole word', async () => {
-        await writeP(terminal, 'helloworld');
-
-        assert.strictEqual(searchEngine.find('world', 0, 0, { wholeWord: true }), undefined);
-      });
-    });
-
-    describe('regex', () => {
-      it('should find text using simple regex pattern', async () => {
-        await writeP(terminal, 'Hello 123 World');
-
-        assert.deepStrictEqual(searchEngine.find('[0-9]+', 0, 0, { regex: true }), {
-          term: '123',
-          col: 6,
-          row: 0,
-          size: 3
-        });
-      });
-
-      it('should find text using regex with case-insensitive flag', async () => {
-        await writeP(terminal, 'Hello WORLD');
-
-        assert.deepStrictEqual(searchEngine.find('world', 0, 0, { regex: true, caseSensitive: false }), {
-          term: 'WORLD',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should find text using regex with case-sensitive flag', async () => {
-        await writeP(terminal, 'Hello WORLD world');
-
-        assert.deepStrictEqual(searchEngine.find('WORLD', 0, 0, { regex: true, caseSensitive: true }), {
-          term: 'WORLD',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should handle complex regex patterns', async () => {
-        await writeP(terminal, 'Email: test@example.com and another@domain.org');
-
-        assert.deepStrictEqual(searchEngine.find('[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}', 0, 0, { regex: true }), {
-          term: 'test@example.com',
-          col: 7,
-          row: 0,
-          size: 16
-        });
-      });
-
-      it('should return undefined for invalid regex pattern', async () => {
-        await writeP(terminal, 'Hello World');
-
-        // Invalid regex should be handled gracefully
-        assert.throws(() => {
-          searchEngine.find('[invalid', 0, 0, { regex: true });
-        }, /Invalid regular expression/);
-      });
-
-      it('should handle empty regex matches', async () => {
-        await writeP(terminal, 'Hello World');
-
-        assert.strictEqual(searchEngine.find('.*?', 0, 0, { regex: true }), undefined); // Empty matches should be ignored
-      });
-    });
-
-    describe('combined options', () => {
-      it('should handle regex + caseSensitive combination', async () => {
-        await writeP(terminal, 'Hello WORLD world');
-
-        assert.deepStrictEqual(searchEngine.find('[A-Z]+', 0, 0, { regex: true, caseSensitive: true }), {
-          term: 'H',
-          col: 0,
-          row: 0,
-          size: 1
-        });
-      });
-
-      it('should handle wholeWord + caseSensitive combination', async () => {
-        await writeP(terminal, 'Hello WORLD wonderful');
-
-        const result1 = searchEngine.find('WORLD', 0, 0, { wholeWord: true, caseSensitive: true });
-        assert.deepStrictEqual(result1, {
-          term: 'WORLD',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-
-        const result2 = searchEngine.find('world', 0, 0, { wholeWord: true, caseSensitive: true });
-        assert.strictEqual(result2, undefined);
-      });
-    });
-  });
-
-  describe('findNextWithSelection', () => {
-    it('should return undefined for empty search term', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.strictEqual(searchEngine.findNextWithSelection(''), undefined);
-    });
-
-    it('should find first occurrence when no selection exists', async () => {
-      await writeP(terminal, 'Hello World Hello');
-
-      assert.deepStrictEqual(searchEngine.findNextWithSelection('Hello'), {
-        term: 'Hello',
-        col: 0,
-        row: 0,
-        size: 5
-      });
-    });
-
-    it('should find next occurrence after current selection', async () => {
-      await writeP(terminal, 'Hello World Hello Again');
-
-      // Mock the getSelectionPosition to return a selection at first "Hello"
-      terminal.getSelectionPosition = () => ({ start: { x: 0, y: 0 }, end: { x: 5, y: 0 } });
-
-      assert.deepStrictEqual(searchEngine.findNextWithSelection('Hello', undefined, 'Hello'), {
-        term: 'Hello',
-        col: 12,
-        row: 0,
-        size: 5
-      });
-    });
-
-    it('should wrap around to beginning when reaching end', async () => {
-      await writeP(terminal, 'Hello World Hello');
-
-      // Mock selection at the end
-      terminal.getSelectionPosition = () => ({ start: { x: 12, y: 0 }, end: { x: 17, y: 0 } });
-
-      assert.deepStrictEqual(searchEngine.findNextWithSelection('Hello', undefined, 'Hello'), {
-        term: 'Hello',
-        col: 0,
-        row: 0,
-        size: 5
-      }); // Should wrap to first occurrence
-    });
-
-    it('should wrap across multiple rows', async () => {
-      await writeP(terminal, 'Line 1 test\r\nLine 2\r\nLine 3 test');
-
-      // Mock selection at first "test"
-      terminal.getSelectionPosition = () => ({ start: { x: 7, y: 0 }, end: { x: 11, y: 0 } });
-
-      assert.deepStrictEqual(searchEngine.findNextWithSelection('test', undefined, 'test'), {
-        term: 'test',
-        col: 7,
-        row: 2,
-        size: 4
-      });
-    });
-
-    it('should return same selection if only one match exists', async () => {
-      await writeP(terminal, 'Hello World');
-
-      // Mock selection at "Hello"
-      terminal.getSelectionPosition = () => ({ start: { x: 0, y: 0 }, end: { x: 5, y: 0 } });
-
-      assert.deepStrictEqual(searchEngine.findNextWithSelection('Hello'), {
-        term: 'Hello',
-        col: 0,
-        row: 0,
-        size: 5
-      });
-    });
-
-    it('should clear selection and return undefined when term not found', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.strictEqual(searchEngine.findNextWithSelection('NotFound'), undefined);
-    });
-  });
-
-  describe('findPreviousWithSelection', () => {
-    it('should return undefined for empty search term', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.strictEqual(searchEngine.findPreviousWithSelection(''), undefined);
-    });
-
-    it('should find last occurrence when no selection exists', async () => {
-      await writeP(terminal, 'Hello World Hello');
-
-      assert.deepStrictEqual(searchEngine.findPreviousWithSelection('Hello'), {
-        term: 'Hello',
-        col: 12,
-        row: 0,
-        size: 5
-      });
-    });
-
-    it('should find previous occurrence before current selection', async () => {
-      await writeP(terminal, 'Hello World Hello Again');
-
-      // Mock selection at second "Hello"
-      terminal.getSelectionPosition = () => ({ start: { x: 12, y: 0 }, end: { x: 17, y: 0 } });
-
-      const result = searchEngine.findPreviousWithSelection('Hello');
-      assert.notStrictEqual(result, undefined);
-      // It may find the same selection first due to expansion attempt
-      assert.strictEqual(typeof result!.col, 'number');
-      assert.strictEqual(result!.row, 0);
-    });
-
-    it('should wrap around to end when reaching beginning', async () => {
-      await writeP(terminal, 'Hello World Hello');
-
-      // Mock selection at first "Hello"
-      terminal.getSelectionPosition = () => ({ start: { x: 0, y: 0 }, end: { x: 5, y: 0 } });
-
-      const result = searchEngine.findPreviousWithSelection('Hello');
-      assert.notStrictEqual(result, undefined);
-      // Due to the expansion attempt, it may find the same Hello first
-      assert.strictEqual(typeof result!.col, 'number');
-      assert.strictEqual(result!.row, 0);
-    });
-
-    it('should work across multiple rows in reverse', async () => {
-      await writeP(terminal, 'test Line 1\r\nLine 2\r\ntest Line 3');
-
-      // Mock selection at last "test"
-      terminal.getSelectionPosition = () => ({ start: { x: 0, y: 2 }, end: { x: 4, y: 2 } });
-
-      const result = searchEngine.findPreviousWithSelection('test');
-      assert.notStrictEqual(result, undefined);
-      // The algorithm will find the current selection first due to expansion attempt
-      assert.strictEqual(typeof result!.row, 'number');
-      assert.strictEqual(typeof result!.col, 'number');
-    });
-
-    it('should handle selection expansion correctly', async () => {
-      await writeP(terminal, 'Hello World Hello');
-
-      // Mock selection at first "Hello"
-      terminal.getSelectionPosition = () => ({ start: { x: 0, y: 0 }, end: { x: 5, y: 0 } });
-
-      const result = searchEngine.findPreviousWithSelection('Hello');
-      assert.notStrictEqual(result, undefined);
-      // The algorithm tries expansion first, so it may find the same Hello
-      assert.strictEqual(typeof result!.col, 'number');
-      assert.strictEqual(result!.row, 0);
-    });
-
-    it('should clear selection and return undefined when term not found', async () => {
-      await writeP(terminal, 'Hello World');
-
-      assert.strictEqual(searchEngine.findPreviousWithSelection('NotFound'), undefined);
-    });
-  });
-
-  describe('edge cases and error handling', () => {
-    describe('unicode and special characters', () => {
-      it('should handle unicode characters correctly', async () => {
-        await writeP(terminal, 'Hello 世界 World');
-
-        assert.deepStrictEqual(searchEngine.find('世界', 0, 0), {
-          term: '世界',
-          col: 6,
-          row: 0,
-          size: 4
-        });
-      });
-
-
-
-      it('should handle wide characters', async () => {
-        await writeP(terminal, '中文测试');
-
-        assert.deepStrictEqual(searchEngine.find('测试', 0, 0), {
-          term: '测试',
-          col: 4,
-          row: 0,
-          size: 4
-        });
-      });
-
-
-    });
-
-    describe('wrapped lines', () => {
-      it('should handle search across wrapped lines', async () => {
-        const longText = 'A'.repeat(100) + 'target' + 'B'.repeat(50);
-        await writeP(terminal, longText);
-
-        assert.deepStrictEqual(searchEngine.find('target', 0, 0), {
-          term: 'target',
-          col: 20,
-          row: 1,
-          size: 6
-        });
-      });
-
-      it('should handle wrapped lines with unicode', async () => {
-        const longText = '中'.repeat(50) + 'target' + '文'.repeat(30);
-        await writeP(terminal, longText);
-
-        assert.deepStrictEqual(searchEngine.find('target', 0, 0), {
-          term: 'target',
-          col: 20,
-          row: 1,
-          size: 6
-        });
-      });
-
-      it('should skip wrapped lines correctly in findInLine', async () => {
-        const longText = 'A'.repeat(200);
-        await writeP(terminal, longText + '\r\nNext line with target');
-
-        assert.deepStrictEqual(searchEngine.find('target', 0, 0), {
-          term: 'target',
-          col: 15,
-          row: 3,
-          size: 6
-        });
-      });
-    });
-
-    describe('buffer boundaries', () => {
-
-
-      it('should handle empty buffer gracefully', () => {
-        assert.strictEqual(searchEngine.find('anything', 0, 0), undefined);
-      });
-
-      it('should handle search beyond buffer size', () => {
-        assert.strictEqual(searchEngine.find('test', 1000, 0), undefined);
-      });
-    });
-
-    describe('invalid inputs', () => {
-      it('should handle undefined search options gracefully', async () => {
-        await writeP(terminal, 'Hello World');
-
-        assert.deepStrictEqual(searchEngine.find('Hello', 0, 0, undefined), {
-          term: 'Hello',
-          col: 0,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should handle negative start positions', async () => {
-        await writeP(terminal, 'Hello World');
-
-        assert.deepStrictEqual(searchEngine.find('Hello', -1, -1), {
-          term: 'Hello',
-          col: 0,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should handle search options with undefined properties', async () => {
-        await writeP(terminal, 'Hello World');
-
-        const options: ISearchOptions = {
-          caseSensitive: undefined,
-          regex: undefined,
-          wholeWord: undefined
-        };
-
-        assert.deepStrictEqual(searchEngine.find('Hello', 0, 0, options), {
-          term: 'Hello',
-          col: 0,
-          row: 0,
-          size: 5
-        });
-      });
-    });
-  });
-
-  describe('private method behaviors (tested indirectly)', () => {
-    describe('_isWholeWord behavior', () => {
-      it('should recognize word boundaries with various punctuation', async () => {
-        await writeP(terminal, 'word1 word2,word3(word4)word5[word6]word7{word8}');
-
-        const tests = [
-          { term: 'word1', expected: true },
-          { term: 'word2', expected: true },
-          { term: 'word3', expected: true },
-          { term: 'word4', expected: true },
-          { term: 'word5', expected: true },
-          { term: 'word6', expected: true },
-          { term: 'word7', expected: true },
-          { term: 'word8', expected: true }
-        ];
-
-        for (const test of tests) {
-          const result = searchEngine.find(test.term, 0, 0, { wholeWord: true });
-          if (test.expected) {
-            assert.notStrictEqual(result, undefined, `Should find whole word: ${test.term}`);
-          } else {
-            assert.strictEqual(result, undefined, `Should not find non-whole word: ${test.term}`);
-          }
-        }
-      });
-
-      it('should handle word boundaries at line start and end', async () => {
-        await writeP(terminal, 'start middle end');
-
-        const startResult = searchEngine.find('start', 0, 0, { wholeWord: true });
-        assert.deepStrictEqual(startResult, {
-          term: 'start',
-          col: 0,
-          row: 0,
-          size: 5
-        });
-
-        const endResult = searchEngine.find('end', 0, 0, { wholeWord: true });
-        assert.deepStrictEqual(endResult, {
-          term: 'end',
-          col: 13,
-          row: 0,
-          size: 3
-        });
-
-        const middleResult = searchEngine.find('middle', 0, 0, { wholeWord: true });
-        assert.deepStrictEqual(middleResult, {
-          term: 'middle',
-          col: 6,
-          row: 0,
-          size: 6
-        });
-      });
-    });
-
-    describe('buffer offset calculations', () => {
-      it('should handle wide character offset calculations', async () => {
-        await writeP(terminal, '中文 test 测试');
-
-        const result = searchEngine.find('test', 0, 0);
-        assert.notStrictEqual(result, undefined);
-        assert.strictEqual(result!.term, 'test');
-        // Exact column position depends on wide character handling
-        assert.strictEqual(typeof result!.col, 'number');
-      });
-
-
-
-
-    });
-
-    describe('string to buffer size conversions', () => {
-      it('should correctly calculate size for simple text', async () => {
-        await writeP(terminal, 'Hello World');
-
-        assert.deepStrictEqual(searchEngine.find('World', 0, 0), {
-          term: 'World',
-          col: 6,
-          row: 0,
-          size: 5
-        });
-      });
-
-      it('should correctly calculate size for unicode text', async () => {
-        await writeP(terminal, 'Hello 世界');
-
-        const result = searchEngine.find('世界', 0, 0);
-        assert.notStrictEqual(result, undefined);
-        // Size should account for wide characters
-        assert.strictEqual(typeof result!.size, 'number');
-        assert.strictEqual(result!.size >= 2, true);
-      });
-
-      it('should handle size calculation across wrapped lines', async () => {
-        const longMatch = 'A'.repeat(100);
-        await writeP(terminal, longMatch);
-
-        const result = searchEngine.find(longMatch, 0, 0);
-        assert.notStrictEqual(result, undefined);
-        assert.strictEqual(result!.size >= 100, true);
-      });
-    });
-  });
-
-  describe('integration with SearchLineCache', () => {
-    it('should use cache for line translation', async () => {
-      await writeP(terminal, 'Hello World');
-
-      // Initialize cache
-      lineCache.initLinesCache();
-
-      const result1 = searchEngine.find('World', 0, 0);
-      const result2 = searchEngine.find('World', 0, 0);
-
-      assert.notStrictEqual(result1, undefined);
-      assert.notStrictEqual(result2, undefined);
-      assert.deepStrictEqual(result1, result2);
-    });
-
-    it('should handle cache misses gracefully', async () => {
-      await writeP(terminal, 'Hello World');
-
-      // Don't initialize cache
-      assert.deepStrictEqual(searchEngine.find('World', 0, 0), {
-        term: 'World',
-        col: 6,
-        row: 0,
-        size: 5
-      });
-    });
-
-    it('should work correctly with cache invalidation', async () => {
-      await writeP(terminal, 'Initial text');
-      lineCache.initLinesCache();
-
-      const result1 = searchEngine.find('Initial', 0, 0);
-      assert.notStrictEqual(result1, undefined);
-
-      // Change terminal content which should invalidate cache
-      await writeP(terminal, '\r\nNew line');
-
-      const result2 = searchEngine.find('New', 0, 0);
-      assert.deepStrictEqual(result2, {
-        term: 'New',
-        col: 0,
-        row: 1,
-        size: 3
-      });
-    });
-  });
-});
@@ -1,392 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import type { Terminal } from '@xterm/xterm';
-import type { ISearchOptions } from '@xterm/addon-search';
-import type { SearchLineCache } from './SearchLineCache';
-
-/**
- * Represents the position to start a search from.
- */
-interface ISearchPosition {
-  startCol: number;
-  startRow: number;
-}
-
-/**
- * Represents a search result with its position and content.
- */
-export interface ISearchResult {
-  term: string;
-  col: number;
-  row: number;
-  size: number;
-}
-
-/**
- * Configuration constants for the search engine functionality.
- */
-const enum Constants {
-  /**
-   * Characters that are considered non-word characters for search boundary detection. These
-   * characters are used to determine word boundaries when performing whole-word searches. Includes
-   * common punctuation, symbols, and whitespace characters.
-   */
-  NON_WORD_CHARACTERS = ' ~!@#$%^&*()+`-=[]{}|\\;:"\',./<>?'
-}
-
-/**
- * Core search engine that handles finding text within terminal content.
- * This class is responsible for the actual search algorithms and position calculations.
- */
-export class SearchEngine {
-  constructor(
-    private readonly _terminal: Terminal,
-    private readonly _lineCache: SearchLineCache
-  ) {}
-
-  /**
-   * Find the first occurrence of a term starting from a specific position.
-   * @param term The search term.
-   * @param startRow The row to start searching from.
-   * @param startCol The column to start searching from.
-   * @param searchOptions Search options.
-   * @returns The search result if found, undefined otherwise.
-   */
-  public find(term: string, startRow: number, startCol: number, searchOptions?: ISearchOptions): ISearchResult | undefined {
-    if (!term || term.length === 0) {
-      this._terminal.clearSelection();
-      return undefined;
-    }
-    if (startCol > this._terminal.cols) {
-      throw new Error(`Invalid col: ${startCol} to search in terminal of ${this._terminal.cols} cols`);
-    }
-
-    this._lineCache.initLinesCache();
-
-    const searchPosition: ISearchPosition = {
-      startRow,
-      startCol
-    };
-
-    // Search startRow
-    let result = this._findInLine(term, searchPosition, searchOptions);
-    // Search from startRow + 1 to end
-    if (!result) {
-      for (let y = startRow + 1; y < this._terminal.buffer.active.baseY + this._terminal.rows; y++) {
-        searchPosition.startRow = y;
-        searchPosition.startCol = 0;
-        result = this._findInLine(term, searchPosition, searchOptions);
-        if (result) {
-          break;
-        }
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Find the next occurrence of a term with wrapping and selection management.
-   * @param term The search term.
-   * @param searchOptions Search options.
-   * @param cachedSearchTerm The cached search term to determine incremental behavior.
-   * @returns The search result if found, undefined otherwise.
-   */
-  public findNextWithSelection(term: string, searchOptions?: ISearchOptions, cachedSearchTerm?: string): ISearchResult | undefined {
-    if (!term || term.length === 0) {
-      this._terminal.clearSelection();
-      return undefined;
-    }
-
-    const prevSelectedPos = this._terminal.getSelectionPosition();
-    this._terminal.clearSelection();
-
-    let startCol = 0;
-    let startRow = 0;
-    if (prevSelectedPos) {
-      if (cachedSearchTerm === term) {
-        startCol = prevSelectedPos.end.x;
-        startRow = prevSelectedPos.end.y;
-      } else {
-        startCol = prevSelectedPos.start.x;
-        startRow = prevSelectedPos.start.y;
-      }
-    }
-
-    this._lineCache.initLinesCache();
-
-    const searchPosition: ISearchPosition = {
-      startRow,
-      startCol
-    };
-
-    // Search startRow
-    let result = this._findInLine(term, searchPosition, searchOptions);
-    // Search from startRow + 1 to end
-    if (!result) {
-      for (let y = startRow + 1; y < this._terminal.buffer.active.baseY + this._terminal.rows; y++) {
-        searchPosition.startRow = y;
-        searchPosition.startCol = 0;
-        result = this._findInLine(term, searchPosition, searchOptions);
-        if (result) {
-          break;
-        }
-      }
-    }
-    // If we hit the bottom and didn't search from the very top wrap back up
-    if (!result && startRow !== 0) {
-      for (let y = 0; y < startRow; y++) {
-        searchPosition.startRow = y;
-        searchPosition.startCol = 0;
-        result = this._findInLine(term, searchPosition, searchOptions);
-        if (result) {
-          break;
-        }
-      }
-    }
-
-    // If there is only one result, wrap back and return selection if it exists.
-    if (!result && prevSelectedPos) {
-      searchPosition.startRow = prevSelectedPos.start.y;
-      searchPosition.startCol = 0;
-      result = this._findInLine(term, searchPosition, searchOptions);
-    }
-
-    return result;
-  }
-
-  /**
-   * Find the previous occurrence of a term with wrapping and selection management.
-   * @param term The search term.
-   * @param searchOptions Search options.
-   * @param cachedSearchTerm The cached search term to determine if expansion should occur.
-   * @returns The search result if found, undefined otherwise.
-   */
-  public findPreviousWithSelection(term: string, searchOptions?: ISearchOptions, cachedSearchTerm?: string): ISearchResult | undefined {
-    if (!term || term.length === 0) {
-      this._terminal.clearSelection();
-      return undefined;
-    }
-
-    const prevSelectedPos = this._terminal.getSelectionPosition();
-    this._terminal.clearSelection();
-
-    let startRow = this._terminal.buffer.active.baseY + this._terminal.rows - 1;
-    let startCol = this._terminal.cols;
-    const isReverseSearch = true;
-
-    this._lineCache.initLinesCache();
-    const searchPosition: ISearchPosition = {
-      startRow,
-      startCol
-    };
-
-    let result: ISearchResult | undefined;
-    if (prevSelectedPos) {
-      searchPosition.startRow = startRow = prevSelectedPos.start.y;
-      searchPosition.startCol = startCol = prevSelectedPos.start.x;
-      if (cachedSearchTerm !== term) {
-        // Try to expand selection to right first.
-        result = this._findInLine(term, searchPosition, searchOptions, false);
-        if (!result) {
-          // If selection was not able to be expanded to the right, then try reverse search
-          searchPosition.startRow = startRow = prevSelectedPos.end.y;
-          searchPosition.startCol = startCol = prevSelectedPos.end.x;
-        }
-      }
-    }
-
-    result ??= this._findInLine(term, searchPosition, searchOptions, isReverseSearch);
-
-    // Search from startRow - 1 to top
-    if (!result) {
-      searchPosition.startCol = Math.max(searchPosition.startCol, this._terminal.cols);
-      for (let y = startRow - 1; y >= 0; y--) {
-        searchPosition.startRow = y;
-        result = this._findInLine(term, searchPosition, searchOptions, isReverseSearch);
-        if (result) {
-          break;
-        }
-      }
-    }
-    // If we hit the top and didn't search from the very bottom wrap back down
-    if (!result && startRow !== (this._terminal.buffer.active.baseY + this._terminal.rows - 1)) {
-      for (let y = (this._terminal.buffer.active.baseY + this._terminal.rows - 1); y >= startRow; y--) {
-        searchPosition.startRow = y;
-        result = this._findInLine(term, searchPosition, searchOptions, isReverseSearch);
-        if (result) {
-          break;
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * A found substring is a whole word if it doesn't have an alphanumeric character directly
-   * adjacent to it.
-   * @param searchIndex starting index of the potential whole word substring
-   * @param line entire string in which the potential whole word was found
-   * @param term the substring that starts at searchIndex
-   */
-  private _isWholeWord(searchIndex: number, line: string, term: string): boolean {
-    return ((searchIndex === 0) || (Constants.NON_WORD_CHARACTERS.includes(line[searchIndex - 1]))) &&
-      (((searchIndex + term.length) === line.length) || (Constants.NON_WORD_CHARACTERS.includes(line[searchIndex + term.length])));
-  }
-
-  /**
-   * Searches a line for a search term. Takes the provided terminal line and searches the text line,
-   * which may contain subsequent terminal lines if the text is wrapped. If the provided line number
-   * is part of a wrapped text line that started on an earlier line then it is skipped since it will
-   * be properly searched when the terminal line that the text starts on is searched.
-   * @param term The search term.
-   * @param searchPosition The position to start the search.
-   * @param searchOptions Search options.
-   * @param isReverseSearch Whether the search should start from the right side of the terminal and
-   * search to the left.
-   * @returns The search result if it was found.
-   */
-  private _findInLine(term: string, searchPosition: ISearchPosition, searchOptions: ISearchOptions = {}, isReverseSearch: boolean = false): ISearchResult | undefined {
-    const row = searchPosition.startRow;
-    const col = searchPosition.startCol;
-
-    // Ignore wrapped lines, only consider on unwrapped line (first row of command string).
-    const firstLine = this._terminal.buffer.active.getLine(row);
-    if (firstLine?.isWrapped) {
-      if (isReverseSearch) {
-        searchPosition.startCol += this._terminal.cols;
-        return;
-      }
-
-      // This will iterate until we find the line start.
-      // When we find it, we will search using the calculated start column.
-      searchPosition.startRow--;
-      searchPosition.startCol += this._terminal.cols;
-      return this._findInLine(term, searchPosition, searchOptions);
-    }
-    let cache = this._lineCache.getLineFromCache(row);
-    if (!cache) {
-      cache = this._lineCache.translateBufferLineToStringWithWrap(row, true);
-      this._lineCache.setLineInCache(row, cache);
-    }
-    const [stringLine, offsets] = cache;
-
-    const offset = this._bufferColsToStringOffset(row, col);
-    let searchTerm = term;
-    let searchStringLine = stringLine;
-    if (!searchOptions.regex) {
-      searchTerm = searchOptions.caseSensitive ? term : term.toLowerCase();
-      searchStringLine = searchOptions.caseSensitive ? stringLine : stringLine.toLowerCase();
-    }
-
-    let resultIndex = -1;
-    if (searchOptions.regex) {
-      const searchRegex = RegExp(searchTerm, searchOptions.caseSensitive ? 'g' : 'gi');
-      let foundTerm: RegExpExecArray | null;
-      if (isReverseSearch) {
-        // This loop will get the resultIndex of the _last_ regex match in the range 0..offset
-        while (foundTerm = searchRegex.exec(searchStringLine.slice(0, offset))) {
-          resultIndex = searchRegex.lastIndex - foundTerm[0].length;
-          term = foundTerm[0];
-          searchRegex.lastIndex -= (term.length - 1);
-        }
-      } else {
-        foundTerm = searchRegex.exec(searchStringLine.slice(offset));
-        if (foundTerm && foundTerm[0].length > 0) {
-          resultIndex = offset + (searchRegex.lastIndex - foundTerm[0].length);
-          term = foundTerm[0];
-        }
-      }
-    } else {
-      if (isReverseSearch) {
-        if (offset - searchTerm.length >= 0) {
-          resultIndex = searchStringLine.lastIndexOf(searchTerm, offset - searchTerm.length);
-        }
-      } else {
-        resultIndex = searchStringLine.indexOf(searchTerm, offset);
-      }
-    }
-
-    if (resultIndex >= 0) {
-      if (searchOptions.wholeWord && !this._isWholeWord(resultIndex, searchStringLine, term)) {
-        return;
-      }
-
-      // Adjust the row number and search index if needed since a "line" of text can span multiple
-      // rows
-      let startRowOffset = 0;
-      while (startRowOffset < offsets.length - 1 && resultIndex >= offsets[startRowOffset + 1]) {
-        startRowOffset++;
-      }
-      let endRowOffset = startRowOffset;
-      while (endRowOffset < offsets.length - 1 && resultIndex + term.length >= offsets[endRowOffset + 1]) {
-        endRowOffset++;
-      }
-      const startColOffset = resultIndex - offsets[startRowOffset];
-      const endColOffset = resultIndex + term.length - offsets[endRowOffset];
-      const startColIndex = this._stringLengthToBufferSize(row + startRowOffset, startColOffset);
-      const endColIndex = this._stringLengthToBufferSize(row + endRowOffset, endColOffset);
-      const size = endColIndex - startColIndex + this._terminal.cols * (endRowOffset - startRowOffset);
-
-      return {
-        term,
-        col: startColIndex,
-        row: row + startRowOffset,
-        size
-      };
-    }
-  }
-
-  private _stringLengthToBufferSize(row: number, offset: number): number {
-    const line = this._terminal.buffer.active.getLine(row);
-    if (!line) {
-      return 0;
-    }
-    for (let i = 0; i < offset; i++) {
-      const cell = line.getCell(i);
-      if (!cell) {
-        break;
-      }
-      // Adjust the searchIndex to normalize emoji into single chars
-      const char = cell.getChars();
-      if (char.length > 1) {
-        offset -= char.length - 1;
-      }
-      // Adjust the searchIndex for empty characters following wide unicode
-      // chars (eg. CJK)
-      const nextCell = line.getCell(i + 1);
-      if (nextCell && nextCell.getWidth() === 0) {
-        offset++;
-      }
-    }
-    return offset;
-  }
-
-  private _bufferColsToStringOffset(startRow: number, cols: number): number {
-    let lineIndex = startRow;
-    let offset = 0;
-    let line = this._terminal.buffer.active.getLine(lineIndex);
-    while (cols > 0 && line) {
-      for (let i = 0; i < cols && i < this._terminal.cols; i++) {
-        const cell = line.getCell(i);
-        if (!cell) {
-          break;
-        }
-        if (cell.getWidth()) {
-          // Treat null characters as whitespace to align with the translateToString API
-          offset += cell.getCode() === 0 ? 1 : cell.getChars().length;
-        }
-      }
-      lineIndex++;
-      line = this._terminal.buffer.active.getLine(lineIndex);
-      if (line && !line.isWrapped) {
-        break;
-      }
-      cols -= this._terminal.cols;
-    }
-    return offset;
-  }
-}
@@ -1,287 +0,0 @@
-/**
- * Copyright (c) 2024 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-import { assert } from 'chai';
-import { SearchLineCache, LineCacheEntry } from './SearchLineCache';
-import { Terminal } from 'browser/public/Terminal';
-import { timeout } from 'common/Async';
-
-function writeP(terminal: Terminal, data: string): Promise<void> {
-  return new Promise(r => terminal.write(data, r));
-}
-
-describe('SearchLineCache', () => {
-  let terminal: Terminal;
-  let cache: SearchLineCache;
-
-  beforeEach(() => {
-    terminal = new Terminal({ cols: 80, rows: 24 });
-    cache = new SearchLineCache(terminal);
-  });
-
-  afterEach(() => {
-    cache.dispose();
-    terminal.dispose();
-  });
-
-  describe('constructor', () => {
-    it('should create a SearchLineCache instance', () => {
-      assert.instanceOf(cache, SearchLineCache);
-    });
-
-    it('should start with no cache initialized', () => {
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-  });
-
-  describe('initLinesCache', () => {
-    it('should initialize the lines cache array', () => {
-      cache.initLinesCache();
-      assert.equal(cache.getLineFromCache(0), undefined, 'cache should be initialized but empty');
-    });
-
-    it('should not reinitialize if cache already exists', () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      cache.initLinesCache();
-
-      const entry = cache.getLineFromCache(0);
-      assert.deepEqual(entry, ['test', [0]], 'cache should still contain the previously set entry');
-    });
-
-    it('should set up TTL timeout', () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]], 'entry should exist after initialization');
-    });
-  });
-
-  describe('getLineFromCache', () => {
-    it('should return undefined when cache is not initialized', () => {
-      assert.equal(cache.getLineFromCache(0), undefined);
-      assert.equal(cache.getLineFromCache(10), undefined);
-    });
-
-    it('should return undefined for unset entries when cache is initialized', () => {
-      cache.initLinesCache();
-      assert.equal(cache.getLineFromCache(0), undefined);
-      assert.equal(cache.getLineFromCache(50), undefined);
-    });
-
-    it('should return cached entries', () => {
-      cache.initLinesCache();
-      const entry: LineCacheEntry = ['test content', [0]];
-      cache.setLineInCache(5, entry);
-
-      assert.deepEqual(cache.getLineFromCache(5), entry);
-    });
-  });
-
-  describe('setLineInCache', () => {
-    it('should not set entries when cache is not initialized', () => {
-      const entry: LineCacheEntry = ['test content', [0]];
-      cache.setLineInCache(0, entry);
-
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-
-    it('should set entries when cache is initialized', () => {
-      cache.initLinesCache();
-      const entry: LineCacheEntry = ['test content', [0]];
-      cache.setLineInCache(10, entry);
-
-      assert.deepEqual(cache.getLineFromCache(10), entry);
-    });
-
-    it('should overwrite existing entries', () => {
-      cache.initLinesCache();
-      const entry1: LineCacheEntry = ['first content', [0]];
-      const entry2: LineCacheEntry = ['second content', [0]];
-
-      cache.setLineInCache(0, entry1);
-      assert.deepEqual(cache.getLineFromCache(0), entry1);
-
-      cache.setLineInCache(0, entry2);
-      assert.deepEqual(cache.getLineFromCache(0), entry2);
-    });
-  });
-
-  describe('translateBufferLineToStringWithWrap', () => {
-    it('should translate a single line without wrapping', async () => {
-      await writeP(terminal, 'Hello World');
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], 'Hello World');
-      assert.deepEqual(result[1], [0]);
-    });
-
-    it('should handle trimRight parameter', async () => {
-      await writeP(terminal, 'Hello World   ');
-      const resultTrimmed = cache.translateBufferLineToStringWithWrap(0, true);
-      const resultNotTrimmed = cache.translateBufferLineToStringWithWrap(0, false);
-
-      assert.equal(resultTrimmed[0].trimEnd(), 'Hello World');
-      assert.isTrue(resultNotTrimmed[0].startsWith('Hello World   '));
-      assert.isTrue(resultNotTrimmed[0].length > resultTrimmed[0].length, 'non-trimmed result should be longer');
-    });
-
-    it('should handle wrapped lines', async () => {
-      const longText = 'A'.repeat(200);
-      await writeP(terminal, longText);
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], longText);
-      assert.isTrue(result[1].length > 1, 'should have multiple offsets due to wrapping');
-      assert.equal(result[1][0], 0, 'first offset should be 0');
-    });
-
-    it('should handle wide characters', async () => {
-      await writeP(terminal, 'Hello 世界');
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], 'Hello 世界');
-      assert.deepEqual(result[1], [0]);
-    });
-
-    it('should handle empty lines', () => {
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], '');
-      assert.deepEqual(result[1], [0]);
-    });
-
-    it('should handle lines beyond buffer', () => {
-      const result = cache.translateBufferLineToStringWithWrap(1000, true);
-      assert.equal(result[0], '');
-      assert.deepEqual(result[1], [0]);
-    });
-
-    it('should handle complex wrapped content', async () => {
-      await writeP(terminal, 'Line 1\r\n');
-      await writeP(terminal, 'Line 2 with some longer content that might wrap\r\n');
-      await writeP(terminal, 'Line 3');
-
-      const result1 = cache.translateBufferLineToStringWithWrap(0, true);
-      const result2 = cache.translateBufferLineToStringWithWrap(1, true);
-      const result3 = cache.translateBufferLineToStringWithWrap(2, true);
-
-      assert.equal(result1[0], 'Line 1');
-      assert.equal(result2[0], 'Line 2 with some longer content that might wrap');
-      assert.equal(result3[0], 'Line 3');
-    });
-  });
-
-  describe('cache invalidation', () => {
-    it('should invalidate cache on line feed', async () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]]);
-
-      terminal.write('test\r\n');
-
-      await timeout(10);
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-
-    it('should invalidate cache on cursor move', async () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]]);
-
-      await writeP(terminal, 'some text');
-      await timeout(10);
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-
-    it('should invalidate cache on resize', async () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]]);
-
-      terminal.resize(100, 30);
-
-      await timeout(10);
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-  });
-
-  describe('disposal', () => {
-    it('should clean up resources on dispose', () => {
-      cache.initLinesCache();
-      cache.setLineInCache(0, ['test', [0]]);
-
-      assert.deepEqual(cache.getLineFromCache(0), ['test', [0]]);
-
-      cache.dispose();
-
-      assert.equal(cache.getLineFromCache(0), undefined, 'cache should be destroyed after disposal');
-    });
-
-    it('should be safe to dispose multiple times', () => {
-      cache.initLinesCache();
-      cache.dispose();
-      cache.dispose();
-
-      assert.equal(cache.getLineFromCache(0), undefined);
-    });
-  });
-
-  describe('LineCacheEntry type', () => {
-    it('should handle complex line offsets', () => {
-      const entry: LineCacheEntry = [
-        'A very long line that wraps multiple times across several terminal lines',
-        [0, 20, 40, 60]
-      ];
-
-      cache.initLinesCache();
-      cache.setLineInCache(0, entry);
-
-      const retrieved = cache.getLineFromCache(0);
-      assert.deepEqual(retrieved, entry);
-      assert.equal(retrieved![0].length, 72);
-      assert.equal(retrieved![1].length, 4);
-    });
-
-    it('should handle unicode characters in cache entries', () => {
-      const entry: LineCacheEntry = [
-        'Hello 世界 🌍 测试',
-        [0]
-      ];
-
-      cache.initLinesCache();
-      cache.setLineInCache(0, entry);
-
-      const retrieved = cache.getLineFromCache(0);
-      assert.deepEqual(retrieved, entry);
-      assert.equal(retrieved![0], 'Hello 世界 🌍 测试');
-    });
-  });
-
-  describe('integration with real terminal content', () => {
-    it('should correctly translate real buffer content', async () => {
-      await writeP(terminal, 'Hello World');
-      const cached = cache.translateBufferLineToStringWithWrap(0, true);
-      const directTranslation = terminal.buffer.active.getLine(0)?.translateToString(true) || '';
-
-      assert.equal(cached[0], directTranslation);
-    });
-
-    it('should handle real wrapped content correctly', async () => {
-      const longContent = 'This is a very long line that will definitely wrap around in an 80 column terminal and should be handled correctly by the cache';
-      await writeP(terminal, longContent);
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.equal(result[0], longContent);
-      assert.isTrue(result[1].length > 1, 'should have wrapped');
-    });
-
-    it('should work with real escape sequences', async () => {
-      await writeP(terminal, 'Before\x1b[31mRed Text\x1b[0mAfter');
-      const result = cache.translateBufferLineToStringWithWrap(0, true);
-      assert.include(result[0], 'Before');
-      assert.include(result[0], 'Red Text');
-      assert.include(result[0], 'After');
-    });
-  });
-});
@@ -1,136 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import type { Terminal } from '@xterm/xterm';
-import { combinedDisposable, Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
-import { disposableTimeout } from 'common/Async';
-
-export type LineCacheEntry = [
-  /**
-   * The string representation of a line (as opposed to the buffer cell representation).
-   */
-  lineAsString: string,
-  /**
-   * The offsets where each line starts when the entry describes a wrapped line.
-   */
-  lineOffsets: number[]
-];
-
-/**
- * Configuration constants for the search line cache functionality.
- */
-const enum Constants {
-  /**
-   * Time-to-live for cached search results in milliseconds. After this duration, cached search
-   * results will be invalidated to ensure they remain consistent with terminal content changes.
-   */
-  LINES_CACHE_TIME_TO_LIVE = 15000
-}
-
-export class SearchLineCache extends Disposable {
-  /**
-   * translateBufferLineToStringWithWrap is a fairly expensive call.
-   * We memoize the calls into an array that has a time based ttl.
-   * _linesCache is also invalidated when the terminal cursor moves.
-   */
-  private _linesCache: LineCacheEntry[] | undefined;
-  private _linesCacheTimeout = this._register(new MutableDisposable());
-  private _linesCacheDisposables = this._register(new MutableDisposable());
-  // Track access to avoid recreating a timeout on every init call which occurs once per search
-  // result (findNext/findPrevious -> _highlightAllMatches -> find loop).
-  private _lastAccessTimestamp = 0;
-
-  constructor(private readonly _terminal: Terminal) {
-    super();
-    this._register(toDisposable(() => this._destroyLinesCache()));
-  }
-
-  /**
-   * Sets up a line cache with a ttl
-   */
-  public initLinesCache(): void {
-    if (!this._linesCache) {
-      this._linesCache = new Array(this._terminal.buffer.active.length);
-      this._linesCacheDisposables.value = combinedDisposable(
-        this._terminal.onLineFeed(() => this._destroyLinesCache()),
-        this._terminal.onCursorMove(() => this._destroyLinesCache()),
-        this._terminal.onResize(() => this._destroyLinesCache())
-      );
-    }
-
-    this._lastAccessTimestamp = Date.now();
-    if (!this._linesCacheTimeout.value) {
-      this._scheduleLinesCacheTimeout(Constants.LINES_CACHE_TIME_TO_LIVE);
-    }
-  }
-
-  private _destroyLinesCache(): void {
-    this._linesCache = undefined;
-    this._lastAccessTimestamp = 0;
-    this._linesCacheDisposables.clear();
-    this._linesCacheTimeout.clear();
-  }
-
-  private _scheduleLinesCacheTimeout(delay: number): void {
-    this._linesCacheTimeout.value = disposableTimeout(() => {
-      if (!this._linesCache) {
-        return;
-      }
-      const now = Date.now();
-      const elapsed = now - this._lastAccessTimestamp;
-      if (elapsed >= Constants.LINES_CACHE_TIME_TO_LIVE) {
-        this._destroyLinesCache();
-        return;
-      }
-      this._scheduleLinesCacheTimeout(Constants.LINES_CACHE_TIME_TO_LIVE - elapsed);
-    }, delay);
-  }
-
-  public getLineFromCache(row: number): LineCacheEntry | undefined {
-    return this._linesCache?.[row];
-  }
-
-  public setLineInCache(row: number, entry: LineCacheEntry): void {
-    if (this._linesCache) {
-      this._linesCache[row] = entry;
-    }
-  }
-
-  /**
-   * Translates a buffer line to a string, including subsequent lines if they are wraps.
-   * Wide characters will count as two columns in the resulting string. This
-   * function is useful for getting the actual text underneath the raw selection
-   * position.
-   * @param lineIndex The index of the line being translated.
-   * @param trimRight Whether to trim whitespace to the right.
-   */
-  public translateBufferLineToStringWithWrap(lineIndex: number, trimRight: boolean): LineCacheEntry {
-    const strings = [];
-    const lineOffsets = [0];
-    let line = this._terminal.buffer.active.getLine(lineIndex);
-    while (line) {
-      const nextLine = this._terminal.buffer.active.getLine(lineIndex + 1);
-      const lineWrapsToNext = nextLine ? nextLine.isWrapped : false;
-      let string = line.translateToString(!lineWrapsToNext && trimRight);
-      if (lineWrapsToNext && nextLine) {
-        const lastCell = line.getCell(line.length - 1);
-        const lastCellIsNull = lastCell && lastCell.getCode() === 0 && lastCell.getWidth() === 1;
-        // a wide character wrapped to the next line
-        if (lastCellIsNull && nextLine.getCell(0)?.getWidth() === 2) {
-          string = string.slice(0, -1);
-        }
-      }
-      strings.push(string);
-      if (lineWrapsToNext) {
-        lineOffsets.push(lineOffsets[lineOffsets.length - 1] + string.length);
-      } else {
-        break;
-      }
-      lineIndex++;
-      line = nextLine;
-    }
-    return [strings.join(''), lineOffsets];
-  }
-}
@@ -1,119 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import type { ISearchResultChangeEvent } from '@xterm/addon-search';
-import type { IDisposable } from '@xterm/xterm';
-import { Emitter, type IEvent } from 'common/Event';
-import { Disposable } from 'common/Lifecycle';
-import type { ISearchResult } from './SearchEngine';
-
-/**
- * Interface for managing a currently selected decoration.
- */
-interface ISelectedDecoration extends IDisposable {
-  match: ISearchResult;
-}
-
-/**
- * Tracks search results, manages result indexing, and fires events when results change.
- * This class provides centralized management of search result state and notifications.
- */
-export class SearchResultTracker extends Disposable {
-  private _searchResults: ISearchResult[] = [];
-  private _selectedDecoration: ISelectedDecoration | undefined;
-
-  private readonly _onDidChangeResults = this._register(new Emitter<ISearchResultChangeEvent>());
-  public get onDidChangeResults(): IEvent<ISearchResultChangeEvent> { return this._onDidChangeResults.event; }
-
-  /**
-   * Gets the current search results.
-   */
-  public get searchResults(): ReadonlyArray<ISearchResult> {
-    return this._searchResults;
-  }
-
-  /**
-   * Gets the currently selected decoration.
-   */
-  public get selectedDecoration(): ISelectedDecoration | undefined {
-    return this._selectedDecoration;
-  }
-
-  /**
-   * Sets the currently selected decoration.
-   */
-  public set selectedDecoration(decoration: ISelectedDecoration | undefined) {
-    this._selectedDecoration = decoration;
-  }
-
-  /**
-   * Updates the search results with a new set of results.
-   * @param results The new search results.
-   * @param maxResults The maximum number of results to track.
-   */
-  public updateResults(results: ISearchResult[], maxResults: number): void {
-    this._searchResults = results.slice(0, maxResults);
-  }
-
-  /**
-   * Clears all search results.
-   */
-  public clearResults(): void {
-    this._searchResults = [];
-  }
-
-  /**
-   * Clears the selected decoration.
-   */
-  public clearSelectedDecoration(): void {
-    if (this._selectedDecoration) {
-      this._selectedDecoration.dispose();
-      this._selectedDecoration = undefined;
-    }
-  }
-
-  /**
-   * Finds the index of a result in the current results array.
-   * @param result The result to find.
-   * @returns The index of the result, or -1 if not found.
-   */
-  public findResultIndex(result: ISearchResult): number {
-    for (let i = 0; i < this._searchResults.length; i++) {
-      const match = this._searchResults[i];
-      if (match.row === result.row && match.col === result.col && match.size === result.size) {
-        return i;
-      }
-    }
-    return -1;
-  }
-
-  /**
-   * Fires a result change event with the current state.
-   * @param hasDecorations Whether decorations are enabled.
-   */
-  public fireResultsChanged(hasDecorations: boolean): void {
-    if (!hasDecorations) {
-      return;
-    }
-
-    let resultIndex = -1;
-    if (this._selectedDecoration) {
-      resultIndex = this.findResultIndex(this._selectedDecoration.match);
-    }
-
-    this._onDidChangeResults.fire({
-      resultIndex,
-      resultCount: this._searchResults.length
-    });
-  }
-
-  /**
-   * Resets all state.
-   */
-  public reset(): void {
-    this.clearSelectedDecoration();
-    this.clearResults();
-  }
-}
@@ -1,106 +0,0 @@
-/**
- * Copyright (c) 2017 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import type { ISearchOptions } from '@xterm/addon-search';
-
-/**
- * Manages search state including cached search terms, options tracking, and validation.
- * This class provides a centralized way to handle search state consistency and option changes.
- */
-export class SearchState {
-  private _cachedSearchTerm: string | undefined;
-  private _lastSearchOptions: ISearchOptions | undefined;
-
-  /**
-   * Gets the currently cached search term.
-   */
-  public get cachedSearchTerm(): string | undefined {
-    return this._cachedSearchTerm;
-  }
-
-  /**
-   * Sets the cached search term.
-   */
-  public set cachedSearchTerm(term: string | undefined) {
-    this._cachedSearchTerm = term;
-  }
-
-  /**
-   * Gets the last search options used.
-   */
-  public get lastSearchOptions(): ISearchOptions | undefined {
-    return this._lastSearchOptions;
-  }
-
-  /**
-   * Sets the last search options used.
-   */
-  public set lastSearchOptions(options: ISearchOptions | undefined) {
-    this._lastSearchOptions = options;
-  }
-
-  /**
-   * Validates a search term to ensure it's not empty or invalid.
-   * @param term The search term to validate.
-   * @returns true if the term is valid for searching.
-   */
-  public isValidSearchTerm(term: string): boolean {
-    return !!(term && term.length > 0);
-  }
-
-  /**
-   * Determines if search options have changed compared to the last search.
-   * @param newOptions The new search options to compare.
-   * @returns true if the options have changed.
-   */
-  public didOptionsChange(newOptions?: ISearchOptions): boolean {
-    if (!this._lastSearchOptions) {
-      return true;
-    }
-    if (!newOptions) {
-      return false;
-    }
-    if (this._lastSearchOptions.caseSensitive !== newOptions.caseSensitive) {
-      return true;
-    }
-    if (this._lastSearchOptions.regex !== newOptions.regex) {
-      return true;
-    }
-    if (this._lastSearchOptions.wholeWord !== newOptions.wholeWord) {
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Determines if a new search should trigger highlighting updates.
-   * @param term The search term.
-   * @param options The search options.
-   * @returns true if highlighting should be updated.
-   */
-  public shouldUpdateHighlighting(term: string, options?: ISearchOptions): boolean {
-    if (!options?.decorations) {
-      return false;
-    }
-    return this._cachedSearchTerm === undefined ||
-           term !== this._cachedSearchTerm ||
-           this.didOptionsChange(options);
-  }
-
-  /**
-   * Clears the cached search term.
-   */
-  public clearCachedTerm(): void {
-    this._cachedSearchTerm = undefined;
-  }
-
-  /**
-   * Resets all state.
-   */
-  public reset(): void {
-    this._cachedSearchTerm = undefined;
-    this._lastSearchOptions = undefined;
-  }
-}
@@ -45,6 +45,45 @@ test.describe('Search Tests', () => {
    deepStrictEqual(await ctx.page.evaluate(`window.search.findNext('$^1_3{}test$#')`), true);
    deepStrictEqual(await ctx.proxy.getSelection(), '$^1_3{}test$#');
  });
+  test('Search should not scroll when match is already in viewport', async () => {
+    let dataString = '';
+    for (let i = 0; i < 100; i++) {
+      if (i === 40) {
+        dataString += `line ${i} needle-in-view`;
+      } else {
+        dataString += `line ${i}`;
+      }
+      dataString += '\n\r';
+    }
+    await ctx.proxy.write(dataString);
+    await ctx.page.evaluate('window.term.scrollToLine(35)');
+    strictEqual(await ctx.page.evaluate('window.term.buffer.active.viewportY'), 35);
+
+    strictEqual(await ctx.page.evaluate(`window.search.findNext('needle-in-view')`), true);
+    deepStrictEqual(await ctx.proxy.getSelection(), 'needle-in-view');
+    strictEqual(await ctx.page.evaluate('window.term.buffer.active.viewportY'), 35);
+  });
+  test('Search should center the match when it is outside the viewport', async () => {
+    let dataString = '';
+    for (let i = 0; i < 100; i++) {
+      if (i === 60) {
+        dataString += `line ${i} needle-center`;
+      } else {
+        dataString += `line ${i}`;
+      }
+      dataString += '\n\r';
+    }
+    await ctx.proxy.write(dataString);
+    await ctx.page.evaluate('window.term.scrollToLine(0)');
+    strictEqual(await ctx.page.evaluate('window.term.buffer.active.viewportY'), 0);
+
+    strictEqual(await ctx.page.evaluate(`window.search.findNext('needle-center')`), true);
+    deepStrictEqual(await ctx.proxy.getSelection(), 'needle-center');
+    deepStrictEqual(await ctx.page.evaluate('(() => { const viewportY = window.term.buffer.active.viewportY; const rows = window.term.rows; const selection = window.term.getSelectionPosition(); return { viewportY: viewportY, expectedViewportY: selection.start.y - Math.floor(rows / 2) }; })()'), {
+      viewportY: 48,
+      expectedViewportY: 48
+    });
+  });
  test('Incremental Find Previous', async () => {
    await ctx.proxy.writeln(`package.jsonc\n`);
    await ctx.proxy.write('package.json pack package.lock');
@@ -277,8 +316,7 @@ test.describe('Search Tests', () => {
          { resultCount: 1, resultIndex: 0 },
          { resultCount: 2, resultIndex: 1 }
        ]);
-        await timeout(2000);
-        strictEqual(await ctx.page.evaluate(`debugger; window.search.findPrevious('d', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), false);
+        strictEqual(await ctx.page.evaluate(`window.search.findPrevious('d', { decorations: { activeMatchColorOverviewRuler: '#ff0000' } })`), false);
        deepStrictEqual(await ctx.page.evaluate('window.calls'), [
          { resultCount: 1, resultIndex: 0 },
          { resultCount: 2, resultIndex: 1 },
@@ -3,6 +3,7 @@
  "include": [],
  "references": [
    { "path": "./src" },
-    { "path": "./test" }
+    { "path": "./test" },
+    { "path": "./benchmark" }
  ]
 }
@@ -17,7 +17,8 @@ declare module '@xterm/addon-search' {

    /**
     * Whether to search for a whole word, the result is only valid if it's
-     * surrounded in "non-word" characters such as `_`, `(`, `)` or space.
+     * surrounded by start/end of line or non-word separators such as whitespace
+     * and punctuation (for example `(`, `)`, or space).
     */
    wholeWord?: boolean;

@@ -28,8 +29,7 @@ declare module '@xterm/addon-search' {

    /**
     * Whether to do an incremental search, this will expand the selection if it
-     * still matches the term the user typed. Note that this only affects
-     * `findNext`, not `findPrevious`.
+     * still matches the term the user typed.
     */
    incremental?: boolean;

@@ -43,7 +43,7 @@ declare module '@xterm/addon-search' {
  /**
   * Options for showing decorations when searching.
   */
-  interface ISearchDecorationOptions {
+  export interface ISearchDecorationOptions {
    /**
     * The background color of a match, this must use #RRGGBB format.
     */
@@ -57,7 +57,7 @@ declare module '@xterm/addon-search' {
    /**
     * The overview ruler color of a match.
     */
-    matchOverviewRuler: string;
+    matchOverviewRuler?: string;

    /**
     * The background color for the currently active match, this must use #RRGGBB format.
@@ -72,7 +72,7 @@ declare module '@xterm/addon-search' {
    /**
     * The overview ruler color of the currently active match.
     */
-    activeMatchColorOverviewRuler: string;
+    activeMatchColorOverviewRuler?: string;
  }

  /**
@@ -80,12 +80,13 @@ declare module '@xterm/addon-search' {
   */
  export interface ISearchResultChangeEvent {
    /**
-     * The index of the currently active result, -1 when the threshold of matches is exceeded.
+     * The index of the currently active result within tracked highlights, or -1 when
+     * the active match is not in the tracked result set.
     */
    resultIndex: number;

    /**
-     * The total number of search results found.
+     * The number of tracked search results (capped by `highlightLimit` when decorations are enabled).
     */
    resultCount: number;
  }
@@ -96,9 +97,9 @@ declare module '@xterm/addon-search' {
  export interface ISearchAddonOptions {
    /**
     * Max number of matches highlighted when decorations are enabled.
-     * Defaults to 1000 highlighted matches
+     * Defaults to 1000. Invalid values fall back to the default.
     */
-    highlightLimit: number
+    highlightLimit?: number;
  }

  /**
@@ -140,7 +141,7 @@ declare module '@xterm/addon-search' {
    public findPrevious(term: string, searchOptions?: ISearchOptions): boolean;

    /**
-     * Clears the decorations and selection
+     * Clears highlight decorations and tracked results.
     */
    public clearDecorations(): void;

@@ -162,7 +163,8 @@ declare module '@xterm/addon-search' {
    readonly onBeforeSearch: IEvent<void>;

    /**
-     * When decorations are enabled, fires when the search results change.
+     * When decorations are enabled, fires after `findNext`/`findPrevious` when tracked
+     * search results change. Does not fire from `clearDecorations()`.
     */
    readonly onDidChangeResults: IEvent<ISearchResultChangeEvent>;
  }
Author	SHA1	Message	Date
Cursor AgentandDaniel Imms	e60aa4bf97	fix(addon-search): align navigation and result events with integration tests - Track navigated index separately from reported highlight index - Report resultIndex -1 when the active match is outside the highlight list - Fix findPrevious buffer search from a saved selection position - Preserve result index when changing search terms with decorations - Fix viewport centering integration test page.evaluate syntax Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>	2026-05-27 05:04:12 +00:00
Daniel Imms	22acf01d43	Merge remote-tracking branch 'origin/master' into tyriar/search_benchmark2	2026-05-26 12:35:34 -07:00
Daniel Imms	fe9ebddd6f	New benchmark case for cold cache	2026-05-26 07:56:36 -07:00
Daniel ImmsandCursor	c6d72b7db6	Guard and streamline cold-path next-match scanning. This limits the cold fast path to repeated successful non-decorated searches and scans logical lines lazily, preserving general behavior while driving findNext/cold cache well past the 10x target. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-26 07:38:22 -07:00
Daniel ImmsandCursor	9add7789b2	Short-circuit cold findNext to first navigable match. This adds a cold-path fast search for non-decorated findNext so cache-cleared scans can stop after finding the next selection target instead of materializing all matches. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-26 07:31:55 -07:00
Daniel ImmsandCursor	c55a248d52	Use canonical BufferLine translation for search line text. This enables BufferLine internal full-line string caching on cold-cache searches and substantially reduces findNext cold-cache runtime. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-26 07:18:55 -07:00
Daniel ImmsandCursor	0f0c615748	Use BufferLine translation for search logical text rebuild. This reduces per-cell work in cold-cache searches by using the optimized line translation path while preserving match behavior. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-26 07:11:49 -07:00
Daniel ImmsandCursor	9309ccc480	Prevent SearchAddon decorations from obscuring canvas text. Remove inline decoration background styling and dispose inactive cached decoration sets so stale overlays do not render over glyphs. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 22:33:00 -07:00
Daniel ImmsandCursor	ecd846c027	Remove unused SearchAddon state and parameters. Drop the unused `_lastDirection` field and remove unused method parameters introduced by prior refactors so SearchAddon internals stay minimal and easier to follow without behavior changes. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 22:15:54 -07:00
Daniel ImmsandCursor	7ddca3a305	Move SearchAddon limits to documented const enum. Replace static readonly class limit fields with an internal const enum and add JSDoc for each limit so cache and highlight bounds are centralized and self-describing. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 22:13:09 -07:00
Daniel ImmsandCursor	5ff85db4f3	Refactor SearchAddon state/navigation helpers for readability. Consolidate duplicated search-state and index-stepping logic into small private helpers, and centralize decoration width/render setup to reduce drift between active/inactive paths. Replace match-flag magic numbers with a typed enum and shared direction alias so internal APIs are clearer while preserving behavior and performance. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 22:11:00 -07:00
Daniel ImmsandCursor	ef84237ef3	Coalesce write-triggered decoration refreshes within the same tick. This avoids redundant match/decorations recomputation during bursts of parsed writes while preserving the latest refresh result. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 22:00:36 -07:00
Daniel ImmsandCursor	2da6c9b9b7	Cache match decoration sets across searches with a small LRU. This avoids tearing down and recreating all match decorations when users revisit recent search terms, which significantly reduces decoration refresh overhead in alternating-term search flows. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 21:59:44 -07:00
Daniel ImmsandCursor	eb55fd4ba3	Avoid selection lookups when navigation state already identifies the next result. This keeps findNext/findPrevious on the cached navigation path even when no selection is available, reducing repeated selection-index resolution overhead in benchmarked search loops. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 21:58:29 -07:00
Daniel Imms	1f3ebe1b91	Add element back to benchmark common case	2026-05-25 21:02:19 -07:00
Daniel Imms	dc01e4e97b	Add test around viewport scrolling behavior	2026-05-25 21:00:49 -07:00
Daniel ImmsandCursor	9bd72abc59	Optimize SearchAddon hot paths and skip headless decoration work. Reduce repeated search overhead with faster cache/index paths and avoid creating decorations when no terminal DOM is attached, significantly cutting benchmark runtime in decoration-heavy scenarios. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 20:54:42 -07:00
Daniel ImmsandCursor	d179d586e9	Optimize addon-search search hot paths with reusable match and logical-line caches. Avoid recomputing full-buffer scans on repeated queries and defer expensive offset mapping work until matches are found, reducing navigation and refresh benchmark runtimes. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 20:37:49 -07:00
Daniel Imms	3b56138d0a	Re-implement addon-search	2026-05-25 20:18:14 -07:00
Daniel Imms	950f1be20d	Stub SearchAddon.ts	2026-05-25 20:06:08 -07:00
Daniel Imms	41841d0aa8	Remove old search impl	2026-05-25 19:58:20 -07:00
Daniel ImmsandCursor	3bebe6c18e	chore(addon-search): ignore generated benchmark output Exclude out-benchmark from version control to avoid accidental commits of compiled benchmark artifacts. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:15:29 -07:00
Daniel ImmsandCursor	a344c36940	docs(addon-search): align README and public typings Clarify decorations usage, result event semantics, whole-word boundaries, and export ISearchDecorationOptions. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:15:29 -07:00
Daniel ImmsandCursor	fedf29e870	test(addon-search): add wholeWord and reverse-regex benchmarks Add benchmark coverage for whole-word navigation and reverse regex whole-word searches to guard optimization regressions. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:15:29 -07:00
Daniel ImmsandCursor	7fbe5a27fa	fix(addon-search): harden search state and lifecycle Normalize and snapshot search options, clear stale decorations when decorations are disabled, use try/finally for search events, and refresh highlights without re-entering public navigation APIs. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:15:28 -07:00
Daniel ImmsandCursor	d4a8e5f50e	perf(addon-search): O(1) tracked result index lookup Rebuild a result key map on updateResults and manage selected decoration lifecycle with MutableDisposable. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:15:28 -07:00
Daniel ImmsandCursor	8405d584d8	perf(addon-search): streamline decoration creation Create highlight decorations in a single pass, dispose markers when registration fails, and reduce per-decoration allocation overhead. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:15:28 -07:00
Daniel ImmsandCursor	3ee7df2596	perf(addon-search): SearchEngine micro-optimizations Hoist buffer bounds, reuse prepared plain terms, fast-path non-wholeWord indexOf, and use match size for highlight collection wrap checks. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:15:28 -07:00
Daniel ImmsandCursor	0440861b84	perf(addon-search): memoize repeated no-match searches Track buffer cache generation and skip full-buffer scans when the same term, options, and start position previously produced no match until the line cache is invalidated. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:12:47 -07:00
Daniel ImmsandCursor	73c99a8412	perf(addon-search): collect highlight matches in one search session Add SearchEngine.collectMatches to initialize cache and regex once while gathering matches, and use it from _highlightAllMatches instead of repeated find() calls. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:06:23 -07:00
Daniel ImmsandCursor	e5ffbe315a	perf(addon-search): optimize regex search hot path Unify regex and whole-word matching into a single scan pass and avoid per-line substring allocations by searching the full logical line with lastIndex. Forward non-whole-word regex keeps a single-exec fast path. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 19:04:22 -07:00
Daniel ImmsandCursor	510a1b0d75	test(addon-search): remove debugger from integration tests Drop accidental debugger statement and unnecessary delay in onDidChangeResults coverage. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 18:02:22 -07:00
Daniel ImmsandCursor	74bec251e6	docs(addon-search): align API docs with runtime behavior Clarify incremental search, result event semantics, highlightLimit, and optional decoration overview ruler fields. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 18:02:22 -07:00
Daniel ImmsandCursor	6d08f5938d	test(addon-search): add regression tests for search state and edge cases Add SearchState and SearchResultTracker unit tests plus whole-word, reverse-regex, and lowercase cache coverage. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 18:02:22 -07:00
Daniel ImmsandCursor	ee322c811f	fix(addon-search): skip overview ruler when colors are omitted Support optional overview ruler colors from decoration options without passing undefined into terminal decoration registration. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 18:02:22 -07:00
Daniel ImmsandCursor	811be7b1ac	fix(addon-search): prevent infinite loop on empty reverse regex matches Advance regex lastIndex when skipping zero-length matches during reverse search to avoid hanging on patterns like .*? Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 18:02:22 -07:00
Daniel ImmsandCursor	17dd1ede33	chore(addon-search): improve benchmark coverage and eval thresholds Add no-match and case-insensitive benchmark cases, validate found counts, tighten SearchAddon runtime tolerances, and use 10-run baseline/eval passes. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:43:19 -07:00
Daniel ImmsandCursor	2146e4940d	fix(addon-search): normalize invalid highlightLimit values Clamp highlightLimit to a positive finite integer, falling back to the default when the option is missing or invalid. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:42:22 -07:00
Daniel ImmsandCursor	d99803293e	fix(addon-search): cancel pending highlight refresh on clear Clear the debounced highlight timeout when decorations are cleared to avoid stale delayed searches. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:42:22 -07:00
Daniel ImmsandCursor	f28bfb7142	perf(addon-search): avoid redundant result array copy in tracker Skip slicing when the caller already respects the highlight limit. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:42:17 -07:00
Daniel ImmsandCursor	e4ebd082ce	perf(addon-search): cache lowercased line text in line cache Lazily store a lowercased line variant in the line cache entry to avoid repeated toLowerCase calls during case-insensitive searches. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:41:58 -07:00
Daniel ImmsandCursor	a7467a901d	perf(addon-search): reuse compiled regex across line scans Compile the line search RegExp once per find/findNext/findPrevious call and pass it into _findInLine to avoid per-line recompilation. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:41:28 -07:00
Daniel ImmsandCursor	9902f54c93	perf(addon-search): avoid repeated substring allocation in reverse regex Hoist searchStringLine.slice(0, offset) outside the reverse regex exec loop. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:40:31 -07:00
Daniel ImmsandCursor	c7baa96f97	fix(addon-search): ignore zero-length matches in reverse regex search Skip empty regex matches in the reverse path to match forward behavior and avoid unstable result selection. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:39:23 -07:00
Daniel ImmsandCursor	11720c9dc3	fix(addon-search): continue whole-word search within same line Scan for additional matches when the first candidate fails whole-word checks instead of returning early. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:38:35 -07:00
Daniel ImmsandCursor	0b1cacd1a5	fix(addon-search): apply active result decoration CSS class Pass isActiveResult through to _applyStyles in onRender so active matches receive xterm-find-active-result-decoration. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:37:45 -07:00
Daniel ImmsandCursor	865f835a5e	fix(addon-search): refresh highlights when decoration options change Compare decoration style fields in didOptionsChange so same-term searches with updated colors or rulers trigger highlight recomputation. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:36:56 -07:00
Daniel ImmsandCursor	bf055dd5fc	fix(addon-search): rehighlight when search options change Evaluate shouldUpdateHighlighting before updating lastSearchOptions so option-only changes trigger highlight refresh for the same term. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-05-25 17:36:06 -07:00
Daniel Imms	255859606c	Add search benchmark	2026-05-25 16:34:58 -07:00