@reekon-tools/boldr-utils 1.22.0 → 1.24.0

package/dist/annotation/data/hooks/usePdfCanvasDoc.js

@@ -0,0 +1,344 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { applyPatch, createEmptyCanvasState, } from '../../../types/annotation.js';
+import { canvasStateToPageState, pageStateToCanvasState, pdfCanvasKnobsEqual, pdfCanvasKnobsOf, pdfPageDisplaySize, rotatePageState, rotatePdfCanvasPage, } from '../../canvas/pdfCanvasPages.js';
+import { useAnnotationData } from '../AnnotationDataContext.js';
+import { annotationScopeKey, } from '../AnnotationDataProvider.js';
+import { createCoalescedRunner } from '../coalescedRunner.js';
+import { useAnnotationDoc } from './useAnnotationDoc.js';
+const makeClientId = () => `${Date.now().toString(36)}-${Math.floor(Math.random() * 0x100000000).toString(36)}`;
+const hasContent = (canvas) => canvas.strokes.length > 0 ||
+    canvas.shapes.length > 0 ||
+    canvas.placedMeasurements.length > 0 ||
+    (canvas.planes?.length ?? 0) > 0;
+// Drop undefined keys (Firestore — RN in particular — rejects them) and detach
+// the persisted payload from the working state's object identities.
+const jsonClone = (value) => JSON.parse(JSON.stringify(value));
+// Load + explicit-save orchestration for ONE page of a PdfCanvas file. The
+// canvas engine is page-agnostic: this hook hands it the page's state as an
+// ordinary AnnotationCanvasState (pageStateToCanvasState) and persists it back
+// as a page doc. Mirrors useAnnotationCanvasDoc's echo suppression (a `rev`
+// stamped with this session's clientId) and single-flight flushing.
+export const usePdfCanvasDoc = (options) => {
+    const { scope, fileId, pageIndex, onSaveError, captureThumbnail, debugLogging = false, } = options;
+    const provider = useAnnotationData();
+    const { data: file, loading: fileLoading, error: fileError, } = useAnnotationDoc(scope, fileId);
+    const pdfCanvas = file?.fileData.pdfCanvas ?? null;
+    const [pageDoc, setPageDoc] = useState(null);
+    const [pageLoading, setPageLoading] = useState(true);
+    const [pageError, setPageError] = useState(null);
+    const [working, setWorking] = useState(null);
+    const [saveStatus, setSaveStatus] = useState('idle');
+    const workingRef = useRef(null);
+    const pdfCanvasRef = useRef(null);
+    const pageDocRef = useRef(null);
+    const statusRef = useRef('idle');
+    const pageIndexRef = useRef(pageIndex);
+    const scopeRef = useRef(scope);
+    const fileIdRef = useRef(fileId);
+    const onSaveErrorRef = useRef(onSaveError);
+    const captureThumbnailRef = useRef(captureThumbnail);
+    const debugRef = useRef(debugLogging);
+    const clientIdRef = useRef(null);
+    if (clientIdRef.current === null)
+        clientIdRef.current = makeClientId();
+    const writeSeqRef = useRef(0);
+    const editSeqRef = useRef(0);
+    const thumbnailSavingRef = useRef(false);
+    const thumbnailRequestedRef = useRef(false);
+    const thumbnailPromiseRef = useRef(undefined);
+    // A page whose edits must be persisted although it is no longer the current
+    // page (the user turned the page with unsaved edits).
+    const outgoingRef = useRef(null);
+    workingRef.current = working;
+    pdfCanvasRef.current = pdfCanvas;
+    pageDocRef.current = pageDoc;
+    statusRef.current = saveStatus;
+    scopeRef.current = scope;
+    fileIdRef.current = fileId;
+    onSaveErrorRef.current = onSaveError;
+    captureThumbnailRef.current = captureThumbnail;
+    debugRef.current = debugLogging;
+    const setStatus = useCallback((next) => {
+        statusRef.current = next;
+        setSaveStatus(next);
+    }, []);
+    // Subscribe to the current page's doc.
+    useEffect(() => {
+        if (!scope || !fileId) {
+            setPageDoc(null);
+            setPageLoading(false);
+            return;
+        }
+        setPageLoading(true);
+        setPageError(null);
+        const unsubscribe = provider.subscribePage(scope, fileId, pageIndex, (doc) => {
+            setPageDoc(doc);
+            setPageLoading(false);
+        }, (err) => {
+            setPageError(err);
+            setPageLoading(false);
+        });
+        return unsubscribe;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [provider, annotationScopeKey(scope), fileId, pageIndex]);
+    // Persist one page: the page doc, then whatever file-level fields it moved
+    // (first-annotation marker, tile knobs). Returns normally on failure after
+    // reporting it — callers read the status, not a rejection.
+    const persist = useCallback(async (target) => {
+        const currentScope = scopeRef.current;
+        const currentFileId = fileIdRef.current;
+        if (!currentScope || !currentFileId)
+            return false;
+        const rev = {
+            clientId: clientIdRef.current,
+            seq: ++writeSeqRef.current,
+        };
+        const state = jsonClone(canvasStateToPageState(target.canvas, target.pageIndex, {
+            updatedAt: Date.now(),
+            rev,
+        }));
+        if (debugRef.current) {
+            console.log('[usePdfCanvasDoc] save attempt', {
+                fileId: currentFileId,
+                pageIndex: target.pageIndex,
+                strokes: state.strokes.length,
+                shapes: state.shapes.length,
+                measurements: state.placedMeasurements.length,
+            });
+        }
+        try {
+            await provider.writePage(currentScope, currentFileId, target.pageIndex, state);
+            const patch = {};
+            if (!target.pdfCanvas.annotatedPages.includes(target.pageIndex)) {
+                patch['fileData.pdfCanvas.annotatedPages'] = {
+                    kind: 'arrayUnion',
+                    values: [target.pageIndex],
+                };
+            }
+            const knobs = pdfCanvasKnobsOf(target.canvas);
+            if (!pdfCanvasKnobsEqual(knobs, pdfCanvasKnobsOf(target.pdfCanvas))) {
+                for (const [key, value] of Object.entries(knobs)) {
+                    patch[`fileData.pdfCanvas.${key}`] = value;
+                }
+            }
+            if (Object.keys(patch).length > 0) {
+                await provider.update(currentScope, currentFileId, patch);
+            }
+            return true;
+        }
+        catch (e) {
+            console.error('[usePdfCanvasDoc] save failed', { fileId: currentFileId, pageIndex: target.pageIndex }, e);
+            onSaveErrorRef.current?.(e);
+            return false;
+        }
+    }, [provider]);
+    const saveThumbnail = useCallback(async (targetFileId) => {
+        const capture = captureThumbnailRef.current;
+        const currentScope = scopeRef.current;
+        if (!capture || !currentScope || thumbnailSavingRef.current)
+            return;
+        thumbnailSavingRef.current = true;
+        try {
+            const blob = await capture();
+            if (blob) {
+                await provider.uploadImage(currentScope, targetFileId, 'thumbnail', blob);
+            }
+        }
+        catch (e) {
+            console.warn('[usePdfCanvasDoc] thumbnail save failed', e);
+        }
+        finally {
+            thumbnailSavingRef.current = false;
+        }
+    }, [provider]);
+    // One flush pass: an outgoing page first (if a page turn left one behind),
+    // then the current page when it is dirty.
+    const runFlush = useCallback(async () => {
+        const outgoing = outgoingRef.current;
+        if (outgoing) {
+            outgoingRef.current = null;
+            await persist(outgoing);
+        }
+        const canvas = workingRef.current;
+        const data = pdfCanvasRef.current;
+        if (!canvas ||
+            !data ||
+            (statusRef.current !== 'dirty' && statusRef.current !== 'error')) {
+            return;
+        }
+        const editSeqAtFlush = editSeqRef.current;
+        const wantThumbnail = thumbnailRequestedRef.current;
+        thumbnailRequestedRef.current = false;
+        const targetPage = pageIndexRef.current;
+        setStatus('saving');
+        const ok = await persist({
+            pageIndex: targetPage,
+            canvas,
+            pdfCanvas: data,
+        });
+        if (!ok) {
+            setStatus('error');
+            return;
+        }
+        const currentFileId = fileIdRef.current;
+        if (wantThumbnail && targetPage === 0 && currentFileId) {
+            thumbnailPromiseRef.current = saveThumbnail(currentFileId);
+        }
+        setStatus(editSeqRef.current !== editSeqAtFlush ? 'dirty' : 'saved');
+    }, [persist, saveThumbnail, setStatus]);
+    const runFlushRef = useRef(runFlush);
+    runFlushRef.current = runFlush;
+    const flushRunner = useMemo(() => createCoalescedRunner(() => runFlushRef.current()), []);
+    const flush = useCallback(() => flushRunner(), [flushRunner]);
+    // Page turn: hand the outgoing page to the flusher if it has unsaved edits,
+    // then drop the working state so the next snapshot hydrates the new page.
+    useEffect(() => {
+        if (pageIndexRef.current === pageIndex)
+            return;
+        const previous = workingRef.current;
+        const data = pdfCanvasRef.current;
+        if (previous &&
+            data &&
+            (statusRef.current === 'dirty' || statusRef.current === 'error')) {
+            outgoingRef.current = {
+                pageIndex: pageIndexRef.current,
+                canvas: previous,
+                pdfCanvas: data,
+            };
+            void flush();
+        }
+        pageIndexRef.current = pageIndex;
+        workingRef.current = null;
+        setWorking(null);
+        setStatus('idle');
+    }, [pageIndex, flush, setStatus]);
+    // Reset on a different file.
+    useEffect(() => {
+        workingRef.current = null;
+        setWorking(null);
+        setStatus('idle');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [annotationScopeKey(scope), fileId]);
+    // Hydrate / reconcile from the persisted docs.
+    useEffect(() => {
+        if (!pdfCanvas || pageLoading)
+            return;
+        if (pageIndex >= pdfCanvas.document.pages.length)
+            return;
+        if (workingRef.current === null) {
+            const next = pageStateToCanvasState(pdfCanvas, pageDoc, pageIndex);
+            workingRef.current = next;
+            setWorking(next);
+            return;
+        }
+        // Local edits pending or a write in flight: never clobber them.
+        if (statusRef.current === 'saving' || statusRef.current === 'dirty')
+            return;
+        // The echo of this session's own write carries our clientId.
+        if (pageDoc?.rev?.clientId === clientIdRef.current)
+            return;
+        const next = pageStateToCanvasState(pdfCanvas, pageDoc, pageIndex);
+        workingRef.current = next;
+        setWorking(next);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [pdfCanvas, pageDoc, pageLoading, pageIndex]);
+    const onCommit = useCallback((patch) => {
+        editSeqRef.current += 1;
+        setWorking((prev) => {
+            if (!prev)
+                return prev;
+            const next = applyPatch(prev, patch);
+            workingRef.current = next;
+            return next;
+        });
+        setStatus('dirty');
+    }, [setStatus]);
+    const save = useCallback(async () => {
+        thumbnailRequestedRef.current = true;
+        await flush();
+        await thumbnailPromiseRef.current;
+    }, [flush]);
+    const refreshThumbnail = useCallback(async () => {
+        const currentFileId = fileIdRef.current;
+        if (!currentFileId)
+            return;
+        await saveThumbnail(currentFileId);
+    }, [saveThumbnail]);
+    const rotatePage = useCallback(async (delta) => {
+        const currentScope = scopeRef.current;
+        const currentFileId = fileIdRef.current;
+        // Pending edits first, so the rewrite below starts from persisted truth.
+        await flush();
+        const data = pdfCanvasRef.current;
+        const canvas = workingRef.current;
+        const index = pageIndexRef.current;
+        if (!currentScope || !currentFileId || !data || !canvas)
+            return;
+        const page = data.document.pages[index];
+        if (!page)
+            return;
+        const size = pdfPageDisplaySize(page);
+        const turnedPage = rotatePdfCanvasPage(page, delta);
+        const pages = data.document.pages.map((p, i) => i === index ? turnedPage : p);
+        // Knobs the flush just wrote may not have echoed back yet; carry them.
+        const nextData = {
+            ...data,
+            ...pdfCanvasKnobsOf(canvas),
+            document: { ...data.document, pages },
+        };
+        setStatus('saving');
+        try {
+            const patch = {
+                'fileData.pdfCanvas.document.pages': pages,
+            };
+            let turnedState = null;
+            if (hasContent(canvas)) {
+                const rev = {
+                    clientId: clientIdRef.current,
+                    seq: ++writeSeqRef.current,
+                };
+                turnedState = jsonClone(rotatePageState(canvasStateToPageState(canvas, index, {
+                    updatedAt: Date.now(),
+                    rev,
+                }), size, delta));
+                await provider.writePage(currentScope, currentFileId, index, turnedState);
+                if (!data.annotatedPages.includes(index)) {
+                    patch['fileData.pdfCanvas.annotatedPages'] = {
+                        kind: 'arrayUnion',
+                        values: [index],
+                    };
+                }
+            }
+            await provider.update(currentScope, currentFileId, patch);
+            const next = pageStateToCanvasState(nextData, turnedState, index);
+            workingRef.current = next;
+            setWorking(next);
+            setStatus('saved');
+        }
+        catch (e) {
+            console.error('[usePdfCanvasDoc] rotate failed', { fileId: currentFileId, pageIndex: index, delta }, e);
+            onSaveErrorRef.current?.(e);
+            setStatus('error');
+        }
+    }, [flush, provider, setStatus]);
+    const page = pdfCanvas?.document.pages[pageIndex] ?? null;
+    const canvas = useMemo(() => working ??
+        (page
+            ? createEmptyCanvasState(pdfPageDisplaySize(page))
+            : createEmptyCanvasState()), [working, page]);
+    return {
+        file,
+        pdfCanvas,
+        pageCount: pdfCanvas?.document.pageCount ?? 0,
+        page,
+        canvas,
+        onCommit,
+        loading: fileLoading || pageLoading || working === null,
+        error: fileError ?? pageError,
+        saveStatus,
+        hasUnsavedChanges: saveStatus === 'dirty' || saveStatus === 'error',
+        save,
+        rotatePage,
+        refreshThumbnail,
+    };
+};

package/dist/export/pdf/annots.d.ts

@@ -0,0 +1,23 @@
+import { PDFDocument, PDFPage, PDFRef } from 'pdf-lib';
+import type { Mark } from './marks.js';
+import { type AffineMatrix, type DocRect } from './pageMapping.js';
+import type { FormScope } from './resources.js';
+export interface AddAnnotationInput {
+    doc: PDFDocument;
+    page: PDFPage;
+    mark: Mark;
+    /** The page's doc-space rect; the appearance is clipped to it. */
+    pageRect: DocRect;
+    matrix: AffineMatrix;
+    /** The scope the mark's operators registered their resources in. */
+    scope: FormScope;
+    /** A sibling annotation this one belongs with (Acrobat groups them). */
+    groupWith?: PDFRef;
+}
+/**
+ * Wrap a mark as an annotation on `page`. Returns the annotation's ref, or
+ * null when the mark lies entirely outside the page.
+ */
+export declare const addMarkAnnotation: ({ doc, page, mark, pageRect, matrix, scope, groupWith, }: AddAnnotationInput) => PDFRef | null;
+/** How many annotations a page carries (for tests and the result). */
+export declare const annotationCount: (page: PDFPage) => number;

package/dist/export/pdf/annots.js

@@ -0,0 +1,135 @@
+// Annotation mode: every element becomes a PDF annotation object — what
+// Preview, Acrobat and friends show as selectable, movable, deletable
+// markup — carrying the element's exact drawing as its appearance stream
+// plus the standard fields a viewer reads back (colour, width, points).
+//
+// The appearance stream is a Form XObject whose space IS doc space: its
+// /Matrix is the page's doc→user matrix and its /BBox the element's doc
+// bounds clipped to the page, so the operators the flatten path emits are
+// reused byte for byte. /Rect is set to exactly the transformed /BBox, which
+// makes the spec's rect-fitting step (§12.5.5) the identity.
+import { PDFHexString, PDFString, } from 'pdf-lib';
+import { dashIntervals } from '../../annotation/canvas/strokeGeometry.js';
+import { parseHexColor } from './color.js';
+import { applyMatrix, intersectRects, } from './pageMapping.js';
+/** /F flags: Print (bit 3). Not Hidden, not NoView, not Locked. */
+const ANNOT_FLAG_PRINT = 4;
+const rgbArray = (hex) => {
+    const { rgb } = parseHexColor(hex);
+    return [rgb.red, rgb.green, rgb.blue];
+};
+const round = (n) => Math.round(n * 1000) / 1000;
+const mapPoint = (m, p) => {
+    const q = applyMatrix(m, p.x, p.y);
+    return [round(q.x), round(q.y)];
+};
+const flatPoints = (m, pts) => pts.flatMap((p) => mapPoint(m, p));
+/** Axis-aligned user-space rect [llx lly urx ury] of a doc rect under `m`. */
+const userRect = (m, r) => {
+    const corners = [
+        applyMatrix(m, r.x, r.y),
+        applyMatrix(m, r.x + r.width, r.y),
+        applyMatrix(m, r.x, r.y + r.height),
+        applyMatrix(m, r.x + r.width, r.y + r.height),
+    ];
+    const xs = corners.map((c) => c.x);
+    const ys = corners.map((c) => c.y);
+    return [
+        round(Math.min(...xs)),
+        round(Math.min(...ys)),
+        round(Math.max(...xs)),
+        round(Math.max(...ys)),
+    ];
+};
+const lineEnding = (arrow) => (arrow ? 'ClosedArrow' : 'None');
+/** Subtype-specific dictionary entries, in page user space. */
+const metaEntries = (meta, m) => {
+    switch (meta.subtype) {
+        case 'Ink':
+            return {
+                C: rgbArray(meta.color),
+                BS: { W: meta.width, S: 'S' },
+                InkList: meta.paths.map((path) => flatPoints(m, path)),
+            };
+        case 'Line':
+            return {
+                C: rgbArray(meta.color),
+                IC: rgbArray(meta.color), // arrowhead fill
+                BS: borderStyle(meta.width, meta.dash),
+                L: [...mapPoint(m, meta.a), ...mapPoint(m, meta.b)],
+                LE: [lineEnding(meta.startArrow), lineEnding(meta.endArrow)],
+            };
+        case 'Square':
+        case 'Circle':
+            return {
+                C: rgbArray(meta.color),
+                ...(meta.fill ? { IC: rgbArray(meta.fill) } : {}),
+                BS: borderStyle(meta.width, meta.dash),
+            };
+        case 'Polygon':
+        case 'PolyLine':
+            return {
+                C: rgbArray(meta.color),
+                ...(meta.fill ? { IC: rgbArray(meta.fill) } : {}),
+                BS: borderStyle(meta.width, meta.dash),
+                Vertices: flatPoints(m, meta.vertices),
+                ...(meta.subtype === 'PolyLine'
+                    ? { LE: [lineEnding(meta.startArrow), lineEnding(meta.endArrow)] }
+                    : {}),
+            };
+        case 'FreeText': {
+            const [r, g, b] = rgbArray(meta.color);
+            return {
+                DA: PDFString.of(`/Helv ${round(meta.fontSize)} Tf ${r} ${g} ${b} rg`),
+                Contents: PDFHexString.fromText(meta.text),
+            };
+        }
+        case 'Stamp':
+            return meta.contents
+                ? { Contents: PDFHexString.fromText(meta.contents) }
+                : {};
+    }
+};
+const borderStyle = (width, dash) => dash ? { W: width, S: 'D', D: dashIntervals(width) } : { W: width, S: 'S' };
+const alphaOf = (meta) => ('alpha' in meta ? meta.alpha : 1);
+/**
+ * Wrap a mark as an annotation on `page`. Returns the annotation's ref, or
+ * null when the mark lies entirely outside the page.
+ */
+export const addMarkAnnotation = ({ doc, page, mark, pageRect, matrix, scope, groupWith, }) => {
+    const bbox = intersectRects(mark.bounds, pageRect);
+    if (!bbox || mark.ops.length === 0)
+        return null;
+    const { context } = doc;
+    const form = context.formXObject(mark.ops, {
+        BBox: [
+            round(bbox.x),
+            round(bbox.y),
+            round(bbox.x + bbox.width),
+            round(bbox.y + bbox.height),
+        ],
+        Matrix: matrix.map(round),
+        Resources: scope.resources(),
+    });
+    const formRef = context.register(form);
+    const alpha = alphaOf(mark.annot);
+    const dict = {
+        Type: 'Annot',
+        Subtype: mark.annot.subtype,
+        Rect: userRect(matrix, bbox),
+        F: ANNOT_FLAG_PRINT,
+        P: page.ref,
+        NM: PDFString.of(mark.id),
+        AP: { N: formRef },
+        ...(alpha < 1 ? { CA: round(alpha) } : {}),
+        ...metaEntries(mark.annot, matrix),
+        ...(groupWith ? { IRT: groupWith, RT: 'Group' } : {}),
+    };
+    // `LiteralObject` is not re-exported by pdf-lib, so the shape is asserted
+    // from `obj`'s own parameter type.
+    const ref = context.register(context.obj(dict));
+    page.node.addAnnot(ref);
+    return ref;
+};
+/** How many annotations a page carries (for tests and the result). */
+export const annotationCount = (page) => page.node.Annots()?.size() ?? 0;

package/dist/export/pdf/decrypt.d.ts

@@ -0,0 +1,21 @@
+export interface StripPdfEncryptionOptions {
+    /** User password, when the document needs one. Never stored. */
+    password?: string;
+    /** The PDFium wasm bytes; resolved from `@embedpdf/pdfium` when absent. */
+    wasmBinary?: ArrayBuffer;
+}
+export interface StripPdfEncryptionResult {
+    bytes: Uint8Array;
+    /** False when the input had no /Encrypt and was returned untouched. */
+    wasEncrypted: boolean;
+}
+/**
+ * Open `bytes` with PDFium and return a plaintext copy when the document is
+ * encrypted, or the input untouched when it is not.
+ *
+ * @throws PdfExportError `password-required` when the document needs a user
+ * password and none was given; `password-incorrect` when the given one was
+ * refused; `unsupported` for a security handler PDFium cannot open;
+ * `corrupt` when the bytes are not a PDF or the copy could not be written.
+ */
+export declare const stripPdfEncryption: (bytes: Uint8Array, options?: StripPdfEncryptionOptions) => Promise<StripPdfEncryptionResult>;

package/dist/export/pdf/decrypt.js

@@ -0,0 +1,121 @@
+// Strip a PDF's encryption so pdf-lib can append to it.
+//
+// Files saved by annotation tools (Nutrient included) and by many CAD /
+// Bluebeam exports carry an /Encrypt dictionary with an EMPTY user password:
+// every viewer opens them without a prompt, but every stream inside is still
+// RC4 / AES ciphertext keyed off that empty password. PDFium decrypts on the
+// fly, which is why the canvas renders such a file; pdf-lib cannot decrypt at
+// all and refuses to load it. Appending plaintext marks to a document whose
+// trailer says "encrypted" is not an option either — a viewer would run the
+// document key over our plaintext and paint garbage.
+//
+// So the fix is to open with PDFium (the same wasm build the web canvas
+// renders with), drop the encryption, and save a plaintext copy. A document
+// that genuinely needs a user password is reported as such so a host can
+// prompt for it and call again with `password`; nothing here persists it.
+//
+// NODE ONLY. Reached from the `./server` entry, never from the app barrel:
+// it resolves the wasm off disk and loads `@embedpdf/pdfium` lazily (an
+// optional peer), so a consumer that never calls it never pays for it.
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { PdfExportError } from './types.js';
+/** PDFium's FPDF_GetLastError codes. */
+const FPDF_ERR_PASSWORD = 4;
+const FPDF_ERR_SECURITY = 5;
+let modulePromise = null;
+// `HEAPU8` is an Emscripten runtime field the wrapper's typings omit. Read it
+// through a call every time: Emscripten REPLACES the view when memory grows.
+const heapU8 = (m) => m.pdfium.HEAPU8;
+const loadPdfium = (wasmBinary) => {
+    if (wasmBinary)
+        return initPdfium(wasmBinary);
+    if (modulePromise === null) {
+        modulePromise = (async () => {
+            const require_ = createRequire(import.meta.url);
+            const bytes = await readFile(require_.resolve('@embedpdf/pdfium/pdfium.wasm'));
+            return initPdfium(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+        })();
+    }
+    return modulePromise;
+};
+const initPdfium = async (wasmBinary) => {
+    const { init } = await import('@embedpdf/pdfium');
+    const m = await init({ wasmBinary });
+    m.PDFiumExt_Init();
+    return m;
+};
+/**
+ * Open `bytes` with PDFium and return a plaintext copy when the document is
+ * encrypted, or the input untouched when it is not.
+ *
+ * @throws PdfExportError `password-required` when the document needs a user
+ * password and none was given; `password-incorrect` when the given one was
+ * refused; `unsupported` for a security handler PDFium cannot open;
+ * `corrupt` when the bytes are not a PDF or the copy could not be written.
+ */
+export const stripPdfEncryption = async (bytes, options = {}) => {
+    const m = await loadPdfium(options.wasmBinary);
+    const { malloc, free } = m.pdfium.wasmExports;
+    const ptr = malloc(bytes.byteLength);
+    heapU8(m).set(bytes, ptr);
+    const doc = m.FPDF_LoadMemDocument(ptr, bytes.byteLength, options.password ?? '');
+    if (!doc) {
+        const err = m.FPDF_GetLastError();
+        free(ptr);
+        if (err === FPDF_ERR_PASSWORD) {
+            throw options.password !== undefined
+                ? new PdfExportError('password-incorrect', 'The PDF password is incorrect')
+                : new PdfExportError('password-required', 'This PDF is protected by a password');
+        }
+        if (err === FPDF_ERR_SECURITY) {
+            throw new PdfExportError('unsupported', 'This PDF uses a security handler that cannot be opened');
+        }
+        throw new PdfExportError('corrupt', `PDFium could not open the PDF (error ${err})`);
+    }
+    try {
+        if (!m.EPDF_IsEncrypted(doc))
+            return { bytes, wasEncrypted: false };
+        if (!m.EPDF_RemoveEncryption(doc)) {
+            throw new PdfExportError('corrupt', 'The PDF encryption could not be removed');
+        }
+        return { bytes: saveCopy(m, doc), wasEncrypted: true };
+    }
+    finally {
+        m.FPDF_CloseDocument(doc);
+        free(ptr);
+    }
+};
+/**
+ * FPDF_SaveAsCopy through an FPDF_FILEWRITE: `{ int version; int (*WriteBlock)
+ * (FPDF_FILEWRITE*, const void*, unsigned long); }` — two 32-bit words in
+ * wasm32, the callback registered into the function table for the duration.
+ */
+const saveCopy = (m, doc) => {
+    const { malloc, free } = m.pdfium.wasmExports;
+    const chunks = [];
+    const writeBlock = m.pdfium.addFunction((_self, data, size) => {
+        // Re-read the heap each call: it is replaced when memory grows.
+        chunks.push(heapU8(m).slice(data, data + size));
+        return 1;
+    }, 'iiii');
+    const fileWrite = malloc(8);
+    try {
+        m.pdfium.setValue(fileWrite, 1, 'i32');
+        m.pdfium.setValue(fileWrite + 4, writeBlock, 'i32');
+        if (!m.FPDF_SaveAsCopy(doc, fileWrite, 0)) {
+            throw new PdfExportError('corrupt', 'PDFium could not write the decrypted copy');
+        }
+    }
+    finally {
+        free(fileWrite);
+        m.pdfium.removeFunction(writeBlock);
+    }
+    const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+    let o = 0;
+    for (const c of chunks) {
+        out.set(c, o);
+        o += c.length;
+    }
+    return out;
+};

package/dist/export/pdf/fonts.d.ts

@@ -1,4 +1,5 @@
-import { PDFDocument, PDFFont, PDFName, PDFPage, type PDFOperator } from 'pdf-lib';
+import { PDFDocument, PDFFont, PDFName, type PDFOperator } from 'pdf-lib';
+import type { ResourceScope } from './resources.js';
 export type TextAlign = 'left' | 'center' | 'right';
 export interface TextOptions {
     align?: TextAlign;
@@ -8,7 +9,6 @@ export interface TextOptions {
 export declare class PdfFonts {
     private readonly primary;
     private readonly fallback;
-    private readonly keys;
     private constructor();
     static create(doc: PDFDocument, primaryBytes: Uint8Array): Promise<PdfFonts>;
     /** Whether the primary face has a glyph for every code point of `text`. */
@@ -26,13 +26,12 @@ export declare class PdfFonts {
         dropped: boolean;
     };
     width(text: string, size: number): number;
-    private keyFor;
     /**
      * Operators drawing one line of text in a y-DOWN space, with its baseline at
      * `yBaseline` and its left / centre / right edge at `x`. Returns [] when
      * nothing of the text is drawable.
      */
-    textOps(page: PDFPage, text: string, size: number, color: string, x: number, yBaseline: number, options?: TextOptions): PDFOperator[];
+    textOps(scope: ResourceScope, text: string, size: number, color: string, x: number, yBaseline: number, options?: TextOptions): PDFOperator[];
     /** Largest size ≤ `max` at which `text` fits in `maxWidth`. */
     fitSize(text: string, maxWidth: number, max: number, min?: number): number;
 }