@reekon-tools/boldr-utils 1.22.0 → 1.24.0

package/dist/export/pdf/renderCanvasToPdf.js

@@ -2,16 +2,27 @@
 // canvas's layers, marks and tiles to each page's content stream under one
 // matrix per page. The original page content and its own /Annots are never
 // touched, so the source stays vector, searchable and selectable.
-import { EncryptedPDFError, PDFDocument, } from 'pdf-lib';
+//
+// Two entry points share one page renderer:
+//  - renderCanvasToPdf: a Canvas file carrying a `viewport.pdfDocument`
+//    filmstrip — every element lives in one stacked doc space and is drawn on
+//    each page its bounds intersect.
+//  - renderPdfCanvasToPdf: a PdfCanvas file — one page state per page, each in
+//    that page's own doc space, with the user's per-page rotation folded into
+//    /Rotate and the page matrix.
+import { EncryptedPDFError, PDFDocument, degrees, } from 'pdf-lib';
 import { backgroundLayersOf } from '../../annotation/canvas/backgroundLayers.js';
+import { effectivePageRotation, pdfPageDisplaySize, } from '../../annotation/canvas/pdfCanvasPages.js';
 import { fitRectToScreen } from '../../annotation/canvas/viewport.js';
 import { STAMP_TILE_SIZE } from '../../annotation/canvas/stampLayout.js';
 import { clipRectOps, withMatrix } from './emit.js';
 import { PdfFonts } from './fonts.js';
 import { layerOps, layerVisibleRect } from './layers.js';
-import { measurementMarkBounds, measurementMarkOps, shapeBounds, shapeOps, strokeBounds, strokeOps, } from './marks.js';
+import { addMarkAnnotation } from './annots.js';
+import { measurementMark, measurementMarkBounds, measurementMarkOps, shapeBounds, shapeMark, shapeOps, strokeBounds, strokeMark, strokeOps, } from './marks.js';
+import { FormScope, PageScope } from './resources.js';
 import { docToPageMatrix, normalizeRotation, pageRectsOf, rectsIntersect, rotatedBoxSize, } from './pageMapping.js';
-import { designBoxFor, tileFootprint, tileOps, } from './tiles.js';
+import { designBoxFor, tileFootprint, tileOps } from './tiles.js';
 import { PdfExportError, } from './types.js';
 /** Stored page sizes may differ from the file's boxes by rounding only. */
 const PAGE_SIZE_TOLERANCE_PT = 1.5;
@@ -41,161 +52,333 @@ const loadSource = async (bytes) => {
         return await PDFDocument.load(bytes, { updateMetadata: false });
     }
     catch (e) {
-        if (e instanceof EncryptedPDFError) {
-            throw new PdfExportError('encrypted', 'The source PDF is encrypted and cannot be exported');
+        // Both checks: pdf-lib's dual CJS/ESM build can hand back an
+        // EncryptedPDFError whose class identity differs from the one imported.
+        if (e instanceof EncryptedPDFError ||
+            (e instanceof Error && /is encrypted/i.test(e.message))) {
+            throw new PdfExportError('encrypted', 'The source PDF is encrypted; strip it with stripPdfEncryption before rendering');
         }
         throw new PdfExportError('corrupt', `The source PDF could not be parsed: ${e instanceof Error ? e.message : String(e)}`);
     }
 };
