@jasy/pdf 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/elements/image-element.js

@@ -1,140 +1,174 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageElement = exports.CustomLocalImage = exports.CustomImage = exports.BoxFit = void 0;
-const image_helper_1 = require("../utils/image-helper");
-const pdf_element_1 = require("./pdf-element");
-var BoxFit;
+import { getImageDimensions } from "../utils/image-helper.js";
+import { latin1FromBytes } from "../utils/bytes.js";
+import { readFileBytesAsync } from "../platform/node-fs.js";
+import { extentSpecs, resolveSize, } from "../layout/box-constraints.js";
+import { SizedPDFElement } from "./pdf-element.js";
+// path.extname without node:path (browser-safe): the substring from the last dot, if it sits after the
+// last slash (so a dot in a directory name does not count). Enough for image file extensions.
+function extname(p) {
+    const dot = p.lastIndexOf(".");
+    const slash = p.lastIndexOf("/");
+    return dot > slash + 1 ? p.slice(dot) : "";
+}
+export var BoxFit;
 (function (BoxFit) {
     BoxFit["none"] = "NONE";
     BoxFit["contain"] = "CONTAIN";
     BoxFit["cover"] = "COVER";
     BoxFit["fill"] = "FILL";
-})(BoxFit || (exports.BoxFit = BoxFit = {}));
-class CustomImage {
+})(BoxFit || (BoxFit = {}));
+export class CustomImage {
 }
-exports.CustomImage = CustomImage;
-class CustomLocalImage extends CustomImage {
+export class CustomLocalImage extends CustomImage {
     constructor(imagePath) {
         super();
         this.imagePath = imagePath;
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                // Loading image and convert it to base64
-                yield this.loadImage(this.imagePath);
-            }
-            catch (error) {
-                console.error("Error loading image:", error);
-            }
-        });
+    async init() {
+        if (this.fileBuffer)
+            return; // idempotent: the pre-layout size pass and the renderer both call init()
+        try {
+            // Loading image and convert it to base64
+            await this.loadImage(this.imagePath);
+        }
+        catch (error) {
+            console.error("Error loading image:", error);
+        }
     }
-    getImageType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const path = yield Promise.resolve().then(() => __importStar(require("path"))); // Dynamic import
-            const ext = path.extname(this.imagePath).toLowerCase();
-            switch (ext) {
-                case ".jpg":
-                case ".jpeg":
-                    return "DCTDecode"; // For JPEG
-                case ".png":
-                    return "FlateDecode"; // For PNG
-                case ".bmp":
-                    throw new Error("BMP is not directly supported. Please convert to PNG or JPEG.");
-                case ".webp":
-                    throw new Error("WebP is not directly supported. Please convert to PNG or JPEG.");
-                default:
-                    throw new Error(`Unsupported image format: ${ext}`);
-            }
-        });
+    async getImageType() {
+        const ext = extname(this.imagePath).toLowerCase();
+        switch (ext) {
+            case ".jpg":
+            case ".jpeg":
+                return "DCTDecode"; // For JPEG
+            case ".png":
+                return "FlateDecode"; // For PNG
+            case ".bmp":
+                throw new Error("BMP is not directly supported. Please convert to PNG or JPEG.");
+            case ".webp":
+                throw new Error("WebP is not directly supported. Please convert to PNG or JPEG.");
+            default:
+                throw new Error(`Unsupported image format: ${ext}`);
+        }
     }
-    loadImage(imagePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fs = yield Promise.resolve().then(() => __importStar(require("fs/promises"))); // Dynamic import
-            const result = yield fs.readFile(imagePath);
-            //const result = await convertImageToGrayscaleBuffer(imagePath);
-            this.fileBuffer = result;
-            this.fileRawData = result.toString("binary");
-            return result;
-        });
+    async loadImage(imagePath) {
+        const result = await readFileBytesAsync(imagePath);
+        //const result = await convertImageToGrayscaleBuffer(imagePath);
+        this.fileBuffer = result;
+        this.fileRawData = latin1FromBytes(result);
+        return result;
     }
     getFileData() {
         return this.fileRawData;
     }
