@jasy/pdf 1.0.0-alpha.2 → 1.0.0-alpha.3

package/dist/elements/rectangle-element.js

@@ -1,23 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RectangleElement = void 0;
-const color_1 = require("../common/color");
-const box_constraints_1 = require("../layout/box-constraints");
-const fragmentation_1 = require("../layout/fragmentation");
-const pdf_element_1 = require("./pdf-element");
-class RectangleElement extends pdf_element_1.SizedPDFElement {
-    constructor({ children = [], color = new color_1.Color(0, 0, 0), backgroundColor, borderWidth, width, height, radius, sideBorders, relative, overflow, }) {
+import { Color } from "../common/color.js";
+import { BoxConstraints } from "../layout/box-constraints.js";
+import { packChildren } from "../layout/fragmentation.js";
+import { SizedPDFElement, } from "./pdf-element.js";
+export class RectangleElement extends SizedPDFElement {
+    constructor({ children = [], color = new Color(0, 0, 0), backgroundColor, borderWidth, width, height, radius, sideBorders, relative, overflow, }) {
         super({ x: 0, y: 0, width, height });
         this.children = [];
         this.children = children;
         this.color = color;
         this.backgroundColor = backgroundColor;
         // `?? 1` (not `|| 1`) so an explicit `0` means "no border" instead of snapping to 1.
-        this.borderWidth = borderWidth !== null && borderWidth !== void 0 ? borderWidth : 1;
-        this.radius = radius !== null && radius !== void 0 ? radius : 0;
+        this.borderWidth = borderWidth ?? 1;
+        this.radius = radius ?? 0;
         this.sideBorders = sideBorders;
-        this.relative = relative !== null && relative !== void 0 ? relative : false;
-        this.overflow = overflow !== null && overflow !== void 0 ? overflow : "visible";
+        this.relative = relative ?? false;
+        this.overflow = overflow ?? "visible";
         this.sizeMemory = { x: 0, y: 0, width, height };
     }
     /**
@@ -29,17 +26,16 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
      * box is sized by what it actually holds on each page.
      */
     fragment(maxHeight, width, ctx) {
-        var _a;
-        const boxWidth = (_a = this.sizeMemory.width) !== null && _a !== void 0 ? _a : width;
+        const boxWidth = this.sizeMemory.width ?? width;
         const innerWidth = Math.max(0, boxWidth - 2 * this.borderWidth);
         // Border-box: the content is inset by the border on top and bottom, so a fragment
         // holding `c` of content is `c + 2*border` tall. (Derived, not a fudge factor.)
         const innerMaxHeight = maxHeight - 2 * this.borderWidth;
-        const { fitted, remainder } = (0, fragmentation_1.packChildren)(this.children, innerMaxHeight, innerWidth, ctx);
+        const { fitted, remainder } = packChildren(this.children, innerMaxHeight, innerWidth, ctx);
         if (remainder.length === 0)
             return { fitted: this, remainder: null };
         const contentHeight = (kids) => kids.reduce((sum, child) => sum +
-            child.calculateLayout(box_constraints_1.BoxConstraints.loose(innerWidth, Infinity), { x: 0, y: 0 }, ctx)
+            child.calculateLayout(BoxConstraints.loose(innerWidth, Infinity), { x: 0, y: 0 }, ctx)
                 .height, 0);
         return {
             fitted: this.cloneWithChildren(fitted, contentHeight(fitted) + 2 * this.borderWidth),
@@ -63,7 +59,6 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         });
     }
     calculateLayout(constraints, offset, ctx) {
-        var _a, _b, _c, _d, _e;
         // Width: an explicit size wins (clamped), else fill the offered box. (Without this a
         // fixed box would balloon to the parent's size.)
         this.width =
@@ -93,17 +88,17 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         const frame = this.relative
             ? { origin: { x: 0, y: 0 }, size: { width: 0, height: 0 }, place: [] }
             : undefined;
-        const childCtx = frame ? Object.assign(Object.assign({}, ctx), { frame }) : ctx;
+        const childCtx = frame ? { ...ctx, frame } : ctx;
         // Lay out children stacked inside the border (inset by the border width). Width is
         // finalized here; height is left unbounded so each child sizes to its own content.
         const innerWidth = shrinkWrapWidth
             ? Infinity
-            : Math.max(0, ((_a = this.width) !== null && _a !== void 0 ? _a : 0) - 2 * this.borderWidth);
+            : Math.max(0, (this.width ?? 0) - 2 * this.borderWidth);
         let contentWidth = 0;
         let contentHeight = 0;
         let yCursor = this.y + this.borderWidth;
         for (const child of this.children) {
-            const childSize = child.calculateLayout(box_constraints_1.BoxConstraints.loose(innerWidth, Infinity), { x: this.x + this.borderWidth, y: yCursor }, childCtx);
+            const childSize = child.calculateLayout(BoxConstraints.loose(innerWidth, Infinity), { x: this.x + this.borderWidth, y: yCursor }, childCtx);
             yCursor += childSize.height;
             contentHeight += childSize.height;
             contentWidth = Math.max(contentWidth, childSize.width);
@@ -117,7 +112,7 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         // The box is sized now: place any out-of-flow `Positioned` descendants against its box.
         if (frame) {
             frame.origin = { x: this.x, y: this.y };
-            frame.size = { width: (_b = this.width) !== null && _b !== void 0 ? _b : 0, height: (_c = this.height) !== null && _c !== void 0 ? _c : 0 };
+            frame.size = { width: this.width ?? 0, height: this.height ?? 0 };
             for (const place of frame.place)
                 place(frame, ctx);
         }
@@ -126,8 +121,8 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         // border added on (that asymmetric "+border" was the source of the magic-3 fudge in
         // fragment). Top-left coordinates; the Y-flip happens at the IR -> backend seam.
         return {
-            width: (_d = this.width) !== null && _d !== void 0 ? _d : 0,
-            height: (_e = this.height) !== null && _e !== void 0 ? _e : 0,
+            width: this.width ?? 0,
+            height: this.height ?? 0,
         };
     }
     getProps() {
@@ -146,4 +141,3 @@ class RectangleElement extends pdf_element_1.SizedPDFElement {
         };
     }
 }
-exports.RectangleElement = RectangleElement;

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

@@ -1,6 +1,6 @@
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
-import { MainAlign, CrossAlign } from "../utils/flex-layout";
-import { LayoutContext, PDFElement, SizedPDFElement, WithChildren } from "./pdf-element";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import { MainAlign, CrossAlign } from "../utils/flex-layout.js";
+import { LayoutContext, PDFElement, SizedPDFElement, WithChildren } from "./pdf-element.js";
 interface RowElementParams extends WithChildren {
     /** Space inserted between children, in points. */
     gap?: number;

package/dist/elements/row-element.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowElement = void 0;
-const flex_layout_1 = require("../utils/flex-layout");
-const pdf_element_1 = require("./pdf-element");
+import { FlexLayoutHelper, HORIZONTAL_AXIS } from "../utils/flex-layout.js";
+import { SizedPDFElement } from "./pdf-element.js";
 /**
  * Horizontal stack: the mirror of `ContainerElement` (Column). Children are laid out
  * left-to-right via the shared `FlexLayoutHelper` on the horizontal axis; fixed children
@@ -15,13 +12,13 @@ const pdf_element_1 = require("./pdf-element");
  * does not fit (handled by the parent's `packChildren`); synchronized cell splitting is a
  * Grid/Table concern.
  */
-class RowElement extends pdf_element_1.SizedPDFElement {
+export class RowElement extends SizedPDFElement {
     constructor({ children, gap, main, cross }) {
         super({ x: 0, y: 0 });
         this.children = children;
-        this.gap = gap !== null && gap !== void 0 ? gap : 0;
-        this.main = main !== null && main !== void 0 ? main : "start";
-        this.cross = cross !== null && cross !== void 0 ? cross : "stretch";
+        this.gap = gap ?? 0;
+        this.main = main ?? "start";
+        this.cross = cross ?? "stretch";
     }
     calculateLayout(constraints, offset, ctx) {
         this.x = offset.x;
@@ -32,7 +29,7 @@ class RowElement extends pdf_element_1.SizedPDFElement {
         const crossAvail = constraints.hasBoundedHeight ? constraints.maxHeight : Infinity;
         let result = { mainUsed: 0, crossUsed: 0 };
         if (this.children.length > 0) {
-            result = flex_layout_1.FlexLayoutHelper.layout(this.children, flex_layout_1.HORIZONTAL_AXIS, mainAvail, crossAvail, this.x, this.y, { gap: this.gap, main: this.main, cross: this.cross }, ctx);
+            result = FlexLayoutHelper.layout(this.children, HORIZONTAL_AXIS, mainAvail, crossAvail, this.x, this.y, { gap: this.gap, main: this.main, cross: this.cross }, ctx);
         }
         this.width = constraints.hasBoundedWidth ? constraints.maxWidth : result.mainUsed;
         this.height = constraints.hasBoundedHeight ? constraints.maxHeight : result.crossUsed;
@@ -51,4 +48,3 @@ class RowElement extends pdf_element_1.SizedPDFElement {
         };
     }
 }
-exports.RowElement = RowElement;

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

@@ -1,8 +1,9 @@
-import { Color } from "../common/color";
-import { FontStyle } from "../utils/pdf-object-manager";
-import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
-import { Fragmentable, FragmentResult } from "../layout/fragmentation";
-import { HorizontalAlignment, LayoutContext, SizedPDFElement } from "./pdf-element";
+import { Color } from "../common/color.js";
+import { FontStyle } from "../utils/pdf-object-manager.js";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints.js";
+import { Fragmentable, FragmentResult } from "../layout/fragmentation.js";
+import { TextOverflow } from "../text/line-breaker.js";
+import { HorizontalAlignment, LayoutContext, SizedPDFElement } from "./pdf-element.js";
 export interface TextSegment {
     content: string;
     fontStyle?: FontStyle;
@@ -12,21 +13,39 @@ export interface TextSegment {
 }
 interface TextElementParams {
     id?: string;
-    fontSize: number;
+    /** Unset (undefined) inherits the cascaded size; see ResolvedTextStyle. */
+    fontSize?: number;
     fontFamily?: string;
     fontStyle?: FontStyle;
     content: string | TextSegment[];
     color?: Color;
     textAlignment?: HorizontalAlignment;
+    /** Cap the wrapped lines (default: unlimited / open-end). */
+    maxLines?: number;
+    /** What to do past `maxLines`: `"clip"` (default) drops them, `"ellipsis"` ends with "…". */
+    overflow?: TextOverflow;
+    /** Line-height multiplier: each line is `fontSize * lineHeight` tall (default `1`). */
+    lineHeight?: number;
 }
 export declare class TextElement extends SizedPDFElement implements Fragmentable {
+    private readonly rawFontSize?;
+    private readonly rawFontFamily?;
+    private readonly rawFontStyle?;
+    private readonly rawColor?;
+    private readonly rawTextAlignment?;
+    private readonly rawLineHeight?;
     private fontSize;
     private fontFamily;
     private fontStyle;
     private color;
-    private content;
     private textAlignment;
-    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, }: TextElementParams);
+    private lineHeight;
+    private content;
+    private maxLines?;
+    private overflow;
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow, lineHeight, }: TextElementParams);
+    private resolveStyle;
+    private applyStyle;
     /**
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
      * the rest become a remainder `TextElement` re-wrapped on the next page. If not even one
@@ -39,9 +58,13 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     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).
-     *  Mirrors the renderer's advance EXACTLY: per-glyph, WITHOUT kerning. `getStringWidth` subtracts
-     *  kerning, so it under-reserves and the text would wrap inside its own natural-width box - the cause
-     *  of fixed Row children wrapping despite ample space. */
+     *  Must match the LINE-BREAKER's one-line measure EXACTLY - not just algebraically but BIT-for-bit,
+     *  so a text laid out at this width never re-wraps inside its own natural-width box. The breaker
+     *  accumulates `currentWidth += wordWidth + spaceWidth`, grouping the word and its trailing space
+     *  into one term; we must group the same way. Adding word and space as two separate steps is
+     *  algebraically equal but, because floating-point addition is not associative, drifts by a sub-ULP
+     *  - 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;
     getProps(): {
         x: number;
@@ -54,6 +77,9 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
         color: Color;
         content: string | TextSegment[];
         textAlignment: HorizontalAlignment;
+        maxLines: number | undefined;
+        overflow: TextOverflow;
+        lineHeight: number;
     };
 }
 export {};

package/dist/elements/text-element.js

@@ -1,24 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextElement = void 0;
-const color_1 = require("../common/color");
 // Import the renderer DIRECTLY, not via the "../renderer" barrel: the barrel pulls in
 // pdf-renderer (and every element) while this element module is still loading, which under
 // ESM (Vite/vitest, and the future framework bindings) duplicates the element classes and
 // breaks the constructor-keyed RendererRegistry. A direct import keeps the graph acyclic.
-const text_renderer_1 = require("../renderer/text-renderer");
-const pdf_object_manager_1 = require("../utils/pdf-object-manager");
-const line_breaker_1 = require("../text/line-breaker");
-const pdf_element_1 = require("./pdf-element");
-class TextElement extends pdf_element_1.SizedPDFElement {
-    constructor({ fontSize, content, fontFamily = "Helvetica", fontStyle = pdf_object_manager_1.FontStyle.Normal, color = new color_1.Color(0, 0, 0), textAlignment = pdf_element_1.HorizontalAlignment.left, }) {
+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 { SizedPDFElement } from "./pdf-element.js";
+export class TextElement extends SizedPDFElement {
+    constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, overflow = "clip", lineHeight, }) {
         super({ x: 0, y: 0 });
-        this.fontSize = fontSize;
-        this.fontFamily = fontFamily;
-        this.fontStyle = fontStyle;
-        this.color = color;
+        this.rawFontSize = fontSize;
+        this.rawFontFamily = fontFamily;
+        this.rawFontStyle = fontStyle;
+        this.rawColor = color;
+        this.rawTextAlignment = textAlignment;
+        this.rawLineHeight = lineHeight;
         this.content = content;
-        this.textAlignment = textAlignment;
+        this.maxLines = maxLines;
+        this.overflow = overflow;
+        this.applyStyle(DEFAULT_TEXT_STYLE);
+    }
+    // Resolve the author-set values against the cascade: explicit > inherited (ctx) > built-in default.
+    resolveStyle(ctx) {
+        this.applyStyle(ctx.textStyle ?? DEFAULT_TEXT_STYLE);
+    }
+    applyStyle(ts) {
+        this.fontSize = this.rawFontSize ?? ts.fontSize;
+        this.fontFamily = this.rawFontFamily ?? ts.fontFamily;
+        this.fontStyle = this.rawFontStyle ?? ts.fontStyle;
+        this.color = this.rawColor ?? ts.color;
+        this.textAlignment = this.rawTextAlignment ?? ts.textAlignment;
+        this.lineHeight = this.rawLineHeight ?? ts.lineHeight;
     }
     /**
      * Splits the paragraph at line boxes (Slice 1). The lines that fit in `maxHeight` stay;
@@ -27,6 +39,7 @@ class TextElement extends pdf_element_1.SizedPDFElement {
      * the whole element on for progress. Handles both plain strings and styled segments.
      */
     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);
@@ -34,8 +47,8 @@ class TextElement extends pdf_element_1.SizedPDFElement {
     // Plain string: every wrapped line is `fontSize` tall (matches calculateTextHeight),
     // so `floor(maxHeight / fontSize)` lines fit.
     fragmentString(content, maxHeight, width, ctx) {
-        const lines = (0, line_breaker_1.wrapStringIntoLines)(content, this.fontFamily, this.fontSize, this.fontStyle, width, ctx.metrics);
-        const fittedLineCount = Math.floor(maxHeight / this.fontSize);
+        const lines = wrapStringIntoLines(content, this.fontFamily, this.fontSize, this.fontStyle, width, ctx.metrics, this.maxLines, this.overflow);
+        const fittedLineCount = Math.floor(maxHeight / (this.fontSize * this.lineHeight));
         if (fittedLineCount <= 0)
             return { fitted: null, remainder: this };
         if (fittedLineCount >= lines.length)
@@ -48,17 +61,18 @@ class TextElement extends pdf_element_1.SizedPDFElement {
     // Styled segments: each line's height is its tallest font (maxFontSize), so pack lines
     // by cumulative leading. Rebuild the fitted/remainder halves back into TextSegment[].
     fragmentSegments(content, maxHeight, width, ctx) {
-        const lines = (0, line_breaker_1.breakSegmentsIntoLines)(content, {
+        const lines = breakSegmentsIntoLines(content, {
             fontFamily: this.fontFamily,
             fontSize: this.fontSize,
             fontStyle: this.fontStyle,
-        }, width, ctx.metrics);
+        }, width, ctx.metrics, this.maxLines, this.overflow);
         let used = 0;
         let fittedLineCount = 0;
         for (const line of lines) {
-            if (used + line.maxFontSize > maxHeight)
+            const lineBox = line.maxFontSize * this.lineHeight;
+            if (used + lineBox > maxHeight)
                 break;
-            used += line.maxFontSize;
+            used += lineBox;
             fittedLineCount++;
         }
         if (fittedLineCount <= 0)
@@ -66,8 +80,8 @@ class TextElement extends pdf_element_1.SizedPDFElement {
         if (fittedLineCount >= lines.length)
             return { fitted: this, remainder: null };
         return {
-            fitted: this.cloneWithContent((0, line_breaker_1.segmentLinesToSegments)(lines.slice(0, fittedLineCount))),
-            remainder: this.cloneWithContent((0, line_breaker_1.segmentLinesToSegments)(lines.slice(fittedLineCount))),
+            fitted: this.cloneWithContent(segmentLinesToSegments(lines.slice(0, fittedLineCount))),
+            remainder: this.cloneWithContent(segmentLinesToSegments(lines.slice(fittedLineCount))),
         };
     }
     // A copy carrying the same style but different (already-wrapped) content. Re-wrapping at
@@ -80,10 +94,13 @@ class TextElement extends pdf_element_1.SizedPDFElement {
             fontStyle: this.fontStyle,
             color: this.color,
             textAlignment: this.textAlignment,
+            maxLines: this.maxLines,
+            overflow: this.overflow,
+            lineHeight: this.lineHeight,
         });
     }
     calculateLayout(constraints, offset, ctx) {
-        var _a;
+        this.resolveStyle(ctx);
         this.x = offset.x;
         this.y = offset.y;
         // Bounded width (e.g. inside a Column) wraps to that width; an unbounded width
@@ -92,32 +109,38 @@ class TextElement extends pdf_element_1.SizedPDFElement {
         this.width = constraints.hasBoundedWidth
             ? constraints.maxWidth
             : this.naturalWidth(ctx.metrics);
-        const wrapWidth = (_a = this.width) !== null && _a !== void 0 ? _a : 0;
-        this.height = text_renderer_1.TextRenderer.calculateTextHeight(this.content, this.fontSize, this.fontFamily, this.fontStyle, ctx.metrics, wrapWidth);
+        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);
         // 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.
         return { width: wrapWidth, height: this.height };
     }
     /** The unwrapped single-line width of the content (used when width is unbounded, e.g. inside a Row).
-     *  Mirrors the renderer's advance EXACTLY: per-glyph, WITHOUT kerning. `getStringWidth` subtracts
-     *  kerning, so it under-reserves and the text would wrap inside its own natural-width box - the cause
-     *  of fixed Row children wrapping despite ample space. */
+     *  Must match the LINE-BREAKER's one-line measure EXACTLY - not just algebraically but BIT-for-bit,
+     *  so a text laid out at this width never re-wraps inside its own natural-width box. The breaker
+     *  accumulates `currentWidth += wordWidth + spaceWidth`, grouping the word and its trailing space
+     *  into one term; we must group the same way. Adding word and space as two separate steps is
+     *  algebraically equal but, because floating-point addition is not associative, drifts by a sub-ULP
+     *  - 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 advance = (text, family, size, style) => {
+        const oneLine = (text, family, size, style) => {
+            const words = text.split(" ");
+            const space = metrics.getCharWidth(" ", size, undefined, family, style);
             let width = 0;
-            for (const ch of text)
-                width += metrics.getCharWidth(ch, size, undefined, family, style);
+            words.forEach((word, i) => {
+                const w = metrics.getStringWidth(word, family, size, style);
+                // Group (word + space) as one term, exactly like the breaker - see the note above.
+                width += i < words.length - 1 ? w + space : w;
+            });
             return width;
         };
         if (typeof this.content === "string") {
-            return advance(this.content, this.fontFamily, this.fontSize, this.fontStyle);
+            return oneLine(this.content, this.fontFamily, this.fontSize, this.fontStyle);
         }
-        return this.content.reduce((sum, seg) => {
-            var _a, _b, _c;
-            return sum +
-                advance(seg.content, (_a = seg.fontFamily) !== null && _a !== void 0 ? _a : this.fontFamily, (_b = seg.fontSize) !== null && _b !== void 0 ? _b : this.fontSize, (_c = seg.fontStyle) !== null && _c !== void 0 ? _c : this.fontStyle);
-        }, 0);
+        return this.content.reduce((sum, seg) => sum +
+            oneLine(seg.content, seg.fontFamily ?? this.fontFamily, seg.fontSize ?? this.fontSize, seg.fontStyle ?? this.fontStyle), 0);
     }
     getProps() {
         return {
@@ -131,7 +154,9 @@ class TextElement extends pdf_element_1.SizedPDFElement {
             color: this.color,
             content: this.content,
             textAlignment: this.textAlignment,
+            maxLines: this.maxLines,
+            overflow: this.overflow,
+            lineHeight: this.lineHeight,
         };
     }
 }
-exports.TextElement = TextElement;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./elements";
-export * from "./renderer";
-export * from "./api";
+export * from "./elements/index.js";
+export * from "./renderer/index.js";
+export * from "./api/index.js";

package/dist/index.js

@@ -1,21 +1,5 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./elements"), exports);
-__exportStar(require("./renderer"), exports);
-__exportStar(require("./api"), exports);
+export * from "./elements/index.js";
+export * from "./renderer/index.js";
+export * from "./api/index.js";
 // export * from './validator';
 // export * from './utils';

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

@@ -1,5 +1,5 @@
-import { Color } from "../common/color";
-import { FontStyle } from "../utils/pdf-object-manager";
+import { Color } from "../common/color.js";
+import { FontStyle } from "../utils/pdf-object-manager.js";
 /**
  * Display list - the seam between layout and the PDF backend.
  *
@@ -60,6 +60,8 @@ export interface Image {
     intrinsicHeight: number;
     data: string;
     imageType: string;
+    /** Flate-compressed DeviceGray alpha channel for a transparent PNG, embedded as the XObject's /SMask. */
+    smask?: string;
     /** cover/contain fits clip the placement to the element's original frame. */
     clip?: {
         x: number;

package/dist/ir/display-list.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/layout/box-constraints.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BoxConstraints = void 0;
 /**
  * The size constraints handed DOWN the tree during layout (Flutter's BoxConstraints
  * model). Pure geometry: a min/max range per axis, no position. An element receives a
@@ -15,7 +12,7 @@ exports.BoxConstraints = void 0;
  * remaining vertical space becomes a `maxHeight`, and "does this fit?" is a constraint
  * check, not a special case.
  */
-class BoxConstraints {
+export class BoxConstraints {
     constructor(minWidth = 0, maxWidth = Infinity, minHeight = 0, maxHeight = Infinity) {
         this.minWidth = minWidth;
         this.maxWidth = maxWidth;
@@ -28,7 +25,7 @@ class BoxConstraints {
     }
     /** Tight only on the axes given; the others stay unbounded (0..Infinity). */
     static tightFor({ width, height }) {
-        return new BoxConstraints(width !== null && width !== void 0 ? width : 0, width !== null && width !== void 0 ? width : Infinity, height !== null && height !== void 0 ? height : 0, height !== null && height !== void 0 ? height : Infinity);
+        return new BoxConstraints(width ?? 0, width ?? Infinity, height ?? 0, height ?? Infinity);
     }
     /** Caps each axis at `max` but allows anything down to zero (shrink-wrap). */
     static loose(maxWidth, maxHeight) {
@@ -70,4 +67,3 @@ class BoxConstraints {
         return new BoxConstraints(Math.max(parent.minWidth, Math.min(this.minWidth, parent.maxWidth)), Math.max(parent.minWidth, Math.min(this.maxWidth, parent.maxWidth)), Math.max(parent.minHeight, Math.min(this.minHeight, parent.maxHeight)), Math.max(parent.minHeight, Math.min(this.maxHeight, parent.maxHeight)));
     }
 }
-exports.BoxConstraints = BoxConstraints;

package/dist/layout/fragmentation.d.ts

@@ -1,4 +1,4 @@
-import { LayoutContext, PDFElement } from "../elements/pdf-element";
+import { LayoutContext, PDFElement } from "../elements/pdf-element.js";
 /**
  * The result of splitting an element against a fragmentation region (a page, later a
  * column). `fitted` is the part that fits in the region; `remainder` describes what did
@@ -22,6 +22,13 @@ export interface Fragmentable {
     fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
 }
 export declare function isFragmentable(element: PDFElement): element is PDFElement & Fragmentable;
+/**
+ * What to do when an element is taller than the whole page region and cannot be broken. We always
+ * still place it (clipped) so pagination terminates - this only controls how loud we are about it:
+ * `"error"` throws (the default; an unbreakable overflow is almost always a layout bug), `"warn"`
+ * logs and clips, `"ignore"` clips silently.
+ */
+export type OverflowPolicy = "error" | "warn" | "ignore";
 /**
  * Packs a vertical stack of children into `maxHeight`, in order. Children are measured
  * against `width` (unbounded height) and added until one would overflow; that straddling

package/dist/layout/fragmentation.js

@@ -1,12 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFragmentable = isFragmentable;
-exports.packChildren = packChildren;
-const box_constraints_1 = require("./box-constraints");
-function isFragmentable(element) {
+import { BoxConstraints } from "./box-constraints.js";
+export function isFragmentable(element) {
     return ("fragment" in element &&
         typeof element.fragment === "function");
 }
+function reportOverflow(child, childHeight, maxHeight, policy) {
+    if (policy === "ignore")
+        return;
+    const name = child.constructor.name.replace(/Element$/, "");
+    const detail = `${name} is ${Math.round(childHeight)}pt tall but the page region is only ` +
+        `${Math.round(maxHeight)}pt and it cannot be broken - reduce its size, give it a bounded ` +
+        `height, or let it split across pages.`;
+    if (policy === "error")
+        throw new Error(`Layout overflow: ${detail}`);
+    console.warn(`Layout overflow (clipped): ${detail}`);
+}
 /**
  * Packs a vertical stack of children into `maxHeight`, in order. Children are measured
  * against `width` (unbounded height) and added until one would overflow; that straddling
@@ -21,13 +28,13 @@ function isFragmentable(element) {
  * Shared by every element that lays out a vertical stack and can split it across regions
  * (Container, and the decorated boxes Padding/Rectangle).
  */
-function packChildren(children, maxHeight, width, ctx, gap = 0) {
+export function packChildren(children, maxHeight, width, ctx, gap = 0) {
     const fitted = [];
     const remainder = [];
     let usedHeight = 0;
     for (let i = 0; i < children.length; i++) {
         const child = children[i];
-        const childHeight = child.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), { x: 0, y: 0 }, ctx).height;
+        const childHeight = child.calculateLayout(BoxConstraints.loose(width, Infinity), { x: 0, y: 0 }, ctx).height;
         // A gap precedes every child except the first one placed in this region.
         const lead = fitted.length > 0 ? gap : 0;
         if (usedHeight + lead + childHeight <= maxHeight) {
@@ -48,10 +55,15 @@ function packChildren(children, maxHeight, width, ctx, gap = 0) {
             }
         }
         if (!placedPart) {
-            if (fitted.length === 0)
+            if (fitted.length === 0) {
+                // Taller than the whole region and unsplittable: force it on (it overflows and is clipped)
+                // so the next region still advances - and surface it per the overflow policy.
+                reportOverflow(child, childHeight, maxHeight, ctx.onOverflow ?? "ignore");
                 fitted.push(child);
-            else
+            }
+            else {
                 remainder.push(child);
+            }
         }
         for (let j = i + 1; j < children.length; j++)
             remainder.push(children[j]);

package/dist/platform/browser-fs.d.ts

@@ -0,0 +1,2 @@
+export declare function readFileBytes(_path: string): Uint8Array;
+export declare function readFileBytesAsync(_path: string): Promise<Uint8Array>;

package/dist/platform/browser-fs.js

@@ -0,0 +1,9 @@
+// Browser stand-in for platform/node-fs.ts (selected by the package.json "browser" field). The browser has
+// no file paths, so loading from one throws a clear, actionable error - pass bytes instead.
+const hint = "needs Node. In the browser pass bytes (Uint8Array / ArrayBuffer) instead - e.g. import the file as a URL and fetch() it, or register a font from its bytes.";
+export function readFileBytes(_path) {
+    throw new Error(`Loading a font from a file path ${hint}`);
+}
+export function readFileBytesAsync(_path) {
+    throw new Error(`Loading an image from a file path ${hint}`);
+}

package/dist/platform/browser-image.d.ts

@@ -0,0 +1,5 @@
+export declare function pngToRgba(bytes: Uint8Array): Promise<{
+    width: number;
+    height: number;
+    rgba: Uint8Array;
+}>;

package/dist/platform/browser-image.js

@@ -0,0 +1,13 @@
+// PNG decode in the browser: the platform's own image decoder, via an OffscreenCanvas, to raw RGBA. No
+// jimp, no Buffer - keeps the browser bundle lean and works wherever Canvas does. The package `browser`
+// field swaps `node-image.ts` for this module at bundle time.
+export async function pngToRgba(bytes) {
+    const bitmap = await createImageBitmap(new Blob([new Uint8Array(bytes)], { type: "image/png" }));
+    const { width, height } = bitmap;
+    const ctx = new OffscreenCanvas(width, height).getContext("2d");
+    if (!ctx)
+        throw new Error("@jasy/pdf: no 2D canvas context available to decode the PNG.");
+    ctx.drawImage(bitmap, 0, 0);
+    bitmap.close();
+    return { width, height, rgba: new Uint8Array(ctx.getImageData(0, 0, width, height).data.buffer) };
+}

package/dist/platform/node-fs.d.ts

@@ -0,0 +1,2 @@
+export declare function readFileBytes(path: string): Uint8Array;
+export declare function readFileBytesAsync(path: string): Promise<Uint8Array>;