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

package/dist/layout/fragmentation.js

@@ -1,11 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFragmentable = isFragmentable;
-exports.packChildren = packChildren;
-const box_constraints_1 = require("./box-constraints");
-function isFragmentable(element) {
-    return ("fragment" in element &&
-        typeof element.fragment === "function");
+import { BoxConstraints } from "./box-constraints.js";
+export function isFragmentable(element) {
+    if (!("fragment" in element) ||
+        typeof element.fragment !== "function") {
+        return false;
+    }
+    // An element may veto splitting at runtime via canFragment() - a transparent StructGroup only fragments
+    // when its wrapped child does, so a non-splittable wrapped child (e.g. a table row) is moved whole to the
+    // next page instead of being clipped at the boundary. Elements without canFragment() are always splittable.
+    const canFragment = element.canFragment;
+    return typeof canFragment !== "function" || canFragment.call(element);
+}
+export function reportOverflow(child, childHeight, maxHeight, policy) {
+    if (policy === "ignore")
+        return;
+    const name = child.constructor.name.replace(/Element$/, "");
+    const detail = `${name} is ${Math.round(childHeight)}pt tall but the page region is only ` +
+        `${Math.round(maxHeight)}pt and it cannot be broken - reduce its size, give it a bounded ` +
+        `height, or let it split across pages.`;
+    if (policy === "error")
+        throw new Error(`Layout overflow: ${detail}`);
+    console.warn(`Layout overflow (clipped): ${detail}`);
+}
+/**
+ * True if packing `children` will hit a forced cut: a child that IS a break, contains one deeper in its
+ * subtree, or asks to break before/after itself. A flow container reports this from `hasForcedBreak` so
+ * its parent fragments it (runs `packChildren`) instead of placing it whole and swallowing the cut.
+ */
+export function childrenForceBreak(children) {
+    return children.some((child) => child.hasForcedBreak() || child.breaksBefore() || child.breaksAfter());
 }
 /**
  * Packs a vertical stack of children into `maxHeight`, in order. Children are measured
@@ -21,41 +43,75 @@ function isFragmentable(element) {
  * Shared by every element that lays out a vertical stack and can split it across regions
  * (Container, and the decorated boxes Padding/Rectangle).
  */
-function packChildren(children, maxHeight, width, ctx, gap = 0) {
+export function packChildren(children, maxHeight, width, ctx, gap = 0) {
     const fitted = [];
     const remainder = [];
     let usedHeight = 0;
+    // Everything from index `from` onward spills to the next region; `broke` says whether the cut was
+    // a FORCED page break (so an enclosing flow stops too) rather than the region filling up.
+    const spill = (from, broke) => {
+        for (let j = from; j < children.length; j++)
+            remainder.push(children[j]);
+        return { fitted, remainder, forceBreak: broke };
+    };
     for (let i = 0; i < children.length; i++) {
         const child = children[i];
-        const childHeight = child.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), { x: 0, y: 0 }, ctx).height;
+        // A forced break: consume the marker (it draws nothing) and send everything after it to a fresh
+        // page, regardless of how much room is left.
+        if (child.isPageBreak())
+            return spill(i + 1, true);
+        // break-before: this child wants a fresh page. Honour it only if something is already on this region
+        // (CSS ignores break-before at the top of a page); that guard also prevents an empty page + a loop.
+        if (child.breaksBefore() && fitted.length > 0)
+            return spill(i, true);
+        const childHeight = child.calculateLayout(BoxConstraints.loose(width, Infinity), { x: 0, y: 0 }, ctx).height;
         // A gap precedes every child except the first one placed in this region.
         const lead = fitted.length > 0 ? gap : 0;
-        if (usedHeight + lead + childHeight <= maxHeight) {
+        // Place whole only if it fits AND holds no forced break: a child that fits by height but contains
+        // a `PageBreak` (or a break-before/after) in its subtree must still be fragmented, or the break
+        // would be swallowed.
+        if (usedHeight + lead + childHeight <= maxHeight && !child.hasForcedBreak()) {
             fitted.push(child);
             usedHeight += lead + childHeight;
+            // break-after: everything after this child starts a fresh page.
+            if (child.breaksAfter())
+                return spill(i + 1, true);
             continue;
         }
-        // `child` straddles the boundary. Try to split it; otherwise place/defer it whole.
+        // `child` straddles the boundary, or carries a forced break. Split it; otherwise place/defer whole.
         const remaining = maxHeight - usedHeight - lead;
         let placedPart = false;
+        let childBroke = false;
         if (isFragmentable(child)) {
             const split = child.fragment(Math.max(0, remaining), width, ctx);
+            childBroke = split.forceBreak ?? false;
             if (split.fitted) {
                 fitted.push(split.fitted);
+                // The child fully fit and triggered no cut: it only reached this path because its subtree
+                // FLAGGED a possible break (hasForcedBreak) that turned out to be a no-op here - e.g. a
+                // break-before at the top of the region, which CSS ignores. Keep packing the siblings after
+                // it instead of spilling them, so break-before does not accidentally push later content away.
+                if (!split.remainder && !childBroke) {
+                    usedHeight += lead + childHeight;
+                    continue;
+                }
                 if (split.remainder)
                     remainder.push(split.remainder);
                 placedPart = true;
             }
         }
         if (!placedPart) {
-            if (fitted.length === 0)
+            if (fitted.length === 0 && !childBroke) {
+                // Taller than the whole region and unsplittable: force it on (it overflows and is clipped)
+                // so the next region still advances - and surface it per the overflow policy.
+                reportOverflow(child, childHeight, maxHeight, ctx.onOverflow ?? "ignore");
                 fitted.push(child);
-            else
+            }
+            else {
                 remainder.push(child);
+            }
         }
-        for (let j = i + 1; j < children.length; j++)
-            remainder.push(children[j]);
-        break;
+        return spill(i + 1, childBroke);
     }
-    return { fitted, remainder };
+    return { fitted, remainder, forceBreak: false };
 }

package/dist/layout/insets.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Resolved and unresolved edge insets, on the LAYOUT side of the seam.
+ *
+ * The public `Insets` input (points, percentages, four shapes) lives in `api/insets.ts` and normalizes
+ * into the specs below - the same split `dimension.ts` and `box-constraints.ts` already use for sizes,
+ * so an element never sees a percentage string and the api layer never sees layout geometry.
+ */
+/** One side: an absolute point size, or a fraction of the available width. */
+export interface EdgeSpec {
+    points?: number;
+    factor?: number;
+}
+/**
+ * `[top, right, bottom, left]`, each still unresolved.
+ *
+ * A plain number is accepted as shorthand for `{ points: n }`: the engine elements are exported for
+ * power users and used to take four numbers, so requiring `{ points: 5 }` would break them for a
+ * feature they are not using.
+ */
+export type EdgeSpecs = [EdgeInput, EdgeInput, EdgeInput, EdgeInput];
+/** A side as given: points for short, or a spec when it may be a percentage. */
+export type EdgeInput = number | EdgeSpec;
+/**
+ * Turn the specs into points. `available` is the WIDTH the element was offered - a percentage resolves
+ * against the width on ALL FOUR sides, top and bottom included, which is the CSS rule (and Yoga's, so
+ * react-pdf agrees). An unbounded width leaves a percentage at 0, the no-op a percentage size gives.
+ */
+export declare function resolveEdges(specs: EdgeSpecs, available: number): [number, number, number, number];

package/dist/layout/insets.js

@@ -0,0 +1,20 @@
+/**
+ * Resolved and unresolved edge insets, on the LAYOUT side of the seam.
+ *
+ * The public `Insets` input (points, percentages, four shapes) lives in `api/insets.ts` and normalizes
+ * into the specs below - the same split `dimension.ts` and `box-constraints.ts` already use for sizes,
+ * so an element never sees a percentage string and the api layer never sees layout geometry.
+ */
+/**
+ * Turn the specs into points. `available` is the WIDTH the element was offered - a percentage resolves
+ * against the width on ALL FOUR sides, top and bottom included, which is the CSS rule (and Yoga's, so
+ * react-pdf agrees). An unbounded width leaves a percentage at 0, the no-op a percentage size gives.
+ */
+export function resolveEdges(specs, available) {
+    const one = (e) => {
+        if (typeof e === "number")
+            return e;
+        return (e.points ?? (e.factor !== undefined && Number.isFinite(available) ? available * e.factor : 0));
+    };
+    return [one(specs[0]), one(specs[1]), one(specs[2]), one(specs[3])];
+}

package/dist/platform/browser-fs.d.ts

@@ -0,0 +1,2 @@
+export declare function readFileBytes(_path: string): Uint8Array;
+export declare function readFileBytesAsync(_path: string): Promise<Uint8Array>;

package/dist/platform/browser-fs.js

@@ -0,0 +1,9 @@
+// Browser stand-in for platform/node-fs.ts (selected by the package.json "browser" field). The browser has
+// no file paths, so loading from one throws a clear, actionable error - pass bytes instead.
+const hint = "needs Node. In the browser pass bytes (Uint8Array / ArrayBuffer) instead - e.g. import the file as a URL and fetch() it, or register a font from its bytes.";
+export function readFileBytes(_path) {
+    throw new Error(`Loading a font from a file path ${hint}`);
+}
+export function readFileBytesAsync(_path) {
+    throw new Error(`Loading an image from a file path ${hint}`);
+}

package/dist/platform/browser-image.d.ts

@@ -0,0 +1,5 @@
+export declare function pngToRgba(bytes: Uint8Array): Promise<{
+    width: number;
+    height: number;
+    rgba: Uint8Array;
+}>;

package/dist/platform/browser-image.js

@@ -0,0 +1,13 @@
+// PNG decode in the browser: the platform's own image decoder, via an OffscreenCanvas, to raw RGBA. No
+// jimp, no Buffer - keeps the browser bundle lean and works wherever Canvas does. The package `browser`
+// field swaps `node-image.ts` for this module at bundle time.
+export async function pngToRgba(bytes) {
+    const bitmap = await createImageBitmap(new Blob([new Uint8Array(bytes)], { type: "image/png" }));
+    const { width, height } = bitmap;
+    const ctx = new OffscreenCanvas(width, height).getContext("2d");
+    if (!ctx)
+        throw new Error("@jasy/pdf: no 2D canvas context available to decode the PNG.");
+    ctx.drawImage(bitmap, 0, 0);
+    bitmap.close();
+    return { width, height, rgba: new Uint8Array(ctx.getImageData(0, 0, width, height).data.buffer) };
+}

package/dist/platform/node-fs.d.ts

@@ -0,0 +1,2 @@
+export declare function readFileBytes(path: string): Uint8Array;
+export declare function readFileBytesAsync(path: string): Promise<Uint8Array>;

package/dist/platform/node-fs.js

@@ -0,0 +1,10 @@
+// Node implementation of the platform file reads. In a browser bundle this whole module is swapped for
+// platform/browser-fs.ts via the package.json "browser" field, so `node:fs` never reaches the browser.
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+export function readFileBytes(path) {
+    return readFileSync(path);
+}
+export function readFileBytesAsync(path) {
+    return readFile(path);
+}

package/dist/platform/node-image.d.ts

@@ -0,0 +1,5 @@
+export declare function pngToRgba(bytes: Uint8Array): Promise<{
+    width: number;
+    height: number;
+    rgba: Uint8Array;
+}>;

package/dist/platform/node-image.js

@@ -0,0 +1,9 @@
+// PNG decode on Node: jimp → raw RGBA pixels. jimp is lazy-imported (it pulls Node-ish bits in) so a
+// text-only render never loads it. The browser swaps this whole module for `browser-image.ts` (a Canvas
+// decode) via the package `browser` field, so neither jimp nor Buffer reach the browser bundle.
+export async function pngToRgba(bytes) {
+    const { Jimp } = await import("jimp");
+    const image = await Jimp.fromBuffer(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+    const { width, height, data } = image.bitmap;
+    return { width, height, rgba: new Uint8Array(data.buffer, data.byteOffset, data.byteLength) };
+}

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

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

package/dist/renderer/anchor-renderer.js

@@ -0,0 +1,11 @@
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class AnchorRenderer {
+    static async render(element, objectManager) {
+        const { name, child, y } = element.getProps();
+        const renderer = RendererRegistry.getRenderer(child);
+        const childNodes = await renderer(child, objectManager);
+        // The child draws normally; an Anchor IR node carries the name + scroll target for the page renderer
+        // to register as a named destination (it produces no content-stream ops itself).
+        return [...childNodes, { type: "anchor", y, name }];
+    }
+}

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

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

package/dist/renderer/bookmark-renderer.js

@@ -0,0 +1,11 @@
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class BookmarkRenderer {
+    static async render(element, objectManager) {
+        const { title, level, child, y } = element.getProps();
+        const renderer = RendererRegistry.getRenderer(child);
+        const childNodes = await renderer(child, objectManager);
+        // The child draws normally; an Outline IR node carries the title + nesting + scroll target for the
+        // page renderer to collect into the /Outlines tree (it produces no content-stream ops itself).
+        return [...childNodes, { type: "outline", y, title, level }];
+    }
+}

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

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

package/dist/renderer/container-renderer.js

@@ -1,30 +1,13 @@
-"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.ContainerRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class ContainerRenderer {
-    static render(containerElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { children } = containerElement.getProps();
-            const nodes = [];
-            if (children)
-                for (const child of children) {
-                    const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
-                    if (renderer) {
-                        nodes.push(...(yield renderer(child, objectManager)));
-                    }
-                }
-            return nodes;
-        });
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class ContainerRenderer {
+    static async render(containerElement, objectManager) {
+        const { children } = containerElement.getProps();
+        const nodes = [];
+        if (children)
+            for (const child of children) {
+                const renderer = RendererRegistry.getRenderer(child);
+                nodes.push(...(await renderer(child, objectManager)));
+            }
+        return nodes;
     }
 }
-exports.ContainerRenderer = ContainerRenderer;

package/dist/renderer/default-text-style-renderer.d.ts

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

package/dist/renderer/default-text-style-renderer.js

@@ -0,0 +1,10 @@
+import { RendererRegistry } from "../utils/renderer-registry.js";
+// Transparent wrapper: the text style was already resolved onto the descendants at layout time, so
+// the renderer just emits the child's display list (like PaddingRenderer).
+export class DefaultTextStyleRenderer {
+    static async render(element, objectManager) {
+        const { child } = element.getProps();
+        const renderer = RendererRegistry.getRenderer(child);
+        return renderer(child, objectManager);
+    }
+}

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

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

package/dist/renderer/deferred-renderer.js

@@ -1,25 +1,10 @@
-"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.DeferredRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class DeferredRenderer {
-    static render(element, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { composed } = element.getProps();
-            if (!composed)
-                return [];
-            const renderer = renderer_registry_1.RendererRegistry.getRenderer(composed);
-            return renderer ? renderer(composed, objectManager) : [];
-        });
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class DeferredRenderer {
+    static async render(element, objectManager) {
+        const { composed } = element.getProps();
+        if (!composed)
+            return [];
+        const renderer = RendererRegistry.getRenderer(composed);
+        return renderer(composed, objectManager);
     }
 }
