@lpdfio/lpdf 0.28.1 → 0.30.0

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,15 +48,38 @@ 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`.
+ * The words are strings and spans.
+ */
+function fn(attrs, nodes = []) {
+    return { type: 'fn', attrs: {}, nodes };
+}
 function divider(attrs = null) {
     return { type: 'divider', attrs: (0, _shared_1.buildAttrs)(attrs) };
 }
 function img(attrs) {
     return { type: 'img', attrs: (0, _shared_1.buildAttrs)(attrs) };
 }
+/** A rect, circle or ellipse that takes its box in the layout, as an image does. */
+function shape(attrs) {
+    return { type: 'shape', attrs: (0, _shared_1.buildAttrs)(attrs) };
+}
 function barcode(attrs) {
     return { type: 'barcode', attrs: (0, _shared_1.buildAttrs)(attrs) };
 }
@@ -66,12 +100,18 @@ exports.LpdfLayout = Object.freeze({
     column,
     row,
     grid,
+    list,
+    li,
     frame,
     link,
     text,
+    code,
     span,
+    codeSpan,
+    fn,
     divider,
     img,
+    shape,
     barcode,
     table,
     thead,

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 {};

package/dist/markdown.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LpdfMarkdown = exports.LMarkdown = void 0;
+const _shared_1 = require("./_shared");
+// ── The markdown of a section ─────────────────────────────────────────────────
+/**
+ * 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]),
+ * ])
+ * ```
+ */
+function markdown(attrs, nodes = []) {
+    return { type: 'markdown', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
+}
+// ── LMarkdown: the parts of a markdown ────────────────────────────────────────
+/**
+ * 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.
+ */
+function styles(attrs, nodes = []) {
+    return { type: 'markdown-styles', attrs: (0, _shared_1.buildAttrs)(attrs), nodes };
+}
+/**
+ * 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`.
+ */
+function content(attrs, nodes = []) {
+    return { type: 'markdown-content', attrs: {}, nodes };
+}
+function rule(type) {
+    return (attrs = null) => ({ type, attrs: (0, _shared_1.buildAttrs)(attrs) });
+}
+/** The parts of a markdown: its styles, its content and the rules of its styles. */
+exports.LMarkdown = Object.freeze({
+    styles,
+    content,
+    h1: rule('h1'),
+    h2: rule('h2'),
+    h3: rule('h3'),
+    h4: rule('h4'),
+    h5: rule('h5'),
+    h6: rule('h6'),
+    p: rule('p'),
+    code: rule('code'),
+    quote: rule('quote'),
+    li: rule('li'),
+    a: rule('a'),
+    strong: rule('strong'),
+    em: rule('em'),
+    del: rule('del'),
+    table: rule('table'),
+    th: rule('th'),
+    td: rule('td'),
+});
+exports.LpdfMarkdown = Object.freeze({ markdown });

package/dist/wasm/lpdf-web.js

@@ -46,6 +46,20 @@ export class LpdfEngine {
         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
      */
@@ -152,26 +166,40 @@ export class LpdfEngine {
         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.
@@ -344,6 +372,132 @@ export function kit_to_xml(json) {
         wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
+
+/**
+ * The template `template` with an `<image>` declared for each path of the JSON array `srcs`, named as
+ * `markdown_file_images` says.
+ * @param {string} template
+ * @param {string} srcs
+ * @returns {string}
+ */
+export function markdown_declare_images(template, srcs) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(template, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(srcs, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.markdown_declare_images(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * The rules a `<markdown>` with no styles uses, as the file to start a style of one's own from.
+ * @returns {string}
+ */
+export function markdown_default_styles() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.markdown_default_styles();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * The data a template gets for the `.md` file `markdown`, as JSON: the text as `markdown`, and the fields of its
+ * front matter, each a string.
+ * @param {string} markdown
+ * @returns {string}
+ */
+export function markdown_file_data(markdown) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.markdown_file_data(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * The relative paths of the images of the `.md` file `markdown`, as a JSON array. The caller declares them with
+ * `markdown_declare_images` and loads each file, relative to the `.md`, under the name `markdown-image-N` where N
+ * counts from 1 in the order of the array.
+ * @param {string} markdown
+ * @returns {string}
+ */
+export function markdown_file_images(markdown) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.markdown_file_images(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * The looks a `.md` file can start from besides the default one, as a JSON array of `name`, `label`, `description`
+ * and `styles`: the file of styles, to write beside the `.md` file and edit.
+ * @returns {string}
+ */
+export function markdown_style_presets() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.markdown_style_presets();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * The template that wraps a `.md` file when it is rendered with no template of its own: A4, a margin and the
+ * page number. It reads the Markdown from the data `markdown`, the rest of which is the file's front matter.
+ * @returns {string}
+ */
+export function markdown_template() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.markdown_template();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,

package/dist/wasm/lpdf.js

@@ -46,6 +46,20 @@ class LpdfEngine {
         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
      */
@@ -152,26 +166,40 @@ class LpdfEngine {
         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.
@@ -349,6 +377,138 @@ function kit_to_xml(json) {
     }
 }
 exports.kit_to_xml = kit_to_xml;
+
+/**
+ * The template `template` with an `<image>` declared for each path of the JSON array `srcs`, named as
+ * `markdown_file_images` says.
+ * @param {string} template
+ * @param {string} srcs
+ * @returns {string}
+ */
+function markdown_declare_images(template, srcs) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(template, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(srcs, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.markdown_declare_images(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.markdown_declare_images = markdown_declare_images;
+
+/**
+ * The rules a `<markdown>` with no styles uses, as the file to start a style of one's own from.
+ * @returns {string}
+ */
+function markdown_default_styles() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.markdown_default_styles();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.markdown_default_styles = markdown_default_styles;
+
+/**
+ * The data a template gets for the `.md` file `markdown`, as JSON: the text as `markdown`, and the fields of its
+ * front matter, each a string.
+ * @param {string} markdown
+ * @returns {string}
+ */
+function markdown_file_data(markdown) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.markdown_file_data(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.markdown_file_data = markdown_file_data;
+
+/**
+ * The relative paths of the images of the `.md` file `markdown`, as a JSON array. The caller declares them with
+ * `markdown_declare_images` and loads each file, relative to the `.md`, under the name `markdown-image-N` where N
+ * counts from 1 in the order of the array.
+ * @param {string} markdown
+ * @returns {string}
+ */
+function markdown_file_images(markdown) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.markdown_file_images(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.markdown_file_images = markdown_file_images;
+
+/**
+ * The looks a `.md` file can start from besides the default one, as a JSON array of `name`, `label`, `description`
+ * and `styles`: the file of styles, to write beside the `.md` file and edit.
+ * @returns {string}
+ */
+function markdown_style_presets() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.markdown_style_presets();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.markdown_style_presets = markdown_style_presets;
+
+/**
+ * The template that wraps a `.md` file when it is rendered with no template of its own: A4, a margin and the
+ * page number. It reads the Markdown from the data `markdown`, the rest of which is the file's front matter.
+ * @returns {string}
+ */
+function markdown_template() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.markdown_template();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.markdown_template = markdown_template;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lpdfio/lpdf",
-  "version": "0.28.1",
+  "version": "0.30.0",
   "description": "Node.js SDK for Lpdf — PDF as Code on every platform. You describe a document as code or XML. Lpdf renders a compact, pixel-perfect PDF — identical across platforms.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,5 +48,8 @@
     "@types/node": "^20.0.0",
     "esbuild": "^0.25.0",
     "typescript": "^5.0.0"
+  },
+  "allowScripts": {
+    "esbuild": false
   }
 }