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

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>;

package/dist/platform/node-fs.js

@@ -0,0 +1,10 @@
+// Node implementation of the platform file reads. In a browser bundle this whole module is swapped for
+// platform/browser-fs.ts via the package.json "browser" field, so `node:fs` never reaches the browser.
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+export function readFileBytes(path) {
+    return readFileSync(path);
+}
+export function readFileBytesAsync(path) {
+    return readFile(path);
+}

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

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

package/dist/platform/node-image.js

@@ -0,0 +1,9 @@
+// PNG decode on Node: jimp → raw RGBA pixels. jimp is lazy-imported (it pulls Node-ish bits in) so a
+// text-only render never loads it. The browser swaps this whole module for `browser-image.ts` (a Canvas
+// decode) via the package `browser` field, so neither jimp nor Buffer reach the browser bundle.
+export async function pngToRgba(bytes) {
+    const { Jimp } = await import("jimp");
+    const image = await Jimp.fromBuffer(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+    const { width, height, data } = image.bitmap;
+    return { width, height, rgba: new Uint8Array(data.buffer, data.byteOffset, data.byteLength) };
+}

package/dist/renderer/container-renderer.d.ts

@@ -1,6 +1,6 @@
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { ContainerElement } from "../elements/container-element";
-import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { ContainerElement } from "../elements/container-element.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class ContainerRenderer {
     static render(containerElement: ContainerElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
 }

package/dist/renderer/container-renderer.js

@@ -1,30 +1,15 @@
-"use strict";
-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.ContainerRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class ContainerRenderer {
-    static render(containerElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { children } = containerElement.getProps();
-            const nodes = [];
-            if (children)
-                for (const child of children) {
-                    const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
-                    if (renderer) {
-                        nodes.push(...(yield renderer(child, objectManager)));
-                    }
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class ContainerRenderer {
+    static async render(containerElement, objectManager) {
+        const { children } = containerElement.getProps();
+        const nodes = [];
+        if (children)
+            for (const child of children) {
+                const renderer = RendererRegistry.getRenderer(child);
+                if (renderer) {
+                    nodes.push(...(await renderer(child, objectManager)));
                 }
-            return nodes;
-        });
+            }
+        return nodes;
     }
 }
-exports.ContainerRenderer = ContainerRenderer;

package/dist/renderer/default-text-style-renderer.d.ts

@@ -0,0 +1,6 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { DefaultTextStyleElement } from "../elements/layout/default-text-style-element.js";
+import { IRNode } from "../ir/display-list.js";
+export declare class DefaultTextStyleRenderer {
+    static render(element: DefaultTextStyleElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
+}

package/dist/renderer/default-text-style-renderer.js

@@ -0,0 +1,10 @@
+import { RendererRegistry } from "../utils/renderer-registry.js";
+// Transparent wrapper: the text style was already resolved onto the descendants at layout time, so
+// the renderer just emits the child's display list (like PaddingRenderer).
+export class DefaultTextStyleRenderer {
+    static async render(element, objectManager) {
+        const { child } = element.getProps();
+        const renderer = RendererRegistry.getRenderer(child);
+        return renderer ? await renderer(child, objectManager) : [];
+    }
+}

package/dist/renderer/deferred-renderer.d.ts

@@ -1,6 +1,6 @@
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { DeferredElement } from "../elements/layout/deferred-element";
-import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { DeferredElement } from "../elements/layout/deferred-element.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class DeferredRenderer {
     static render(element: DeferredElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
 }

package/dist/renderer/deferred-renderer.js

@@ -1,25 +1,10 @@
-"use strict";
-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.DeferredRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class DeferredRenderer {
-    static render(element, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { composed } = element.getProps();
-            if (!composed)
-                return [];
-            const renderer = renderer_registry_1.RendererRegistry.getRenderer(composed);
-            return renderer ? renderer(composed, objectManager) : [];
-        });
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class DeferredRenderer {
+    static async render(element, objectManager) {
+        const { composed } = element.getProps();
+        if (!composed)
+            return [];
+        const renderer = RendererRegistry.getRenderer(composed);
+        return renderer ? renderer(composed, objectManager) : [];
     }
 }
-exports.DeferredRenderer = DeferredRenderer;

package/dist/renderer/expanded-renderer.d.ts

@@ -1,6 +1,6 @@
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { ExpandedElement } from "../elements";
-import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { ExpandedElement } from "../elements/index.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class ExpandedRenderer {
     static render(expandedElement: ExpandedElement, objectManager: PDFObjectManager): Promise<IRNode[]>;
 }

package/dist/renderer/expanded-renderer.js

@@ -1,23 +1,8 @@
-"use strict";
-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.ExpandedRenderer = void 0;
-const renderer_registry_1 = require("../utils/renderer-registry");
-class ExpandedRenderer {
-    static render(expandedElement, objectManager) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { child } = expandedElement.getProps();
-            const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
-            return renderer ? yield renderer(child, objectManager) : [];
-        });
+import { RendererRegistry } from "../utils/renderer-registry.js";
+export class ExpandedRenderer {
+    static async render(expandedElement, objectManager) {
+        const { child } = expandedElement.getProps();
+        const renderer = RendererRegistry.getRenderer(child);
+        return renderer ? await renderer(child, objectManager) : [];
     }
 }
-exports.ExpandedRenderer = ExpandedRenderer;

package/dist/renderer/image-renderer.d.ts

@@ -1,6 +1,6 @@
-import { ImageElement } from "../elements/image-element";
-import { PDFObjectManager } from "../utils/pdf-object-manager";
-import { IRNode } from "../ir/display-list";
+import { ImageElement } from "../elements/image-element.js";
+import { PDFObjectManager } from "../utils/pdf-object-manager.js";
+import { IRNode } from "../ir/display-list.js";
 export declare class ImageRenderer {
     static render(imageElement: ImageElement, _objectManager: PDFObjectManager): Promise<IRNode[]>;
 }