-exports.DeferredRenderer = DeferredRenderer;

package/dist/renderer/emoji-image.d.ts

@@ -0,0 +1,9 @@
+import { Image } from "../ir/display-list.js";
+export declare function emojiImageUrl(codePoint: number, source: {
+    url: string;
+    format: string;
+}): string;
+export declare function emojiImageNode(codePoint: number, source: {
+    url: string;
+    format: string;
+}, x: number, baselineY: number, em: number): Promise<Image | null>;

package/dist/renderer/emoji-image.js

@@ -0,0 +1,68 @@
+import { CustomBytesImage } from "../elements/image-element.js";
+import { decodePngToRgbFlate } from "../utils/image-helper.js";
+import { bytesFromLatin1 } from "../utils/bytes.js";
+// Per-URL fetch cache (process-wide): an emoji image is fetched once, however many times it appears.
+const cache = new Map();
+const FETCH_TIMEOUT_MS = 5000; // a slow CDN must not stall the whole render
+async function fetchBytes(url) {
+    const cached = cache.get(url);
+    if (cached)
+        return cached;
+    const pending = (async () => {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        try {
+            const r = await fetch(url, { signal: controller.signal });
+            return r.ok ? new Uint8Array(await r.arrayBuffer()) : null;
+        }
+        catch {
+            return null; // offline / 404 / timeout -> null; the caller leaves a blank gap (graceful)
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    })();
+    cache.set(url, pending);
+    // Cache only SUCCESSFUL results: drop a failure so a transient error (offline) can be retried later.
+    void pending.then((bytes) => {
+        if (!bytes && cache.get(url) === pending)
+            cache.delete(url);
+    });
+    return pending;
+}
+// Twemoji-style URL: base + lowercase hex code point + "." + format (e.g. ".../1f600.png"). Single
+// code points only - multi-code-point sequences (flags, ZWJ) are out of scope for now.
+export function emojiImageUrl(codePoint, source) {
+    return `${source.url}${codePoint.toString(16)}.${source.format}`;
+}
+// Builds an `Image` IR node for an emoji drawn as a 1em square seated on the baseline (mostly above
+// it, a little below - like a text glyph), or null when the fetch/decode fails.
+export async function emojiImageNode(codePoint, source, x, baselineY, em) {
+    const bytes = await fetchBytes(emojiImageUrl(codePoint, source));
+    if (!bytes)
+        return null;
+    const img = new CustomBytesImage(bytes);
+    const imageType = await img.getImageType();
+    const fileData = await img.getFileData();
+    const dims = await img.getImageDimensions();
+    // JPEG embeds raw; PNG is decoded to DeviceRGB + an /SMask alpha channel (transparency).
+    let data = fileData;
+    let smask;
+    if (imageType === "FlateDecode") {
+        const decoded = await decodePngToRgbFlate(bytesFromLatin1(fileData));
+        data = decoded.data;
+        smask = decoded.smask;
+    }
+    return {
+        type: "image",
+        x,
+        y: baselineY - em * 0.82,
+        width: em,
+        height: em,
+        intrinsicWidth: dims.width,
+        intrinsicHeight: dims.height,
+        data,
+        imageType,
+        ...(smask ? { smask } : {}),
+    };
+}

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

@@ -1,6 +1,6 @@
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { ExpandedElement } from "../elements";
-import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { ExpandedElement } from "../elements/index.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class ExpandedRenderer {
     static render(expandedElement: ExpandedElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
 }

package/dist/renderer/expanded-renderer.js

@@ -1,23 +1,8 @@
-"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.ExpandedRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class ExpandedRenderer {
-    static render(expandedElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { child } = expandedElement.getProps();
-            const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
-            return renderer ? yield renderer(child, objectManager) : [];
-        });
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class ExpandedRenderer {
+    static async render(expandedElement, objectManager) {
+        const { child } = expandedElement.getProps();
+        const renderer = RendererRegistry.getRenderer(child);
+        return renderer(child, objectManager);
     }
 }
