@jasy/pdf 1.0.0-alpha.1

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

@@ -0,0 +1,74 @@
+import { Color } from "../common/color";
+import { FontStyle } from "../utils/pdf-object-manager";
+/**
+ * Display list - the seam between layout and the PDF backend.
+ *
+ * Everything above this line (components, layout) produces an `IRNode[]`; the PDF
+ * backend below consumes ONLY `IRNode`s and never sees a component. The primitives
+ * are intentionally "dumb": absolute geometry + semantic style, with no PDF
+ * operators, no font indices, and no object numbers - those are the backend's job.
+ *
+ * Coordinates are in PDF points (1/72"). Which origin they use is still the
+ * producer's concern for now; centralizing the Y-flip at this seam is Phase 3.
+ */
+/**
+ * A single positioned run of text in one font / size / color. Line wrapping has
+ * already happened upstream: the producer emits one `TextRun` per laid-out line or
+ * per styled segment within a line.
+ */
+export interface TextRun {
+    type: "text";
+    x: number;
+    y: number;
+    text: string;
+    fontFamily: string;
+    fontStyle: FontStyle;
+    fontSize: number;
+    color: Color;
+}
+/** An axis-aligned rectangle. An absent `fill` or `stroke` means that part is not drawn. */
+export interface Rect {
+    type: "rect";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fill?: Color;
+    stroke?: Color;
+    strokeWidth: number;
+    /** Corner radius in points; absent/0 = sharp corners (plain `re`). */
+    radius?: number;
+}
+/** A straight line segment between two points. */
+export interface Line {
+    type: "line";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    stroke: Color;
+    strokeWidth: number;
+}
+/** A raster image, already resolved to bytes by the producer (no `CustomImage` here). */
+export interface Image {
+    type: "image";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    intrinsicWidth: number;
+    intrinsicHeight: number;
+    data: string;
+    imageType: string;
+    /** cover/contain fits clip the placement to the element's original frame. */
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Corner radius in points for the image box; absent/0 = sharp corners. */
+    radius?: number;
+}
+/** The closed set of primitives the PDF backend knows how to draw. */
+export type IRNode = TextRun | Rect | Line | Image;

package/dist/ir/display-list.js

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

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

@@ -0,0 +1,56 @@
+/**
+ * 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
+ * `BoxConstraints`, chooses a `Size` within it, and returns that size UP.
+ *
+ * `Infinity` means "unbounded" on that side - the element may be as large as it wants
+ * and should size to its own content (e.g. text height, a shrink-wrapping padding).
+ * A *tight* axis (`min === max`) forces an exact size; a *loose* axis (`min === 0`)
+ * lets the element pick anything up to `max`.
+ *
+ * This is the contract the future fragmentation pass (roadmap Phase 5) reads: a page's
+ * remaining vertical space becomes a `maxHeight`, and "does this fit?" is a constraint
+ * check, not a special case.
+ */
+export declare class BoxConstraints {
+    readonly minWidth: number;
+    readonly maxWidth: number;
+    readonly minHeight: number;
+    readonly maxHeight: number;
+    constructor(minWidth?: number, maxWidth?: number, minHeight?: number, maxHeight?: number);
+    /** Forces an exact size: the element has no choice but `width` x `height`. */
+    static tight(width: number, height: number): BoxConstraints;
+    /** Tight only on the axes given; the others stay unbounded (0..Infinity). */
+    static tightFor({ width, height }: {
+        width?: number;
+        height?: number;
+    }): BoxConstraints;
+    /** Caps each axis at `max` but allows anything down to zero (shrink-wrap). */
+    static loose(maxWidth: number, maxHeight: number): BoxConstraints;
+    get hasBoundedWidth(): boolean;
+    get hasBoundedHeight(): boolean;
+    get isTight(): boolean;
+    /** Clamps a desired width into [minWidth, maxWidth]. */
+    constrainWidth(width?: number): number;
+    /** Clamps a desired height into [minHeight, maxHeight]. */
+    constrainHeight(height?: number): number;
+    /** Clamps a desired size into this box on both axes. */
+    constrain(size: Size): Size;
+    /**
+     * Shrinks the box by `horizontal`/`vertical` on both bounds (never below zero) -
+     * what a padding/border element hands its child after reserving its own insets.
+     */
+    deflate(horizontal: number, vertical: number): BoxConstraints;
+    /** Returns the constraints clamped to lie within `parent` (Flutter's enforce). */
+    enforce(parent: BoxConstraints): BoxConstraints;
+}
+/** The size an element resolves to and returns UP the tree. */
+export interface Size {
+    width: number;
+    height: number;
+}
+/** The absolute top-left position a parent assigns to a child (threaded DOWN). */
+export interface Offset {
+    x: number;
+    y: number;
+}

