@lpdfio/lpdf 0.0.3

package/dist/canvas.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LpdfCanvas = exports.CanvasTransform = void 0;
+// ── CanvasTransform ───────────────────────────────────────────────────────────
+class CanvasTransform {
+    constructor(matrix) {
+        this.matrix = matrix;
+    }
+    /** Rotate clockwise by `degrees` around the origin, or around (cx, cy). */
+    static rotate(degrees, cx = 0, cy = 0) {
+        const rad = (degrees * Math.PI) / 180;
+        const cos = Math.cos(rad);
+        const sin = Math.sin(rad);
+        const e = cx - cx * cos + cy * sin;
+        const f = cy - cx * sin - cy * cos;
+        return new CanvasTransform([cos, sin, -sin, cos, e, f]);
+    }
+    /** Scale by sx (and optionally sy; defaults to sx for uniform scale). */
+    static scale(sx, sy) {
+        return new CanvasTransform([sx, 0, 0, sy ?? sx, 0, 0]);
+    }
+    /** Translate by (tx, ty). */
+    static translate(tx, ty) {
+        return new CanvasTransform([1, 0, 0, 1, tx, ty]);
+    }
+    /**
+     * Combine: apply `other` first, then `this`.
+     * Equivalent to matrix multiplication: this × other.
+     */
+    then(other) {
+        const [a1, b1, c1, d1, e1, f1] = this.matrix;
+        const [a2, b2, c2, d2, e2, f2] = other.matrix;
+        return new CanvasTransform([
+            a1 * a2 + c1 * b2,
+            b1 * a2 + d1 * b2,
+            a1 * c2 + c1 * d2,
+            b1 * c2 + d1 * d2,
+            a1 * e2 + c1 * f2 + e1,
+            b1 * e2 + d1 * f2 + f1,
+        ]);
+    }
+    /** Serialise to the `"matrix(a,b,c,d,e,f)"` string form that Rust `jattr()` reads. */
+    toString() {
+        return `matrix(${this.matrix.join(',')})`;
+    }
+}
+exports.CanvasTransform = CanvasTransform;
+// ── LpdfCanvas factory ────────────────────────────────────────────────────────
+function rect(x, y, w, h, style) {
+    const attrs = {
+        x: String(x), y: String(y), w: String(w), h: String(h),
+    };
+    if (style?.fill !== undefined)
+        attrs['fill'] = style.fill;
+    if (style?.stroke !== undefined)
+        attrs['stroke'] = style.stroke;
+    if (style?.strokeWidth !== undefined)
+        attrs['stroke-width'] = String(style.strokeWidth);
+    if (style?.strokeDash !== undefined)
+        attrs['stroke-dash'] = style.strokeDash.join(' ');
+    if (style?.borderRadius !== undefined)
+        attrs['radius'] = String(style.borderRadius);
+    return { type: 'canvas-rect', attrs };
+}
+function line(x1, y1, x2, y2, style) {
+    const attrs = {
+        x1: String(x1), y1: String(y1), x2: String(x2), y2: String(y2),
+    };
+    if (style?.stroke !== undefined)
+        attrs['stroke'] = style.stroke;
+    if (style?.strokeWidth !== undefined)
+        attrs['stroke-width'] = String(style.strokeWidth);
+    if (style?.strokeDash !== undefined)
+        attrs['stroke-dash'] = style.strokeDash.join(' ');
+    if (style?.lineCap !== undefined)
+        attrs['line-cap'] = style.lineCap;
+    if (style?.lineJoin !== undefined)
+        attrs['line-join'] = style.lineJoin;
+    return { type: 'canvas-line', attrs };
+}
+function ellipse(cx, cy, rx, ry, style) {
+    const attrs = {
+        cx: String(cx), cy: String(cy), rx: String(rx), ry: String(ry),
+    };
+    if (style?.fill !== undefined)
+        attrs['fill'] = style.fill;
+    if (style?.stroke !== undefined)
+        attrs['stroke'] = style.stroke;
+    if (style?.strokeWidth !== undefined)
+        attrs['stroke-width'] = String(style.strokeWidth);
+    if (style?.strokeDash !== undefined)
+        attrs['stroke-dash'] = style.strokeDash.join(' ');
+    return { type: 'canvas-ellipse', attrs };
+}
+function circle(cx, cy, r, style) {
+    const attrs = {
+        cx: String(cx), cy: String(cy), r: String(r),
+    };
+    if (style?.fill !== undefined)
+        attrs['fill'] = style.fill;
+    if (style?.stroke !== undefined)
+        attrs['stroke'] = style.stroke;
+    if (style?.strokeWidth !== undefined)
+        attrs['stroke-width'] = String(style.strokeWidth);
+    if (style?.strokeDash !== undefined)
+        attrs['stroke-dash'] = style.strokeDash.join(' ');
+    return { type: 'canvas-circle', attrs };
+}
+function path(d, style) {
+    const attrs = { d };
+    if (style?.fill !== undefined)
+        attrs['fill'] = style.fill;
+    if (style?.stroke !== undefined)
+        attrs['stroke'] = style.stroke;
+    if (style?.strokeWidth !== undefined)
+        attrs['stroke-width'] = String(style.strokeWidth);
+    if (style?.strokeDash !== undefined)
+        attrs['stroke-dash'] = style.strokeDash.join(' ');
+    if (style?.fillRuleEvenodd !== undefined)
+        attrs['fill-rule'] = style.fillRuleEvenodd ? 'evenodd' : 'nonzero';
+    if (style?.lineCap !== undefined)
+        attrs['line-cap'] = style.lineCap;
+    if (style?.lineJoin !== undefined)
+        attrs['line-join'] = style.lineJoin;
+    return { type: 'canvas-path', attrs };
+}
+function canvasText(x, y, content, style, runs) {
+    const attrs = { x: String(x), y: String(y) };
+    if (style?.font !== undefined)
+        attrs['font'] = style.font;
+    if (style?.size !== undefined)
+        attrs['font-size'] = String(style.size);
+    if (style?.color !== undefined)
+        attrs['color'] = style.color;
+    if (style?.align !== undefined)
+        attrs['align'] = style.align;
+    if (style?.lineHeight !== undefined)
+        attrs['line-height'] = String(style.lineHeight);
+    if (style?.width !== undefined)
+        attrs['w'] = String(style.width);
+    const node = { type: 'canvas-text', text: content, attrs };
+    if (runs && runs.length > 0) {
+        node.runs = runs.map(r => {
+            const runAttrs = {};
+            if (r.font !== undefined)
+                runAttrs['font'] = r.font;
+            if (r.size !== undefined)
+                runAttrs['font-size'] = String(r.size);
+            if (r.color !== undefined)
+                runAttrs['color'] = r.color;
+            return { text: r.text, attrs: runAttrs };
+        });
+    }
+    return node;
+}
+function img(x, y, w, h, name) {
+    return {
+        type: 'canvas-img',
+        attrs: { x: String(x), y: String(y), w: String(w), h: String(h), name },
+    };
+}
+function layer(nodes, options) {
+    const attrs = {};
+    if (options?.page !== undefined)
+        attrs['page'] = options.page;
+    if (options?.opacity !== undefined)
+        attrs['opacity'] = String(options.opacity);
+    if (options?.transform !== undefined)
+        attrs['transform'] = options.transform.toString();
+    return { type: 'canvas-layer', attrs, nodes };
+}
+exports.LpdfCanvas = Object.freeze({
+    rect,
+    line,
+    ellipse,
+    circle,
+    path,
+    text: canvasText,
+    img,
+    layer,
+});

