@jasy/pdf 1.0.0-beta.3 → 1.0.0-beta.5

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

@@ -0,0 +1,317 @@
+import { BoxConstraints } from "../../layout/box-constraints.js";
+import { reportClipped } from "../../layout/fragmentation.js";
+import { Diagnostics, pageOf } from "../../common/diagnostics.js";
+import { SizedPDFElement } from "../pdf-element.js";
+import { PageBuilderElement } from "./page-builder-element.js";
+import { RegionElement } from "./region-element.js";
+/** A template with no `Region` would place nothing on every page, forever. */
+export class FlowWithoutRegionError extends Error {
+    constructor() {
+        super("@jasy/pdf: a Flow's template holds no Region, so the content has nowhere to go. Put at least " +
+            "one Region in the template (in @jasy/vue: the #page slot).");
+        this.name = "FlowWithoutRegionError";
+    }
+}
+/** A template that leaves every Region without room, where the Flow cannot move on to find more. */
+export class FlowRegionsEmptyError extends Error {
+    constructor(width, height) {
+        super(`@jasy/pdf: a Flow's template leaves its Regions no room in ${Math.round(width)} x ` +
+            `${Math.round(height)}pt - every Region is 0 wide or 0 tall (too many columns or gaps for the ` +
+            "width, or the rest of the template is taller than the space). Give the Regions room." +
+            (height <= 0
+                ? " In a wrapping Row a line is only as tall as its content - give the Row around the " +
+                    "Flow a height."
+                : ""));
+        this.name = "FlowRegionsEmptyError";
+    }
+}
+/** Laid out with no height to fill: every line would land in the first Region. */
+export class FlowUnboundedError extends Error {
+    constructor() {
+        super("@jasy/pdf: a Flow takes its height from where it sits - the page, or a box with a height. " +
+            "Here it has none (in a Row without a height, for instance). Give the Row or a Box around " +
+            "the Flow a height.");
+        this.name = "FlowUnboundedError";
+    }
+}
+/** A PageBuilder builds again for the page it is drawn on, so Regions inside it lose their content. */
+export class RegionInPageBuilderError extends Error {
+    constructor() {
+        super("@jasy/pdf: a Region inside a PageBuilder - it builds again for the page it is drawn on, and " +
+            "its Regions would come back empty. A Flow's template is built for every page already and " +
+            "gets { index, pageNumber }: build the Regions there.");
+        this.name = "RegionInPageBuilderError";
+    }
+}
+/** The Regions of a laid-out template, in tree order - the order the content flows through them. */
+function regionsIn(root) {
+    const out = [];
+    const visit = (el, built) => {
+        if (el instanceof RegionElement) {
+            if (built)
+                throw new RegionInPageBuilderError();
+            out.push(el);
+        }
+        else {
+            const inBuilder = built || el instanceof PageBuilderElement;
+            for (const child of el.layoutChildren())
+                visit(child, inBuilder);
+        }
+    };
+    visit(root, false);
+    return out;
+}
+const room = (r) => r.getProps().width > 0 && r.getProps().height > 0;
+const SLACK_EPSILON = 1e-6;
+// How close the last page's height gets to the tightest one that holds the content, in points.
+const SHRINK_PRECISION = 0.01;
+/**
+ * One page of a Flow: its template, with each Region holding its content. It is drawn laid out at the
+ * height it was filled at - not at its own size, which a template that does not fill (`50%`) differs from.
+ */
+export class FlowPieceElement extends SizedPDFElement {
+    constructor(template, size, bound, page) {
+        super({ x: 0, y: 0, ...size });
+        this.template = template;
+        this.size = size;
+        this.bound = bound;
+        this.page = page;
+    }
+    calculateLayout(_constraints, offset, ctx) {
+        this.x = offset.x;
+        this.y = offset.y;
+        this.template.calculateLayout(BoxConstraints.loose(this.size.width, this.bound), { x: 0, y: 0 }, { ...ctx, flowPage: this.page });
+        return this.size;
+    }
+    computeSize() {
+        return this.size;
+    }
+    layoutChildren() {
+        return [this.template];
+    }
+    getProps() {
+        return { x: this.x, y: this.y, ...this.size, child: this.template };
+    }
+}
+/**
+ * Content flowing through the Regions of a template, page after page. It has no height of its own -
+ * like an `Expanded`, it takes what it is given: the rest of the page when it is fragmented, the rest
+ * of a box with a height otherwise. On its last page it shrinks to what the content used.
+ */
+export class FlowElement extends SizedPDFElement {
+    constructor({ content, template, index = 0, balance = false, }) {
+        super({ x: 0, y: 0 });
+        this.content = content;
+        this.template = template;
+        this.index = index;
+        this.balance = balance;
+    }
+    needsRegion() {
+        return true;
+    }
+    /** Its height comes from the parent, as an `Expanded`'s does. */
+    needsBoundedMain(horizontal) {
+        return !horizontal;
+    }
+    /** The template is built from the page it lands on. */
+    dependsOnPage() {
+        return true;
+    }
+    fragment(maxHeight, width, ctx) {
+        // Below other content, a template with no room here may find it on the next page.
+        const filled = this.fill(maxHeight, width, ctx, !ctx.belowContent);
+        // Nothing fit: move on whole. On a fresh page the packer forces it on, so this always advances.
+        if (!filled.placed)
+            return { fitted: null, remainder: this };
+        return {
+            fitted: filled.piece,
+            remainder: filled.rest
+                ? new FlowElement({
+                    content: filled.rest,
+                    template: this.template,
+                    index: this.index + 1,
+                    balance: this.balance,
+                })
+                : null,
+            forceBreak: filled.forceBreak,
+        };
+    }
+    calculateLayout(constraints, offset, ctx) {
+        if (!constraints.hasBoundedHeight || !constraints.hasBoundedWidth) {
+            throw new FlowUnboundedError();
+        }
+        this.x = offset.x;
+        this.y = offset.y;
+        const filled = this.fill(constraints.maxHeight, constraints.maxWidth, ctx, true);
+        // Not paginated here (a box with a height): what does not fit is cut, as any overflow is.
+        if (filled.rest) {
+            reportClipped(this, "a Flow has more content than its Regions hold here, and it cannot continue on a next " +
+                "page (it sits in a box with a height) - give the box more height, or let the Flow " +
+                "continue on the page.", ctx);
+        }
+        this.piece = filled.piece;
+        const size = this.piece.calculateLayout(constraints, { x: 0, y: 0 }, ctx);
+        this.width = size.width;
+        this.height = size.height;
+        return size;
+    }
+    /** Unbounded, it has no height of its own (a parent that bounds it asks again); bounded, it fills. */
+    computeSize(constraints, ctx) {
+        if (!constraints.hasBoundedHeight || !constraints.hasBoundedWidth) {
+            return { width: constraints.hasBoundedWidth ? constraints.maxWidth : 0, height: 0 };
+        }
+        return this.fill(constraints.maxHeight, constraints.maxWidth, ctx, false).piece.measure(constraints, ctx);
+    }
+    /**
+     * The one place a page of the Flow is made: the template at `width` x `maxHeight`, the content
+     * fragmented into its Regions in turn, and - when the content ends here - the template shrunk to
+     * what it used, or balanced.
+     */
+    fill(maxHeight, width, ctx, final) {
+        const template = this.template({ index: this.index, pageNumber: pageOf(ctx) ?? 1 });
+        // Laid out as this page of the Flow, its Regions claim themselves - wherever the template made
+        // them, a PageBuilder or a Table included - and are collected from the laid-out tree.
+        const pageCtx = { ...ctx, flowPage: this };
+        const layOut = (height) => template.calculateLayout(BoxConstraints.loose(width, height), { x: 0, y: 0 }, pageCtx);
+        const size = layOut(maxHeight);
+        const regions = regionsIn(template);
+        if (regions.length === 0)
+            throw new FlowWithoutRegionError();
+        // No room here: every Region is empty, or the rest of the template (its height with the Regions
+        // empty) is taller than the space.
+        const own = template.measure(BoxConstraints.loose(width, Infinity), ctx).height;
+        if (own > maxHeight + SLACK_EPSILON || !regions.some(room)) {
+            if (final)
+                throw new FlowRegionsEmptyError(width, maxHeight);
+            const piece = new FlowPieceElement(template, size, maxHeight, this);
+            return { piece, rest: this.content, placed: false, forceBreak: false };
+        }
+        const { rest, placed, forceBreak } = this.pour(regions, ctx);
+        const ends = !rest && placed;
+        const last = !ends
+            ? null
+            : this.balance && regions.filter(room).length > 1
+                ? this.balanced(regions, own, maxHeight, layOut, ctx)
+                : this.shrink(regions, own, maxHeight, layOut, ctx);
+        const piece = last
+            ? new FlowPieceElement(template, last.size, last.bound, this)
+            : new FlowPieceElement(template, size, maxHeight, this);
+        return { piece, rest, placed, forceBreak };
+    }
+    /**
+     * The content fragmented into the laid-out Regions in turn; each holds its piece. `fresh` is how tall
+     * each Region is on a full page - what a block that does not fit here may wait for.
+     */
+    pour(regions, ctx, fresh) {
+        let rest = this.content;
+        let placed = false;
+        let forceBreak = false;
+        for (const region of regions)
+            region.hold(null);
+        for (const region of regions) {
+            if (!rest)
+                break;
+            if (!room(region))
+                continue;
+            const { width: w, height: h } = region.getProps();
+            // Each Region is a fragmentation region of its own: a page break inside it is measured by it.
+            const split = rest.fragment(h, w, {
+                ...ctx,
+                pageBodyHeight: fresh?.get(region) ?? h,
+                inFlowRegion: true,
+                flowPage: undefined,
+            });
+            region.hold(split.fitted);
+            if (split.fitted)
+                placed = true;
+            rest = split.remainder;
+            // A column break is this Flow's: on to the next Region (or the next page's first).
+            if (split.forceBreak === "column")
+                continue;
+            if (split.forceBreak) {
+                forceBreak = true;
+                break;
+            }
+        }
+        return { rest, placed, forceBreak };
+    }
+    /**
+     * The last page, balanced: the smallest height at which the content, poured again, still ends here,
+     * so the Regions come out about equally full. Every candidate is a real pour - breaks,
+     * `keepTogether` and orphans hold as on any page - and the last one poured is the one drawn. A
+     * candidate is silent, and one that had to clip a block it could not break is too low.
+     */
+    balanced(regions, own, maxHeight, layOut, ctx) {
+        const fresh = new Map(regions.map((r) => [r, r.getProps().height]));
+        const endsAt = (bound) => {
+            layOut(bound);
+            let clipped = false;
+            const trial = new Diagnostics();
+            trial.setHandler((d) => (clipped || (clipped = d.code === "overflow-clipped")));
+            const poured = this.pour(regions, { ...ctx, onOverflow: "ignore", diagnostics: trial }, fresh);
+            return !poured.rest && poured.placed && !clipped;
+        };
+        let low = Math.min(maxHeight, own);
+        let high = maxHeight;
+        while (high - low > SHRINK_PRECISION) {
+            const mid = (low + high) / 2;
+            if (endsAt(mid))
+                high = mid;
+            else
+                low = mid;
+        }
+        const size = layOut(high);
+        this.pour(regions, ctx, fresh);
+        return { size, bound: high };
+    }
+    /**
+     * The last page: the smallest height at which every filled Region still holds what it was given.
+     * Only a layout knows how a template's Regions answer a height (`%`, stacked, `minHeight`, fixed), so
+     * each candidate is laid out and checked. The first is exact for Regions side by side (the full bound
+     * less the smallest slack); below it the bound is searched, down to the template's own height.
+     * Content that overflowed its Region at full height asks for no more than it had there.
+     */
+    shrink(regions, own, maxHeight, layOut, ctx) {
+        const filled = regions.filter((r) => r.held);
+        const needed = new Map(filled.map((r) => {
+            const { width, height } = r.getProps();
+            const used = r.held.measure(BoxConstraints.loose(width, Infinity), ctx).height;
+            return [r, Math.min(used, height)];
+        }));
+        const slack = Math.min(...filled.map((r) => r.getProps().height - needed.get(r)));
+        const fitsAt = (bound) => {
+            const size = layOut(bound);
+            const fits = filled.every((r) => r.getProps().height + SLACK_EPSILON >= needed.get(r));
+            return fits ? { size, bound } : null;
+        };
+        let low = Math.min(maxHeight, own);
+        let high = maxHeight;
+        const exact = fitsAt(Math.max(low, maxHeight - slack));
+        if (exact) {
+            if (exact.bound === low)
+                return exact;
+            high = exact.bound;
+        }
+        while (high - low > SHRINK_PRECISION) {
+            const mid = (low + high) / 2;
+            if (fitsAt(mid))
+                high = mid;
+            else
+                low = mid;
+        }
+        return { size: layOut(high), bound: high };
+    }
+    layoutChildren() {
+        return [this.content];
+    }
+    getProps() {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            child: this.content,
+            piece: this.piece,
+        };
+    }
+}

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

