@jasy/pdf 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/renderer/pdf-document-renderer.d.ts

@@ -1,19 +1,28 @@
-import { PDFDocumentElement } from "../elements/pdf-document-element";
-import { LayoutContext } from "../elements/pdf-element";
-import { PDFObjectManager } from "../utils/pdf-object-manager";
+import { PDFDocumentElement } from "../elements/pdf-document-element.js";
+import { LayoutContext } from "../elements/pdf-element.js";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 export declare class PDFDocumentRenderer {
     static render(document: PDFDocumentElement, objectManager: PDFObjectManager, ctx: LayoutContext): Promise<number>;
     /**
-     * Renders one logical page, paginating it into one or more physical pages.
+     * The page geometry a physical page will use. `PageElement.calculateLayout` has already folded the
+     * document defaults into every page's config by the time we get here (`PDFRenderer` lays the document
+     * out before it calls us, and it is our only caller). Merging again is therefore a no-op today - it is
+     * here so this stays correct BY CONSTRUCTION rather than by call order: were that order ever changed,
+     * an unmerged config would otherwise make `resolvePageSize` fall back to A4 and quietly report the
+     * wrong page size.
+     */
+    private static configOf;
+    /**
+     * Splits one logical page into the physical pages it will occupy, without rendering.
      *
-     * Slice 0 only auto-paginates the common shape - a page whose single child is a
-     * fragmentation context (a Container). Anything else renders as a single page on the
-     * unchanged path, so non-overflowing documents stay byte-identical to pre-Slice-0.
+     * Only the common shape auto-paginates - a page whose single child is a fragmentation context
+     * (a Container). Anything else stays a single page on the unchanged path, so non-overflowing
+     * documents keep producing byte-identical output.
      */
-    private static renderLogicalPage;
+    private static paginateLogicalPage;
     /**
-     * Lays out one fragment on a fresh page of the same geometry and renders it. The
-     * header/footer are attached to every physical page so they repeat; `PageElement`
+     * Lays out one physical page and renders it. A fragment gets a fresh `PageElement` of the same
+     * geometry; the header/footer are attached to every physical page so they repeat, and `PageElement`
      * re-places them and the body in the band between.
      */
     private static renderPhysicalPage;

package/dist/renderer/pdf-document-renderer.js

@@ -1,104 +1,148 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PDFDocumentRenderer = void 0;
-const page_element_1 = require("../elements/page-element");
-const box_constraints_1 = require("../layout/box-constraints");
-const fragmentation_1 = require("../layout/fragmentation");
-const page_renderer_1 = require("./page-renderer");
-class PDFDocumentRenderer {
-    static render(document, objectManager, ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pageNumbers = [];
-            // Add the pages object first... we need its object number (resources). The count is
-            // a placeholder; it is replaced below with the real (post-pagination) page count.
-            const pagesObject = `<< /Type /Pages /Kids [] /Count ${document.getProps().children.length} >>`;
-            const pagesObjectNumber = objectManager.addObject(pagesObject);
-            // Now set the given object number all its childs
-            objectManager.setParentObjectNumber(pagesObjectNumber);
-            // The page driver: each logical PageElement may produce SEVERAL physical PDF pages
-            // when its content overflows (Slice 0: whole children reflow to the next page).
-            for (let page of document.getProps().children) {
-                const numbers = yield PDFDocumentRenderer.renderLogicalPage(page, objectManager, ctx);
-                pageNumbers.push(...numbers);
-            }
-            // We must update the pages object with the real physical page numbers and count.
-            const updatedPagesObject = `<< /Type /Pages /Kids [${pageNumbers
-                .map((num) => `${num} 0 R`)
-                .join(" ")}] /Count ${pageNumbers.length} >>`;
-            // Now we must replace it in the object manager
-            objectManager.replaceObject(pagesObjectNumber, updatedPagesObject);
-            return pagesObjectNumber;
-        });
+import { layoutPageBands, pageFrame, PageElement, resolvePageSize, } from "../elements/page-element.js";
+import { BoxConstraints } from "../layout/box-constraints.js";
+import { isFragmentable, reportOverflow } from "../layout/fragmentation.js";
+import { PageRenderer } from "./page-renderer.js";
+export class PDFDocumentRenderer {
+    static async render(document, objectManager, ctx) {
+        // Add the pages object first... we need its object number (resources). The count is
+        // a placeholder; it is replaced below with the real (post-pagination) page count.
+        const pagesObject = `<< /Type /Pages /Kids [] /Count ${document.getProps().children.length} >>`;
+        const pagesObjectNumber = objectManager.addObject(pagesObject);
+        // Now set the given object number all its childs
+        objectManager.setParentObjectNumber(pagesObjectNumber);
+        // Pass A - paginate the whole document WITHOUT drawing anything. Fragmentation is synchronous and
+        // pure (`{ fitted, remainder }`), so the full list of physical pages can be settled up front. Only
+        // then is the total page count known, which is what page numbers in a header/footer need.
+        const physicalPages = [];
+        // Where each sheet sits WITHIN the logical page it came from. Pass A already knows: one logical
+        // `Page` element produces one run of sheets, so the run's length is that section's total.
+        const section = [];
+        for (const page of document.getProps().children) {
+            const sheets = PDFDocumentRenderer.paginateLogicalPage(page, ctx);
+            sheets.forEach((_, i) => section.push({ number: i + 1, total: sheets.length }));
+            physicalPages.push(...sheets);
+        }
+        // Pass B - draw them, in order, so the emitted page objects keep their previous numbering. Each page
+        // is laid out again with its own PageInfo, which is how a `PageBuilder` anywhere in the tree (header,
+        // footer or body) learns its final page number and the now-known document total.
+        const pageNumbers = [];
+        for (const [index, physical] of physicalPages.entries()) {
+            const pageInfo = {
+                pageNumber: index + 1,
+                pageCount: physicalPages.length,
+                subPageNumber: section[index].number,
+                subPageTotalPages: section[index].total,
+                pageSize: resolvePageSize(PDFDocumentRenderer.configOf(physical, ctx)),
+            };
+            pageNumbers.push(await PDFDocumentRenderer.renderPhysicalPage(physical, objectManager, {
+                ...ctx,
+                pageInfo,
+            }));
+        }
+        // We must update the pages object with the real physical page numbers and count.
+        const updatedPagesObject = `<< /Type /Pages /Kids [${pageNumbers
+            .map((num) => `${num} 0 R`)
+            .join(" ")}] /Count ${pageNumbers.length} >>`;
+        // Now we must replace it in the object manager
+        objectManager.replaceObject(pagesObjectNumber, updatedPagesObject);
+        return pagesObjectNumber;
     }
     /**
-     * Renders one logical page, paginating it into one or more physical pages.
+     * The page geometry a physical page will use. `PageElement.calculateLayout` has already folded the
+     * document defaults into every page's config by the time we get here (`PDFRenderer` lays the document
+     * out before it calls us, and it is our only caller). Merging again is therefore a no-op today - it is
+     * here so this stays correct BY CONSTRUCTION rather than by call order: were that order ever changed,
+     * an unmerged config would otherwise make `resolvePageSize` fall back to A4 and quietly report the
+     * wrong page size.
+     */
+    static configOf(physical, ctx) {
+        const config = physical.kind === "whole" ? physical.page.getProps().config : physical.config;
+        return { ...ctx.pageConfig, ...config };
+    }
+    /**
+     * Splits one logical page into the physical pages it will occupy, without rendering.
      *
-     * Slice 0 only auto-paginates the common shape - a page whose single child is a
-     * fragmentation context (a Container). Anything else renders as a single page on the
-     * unchanged path, so non-overflowing documents stay byte-identical to pre-Slice-0.
+     * Only the common shape auto-paginates - a page whose single child is a fragmentation context
+     * (a Container). Anything else stays a single page on the unchanged path, so non-overflowing
+     * documents keep producing byte-identical output.
      */
-    static renderLogicalPage(page, objectManager, ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { children, config, header, footer } = page.getProps();
-            if (children.length !== 1 || !(0, fragmentation_1.isFragmentable)(children[0])) {
-                return [yield page_renderer_1.PageRenderer.render(page, objectManager)];
+    static paginateLogicalPage(page, ctx) {
+        const { children, config, header, footer } = page.getProps();
+        if (children.length !== 1 || !isFragmentable(children[0])) {
+            return [{ kind: "whole", page }];
+        }
+        // Header/footer repeat on every physical page, so the body only ever flows into the
+        // band between them. Resolve that band once (config is already merged by pass 1).
+        // The frame is a throwaway: this pass only wants the band HEIGHTS, and an out-of-flow child
+        // contributes none. It exists because a `Positioned` in a band demands one; pass 2 builds the
+        // real frame (in `PageElement`) and drains it.
+        const pageCtx = {
+            metrics: ctx.metrics,
+            pageConfig: config,
+            textStyle: ctx.textStyle,
+            onOverflow: ctx.onOverflow,
+            frame: pageFrame(config),
+        };
+        const { bodyWidth: width, bodyHeight: height } = layoutPageBands(config, header, footer, pageCtx);
+        // A `keepTogether` group compares its height against a FULL fresh page (this band), so thread it in.
+        pageCtx.pageBodyHeight = height;
+        const pages = [];
+        let region = children[0];
+        let isFirstRegion = true;
+        while (region) {
+            if (!isFragmentable(region)) {
+                // A non-fragmentable remainder is placed whole on its own page.
+                pages.push({ kind: "fragment", config, content: region, header, footer });
+                break;
             }
-            // Header/footer repeat on every physical page, so the body only ever flows into the
-            // band between them. Resolve that band once (config is already merged by pass 1).
-            const pageCtx = { metrics: ctx.metrics, pageConfig: config };
-            const { bodyWidth: width, bodyHeight: height } = (0, page_element_1.layoutPageBands)(config, header, footer, pageCtx);
-            const numbers = [];
-            let region = children[0];
-            let isFirstRegion = true;
-            while (region) {
-                if (!(0, fragmentation_1.isFragmentable)(region)) {
-                    // A non-fragmentable remainder is placed whole on its own page.
-                    numbers.push(yield PDFDocumentRenderer.renderPhysicalPage(config, region, header, footer, objectManager, ctx));
-                    break;
-                }
-                const { fitted, remainder } = region.fragment(height, width, ctx);
-                // Everything fits on one page: render the ORIGINAL page so output is unchanged.
-                // Measuring inside fragment() laid the children out at the origin to size them, so
-                // re-run the page layout first to restore their real positions (deterministic).
-                if (isFirstRegion && remainder === null) {
-                    page.calculateLayout(new box_constraints_1.BoxConstraints(), { x: 0, y: 0 }, ctx);
-                    numbers.push(yield page_renderer_1.PageRenderer.render(page, objectManager));
-                    break;
-                }
-                if (fitted) {
-                    numbers.push(yield PDFDocumentRenderer.renderPhysicalPage(config, fitted, header, footer, objectManager, ctx));
-                }
-                region = remainder;
-                isFirstRegion = false;
+            // pageCtx, not the document ctx: a descendant that reads `pageConfig` while being measured (a
+            // `PageBuilder` sizing its provisional build) must see THIS page's geometry, not the document default.
+            const { fitted, remainder, forceBreak } = region.fragment(height, width, pageCtx);
+            // Everything fits on one page: keep the ORIGINAL page so output is unchanged. Measuring inside
+            // fragment() left its children at the measuring origin; pass B lays the page out again, which
+            // restores their real positions (layout is deterministic). A consumed trailing `PageBreak`
+            // (forceBreak with no remainder) is the exception: render the packed `fitted` instead, which no
+            // longer holds the break marker, so the original with the break does not leak into the render pass.
+            if (isFirstRegion && remainder === null && !forceBreak) {
+                pages.push({ kind: "whole", page });
+                break;
             }
-            return numbers;
-        });
+            // TERMINATION GUARANTEE. Every page here has the full body height, so `fitted === null` means
+            // nothing fit even on a whole page - the region did not get smaller. Advancing to the
+            // (identical) remainder would loop forever. So we stop: place the region whole (clipped to the
+            // page) and surface it per the overflow policy. A step that shrinks nothing ends the loop, for
+            // ANY region - an oversized unbreakable block, a future keep-together group, or an engine bug.
+            if (fitted === null) {
+                // Measure the region's true height for the message (rare path, so the extra pass is free);
+                // pass B lays it out again, so this mutation does not leak.
+                const needed = region.calculateLayout(BoxConstraints.loose(width, Infinity), { x: 0, y: 0 }, pageCtx).height;
+                reportOverflow(region, needed, height, pageCtx.onOverflow ?? "ignore");
+                pages.push({ kind: "fragment", config, content: region, header, footer });
+                break;
+            }
+            pages.push({ kind: "fragment", config, content: fitted, header, footer });
+            region = remainder;
+            isFirstRegion = false;
+        }
+        return pages;
     }
     /**
-     * Lays out one fragment on a fresh page of the same geometry and renders it. The
-     * header/footer are attached to every physical page so they repeat; `PageElement`
+     * Lays out one physical page and renders it. A fragment gets a fresh `PageElement` of the same
+     * geometry; the header/footer are attached to every physical page so they repeat, and `PageElement`
      * re-places them and the body in the band between.
      */
-    static renderPhysicalPage(config, content, header, footer, objectManager, ctx) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const physicalPage = new page_element_1.PageElement({
-                config,
-                header,
-                footer,
-                children: [content],
-            });
-            physicalPage.calculateLayout(new box_constraints_1.BoxConstraints(), { x: 0, y: 0 }, ctx);
-            return page_renderer_1.PageRenderer.render(physicalPage, objectManager);
+    static async renderPhysicalPage(physical, objectManager, ctx) {
+        if (physical.kind === "whole") {
+            physical.page.calculateLayout(new BoxConstraints(), { x: 0, y: 0 }, ctx);
+            return PageRenderer.render(physical.page, objectManager);
+        }
+        const page = new PageElement({
+            config: physical.config,
+            header: physical.header,
+            footer: physical.footer,
+            children: [physical.content],
         });
+        page.calculateLayout(new BoxConstraints(), { x: 0, y: 0 }, ctx);
+        return PageRenderer.render(page, objectManager);
     }
 }
-exports.PDFDocumentRenderer = PDFDocumentRenderer;

package/dist/renderer/pdf-renderer.d.ts

@@ -1,5 +1,5 @@
-import { PDFDocumentElement } from "../elements/pdf-document-element";
-import { PDFObjectManager } from "../utils/pdf-object-manager";
+import { PDFDocumentElement } from "../elements/pdf-document-element.js";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
 export declare class PDFRenderer {
     static render(document: PDFDocumentElement, objectManager: PDFObjectManager): Promise<string>;
 }

package/dist/renderer/pdf-renderer.js

@@ -1,92 +1,167 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PDFRenderer = void 0;
-const pdf_document_renderer_1 = require("./pdf-document-renderer");
-const renderer_registry_1 = require("../utils/renderer-registry");
-const elements_1 = require("../elements");
-const text_renderer_1 = require("./text-renderer");
-const container_element_1 = require("../elements/container-element");
-const rectangle_element_1 = require("../elements/rectangle-element");
-const row_element_1 = require("../elements/row-element");
-const container_renderer_1 = require("./container-renderer");
-const rectangle_renderer_1 = require("./rectangle-renderer");
-const row_renderer_1 = require("./row-renderer");
-const expanded_renderer_1 = require("./expanded-renderer");
-const padding_renderer_1 = require("./padding-renderer");
-const image_renderer_1 = require("./image-renderer");
-const line_renderer_1 = require("./line-renderer");
-const repeating_header_element_1 = require("../elements/layout/repeating-header-element");
-const repeating_header_renderer_1 = require("./repeating-header-renderer");
-const deferred_element_1 = require("../elements/layout/deferred-element");
-const deferred_renderer_1 = require("./deferred-renderer");
-const box_constraints_1 = require("../layout/box-constraints");
-class PDFRenderer {
-    static render(document, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Register all Renderer
-            renderer_registry_1.RendererRegistry.register(elements_1.TextElement, text_renderer_1.TextRenderer.render);
-            renderer_registry_1.RendererRegistry.register(container_element_1.ContainerElement, container_renderer_1.ContainerRenderer.render);
-            renderer_registry_1.RendererRegistry.register(row_element_1.RowElement, row_renderer_1.RowRenderer.render);
-            renderer_registry_1.RendererRegistry.register(rectangle_element_1.RectangleElement, rectangle_renderer_1.RectangleRenderer.render);
-            renderer_registry_1.RendererRegistry.register(elements_1.ExpandedElement, expanded_renderer_1.ExpandedRenderer.render);
-            renderer_registry_1.RendererRegistry.register(elements_1.PaddingElement, padding_renderer_1.PaddingRenderer.render);
-            renderer_registry_1.RendererRegistry.register(elements_1.ImageElement, image_renderer_1.ImageRenderer.render);
-            renderer_registry_1.RendererRegistry.register(elements_1.LineElement, line_renderer_1.LineRenderer.render);
-            renderer_registry_1.RendererRegistry.register(repeating_header_element_1.RepeatingHeaderElement, repeating_header_renderer_1.RepeatingHeaderRenderer.render);
-            renderer_registry_1.RendererRegistry.register(deferred_element_1.DeferredElement, deferred_renderer_1.DeferredRenderer.render);
-            let pdfContent = "";
-            // Header: version line + the PDF/A binary marker (the object manager owns it so its length
-            // matches the xref offset calculation).
-            pdfContent += objectManager.getHeader();
-            // Layout pass: thread the context explicitly. The seed page config is the document
-            // default; each PageElement overrides it for its own subtree.
-            const ctx = {
-                metrics: objectManager,
-                pageConfig: objectManager.getPDFConfig(),
-            };
-            document.calculateLayout(new box_constraints_1.BoxConstraints(), { x: 0, y: 0 }, ctx);
-            // Render pages and contents (the driver paginates overflowing pages).
-            yield pdf_document_renderer_1.PDFDocumentRenderer.render(document, objectManager, ctx);
-            // Add the catalog. XMP metadata (/Metadata) and embedded files (/AF + /Names/EmbeddedFiles)
-            // are added only when present; with neither, the catalog is byte-identical to before.
-            const catalogParts = [`/Type /Catalog /Pages ${objectManager.getParentObjectNumber()} 0 R`];
-            const xmp = objectManager.getXmpMetadata();
-            if (xmp) {
-                const metadataObject = objectManager.addObject(`<< /Type /Metadata /Subtype /XML /Length ${xmp.length} >>\nstream\n${xmp}\nendstream`);
-                catalogParts.push(`/Metadata ${metadataObject} 0 R`);
-            }
-            const outputIntent = objectManager.getOutputIntent();
-            if (outputIntent) {
-                catalogParts.push(`/OutputIntents [${outputIntent} 0 R]`);
-            }
-            const attachments = objectManager.getAttachments();
-            if (attachments.length > 0) {
-                const names = attachments.map((a) => `(${a.name}) ${a.filespec} 0 R`).join(" ");
-                const af = attachments.map((a) => `${a.filespec} 0 R`).join(" ");
-                catalogParts.push(`/AF [${af}]`, `/Names << /EmbeddedFiles << /Names [${names}] >> >>`);
-            }
-            const catalogObject = `<< ${catalogParts.join(" ")} >>`;
-            objectManager.addObject(catalogObject);
-            // Now that the render pass has revealed which glyphs each embedded font uses, fill the reserved
-            // font objects with the subset font program (must happen before the objects are serialized).
-            objectManager.finalizeCustomFonts();
-            // Add rendered objects
-            pdfContent += objectManager.getRenderedObjects();
-            // Add XRef table and trailer
-            const startxref = pdfContent.length;
-            pdfContent += objectManager.getXRefTable();
-            pdfContent += objectManager.getTrailerAndXRef(startxref);
-            return pdfContent;
-        });
+import { PDFDocumentRenderer } from "./pdf-document-renderer.js";
+import { RendererRegistry } from "../utils/renderer-registry.js";
+import { DefaultTextStyleElement, ExpandedElement, ImageElement, LineElement, PaddingElement, TextElement, } from "../elements/index.js";
+import { TextRenderer } from "./text-renderer.js";
+import { ContainerElement } from "../elements/container-element.js";
+import { RectangleElement } from "../elements/rectangle-element.js";
+import { RowElement } from "../elements/row-element.js";
+import { ContainerRenderer } from "./container-renderer.js";
+import { RectangleRenderer } from "./rectangle-renderer.js";
+import { RowRenderer } from "./row-renderer.js";
+import { ExpandedRenderer } from "./expanded-renderer.js";
+import { PaddingRenderer } from "./padding-renderer.js";
+import { DefaultTextStyleRenderer } from "./default-text-style-renderer.js";
+import { ImageRenderer } from "./image-renderer.js";
+import { LineRenderer } from "./line-renderer.js";
+import { RepeatingHeaderElement } from "../elements/layout/repeating-header-element.js";
+import { RepeatingHeaderRenderer } from "./repeating-header-renderer.js";
+import { DeferredElement } from "../elements/layout/deferred-element.js";
+import { DeferredRenderer } from "./deferred-renderer.js";
+import { PositionedElement } from "../elements/layout/positioned-element.js";
+import { PositionedRenderer } from "./positioned-renderer.js";
+import { StructGroup } from "../elements/layout/struct-group.js";
+import { StructGroupRenderer } from "./struct-group-renderer.js";
+import { LinkElement } from "../elements/layout/link-element.js";
+import { LinkRenderer } from "./link-renderer.js";
+import { BookmarkElement } from "../elements/layout/bookmark-element.js";
+import { BookmarkRenderer } from "./bookmark-renderer.js";
+import { AnchorElement } from "../elements/layout/anchor-element.js";
+import { PageBreakElement } from "../elements/layout/page-break-element.js";
+import { AnchorRenderer } from "./anchor-renderer.js";
+import { PageBreakRenderer } from "./page-break-renderer.js";
+import { KeepTogetherElement } from "../elements/layout/keep-together-element.js";
+import { KeepTogetherRenderer } from "./keep-together-renderer.js";
+import { TextFieldElement } from "../elements/forms/text-field-element.js";
+import { CheckboxElement } from "../elements/forms/checkbox-element.js";
+import { RadioElement } from "../elements/forms/radio-element.js";
+import { ChoiceElement } from "../elements/forms/choice-element.js";
+import { PushButtonElement } from "../elements/forms/push-button-element.js";
+import { SignatureFieldElement } from "../elements/forms/signature-element.js";
+import { FormFieldRenderer } from "./form-field-renderer.js";
+import { PageBuilderElement } from "../elements/layout/page-builder-element.js";
+import { PageBuilderRenderer } from "./page-builder-renderer.js";
+import { RotatedElement } from "../elements/layout/rotated-element.js";
+import { RotatedBoxElement } from "../elements/layout/rotated-box-element.js";
+import { RotatedRenderer } from "./rotated-renderer.js";
+import { PdfBackend } from "./pdf-backend.js";
+import { BoxConstraints } from "../layout/box-constraints.js";
+import { collectImageElements } from "../layout/collect-images.js";
+import { DEFAULT_TEXT_STYLE, mergeTextStyle } from "../text/text-style.js";
+export class PDFRenderer {
+    static async render(document, objectManager) {
+        // Register all Renderer
+        RendererRegistry.register(TextElement, TextRenderer.render);
+        RendererRegistry.register(ContainerElement, ContainerRenderer.render);
+        RendererRegistry.register(RowElement, RowRenderer.render);
+        RendererRegistry.register(RectangleElement, RectangleRenderer.render);
+        RendererRegistry.register(ExpandedElement, ExpandedRenderer.render);
+        RendererRegistry.register(PaddingElement, PaddingRenderer.render);
+        RendererRegistry.register(PageBreakElement, PageBreakRenderer.render);
+        RendererRegistry.register(KeepTogetherElement, KeepTogetherRenderer.render);
+        RendererRegistry.register(TextFieldElement, FormFieldRenderer.render);
+        RendererRegistry.register(CheckboxElement, FormFieldRenderer.render);
+        RendererRegistry.register(RadioElement, FormFieldRenderer.render);
+        RendererRegistry.register(ChoiceElement, FormFieldRenderer.render);
+        RendererRegistry.register(PushButtonElement, FormFieldRenderer.render);
+        RendererRegistry.register(SignatureFieldElement, FormFieldRenderer.render);
+        RendererRegistry.register(DefaultTextStyleElement, DefaultTextStyleRenderer.render);
+        RendererRegistry.register(ImageElement, ImageRenderer.render);
+        RendererRegistry.register(LineElement, LineRenderer.render);
+        RendererRegistry.register(RepeatingHeaderElement, RepeatingHeaderRenderer.render);
+        RendererRegistry.register(DeferredElement, DeferredRenderer.render);
+        RendererRegistry.register(PositionedElement, PositionedRenderer.render);
+        RendererRegistry.register(StructGroup, StructGroupRenderer.render);
+        RendererRegistry.register(LinkElement, LinkRenderer.render);
+        RendererRegistry.register(BookmarkElement, BookmarkRenderer.render);
+        RendererRegistry.register(AnchorElement, AnchorRenderer.render);
+        RendererRegistry.register(PageBuilderElement, PageBuilderRenderer.render);
+        RendererRegistry.register(RotatedElement, RotatedRenderer.render);
+        RendererRegistry.register(RotatedBoxElement, RotatedRenderer.render);
+        let pdfContent = "";
+        // Header: version line + the PDF/A binary marker (the object manager owns it so its length
+        // matches the xref offset calculation).
+        pdfContent += objectManager.getHeader();
+        // Layout pass: thread the context explicitly. The seed page config is the document
+        // default; each PageElement overrides it for its own subtree.
+        const ctx = {
+            metrics: objectManager,
+            pageConfig: objectManager.getPDFConfig(),
+            textStyle: mergeTextStyle(DEFAULT_TEXT_STYLE, document.getDefaultTextStyle()),
+            onOverflow: objectManager.getOverflowPolicy(),
+        };
+        // Pre-layout: resolve every image's intrinsic pixel size (async), so the synchronous layout can
+        // give a width-only image a proportional height. init() is idempotent, so the renderer reuses it.
+        const images = collectImageElements(document);
+        if (images.length > 0)
+            await Promise.all(images.map((img) => img.resolveIntrinsicSize()));
+        document.calculateLayout(new BoxConstraints(), { x: 0, y: 0 }, ctx);
+        // Render pages and contents (the driver paginates overflowing pages).
+        await PDFDocumentRenderer.render(document, objectManager, ctx);
+        // Add the catalog. XMP metadata (/Metadata) and embedded files (/AF + /Names/EmbeddedFiles)
+        // are added only when present; with neither, the catalog is byte-identical to before.
+        const catalogParts = [`/Type /Catalog /Pages ${objectManager.getParentObjectNumber()} 0 R`];
+        const xmp = objectManager.getXmpMetadata();
+        if (xmp) {
+            const metadataObject = objectManager.addObject(`<< /Type /Metadata /Subtype /XML /Length ${xmp.length} >>\nstream\n${xmp}\nendstream`);
+            catalogParts.push(`/Metadata ${metadataObject} 0 R`);
+        }
+        const outputIntent = objectManager.getOutputIntent();
+        if (outputIntent) {
+            catalogParts.push(`/OutputIntents [${outputIntent} 0 R]`);
+        }
+        // The catalog has exactly one /Names dict; embedded files and named destinations are two entries in
+        // it, so collect both and emit the /Names once (below).
+        const namesParts = [];
+        const attachments = objectManager.getAttachments();
+        if (attachments.length > 0) {
+            // The name-tree key is a PDF literal string, so it needs the same escaping the /Filespec's /F and
+            // /UF get in attachFile(). Unescaped, a ")" or "\" in a file name closes the string early and the
+            // rest of it leaks out as raw operators.
+            const names = attachments
+                .map((a) => `(${PdfBackend.escapePdfString(a.name)}) ${a.filespec} 0 R`)
+                .join(" ");
+            const af = attachments.map((a) => `${a.filespec} 0 R`).join(" ");
+            catalogParts.push(`/AF [${af}]`);
+            namesParts.push(`/EmbeddedFiles << /Names [${names}] >>`);
+        }
+        // Accessible tagging: finalize the structure tree (emits StructTreeRoot + StructElems + ParentTree) and
+        // fold /MarkInfo + /StructTreeRoot + /Lang into the catalog. Returns "" (no-op) when tagging is off.
+        const structCatalog = objectManager.struct.finalize(objectManager);
+        if (structCatalog) {
+            catalogParts.push(structCatalog);
+            // PDF/UA requires the viewer to show the document title (not the file name).
+            catalogParts.push("/ViewerPreferences << /DisplayDocTitle true >>");
+        }
+        // Document outline (bookmarks): emit the /Outlines tree collected during page rendering. Returns
+        // "" (no-op) when no Bookmark was placed, so a plain document's catalog is unchanged.
+        const outlineCatalog = objectManager.outline.finalize(objectManager);
+        if (outlineCatalog)
+            catalogParts.push(outlineCatalog);
+        // Interactive form fields: emit the catalog /AcroForm dict collected as pages rendered. Returns ""
+        // (no-op) when no field was placed, so a plain document's catalog is unchanged.
+        const acroformCatalog = objectManager.acroform.finalize(objectManager);
+        if (acroformCatalog)
+            catalogParts.push(acroformCatalog);
+        // Named destinations (internal-link targets): a /Dests entry in the shared /Names dict.
+        const destsNames = objectManager.dests.finalize(objectManager);
+        if (destsNames)
+            namesParts.push(destsNames);
+        // Emit the single /Names dict if either embedded files or destinations contributed to it.
+        if (namesParts.length > 0)
+            catalogParts.push(`/Names << ${namesParts.join(" ")} >>`);
+        const catalogObject = `<< ${catalogParts.join(" ")} >>`;
+        objectManager.addObject(catalogObject);
+        // Now that the render pass has revealed which glyphs each embedded font uses, fill the reserved
+        // font objects with the subset font program (must happen before the objects are serialized).
+        objectManager.finalizeCustomFonts();
+        // Encrypt every registered stream + add the /Encrypt object (no-op unless a security handler was set).
+        await objectManager.finalizeEncryption();
+        // Add rendered objects
+        pdfContent += objectManager.getRenderedObjects();
+        // Add XRef table and trailer
+        const startxref = pdfContent.length;
+        pdfContent += objectManager.getXRefTable();
+        pdfContent += objectManager.getTrailerAndXRef(startxref);
+        return pdfContent;
     }
 }
-exports.PDFRenderer = PDFRenderer;

package/dist/renderer/positioned-renderer.d.ts

@@ -0,0 +1,6 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { PositionedElement } from "../elements/layout/positioned-element.js";
+import { IRNode } from "../ir/display-list.js";
+export declare class PositionedRenderer {
+    static render(positionedElement: PositionedElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+}

package/dist/renderer/positioned-renderer.js

@@ -0,0 +1,10 @@
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class PositionedRenderer {
+    static async render(positionedElement, objectManager) {
+        // The child was already placed (by the frame) during layout; just emit its IR. It is drawn
+        // after the frame's flow content, so it paints on top.
+        const { child } = positionedElement.getProps();
+        const renderer = RendererRegistry.getRenderer(child);
+        return renderer(child, objectManager);
+    }
+}

package/dist/renderer/rectangle-renderer.d.ts

@@ -1,6 +1,6 @@
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { RectangleElement } from "../elements/rectangle-element";
-import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { RectangleElement } from "../elements/rectangle-element.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class RectangleRenderer {
     static render(rectangleElement: RectangleElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
     /** One `line` node per present side, along the box edges (top-left coordinates). */