@lpdfio/lpdf 0.22.0 → 0.23.0

package/dist/browser.js

@@ -392,6 +392,48 @@ async function __wbg_init(module_or_path) {
   return __wbg_finalize_init(instance, module);
 }
 
+// src/constants.ts
+var FieldType = {
+  Text: "text",
+  Checkbox: "checkbox",
+  Dropdown: "dropdown",
+  Radio: "radio",
+  Button: "button"
+};
+var Pin = {
+  Top: "top",
+  Bottom: "bottom",
+  Left: "left",
+  Right: "right"
+};
+var Orientation = {
+  Portrait: "portrait",
+  Landscape: "landscape"
+};
+var BuiltinFont = {
+  Courier: "Courier",
+  CourierBold: "Courier-Bold",
+  CourierOblique: "Courier-Oblique",
+  CourierBoldOblique: "Courier-BoldOblique",
+  Helvetica: "Helvetica",
+  HelveticaBold: "Helvetica-Bold",
+  HelveticaOblique: "Helvetica-Oblique",
+  HelveticaBoldOblique: "Helvetica-BoldOblique",
+  TimesRoman: "Times-Roman",
+  TimesBold: "Times-Bold",
+  TimesItalic: "Times-Italic",
+  TimesBoldItalic: "Times-BoldItalic",
+  Symbol: "Symbol",
+  ZapfDingbats: "ZapfDingbats"
+};
+var PageScope = {
+  Each: "each",
+  First: "first",
+  Last: "last",
+  Odd: "odd",
+  Even: "even"
+};
+
 // src/browser.ts
 var NoAttr = null;
 function nowUnix() {
@@ -443,6 +485,11 @@ async function initLpdf(wasmSource, licenseKey = "") {
   };
 }
 export {
+  BuiltinFont,
+  FieldType,
   NoAttr,
+  Orientation,
+  PageScope,
+  Pin,
   initLpdf
 };

package/dist/canvas.d.ts

