@jasy/pdf 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/elements/svg-element.js

@@ -0,0 +1,93 @@
+import { readFileBytes } from "../platform/node-fs.js";
+import { SvgParseError, svgSize, svgToIr } from "../svg/index.js";
+import { extentSpecs, resolveSize, } from "../layout/box-constraints.js";
+import { SizedPDFElement } from "./pdf-element.js";
+/** Markup is recognised by its first non-space character - anything else is treated as a path. */
+const looksLikeMarkup = (value) => /^\s*[<]/.test(value);
+/**
+ * Reads the file, or says what went wrong in the caller's terms. A string that is neither markup nor
+ * a readable path would otherwise surface as a bare `ENOENT`, which never mentions that the argument
+ * was taken as a PATH in the first place.
+ */
+function readSource(path) {
+    try {
+        return readFileBytes(path);
+    }
+    catch (error) {
+        const shown = path.length > 80 ? `${path.slice(0, 77)}...` : path;
+        throw new SvgParseError(`could not read "${shown}" as an SVG file. It does not start with "<", so it was taken as a ` +
+            `path: ${error.message}`);
+    }
+}
+/**
+ * An SVG drawing placed in the layout like an image.
+ *
+ * Unlike a bitmap it needs no decoder, so its intrinsic size is known SYNCHRONOUSLY, in the
+ * constructor - which also means a broken file fails on the line that asked for it rather than deep
+ * inside a later render, the same bargain `addFont` makes.
+ */
+export class SvgElement extends SizedPDFElement {
+    constructor(params) {
+        super({ x: 0, y: 0, width: params.width, height: params.height });
+        const { source, alt, widthFactor, heightFactor, ...sizing } = params;
+        this.widthFactor = widthFactor;
+        this.heightFactor = heightFactor;
+        this.source =
+            typeof source === "string"
+                ? looksLikeMarkup(source)
+                    ? source
+                    : new TextDecoder().decode(readSource(source))
+                : new TextDecoder().decode(source);
+        // Parsed here on purpose: an unreadable file is an error where it was NAMED, not inside a render
+        // three call frames later. The whole document is walked, not just its root, so an element outside
+        // the subset surfaces here too - which is what makes the error predictable rather than a lottery
+        // between construction and render time. A logo parses in well under a millisecond.
+        this.intrinsic = svgSize(this.source);
+        svgToIr(this.source, { x: 0, y: 0, width: 1, height: 1 });
+        this.alt = alt;
+        this.sizing = sizing;
+        this.requested = { width: params.width, height: params.height };
+    }
+    getProps() {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            source: this.source,
+            intrinsic: this.intrinsic,
+            alt: this.alt,
+        };
+    }
+    calculateLayout(constraints, offset, _ctx) {
+        this.x = offset.x;
+        this.y = offset.y;
+        const specs = extentSpecs({
+            ...this.sizing,
+            width: this.requested.width,
+            height: this.requested.height,
+            widthFactor: this.widthFactor,
+            heightFactor: this.heightFactor,
+        });
+        const resolved = resolveSize(specs.width, specs.height, this.sizing.aspectRatio, constraints);
+        let w = resolved.width;
+        let h = resolved.height;
+        const bounds = resolved.constraints;
+        // One pinned axis derives the other from the drawing's own ratio (CSS `width: 120; height: auto`).
+        // A bitmap needs a decode pass before it can do this; an SVG knows it from its viewBox.
+        if (this.sizing.aspectRatio === undefined &&
+            this.intrinsic.width > 0 &&
+            this.intrinsic.height > 0) {
+            const ratio = this.intrinsic.width / this.intrinsic.height;
+            if (w !== undefined && h === undefined)
+                h = bounds.constrainHeight(w / ratio);
+            else if (h !== undefined && w === undefined)
+                w = bounds.constrainWidth(h * ratio);
+        }
+        // Nothing pinned: draw at the intrinsic size, as an unsized `<img>` does - never fill the region,
+        // which would blow a 24pt icon up to the whole page.
+        this.width = w ?? bounds.constrainWidth(this.intrinsic.width);
+        this.height = h ?? bounds.constrainHeight(this.intrinsic.height);
+        return { width: this.width, height: this.height };
+    }
+}

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

