@lpdfio/lpdf 0.29.0 → 0.31.0

package/dist/engine.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PdfEngine = exports.LpdfRenderError = void 0;
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
+const _shared_1 = require("./_shared");
 // 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/.
@@ -28,13 +30,18 @@ class LpdfRenderError extends Error {
     }
 }
 exports.LpdfRenderError = LpdfRenderError;
+/** Node's secure generator, for the entropy of AES-256. */
+function secureRandomBytes(count) {
+    return new Uint8Array((0, node_crypto_1.randomBytes)(count));
+}
 class PdfEngine {
     constructor() {
         this._licenseKey = '';
         this._fonts = new Map();
         this._images = new Map();
+        this._files = new Map();
+        this._markdownStyles = new Map();
         this._disposed = false;
-        this._encrypt = null;
     }
     /**
      * Set the license key. Returns `this` for chaining.
@@ -78,21 +85,21 @@ class PdfEngine {
         return this;
     }
     /**
-     * Configure RC4-128 encryption for all subsequent `render` calls.
-     * Returns `this` for chaining.
+     * Register the bytes of a file the document carries, for the `<file>` of its `<attachments>` whose `ref`, or with
+     * no ref whose name, is `name`. The PDF carries them as they are. Call before `render`. Returns `this` for chaining.
      */
-    setEncryption(options) {
+    loadFile(name, bytes) {
         this._throwIfDisposed();
-        this._encrypt = options;
+        this._files.set(name, bytes);
         return this;
     }
     /**
-     * Remove any previously configured encryption.
-     * Returns `this` for chaining.
+     * Register the text of a file of Markdown rules, the root of which is a `<markdown-styles>`, for the `src` that
+     * names it, as `<markdown-styles src="…">` does. Call before `render`. Returns `this` for chaining.
      */
-    clearEncryption() {
+    loadMarkdownStyles(src, text) {
         this._throwIfDisposed();
-        this._encrypt = null;
+        this._markdownStyles.set(src, text);
         return this;
     }
     /**
@@ -103,6 +110,44 @@ class PdfEngine {
         this._disposed = true;
     }
     [Symbol.dispose]() { this.dispose(); }
+    /**
+     * Hand the engine the files of Markdown rules that a document names: the ones loaded here, and the ones read from
+     * their `src`. A file that can't be read is left for the engine to report, naming the `src`.
+     */
+    _loadMarkdownStyles(engine, srcs) {
+        const files = new Map(this._markdownStyles);
+        for (const src of srcs) {
+            if (!files.has(src)) {
+                try {
+                    files.set(src, (0, node_fs_1.readFileSync)(src, 'utf8'));
+                }
+                catch { /* not found; the engine says so */ }
+            }
+        }
+        for (const [src, text] of files) {
+            engine.load_markdown_styles(src, text);
+        }
+    }
+    /**
+     * Hand the engine the files the document carries: the ones loaded here, and the ones read from the `src` of a file
+     * that wasn't. A `src` that can't be read is an error that names the file and the path.
+     */
+    _loadFiles(engine, srcs) {
+        const files = new Map(this._files);
+        for (const [key, src] of srcs) {
+            if (files.has(key))
+                continue;
+            try {
+                files.set(key, (0, node_fs_1.readFileSync)(src));
+            }
+            catch (e) {
+                throw new LpdfRenderError(`file '${key}' of <attachments>: cannot read its src '${src}': ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        for (const [key, bytes] of files) {
+            engine.load_file(key, bytes);
+        }
+    }
     _throwIfDisposed() {
         if (this._disposed)
             throw new Error('PdfEngine has been disposed.');
@@ -136,6 +181,8 @@ class PdfEngine {
                 for (const [name, bytes] of this._images) {
                     engine.load_image(name, bytes);
                 }
+                this._loadMarkdownStyles(engine, markdownStylesSrcs(xml));
+                this._loadFiles(engine, extractAssetSrcs(xml, 'file'));
                 // 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)) {
@@ -145,12 +192,8 @@ class PdfEngine {
                         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);
+                pdf = engine.render_pdf(xml, dataJson, ...(0, _shared_1.encryptionArguments)(callOptions, secureRandomBytes));
             }
             else {
                 // JSON (Kit tree) path — pass JSON directly to render_tree_pdf. Fonts and images the
@@ -180,15 +223,15 @@ class PdfEngine {
                 for (const [name, bytes] of allImages) {
                     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);
+                this._loadMarkdownStyles(engine, markdownStylesSrcsOfDocument(input));
+                this._loadFiles(engine, fileSrcsOfDocument(input));
+                pdf = engine.render_tree_pdf(json, ...(0, _shared_1.encryptionArguments)(callOptions, secureRandomBytes));
             }
         }
         catch (e) {
             engine.free();
+            if (e instanceof LpdfRenderError)
+                throw e;
             const msg = e instanceof Error ? e.message : String(e);
             throw new LpdfRenderError(msg);
         }
@@ -198,21 +241,80 @@ class PdfEngine {
 }
 exports.PdfEngine = PdfEngine;
 // ── Helpers ───────────────────────────────────────────────────────────────────
-/** Extract `ref??name → src` pairs from `<font>` or `<image>` tags in XML. */
+// Comments and CDATA sections, whose text is not markup: a <file> shown in a Markdown block is text, not a file.
+const XML_NOT_MARKUP_RE = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>/g;
+const XML_ATTRIBUTE_RE = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+const XML_ENTITY_RE = /&(?:(amp|lt|gt|quot|apos)|#(\d+)|#x([0-9a-fA-F]+));/g;
+const XML_ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+/** An attribute value as the XML means it, with its entities and character references decoded. */
+function decodeXml(value) {
+    return value.replace(XML_ENTITY_RE, (_, name, decimal, hex) => 
+    // XML_ENTITY_RE matches exactly one of its three groups, so without a name or a decimal there is a hex.
+    name ? XML_ENTITIES[name] : String.fromCodePoint(parseInt(decimal ?? hex, decimal ? 10 : 16)));
+}
+/**
+ * The attributes of each `<tag>` element in XML, read as the engine reads them: comments and CDATA sections are left
+ * out, a quoted value may hold a `>`, either quote may be used, and the values are decoded.
+ */
+function xmlElements(xml, tag) {
+    const elements = [];
+    // Attribute values may contain '>', so quoted runs are matched whole.
+    const re = new RegExp(`<${tag}\\b((?:[^>"']|"[^"]*"|'[^']*')*)>`, 'g');
+    for (const match of xml.replace(XML_NOT_MARKUP_RE, '').matchAll(re)) {
+        const attributes = new Map();
+        for (const attribute of match[1].matchAll(XML_ATTRIBUTE_RE)) {
+            attributes.set(attribute[1], decodeXml(attribute[2] ?? attribute[3]));
+        }
+        elements.push(attributes);
+    }
+    return elements;
+}
+/** The `ref ?? name → src` pairs of the `<font>`, `<image>` or `<file>` elements 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;
+    for (const attributes of xmlElements(xml, tag)) {
+        const key = attributes.get('ref') ?? attributes.get('name');
+        const src = attributes.get('src');
         if (key && src)
             result.set(key, src);
     }
     return result;
 }
+/** The `src` of each `<markdown-styles>` in XML. */
+function markdownStylesSrcs(xml) {
+    const srcs = [];
+    for (const attributes of xmlElements(xml, 'markdown-styles')) {
+        const src = attributes.get('src');
+        if (src)
+            srcs.push(src);
+    }
+    return srcs;
+}
+/** The `src` of each `markdown-styles` a document holds, in the markdown of any of its sections. */
+function markdownStylesSrcsOfDocument(document) {
+    const srcs = [];
+    for (const section of document.nodes) {
+        for (const child of section.nodes) {
+            if (child.type !== 'markdown')
+                continue;
+            for (const part of child.nodes) {
+                const src = part.type === 'markdown-styles' ? part.attrs['src'] : undefined;
+                if (typeof src === 'string' && src)
+                    srcs.push(src);
+            }
+        }
+    }
+    return srcs;
+}
+/** The `ref ?? name → src` pairs of the files a document carries in `attrs.attachments`. */
+function fileSrcsOfDocument(document) {
+    const result = new Map();
+    for (const { name, ref, src } of document.attrs['attachments'] ?? []) {
+        if (src)
+            result.set(ref ?? name, src);
+    }
+    return result;
+}
 /** The `ref ?? name → src` pairs of the fonts or images a document declares in `attrs.assets`. */
 function assetSrcsOfDocument(document, kind) {
     const result = new Map();

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 export { PdfEngine, LpdfRenderError } from './engine';
-export type { EncryptPermissions, EncryptOptions } from './engine';
 export type { RenderOptions, EngineOptions } from './_shared';
-export { FieldType, Pin, Orientation, SectionType, FootnoteCounter, BuiltinFont, PageScope } from './constants';
-export type { PdfDocument, LpdfSectionNode, LpdfSectionChild, LpdfLayoutBlock, DocumentTokens, GradientToken, GradientStop, DocumentAssets, DocumentMeta, SectionAttr, DocumentAttr, } from './kit';
-export type { ColumnAttr, RowAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, ShapeAttr, BarcodeAttr, RegionAttr, FieldAttr, BookmarkAttr, LayerAttr, RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, TextAtAttr, ImgAtAttr, BarcodeAtAttr, FontAttr, ImageAttr, LayoutAttr, } from './attrs';
-export type { LpdfNode, LpdfContainerNode, LpdfTextNode, LpdfSpanNode, LpdfFnNode, LpdfDividerNode, LpdfImgNode, LpdfShapeNode, LpdfBarcodeNode, LpdfTableNode, LpdfTheadNode, LpdfTrNode, LpdfTdNode, LpdfRegionNode, LpdfFieldNode, LpdfBookmarkNode, } from './layout';
+export { FieldType, Pin, Orientation, SectionType, FootnoteCounter, Cipher, Permission, FileRelationship, BuiltinFont, PageScope, } from './constants';
+export type { PdfDocument, LpdfSectionNode, LpdfSectionChild, LpdfLayoutBlock, DocumentTokens, TokenSlot, TokenRow, DocumentAssets, DocumentMeta, DocumentOutput, SectionAttr, DocumentAttr, } from './kit';
+export type { ColumnAttr, RowAttr, GridAttr, ListAttr, LiAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, CodeAttr, SpanAttr, CodeSpanAttr, DividerAttr, ImgAttr, ShapeAttr, BarcodeAttr, RegionAttr, FieldAttr, BookmarkAttr, LayerAttr, RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, TextAtAttr, ImgAtAttr, BarcodeAtAttr, FontAttr, ImageAttr, FileAttr, LayoutAttr, GradientToken, GradientStop, MarkdownAttr, MarkdownStylesAttr, MarkdownH1Attr, MarkdownH2Attr, MarkdownH3Attr, MarkdownH4Attr, MarkdownH5Attr, MarkdownH6Attr, MarkdownPAttr, MarkdownCodeAttr, MarkdownQuoteAttr, MarkdownLiAttr, MarkdownAAttr, MarkdownStrongAttr, MarkdownEmAttr, MarkdownDelAttr, MarkdownTableAttr, MarkdownThAttr, MarkdownTdAttr, } from './attrs';
+export type { LpdfNode, LpdfContainerNode, LpdfListNode, LpdfLiNode, LpdfTextNode, LpdfCodeNode, LpdfSpanNode, LpdfCodeSpanNode, LpdfFnNode, LpdfDividerNode, LpdfImgNode, LpdfShapeNode, LpdfBarcodeNode, LpdfTableNode, LpdfTheadNode, LpdfTrNode, LpdfTdNode, LpdfRegionNode, LpdfFieldNode, LpdfBookmarkNode, } from './layout';
+export { LMarkdown } from './markdown';
+export type { LpdfMarkdownNode, LpdfMarkdownStylesNode, LpdfMarkdownContentNode, LpdfMarkdownRuleNode, } from './markdown';
 export { CanvasTransform } from './canvas';
 export type { LpdfCanvasLayerNode, LpdfCanvasPrimitiveNode, LpdfCanvasRectNode, LpdfCanvasLineNode, LpdfCanvasEllipseNode, LpdfCanvasCircleNode, LpdfCanvasPathNode, LpdfCanvasTextAtNode, LpdfCanvasImgAtNode, LpdfCanvasBarcodeAtNode, } from './canvas';
 export { L, NoAttr } from './L';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoAttr = exports.L = exports.CanvasTransform = exports.PageScope = exports.BuiltinFont = exports.FootnoteCounter = exports.SectionType = exports.Orientation = exports.Pin = exports.FieldType = exports.LpdfRenderError = exports.PdfEngine = void 0;
+exports.NoAttr = exports.L = exports.CanvasTransform = exports.LMarkdown = exports.PageScope = exports.BuiltinFont = exports.FileRelationship = exports.Permission = exports.Cipher = exports.FootnoteCounter = exports.SectionType = 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; } });
@@ -12,8 +12,14 @@ Object.defineProperty(exports, "Pin", { enumerable: true, get: function () { ret
 Object.defineProperty(exports, "Orientation", { enumerable: true, get: function () { return constants_1.Orientation; } });
 Object.defineProperty(exports, "SectionType", { enumerable: true, get: function () { return constants_1.SectionType; } });
 Object.defineProperty(exports, "FootnoteCounter", { enumerable: true, get: function () { return constants_1.FootnoteCounter; } });
+Object.defineProperty(exports, "Cipher", { enumerable: true, get: function () { return constants_1.Cipher; } });
+Object.defineProperty(exports, "Permission", { enumerable: true, get: function () { return constants_1.Permission; } });
+Object.defineProperty(exports, "FileRelationship", { enumerable: true, get: function () { return constants_1.FileRelationship; } });
 Object.defineProperty(exports, "BuiltinFont", { enumerable: true, get: function () { return constants_1.BuiltinFont; } });
 Object.defineProperty(exports, "PageScope", { enumerable: true, get: function () { return constants_1.PageScope; } });
+// ── Markdown ──────────────────────────────────────────────────────────────────
+var markdown_1 = require("./markdown");
+Object.defineProperty(exports, "LMarkdown", { enumerable: true, get: function () { return markdown_1.LMarkdown; } });
 // ── Layer types ───────────────────────────────────────────────────────────────
 var canvas_1 = require("./canvas");
 Object.defineProperty(exports, "CanvasTransform", { enumerable: true, get: function () { return canvas_1.CanvasTransform; } });

package/dist/kit.d.ts

@@ -21,24 +21,13 @@
  */
 import type { LpdfBookmarkNode, LpdfNode } from './layout';
 import type { LpdfCanvasLayerNode } from './canvas';
-import type { FontAttr, ImageAttr, LayoutAttr } from './attrs';
-/** One color of a gradient: `color` is hex or a color token, at an `offset` from `'0%'` to `'100%'`. */
-export interface GradientStop {
-    offset: string;
-    color: string;
-}
-/**
- * A gradient of the tokens, which a background or a fill uses as `gradient:name`. Give `from` and `to` for two
- * colors, or `stops` for more. `angle` is the direction of a linear gradient in degrees: 0 runs top to bottom
- * and 90 left to right. A radial gradient runs from the center of the box out to its farthest corner.
- */
-export interface GradientToken {
-    type: 'linear' | 'radial';
-    from?: string;
-    to?: string;
-    angle?: number | string;
-    stops?: GradientStop[];
-}
+import type { LpdfMarkdownNode } from './markdown';
+import type { FileAttr, FontAttr, GradientToken, ImageAttr, LayoutAttr } from './attrs';
+import { type AttrValue } from './_shared';
+/** A slot of a token row, from the smallest to the largest. */
+export type TokenSlot = 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl';
+/** A token row: a value for each slot it sets. */
+export type TokenRow<T> = Partial<Record<TokenSlot, T>>;
 export interface DocumentTokens {
     colors?: Record<string, string>;
     gradients?: Record<string, GradientToken>;
@@ -48,15 +37,16 @@ export interface DocumentTokens {
      * starting with a letter, and is neither a slot nor `fill` or `full`.
      */
     aliases?: Record<string, string>;
-    space?: Record<string, string>;
-    grid?: Record<string, string>;
-    border?: Record<string, string>;
-    radius?: Record<string, string>;
-    width?: Record<string, string>;
+    space?: TokenRow<string>;
+    grid?: TokenRow<string>;
+    border?: TokenRow<string>;
+    radius?: TokenRow<string>;
+    width?: TokenRow<string>;
     /** The heights `height` names: `{ xs: '16pt', s: '24pt', m: '32pt', l: '48pt', xl: '64pt', xxl: '96pt' }` by default. */
-    height?: Record<string, string>;
-    textSize?: Record<string, string>;
-    lineHeight?: Record<string, string>;
+    height?: TokenRow<string>;
+    textSize?: TokenRow<string>;
+    /** The factors `lineHeight` names, each a number above 0: `{ xs: 1, s: 1.1, m: 1.2, l: 1.4, xl: 1.6, xxl: 2 }` by default. */
+    lineHeight?: TokenRow<number>;
 }
 /**
  * The fonts and images the document declares, as the `assets` element of the XML does. A font or image
@@ -73,12 +63,32 @@ export interface DocumentMeta {
     keywords?: string;
     creator?: string;
 }
+/**
+ * How the PDF file is written, as the `output` element of the XML is: whether it is encrypted, and what a reader
+ * may do with it, and the standard it meets. The passwords are not here: they come with the render call.
+ */
+export interface DocumentOutput {
+    /** The cipher the PDF is encrypted with, `aes-256` or `rc4-128` (`Cipher`). Without it the PDF is not encrypted. */
+    encrypt?: string;
+    /**
+     * What a reader may do without the owner password, separated by spaces (`Permission`): `all`, or any of
+     * `print`, `modify`, `copy`, `annotate`, `fill-forms`, `accessibility`, `assemble`. A permission comes only from
+     * naming it: without `allow`, or with `''`, nothing is allowed, and `all` allows everything. It needs `encrypt`.
+     */
+    allow?: string;
+    /**
+     * Writes the PDF as PDF/A, the standard for files kept for the long term: `2b`, or `2u` when its text must also
+     * be searchable. The render needs `createdOn`, and every text a font of `assets`. What PDF/A cannot hold is an
+     * error that says what to change: a built-in font, a CMYK color, a form field, a barcode's digits, `encrypt`.
+     */
+    pdfa?: string;
+}
 export interface SectionAttr {
     size?: string;
     orientation?: string;
     background?: string;
     title?: string;
-    debug?: string;
+    debug?: boolean;
     type?: string;
     tocIndentStep?: string;
     footnoteCounter?: string;
@@ -91,25 +101,31 @@ export interface DocumentAttr {
     assets?: DocumentAssets;
     tokens?: DocumentTokens;
     meta?: DocumentMeta;
-    debug?: string;
+    output?: DocumentOutput;
+    /**
+     * Files the PDF carries inside it, as the `attachments` element of the XML does: a reader lists them in its
+     * attachments panel. Each file's bytes are read from its `src`, or loaded with `loadFile` under its `ref` or name.
+     */
+    attachments?: FileAttr[];
+    debug?: boolean;
     footnoteCounter?: string;
 }
 /** A layout block — wraps an ordered list of layout nodes. */
 export interface LpdfLayoutBlock {
     type: 'layout';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
     nodes: LpdfNode[];
 }
 export interface LpdfSectionNode {
     type: 'section';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
     nodes: LpdfSectionChild[];
 }
 /**
- * What a section holds: a bookmark first, then layers, then at most one layout, then layers. Layers before
- * the layout paint under it, and layers after it paint over it.
+ * What a section holds: a bookmark first, then layers, then at most one layout or one markdown, then layers.
+ * Layers before the layout paint under it, and layers after it paint over it.
  */
-export type LpdfSectionChild = LpdfBookmarkNode | LpdfCanvasLayerNode | LpdfLayoutBlock;
+export type LpdfSectionChild = LpdfBookmarkNode | LpdfCanvasLayerNode | LpdfLayoutBlock | LpdfMarkdownNode;
 export interface PdfDocument {
     version: 1;
     type: 'document';

package/dist/kit.js

@@ -35,13 +35,15 @@ function section(attrs, nodes = []) {
     };
 }
 function document(attrs, nodes = []) {
-    const { assets, tokens, meta, ...restOpts } = attrs ?? {};
+    const { assets, tokens, meta, output, attachments, ...restOpts } = attrs ?? {};
     const attrsObj = {
         ...(0, _shared_1.buildAttrs)(restOpts),
     };
     if (assets !== undefined)
         attrsObj['assets'] = assets;
     if (tokens !== undefined) {
+        // A factor of the line-height row and a gradient's angle are numbers, which JSON can't hold as NaN or infinity.
+        (0, _shared_1.assertFiniteIn)('tokens', tokens);
         const { textSize, lineHeight, ...rest } = tokens;
         attrsObj['tokens'] = {
             ...rest,
@@ -51,6 +53,10 @@ function document(attrs, nodes = []) {
     }
     if (meta !== undefined)
         attrsObj['meta'] = meta;
+    if (output !== undefined)
+        attrsObj['output'] = output;
+    if (attachments !== undefined)
+        attrsObj['attachments'] = attachments;
     return {
         version: 1,
         type: 'document',

package/dist/layout.d.ts

@@ -1,87 +1,126 @@
-import type { ColumnAttr, RowAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, ShapeAttr, BarcodeAttr, FieldAttr, RegionAttr, BookmarkAttr } from './attrs';
+import type { ColumnAttr, RowAttr, GridAttr, ListAttr, LiAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, CodeAttr, SpanAttr, CodeSpanAttr, DividerAttr, ImgAttr, ShapeAttr, BarcodeAttr, FieldAttr, RegionAttr, BookmarkAttr } from './attrs';
+import { type AttrValue } from './_shared';
 export interface LpdfSpanNode {
     type: 'span';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
+    nodes: string[];
+}
+/** A run of code inside a text: its words in the code font on a tint. */
+export interface LpdfCodeSpanNode {
+    type: 'code-span';
+    attrs: Record<string, AttrValue>;
     nodes: string[];
 }
 /** A footnote: its words go at the bottom of the page where its number lands. */
 export interface LpdfFnNode {
     type: 'fn';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
     nodes: (string | LpdfSpanNode)[];
 }
 export interface LpdfContainerNode {
     type: 'column' | 'row' | 'grid' | 'frame' | 'link';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
+    nodes: LpdfNode[];
+}
+/** A list of items, each marked with a bullet or a number the engine gives. */
+export interface LpdfListNode {
+    type: 'list';
+    attrs: Record<string, AttrValue>;
+    nodes: LpdfLiNode[];
+}
+/** One item of a list: what a layout holds, beside the item's marker. */
+export interface LpdfLiNode {
+    type: 'li';
+    attrs: Record<string, AttrValue>;
     nodes: LpdfNode[];
 }
 export interface LpdfTextNode {
     type: 'text';
-    attrs: Record<string, string>;
-    nodes: (string | LpdfSpanNode | LpdfFnNode)[];
+    attrs: Record<string, AttrValue>;
+    nodes: (string | LpdfSpanNode | LpdfCodeSpanNode | LpdfFnNode)[];
+}
+/** Code in a box. Its strings keep their spaces and lines; its spans color parts of it. */
+export interface LpdfCodeNode {
+    type: 'code';
+    attrs: Record<string, AttrValue>;
+    nodes: (string | LpdfSpanNode)[];
 }
 export interface LpdfDividerNode {
     type: 'divider';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
 }
 export interface LpdfImgNode {
     type: 'img';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
 }
 export interface LpdfShapeNode {
     type: 'shape';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
 }
 export interface LpdfBarcodeNode {
     type: 'barcode';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
 }
 export interface LpdfTheadNode {
     type: 'thead';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
     nodes: LpdfTdNode[];
 }
 export interface LpdfTrNode {
     type: 'tr';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
     nodes: LpdfTdNode[];
 }
 export interface LpdfTdNode {
     type: 'td';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
     nodes: LpdfNode[];
 }
 export interface LpdfTableNode {
     type: 'table';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
     nodes: (LpdfTheadNode | LpdfTrNode)[];
 }
 export interface LpdfRegionNode {
     type: 'region';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
     nodes: LpdfNode[];
 }
 export interface LpdfFieldNode {
     type: 'field';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
 }
 /** An outline entry and link target that marks the node after it; it draws nothing. */
 export interface LpdfBookmarkNode {
     type: 'bookmark';
-    attrs: Record<string, string>;
+    attrs: Record<string, AttrValue>;
 }
-export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfShapeNode | LpdfBarcodeNode | LpdfRegionNode | LpdfFieldNode | LpdfBookmarkNode;
+export type LpdfNode = LpdfContainerNode | LpdfListNode | LpdfTextNode | LpdfCodeNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfShapeNode | LpdfBarcodeNode | LpdfRegionNode | LpdfFieldNode | LpdfBookmarkNode;
 declare function column(attrs: ColumnAttr | null, nodes?: LpdfNode[]): LpdfContainerNode;
 declare function row(attrs: RowAttr | 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, nodes?: LpdfNode[]): LpdfContainerNode;
+/**
+ * A list of items, which are `li` nodes. A bullet list marks each item with a shape; with `type: 'number'` the
+ * engine numbers them, in the `format` given, and the numbers follow the items that `data-source` makes.
+ */
+declare function list(attrs: ListAttr | null, nodes?: LpdfLiNode[]): LpdfListNode;
+/** An item of a list. Its words go in a `text`; a `list` inside it is a list under the item. */
+declare function li(attrs: LiAttr | null, nodes?: LpdfNode[]): LpdfLiNode;
 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 | LpdfFnNode)[]): LpdfTextNode;
+declare function text(attrs: TextAttr | null, nodes?: (string | LpdfSpanNode | LpdfCodeSpanNode | LpdfFnNode)[]): LpdfTextNode;
+/**
+ * Code in a box that fills the width and grows with its lines. The strings are kept as they are written: every
+ * space, and a new line wherever a `\n` is. A line longer than the box wraps. The spans color parts of it.
+ */
+declare function code(attrs: CodeAttr | null, nodes?: (string | LpdfSpanNode)[]): LpdfCodeNode;
 declare function span(attrs: SpanAttr | null, nodes?: string[]): LpdfSpanNode;
+/** A run of code in the nodes of a text: its words in the code font on a tint. */
+declare function codeSpan(attrs: CodeSpanAttr | null, nodes?: string[]): LpdfCodeSpanNode;
 /**
  * A footnote, in the nodes of a text. The engine numbers it and puts a small raised number at its place in the
  * text; its words go at the bottom of the page where that number lands. It has no attributes: pass `NoAttr`.
@@ -104,10 +143,14 @@ export declare const LpdfLayout: Readonly<{
     column: typeof column;
     row: typeof row;
     grid: typeof grid;
+    list: typeof list;
+    li: typeof li;
     frame: typeof frame;
     link: typeof link;
     text: typeof text;
+    code: typeof code;
     span: typeof span;
+    codeSpan: typeof codeSpan;
     fn: typeof fn;
     divider: typeof divider;
     img: typeof img;

package/dist/layout.js

@@ -22,6 +22,17 @@ function frame(attrs, nodes = []) {
 function link(attrs, nodes = []) {
     return makeContainer('link', attrs, nodes);
 }
+/**
+ * A list of items, which are `li` nodes. A bullet list marks each item with a shape; with `type: 'number'` the
+ * engine numbers them, in the `format` given, and the numbers follow the items that `data-source` makes.
+ */
+function list(attrs, nodes = []) {
+    return { type: 'list', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
+}
+/** An item of a list. Its words go in a `text`; a `list` inside it is a list under the item. */
+function li(attrs, nodes = []) {
+    return { type: 'li', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
+}
 function table(attrs, nodes = []) {
     return { type: 'table', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
 }
@@ -37,9 +48,20 @@ function td(attrs, nodes = []) {
 function text(attrs, nodes = []) {
     return { type: 'text', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
 }
+/**
+ * Code in a box that fills the width and grows with its lines. The strings are kept as they are written: every
+ * space, and a new line wherever a `\n` is. A line longer than the box wraps. The spans color parts of it.
+ */
+function code(attrs, nodes = []) {
+    return { type: 'code', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
+}
 function span(attrs, nodes = []) {
     return { type: 'span', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
 }
+/** A run of code in the nodes of a text: its words in the code font on a tint. */
+function codeSpan(attrs, nodes = []) {
+    return { type: 'code-span', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
+}
 /**
  * A footnote, in the nodes of a text. The engine numbers it and puts a small raised number at its place in the
  * text; its words go at the bottom of the page where that number lands. It has no attributes: pass `NoAttr`.
@@ -78,10 +100,14 @@ exports.LpdfLayout = Object.freeze({
     column,
     row,
     grid,
+    list,
+    li,
     frame,
     link,
     text,
+    code,
     span,
+    codeSpan,
     fn,
     divider,
     img,