package/dist/layout/box-constraints.js

@@ -0,0 +1,73 @@
+"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
+ * `BoxConstraints`, chooses a `Size` within it, and returns that size UP.
+ *
+ * `Infinity` means "unbounded" on that side - the element may be as large as it wants
+ * and should size to its own content (e.g. text height, a shrink-wrapping padding).
+ * A *tight* axis (`min === max`) forces an exact size; a *loose* axis (`min === 0`)
+ * lets the element pick anything up to `max`.
+ *
+ * This is the contract the future fragmentation pass (roadmap Phase 5) reads: a page's
+ * remaining vertical space becomes a `maxHeight`, and "does this fit?" is a constraint
+ * check, not a special case.
+ */
+class BoxConstraints {
+    constructor(minWidth = 0, maxWidth = Infinity, minHeight = 0, maxHeight = Infinity) {
+        this.minWidth = minWidth;
+        this.maxWidth = maxWidth;
+        this.minHeight = minHeight;
+        this.maxHeight = maxHeight;
+    }
+    /** Forces an exact size: the element has no choice but `width` x `height`. */
+    static tight(width, height) {
+        return new BoxConstraints(width, width, height, height);
+    }
+    /** 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);
+    }
+    /** Caps each axis at `max` but allows anything down to zero (shrink-wrap). */
+    static loose(maxWidth, maxHeight) {
+        return new BoxConstraints(0, maxWidth, 0, maxHeight);
+    }
+    get hasBoundedWidth() {
+        return this.maxWidth !== Infinity;
+    }
+    get hasBoundedHeight() {
+        return this.maxHeight !== Infinity;
+    }
+    get isTight() {
+        return this.minWidth === this.maxWidth && this.minHeight === this.maxHeight;
+    }
+    /** Clamps a desired width into [minWidth, maxWidth]. */
+    constrainWidth(width = Infinity) {
+        return Math.max(this.minWidth, Math.min(width, this.maxWidth));
+    }
+    /** Clamps a desired height into [minHeight, maxHeight]. */
+    constrainHeight(height = Infinity) {
+        return Math.max(this.minHeight, Math.min(height, this.maxHeight));
+    }
+    /** Clamps a desired size into this box on both axes. */
+    constrain(size) {
+        return {
+            width: this.constrainWidth(size.width),
+            height: this.constrainHeight(size.height),
+        };
+    }
+    /**
+     * Shrinks the box by `horizontal`/`vertical` on both bounds (never below zero) -
+     * what a padding/border element hands its child after reserving its own insets.
+     */
+    deflate(horizontal, vertical) {
+        return new BoxConstraints(Math.max(0, this.minWidth - horizontal), Math.max(0, this.maxWidth - horizontal), Math.max(0, this.minHeight - vertical), Math.max(0, this.maxHeight - vertical));
+    }
+    /** Returns the constraints clamped to lie within `parent` (Flutter's enforce). */
+    enforce(parent) {
+        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

@@ -0,0 +1,42 @@
+import { LayoutContext, PDFElement } from "../elements/pdf-element";
+/**
+ * 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
+ * not and is re-fragmented in the NEXT region. Either side may be null:
+ * `fitted === null` means nothing fit, `remainder === null` means the element is done.
+ *
+ * Both sides are plain `PDFElement`s - the remainder is a normal element describing the
+ * rest, so no information flows back UP after a break. This one-way flow is what keeps
+ * fragmentation terminating (no overflow-cascade fixpoint).
+ */
+export interface FragmentResult {
+    fitted: PDFElement | null;
+    remainder: PDFElement | null;
+}
+/**
+ * An element that knows how to split itself across regions. Width is already finalized
+ * by the measure step (width-stable); `fragment` only splits height, packing into
+ * `maxHeight`.
+ */
+export interface Fragmentable {
+    fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
+}
+export declare function isFragmentable(element: PDFElement): element is PDFElement & Fragmentable;
+/**
+ * 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
+ * child is itself fragmented if it can be, otherwise placed/deferred whole. Everything
+ * after the break spills. Progress is guaranteed: if nothing fit, the straddling child is
+ * forced on (it overflows) so the next region always advances.
+ *
+ * `gap` is the spacing the parent inserts BETWEEN children (a `Column` gap) - it must be
+ * counted here, otherwise the packed fragment renders taller than `maxHeight` (the gaps
+ * are added back at render time) and overflows the region.
+ *
+ * Shared by every element that lays out a vertical stack and can split it across regions
+ * (Container, and the decorated boxes Padding/Rectangle).
+ */
+export declare function packChildren(children: PDFElement[], maxHeight: number, width: number, ctx: LayoutContext, gap?: number): {
+    fitted: PDFElement[];
+    remainder: PDFElement[];
+};

package/dist/layout/fragmentation.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFragmentable = isFragmentable;
+exports.packChildren = packChildren;
+const box_constraints_1 = require("./box-constraints");
+function isFragmentable(element) {
+    return ("fragment" in element &&
+        typeof element.fragment === "function");
+}
+/**
+ * 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
+ * child is itself fragmented if it can be, otherwise placed/deferred whole. Everything
+ * after the break spills. Progress is guaranteed: if nothing fit, the straddling child is
+ * forced on (it overflows) so the next region always advances.
+ *
+ * `gap` is the spacing the parent inserts BETWEEN children (a `Column` gap) - it must be
+ * counted here, otherwise the packed fragment renders taller than `maxHeight` (the gaps
+ * are added back at render time) and overflows the region.
+ *
+ * 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) {
+    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;
+        // 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) {
+            fitted.push(child);
+            usedHeight += lead + childHeight;
+            continue;
+        }
+        // `child` straddles the boundary. Try to split it; otherwise place/defer it whole.
+        const remaining = maxHeight - usedHeight - lead;
+        let placedPart = false;
+        if (isFragmentable(child)) {
+            const split = child.fragment(Math.max(0, remaining), width, ctx);
+            if (split.fitted) {
+                fitted.push(split.fitted);
+                if (split.remainder)
+                    remainder.push(split.remainder);
+                placedPart = true;
+            }
+        }
+        if (!placedPart) {
+            if (fitted.length === 0)
+                fitted.push(child);
+            else
+                remainder.push(child);
+        }
+        for (let j = i + 1; j < children.length; j++)
+            remainder.push(children[j]);
+        break;
+    }
+    return { fitted, remainder };
+}

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

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

package/dist/renderer/container-renderer.js

@@ -0,0 +1,30 @@
+"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)));
+                    }
+                }
+            return nodes;
+        });
+    }
+}
+exports.ContainerRenderer = ContainerRenderer;

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

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

package/dist/renderer/deferred-renderer.js

@@ -0,0 +1,25 @@
+"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) : [];
+        });
+    }
+}
+exports.DeferredRenderer = DeferredRenderer;

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

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

package/dist/renderer/expanded-renderer.js

@@ -0,0 +1,23 @@
+"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) : [];
+        });
+    }
+}
+exports.ExpandedRenderer = ExpandedRenderer;

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

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

package/dist/renderer/image-renderer.js

@@ -0,0 +1,85 @@
+"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.ImageRenderer = void 0;
+const image_element_1 = require("../elements/image-element");
+const image_helper_1 = require("../utils/image-helper");
+class ImageRenderer {
+    static render(imageElement, _objectManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Load the image and convert it in a binary string
+            let { x, y, width, height, image, fit, radius } = imageElement.getProps();
+            yield image.init(); // Load and initialize the image
+            const imageType = yield image.getImageType(); // For the moment we can handle `png` and `jpg/jpeg` files
+            const fileData = yield image.getFileData();
+            const dimensions = yield image.getImageDimensions();
+            if (!fileData) {
+                throw new Error("File data cannot be `null`");
+            }
+            // JPEG embeds raw (PDF decodes DCTDecode natively). PNG is not a valid Flate stream,
+            // so decode it to raw DeviceRGB samples that the FlateDecode XObject path expects.
+            const embedData = imageType === "FlateDecode"
+                ? (yield (0, image_helper_1.decodePngToRgbFlate)(Buffer.from(fileData, "binary"))).data
+                : fileData;
+            // Now we check the `fit` property and changing the dimensions of the image
+            // Optionally we must add an overflow container
+            let mustCreateOverflowContainer = false;
+            const containerDimensions = JSON.parse(JSON.stringify({ x, y, width, height })); // Deep clone images dimensions
+            switch (fit) {
+                case image_element_1.BoxFit.cover:
+                    mustCreateOverflowContainer = true;
+                    const fitCoverResult = (0, image_helper_1.applyCoverFit)(dimensions.width, dimensions.height, width !== null && width !== void 0 ? width : 0, height !== null && height !== void 0 ? height : 0);
+                    x += fitCoverResult.offsetX;
+                    y += fitCoverResult.offsetY;
+                    width = fitCoverResult.width;
+                    height = fitCoverResult.height;
+                    break;
+                case image_element_1.BoxFit.contain:
+                    mustCreateOverflowContainer = true;
+                    const fitContainResult = (0, image_helper_1.applyContainFit)(dimensions.width, dimensions.height, width !== null && width !== void 0 ? width : 0, height !== null && height !== void 0 ? height : 0);
+                    x += fitContainResult.offsetX;
+                    y += fitContainResult.offsetY;
+                    width = fitContainResult.width;
+                    height = fitContainResult.height;
+                    break;
+                case image_element_1.BoxFit.none:
+                    const fitNoneResult = (0, image_helper_1.applyFitNone)(dimensions.width, dimensions.height, width !== null && width !== void 0 ? width : 0, height !== null && height !== void 0 ? height : 0);
+                    x += fitNoneResult.offsetX;
+                    y += fitNoneResult.offsetY;
+                    width = fitNoneResult.width;
+                    height = fitNoneResult.height;
+                    break;
+                case image_element_1.BoxFit.fill:
+                    const fitFillResult = (0, image_helper_1.applyFillFit)(width !== null && width !== void 0 ? width : 0, height !== null && height !== void 0 ? height : 0);
+                    width = fitFillResult.width;
+                    height = fitFillResult.height;
+            }
+            // A radius rounds the image BOX (the element frame), so it clips to that frame too -
+            // independent of the cover/contain overflow clip.
+            const wantsClip = mustCreateOverflowContainer || (radius !== null && radius !== void 0 ? radius : 0) > 0;
+            // The fitted geometry becomes a display-list primitive; the backend registers
+            // the XObject and emits the placement (+ clip, rounded when a radius is set).
+            const node = Object.assign(Object.assign({ type: "image", x,
+                y, width: width, height: height, intrinsicWidth: dimensions.width, intrinsicHeight: dimensions.height, data: embedData, imageType }, (radius ? { radius } : {})), (wantsClip
+                ? {
+                    clip: {
+                        x: containerDimensions.x,
+                        y: containerDimensions.y,
+                        width: containerDimensions.width,
+                        height: containerDimensions.height,
+                    },
+                }
+                : {}));
+            return [node];
+        });
+    }
+}
+exports.ImageRenderer = ImageRenderer;

package/dist/renderer/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./container-renderer";
+export * from "./page-renderer";
+export * from "./pdf-document-class";
+export * from "./pdf-document-renderer";
+export * from "./pdf-renderer";
+export * from "./rectangle-renderer";
+export * from "./text-renderer";
+export * from "./expanded-renderer";
+export * from "./line-renderer";
+export * from "./row-renderer";

package/dist/renderer/index.js

@@ -0,0 +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 });
+__exportStar(require("./container-renderer"), exports);
+__exportStar(require("./page-renderer"), exports);
+__exportStar(require("./pdf-document-class"), exports);
+__exportStar(require("./pdf-document-renderer"), exports);
+__exportStar(require("./pdf-renderer"), exports);
+__exportStar(require("./rectangle-renderer"), exports);
+__exportStar(require("./text-renderer"), exports);
+__exportStar(require("./expanded-renderer"), exports);
+__exportStar(require("./line-renderer"), exports);
+__exportStar(require("./row-renderer"), exports);

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

@@ -0,0 +1,6 @@
+import { PDFObjectManager } from "../utils/pdf-object-manager";
+import { LineElement } from "../elements";
+import { IRNode } from "../ir/display-list";
+export declare class LineRenderer {
+    static render(lineElement: LineElement, _objectManager: PDFObjectManager): Promise<IRNode[]>;
+}

package/dist/renderer/line-renderer.js

@@ -0,0 +1,30 @@
+"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.LineRenderer = void 0;
+class LineRenderer {
+    static render(lineElement, _objectManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { x, y, xEnd, yEnd, color, strokeWidth } = lineElement.getProps();
+            const node = {
+                type: "line",
+                x1: x,
+                y1: y,
+                x2: xEnd,
+                y2: yEnd,
+                stroke: color,
+                strokeWidth: strokeWidth,
+            };
+            return [node];
+        });
+    }
+}
+exports.LineRenderer = LineRenderer;

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

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

package/dist/renderer/padding-renderer.js

@@ -0,0 +1,23 @@
+"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.PaddingRenderer = void 0;
+const renderer_registry_1 = require("../utils/renderer-registry");
+class PaddingRenderer {
+    static render(paddingElement, objectManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { child } = paddingElement.getProps();
+            const renderer = renderer_registry_1.RendererRegistry.getRenderer(child);
+            return renderer ? yield renderer(child, objectManager) : [];
+        });
+    }
+}
+exports.PaddingRenderer = PaddingRenderer;

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

@@ -0,0 +1,5 @@
+import { PageElement } from "../elements/page-element";
+import { PDFObjectManager } from "../utils/pdf-object-manager";
+export declare class PageRenderer {
+    static render(page: PageElement, objectManager: PDFObjectManager): Promise<number>;
+}