@lpdfio/lpdf 0.29.0 → 0.31.0

package/dist/markdown.d.ts

@@ -0,0 +1,76 @@
+import type { MarkdownAttr, MarkdownStylesAttr, MarkdownH1Attr, MarkdownH2Attr, MarkdownH3Attr, MarkdownH4Attr, MarkdownH5Attr, MarkdownH6Attr, MarkdownPAttr, MarkdownCodeAttr, MarkdownQuoteAttr, MarkdownLiAttr, MarkdownAAttr, MarkdownStrongAttr, MarkdownEmAttr, MarkdownDelAttr, MarkdownTableAttr, MarkdownThAttr, MarkdownTdAttr } from './attrs';
+import { type AttrValue } from './_shared';
+/** 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, AttrValue>;
+}
+/** 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, AttrValue>;
+    nodes: LpdfMarkdownRuleNode[];
+}
+/** The Markdown itself, as strings. */
+export interface LpdfMarkdownContentNode {
+    type: 'markdown-content';
+    attrs: Record<string, AttrValue>;
+    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, AttrValue>;
+    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

@@ -12,10 +12,17 @@ export class LpdfEngine {
         wasm.__wbg_lpdfengine_free(ptr, 0);
     }
     /**
-     * Remove any previously configured encryption.
+     * Register the bytes of a file a 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.
+     * @param {string} name
+     * @param {Uint8Array} bytes
      */
-    clear_encryption() {
-        wasm.lpdfengine_clear_encryption(this.__wbg_ptr);
+    load_file(name, bytes) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.lpdfengine_load_file(this.__wbg_ptr, ptr0, len0, ptr1, len1);
     }
     /**
      * Register raw font bytes (TTF/OTF) for a custom font name.
@@ -46,6 +53,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
      */
@@ -84,22 +105,38 @@ export class LpdfEngine {
      * `json_data` is an optional JSON string used to resolve `data-*`
      * attributes in the template.  Pass `None` (or `null` / `undefined` from
      * JavaScript) to render the template with its inline fallback content.
+     *
+     * The rest is for a document that asks for encryption in its `<output>`, which sets the cipher and
+     * the permissions: the passwords, which the template never holds, and `entropy`, at least 32 random
+     * bytes from the host's secure generator for AES-256. A document that asks for encryption needs an
+     * owner password, or `skip_encryption` to render it unencrypted, as a preview does; passwords for a
+     * document that doesn't ask for it are an error, and so are passwords with `skip_encryption`.
      * @param {string} xml
-     * @param {string | null} [json_data]
+     * @param {string | null | undefined} json_data
+     * @param {string | null | undefined} user_password
+     * @param {string | null | undefined} owner_password
+     * @param {boolean} skip_encryption
+     * @param {Uint8Array} entropy
      * @returns {Uint8Array}
      */
-    render_pdf(xml, json_data) {
+    render_pdf(xml, json_data, user_password, owner_password, skip_encryption, entropy) {
         const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         var ptr1 = isLikeNone(json_data) ? 0 : passStringToWasm0(json_data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.lpdfengine_render_pdf(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        var ptr2 = isLikeNone(user_password) ? 0 : passStringToWasm0(user_password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(owner_password) ? 0 : passStringToWasm0(owner_password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray8ToWasm0(entropy, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.lpdfengine_render_pdf(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, skip_encryption, ptr4, len4);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
-        var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        var v6 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v3;
+        return v6;
     }
     /**
      * @param {string} json
@@ -126,23 +163,37 @@ export class LpdfEngine {
      * when an `LpdfDocument` Kit tree is passed to `renderPdf()`, avoiding an
      * intermediate XML serialisation step. PHP, Python, and .NET adapters also
      * use this entry point.
+     *
+     * The passwords, `skip_encryption` and `entropy` are those of `render_pdf`, for a document whose
+     * `output` asks for encryption.
      * @param {string} json
+     * @param {string | null | undefined} user_password
+     * @param {string | null | undefined} owner_password
+     * @param {boolean} skip_encryption
+     * @param {Uint8Array} entropy
      * @returns {Uint8Array}
      */
-    render_tree_pdf(json) {
+    render_tree_pdf(json, user_password, owner_password, skip_encryption, entropy) {
         const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.lpdfengine_render_tree_pdf(this.__wbg_ptr, ptr0, len0);
+        var ptr1 = isLikeNone(user_password) ? 0 : passStringToWasm0(user_password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(owner_password) ? 0 : passStringToWasm0(owner_password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray8ToWasm0(entropy, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.lpdfengine_render_tree_pdf(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, skip_encryption, ptr3, len3);
         if (ret[3]) {
             throw takeFromExternrefTable0(ret[2]);
         }
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        var v5 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v2;
+        return v5;
     }
     /**
-     * Set an optional ISO 8601 creation timestamp (e.g. `"2024-06-01T12:00:00"`).
-     * When provided, written as `/CreationDate` in the PDF info dictionary.
+     * Set an optional ISO 8601 creation timestamp (e.g. `"2024-06-01T12:00:00"`, `"2024-06-01T12:00:00.000Z"` or
+     * `"2024-06-01T12:00:00+01:00"`). When provided, written as `/CreationDate` in the PDF info dictionary, with
+     * the precision and the time zone it was given in; a value that is not a date makes the render an error.
      * Omitting this keeps builds reproducible (no embedded timestamp).
      * @param {string} iso
      */
@@ -151,28 +202,6 @@ export class LpdfEngine {
         const len0 = WASM_VECTOR_LEN;
         wasm.lpdfengine_set_created_on(this.__wbg_ptr, ptr0, len0);
     }
-    /**
-     * Configure RC4-128 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`.
-     *
-     * 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
-     */
-    set_encryption(user_password, owner_password, permissions_json) {
-        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);
-    }
     /**
      * Inject glyph advance-width tables for custom fonts.
      *
@@ -344,6 +373,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,