@quillmark/wasm 0.58.0 → 0.58.2-rc.4

package/node-esm/wasm.js

@@ -2,41 +2,362 @@
 import { readFileSync } from 'node:fs';
 
 
-export class ParsedDocument {
+/**
+ * Typed in-memory Quillmark document.
+ *
+ * Created via `Document.fromMarkdown(markdown)`. Exposes:
+ * - `quillRef` (string)
+ * - `frontmatter` (JS object/Record)
+ * - `body` (string)
+ * - `cards` (array of Card objects)
+ * - `warnings` (array of Diagnostic objects)
+ *
+ * `toMarkdown()` emits canonical Quillmark Markdown that round-trips back to
+ * an equal `Document` by value and by type.
+ */
+export class Document {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Document.prototype);
+        obj.__wbg_ptr = ptr;
+        DocumentFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ParsedDocumentFinalization.unregister(this);
+        DocumentFinalization.unregister(this);
         return ptr;
     }
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_parseddocument_free(ptr, 0);
+        wasm.__wbg_document_free(ptr, 0);
+    }
+    /**
+     * Global Markdown body between frontmatter and the first card.
+     *
+     * Trailing newlines are stripped — those are structural separators in
+     * the Markdown wire format, not content the consumer wrote.
+     *
+     * Empty string when no body is present.
+     * @returns {string}
+     */
+    get body() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_body(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
     }
     /**
-     * Parse markdown into a ParsedDocument.
+     * Ordered list of card blocks as JS objects with `tag`, `fields`, and `body`.
+     * @returns {any}
+     */
+    get cards() {
+        const ret = wasm.document_cards(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Parse markdown into a typed Document.
+     *
+     * Returns the document with any parse-time warnings accessible via `.warnings`.
+     * Throws on parse errors.
      * @param {string} markdown
-     * @returns {ParsedDocument}
+     * @returns {Document}
      */
     static fromMarkdown(markdown) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.parseddocument_fromMarkdown(retptr, ptr0, len0);
+            wasm.document_fromMarkdown(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return takeObject(r0);
+            return Document.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Typed YAML frontmatter fields as a JS object (no QUILL, BODY, or CARDS keys).
+     * @returns {any}
+     */
+    get frontmatter() {
+        const ret = wasm.document_frontmatter(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Insert a card at the given index.
+     *
+     * `index` must be in `0..=cards.length`. Out-of-range throws an `Error`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} index
+     * @param {any} card
+     */
+    insertCard(index, card) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_insertCard(retptr, this.__wbg_ptr, index, addHeapObject(card));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Move the card at `from` to position `to`.
+     *
+     * `from == to` is a no-op. Both indices must be in `0..cards.length`.
+     * Out-of-range throws an `Error`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} from
+     * @param {number} to
+     */
+    moveCard(from, to) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_moveCard(retptr, this.__wbg_ptr, from, to);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Append a card to the end of the card list.
+     *
+     * `card` must be a JS object with a `tag` string field and optional
+     * `fields` (object) and `body` (string).
+     *
+     * Throws an `Error` if `card.tag` is not a valid tag name.
+     *
+     * Mutators never modify `warnings`.
+     * @param {any} card
+     */
+    pushCard(card) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_pushCard(retptr, this.__wbg_ptr, addHeapObject(card));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The QUILL reference string (e.g. `"usaf_memo@0.1"`).
+     * @returns {string}
+     */
+    get quillRef() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_quillRef(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Remove the card at `index` and return it, or `undefined` if out of range.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} index
+     * @returns {any}
+     */
+    removeCard(index) {
+        const ret = wasm.document_removeCard(this.__wbg_ptr, index);
+        return takeObject(ret);
+    }
+    /**
+     * Remove a frontmatter field, returning the removed value or `undefined`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {string} name
+     * @returns {any}
+     */
+    removeField(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.document_removeField(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Replace the global Markdown body.
+     *
+     * Mutators never modify `warnings`.
+     * @param {string} body
+     */
+    replaceBody(body) {
+        const ptr0 = passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.document_replaceBody(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Set a frontmatter field.
+     *
+     * Throws an `Error` whose message includes the `EditError` variant name and
+     * details if `name` is reserved (`BODY`, `CARDS`, `QUILL`, `CARD`) or does
+     * not match `[a-z_][a-z0-9_]*`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {string} name
+     * @param {any} value
+     */
+    setField(name, value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_setField(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(value));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Replace the QUILL reference string.
+     *
+     * Throws if `ref_str` is not a valid `QuillReference`.
+     *
+     * Mutators never modify `warnings`.
+     * @param {string} ref_str
+     */
+    setQuillRef(ref_str) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(ref_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_setQuillRef(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Emit canonical Quillmark Markdown.
+     *
+     * Returns the document serialised as a Quillmark Markdown string.
+     * The output is type-fidelity round-trip safe: re-parsing the result
+     * produces a `Document` equal to `self` by value and by type.
+     * @returns {string}
+     */
+    toMarkdown() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_toMarkdown(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Replace the body of the card at `index`.
+     *
+     * Throws if `index` is out of range.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} index
+     * @param {string} body
+     */
+    updateCardBody(index, body) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_updateCardBody(retptr, this.__wbg_ptr, index, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Update a field on the card at `index`.
+     *
+     * Convenience method: equivalent to `doc.card_mut(index)?.set_field(name, value)`.
+     *
+     * Throws if `index` is out of range, `name` is reserved or invalid, or
+     * `value` cannot be serialized.
+     *
+     * Mutators never modify `warnings`.
+     * @param {number} index
+     * @param {string} name
+     * @param {any} value
+     */
+    updateCardField(index, name, value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_updateCardField(retptr, this.__wbg_ptr, index, ptr0, len0, addHeapObject(value));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Non-fatal parse-time warnings as a JS array of Diagnostic objects.
+     * @returns {any}
+     */
+    get warnings() {
+        const ret = wasm.document_warnings(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
-if (Symbol.dispose) ParsedDocument.prototype[Symbol.dispose] = ParsedDocument.prototype.free;
+if (Symbol.dispose) Document.prototype[Symbol.dispose] = Document.prototype.free;
 
 /**
  * Opaque, shareable Quill handle.
@@ -59,15 +380,37 @@ export class Quill {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_quill_free(ptr, 0);
     }
+    /**
+     * The resolved backend identifier (e.g. `"typst"`).
+     * @returns {string}
+     */
+    get backendId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quill_backendId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Open an iterative render session for page-selective rendering.
-     * @param {ParsedDocument} parsed
+     * @param {Document} doc
      * @returns {RenderSession}
      */
-    open(parsed) {
+    open(doc) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_open(retptr, this.__wbg_ptr, addHeapObject(parsed));
+            _assertClass(doc, Document);
+            var ptr0 = doc.__destroy_into_raw();
+            wasm.quill_open(retptr, this.__wbg_ptr, ptr0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -79,16 +422,56 @@ export class Quill {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Project a document through this quill's schema.
+     *
+     * Returns a plain JS object (not a class) that is immediately
+     * `JSON.stringify`-able. The shape mirrors [`FormProjection`]:
+     *
+     * ```json
+     * {
+     *   "main":  { "schema": {...}, "values": { "field": {...} } },
+     *   "cards": [ ... ],
+     *   "diagnostics": [ ... ]
+     * }
+     * ```
+     *
+     * **Snapshot semantics.** This is a read-only snapshot of the document
+     * at call time. Subsequent edits to `doc` require calling `projectForm`
+     * again.
+     *
+     * [`FormProjection`]: quillmark::form::FormProjection
+     * @param {Document} doc
+     * @returns {any}
+     */
+    projectForm(doc) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(doc, Document);
+            wasm.quill_projectForm(retptr, this.__wbg_ptr, doc.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Render a document to final artifacts.
-     * @param {ParsedDocument} parsed
-     * @param {RenderOptions} opts
+     * @param {Document} doc
+     * @param {RenderOptions | null} [opts]
      * @returns {RenderResult}
      */
-    render(parsed, opts) {
+    render(doc, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_render(retptr, this.__wbg_ptr, addHeapObject(parsed), addHeapObject(opts));
+            _assertClass(doc, Document);
+            var ptr0 = doc.__destroy_into_raw();
+            wasm.quill_render(retptr, this.__wbg_ptr, ptr0, isLikeNone(opts) ? 0 : addHeapObject(opts));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -179,13 +562,13 @@ export class RenderSession {
     }
     /**
      * Render all or selected pages from this session.
-     * @param {RenderOptions} opts
+     * @param {RenderOptions | null} [opts]
      * @returns {RenderResult}
      */
     render(opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rendersession_render(retptr, this.__wbg_ptr, addHeapObject(opts));
+            wasm.rendersession_render(retptr, this.__wbg_ptr, isLikeNone(opts) ? 0 : addHeapObject(opts));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -213,6 +596,17 @@ function __wbg_get_imports() {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         },
+        __wbg_Number_32bf70a599af1d4b: function(arg0) {
+            const ret = Number(getObject(arg0));
+            return ret;
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg_String_b51de6b05a10845b: function(arg0, arg1) {
             const ret = String(getObject(arg1));
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -350,6 +744,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0)[arg1 >>> 0];
             return addHeapObject(ret);
         },
+        __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
+            const ret = getObject(arg0)[getObject(arg1)];
+            return addHeapObject(ret);
+        },
         __wbg_get_with_ref_key_f64427178466f623: function(arg0, arg1) {
             const ret = getObject(arg0)[getObject(arg1)];
             return addHeapObject(ret);
@@ -420,6 +818,10 @@ function __wbg_get_imports() {
             const ret = new Map();
             return addHeapObject(ret);
         },
+        __wbg_new_5e360d2ff7b9e1c3: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
         __wbg_new_682678e2f47e32bc: function() {
             const ret = new Array();
             return addHeapObject(ret);
@@ -447,6 +849,10 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_a6b02eb00b0f4ce2: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_set_022bee52d0b05b19: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
         __wbg_set_3bf1de9fab0cd644: function(arg0, arg1, arg2) {
             getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
         },
@@ -505,9 +911,9 @@ function __wbg_get_imports() {
     };
 }
 
-const ParsedDocumentFinalization = (typeof FinalizationRegistry === 'undefined')
+const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_parseddocument_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr >>> 0, 1));
 const QuillFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_quill_free(ptr >>> 0, 1));
@@ -527,6 +933,12 @@ function addHeapObject(obj) {
     return idx;
 }
 
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;

package/node-esm/wasm_bg.wasm.d.ts

@@ -1,30 +1,49 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const __wbg_quillmark_free: (a: number, b: number) => void;
+export const __wbg_document_free: (a: number, b: number) => void;
 export const __wbg_quill_free: (a: number, b: number) => void;
+export const __wbg_quillmark_free: (a: number, b: number) => void;
 export const __wbg_rendersession_free: (a: number, b: number) => void;
+export const document_body: (a: number, b: number) => void;
+export const document_cards: (a: number) => number;
+export const document_fromMarkdown: (a: number, b: number, c: number) => void;
+export const document_frontmatter: (a: number) => number;
+export const document_insertCard: (a: number, b: number, c: number, d: number) => void;
+export const document_moveCard: (a: number, b: number, c: number, d: number) => void;
+export const document_pushCard: (a: number, b: number, c: number) => void;
+export const document_quillRef: (a: number, b: number) => void;
+export const document_removeCard: (a: number, b: number) => number;
+export const document_removeField: (a: number, b: number, c: number) => number;
+export const document_replaceBody: (a: number, b: number, c: number) => void;
+export const document_setField: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
+export const document_toMarkdown: (a: number, b: number) => void;
+export const document_updateCardBody: (a: number, b: number, c: number, d: number, e: number) => void;
+export const document_updateCardField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const document_warnings: (a: number) => number;
+export const init: () => void;
+export const quill_backendId: (a: number, b: number) => void;
+export const quill_open: (a: number, b: number, c: number) => void;
+export const quill_projectForm: (a: number, b: number, c: number) => void;
+export const quill_render: (a: number, b: number, c: number, d: number) => void;
 export const quillmark_new: () => number;
 export const quillmark_quill: (a: number, b: number, c: number) => void;
-export const quill_render: (a: number, b: number, c: number, d: number) => void;
-export const quill_open: (a: number, b: number, c: number) => void;
-export const parseddocument_fromMarkdown: (a: number, b: number, c: number) => void;
 export const rendersession_pageCount: (a: number) => number;
 export const rendersession_render: (a: number, b: number, c: number) => void;
-export const init: () => void;
-export const qcms_profile_is_bogus: (a: number) => number;
-export const qcms_white_point_sRGB: (a: number) => void;
+export const lut_inverse_interp16: (a: number, b: number, c: number) => number;
 export const qcms_profile_precache_output_transform: (a: number) => void;
-export const qcms_transform_data_rgb_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
-export const qcms_transform_data_rgba_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
-export const qcms_transform_data_bgra_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
+export const qcms_white_point_sRGB: (a: number) => void;
 export const qcms_transform_data_rgb_out_lut: (a: number, b: number, c: number, d: number) => void;
 export const qcms_transform_data_rgba_out_lut: (a: number, b: number, c: number, d: number) => void;
 export const qcms_transform_data_bgra_out_lut: (a: number, b: number, c: number, d: number) => void;
-export const qcms_transform_release: (a: number) => void;
-export const qcms_enable_iccv4: () => void;
+export const qcms_transform_data_rgb_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
+export const qcms_transform_data_rgba_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
+export const qcms_transform_data_bgra_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
 export const lut_interp_linear16: (a: number, b: number, c: number) => number;
-export const lut_inverse_interp16: (a: number, b: number, c: number) => number;
+export const qcms_enable_iccv4: () => void;
+export const qcms_profile_is_bogus: (a: number) => number;
+export const qcms_transform_release: (a: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.58.0",
+  "version": "0.58.2-rc.4",
   "description": "WebAssembly bindings for quillmark",
   "type": "module",
   "license": "MIT OR Apache-2.0",