@lpdfio/lpdf 0.29.0 → 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.
@@ -451,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);
@@ -458,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()));
     },
@@ -470,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);
       }

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/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, 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 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.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.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; } });
@@ -14,6 +14,9 @@ Object.defineProperty(exports, "SectionType", { enumerable: true, get: function
 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 {
@@ -106,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,9 +1,15 @@
-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';
 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';
@@ -15,10 +21,28 @@ export interface LpdfContainerNode {
     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 | LpdfFnNode)[];
+    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 {
     type: 'divider';
@@ -70,18 +94,32 @@ export interface LpdfBookmarkNode {
     type: 'bookmark';
     attrs: Record<string, string>;
 }
-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 +142,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,

package/dist/markdown.d.ts

@@ -0,0 +1,75 @@
+import type { MarkdownAttr, MarkdownStylesAttr, MarkdownH1Attr, MarkdownH2Attr, MarkdownH3Attr, MarkdownH4Attr, MarkdownH5Attr, MarkdownH6Attr, MarkdownPAttr, MarkdownCodeAttr, MarkdownQuoteAttr, MarkdownLiAttr, MarkdownAAttr, MarkdownStrongAttr, MarkdownEmAttr, MarkdownDelAttr, MarkdownTableAttr, MarkdownThAttr, MarkdownTdAttr } from './attrs';
+/** A rule of a markdown's styles: the element it is named after, with the attributes it sets. */
+export interface LpdfMarkdownRuleNode {
+    type: 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'code' | 'quote' | 'li' | 'a' | 'strong' | 'em' | 'del' | 'table' | 'th' | 'td';
+    attrs: Record<string, string>;
+}
+/** The rules that say how the parts of a markdown look, with a file of them in `src` when it has one. */
+export interface LpdfMarkdownStylesNode {
+    type: 'markdown-styles';
+    attrs: Record<string, string>;
+    nodes: LpdfMarkdownRuleNode[];
+}
+/** The Markdown itself, as strings. */
+export interface LpdfMarkdownContentNode {
+    type: 'markdown-content';
+    attrs: Record<string, string>;
+    nodes: string[];
+}
+/** A markdown, which takes the place of a layout in a section and holds only Markdown. */
+export interface LpdfMarkdownNode {
+    type: 'markdown';
+    attrs: Record<string, string>;
+    nodes: (LpdfMarkdownStylesNode | LpdfMarkdownContentNode)[];
+}
+/**
+ * Markdown as the content of a section, where a layout would go. It holds only Markdown: the `LMarkdown.styles`
+ * that say how each part looks, which are optional, and one `LMarkdown.content` with the text. What Markdown
+ * can't say, such as the page, a header, a footer or a cover, stays in the section around it: layers paint a
+ * header and a footer in the margin it leaves.
+ *
+ * ```ts
+ * L.markdown({ margin: '54pt', gap: 'm' }, [
+ *   LMarkdown.styles(NoAttr, [LMarkdown.h1({ color: 'muted' })]),
+ *   LMarkdown.content(NoAttr, [body]),
+ * ])
+ * ```
+ */
+declare function markdown(attrs: MarkdownAttr | null, nodes?: (LpdfMarkdownStylesNode | LpdfMarkdownContentNode)[]): LpdfMarkdownNode;
+/**
+ * The rules that say how the parts of a markdown look. A rule is named after the Markdown it styles and takes the
+ * attributes of the element it becomes. A rule here overrides the same rule of the file `src` names, which
+ * overrides the defaults.
+ */
+declare function styles(attrs: MarkdownStylesAttr | null, nodes?: LpdfMarkdownRuleNode[]): LpdfMarkdownStylesNode;
+/**
+ * The Markdown, as strings that make one text. The common indent of its lines is removed, so that indenting the
+ * code does not make a code block of it. It has no attributes: pass `NoAttr`.
+ */
+declare function content(attrs: null, nodes?: string[]): LpdfMarkdownContentNode;
+/** The parts of a markdown: its styles, its content and the rules of its styles. */
+export declare const LMarkdown: Readonly<{
+    styles: typeof styles;
+    content: typeof content;
+    h1: (attrs?: MarkdownH1Attr | null) => LpdfMarkdownRuleNode;
+    h2: (attrs?: MarkdownH2Attr | null) => LpdfMarkdownRuleNode;
+    h3: (attrs?: MarkdownH3Attr | null) => LpdfMarkdownRuleNode;
+    h4: (attrs?: MarkdownH4Attr | null) => LpdfMarkdownRuleNode;
+    h5: (attrs?: MarkdownH5Attr | null) => LpdfMarkdownRuleNode;
+    h6: (attrs?: MarkdownH6Attr | null) => LpdfMarkdownRuleNode;
+    p: (attrs?: MarkdownPAttr | null) => LpdfMarkdownRuleNode;
+    code: (attrs?: MarkdownCodeAttr | null) => LpdfMarkdownRuleNode;
+    quote: (attrs?: MarkdownQuoteAttr | null) => LpdfMarkdownRuleNode;
+    li: (attrs?: MarkdownLiAttr | null) => LpdfMarkdownRuleNode;
+    a: (attrs?: MarkdownAAttr | null) => LpdfMarkdownRuleNode;
+    strong: (attrs?: MarkdownStrongAttr | null) => LpdfMarkdownRuleNode;
+    em: (attrs?: MarkdownEmAttr | null) => LpdfMarkdownRuleNode;
+    del: (attrs?: MarkdownDelAttr | null) => LpdfMarkdownRuleNode;
+    table: (attrs?: MarkdownTableAttr | null) => LpdfMarkdownRuleNode;
+    th: (attrs?: MarkdownThAttr | null) => LpdfMarkdownRuleNode;
+    td: (attrs?: MarkdownTdAttr | null) => LpdfMarkdownRuleNode;
+}>;
+export declare const LpdfMarkdown: Readonly<{
+    markdown: typeof markdown;
+}>;
+export {};