@rightkit/document-core 0.1.2 → 0.2.0

package/dist/documents/pdf/usePdfSearch.js

@@ -1,367 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { findLiteralMatches } from "../searchUtils.js";
-import { MARK_ACTIVE_BG, MARK_BG, highlightSpan } from "./pdfShared.js";
-const NO_RESULT = { count: 0, activeIndex: -1 };
-export const PDF_SEARCH_CACHE_MAX_BYTES = 8 * 1024 * 1024;
-function textBytes(text) {
-    // UTF-16 storage is a safe upper bound for this in-memory cache and avoids allocating a second
-    // encoded copy merely to account for it.
-    return text.length * 2;
-}
-/**
- * Read page text through same streaming API used by rendered text layers. WKWebView's PDF.js worker
- * can finish a stream-backed text layer while a parallel getTextContent() request remains empty;
- * search must consume stream chunks so native search sees text already visible on page.
- */
-export async function readPdfPageText(page, signal) {
-    const reader = page.streamTextContent().getReader();
-    const items = [];
-    let canceled = false;
-    const cancelRead = () => {
-        if (canceled)
-            return;
-        canceled = true;
-        void reader.cancel().catch(() => undefined);
-    };
-    signal?.addEventListener("abort", cancelRead, { once: true });
-    try {
-        while (true) {
-            if (signal?.aborted)
-                throw new DOMException("Search canceled", "AbortError");
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            for (const item of value.items) {
-                if ("str" in item)
-                    items.push(item.str);
-            }
-        }
-    }
-    finally {
-        signal?.removeEventListener("abort", cancelRead);
-        if (signal?.aborted)
-            cancelRead();
-        reader.releaseLock();
-    }
-    return items.join(" ");
-}
-/**
- * PDF find, exposed as the app's shared `SearchProvider`. Owns the match model + committed query +
- * options (read by the viewer's render path via the returned refs to draw <mark>s, and as effect
- * deps to re-highlight already-rendered pages). Page text is extracted once per page and cached
- * (original case — case folding happens at match time); rapid typing supersedes in-flight runs via a
- * sequence guard. Supports match-case + whole-word; read-only (no replace).
- */
-export function usePdfSearch({ url, pdfRef, slotRefs, scrollRef, goToPage, registerSearchProvider, }) {
-    const [committedQuery, setCommittedQuery] = useState("");
-    const [opts, setOpts] = useState({ matchCase: false, wholeWord: false });
-    const [matches, setMatches] = useState([]);
-    const [activeIdx, setActiveIdx] = useState(0);
-    const pageTextRef = useRef(new Map()); // page → original-case text (find cache)
-    const pageTextBytesRef = useRef(0);
-    const searchAbortRef = useRef(null);
-    const queryRef = useRef(""); // committed query, read by the viewer's renderPage to highlight
-    const optionsRef = useRef(opts); // current options, read by renderPage's highlight
-    const activeMarkRef = useRef(null);
-    const searchSeqRef = useRef(0); // bumped per search; guards stale overlapping runSearch results
-    const matchesLenRef = useRef(0); // live match count for stable next()/prev() provider methods
-    const activeIdxRef = useRef(0);
-    const searchResultListenersRef = useRef(new Set());
-    queryRef.current = committedQuery;
-    optionsRef.current = opts;
-    matchesLenRef.current = matches.length;
-    activeIdxRef.current = activeIdx;
-    const cachePageText = useCallback((page, text) => {
-        const previous = pageTextRef.current.get(page);
-        if (previous !== undefined)
-            pageTextBytesRef.current -= textBytes(previous);
-        pageTextRef.current.delete(page);
-        const bytes = textBytes(text);
-        if (bytes <= PDF_SEARCH_CACHE_MAX_BYTES) {
-            pageTextRef.current.set(page, text);
-            pageTextBytesRef.current += bytes;
-        }
-        while (pageTextBytesRef.current > PDF_SEARCH_CACHE_MAX_BYTES) {
-            const oldest = pageTextRef.current.keys().next().value;
-            if (oldest === undefined)
-                break;
-            const oldText = pageTextRef.current.get(oldest) ?? "";
-            pageTextRef.current.delete(oldest);
-            pageTextBytesRef.current -= textBytes(oldText);
-        }
-    }, []);
-    // --- Find: extract text, count matches, navigate -------------------------------
-    // NOTE (approximate by design): the match COUNT comes from each page's getTextContent() items
-    // joined with a space, while the highlight <mark>s are applied per rendered text-layer span. A
-    // query that straddles a text-item/span boundary can be counted but not visibly highlighted (and
-    // vice versa). Accepted as approximate PDF search; the page-nav fallback always lands right.
-    const runSearch = useCallback(async (raw, options, notifyListeners = false) => {
-        const pdf = pdfRef.current;
-        const q = raw.trim();
-        searchAbortRef.current?.abort();
-        const controller = new AbortController();
-        searchAbortRef.current = controller;
-        const seq = ++searchSeqRef.current; // supersede any in-flight search (rapid typing on big docs)
-        if (!pdf || !q) {
-            setMatches([]);
-            setActiveIdx(0);
-            return [];
-        }
-        // Extract uncached pages in parallel chunks instead of one page at a time — a first search on
-        // a big PDF used to freeze with zero feedback until every page had round-tripped through
-        // getTextContent(). Chunking keeps memory/IPC fan-out bounded while still overlapping the work.
-        const CHUNK = 8;
-        const pending = [];
-        for (let n = 1; n <= pdf.numPages; n++) {
-            if (!pageTextRef.current.has(n))
-                pending.push(n);
-        }
-        // Each page's text is scanned for matches exactly ONCE per search (counts keyed by page), and
-        // publishes just flatten the counts in page order. Rescanning every page's text on every
-        // chunk publish was quadratic on big PDFs (125 chunks × 1000 pages of regex work).
-        const counts = new Map();
-        const scanPage = (n, text = pageTextRef.current.get(n) ?? "") => {
-            counts.set(n, findLiteralMatches(text, q, options).length);
-        };
-        for (let n = 1; n <= pdf.numPages; n++) {
-            if (pageTextRef.current.has(n))
-                scanPage(n);
-        }
-        const flatten = () => {
-            const found = [];
-            for (let n = 1; n <= pdf.numPages; n++) {
-                const c = counts.get(n) ?? 0;
-                for (let occ = 0; occ < c; occ++)
-                    found.push({ page: n, occ });
-            }
-            return found;
-        };
-        for (let i = 0; i < pending.length; i += CHUNK) {
-            if (searchSeqRef.current !== seq || controller.signal.aborted)
-                return [];
-            const chunk = pending.slice(i, i + CHUNK);
-            await Promise.all(chunk.map(async (n) => {
-                try {
-                    const page = await pdf.getPage(n);
-                    const text = await readPdfPageText(page, controller.signal);
-                    if (controller.signal.aborted)
-                        return;
-                    cachePageText(n, text);
-                    scanPage(n, text);
-                }
-                catch {
-                    if (!controller.signal.aborted) {
-                        cachePageText(n, "");
-                        scanPage(n, "");
-                    }
-                }
-            }));
-            if (searchSeqRef.current !== seq || controller.signal.aborted)
-                return [];
-            // Publish a growing count as each chunk lands instead of staying blank until the whole
-            // document is scanned; the active index is only committed once, after the final chunk.
-            if (i + CHUNK < pending.length)
-                setMatches(flatten());
-        }
-        if (searchSeqRef.current !== seq || controller.signal.aborted)
-            return [];
-        const found = flatten();
-        const nextResult = {
-            count: found.length,
-            activeIndex: found.length ? 0 : -1,
-        };
-        const previousCount = matchesLenRef.current;
-        const previousResult = {
-            count: previousCount,
-            activeIndex: previousCount ? activeIdxRef.current : -1,
-        };
-        setMatches(found);
-        setActiveIdx(0);
-        if (notifyListeners &&
-            queryRef.current === q &&
-            (previousResult.count !== nextResult.count ||
-                previousResult.activeIndex !== nextResult.activeIndex)) {
-            for (const listener of searchResultListenersRef.current)
-                listener(q, nextResult);
-        }
-        return found;
-    }, [cachePageText, pdfRef]);
-    // A scanned page's empty text layer caches "" forever, leaving later OCR text invisible to find.
-    // Keep the cache private while letting recognition inject authoritative original-case text and
-    // recount an already-committed query through the same guarded search path.
-    const setPageText = useCallback((page, text) => {
-        cachePageText(page, text);
-        if (queryRef.current)
-            void runSearch(queryRef.current, optionsRef.current, true);
-    }, [cachePageText, runSearch]);
-    const invalidatePageText = useCallback((page) => {
-        const previous = pageTextRef.current.get(page);
-        if (previous !== undefined)
-            pageTextBytesRef.current -= textBytes(previous);
-        pageTextRef.current.delete(page);
-    }, []);
-    // SearchProvider for the shared FindBar. find() commits the query + options (drives the <mark>
-    // highlight render) and runs the search; next/prev step the active match (live count via a ref so
-    // the methods stay referentially stable). Returns the provider-owned {count, activeIndex}.
-    const providerFind = useCallback(async (raw, options) => {
-        setCommittedQuery(raw.trim());
-        setOpts(options);
-        // FindBar-initiated searches return their result directly; pushing it too would duplicate
-        // the update and can create a render loop.
-        const found = await runSearch(raw, options, false);
-        return { count: found.length, activeIndex: found.length ? 0 : -1 };
-    }, [runSearch]);
-    const providerNext = useCallback(() => {
-        const n = matchesLenRef.current;
-        if (!n)
-            return NO_RESULT;
-        let idx = 0;
-        setActiveIdx((i) => {
-            idx = (i + 1) % n;
-            return idx;
-        });
-        return { count: n, activeIndex: idx };
-    }, []);
-    const providerPrev = useCallback(() => {
-        const n = matchesLenRef.current;
-        if (!n)
-            return NO_RESULT;
-        let idx = 0;
-        setActiveIdx((i) => {
-            idx = (i - 1 + n) % n;
-            return idx;
-        });
-        return { count: n, activeIndex: idx };
-    }, []);
-    const providerSubscribe = useCallback((listener) => {
-        searchResultListenersRef.current.add(listener);
-        return () => searchResultListenersRef.current.delete(listener);
-    }, []);
-    const providerClose = useCallback(() => {
-        searchResultListenersRef.current.clear();
-        searchSeqRef.current++;
-        searchAbortRef.current?.abort();
-        searchAbortRef.current = null;
-        setCommittedQuery("");
-        setMatches([]);
-        setActiveIdx(0);
-        activeMarkRef.current = null;
-    }, []);
-    const searchProvider = useMemo(() => ({
-        kind: "pdf",
-        canReplace: false,
-        supportsMatchCase: true,
-        supportsWholeWord: true,
-        supportsRegex: true,
-        find: providerFind,
-        next: providerNext,
-        prev: providerPrev,
-        subscribe: providerSubscribe,
-        close: providerClose,
-    }), [providerFind, providerNext, providerPrev, providerSubscribe, providerClose]);
-    // Register on mount, unregister on unmount. DocumentRouter keys the viewer by doc.path, so a
-    // document switch remounts this hook — registration rides the normal lifecycle.
-    useEffect(() => {
-        if (!registerSearchProvider)
-            return;
-        registerSearchProvider(searchProvider);
-        return () => registerSearchProvider(null);
-    }, [registerSearchProvider, searchProvider]);
-    // Reset all search state when the document changes. `url` is deliberately a lifecycle trigger:
-    // the state belongs to the mounted PDF, rather than a value read by the reset body.
-    // biome-ignore lint/correctness/useExhaustiveDependencies: reset state when the document URL changes.
-    useEffect(() => {
-        pageTextRef.current.clear();
-        pageTextBytesRef.current = 0;
-        searchAbortRef.current?.abort();
-        searchAbortRef.current = null;
-        searchSeqRef.current++;
-        activeMarkRef.current = null;
-        setCommittedQuery("");
-        setMatches([]);
-        setActiveIdx(0);
-        return () => {
-            searchSeqRef.current++;
-            searchAbortRef.current?.abort();
-            searchAbortRef.current = null;
-            pageTextRef.current.clear();
-            pageTextBytesRef.current = 0;
-        };
-    }, [url]);
-    // Re-apply highlights to all *currently-rendered* text layers when the query OR options change —
-    // in place, without tearing pages down (that teardown was the typing jitter). Pages that scroll in
-    // afterward are highlighted by renderPage via queryRef/optionsRef. Empty query flattens marks away.
-    // The callback is also used after OCR mounts a recognized-text layer without changing the query.
-    // biome-ignore lint/correctness/useExhaustiveDependencies: slotRefs is a stable mutable render registry.
-    const rehighlight = useCallback(() => {
-        const q = queryRef.current;
-        const options = optionsRef.current;
-        slotRefs.current.forEach((slot) => {
-            for (const selector of [".textLayer", ".pdfOcrLayer"]) {
-                const layer = slot.querySelector(selector);
-                if (!layer)
-                    continue;
-                layer.querySelectorAll("span").forEach((span) => {
-                    if (q)
-                        highlightSpan(span, q, options);
-                    else if (span.childElementCount > 0)
-                        span.replaceChildren(document.createTextNode(span.textContent ?? ""));
-                });
-            }
-        });
-    }, []);
-    // biome-ignore lint/correctness/useExhaustiveDependencies: query/options intentionally trigger ref-driven DOM repaint.
-    useEffect(() => {
-        rehighlight();
-    }, [committedQuery, opts, rehighlight]);
-    // Emphasize the active match and bring it into view. Only scrolls when the match isn't already
-    // visible. `goToPage` is the fallback when the match's page hasn't rendered yet.
-    useEffect(() => {
-        if (matches.length === 0)
-            return;
-        const m = matches[activeIdx];
-        if (!m)
-            return;
-        let raf = 0;
-        let tries = 0;
-        let navigated = false;
-        const tick = () => {
-            const slot = slotRefs.current.get(m.page);
-            const marks = slot?.querySelectorAll("mark");
-            if (marks && marks.length > m.occ) {
-                if (activeMarkRef.current && activeMarkRef.current !== marks[m.occ]) {
-                    activeMarkRef.current.style.background = MARK_BG;
-                }
-                const el = marks[m.occ];
-                el.style.background = MARK_ACTIVE_BG;
-                activeMarkRef.current = el;
-                const root = scrollRef.current;
-                if (root) {
-                    const er = el.getBoundingClientRect();
-                    const cr = root.getBoundingClientRect();
-                    if (er.top < cr.top || er.bottom > cr.bottom)
-                        el.scrollIntoView({ block: "center" });
-                }
-                return;
-            }
-            if (!navigated) {
-                goToPage(m.page);
-                navigated = true;
-            }
-            if (tries++ < 60)
-                raf = requestAnimationFrame(tick);
-        };
-        raf = requestAnimationFrame(tick);
-        return () => cancelAnimationFrame(raf);
-    }, [activeIdx, matches, goToPage, scrollRef, slotRefs]);
-    // committedQuery drives the viewer's highlight re-render dependency; queryRef/optionsRef are read
-    // by its per-page render to apply <mark>s as pages render in.
-    return {
-        committedQuery,
-        queryRef,
-        optionsRef,
-        setPageText,
-        invalidatePageText,
-        rehighlight,
-    };
-}