@@ -6,6 +6,7 @@ import { type TextTransform } from "../text/text-style.js";
 import { Fragmentable, FragmentResult } from "../layout/fragmentation.js";
 import { TextOverflow } from "../text/line-breaker.js";
 import { HorizontalAlignment, LayoutContext, SizedPDFElement } from "./pdf-element.js";
+import type { Hyphenator } from "../text/word-splitting.js";
 export interface TextSegment {
     content: string;
     fontStyle?: FontStyle;
@@ -74,6 +75,12 @@ interface TextElementParams {
     wordSpacing?: number;
     /** CSS `text-indent`, in points: how far the first line starts in. */
     textIndent?: number;
+    /** CSS `overflow-wrap: break-word` - split a word wider than its box, anywhere. */
+    breakWord?: boolean;
+    /** The font's ligatures; on unless switched off. */
+    ligatures?: boolean;
+    /** Language-aware splitting; a hyphen is drawn at the break. See text/word-splitting.ts. */
+    hyphenate?: Hyphenator;
     /** Accessibility role for the tagged structure tree (heading level or paragraph; default `"p"`). */
     role?: TextRole;
 }
@@ -93,6 +100,9 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private readonly rawTextTransform?;
     private readonly rawWordSpacing?;
     private readonly rawTextIndent?;
+    private readonly rawBreakWord?;
+    private readonly rawLigatures?;
+    private readonly rawHyphenate?;
     private fontSize;
     private fontFamily;
     private fontStyle;
@@ -109,13 +119,16 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private textTransform;
     private wordSpacing;
     private textIndent;
+    private breakWord;
+    private ligatures;
+    private hyphenate?;
     private content;
     private maxLines?;
     private orphans?;
     private widows?;
     private overflow;
     private readonly role?;
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, role, }: TextElementParams);
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, }: TextElementParams);
     private resolveStyle;
     /** Justified lines may be squeezed to keep a word; every other alignment gets no slack. Read by the
      *  breaker in BOTH passes, or a measured line and a drawn one would disagree about where it ends. */
@@ -125,6 +138,13 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
      * same width in most fonts).
      */
     private display;
+    /**
+     * Drops or substitutes whatever the RESOLVED font cannot draw. Runs last, after the fallback stack
+     * has had its say, and before anything is measured - a character removed at draw time only would
+     * make the measured line and the drawn one disagree. A font that draws everything gets its input
+     * back unchanged, so an ordinary document is byte-identical.
+     */
+    private covered;
     /** The content with `text-transform` applied, and nothing else. */
     private recased;
     private lineOptions;
@@ -151,6 +171,15 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
      *  - enough to tip a borderline string (e.g. "20 Jun 2026", wider than "04 Jul 2026" only because
      *  'n' beats 'l') one bit over its own width, dropping the last word onto a second line. */
     private naturalWidth;
+    /**
+     * The widest piece of this text that cannot be broken - CSS's `min-content` width. A shrinking flex
+     * parent floors the width it hands us here, so a squeezed paragraph stops at its longest word
+     * instead of becoming one word per line.
+     *
+     * With `breakWord` or `hyphenate` on, the text may be cut mid-word, so the unbreakable piece is a
+     * single character - the same reasoning CSS applies to `word-break: break-all`.
+     */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     getProps(): {
         x: number;
         y: number;
@@ -174,6 +203,9 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
         direction: Direction;
         wordSpacing: number;
         textIndent: number;
+        breakWord: boolean;
+        ligatures: boolean;
+        hyphenate: Hyphenator | undefined;
         role: TextRole | undefined;
     };
 }

package/dist/elements/text-element.js

@@ -6,10 +6,13 @@ import { TextRenderer } from "../renderer/text-renderer.js";
 import { DEFAULT_TEXT_STYLE } from "../text/text-style.js";
 import { applyTextTransform } from "../text/text-style.js";
 import { splitByFont } from "../text/font-fallback.js";
+import { runAdvance } from "../text/advance.js";
 import { singleLineWidth, MAX_SPACE_SHRINK, wrapStringIntoLines, breakSegmentsIntoLines, segmentLinesToSegments, } from "../text/line-breaker.js";
 import { adjustForOrphansWidows, DEFAULT_ORPHANS, DEFAULT_WIDOWS, } from "../text/orphans-widows.js";
 import { lineBoxForSegmentLine, lineBoxForString } from "../text/line-metrics.js";
 import { HorizontalAlignment, SizedPDFElement } from "./pdf-element.js";