@@ -1,57 +1,9 @@
-import type { PageScope } from './_shared';
-export type TextAlign = 'left' | 'center' | 'right' | 'justify';
-export type LineCap = 'butt' | 'round' | 'square';
-export type LineJoin = 'miter' | 'round' | 'bevel';
-export interface CanvasRectStyle {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-    strokeDash?: number[];
-    borderRadius?: number;
-    opacity?: number;
-    anchor?: string;
-}
-export interface CanvasLineStyle {
-    stroke?: string;
-    strokeWidth?: number;
-    strokeDash?: number[];
-    lineCap?: LineCap;
-    lineJoin?: LineJoin;
-}
-export interface CanvasEllipseStyle {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-    strokeDash?: number[];
-    opacity?: number;
-    anchor?: string;
-}
-export interface CanvasPathStyle {
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-    strokeDash?: number[];
-    fillRuleEvenodd?: boolean;
-    lineCap?: LineCap;
-    lineJoin?: LineJoin;
-    opacity?: number;
-}
-export interface CanvasTextStyle {
-    font?: string;
-    size?: number;
-    color?: string;
-    align?: TextAlign;
-    lineHeight?: number;
-    width?: number;
-    opacity?: number;
-    anchor?: string;
-}
-export interface CanvasRun {
-    text: string;
-    font?: string;
-    size?: number;
-    color?: string;
-}
+import type { RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, CanvasTextAttr, CanvasImgAttr, LayerAttr } from './attrs';
+import type { LpdfSpanNode } from './layout';
+/**
+ * Builds the `transform` string of a layer. `String(CanvasTransform.rotate(45))` is
+ * `matrix(...)`, which a layer's `transform` attribute accepts like `rotate(45)`.
+ */
 export declare class CanvasTransform {
     readonly matrix: number[];
     constructor(matrix: number[]);
@@ -66,67 +18,52 @@ export declare class CanvasTransform {
      * Equivalent to matrix multiplication: this × other.
      */
     then(other: CanvasTransform): CanvasTransform;
-    /** Serialise to the `"matrix(a,b,c,d,e,f)"` string form that Rust `jattr()` reads. */
+    /** The `"matrix(a,b,c,d,e,f)"` form of the transform. */
     toString(): string;
 }
 export interface LpdfCanvasRectNode {
-    type: 'canvas-rect';
+    type: 'rect';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasLineNode {
-    type: 'canvas-line';
+    type: 'line';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasEllipseNode {
-    type: 'canvas-ellipse';
+    type: 'ellipse';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasCircleNode {
-    type: 'canvas-circle';
+    type: 'circle';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasPathNode {
-    type: 'canvas-path';
+    type: 'path';
     attrs: Record<string, string>;
 }
 export interface LpdfCanvasTextNode {
-    type: 'canvas-text';
-    text: string;
+    type: 'text';
     attrs: Record<string, string>;
-    runs?: {
-        text: string;
-        attrs: {
-            font?: string;
-            'font-size'?: string;
-            color?: string;
-        };
-    }[];
+    nodes: (string | LpdfSpanNode)[];
 }
 export interface LpdfCanvasImgNode {
-    type: 'canvas-img';
+    type: 'img';
     attrs: Record<string, string>;
 }
 export type LpdfCanvasPrimitiveNode = LpdfCanvasRectNode | LpdfCanvasLineNode | LpdfCanvasEllipseNode | LpdfCanvasCircleNode | LpdfCanvasPathNode | LpdfCanvasTextNode | LpdfCanvasImgNode;
-/** @deprecated Use {@link LayerAttr} */
-export type CanvasLayerOptions = LayerAttr;
-export interface LayerAttr {
-    page?: PageScope | string;
-    opacity?: number;
-    transform?: CanvasTransform;
-}
 export interface LpdfCanvasLayerNode {
-    type: 'canvas-layer';
+    type: 'layer';
     attrs: Record<string, string>;
     nodes: LpdfCanvasPrimitiveNode[];
 }
-declare function rect(x: number, y: number, w: number, h: number, style?: CanvasRectStyle): LpdfCanvasRectNode;
-declare function line(x1: number, y1: number, x2: number, y2: number, style?: CanvasLineStyle): LpdfCanvasLineNode;
-declare function ellipse(cx: number, cy: number, rx: number, ry: number, style?: CanvasEllipseStyle): LpdfCanvasEllipseNode;
-declare function circle(cx: number, cy: number, r: number, style?: CanvasEllipseStyle): LpdfCanvasCircleNode;
-declare function path(d: string, style?: CanvasPathStyle): LpdfCanvasPathNode;
-declare function textAt(x: number, y: number, content: string, style?: CanvasTextStyle, runs?: CanvasRun[]): LpdfCanvasTextNode;
-declare function imgAt(x: number, y: number, w: number, h: number, name: string, anchor?: string): LpdfCanvasImgNode;
-declare function layer(attrs: LayerAttr | null, nodes: LpdfCanvasPrimitiveNode[]): LpdfCanvasLayerNode;
+declare function rect(attrs: RectAttr): LpdfCanvasRectNode;
+declare function line(attrs: LineAttr): LpdfCanvasLineNode;
+declare function ellipse(attrs: EllipseAttr): LpdfCanvasEllipseNode;
+declare function circle(attrs: CircleAttr): LpdfCanvasCircleNode;
+declare function path(attrs: PathAttr): LpdfCanvasPathNode;
+declare function textAt(attrs: CanvasTextAttr, nodes?: (string | LpdfSpanNode)[]): LpdfCanvasTextNode;
+declare function imgAt(attrs: CanvasImgAttr): LpdfCanvasImgNode;
+declare function layer(attrs: LayerAttr | null, nodes?: LpdfCanvasPrimitiveNode[]): LpdfCanvasLayerNode;
 export declare const LpdfCanvas: Readonly<{
     rect: typeof rect;
     line: typeof line;

package/dist/canvas.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LpdfCanvas = exports.CanvasTransform = void 0;
+const _shared_1 = require("./_shared");
 // ── CanvasTransform ───────────────────────────────────────────────────────────
+/**
+ * Builds the `transform` string of a layer. `String(CanvasTransform.rotate(45))` is
+ * `matrix(...)`, which a layer's `transform` attribute accepts like `rotate(45)`.
+ */
 class CanvasTransform {
     constructor(matrix) {
         this.matrix = matrix;
@@ -39,153 +44,36 @@ class CanvasTransform {
             b1 * e2 + d1 * f2 + f1,
         ]);
     }
-    /** Serialise to the `"matrix(a,b,c,d,e,f)"` string form that Rust `jattr()` reads. */
+    /** The `"matrix(a,b,c,d,e,f)"` form of the transform. */
     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);
-    if (style?.opacity !== undefined)
-        attrs['opacity'] = String(style.opacity);
-    if (style?.anchor !== undefined)
-        attrs['anchor'] = style.anchor;
-    return { type: 'canvas-rect', attrs };
+function rect(attrs) {
+    return { type: 'rect', attrs: (0, _shared_1.buildAttrs)(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 line(attrs) {
+    return { type: 'line', attrs: (0, _shared_1.buildAttrs)(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(' ');
-    if (style?.opacity !== undefined)
-        attrs['opacity'] = String(style.opacity);
-    if (style?.anchor !== undefined)
-        attrs['anchor'] = style.anchor;
-    return { type: 'canvas-ellipse', attrs };
+function ellipse(attrs) {
+    return { type: 'ellipse', attrs: (0, _shared_1.buildAttrs)(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(' ');
-    if (style?.opacity !== undefined)
-        attrs['opacity'] = String(style.opacity);
-    if (style?.anchor !== undefined)
-        attrs['anchor'] = style.anchor;
-    return { type: 'canvas-circle', attrs };
+function circle(attrs) {
+    return { type: 'circle', attrs: (0, _shared_1.buildAttrs)(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;
-    if (style?.opacity !== undefined)
-        attrs['opacity'] = String(style.opacity);
-    return { type: 'canvas-path', attrs };
+function path(attrs) {
+    return { type: 'path', attrs: (0, _shared_1.buildAttrs)(attrs) };
 }
-function textAt(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);
-    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 => {
-            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 textAt(attrs, nodes = []) {
+    return { type: 'text', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
 }
-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 imgAt(attrs) {
+    return { type: 'img', attrs: (0, _shared_1.buildAttrs)(attrs) };
 }
-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 };
+function layer(attrs, nodes = []) {
+    return { type: 'layer', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
 }
 exports.LpdfCanvas = Object.freeze({
     rect,

package/dist/constants.d.ts

@@ -0,0 +1,50 @@
+/** The values of the `type` attribute of a field. */
+export declare const FieldType: {
+    readonly Text: "text";
+    readonly Checkbox: "checkbox";
+    readonly Dropdown: "dropdown";
+    readonly Radio: "radio";
+    readonly Button: "button";
+};
+export type FieldType = (typeof FieldType)[keyof typeof FieldType];
+/** The values of the `pin` attribute of a region. */
+export declare const Pin: {
+    readonly Top: "top";
+    readonly Bottom: "bottom";
+    readonly Left: "left";
+    readonly Right: "right";
+};
+export type Pin = (typeof Pin)[keyof typeof Pin];
+/** The values of the `orientation` attribute of a document or a section. */
+export declare const Orientation: {
+    readonly Portrait: "portrait";
+    readonly Landscape: "landscape";
+};
+export type Orientation = (typeof Orientation)[keyof typeof Orientation];
+/** The values of the `core` attribute of a font: the built-in PDF fonts, which need no file. */
+export declare const BuiltinFont: {
+    readonly Courier: "Courier";
+    readonly CourierBold: "Courier-Bold";
+    readonly CourierOblique: "Courier-Oblique";
+    readonly CourierBoldOblique: "Courier-BoldOblique";
+    readonly Helvetica: "Helvetica";
+    readonly HelveticaBold: "Helvetica-Bold";
+    readonly HelveticaOblique: "Helvetica-Oblique";
+    readonly HelveticaBoldOblique: "Helvetica-BoldOblique";
+    readonly TimesRoman: "Times-Roman";
+    readonly TimesBold: "Times-Bold";
+    readonly TimesItalic: "Times-Italic";
+    readonly TimesBoldItalic: "Times-BoldItalic";
+    readonly Symbol: "Symbol";
+    readonly ZapfDingbats: "ZapfDingbats";
+};
+export type BuiltinFont = (typeof BuiltinFont)[keyof typeof BuiltinFont];
+/** The named values of the `page` attribute of a layer or a region. A range such as 2-4 or 1,3-5 is a string. */
+export declare const PageScope: {
+    readonly Each: "each";
+    readonly First: "first";
+    readonly Last: "last";
+    readonly Odd: "odd";
+    readonly Even: "even";
+};
+export type PageScope = (typeof PageScope)[keyof typeof PageScope];

package/dist/constants.js

@@ -0,0 +1,50 @@
+"use strict";
+// Generated from lpdf.xsd by scripts/gen-sdk-api.mjs.
+// Do not edit: change the schema and run `make gen-sdk-api`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageScope = exports.BuiltinFont = exports.Orientation = exports.Pin = exports.FieldType = void 0;
+/** The values of the `type` attribute of a field. */
+exports.FieldType = {
+    Text: 'text',
+    Checkbox: 'checkbox',
+    Dropdown: 'dropdown',
+    Radio: 'radio',
+    Button: 'button',
+};
+/** The values of the `pin` attribute of a region. */
+exports.Pin = {
+    Top: 'top',
+    Bottom: 'bottom',
+    Left: 'left',
+    Right: 'right',
+};
+/** The values of the `orientation` attribute of a document or a section. */
+exports.Orientation = {
+    Portrait: 'portrait',
+    Landscape: 'landscape',
+};
+/** The values of the `core` attribute of a font: the built-in PDF fonts, which need no file. */
+exports.BuiltinFont = {
+    Courier: 'Courier',
+    CourierBold: 'Courier-Bold',
+    CourierOblique: 'Courier-Oblique',
+    CourierBoldOblique: 'Courier-BoldOblique',
+    Helvetica: 'Helvetica',
+    HelveticaBold: 'Helvetica-Bold',
+    HelveticaOblique: 'Helvetica-Oblique',
+    HelveticaBoldOblique: 'Helvetica-BoldOblique',
+    TimesRoman: 'Times-Roman',
+    TimesBold: 'Times-Bold',
+    TimesItalic: 'Times-Italic',
+    TimesBoldItalic: 'Times-BoldItalic',
+    Symbol: 'Symbol',
+    ZapfDingbats: 'ZapfDingbats',
+};
+/** The named values of the `page` attribute of a layer or a region. A range such as 2-4 or 1,3-5 is a string. */
+exports.PageScope = {
+    Each: 'each',
+    First: 'first',
+    Last: 'last',
+    Odd: 'odd',
+    Even: 'even',
+};

package/dist/engine.js

@@ -153,10 +153,11 @@ class PdfEngine {
                 pdf = engine.render_pdf(xml, dataJson);
             }
             else {
-                // JSON (Kit tree) path — pass JSON directly to render_tree_pdf.
+                // JSON (Kit tree) path — pass JSON directly to render_tree_pdf. Fonts and images the
+                // document declares with a src are read from there, as on the XML path.
                 const json = JSON.stringify(input);
                 const allFonts = new Map(this._fonts);
-                for (const [key, src] of extractFontSrcsFromJson(json)) {
+                for (const [key, src] of assetSrcsOfDocument(input, 'fonts')) {
                     if (!allFonts.has(key)) {
                         try {
                             allFonts.set(key, (0, node_fs_1.readFileSync)(src));
@@ -167,7 +168,16 @@ class PdfEngine {
                 for (const [name, bytes] of allFonts) {
                     engine.load_font(name, bytes);
                 }
-                for (const [name, bytes] of this._images) {
+                const allImages = new Map(this._images);
+                for (const [key, src] of assetSrcsOfDocument(input, 'images')) {
+                    if (!allImages.has(key)) {
+                        try {
+                            allImages.set(key, (0, node_fs_1.readFileSync)(src));
+                        }
+                        catch { /* skip unresolvable image */ }
+                    }
+                }
+                for (const [name, bytes] of allImages) {
                     engine.load_image(name, bytes);
                 }
                 if (this._encrypt) {
@@ -203,19 +213,13 @@ function extractAssetSrcs(xml, tag) {
     }
     return result;
 }
-/** Extract `ref??name → src` pairs from `attrs.tokens.fonts[name].src` in a kit JSON string. */
-function extractFontSrcsFromJson(json) {
+/** The `ref ?? name → src` pairs of the fonts or images a document declares in `attrs.assets`. */
+function assetSrcsOfDocument(document, kind) {
     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);
-            }
-        }
+    const declared = document.attrs['assets']?.[kind] ?? [];
+    for (const { name, ref, src } of declared) {
+        if (src)
+            result.set(ref ?? name, src);
     }
-    catch { /* ignore */ }
     return result;
 }

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 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 { RenderOptions, EngineOptions } from './_shared';
+export { FieldType, Pin, Orientation, BuiltinFont, PageScope } from './constants';
+export type { PdfDocument, LpdfSectionNode, LpdfLayoutBlock, LpdfCanvasBlock, DocumentTokens, DocumentAssets, DocumentMeta, SectionAttr, DocumentAttr, } from './kit';
+export type { StackAttr, FlankAttr, SplitAttr, ClusterAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, BarcodeAttr, RegionAttr, FieldAttr, LayerAttr, RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, CanvasTextAttr, CanvasImgAttr, FontAttr, ImageAttr, } from './attrs';
 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 type { LpdfCanvasLayerNode, LpdfCanvasPrimitiveNode, LpdfCanvasRectNode, LpdfCanvasLineNode, LpdfCanvasEllipseNode, LpdfCanvasCircleNode, LpdfCanvasPathNode, LpdfCanvasTextNode, LpdfCanvasImgNode, } from './canvas';
 export { L, NoAttr } from './L';

package/dist/index.js

@@ -1,10 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoAttr = exports.L = exports.CanvasTransform = exports.LpdfRenderError = exports.PdfEngine = void 0;
+exports.NoAttr = exports.L = exports.CanvasTransform = exports.PageScope = exports.BuiltinFont = exports.Orientation = exports.Pin = exports.FieldType = 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; } });
+// ── Constants for the schema's enumerations ───────────────────────────────────
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "FieldType", { enumerable: true, get: function () { return constants_1.FieldType; } });
+Object.defineProperty(exports, "Pin", { enumerable: true, get: function () { return constants_1.Pin; } });
+Object.defineProperty(exports, "Orientation", { enumerable: true, get: function () { return constants_1.Orientation; } });
+Object.defineProperty(exports, "BuiltinFont", { enumerable: true, get: function () { return constants_1.BuiltinFont; } });
+Object.defineProperty(exports, "PageScope", { enumerable: true, get: function () { return constants_1.PageScope; } });
 // ── Canvas types ──────────────────────────────────────────────────────────────
 var canvas_1 = require("./canvas");
 Object.defineProperty(exports, "CanvasTransform", { enumerable: true, get: function () { return canvas_1.CanvasTransform; } });

package/dist/kit.d.ts

@@ -25,7 +25,8 @@
  */
 import type { LpdfNode } from './layout';
 import type { LpdfCanvasLayerNode } from './canvas';
-export interface LpdfTokens {
+import type { FontAttr, ImageAttr } from './attrs';
+export interface DocumentTokens {
     colors?: Record<string, string>;
     space?: Record<string, string>;
     grid?: Record<string, string>;
@@ -33,16 +34,16 @@ export interface LpdfTokens {
     radius?: Record<string, string>;
     width?: Record<string, string>;
     textSize?: Record<string, string>;
-    fonts?: Record<string, LpdfFontDef>;
 }
-export type LpdfFontDef = {
-    src: string;
-    builtin?: never;
-} | {
-    builtin: string;
-    src?: never;
-};
-export interface LpdfMeta {
+/**
+ * The fonts and images the document declares, as the `assets` element of the XML does. A font or image
+ * is picked by its `name`: text sets `font` to a font's name, an `img` sets `name` to an image's.
+ */
+export interface DocumentAssets {
+    fonts?: FontAttr[];
+    images?: ImageAttr[];
+}
+export interface DocumentMeta {
     title?: string;
     author?: string;
     subject?: string;
@@ -62,8 +63,10 @@ export interface DocumentAttr {
     orientation?: string;
     margin?: string;
     background?: string;
-    tokens?: LpdfTokens;
-    meta?: LpdfMeta;
+    font?: string;
+    assets?: DocumentAssets;
+    tokens?: DocumentTokens;
+    meta?: DocumentMeta;
     debug?: string;
 }
 /** A layout block — wraps an ordered list of layout nodes. */
@@ -87,10 +90,10 @@ export interface PdfDocument {
     attrs: Record<string, unknown>;
     nodes: LpdfSectionNode[];
 }
-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;
+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;