-    getImageDimensions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.fileBuffer) {
-                throw new Error("You must first call the `loadAndConvertImage` method");
-            }
-            // Since now (30.09.2024) we using "Jimp" - So we don't need our custom method to get the image dimension.
-            // But at the moment I let it still here...
-            const dimensions = yield (0, image_helper_1.getImageDimensions)(this.fileBuffer);
-            return dimensions;
-        });
+    async getImageDimensions() {
+        if (this.dims)
+            return this.dims; // reuse: the pre-layout size pass and the renderer both ask
+        if (!this.fileBuffer) {
+            throw new Error("You must first call the `loadAndConvertImage` method");
+        }
+        this.dims = await getImageDimensions(this.fileBuffer);
+        return this.dims;
+    }
+}
+/**
+ * An image straight from raw bytes (a browser upload / fetch, no filesystem). The PDF filter is sniffed
+ * from the magic bytes: JPEG embeds raw (DCTDecode, no decode step), PNG is decoded to RGB (FlateDecode).
+ */
+export class CustomBytesImage extends CustomImage {
+    constructor(bytes) {
+        super();
+        this.bytes = bytes;
+        this.fileRawData = latin1FromBytes(bytes);
+    }
+    async init() { }
+    async getImageType() {
+        const b = this.bytes;
+        if (b[0] === 0xff && b[1] === 0xd8)
+            return "DCTDecode"; // JPEG
+        if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47)
+            return "FlateDecode"; // PNG
+        throw new Error("Unsupported image bytes (only JPEG and PNG are supported).");
+    }
+    getFileData() {
+        return this.fileRawData;
+    }
+    async getImageDimensions() {
+        if (!this.dims)
+            this.dims = await getImageDimensions(this.bytes); // reuse across pre-pass + render
+        return this.dims;
     }
 }