package/dist/engine.d.ts

@@ -0,0 +1,70 @@
+import type { RenderOptions } from './_shared';
+import type { LpdfDocument } from './kit';
+/** Thrown when the lpdf engine returns a layout or parse error. */
+export declare class LpdfRenderError extends Error {
+    constructor(message: string);
+}
+/** PDF permission flags for RC4-128 encryption. All flags default to `true` (allowed). */
+export interface EncryptPermissions {
+    print?: boolean;
+    modify?: boolean;
+    copy?: boolean;
+    annotate?: boolean;
+    fill_forms?: boolean;
+    accessibility?: boolean;
+    assemble?: boolean;
+    print_hq?: boolean;
+}
+/** RC4-128 encryption options passed to {@link LpdfEngine.setEncryption}. */
+export interface EncryptOptions {
+    /** Open password shown to readers. Empty string = no open password required. */
+    userPassword: string;
+    /** Owner (permissions) password. Required; must be non-empty. */
+    ownerPassword: string;
+    /** Permission flags applied to the document. Omitted flags default to `true`. */
+    permissions?: EncryptPermissions;
+}
+export declare class LpdfEngine {
+    private readonly _licenseKey;
+    private readonly _opts;
+    private readonly _fonts;
+    private readonly _images;
+    private _disposed;
+    private _encrypt;
+    constructor(licenseKey: string, options?: RenderOptions);
+    /**
+     * Register raw TTF/OTF bytes for a custom font name used in `<font src="…">`.
+     * Call before `renderPdf`. Returns `this` for chaining.
+     */
+    loadFont(name: string, bytes: Uint8Array): this;
+    /**
+     * Register raw image bytes (PNG or JPEG) for an image name used in `<img name="…">`.
+     * Call before `renderPdf`. Returns `this` for chaining.
+     */
+    loadImage(name: string, bytes: Uint8Array): this;
+    /**
+     * Configure RC4-128 encryption for all subsequent `renderPdf` calls.
+     * Returns `this` for chaining.
+     */
+    setEncryption(options: EncryptOptions): this;
+    /**
+     * Remove any previously configured encryption.
+     * Returns `this` for chaining.
+     */
+    clearEncryption(): this;
+    /**
+     * Release held resources. Idempotent. Subsequent `renderPdf` / `loadFont`
+     * calls after disposal will throw.
+     */
+    dispose(): void;
+    [Symbol.dispose](): void;
+    private _throwIfDisposed;
+    /**
+     * Render an lpdf XML string to PDF bytes (Node.js).
+     */
+    renderPdf(input: string, callOptions?: RenderOptions): Promise<Uint8Array>;
+    /**
+     * Render an `LpdfDocument` tree (built with `LpdfKit`) to PDF bytes (Node.js).
+     */
+    renderPdf(input: LpdfDocument, callOptions?: RenderOptions): Promise<Uint8Array>;
+}

