@jasy/pdf 1.0.0-alpha.8 → 1.0.0-alpha.9

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

@@ -1,6 +1,8 @@
 import { Color } from "../common/color.js";
 import { FontStyle } from "../utils/pdf-object-manager.js";
 import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import type { Direction } from "../text/bidi.js";
+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";
@@ -9,6 +11,8 @@ export interface TextSegment {
     fontStyle?: FontStyle;
     fontColor?: Color;
     fontFamily?: string;
+    /** The rest of the family stack for THIS run; unset inherits the Text's own. */
+    fontFallback?: string[];
     fontSize?: number;
     /** External URL: this segment becomes an inline hyperlink (a /Link annotation over its glyphs). */
     href?: string;
@@ -19,7 +23,17 @@ export interface TextSegment {
     strikethrough?: boolean;
     /** Extra space after every glyph, in points; unset inherits the Text's own value. */
     letterSpacing?: number;
+    /**
+     * CSS `vertical-align`, for a footnote marker or a formula index. Shifts THIS run's baseline;
+     * it does not resize the text, and it does not change the line's height - set `fontSize` yourself
+     * for the smaller look a browser's `<sup>` gets from its default stylesheet.
+     */
+    verticalAlign?: VerticalTextAlign;
 }
+/** How far a run sits off the baseline, as a fraction of its font size (up is positive). */
+export declare const VERTICAL_TEXT_SHIFT: Record<VerticalTextAlign, number>;
+/** CSS `vertical-align`, the three values that mean something for a run of text. */
+export type VerticalTextAlign = "baseline" | "super" | "sub";
 /** 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 {
@@ -27,12 +41,18 @@ interface TextElementParams {
     /** Unset (undefined) inherits the cascaded size; see ResolvedTextStyle. */
     fontSize?: number;
     fontFamily?: string;
+    /** The rest of the family stack, for code points `fontFamily` cannot draw. */
+    fontFallback?: string[];
     fontStyle?: FontStyle;
     content: string | TextSegment[];
     color?: Color;
     textAlignment?: HorizontalAlignment;
     /** Cap the wrapped lines (default: unlimited / open-end). */
     maxLines?: number;
+    /** Minimum lines that must stay behind at a page break (CSS `orphans`, default 2). */
+    orphans?: number;
+    /** Minimum lines that must carry over to the next page (CSS `widows`, default 2). */
+    widows?: number;
     /** What to do past `maxLines`: `"clip"` (default) drops them, `"ellipsis"` ends with "…". */
     overflow?: TextOverflow;
     /** Line-height multiplier: each line is `fontSize * lineHeight` tall. Unset means the font's
@@ -46,6 +66,14 @@ interface TextElementParams {
     skipInk?: boolean;
     /** Extra space after every glyph, in points (CSS `letter-spacing`). Default 0. */
     letterSpacing?: number;
+    /** Base writing direction (CSS `direction`); decides where a line starts. Default `"ltr"`. */
+    direction?: Direction;
+    /** CSS `text-transform`; applied before the text is measured or drawn. */
+    textTransform?: TextTransform;
+    /** CSS `word-spacing`, in points: extra advance at every space. */
+    wordSpacing?: number;
+    /** CSS `text-indent`, in points: how far the first line starts in. */
+    textIndent?: number;
     /** Accessibility role for the tagged structure tree (heading level or paragraph; default `"p"`). */
     role?: TextRole;
 }
@@ -60,6 +88,11 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private readonly rawStrikethrough?;
     private readonly rawSkipInk?;
     private readonly rawLetterSpacing?;
+    private readonly rawDirection?;
+    private readonly rawFontFallback?;
+    private readonly rawTextTransform?;
+    private readonly rawWordSpacing?;
+    private readonly rawTextIndent?;
     private fontSize;
     private fontFamily;
     private fontStyle;
@@ -70,12 +103,31 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private strikethrough;
     private skipInk;
     private letterSpacing;
+    private direction;
+    private fontFallback;
+    private resolved?;
+    private textTransform;
+    private wordSpacing;
+    private textIndent;
     private content;
     private maxLines?;
