@jasy/pdf 1.0.0-alpha.4 → 1.0.0-alpha.6

package/dist/elements/row-element.js

@@ -1,5 +1,6 @@
+import { resolveExtent } from "../layout/box-constraints.js";
 import { FlexLayoutHelper, HORIZONTAL_AXIS } from "../utils/flex-layout.js";
-import { SizedPDFElement } from "./pdf-element.js";
+import { FlexiblePDFElement, SizedPDFElement, } from "./pdf-element.js";
 /**
  * Horizontal stack: the mirror of `ContainerElement` (Column). Children are laid out
  * left-to-right via the shared `FlexLayoutHelper` on the horizontal axis; fixed children
@@ -13,26 +14,54 @@ import { SizedPDFElement } from "./pdf-element.js";
  * Grid/Table concern.
  */
 export class RowElement extends SizedPDFElement {
-    constructor({ children, gap, main, cross }) {
+    constructor({ children, gap, main, cross, width, height, widthFactor, heightFactor, }) {
         super({ x: 0, y: 0 });
         this.children = children;
         this.gap = gap ?? 0;
         this.main = main ?? "start";
         this.cross = cross ?? "stretch";
+        this.requested = { width, height, widthFactor, heightFactor };
+    }
+    relativeSizeFactor(horizontal) {
+        return horizontal ? this.requested.widthFactor : this.requested.heightFactor;
+    }
+    /** The mirror of `ContainerElement`: a Row's OWN flex child needs a bounded width, and the need of any
+     *  descendant propagates on both axes (see the Column for the reasoning). */
+    needsBoundedMain(horizontal) {
+        const requested = horizontal
+            ? [this.requested.width, this.requested.widthFactor]
+            : [this.requested.height, this.requested.heightFactor];
+        if (requested.some((v) => v !== undefined))
+            return false;
+        const ownFlexChild = horizontal && this.children.some((c) => c instanceof FlexiblePDFElement);
+        return ownFlexChild || this.children.some((c) => c.needsBoundedMain(horizontal));
     }
     calculateLayout(constraints, offset, ctx) {
         this.x = offset.x;
         this.y = offset.y;
-        // Width fills the offered space (flex children split the leftover); height is the
-        // tallest child unless the parent bounds it.
-        const mainAvail = constraints.hasBoundedWidth ? constraints.maxWidth : Infinity;
-        const crossAvail = constraints.hasBoundedHeight ? constraints.maxHeight : Infinity;
+        // Relative sizing: a pinned extent (fixed or a fraction of the offered box, clamped) wins; else
+        // width fills the offered space (flex children split the leftover) and height is the tallest child.
+        const explicitWidth = resolveExtent(this.requested.width, this.requested.widthFactor, constraints.maxWidth, constraints.hasBoundedWidth);
+        const explicitHeight = resolveExtent(this.requested.height, this.requested.heightFactor, constraints.maxHeight, constraints.hasBoundedHeight);
+        const boundedWidth = explicitWidth !== undefined
+            ? constraints.constrainWidth(explicitWidth)
+            : constraints.hasBoundedWidth
+                ? constraints.maxWidth
+                : undefined;
+        const boundedHeight = explicitHeight !== undefined
+            ? constraints.constrainHeight(explicitHeight)
+            : constraints.hasBoundedHeight
+                ? constraints.maxHeight
+                : undefined;
+        // Horizontal stack: main = width (children fill it), cross = height (children can stretch to it).
+        const mainAvail = boundedWidth ?? Infinity;
+        const crossAvail = boundedHeight ?? Infinity;
         let result = { mainUsed: 0, crossUsed: 0 };
         if (this.children.length > 0) {
             result = FlexLayoutHelper.layout(this.children, HORIZONTAL_AXIS, mainAvail, crossAvail, this.x, this.y, { gap: this.gap, main: this.main, cross: this.cross }, ctx);
         }
-        this.width = constraints.hasBoundedWidth ? constraints.maxWidth : result.mainUsed;
-        this.height = constraints.hasBoundedHeight ? constraints.maxHeight : result.crossUsed;
+        this.width = boundedWidth ?? result.mainUsed;
+        this.height = boundedHeight ?? result.crossUsed;
         return { width: this.width, height: this.height };
     }
     getProps() {

package/dist/elements/text-element.d.ts

@@ -10,7 +10,13 @@ export interface TextSegment {
     fontColor?: Color;
     fontFamily?: string;
     fontSize?: number;
+    /** External URL: this segment becomes an inline hyperlink (a /Link annotation over its glyphs). */
+    href?: string;
+    /** Internal named destination (an `Anchor`): this segment links to it (a /GoTo /Link annotation). */
+    dest?: string;
 }
+/** Accessibility role for the tagged structure tree: a heading level or a paragraph (the default). */
+export type TextRole = "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "p";
 interface TextElementParams {
     id?: string;
     /** Unset (undefined) inherits the cascaded size; see ResolvedTextStyle. */
@@ -26,6 +32,8 @@ interface TextElementParams {
     overflow?: TextOverflow;
     /** Line-height multiplier: each line is `fontSize * lineHeight` tall (default `1`). */
     lineHeight?: number;
+    /** Accessibility role for the tagged structure tree (heading level or paragraph; default `"p"`). */
+    role?: TextRole;
 }
 export declare class TextElement extends SizedPDFElement implements Fragmentable {
     private readonly rawFontSize?;
@@ -43,7 +51,8 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private content;
     private maxLines?;
     private overflow;
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow, lineHeight, }: TextElementParams);
+    private readonly role?;
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow, lineHeight, role, }: TextElementParams);
     private resolveStyle;
     private applyStyle;
     /**
@@ -80,6 +89,7 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
         maxLines: number | undefined;
         overflow: TextOverflow;
         lineHeight: number;
+        role: TextRole | undefined;
     };
 }
 export {};

package/dist/elements/text-element.js

@@ -7,8 +7,9 @@ import { DEFAULT_TEXT_STYLE } from "../text/text-style.js";
 import { wrapStringIntoLines, breakSegmentsIntoLines, segmentLinesToSegments, } from "../text/line-breaker.js";
 import { SizedPDFElement } from "./pdf-element.js";
 export class TextElement extends SizedPDFElement {
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow = "clip", lineHeight, }) {
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow = "clip", lineHeight, role, }) {
         super({ x: 0, y: 0 });
+        this.role = role;
         this.rawFontSize = fontSize;
         this.rawFontFamily = fontFamily;
         this.rawFontStyle = fontStyle;
@@ -97,7 +98,8 @@ export class TextElement extends SizedPDFElement {
             maxLines: this.maxLines,
             overflow: this.overflow,
             lineHeight: this.lineHeight,
-        });
+            role: this.role,
+        }).adoptStructId(this); // a wrapped remainder is the SAME logical paragraph (one P across pages)
     }
     calculateLayout(constraints, offset, ctx) {
         this.resolveStyle(ctx);
@@ -157,6 +159,7 @@ export class TextElement extends SizedPDFElement {
             maxLines: this.maxLines,
             overflow: this.overflow,
             lineHeight: this.lineHeight,
+            role: this.role,
         };
     }
 }

package/dist/ir/display-list.d.ts

@@ -11,6 +11,16 @@ import { FontStyle } from "../utils/pdf-object-manager.js";
  * Coordinates are in PDF points (1/72"). Which origin they use is still the
  * producer's concern for now; centralizing the Y-flip at this seam is Phase 3.
  */
+/**
+ * Structure tag for accessible (PDF/UA) tagging. `role` is the PDF structure type the content maps to
+ * (`P`, `H1`..`H6`, `Figure`, `TD`, …); `key` groups the IR nodes of one logical element (e.g. every line
+ * of a paragraph) into a single structure element; `alt` is the alternate text for a figure. A drawable
+ * node WITHOUT a tag is emitted as an Artifact (decoration, skipped by screen readers).
+ */
+export interface StructTag {
+    role: string;
+    key: number;
+}
 /**
  * A single positioned run of text in one font / size / color. Line wrapping has
  * already happened upstream: the producer emits one `TextRun` per laid-out line or
@@ -25,6 +35,7 @@ export interface TextRun {
     fontStyle: FontStyle;
     fontSize: number;
     color: Color;
+    tag?: StructTag;
 }
 /** An axis-aligned rectangle. An absent `fill` or `stroke` means that part is not drawn. */
 export interface Rect {
@@ -38,6 +49,7 @@ export interface Rect {
     strokeWidth: number;
     /** Corner radius in points; absent/0 = sharp corners (plain `re`). */
     radius?: number;
+    tag?: StructTag;
 }
 /** A straight line segment between two points. */
 export interface Line {
@@ -48,6 +60,7 @@ export interface Line {
     y2: number;
     stroke: Color;
     strokeWidth: number;
+    tag?: StructTag;
 }
 /** A raster image, already resolved to bytes by the producer (no `CustomImage` here). */
 export interface Image {
@@ -71,6 +84,7 @@ export interface Image {
     };
     /** Corner radius in points for the image box; absent/0 = sharp corners. */
     radius?: number;
+    tag?: StructTag;
 }
 /**
  * Pushes a clipping region (a rectangle, rounded when `radius` is set). Everything between this and
@@ -89,5 +103,127 @@ export interface ClipPush {
 export interface ClipPop {
     type: "clip-pop";
 }
+/**
+ * A hyperlink over a rectangle. Unlike every other IR node this draws NOTHING into the content stream -
+ * it becomes a PDF Link ANNOTATION on the page (`/Annots`), a side channel next to the drawing. Exactly
+ * one target is set: `href` is an external URL (a `/URI` action); `dest` is a named destination inside
+ * this document (a `/GoTo` action, resolved via the catalog `/Names /Dests` tree - see `Anchor`). The
+ * rect is the clickable region in top-left engine coords; the Y-flip converts it to PDF page space.
+ *
+ * NOTE: a Link inside a `TransformPush` is NOT yet rotated with it - the annotation rect lives in page
+ * space and ignores the content-stream matrix. Completing that is a planned follow-up (see todo.md).
+ */
+export interface Link {
+    type: "link";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    href?: string;
+    dest?: string;
+}
+/**
+ * A named destination anchor - a jump TARGET for an internal `Link({ to })`. Like `Link` it draws
+ * NOTHING; it registers `name` -> (this page, `y`) in the catalog `/Names /Dests` name tree. `y` is the
+ * top of the target in top-left engine coords (the Y-flip turns it into the page-space scroll target).
+ */
+export interface Anchor {
+    type: "anchor";
+    y: number;
+    name: string;
+}
+/**
+ * A document-outline (bookmark) anchor. Like `Link` it draws NOTHING - it becomes an entry in the PDF
+ * outline tree (`/Outlines`), a side channel the viewer shows in its bookmark panel. `y` is the top of
+ * the target in top-left engine coords (the Y-flip turns it into the page-space scroll target); `level`
+ * (1-based) nests the entry under the nearest preceding entry of a smaller level.
+ */
+export interface Outline {
+    type: "outline";
+    y: number;
+    title: string;
+    level: number;
+}
+/**
+ * Pushes an affine transform (a `q` + `cm` in the content stream): everything between this and the
+ * matching `TransformPop` is painted through `matrix`. This is what `Rotated` wraps its child's nodes
+ * in, so a subtree draws rotated (or scaled/translated) around a pivot without touching its layout.
+ *
+ * `matrix` is `[a, b, c, d, e, f]` in the engine's TOP-LEFT coordinates - the same space every other IR
+ * node uses. The Y-flip at the IR -> backend seam converts it to PDF's bottom-left once per page, so
+ * producers stay coordinate-system-blind (they never see a flipped matrix).
+ */
+export interface TransformPush {
+    type: "transform-push";
+    matrix: [number, number, number, number, number, number];
+}
+/** Closes the most recent `TransformPush` (restores the graphics state). */
+export interface TransformPop {
+    type: "transform-pop";
+}
+/**
+ * One drawing command of a `Path`, in absolute page coordinates. Curves are CUBIC because PDF
+ * content streams have no quadratic operator - a producer converts TrueType quads to cubics before
+ * emitting. `z` closes the current subpath (a glyph contour).
+ */
+export type PathCommand = {
+    op: "m";
+    x: number;
+    y: number;
+} | {
+    op: "l";
+    x: number;
+    y: number;
+} | {
+    op: "c";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    op: "z";
+};
+/** One color stop of a gradient: a position 0..1 along the axis and its color. */
+export interface GradientStop {
+    offset: number;
+    color: Color;
+}
+/** An axial (linear) gradient between two points, in absolute page coordinates. */
+export interface LinearGradient {
+    type: "linear";
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    stops: GradientStop[];
+    extend: "pad" | "repeat" | "reflect";
+}
+/** A radial gradient between two circles, in absolute page coordinates. */
+export interface RadialGradient {
+    type: "radial";
+    x0: number;
+    y0: number;
+    r0: number;
+    x1: number;
+    y1: number;
+    r1: number;
+    stops: GradientStop[];
+    extend: "pad" | "repeat" | "reflect";
+}
+export type Gradient = LinearGradient | RadialGradient;
+/**
+ * A filled vector path - one or more closed subpaths sharing a single fill, using the nonzero
+ * winding rule (so a glyph's inner contour cuts a hole). This is what a color glyph's layers draw
+ * onto: each COLR layer is one `Path` filled with a solid `Color` (v0) or a `Gradient` (v1).
+ */
+export interface Path {
+    type: "path";
+    commands: PathCommand[];
+    fill: Color | Gradient;
+    /** Accessibility structure tag (absent = drawn as an artifact); color-emoji layers stay untagged. */
+    tag?: StructTag;
+}
 /** The closed set of primitives the PDF backend knows how to draw. */
-export type IRNode = TextRun | Rect | Line | Image | ClipPush | ClipPop;
+export type IRNode = TextRun | Rect | Line | Image | ClipPush | ClipPop | Path | Link | Outline | Anchor | TransformPush | TransformPop;

package/dist/layout/box-constraints.d.ts

@@ -44,6 +44,14 @@ export declare class BoxConstraints {
     /** Returns the constraints clamped to lie within `parent` (Flutter's enforce). */
     enforce(parent: BoxConstraints): BoxConstraints;
 }
+/**
+ * Resolves a sized element's extent on one axis (relative sizing). An explicit point size (`fixed`)
+ * always wins; otherwise a `factor` (0..1) of the offered extent, but ONLY when that axis is bounded -
+ * a fraction of an unbounded axis has no meaning (Flutter's FractionallySizedBox under unbounded
+ * constraints). Returns `undefined` to mean "no explicit extent", i.e. fill the box or shrink-wrap.
+ * Shared by every sized element so `width: "50%"` behaves identically across Box / Column / Row / Image.
+ */
+export declare function resolveExtent(fixed: number | undefined, factor: number | undefined, boundedMax: number, hasBounded: boolean): number | undefined;
 /** The size an element resolves to and returns UP the tree. */
 export interface Size {
     width: number;

package/dist/layout/box-constraints.js

@@ -67,3 +67,17 @@ export class BoxConstraints {
         return new BoxConstraints(Math.max(parent.minWidth, Math.min(this.minWidth, parent.maxWidth)), Math.max(parent.minWidth, Math.min(this.maxWidth, parent.maxWidth)), Math.max(parent.minHeight, Math.min(this.minHeight, parent.maxHeight)), Math.max(parent.minHeight, Math.min(this.maxHeight, parent.maxHeight)));
     }
 }
+/**
+ * Resolves a sized element's extent on one axis (relative sizing). An explicit point size (`fixed`)
+ * always wins; otherwise a `factor` (0..1) of the offered extent, but ONLY when that axis is bounded -
+ * a fraction of an unbounded axis has no meaning (Flutter's FractionallySizedBox under unbounded
+ * constraints). Returns `undefined` to mean "no explicit extent", i.e. fill the box or shrink-wrap.
+ * Shared by every sized element so `width: "50%"` behaves identically across Box / Column / Row / Image.
+ */
+export function resolveExtent(fixed, factor, boundedMax, hasBounded) {
+    if (fixed !== undefined)
+        return fixed;
+    if (factor !== undefined && hasBounded)
+        return boundedMax * factor;
+    return undefined;
+}

package/dist/layout/collect-images.d.ts

@@ -0,0 +1,9 @@
+import { PDFElement } from "../elements/pdf-element.js";
+import { ImageElement } from "../elements/image-element.js";
+/**
+ * Walks the element tree (via `getProps`, the same shallow-reflection style as the validator) and
+ * returns every `ImageElement`. A pre-layout pass uses this to resolve each image's intrinsic pixel
+ * size asynchronously: layout is synchronous and cannot await jimp, yet it needs the aspect ratio to
+ * give a width-only image its proportional height. Cheap - images are few and this runs once.
+ */
+export declare function collectImageElements(root: PDFElement): ImageElement[];

package/dist/layout/collect-images.js

@@ -0,0 +1,34 @@
+import { PDFElement, hasChildrenProp, hasChildProp } from "../elements/pdf-element.js";
+import { ImageElement } from "../elements/image-element.js";
+/**
+ * Walks the element tree (via `getProps`, the same shallow-reflection style as the validator) and
+ * returns every `ImageElement`. A pre-layout pass uses this to resolve each image's intrinsic pixel
+ * size asynchronously: layout is synchronous and cannot await jimp, yet it needs the aspect ratio to
+ * give a width-only image its proportional height. Cheap - images are few and this runs once.
+ */
+export function collectImageElements(root) {
+    const out = [];
+    const visit = (el) => {
+        if (el instanceof ImageElement)
+            out.push(el);
+        const props = el.getProps();
+        if (hasChildrenProp(props))
+            for (const c of props.children)
+                visit(c);
+        else if (hasChildProp(props))
+            visit(props.child);
+        // Wrappers that hold a subtree outside `children`/`child`: a Page's header/footer and a
+        // RepeatingHeaderElement's `body` (a Table with a header wraps its rows there). A
+        // DeferredElement's `composed` is null until layout runs, so it cannot be reached from this
+        // pre-layout pass; an image inside a deferred subtree just skips aspect pre-resolution.
+        const w = props;
+        if (w.header instanceof PDFElement)
+            visit(w.header);
+        if (w.footer instanceof PDFElement)
+            visit(w.footer);
+        if (w.body instanceof PDFElement)
+            visit(w.body);
+    };
+    visit(root);
+    return out;
+}

package/dist/layout/fragmentation.js

@@ -1,7 +1,14 @@
 import { BoxConstraints } from "./box-constraints.js";
 export function isFragmentable(element) {
-    return ("fragment" in element &&
-        typeof element.fragment === "function");
+    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);
 }
 function reportOverflow(child, childHeight, maxHeight, policy) {
     if (policy === "ignore")

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 = renderer ? 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 = renderer ? 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/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/image-renderer.d.ts

@@ -2,5 +2,5 @@ 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[]>;
 }

package/dist/renderer/image-renderer.js

@@ -2,9 +2,9 @@ import { BoxFit } from "../elements/image-element.js";
 import { bytesFromLatin1 } from "../utils/bytes.js";
 import { applyContainFit, applyCoverFit, applyFillFit, applyFitNone, decodePngToRgbFlate, } from "../utils/image-helper.js";
 export class ImageRenderer {
-    static async render(imageElement, _objectManager) {
+    static async render(imageElement, objectManager) {
         // Load the image and convert it in a binary string
-        let { x, y, width, height, image, fit, radius } = imageElement.getProps();
+        let { x, y, width, height, image, fit, radius, alt } = imageElement.getProps();
         await image.init(); // Load and initialize the image
         const imageType = await image.getImageType(); // For the moment we can handle `png` and `jpg/jpeg` files
         const fileData = await image.getFileData();
@@ -82,6 +82,14 @@ export class ImageRenderer {
                 }
                 : {}),
         };
+        // Accessible tagging: an image WITH alt text is a Figure; without, it stays untagged and the backend
+        // treats it as decoration (an Artifact). One struct element per image.
+        if (objectManager.struct.enabled && alt) {
+            node.tag = {
+                role: "Figure",
+                key: objectManager.struct.openElement(imageElement.structId, "Figure", { alt }),
+            };
+        }
         return [node];
     }
 }

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

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

package/dist/renderer/link-renderer.js

@@ -0,0 +1,11 @@
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class LinkRenderer {
+    static async render(element, objectManager) {
+        const { href, dest, child, x, y, width, height } = element.getProps();
+        const renderer = RendererRegistry.getRenderer(child);
+        const childNodes = renderer ? await renderer(child, objectManager) : [];
+        // The child draws normally; a Link IR node carries the clickable rect + target (external href or
+        // internal dest) for the page renderer to emit as a /Link annotation (no content-stream ops itself).
+        return [...childNodes, { type: "link", x, y, width, height, href, dest }];
+    }
+}

package/dist/renderer/page-builder-renderer.d.ts

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

package/dist/renderer/page-builder-renderer.js

@@ -0,0 +1,11 @@
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class PageBuilderRenderer {
+    static async render(element, objectManager) {
+        // `composed` is whatever the closure built for THIS page during the render pass's layout.
+        const { composed } = element.getProps();
+        if (!composed)
+            return [];
+        const renderer = RendererRegistry.getRenderer(composed);
+        return renderer ? renderer(composed, objectManager) : [];
+    }
+}