-exports.CustomLocalImage = CustomLocalImage;
-class ImageElement extends pdf_element_1.SizedPDFElement {
-    constructor({ image, width, height, fit = BoxFit.none, radius }) {
+export class ImageElement extends SizedPDFElement {
+    constructor({ image, width, height, widthFactor, heightFactor, fit = BoxFit.none, radius, alt, ...sizing }) {
+        // Seed this.width/height from the request so getProps() reflects it before layout; calculateLayout
+        // then reads `requested` (never the mutated fields) and overwrites these with the laid-out size.
         super({ x: 0, y: 0, width });
         this.image = image;
         this.height = height;
+        this.requested = { width, height };
+        this.widthFactor = widthFactor;
+        this.heightFactor = heightFactor;
+        this.sizing = sizing;
         this.fit = fit;
-        this.radius = radius !== null && radius !== void 0 ? radius : 0;
+        this.radius = radius ?? 0;
+        this.alt = alt;
+    }
+    /**
+     * Loads the image and records its intrinsic pixel size. Runs in the async pre-layout pass (layout
+     * itself is synchronous and cannot await jimp) so `calculateLayout` can turn a width-only image
+     * into a proportional box. Best-effort: a load failure leaves the size unresolved (the renderer
+     * surfaces the real error) and the image just keeps whatever explicit size it was given.
+     */
+    async resolveIntrinsicSize() {
+        try {
+            await this.image.init();
+            this.intrinsic = await this.image.getImageDimensions();
+        }
+        catch {
+            // leave intrinsic undefined - aspect derivation simply doesn't fire
+        }
+    }
+    relativeSizeFactor(horizontal) {
+        return horizontal ? this.widthFactor : this.heightFactor;
     }
     calculateLayout(constraints, offset, _ctx) {
-        var _a, _b;
         this.x = offset.x;
         this.y = offset.y;
-        // A bounded axis overrides the intrinsic/explicit size; otherwise keep our own.
-        if (constraints.hasBoundedWidth)
-            this.width = constraints.maxWidth;
-        if (constraints.hasBoundedHeight)
-            this.height = constraints.maxHeight;
+        // Relative sizing: a fixed size or a fraction of the offered box (fraction only in a bounded axis).
+        // Read from `requested` (not this.width/height, which we overwrite below) so every pass re-resolves.
+        const specs = extentSpecs({
+            ...this.sizing,
+            width: this.requested.width,
+            height: this.requested.height,
+            widthFactor: this.widthFactor,
+            heightFactor: this.heightFactor,
+        });
+        // An explicit `aspectRatio` wins over the image's own, as it does in CSS - and only it may size a
+        // box with NEITHER axis pinned. Left to the intrinsic ratio that would change what an unsized image
+        // has always done here (fill both axes and let `fit` sort it out).
+        const resolved = resolveSize(specs.width, specs.height, this.sizing.aspectRatio, constraints);
+        let w = resolved.width;
+        let h = resolved.height;
+        const bounds = resolved.constraints;
+        // Aspect auto-size: when exactly ONE axis is pinned, derive the other from the intrinsic ratio
+        // (CSS `width: 50%; height: auto`). Only fires once the pre-pass resolved the pixel size.
+        if (this.sizing.aspectRatio === undefined &&
+            this.intrinsic &&
+            this.intrinsic.width > 0 &&
+            this.intrinsic.height > 0) {
+            const ratio = this.intrinsic.width / this.intrinsic.height;
+            if (w !== undefined && h === undefined)
+                h = bounds.constrainHeight(w / ratio);
+            else if (h !== undefined && w === undefined)
+                w = bounds.constrainWidth(h * ratio);
+        }
+        // Fall back to the prior behavior for an unpinned axis: a bounded axis fills, otherwise keep the
+        // requested fixed size (or undefined). Read from `requested`, never the mutated this.width/height.
+        this.width = w ?? (bounds.hasBoundedWidth ? bounds.maxWidth : this.requested.width);
+        this.height = h ?? (bounds.hasBoundedHeight ? bounds.maxHeight : this.requested.height);
         // Top-left coordinates; the fit logic (renderer) and the Y-flip (seam) run later.
-        return { width: (_a = this.width) !== null && _a !== void 0 ? _a : 0, height: (_b = this.height) !== null && _b !== void 0 ? _b : 0 };
+        return { width: this.width ?? 0, height: this.height ?? 0 };
     }
     getProps() {
         return {
@@ -145,7 +179,7 @@ class ImageElement extends pdf_element_1.SizedPDFElement {
             image: this.image,
             fit: this.fit,
             radius: this.radius,
+            alt: this.alt,
         };
     }
 }
-exports.ImageElement = ImageElement;

package/dist/elements/index.d.ts

@@ -1,10 +1,26 @@
-export { PDFElement } from "./pdf-element";
-export * from "./text-element";
-export * from "./pdf-document-element";
-export * from "./page-element";
-export * from "./rectangle-element";
-export * from "./image-element";
-export * from "./layout/expanded-element";
-export * from "./layout/padding-element";
-export * from "./line-element";
-export * from "./row-element";
+export { PDFElement } from "./pdf-element.js";
+export * from "./text-element.js";
+export * from "./pdf-document-element.js";
+export * from "./page-element.js";
+export * from "./rectangle-element.js";
+export * from "./image-element.js";
+export * from "./layout/expanded-element.js";
+export * from "./layout/padding-element.js";
+export * from "./layout/page-break-element.js";
+export * from "./layout/keep-together-element.js";
+export * from "./forms/text-field-element.js";
+export * from "./forms/checkbox-element.js";
+export * from "./forms/radio-element.js";
+export * from "./forms/choice-element.js";
+export * from "./forms/push-button-element.js";
+export * from "./forms/signature-element.js";
+export * from "./layout/default-text-style-element.js";
+export * from "./layout/positioned-element.js";
+export * from "./layout/link-element.js";
+export * from "./layout/bookmark-element.js";
+export * from "./layout/anchor-element.js";
+export * from "./layout/page-builder-element.js";
+export * from "./layout/rotated-element.js";
+export * from "./layout/rotated-box-element.js";
+export * from "./line-element.js";
+export * from "./row-element.js";

package/dist/elements/index.js

@@ -1,28 +1,26 @@
-"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 });
-exports.PDFElement = void 0;
-var pdf_element_1 = require("./pdf-element"); // the base element type - public for composing custom layouts
-Object.defineProperty(exports, "PDFElement", { enumerable: true, get: function () { return pdf_element_1.PDFElement; } });
-__exportStar(require("./text-element"), exports);
-__exportStar(require("./pdf-document-element"), exports);
-__exportStar(require("./page-element"), exports);
-__exportStar(require("./rectangle-element"), exports);
-__exportStar(require("./image-element"), exports);
-__exportStar(require("./layout/expanded-element"), exports);
-__exportStar(require("./layout/padding-element"), exports);
-__exportStar(require("./line-element"), exports);
-__exportStar(require("./row-element"), exports);
+export { PDFElement } from "./pdf-element.js"; // the base element type - public for composing custom layouts
+export * from "./text-element.js";
+export * from "./pdf-document-element.js";
+export * from "./page-element.js";
+export * from "./rectangle-element.js";
+export * from "./image-element.js";
+export * from "./layout/expanded-element.js";
+export * from "./layout/padding-element.js";
+export * from "./layout/page-break-element.js";
+export * from "./layout/keep-together-element.js";
+export * from "./forms/text-field-element.js";
+export * from "./forms/checkbox-element.js";
+export * from "./forms/radio-element.js";
+export * from "./forms/choice-element.js";
+export * from "./forms/push-button-element.js";
+export * from "./forms/signature-element.js";
+export * from "./layout/default-text-style-element.js";
+export * from "./layout/positioned-element.js";
+export * from "./layout/link-element.js";
+export * from "./layout/bookmark-element.js";
+export * from "./layout/anchor-element.js";
+export * from "./layout/page-builder-element.js";
+export * from "./layout/rotated-element.js";
+export * from "./layout/rotated-box-element.js";
+export * from "./line-element.js";
+export * from "./row-element.js";

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

@@ -0,0 +1,23 @@
+import { PDFElement, LayoutContext } from "../pdf-element.js";
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints.js";
+/**
+ * Marks its child as a named jump target for an internal `Link({ to: name })`. Layout-transparent: it
+ * delegates `calculateLayout` to the child and records the child's top, which the renderer turns into an
+ * `Anchor` IR node (and PDFRenderer into a /Names /Dests entry). It draws nothing - the child renders
+ * exactly as it would on its own.
+ */
+export declare class AnchorElement extends PDFElement {
+    private name;
+    private child;
+    private y;
+    constructor({ name, child }: {
+        name: string;
+        child: PDFElement;
+    });
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    getProps(): {
+        name: string;
+        child: PDFElement;
+        y: number;
+    };
+}

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

@@ -0,0 +1,27 @@
+import { PDFElement } from "../pdf-element.js";
+/**
+ * Marks its child as a named jump target for an internal `Link({ to: name })`. Layout-transparent: it
+ * delegates `calculateLayout` to the child and records the child's top, which the renderer turns into an
+ * `Anchor` IR node (and PDFRenderer into a /Names /Dests entry). It draws nothing - the child renders
+ * exactly as it would on its own.
+ */
+export class AnchorElement extends PDFElement {
+    constructor({ name, child }) {
+        super();
+        this.y = 0;
+        this.name = name;
+        this.child = child;
+    }
+    calculateLayout(constraints, offset, ctx) {
+        const size = this.child.calculateLayout(constraints, offset, ctx);
+        this.y = offset.y; // the child's top - the scroll target for a link that jumps here
+        return size;
+    }
+    getProps() {
+        return {
+            name: this.name,
+            child: this.child,
+            y: this.y,
+        };
+    }
+}

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

@@ -0,0 +1,27 @@
+import { PDFElement, LayoutContext } from "../pdf-element.js";
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints.js";
+/**
+ * Adds a document-outline entry (a bookmark) that jumps to its child. Layout-transparent: it delegates
+ * `calculateLayout` to the child and records the child's top, which the renderer turns into an `Outline`
+ * IR node (and PDFRenderer into a /Outlines tree entry). `title` is the label shown in the viewer's
+ * bookmark panel; `level` (1-based, default 1) nests it under the nearest preceding smaller level. It
+ * draws nothing - the child renders exactly as it would without the bookmark.
+ */
+export declare class BookmarkElement extends PDFElement {
+    private title;
+    private level;
+    private child;
+    private y;
+    constructor({ title, level, child }: {
+        title: string;
+        level?: number;
+        child: PDFElement;
+    });
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    getProps(): {
+        title: string;
+        level: number;
+        child: PDFElement;
+        y: number;
+    };
+}

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

@@ -0,0 +1,30 @@
+import { PDFElement } from "../pdf-element.js";
+/**
+ * Adds a document-outline entry (a bookmark) that jumps to its child. Layout-transparent: it delegates
+ * `calculateLayout` to the child and records the child's top, which the renderer turns into an `Outline`
+ * IR node (and PDFRenderer into a /Outlines tree entry). `title` is the label shown in the viewer's
+ * bookmark panel; `level` (1-based, default 1) nests it under the nearest preceding smaller level. It
+ * draws nothing - the child renders exactly as it would without the bookmark.
+ */
+export class BookmarkElement extends PDFElement {
+    constructor({ title, level = 1, child }) {
+        super();
+        this.y = 0;
+        this.title = title;
+        this.level = level;
+        this.child = child;
+    }
+    calculateLayout(constraints, offset, ctx) {
+        const size = this.child.calculateLayout(constraints, offset, ctx);
+        this.y = offset.y; // the child's top - the scroll target for the bookmark
+        return size;
+    }
+    getProps() {
+        return {
+            title: this.title,
+            level: this.level,
+            child: this.child,
+            y: this.y,
+        };
+    }
+}

package/dist/elements/layout/default-text-style-element.d.ts

@@ -0,0 +1,30 @@
+import { PDFElement, LayoutContext, WithChild, SizedPDFElement } from "../pdf-element.js";
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints.js";
+import { Fragmentable, FragmentResult } from "../../layout/fragmentation.js";
+import { ResolvedTextStyle } from "../../text/text-style.js";
+interface DefaultTextStyleParams extends WithChild {
+    style: Partial<ResolvedTextStyle>;
+}
+/**
+ * Provides default text properties (font/size/color/lineHeight/align/weight) to its whole subtree -
+ * Flutter's `DefaultTextStyle`. Transparent to layout: the child takes the same constraints, offset
+ * and size; only the inherited TextStyle changes. A `Text` below still wins per property, and these
+ * overrides layer onto whatever the element already inherited from above.
+ */
+export declare class DefaultTextStyleElement extends SizedPDFElement implements Fragmentable {
+    private child;
+    private style;
+    constructor({ child, style }: DefaultTextStyleParams);
+    private childCtx;
+    fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
+    private cloneWithChild;
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    getProps(): {
+        x: number;
+        y: number;
+        width: number | undefined;
+        height: number | undefined;
+        child: PDFElement;
+    };
+}
+export {};

package/dist/elements/layout/default-text-style-element.js

@@ -0,0 +1,47 @@
+import { SizedPDFElement } from "../pdf-element.js";
+import { isFragmentable } from "../../layout/fragmentation.js";
+import { DEFAULT_TEXT_STYLE, mergeTextStyle } from "../../text/text-style.js";
+/**
+ * Provides default text properties (font/size/color/lineHeight/align/weight) to its whole subtree -
+ * Flutter's `DefaultTextStyle`. Transparent to layout: the child takes the same constraints, offset
+ * and size; only the inherited TextStyle changes. A `Text` below still wins per property, and these
+ * overrides layer onto whatever the element already inherited from above.
+ */
+export class DefaultTextStyleElement extends SizedPDFElement {
+    constructor({ child, style }) {
+        super({ x: 0, y: 0 });
+        this.child = child;
+        this.style = style;
+    }
+    childCtx(ctx) {
+        return {
+            ...ctx,
+            textStyle: mergeTextStyle(ctx.textStyle ?? DEFAULT_TEXT_STYLE, this.style),
+        };
+    }
+    // Transparent to fragmentation too: split the child against the merged context, re-wrapping each
+    // half so the remainder on the next page keeps the same defaults.
+    fragment(maxHeight, width, ctx) {
+        if (!isFragmentable(this.child))
+            return { fitted: null, remainder: this };
+        const split = this.child.fragment(maxHeight, width, this.childCtx(ctx));
+        return {
+            fitted: split.fitted ? this.cloneWithChild(split.fitted) : null,
+            remainder: split.remainder ? this.cloneWithChild(split.remainder) : null,
+        };
+    }
+    cloneWithChild(child) {
+        return new DefaultTextStyleElement({ child, style: this.style });
+    }
+    calculateLayout(constraints, offset, ctx) {
+        this.x = offset.x;
+        this.y = offset.y;
+        const size = this.child.calculateLayout(constraints, offset, this.childCtx(ctx));
+        this.width = size.width;
+        this.height = size.height;
+        return size;
+    }
+    getProps() {
+        return { x: this.x, y: this.y, width: this.width, height: this.height, child: this.child };
+    }
+}

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

@@ -1,6 +1,6 @@
-import { BoxConstraints, Offset, Size } from "../../layout/box-constraints";
-import { Fragmentable, FragmentResult } from "../../layout/fragmentation";
-import { LayoutContext, PDFElement } from "../pdf-element";
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints.js";
+import { Fragmentable, FragmentResult } from "../../layout/fragmentation.js";
+import { LayoutContext, PDFElement } from "../pdf-element.js";
 /**
  * Builds its subtree at layout time via `resolve(ctx)`, so the tree can depend on font
  * metrics (e.g. a Table resolving `"auto"` column widths from cell content). The engine

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

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeferredElement = void 0;
-const fragmentation_1 = require("../../layout/fragmentation");
-const pdf_element_1 = require("../pdf-element");
+import { isFragmentable } from "../../layout/fragmentation.js";
+import { PDFElement } from "../pdf-element.js";
 /**
  * Builds its subtree at layout time via `resolve(ctx)`, so the tree can depend on font
  * metrics (e.g. a Table resolving `"auto"` column widths from cell content). The engine
  * stays table-agnostic - the closure comes from the API layer.
  */
-class DeferredElement extends pdf_element_1.PDFElement {
+export class DeferredElement extends PDFElement {
     constructor(resolve) {
         super();
         this.resolve = resolve;
@@ -22,7 +19,7 @@ class DeferredElement extends pdf_element_1.PDFElement {
     }
     fragment(maxHeight, width, ctx) {
         const c = this.build(ctx);
-        return (0, fragmentation_1.isFragmentable)(c)
+        return isFragmentable(c)
             ? c.fragment(maxHeight, width, ctx)
             : { fitted: this, remainder: null };
     }
@@ -30,4 +27,3 @@ class DeferredElement extends pdf_element_1.PDFElement {
         return { composed: this.composed };
     }
 }
-exports.DeferredElement = DeferredElement;