web-doc 0.6.0 → 0.6.2

package/dist/adapters/office.js

@@ -341,7 +341,7 @@ export class OfficeDocumentAdapter {
     async #loadPptx(data, options) {
         if (this.#options.engines?.pptx)
             return this.#options.engines.pptx(data, options);
-        const { PptxPresentation } = await import("@silurus/ooxml/pptx");
+        const { PptxPresentation } = await import("@silurus/ooxml-pptx/pptx");
         return PptxPresentation.load(data, options);
     }
 }

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`. */

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.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
@@ -33,7 +34,7 @@ export interface FuzzyPageText {
  * 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 the Bitap pass runs for those pages.
+ * `Fuse.parseIndex`, so only scoring and alignment run for those pages.
  */
 export declare class FuzzyPageIndex {
     #private;
@@ -44,9 +45,9 @@ export declare class FuzzyPageIndex {
     get pageCount(): number;
     /**
      * 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. `pageIndices` restricts the scan; the
-     * result is in page order either way.
+     * 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[];
 }

package/dist/fuzzy-search.js

@@ -1,9 +1,10 @@
 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,
@@ -45,7 +46,6 @@ function fuseOptions(threshold, caseSensitive) {
         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.
@@ -62,14 +62,16 @@ function fuseOptions(threshold, caseSensitive) {
  * 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 the Bitap pass runs for those pages.
+ * `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),
@@ -83,9 +85,9 @@ export class FuzzyPageIndex {
     }
     /**
      * 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. `pageIndices` restricts the scan; the
-     * result is in page order either way.
+     * 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())
@@ -95,15 +97,10 @@ export class FuzzyPageIndex {
         for (const result of fuse.search(query)) {
             if ((result.score ?? 1) > maxScore)
                 continue;
-            const indices = result.matches?.[0]?.indices ?? [];
-            if (indices.length === 0)
+            const span = alignFuzzyPassage(result.item.text, query, this.#caseSensitive, maxScore);
+            if (!span)
                 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);
-            }
+            const { start, end } = span;
             const text = result.item.text.slice(start, end);
             matches.push({ pageIndex: result.item.pageIndex, start, end, text });
         }

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;
+}[];

package/dist/search-text.js

@@ -0,0 +1,44 @@
+export function normalizeSearchText(text, caseSensitive = false) {
+    const normalized = text.normalize("NFKC");
+    return caseSensitive ? normalized : unicodeCaseFold(normalized);
+}
+export 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 };
+}
+export 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("ς", "σ");
+}

package/dist/workers/fuzzy-search-worker.js

@@ -1545,12 +1545,104 @@ Fuse.use = function(...plugins) {
 };
 var entry_default = Fuse;
 
+// src/search-text.ts
+function normalizeSearchText(text, caseSensitive = false) {
+  const normalized = text.normalize("NFKC");
+  return caseSensitive ? normalized : unicodeCaseFold(normalized);
+}
+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(void 0, {
+      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("\xDF", "ss").replaceAll("\u03C2", "\u03C3");
+}
+
+// src/fuzzy-alignment.ts
+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 void 0;
+  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 end2 = 1; end2 <= source.text.length; end2 += 1) {
+    let diagonalCost = costs[0];
+    let diagonalStart = starts[0];
+    costs[0] = 0;
+    starts[0] = end2;
+    for (let i = 1; i <= length; i += 1) {
+      const previousCost = costs[i];
+      const previousStart = starts[i];
+      let cost = diagonalCost + (pattern[i - 1] === source.text[end2 - 1] ? 0 : 1);
+      let start2 = diagonalStart;
+      const deletion = costs[i - 1] + 1;
+      if (deletion <= cost) {
+        cost = deletion;
+        start2 = starts[i - 1];
+      }
+      const insertion = previousCost + 1;
+      if (insertion < cost) {
+        cost = insertion;
+        start2 = previousStart;
+      }
+      costs[i] = cost;
+      starts[i] = start2;
+      diagonalCost = previousCost;
+      diagonalStart = previousStart;
+    }
+    if (costs[length] < bestCost) {
+      bestCost = costs[length];
+      bestStart = starts[length];
+      bestEnd = end2;
+    }
+  }
+  if (bestEnd <= bestStart || bestCost / length > maxScore) return void 0;
+  const start = source.starts[bestStart];
+  const end = source.ends[bestEnd - 1];
+  return start === void 0 || end === void 0 ? void 0 : { start, end };
+}
+
 // src/fuzzy-search.ts
 var 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: 2e4,
   pagesPerBatch: 2,
@@ -1562,7 +1654,6 @@ function fuseOptions(threshold, caseSensitive) {
     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.
@@ -1575,11 +1666,13 @@ function fuseOptions(threshold, caseSensitive) {
   };
 }
 var FuzzyPageIndex = class {
+  #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)
@@ -1593,9 +1686,9 @@ var FuzzyPageIndex = class {
   }
   /**
    * 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. `pageIndices` restricts the scan; the
-   * result is in page order either way.
+   * 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 [];
@@ -1603,14 +1696,14 @@ var FuzzyPageIndex = class {
     const matches = [];
     for (const result of fuse.search(query)) {
       if ((result.score ?? 1) > 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);
-      }
+      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 });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-doc",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "web-doc — embeddable browser-only document viewer with Rust/WASM adapters (a fork of Zrimo)",
   "keywords": [
     "document-viewer",
@@ -69,6 +69,7 @@
   },
   "dependencies": {
     "@silurus/ooxml": "0.72.2",
+    "@silurus/ooxml-pptx": "npm:@silurus/ooxml@0.88.0",
     "fuse.js": "7.5.0",
     "pdfjs-dist": "6.2.108"
   }