@anaralabs/lector 3.14.13 → 3.15.1

package/dist/index.js

@@ -219,6 +219,825 @@ 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) {
+  for (const match of text.matchAll(/\p{ASCII}?\P{ASCII}+/gu)) {
+    if (normalizeUnicode(match[0], matchDiacritics) === match[0]) continue;
+    const prefix = match[0].charCodeAt(0) < 128 ? 1 : 0;
+    const code = match[0].charCodeAt(prefix);
+    if (match[0].length === prefix + 1 && code >= 64256 && code <= 64262) {
+      yield {
+        index: match.index + prefix,
+        length: 1,
+        text: ligatures[code - 64256]
+      };
+      continue;
+    }
+    segmenter ??= new Intl.Segmenter(void 0, { granularity: "grapheme" });
+    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) {
@@ -268,6 +1087,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: {
@@ -3104,6 +3928,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;
@@ -3151,7 +4083,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);
@@ -3289,7 +4233,7 @@ var useSelectionDimensions = () => {
       underlines: consolidateUnderlines(underlineRects).sort(
         (a, b) => a.pageNumber - b.pageNumber
       ),
-      text: range.toString().trim(),
+      text: (getText() ?? range.toString()).trim(),
       isCollapsed: false
     };
   };
@@ -3346,6 +4290,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);
@@ -3374,12 +4320,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);
@@ -3514,6 +4460,7 @@ var SelectionTooltip = ({ children }) => {
   return /* @__PURE__ */ jsx(Fragment, { children: isOpen && /* @__PURE__ */ jsx(
     "div",
     {
+      "data-selection-tooltip": "",
       ref: refs.setFloating,
       style: {
         ...floatingStyles
@@ -3929,13 +4876,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",
@@ -4061,12 +5008,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;
@@ -4083,13 +5032,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;
@@ -4098,6 +5047,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?.();
@@ -4111,6 +5070,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;
@@ -4140,9 +5105,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?.();
@@ -4155,7 +5126,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;
@@ -4174,7 +5151,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);
@@ -4242,7 +5222,7 @@ var useTextLayer = () => {
       if (settleTimer) clearTimeout(settleTimer);
       show();
     };
-  }, [viewportRef, store]);
+  }, [viewportRef, store, selection, pageNumber]);
   return {
     textContainerRef,
     pageNumber: pdfPageProxy.pageNumber
@@ -6829,6 +7809,10 @@ var useViewportContainer = ({
       if (!st.active) {
         return;
       }
+      if (Math.abs(event.deltaX) > abs) {
+        st.active = false;
+        return;
+      }
       if (now - st.lastTime > WHEEL_INERTIA_GAP_MS) {
         st.active = false;
         return;
@@ -6888,12 +7872,11 @@ var useViewportContainer = ({
             contentPosition,
             containerPosition,
             originZoom: currentZoom,
+            origin: [...origin],
             lastZoom: currentZoom
           };
         });
-        if (first) {
-          return newMemo;
-        }
+        if (first && ms === 1) return newMemo;
         const gestureValuesValid = Number.isFinite(ms) && ms > 0;
         let effectiveScale = ms;
         if (!gestureValuesValid) {
@@ -6912,9 +7895,18 @@ var useViewportContainer = ({
           minZoom,
           maxZoom
         );
+        if (event.type === "wheel") {
+          const previousScale = newMemo.lastZoom / newMemo.originZoom;
+          for (const axis of [0, 1]) {
+            const movement2 = origin[axis] - newMemo.origin[axis];
+            newMemo.contentPosition[axis] += movement2 / previousScale;
+            newMemo.containerPosition[axis] += movement2;
+            newMemo.origin[axis] = origin[axis];
+          }
+        }
         const realMs = newZoom / newMemo.originZoom;
-        const newTranslateX = newMemo.contentPosition[0] * realMs - newMemo.containerPosition[0];
-        const newTranslateY = newMemo.contentPosition[1] * realMs - newMemo.containerPosition[1];
+        const newTranslateX = newMemo.contentPosition[0] * realMs - newMemo.containerPosition[0] - (origin[0] - newMemo.origin[0]);
+        const newTranslateY = newMemo.contentPosition[1] * realMs - newMemo.containerPosition[1] - (origin[1] - newMemo.origin[1]);
         transformations.current = {
           zoom: newZoom,
           translateX: newTranslateX,
@@ -6988,16 +7980,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,
@@ -7078,7 +8088,14 @@ var Pages = ({
     };
   }, [isPinching, virtualizer?.measure, virtualizer?.getVirtualItems]);
   const virtualizerItems = virtualizer?.getVirtualItems() ?? [];
-  const items = tempItems.length ? tempItems : virtualizerItems;
+  const items = useMemo(() => {
+    if (!tempItems.length) return virtualizerItems;
+    const combined = new Map(
+      virtualizerItems.map((item) => [item.index, item])
+    );
+    for (const item of tempItems) combined.set(item.index, item);
+    return [...combined.values()].sort((a, b) => a.index - b.index);
+  }, [tempItems, virtualizerItems]);
   useVisiblePage({
     items,
     // Pass through nullish (pre-measure) rather than coercing to 0, so the
@@ -7115,6 +8132,7 @@ var Pages = ({
     Primitive.div,
     {
       ref: containerRef,
+      tabIndex: 0,
       ...props,
       style: {
         display: "flex",
@@ -7759,6 +8777,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) {
@@ -7768,9 +8788,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)
@@ -7778,7 +8802,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 = {
@@ -8187,33 +9215,31 @@ var CurrentZoom = ({ ...props }) => {
 
 // src/lib/search.ts
 var normalizedPages = /* @__PURE__ */ new WeakMap();
-function normalize(page) {
-  const cached = normalizedPages.get(page);
-  if (cached?.text === page.text) return cached;
-  const lower = page.text.toLowerCase();
-  const result = { text: page.text, lower };
-  if (lower.length !== page.text.length) {
-    result.starts = new Uint32Array(lower.length);
-    result.ends = new Uint32Array(lower.length);
-    let original = 0;
-    let normalized = 0;
-    for (const character of page.text) {
-      const length = character.toLowerCase().length;
-      for (let i = 0; i < length; i++) {
-        result.starts[normalized + i] = original + (length === character.length ? i : 0);
-        result.ends[normalized + i] = original + (length === character.length ? i + 1 : character.length);
-      }
-      original += character.length;
-      normalized += length;
-    }
-  }
-  normalizedPages.set(page, result);
+function normalize(page, options) {
+  let cached = normalizedPages.get(page);
+  if (cached?.text !== page.text || cached.lineBreaks !== page.lineBreaks) {
+    cached = {
+      text: page.text,
+      lineBreaks: page.lineBreaks,
+      variants: /* @__PURE__ */ new Map()
+    };
+    normalizedPages.set(page, cached);
+  }
+  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.lower.length, start + length);
-  const matchIndex = normalized.starts?.[start] ?? start;
-  const matchEnd = normalized.ends?.[end - 1] ?? end;
+  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,
@@ -8276,7 +9302,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 = [];
@@ -8286,10 +9313,16 @@ function* runSearch(pages, searchText, options = {}, cooperative = false, budget
   let steps = 0;
   let deadline = cooperative ? performance.now() + budget : 0;
   for (const page of pages) {
-    const normalized = normalize(page);
-    const lower = normalized.lower;
+    if (cooperative && performance.now() >= deadline) {
+      yield;
+      deadline = performance.now() + budget;
+    }
+    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;
@@ -8297,8 +9330,20 @@ 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 (maxDistance === 0 && exactCount > limit) {
+        return { exactMatches, fuzzyMatches, hasMoreResults: true };
+      }
       if (exactMatches.length < limit) {
         exactMatches.push(
           createMatch(
@@ -8373,7 +9418,19 @@ async function searchDocumentAsync(pages, searchText, options = {}) {
       throw new DOMException("Search aborted", "AbortError");
     const result = iterator.next();
     if (result.done) return result.value;
-    await new Promise((resolve) => setTimeout(resolve, 0));
+    await new Promise((resolve) => {
+      if (typeof MessageChannel === "undefined") {
+        setTimeout(resolve, 0);
+        return;
+      }
+      const channel = new MessageChannel();
+      channel.port1.onmessage = () => {
+        channel.port1.close();
+        channel.port2.close();
+        resolve();
+      };
+      channel.port2.postMessage(null);
+    });
   }
 }
 
@@ -8471,10 +9528,16 @@ async function calculateHighlightRects(pageProxy, textMatch) {
         const start = Math.max(0, textMatch.matchIndex - offset3);
         const end = Math.min(length, matchEnd - offset3);
         if (end > start && item.str.slice(start, end).trim()) {
+          let style = styles[item.fontName];
+          if (style?.fontFamily && !style.vertical && (start > 0 || end < length)) {
+            const { TextLayer: TextLayer2 } = await loadPdfJs();
+            const fontFamily = TextLayer2.fontFamilyMap.get(style.fontFamily);
+            if (fontFamily) style = { ...style, fontFamily };
+          }
           matchRects.push(
             getItemRect(
               item,
-              styles[item.fontName],
+              style,
               viewport,
               start,
               end,
@@ -8579,5 +9642,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 };