package/dist/engine.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LpdfEngine = exports.LpdfRenderError = void 0;
+const node_fs_1 = require("node:fs");
+// require() path is relative to the compiled output at dist/engine.js.
+// In the published package, wasm-pack artifacts live in dist/wasm/.
+// In the monorepo, `npm run build` copies them there from <root>/dist/node/.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const wasmModule = require('./wasm/lpdf.js');
+const WasmEngine = wasmModule.LpdfEngine;
+/** Thrown when the lpdf engine returns a layout or parse error. */
+class LpdfRenderError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'LpdfRenderError';
+    }
+}
+exports.LpdfRenderError = LpdfRenderError;
+class LpdfEngine {
+    constructor(licenseKey, options = {}) {
+        this._fonts = new Map();
+        this._images = new Map();
+        this._disposed = false;
+        this._encrypt = null;
+        this._licenseKey = licenseKey;
+        this._opts = options;
+    }
+    /**
+     * Register raw TTF/OTF bytes for a custom font name used in `<font src="…">`.
+     * Call before `renderPdf`. Returns `this` for chaining.
+     */
+    loadFont(name, bytes) {
+        this._throwIfDisposed();
+        this._fonts.set(name, bytes);
+        return this;
+    }
+    /**
+     * Register raw image bytes (PNG or JPEG) for an image name used in `<img name="…">`.
+     * Call before `renderPdf`. Returns `this` for chaining.
+     */
+    loadImage(name, bytes) {
+        this._throwIfDisposed();
+        this._images.set(name, bytes);
+        return this;
+    }
+    /**
+     * Configure RC4-128 encryption for all subsequent `renderPdf` calls.
+     * Returns `this` for chaining.
+     */
+    setEncryption(options) {
+        this._throwIfDisposed();
+        this._encrypt = options;
+        return this;
+    }
+    /**
+     * Remove any previously configured encryption.
+     * Returns `this` for chaining.
+     */
+    clearEncryption() {
+        this._throwIfDisposed();
+        this._encrypt = null;
+        return this;
+    }
+    /**
+     * Release held resources. Idempotent. Subsequent `renderPdf` / `loadFont`
+     * calls after disposal will throw.
+     */
+    dispose() {
+        this._disposed = true;
+    }
+    [Symbol.dispose]() { this.dispose(); }
+    _throwIfDisposed() {
+        if (this._disposed)
+            throw new Error('LpdfEngine has been disposed.');
+    }
+    async renderPdf(input, callOptions = {}) {
+        this._throwIfDisposed();
+        // Merge fonts: instance-level loadFont() calls take precedence over the
+        // deprecated fontBytes option, which is kept for one-version compat.
+        const allFonts = new Map(this._fonts);
+        const extraBytes = { ...this._opts.fontBytes, ...callOptions.fontBytes };
+        for (const [name, bytes] of Object.entries(extraBytes)) {
+            if (!allFonts.has(name))
+                allFonts.set(name, bytes);
+        }
+        const engine = new WasmEngine(this._licenseKey);
+        const createdOn = callOptions.createdOn ?? this._opts.createdOn;
+        if (createdOn) {
+            engine.set_created_on(createdOn);
+        }
+        let pdf;
+        try {
+            if (typeof input === 'string') {
+                // XML path — auto-load fonts and images declared via src="…".
+                const xml = input;
+                for (const [key, src] of extractAssetSrcs(xml, 'font')) {
+                    if (!allFonts.has(key)) {
+                        try {
+                            allFonts.set(key, (0, node_fs_1.readFileSync)(src));
+                        }
+                        catch { /* not found; Rust falls back to Helvetica */ }
+                    }
+                }
+                for (const [name, bytes] of allFonts) {
+                    engine.load_font(name, bytes);
+                }
+                for (const [name, bytes] of this._images) {
+                    engine.load_image(name, bytes);
+                }
+                // Auto-load images declared via <image src="…"> that weren't pre-loaded.
+                for (const [key, src] of extractAssetSrcs(xml, 'image')) {
+                    if (!this._images.has(key)) {
+                        try {
+                            engine.load_image(key, (0, node_fs_1.readFileSync)(src));
+                        }
+                        catch { /* skip unresolvable image */ }
+                    }
+                }
+                if (this._encrypt) {
+                    const permsJson = JSON.stringify(this._encrypt.permissions ?? {});
+                    engine.set_encryption(this._encrypt.userPassword, this._encrypt.ownerPassword, permsJson);
+                }
+                const dataJson = callOptions.data != null ? JSON.stringify(callOptions.data) : null;
+                pdf = engine.render_pdf(xml, dataJson);
+            }
+            else {
+                // JSON (Kit tree) path — pass JSON directly to render_tree_pdf.
+                const json = JSON.stringify(input);
+                for (const [key, src] of extractFontSrcsFromJson(json)) {
+                    if (!allFonts.has(key)) {
+                        try {
+                            allFonts.set(key, (0, node_fs_1.readFileSync)(src));
+                        }
+                        catch { /* not found; Rust falls back to Helvetica */ }
+                    }
+                }
+                for (const [name, bytes] of allFonts) {
+                    engine.load_font(name, bytes);
+                }
+                for (const [name, bytes] of this._images) {
+                    engine.load_image(name, bytes);
+                }
+                if (this._encrypt) {
+                    const permsJson = JSON.stringify(this._encrypt.permissions ?? {});
+                    engine.set_encryption(this._encrypt.userPassword, this._encrypt.ownerPassword, permsJson);
+                }
+                pdf = engine.render_tree_pdf(json);
+            }
+        }
+        catch (e) {
+            engine.free();
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new LpdfRenderError(msg);
+        }
+        engine.free();
+        return pdf;
+    }
+}
+exports.LpdfEngine = LpdfEngine;
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/** Extract `ref??name → src` pairs from `<font>` or `<image>` tags in XML. */
+function extractAssetSrcs(xml, tag) {
+    const result = new Map();
+    const re = tag === 'font' ? /<font\s[^>]*>/g : /<image\s[^>]*>/g;
+    for (const match of xml.matchAll(re)) {
+        const t = match[0];
+        const name = /\bname="([^"]*)"/.exec(t)?.[1];
+        const ref = /\bref="([^"]*)"/.exec(t)?.[1];
+        const src = /\bsrc="([^"]*)"/.exec(t)?.[1];
+        const key = ref ?? name;
+        if (key && src)
+            result.set(key, src);
+    }
+    return result;
+}
+/** Extract `ref??name → src` pairs from `attrs.tokens.fonts[name].src` in a kit JSON string. */
+function extractFontSrcsFromJson(json) {
+    const result = new Map();
+    try {
+        const doc = JSON.parse(json);
+        const fonts = doc?.attrs?.tokens?.fonts ?? {};
+        for (const [name, def] of Object.entries(fonts)) {
+            if (def.src) {
+                const key = def.ref ?? name;
+                result.set(key, def.src);
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+export * from './engine';
+export * from './kit';
+export * from './layout';
+export * from './canvas';
+export * from './_shared';
+export { kitToXml } from './kit-to-xml';
+import { LpdfEngine } from './engine';
+export declare const Lpdf: Readonly<{
+    Engine: typeof LpdfEngine;
+    Kit: Readonly<{
+        layout: (nodes?: import("./layout").LpdfNode[]) => import("./kit").LpdfLayoutBlock;
+        canvas: (layers?: import("./canvas").LpdfCanvasLayerNode[]) => import("./kit").LpdfCanvasBlock;
+        section: (input?: import("./kit").SectionInput) => import("./kit").LpdfSectionNode;
+        document: (input?: import("./kit").DocumentInput) => import("./kit").LpdfDocument;
+    }>;
+    Layout: Readonly<{
+        stack: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").StackOptions) => import("./layout").LpdfContainerNode;
+        flank: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").FlankOptions) => import("./layout").LpdfContainerNode;
+        split: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").SplitOptions) => import("./layout").LpdfContainerNode;
+        cluster: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").ClusterOptions) => import("./layout").LpdfContainerNode;
+        grid: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").GridOptions) => import("./layout").LpdfContainerNode;
+        frame: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").FrameOptions) => import("./layout").LpdfContainerNode;
+        link: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").LinkOptions) => import("./layout").LpdfContainerNode;
+        text: (nodes?: (string | import("./layout").LpdfSpanNode)[], options?: import("./layout").TextOptions) => import("./layout").LpdfTextNode;
+        span: (nodes?: string[], options?: import("./layout").SpanOptions) => import("./layout").LpdfSpanNode;
+        divider: (options?: import("./layout").DividerOptions) => import("./layout").LpdfDividerNode;
+        img: (options: import("./layout").ImgOptions) => import("./layout").LpdfImgNode;
+        barcode: (options: import("./layout").BarcodeOptions) => import("./layout").LpdfBarcodeNode;
+        table: (options: import("./layout").TableOptions, nodes?: (import("./layout").LpdfTheadNode | import("./layout").LpdfTrNode)[]) => import("./layout").LpdfTableNode;
+        thead: (nodes?: import("./layout").LpdfTdNode[], options?: import("./layout").TheadOptions) => import("./layout").LpdfTheadNode;
+        tr: (nodes?: import("./layout").LpdfTdNode[], options?: import("./layout").TrOptions) => import("./layout").LpdfTrNode;
+        td: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").TdOptions) => import("./layout").LpdfTdNode;
+        region: (pin: string, nodes?: import("./layout").LpdfNode[], options?: import("./layout").RegionOptions) => import("./layout").LpdfRegionNode;
+    }>;
+    Canvas: Readonly<{
+        rect: (x: number, y: number, w: number, h: number, style?: import("./canvas").CanvasRectStyle) => import("./canvas").LpdfCanvasRectNode;
+        line: (x1: number, y1: number, x2: number, y2: number, style?: import("./canvas").CanvasLineStyle) => import("./canvas").LpdfCanvasLineNode;
+        ellipse: (cx: number, cy: number, rx: number, ry: number, style?: import("./canvas").CanvasEllipseStyle) => import("./canvas").LpdfCanvasEllipseNode;
+        circle: (cx: number, cy: number, r: number, style?: import("./canvas").CanvasEllipseStyle) => import("./canvas").LpdfCanvasCircleNode;
+        path: (d: string, style?: import("./canvas").CanvasPathStyle) => import("./canvas").LpdfCanvasPathNode;
+        text: (x: number, y: number, content: string, style?: import("./canvas").CanvasTextStyle, runs?: import("./canvas").CanvasRun[]) => import("./canvas").LpdfCanvasTextNode;
+        img: (x: number, y: number, w: number, h: number, name: string) => import("./canvas").LpdfCanvasImgNode;
+        layer: (nodes: import("./canvas").LpdfCanvasPrimitiveNode[], options?: import("./canvas").CanvasLayerOptions) => import("./canvas").LpdfCanvasLayerNode;
+    }>;
+}>;

package/dist/index.js

@@ -0,0 +1,34 @@
+"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.Lpdf = exports.kitToXml = void 0;
+__exportStar(require("./engine"), exports);
+__exportStar(require("./kit"), exports);
+__exportStar(require("./layout"), exports);
+__exportStar(require("./canvas"), exports);
+__exportStar(require("./_shared"), exports);
+var kit_to_xml_1 = require("./kit-to-xml");
+Object.defineProperty(exports, "kitToXml", { enumerable: true, get: function () { return kit_to_xml_1.kitToXml; } });
+const engine_1 = require("./engine");
+const kit_1 = require("./kit");
+const layout_1 = require("./layout");
+const canvas_1 = require("./canvas");
+exports.Lpdf = Object.freeze({
+    Engine: engine_1.LpdfEngine,
+    Kit: kit_1.LpdfKit,
+    Layout: layout_1.LpdfLayout,
+    Canvas: canvas_1.LpdfCanvas,
+});

package/dist/kit-to-xml.d.ts

@@ -0,0 +1,30 @@
+/**
+ * kitToXml — serialise an LpdfDocument tree (produced by LpdfKit) back to an
+ * lpdf XML string that can be passed directly to `LpdfEngine.renderPdf()` or
+ * saved to disk.
+ *
+ * The serialisation is performed by the Rust core (exposed as a WASM export)
+ * so every adapter produces identical XML and any schema change only requires
+ * a single Rust update.
+ *
+ * @example
+ * ```ts
+ * import { LpdfKit, kitToXml } from './dist/index.js';
+ *
+ * const doc = LpdfKit.document({ nodes: [...], options: { ... } });
+ * const xml = kitToXml(doc);
+ * console.log(xml);
+ * ```
+ */
+import type { LpdfDocument } from './kit';
+/**
+ * Convert an `LpdfDocument` tree (built with `LpdfKit`) into an lpdf XML
+ * string.
+ *
+ * The returned string can be passed directly to `LpdfEngine.renderPdf()` or
+ * written to a `.xml` file.
+ *
+ * @param doc - The document tree returned by `LpdfKit.document(...)`.
+ * @returns A well-formed XML string with an `<?xml ...?>` declaration.
+ */
+export declare function kitToXml(doc: LpdfDocument): string;

package/dist/kit-to-xml.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * kitToXml — serialise an LpdfDocument tree (produced by LpdfKit) back to an
+ * lpdf XML string that can be passed directly to `LpdfEngine.renderPdf()` or
+ * saved to disk.
+ *
+ * The serialisation is performed by the Rust core (exposed as a WASM export)
+ * so every adapter produces identical XML and any schema change only requires
+ * a single Rust update.
+ *
+ * @example
+ * ```ts
+ * import { LpdfKit, kitToXml } from './dist/index.js';
+ *
+ * const doc = LpdfKit.document({ nodes: [...], options: { ... } });
+ * const xml = kitToXml(doc);
+ * console.log(xml);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kitToXml = kitToXml;
+// Load the standalone kit_to_xml export from the compiled WASM module.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { kit_to_xml: wasmKitToXml } = require('./wasm/lpdf.js');
+/**
+ * Convert an `LpdfDocument` tree (built with `LpdfKit`) into an lpdf XML
+ * string.
+ *
+ * The returned string can be passed directly to `LpdfEngine.renderPdf()` or
+ * written to a `.xml` file.
+ *
+ * @param doc - The document tree returned by `LpdfKit.document(...)`.
+ * @returns A well-formed XML string with an `<?xml ...?>` declaration.
+ */
+function kitToXml(doc) {
+    return wasmKitToXml(JSON.stringify(doc));
+}