@@ -1,10 +1,9 @@
-import { BoxConstraints, Offset, Size } from "../../layout/box-constraints.js";
-import { Fragmentable, FragmentResult } from "../../layout/fragmentation.js";
+import { FragmentResult } from "../../layout/fragmentation.js";
 import { LayoutContext, PDFElement } from "../pdf-element.js";
+import { ProxyElement } from "./proxy-element.js";
 /**
- * A layout-TRANSPARENT wrapper that tries to keep its content on ONE page (CSS `break-inside: avoid`).
- * It delegates all layout and rendering to its child, so the visual result is byte-identical to the
- * unwrapped content; only pagination behaves differently.
+ * A layout-transparent wrapper (a `ProxyElement`) that tries to keep its content on ONE page (CSS
+ * `break-inside: avoid`). Only pagination behaves differently from the unwrapped content.
  *
  * The rule, decided in `fragment`:
  *   1. Fits in the space offered here           -> place it whole.
@@ -20,23 +19,14 @@ import { LayoutContext, PDFElement } from "../pdf-element.js";
  * keeping it together: the break wins (CSS behaves the same), and we WARN once rather than silently
  * swallowing either intent.
  */
-export declare class KeepTogetherElement extends PDFElement implements Fragmentable {
-    private child;
-    private warnedBreakConflict;
+export declare class KeepTogetherElement extends ProxyElement {
     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;
-    hasForcedBreak(): boolean;
-    breaksBefore(): boolean;
-    breaksAfter(): boolean;
+    protected rewrap(child: PDFElement): PDFElement;
     fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
-    /** Delegate the actual split to the child, unwrapping - once we have decided to break the group, the
-     *  pieces just flow (any INNER keepTogether lives in the child subtree and still vetoes there). */
+    /** Split like any wrapper - once we have decided to break the group, the pieces flow bare but keep
+     *  the group's place in the flex line (any INNER keepTogether lives in the child and still vetoes). */
     private splitChild;
     getProps(): {
         child: PDFElement;

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

@@ -1,10 +1,9 @@
 import { BoxConstraints } from "../../layout/box-constraints.js";
-import { isFragmentable } from "../../layout/fragmentation.js";
-import { PDFElement } from "../pdf-element.js";
+import { ProxyElement } from "./proxy-element.js";
+import { diagnose, pageOf } from "../../common/diagnostics.js";
 /**
- * A layout-TRANSPARENT wrapper that tries to keep its content on ONE page (CSS `break-inside: avoid`).
- * It delegates all layout and rendering to its child, so the visual result is byte-identical to the
- * unwrapped content; only pagination behaves differently.
+ * A layout-transparent wrapper (a `ProxyElement`) that tries to keep its content on ONE page (CSS
+ * `break-inside: avoid`). Only pagination behaves differently from the unwrapped content.
  *
  * The rule, decided in `fragment`:
  *   1. Fits in the space offered here           -> place it whole.
@@ -20,50 +19,41 @@ import { PDFElement } from "../pdf-element.js";
  * keeping it together: the break wins (CSS behaves the same), and we WARN once rather than silently
  * swallowing either intent.
  */
-export class KeepTogetherElement extends PDFElement {
+export class KeepTogetherElement extends ProxyElement {
     constructor({ child }) {
-        super();
-        this.warnedBreakConflict = false;
-        this.child = child;
+        super(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);
-    }
-    // Transparent: forward the sizing hints the flex parent reads, so a %-sized or Spacer-holding child
-    // keeps working when it is wrapped (the wrapper must not swallow these).
-    relativeSizeFactor(horizontal) {
-        return this.child.relativeSizeFactor(horizontal);
-    }
-    needsBoundedMain(horizontal) {
-        return this.child.needsBoundedMain(horizontal);
-    }
-    // Transparent to break control: a break-before/after on the wrapped element still applies to the group
-    // as a whole, and an inner forced break still forces the parent to fragment us (so `fragment` runs).
-    hasForcedBreak() {
-        return this.child.hasForcedBreak();
-    }
-    breaksBefore() {
-        return this.child.breaksBefore();
-    }
-    breaksAfter() {
-        return this.child.breaksAfter();
+    // Once the group is broken, its pieces flow bare (see `splitChild`).
+    rewrap(child) {
+        return child;
     }
     fragment(maxHeight, width, ctx) {
         // Contradiction: a forced break inside the group beats keeping it together. Split at the break by
         // delegating to the child (which honours it), and say so once - never keep such a group whole.
         if (this.child.hasForcedBreak()) {
-            if (!this.warnedBreakConflict) {
-                this.warnedBreakConflict = true;
-                console.warn("keepTogether contains a forced page break (PageBreak / breakBefore / breakAfter). The break " +
-                    "wins and the group is split. Remove the break, or the keepTogether, to resolve this.");
-            }
+            diagnose(ctx.diagnostics, {
+                code: "keep-together-split",
+                severity: "warning",
+                message: "keepTogether contains a forced break (PageBreak, ColumnBreak, breakBefore / breakAfter). " +
+                    "The break wins and the group is split. Remove the break, or the keepTogether, to resolve this.",
+                about: this,
+                page: pageOf(ctx),
+            });
             return this.splitChild(maxHeight, width, ctx);
         }
-        const natural = this.child.calculateLayout(BoxConstraints.loose(width, Infinity), { x: 0, y: 0 }, ctx).height;
+        // A region-sized child (a Flow) has no height of its own to compare, so the same three rules ask
+        // whether it ENDS here, or on a fresh page.
+        if (this.child.needsRegion()) {
+            const here = this.splitChild(maxHeight, width, ctx);
+            if (!here.remainder)
+                return here;
+            const pageBody = ctx.pageBodyHeight ?? maxHeight;
+            if (maxHeight < pageBody && !this.splitChild(pageBody, width, ctx).remainder) {
+                return { fitted: null, remainder: this };
+            }
+            return here;
+        }
+        const natural = this.child.measure(BoxConstraints.loose(width, Infinity), ctx).height;
         // 1. Fits in the offered space: keep whole.
         if (natural <= maxHeight)
             return { fitted: this, remainder: null };
@@ -76,12 +66,10 @@ export class KeepTogetherElement extends PDFElement {
         // 3. Bigger than a whole page: it can never be kept together, so split it.
         return this.splitChild(maxHeight, width, ctx);
     }
-    /** Delegate the actual split to the child, unwrapping - once we have decided to break the group, the
-     *  pieces just flow (any INNER keepTogether lives in the child subtree and still vetoes there). */
+    /** Split like any wrapper - once we have decided to break the group, the pieces flow bare but keep
+     *  the group's place in the flex line (any INNER keepTogether lives in the child and still vetoes). */
     splitChild(maxHeight, width, ctx) {
-        if (!isFragmentable(this.child))
-            return { fitted: null, remainder: this };
-        return this.child.fragment(maxHeight, width, ctx);
+        return super.fragment(maxHeight, width, ctx);
     }
     getProps() {
         return { child: this.child };

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

@@ -1,26 +1,21 @@
-import { PDFElement, LayoutContext } from "../pdf-element.js";
-import { BoxConstraints, Offset, Size } from "../../layout/box-constraints.js";
+import { PDFElement } from "../pdf-element.js";
+import { ProxyElement } from "./proxy-element.js";
 /**
  * Makes its child a clickable hyperlink. `href` is an external URL; `dest` is an internal named
- * destination (an `Anchor` elsewhere in the document) - exactly one is set. Layout-transparent: it
- * delegates `calculateLayout` to the child and records the resulting box, which the renderer turns into
- * a `Link` IR node (and the page renderer into a /Link annotation). The link draws nothing itself -
- * style the child (e.g. a blue Text) if you want it to look like a link.
+ * destination (an `Anchor` elsewhere in the document) - exactly one is set. Layout-transparent (a
+ * `ProxyElement`); the renderer turns the child's box into a `Link` IR node (and the page renderer into
+ * a /Link annotation). The link draws nothing itself - style the child (e.g. a blue Text) if you want it
+ * to look like a link. Split across pages, every piece stays clickable.
  */
-export declare class LinkElement extends PDFElement {
+export declare class LinkElement extends ProxyElement {
     private href?;
     private dest?;
-    private child;
-    private x;
-    private y;
-    private width;
-    private height;
     constructor({ href, dest, child }: {
         href?: string;
         dest?: string;
         child: PDFElement;
     });
-    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    protected rewrap(child: PDFElement): PDFElement;
     getProps(): {
         href: string | undefined;
         dest: string | undefined;

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

@@ -1,29 +1,19 @@
-import { PDFElement } from "../pdf-element.js";
+import { ProxyElement } from "./proxy-element.js";
 /**
  * Makes its child a clickable hyperlink. `href` is an external URL; `dest` is an internal named
- * destination (an `Anchor` elsewhere in the document) - exactly one is set. Layout-transparent: it
- * delegates `calculateLayout` to the child and records the resulting box, which the renderer turns into
- * a `Link` IR node (and the page renderer into a /Link annotation). The link draws nothing itself -
- * style the child (e.g. a blue Text) if you want it to look like a link.
+ * destination (an `Anchor` elsewhere in the document) - exactly one is set. Layout-transparent (a
+ * `ProxyElement`); the renderer turns the child's box into a `Link` IR node (and the page renderer into
+ * a /Link annotation). The link draws nothing itself - style the child (e.g. a blue Text) if you want it
+ * to look like a link. Split across pages, every piece stays clickable.
  */
-export class LinkElement extends PDFElement {
+export class LinkElement extends ProxyElement {
     constructor({ href, dest, child }) {
-        super();
-        this.x = 0;
-        this.y = 0;
-        this.width = 0;
-        this.height = 0;
+        super(child);
         this.href = href;
         this.dest = dest;
-        this.child = child;
     }
-    calculateLayout(constraints, offset, ctx) {
-        const size = this.child.calculateLayout(constraints, offset, ctx);
-        this.x = offset.x;
-        this.y = offset.y;
-        this.width = size.width;
-        this.height = size.height;
-        return size;
+    rewrap(child) {
+        return new LinkElement({ href: this.href, dest: this.dest, child });
     }
     getProps() {
         return {

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

@@ -5,11 +5,21 @@ import { type EdgeSpecs } from "../../layout/insets.js";
 interface PaddingElementParams extends WithChild {
     /** Still unresolved: a side may be a percentage of the offered WIDTH (see `Insets`). */
     margin: EdgeSpecs;
+    /** This is a `Box`'s own padding: a percentage resolves against what the Box was offered
+     *  (`ctx.boxPaddingBase`), as CSS resolves it against the containing block. */
+    ofBox?: boolean;
 }
 export declare class PaddingElement extends SizedPDFElement implements Fragmentable {
     private child;
     private margin;
-    constructor({ margin, child }: PaddingElementParams);
+    readonly ofBox: boolean;
+    constructor({ margin, child, ofBox }: PaddingElementParams);
+    /** Some side is a percentage. */
+    get hasPercentSide(): boolean;
+    /** The width a percentage side resolves against, and the context the child sees: a Box's base is
+     *  for this padding alone, so it does not travel further down. */
+    private percentBase;
+    private childContext;
     /**
      * Splits the padded box across pages (box-decoration-break: clone - every fragment
      * keeps its full top/bottom inset). The child is fragmented into the space left after
@@ -17,6 +27,9 @@ export declare class PaddingElement extends SizedPDFElement implements Fragmenta
      * child can't be split, the whole padding moves on as the remainder.
      */
     fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
+    /** A wrapper: it needs a bound exactly when its child does, and passes the bound on. */
+    needsBoundedMain(horizontal: boolean): boolean;
+    needsRegion(): boolean;
     hasForcedBreak(): boolean;
     breaksBefore(): boolean;
     breaksAfter(): boolean;
@@ -27,6 +40,10 @@ export declare class PaddingElement extends SizedPDFElement implements Fragmenta
      */
     minIntrinsicMain(horizontal: boolean, ctx: LayoutContext): number;
     calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    protected computeSize(constraints: BoxConstraints, ctx: LayoutContext): Size;
+    /** The one sizing path: `layout` places the child (relative to this box), `measure` only sizes it. */
+    private sizeWith;
+    layoutChildren(): readonly PDFElement[];
     getProps(): {
         x: number;
         y: number;