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

package/dist/canvas/painter.js

@@ -0,0 +1,183 @@
+import { toColor } from "../api/color.js";
+import { isGradientInput, resolveGradient } from "../api/gradient.js";
+import { pathData } from "../svg/shapes.js";
+import { boundsOf, quadToCubic } from "../vector/path.js";
+const DEGREES = Math.PI / 180;
+export class CanvasPainter {
+    constructor(size) {
+        this.size = size;
+        /** The nodes drawn so far, in order. */
+        this.nodes = [];
+        /** The path being built. Emptied by every painting call, so a shape cannot leak into the next. */
+        this.current = [];
+        this.cursor = [0, 0];
+        this.start = [0, 0];
+    }
+    /** Everything drawn, for the renderer. */
+    drawn() {
+        return this.nodes;
+    }
+    // --- building a path ---------------------------------------------------------------------------
+    move(x, y) {
+        this.current.push({ op: "m", x, y });
+        this.cursor = [x, y];
+        this.start = [x, y];
+        return this;
+    }
+    line(x, y) {
+        this.current.push({ op: "l", x, y });
+        this.cursor = [x, y];
+        return this;
+    }
+    /** A cubic Bézier - the curve PDF draws natively. */
+    curve(x1, y1, x2, y2, x, y) {
+        this.current.push({ op: "c", x1, y1, x2, y2, x, y });
+        this.cursor = [x, y];
+        return this;
+    }
+    /** A quadratic Bézier. PDF has no operator for one, so it is raised to a cubic exactly. */
+    quad(cx, cy, x, y) {
+        this.current.push(quadToCubic(this.cursor[0], this.cursor[1], cx, cy, x, y));
+        this.cursor = [x, y];
+        return this;
+    }
+    close() {
+        this.current.push({ op: "z" });
+        this.cursor = [...this.start];
+        return this;
+    }
+    rect(x, y, width, height) {
+        return this.move(x, y)
+            .line(x + width, y)
+            .line(x + width, y + height)
+            .line(x, y + height)
+            .close();
+    }
+    circle(cx, cy, r) {
+        return this.ellipse(cx, cy, r, r);
+    }
+    /** Four cubics; the constant is the standard circle-to-Bézier one. */
+    ellipse(cx, cy, rx, ry) {
+        const k = 0.5522847498307936;
+        const [ox, oy] = [rx * k, ry * k];
+        return this.move(cx - rx, cy)
+            .curve(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry)
+            .curve(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy)
+            .curve(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry)
+            .curve(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy)
+            .close();
+    }
+    polygon(points) {
+        if (points.length === 0)
+            return this;
+        this.move(points[0][0], points[0][1]);
+        for (const [x, y] of points.slice(1))
+            this.line(x, y);
+        return this.close();
+    }
+    /** SVG path data, through the same reader `Svg()` uses - arcs and shorthands included. */
+    path(d) {
+        const parsed = pathData(d);
+        this.current.push(...parsed);
+        // Where the pen ends up: after a `z` it is back at that subpath's `m`, not at the last point.
+        for (const cmd of parsed) {
+            if (cmd.op === "m")
+                this.start = [cmd.x, cmd.y];
+            this.cursor = cmd.op === "z" ? [...this.start] : [cmd.x, cmd.y];
+        }
+        return this;
+    }
+    // --- painting it -------------------------------------------------------------------------------
+    /** Fills the path built so far and starts a new one. Default black, as in SVG and PDF. */
+    fill(paint = "black", options = {}) {
+        return this.paint(this.resolve(paint), undefined, options.rule);
+    }
+    /** Strokes the path built so far and starts a new one. */
+    stroke(color = "black", options = {}) {
+        return this.paint(undefined, this.strokeStyle(color, options));
+    }
+    fillAndStroke(paint, color, options = {}) {
+        return this.paint(this.resolve(paint), this.strokeStyle(color, options), options.rule);
+    }
+    // --- scopes, instead of save/restore -----------------------------------------------------------
+    /**
+     * Draws inside a transform. It closes itself, so there is no `restore()` to forget - and a nested
+     * `group` composes, exactly like a `<g transform>` in SVG.
+     */
+    group(transform, draw) {
+        this.assertNoPendingPath("group");
+        const matrix = this.matrixOf(transform);
+        this.nodes.push({ type: "transform-push", matrix });
+        draw(this);
+        this.assertNoPendingPath("group");
+        this.nodes.push({ type: "transform-pop" });
+        return this;
+    }
+    /**
+     * Draws clipped to a path. `build` draws the clip shape (nothing is painted from it), `draw` draws
+     * what the clip applies to.
+     */
+    clipped(build, draw, options = {}) {
+        this.assertNoPendingPath("clipped");
+        build(this);
+        const commands = this.current;
+        this.current = [];
+        this.nodes.push({ type: "clip-path-push", commands, fillRule: options.rule });
+        draw(this);
+        this.assertNoPendingPath("clipped");
+        this.nodes.push({ type: "clip-pop" });
+        return this;
+    }
+    // --- internals ---------------------------------------------------------------------------------
+    paint(fill, stroke, rule) {
+        const commands = this.current;
+        this.current = [];
+        if (commands.length === 0)
+            return this;
+        this.nodes.push({ type: "path", commands, fill, fillRule: rule, stroke });
+        return this;
+    }
+    /**
+     * A path may not cross the edge of a scope. It would be built in one coordinate space and painted
+     * in another, and the version that just dropped it made a shape vanish without a word - exactly
+     * the silence this codebase refuses everywhere else.
+     */
+    assertNoPendingPath(scope) {
+        if (this.current.length === 0)
+            return;
+        this.current = [];
+        throw new Error(`@jasy/pdf: a Canvas path was built but never filled or stroked around \`${scope}()\`. ` +
+            `Paint it before the scope opens, or move the drawing inside it.`);
+    }
+    resolve(paint) {
+        if (isGradientInput(paint)) {
+            const box = boundsOf(this.current);
+            return resolveGradient(paint, box.x, box.y, box.width, box.height);
+        }
+        return toColor(paint);
+    }
+    strokeStyle(color, options) {
+        return {
+            color: toColor(color),
+            width: options.width ?? 1,
+            cap: options.cap,
+            join: options.join,
+            miterLimit: options.miterLimit,
+            dash: options.dash,
+            dashOffset: options.dashOffset,
+        };
+    }
+    matrixOf(t) {
+        const [ox, oy] = t.origin ?? [0, 0];
+        const [sx, sy] = Array.isArray(t.scale) ? t.scale : [t.scale ?? 1, t.scale ?? 1];
+        const theta = (t.rotate ?? 0) * DEGREES;
+        const [cos, sin] = [Math.cos(theta), Math.sin(theta)];
+        // T(translate) · T(origin) · R · S · T(-origin), written out as a PDF `cm` operand.
+        const [a, b, c, d] = [cos * sx, sin * sx, -sin * sy, cos * sy];
+        const [tx, ty] = t.translate ?? [0, 0];
+        // `-sin(0)` is -0, which is a surprising value to read back out of a matrix. It writes as
+        // "0.000" either way, so normalising costs nothing and keeps the number predictable.
+        const zero = (n) => (n === 0 ? 0 : n);
+        return [a, b, c, d, tx + ox - (a * ox + c * oy), ty + oy - (b * ox + d * oy)].map(zero);
+    }
+}

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