package/dist/documents/pdf/usePdfViewControls.d.ts

@@ -1,72 +0,0 @@
-import { type Dispatch, type MutableRefObject, type SetStateAction, type WheelEvent as ReactWheelEvent } from "react";
-import type { PDFDocumentProxy } from "pdfjs-dist";
-interface UsePdfViewControlsArgs {
-    active: boolean;
-    numPages: number;
-    pageDraft: string | null;
-    scale: number;
-    scaleDraft: string;
-    scrollRef: MutableRefObject<HTMLDivElement | null>;
-    pdfRef: MutableRefObject<PDFDocumentProxy | null>;
-    goToPage: (page: number) => void;
-    setPageDraft: Dispatch<SetStateAction<string | null>>;
-    setPageShake: Dispatch<SetStateAction<boolean>>;
-    setScale: Dispatch<SetStateAction<number>>;
-    setScaleDraft: Dispatch<SetStateAction<string>>;
-    setFitMode: Dispatch<SetStateAction<"width" | "page" | null>>;
-    setRotation: Dispatch<SetStateAction<number>>;
-}
-export declare function isPdfTypingTarget(target: EventTarget | null): boolean;
-type PdfViewShortcutHandlers = {
-    /** True while Home/End should page-jump (the scroll pane itself has focus). */
-    homeEnd: () => boolean;
-    goHome: () => void;
-    goEnd: () => void;
-    zoomBy: (delta: number) => void;
-    fitWidth: () => void;
-};
-/**
- * The PDF pane's view shortcuts as a registry: Home/End to the first/last page (scroll pane
- * focused), Ctrl/Cmd `=`/`+` zoom in, `-` zoom out, `0` fit to width. A key that lands in a text
- * field or editable region is left alone (`run` answers `false`).
- *
- * The raw handler these replace accepted every modifier combination around its named key (Shift,
- * Alt, both Ctrl and Meta), ignored whether the event was already prevented, and did not look at
- * IME composition. The registry options keep that: `ignoreExtraModifiers` (a named modifier must be
- * held, any other may be), `ctrlormeta` (Ctrl or Meta, either or both), `allowDefaultPrevented`
- * and `allowComposing`.
- */
-export declare function createPdfViewShortcuts(handlers: PdfViewShortcutHandlers): {
-    platform: import("@rightkit/platform-ui").Platform;
-    register: (def: import("@rightkit/react-shell").ShortcutDef) => () => void;
-    handle: (event: KeyboardEvent) => boolean;
-    attach: (target?: Pick<EventTarget, "addEventListener" | "removeEventListener">) => () => void;
-    list: () => import("@rightkit/react-shell").ShortcutInfo[];
-    groups: () => {
-        title: string;
-        items: import("@rightkit/react-shell").ShortcutInfo[];
-    }[];
-    conflicts: () => {
-        chord: string;
-        ids: string[];
-        kind: "exact" | "prefix";
-    }[];
-    invoke(id: string): boolean;
-    chordFor: (id: string) => string | undefined;
-    setOverrides(next: Record<string, string | null>): void;
-    suspend(): void;
-    resume(): void;
-    isSuspended: () => boolean;
-    overrides: () => Record<string, string | null>;
-    subscribe(listener: () => void): () => void;
-    version: () => number;
-};
-export declare function usePdfViewControls({ active, numPages, pageDraft, scale, scaleDraft, scrollRef, pdfRef, goToPage, setPageDraft, setPageShake, setScale, setScaleDraft, setFitMode, setRotation, }: UsePdfViewControlsArgs): {
-    goToDest: (dest: string | unknown[] | null) => Promise<void>;
-    commitPageDraft: () => void;
-    zoom: (delta: number) => void;
-    commitScaleDraft: () => void;
-    onWheelZoom: (event: ReactWheelEvent<HTMLDivElement>) => void;
-    rotate: (delta: number) => void;
-};
-export {};