+    private orphans?;
+    private widows?;
     private overflow;
     private readonly role?;
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, role, }: TextElementParams);
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, 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. */
+    /**
+     * The content as it is measured AND drawn - `text-transform` applied. One place, so a recased
+     * paragraph can never be measured in one casing and drawn in another (`ABC` and `abc` are not the
+     * same width in most fonts).
+     */
+    private display;
+    /** The content with `text-transform` applied, and nothing else. */
+    private recased;
+    private lineOptions;
     private applyStyle;
     /**
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
@@ -86,6 +138,8 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
     private fragmentString;
     private fragmentSegments;
+    /** The orphan/widow minimums for this paragraph; unset means the CSS default of 2 lines each. */
+    private breakRule;
     private cloneWithContent;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
     /** The unwrapped single-line width of the content (used when width is unbounded, e.g. inside a Row).
@@ -109,12 +163,17 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
         content: string | TextSegment[];
         textAlignment: HorizontalAlignment;
         maxLines: number | undefined;
+        orphans: number | undefined;
+        widows: number | undefined;
         overflow: TextOverflow;
         lineHeight: number | undefined;
         underline: boolean;
         strikethrough: boolean;
         skipInk: boolean;
         letterSpacing: number;
+        direction: Direction;
+        wordSpacing: number;
+        textIndent: number;
         role: TextRole | undefined;
     };
 }

package/dist/elements/text-element.js

@@ -4,12 +4,31 @@
 // breaks the constructor-keyed RendererRegistry. A direct import keeps the graph acyclic.
 import { TextRenderer } from "../renderer/text-renderer.js";
 import { DEFAULT_TEXT_STYLE } from "../text/text-style.js";
-import { wrapStringIntoLines, breakSegmentsIntoLines, segmentLinesToSegments, } from "../text/line-breaker.js";
+import { applyTextTransform } from "../text/text-style.js";
+import { splitByFont } from "../text/font-fallback.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 { runAdvance } from "../text/advance.js";
-import { SizedPDFElement } from "./pdf-element.js";
+import { HorizontalAlignment, SizedPDFElement } from "./pdf-element.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,
+    super: 1 / 3,
+    sub: -1 / 5,
+};
+/**
+ * A measurement in points has to be a real number. A NaN or an Infinity would travel all the way into
+ * the content stream as a position - the backend refuses it there, but by then the message names a
+ * coordinate rather than the property that was wrong. Rejected here, where the caller can see it.
+ */
+function finitePoints(value, name) {
+    if (value !== undefined && !Number.isFinite(value)) {
+        throw new Error(`@jasy/pdf: Invalid ${name} ${value}: it must be a finite number of points.`);
+    }
+    return value;
+}
 export class TextElement extends SizedPDFElement {
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow = "clip", lineHeight, underline, strikethrough, skipInk, letterSpacing, role, }) {
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow = "clip", lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, role, }) {
         super({ x: 0, y: 0 });
         this.role = role;
         this.rawFontSize = fontSize;
@@ -22,8 +41,15 @@ export class TextElement extends SizedPDFElement {
         this.rawStrikethrough = strikethrough;
         this.rawSkipInk = skipInk;
         this.rawLetterSpacing = letterSpacing;
+        this.rawDirection = direction;
+        this.rawFontFallback = fontFallback;
+        this.rawTextTransform = textTransform;
+        this.rawWordSpacing = finitePoints(wordSpacing, "wordSpacing");
+        this.rawTextIndent = finitePoints(textIndent, "textIndent");
         this.content = content;
         this.maxLines = maxLines;
+        this.orphans = orphans;
+        this.widows = widows;
         this.overflow = overflow;
         this.applyStyle(DEFAULT_TEXT_STYLE);
     }
@@ -31,6 +57,57 @@ export class TextElement extends SizedPDFElement {
     resolveStyle(ctx) {
         this.applyStyle(ctx.textStyle ?? DEFAULT_TEXT_STYLE);
     }
+    /** 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. */
+    /**
+     * The content as it is measured AND drawn - `text-transform` applied. One place, so a recased
+     * paragraph can never be measured in one casing and drawn in another (`ABC` and `abc` are not the
+     * same width in most fonts).
+     */
+    display(metrics) {
+        const cased = this.recased();
+        // 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)
+            return cased;
+        // 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;
+        const out = [];
+        for (const seg of pieces) {
+            const runs = splitByFont(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontFallback ?? this.fontFallback, seg.fontStyle ?? this.fontStyle, metrics);
+            if (!runs)
+                out.push(seg);
+            else
+                for (const run of runs)
+                    out.push({ ...seg, content: run.text, fontFamily: run.fontFamily });
+        }
+        return out;
+    }
+    /** The content with `text-transform` applied, and nothing else. */
+    recased() {
+        if (this.textTransform === "none")
+            return this.content;
+        if (typeof this.content === "string") {
+            return applyTextTransform(this.content, this.textTransform).text;
+        }
+        // The capitalisation state runs THROUGH the spans: `span("hel") + span("lo")` is one word.
+        let atWordStart = true;
+        return this.content.map((seg) => {
+            const done = applyTextTransform(seg.content, this.textTransform, atWordStart);
+            atWordStart = done.atWordStart;
+            return { ...seg, content: done.text };
+        });
+    }
+    lineOptions() {
+        return {
+            wordSpacing: this.wordSpacing,
+            indent: this.textIndent,
+            // Justified lines may be squeezed to keep a word; every other alignment gets no slack.
+            shrink: this.textAlignment === HorizontalAlignment.justify ? MAX_SPACE_SHRINK : 0,
+        };
+    }
     applyStyle(ts) {
         this.fontSize = this.rawFontSize ?? ts.fontSize;
         this.fontFamily = this.rawFontFamily ?? ts.fontFamily;
@@ -42,6 +119,11 @@ export class TextElement extends SizedPDFElement {
         this.strikethrough = this.rawStrikethrough ?? ts.strikethrough;
         this.skipInk = this.rawSkipInk ?? ts.skipInk;
         this.letterSpacing = this.rawLetterSpacing ?? ts.letterSpacing;
+        this.direction = this.rawDirection ?? ts.direction;
+        this.fontFallback = this.rawFontFallback ?? ts.fontFallback;
+        this.textTransform = this.rawTextTransform ?? ts.textTransform;
+        this.wordSpacing = this.rawWordSpacing ?? ts.wordSpacing;
+        this.textIndent = this.rawTextIndent ?? ts.textIndent;
     }
     /**
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
@@ -51,23 +133,25 @@ export class TextElement extends SizedPDFElement {
      */
     fragment(maxHeight, width, ctx) {
         this.resolveStyle(ctx);
-        return typeof this.content === "string"
-            ? this.fragmentString(this.content, maxHeight, width, ctx)
-            : this.fragmentSegments(this.content, maxHeight, width, ctx);
+        const content = this.display(ctx.metrics);
+        return typeof content === "string"
+            ? this.fragmentString(content, maxHeight, width, ctx)
+            : this.fragmentSegments(content, maxHeight, width, ctx);
     }
     // Plain string: every wrapped line gets the same box (the same one calculateTextHeight uses),
     // so `floor(maxHeight / lineBox)` lines fit.
     fragmentString(content, maxHeight, width, ctx) {
-        const lines = wrapStringIntoLines(content, this.fontFamily, this.fontSize, this.fontStyle, width, ctx.metrics, this.maxLines, this.overflow, this.letterSpacing);
+        const lines = wrapStringIntoLines(content, this.fontFamily, this.fontSize, this.fontStyle, width, ctx.metrics, this.maxLines, this.overflow, this.letterSpacing, this.lineOptions());
         const box = lineBoxForString(ctx.metrics, this.fontFamily, this.fontStyle, this.fontSize, this.lineHeight);
-        const fittedLineCount = Math.floor(maxHeight / box.height);
+        const fittedLineCount = adjustForOrphansWidows(Math.floor(maxHeight / box.height), lines.length, this.breakRule());
         if (fittedLineCount <= 0)
             return { fitted: null, remainder: this };
         if (fittedLineCount >= lines.length)
             return { fitted: this, remainder: null };
         return {
             fitted: this.cloneWithContent(lines.slice(0, fittedLineCount).join(" ")),
-            remainder: this.cloneWithContent(lines.slice(fittedLineCount).join(" ")),
+            // A continuation is no longer the paragraph's FIRST line, so it carries no indent.
+            remainder: this.cloneWithContent(lines.slice(fittedLineCount).join(" "), 0),
         };
     }
     // Styled segments: each line's height comes from the fonts on it, so pack lines by cumulative
@@ -78,29 +162,40 @@ export class TextElement extends SizedPDFElement {
             fontSize: this.fontSize,
             fontStyle: this.fontStyle,
             letterSpacing: this.letterSpacing,
+            direction: this.direction,
+            wordSpacing: this.wordSpacing,
+            textIndent: this.textIndent,
         };
         const lines = breakSegmentsIntoLines(content, defaults, width, ctx.metrics, this.maxLines, this.overflow);
         let used = 0;
-        let fittedLineCount = 0;
+        let packed = 0;
         for (const line of lines) {
             const lineBox = lineBoxForSegmentLine(line, defaults, ctx.metrics, this.lineHeight).height;
             if (used + lineBox > maxHeight)
                 break;
             used += lineBox;
-            fittedLineCount++;
+            packed++;
         }
+        const fittedLineCount = adjustForOrphansWidows(packed, lines.length, this.breakRule());
         if (fittedLineCount <= 0)
             return { fitted: null, remainder: this };
         if (fittedLineCount >= lines.length)
             return { fitted: this, remainder: null };
         return {
             fitted: this.cloneWithContent(segmentLinesToSegments(lines.slice(0, fittedLineCount))),
-            remainder: this.cloneWithContent(segmentLinesToSegments(lines.slice(fittedLineCount))),
+            remainder: this.cloneWithContent(segmentLinesToSegments(lines.slice(fittedLineCount)), 0),
+        };
+    }
+    /** The orphan/widow minimums for this paragraph; unset means the CSS default of 2 lines each. */
+    breakRule() {
+        return {
+            orphans: this.orphans ?? DEFAULT_ORPHANS,
+            widows: this.widows ?? DEFAULT_WIDOWS,
         };
     }
     // A copy carrying the same style but different (already-wrapped) content. Re-wrapping at
     // the same width reproduces exactly those lines (greedy is deterministic).
-    cloneWithContent(content) {
+    cloneWithContent(content, indent = this.textIndent) {
         return new TextElement({
             content,
             fontSize: this.fontSize,
@@ -109,12 +204,17 @@ export class TextElement extends SizedPDFElement {
             color: this.color,
             textAlignment: this.textAlignment,
             maxLines: this.maxLines,
+            orphans: this.orphans,
+            widows: this.widows,
             overflow: this.overflow,
             lineHeight: this.lineHeight,
             underline: this.underline,
             strikethrough: this.strikethrough,
             skipInk: this.skipInk,
             letterSpacing: this.letterSpacing,
+            direction: this.direction,
+            wordSpacing: this.wordSpacing,
+            textIndent: indent,
             role: this.role,
         }).adoptStructId(this); // a wrapped remainder is the SAME logical paragraph (one P across pages)
     }
@@ -125,11 +225,12 @@ export class TextElement extends SizedPDFElement {
         // Bounded width (e.g. inside a Column) wraps to that width; an unbounded width
         // (e.g. inside a Row) means the text takes its natural single-line width and does
         // not wrap. Columns always bound the width, so this leaves their layout untouched.
+        this.resolved = this.display(ctx.metrics);
         this.width = constraints.hasBoundedWidth
             ? constraints.maxWidth
             : this.naturalWidth(ctx.metrics);
         const wrapWidth = this.width ?? 0;
-        this.height = TextRenderer.calculateTextHeight(this.content, this.fontSize, this.fontFamily, this.fontStyle, ctx.metrics, wrapWidth, this.maxLines, this.overflow, this.lineHeight, this.letterSpacing);
+        this.height = TextRenderer.calculateTextHeight(this.resolved, this.fontSize, this.fontFamily, this.fontStyle, ctx.metrics, wrapWidth, this.maxLines, this.overflow, this.lineHeight, this.letterSpacing, this.lineOptions());
         // Top-left coordinates (y = top of the text box). The baseline offset and the
         // Y-flip are applied downstream (the line-builder positions baselines, the seam
         // flips to PDF), so the element stays coordinate-system-blind.
@@ -144,24 +245,17 @@ export class TextElement extends SizedPDFElement {
      *  - 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. */
     naturalWidth(metrics) {
-        const oneLine = (text, family, size, style, letterSpacing) => {
-            const font = { fontFamily: family, fontSize: size, fontStyle: style };
-            const words = text.split(" ");
-            const space = runAdvance(metrics, " ", font, letterSpacing);
-            let width = 0;
-            words.forEach((word, i) => {
-                const w = runAdvance(metrics, word, font, letterSpacing);
-                // Group (word + space) as one term, exactly like the breaker - see the note above. Both use
-                // the same `runAdvance`, so the two agree bit for bit even with letterSpacing.
-                width += i < words.length - 1 ? w + space : w;
-            });
-            return width;
-        };
-        if (typeof this.content === "string") {
-            return oneLine(this.content, this.fontFamily, this.fontSize, this.fontStyle, this.letterSpacing);
+        // The breaker's own sum, to the last bit - see `singleLineWidth`.
+        const oneLine = (text, family, size, style, letterSpacing) => singleLineWidth(text, { fontFamily: family, fontSize: size, fontStyle: style }, metrics, letterSpacing, this.wordSpacing);
+        // The FIRST line starts `textIndent` in, so an unbounded box has to be that much wider.
+        const indent = Math.max(0, this.textIndent);
+        const content = this.display(metrics);
+        if (typeof content === "string") {
+            return (indent +
+                oneLine(content, this.fontFamily, this.fontSize, this.fontStyle, this.letterSpacing));
         }
-        return this.content.reduce((sum, seg) => sum +
-            oneLine(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontSize ?? this.fontSize, seg.fontStyle ?? this.fontStyle, seg.letterSpacing ?? this.letterSpacing), 0);
+        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);
     }
     getProps() {
         return {
@@ -173,15 +267,20 @@ export class TextElement extends SizedPDFElement {
             fontFamily: this.fontFamily,
             fontStyle: this.fontStyle,
             color: this.color,
-            content: this.content,
+            content: this.resolved ?? this.content,
             textAlignment: this.textAlignment,
             maxLines: this.maxLines,
+            orphans: this.orphans,
+            widows: this.widows,
             overflow: this.overflow,
             lineHeight: this.lineHeight,
             underline: this.underline,
             strikethrough: this.strikethrough,
             skipInk: this.skipInk,
             letterSpacing: this.letterSpacing,
+            direction: this.direction,
+            wordSpacing: this.wordSpacing,
+            textIndent: this.textIndent,
             role: this.role,
         };
     }

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

@@ -32,6 +32,9 @@ export interface TextRun {
     x: number;
     y: number;
     text: string;
+    /** The glyphs to draw, when the run was SHAPED. The backend emits these instead of encoding `text`,
+     *  which stays logical for `ToUnicode` and the accessible tree. */
+    glyphs?: number[];
     fontFamily: string;
     fontStyle: FontStyle;
     fontSize: number;
@@ -40,17 +43,31 @@ export interface TextRun {
     tag?: StructTag;
 }
 /** An axis-aligned rectangle. An absent `fill` or `stroke` means that part is not drawn. */
+/**
+ * Corner radii in points (CSS `border-radius`). Any corner left out falls back to 0. A single number
+ * everywhere is the common case and stays a plain `number` on the nodes, so nothing changed for a
+ * document that never asks for different corners.
+ */
+export interface Radii {
+    tl?: number;
+    tr?: number;
+    br?: number;
+    bl?: number;
+}
+/** True when any corner asks for a radius - the gate between a plain rect and a curved path. */
+export declare function isRounded(radius: number | Radii | undefined): boolean;
 export interface Rect {
     type: "rect";
     x: number;
     y: number;
     width: number;
     height: number;
-    fill?: Color;
+    /** Solid colour, or a gradient whose anchor points are in absolute page coordinates. */
+    fill?: Color | Gradient;
     stroke?: Color;
     strokeWidth: number;
-    /** Corner radius in points; absent/0 = sharp corners (plain `re`). */
-    radius?: number;
+    /** Corner radius in points - one number for all four, or per corner. Absent/0 = sharp (plain `re`). */
+    radius?: number | Radii;
     tag?: StructTag;
 }
 /** A straight line segment between two points. */
@@ -84,8 +101,8 @@ export interface Image {
         width: number;
         height: number;
     };
-    /** Corner radius in points for the image box; absent/0 = sharp corners. */
-    radius?: number;
+    /** Corner radius in points for the image box - one number or per corner; absent/0 = sharp. */
+    radius?: number | Radii;
     tag?: StructTag;
 }
 /**
@@ -99,7 +116,7 @@ export interface ClipPush {
     y: number;
     width: number;
     height: number;
-    radius?: number;
+    radius?: number | Radii;
 }
 /** Closes the most recent `ClipPush` (restores the graphics state). */
 export interface ClipPop {

package/dist/ir/display-list.js

@@ -1 +1,8 @@
-export {};
+/** True when any corner asks for a radius - the gate between a plain rect and a curved path. */
+export function isRounded(radius) {
+    if (radius === undefined)
+        return false;
+    if (typeof radius === "number")
+        return radius > 0;
+    return ((radius.tl ?? 0) > 0 || (radius.tr ?? 0) > 0 || (radius.br ?? 0) > 0 || (radius.bl ?? 0) > 0);
+}

package/dist/layout/alignment.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Flex alignment vocabulary. It lives here rather than in `utils/flex-layout.ts` because the base
+ * `PDFElement` needs `CrossAlign` for `alignSelf`, and flex-layout imports the elements - defining it
+ * there would close a cycle.
+ */
+/** Distribution along the MAIN axis (CSS `justify-content`). */
+export type MainAlign = "start" | "center" | "end" | "between" | "around";
+/** Position/size ACROSS the axis (CSS `align-items` / `align-self`). `stretch` fills the cross extent;
+ *  the others place the child at its natural cross size. */
+export type CrossAlign = "start" | "center" | "end" | "stretch";

package/dist/layout/alignment.js

@@ -0,0 +1,6 @@
+/**
+ * Flex alignment vocabulary. It lives here rather than in `utils/flex-layout.ts` because the base
+ * `PDFElement` needs `CrossAlign` for `alignSelf`, and flex-layout imports the elements - defining it
+ * there would close a cycle.
+ */
+export {};

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

@@ -41,6 +41,12 @@ export declare class BoxConstraints {
      * what a padding/border element hands its child after reserving its own insets.
      */
     deflate(horizontal: number, vertical: number): BoxConstraints;
+    /**
+     * Tightens this box by an element's own `min`/`max` on either axis. A max never widens the offered
+     * room, and a min may push past it - `minHeight: 500` in a 300pt region means 500, and pagination
+     * deals with the overflow, the same answer CSS gives.
+     */
+    narrow(minWidth?: number, maxWidth?: number, minHeight?: number, maxHeight?: number): BoxConstraints;
     /** Returns the constraints clamped to lie within `parent` (Flutter's enforce). */
     enforce(parent: BoxConstraints): BoxConstraints;
 }
@@ -52,6 +58,53 @@ export declare class BoxConstraints {
  * 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;
+/** What one axis of a sized element was asked for: a size, plus the bounds it must stay inside. */
+export interface ExtentSpec {
+    fixed?: number;
+    factor?: number;
+    min?: number;
+    minFactor?: number;
+    max?: number;
+    maxFactor?: number;
+}
+/** The sizing options every sized element accepts. Each `*Factor` is the percentage form of its pair. */
+export interface SizingParams {
+    width?: number;
+    height?: number;
+    widthFactor?: number;
+    heightFactor?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    minWidthFactor?: number;
+    maxWidthFactor?: number;
+    minHeightFactor?: number;
+    maxHeightFactor?: number;
+    /** width / height. Derives whichever axis is left open; see `resolveSize`. */
+    aspectRatio?: number;
+}
+/** Split `SizingParams` into the per-axis form `resolveSize` takes. */
+export declare function extentSpecs(p: SizingParams): {
+    width: ExtentSpec;
+    height: ExtentSpec;
+};
+/**
+ * Resolve both axes of a sized element: relative sizing, then `aspectRatio`, then `min`/`max`.
+ *
+ * The order follows CSS: a ratio fills in the axis you left open, and min/max clamp afterwards - so an
+ * explicit bound wins over the ratio, exactly as `min-height` beats `aspect-ratio` in a browser.
+ *
+ * `min`/`max` also come back as NARROWED constraints, because an axis with no explicit size still has
+ * to obey them. `maxWidth` alone means "fill, but no wider than this", and the caller's own fill and
+ * shrink-wrap paths get that for free by using the returned constraints instead of the ones passed in.
+ * A `width` of `undefined` keeps its usual meaning: fill or shrink-wrap.
+ */
+export declare function resolveSize(width: ExtentSpec, height: ExtentSpec, aspectRatio: number | undefined, constraints: BoxConstraints): {
+    width?: number;
+    height?: number;
+    constraints: BoxConstraints;
+};
 /** The size an element resolves to and returns UP the tree. */
 export interface Size {
     width: number;