+import { normalizeContent } from "../text/whitespace.js";
+import { coverText } from "../text/glyph-coverage.js";
 /** How far a run sits off the baseline, as a fraction of its font size (up is positive). */
 export const VERTICAL_TEXT_SHIFT = {
     baseline: 0,
@@ -28,7 +31,7 @@ function finitePoints(value, name) {
     return value;
 }
 export class TextElement extends SizedPDFElement {
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow = "clip", lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, role, }) {
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow = "clip", lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, }) {
         super({ x: 0, y: 0 });
         this.role = role;
         this.rawFontSize = fontSize;
@@ -46,7 +49,12 @@ export class TextElement extends SizedPDFElement {
         this.rawTextTransform = textTransform;
         this.rawWordSpacing = finitePoints(wordSpacing, "wordSpacing");
         this.rawTextIndent = finitePoints(textIndent, "textIndent");
-        this.content = content;
+        this.rawBreakWord = breakWord;
+        this.rawLigatures = ligatures;
+        this.rawHyphenate = hyphenate;
+        // Control characters have no glyph and would be DRAWN as .notdef boxes; `\n` survives
+        // because the breaker treats it as a hard break. See text/whitespace.ts.
+        this.content = normalizeContent(content);
         this.maxLines = maxLines;
         this.orphans = orphans;
         this.widows = widows;
@@ -69,8 +77,10 @@ export class TextElement extends SizedPDFElement {
         // A SPAN may bring its own stack, so the element's being empty is not enough to skip the pass.
         const anyStack = this.fontFallback.length > 0 ||
             (typeof cased !== "string" && cased.some((seg) => (seg.fontFallback?.length ?? 0) > 0));
-        if (!anyStack || !metrics)
+        if (!metrics)
             return cased;
+        if (!anyStack)
+            return this.covered(cased, metrics);
         // Font fallback turns the content into spans - one per family - which every later pass already
         // knows how to handle. Nothing new downstream.
         const pieces = typeof cased === "string" ? [{ content: cased }] : cased;
@@ -83,7 +93,28 @@ export class TextElement extends SizedPDFElement {
                 for (const run of runs)
                     out.push({ ...seg, content: run.text, fontFamily: run.fontFamily });
         }
-        return out;
+        return this.covered(out, metrics);
+    }
+    /**
+     * Drops or substitutes whatever the RESOLVED font cannot draw. Runs last, after the fallback stack
+     * has had its say, and before anything is measured - a character removed at draw time only would
+     * make the measured line and the drawn one disagree. A font that draws everything gets its input
+     * back unchanged, so an ordinary document is byte-identical.
+     */
+    covered(content, metrics) {
+        const report = (dropped) => metrics.reportMissingGlyph?.(dropped);
+        if (typeof content === "string") {
+            const { text, dropped } = coverText(content, this.fontFamily, this.fontStyle, metrics);
+            if (dropped.length > 0)
+                report(dropped);
+            return text;
+        }
+        return content.map((seg) => {
+            const { text, dropped } = coverText(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontStyle ?? this.fontStyle, metrics);
+            if (dropped.length > 0)
+                report(dropped);
+            return text === seg.content ? seg : { ...seg, content: text };
+        });
     }
     /** The content with `text-transform` applied, and nothing else. */
     recased() {
@@ -104,6 +135,8 @@ export class TextElement extends SizedPDFElement {
         return {
             wordSpacing: this.wordSpacing,
             indent: this.textIndent,
+            splitting: { breakWord: this.breakWord, hyphenate: this.hyphenate },
+            ligatures: this.ligatures,
             // Justified lines may be squeezed to keep a word; every other alignment gets no slack.
             shrink: this.textAlignment === HorizontalAlignment.justify ? MAX_SPACE_SHRINK : 0,
         };
@@ -124,6 +157,9 @@ export class TextElement extends SizedPDFElement {
         this.textTransform = this.rawTextTransform ?? ts.textTransform;
         this.wordSpacing = this.rawWordSpacing ?? ts.wordSpacing;
         this.textIndent = this.rawTextIndent ?? ts.textIndent;
+        this.breakWord = this.rawBreakWord ?? ts.breakWord;
+        this.ligatures = this.rawLigatures ?? ts.ligatures;
+        this.hyphenate = this.rawHyphenate ?? ts.hyphenate;
     }
     /**
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
@@ -257,6 +293,43 @@ export class TextElement extends SizedPDFElement {
         return content.reduce((sum, seg) => sum +
             oneLine(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontSize ?? this.fontSize, seg.fontStyle ?? this.fontStyle, seg.letterSpacing ?? this.letterSpacing), indent);
     }
+    /**
+     * The widest piece of this text that cannot be broken - CSS's `min-content` width. A shrinking flex
+     * parent floors the width it hands us here, so a squeezed paragraph stops at its longest word
+     * instead of becoming one word per line.
+     *
+     * With `breakWord` or `hyphenate` on, the text may be cut mid-word, so the unbreakable piece is a
+     * single character - the same reasoning CSS applies to `word-break: break-all`.
+     */
+    minIntrinsicMain(horizontal, ctx) {
+        // Only the width is a question here: the height of a text is whatever its lines add up to, and a
+        // column squeezing it vertically is the paginator's business, not the shrink pass's.
+        if (!horizontal)
+            return 0;
+        this.resolveStyle(ctx);
+        const metrics = ctx.metrics;
+        const widest = (text, family, size, style, letterSpacing) => {
+            // `ligatures` belongs to the FONT: it decides which glyphs are drawn and therefore how wide the
+            // piece is. Leaving it out here would measure a floor the drawing never matches.
+            const font = {
+                fontFamily: family,
+                fontSize: size,
+                fontStyle: style,
+                ligatures: this.ligatures,
+            };
+            // Split on the same boundaries the breaker uses - a hard break ends a line too.
+            const pieces = this.breakWord || this.hyphenate ? [...text] : text.split(/[ \n]/);
+            return pieces.reduce((max, piece) => Math.max(max, runAdvance(metrics, piece, font, letterSpacing)), 0);
+        };
+        const content = this.display(metrics);
+        if (typeof content === "string") {
+            return widest(content, this.fontFamily, this.fontSize, this.fontStyle, this.letterSpacing);
+        }
+        // Segments join without a space, so a word may straddle two of them; taking the widest piece per
+        // segment can therefore UNDER-estimate. That errs towards squeezing a little too far, which lands
+        // back on the old overflow behaviour rather than on something new.
+        return content.reduce((max, seg) => Math.max(max, widest(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontSize ?? this.fontSize, seg.fontStyle ?? this.fontStyle, seg.letterSpacing ?? this.letterSpacing)), 0);
+    }
     getProps() {
         return {
             x: this.x,
@@ -281,6 +354,9 @@ export class TextElement extends SizedPDFElement {
             direction: this.direction,
             wordSpacing: this.wordSpacing,
             textIndent: this.textIndent,
+            breakWord: this.breakWord,
+            ligatures: this.ligatures,
+            hyphenate: this.hyphenate,
             role: this.role,
         };
     }

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

@@ -233,6 +233,9 @@ export interface LinearGradient {
     y1: number;
     stops: GradientStop[];
     extend: "pad" | "repeat" | "reflect";
+    /** One opacity for the whole shading (0-1). A PDF shading is DeviceRGB and has no alpha channel,
+     *  so a PER-STOP alpha is not representable - but a uniform one is, as an ExtGState. */
+    alpha?: number;
 }
 /** A radial gradient between two circles, in absolute page coordinates. */
 export interface RadialGradient {
@@ -245,19 +248,55 @@ export interface RadialGradient {
     r1: number;
     stops: GradientStop[];
     extend: "pad" | "repeat" | "reflect";
+    /** One opacity for the whole shading (0-1). A PDF shading is DeviceRGB and has no alpha channel,
+     *  so a PER-STOP alpha is not representable - but a uniform one is, as an ExtGState. */
+    alpha?: number;
 }
 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).
+ * How a path's outline is stroked. The names are SVG's, the semantics are the PDF operators they map
+ * to (`w`, `J`, `j`, `M`, `d`), and the defaults are SVG's initial values - not PDF's, which differ on
+ * the miter limit. Opacity rides on the `Color`, as everywhere else in the IR.
+ */
+export interface StrokeStyle {
+    color: Color;
+    width: number;
+    /** `J`. Default `butt`. */
+    cap?: "butt" | "round" | "square";
+    /** `j`. Default `miter`. */
+    join?: "miter" | "round" | "bevel";
+    /** `M`. Default 4 (SVG); PDF's own default is 10, so we always emit it when a join can miter. */
+    miterLimit?: number;
+    /** `d`: dash lengths in points, plus the phase to start at. Absent or empty = solid. */
+    dash?: number[];
+    dashOffset?: number;
+}
+/**
+ * A vector path - one or more subpaths that share one fill and/or one stroke. `fill` uses the nonzero
+ * winding rule unless `fillRule` says otherwise, so a glyph's inner contour cuts a hole by default.
+ * A color glyph's layer is one `Path` filled with a solid `Color` (COLR v0) or a `Gradient` (v1); an
+ * SVG shape is one `Path` that may also carry a stroke, or carry ONLY a stroke.
  */
 export interface Path {
     type: "path";
     commands: PathCommand[];
-    fill: Color | Gradient;
+    /** Absent = not filled (a stroke-only outline). */
+    fill?: Color | Gradient;
+    /** `evenodd` maps to the `*` operators; absent = nonzero, which is what glyphs need. */
+    fillRule?: "nonzero" | "evenodd";
+    stroke?: StrokeStyle;
     /** Accessibility structure tag (absent = drawn as an artifact); color-emoji layers stay untagged. */
     tag?: StructTag;
 }
+/**
+ * Clips to an arbitrary path until the matching `clip-pop` - what SVG's `<clipPath>` needs, and what
+ * `ClipPush` cannot express, being a rectangle. The commands are in the same space as a `Path`'s.
+ */
+export interface ClipPathPush {
+    type: "clip-path-push";
+    commands: PathCommand[];
+    /** `evenodd` maps to `W*`; absent = nonzero. SVG spells this `clip-rule`. */
+    fillRule?: "nonzero" | "evenodd";
+}
 /** The closed set of primitives the PDF backend knows how to draw. */
-export type IRNode = TextRun | Rect | Line | Image | ClipPush | ClipPop | Path | Link | Outline | Anchor | FormFieldNode | TransformPush | TransformPop;
+export type IRNode = TextRun | Rect | Line | Image | ClipPush | ClipPathPush | ClipPop | Path | Link | Outline | Anchor | FormFieldNode | TransformPush | TransformPop;

package/dist/layout/min-intrinsic.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `min-content` sizing - the smallest extent a subtree can be squeezed into and still hold together.
+ *
+ * The shrink pass in `FlexLayoutHelper` floors every child at this, so an overflowing line stops
+ * squeezing instead of grinding a paragraph down to one word per line. It is the same rule a browser
+ * applies through the automatic `min-width` of a flex item (CSS Flexbox 4.5).
+ *
+ * Only the leaves know a real number - a `Text` its longest word, everything else nothing in
+ * particular. These helpers are how a container folds its children's answers into its own.
+ */
+import type { LayoutContext } from "../elements/pdf-element.js";
+import type { PDFElement } from "../elements/pdf-element.js";
+/**
+ * The children's floor, folded along one axis: children laid out ALONG the queried axis have to fit
+ * side by side, so their floors add up (plus the gaps between them); across it they merely overlap,
+ * so the widest one wins.
+ *
+ * A wrapping stack adds up nothing: it may put every child on its own line, so it is only as wide as
+ * its widest child - which is what CSS says about a multi-line flex container too.
+ */
+export declare function stackMinIntrinsic(children: PDFElement[], gap: number, alongAxis: boolean, horizontal: boolean, ctx: LayoutContext, wraps?: boolean): number;
+/**
+ * Folds an element's own declared extent into the floor its content asks for. CSS calls these the
+ * "specified size suggestion" and the "content size suggestion" and takes the SMALLER: a box that
+ * declares 400pt around content needing 50 may still be squeezed to 50, while one declaring 400
+ * around content needing 500 cannot go below 400. An extent given as a fraction is not a suggestion
+ * at all - it has no size of its own until the parent is known - so it is ignored here.
+ */
+export declare function withDeclaredExtent(contentFloor: number, declared: number | undefined, explicitMin?: number): number;

package/dist/layout/min-intrinsic.js

@@ -0,0 +1,37 @@
+/**
+ * The children's floor, folded along one axis: children laid out ALONG the queried axis have to fit
+ * side by side, so their floors add up (plus the gaps between them); across it they merely overlap,
+ * so the widest one wins.
+ *
+ * A wrapping stack adds up nothing: it may put every child on its own line, so it is only as wide as
+ * its widest child - which is what CSS says about a multi-line flex container too.
+ */
+export function stackMinIntrinsic(children, gap, alongAxis, horizontal, ctx, wraps = false) {
+    const floors = children.map((c) => c.minIntrinsicMain(horizontal, ctx));
+    if (floors.length === 0)
+        return 0;
+    if (!alongAxis || wraps)
+        return Math.max(...floors);
+    return floors.reduce((sum, f) => sum + f, 0) + gap * (floors.length - 1);
+}
+/**
+ * Folds an element's own declared extent into the floor its content asks for. CSS calls these the
+ * "specified size suggestion" and the "content size suggestion" and takes the SMALLER: a box that
+ * declares 400pt around content needing 50 may still be squeezed to 50, while one declaring 400
+ * around content needing 500 cannot go below 400. An extent given as a fraction is not a suggestion
+ * at all - it has no size of its own until the parent is known - so it is ignored here.
+ */
+export function withDeclaredExtent(contentFloor, declared, explicitMin) {
+    // An explicit `minWidth`/`minHeight` REPLACES the automatic minimum - it does not compete with it.
+    // CSS applies the automatic minimum only while `min-width` is `auto`, so a smaller explicit value
+    // wins too: `min-width: 0` is the standard way to let a flex item shrink past its longest word, and
+    // taking the larger of the two would quietly ignore it. Measured in Chrome on one long word in a
+    // 200pt line: 132.08pt with `auto`, 84.64pt with `0`.
+    if (explicitMin !== undefined)
+        return explicitMin;
+    // Without an explicit bound the floor is CSS's content-based minimum: the smaller of what the
+    // element declares and what its content actually needs. It matters because the shrink pass must not
+    // aim below a size the child will refuse - the share it was supposed to give would never arrive,
+    // and the line would stay over its width.
+    return declared === undefined ? contentFloor : Math.min(declared, contentFloor);
+}

package/dist/renderer/anchor-renderer.js

@@ -3,7 +3,7 @@ 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) : [];
+        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.js

@@ -3,7 +3,7 @@ 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) : [];
+        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/canvas-renderer.d.ts

@@ -0,0 +1,14 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { CanvasElement } from "../elements/canvas-element.js";
+import type { IRNode } from "../ir/display-list.js";
+/**
+ * Runs the caller's paint callback and hands back what it drew.
+ *
+ * The painter works in CANVAS coordinates (0,0 is the box's own corner), so the whole drawing is
+ * wrapped in one translate rather than every point being offset - the same shape `Svg` uses, and it
+ * keeps the callback independent of where the box ended up. The clip is the box: a drawing that runs
+ * past its own edge would otherwise bleed into the layout beside it.
+ */
+export declare class CanvasRenderer {
+    static render(element: CanvasElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+}

package/dist/renderer/canvas-renderer.js

@@ -0,0 +1,36 @@
+import { CanvasPainter } from "../canvas/painter.js";
+/**
+ * Runs the caller's paint callback and hands back what it drew.
+ *
+ * The painter works in CANVAS coordinates (0,0 is the box's own corner), so the whole drawing is
+ * wrapped in one translate rather than every point being offset - the same shape `Svg` uses, and it
+ * keeps the callback independent of where the box ended up. The clip is the box: a drawing that runs
+ * past its own edge would otherwise bleed into the layout beside it.
+ */
+export class CanvasRenderer {
+    static async render(element, objectManager) {
+        const { x, y, width, height, paint, alt } = element.getProps();
+        // The layout bounds are kept as plain numbers, and the painter and the callback each get their
+        // OWN size object. Sharing one meant a callback that wrote to `size.width` moved the clip away
+        // from the box layout had reserved - the drawing would then bleed into what sits beside it.
+        const w = width ?? 0;
+        const h = height ?? 0;
+        const painter = new CanvasPainter({ width: w, height: h });
+        paint(painter, { width: w, height: h });
+        const drawn = painter.drawn();
+        const nodes = [
+            { type: "clip-push", x: x ?? 0, y: y ?? 0, width: w, height: h },
+            { type: "transform-push", matrix: [1, 0, 0, 1, x ?? 0, y ?? 0] },
+            ...drawn,
+            { type: "transform-pop" },
+            { type: "clip-pop" },
+        ];
+        if (!alt || !objectManager.struct.enabled)
+            return nodes;
+        const tag = {
+            role: "Figure",
+            key: objectManager.struct.openElement(element.structId, "Figure", { alt }),
+        };
+        return nodes.map((node) => (node.type === "path" ? { ...node, tag } : node));
+    }
+}

package/dist/renderer/container-renderer.js

@@ -6,9 +6,7 @@ export class ContainerRenderer {
         if (children)
             for (const child of children) {
                 const renderer = RendererRegistry.getRenderer(child);
-                if (renderer) {
-                    nodes.push(...(await renderer(child, objectManager)));
-                }
+                nodes.push(...(await renderer(child, objectManager)));
             }
         return nodes;
     }

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

@@ -5,6 +5,6 @@ export class DefaultTextStyleRenderer {
     static async render(element, objectManager) {
         const { child } = element.getProps();
         const renderer = RendererRegistry.getRenderer(child);
-        return renderer ? await renderer(child, objectManager) : [];
+        return renderer(child, objectManager);
     }
 }

package/dist/renderer/deferred-renderer.js

@@ -5,6 +5,6 @@ export class DeferredRenderer {
         if (!composed)
             return [];
         const renderer = RendererRegistry.getRenderer(composed);
-        return renderer ? renderer(composed, objectManager) : [];
+        return renderer(composed, objectManager);
     }
 }

package/dist/renderer/expanded-renderer.js

@@ -3,6 +3,6 @@ export class ExpandedRenderer {
     static async render(expandedElement, objectManager) {
         const { child } = expandedElement.getProps();
         const renderer = RendererRegistry.getRenderer(child);
-        return renderer ? await renderer(child, objectManager) : [];
+        return renderer(child, objectManager);
     }
 }

package/dist/renderer/index.d.ts

@@ -8,3 +8,5 @@ export * from "./text-renderer.js";
 export * from "./expanded-renderer.js";
 export * from "./line-renderer.js";
 export * from "./row-renderer.js";
+export * from "./svg-renderer.js";
+export * from "./canvas-renderer.js";

package/dist/renderer/index.js

@@ -8,3 +8,5 @@ export * from "./text-renderer.js";
 export * from "./expanded-renderer.js";
 export * from "./line-renderer.js";
 export * from "./row-renderer.js";
+export * from "./svg-renderer.js";
+export * from "./canvas-renderer.js";

package/dist/renderer/keep-together-renderer.js

@@ -7,6 +7,6 @@ export class KeepTogetherRenderer {
     static async render(group, objectManager) {
         const { child } = group.getProps();
         const renderer = RendererRegistry.getRenderer(child);
-        return renderer ? await renderer(child, objectManager) : [];
+        return renderer(child, objectManager);
     }
 }

package/dist/renderer/link-renderer.js

@@ -3,7 +3,7 @@ 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) : [];
+        const childNodes = 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/padding-renderer.js

@@ -3,6 +3,6 @@ export class PaddingRenderer {
     static async render(paddingElement, objectManager) {
         const { child } = paddingElement.getProps();
         const renderer = RendererRegistry.getRenderer(child);
-        return renderer ? await renderer(child, objectManager) : [];
+        return renderer(child, objectManager);
     }
 }

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

@@ -6,6 +6,6 @@ export class PageBuilderRenderer {
         if (!composed)
             return [];
         const renderer = RendererRegistry.getRenderer(composed);
-        return renderer ? renderer(composed, objectManager) : [];
+        return renderer(composed, objectManager);
     }
 }

package/dist/renderer/page-renderer.js

@@ -21,9 +21,7 @@ export class PageRenderer {
         const nodes = [];
         for (const element of renderables) {
             const renderer = RendererRegistry.getRenderer(element);
-            if (renderer) {
-                nodes.push(...(await renderer(element, objectManager)));
-            }
+            nodes.push(...(await renderer(element, objectManager)));
         }
         // Accessible tagging: one struct context per page (allocates its StructParents index), threaded into
         // serialize so each drawable node is wrapped in marked content. Undefined = tagging off (byte-identical).