-exports.ExpandedRenderer = ExpandedRenderer;

package/dist/renderer/form-field-renderer.d.ts

@@ -0,0 +1,20 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager.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 { IRNode } from "../ir/display-list.js";
+/** Any form-field element exposes its box + shared spec + style through `getProps()`. */
+type FormFieldElement = TextFieldElement | CheckboxElement | RadioElement | ChoiceElement | PushButtonElement | SignatureFieldElement;
+/**
+ * Renders a form-field element to a single `formfield` IR node - the field's box + its shared
+ * `FormFieldSpec` + style. It draws nothing; the PageRenderer peels it into a Widget /Annot and the
+ * /AcroForm (via forms/acroform.ts). One renderer serves every field element (the spec's `kind`
+ * discriminates downstream).
+ */
+export declare class FormFieldRenderer {
+    static render(element: FormFieldElement, _objectManager: PDFObjectManager): Promise<IRNode[]>;
+}
+export {};

package/dist/renderer/form-field-renderer.js

@@ -0,0 +1,12 @@
+/**
+ * Renders a form-field element to a single `formfield` IR node - the field's box + its shared
+ * `FormFieldSpec` + style. It draws nothing; the PageRenderer peels it into a Widget /Annot and the
+ * /AcroForm (via forms/acroform.ts). One renderer serves every field element (the spec's `kind`
+ * discriminates downstream).
+ */
+export class FormFieldRenderer {
+    static async render(element, _objectManager) {
+        const { x, y, width, height, spec, style } = element.getProps();
+        return [{ type: "formfield", x, y, width, height, field: spec, style }];
+    }
+}

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

@@ -1,6 +1,6 @@
-import { ImageElement } from "../elements/image-element";
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { IRNode } from "../ir/display-list";
+import { ImageElement } from "../elements/image-element.js";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class ImageRenderer {
-    static render(imageElement: ImageElement, _objectManager: PDFObjectManager): Promise<IRNode[]>;
+    static render(imageElement: ImageElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
 }