web-doc 0.5.0 → 0.6.1

package/THIRD_PARTY_NOTICES.md

@@ -4,6 +4,7 @@ The release artifact contains or depends on the following principal components.
 
 - [`@silurus/ooxml`](https://github.com/yukiyokotani/office-open-xml-viewer) — MIT; modern Office parsing/rendering.
 - [`office_oxide`](https://github.com/yfedoseev/office_oxide) — MIT OR Apache-2.0; compound-file handling, Office IR/writer utilities and legacy XLS/PPT conversion.
+- [`Fuse.js`](https://github.com/krisk/Fuse) — Apache-2.0; fuzzy matching behind the opt-in `search()` fallback.
 - [`pdfjs-dist` / Mozilla PDF.js](https://github.com/mozilla/pdf.js) — Apache-2.0; browser PDF parsing,
   font/CMap handling, canvas rendering, and text extraction. The packaged
   standard-font, ICC, CMap, OpenJPEG, JBIG2, and QCMS assets retain the license

package/dist/contracts.d.ts

@@ -219,9 +219,9 @@ export interface ViewerEventMap {
 }
 /**
  * Tuning for the fuzzy fallback that runs when the exact search finds
- * nothing. Matching is delegated to Fuse.js: the query is compared to each
- * page's text with a bounded edit budget, so spacing, line breaks, list
- * bullets, table separators and typographic punctuation may differ from the
+ * nothing. Fuse.js selects candidate pages; a contiguous edit alignment
+ * determines the original-text boundaries with a bounded edit budget. Spacing,
+ * line breaks, list bullets, table separators and punctuation may differ from the
  * source, and every hit maps back to the verbatim page text.
  */
 export interface FuzzySearchOptions {
@@ -231,15 +231,15 @@ export interface FuzzySearchOptions {
      */
     readonly threshold?: number;
     /**
-     * Highest Fuse.js score (`0` perfect, `1` no resemblance) a page may have to
-     * count as a match. Default `0.4`; raise it to accept a passage that only
-     * partly survives on a page, such as a citation that spans a page break.
+     * Highest Fuse.js score and whole-passage edit ratio (`0` perfect, `1` no
+     * resemblance) a match may have. Default `0.4`; raise it to accept a passage
+     * that only partly survives on a page, such as one spanning a page break.
      */
     readonly maxScore?: number;
     /**
      * Query characters considered. The matcher's cost grows with the query and
      * a passage is identified well before its end, so the default `600` keeps
-     * a page under about 100 ms; the highlight covers the matched prefix.
+     * the work bounded; the highlight covers the matched prefix.
      */
     readonly maxQueryLength?: number;
     /** Characters of each page's text considered. Default `20000`. */
@@ -257,6 +257,13 @@ export interface FuzzySearchOptions {
      * hint every page in range is scanned. Default `12`.
      */
     readonly pageWindow?: number;
+    /**
+     * Run the matcher in a Web Worker that keeps the document's index, so a
+     * long scan never blocks the page and repeated citation lookups reuse the
+     * index. Falls back to the main thread where workers are unavailable or
+     * the worker script cannot be loaded. Default `true`.
+     */
+    readonly worker?: boolean;
 }
 export interface SearchOptions {
     readonly caseSensitive?: boolean;

package/dist/fuzzy-alignment.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Fuse's indices describe character masks, not a contiguous edit alignment.
+ * Refine an accepted page with semi-global Levenshtein alignment: consume the
+ * whole query, allowing free text before and after one occurrence. Tracking
+ * the start alongside each cost needs O(query length) working memory rather
+ * than a page × query traceback matrix. Equal-cost occurrences prefer the
+ * earliest end, so an unmatched character after a passage cannot extend it.
+ */
+export declare function alignFuzzyPassage(text: string, query: string, caseSensitive: boolean, maxScore: number): {
+    start: number;
+    end: number;
+} | undefined;

package/dist/fuzzy-alignment.js

@@ -0,0 +1,63 @@
+import { normalizeSearchText, normalizeWithMap } from "./search-text.js";
+/**
+ * Fuse's indices describe character masks, not a contiguous edit alignment.
+ * Refine an accepted page with semi-global Levenshtein alignment: consume the
+ * whole query, allowing free text before and after one occurrence. Tracking
+ * the start alongside each cost needs O(query length) working memory rather
+ * than a page × query traceback matrix. Equal-cost occurrences prefer the
+ * earliest end, so an unmatched character after a passage cannot extend it.
+ */
+export function alignFuzzyPassage(text, query, caseSensitive, maxScore) {
+    const source = normalizeWithMap(text, caseSensitive);
+    const pattern = normalizeSearchText(query, caseSensitive);
+    const length = pattern.length;
+    if (!length || !source.text.length)
+        return undefined;
+    const costs = new Uint32Array(length + 1);
+    const starts = new Uint32Array(length + 1);
+    for (let i = 0; i <= length; i += 1)
+        costs[i] = i;
+    let bestCost = length;
+    let bestStart = 0;
+    let bestEnd = 0;
+    for (let end = 1; end <= source.text.length; end += 1) {
+        let diagonalCost = costs[0];
+        let diagonalStart = starts[0];
+        costs[0] = 0;
+        starts[0] = end;
+        for (let i = 1; i <= length; i += 1) {
+            const previousCost = costs[i];
+            const previousStart = starts[i];
+            let cost = diagonalCost + (pattern[i - 1] === source.text[end - 1] ? 0 : 1);
+            let start = diagonalStart;
+            // Prefer dropping an unmatched query character over substituting a
+            // neighbouring source character when both alignments cost the same.
+            const deletion = costs[i - 1] + 1;
+            if (deletion <= cost) {
+                cost = deletion;
+                start = starts[i - 1];
+            }
+            const insertion = previousCost + 1;
+            if (insertion < cost) {
+                cost = insertion;
+                start = previousStart;
+            }
+            costs[i] = cost;
+            starts[i] = start;
+            diagonalCost = previousCost;
+            diagonalStart = previousStart;
+        }
+        if (costs[length] < bestCost) {
+            bestCost = costs[length];
+            bestStart = starts[length];
+            bestEnd = end;
+        }
+    }
+    // A page-level Fuse score alone can accept disconnected 32-character
+    // chunks. Require the single passage to meet the same score ceiling.
+    if (bestEnd <= bestStart || bestCost / length > maxScore)
+        return undefined;
+    const start = source.starts[bestStart];
+    const end = source.ends[bestEnd - 1];
+    return start === undefined || end === undefined ? undefined : { start, end };
+}

package/dist/fuzzy-search-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fuzzy-search-worker.js

@@ -0,0 +1,6 @@
+import { handleFuzzyWorkerRequest, } from "./fuzzy-worker-protocol.js";
+const workerScope = self;
+const state = {};
+workerScope.onmessage = (event) => {
+    workerScope.postMessage(handleFuzzyWorkerRequest(state, event.data));
+};

package/dist/fuzzy-search.d.ts

@@ -1,7 +1,8 @@
 import type { FuzzySearchOptions, SearchMatch } from "./contracts.js";
 /**
- * Fuzzy matching is delegated to Fuse.js (Bitap with a bounded edit budget per
- * 32-character chunk). It bridges the gaps NFKC + case folding leave open when
+ * Fuse.js selects candidate pages (Bitap with a bounded edit budget per
+ * 32-character chunk); contiguous alignment determines highlight boundaries.
+ * This bridges the gaps NFKC + case folding leave open when
  * a query was not copied verbatim from the document: AI-generated citations
  * and OCR'd passages differ from the source in spacing, line breaks, list
  * bullets, table separators and typographic punctuation. Every hit maps back
@@ -14,6 +15,7 @@ export interface ResolvedFuzzySearchOptions {
     readonly maxPageTextLength: number;
     readonly pagesPerBatch: number;
     readonly pageWindow: number;
+    readonly worker: boolean;
 }
 export declare const DEFAULT_FUZZY_SEARCH_OPTIONS: ResolvedFuzzySearchOptions;
 /**
@@ -28,9 +30,30 @@ export interface FuzzyPageText {
     readonly text: string;
 }
 /**
- * One match per page whose text holds the query within the edit budget: the
- * span from the first to the last matched character, so the highlight covers
- * the passage as one block. Pages are returned in page order.
+ * A document's pages, indexed once for Fuse.js so that every fuzzy search
+ * reuses the normalized records instead of rebuilding them: a citation
+ * lookup tries several anchors in a row, and each used to pay for the index
+ * again. A scan restricted to a page window reuses the same records through
+ * `Fuse.parseIndex`, so only scoring and alignment run for those pages.
+ */
+export declare class FuzzyPageIndex {
+    #private;
+    constructor(pages: readonly FuzzyPageText[], options: {
+        threshold: number;
+        maxPageTextLength: number;
+    }, caseSensitive?: boolean);
+    get pageCount(): number;
+    /**
+     * One match per page whose text holds the query within the edit budget:
+     * the best contiguous alignment, so neighbouring text and repeated
+     * occurrences cannot expand the highlight. `pageIndices` restricts the scan;
+     * the result is in page order either way.
+     */
+    search(query: string, maxScore: number, pageIndices?: readonly number[]): readonly SearchMatch[];
+}
+/**
+ * One-off scan of a few pages, for callers without a standing index. The
+ * viewer keeps a {@link FuzzyPageIndex} per document instead.
  */
 export declare function findFuzzyPageMatches(pages: readonly FuzzyPageText[], query: string, options: ResolvedFuzzySearchOptions, caseSensitive?: boolean): readonly SearchMatch[];
 /** Page indices of `[first, last]` ordered by distance from `nearPage`, ties earlier-first. */

package/dist/fuzzy-search.js

@@ -1,13 +1,15 @@
-import Fuse from "fuse.js";
+import Fuse, {} from "fuse.js";
+import { alignFuzzyPassage } from "./fuzzy-alignment.js";
 export const DEFAULT_FUZZY_SEARCH_OPTIONS = Object.freeze({
     threshold: 0.3,
     maxScore: 0.4,
     // Bitap cost grows with the query; 600 characters still identifies a
-    // passage while keeping a page under ~100 ms on a laptop.
+    // passage while bounding both candidate scoring and alignment work.
     maxQueryLength: 600,
     maxPageTextLength: 20_000,
     pagesPerBatch: 2,
     pageWindow: 12,
+    worker: true,
 });
 /**
  * Layer fuzzy settings in precedence order (viewer defaults first, then the
@@ -33,55 +35,90 @@ export function resolveFuzzySearchOptions(...layers) {
             maxPageTextLength: positiveInteger(layer.maxPageTextLength, resolved.maxPageTextLength),
             pagesPerBatch: positiveInteger(layer.pagesPerBatch, resolved.pagesPerBatch),
             pageWindow: positiveInteger(layer.pageWindow, resolved.pageWindow),
+            worker: layer.worker ?? resolved.worker,
         };
     }
     return enabled ? resolved : undefined;
 }
-/**
- * One match per page whose text holds the query within the edit budget: the
- * span from the first to the last matched character, so the highlight covers
- * the passage as one block. Pages are returned in page order.
- */
-export function findFuzzyPageMatches(pages, query, options, caseSensitive = false) {
-    const pattern = query.slice(0, options.maxQueryLength);
-    if (!pattern.trim())
-        return [];
-    const items = pages.map((page) => ({
-        pageIndex: page.pageIndex,
-        text: page.text.slice(0, options.maxPageTextLength),
-    }));
-    const fuse = new Fuse(items, {
+/** Fuse.js options shared by every fuzzy scan; `keys` and `threshold` are fixed per index. */
+function fuseOptions(threshold, caseSensitive) {
+    return {
         keys: ["text"],
         isCaseSensitive: caseSensitive,
         ignoreDiacritics: false,
-        includeMatches: true,
         includeScore: true,
         // A citation can sit anywhere on the page; Fuse's location bias would
         // otherwise penalize matches far from the start of the text.
         ignoreLocation: true,
         // Long page text must not dilute the score of a match inside it.
         ignoreFieldNorm: true,
-        threshold: options.threshold,
+        threshold,
         minMatchCharLength: 3,
         shouldSort: false,
-    });
-    const matches = [];
-    for (const result of fuse.search(pattern)) {
-        if ((result.score ?? 1) > options.maxScore)
-            continue;
-        const indices = result.matches?.[0]?.indices ?? [];
-        if (indices.length === 0)
-            continue;
-        let start = Number.POSITIVE_INFINITY;
-        let end = 0;
-        for (const [first, last] of indices) {
-            start = Math.min(start, first);
-            end = Math.max(end, last + 1);
+    };
+}
+/**
+ * A document's pages, indexed once for Fuse.js so that every fuzzy search
+ * reuses the normalized records instead of rebuilding them: a citation
+ * lookup tries several anchors in a row, and each used to pay for the index
+ * again. A scan restricted to a page window reuses the same records through
+ * `Fuse.parseIndex`, so only scoring and alignment run for those pages.
+ */
+export class FuzzyPageIndex {
+    #caseSensitive;
+    #pages;
+    #index;
+    #options;
+    #fuse;
+    constructor(pages, options, caseSensitive = false) {
+        this.#caseSensitive = caseSensitive;
+        this.#pages = pages.map((page) => ({
+            pageIndex: page.pageIndex,
+            text: page.text.slice(0, options.maxPageTextLength),
+        }));
+        this.#options = fuseOptions(options.threshold, caseSensitive);
+        this.#index = Fuse.createIndex(["text"], this.#pages);
+        this.#fuse = new Fuse(this.#pages, this.#options, this.#index);
+    }
+    get pageCount() {
+        return this.#pages.length;
+    }
+    /**
+     * One match per page whose text holds the query within the edit budget:
+     * the best contiguous alignment, so neighbouring text and repeated
+     * occurrences cannot expand the highlight. `pageIndices` restricts the scan;
+     * the result is in page order either way.
+     */
+    search(query, maxScore, pageIndices) {
+        if (!query.trim())
+            return [];
+        const fuse = pageIndices ? this.#subset(pageIndices) : this.#fuse;
+        const matches = [];
+        for (const result of fuse.search(query)) {
+            if ((result.score ?? 1) > maxScore)
+                continue;
+            const span = alignFuzzyPassage(result.item.text, query, this.#caseSensitive, maxScore);
+            if (!span)
+                continue;
+            const { start, end } = span;
+            const text = result.item.text.slice(start, end);
+            matches.push({ pageIndex: result.item.pageIndex, start, end, text });
         }
-        const text = result.item.text.slice(start, end);
-        matches.push({ pageIndex: result.item.pageIndex, start, end, text });
+        return matches.sort((a, b) => a.pageIndex - b.pageIndex);
     }
-    return matches.sort((a, b) => a.pageIndex - b.pageIndex);
+    #subset(pageIndices) {
+        const wanted = new Set(pageIndices);
+        const { keys, records } = this.#index.toJSON();
+        const kept = records.filter((record) => wanted.has(this.#pages[record.i]?.pageIndex ?? -1));
+        return new Fuse(this.#pages, this.#options, Fuse.parseIndex({ keys, records: kept }));
+    }
+}
+/**
+ * One-off scan of a few pages, for callers without a standing index. The
+ * viewer keeps a {@link FuzzyPageIndex} per document instead.
+ */
+export function findFuzzyPageMatches(pages, query, options, caseSensitive = false) {
+    return new FuzzyPageIndex(pages, options, caseSensitive).search(query.slice(0, options.maxQueryLength), options.maxScore);
 }
 /** Page indices of `[first, last]` ordered by distance from `nearPage`, ties earlier-first. */
 export function pagesNearestFirst(first, last, nearPage) {

package/dist/fuzzy-worker-client.d.ts

@@ -0,0 +1,28 @@
+import type { SearchMatch } from "./contracts.js";
+import type { FuzzyPageText } from "./fuzzy-search.js";
+import type { FuzzyWorkerReply, FuzzyWorkerRequest } from "./fuzzy-worker-protocol.js";
+/** The slice of `Worker` the client needs; tests pass a fake. */
+export interface FuzzyWorkerTransport {
+    postMessage(message: FuzzyWorkerRequest): void;
+    addEventListener(type: "message", listener: (event: MessageEvent<FuzzyWorkerReply>) => void): void;
+    addEventListener(type: "error", listener: (event: Event) => void): void;
+    terminate(): void;
+}
+/**
+ * Main-thread side of the fuzzy-search worker. Bitap over a long document
+ * is CPU work that used to run on the main thread and freeze the page; the
+ * worker keeps the document's index and answers each search off-thread.
+ */
+export declare class FuzzyWorkerClient {
+    #private;
+    constructor(worker: FuzzyWorkerTransport);
+    /** Spawn the bundled worker script; `undefined` where workers do not exist. */
+    static create(workerUrl: URL): FuzzyWorkerClient | undefined;
+    index(pages: readonly FuzzyPageText[], options: {
+        readonly threshold: number;
+        readonly maxPageTextLength: number;
+        readonly caseSensitive: boolean;
+    }): Promise<number>;
+    search(query: string, maxScore: number, pageIndices?: readonly number[]): Promise<readonly SearchMatch[]>;
+    terminate(): void;
+}

package/dist/fuzzy-worker-client.js

@@ -0,0 +1,75 @@
+import { ViewerError } from "./errors.js";
+/**
+ * Main-thread side of the fuzzy-search worker. Bitap over a long document
+ * is CPU work that used to run on the main thread and freeze the page; the
+ * worker keeps the document's index and answers each search off-thread.
+ */
+export class FuzzyWorkerClient {
+    #worker;
+    #pending = new Map();
+    #nextId = 1;
+    #dead;
+    constructor(worker) {
+        this.#worker = worker;
+        worker.addEventListener("message", (event) => {
+            const pending = this.#pending.get(event.data.id);
+            if (!pending)
+                return;
+            this.#pending.delete(event.data.id);
+            pending.resolve(event.data);
+        });
+        worker.addEventListener("error", (event) => {
+            this.#fail(new ViewerError("worker-crashed", "Fuzzy search worker crashed", {
+                details: { message: event.message },
+            }));
+        });
+    }
+    /** Spawn the bundled worker script; `undefined` where workers do not exist. */
+    static create(workerUrl) {
+        if (typeof Worker === "undefined")
+            return undefined;
+        return new FuzzyWorkerClient(new Worker(workerUrl, { type: "module", name: "fuzzy-search" }));
+    }
+    async index(pages, options) {
+        const reply = await this.#send({ kind: "index", id: 0, pages, ...options });
+        if (reply.kind !== "indexed")
+            throw unexpected(reply);
+        return reply.pageCount;
+    }
+    async search(query, maxScore, pageIndices) {
+        const reply = await this.#send({
+            kind: "search",
+            id: 0,
+            query,
+            maxScore,
+            ...(pageIndices ? { pageIndices } : {}),
+        });
+        if (reply.kind !== "matches")
+            throw unexpected(reply);
+        return reply.matches;
+    }
+    terminate() {
+        this.#fail(new ViewerError("lifecycle-error", "Fuzzy search worker was terminated"));
+        this.#worker.terminate();
+    }
+    #send(request) {
+        if (this.#dead)
+            return Promise.reject(this.#dead);
+        const id = this.#nextId++;
+        return new Promise((resolve, reject) => {
+            this.#pending.set(id, { resolve, reject });
+            this.#worker.postMessage({ ...request, id });
+        });
+    }
+    #fail(error) {
+        this.#dead = error;
+        for (const pending of this.#pending.values())
+            pending.reject(error);
+        this.#pending.clear();
+    }
+}
+function unexpected(reply) {
+    return new ViewerError("render-failed", reply.kind === "failure"
+        ? reply.message
+        : `Unexpected worker reply: ${reply.kind}`);
+}

package/dist/fuzzy-worker-protocol.d.ts

@@ -0,0 +1,39 @@
+import type { SearchMatch } from "./contracts.js";
+import { FuzzyPageIndex, type FuzzyPageText } from "./fuzzy-search.js";
+/**
+ * Messages between the viewer and the fuzzy-search worker. The worker holds
+ * one {@link FuzzyPageIndex} at a time: `index` replaces it, `search` runs
+ * against it. Every request is answered by exactly one reply with its `id`.
+ */
+export type FuzzyWorkerRequest = {
+    readonly kind: "index";
+    readonly id: number;
+    readonly pages: readonly FuzzyPageText[];
+    readonly threshold: number;
+    readonly maxPageTextLength: number;
+    readonly caseSensitive: boolean;
+} | {
+    readonly kind: "search";
+    readonly id: number;
+    readonly query: string;
+    readonly maxScore: number;
+    readonly pageIndices?: readonly number[];
+};
+export type FuzzyWorkerReply = {
+    readonly kind: "indexed";
+    readonly id: number;
+    readonly pageCount: number;
+} | {
+    readonly kind: "matches";
+    readonly id: number;
+    readonly matches: readonly SearchMatch[];
+} | {
+    readonly kind: "failure";
+    readonly id: number;
+    readonly message: string;
+};
+export interface FuzzyWorkerState {
+    index?: FuzzyPageIndex;
+}
+/** Apply one request to the worker's state and produce its reply. */
+export declare function handleFuzzyWorkerRequest(state: FuzzyWorkerState, request: FuzzyWorkerRequest): FuzzyWorkerReply;

package/dist/fuzzy-worker-protocol.js

@@ -0,0 +1,35 @@
+import { FuzzyPageIndex } from "./fuzzy-search.js";
+/** Apply one request to the worker's state and produce its reply. */
+export function handleFuzzyWorkerRequest(state, request) {
+    try {
+        if (request.kind === "index") {
+            state.index = new FuzzyPageIndex(request.pages, {
+                threshold: request.threshold,
+                maxPageTextLength: request.maxPageTextLength,
+            }, request.caseSensitive);
+            return {
+                kind: "indexed",
+                id: request.id,
+                pageCount: state.index.pageCount,
+            };
+        }
+        if (!state.index)
+            return {
+                kind: "failure",
+                id: request.id,
+                message: "No document is indexed",
+            };
+        return {
+            kind: "matches",
+            id: request.id,
+            matches: state.index.search(request.query, request.maxScore, request.pageIndices),
+        };
+    }
+    catch (error) {
+        return {
+            kind: "failure",
+            id: request.id,
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/index.d.ts

@@ -6,6 +6,8 @@ export * from "./format.js";
 export * from "./limits.js";
 export * from "./interaction.js";
 export * from "./fuzzy-search.js";
+export * from "./fuzzy-worker-protocol.js";
+export * from "./fuzzy-worker-client.js";
 export * from "./search-reveal.js";
 export * from "./adapters/docx-images.js";
 export * from "./render-scheduler.js";

package/dist/index.js

@@ -6,6 +6,8 @@ export * from "./format.js";
 export * from "./limits.js";
 export * from "./interaction.js";
 export * from "./fuzzy-search.js";
+export * from "./fuzzy-worker-protocol.js";
+export * from "./fuzzy-worker-client.js";
 export * from "./search-reveal.js";
 export * from "./adapters/docx-images.js";
 export * from "./render-scheduler.js";

package/dist/interaction.d.ts

@@ -1,3 +1,4 @@
+export { normalizeSearchText } from "./search-text.js";
 import type { CellRange, SearchMatch } from "./contracts.js";
 export interface VirtualRange {
     readonly start: number;
@@ -6,7 +7,6 @@ export interface VirtualRange {
 export declare function visibleRange(scrollOffset: number, viewportExtent: number, itemExtent: number, itemCount: number, overscan?: number): VirtualRange;
 export declare function normalizeCellRange(range: CellRange): CellRange;
 export declare function findNormalizedMatches(text: string, query: string, pageIndex: number, caseSensitive?: boolean): readonly SearchMatch[];
-export declare function normalizeSearchText(text: string, caseSensitive?: boolean): string;
 /** Clamp a UTF-16 DOM offset to a grapheme boundary for native selection UI. */
 export declare function snapGraphemeOffset(text: string, offset: number, edge: "start" | "end"): number;
 export declare function cellRangeToTsv(range: CellRange, cells: ReadonlyMap<string, string>): string;

package/dist/interaction.js

@@ -1,3 +1,5 @@
+import { graphemeSegments, normalizeSearchText, normalizeWithMap, } from "./search-text.js";
+export { normalizeSearchText } from "./search-text.js";
 export function visibleRange(scrollOffset, viewportExtent, itemExtent, itemCount, overscan = 1) {
     if (itemCount <= 0 || itemExtent <= 0)
         return { start: 0, end: 0 };
@@ -41,10 +43,6 @@ export function findNormalizedMatches(text, query, pageIndex, caseSensitive = fa
     }
     return matches;
 }
-export function normalizeSearchText(text, caseSensitive = false) {
-    const normalized = text.normalize("NFKC");
-    return caseSensitive ? normalized : unicodeCaseFold(normalized);
-}
 /** Clamp a UTF-16 DOM offset to a grapheme boundary for native selection UI. */
 export function snapGraphemeOffset(text, offset, edge) {
     const safeOffset = Math.max(0, Math.min(text.length, Math.trunc(offset)));
@@ -126,46 +124,6 @@ export class LruMap {
         this.#values.clear();
     }
 }
-function normalizeWithMap(text, caseSensitive) {
-    const output = [];
-    const starts = [];
-    const ends = [];
-    const segments = graphemeSegments(text);
-    for (const segment of segments) {
-        const normalized = normalizeSearchText(segment.value, caseSensitive);
-        output.push(normalized);
-        for (let index = 0; index < normalized.length; index += 1) {
-            starts.push(segment.start);
-            ends.push(segment.end);
-        }
-    }
-    return { text: output.join(""), starts, ends };
-}
-function graphemeSegments(text) {
-    if (typeof Intl.Segmenter === "function") {
-        const segmenter = new Intl.Segmenter(undefined, {
-            granularity: "grapheme",
-        });
-        return [...segmenter.segment(text)].map((segment) => ({
-            value: segment.segment,
-            start: segment.index,
-            end: segment.index + segment.segment.length,
-        }));
-    }
-    const result = [];
-    let offset = 0;
-    for (const value of text) {
-        result.push({ value, start: offset, end: offset + value.length });
-        offset += value.length;
-    }
-    return result;
-}
-function unicodeCaseFold(text) {
-    return text
-        .toLocaleLowerCase("und")
-        .replaceAll("ß", "ss")
-        .replaceAll("ς", "σ");
-}
 function escapeTsv(value) {
     return /[\t\n\r"]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value;
 }

package/dist/search-text.d.ts

@@ -0,0 +1,11 @@
+export declare function normalizeSearchText(text: string, caseSensitive?: boolean): string;
+export declare function normalizeWithMap(text: string, caseSensitive: boolean): {
+    text: string;
+    starts: number[];
+    ends: number[];
+};
+export declare function graphemeSegments(text: string): readonly {
+    value: string;
+    start: number;
+    end: number;
+}[];