@lpdfio/lpdf 0.6.0 → 0.8.0

package/dist/canvas.js

@@ -60,6 +60,10 @@ function rect(x, y, w, h, style) {
         attrs['stroke-dash'] = style.strokeDash.join(' ');
     if (style?.borderRadius !== undefined)
         attrs['radius'] = String(style.borderRadius);
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
+    if (style?.anchor !== undefined)
+        attrs['anchor'] = style.anchor;
     return { type: 'canvas-rect', attrs };
 }
 function line(x1, y1, x2, y2, style) {
@@ -90,6 +94,10 @@ function ellipse(cx, cy, rx, ry, style) {
         attrs['stroke-width'] = String(style.strokeWidth);
     if (style?.strokeDash !== undefined)
         attrs['stroke-dash'] = style.strokeDash.join(' ');
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
+    if (style?.anchor !== undefined)
+        attrs['anchor'] = style.anchor;
     return { type: 'canvas-ellipse', attrs };
 }
 function circle(cx, cy, r, style) {
@@ -104,6 +112,10 @@ function circle(cx, cy, r, style) {
         attrs['stroke-width'] = String(style.strokeWidth);
     if (style?.strokeDash !== undefined)
         attrs['stroke-dash'] = style.strokeDash.join(' ');
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
+    if (style?.anchor !== undefined)
+        attrs['anchor'] = style.anchor;
     return { type: 'canvas-circle', attrs };
 }
 function path(d, style) {
@@ -122,9 +134,11 @@ function path(d, style) {
         attrs['line-cap'] = style.lineCap;
     if (style?.lineJoin !== undefined)
         attrs['line-join'] = style.lineJoin;
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
     return { type: 'canvas-path', attrs };
 }
-function canvasText(x, y, content, style, runs) {
+function textAt(x, y, content, style, runs) {
     const attrs = { x: String(x), y: String(y) };
     if (style?.font !== undefined)
         attrs['font'] = style.font;
@@ -138,6 +152,10 @@ function canvasText(x, y, content, style, runs) {
         attrs['line-height'] = String(style.lineHeight);
     if (style?.width !== undefined)
         attrs['w'] = String(style.width);
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
+    if (style?.anchor !== undefined)
+        attrs['anchor'] = style.anchor;
     const node = { type: 'canvas-text', text: content, attrs };
     if (runs && runs.length > 0) {
         node.runs = runs.map(r => {
@@ -153,21 +171,21 @@ function canvasText(x, y, content, style, runs) {
     }
     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 imgAt(x, y, w, h, name, anchor) {
+    const attrs = { x: String(x), y: String(y), w: String(w), h: String(h), name };
+    if (anchor !== undefined)
+        attrs['anchor'] = anchor;
+    return { type: 'canvas-img', attrs };
 }
-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 };
+function layer(attrs, nodes) {
+    const a = {};
+    if (attrs?.page !== undefined)
+        a['page'] = attrs.page;
+    if (attrs?.opacity !== undefined)
+        a['opacity'] = String(attrs.opacity);
+    if (attrs?.transform !== undefined)
+        a['transform'] = attrs.transform.toString();
+    return { type: 'canvas-layer', attrs: a, nodes };
 }
 exports.LpdfCanvas = Object.freeze({
     rect,
@@ -175,7 +193,7 @@ exports.LpdfCanvas = Object.freeze({
     ellipse,
     circle,
     path,
-    text: canvasText,
-    img,
+    textAt,
+    imgAt,
     layer,
 });

package/dist/engine.d.ts

@@ -1,5 +1,5 @@
 import type { RenderOptions } from './_shared';
-import type { LpdfDocument } from './kit';
+import type { PdfDocument } from './kit';
 /** Thrown when the lpdf engine returns a layout or parse error. */
 export declare class LpdfRenderError extends Error {
     constructor(message: string);
@@ -15,7 +15,7 @@ export interface EncryptPermissions {
     assemble?: boolean;
     print_hq?: boolean;
 }
-/** RC4-128 encryption options passed to {@link LpdfEngine.setEncryption}. */
+/** RC4-128 encryption options passed to {@link PdfEngine.setEncryption}. */
 export interface EncryptOptions {
     /** Open password shown to readers. Empty string = no open password required. */
     userPassword: string;
@@ -24,26 +24,29 @@ export interface EncryptOptions {
     /** Permission flags applied to the document. Omitted flags default to `true`. */
     permissions?: EncryptPermissions;
 }
-export declare class LpdfEngine {
-    private readonly _licenseKey;
-    private readonly _opts;
+export declare class PdfEngine {
+    private _licenseKey;
     private readonly _fonts;
     private readonly _images;
     private _disposed;
     private _encrypt;
-    constructor(licenseKey: string, options?: RenderOptions);
+    constructor();
+    /**
+     * Set the license key. Returns `this` for chaining.
+     */
+    setLicenseKey(key: string): this;
     /**
      * Register raw TTF/OTF bytes for a custom font name used in `<font src="…">`.
-     * Call before `renderPdf`. Returns `this` for chaining.
+     * Call before `render`. 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.
+     * Call before `render`. Returns `this` for chaining.
      */
     loadImage(name: string, bytes: Uint8Array): this;
     /**
-     * Configure RC4-128 encryption for all subsequent `renderPdf` calls.
+     * Configure RC4-128 encryption for all subsequent `render` calls.
      * Returns `this` for chaining.
      */
     setEncryption(options: EncryptOptions): this;
@@ -53,7 +56,7 @@ export declare class LpdfEngine {
      */
     clearEncryption(): this;
     /**
-     * Release held resources. Idempotent. Subsequent `renderPdf` / `loadFont`
+     * Release held resources. Idempotent. Subsequent `render` / `loadFont`
      * calls after disposal will throw.
      */
     dispose(): void;
@@ -62,9 +65,9 @@ export declare class LpdfEngine {
     /**
      * Render an lpdf XML string to PDF bytes (Node.js).
      */
-    renderPdf(input: string, callOptions?: RenderOptions): Promise<Uint8Array>;
+    render(input: string, callOptions?: RenderOptions): Promise<Uint8Array>;
     /**
-     * Render an `LpdfDocument` tree (built with `LpdfKit`) to PDF bytes (Node.js).
+     * Render a `PdfDocument` tree (built with `Pdf.document`) to PDF bytes (Node.js).
      */
-    renderPdf(input: LpdfDocument, callOptions?: RenderOptions): Promise<Uint8Array>;
+    render(input: PdfDocument, callOptions?: RenderOptions): Promise<Uint8Array>;
 }

package/dist/engine.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LpdfEngine = exports.LpdfRenderError = void 0;
+exports.PdfEngine = 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/.
@@ -16,18 +16,25 @@ class LpdfRenderError extends Error {
     }
 }
 exports.LpdfRenderError = LpdfRenderError;
-class LpdfEngine {
-    constructor(licenseKey, options = {}) {
+class PdfEngine {
+    constructor() {
+        this._licenseKey = '';
         this._fonts = new Map();
         this._images = new Map();
         this._disposed = false;
         this._encrypt = null;
-        this._licenseKey = licenseKey;
-        this._opts = options;
+    }
+    /**
+     * Set the license key. Returns `this` for chaining.
+     */
+    setLicenseKey(key) {
+        this._throwIfDisposed();
+        this._licenseKey = key;
+        return this;
     }
     /**
      * Register raw TTF/OTF bytes for a custom font name used in `<font src="…">`.
-     * Call before `renderPdf`. Returns `this` for chaining.
+     * Call before `render`. Returns `this` for chaining.
      */
     loadFont(name, bytes) {
         this._throwIfDisposed();
@@ -36,7 +43,7 @@ class LpdfEngine {
     }
     /**
      * Register raw image bytes (PNG or JPEG) for an image name used in `<img name="…">`.
-     * Call before `renderPdf`. Returns `this` for chaining.
+     * Call before `render`. Returns `this` for chaining.
      */
     loadImage(name, bytes) {
         this._throwIfDisposed();
@@ -44,7 +51,7 @@ class LpdfEngine {
         return this;
     }
     /**
-     * Configure RC4-128 encryption for all subsequent `renderPdf` calls.
+     * Configure RC4-128 encryption for all subsequent `render` calls.
      * Returns `this` for chaining.
      */
     setEncryption(options) {
@@ -62,7 +69,7 @@ class LpdfEngine {
         return this;
     }
     /**
-     * Release held resources. Idempotent. Subsequent `renderPdf` / `loadFont`
+     * Release held resources. Idempotent. Subsequent `render` / `loadFont`
      * calls after disposal will throw.
      */
     dispose() {
@@ -71,28 +78,20 @@ class LpdfEngine {
     [Symbol.dispose]() { this.dispose(); }
     _throwIfDisposed() {
         if (this._disposed)
-            throw new Error('LpdfEngine has been disposed.');
+            throw new Error('PdfEngine has been disposed.');
     }
-    async renderPdf(input, callOptions = {}) {
+    async render(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);
+        if (callOptions.createdOn) {
+            engine.set_created_on(callOptions.createdOn);
         }
         let pdf;
         try {
             if (typeof input === 'string') {
                 // XML path — auto-load fonts and images declared via src="…".
                 const xml = input;
+                const allFonts = new Map(this._fonts);
                 for (const [key, src] of extractAssetSrcs(xml, 'font')) {
                     if (!allFonts.has(key)) {
                         try {
@@ -126,6 +125,7 @@ class LpdfEngine {
             else {
                 // JSON (Kit tree) path — pass JSON directly to render_tree_pdf.
                 const json = JSON.stringify(input);
+                const allFonts = new Map(this._fonts);
                 for (const [key, src] of extractFontSrcsFromJson(json)) {
                     if (!allFonts.has(key)) {
                         try {
@@ -156,7 +156,7 @@ class LpdfEngine {
         return pdf;
     }
 }
-exports.LpdfEngine = LpdfEngine;
+exports.PdfEngine = PdfEngine;
 // ── Helpers ───────────────────────────────────────────────────────────────────
 /** Extract `ref??name → src` pairs from `<font>` or `<image>` tags in XML. */
 function extractAssetSrcs(xml, tag) {

package/dist/index.d.ts

@@ -1,45 +1,9 @@
-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;
-    }>;
-}>;
+export { PdfEngine, LpdfRenderError } from './engine';
+export type { EncryptPermissions, EncryptOptions } from './engine';
+export type { RenderOptions, EngineOptions, PageScope } from './_shared';
+export type { PdfDocument, LpdfSectionNode, LpdfLayoutBlock, LpdfCanvasBlock, LpdfTokens, LpdfFontDef, LpdfMeta, SectionAttr, DocumentAttr, } from './kit';
+export type { StackAttr, FlankAttr, SplitAttr, ClusterAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, BarcodeAttr, RegionAttr, FieldAttr, } from './layout';
+export type { LpdfNode, LpdfContainerNode, LpdfTextNode, LpdfSpanNode, LpdfDividerNode, LpdfImgNode, LpdfBarcodeNode, LpdfTableNode, LpdfTheadNode, LpdfTrNode, LpdfTdNode, LpdfRegionNode, LpdfFieldNode, } from './layout';
+export { CanvasTransform } from './canvas';
+export type { LineCap, LineJoin, TextAlign, LayerAttr, CanvasRun, CanvasRectStyle, CanvasLineStyle, CanvasEllipseStyle, CanvasPathStyle, CanvasTextStyle, LpdfCanvasLayerNode, LpdfCanvasPrimitiveNode, LpdfCanvasRectNode, LpdfCanvasLineNode, LpdfCanvasEllipseNode, LpdfCanvasCircleNode, LpdfCanvasPathNode, LpdfCanvasTextNode, LpdfCanvasImgNode, } from './canvas';
+export { L, NoAttr } from './L';

package/dist/index.js

@@ -1,34 +1,14 @@
 "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,
-});
+exports.NoAttr = exports.L = exports.CanvasTransform = exports.LpdfRenderError = exports.PdfEngine = void 0;
+// ── Engine ────────────────────────────────────────────────────────────────────
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "PdfEngine", { enumerable: true, get: function () { return engine_1.PdfEngine; } });
+Object.defineProperty(exports, "LpdfRenderError", { enumerable: true, get: function () { return engine_1.LpdfRenderError; } });
+// ── Canvas types ──────────────────────────────────────────────────────────────
+var canvas_1 = require("./canvas");
+Object.defineProperty(exports, "CanvasTransform", { enumerable: true, get: function () { return canvas_1.CanvasTransform; } });
+// ── Facade ────────────────────────────────────────────────────────────────────
+var L_1 = require("./L");
+Object.defineProperty(exports, "L", { enumerable: true, get: function () { return L_1.L; } });
+Object.defineProperty(exports, "NoAttr", { enumerable: true, get: function () { return L_1.NoAttr; } });

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

@@ -16,7 +16,7 @@
  * console.log(xml);
  * ```
  */
-import type { LpdfDocument } from './kit';
+import type { PdfDocument } from './kit';
 /**
  * Convert an `LpdfDocument` tree (built with `LpdfKit`) into an lpdf XML
  * string.
@@ -27,4 +27,4 @@ import type { LpdfDocument } from './kit';
  * @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;
+export declare function kitToXml(doc: PdfDocument): string;

package/dist/kit.d.ts

@@ -32,7 +32,7 @@ export interface LpdfTokens {
     border?: Record<string, string>;
     radius?: Record<string, string>;
     width?: Record<string, string>;
-    text?: Record<string, string>;
+    textSize?: Record<string, string>;
     fonts?: Record<string, LpdfFontDef>;
 }
 export type LpdfFontDef = {
@@ -49,7 +49,7 @@ export interface LpdfMeta {
     keywords?: string;
     creator?: string;
 }
-export interface SectionOptions {
+export interface SectionAttr {
     size?: string;
     orientation?: string;
     margin?: string;
@@ -57,7 +57,7 @@ export interface SectionOptions {
     title?: string;
     debug?: string;
 }
-export interface DocumentOptions {
+export interface DocumentAttr {
     size?: string;
     orientation?: string;
     margin?: string;
@@ -81,25 +81,16 @@ export interface LpdfSectionNode {
     attrs: Record<string, string>;
     nodes: (LpdfLayoutBlock | LpdfCanvasBlock)[];
 }
-export interface LpdfDocument {
+export interface PdfDocument {
     version: 1;
     type: 'document';
     attrs: Record<string, unknown>;
     nodes: LpdfSectionNode[];
 }
-export interface SectionInput {
-    nodes?: (LpdfLayoutBlock | LpdfCanvasBlock)[];
-    options?: SectionOptions;
-}
-export interface DocumentInput {
-    /** Sections — serialised as `nodes` on the wire (matching kit_to_xml and parse_tree). */
-    sections?: LpdfSectionNode[];
-    options?: DocumentOptions;
-}
-declare function layout(nodes?: LpdfNode[]): LpdfLayoutBlock;
-declare function canvas(layers?: LpdfCanvasLayerNode[]): LpdfCanvasBlock;
-declare function section(input?: SectionInput): LpdfSectionNode;
-declare function document(input?: DocumentInput): LpdfDocument;
+declare function layout(_attrs: null, nodes: LpdfNode[]): LpdfLayoutBlock;
+declare function canvas(_attrs: null, layers: LpdfCanvasLayerNode[]): LpdfCanvasBlock;
+declare function section(attrs: SectionAttr | null, nodes: (LpdfLayoutBlock | LpdfCanvasBlock)[]): LpdfSectionNode;
+declare function document(attrs: DocumentAttr | null, nodes: LpdfSectionNode[]): PdfDocument;
 export declare const LpdfKit: Readonly<{
     layout: typeof layout;
     canvas: typeof canvas;

package/dist/kit.js

@@ -40,33 +40,35 @@ function buildAttrs(options) {
     return result;
 }
 // ── Factory functions ─────────────────────────────────────────────────────────
-function layout(nodes = []) {
+function layout(_attrs, nodes) {
     return { type: 'layout', nodes };
 }
-function canvas(layers = []) {
+function canvas(_attrs, layers) {
     return { type: 'canvas', nodes: layers };
 }
-function section(input = {}) {
+function section(attrs, nodes) {
     return {
         type: 'section',
-        attrs: buildAttrs((input.options ?? {})),
-        nodes: input.nodes ?? [],
+        attrs: buildAttrs((attrs ?? {})),
+        nodes,
     };
 }
-function document(input = {}) {
-    const { tokens, meta, ...restOpts } = input.options ?? {};
-    const attrs = {
+function document(attrs, nodes) {
+    const { tokens, meta, ...restOpts } = attrs ?? {};
+    const attrsObj = {
         ...buildAttrs(restOpts),
     };
-    if (tokens !== undefined)
-        attrs['tokens'] = tokens;
+    if (tokens !== undefined) {
+        const { textSize, ...rest } = tokens;
+        attrsObj['tokens'] = textSize !== undefined ? { 'text-size': textSize, ...rest } : rest;
+    }
     if (meta !== undefined)
-        attrs['meta'] = meta;
+        attrsObj['meta'] = meta;
     return {
         version: 1,
         type: 'document',
-        attrs,
-        nodes: input.sections ?? [],
+        attrs: attrsObj,
+        nodes,
     };
 }
 // ── LpdfKit export ────────────────────────────────────────────────────────────