package/dist/documents/pdf/usePdfViewControls.js

@@ -1,152 +0,0 @@
-import { useCallback, useEffect, } from "react";
-import { createShortcutRegistry } from "@rightkit/react-shell";
-import { clampScale, ZOOM_MAX, ZOOM_MIN } from "./pdfShared.js";
-export function isPdfTypingTarget(target) {
-    if (!(target instanceof Element))
-        return false;
-    return (target.tagName === "INPUT" ||
-        target.tagName === "TEXTAREA" ||
-        (target instanceof HTMLElement && target.isContentEditable) ||
-        target.closest("[contenteditable='true']") !== null);
-}
-const LEGACY_KEY_MATCH = {
-    ignoreExtraModifiers: true,
-    allowDefaultPrevented: true,
-    allowComposing: true,
-};
-/**
- * The PDF pane's view shortcuts as a registry: Home/End to the first/last page (scroll pane
- * focused), Ctrl/Cmd `=`/`+` zoom in, `-` zoom out, `0` fit to width. A key that lands in a text
- * field or editable region is left alone (`run` answers `false`).
- *
- * The raw handler these replace accepted every modifier combination around its named key (Shift,
- * Alt, both Ctrl and Meta), ignored whether the event was already prevented, and did not look at
- * IME composition. The registry options keep that: `ignoreExtraModifiers` (a named modifier must be
- * held, any other may be), `ctrlormeta` (Ctrl or Meta, either or both), `allowDefaultPrevented`
- * and `allowComposing`.
- */
-export function createPdfViewShortcuts(handlers) {
-    const registry = createShortcutRegistry();
-    const guarded = (run) => (event) => {
-        if (isPdfTypingTarget(event.target))
-            return false;
-        run();
-    };
-    registry.register({
-        id: "pdf.first-page",
-        label: "First page",
-        chord: "home",
-        hidden: true,
-        ...LEGACY_KEY_MATCH,
-        when: handlers.homeEnd,
-        run: guarded(handlers.goHome),
-    });
-    registry.register({
-        id: "pdf.last-page",
-        label: "Last page",
-        chord: "end",
-        hidden: true,
-        ...LEGACY_KEY_MATCH,
-        when: handlers.homeEnd,
-        run: guarded(handlers.goEnd),
-    });
-    registry.register({
-        id: "pdf.zoom-in",
-        label: "Zoom in",
-        chord: ["ctrlormeta+=", "ctrlormeta+plus"],
-        hidden: true,
-        ...LEGACY_KEY_MATCH,
-        run: guarded(() => handlers.zoomBy(0.15)),
-    });
-    registry.register({
-        id: "pdf.zoom-out",
-        label: "Zoom out",
-        chord: "ctrlormeta+-",
-        hidden: true,
-        ...LEGACY_KEY_MATCH,
-        run: guarded(() => handlers.zoomBy(-0.15)),
-    });
-    registry.register({
-        id: "pdf.fit-width",
-        label: "Fit to width",
-        chord: "ctrlormeta+0",
-        hidden: true,
-        ...LEGACY_KEY_MATCH,
-        run: guarded(handlers.fitWidth),
-    });
-    return registry;
-}
-export function usePdfViewControls({ active, numPages, pageDraft, scale, scaleDraft, scrollRef, pdfRef, goToPage, setPageDraft, setPageShake, setScale, setScaleDraft, setFitMode, setRotation, }) {
-    const goToDest = useCallback(async (dest) => {
-        const pdf = pdfRef.current;
-        if (!pdf || !dest)
-            return;
-        try {
-            const explicit = typeof dest === "string" ? await pdf.getDestination(dest) : dest;
-            const ref = Array.isArray(explicit) ? explicit[0] : null;
-            if (!ref)
-                return;
-            const pageIndex = await pdf.getPageIndex(ref);
-            goToPage(pageIndex + 1);
-        }
-        catch {
-            /* malformed destination - ignore */
-        }
-    }, [goToPage, pdfRef]);
-    const commitPageDraft = useCallback(() => {
-        if (pageDraft == null)
-            return;
-        const n = Number(pageDraft);
-        if (Number.isFinite(n) && n >= 1 && (numPages === 0 || n <= numPages)) {
-            goToPage(n);
-        }
-        else {
-            setPageShake(true);
-            window.setTimeout(() => setPageShake(false), 360);
-        }
-        setPageDraft(null);
-    }, [goToPage, numPages, pageDraft, setPageDraft, setPageShake]);
-    const zoom = useCallback((delta) => {
-        setFitMode(null);
-        setScale((s) => clampScale(+(s + delta).toFixed(2)));
-    }, [setFitMode, setScale]);
-    useEffect(() => {
-        setScaleDraft(String(Math.round(scale * 100)));
-    }, [scale, setScaleDraft]);
-    const commitScaleDraft = useCallback(() => {
-        const parsed = Number.parseInt(scaleDraft, 10);
-        if (Number.isNaN(parsed)) {
-            setScaleDraft(String(Math.round(scale * 100)));
-            return;
-        }
-        const clamped = Math.max(Math.round(ZOOM_MIN * 100), Math.min(Math.round(ZOOM_MAX * 100), parsed));
-        setFitMode(null);
-        setScale(clamped / 100);
-        setScaleDraft(String(clamped));
-    }, [scale, scaleDraft, setFitMode, setScale, setScaleDraft]);
-    const onWheelZoom = useCallback((event) => {
-        if (!(event.ctrlKey || event.metaKey))
-            return;
-        event.preventDefault();
-        event.stopPropagation();
-        zoom(event.deltaY < 0 ? 0.1 : -0.1);
-    }, [zoom]);
-    const rotate = useCallback((delta) => setRotation((r) => (((r + delta) % 360) + 360) % 360), [setRotation]);
-    useEffect(() => {
-        if (!active)
-            return;
-        const el = scrollRef.current;
-        const registry = createPdfViewShortcuts({
-            homeEnd: () => Boolean(el) && document.activeElement === el,
-            goHome: () => goToPage(1),
-            goEnd: () => goToPage(numPages),
-            zoomBy: (delta) => {
-                setFitMode(null);
-                setScale((s) => clampScale(+(s + delta).toFixed(2)));
-            },
-            fitWidth: () => setFitMode("width"),
-        });
-        return registry.attach(window);
-    }, [active, goToPage, numPages, scrollRef, setFitMode, setScale]);
-    return { goToDest, commitPageDraft, zoom, commitScaleDraft, onWheelZoom, rotate };
-}