-export const renderCanvasToPdf = async (input) => {
-    const { canvas } = input;
-    const pdfDoc = canvas.viewport.pdfDocument;
-    if (!pdfDoc) {
-        throw new PdfExportError('no-pdf-document', 'This canvas has no PDF document to export');
+const assertPageCount = (pages, recorded, stored) => {
+    if (pages.length !== recorded || stored !== pages.length) {
+        throw new PdfExportError('page-count-mismatch', `The canvas records ${stored} pages but the PDF has ${pages.length}`);
     }
-    const doc = await loadSource(input.sourcePdf);
-    const pages = doc.getPages();
-    if (pages.length !== pdfDoc.pageCount ||
-        pdfDoc.pages.length !== pages.length) {
-        throw new PdfExportError('page-count-mismatch', `The canvas records ${pdfDoc.pages.length} pages but the PDF has ${pages.length}`);
+};
+const assertPageSize = (index, actual, stored) => {
+    if (Math.abs(actual.width - stored.width) > PAGE_SIZE_TOLERANCE_PT ||
+        Math.abs(actual.height - stored.height) > PAGE_SIZE_TOLERANCE_PT) {
+        throw new PdfExportError('page-geometry-mismatch', `Page ${index + 1} is ${actual.width}×${actual.height} pt in the PDF but ${stored.width}×${stored.height} pt on the canvas`);
     }
-    const pageRects = pageRectsOf(pdfDoc);
-    const skipped = [];
-    // Per-page geometry, validated against what the canvas was laid out from.
-    const geometry = pages.map((page, i) => {
-        const box = pageBox(page);
-        const rotation = normalizeRotation(page.getRotation().angle);
-        const size = rotatedBoxSize(box, rotation);
-        const stored = pdfDoc.pages[i];
-        if (Math.abs(size.width - stored.width) > PAGE_SIZE_TOLERANCE_PT ||
-            Math.abs(size.height - stored.height) > PAGE_SIZE_TOLERANCE_PT) {
-            throw new PdfExportError('page-geometry-mismatch', `Page ${i + 1} is ${size.width}×${size.height} pt in the PDF but ${stored.width}×${stored.height} pt on the canvas`);
-        }
-        return { page, box, rotation, rect: pageRects[i] };
-    });
-    const fonts = await PdfFonts.create(doc, input.primaryFont);
+};
+/** Content string for a tile's annotation (what Acrobat's comment shows). */
+const tileContents = (content) => {
+    switch (content.kind) {
+        case 'measurement':
+            return [
+                content.label,
+                `${content.negative ? '-' : ''}${content.value} ${content.unit}`.trim(),
+            ]
+                .filter(Boolean)
+                .join(': ');
+        case 'planeDimension':
+            return `${content.value} ${content.unit}`.trim();
+        case 'header':
+            return (content.descriptor.name ??
+                content.descriptor.badges.map((b) => b.text).join(' '));
+        case 'object':
+            return content.name;
+        case 'literal':
+            return content.value || undefined;
+        case 'instructions':
+            return content.text || undefined;
+        default:
+            return undefined;
+    }
+};
+const renderJobs = async (doc, jobs, options, skipped) => {
+    const fonts = await PdfFonts.create(doc, options.primaryFont);
     // Background layers: embed once, draw on every page they overlap.
-    const layers = backgroundLayersOf(canvas.viewport);
     const layerImages = new Map();
-    for (const layer of layers) {
-        if (layer.format === 'svg') {
-            skipped.push({
-                id: layer.id,
-                kind: 'layer',
-                reason: 'SVG background layers are not exported yet',
-            });
-            continue;
-        }
-        const bytes = input.layerImages[layer.id];
-        if (!bytes) {
-            skipped.push({
-                id: layer.id,
-                kind: 'layer',
-                reason: 'Layer image bytes were not provided',
-            });
-            continue;
-        }
-        try {
-            layerImages.set(layer.id, await embedImage(doc, bytes));
-        }
-        catch (e) {
-            skipped.push({
-                id: layer.id,
-                kind: 'layer',
-                reason: `Layer image could not be embedded: ${e instanceof Error ? e.message : String(e)}`,
-            });
-        }
-    }
-    // Tiles: resolve content once; embed object thumbnails once.
-    const tiles = canvas.placedMeasurements.map((placed) => {
-        const content = input.resolveTile(placed) ?? {
-            kind: 'empty',
-        };
-        return { placed, content };
-    });
-    const thumbnails = new Map();
-    for (const { placed, content } of tiles) {
-        if (content.kind === 'object' && content.thumbnail) {
+    const seenLayers = new Set();
+    for (const job of jobs) {
+        for (const layer of job.layers) {
+            if (seenLayers.has(layer.id))
+                continue;
+            seenLayers.add(layer.id);
+            if (layer.format === 'svg') {
+                skipped.push({
+                    id: layer.id,
+                    kind: 'layer',
+                    reason: 'SVG background layers are not exported yet',
+                });
+                continue;
+            }
+            const bytes = options.layerImages[layer.id];
+            if (!bytes) {
+                skipped.push({
+                    id: layer.id,
+                    kind: 'layer',
+                    reason: 'Layer image bytes were not provided',
+                });
+                continue;
+            }
             try {
-                thumbnails.set(placed.id, await embedImage(doc, content.thumbnail));
+                layerImages.set(layer.id, await embedImage(doc, bytes));
             }
             catch (e) {
                 skipped.push({
-                    id: placed.id,
-                    kind: 'tile',
-                    reason: `Object thumbnail could not be embedded: ${e instanceof Error ? e.message : String(e)}`,
+                    id: layer.id,
+                    kind: 'layer',
+                    reason: `Layer image could not be embedded: ${e instanceof Error ? e.message : String(e)}`,
                 });
             }
         }
     }
-    const firstRect = pageRects[0];
+    // Tiles: resolve content once per placed ref; embed object thumbnails once.
+    const tileContent = new Map();
+    const thumbnails = new Map();
+    for (const job of jobs) {
+        for (const placed of job.placed) {
+            if (tileContent.has(placed.id))
+                continue;
+            const content = options.resolveTile(placed) ?? {
+                kind: 'empty',
+            };
+            tileContent.set(placed.id, content);
+            if (content.kind === 'object' && content.thumbnail) {
+                try {
+                    thumbnails.set(placed.id, await embedImage(doc, content.thumbnail));
+                }
+                catch (e) {
+                    skipped.push({
+                        id: placed.id,
+                        kind: 'tile',
+                        reason: `Object thumbnail could not be embedded: ${e instanceof Error ? e.message : String(e)}`,
+                    });
+                }
+            }
+        }
+    }
+    // Calibration fallback from the first page's rect (the tile-scale reference
+    // on screen is the first page too).
+    const firstRect = jobs[0]?.rect ?? { x: 0, y: 0, width: 612, height: 792 };
     const fallbackDocEdge = STAMP_TILE_SIZE /
         Math.max(fitRectToScreen(firstRect, FALLBACK_VIEW.width, FALLBACK_VIEW.height)
             .zoom, 1e-6);
-    const hiddenLayerIds = new Set(canvas.layers.filter((l) => l.visible === false).map((l) => l.id));
-    const visible = (layerId) => !hiddenLayerIds.has(layerId);
-    for (const { page, box, rotation, rect } of geometry) {
-        // Per-page resource registries.
-        const alphaStates = new Map();
-        const alphaState = (alpha) => {
-            const a = Math.round(Math.min(1, Math.max(0, alpha)) * 1000) / 1000;
-            if (a >= 1)
-                return undefined;
-            let name = alphaStates.get(a);
-            if (!name) {
-                name = page.node.newExtGState('GSa', doc.context.obj({ Type: 'ExtGState', CA: a, ca: a }));
-                alphaStates.set(a, name);
+    let annotationCount = 0;
+    for (const job of jobs) {
+        const { page, box, rotation, rect } = job;
+        const matrix = docToPageMatrix(rect, box, rotation);
+        const onPage = (b) => b !== null && rectsIntersect(b, rect);
+        const hiddenLayerIds = new Set(job.layerDefs.filter((l) => l.visible === false).map((l) => l.id));
+        const visible = (layerId) => !hiddenLayerIds.has(layerId);
+        const footprintFor = (placed, content) => tileFootprint(placed, { tileDocSize: job.tileDocSize }, options.calibration, fallbackDocEdge, designBoxFor(placed, content));
+        const contentOf = (placed) => tileContent.get(placed.id) ?? { kind: 'empty' };
+        if (options.mode === 'flatten') {
+            // Everything into the page's content stream, under one matrix + clip.
+            const scope = new PageScope(page, doc.context);
+            const ctx = { scope, fonts, skipped };
+            const ops = [];
+            for (const layer of job.layers) {
+                const img = layerImages.get(layer.id);
+                if (!img || !onPage(layerVisibleRect(layer)))
+                    continue;
+                ops.push(...layerOps(layer, scope.imageKey(img)));
+            }
+            for (const s of job.strokes) {
+                if (!visible(s.layerId) || !onPage(strokeBounds(s)))
+                    continue;
+                ops.push(...strokeOps(s, ctx));
             }
-            return name;
+            for (const sh of job.shapes) {
+                if (!visible(sh.layerId) || !onPage(shapeBounds(sh)))
+                    continue;
+                ops.push(...shapeOps(sh, ctx));
+            }
+            for (const placed of job.placed) {
+                if (!visible(placed.layerId) || !onPage(measurementMarkBounds(placed)))
+                    continue;
+                ops.push(...measurementMarkOps(placed, ctx));
+            }
+            for (const placed of job.placed) {
+                if (!visible(placed.layerId))
+                    continue;
+                const content = contentOf(placed);
+                const footprint = footprintFor(placed, content);
+                if (!onPage(footprint))
+                    continue;
+                ops.push(...tileOps({ scope, fonts, thumbnail: thumbnails.get(placed.id) }, content, footprint));
+            }
+            if (ops.length === 0)
+                continue;
+            page.pushOperators(...withMatrix(matrix, [
+                ...clipRectOps(rect.x, rect.y, rect.width, rect.height),
+                ...ops,
+            ]));
+            continue;
+        }
+        // Annotation mode: one annotation per element, each with its own
+        // appearance stream and resources. Same z-order as the screen.
+        const add = (mark, scope, groupWith) => {
+            if (!mark)
+                return null;
+            const ref = addMarkAnnotation({
+                doc,
+                page,
+                mark,
+                pageRect: rect,
+                matrix,
+                scope,
+                groupWith,
+            });
+            if (ref)
+                annotationCount++;
+            return ref;
         };
-        const registerImage = (img) => ({
-            name: page.node.newXObject('Im', img.ref),
-            width: img.width,
-            height: img.height,
-        });
-        const ctx = { page, fonts, alphaState, skipped };
-        const onPage = (b) => b !== null && rectsIntersect(b, rect);
-        const ops = [];
-        // 1. Background image layers, array order.
-        for (const layer of layers) {
+        for (const layer of job.layers) {
             const img = layerImages.get(layer.id);
-            if (!img || !onPage(layerVisibleRect(layer)))
+            const bounds = layerVisibleRect(layer);
+            if (!img || !onPage(bounds))
                 continue;
-            ops.push(...layerOps(layer, registerImage(img).name));
+            const scope = new FormScope(doc.context);
+            add({
+                id: layer.id,
+                ops: layerOps(layer, scope.imageKey(img)),
+                bounds,
+                annot: {
+                    subtype: 'Stamp',
+                    contents: layer.fileId ? 'Placed file' : 'Background image',
+                },
+            }, scope);
         }
-        // 2. Strokes, then shapes, then measurement lines / rects — the Skia order.
-        for (const s of canvas.strokes) {
+        for (const s of job.strokes) {
             if (!visible(s.layerId) || !onPage(strokeBounds(s)))
                 continue;
-            ops.push(...strokeOps(s, ctx));
+            const scope = new FormScope(doc.context);
+            add(strokeMark(s, { scope, fonts, skipped }), scope);
         }
-        for (const sh of canvas.shapes) {
+        for (const sh of job.shapes) {
             if (!visible(sh.layerId) || !onPage(shapeBounds(sh)))
                 continue;
-            ops.push(...shapeOps(sh, ctx));
+            const scope = new FormScope(doc.context);
+            add(shapeMark(sh, { scope, fonts, skipped }), scope);
         }
-        for (const { placed } of tiles) {
+        // A measurement's line/rect and its tile are grouped (Acrobat honours
+        // /IRT + /RT /Group; other viewers treat them independently).
+        const markRefs = new Map();
+        for (const placed of job.placed) {
             if (!visible(placed.layerId) || !onPage(measurementMarkBounds(placed)))
                 continue;
-            ops.push(...measurementMarkOps(placed, ctx));
+            const scope = new FormScope(doc.context);
+            const ref = add(measurementMark(placed, { scope, fonts, skipped }), scope);
+            if (ref)
+                markRefs.set(placed.id, ref);
         }
-        // 3. Tiles on top, like the overlay.
-        for (const { placed, content } of tiles) {
+        for (const placed of job.placed) {
             if (!visible(placed.layerId))
                 continue;
-            const footprint = tileFootprint(placed, canvas, input.calibration, fallbackDocEdge, designBoxFor(placed, content));
+            const content = contentOf(placed);
+            const footprint = footprintFor(placed, content);
             if (!onPage(footprint))
                 continue;
-            const thumb = thumbnails.get(placed.id);
-            ops.push(...tileOps({ page, fonts, thumbnail: thumb ? registerImage(thumb) : undefined }, content, footprint));
+            const scope = new FormScope(doc.context);
+            add({
+                id: placed.id,
+                ops: tileOps({ scope, fonts, thumbnail: thumbnails.get(placed.id) }, content, footprint),
+                bounds: footprint,
+                annot: { subtype: 'Stamp', contents: tileContents(content) },
+            }, scope, markRefs.get(placed.id));
         }
-        if (ops.length === 0)
-            continue;
-        page.pushOperators(...withMatrix(docToPageMatrix(rect, box, rotation), [
-            ...clipRectOps(rect.x, rect.y, rect.width, rect.height),
-            ...ops,
-        ]));
     }
+    return annotationCount;
+};
+export const renderCanvasToPdf = async (input) => {
+    const { canvas } = input;
+    const pdfDoc = canvas.viewport.pdfDocument;
+    if (!pdfDoc) {
+        throw new PdfExportError('no-pdf-document', 'This canvas has no PDF document to export');
+    }
+    const doc = await loadSource(input.sourcePdf);
+    const pages = doc.getPages();
+    assertPageCount(pages, pdfDoc.pageCount, pdfDoc.pages.length);
+    const pageRects = pageRectsOf(pdfDoc);
+    const layers = backgroundLayersOf(canvas.viewport);
+    // Per-page geometry, validated against what the canvas was laid out from.
+    const jobs = pages.map((page, i) => {
+        const box = pageBox(page);
+        const rotation = normalizeRotation(page.getRotation().angle);
+        assertPageSize(i, rotatedBoxSize(box, rotation), pdfDoc.pages[i]);
+        return {
+            page,
+            box,
+            rotation,
+            rect: pageRects[i],
+            layers,
+            layerDefs: canvas.layers,
+            strokes: canvas.strokes,
+            shapes: canvas.shapes,
+            placed: canvas.placedMeasurements,
+            tileDocSize: canvas.tileDocSize,
+        };
+    });
+    const skipped = [];
+    const annotationCount = await renderJobs(doc, jobs, {
+        resolveTile: input.resolveTile,
+        layerImages: input.layerImages,
+        calibration: input.calibration,
+        primaryFont: input.primaryFont,
+        mode: input.mode ?? 'annotations',
+    }, skipped);
+    const pdf = await doc.save({ useObjectStreams: false });
+    return { pdf, pageCount: pages.length, annotationCount, skipped };
+};
+/**
+ * Export a PdfCanvas file. Each page's state is drawn in that page's own doc
+ * space (the DISPLAYED page: rotated extents, origin top-left). A user
+ * rotation is written into the page's /Rotate — so the recipient sees the
+ * page as the user did — and the page matrix undoes the combined rotation.
+ * Pages without a state are still rotated.
+ */
+export const renderPdfCanvasToPdf = async (input) => {
+    const { pdfCanvas } = input;
+    const doc = await loadSource(input.sourcePdf);
+    const pages = doc.getPages();
+    assertPageCount(pages, pdfCanvas.document.pageCount, pdfCanvas.document.pages.length);
+    const jobs = [];
+    pages.forEach((page, i) => {
+        const stored = pdfCanvas.document.pages[i];
+        const box = pageBox(page);
+        const intrinsic = normalizeRotation(page.getRotation().angle);
+        // The stored size is the page after its own /Rotate, before the user's.
+        assertPageSize(i, rotatedBoxSize(box, intrinsic), stored);
+        const effective = effectivePageRotation(intrinsic, stored.rotation);
+        if (effective !== intrinsic)
+            page.setRotation(degrees(effective));
+        const display = pdfPageDisplaySize(stored);
+        const state = input.pageStates[i] ?? undefined;
+        jobs.push({
+            page,
+            box,
+            rotation: effective,
+            rect: { x: 0, y: 0, width: display.width, height: display.height },
+            layers: [],
+            layerDefs: state?.layers ?? [],
+            strokes: state?.strokes ?? [],
+            shapes: state?.shapes ?? [],
+            placed: state?.placedMeasurements ?? [],
+            tileDocSize: pdfCanvas.tileDocSize,
+        });
+    });
+    const skipped = [];
+    const annotationCount = await renderJobs(doc, jobs, {
+        resolveTile: input.resolveTile,
+        layerImages: {},
+        calibration: input.calibration,
+        primaryFont: input.primaryFont,
+        mode: input.mode ?? 'annotations',
+    }, skipped);
     const pdf = await doc.save({ useObjectStreams: false });
-    return { pdf, pageCount: pages.length, skipped };
+    return { pdf, pageCount: pages.length, annotationCount, skipped };
 };

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

@@ -0,0 +1,35 @@
+import { PDFContext, PDFDict, PDFFont, PDFImage, PDFName, PDFPage } from 'pdf-lib';
+export interface ResourceScope {
+    fontKey(font: PDFFont): PDFName;
+    imageKey(image: PDFImage): PDFName;
+    /** An ExtGState carrying `alpha` (CA/ca), or undefined at full opacity. */
+    alphaState(alpha: number): PDFName | undefined;
+}
+/** Resources on the page itself — content-stream (flatten) output. */
+export declare class PageScope implements ResourceScope {
+    private readonly page;
+    private readonly context;
+    private readonly fonts;
+    private readonly images;
+    private readonly alphas;
+    constructor(page: PDFPage, context: PDFContext);
+    fontKey(font: PDFFont): PDFName;
+    imageKey(image: PDFImage): PDFName;
+    alphaState(alpha: number): PDFName | undefined;
+}
+/** Resources collected for ONE appearance stream (annotation mode). */
+export declare class FormScope implements ResourceScope {
+    private readonly context;
+    private readonly fontDict;
+    private readonly xobjectDict;
+    private readonly gsDict;
+    private readonly fonts;
+    private readonly images;
+    private readonly alphas;
+    constructor(context: PDFContext);
+    fontKey(font: PDFFont): PDFName;
+    imageKey(image: PDFImage): PDFName;
+    alphaState(alpha: number): PDFName | undefined;
+    /** The /Resources dictionary for the appearance stream. */
+    resources(): PDFDict;
+}

package/dist/export/pdf/resources.js

@@ -0,0 +1,95 @@
+// Where an element's PDF resources (fonts, images, opacity states) get
+// registered. The emitters only ask a scope for a resource NAME; whether that
+// name lands in the page's resource dictionary (flatten mode) or in one
+// annotation appearance stream's own /Resources (annotation mode) is the
+// scope's business.
+import { PDFName, } from 'pdf-lib';
+const roundAlpha = (alpha) => Math.round(Math.min(1, Math.max(0, alpha)) * 1000) / 1000;
+const extGState = (context, alpha) => context.obj({ Type: 'ExtGState', CA: alpha, ca: alpha });
+/** Resources on the page itself — content-stream (flatten) output. */
+export class PageScope {
+    constructor(page, context) {
+        this.page = page;
+        this.context = context;
+        this.fonts = new Map();
+        this.images = new Map();
+        this.alphas = new Map();
+    }
+    fontKey(font) {
+        let key = this.fonts.get(font);
+        if (!key) {
+            key = this.page.node.newFontDictionary(font.name, font.ref);
+            this.fonts.set(font, key);
+        }
+        return key;
+    }
+    imageKey(image) {
+        let key = this.images.get(image);
+        if (!key) {
+            key = this.page.node.newXObject('Im', image.ref);
+            this.images.set(image, key);
+        }
+        return key;
+    }
+    alphaState(alpha) {
+        const a = roundAlpha(alpha);
+        if (a >= 1)
+            return undefined;
+        let key = this.alphas.get(a);
+        if (!key) {
+            key = this.page.node.newExtGState('GSa', extGState(this.context, a));
+            this.alphas.set(a, key);
+        }
+        return key;
+    }
+}
+/** Resources collected for ONE appearance stream (annotation mode). */
+export class FormScope {
+    constructor(context) {
+        this.context = context;
+        this.fonts = new Map();
+        this.images = new Map();
+        this.alphas = new Map();
+        this.fontDict = context.obj({});
+        this.xobjectDict = context.obj({});
+        this.gsDict = context.obj({});
+    }
+    fontKey(font) {
+        let key = this.fonts.get(font);
+        if (!key) {
+            key = PDFName.of(`F${this.fonts.size + 1}`);
+            this.fontDict.set(key, font.ref);
+            this.fonts.set(font, key);
+        }
+        return key;
+    }
+    imageKey(image) {
+        let key = this.images.get(image);
+        if (!key) {
+            key = PDFName.of(`Im${this.images.size + 1}`);
+            this.xobjectDict.set(key, image.ref);
+            this.images.set(image, key);
+        }
+        return key;
+    }
+    alphaState(alpha) {
+        const a = roundAlpha(alpha);
+        if (a >= 1)
+            return undefined;
+        let key = this.alphas.get(a);
+        if (!key) {
+            key = PDFName.of(`GS${this.alphas.size + 1}`);
+            this.gsDict.set(key, extGState(this.context, a));
+            this.alphas.set(a, key);
+        }
+        return key;
+    }
+    /** The /Resources dictionary for the appearance stream. */
+    resources() {
+        return this.context.obj({
+            Font: this.fontDict,
+            XObject: this.xobjectDict,
+            ExtGState: this.gsDict,
+        });
+    }
+}

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

@@ -1,19 +1,15 @@
-import { type PDFName, type PDFOperator, type PDFPage } from 'pdf-lib';
+import { type PDFImage, type PDFOperator } from 'pdf-lib';
 import type { AnnotationCanvasState, PlacedMeasurementRef } from '../../types/annotation.js';
 import type { PdfFonts } from './fonts.js';
+import type { ResourceScope } from './resources.js';
 import type { AffineMatrix, DocRect } from './pageMapping.js';
 import type { PdfExportCalibration, ResolvedTileContent } from './types.js';
-/** An image XObject already registered on the page, with its pixel size. */
-export interface PageImage {
-    name: PDFName;
-    width: number;
-    height: number;
-}
 export interface TilePaintContext {
-    page: PDFPage;
+    /** Where fonts, images and opacity states get registered. */
+    scope: ResourceScope;
     fonts: PdfFonts;
     /** Object-tile thumbnail, when the content carries one and it embedded. */
-    thumbnail?: PageImage;
+    thumbnail?: PDFImage;
 }
 export interface TileFootprint extends DocRect {
     /** Design-space box the painter lays out in. */