@@ -0,0 +1,38 @@
+import { BoxConstraints, Offset, Size, SizingParams } from "../layout/box-constraints.js";
+import type { CanvasPainter, CanvasSize } from "../canvas/painter.js";
+import { LayoutContext, SizedPDFElement } from "./pdf-element.js";
+/** What the user draws. Runs at RENDER time, once the box is known. */
+export type CanvasPaint = (painter: CanvasPainter, size: CanvasSize) => void;
+interface CanvasElementParams extends SizingParams {
+    paint: CanvasPaint;
+    widthFactor?: number;
+    heightFactor?: number;
+    /** Alternate text (tagged PDF): with it the drawing is a Figure, without it decoration. */
+    alt?: string;
+}
+/**
+ * A box in the layout that the caller draws into.
+ *
+ * It has no children and no intrinsic size, so unlike an image it FILLS what it is offered when no
+ * size is given - there is nothing to derive one from. That is also why the callback is handed the
+ * resolved size: a drawing written against `size.width` works at any box.
+ */
+export declare class CanvasElement extends SizedPDFElement {
+    private paintFn;
+    private alt?;
+    private requested;
+    private sizing;
+    private widthFactor?;
+    private heightFactor?;
+    constructor(params: CanvasElementParams);
+    getProps(): {
+        x: number;
+        y: number;
+        width: number | undefined;
+        height: number | undefined;
+        paint: CanvasPaint;
+        alt: string | undefined;
+    };
+    calculateLayout(constraints: BoxConstraints, offset: Offset, _ctx: LayoutContext): Size;
+}
+export {};

