@lpdfio/lpdf 0.5.0 → 0.7.0

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, } from './layout';
+export type { LpdfNode, LpdfContainerNode, LpdfTextNode, LpdfSpanNode, LpdfDividerNode, LpdfImgNode, LpdfBarcodeNode, LpdfTableNode, LpdfTheadNode, LpdfTrNode, LpdfTdNode, LpdfRegionNode, } 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 './pdf';

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 pdf_1 = require("./pdf");
+Object.defineProperty(exports, "L", { enumerable: true, get: function () { return pdf_1.L; } });
+Object.defineProperty(exports, "NoAttr", { enumerable: true, get: function () { return pdf_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

@@ -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,33 @@ 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;
+        attrsObj['tokens'] = tokens;
     if (meta !== undefined)
-        attrs['meta'] = meta;
+        attrsObj['meta'] = meta;
     return {
         version: 1,
         type: 'document',
-        attrs,
-        nodes: input.sections ?? [],
+        attrs: attrsObj,
+        nodes,
     };
 }
 // ── LpdfKit export ────────────────────────────────────────────────────────────

package/dist/layout.d.ts

@@ -1,5 +1,5 @@
 import type { PageScope } from './_shared';
-export interface StackOptions {
+export interface StackAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -11,7 +11,7 @@ export interface StackOptions {
     radius?: string;
     debug?: string;
 }
-export interface FlankOptions {
+export interface FlankAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -24,7 +24,7 @@ export interface FlankOptions {
     radius?: string;
     debug?: string;
 }
-export interface SplitOptions {
+export interface SplitAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -36,7 +36,7 @@ export interface SplitOptions {
     radius?: string;
     debug?: string;
 }
-export interface ClusterOptions {
+export interface ClusterAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -48,7 +48,7 @@ export interface ClusterOptions {
     radius?: string;
     debug?: string;
 }
-export interface GridOptions {
+export interface GridAttr {
     cols?: string;
     colWidth?: string;
     gap?: string;
@@ -61,7 +61,7 @@ export interface GridOptions {
     radius?: string;
     debug?: string;
 }
-export interface FrameOptions {
+export interface FrameAttr {
     width?: string;
     height?: string;
     padding?: string;
@@ -71,13 +71,13 @@ export interface FrameOptions {
     align?: string;
     debug?: string;
 }
-export interface LinkOptions {
+export interface LinkAttr {
     url?: string;
     width?: string;
     height?: string;
     debug?: string;
 }
-export interface TableOptions {
+export interface TableAttr {
     cols: string;
     border?: string;
     stripe?: string;
@@ -89,13 +89,13 @@ export interface TableOptions {
     repeat?: string;
     debug?: string;
 }
-export interface TheadOptions {
+export interface TheadAttr {
     background?: string;
 }
-export interface TrOptions {
+export interface TrAttr {
     background?: string;
 }
-export interface TdOptions {
+export interface TdAttr {
     padding?: string;
     background?: string;
     align?: string;
@@ -105,7 +105,7 @@ export interface TdOptions {
     gap?: string;
     debug?: string;
 }
-export interface TextOptions {
+export interface TextAttr {
     font?: string;
     fontSize?: string;
     textAlign?: string;
@@ -121,7 +121,7 @@ export interface TextOptions {
     repeat?: string;
     debug?: string;
 }
-export interface SpanOptions {
+export interface SpanAttr {
     font?: string;
     fontSize?: string;
     color?: string;
@@ -130,13 +130,13 @@ export interface SpanOptions {
     underline?: string;
     strike?: string;
 }
-export interface DividerOptions {
+export interface DividerAttr {
     color?: string;
     thickness?: string;
     direction?: string;
     debug?: string;
 }
-export interface ImgOptions {
+export interface ImgAttr {
     name: string;
     height?: string;
     width?: string;
@@ -150,7 +150,7 @@ export interface ImgOptions {
     repeat?: string;
     debug?: string;
 }
-export interface BarcodeOptions {
+export interface BarcodeAttr {
     type: string;
     data: string;
     size?: string;
@@ -163,7 +163,8 @@ export interface BarcodeOptions {
     repeat?: string;
     debug?: string;
 }
-export interface RegionOptions {
+export interface RegionAttr {
+    pin: string;
     page?: PageScope | string;
     w?: string;
     debug?: string;
@@ -221,23 +222,23 @@ export interface LpdfRegionNode {
     nodes: LpdfNode[];
 }
 export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfBarcodeNode | LpdfRegionNode;
-declare function stack(nodes?: LpdfNode[], options?: StackOptions): LpdfContainerNode;
-declare function flank(nodes?: LpdfNode[], options?: FlankOptions): LpdfContainerNode;
-declare function split(nodes?: LpdfNode[], options?: SplitOptions): LpdfContainerNode;
-declare function cluster(nodes?: LpdfNode[], options?: ClusterOptions): LpdfContainerNode;
-declare function grid(nodes?: LpdfNode[], options?: GridOptions): LpdfContainerNode;
-declare function frame(nodes?: LpdfNode[], options?: FrameOptions): LpdfContainerNode;
-declare function link(nodes?: LpdfNode[], options?: LinkOptions): LpdfContainerNode;
-declare function table(options: TableOptions, nodes?: (LpdfTheadNode | LpdfTrNode)[]): LpdfTableNode;
-declare function thead(nodes?: LpdfTdNode[], options?: TheadOptions): LpdfTheadNode;
-declare function tr(nodes?: LpdfTdNode[], options?: TrOptions): LpdfTrNode;
-declare function td(nodes?: LpdfNode[], options?: TdOptions): LpdfTdNode;
-declare function text(nodes?: (string | LpdfSpanNode)[], options?: TextOptions): LpdfTextNode;
-declare function span(nodes?: string[], options?: SpanOptions): LpdfSpanNode;
-declare function divider(options?: DividerOptions): LpdfDividerNode;
-declare function img(options: ImgOptions): LpdfImgNode;
-declare function barcode(options: BarcodeOptions): LpdfBarcodeNode;
-declare function region(pin: string, nodes?: LpdfNode[], options?: RegionOptions): LpdfRegionNode;
+declare function stack(attrs: StackAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function flank(attrs: FlankAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function split(attrs: SplitAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function cluster(attrs: ClusterAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function grid(attrs: GridAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function frame(attrs: FrameAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function link(attrs: LinkAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function table(attrs: TableAttr, nodes: (LpdfTheadNode | LpdfTrNode)[]): LpdfTableNode;
+declare function thead(attrs: TheadAttr | null, nodes: LpdfTdNode[]): LpdfTheadNode;
+declare function tr(attrs: TrAttr | null, nodes: LpdfTdNode[]): LpdfTrNode;
+declare function td(attrs: TdAttr | null, nodes: LpdfNode[]): LpdfTdNode;
+declare function text(attrs: TextAttr | null, nodes: (string | LpdfSpanNode)[]): LpdfTextNode;
+declare function span(attrs: SpanAttr | null, nodes: string[]): LpdfSpanNode;
+declare function divider(attrs: DividerAttr | null): LpdfDividerNode;
+declare function img(attrs: ImgAttr): LpdfImgNode;
+declare function barcode(attrs: BarcodeAttr): LpdfBarcodeNode;
+declare function region(attrs: RegionAttr, nodes: LpdfNode[]): LpdfRegionNode;
 export declare const LpdfLayout: Readonly<{
     stack: typeof stack;
     flank: typeof flank;

package/dist/layout.js

@@ -15,100 +15,100 @@ function buildAttrs(options) {
     return result;
 }
 // ── Helper ────────────────────────────────────────────────────────────────────
-function makeContainer(type, nodes, options) {
-    return { type, attrs: buildAttrs(options ?? {}), nodes };
+function makeContainer(type, attrs, nodes) {
+    return { type, attrs: buildAttrs(attrs ?? {}), nodes };
 }
 // ── LpdfLayout factory ────────────────────────────────────────────────────────
-function stack(nodes = [], options) {
-    return makeContainer('stack', nodes, options);
+function stack(attrs, nodes) {
+    return makeContainer('stack', attrs, nodes);
 }
-function flank(nodes = [], options) {
-    return makeContainer('flank', nodes, options);
+function flank(attrs, nodes) {
+    return makeContainer('flank', attrs, nodes);
 }
-function split(nodes = [], options) {
-    return makeContainer('split', nodes, options);
+function split(attrs, nodes) {
+    return makeContainer('split', attrs, nodes);
 }
-function cluster(nodes = [], options) {
-    return makeContainer('cluster', nodes, options);
+function cluster(attrs, nodes) {
+    return makeContainer('cluster', attrs, nodes);
 }
-function grid(nodes = [], options) {
-    return makeContainer('grid', nodes, options);
+function grid(attrs, nodes) {
+    return makeContainer('grid', attrs, nodes);
 }
-function frame(nodes = [], options) {
-    return makeContainer('frame', nodes, options);
+function frame(attrs, nodes) {
+    return makeContainer('frame', attrs, nodes);
 }
-function link(nodes = [], options) {
-    return makeContainer('link', nodes, options);
+function link(attrs, nodes) {
+    return makeContainer('link', attrs, nodes);
 }
-function table(options, nodes = []) {
+function table(attrs, nodes) {
     return {
         type: 'table',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
         nodes,
     };
 }
-function thead(nodes = [], options) {
+function thead(attrs, nodes) {
     return {
         type: 'thead',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function tr(nodes = [], options) {
+function tr(attrs, nodes) {
     return {
         type: 'tr',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function td(nodes = [], options) {
+function td(attrs, nodes) {
     return {
         type: 'td',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function text(nodes = [], options) {
+function text(attrs, nodes) {
     return {
         type: 'text',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function span(nodes = [], options) {
+function span(attrs, nodes) {
     return {
         type: 'span',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function divider(options) {
+function divider(attrs) {
     return {
         type: 'divider',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
     };
 }
-function img(options) {
+function img(attrs) {
     return {
         type: 'img',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
     };
 }
-function barcode(options) {
+function barcode(attrs) {
     return {
         type: 'barcode',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
     };
 }
-function region(pin, nodes = [], options) {
-    const attrs = { pin };
-    if (options?.page !== undefined)
-        attrs['page'] = options.page;
-    if (options?.w !== undefined)
-        attrs['w'] = options.w;
-    if (options?.debug !== undefined)
-        attrs['debug'] = options.debug;
-    return { type: 'layout-region', attrs, nodes };
+function region(attrs, nodes) {
+    const a = { pin: attrs.pin };
+    if (attrs.page !== undefined)
+        a['page'] = attrs.page;
+    if (attrs.w !== undefined)
+        a['w'] = attrs.w;
+    if (attrs.debug !== undefined)
+        a['debug'] = attrs.debug;
+    return { type: 'layout-region', attrs: a, nodes };
 }
 exports.LpdfLayout = Object.freeze({
     stack,

package/dist/pdf.d.ts

@@ -0,0 +1,61 @@
+import type { PdfDocument } from './kit';
+import { PdfEngine } from './engine';
+/** Pass as `attrs` when a node has no attributes. Equivalent to `null`. */
+export declare const NoAttr: null;
+/**
+ * Unified lpdf facade.
+ *
+ * All document, layout, and canvas factory methods are available as flat
+ * properties on this object. Construction-time configuration is handled via
+ * `L.engine()`.
+ *
+ * @example
+ * ```ts
+ * import { L, NoAttr } from 'lpdf';
+ *
+ * const engine = L.engine().setLicenseKey(process.env.LPDF_KEY);
+ *
+ * const doc = L.document(NoAttr, [
+ *   L.section(NoAttr, [
+ *     L.layout(null, [ L.text(NoAttr, ['Hello']) ]),
+ *   ]),
+ * ]);
+ *
+ * const pdf = await engine.render(doc);
+ * ```
+ */
+export declare const L: Readonly<{
+    /** Create a new {@link PdfEngine} instance. Call `.setLicenseKey()` to configure. */
+    engine: () => PdfEngine;
+    /** Convert a `PdfDocument` tree to an lpdf XML string. */
+    toXml: (doc: PdfDocument) => string;
+    document: (attrs: import("./kit").DocumentAttr | null, nodes: import("./kit").LpdfSectionNode[]) => PdfDocument;
+    section: (attrs: import("./kit").SectionAttr | null, nodes: (import("./kit").LpdfLayoutBlock | import("./kit").LpdfCanvasBlock)[]) => import("./kit").LpdfSectionNode;
+    layout: (_attrs: null, nodes: import("./layout").LpdfNode[]) => import("./kit").LpdfLayoutBlock;
+    canvas: (_attrs: null, layers: import("./canvas").LpdfCanvasLayerNode[]) => import("./kit").LpdfCanvasBlock;
+    stack: (attrs: import("./layout").StackAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    flank: (attrs: import("./layout").FlankAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    split: (attrs: import("./layout").SplitAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    cluster: (attrs: import("./layout").ClusterAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    grid: (attrs: import("./layout").GridAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    frame: (attrs: import("./layout").FrameAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    link: (attrs: import("./layout").LinkAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    table: (attrs: import("./layout").TableAttr, nodes: (import("./layout").LpdfTheadNode | import("./layout").LpdfTrNode)[]) => import("./layout").LpdfTableNode;
+    thead: (attrs: import("./layout").TheadAttr | null, nodes: import("./layout").LpdfTdNode[]) => import("./layout").LpdfTheadNode;
+    tr: (attrs: import("./layout").TrAttr | null, nodes: import("./layout").LpdfTdNode[]) => import("./layout").LpdfTrNode;
+    td: (attrs: import("./layout").TdAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfTdNode;
+    text: (attrs: import("./layout").TextAttr | null, nodes: (string | import("./layout").LpdfSpanNode)[]) => import("./layout").LpdfTextNode;
+    span: (attrs: import("./layout").SpanAttr | null, nodes: string[]) => import("./layout").LpdfSpanNode;
+    divider: (attrs: import("./layout").DividerAttr | null) => import("./layout").LpdfDividerNode;
+    img: (attrs: import("./layout").ImgAttr) => import("./layout").LpdfImgNode;
+    barcode: (attrs: import("./layout").BarcodeAttr) => import("./layout").LpdfBarcodeNode;
+    region: (attrs: import("./layout").RegionAttr, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfRegionNode;
+    layer: (attrs: import("./canvas").LayerAttr | null, nodes: import("./canvas").LpdfCanvasPrimitiveNode[]) => import("./canvas").LpdfCanvasLayerNode;
+    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;
+    textAt: (x: number, y: number, content: string, style?: import("./canvas").CanvasTextStyle, runs?: import("./canvas").CanvasRun[]) => import("./canvas").LpdfCanvasTextNode;
+    imgAt: (x: number, y: number, w: number, h: number, name: string) => import("./canvas").LpdfCanvasImgNode;
+}>;