@anaralabs/lector 3.14.12 → 3.15.0

package/dist/index.js

@@ -1,6 +1,6 @@
 'use client';
 
-import React, { createContext, memo, forwardRef, useMemo, cloneElement, useEffect, useRef, useState, useCallback, useContext, useLayoutEffect, createRef, useSyncExternalStore, useImperativeHandle } from 'react';
+import React, { createContext, memo, forwardRef, useMemo, cloneElement, useEffect, useRef, useLayoutEffect, useContext, useState, useCallback, useSyncExternalStore, createRef, 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';
@@ -9,7 +9,7 @@ import { useShallow } from 'zustand/react/shallow';
 import { useDebounce } from 'use-debounce';
 import { v4 } from 'uuid';
 import { Slot } from '@radix-ui/react-slot';
-import { useVirtualizer, elementScroll, debounce } from '@tanstack/react-virtual';
+import { useVirtualizer, elementScroll, observeElementRect } from '@tanstack/react-virtual';
 
 // src/lib/clamp.ts
 var clamp = (value, minimum, maximum) => {
@@ -219,6 +219,828 @@ function createDarkModeColorMap(colors) {
   return map;
 }
 
+// src/lib/selection-page.ts
+var SelectionPage = class {
+  constructor(element, pageNumber, width, height) {
+    this.element = element;
+    this.pageNumber = pageNumber;
+    this.width = width;
+    this.height = height;
+    const walker = element.ownerDocument.createTreeWalker(
+      element,
+      NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT
+    );
+    const chunks = [];
+    const lineBreaks = [];
+    let offset3 = 0;
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+      if (node.nodeType === Node.TEXT_NODE) {
+        const text = node.textContent ?? "";
+        if (!text) continue;
+        this.nodes.push({
+          node,
+          start: offset3,
+          end: offset3 + text.length
+        });
+        chunks.push(text);
+        offset3 += text.length;
+      } else if (node.tagName === "BR") lineBreaks.push(offset3);
+    }
+    this.content = { text: chunks.join(""), lineBreaks };
+  }
+  nodes = [];
+  content;
+  offset(node, offset3) {
+    if (!this.element.contains(node)) return null;
+    const item = this.nodes.find((item2) => item2.node === node);
+    if (item)
+      return item.start + Math.max(0, Math.min(offset3, item.end - item.start));
+    const range = this.element.ownerDocument.createRange();
+    range.selectNodeContents(this.element);
+    try {
+      range.setEnd(node, offset3);
+    } catch {
+      return null;
+    }
+    return Math.min(range.toString().length, this.content.text.length);
+  }
+  point(offset3, end = false) {
+    const index = Math.max(0, Math.min(offset3, this.content.text.length));
+    const item = this.nodes.find((item2) => end ? item2.end >= index : item2.end > index) ?? this.nodes.at(-1);
+    return item ? { node: item.node, offset: Math.max(0, index - item.start) } : null;
+  }
+  rects(from, to) {
+    const bounds = this.element.getBoundingClientRect();
+    const scaleX = bounds.width / this.width || 1;
+    const scaleY = bounds.height / this.height || 1;
+    const rects = [];
+    for (const item of this.nodes) {
+      const start = Math.max(from, item.start);
+      const end = Math.min(to, item.end);
+      if (end <= start || !item.node.textContent?.slice(start - item.start, end - item.start).trim())
+        continue;
+      const range = this.element.ownerDocument.createRange();
+      range.setStart(item.node, start - item.start);
+      range.setEnd(item.node, end - item.start);
+      for (const rect of range.getClientRects()) {
+        if (rect.width <= 0 || rect.height <= 0) continue;
+        rects.push({
+          pageNumber: this.pageNumber,
+          left: (rect.left - bounds.left) / scaleX,
+          top: (rect.top - bounds.top) / scaleY,
+          width: rect.width / scaleX,
+          height: rect.height / scaleY
+        });
+      }
+    }
+    return rects;
+  }
+};
+async function withSelectionPage(proxy, owner, signal, read) {
+  signal.throwIfAborted();
+  const { TextLayer: TextLayer2 } = await import('pdfjs-dist/legacy/build/pdf.mjs');
+  signal.throwIfAborted();
+  const viewport = proxy.getViewport({ scale: 1 });
+  const container = owner.createElement("div");
+  container.className = "textLayer";
+  container.setAttribute("aria-hidden", "true");
+  container.style.cssText = `position:fixed;left:-100000px;top:0;visibility:hidden;pointer-events:none;width:${viewport.width}px;height:${viewport.height}px;--scale-factor:1;--total-scale-factor:1;`;
+  owner.body.append(container);
+  let layer;
+  const cancel = () => layer?.cancel();
+  signal.addEventListener("abort", cancel, { once: true });
+  try {
+    layer = new TextLayer2({
+      container,
+      viewport,
+      textContentSource: proxy.streamTextContent()
+    });
+    await layer.render();
+    signal.throwIfAborted();
+    const unrotated = proxy.getViewport({ scale: 1, rotation: 0 });
+    container.style.width = `${unrotated.width}px`;
+    container.style.height = `${unrotated.height}px`;
+    return read(
+      new SelectionPage(
+        container,
+        proxy.pageNumber,
+        viewport.width,
+        viewport.height
+      )
+    );
+  } finally {
+    signal.removeEventListener("abort", cancel);
+    layer?.cancel();
+    container.remove();
+  }
+}
+
+// src/lib/text-normalization.ts
+function replace(source, replacements2) {
+  const chunks = [];
+  const edits = [];
+  let offset3 = 0;
+  let outputLength = 0;
+  for (const replacement of replacements2) {
+    const { index, length, text } = replacement;
+    if (source.text.slice(index, index + length) === text) continue;
+    const before = source.text.slice(offset3, index);
+    chunks.push(before, text);
+    outputLength += before.length;
+    edits.push({
+      start: outputLength,
+      end: outputLength + text.length,
+      sourceStart: index,
+      sourceEnd: index + length
+    });
+    outputLength += text.length;
+    offset3 = index + length;
+  }
+  if (!edits.length) return source;
+  chunks.push(source.text.slice(offset3));
+  return { text: chunks.join(""), maps: [...source.maps, edits] };
+}
+function* replacements(text, pattern, value) {
+  for (const match of text.matchAll(pattern)) {
+    yield { index: match.index, length: match[0].length, text: value };
+  }
+}
+function* insertLineBreaks(text, lineBreaks) {
+  let previous = -1;
+  for (const index of lineBreaks) {
+    if (!Number.isInteger(index) || index <= previous || index < 0 || index > text.length)
+      continue;
+    previous = index;
+    yield { index, length: 0, text: "\n" };
+  }
+}
+var ligatures = ["ff", "fi", "fl", "ffi", "ffl", "st", "st"];
+var softHyphen = /\u00ad(?:[^\S\r\n]*\r?\n[^\S\r\n]*(?=\p{L}))?/gu;
+var wrappedHyphen = /(?<=[\p{L}\p{M}])[-\u2010][^\S\r\n]*\r?\n[^\S\r\n]*(?=\p{Ll})/gu;
+var cjkLineBreak = /(?<=[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])\r?\n(?=[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}])/gu;
+function normalizeSelectionText(text, options = {}) {
+  let result = normalizeUnicode(text).replace(softHyphen, "");
+  if (options.ignoreHyphenation) result = result.replace(wrappedHyphen, "");
+  if (options.lineBreaks === "space") {
+    result = result.replace(cjkLineBreak, "").replace(/(?<!\n)\n(?!\n)/g, " ");
+  }
+  return result;
+}
+function normalizeUnicode(text, matchDiacritics = true) {
+  let result = text.replace(
+    /[\uFB00-\uFB06]/g,
+    (char) => ligatures[char.charCodeAt(0) - 64256]
+  );
+  if (!matchDiacritics) {
+    result = result.normalize("NFD").replace(
+      /([\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}])\p{M}+/gu,
+      "$1"
+    );
+  }
+  return result.normalize("NFC");
+}
+var segmenter;
+function* unicodeReplacements(text, matchDiacritics) {
+  segmenter ??= new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  for (const match of text.matchAll(/\p{ASCII}?\P{ASCII}+/gu)) {
+    if (normalizeUnicode(match[0], matchDiacritics) === match[0]) continue;
+    for (const { segment, index } of segmenter.segment(match[0])) {
+      yield {
+        index: match.index + index,
+        length: segment.length,
+        text: normalizeUnicode(segment, matchDiacritics)
+      };
+    }
+  }
+}
+function normalizeSearchText(text, options = {}, lineBreaks = []) {
+  let result = { text, maps: [] };
+  if (lineBreaks.length)
+    result = replace(result, insertLineBreaks(text, lineBreaks));
+  const matchDiacritics = options.matchDiacritics !== false;
+  if (normalizeUnicode(result.text, matchDiacritics) !== result.text) {
+    result = replace(result, unicodeReplacements(result.text, matchDiacritics));
+  }
+  result = replace(result, replacements(result.text, softHyphen, ""));
+  if (options.ignoreHyphenation) {
+    result = replace(result, replacements(result.text, wrappedHyphen, ""));
+  }
+  result = replace(result, replacements(result.text, cjkLineBreak, ""));
+  result = replace(result, replacements(result.text, /\s+/gu, " "));
+  const lower = result.text.toLowerCase();
+  if (lower.length !== result.text.length) {
+    function* caseReplacements(value) {
+      let index = 0;
+      for (const char of value) {
+        const folded = char.toLowerCase();
+        if (folded.length !== char.length)
+          yield { index, length: char.length, text: folded };
+        index += char.length;
+      }
+    }
+    result = replace(result, caseReplacements(result.text));
+  }
+  return { ...result, text: lower };
+}
+function sourceOffset(edits, offset3, end) {
+  let low = 0;
+  let high = edits.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (edits[middle].start <= offset3) low = middle + 1;
+    else high = middle;
+  }
+  const edit = edits[low - 1];
+  if (!edit) return offset3 + (end ? 1 : 0);
+  if (offset3 < edit.end) return end ? edit.sourceEnd : edit.sourceStart;
+  return offset3 + edit.sourceEnd - edit.end + (end ? 1 : 0);
+}
+function originalTextRange(normalized, start, end) {
+  for (let i = normalized.maps.length - 1; i >= 0; i--) {
+    const map = normalized.maps[i];
+    start = sourceOffset(map, start, false);
+    end = sourceOffset(map, end - 1, true);
+  }
+  return { start, end };
+}
+
+// src/lib/pdf-selection.ts
+var sameAnchor = (a, b) => a.pageNumber === b.pageNumber && a.offset === b.offset;
+var compare = (a, b) => a.pageNumber - b.pageNumber || a.offset - b.offset;
+var samePoint = (a, node, offset3) => a.node === node && a.offset === offset3;
+var selectionOwners = /* @__PURE__ */ new WeakMap();
+var PDFSelectionController = class {
+  constructor(options) {
+    this.options = options;
+  }
+  snapshot = null;
+  listeners = /* @__PURE__ */ new Set();
+  layers = /* @__PURE__ */ new Map();
+  pages = /* @__PURE__ */ new Map();
+  container = null;
+  projection = null;
+  frame = null;
+  work = null;
+  structuralChange = false;
+  drag = null;
+  connectedCleanup = null;
+  generation = 0;
+  keyboardWork = null;
+  keyboardMoves = [];
+  getSnapshot = () => this.snapshot;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  get isDragging() {
+    return this.drag !== null;
+  }
+  includesPage(page) {
+    const range = this.ordered();
+    return Boolean(
+      range && page >= range.start.pageNumber && page <= range.end.pageNumber
+    );
+  }
+  publish(snapshot) {
+    this.snapshot = snapshot;
+    for (const listener of this.listeners) listener();
+  }
+  ordered() {
+    if (!this.snapshot) return null;
+    const { anchor, focus } = this.snapshot;
+    return compare(anchor, focus) <= 0 ? { start: anchor, end: focus } : { start: focus, end: anchor };
+  }
+  bounds(page, length) {
+    const range = this.ordered();
+    return {
+      from: page === range.start.pageNumber ? Math.min(range.start.offset, length) : 0,
+      to: page === range.end.pageNumber ? Math.min(range.end.offset, length) : length
+    };
+  }
+  remember(page) {
+    if (!this.includesPage(page.pageNumber)) return;
+    for (const point of [this.snapshot.anchor, this.snapshot.focus]) {
+      if (point.pageNumber === page.pageNumber && point.offset > page.content.text.length)
+        throw new RangeError("Selection offset exceeds page text length");
+    }
+    const { from, to } = this.bounds(page.pageNumber, page.content.text.length);
+    const cached = this.pages.get(page.pageNumber);
+    if (cached?.content.text === page.content.text && cached.from === from && cached.to === to)
+      return;
+    this.pages.set(page.pageNumber, {
+      content: page.content,
+      from,
+      to,
+      rects: page.rects(from, to)
+    });
+  }
+  complete() {
+    const range = this.ordered();
+    if (!range) return false;
+    for (let n = range.start.pageNumber; n <= range.end.pageNumber; n++) {
+      const page = this.pages.get(n);
+      if (!page) return false;
+      const bounds = this.bounds(n, page.content.text.length);
+      if (page.from !== bounds.from || page.to !== bounds.to) return false;
+    }
+    return true;
+  }
+  setSelection = (anchor, focus) => {
+    for (const point of [anchor, focus]) {
+      const text = this.layers.get(point.pageNumber)?.content.text ?? this.pages.get(point.pageNumber)?.content.text;
+      if (text !== void 0 && point.offset > text.length)
+        throw new RangeError("Selection offset exceeds page text length");
+      if (!Number.isInteger(point.pageNumber) || point.pageNumber < 1 || point.pageNumber > this.options.pageCount || !Number.isInteger(point.offset) || point.offset < 0)
+        throw new RangeError(
+          "Selection anchors need a valid page and nonnegative UTF-16 offset"
+        );
+    }
+    if (sameAnchor(anchor, focus)) {
+      const drag = this.drag;
+      this.clear();
+      this.drag = drag;
+      return;
+    }
+    if (this.snapshot && this.snapshot.status !== "error" && sameAnchor(this.snapshot.anchor, anchor) && sameAnchor(this.snapshot.focus, focus))
+      return;
+    if (this.container) {
+      const owner = this.container.ownerDocument;
+      const previous = selectionOwners.get(owner);
+      if (previous !== this) previous?.clear();
+      selectionOwners.set(owner, this);
+    }
+    this.work?.abort();
+    this.keyboardWork?.abort();
+    this.keyboardWork = null;
+    this.generation++;
+    this.snapshot = {
+      anchor: { ...anchor },
+      focus: { ...focus },
+      status: "loading"
+    };
+    for (const n of this.pages.keys())
+      if (!this.includesPage(n)) this.pages.delete(n);
+    for (const page of this.layers.values()) this.remember(page);
+    this.publish({
+      ...this.snapshot,
+      status: this.complete() ? "ready" : "loading"
+    });
+    this.project();
+    this.schedule();
+    this.hydrate();
+  };
+  clear = () => {
+    const owner = this.container?.ownerDocument;
+    if (owner && selectionOwners.get(owner) === this)
+      selectionOwners.delete(owner);
+    this.work?.abort();
+    this.keyboardWork?.abort();
+    this.keyboardWork = null;
+    this.generation++;
+    this.pages.clear();
+    this.keyboardMoves = [];
+    this.drag = null;
+    const selection = this.container?.ownerDocument.getSelection();
+    if (this.projection && selection && samePoint(
+      this.projection.anchor,
+      selection.anchorNode,
+      selection.anchorOffset
+    ) && samePoint(
+      this.projection.focus,
+      selection.focusNode,
+      selection.focusOffset
+    ))
+      selection.removeAllRanges();
+    this.projection = null;
+    if (this.snapshot) this.publish(null);
+  };
+  getText = (options = {}) => {
+    const range = this.ordered();
+    if (!range || !this.complete()) return null;
+    const chunks = [];
+    for (let n = range.start.pageNumber; n <= range.end.pageNumber; n++) {
+      const page = this.pages.get(n);
+      const pieces = [];
+      let offset3 = page.from;
+      for (const end of page.content.lineBreaks) {
+        if (end <= page.from || end >= page.to) continue;
+        pieces.push(page.content.text.slice(offset3, end), "\n");
+        offset3 = end;
+      }
+      pieces.push(page.content.text.slice(offset3, page.to));
+      chunks.push(pieces.join(""));
+    }
+    return normalizeSelectionText(chunks.join("\n\n"), options);
+  };
+  getSelection = (options) => {
+    const text = this.getText(options);
+    if (text === null || !this.snapshot) return null;
+    const range = this.ordered();
+    const highlights = [];
+    for (let n = range.start.pageNumber; n <= range.end.pageNumber; n++)
+      highlights.push(...this.pages.get(n).rects.map((rect) => ({ ...rect })));
+    return {
+      anchor: { ...this.snapshot.anchor },
+      focus: { ...this.snapshot.focus },
+      text,
+      highlights,
+      underlines: highlights.map((rect) => ({
+        ...rect,
+        top: rect.top + rect.height - 1,
+        height: 1
+      })),
+      isCollapsed: false
+    };
+  };
+  getSelectionAsync = async (options) => {
+    const generation = this.generation;
+    await new Promise((resolve) => {
+      if (this.snapshot?.status !== "loading") {
+        resolve();
+        return;
+      }
+      const unsubscribe = this.subscribe(() => {
+        if (generation !== this.generation || this.snapshot?.status !== "loading") {
+          unsubscribe();
+          resolve();
+        }
+      });
+    });
+    if (generation !== this.generation)
+      throw new DOMException("Selection changed", "AbortError");
+    if (this.snapshot?.status === "error") throw this.snapshot.error;
+    return this.getSelection(options);
+  };
+  finishSelection() {
+    if (this.snapshot?.status !== "loading" || !this.complete()) return;
+    this.work?.abort();
+    this.work = null;
+    this.publish({ ...this.snapshot, status: "ready" });
+  }
+  registerLayer(element, pageNumber, width, height) {
+    const page = new SelectionPage(element, pageNumber, width, height);
+    this.layers.set(pageNumber, page);
+    try {
+      this.remember(page);
+      this.finishSelection();
+    } catch (error) {
+      this.work?.abort();
+      if (this.snapshot)
+        this.publish({ ...this.snapshot, status: "error", error });
+    }
+    this.schedule();
+    return () => {
+      if (this.layers.get(pageNumber) !== page) return;
+      this.structuralChange = true;
+      this.layers.delete(pageNumber);
+      this.projection = null;
+      this.schedule();
+    };
+  }
+  anchorFor(node, offset3) {
+    if (!node) return null;
+    for (const [pageNumber, page] of this.layers) {
+      const index = page.offset(node, offset3);
+      if (index !== null) return { pageNumber, offset: index };
+    }
+    return null;
+  }
+  capture = () => {
+    const owner = this.container?.ownerDocument;
+    const active = owner?.activeElement;
+    if (active && active !== owner?.body && !this.container?.contains(active) && !active.closest(
+      'input, textarea, [contenteditable]:not([contenteditable="false"])'
+    ))
+      return;
+    const selection = owner?.getSelection();
+    if (!selection || selection.rangeCount > 1) return;
+    if (this.projection && samePoint(
+      this.projection.anchor,
+      selection.anchorNode,
+      selection.anchorOffset
+    ) && samePoint(
+      this.projection.focus,
+      selection.focusNode,
+      selection.focusOffset
+    ))
+      return;
+    if (this.structuralChange) {
+      this.schedule();
+      return;
+    }
+    if (selection.isCollapsed) {
+      if (this.structuralChange || this.drag || !this.projection && this.snapshot && (!this.layers.has(this.snapshot.anchor.pageNumber) || !this.layers.has(this.snapshot.focus.pageNumber))) {
+        this.schedule();
+        return;
+      }
+      if (this.snapshot) this.clear();
+      return;
+    }
+    const anchor = this.anchorFor(selection.anchorNode, selection.anchorOffset);
+    const focus = this.anchorFor(selection.focusNode, selection.focusOffset);
+    if (anchor && focus) {
+      if (this.drag && !this.drag.started) {
+        if (!this.drag.shift && !this.drag.moved) this.drag.anchor = anchor;
+        this.drag.started = true;
+      }
+      const savedAnchor = this.projection && samePoint(
+        this.projection.anchor,
+        selection.anchorNode,
+        selection.anchorOffset
+      ) ? this.snapshot?.anchor : void 0;
+      this.setSelection(this.drag?.anchor ?? savedAnchor ?? anchor, focus);
+      this.projection = {
+        anchor: { node: selection.anchorNode, offset: selection.anchorOffset },
+        focus: { node: selection.focusNode, offset: selection.focusOffset }
+      };
+    } else if (!this.structuralChange && !this.drag && (selection.anchorNode || selection.focusNode))
+      this.clear();
+  };
+  schedule() {
+    if (!this.container || this.frame !== null) return;
+    this.frame = this.container.ownerDocument.defaultView.requestAnimationFrame(() => {
+      this.frame = null;
+      this.project();
+      this.structuralChange = false;
+      this.flushKeyboard();
+      if (this.drag) this.autoScroll();
+    });
+  }
+  project() {
+    const range = this.ordered();
+    if (!range || !this.container) return;
+    const visible = [...this.layers.values()].filter((page) => this.includesPage(page.pageNumber) && page.nodes.length).sort((a, b) => a.pageNumber - b.pageNumber);
+    const first = visible[0];
+    const last = visible.at(-1);
+    if (!first || !last) return;
+    const start = first.point(
+      this.bounds(first.pageNumber, first.content.text.length).from
+    );
+    const end = last.point(
+      this.bounds(last.pageNumber, last.content.text.length).to,
+      true
+    );
+    if (!start || !end) return;
+    const backwards = compare(this.snapshot.anchor, this.snapshot.focus) > 0;
+    const anchor = backwards ? end : start;
+    const focus = backwards ? start : end;
+    const selection = this.container.ownerDocument.getSelection();
+    this.projection = { anchor, focus };
+    if (!samePoint(anchor, selection.anchorNode, selection.anchorOffset) || !samePoint(focus, selection.focusNode, selection.focusOffset))
+      selection.setBaseAndExtent(
+        anchor.node,
+        anchor.offset,
+        focus.node,
+        focus.offset
+      );
+  }
+  hydrate() {
+    if (!this.snapshot || this.complete() || !this.container) {
+      return;
+    }
+    const range = this.ordered();
+    const owner = this.container.ownerDocument;
+    const controller = new AbortController();
+    this.work = controller;
+    const generation = this.generation;
+    let next = range.start.pageNumber;
+    const worker = async () => {
+      while (next <= range.end.pageNumber) {
+        controller.signal.throwIfAborted();
+        const n = next++;
+        const cached = this.pages.get(n);
+        if (cached) {
+          const bounds = this.bounds(n, cached.content.text.length);
+          if (bounds.from === cached.from && bounds.to === cached.to) continue;
+        }
+        const page = await this.options.loadPage(n);
+        controller.signal.throwIfAborted();
+        await withSelectionPage(
+          page,
+          owner,
+          controller.signal,
+          (page2) => this.remember(page2)
+        );
+      }
+    };
+    void Promise.all([worker(), worker()]).then(() => {
+      if (!controller.signal.aborted && generation === this.generation) {
+        this.finishSelection();
+        this.schedule();
+      }
+    }).catch((error) => {
+      if (!controller.signal.aborted && generation === this.generation && this.snapshot) {
+        this.publish({ ...this.snapshot, status: "error", error });
+        controller.abort();
+      }
+    });
+  }
+  caret(x, y) {
+    const owner = this.container.ownerDocument;
+    const doc = owner;
+    const position = doc.caretPositionFromPoint?.(x, y);
+    if (position) return this.anchorFor(position.offsetNode, position.offset);
+    const range = doc.caretRangeFromPoint?.(x, y);
+    return range ? this.anchorFor(range.startContainer, range.startOffset) : null;
+  }
+  autoScroll() {
+    if (!this.drag?.moved || !this.container) return;
+    const bounds = this.container.getBoundingClientRect();
+    const { x, y } = this.drag;
+    const edge = Math.min(40, bounds.height / 4);
+    const delta = y < bounds.top + edge ? -Math.min(24, (bounds.top + edge - y) * 0.5) : y > bounds.bottom - edge ? Math.min(24, (y - bounds.bottom + edge) * 0.5) : 0;
+    if (delta) this.container.scrollTop += delta;
+    const focus = this.caret(
+      Math.max(bounds.left + 1, Math.min(x, bounds.right - 1)),
+      Math.max(bounds.top + 1, Math.min(y, bounds.bottom - 1))
+    );
+    if (focus) this.setSelection(this.drag.anchor, focus);
+    if (delta) this.schedule();
+  }
+  flushKeyboard() {
+    if (!this.snapshot || !this.keyboardMoves.length || this.keyboardWork)
+      return;
+    const page = this.layers.get(this.snapshot.focus.pageNumber);
+    if (!page) {
+      this.options.revealPage?.(this.snapshot.focus.pageNumber);
+      return;
+    }
+    const move = this.keyboardMoves.shift();
+    const native = this.container.ownerDocument.getSelection();
+    if (!native?.modify) return;
+    const { anchor, focus } = this.snapshot;
+    native.modify("extend", move.direction, move.granularity);
+    const next = this.anchorFor(native.focusNode, native.focusOffset);
+    if (next && !sameAnchor(next, focus)) {
+      this.setSelection(anchor, next);
+    } else {
+      const point = page.point(focus.offset);
+      const rtl = point && this.container.ownerDocument.defaultView.getComputedStyle(
+        point.node.parentElement
+      ).direction === "rtl";
+      const backwards = move.direction === "backward" || move.direction === (rtl ? "right" : "left");
+      if (move.granularity === "lineboundary" || (backwards ? focus.offset > (move.granularity === "line" ? page.content.lineBreaks[0] ?? 0 : 0) : focus.offset < (move.granularity === "line" ? page.content.lineBreaks.at(-1) ?? page.content.text.length : page.content.text.length))) {
+        this.schedule();
+        return;
+      }
+      const n = focus.pageNumber + (backwards ? -1 : 1);
+      if (n >= 1 && n <= this.options.pageCount) {
+        if (!backwards) {
+          this.setSelection(anchor, { pageNumber: n, offset: 0 });
+          this.options.revealPage?.(n);
+        } else {
+          const generation = this.generation;
+          const controller = new AbortController();
+          this.keyboardWork = controller;
+          const owner = this.container.ownerDocument;
+          void this.options.loadPage(n).then(
+            (proxy) => withSelectionPage(
+              proxy,
+              owner,
+              controller.signal,
+              (page2) => page2.content.text.length
+            )
+          ).then((length) => {
+            if (controller.signal.aborted || generation !== this.generation || !this.container)
+              return;
+            this.setSelection(anchor, { pageNumber: n, offset: length });
+            this.options.revealPage?.(n);
+          }).catch(() => {
+          }).finally(() => {
+            if (this.keyboardWork === controller) this.keyboardWork = null;
+            this.schedule();
+          });
+        }
+      }
+    }
+    if (this.keyboardMoves.length) this.schedule();
+  }
+  connect(container) {
+    this.connectedCleanup?.();
+    this.container = container;
+    const owner = container.ownerDocument;
+    const events = new AbortController();
+    const { signal } = events;
+    const down = (event) => {
+      if (event.defaultPrevented) return;
+      const target = event.target instanceof Element ? event.target : null;
+      if (target?.closest("button, a, [role=button], [data-selection-tooltip]"))
+        return;
+      if (!container.contains(event.target)) {
+        this.clear();
+        return;
+      }
+      if (event.defaultPrevented || event.button !== 0 || event.pointerType === "touch" || !container.contains(event.target))
+        return;
+      const point = this.caret(event.clientX, event.clientY);
+      if (!point) return;
+      const anchor = event.shiftKey && this.snapshot ? this.snapshot.anchor : point;
+      if (!event.shiftKey) this.clear();
+      this.drag = {
+        anchor,
+        x: event.clientX,
+        y: event.clientY,
+        pointerId: event.pointerId,
+        moved: false,
+        started: false,
+        shift: event.shiftKey
+      };
+      this.schedule();
+    };
+    const move = (event) => {
+      if (!this.drag || event.pointerId !== this.drag.pointerId) return;
+      this.drag.moved ||= Math.abs(this.drag.x - event.clientX) + Math.abs(this.drag.y - event.clientY) > 2;
+      this.drag.x = event.clientX;
+      this.drag.y = event.clientY;
+      this.schedule();
+    };
+    const up = () => {
+      this.capture();
+      this.drag = null;
+    };
+    owner.addEventListener("selectionchange", this.capture, { signal });
+    owner.addEventListener("pointerdown", down, { signal });
+    owner.addEventListener("pointermove", move, { signal });
+    owner.addEventListener("pointerup", up, { signal });
+    owner.addEventListener("pointercancel", up, { signal });
+    owner.defaultView.addEventListener("blur", up, { signal });
+    const cancelKeyboard = () => {
+      this.keyboardMoves = [];
+      this.keyboardWork?.abort();
+      this.keyboardWork = null;
+    };
+    container.addEventListener(
+      "focusout",
+      (event) => {
+        if (!container.contains(event.relatedTarget))
+          cancelKeyboard();
+      },
+      { signal }
+    );
+    owner.defaultView.addEventListener("blur", cancelKeyboard, { signal });
+    container.addEventListener(
+      "keydown",
+      (event) => {
+        if (event.defaultPrevented || event.target instanceof Element && event.target.closest(
+          'input, textarea, [contenteditable]:not([contenteditable="false"])'
+        ))
+          return;
+        if (event.key === "Escape" && this.snapshot) {
+          this.clear();
+          return;
+        }
+        if (!event.shiftKey || !this.snapshot) return;
+        const directions = {
+          ArrowLeft: "left",
+          ArrowRight: "right",
+          ArrowUp: "backward",
+          ArrowDown: "forward",
+          Home: "backward",
+          End: "forward"
+        };
+        const direction = directions[event.key];
+        if (!direction) return;
+        const native = owner.getSelection();
+        if (!native?.modify) return;
+        event.preventDefault();
+        const boundary = event.key === "Home" || event.key === "End" || event.metaKey && (event.key === "ArrowLeft" || event.key === "ArrowRight");
+        const granularity = boundary ? "lineboundary" : event.key === "ArrowUp" || event.key === "ArrowDown" ? "line" : event.ctrlKey || event.altKey ? "word" : "character";
+        this.keyboardMoves.push({ direction, granularity });
+        this.schedule();
+      },
+      { signal }
+    );
+    const cleanup = () => {
+      events.abort();
+      if (this.frame !== null)
+        owner.defaultView.cancelAnimationFrame(this.frame);
+      this.frame = null;
+      this.clear();
+      this.container = null;
+      this.connectedCleanup = null;
+    };
+    this.connectedCleanup = cleanup;
+    this.hydrate();
+    this.schedule();
+    return cleanup;
+  }
+};
+
+// src/lib/viewport-zoom.ts
+var viewportZoomHandlers = /* @__PURE__ */ new WeakMap();
+function applyViewportZoom(viewport, zoom) {
+  if (viewport) viewportZoomHandlers.get(viewport)?.(zoom);
+}
+function registerViewportZoom(viewport, apply) {
+  viewportZoomHandlers.set(viewport, apply);
+  return () => {
+    if (viewportZoomHandlers.get(viewport) === apply)
+      viewportZoomHandlers.delete(viewport);
+  };
+}
+
 // src/lib/zoom.ts
 var USE_LAYOUT_ZOOM = typeof navigator !== "undefined" && /AppleWebKit/i.test(navigator.userAgent) && !/Chrome|Chromium|Android/i.test(navigator.userAgent);
 var getFitWidthZoom = (containerWidth, viewports, zoomOptions) => {
@@ -255,6 +1077,11 @@ var PDFStore = createZustandContext(
     renderColorMapRef.current = initialColorScheme === "dark" ? createDarkModeColorMap(initialDarkModeColors) : null;
     return createStore((set, get) => ({
       pdfDocumentProxy: initialState.pdfDocumentProxy,
+      selection: new PDFSelectionController({
+        pageCount: initialState.pdfDocumentProxy.numPages,
+        loadPage: (page) => get().loadPdfPageProxy(page),
+        revealPage: (page) => get().virtualizer?.scrollToIndex(page - 1, { align: "auto" })
+      }),
       zoom: initialState.zoom,
       isZoomFitWidth: initialState.isZoomFitWidth ?? false,
       zoomOptions: {
@@ -271,6 +1098,7 @@ var PDFStore = createZustandContext(
             minZoom,
             maxZoom
           );
+          applyViewportZoom(state.viewportRef.current, newZoom);
           return newZoom === state.zoom && isZoomFitWidth === state.isZoomFitWidth ? state : { zoom: newZoom, isZoomFitWidth };
         });
       },
@@ -285,7 +1113,8 @@ var PDFStore = createZustandContext(
         get().updateZoom(clampedZoom, true);
         return clampedZoom;
       },
-      currentPage: 1,
+      currentPage: initialState.initialPage ?? 1,
+      initialPage: initialState.initialPage ?? 1,
       setCurrentPage: (val) => {
         set(
           (state) => state.currentPage === val ? state : { currentPage: val }
@@ -310,9 +1139,18 @@ var PDFStore = createZustandContext(
         );
       },
       pageProxies: initialState.pageProxies,
+      pagesLoaded: initialState.pageProxies.length === initialState.pdfDocumentProxy.numPages,
+      loadPdfPageProxies: () => initialState.pageResources ? initialState.pageResources.loadAll() : Promise.resolve(get().pageProxies),
+      isPageLoaded: (pageNumber) => Boolean(
+        initialState.pageResources?.get(pageNumber) ?? get().pageProxies[pageNumber - 1]
+      ),
+      loadPdfPageProxy: (pageNumber) => initialState.pageResources ? initialState.pageResources.load(pageNumber) : Promise.resolve().then(() => get().getPdfPageProxy(pageNumber)),
       getPdfPageProxy: (pageNumber) => {
-        const proxy = get().pageProxies[pageNumber - 1];
-        if (!proxy) throw new Error(`Page ${pageNumber} does not exist`);
+        const proxy = initialState.pageResources?.get(pageNumber) ?? get().pageProxies[pageNumber - 1];
+        if (!proxy)
+          throw new Error(
+            initialState.pageResources && Number.isInteger(pageNumber) && pageNumber >= 1 && pageNumber <= initialState.pdfDocumentProxy.numPages ? `Page ${pageNumber} is not loaded. Await loadPdfPageProxy(${pageNumber}) first.` : `Page ${pageNumber} does not exist`
+          );
         return proxy;
       },
       textContent: [],
@@ -665,23 +1503,44 @@ var AnnotationTooltip = ({
 };
 var createAnnotationStore = () => createStore((set) => ({
   annotations: [],
-  addAnnotation: (annotation) => set((state) => ({
-    annotations: [...state.annotations, annotation]
-  })),
-  updateAnnotation: (id, updates) => set((state) => ({
-    annotations: state.annotations.map(
-      (annotation) => annotation.id === id ? {
+  addAnnotation: (annotation) => set((state) => {
+    const annotations = [...state.annotations, annotation];
+    updatePageIndex(state.annotations, annotations, /* @__PURE__ */ new Map(), [
+      annotation
+    ]);
+    return { annotations };
+  }),
+  updateAnnotation: (id, updates) => set((state) => {
+    const changes = /* @__PURE__ */ new Map();
+    const keys = Object.keys(updates);
+    const annotations = state.annotations.map((annotation) => {
+      if (annotation.id !== id || keys.every((key) => Object.is(annotation[key], updates[key])))
+        return annotation;
+      const updated = changes.get(annotation) ?? {
         ...annotation,
         ...updates
-      } : annotation
-    )
-  })),
-  deleteAnnotation: (id) => set((state) => ({
-    annotations: state.annotations.filter(
-      (annotation) => annotation.id !== id
-    )
-  })),
-  setAnnotations: (annotations) => set({ annotations })
+      };
+      changes.set(annotation, updated);
+      return updated;
+    });
+    if (!changes.size) return state;
+    updatePageIndex(state.annotations, annotations, changes);
+    return { annotations };
+  }),
+  deleteAnnotation: (id) => set((state) => {
+    const changes = /* @__PURE__ */ new Map();
+    const annotations = state.annotations.filter((annotation) => {
+      if (annotation.id !== id) return true;
+      changes.set(annotation, null);
+      return false;
+    });
+    if (!changes.size) return state;
+    updatePageIndex(state.annotations, annotations, changes);
+    return { annotations };
+  }),
+  setAnnotations: (annotations) => set(
+    (state) => state.annotations === annotations ? state : { annotations }
+  )
 }));
 var AnnotationsStore = createZustandContext(
   () => createAnnotationStore()
@@ -713,9 +1572,7 @@ function annotationsByPage(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);
+    const pages = annotationPages(annotation);
     for (const page of pages) {
       let values = index.get(page);
       if (!values) {
@@ -728,6 +1585,45 @@ function annotationsByPage(annotations) {
   indexes.set(annotations, index);
   return index;
 }
+function annotationPages(annotation) {
+  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);
+  return pages;
+}
+function isOnPage(annotation, page) {
+  return annotation.pageNumber === page || annotation.highlights.some((rect) => rect.pageNumber === page) || annotation.underlines?.some((rect) => rect.pageNumber === page);
+}
+function updatePageIndex(previous, next, changes, appended = []) {
+  const previousIndex = indexes.get(previous);
+  if (!previousIndex) return;
+  const index = new Map(previousIndex);
+  const affected = /* @__PURE__ */ new Set();
+  const movedTo = /* @__PURE__ */ new Set();
+  for (const [before, after] of changes) {
+    const oldPages = annotationPages(before);
+    for (const page of oldPages) affected.add(page);
+    if (after)
+      for (const page of annotationPages(after)) {
+        affected.add(page);
+        if (!oldPages.has(page)) movedTo.add(page);
+      }
+  }
+  for (const page of affected) {
+    const values = movedTo.has(page) ? next.filter((annotation) => isOnPage(annotation, page)) : (previousIndex.get(page) ?? []).flatMap((annotation) => {
+      if (!changes.has(annotation)) return [annotation];
+      const updated = changes.get(annotation);
+      return updated && isOnPage(updated, page) ? [updated] : [];
+    });
+    if (values.length) index.set(page, values);
+    else index.delete(page);
+  }
+  for (const annotation of appended)
+    for (const page of annotationPages(annotation)) {
+      index.set(page, [...index.get(page) ?? [], annotation]);
+    }
+  indexes.set(next, index);
+}
 function usePageAnnotations(pageNumber) {
   return useAnnotations(
     useShallow(
@@ -1035,7 +1931,7 @@ var usePdfJump = () => {
       }
       let scrollOffset;
       if (align === "center") {
-        const viewportHeight = virtualizer.scrollElement?.clientHeight || 0;
+        const viewportHeight = virtualizer.scrollRect?.height ?? 0;
         const rectCenter = pageStart + rectTop + rectHeight / 2;
         scrollOffset = rectCenter - viewportHeight / 2;
       } else {
@@ -2108,6 +3004,69 @@ function applyContextRecolor(ctx, map, options) {
 function removeContextRecolor(ctx) {
   ctx[RECOLOR_CLEANUP]?.();
 }
+
+// src/lib/viewport-invalidation.ts
+var viewportInvalidationRegistry = /* @__PURE__ */ new WeakMap();
+var notifyCallbacks = (entry) => {
+  entry.rafId = null;
+  entry.callbacks.forEach((callback) => {
+    callback();
+  });
+};
+var scheduleInvalidation = (entry) => {
+  if (entry.rafId !== null) {
+    return;
+  }
+  entry.rafId = requestAnimationFrame(() => {
+    notifyCallbacks(entry);
+  });
+};
+var subscribeToViewportInvalidation = (viewport, callback) => {
+  let entry = viewportInvalidationRegistry.get(viewport);
+  if (!entry) {
+    const callbacks = /* @__PURE__ */ new Set();
+    const schedule = () => {
+      const currentEntry = viewportInvalidationRegistry.get(viewport);
+      if (!currentEntry) {
+        return;
+      }
+      scheduleInvalidation(currentEntry);
+    };
+    entry = {
+      callbacks,
+      scrollListener: schedule,
+      windowResizeListener: schedule,
+      resizeObserver: typeof ResizeObserver === "undefined" ? void 0 : new ResizeObserver(schedule),
+      rafId: null
+    };
+    viewport.addEventListener("scroll", entry.scrollListener, {
+      passive: true
+    });
+    window.addEventListener("resize", entry.windowResizeListener, {
+      passive: true
+    });
+    entry.resizeObserver?.observe(viewport);
+    viewportInvalidationRegistry.set(viewport, entry);
+  }
+  entry.callbacks.add(callback);
+  return () => {
+    const currentEntry = viewportInvalidationRegistry.get(viewport);
+    if (!currentEntry) {
+      return;
+    }
+    currentEntry.callbacks.delete(callback);
+    if (currentEntry.callbacks.size > 0) {
+      return;
+    }
+    if (currentEntry.rafId !== null) {
+      cancelAnimationFrame(currentEntry.rafId);
+    }
+    viewport.removeEventListener("scroll", currentEntry.scrollListener);
+    window.removeEventListener("resize", currentEntry.windowResizeListener);
+    currentEntry.resizeObserver?.disconnect();
+    viewportInvalidationRegistry.delete(viewport);
+  };
+};
 var listeners = /* @__PURE__ */ new Set();
 var media;
 var getSnapshot = () => Math.min(window.devicePixelRatio || 1, 3);
@@ -2369,7 +3328,53 @@ var useCanvasLayer = ({ background }) => {
       releaseBuffer();
       throw error;
     }
+    let continuation = null;
+    let idleTimer = null;
+    let unsubscribeViewport = null;
+    let priorityStopped = false;
+    const clearPriorityWait = () => {
+      if (idleTimer !== null) clearTimeout(idleTimer);
+      idleTimer = null;
+      unsubscribeViewport?.();
+      unsubscribeViewport = null;
+    };
+    const resumeWhenVisible = () => {
+      if (priorityStopped || !continuation) return;
+      const { virtualizer, viewportRef } = store.getState();
+      const item = virtualizer?.getVirtualItems().find((candidate) => candidate.index === pageNumber - 1);
+      const offset3 = virtualizer?.scrollOffset;
+      const height = virtualizer?.scrollRect?.height;
+      if (virtualizer?.isScrolling && item && offset3 != null && height && (item.end < offset3 || item.start > offset3 + height)) {
+        if (!unsubscribeViewport && viewportRef.current) {
+          unsubscribeViewport = subscribeToViewportInvalidation(
+            viewportRef.current,
+            resumeWhenVisible
+          );
+        }
+        if (idleTimer === null) {
+          idleTimer = setTimeout(() => {
+            idleTimer = null;
+            resumeWhenVisible();
+          }, 160);
+        }
+        return;
+      }
+      clearPriorityWait();
+      const proceed = continuation;
+      continuation = null;
+      proceed();
+    };
+    const stopPriority = () => {
+      priorityStopped = true;
+      continuation = null;
+      clearPriorityWait();
+    };
+    renderingTask.onContinue = (proceed) => {
+      continuation = proceed;
+      resumeWhenVisible();
+    };
     renderingTask.promise.then(() => {
+      stopPriority();
       if (cancelled) {
         restoreRecolor?.();
         releaseBuffer();
@@ -2414,6 +3419,7 @@ var useCanvasLayer = ({ background }) => {
         releaseBuffer();
       }
     }).catch((error) => {
+      stopPriority();
       restoreRecolor?.();
       releaseBuffer();
       if (cancelled) return;
@@ -2423,102 +3429,38 @@ var useCanvasLayer = ({ background }) => {
     });
     return () => {
       cancelled = true;
+      stopPriority();
       void renderingTask.cancel();
     };
-  }, [
-    pdfPageProxy,
-    background,
-    dpr,
-    zoom,
-    isResizing,
-    isPinching,
-    pageNumber,
-    markPageRendered,
-    docId,
-    recolor,
-    recolorKey,
-    store
-  ]);
-  useEffect(() => {
-    const canvas = canvasRef.current;
-    return () => {
-      unmarkPageRendered(pageNumber);
-      if (canvas) {
-        canvas.width = 0;
-        canvas.height = 0;
-      }
-      paintedRef.current = null;
-    };
-  }, [pageNumber, unmarkPageRendered]);
-  return {
-    canvasRef
-  };
-};
-
-// src/lib/viewport-invalidation.ts
-var viewportInvalidationRegistry = /* @__PURE__ */ new WeakMap();
-var notifyCallbacks = (entry) => {
-  entry.rafId = null;
-  entry.callbacks.forEach((callback) => {
-    callback();
-  });
-};
-var scheduleInvalidation = (entry) => {
-  if (entry.rafId !== null) {
-    return;
-  }
-  entry.rafId = requestAnimationFrame(() => {
-    notifyCallbacks(entry);
-  });
-};
-var subscribeToViewportInvalidation = (viewport, callback) => {
-  let entry = viewportInvalidationRegistry.get(viewport);
-  if (!entry) {
-    const callbacks = /* @__PURE__ */ new Set();
-    const schedule = () => {
-      const currentEntry = viewportInvalidationRegistry.get(viewport);
-      if (!currentEntry) {
-        return;
-      }
-      scheduleInvalidation(currentEntry);
-    };
-    entry = {
-      callbacks,
-      scrollListener: schedule,
-      windowResizeListener: schedule,
-      resizeObserver: typeof ResizeObserver === "undefined" ? void 0 : new ResizeObserver(schedule),
-      rafId: null
+  }, [
+    pdfPageProxy,
+    background,
+    dpr,
+    zoom,
+    isResizing,
+    isPinching,
+    pageNumber,
+    markPageRendered,
+    docId,
+    recolor,
+    recolorKey,
+    store
+  ]);
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    return () => {
+      unmarkPageRendered(pageNumber);
+      if (canvas) {
+        canvas.width = 0;
+        canvas.height = 0;
+      }
+      paintedRef.current = null;
     };
-    viewport.addEventListener("scroll", entry.scrollListener, {
-      passive: true
-    });
-    window.addEventListener("resize", entry.windowResizeListener, {
-      passive: true
-    });
-    entry.resizeObserver?.observe(viewport);
-    viewportInvalidationRegistry.set(viewport, entry);
-  }
-  entry.callbacks.add(callback);
-  return () => {
-    const currentEntry = viewportInvalidationRegistry.get(viewport);
-    if (!currentEntry) {
-      return;
-    }
-    currentEntry.callbacks.delete(callback);
-    if (currentEntry.callbacks.size > 0) {
-      return;
-    }
-    if (currentEntry.rafId !== null) {
-      cancelAnimationFrame(currentEntry.rafId);
-    }
-    viewport.removeEventListener("scroll", currentEntry.scrollListener);
-    window.removeEventListener("resize", currentEntry.windowResizeListener);
-    currentEntry.resizeObserver?.disconnect();
-    viewportInvalidationRegistry.delete(viewport);
+  }, [pageNumber, unmarkPageRendered]);
+  return {
+    canvasRef
   };
 };
-
-// src/hooks/layers/useDetailCanvasLayer.tsx
 var DETAIL_RENDER_IDLE_MS = 80;
 var SCROLL_POLL_MS = 160;
 var ZOOM_DEBOUNCE_MS = 200;
@@ -2976,6 +3918,114 @@ var mergeTextRuns = (rects) => {
   });
 };
 
+// src/lib/selection-text.ts
+function textLayer(node) {
+  const element = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
+  return element?.closest(".textLayer[data-page-number]") ?? null;
+}
+function getPdfSelectionText(selection, container, options = {}) {
+  if (!selection || selection.isCollapsed || selection.rangeCount !== 1)
+    return null;
+  const range = selection.getRangeAt(0);
+  const first = textLayer(range.startContainer);
+  const last = textLayer(range.endContainer);
+  if (!first || !last || !container.contains(first) || !container.contains(last))
+    return null;
+  const layers = [
+    ...container.querySelectorAll(".textLayer[data-page-number]")
+  ].filter((layer) => range.intersectsNode(layer));
+  let previousPage;
+  for (const layer of layers) {
+    const page = Number(layer.dataset.pageNumber);
+    if (!Number.isInteger(page) || page < 1 || previousPage !== void 0 && page !== previousPage + 1)
+      return null;
+    previousPage = page;
+  }
+  const selectedLayers = new Set(layers);
+  const root = range.commonAncestorContainer;
+  const walker = container.ownerDocument.createTreeWalker(
+    root,
+    NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT,
+    {
+      acceptNode(node2) {
+        if (node2.nodeType !== Node.TEXT_NODE && node2.tagName !== "BR")
+          return NodeFilter.FILTER_SKIP;
+        const layer = textLayer(node2);
+        return layer && selectedLayers.has(layer) && range.intersectsNode(node2) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+      }
+    }
+  );
+  const chunks = [];
+  let previousLayer = null;
+  let trailingLineBreaks = 0;
+  let node = root.nodeType === Node.TEXT_NODE ? root : walker.nextNode();
+  while (node) {
+    const layer = textLayer(node);
+    const start = node === range.startContainer ? range.startOffset : 0;
+    const end = node === range.endContainer ? range.endOffset : node.textContent?.length ?? 0;
+    const text = node.nodeType === Node.TEXT_NODE ? node.textContent.slice(start, end) : "\n";
+    if (text) {
+      if (previousLayer && previousLayer !== layer && trailingLineBreaks < 2) {
+        chunks.push("\n".repeat(2 - trailingLineBreaks));
+        trailingLineBreaks = 2;
+      }
+      chunks.push(text);
+      let trailing = 0;
+      for (let i = text.length - 1; i >= 0 && text[i] === "\n"; i--) trailing++;
+      trailingLineBreaks = trailing === text.length ? trailingLineBreaks + trailing : trailing;
+      previousLayer = layer;
+    }
+    node = walker.nextNode();
+  }
+  return normalizeSelectionText(chunks.join(""), options);
+}
+var documents = /* @__PURE__ */ new WeakMap();
+function registerPdfCopy(container, options, read) {
+  const owner = container.ownerDocument;
+  let binding = documents.get(owner);
+  if (!binding) {
+    const registrations = /* @__PURE__ */ new Set();
+    const listener = (event) => {
+      if (event.defaultPrevented || !event.clipboardData) return;
+      const target = event.target;
+      if (target instanceof Element && target.closest(
+        'input, textarea, [contenteditable]:not([contenteditable="false"])'
+      ))
+        return;
+      for (const registration2 of registrations) {
+        const settings = registration2.options();
+        if (settings === false) continue;
+        const persistent = registration2.read?.(settings);
+        if (registration2.read && persistent === void 0) {
+          event.preventDefault();
+          break;
+        }
+        const text = persistent ?? getPdfSelectionText(
+          owner.getSelection(),
+          registration2.container,
+          settings
+        );
+        if (text === null) continue;
+        event.clipboardData.setData("text/plain", text);
+        event.preventDefault();
+        break;
+      }
+    };
+    binding = { registrations, listener };
+    documents.set(owner, binding);
+    owner.addEventListener("copy", listener);
+  }
+  const registration = { container, options, read };
+  binding.registrations.add(registration);
+  return () => {
+    binding.registrations.delete(registration);
+    if (!binding.registrations.size) {
+      owner.removeEventListener("copy", binding.listener);
+      documents.delete(owner);
+    }
+  };
+}
+
 // src/hooks/useSelectionDimensions.tsx
 var MERGE_THRESHOLD = 2;
 var LAYER_ATTRIBUTION_TOLERANCE_PX = 4;
@@ -3023,7 +4073,19 @@ var mapSelectionRectsToLayers = (range) => {
 };
 var useSelectionDimensions = () => {
   const store = PDFStore.useContext();
+  const getText = (options) => {
+    if (store.getState().selection?.getSnapshot())
+      return store.getState().selection.getText(options);
+    const container = store.getState().viewportRef.current;
+    return container ? getPdfSelectionText(
+      container.ownerDocument.getSelection(),
+      container,
+      options
+    ) : null;
+  };
   const getAnnotationDimension = () => {
+    if (store.getState().selection?.getSnapshot())
+      return store.getState().selection.getSelection() ?? void 0;
     const selection = window.getSelection();
     if (!selection || selection.isCollapsed) return;
     const range = selection.getRangeAt(0);
@@ -3161,7 +4223,7 @@ var useSelectionDimensions = () => {
       underlines: consolidateUnderlines(underlineRects).sort(
         (a, b) => a.pageNumber - b.pageNumber
       ),
-      text: range.toString().trim(),
+      text: (getText() ?? range.toString()).trim(),
       isCollapsed: false
     };
   };
@@ -3218,6 +4280,8 @@ var useSelectionDimensions = () => {
     return consolidated;
   };
   const getDimension = () => {
+    if (store.getState().selection?.getSnapshot())
+      return store.getState().selection.getSelection() ?? void 0;
     const selection = window.getSelection();
     if (!selection || selection.isCollapsed) return;
     const range = selection.getRangeAt(0);
@@ -3246,12 +4310,12 @@ var useSelectionDimensions = () => {
     });
     return {
       highlights: highlights.sort((a, b) => a.pageNumber - b.pageNumber),
-      text: range.toString().trim(),
+      text: (getText() ?? range.toString()).trim(),
       isCollapsed: false
     };
   };
   const getSelection = () => getDimension();
-  return { getDimension, getSelection, getAnnotationDimension };
+  return { getDimension, getSelection, getAnnotationDimension, getText };
 };
 var SelectionTooltip = ({ children }) => {
   const [isOpen, setIsOpen] = useState(false);
@@ -3386,6 +4450,7 @@ var SelectionTooltip = ({ children }) => {
   return /* @__PURE__ */ jsx(Fragment, { children: isOpen && /* @__PURE__ */ jsx(
     "div",
     {
+      "data-selection-tooltip": "",
       ref: refs.setFloating,
       style: {
         ...floatingStyles
@@ -3801,13 +4866,13 @@ var createTextSelectionManager = () => {
     }
     selectionChangeAbortController = new AbortController();
     const { signal } = selectionChangeAbortController;
-    const reset = (endDiv, textLayer) => {
-      if (endDiv.parentNode !== textLayer) {
-        textLayer.appendChild(endDiv);
+    const reset = (endDiv, textLayer2) => {
+      if (endDiv.parentNode !== textLayer2) {
+        textLayer2.appendChild(endDiv);
       }
       endDiv.style.width = "";
       endDiv.style.height = "";
-      textLayer.classList.remove("selecting");
+      textLayer2.classList.remove("selecting");
     };
     document.addEventListener(
       "pointerdown",
@@ -3933,12 +4998,14 @@ var useTextLayer = () => {
   const pdfPageProxy = usePdf((state) => state.getPdfPageProxy(pageNumber));
   const viewportRef = usePdf((state) => state.viewportRef);
   const store = PDFStore.useContext();
+  const selection = store.getState().selection;
   useEffect(() => {
     const textContainer = textContainerRef.current;
     if (!textContainer) {
       return;
     }
     let isCancelled = false;
+    let unregisterSelection;
     let buildTimer = null;
     let unsubscribe = null;
     let built = false;
@@ -3955,13 +5022,13 @@ var useTextLayer = () => {
       void import('pdfjs-dist/legacy/build/pdf.mjs').then(({ TextLayer: TextLayer2 }) => {
         if (isCancelled || gen !== buildGen || textContainerRef.current !== textContainer)
           return;
-        const textLayer = new TextLayer2({
+        const textLayer2 = new TextLayer2({
           textContentSource: pdfPageProxy.streamTextContent(),
           container: textContainer,
           viewport: pdfPageProxy.getViewport({ scale: 1 })
         });
-        textLayerRef.current = textLayer;
-        return textLayer.render();
+        textLayerRef.current = textLayer2;
+        return textLayer2.render();
       }).then(() => {
         if (isCancelled || gen !== buildGen || textContainerRef.current !== textContainer) {
           return;
@@ -3970,6 +5037,16 @@ var useTextLayer = () => {
         endOfContent.className = "endOfContent";
         textContainer.appendChild(endOfContent);
         bindMouseEvents(textContainer, endOfContent);
+        const viewport = pdfPageProxy.getViewport({ scale: 1 });
+        const unrotated = pdfPageProxy.getViewport({ scale: 1, rotation: 0 });
+        textContainer.style.width = `${unrotated.width}px`;
+        textContainer.style.height = `${unrotated.height}px`;
+        unregisterSelection = selection?.registerLayer(
+          textContainer,
+          pageNumber,
+          viewport.width,
+          viewport.height
+        );
         built = true;
         building = false;
         unsubscribe?.();
@@ -3983,6 +5060,12 @@ var useTextLayer = () => {
     };
     const schedule = () => {
       if (built) return;
+      if (selection?.isDragging || selection?.includesPage(pageNumber)) {
+        if (buildTimer) clearTimeout(buildTimer);
+        buildTimer = null;
+        if (!building) build();
+        return;
+      }
       if (building) {
         buildGen++;
         building = false;
@@ -4012,9 +5095,15 @@ var useTextLayer = () => {
       unsubscribe = subscribeToViewportInvalidation(scrollViewport, schedule);
     };
     attachScrollSubscription();
+    const unsubscribeSelection = selection?.subscribe(() => {
+      if (selection.isDragging || selection.includesPage(pageNumber))
+        schedule();
+    });
     schedule();
     return () => {
       isCancelled = true;
+      unregisterSelection?.();
+      unsubscribeSelection?.();
       if (buildTimer) clearTimeout(buildTimer);
       if (attachRaf !== null) cancelAnimationFrame(attachRaf);
       unsubscribe?.();
@@ -4027,7 +5116,13 @@ var useTextLayer = () => {
         delete textContainer._cleanupTextSelection;
       }
     };
-  }, [pdfPageProxy.streamTextContent, pdfPageProxy.getViewport, viewportRef]);
+  }, [
+    pdfPageProxy.streamTextContent,
+    pdfPageProxy.getViewport,
+    viewportRef,
+    selection,
+    pageNumber
+  ]);
   useEffect(() => {
     const textContainer = textContainerRef.current;
     if (!textContainer) return;
@@ -4046,7 +5141,10 @@ var useTextLayer = () => {
       show();
     };
     const hideAndDebounce = () => {
-      if (selecting) return;
+      if (selecting || selection?.isDragging || selection?.includesPage(pageNumber)) {
+        show();
+        return;
+      }
       textContainer.style.visibility = "hidden";
       if (settleTimer) clearTimeout(settleTimer);
       settleTimer = setTimeout(restoreWhenSettled, TEXT_SCROLL_SETTLE_MS);
@@ -4114,7 +5212,7 @@ var useTextLayer = () => {
       if (settleTimer) clearTimeout(settleTimer);
       show();
     };
-  }, [viewportRef, store]);
+  }, [viewportRef, store, selection, pageNumber]);
   return {
     textContainerRef,
     pageNumber: pdfPageProxy.pageNumber
@@ -4311,6 +5409,37 @@ var Outline = ({
     });
   }) });
 };
+function PageLoadingBoundary({
+  pageNumber,
+  children,
+  fallback = null
+}) {
+  const loaded = usePdf((state) => state.isPageLoaded(pageNumber));
+  const loadPage = usePdf((state) => state.loadPdfPageProxy);
+  const [failure, setFailure] = useState(null);
+  const [attempt, setAttempt] = useState(0);
+  useEffect(() => {
+    if (loaded) return;
+    let disposed = false;
+    setFailure(null);
+    void loadPage(pageNumber).catch((error) => {
+      if (!disposed) setFailure({ pageNumber, error });
+    });
+    return () => {
+      disposed = true;
+    };
+  }, [pageNumber, loaded, loadPage, attempt]);
+  if (loaded) return children;
+  if (failure?.pageNumber === pageNumber)
+    return /* @__PURE__ */ jsxs("div", { role: "alert", children: [
+      "Unable to load page ",
+      pageNumber,
+      ".",
+      " ",
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: () => setAttempt((value) => value + 1), children: "Retry" })
+    ] });
+  return fallback;
+}
 var Page = memo(
   ({
     children,
@@ -4318,14 +5447,16 @@ var Page = memo(
     style,
     ...props
   }) => {
-    const pdfPageProxy = usePdf((state) => state.getPdfPageProxy(pageNumber));
+    const loaded = usePdf((state) => state.isPageLoaded(pageNumber));
+    const getPage = usePdf((state) => state.getPdfPageProxy);
+    const proxy = loaded ? getPage(pageNumber) : void 0;
     const viewport = usePdf((state) => state.viewports[pageNumber - 1]);
     const colorScheme = usePdf((state) => state.colorScheme);
     const darkModeColors = usePdf((state) => state.darkModeColors);
     const pageBackground = colorScheme === "dark" ? createDarkModeColorMap(darkModeColors)("#ffffff") : "white";
-    const width = viewport?.width ?? (pdfPageProxy.view[2] ?? 0) - (pdfPageProxy.view[0] ?? 0);
-    const height = viewport?.height ?? (pdfPageProxy.view[3] ?? 0) - (pdfPageProxy.view[1] ?? 0);
-    return /* @__PURE__ */ jsx(PDFPageNumberContext.Provider, { value: pdfPageProxy.pageNumber, children: /* @__PURE__ */ jsx(
+    const width = viewport?.width ?? (proxy?.view[2] ?? 0) - (proxy?.view[0] ?? 0);
+    const height = viewport?.height ?? (proxy?.view[3] ?? 0) - (proxy?.view[1] ?? 0);
+    return /* @__PURE__ */ jsx(PDFPageNumberContext.Provider, { value: pageNumber, children: /* @__PURE__ */ jsx(
       Primitive.div,
       {
         style: {
@@ -4343,8 +5474,9 @@ var Page = memo(
               height,
               ...style
             },
+            "aria-busy": !loaded || void 0,
             ...props,
-            children
+            children: /* @__PURE__ */ jsx(PageLoadingBoundary, { pageNumber, children })
           }
         )
       }
@@ -4465,6 +5597,28 @@ var addEventListenerOptions = {
 };
 var useObserveElement = () => {
   const store = PDFStore.useContext();
+  const observeElementRect$1 = (instance, cb) => {
+    let physicalRect;
+    const publish = () => {
+      if (!physicalRect) return;
+      const zoom = store.getState().zoom;
+      cb({
+        width: physicalRect.width / zoom,
+        height: physicalRect.height / zoom
+      });
+    };
+    const stopObserving = observeElementRect(instance, (rect) => {
+      physicalRect = rect;
+      publish();
+    });
+    const unsubscribe = store.subscribe((state, previous) => {
+      if (state.zoom !== previous.zoom) publish();
+    });
+    return () => {
+      stopObserving?.();
+      unsubscribe();
+    };
+  };
   const observeElementOffset = (instance, cb) => {
     const element = instance.scrollElement;
     if (!element) {
@@ -4474,33 +5628,46 @@ var useObserveElement = () => {
     if (!targetWindow) {
       return;
     }
-    let offset3 = 0;
-    const fallback = instance.options.useScrollendEvent && supportsScrollend ? () => void 0 : debounce(
-      targetWindow,
-      () => {
-        cb(offset3, false);
-      },
-      instance.options.isScrollingResetDelay
-    );
-    const createHandler = (isScrolling) => () => {
+    let isScrolling = false;
+    let idleTimer;
+    const needsIdleFallback = !instance.options.useScrollendEvent || !supportsScrollend;
+    const publish = (scrolling) => {
+      isScrolling = scrolling;
       const { horizontal, isRtl } = instance.options;
-      offset3 = horizontal ? element.scrollLeft * (isRtl && -1 || 1) : element.scrollTop;
-      const zoom = store.getState().zoom;
-      offset3 = offset3 / zoom;
-      fallback();
-      cb(offset3, isScrolling);
+      const physicalOffset = horizontal ? element.scrollLeft * (isRtl ? -1 : 1) : element.scrollTop;
+      cb(physicalOffset / store.getState().zoom, isScrolling);
+    };
+    const clearIdleTimer = () => {
+      if (idleTimer !== void 0) targetWindow.clearTimeout(idleTimer);
+      idleTimer = void 0;
+    };
+    const createHandler = (scrolling) => () => {
+      clearIdleTimer();
+      publish(scrolling);
+      if (scrolling && needsIdleFallback) {
+        idleTimer = targetWindow.setTimeout(() => {
+          idleTimer = void 0;
+          publish(false);
+        }, instance.options.isScrollingResetDelay);
+      }
     };
     const handler = createHandler(true);
     const endHandler = createHandler(false);
     endHandler();
+    const unsubscribe = store.subscribe((state, previous) => {
+      if (state.zoom !== previous.zoom) publish(isScrolling);
+    });
     element.addEventListener("scroll", handler, addEventListenerOptions);
     element.addEventListener("scrollend", endHandler, addEventListenerOptions);
     return () => {
+      unsubscribe();
+      clearIdleTimer();
       element.removeEventListener("scroll", handler);
       element.removeEventListener("scrollend", endHandler);
     };
   };
   return {
+    observeElementRect: observeElementRect$1,
     observeElementOffset
   };
 };
@@ -4510,7 +5677,11 @@ var useScrollFn = () => {
     (_offset, canSmooth, instance) => {
       const zoom = store.getState().zoom;
       const offset3 = _offset * zoom;
-      elementScroll(offset3, canSmooth, instance);
+      elementScroll(
+        offset3,
+        { ...canSmooth, adjustments: (canSmooth.adjustments ?? 0) * zoom },
+        instance
+      );
     },
     [store]
   );
@@ -4628,7 +5799,7 @@ function _toPrimitive(input, hint) {
   if (typeof input !== "object" || input === null) return input;
   var prim = input[Symbol.toPrimitive];
   if (prim !== void 0) {
-    var res = prim.call(input, hint || "default");
+    var res = prim.call(input, hint);
     if (typeof res !== "object") return res;
     throw new TypeError("@@toPrimitive must return a primitive value.");
   }
@@ -6485,6 +7656,8 @@ var useViewportContainer = ({
   });
   const zoomRafRef = useRef(null);
   const lastPushedZoomRef = useRef(null);
+  const initializedZoomRef = useRef(false);
+  const appliedZoomRef = useRef(1);
   const updateTransform = useCallback(
     (zoomUpdate) => {
       if (!elementRef.current || !containerRef.current || !elementWrapperRef.current) {
@@ -6514,17 +7687,36 @@ var useViewportContainer = ({
       elementWrapperRef.current.style.height = `${naturalHeight * zoom2}px`;
       containerRef.current.scrollTop = translateY;
       containerRef.current.scrollLeft = translateX;
-      if (zoomUpdate && zoomRafRef.current === null) {
-        zoomRafRef.current = requestAnimationFrame(() => {
-          zoomRafRef.current = null;
-          const z = transformations.current.zoom;
-          lastPushedZoomRef.current = z;
-          updateZoom(() => z);
-        });
+      appliedZoomRef.current = zoom2;
+      if (zoomUpdate) {
+        lastPushedZoomRef.current = zoom2;
+        updateZoom(() => zoom2);
       }
     },
     [containerRef, elementRef, elementWrapperRef, updateZoom, store]
   );
+  useLayoutEffect(() => {
+    const viewport = containerRef.current;
+    if (!viewport) return;
+    return registerViewportZoom(viewport, (nextZoom) => {
+      if (initializedZoomRef.current && appliedZoomRef.current === nextZoom && zoomRafRef.current === null)
+        return;
+      if (zoomRafRef.current !== null) {
+        cancelAnimationFrame(zoomRafRef.current);
+        zoomRafRef.current = null;
+      }
+      lastPushedZoomRef.current = null;
+      const previousZoom = initializedZoomRef.current ? appliedZoomRef.current : store.getState().zoom;
+      const ratio = previousZoom > 0 && Number.isFinite(previousZoom) ? nextZoom / previousZoom : 1;
+      transformations.current = {
+        zoom: nextZoom,
+        translateX: viewport.scrollLeft * ratio,
+        translateY: viewport.scrollTop * ratio
+      };
+      initializedZoomRef.current = true;
+      updateTransform();
+    });
+  }, [containerRef, store, updateTransform]);
   useEffect(() => {
     if (USE_LAYOUT_ZOOM && gestureTransformAppliedRef.current && !isPinching)
       updateTransform();
@@ -6537,6 +7729,16 @@ var useViewportContainer = ({
     };
   }, []);
   useEffect(() => {
+    if (!initializedZoomRef.current && containerRef.current) {
+      initializedZoomRef.current = true;
+      transformations.current = {
+        zoom,
+        translateX: containerRef.current.scrollLeft,
+        translateY: containerRef.current.scrollTop
+      };
+      updateTransform();
+      return;
+    }
     if (transformations.current.zoom === zoom || !containerRef.current) {
       return;
     }
@@ -6549,7 +7751,7 @@ var useViewportContainer = ({
       zoomRafRef.current = null;
     }
     lastPushedZoomRef.current = null;
-    const prevZoom = transformations.current.zoom;
+    const prevZoom = appliedZoomRef.current;
     if (!prevZoom || !Number.isFinite(prevZoom)) {
       transformations.current = {
         translateX: containerRef.current.scrollLeft,
@@ -6689,11 +7891,26 @@ var useViewportContainer = ({
           translateY: newTranslateY
         };
         newMemo.lastZoom = newZoom;
-        updateTransform(true);
+        if (zoomRafRef.current === null) {
+          zoomRafRef.current = requestAnimationFrame(() => {
+            zoomRafRef.current = null;
+            updateTransform(true);
+          });
+        }
         return newMemo;
       },
       onPinchStart: () => setIsPinching(true),
-      onPinchEnd: () => setIsPinching(false)
+      onPinchEnd: () => {
+        const pendingFrame = zoomRafRef.current !== null;
+        if (zoomRafRef.current !== null) {
+          cancelAnimationFrame(zoomRafRef.current);
+          zoomRafRef.current = null;
+        }
+        setIsPinching(false);
+        if (pendingFrame || gestureTransformAppliedRef.current) {
+          updateTransform(pendingFrame);
+        }
+      }
     },
     {
       target: containerRef
@@ -6741,15 +7958,34 @@ var Pages = ({
   virtualizerOptions = DEFAULT_VIRTUALIZER_OPTIONS,
   initialOffset,
   onOffsetChange,
+  copyOptions,
   ...props
 }) => {
   const [tempItems, setTempItems] = useState([]);
   const viewports = usePdf((state) => state.viewports);
+  const selection = usePdf((state) => state.selection);
   const numPages = usePdf((state) => state.pdfDocumentProxy.numPages);
+  const initialPage = usePdf((state) => state.initialPage);
   const isPinching = usePdf((state) => state.isPinching);
   const elementWrapperRef = useRef(null);
   const elementRef = useRef(null);
   const containerRef = useRef(null);
+  const copyOptionsRef = useRef(copyOptions);
+  copyOptionsRef.current = copyOptions;
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const disconnect = selection.connect(container);
+    const unregisterCopy = registerPdfCopy(
+      container,
+      () => copyOptionsRef.current ?? {},
+      (options) => selection.getSnapshot() ? selection.getText(options) ?? void 0 : null
+    );
+    return () => {
+      unregisterCopy();
+      disconnect();
+    };
+  }, [selection]);
   useViewportContainer({
     elementRef,
     elementWrapperRef,
@@ -6757,7 +7993,7 @@ var Pages = ({
   });
   const setVirtualizer = usePdf((state) => state.setVirtualizer);
   const { scrollToFn } = useScrollFn();
-  const { observeElementOffset } = useObserveElement();
+  const { observeElementOffset, observeElementRect } = useObserveElement();
   const viewportsRef = useRef(viewports);
   viewportsRef.current = viewports;
   const estimateSize = useCallback(
@@ -6769,15 +8005,22 @@ var Pages = ({
     []
     // Stable — reads from ref
   );
+  const [startingOffset] = useState(
+    () => initialOffset ?? viewports.slice(0, initialPage - 1).reduce(
+      (offset3, viewport) => offset3 + viewport.height + EXTRA_HEIGHT + gap,
+      0
+    )
+  );
   const virtualizer = useVirtualizer({
     count: numPages || 0,
     getScrollElement: () => containerRef.current,
     estimateSize,
     observeElementOffset,
+    observeElementRect,
     overscan: virtualizerOptions?.overscan ?? 0,
     scrollToFn,
     gap,
-    initialOffset,
+    initialOffset: startingOffset,
     // Never trust scrollend alone to reset isScrolling: a single missed
     // event (a documented browser flake — TanStack flipped this default to
     // false in later 3.x) would pin isScrolling=true forever, and every
@@ -6785,6 +8028,21 @@ var Pages = ({
     // false keeps the isScrollingResetDelay debounce active as a fallback.
     useScrollendEvent: false
   });
+  const previousViewports = useRef(viewports);
+  useLayoutEffect(() => {
+    if (isPinching) return;
+    const previous = previousViewports.current;
+    previousViewports.current = viewports;
+    if (previous === viewports) return;
+    let resized = false;
+    for (let index = 0; index < viewports.length; index++) {
+      if (previous[index]?.height !== viewports[index]?.height) {
+        virtualizer.resizeItem(index, viewports[index].height + EXTRA_HEIGHT);
+        resized = true;
+      }
+    }
+    if (resized) setTempItems([]);
+  }, [viewports, virtualizer, isPinching]);
   useEffect(() => {
     if (onOffsetChange && virtualizer.scrollOffset)
       onOffsetChange(virtualizer.scrollOffset);
@@ -6845,6 +8103,7 @@ var Pages = ({
     Primitive.div,
     {
       ref: containerRef,
+      tabIndex: 0,
       ...props,
       style: {
         display: "flex",
@@ -6931,6 +8190,164 @@ async function mapConcurrent(items, concurrency, map, isCancelled = () => false)
   return results;
 }
 
+// src/lib/page-resources.ts
+var PageResources = class {
+  constructor(document2, firstPage, rotation, onError, concurrency = 16) {
+    this.document = document2;
+    this.rotation = rotation;
+    this.onError = onError;
+    this.concurrency = concurrency;
+    this.pages.set(firstPage.pageNumber, firstPage);
+    const viewport = this.viewportFor(firstPage);
+    this.viewports = Array.from({ length: document2.numPages }, () => viewport);
+    if (document2.numPages === 1) this.completePages = [firstPage];
+  }
+  pages = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  queue = [];
+  active = 0;
+  disposed = false;
+  listeners = /* @__PURE__ */ new Set();
+  notification;
+  viewports;
+  completePages;
+  viewportUpdates = /* @__PURE__ */ new Map();
+  viewportFor(page) {
+    return page.getViewport({
+      scale: 1,
+      rotation: this.rotation + (page.rotate || 0)
+    });
+  }
+  get(pageNumber) {
+    return this.pages.get(pageNumber);
+  }
+  getSnapshot = () => ({
+    viewports: this.viewports,
+    pageProxies: this.completePages
+  });
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  /** Visible pages move ahead of the background queue; in-flight requests are shared. */
+  load = (pageNumber) => {
+    if (this.disposed)
+      return Promise.reject(new Error("Document page loading was cancelled"));
+    if (!Number.isInteger(pageNumber) || pageNumber < 1 || pageNumber > this.document.numPages)
+      return Promise.reject(
+        new RangeError(`Page ${pageNumber} does not exist`)
+      );
+    const page = this.pages.get(pageNumber);
+    if (page) return Promise.resolve(page);
+    const existing = this.requests.get(pageNumber);
+    if (existing) {
+      const queued = this.queue.indexOf(pageNumber);
+      if (queued > 0) {
+        this.queue.splice(queued, 1);
+        this.queue.unshift(pageNumber);
+      }
+      return existing.promise;
+    }
+    const request = this.createRequest(pageNumber);
+    this.queue.unshift(pageNumber);
+    this.pump();
+    return request.promise;
+  };
+  createRequest(pageNumber) {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const request = { promise, resolve, reject };
+    this.requests.set(pageNumber, request);
+    return request;
+  }
+  /** Start after the reader mounts, so unrelated page metadata cannot delay its first render. */
+  start = () => {
+    if (this.disposed) return;
+    for (let pageNumber = 1; pageNumber <= this.document.numPages; pageNumber++) {
+      if (this.pages.has(pageNumber) || this.requests.has(pageNumber)) continue;
+      const request = this.createRequest(pageNumber);
+      void request.promise.catch(() => {
+      });
+      this.queue.push(pageNumber);
+    }
+    this.pump();
+  };
+  loadAll = async () => {
+    if (this.disposed) throw new Error("Document page loading was cancelled");
+    if (this.completePages) return this.completePages;
+    this.start();
+    await Promise.all(
+      Array.from({ length: this.document.numPages }, (_, index) => {
+        const pageNumber = index + 1;
+        return this.pages.get(pageNumber) ?? this.requests.get(pageNumber).promise;
+      })
+    );
+    return this.completePages;
+  };
+  pump() {
+    while (!this.disposed && this.active < this.concurrency && this.queue.length) {
+      const pageNumber = this.queue.shift();
+      const request = this.requests.get(pageNumber);
+      this.active++;
+      void Promise.resolve().then(() => {
+        if (this.disposed)
+          throw new Error("Document page loading was cancelled");
+        return this.document.getPage(pageNumber);
+      }).then((page) => {
+        if (this.disposed) return;
+        const viewport = this.viewportFor(page);
+        this.pages.set(pageNumber, page);
+        this.viewportUpdates.set(pageNumber - 1, viewport);
+        if (this.pages.size === this.document.numPages) {
+          this.completePages = Array.from(
+            { length: this.document.numPages },
+            (_, index) => this.pages.get(index + 1)
+          );
+        }
+        this.requests.delete(pageNumber);
+        request.resolve(page);
+        this.notify();
+      }).catch((error) => {
+        if (!this.disposed) {
+          this.requests.delete(pageNumber);
+          request.reject(error);
+          this.onError(error);
+        }
+      }).finally(() => {
+        this.active--;
+        this.pump();
+      });
+    }
+  }
+  notify() {
+    if (this.notification !== void 0) return;
+    this.notification = setTimeout(() => {
+      this.notification = void 0;
+      if (this.disposed) return;
+      this.viewports = this.viewports.slice();
+      for (const [index, viewport] of this.viewportUpdates)
+        this.viewports[index] = viewport;
+      this.viewportUpdates.clear();
+      for (const listener of this.listeners) listener();
+    }, 0);
+  }
+  dispose = () => {
+    this.disposed = true;
+    clearTimeout(this.notification);
+    this.listeners.clear();
+    this.queue = [];
+    for (const request of this.requests.values())
+      request.reject(new Error("Document page loading was cancelled"));
+    this.requests.clear();
+  };
+};
+
 // src/lib/pdfjs.ts
 var pdfJsPromise = null;
 var loadPdfJs = () => {
@@ -7056,6 +8473,8 @@ var usePDFDocumentContext = ({
   onError,
   source,
   initialRotation = 0,
+  progressive = false,
+  initialPage = 1,
   isZoomFitWidth,
   zoom = 1,
   zoomOptions,
@@ -7078,7 +8497,32 @@ var usePDFDocumentContext = ({
   darkModeColorsRef.current = darkModeColors;
   useEffect(() => {
     let isDisposed = false;
+    let pageResources;
     const generateViewports = async (pdf) => {
+      const firstPageNumber = Number.isFinite(initialPage) ? Math.max(1, Math.min(pdf.numPages, Math.trunc(initialPage))) : 1;
+      if (progressive) {
+        const firstPage = await pdf.getPage(firstPageNumber);
+        if (isDisposed) return;
+        pageResources = new PageResources(pdf, firstPage, rotation, (error) => {
+          if (isDisposed) return;
+          console.error("Error generating PDF viewports", error);
+          onErrorRef.current?.({ error, phase: "viewport-generation", source });
+        });
+        setInitialState({
+          isZoomFitWidth,
+          viewports: pageResources.getSnapshot().viewports,
+          pageProxies: pageResources.getSnapshot().pageProxies ?? [],
+          pdfDocumentProxy: pdf,
+          zoom,
+          zoomOptions,
+          pageResources,
+          initialPage: firstPageNumber,
+          colorScheme: colorSchemeRef.current,
+          darkModeColors: darkModeColorsRef.current,
+          renderColorMapRef
+        });
+        return;
+      }
       const pageProxies = [];
       const viewports = await mapConcurrent(
         Array.from({ length: pdf.numPages }, (_, index) => index),
@@ -7104,6 +8548,7 @@ var usePDFDocumentContext = ({
         pdfDocumentProxy: pdf,
         zoom,
         zoomOptions,
+        initialPage: firstPageNumber,
         colorScheme: colorSchemeRef.current,
         darkModeColors: darkModeColorsRef.current,
         renderColorMapRef
@@ -7166,6 +8611,7 @@ var usePDFDocumentContext = ({
       });
       return () => {
         isDisposed = true;
+        pageResources?.dispose();
         void loadingTask?.destroy();
       };
     };
@@ -7207,6 +8653,28 @@ var ColorSchemeSync = ({
   ]);
   return null;
 };
+var PageResourcesSync = ({ resources }) => {
+  const store = PDFStore.useContext();
+  useEffect(() => {
+    if (!resources) return;
+    const update = () => {
+      const snapshot = resources.getSnapshot();
+      store.setState((state) => ({
+        viewports: snapshot.viewports,
+        pageProxies: snapshot.pageProxies ?? state.pageProxies,
+        pagesLoaded: Boolean(snapshot.pageProxies)
+      }));
+    };
+    const unsubscribe = resources.subscribe(update);
+    update();
+    const timer = setTimeout(resources.start, 0);
+    return () => {
+      clearTimeout(timer);
+      unsubscribe();
+    };
+  }, [resources, store]);
+  return null;
+};
 var Root = forwardRef(
   ({
     children,
@@ -7218,6 +8686,8 @@ var Root = forwardRef(
     zoom,
     zoomOptions,
     documentOptions,
+    progressive,
+    initialPage,
     colorScheme,
     darkModeColors,
     ...props
@@ -7230,6 +8700,8 @@ var Root = forwardRef(
       zoom,
       zoomOptions,
       documentOptions,
+      progressive,
+      initialPage,
       colorScheme,
       darkModeColors
     });
@@ -7245,6 +8717,7 @@ var Root = forwardRef(
       };
     }, [documentId]);
     return /* @__PURE__ */ jsx(Primitive.div, { ref, ...props, children: initialState ? /* @__PURE__ */ jsxs(PDFStore.Provider, { initialValue: initialState, children: [
+      /* @__PURE__ */ jsx(PageResourcesSync, { resources: initialState.pageResources }),
       /* @__PURE__ */ jsx(
         ColorSchemeSync,
         {
@@ -7275,6 +8748,8 @@ function acquireDocumentText(pages) {
         const page = pages[index];
         const reader = page.streamTextContent().getReader();
         const chunks = [];
+        const lineBreaks = [];
+        let offset3 = 0;
         let complete = false;
         try {
           while (true) {
@@ -7284,9 +8759,13 @@ function acquireDocumentText(pages) {
               complete = true;
               break;
             }
-            chunks.push(
-              value.items.map((item) => "str" in item ? item.str : "").join("")
-            );
+            for (const item of value.items) {
+              if (!("str" in item)) continue;
+              chunks.push(item.str);
+              offset3 += item.str.length;
+              if (item.hasEOL && lineBreaks.at(-1) !== offset3)
+                lineBreaks.push(offset3);
+            }
           }
         } finally {
           if (!complete)
@@ -7294,7 +8773,11 @@ function acquireDocumentText(pages) {
             });
           reader.releaseLock();
         }
-        result[index] = { pageNumber: page.pageNumber, text: chunks.join("") };
+        result[index] = {
+          pageNumber: page.pageNumber,
+          text: chunks.join(""),
+          ...lineBreaks.length ? { lineBreaks } : {}
+        };
       }
     };
     const created = {
@@ -7339,7 +8822,10 @@ var Search = ({
 }) => {
   const [result, setResult] = useState(null);
   const [attempt, setAttempt] = useState(0);
+  const document2 = usePdf((state) => state.pdfDocumentProxy);
   const proxies = usePdf((state) => state.pageProxies);
+  const pagesLoaded = usePdf((state) => state.pagesLoaded);
+  const loadPages = usePdf((state) => state.loadPdfPageProxies);
   const setTextContent = usePdf((state) => state.setTextContent);
   const retry = useCallback(() => {
     setResult(null);
@@ -7348,22 +8834,27 @@ var Search = ({
   useEffect(() => {
     let disposed = false;
     setResult(null);
-    const task = acquireDocumentText(proxies);
-    void task.promise.then((text) => {
-      if (disposed) return;
+    let task;
+    void loadPages().then((pages) => {
+      if (disposed || !pagesLoaded) return;
+      task = acquireDocumentText(pages);
+      return task.promise;
+    }).then((text) => {
+      if (disposed || !text) return;
       setTextContent(text);
-      setResult({ pages: proxies, status: "ready" });
+      setResult({ document: document2, pages: proxies, status: "ready" });
     }).catch((error) => {
       if (disposed) return;
       console.error("Error extracting PDF text", error);
-      setResult({ pages: proxies, status: "error", error });
+      setResult({ document: document2, pages: proxies, status: "error", error });
     });
     return () => {
       disposed = true;
-      task.release();
+      task?.release();
     };
-  }, [proxies, setTextContent, attempt]);
-  if (!result || result.pages !== proxies) return loading;
+  }, [document2, proxies, pagesLoaded, loadPages, setTextContent, attempt]);
+  if (!result || result.document !== document2 || result.pages !== proxies)
+    return loading;
   if (result.status === "error") {
     if (errorFallback) return errorFallback({ error: result.error, retry });
     return /* @__PURE__ */ jsxs("div", { role: "alert", children: [
@@ -7463,7 +8954,7 @@ var useThumbnail = (pageNumber, config = {}) => {
     isVisible
   };
 };
-var Thumbnail = ({
+var LoadedThumbnail = ({
   pageNumber = 1,
   eager = false,
   ...props
@@ -7472,30 +8963,65 @@ var Thumbnail = ({
     isFirstPage: eager || pageNumber < 5
   });
   const { jumpToPage } = usePdfJump();
+  const isCurrentPage = usePdf((state) => state.currentPage === pageNumber);
+  const spacePressed = useRef(false);
   return /* @__PURE__ */ jsx("div", { ref: containerRef, style: { minHeight: "150px", minWidth: "10px" }, children: isVisible && /* @__PURE__ */ jsx(
     Primitive.canvas,
     {
+      "aria-label": `Page ${pageNumber}`,
+      "aria-current": isCurrentPage ? "page" : void 0,
       ...props,
       role: "button",
       tabIndex: 0,
-      onClick: (e) => {
-        if (props.onClick) {
-          props.onClick(e);
-        }
-        jumpToPage(pageNumber, { behavior: "auto" });
+      onClick: (event) => {
+        props.onClick?.(event);
+        if (!event.defaultPrevented)
+          jumpToPage(pageNumber, { behavior: "auto" });
       },
-      onKeyDown: (e) => {
-        if (props.onKeyDown) {
-          props.onKeyDown(e);
+      onKeyDown: (event) => {
+        props.onKeyDown?.(event);
+        if (event.defaultPrevented) return;
+        if (event.key === "Enter") {
+          event.preventDefault();
+          jumpToPage(pageNumber, { behavior: "auto" });
+        } else if (event.key === " ") {
+          event.preventDefault();
+          spacePressed.current = true;
         }
-        if (e.key === "Enter") {
+      },
+      onKeyUp: (event) => {
+        props.onKeyUp?.(event);
+        if (event.key !== " ") return;
+        const activate = spacePressed.current && !event.defaultPrevented;
+        spacePressed.current = false;
+        if (activate) {
+          event.preventDefault();
           jumpToPage(pageNumber, { behavior: "auto" });
         }
       },
+      onBlur: (event) => {
+        spacePressed.current = false;
+        props.onBlur?.(event);
+      },
       ref: canvasRef
     }
   ) });
 };
+var Thumbnail = (props) => /* @__PURE__ */ jsx(
+  PageLoadingBoundary,
+  {
+    pageNumber: props.pageNumber ?? 1,
+    fallback: /* @__PURE__ */ jsx(
+      "div",
+      {
+        "aria-label": `Loading page ${props.pageNumber ?? 1}`,
+        "aria-busy": "true",
+        style: { minHeight: 150 }
+      }
+    ),
+    children: /* @__PURE__ */ jsx(LoadedThumbnail, { ...props })
+  }
+);
 function VirtualizedThumbnails({
   children,
   count,
@@ -7508,6 +9034,9 @@ function VirtualizedThumbnails({
   const containerRef = useRef(null);
   useImperativeHandle(ref, () => containerRef.current);
   const [focusPage, setFocusPage] = useState(null);
+  const focusPageLoaded = usePdf(
+    (state) => focusPage === null ? false : state.isPageLoaded(focusPage)
+  );
   const itemHeight = Number.isFinite(virtualize.itemHeight) ? Math.max(1, virtualize.itemHeight) : 150;
   const virtualizer = useVirtualizer({
     count,
@@ -7525,7 +9054,7 @@ function VirtualizedThumbnails({
       canvas.focus({ preventScroll: true });
       setFocusPage(null);
     }
-  }, [focusPage, items]);
+  }, [focusPage, focusPageLoaded, items]);
   return /* @__PURE__ */ jsx(
     Primitive.div,
     {
@@ -7657,13 +9186,41 @@ var CurrentZoom = ({ ...props }) => {
 
 // src/lib/search.ts
 var normalizedPages = /* @__PURE__ */ new WeakMap();
-function normalize(page) {
+function normalize(page, options) {
   let cached = normalizedPages.get(page);
-  if (!cached || cached.text !== page.text) {
-    cached = { text: page.text, lower: page.text.toLowerCase() };
+  if (cached?.text !== page.text || cached.lineBreaks !== page.lineBreaks) {
+    cached = {
+      text: page.text,
+      lineBreaks: page.lineBreaks,
+      variants: /* @__PURE__ */ new Map()
+    };
     normalizedPages.set(page, cached);
   }
-  return cached.lower;
+  const key = (options.matchDiacritics === false ? 1 : 0) | (options.ignoreHyphenation ? 2 : 0);
+  let result = cached.variants.get(key);
+  if (!result) {
+    result = normalizeSearchText(page.text, options, page.lineBreaks);
+    cached.variants.set(key, result);
+  }
+  return result;
+}
+function createMatch(page, normalized, start, length, searchText, textSize, score) {
+  const end = Math.min(normalized.text.length, start + length);
+  const { start: matchIndex, end: matchEnd } = originalTextRange(
+    normalized,
+    start,
+    end
+  );
+  const matchLength = matchEnd - matchIndex;
+  return {
+    pageNumber: page.pageNumber,
+    text: page.text.slice(matchIndex, matchEnd + textSize),
+    score,
+    matchIndex,
+    isExactMatch: score === 1,
+    searchText,
+    ...matchLength !== searchText.length ? { matchLength } : {}
+  };
 }
 function createBoundedDistance(query, maxDistance) {
   const length = query.length;
@@ -7716,7 +9273,8 @@ function* runSearch(pages, searchText, options = {}, cooperative = false, budget
   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 query = normalizeSearchText(searchText, options).text;
+  if (!query.trim()) return empty;
   const maxDistance = Math.floor(query.length * (1 - threshold));
   const distance = maxDistance > 0 ? createBoundedDistance(query, maxDistance) : null;
   const exactMatches = [];
@@ -7726,9 +9284,12 @@ function* runSearch(pages, searchText, options = {}, cooperative = false, budget
   let steps = 0;
   let deadline = cooperative ? performance.now() + budget : 0;
   for (const page of pages) {
-    const lower = normalize(page);
+    const normalized = normalize(page, options);
+    const lower = normalized.text;
     const exactStarts = [];
     let index = 0;
+    let lastStart = -1;
+    let lastEnd = -1;
     while (true) {
       if (cooperative && (++steps & 127) === 0 && performance.now() >= deadline) {
         yield;
@@ -7736,19 +9297,31 @@ function* runSearch(pages, searchText, options = {}, cooperative = false, budget
       }
       const matchIndex = lower.indexOf(query, index);
       if (matchIndex === -1) break;
-      exactCount++;
+      const span = originalTextRange(
+        normalized,
+        matchIndex,
+        matchIndex + query.length
+      );
+      index = matchIndex + query.length;
       if (maxDistance > 0) exactStarts.push(matchIndex);
+      if (span.start === lastStart && span.end === lastEnd) continue;
+      lastStart = span.start;
+      lastEnd = span.end;
+      exactCount++;
       if (exactMatches.length < limit) {
-        exactMatches.push({
-          pageNumber: page.pageNumber,
-          text: page.text.substr(matchIndex, searchText.length + textSize),
-          score: 1,
-          matchIndex,
-          isExactMatch: true,
-          searchText
-        });
+        exactMatches.push(
+          createMatch(
+            page,
+            normalized,
+            matchIndex,
+            query.length,
+            searchText,
+            textSize,
+            1
+          )
+        );
       }
-      index = matchIndex + searchText.length;
+      index = matchIndex + query.length;
     }
     if (!(maxDistance > 0)) continue;
     index = 0;
@@ -7758,11 +9331,11 @@ function* runSearch(pages, searchText, options = {}, cooperative = false, budget
         yield;
         deadline = performance.now() + budget;
       }
-      while (exactIndex < exactStarts.length && exactStarts[exactIndex] + searchText.length <= index)
+      while (exactIndex < exactStarts.length && exactStarts[exactIndex] + query.length <= index)
         exactIndex++;
       const exactStart = exactStarts[exactIndex];
       if (exactStart !== void 0 && index >= exactStart) {
-        index = exactStart + searchText.length;
+        index = exactStart + query.length;
         continue;
       }
       const edits = distance(lower, index);
@@ -7772,14 +9345,15 @@ function* runSearch(pages, searchText, options = {}, cooperative = false, budget
         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
-            },
+            createMatch(
+              page,
+              normalized,
+              index,
+              query.length,
+              searchText,
+              textSize,
+              score
+            ),
             limit
           );
         }
@@ -7885,32 +9459,37 @@ var useSearch = () => {
 
 // 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)
+  const matchLength = textMatch.matchLength ?? (textMatch.searchText ? textMatch.searchText.length : textMatch.text.length);
+  if (!Number.isFinite(matchLength) || matchLength <= 0 || !Number.isFinite(textMatch.matchIndex) || textMatch.matchIndex < 0)
     return [];
   const matchEnd = textMatch.matchIndex + matchLength;
   const reader = pageProxy.streamTextContent().getReader();
   const matchRects = [];
   const viewport = pageProxy.getViewport({ scale: 1 });
+  const styles = {};
   let offset3 = 0;
   let foundEnd = false;
   try {
     read: while (true) {
       const { value, done } = await reader.read();
       if (done) break;
+      Object.assign(styles, value.styles);
       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
-          });
+        if (end > start && item.str.slice(start, end).trim()) {
+          matchRects.push(
+            getItemRect(
+              item,
+              styles[item.fontName],
+              viewport,
+              start,
+              end,
+              textMatch.pageNumber
+            )
+          );
         }
         offset3 += length;
         if (offset3 >= matchEnd) {
@@ -7927,6 +9506,61 @@ async function calculateHighlightRects(pageProxy, textMatch) {
   }
   return mergeAdjacentRects(matchRects);
 }
+var measurementContext;
+function getTextFractions(item, style, start, end) {
+  const length = item.str.length;
+  let from = start / length;
+  let to = end / length;
+  if ((start > 0 || end < length) && style?.fontFamily && !style.vertical && typeof document !== "undefined") {
+    if (measurementContext === void 0) {
+      const canvas = document.createElement("canvas");
+      canvas.width = canvas.height = 0;
+      measurementContext = canvas.getContext("2d");
+    }
+    if (measurementContext) {
+      measurementContext.font = `100px ${style.fontFamily}`;
+      const width = measurementContext.measureText(item.str).width;
+      if (width > 0) {
+        from = start === 0 ? 0 : measurementContext.measureText(item.str.slice(0, start)).width / width;
+        to = end === length ? 1 : measurementContext.measureText(item.str.slice(0, end)).width / width;
+      }
+    }
+  }
+  return item.dir === "rtl" ? [1 - to, 1 - from] : [from, to];
+}
+function getItemRect(item, style, viewport, start, end, pageNumber) {
+  const angle = Math.atan2(item.transform[1], item.transform[0]) - (style?.vertical ? Math.PI / 2 : 0);
+  const cosine = Math.cos(angle);
+  const sine = Math.sin(angle);
+  const height = Math.hypot(item.transform[2], item.transform[3]);
+  const ascent = (style?.ascent ?? (style?.descent ? 1 + style.descent : 1)) * height;
+  const width = style?.vertical ? item.height : item.width;
+  const [startFraction, endFraction] = getTextFractions(
+    item,
+    style,
+    start,
+    end
+  );
+  const from = startFraction * width;
+  const to = endFraction * width;
+  let left = Infinity;
+  let top = Infinity;
+  let right = -Infinity;
+  let bottom = -Infinity;
+  for (const along of [from, to]) {
+    for (const above of [ascent, ascent - height]) {
+      const [x, y] = viewport.convertToViewportPoint(
+        item.transform[4] + along * cosine - above * sine,
+        item.transform[5] + along * sine + above * cosine
+      );
+      left = Math.min(left, x);
+      top = Math.min(top, y);
+      right = Math.max(right, x);
+      bottom = Math.max(bottom, y);
+    }
+  }
+  return { pageNumber, left, top, width: right - left, height: bottom - top };
+}
 function mergeAdjacentRects(rects) {
   if (rects.length <= 1) return rects;
   const merged = [];
@@ -7935,10 +9569,13 @@ function mergeAdjacentRects(rects) {
   for (let i = 1; i < rects.length; i++) {
     const next = rects[i];
     if (!next) continue;
-    if (Math.abs(current.top - next.top) < 2 && Math.abs(current.height - next.height) < 2) {
+    if (Math.abs(current.top - next.top) < 2 && Math.abs(current.height - next.height) < 2 && Math.max(current.left, next.left) <= Math.min(current.left + current.width, next.left + next.width) + 2) {
       current = {
         ...current,
-        width: next.left + next.width - current.left
+        left: Math.min(current.left, next.left),
+        top: Math.min(current.top, next.top),
+        width: Math.max(current.left + current.width, next.left + next.width) - Math.min(current.left, next.left),
+        height: Math.max(current.top + current.height, next.top + next.height) - Math.min(current.top, next.top)
       };
     } else {
       merged.push(current);
@@ -7951,5 +9588,24 @@ function mergeAdjacentRects(rects) {
 
 // src/hooks/usePageRendered.ts
 var usePageRendered = (pageNumber) => usePdf((state) => !!state.renderedPages[pageNumber]);
+function usePdfSelection() {
+  const controller = usePdf((state) => state.selection);
+  const selection = useSyncExternalStore(
+    controller.subscribe,
+    controller.getSnapshot,
+    controller.getSnapshot
+  );
+  return useMemo(
+    () => ({
+      selection,
+      setSelection: controller.setSelection,
+      clearSelection: controller.clear,
+      getText: controller.getText,
+      getSelection: controller.getSelection,
+      getSelectionAsync: controller.getSelectionAsync
+    }),
+    [controller, selection]
+  );
+}
 
-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 };
+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, usePdfSelection, useSearch, useSelectionDimensions };