package/dist/elements/canvas-element.js

@@ -0,0 +1,47 @@
+import { extentSpecs, resolveSize, } from "../layout/box-constraints.js";
+import { SizedPDFElement } from "./pdf-element.js";
+/**
+ * A box in the layout that the caller draws into.
+ *
+ * It has no children and no intrinsic size, so unlike an image it FILLS what it is offered when no
+ * size is given - there is nothing to derive one from. That is also why the callback is handed the
+ * resolved size: a drawing written against `size.width` works at any box.
+ */
+export class CanvasElement extends SizedPDFElement {
+    constructor(params) {
+        super({ x: 0, y: 0, width: params.width, height: params.height });
+        const { paint, alt, widthFactor, heightFactor, ...sizing } = params;
+        this.paintFn = paint;
+        this.alt = alt;
+        this.widthFactor = widthFactor;
+        this.heightFactor = heightFactor;
+        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,
+            paint: this.paintFn,
+            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);
+        const bounds = resolved.constraints;
+        this.width = resolved.width ?? (bounds.hasBoundedWidth ? bounds.maxWidth : 0);
+        this.height = resolved.height ?? (bounds.hasBoundedHeight ? bounds.maxHeight : 0);
+        return { width: this.width, height: this.height };
+    }
+}

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

@@ -74,6 +74,8 @@ export declare class ContainerElement extends SizedPDFElement implements Fragmen
      * every existing layout untouched.
      */
     needsBoundedMain(horizontal: boolean): boolean;
+    /** A Column stacks vertically, so widths overlap and heights add up. */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     getProps(): ContainerElementParams;
 }

package/dist/elements/container-element.js

@@ -1,4 +1,5 @@
 import { FlexLayoutHelper, VERTICAL_AXIS } from "../utils/flex-layout.js";
+import { stackMinIntrinsic, withDeclaredExtent } from "../layout/min-intrinsic.js";
 import { extentSpecs, resolveSize, } from "../layout/box-constraints.js";
 import { childrenForceBreak, packChildren, } from "../layout/fragmentation.js";
 import { FlexiblePDFElement, SizedPDFElement, } from "./pdf-element.js";
@@ -93,6 +94,11 @@ export class ContainerElement extends SizedPDFElement {
         const ownFlexChild = !horizontal && this.children.some((c) => c instanceof FlexiblePDFElement);
         return ownFlexChild || this.children.some((c) => c.needsBoundedMain(horizontal));
     }
