@lpdfio/lpdf 0.28.1 → 0.30.0

package/dist/browser.js

@@ -45,6 +45,20 @@ var LpdfEngine = class {
     const len1 = WASM_VECTOR_LEN;
     wasm.lpdfengine_load_image(this.__wbg_ptr, ptr0, len0, ptr1, len1);
   }
+  /**
+   * Register the text of a file of Markdown rules, the root of which is a `<markdown-styles>`, for the
+   * `src` that names it. The engine reads no files: call this once for every `<markdown-styles src="…">`
+   * of the document before `render_pdf`, as `load_font` is called for a font.
+   * @param {string} src
+   * @param {string} xml
+   */
+  load_markdown_styles(src, xml) {
+    const ptr0 = passStringToWasm0(src, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    wasm.lpdfengine_load_markdown_styles(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+  }
   /**
    * @param {string} license_key
    */
@@ -151,26 +165,40 @@ var LpdfEngine = class {
     wasm.lpdfengine_set_created_on(this.__wbg_ptr, ptr0, len0);
   }
   /**
-   * Configure RC4-128 encryption applied to every subsequent `render_pdf` call.
+   * Configure encryption applied to every subsequent `render_pdf` call.
    *
    * `permissions_json` is a JSON object with boolean fields matching the
    * `Permissions` struct (`print`, `modify`, `copy`, `annotate`, `fill_forms`,
    * `accessibility`, `assemble`, `print_hq`). Omitted fields default to `true`.
    *
+   * `algorithm` is `"aes-256"` or `"rc4-128"`. AES-256 needs `entropy`: at least 32
+   * random bytes from the host's secure generator, from which the core cuts the file
+   * key, salts and IVs. RC4-128 ignores it. Fails when the algorithm is unknown or
+   * AES-256 gets too little entropy.
+   *
    * To apply permissions without an open password, pass an empty `user_password`
    * and a non-empty `owner_password`.
    * @param {string} user_password
    * @param {string} owner_password
    * @param {string} permissions_json
+   * @param {string} algorithm
+   * @param {Uint8Array} entropy
    */
-  set_encryption(user_password, owner_password, permissions_json) {
+  set_encryption(user_password, owner_password, permissions_json, algorithm, entropy) {
     const ptr0 = passStringToWasm0(user_password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passStringToWasm0(owner_password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
     const ptr2 = passStringToWasm0(permissions_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len2 = WASM_VECTOR_LEN;
-    wasm.lpdfengine_set_encryption(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    const ptr3 = passStringToWasm0(algorithm, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len3 = WASM_VECTOR_LEN;
+    const ptr4 = passArray8ToWasm0(entropy, wasm.__wbindgen_malloc);
+    const len4 = WASM_VECTOR_LEN;
+    const ret = wasm.lpdfengine_set_encryption(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
   }
   /**
    * Inject glyph advance-width tables for custom fonts.
@@ -413,6 +441,11 @@ var Orientation = {
 var SectionType = {
   Toc: "toc"
 };
+var FootnoteCounter = {
+  Page: "page",
+  Section: "section",
+  Document: "document"
+};
 var BuiltinFont = {
   Courier: "Courier",
   CourierBold: "Courier-Bold",
@@ -446,6 +479,7 @@ async function initLpdf(wasmSource, licenseKey = "") {
   await __wbg_init(wasmSource);
   const fontMap = /* @__PURE__ */ new Map();
   const imageMap = /* @__PURE__ */ new Map();
+  const markdownStyles = /* @__PURE__ */ new Map();
   return {
     loadFont(name, bytes) {
       fontMap.set(name, bytes);
@@ -453,6 +487,9 @@ async function initLpdf(wasmSource, licenseKey = "") {
     loadImage(name, bytes) {
       imageMap.set(name, bytes);
     },
+    loadMarkdownStyles(src, text) {
+      markdownStyles.set(src, text);
+    },
     checkLicenseKey(key) {
       return JSON.parse(check_license(key ?? licenseKey, nowUnix()));
     },
@@ -465,6 +502,9 @@ async function initLpdf(wasmSource, licenseKey = "") {
       for (const [name, bytes] of imageMap) {
         engine.load_image(name, bytes);
       }
+      for (const [src, text] of markdownStyles) {
+        engine.load_markdown_styles(src, text);
+      }
       if (callOptions.createdOn) {
         engine.set_created_on(callOptions.createdOn);
       }
@@ -490,6 +530,7 @@ async function initLpdf(wasmSource, licenseKey = "") {
 export {
   BuiltinFont,
   FieldType,
+  FootnoteCounter,
   NoAttr,
   Orientation,
   PageScope,

package/dist/canvas.d.ts

@@ -1,5 +1,5 @@
 import type { RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, TextAtAttr, ImgAtAttr, BarcodeAtAttr, LayerAttr } from './attrs';
-import type { LpdfSpanNode } from './layout';
+import type { LpdfSpanNode, LpdfCodeSpanNode } 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)`.
@@ -44,7 +44,7 @@ export interface LpdfCanvasPathNode {
 export interface LpdfCanvasTextAtNode {
     type: 'text-at';
     attrs: Record<string, string>;
-    nodes: (string | LpdfSpanNode)[];
+    nodes: (string | LpdfSpanNode | LpdfCodeSpanNode)[];
 }
 export interface LpdfCanvasImgAtNode {
     type: 'img-at';
@@ -65,7 +65,7 @@ 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: TextAtAttr, nodes?: (string | LpdfSpanNode)[]): LpdfCanvasTextAtNode;
+declare function textAt(attrs: TextAtAttr, nodes?: (string | LpdfSpanNode | LpdfCodeSpanNode)[]): LpdfCanvasTextAtNode;
 declare function imgAt(attrs: ImgAtAttr): LpdfCanvasImgAtNode;
 declare function barcodeAt(attrs: BarcodeAtAttr): LpdfCanvasBarcodeAtNode;
 declare function layer(attrs: LayerAttr | null, nodes?: LpdfCanvasPrimitiveNode[]): LpdfCanvasLayerNode;

package/dist/constants.d.ts

@@ -26,6 +26,13 @@ export declare const SectionType: {
     readonly Toc: "toc";
 };
 export type SectionType = (typeof SectionType)[keyof typeof SectionType];
+/** The values of the `footnote-counter` attribute of a document or a section. */
+export declare const FootnoteCounter: {
+    readonly Page: "page";
+    readonly Section: "section";
+    readonly Document: "document";
+};
+export type FootnoteCounter = (typeof FootnoteCounter)[keyof typeof FootnoteCounter];
 /** 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";

package/dist/constants.js

@@ -2,7 +2,7 @@
 // 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.SectionType = exports.Orientation = exports.Pin = exports.FieldType = void 0;
+exports.PageScope = exports.BuiltinFont = exports.FootnoteCounter = exports.SectionType = exports.Orientation = exports.Pin = exports.FieldType = void 0;
 /** The values of the `type` attribute of a field. */
 exports.FieldType = {
     Text: 'text',
@@ -27,6 +27,12 @@ exports.Orientation = {
 exports.SectionType = {
     Toc: 'toc',
 };
+/** The values of the `footnote-counter` attribute of a document or a section. */
+exports.FootnoteCounter = {
+    Page: 'page',
+    Section: 'section',
+    Document: 'document',
+};
 /** The values of the `core` attribute of a font: the built-in PDF fonts, which need no file. */
 exports.BuiltinFont = {
     Courier: 'Courier',

package/dist/engine.d.ts

@@ -26,7 +26,7 @@ export interface LicenseCheck {
 export declare class LpdfRenderError extends Error {
     constructor(message: string);
 }
-/** PDF permission flags for RC4-128 encryption. All flags default to `true` (allowed). */
+/** PDF permission flags. All flags default to `true` (allowed). */
 export interface EncryptPermissions {
     print?: boolean;
     modify?: boolean;
@@ -37,7 +37,12 @@ export interface EncryptPermissions {
     assemble?: boolean;
     print_hq?: boolean;
 }
-/** RC4-128 encryption options passed to {@link PdfEngine.setEncryption}. */
+/**
+ * The cipher a PDF is encrypted with. `'aes-256'` is the default. `'rc4-128'` is deprecated by
+ * PDF 2.0; use it only for readers that cannot open AES-256.
+ */
+export type EncryptAlgorithm = 'aes-256' | '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;
@@ -45,11 +50,17 @@ export interface EncryptOptions {
     ownerPassword: string;
     /** Permission flags applied to the document. Omitted flags default to `true`. */
     permissions?: EncryptPermissions;
+    /**
+     * The cipher. Defaults to `'aes-256'`, which makes every render of the same document differ
+     * in its bytes, since each one gets a fresh random key.
+     */
+    algorithm?: EncryptAlgorithm;
 }
 export declare class PdfEngine {
     private _licenseKey;
     private readonly _fonts;
     private readonly _images;
+    private readonly _markdownStyles;
     private _disposed;
     private _encrypt;
     constructor();
@@ -80,8 +91,13 @@ export declare class PdfEngine {
      */
     loadImage(name: string, bytes: Uint8Array): this;
     /**
-     * Configure RC4-128 encryption for all subsequent `render` calls.
-     * 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.
+     */
+    loadMarkdownStyles(src: string, text: string): this;
+    /**
+     * Configure encryption for all subsequent `render` calls: AES-256 unless
+     * `options.algorithm` says `'rc4-128'`. Returns `this` for chaining.
      */
     setEncryption(options: EncryptOptions): this;
     /**
@@ -95,6 +111,11 @@ export declare class PdfEngine {
      */
     dispose(): void;
     [Symbol.dispose](): void;
+    /**
+     * 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`.
+     */
+    private _loadMarkdownStyles;
     private _throwIfDisposed;
     /**
      * Render an lpdf XML string to PDF bytes (Node.js).

package/dist/engine.js

@@ -1,6 +1,7 @@
 "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");
 // require() path is relative to the compiled output at dist/engine.js.
 // In the published package, wasm-pack artifacts live in dist/wasm/.
@@ -28,11 +29,22 @@ class LpdfRenderError extends Error {
     }
 }
 exports.LpdfRenderError = LpdfRenderError;
+/**
+ * Hands the engine the encryption options. AES-256 needs random bytes, which the engine does not
+ * make: they come from Node's secure generator, 32 bytes for each render.
+ */
+function configureEncryption(engine, options) {
+    const algorithm = options.algorithm ?? 'aes-256';
+    const entropy = algorithm === 'aes-256' ? new Uint8Array((0, node_crypto_1.randomBytes)(32)) : new Uint8Array(0);
+    const permsJson = JSON.stringify(options.permissions ?? {});
+    engine.set_encryption(options.userPassword, options.ownerPassword, permsJson, algorithm, entropy);
+}
 class PdfEngine {
     constructor() {
         this._licenseKey = '';
         this._fonts = new Map();
         this._images = new Map();
+        this._markdownStyles = new Map();
         this._disposed = false;
         this._encrypt = null;
     }
@@ -78,8 +90,17 @@ class PdfEngine {
         return this;
     }
     /**
-     * Configure RC4-128 encryption for all subsequent `render` calls.
-     * 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.
+     */
+    loadMarkdownStyles(src, text) {
+        this._throwIfDisposed();
+        this._markdownStyles.set(src, text);
+        return this;
+    }
+    /**
+     * Configure encryption for all subsequent `render` calls: AES-256 unless
+     * `options.algorithm` says `'rc4-128'`. Returns `this` for chaining.
      */
     setEncryption(options) {
         this._throwIfDisposed();
@@ -103,6 +124,24 @@ 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);
+        }
+    }
     _throwIfDisposed() {
         if (this._disposed)
             throw new Error('PdfEngine has been disposed.');
@@ -136,6 +175,7 @@ class PdfEngine {
                 for (const [name, bytes] of this._images) {
                     engine.load_image(name, bytes);
                 }
+                this._loadMarkdownStyles(engine, markdownStylesSrcs(xml));
                 // 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)) {
@@ -146,8 +186,7 @@ class PdfEngine {
                     }
                 }
                 if (this._encrypt) {
-                    const permsJson = JSON.stringify(this._encrypt.permissions ?? {});
-                    engine.set_encryption(this._encrypt.userPassword, this._encrypt.ownerPassword, permsJson);
+                    configureEncryption(engine, this._encrypt);
                 }
                 const dataJson = callOptions.data != null ? JSON.stringify(callOptions.data) : null;
                 pdf = engine.render_pdf(xml, dataJson);
@@ -180,9 +219,9 @@ class PdfEngine {
                 for (const [name, bytes] of allImages) {
                     engine.load_image(name, bytes);
                 }
+                this._loadMarkdownStyles(engine, markdownStylesSrcsOfDocument(input));
                 if (this._encrypt) {
-                    const permsJson = JSON.stringify(this._encrypt.permissions ?? {});
-                    engine.set_encryption(this._encrypt.userPassword, this._encrypt.ownerPassword, permsJson);
+                    configureEncryption(engine, this._encrypt);
                 }
                 pdf = engine.render_tree_pdf(json);
             }
@@ -213,6 +252,31 @@ function extractAssetSrcs(xml, tag) {
     }
     return result;
 }
+/** The `src` of each `<markdown-styles>` in XML. */
+function markdownStylesSrcs(xml) {
+    const srcs = [];
+    for (const match of xml.matchAll(/<markdown-styles\s[^>]*>/g)) {
+        const src = /\bsrc="([^"]*)"/.exec(match[0])?.[1];
+        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) {
+                if (part.type === 'markdown-styles' && part.attrs['src'])
+                    srcs.push(part.attrs['src']);
+            }
+        }
+    }
+    return srcs;
+}
 /** 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,12 @@
 export { PdfEngine, LpdfRenderError } from './engine';
-export type { EncryptPermissions, EncryptOptions } from './engine';
+export type { EncryptAlgorithm, EncryptPermissions, EncryptOptions } from './engine';
 export type { RenderOptions, EngineOptions } from './_shared';
-export { FieldType, Pin, Orientation, SectionType, BuiltinFont, PageScope } from './constants';
+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, BarcodeAttr, RegionAttr, FieldAttr, BookmarkAttr, LayerAttr, RectAttr, CircleAttr, EllipseAttr, LineAttr, PathAttr, TextAtAttr, ImgAtAttr, BarcodeAtAttr, FontAttr, ImageAttr, LayoutAttr, } from './attrs';
-export type { LpdfNode, LpdfContainerNode, LpdfTextNode, LpdfSpanNode, LpdfDividerNode, LpdfImgNode, LpdfBarcodeNode, LpdfTableNode, LpdfTheadNode, LpdfTrNode, LpdfTdNode, LpdfRegionNode, LpdfFieldNode, LpdfBookmarkNode, } from './layout';
+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, LayoutAttr, 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.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.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; } });
@@ -11,8 +11,12 @@ Object.defineProperty(exports, "FieldType", { enumerable: true, get: function ()
 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, "SectionType", { enumerable: true, get: function () { return constants_1.SectionType; } });
+Object.defineProperty(exports, "FootnoteCounter", { enumerable: true, get: function () { return constants_1.FootnoteCounter; } });
 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,6 +21,7 @@
  */
 import type { LpdfBookmarkNode, LpdfNode } from './layout';
 import type { LpdfCanvasLayerNode } from './canvas';
+import type { LpdfMarkdownNode } from './markdown';
 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 {
@@ -42,11 +43,19 @@ export interface GradientToken {
 export interface DocumentTokens {
     colors?: Record<string, string>;
     gradients?: Record<string, GradientToken>;
+    /**
+     * Names for the slots of the scale, each to the slot it stands for: `{ caption: 'xs' }` lets `fontSize: 'caption'`
+     * mean the text size `xs`, and `gap: 'caption'` the space `xs`. A name is lowercase letters, digits and `-`,
+     * 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>;
+    /** 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>;
 }
@@ -73,6 +82,7 @@ export interface SectionAttr {
     debug?: string;
     type?: string;
     tocIndentStep?: string;
+    footnoteCounter?: string;
 }
 export interface DocumentAttr {
     size?: string;
@@ -83,6 +93,7 @@ export interface DocumentAttr {
     tokens?: DocumentTokens;
     meta?: DocumentMeta;
     debug?: string;
+    footnoteCounter?: string;
 }
 /** A layout block — wraps an ordered list of layout nodes. */
 export interface LpdfLayoutBlock {
@@ -96,10 +107,10 @@ export interface LpdfSectionNode {
     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/layout.d.ts

@@ -1,17 +1,47 @@
-import type { ColumnAttr, RowAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, 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';
 export interface LpdfSpanNode {
     type: 'span';
     attrs: Record<string, string>;
     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, string>;
+    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>;
+    nodes: (string | LpdfSpanNode)[];
+}
 export interface LpdfContainerNode {
     type: 'column' | 'row' | 'grid' | 'frame' | 'link';
     attrs: Record<string, string>;
     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, string>;
+    nodes: LpdfLiNode[];
+}
+/** One item of a list: what a layout holds, beside the item's marker. */
+export interface LpdfLiNode {
+    type: 'li';
+    attrs: Record<string, string>;
+    nodes: LpdfNode[];
+}
 export interface LpdfTextNode {
     type: 'text';
     attrs: Record<string, string>;
+    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, string>;
     nodes: (string | LpdfSpanNode)[];
 }
 export interface LpdfDividerNode {
@@ -22,6 +52,10 @@ export interface LpdfImgNode {
     type: 'img';
     attrs: Record<string, string>;
 }
+export interface LpdfShapeNode {
+    type: 'shape';
+    attrs: Record<string, string>;
+}
 export interface LpdfBarcodeNode {
     type: 'barcode';
     attrs: Record<string, string>;
@@ -60,20 +94,42 @@ export interface LpdfBookmarkNode {
     type: 'bookmark';
     attrs: Record<string, string>;
 }
-export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | 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)[]): 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`.
+ * The words are strings and spans.
+ */
+declare function fn(attrs: null, nodes?: (string | LpdfSpanNode)[]): LpdfFnNode;
 declare function divider(attrs?: DividerAttr | null): LpdfDividerNode;
 declare function img(attrs: ImgAttr): LpdfImgNode;
+/** A rect, circle or ellipse that takes its box in the layout, as an image does. */
+declare function shape(attrs: ShapeAttr): LpdfShapeNode;
 declare function barcode(attrs: BarcodeAttr): LpdfBarcodeNode;
 declare function region(attrs: RegionAttr, nodes?: LpdfNode[]): LpdfRegionNode;
 declare function field(attrs: FieldAttr): LpdfFieldNode;
@@ -86,12 +142,18 @@ 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;
+    shape: typeof shape;
     barcode: typeof barcode;
     table: typeof table;
     thead: typeof thead;