@anaralabs/lector 3.14.10 → 3.14.12

package/dist/index.js

@@ -1,10 +1,11 @@
 'use client';
 
-import React, { createContext, memo, forwardRef, useMemo, cloneElement, useEffect, useRef, useState, useCallback, useContext, useLayoutEffect, createRef } from 'react';
+import React, { createContext, memo, forwardRef, useMemo, cloneElement, useEffect, useRef, useState, useCallback, useContext, useLayoutEffect, createRef, useSyncExternalStore, useImperativeHandle } from 'react';
 import { createPortal } from 'react-dom';
 import { useFloating, autoUpdate, offset, flip, shift, useDismiss, useInteractions, inline } from '@floating-ui/react';
 import { useStore, createStore } from 'zustand';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useShallow } from 'zustand/react/shallow';
 import { useDebounce } from 'use-debounce';
 import { v4 } from 'uuid';
 import { Slot } from '@radix-ui/react-slot';
@@ -265,12 +266,12 @@ var PDFStore = createZustandContext(
       updateZoom: (zoom, isZoomFitWidth = false) => {
         const { minZoom, maxZoom } = get().zoomOptions;
         set((state) => {
-          if (typeof zoom === "function") {
-            const newZoom2 = clamp(zoom(state.zoom), minZoom, maxZoom);
-            return { zoom: newZoom2, isZoomFitWidth };
-          }
-          const newZoom = clamp(zoom, minZoom, maxZoom);
-          return { zoom: newZoom, isZoomFitWidth };
+          const newZoom = clamp(
+            typeof zoom === "function" ? zoom(state.zoom) : zoom,
+            minZoom,
+            maxZoom
+          );
+          return newZoom === state.zoom && isZoomFitWidth === state.isZoomFitWidth ? state : { zoom: newZoom, isZoomFitWidth };
         });
       },
       zoomFitWidth: () => {
@@ -281,23 +282,20 @@ var PDFStore = createZustandContext(
           viewports,
           zoomOptions
         );
-        set({
-          zoom: clampedZoom,
-          isZoomFitWidth: true
-        });
+        get().updateZoom(clampedZoom, true);
         return clampedZoom;
       },
       currentPage: 1,
       setCurrentPage: (val) => {
-        set({
-          currentPage: val
-        });
+        set(
+          (state) => state.currentPage === val ? state : { currentPage: val }
+        );
       },
       isPinching: false,
       setIsPinching: (val) => {
-        set({
-          isPinching: val
-        });
+        set(
+          (state) => state.isPinching === val ? state : { isPinching: val }
+        );
       },
       isResizing: false,
       setIsResizing: (val) => {
@@ -307,9 +305,9 @@ var PDFStore = createZustandContext(
       },
       virtualizer: null,
       setVirtualizer: (val) => {
-        set({
-          virtualizer: val
-        });
+        set(
+          (state) => state.virtualizer === val ? state : { virtualizer: val }
+        );
       },
       pageProxies: initialState.pageProxies,
       getPdfPageProxy: (pageNumber) => {
@@ -319,21 +317,21 @@ var PDFStore = createZustandContext(
       },
       textContent: [],
       setTextContent: (val) => {
-        set({
-          textContent: val
-        });
+        set(
+          (state) => state.textContent === val ? state : { textContent: val }
+        );
       },
       highlights: [],
       setHighlight: (val) => {
-        set({
-          highlights: val
-        });
+        set(
+          (state) => state.highlights === val ? state : { highlights: val }
+        );
       },
       customSelectionRects: [],
       setCustomSelectionRects: (val) => {
-        set({
-          customSelectionRects: val
-        });
+        set(
+          (state) => state.customSelectionRects === val ? state : { customSelectionRects: val }
+        );
       },
       coloredHighlights: [],
       addColoredHighlight: (value) => set((prevState) => ({
@@ -700,10 +698,43 @@ var AnnotationsStoreProvider = ({
   { initialValue: void 0 },
   children
 );
-var useAnnotations = () => {
+var identity = (state) => state;
+function useAnnotations(selector) {
   const ctx = AnnotationsStore.useContext();
-  return useStore(ctx ?? getFallbackStore());
-};
+  return useStore(
+    ctx ?? getFallbackStore(),
+    selector ?? identity
+  );
+}
+var emptyAnnotations = [];
+var indexes = /* @__PURE__ */ new WeakMap();
+function annotationsByPage(annotations) {
+  let index = indexes.get(annotations);
+  if (index) return index;
+  index = /* @__PURE__ */ new Map();
+  for (const annotation of annotations) {
+    const pages = /* @__PURE__ */ new Set([annotation.pageNumber]);
+    for (const rect of annotation.highlights) pages.add(rect.pageNumber);
+    for (const rect of annotation.underlines ?? []) pages.add(rect.pageNumber);
+    for (const page of pages) {
+      let values = index.get(page);
+      if (!values) {
+        values = [];
+        index.set(page, values);
+      }
+      values.push(annotation);
+    }
+  }
+  indexes.set(annotations, index);
+  return index;
+}
+function usePageAnnotations(pageNumber) {
+  return useAnnotations(
+    useShallow(
+      (state) => annotationsByPage(state.annotations).get(pageNumber) ?? emptyAnnotations
+    )
+  );
+}
 var PDFPageNumberContext = createContext(0);
 var usePDFPageNumber = () => {
   return useContext(PDFPageNumberContext);
@@ -725,15 +756,9 @@ var AnnotationHighlightLayer = ({
   onAnnotationTooltipClose,
   hoverTooltipClassName
 }) => {
-  const { annotations } = useAnnotations();
   const pageNumber = usePDFPageNumber();
   const isPageRendered = usePdf((state) => !!state.renderedPages[pageNumber]);
-  const pageAnnotations = useMemo(
-    () => annotations.filter(
-      (a) => a.pageNumber === pageNumber || a.highlights.some((h) => h.pageNumber === pageNumber) || a.underlines?.some((u) => u.pageNumber === pageNumber)
-    ),
-    [annotations, pageNumber]
-  );
+  const pageAnnotations = usePageAnnotations(pageNumber);
   if (!isPageRendered) return null;
   const getCommentIconPosition = (highlights) => {
     if (!highlights.length) return { top: 0, right: 10 };
@@ -1220,20 +1245,42 @@ var PDFLinkServiceContext = createContext(defaultLinkService);
 var usePDFLinkService = () => {
   return useContext(PDFLinkServiceContext);
 };
+var targets = /* @__PURE__ */ new Map();
+var observer;
 var useVisibility = ({
   elementRef
 }) => {
   const [visible, setVisible] = useState(false);
   useEffect(() => {
-    if (!elementRef.current) {
-      return;
-    }
-    const observer = new IntersectionObserver(([entry]) => {
-      setVisible(entry?.isIntersecting ?? false);
+    const element = elementRef.current;
+    if (!element) return;
+    observer ??= new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        const target2 = targets.get(entry.target);
+        if (!target2) continue;
+        target2.visible = entry.isIntersecting;
+        for (const listener of target2.listeners) listener(entry.isIntersecting);
+      }
     });
-    observer.observe(elementRef.current);
+    let target = targets.get(element);
+    if (!target) {
+      target = { listeners: /* @__PURE__ */ new Set(), visible: false };
+      targets.set(element, target);
+      observer.observe(element);
+    }
+    const { listeners: listeners2 } = target;
+    listeners2.add(setVisible);
+    setVisible(target.visible);
     return () => {
-      observer.disconnect();
+      listeners2.delete(setVisible);
+      if (listeners2.size === 0) {
+        observer?.unobserve(element);
+        targets.delete(element);
+      }
+      if (targets.size === 0) {
+        observer?.disconnect();
+        observer = void 0;
+      }
     };
   }, [elementRef]);
   return { visible };
@@ -2061,52 +2108,41 @@ function applyContextRecolor(ctx, map, options) {
 function removeContextRecolor(ctx) {
   ctx[RECOLOR_CLEANUP]?.();
 }
-var DPR_CAP = 3;
-var readDpr = () => typeof window === "undefined" ? 1 : Math.min(window.devicePixelRatio || 1, DPR_CAP);
-var useDpr = () => {
-  const [dpr, setDpr] = useState(readDpr);
-  useEffect(() => {
-    if (typeof window === "undefined") {
-      return;
+var listeners = /* @__PURE__ */ new Set();
+var media;
+var getSnapshot = () => Math.min(window.devicePixelRatio || 1, 3);
+var getServerSnapshot = () => 1;
+function unlisten() {
+  if (!media) return;
+  if (typeof media.removeEventListener === "function")
+    media.removeEventListener("change", onChange);
+  else media.removeListener(onChange);
+}
+function watchResolution() {
+  unlisten();
+  media = window.matchMedia(
+    `(resolution: ${window.devicePixelRatio || 1}dppx), (-webkit-device-pixel-ratio: ${window.devicePixelRatio || 1})`
+  );
+  if (typeof media.addEventListener === "function")
+    media.addEventListener("change", onChange);
+  else media.addListener(onChange);
+}
+function onChange() {
+  watchResolution();
+  for (const listener of listeners) listener();
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  if (listeners.size === 1) watchResolution();
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0) {
+      unlisten();
+      media = void 0;
     }
-    let mediaQuery = null;
-    let cancelled = false;
-    const handleChange = () => {
-      if (cancelled) {
-        return;
-      }
-      setDpr(readDpr());
-      subscribe();
-    };
-    const unlisten = (mql) => {
-      if (!mql) return;
-      if (typeof mql.removeEventListener === "function") {
-        mql.removeEventListener("change", handleChange);
-      } else {
-        mql.removeListener(handleChange);
-      }
-    };
-    const subscribe = () => {
-      unlisten(mediaQuery);
-      const ratio = window.devicePixelRatio || 1;
-      mediaQuery = window.matchMedia(
-        `(resolution: ${ratio}dppx), (-webkit-device-pixel-ratio: ${ratio})`
-      );
-      if (typeof mediaQuery.addEventListener === "function") {
-        mediaQuery.addEventListener("change", handleChange, { once: true });
-      } else {
-        mediaQuery.addListener(handleChange);
-      }
-    };
-    setDpr(readDpr());
-    subscribe();
-    return () => {
-      cancelled = true;
-      unlisten(mediaQuery);
-    };
-  }, []);
-  return dpr;
-};
+  };
+}
+var useDpr = () => useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
 
 // src/hooks/layers/useCanvasLayer.tsx
 var CACHE_MAX_ENTRIES = 60;
@@ -2858,9 +2894,7 @@ var CanvasLayer = memo(
 );
 CanvasLayer.displayName = "CanvasLayer";
 
-// src/hooks/useSelectionDimensions.tsx
-var MERGE_THRESHOLD = 2;
-var LAYER_ATTRIBUTION_TOLERANCE_PX = 4;
+// src/lib/selection-rects.ts
 var getTextNodeClientRects = (range) => {
   const root = range.commonAncestorContainer;
   const ownerDoc = root.ownerDocument ?? document;
@@ -2912,6 +2946,39 @@ var getTextNodeClientRects = (range) => {
   }
   return results;
 };
+var connected = (a, b) => {
+  const overlap = Math.min(a.top + a.height, b.top + b.height) - Math.max(a.top, b.top);
+  const gap = Math.max(a.left, b.left) - Math.min(a.left + a.width, b.left + b.width);
+  return overlap >= Math.min(a.height, b.height) / 2 && gap <= Math.min(a.height, b.height) * 0.5;
+};
+var mergeTextRuns = (rects) => {
+  const groups = [];
+  for (const rect of rects) {
+    const group = [rect];
+    for (let i = groups.length - 1; i >= 0; i--) {
+      if (groups[i].some((member) => connected(member, rect))) {
+        group.push(...groups[i]);
+        groups.splice(i, 1);
+      }
+    }
+    groups.push(group);
+  }
+  return groups.map((group) => {
+    const left = Math.min(...group.map((rect) => rect.left));
+    const top = Math.min(...group.map((rect) => rect.top));
+    return {
+      ...group[0],
+      left,
+      top,
+      width: Math.max(...group.map((rect) => rect.left + rect.width)) - left,
+      height: Math.max(...group.map((rect) => rect.top + rect.height)) - top
+    };
+  });
+};
+
+// src/hooks/useSelectionDimensions.tsx
+var MERGE_THRESHOLD = 2;
+var LAYER_ATTRIBUTION_TOLERANCE_PX = 4;
 var mapSelectionRectsToLayers = (range) => {
   const clientRects = getTextNodeClientRects(range).filter(
     ({ rect }) => rect.width > 2 && rect.height > 2
@@ -2954,122 +3021,6 @@ var mapSelectionRectsToLayers = (range) => {
   }
   return result;
 };
-var shouldMergeRects = (rect1, rect2) => {
-  const verticalOverlap = !(rect1.top > rect2.top + rect2.height || rect2.top > rect1.top + rect1.height);
-  const horizontallyConnected = Math.abs(rect1.left + rect1.width - rect2.left) <= MERGE_THRESHOLD || Math.abs(rect2.left + rect2.width - rect1.left) <= MERGE_THRESHOLD || rect1.left < rect2.left + rect2.width && rect2.left < rect1.left + rect1.width;
-  return verticalOverlap && horizontallyConnected;
-};
-var consolidateHighlightRects = (rects) => {
-  if (rects.length <= 1) return rects;
-  const consolidated = [];
-  const sorted = [...rects].sort((a, b) => {
-    const pageCompare = a.pageNumber - b.pageNumber;
-    if (pageCompare !== 0) return pageCompare;
-    const topDiff = a.top - b.top;
-    return Math.abs(topDiff) < 2 ? a.left - b.left : topDiff;
-  });
-  let current = sorted[0];
-  if (!current) return rects;
-  for (let i = 1; i < sorted.length; i++) {
-    const next = sorted[i];
-    if (!next) continue;
-    const samePageAndLine = current.pageNumber === next.pageNumber && Math.abs(current.top - next.top) < Math.max(current.height, next.height) * 0.5;
-    const horizontallyConnected = samePageAndLine && // Adjacent (touching or very close)
-    (Math.abs(current.left + current.width - next.left) <= MERGE_THRESHOLD || Math.abs(next.left + next.width - current.left) <= MERGE_THRESHOLD || // Overlapping
-    current.left < next.left + next.width && next.left < current.left + current.width || // Very close (small gap)
-    Math.abs(current.left + current.width - next.left) <= current.height * 0.2);
-    if (horizontallyConnected) {
-      const newLeft = Math.min(current.left, next.left);
-      const newRight = Math.max(
-        current.left + current.width,
-        next.left + next.width
-      );
-      const newTop = Math.min(current.top, next.top);
-      const newBottom = Math.max(
-        current.top + current.height,
-        next.top + next.height
-      );
-      current = {
-        left: newLeft,
-        top: newTop,
-        width: newRight - newLeft,
-        height: newBottom - newTop,
-        pageNumber: current.pageNumber
-      };
-    } else {
-      consolidated.push(current);
-      current = next;
-    }
-  }
-  if (current) {
-    consolidated.push(current);
-  }
-  return consolidated;
-};
-var consolidateRects = (rects) => {
-  if (rects.length <= 1) return rects;
-  const result = [];
-  const visited = /* @__PURE__ */ new Set();
-  for (let i = 0; i < rects.length; i++) {
-    if (visited.has(i)) continue;
-    const currentRect = rects[i];
-    if (!currentRect) continue;
-    const currentGroup = [currentRect];
-    visited.add(i);
-    let foundNew = true;
-    while (foundNew) {
-      foundNew = false;
-      for (let j = 0; j < rects.length; j++) {
-        if (visited.has(j)) continue;
-        const candidateRect = rects[j];
-        if (!candidateRect) continue;
-        const shouldMergeWithGroup = currentGroup.some(
-          (groupRect) => doRectsOverlap(groupRect, candidateRect)
-        );
-        if (shouldMergeWithGroup) {
-          currentGroup.push(candidateRect);
-          visited.add(j);
-          foundNew = true;
-        }
-      }
-    }
-    result.push(mergeRectGroup(currentGroup));
-  }
-  return result;
-};
-var doRectsOverlap = (rect1, rect2) => {
-  const horizontalOverlap = rect1.left < rect2.left + rect2.width && rect2.left < rect1.left + rect1.width;
-  const verticalOverlap = rect1.top < rect2.top + rect2.height && rect2.top < rect1.top + rect1.height;
-  const closeEnough = shouldMergeRects(rect1, rect2);
-  return horizontalOverlap && verticalOverlap || closeEnough;
-};
-var mergeRectGroup = (rects) => {
-  if (rects.length === 1) {
-    const rect = rects[0];
-    if (!rect) throw new Error("Invalid rect in group");
-    return rect;
-  }
-  const firstRect = rects[0];
-  if (!firstRect) throw new Error("Invalid first rect in group");
-  let minLeft = firstRect.left;
-  let minTop = firstRect.top;
-  let maxRight = firstRect.left + firstRect.width;
-  let maxBottom = firstRect.top + firstRect.height;
-  rects.forEach((rect) => {
-    if (!rect) return;
-    minLeft = Math.min(minLeft, rect.left);
-    minTop = Math.min(minTop, rect.top);
-    maxRight = Math.max(maxRight, rect.left + rect.width);
-    maxBottom = Math.max(maxBottom, rect.top + rect.height);
-  });
-  return {
-    left: minLeft,
-    top: minTop,
-    width: maxRight - minLeft,
-    height: maxBottom - minTop,
-    pageNumber: firstRect.pageNumber
-  };
-};
 var useSelectionDimensions = () => {
   const store = PDFStore.useContext();
   const getAnnotationDimension = () => {
@@ -3142,14 +3093,7 @@ var useSelectionDimensions = () => {
       }
     });
     textLayerMapHighlight.forEach((rects) => {
-      if (rects.length > 0) {
-        if (rects.length === 1) {
-          highlightRects.push(...rects);
-        } else {
-          const consolidated = consolidateHighlightRects(rects);
-          highlightRects.push(...consolidated);
-        }
-      }
+      highlightRects.push(...mergeTextRuns(rects));
     });
     textLayerMapUnderline.forEach((rects) => {
       if (rects.length > 0) {
@@ -3296,7 +3240,7 @@ var useSelectionDimensions = () => {
     });
     textLayerMap.forEach((rects) => {
       if (rects.length > 0) {
-        const consolidated = consolidateRects(rects);
+        const consolidated = mergeTextRuns(rects);
         highlights.push(...consolidated);
       }
     });
@@ -3741,13 +3685,110 @@ var HighlightLayer = forwardRef(({ asChild, className, style, ...props }, ref) =
   }) });
 });
 HighlightLayer.displayName = "HighlightLayer";
+
+// src/lib/selection-background.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var createSelectionBackground = () => {
+  const overlays = /* @__PURE__ */ new Map();
+  let style;
+  const clear = (layer) => {
+    overlays.get(layer)?.remove();
+    overlays.delete(layer);
+    layer.removeAttribute("data-lector-selection-active");
+    if (overlays.size === 0) {
+      style?.remove();
+      style = void 0;
+    }
+  };
+  const update = (selection, layers) => {
+    const registered = new Set(layers);
+    const byLayer = /* @__PURE__ */ new Map();
+    if (selection && !selection.isCollapsed) {
+      for (let i = 0; i < selection.rangeCount; i++) {
+        for (const { rect, element } of getTextNodeClientRects(
+          selection.getRangeAt(i)
+        )) {
+          const layer = element?.closest(".textLayer");
+          if (!layer || !element || !registered.has(layer) || rect.width <= 0 || rect.height <= 0)
+            continue;
+          let entry = byLayer.get(layer);
+          if (!entry) {
+            entry = { rects: [], element };
+            byLayer.set(layer, entry);
+          }
+          entry.rects.push(rect);
+        }
+      }
+    }
+    for (const layer of registered) {
+      const entry = byLayer.get(layer);
+      if (!entry) {
+        clear(layer);
+        continue;
+      }
+      layer.removeAttribute("data-lector-selection-active");
+      const color = getComputedStyle(
+        entry.element,
+        "::selection"
+      ).backgroundColor;
+      if (!color || color === "transparent" || color === "rgba(0, 0, 0, 0)") {
+        clear(layer);
+        continue;
+      }
+      const bounds = layer.getBoundingClientRect();
+      if (!bounds.width || !bounds.height || !layer.clientWidth || !layer.clientHeight) {
+        clear(layer);
+        continue;
+      }
+      const scaleX = bounds.width / layer.clientWidth;
+      const scaleY = bounds.height / layer.clientHeight;
+      const rects = mergeTextRuns(
+        entry.rects.map((rect) => ({
+          left: (rect.left - bounds.left) / scaleX,
+          top: (rect.top - bounds.top) / scaleY,
+          width: rect.width / scaleX,
+          height: rect.height / scaleY
+        }))
+      );
+      let overlay = overlays.get(layer);
+      if (!overlay) {
+        overlay = document.createElementNS(SVG_NS, "svg");
+        overlay.dataset.lectorSelection = "";
+        overlay.setAttribute("aria-hidden", "true");
+        overlay.style.cssText = "position:absolute;inset:0;width:100%;height:100%;pointer-events:none;user-select:none;transform:none;z-index:0;overflow:visible";
+        overlay.append(document.createElementNS(SVG_NS, "path"));
+        layer.append(overlay);
+        overlays.set(layer, overlay);
+      }
+      const path = overlay.firstElementChild;
+      path.setAttribute(
+        "d",
+        rects.map(
+          (rect) => `M${rect.left} ${rect.top}h${rect.width}v${rect.height}h${-rect.width}Z`
+        ).join(" ")
+      );
+      path.setAttribute("fill", color);
+      if (!style) {
+        style = document.createElement("style");
+        style.textContent = ".textLayer[data-lector-selection-active] ::selection { background-color: transparent !important; }";
+        document.head.append(style);
+      }
+      layer.setAttribute("data-lector-selection-active", "");
+    }
+  };
+  return { update, clear };
+};
+
+// src/hooks/layers/useTextLayer.tsx
 var createTextSelectionManager = () => {
   const textLayers = /* @__PURE__ */ new Map();
+  const selectionBackground = createSelectionBackground();
   let selectionChangeAbortController = null;
   let isPointerDown = false;
   let prevRange = null;
   let isFirefox;
   const removeGlobalSelectionListener = (textLayerDiv) => {
+    selectionBackground.clear(textLayerDiv);
     textLayers.delete(textLayerDiv);
     if (textLayers.size === 0) {
       selectionChangeAbortController?.abort();
@@ -3804,6 +3845,7 @@ var createTextSelectionManager = () => {
       "selectionchange",
       () => {
         const selection = document.getSelection();
+        selectionBackground.update(selection, textLayers.keys());
         if (!selection || selection.rangeCount === 0) {
           textLayers.forEach(reset);
           return;
@@ -4492,9 +4534,9 @@ var useVisiblePage = ({
       window.addEventListener("resize", measure);
       return () => window.removeEventListener("resize", measure);
     }
-    const observer = new ResizeObserver(measure);
-    observer.observe(scrollElement);
-    return () => observer.disconnect();
+    const observer2 = new ResizeObserver(measure);
+    observer2.observe(scrollElement);
+    return () => observer2.disconnect();
   }, [scrollElement]);
   const calculateVisiblePageIndex = useCallback(
     (virtualItems) => {
@@ -5051,7 +5093,7 @@ var CoordinatesEngine = class extends Engine {
     }
   }
 };
-var identity = (v) => v;
+var identity2 = (v) => v;
 var DEFAULT_RUBBERBAND = 0.15;
 var commonConfigResolver = {
   enabled(value = true) {
@@ -5084,7 +5126,7 @@ var commonConfigResolver = {
     const transform = value || config.shared.transform;
     this.hasCustomTransform = !!transform;
     if (process.env.NODE_ENV === "development") {
-      const originalTransform = transform || identity;
+      const originalTransform = transform || identity2;
       return (v) => {
         const r2 = originalTransform(v);
         if (!isFinite(r2[0]) || !isFinite(r2[1])) {
@@ -5093,7 +5135,7 @@ var commonConfigResolver = {
         return r2;
       };
     }
-    return transform || identity;
+    return transform || identity2;
   },
   threshold(value) {
     return V.toVector(value, 0);
@@ -6167,16 +6209,16 @@ var EventStore = class {
     this._gestureKey = gestureKey;
   }
   add(element, device, action, handler, options) {
-    const listeners = this._listeners;
+    const listeners2 = this._listeners;
     const type = toDomEventType(device, action);
     const _options = this._gestureKey ? this._ctrl.config[this._gestureKey].eventOptions : {};
     const eventOptions = _objectSpread2(_objectSpread2({}, _options), options);
     element.addEventListener(type, handler, eventOptions);
     const remove = () => {
       element.removeEventListener(type, handler, eventOptions);
-      listeners.delete(remove);
+      listeners2.delete(remove);
     };
-    listeners.add(remove);
+    listeners2.add(remove);
     return remove;
   }
   clean() {
@@ -6661,7 +6703,6 @@ var useViewportContainer = ({
     origin: originRef.current
   };
 };
-var selectLargestPageWidth = (state) => state.viewports.reduce((max, vp) => Math.max(max, vp.width), 0);
 var DEFAULT_HEIGHT = 600;
 var EXTRA_HEIGHT = 0;
 var DEFAULT_VIRTUALIZER_OPTIONS = { overscan: 1 };
@@ -6776,7 +6817,10 @@ var Pages = ({
     scrollOffset: virtualizer.scrollOffset ?? null
   });
   useFitWidth({ viewportRef: containerRef });
-  const largestPageWidth = usePdf(selectLargestPageWidth);
+  const largestPageWidth = useMemo(
+    () => viewports.reduce((max, viewport) => Math.max(max, viewport.width), 0),
+    [viewports]
+  );
   useEffect(() => {
     virtualizer.getOffsetForAlignment = (toOffset, align, itemSize = 0) => {
       const size = virtualizer.getSize();
@@ -6814,7 +6858,9 @@ var Pages = ({
         {
           ref: elementWrapperRef,
           style: {
-            width: "max-content",
+            // The absolute page list contributes no intrinsic width. Reserve
+            // its width before any zoom effect runs (including zoom === 1).
+            width: largestPageWidth,
             marginLeft: "auto",
             marginRight: "auto",
             flexShrink: 0
@@ -6855,6 +6901,36 @@ var Pages = ({
   );
 };
 
+// src/lib/map-concurrent.ts
+async function mapConcurrent(items, concurrency, map, isCancelled = () => false) {
+  if (!Number.isFinite(concurrency) || concurrency < 1)
+    throw new RangeError("Concurrency must be positive and finite");
+  const results = new Array(items.length);
+  let next = 0;
+  let failed = false;
+  const worker = async () => {
+    while (next < items.length) {
+      if (failed || isCancelled())
+        throw new DOMException("Operation aborted", "AbortError");
+      const index = next++;
+      try {
+        results[index] = await map(items[index], index);
+      } catch (error) {
+        failed = true;
+        throw error;
+      }
+    }
+  };
+  await Promise.all(
+    Array.from(
+      { length: Math.min(Math.max(1, Math.floor(concurrency)), items.length) },
+      worker
+    )
+  );
+  if (isCancelled()) throw new DOMException("Operation aborted", "AbortError");
+  return results;
+}
+
 // src/lib/pdfjs.ts
 var pdfJsPromise = null;
 var loadPdfJs = () => {
@@ -6987,7 +7063,6 @@ var usePDFDocumentContext = ({
   colorScheme,
   darkModeColors
 }) => {
-  const [_, setProgress] = useState(0);
   const [initialState, setInitialState] = useState();
   const [rotation] = useState(initialRotation);
   const [renderColorMapRef] = useState(() => ({
@@ -7002,30 +7077,30 @@ var usePDFDocumentContext = ({
   const darkModeColorsRef = useRef(darkModeColors);
   darkModeColorsRef.current = darkModeColors;
   useEffect(() => {
+    let isDisposed = false;
     const generateViewports = async (pdf) => {
       const pageProxies = [];
-      const rotations = [];
-      const viewports = await Promise.all(
-        Array.from({ length: pdf.numPages }, async (_2, index) => {
+      const viewports = await mapConcurrent(
+        Array.from({ length: pdf.numPages }, (_, index) => index),
+        16,
+        async (index) => {
           const page = await pdf.getPage(index + 1);
           const deltaRotate = page.rotate || 0;
           const viewport = page.getViewport({
             scale: 1,
             rotation: rotation + deltaRotate
           });
-          pageProxies.push(page);
-          rotations.push(page.rotate);
+          pageProxies[index] = page;
           return viewport;
-        })
-      );
-      const sortedPageProxies = pageProxies.toSorted(
-        (a, b) => a.pageNumber - b.pageNumber
+        },
+        () => isDisposed
       );
+      if (isDisposed) return;
       setInitialState((prev) => ({
         ...prev,
         isZoomFitWidth,
         viewports,
-        pageProxies: sortedPageProxies,
+        pageProxies,
         pdfDocumentProxy: pdf,
         zoom,
         zoomOptions,
@@ -7036,9 +7111,7 @@ var usePDFDocumentContext = ({
     };
     const loadDocument = () => {
       setInitialState(null);
-      setProgress(0);
       let loadingTask = null;
-      let isDisposed = false;
       void loadPdfJs().then(({ getDocument, version }) => {
         if (isDisposed) {
           return;
@@ -7051,18 +7124,11 @@ var usePDFDocumentContext = ({
             documentOptionsRef.current
           )
         );
-        loadingTask.onProgress = (progressEvent) => {
-          if (progressEvent.loaded === progressEvent.total) {
-            return;
-          }
-          setProgress(progressEvent.loaded / progressEvent.total);
-        };
         return loadingTask.promise.then(async (proxy) => {
           if (isDisposed || loadingTask?.destroyed) {
             return;
           }
           onDocumentLoad?.({ proxy, source });
-          setProgress(1);
           try {
             await generateViewports(proxy);
           } catch (error) {
@@ -7191,31 +7257,122 @@ var Root = forwardRef(
   }
 );
 Root.displayName = "Root";
-var Search = ({ children, loading = "Loading..." }) => {
-  const [isLoading, setIsLoading] = useState(false);
+
+// src/lib/document-text.ts
+var jobs = /* @__PURE__ */ new WeakMap();
+var CONCURRENCY = 4;
+function acquireDocumentText(pages) {
+  let job = jobs.get(pages);
+  if (!job) {
+    const controller = new AbortController();
+    const { signal } = controller;
+    let next = 0;
+    const result = new Array(pages.length);
+    const worker = async () => {
+      while (next < pages.length) {
+        signal.throwIfAborted();
+        const index = next++;
+        const page = pages[index];
+        const reader = page.streamTextContent().getReader();
+        const chunks = [];
+        let complete = false;
+        try {
+          while (true) {
+            const { value, done } = await reader.read();
+            signal.throwIfAborted();
+            if (done) {
+              complete = true;
+              break;
+            }
+            chunks.push(
+              value.items.map((item) => "str" in item ? item.str : "").join("")
+            );
+          }
+        } finally {
+          if (!complete)
+            void reader.cancel(new Error("Text indexing stopped")).catch(() => {
+            });
+          reader.releaseLock();
+        }
+        result[index] = { pageNumber: page.pageNumber, text: chunks.join("") };
+      }
+    };
+    const created = {
+      controller,
+      users: 0,
+      settled: false,
+      promise: Promise.resolve([])
+    };
+    created.promise = Promise.all(
+      Array.from({ length: Math.min(CONCURRENCY, pages.length) }, worker)
+    ).then(() => result).catch((error) => {
+      controller.abort();
+      if (jobs.get(pages) === created) jobs.delete(pages);
+      throw error;
+    }).finally(() => {
+      created.settled = true;
+    });
+    jobs.set(pages, created);
+    job = created;
+  }
+  job.users++;
+  const acquired = job;
+  let released = false;
+  return {
+    promise: acquired.promise,
+    release() {
+      if (released) return;
+      released = true;
+      acquired.users--;
+      queueMicrotask(() => {
+        if (acquired.users || acquired.settled) return;
+        if (jobs.get(pages) === acquired) jobs.delete(pages);
+        acquired.controller.abort();
+      });
+    }
+  };
+}
+var Search = ({
+  children,
+  loading = "Loading...",
+  errorFallback
+}) => {
+  const [result, setResult] = useState(null);
+  const [attempt, setAttempt] = useState(0);
   const proxies = usePdf((state) => state.pageProxies);
   const setTextContent = usePdf((state) => state.setTextContent);
-  const getTextContent = useCallback(
-    async (pages) => {
-      setIsLoading(true);
-      const promises = pages.map(async (proxy) => {
-        const content = await proxy.getTextContent();
-        const text2 = content.items.map((item) => item?.str || "").join("");
-        return Promise.resolve({
-          pageNumber: proxy.pageNumber,
-          text: text2
-        });
-      });
-      const text = await Promise.all(promises);
-      setIsLoading(false);
-      setTextContent(text);
-    },
-    [setTextContent]
-  );
+  const retry = useCallback(() => {
+    setResult(null);
+    setAttempt((value) => value + 1);
+  }, []);
   useEffect(() => {
-    getTextContent(proxies);
-  }, [proxies, getTextContent]);
-  return isLoading ? loading : children;
+    let disposed = false;
+    setResult(null);
+    const task = acquireDocumentText(proxies);
+    void task.promise.then((text) => {
+      if (disposed) return;
+      setTextContent(text);
+      setResult({ pages: proxies, status: "ready" });
+    }).catch((error) => {
+      if (disposed) return;
+      console.error("Error extracting PDF text", error);
+      setResult({ pages: proxies, status: "error", error });
+    });
+    return () => {
+      disposed = true;
+      task.release();
+    };
+  }, [proxies, setTextContent, attempt]);
+  if (!result || result.pages !== proxies) return loading;
+  if (result.status === "error") {
+    if (errorFallback) return errorFallback({ error: result.error, retry });
+    return /* @__PURE__ */ jsxs("div", { role: "alert", children: [
+      "Unable to index this document for search.",
+      " ",
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: retry, children: "Retry" })
+    ] });
+  }
+  return children;
 };
 var DEFAULT_CONFIG = {
   maxHeight: 800,
@@ -7308,10 +7465,11 @@ var useThumbnail = (pageNumber, config = {}) => {
 };
 var Thumbnail = ({
   pageNumber = 1,
+  eager = false,
   ...props
 }) => {
   const { canvasRef, containerRef, isVisible } = useThumbnail(pageNumber, {
-    isFirstPage: pageNumber < 5
+    isFirstPage: eager || pageNumber < 5
   });
   const { jumpToPage } = usePdfJump();
   return /* @__PURE__ */ jsx("div", { ref: containerRef, style: { minHeight: "150px", minWidth: "10px" }, children: isVisible && /* @__PURE__ */ jsx(
@@ -7338,16 +7496,107 @@ var Thumbnail = ({
     }
   ) });
 };
+function VirtualizedThumbnails({
+  children,
+  count,
+  virtualize,
+  style,
+  onKeyDown,
+  ref,
+  ...props
+}) {
+  const containerRef = useRef(null);
+  useImperativeHandle(ref, () => containerRef.current);
+  const [focusPage, setFocusPage] = useState(null);
+  const itemHeight = Number.isFinite(virtualize.itemHeight) ? Math.max(1, virtualize.itemHeight) : 150;
+  const virtualizer = useVirtualizer({
+    count,
+    getScrollElement: () => containerRef.current,
+    estimateSize: () => itemHeight,
+    overscan: virtualize.overscan ?? 2
+  });
+  const items = virtualizer.getVirtualItems();
+  useLayoutEffect(() => {
+    if (focusPage === null) return;
+    const canvas = containerRef.current?.querySelector(
+      `[data-thumbnail-page="${focusPage}"] canvas`
+    );
+    if (canvas) {
+      canvas.focus({ preventScroll: true });
+      setFocusPage(null);
+    }
+  }, [focusPage, items]);
+  return /* @__PURE__ */ jsx(
+    Primitive.div,
+    {
+      ...props,
+      ref: containerRef,
+      style: {
+        height: "100%",
+        overflow: "auto",
+        position: "relative",
+        ...style
+      },
+      onKeyDown: (event) => {
+        onKeyDown?.(event);
+        if (event.defaultPrevented || !count) return;
+        const row = event.target.closest(
+          "[data-thumbnail-page]"
+        );
+        if (!row) return;
+        const current = Number(row.dataset.thumbnailPage) - 1;
+        const next = event.key === "Home" ? 0 : event.key === "End" ? count - 1 : event.key === "ArrowDown" ? Math.min(count - 1, current + 1) : event.key === "ArrowUp" ? Math.max(0, current - 1) : null;
+        if (next === null) return;
+        event.preventDefault();
+        virtualizer.scrollToIndex(next, { align: "auto" });
+        setFocusPage(next + 1);
+      },
+      children: /* @__PURE__ */ jsx("div", { style: { height: virtualizer.getTotalSize(), position: "relative" }, children: items.map((item) => /* @__PURE__ */ jsx(
+        "div",
+        {
+          "data-thumbnail-page": item.index + 1,
+          style: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            width: "100%",
+            height: itemHeight,
+            transform: `translateY(${item.start}px)`
+          },
+          children: cloneElement(
+            children,
+            { pageNumber: item.index + 1, eager: true }
+          )
+        },
+        item.key
+      )) })
+    }
+  );
+}
 var Thumbnails = ({
   children,
+  virtualize,
   ...props
 }) => {
   const pageCount = usePdf((state) => state.pdfDocumentProxy.numPages);
-  return /* @__PURE__ */ jsx(Primitive.div, { ...props, children: Array.from({
-    length: pageCount
-  }).map((_, index) => {
-    return cloneElement(children, { key: index, pageNumber: index + 1 });
-  }) });
+  if (virtualize)
+    return /* @__PURE__ */ jsx(
+      VirtualizedThumbnails,
+      {
+        ...props,
+        virtualize,
+        count: pageCount,
+        children
+      }
+    );
+  return /* @__PURE__ */ jsx(Primitive.div, { ...props, children: Array.from(
+    { length: pageCount },
+    (_, index) => cloneElement(children, {
+      // biome-ignore lint/suspicious/noArrayIndexKey: a PDF page has a stable ordinal within this document
+      key: index,
+      pageNumber: index + 1
+    })
+  ) });
 };
 var ZoomIn = ({ ...props }) => {
   const setZoom = usePdf((state) => state.updateZoom);
@@ -7405,220 +7654,277 @@ var CurrentZoom = ({ ...props }) => {
     }
   );
 };
-function levenshteinDistance(a, b) {
-  const matrix = [];
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1,
-          matrix[i][j - 1] + 1,
-          matrix[i - 1][j] + 1
+
+// src/lib/search.ts
+var normalizedPages = /* @__PURE__ */ new WeakMap();
+function normalize(page) {
+  let cached = normalizedPages.get(page);
+  if (!cached || cached.text !== page.text) {
+    cached = { text: page.text, lower: page.text.toLowerCase() };
+    normalizedPages.set(page, cached);
+  }
+  return cached.lower;
+}
+function createBoundedDistance(query, maxDistance) {
+  const length = query.length;
+  let previous = new Float64Array(length + 1);
+  let current = new Float64Array(length + 1);
+  const exceeded = maxDistance + 1;
+  return (text, offset3) => {
+    const size = Math.min(length, text.length - offset3);
+    if (length - size > maxDistance) return exceeded;
+    for (let j = 0; j <= length; j++) previous[j] = j;
+    for (let i = 1; i <= size; i++) {
+      const start = Math.max(1, i - maxDistance);
+      const end = Math.min(length, i + maxDistance);
+      current[0] = i;
+      if (start > 1) current[start - 1] = exceeded;
+      let minimum = exceeded;
+      const code = text.charCodeAt(offset3 + i - 1);
+      for (let j = start; j <= end; j++) {
+        const value = Math.min(
+          previous[j] + 1,
+          current[j - 1] + 1,
+          previous[j - 1] + (query.charCodeAt(j - 1) === code ? 0 : 1)
         );
+        current[j] = value;
+        minimum = Math.min(minimum, value);
       }
+      if (end < length) current[end + 1] = exceeded;
+      if (minimum > maxDistance) return exceeded;
+      [previous, current] = [current, previous];
     }
+    return previous[length];
+  };
+}
+function insertMatch(matches, match, limit) {
+  if (!limit || matches.length === limit && matches[limit - 1].score >= match.score)
+    return;
+  let low = 0;
+  let high = matches.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if (matches[mid].score >= match.score) low = mid + 1;
+    else high = mid;
+  }
+  matches.splice(low, 0, match);
+  if (matches.length > limit) matches.pop();
+}
+function* runSearch(pages, searchText, options = {}, cooperative = false, budget = 8) {
+  const empty = { exactMatches: [], fuzzyMatches: [], hasMoreResults: false };
+  if (!searchText.trim()) return empty;
+  const threshold = Math.max(0, Math.min(1, options.threshold ?? 0.7));
+  const limit = Number.isFinite(options.limit) ? Math.max(0, Math.floor(options.limit)) : 10;
+  const textSize = options.textSize ?? 100;
+  const query = searchText.toLowerCase();
+  const maxDistance = Math.floor(query.length * (1 - threshold));
+  const distance = maxDistance > 0 ? createBoundedDistance(query, maxDistance) : null;
+  const exactMatches = [];
+  const fuzzyMatches = [];
+  let exactCount = 0;
+  let fuzzyCount = 0;
+  let steps = 0;
+  let deadline = cooperative ? performance.now() + budget : 0;
+  for (const page of pages) {
+    const lower = normalize(page);
+    const exactStarts = [];
+    let index = 0;
+    while (true) {
+      if (cooperative && (++steps & 127) === 0 && performance.now() >= deadline) {
+        yield;
+        deadline = performance.now() + budget;
+      }
+      const matchIndex = lower.indexOf(query, index);
+      if (matchIndex === -1) break;
+      exactCount++;
+      if (maxDistance > 0) exactStarts.push(matchIndex);
+      if (exactMatches.length < limit) {
+        exactMatches.push({
+          pageNumber: page.pageNumber,
+          text: page.text.substr(matchIndex, searchText.length + textSize),
+          score: 1,
+          matchIndex,
+          isExactMatch: true,
+          searchText
+        });
+      }
+      index = matchIndex + searchText.length;
+    }
+    if (!(maxDistance > 0)) continue;
+    index = 0;
+    let exactIndex = 0;
+    while (index < lower.length) {
+      if (cooperative && (++steps & 127) === 0 && performance.now() >= deadline) {
+        yield;
+        deadline = performance.now() + budget;
+      }
+      while (exactIndex < exactStarts.length && exactStarts[exactIndex] + searchText.length <= index)
+        exactIndex++;
+      const exactStart = exactStarts[exactIndex];
+      if (exactStart !== void 0 && index >= exactStart) {
+        index = exactStart + searchText.length;
+        continue;
+      }
+      const edits = distance(lower, index);
+      if (edits > 0 && edits <= maxDistance) {
+        fuzzyCount++;
+        const score = 1 - edits / query.length;
+        if (fuzzyMatches.length < limit || score > (fuzzyMatches[limit - 1]?.score ?? Infinity)) {
+          insertMatch(
+            fuzzyMatches,
+            {
+              pageNumber: page.pageNumber,
+              text: page.text.substr(index, query.length + textSize),
+              score,
+              matchIndex: index,
+              isExactMatch: false,
+              searchText
+            },
+            limit
+          );
+        }
+        index += query.length;
+      } else index++;
+    }
+  }
+  const exactLimit = Math.min(
+    exactCount,
+    Math.max(Math.ceil(limit / 2), limit - fuzzyCount)
+  );
+  return {
+    exactMatches: exactMatches.slice(0, exactLimit),
+    fuzzyMatches: fuzzyMatches.slice(0, limit - exactLimit),
+    hasMoreResults: exactCount + fuzzyCount > limit
+  };
+}
+function searchDocument(pages, searchText, options = {}) {
+  return runSearch(pages, searchText, options).next().value;
+}
+async function searchDocumentAsync(pages, searchText, options = {}) {
+  const budget = Number.isFinite(options.timeSliceMs) ? Math.max(1, options.timeSliceMs) : 8;
+  const iterator = runSearch(pages, searchText, options, true, budget);
+  while (true) {
+    if (options.signal?.aborted)
+      throw new DOMException("Search aborted", "AbortError");
+    const result = iterator.next();
+    if (result.done) return result.value;
+    await new Promise((resolve) => setTimeout(resolve, 0));
   }
-  return matrix[b.length][a.length];
 }
+
+// src/hooks/search/useSearch.tsx
 var useSearch = () => {
   const textContent = usePdf((state) => state.textContent);
+  const activeSearch = useRef(null);
+  const [isSearching, setIsSearching] = useState(false);
   const [keywords] = useState([]);
   const [searchResults, setSearchResults] = useState({
     exactMatches: [],
     fuzzyMatches: [],
     hasMoreResults: false
   });
-  const findExactMatches = useCallback(
-    (searchText, text, pageNumber, textSize) => {
-      const results = [];
-      const textLower = text.toLowerCase();
-      const searchLower = searchText.toLowerCase();
-      let index = 0;
-      while (true) {
-        const matchIndex = textLower.indexOf(searchLower, index);
-        if (matchIndex === -1) break;
-        results.push({
-          pageNumber,
-          text: text.substr(matchIndex, searchText.length + textSize),
-          score: 1,
-          matchIndex,
-          isExactMatch: true,
-          searchText
+  useEffect(() => {
+    setIsSearching(false);
+    return () => {
+      activeSearch.current?.abort();
+      activeSearch.current = null;
+    };
+  }, [textContent]);
+  const cancelSearch = useCallback(() => {
+    activeSearch.current?.abort();
+    activeSearch.current = null;
+    setIsSearching(false);
+  }, []);
+  const searchAsync = useCallback(
+    async (searchText, options = {}) => {
+      activeSearch.current?.abort();
+      const controller = new AbortController();
+      activeSearch.current = controller;
+      const abort = () => controller.abort();
+      if (options.signal?.aborted) abort();
+      else options.signal?.addEventListener("abort", abort, { once: true });
+      setIsSearching(true);
+      try {
+        const results = await searchDocumentAsync(textContent, searchText, {
+          ...options,
+          signal: controller.signal
         });
-        index = matchIndex + searchText.length;
-      }
-      return results;
-    },
-    []
-  );
-  const findFuzzyMatches = useCallback(
-    (searchText, text, pageNumber, threshold, excludeIndices, textSize) => {
-      const results = [];
-      const textLower = text.toLowerCase();
-      const searchLower = searchText.toLowerCase();
-      let index = 0;
-      while (index < textLower.length) {
-        if (excludeIndices.has(index)) {
-          index++;
-          continue;
-        }
-        const chunk = textLower.substr(index, searchLower.length + 10);
-        const distance = levenshteinDistance(
-          searchLower,
-          chunk.substr(0, searchLower.length)
-        );
-        const maxDistance = Math.floor(searchLower.length * (1 - threshold));
-        if (distance <= maxDistance && distance > 0) {
-          const score = 1 - distance / searchLower.length;
-          results.push({
-            pageNumber,
-            text: text.substr(index, searchLower.length + textSize),
-            score,
-            matchIndex: index,
-            isExactMatch: false,
-            searchText
-          });
-          index += searchLower.length;
-        } else {
-          index++;
+        if (controller.signal.aborted)
+          throw new DOMException("Search aborted", "AbortError");
+        if (activeSearch.current === controller) setSearchResults(results);
+        return results;
+      } finally {
+        options.signal?.removeEventListener("abort", abort);
+        if (activeSearch.current === controller) {
+          activeSearch.current = null;
+          setIsSearching(false);
         }
       }
-      return results;
     },
-    []
+    [textContent]
   );
   const search = useCallback(
     (searchText, options = {}) => {
-      const { threshold = 0.7, limit = 10, textSize = 100 } = options;
-      if (!searchText.trim()) {
-        const emptyResults = {
-          exactMatches: [],
-          fuzzyMatches: [],
-          hasMoreResults: false
-        };
-        setSearchResults(emptyResults);
-        return emptyResults;
-      }
-      let exactMatches = [];
-      let fuzzyMatches = [];
-      const exactMatchIndices = /* @__PURE__ */ new Set();
-      textContent.forEach(({ pageNumber, text }) => {
-        const matches = findExactMatches(
-          searchText,
-          text,
-          pageNumber,
-          textSize
-        );
-        exactMatches = [...exactMatches, ...matches];
-        matches.forEach((match) => {
-          for (let i = 0; i < searchText.length; i++) {
-            exactMatchIndices.add(match.matchIndex + i);
-          }
-        });
-      });
-      textContent.forEach(({ pageNumber, text }) => {
-        const matches = findFuzzyMatches(
-          searchText,
-          text,
-          pageNumber,
-          threshold,
-          exactMatchIndices,
-          textSize
-        );
-        fuzzyMatches = [...fuzzyMatches, ...matches];
-      });
-      exactMatches.sort((a, b) => b.score - a.score);
-      fuzzyMatches.sort((a, b) => b.score - a.score);
-      const exactLimit = Math.min(exactMatches.length, Math.ceil(limit / 2));
-      const fuzzyLimit = Math.min(fuzzyMatches.length, limit - exactLimit);
-      const limitedResults = {
-        exactMatches: exactMatches.slice(0, exactLimit),
-        fuzzyMatches: fuzzyMatches.slice(0, fuzzyLimit),
-        hasMoreResults: exactMatches.length + fuzzyMatches.length > limit
-      };
-      setSearchResults(limitedResults);
-      return limitedResults;
+      cancelSearch();
+      const results = searchDocument(textContent, searchText, options);
+      setSearchResults(results);
+      return results;
     },
-    [textContent, findExactMatches, findFuzzyMatches]
+    [textContent, cancelSearch]
   );
   return {
     textContent,
     keywords,
     searchResults,
-    search
+    search,
+    searchAsync,
+    cancelSearch,
+    isSearching
   };
 };
 
 // src/hooks/search/useSearchPosition.tsx
 async function calculateHighlightRects(pageProxy, textMatch) {
+  const matchLength = textMatch.searchText ? textMatch.searchText.length : textMatch.text.length;
+  if (matchLength === 0 || !Number.isFinite(textMatch.matchIndex) || textMatch.matchIndex < 0)
+    return [];
+  const matchEnd = textMatch.matchIndex + matchLength;
   const reader = pageProxy.streamTextContent().getReader();
-  const items = [];
+  const matchRects = [];
+  const viewport = pageProxy.getViewport({ scale: 1 });
+  let offset3 = 0;
+  let foundEnd = false;
   try {
-    for (; ; ) {
+    read: while (true) {
       const { value, done } = await reader.read();
       if (done) break;
-      items.push(
-        ...value.items.filter((item) => "str" in item)
-      );
+      for (const item of value.items) {
+        if (!("str" in item) || item.str.length === 0) continue;
+        const length = item.str.length;
+        const start = Math.max(0, textMatch.matchIndex - offset3);
+        const end = Math.min(length, matchEnd - offset3);
+        if (end > start) {
+          matchRects.push({
+            pageNumber: textMatch.pageNumber,
+            left: item.transform[4] + start * (item.width / length),
+            top: viewport.height - (item.transform[5] + item.height),
+            width: (end - start) * (item.width / length),
+            height: item.height
+          });
+        }
+        offset3 += length;
+        if (offset3 >= matchEnd) {
+          foundEnd = true;
+          break read;
+        }
+      }
     }
   } finally {
+    if (foundEnd)
+      void reader.cancel(new Error("Highlight range found")).catch(() => {
+      });
     reader.releaseLock();
   }
-  const matchLength = textMatch.searchText ? textMatch.searchText.length : textMatch.text.length;
-  const matchRects = [];
-  let currentIndex = 0;
-  let remainingMatchLength = matchLength;
-  let foundStart = false;
-  const viewport = pageProxy.getViewport({ scale: 1 });
-  for (let i = 0; i < items.length; i++) {
-    const item = items[i];
-    if (!item) continue;
-    const itemLength = item.str.length;
-    if (!foundStart && currentIndex <= textMatch.matchIndex && textMatch.matchIndex < currentIndex + itemLength) {
-      foundStart = true;
-      const matchStartInItem = textMatch.matchIndex - currentIndex;
-      const matchLengthInItem = Math.min(
-        itemLength - matchStartInItem,
-        remainingMatchLength
-      );
-      const transform = item.transform;
-      const y = viewport.height - (transform[5] + item.height);
-      const rect = {
-        pageNumber: textMatch.pageNumber,
-        left: transform[4] + matchStartInItem * (item.width / itemLength),
-        top: y,
-        width: matchLengthInItem * (item.width / itemLength),
-        height: item.height
-      };
-      matchRects.push(rect);
-      remainingMatchLength -= matchLengthInItem;
-    } else if (foundStart && remainingMatchLength > 0) {
-      const matchLengthInItem = Math.min(itemLength, remainingMatchLength);
-      const transform = item.transform;
-      const y = viewport.height - (transform[5] + item.height);
-      const rect = {
-        pageNumber: textMatch.pageNumber,
-        left: transform[4],
-        top: y,
-        width: matchLengthInItem * (item.width / itemLength),
-        height: item.height
-      };
-      matchRects.push(rect);
-      remainingMatchLength -= matchLengthInItem;
-    }
-    if (remainingMatchLength <= 0 && foundStart) {
-      break;
-    }
-    currentIndex += itemLength;
-  }
   return mergeAdjacentRects(matchRects);
 }
 function mergeAdjacentRects(rects) {
@@ -7646,4 +7952,4 @@ function mergeAdjacentRects(rects) {
 // src/hooks/usePageRendered.ts
 var usePageRendered = (pageNumber) => usePdf((state) => !!state.renderedPages[pageNumber]);
 
-export { AnnotationHighlightLayer, AnnotationLayer, AnnotationTooltip, AnnotationsStoreProvider, CanvasLayer, ColoredHighlightLayer, CurrentPage, CurrentZoom, CustomLayer, DEFAULT_DARK_MODE_COLORS, HighlightLayer, LinkService, NextPage, Outline, OutlineChildItems, OutlineItem, PDFLinkServiceContext, Page, Pages, PreviousPage, Root, Search, SelectionTooltip, TextLayer, Thumbnail, Thumbnails, TotalPages, ZoomIn, ZoomOut, calculateHighlightRects, createDarkModeColorMap, useAnnotations, useCreatePDFLinkService, usePDFLinkService, usePDFPageNumber, usePageRendered, usePdf, usePdfJump, useSearch, useSelectionDimensions };
+export { AnnotationHighlightLayer, AnnotationLayer, AnnotationTooltip, AnnotationsStoreProvider, CanvasLayer, ColoredHighlightLayer, CurrentPage, CurrentZoom, CustomLayer, DEFAULT_DARK_MODE_COLORS, HighlightLayer, LinkService, NextPage, Outline, OutlineChildItems, OutlineItem, PDFLinkServiceContext, Page, Pages, PreviousPage, Root, Search, SelectionTooltip, TextLayer, Thumbnail, Thumbnails, TotalPages, ZoomIn, ZoomOut, calculateHighlightRects, createDarkModeColorMap, useAnnotations, useCreatePDFLinkService, usePDFLinkService, usePDFPageNumber, usePageAnnotations, usePageRendered, usePdf, usePdfJump, useSearch, useSelectionDimensions };