+    /** A Column stacks vertically, so widths overlap and heights add up. */
+    minIntrinsicMain(horizontal, ctx) {
+        const content = stackMinIntrinsic(this.children, this.gap, !horizontal, horizontal, ctx, this.wrap);
+        return withDeclaredExtent(content, horizontal ? this.requested.width : this.requested.height, horizontal ? this.requested.minWidth : this.requested.minHeight);
+    }
     calculateLayout(constraints, offset, ctx) {
         this.x = offset.x;
         this.y = offset.y;

package/dist/elements/index.d.ts

@@ -24,3 +24,5 @@ export * from "./layout/rotated-element.js";
 export * from "./layout/rotated-box-element.js";
 export * from "./line-element.js";
 export * from "./row-element.js";
+export * from "./svg-element.js";
+export * from "./canvas-element.js";

package/dist/elements/index.js

@@ -24,3 +24,5 @@ export * from "./layout/rotated-element.js";
 export * from "./layout/rotated-box-element.js";
 export * from "./line-element.js";
 export * from "./row-element.js";
+export * from "./svg-element.js";
+export * from "./canvas-element.js";

package/dist/elements/layout/expanded-element.d.ts

@@ -10,6 +10,8 @@ export declare class ExpandedElement extends FlexiblePDFElement implements Fragm
     private width;
     private height;
     constructor({ flex, basis, basisFactor, child }: ExpandedElementParams);
+    /** Layout-transparent: the floor is whatever the wrapped child needs. */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     /**
      * When the column paginates, a flex region can't "fill" across pages, so it delegates to

package/dist/elements/layout/expanded-element.js

@@ -11,6 +11,10 @@ export class ExpandedElement extends FlexiblePDFElement {
         this.height = 0;
         this.child = child;
     }
+    /** Layout-transparent: the floor is whatever the wrapped child needs. */
+    minIntrinsicMain(horizontal, ctx) {
+        return this.child.minIntrinsicMain(horizontal, ctx);
+    }
     calculateLayout(constraints, offset, ctx) {
         if (constraints.hasBoundedWidth)
             this.width = constraints.maxWidth;

package/dist/elements/layout/keep-together-element.d.ts

@@ -26,6 +26,8 @@ export declare class KeepTogetherElement extends PDFElement implements Fragmenta
     constructor({ child }: {
         child: PDFElement;
     });
+    /** Layout-transparent: the floor is whatever the wrapped child needs. */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     relativeSizeFactor(horizontal: boolean): number | undefined;
     needsBoundedMain(horizontal: boolean): boolean;

package/dist/elements/layout/keep-together-element.js

@@ -26,6 +26,10 @@ export class KeepTogetherElement extends PDFElement {
         this.warnedBreakConflict = false;
         this.child = child;
     }
+    /** Layout-transparent: the floor is whatever the wrapped child needs. */
+    minIntrinsicMain(horizontal, ctx) {
+        return this.child.minIntrinsicMain(horizontal, ctx);
+    }
     calculateLayout(constraints, offset, ctx) {
         return this.child.calculateLayout(constraints, offset, ctx);
     }

package/dist/elements/layout/padding-element.d.ts

@@ -21,6 +21,11 @@ export declare class PaddingElement extends SizedPDFElement implements Fragmenta
     breaksBefore(): boolean;
     breaksAfter(): boolean;
     private cloneWithChild;
+    /**
+     * The child plus our own insets. A PERCENTAGE inset counts as zero here: it resolves against a width
+     * that is not decided yet, which is exactly how CSS treats a percentage when sizing intrinsically.
+     */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     getProps(): {
         x: number;

package/dist/elements/layout/padding-element.js

@@ -43,6 +43,14 @@ export class PaddingElement extends SizedPDFElement {
     cloneWithChild(child) {
         return new PaddingElement({ margin: this.margin, child });
     }
+    /**
+     * The child plus our own insets. A PERCENTAGE inset counts as zero here: it resolves against a width
+     * that is not decided yet, which is exactly how CSS treats a percentage when sizing intrinsically.
+     */
+    minIntrinsicMain(horizontal, ctx) {
+        const [top, right, bottom, left] = resolveEdges(this.margin, 0);
+        return (this.child.minIntrinsicMain(horizontal, ctx) + (horizontal ? left + right : top + bottom));
+    }
     calculateLayout(constraints, offset, ctx) {
         // Padding takes the width it is offered; its height shrink-wraps the child.
         if (constraints.hasBoundedWidth)

package/dist/elements/layout/struct-group.d.ts

@@ -16,6 +16,8 @@ export declare class StructGroup extends PDFElement implements Fragmentable {
         role: string;
         child: PDFElement;
     });
+    /** Layout-transparent: the floor is whatever the wrapped child needs. */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     /** Only splittable when the wrapped child is - so a StructGroup(Row) is moved whole to the next page,
      *  not clipped at the boundary (isFragmentable honours this veto). */

package/dist/elements/layout/struct-group.js

@@ -14,6 +14,10 @@ export class StructGroup extends PDFElement {
         this.role = role;
         this.child = child;
     }
+    /** Layout-transparent: the floor is whatever the wrapped child needs. */
+    minIntrinsicMain(horizontal, ctx) {
+        return this.child.minIntrinsicMain(horizontal, ctx);
+    }
     calculateLayout(constraints, offset, ctx) {
         return this.child.calculateLayout(constraints, offset, ctx);
     }

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

@@ -95,6 +95,17 @@ export declare abstract class PDFElement {
      * the parent hands it the line's bounded main extent instead of `Infinity`. Default: no.
      */
     needsBoundedMain(_horizontal: boolean): boolean;
+    /**
+     * The smallest main-axis extent this element can be squeezed into and still hold its content - CSS's
+     * `min-content` size, which is what an automatic `min-width` resolves to on a flex item. The shrink
+     * pass floors every child at this value, so a line that overflows badly stops squeezing rather than
+     * grinding a paragraph down to one word per line (which would only trade a wide box for a tall one).
+     *
+     * `horizontal` = the width. Default 0: an element with no opinion may be squeezed to nothing, which
+     * is what an empty box or a plain drawing can do without harm. Text and the layout containers
+     * override it; containers recurse, since a Row is only as unsqueezable as its children.
+     */
+    minIntrinsicMain(_horizontal: boolean, _ctx: LayoutContext): number;
     /**
      * Whether this element IS a forced page break (a `PageBreak`). The pagination packer cuts the flow
      * at such a marker: everything before it stays, everything after starts a new page. Default: no.
@@ -135,9 +146,14 @@ export declare abstract class PDFElement {
     order: number;
     /**
      * How willingly this child gives up main-axis space when the line overflows (CSS `flex-shrink`),
-     * weighted by its own size as CSS does. **Default 0, deliberately unlike CSS's 1**: shrinking is a
-     * change of what a document LOOKS like, and every document written before this existed must keep
-     * laying out exactly as it did. Opt in per child.
+     * weighted by its own size as CSS does. Default 1, as in CSS: an overflowing line squeezes its
+     * children back inside instead of letting them run past the edge of the box. `0` opts out and keeps
+     * a child at its natural size.
+     *
+     * This was 0 until the alpha, so that adding flexShrink could not move an existing layout. That
+     * caution outlived its use: four of the gallery cases turned out to be overflowing their page
+     * margin without anyone noticing, because nothing ever pulled them back. Shrinking is bounded from
+     * below by `minIntrinsicMain`, so a child is never squeezed past what it can actually hold.
      */
     flexShrink: number;
     /** Sets `flexShrink` and returns the element. */

package/dist/elements/pdf-element.js

@@ -13,11 +13,16 @@ export class PDFElement {
         this.order = 0;
         /**
          * How willingly this child gives up main-axis space when the line overflows (CSS `flex-shrink`),
-         * weighted by its own size as CSS does. **Default 0, deliberately unlike CSS's 1**: shrinking is a
-         * change of what a document LOOKS like, and every document written before this existed must keep
-         * laying out exactly as it did. Opt in per child.
+         * weighted by its own size as CSS does. Default 1, as in CSS: an overflowing line squeezes its
+         * children back inside instead of letting them run past the edge of the box. `0` opts out and keeps
+         * a child at its natural size.
+         *
+         * This was 0 until the alpha, so that adding flexShrink could not move an existing layout. That
+         * caution outlived its use: four of the gallery cases turned out to be overflowing their page
+         * margin without anyone noticing, because nothing ever pulled them back. Shrinking is bounded from
+         * below by `minIntrinsicMain`, so a child is never squeezed past what it can actually hold.
          */
-        this.flexShrink = 0;
+        this.flexShrink = 1;
     }
     get structId() {
         return this._structId;
@@ -46,6 +51,19 @@ export class PDFElement {
     needsBoundedMain(_horizontal) {
         return false;
     }
+    /**
+     * The smallest main-axis extent this element can be squeezed into and still hold its content - CSS's
+     * `min-content` size, which is what an automatic `min-width` resolves to on a flex item. The shrink
+     * pass floors every child at this value, so a line that overflows badly stops squeezing rather than
+     * grinding a paragraph down to one word per line (which would only trade a wide box for a tall one).
+     *
+     * `horizontal` = the width. Default 0: an element with no opinion may be squeezed to nothing, which
+     * is what an empty box or a plain drawing can do without harm. Text and the layout containers
+     * override it; containers recurse, since a Row is only as unsqueezable as its children.
+     */
+    minIntrinsicMain(_horizontal, _ctx) {
+        return 0;
+    }
     /**
      * Whether this element IS a forced page break (a `PageBreak`). The pagination packer cuts the flow
      * at such a marker: everything before it stays, everything after starts a new page. Default: no.

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

@@ -78,6 +78,8 @@ export declare class RectangleElement extends SizedPDFElement implements Fragmen
      *  `Spacer` in a box can only resolve if the box itself was given a bounded extent to pass down. With an
      *  explicit size on an axis the box already knows its extent there and asks for nothing. */
     needsBoundedMain(horizontal: boolean): boolean;
+    /** A Box stacks its children vertically inside its border, which is on both sides of the axis. */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     getProps(): {
         x: number;

package/dist/elements/rectangle-element.js

@@ -1,5 +1,6 @@
 import { Color } from "../common/color.js";
 import { BoxConstraints, extentSpecs, resolveSize, } from "../layout/box-constraints.js";
+import { stackMinIntrinsic, withDeclaredExtent } from "../layout/min-intrinsic.js";
 import { childrenForceBreak, packChildren, } from "../layout/fragmentation.js";
 import { SizedPDFElement, } from "./pdf-element.js";
 export class RectangleElement extends SizedPDFElement {
@@ -99,6 +100,11 @@ export class RectangleElement extends SizedPDFElement {
             return false;
         return this.children.some((c) => c.needsBoundedMain(horizontal));
     }
+    /** A Box stacks its children vertically inside its border, which is on both sides of the axis. */
+    minIntrinsicMain(horizontal, ctx) {
+        const content = stackMinIntrinsic(this.children, 0, !horizontal, horizontal, ctx) + 2 * this.borderWidth;
+        return withDeclaredExtent(content, horizontal ? this.sizeMemory.width : this.sizeMemory.height, horizontal ? this.sizeMemory.minWidth : this.sizeMemory.minHeight);
+    }
     calculateLayout(constraints, offset, ctx) {
         // An explicit extent is a fixed point size or a fraction of the offered box (relative sizing);
         // the fraction only resolves in a bounded region. `undefined` = fill / shrink-wrap below.

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

@@ -65,6 +65,8 @@ export declare class RowElement extends SizedPDFElement {
     /** 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: boolean): boolean;
+    /** A Row lays out side by side, so widths add up (gaps included) and heights overlap. */
+    minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     getProps(): {
         x: number;

package/dist/elements/row-element.js

@@ -1,5 +1,6 @@
 import { extentSpecs, resolveSize, } from "../layout/box-constraints.js";
 import { FlexLayoutHelper, HORIZONTAL_AXIS } from "../utils/flex-layout.js";
+import { stackMinIntrinsic, withDeclaredExtent } from "../layout/min-intrinsic.js";
 import { FlexiblePDFElement, SizedPDFElement, } from "./pdf-element.js";
 /**
  * Horizontal stack: the mirror of `ContainerElement` (Column). Children are laid out
@@ -47,6 +48,11 @@ export class RowElement extends SizedPDFElement {
         const ownFlexChild = horizontal && this.children.some((c) => c instanceof FlexiblePDFElement);
         return ownFlexChild || this.children.some((c) => c.needsBoundedMain(horizontal));
     }
+    /** A Row lays out side by side, so widths add up (gaps included) and heights overlap. */
+    minIntrinsicMain(horizontal, ctx) {
+        const content = stackMinIntrinsic(this.children, this.gap, horizontal, horizontal, ctx, this.wrap);
+        return withDeclaredExtent(content, horizontal ? this.requested.width : this.requested.height, horizontal ? this.requested.minWidth : this.requested.minHeight);
+    }
     calculateLayout(constraints, offset, ctx) {
         this.x = offset.x;
         this.y = offset.y;

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

@@ -0,0 +1,41 @@
+import { type SvgSize } from "../svg/index.js";
+import { BoxConstraints, Offset, Size, SizingParams } from "../layout/box-constraints.js";
+import { LayoutContext, SizedPDFElement } from "./pdf-element.js";
+/** Markup, a file path (Node only), or the file's bytes. */
+export type SvgSource = string | Uint8Array;
+interface SvgElementParams extends SizingParams {
+    source: SvgSource;
+    /** Width/height as a fraction (0..1) of the offered box, for `"50%"`. */
+    widthFactor?: number;
+    heightFactor?: number;
+    /** Alternate text for the tagged structure tree; makes the drawing a Figure rather than decoration. */
+    alt?: string;
+}
+/**
+ * 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 declare class SvgElement extends SizedPDFElement {
+    private source;
+    private intrinsic;
+    private alt?;
+    private requested;
+    private sizing;
+    private widthFactor?;
+    private heightFactor?;
+    constructor(params: SvgElementParams);
+    getProps(): {
+        x: number;
+        y: number;
+        width: number | undefined;
+        height: number | undefined;
+        source: string;
+        intrinsic: SvgSize;
+        alt: string | undefined;
+    };
+    calculateLayout(constraints: BoxConstraints, offset: Offset, _ctx: LayoutContext): Size;
+}
+export {};