package/dist/documents/scopedSelectAll.d.ts

@@ -1,5 +0,0 @@
-export declare function isSelectAllShortcut(event: Pick<KeyboardEvent, "key" | "ctrlKey" | "metaKey" | "altKey">): boolean;
-export declare function isEditableSelectionTarget(target: EventTarget | null): boolean;
-export declare function selectionIntersectsElement(element: Element, win?: Window): boolean;
-export declare function selectElementContents(element: Element, win?: Window): void;
-export declare function selectVisualLineAtPoint(element: HTMLElement, clientY: number): boolean;

package/dist/documents/scopedSelectAll.js

@@ -1,77 +0,0 @@
-export function isSelectAllShortcut(event) {
-    return (event.ctrlKey || event.metaKey) && !event.altKey && event.key.toLowerCase() === "a";
-}
-export function isEditableSelectionTarget(target) {
-    if (!(target instanceof Element))
-        return false;
-    const tag = target.tagName.toLowerCase();
-    if (tag === "input" || tag === "textarea" || tag === "select")
-        return true;
-    if (target instanceof HTMLElement && typeof target.isContentEditable === "boolean") {
-        return target.isContentEditable;
-    }
-    const editable = target.closest("[contenteditable]");
-    const value = editable?.getAttribute("contenteditable")?.trim().toLowerCase();
-    return value === "" || value === "true" || value === "plaintext-only";
-}
-export function selectionIntersectsElement(element, win = window) {
-    const selection = win.getSelection();
-    if (!selection || selection.rangeCount === 0)
-        return false;
-    for (let i = 0; i < selection.rangeCount; i += 1) {
-        const range = selection.getRangeAt(i);
-        if (range.intersectsNode(element))
-            return true;
-    }
-    return false;
-}
-export function selectElementContents(element, win = window) {
-    const doc = element.ownerDocument;
-    const range = doc.createRange();
-    range.selectNodeContents(element);
-    const selection = win.getSelection();
-    selection?.removeAllRanges();
-    selection?.addRange(range);
-}
-function caretRangeAtPoint(doc, x, y) {
-    const position = doc.caretPositionFromPoint?.(x, y);
-    if (position) {
-        const range = doc.createRange();
-        range.setStart(position.offsetNode, position.offset);
-        range.collapse(true);
-        return range;
-    }
-    return doc.caretRangeFromPoint?.(x, y) ?? null;
-}
-export function selectVisualLineAtPoint(element, clientY) {
-    const doc = element.ownerDocument;
-    const rect = element.getBoundingClientRect();
-    if (rect.width <= 0 || rect.height <= 0)
-        return false;
-    const xStart = Math.min(rect.right - 1, rect.left + 1);
-    const xEnd = Math.max(xStart, rect.right - 1);
-    const y = Math.max(rect.top + 1, Math.min(rect.bottom - 1, clientY));
-    const start = caretRangeAtPoint(doc, xStart, y);
-    const end = caretRangeAtPoint(doc, xEnd, y);
-    if (!start ||
-        !end ||
-        !element.contains(start.startContainer) ||
-        !element.contains(end.startContainer)) {
-        return false;
-    }
-    const range = doc.createRange();
-    if (start.compareBoundaryPoints(Range.START_TO_START, end) <= 0) {
-        range.setStart(start.startContainer, start.startOffset);
-        range.setEnd(end.startContainer, end.startOffset);
-    }
-    else {
-        range.setStart(end.startContainer, end.startOffset);
-        range.setEnd(start.startContainer, start.startOffset);
-    }
-    const selection = doc.defaultView?.getSelection();
-    if (!selection)
-        return false;
-    selection.removeAllRanges();
-    selection.addRange(range);
-    return true;
-}