@quillmark/wasm 0.100.0 → 0.102.0

package/backends/typst/wasm_bg.js

@@ -1,2882 +0,0 @@
-/**
- * Typed in-memory Quillmark document.
- */
-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;
-        DocumentFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_document_free(ptr, 0);
-    }
-    /**
-     * Build a composable card of `kind`, typed-commit `fields` onto it, set its
-     * body from optional markdown, and place it: the ABI under `writer.addCard`.
-     * `at` picks the position: absent appends, a number inserts at that index
-     * (`0..=cards.length`), so a positioned typed insert is one atomic call
-     * rather than `addCard` + `moveCard`. Fuses `makeCard` + typed commit +
-     * insertion transactionally: the card is committed in full before it joins
-     * the document, so a rejected field (or an invalid kind, body, or
-     * out-of-range `at`) leaves the document untouched. Field errors throw the
-     * same per-field diagnostic bundle as [`commitFields`](Self::commit_fields),
-     * including an `edit::unknown_field` per undeclared name; an invalid
-     * kind or body, or an out-of-range position, throws a single-entry bundle
-     * keyed `$kind` / `$body`.
-     * @param {Quill} quill
-     * @param {string} kind
-     * @param {Record<string, unknown>} [fields]
-     * @param {string} [body]
-     * @param {number} [at]
-     */
-    _addCard(quill, kind, fields, body, at) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            var ptr1 = isLikeNone(body) ? 0 : passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            var len1 = WASM_VECTOR_LEN;
-            wasm.document__addCard(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0, isLikeNone(fields) ? 0 : addHeapObject(fields), ptr1, len1, isLikeNone(at) ? 0x100000001 : (at) >>> 0);
-            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);
-        }
-    }
-    /**
-     * Typed field write at `addr`, resolving the field's schema `type` from
-     * `quill`: the stable ABI under the runtime `writer.set` / `writer.card(i).set`.
-     * The one write verb for **every** field type (richtext, scalar, array,
-     * object); the schema carries the `inline` constraint, so no type token or
-     * flag is passed. A richtext-typed field stores the canonical content, so
-     * identity marks (anchors, island ids) and content-only marks (e.g.
-     * `underline`) live on it and survive compiles and the storage DTO. Values
-     * use the encoding the seam already speaks: a content object or markdown
-     * string for richtext, a scalar/array/object otherwise.
-     *
-     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
-     * targets a composable card (its `$kind` resolves the schema). A body
-     * address throws: a body has no field schema; write it with `writer.setBody`
-     * / `revise`. A field declared in the schema is strict-committed (a mismatch
-     * throws now, not at render); a name the schema does not declare throws
-     * `edit::unknown_field` rather than falling to the opaque store: on
-     * the typed path it is a typo. Use [`storeField`](Document::store_field) for
-     * opaque storage. Also throws `edit::field_conform` /
-     * `edit::field_richtext_decode` / `edit::field_richtext_not_inline`
-     * on a typed mismatch, `edit::invalid_field_name` on a malformed name,
-     * and `edit::index_out_of_range` on an out-of-range card.
-     *
-     * The `quill` handle is passed per call because a `Document` carries only a
-     * `$quill` reference, not the resolved schema.
-     * @param {Quill} quill
-     * @param {Addr | string} addr
-     * @param {any} value
-     */
-    _commitField(quill, addr, value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            wasm.document__commitField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), 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);
-        }
-    }
-    /**
-     * Batched twin of [`commitField`](Document::commit_field): typed-commit
-     * several fields on the card `addr` targets atomically, resolving each
-     * field's schema `type` from `quill`. `addr` is a **card address**
-     * (`{ card }`, absent = main; a present `field` throws). All-or-nothing with
-     * the same per-field-diagnostic error contract as
-     * [`storeFields`](Document::store_fields): nothing is applied on error and
-     * the thrown error's `diagnostics` carry one entry per offending field,
-     * including an `edit::unknown_field` for any name the schema does not
-     * declare, so a whole-form submit sees every typo in one pass. Throws on an
-     * out-of-range card.
-     * @param {Quill} quill
-     * @param {CardAddr} addr
-     * @param {Record<string, unknown>} fields
-     */
-    _commitFields(quill, addr, fields) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            wasm.document__commitFields(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), addHeapObject(fields));
-            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);
-        }
-    }
-    /**
-     * Interpreted read at `addr`, resolving the field's declared `type` from
-     * `quill`: the stable ABI under the runtime `reader.get` / `reader.card(i).get`.
-     * The schema-plane twin of the quill-free [`getStored`](Self::get_stored): a `richtext`
-     * field returns its markdown projection, every other declared type its
-     * canonical value verbatim, so a consumer holding the quill reads by field
-     * meaning rather than by wire shape.
-     *
-     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
-     * targets a composable card (its `$kind` resolves the schema). Returns
-     * `undefined` for an **absent** field. An absent `addr.field` reads the body
-     * markdown: quill-free, mirroring [`getMarkdown`](Self::get_markdown), since
-     * a body's type is a format fact, not a schema fact. A name the schema does
-     * not declare throws `edit::unknown_field` (the authority `getMarkdown`
-     * lacks: there an unknown name reads back `undefined`); a `richtext` field
-     * holding a value that does not decode throws `edit::field_richtext_decode`;
-     * an out-of-range `addr.card` throws.
-     *
-     * The `quill` handle is passed per call because a `Document` carries only a
-     * `$quill` reference, not the resolved schema.
-     * @param {Quill} quill
-     * @param {Addr | string} addr
-     * @returns {unknown}
-     */
-    _readerGet(quill, addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            wasm.document__readerGet(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr));
-            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);
-        }
-    }
-    /**
-     * Interpreted **corpus** read at `addr`: the stable ABI under the runtime
-     * `reader.getContent` / `reader.card(i).getContent`. The corpus twin of
-     * [`reader.get`](Self::reader_get), which projects; this decodes the stored
-     * value through the codec the field's declared type names (`richtext` as
-     * markdown, `plaintext` as literal text) and returns the canonical `Content`.
-     *
-     * Total over the storage form: a committed field holds a content object and
-     * a parsed one holds the authored string, and both read back as a corpus
-     * here, so a consumer mounting a corpus editor stops branching on how the
-     * document was built.
-     *
-     * A bare string is `Addr` shorthand for `{ field }`; `{ card, field }`
-     * targets a composable card. Returns `undefined` for an **absent** field. An
-     * absent `addr.field` reads the **body** corpus, quill-free, mirroring
-     * [`getStored`](Self::get_stored). Throws `edit::unknown_field` for a name
-     * the schema does not declare, `edit::field_not_content` for a declared type
-     * that is not a content leaf (`array<richtext>` carries content and still has
-     * no one corpus), `edit::field_richtext_decode` for a stored value
-     * that decodes under neither encoding, and `edit::index_out_of_range` for a
-     * bad `addr.card`.
-     * @param {Quill} quill
-     * @param {Addr | string} addr
-     * @returns {Content | undefined}
-     */
-    _readerGetContent(quill, addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            wasm.document__readerGetContent(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr));
-            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);
-        }
-    }
-    /**
-     * Revise the content field at `addr` from authored text, typed *and*
-     * anchor-preserving: the ABI under `writer.reviseField`. Resolves the
-     * field's schema from `quill` (main card, or the addressed card's `$kind`)
-     * and defers to [`TypedWriter::revise_field`](quillmark_core::TypedWriter::revise_field):
-     * surviving anchors rebase (as [`revise`](Self::revise)), then the diffed
-     * result is schema-conformed, so a `richtext(inline)` field rejects a
-     * multi-block result with `edit::field_richtext_not_inline`. Returns the
-     * text `Delta`.
-     *
-     * The codec is the declared type's: `richtext` diffs markdown, `plaintext`
-     * the literal text.
-     *
-     * `addr` must name a field (a bare string is `{ field }`); a body address
-     * throws (a body carries no field schema: use [`revise`](Self::revise)). A
-     * name the schema does not declare throws `edit::unknown_field`. Throws
-     * on an out-of-range card. Hidden from the `.d.ts`; the visible verb is
-     * `writer.reviseField` in the runtime layer.
-     * @param {Quill} quill
-     * @param {Addr | string} addr
-     * @param {string} text
-     * @returns {Delta}
-     */
-    _reviseField(quill, addr, text) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document__reviseField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), 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);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * **Apply** a committed content edit `bundle` (`{ delta?, lineOps?, markOps? }`)
-     * at `addr`, the editor splice: text delta first, then line ops, then mark
-     * ops (mark ranges in final-text coordinates), each all-or-nothing. An absent
-     * `addr.field` targets the body, an absent `addr.card` the main card.
-     *
-     * Throws on an out-of-range card, a field that is not richtext, a malformed
-     * bundle, or an op that applies out of bounds (the value is unchanged on a
-     * failed apply).
-     * @param {Addr | string} addr
-     * @param {ChangeBundle} bundle
-     */
-    applyChange(addr, bundle) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_applyChange(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(bundle));
-            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);
-        }
-    }
-    /**
-     * Authoring-ergonomics header introducing a blueprint to an LLM/MCP
-     * consumer for the given `quillName`. Re-exposes core's canonical text for
-     * JS consumers; any surface that draws from the same core source stays
-     * uniform.
-     * @param {string} quill_name
-     * @returns {string}
-     */
-    static blueprintInstruction(quill_name) {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(quill_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_blueprintInstruction(retptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
-        }
-    }
-    /**
-     * A single composable card by index: the whole `Card`, the card-indexed
-     * twin of the [`main`](Self::main) getter, so reading one card need not
-     * materialize every card via [`cards`](Self::cards). An out-of-range
-     * `index` throws `edit::index_out_of_range`, matching the card write
-     * verbs.
-     * @param {number} index
-     * @returns {Card}
-     */
-    card(index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_card(retptr, this.__wbg_ptr, index);
-            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);
-        }
-    }
-    /**
-     * Number of composable cards (excludes the main card). O(1).
-     * @returns {number}
-     */
-    get cardCount() {
-        const ret = wasm.document_cardCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {Card[]}
-     */
-    get cards() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_cards(retptr, this.__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);
-        }
-    }
-    /**
-     * @returns {Document}
-     */
-    clone() {
-        const ret = wasm.document_clone(this.__wbg_ptr);
-        return Document.__wrap(ret);
-    }
-    /**
-     * Schema version this build writes via [`toJson`](Document::to_json).
-     * Tracks the `Document` model version (not the running crate version):
-     * the tag advances only when the wire format changes, not on every release.
-     * @returns {string}
-     */
-    static currentSchemaVersion() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_currentSchemaVersion(retptr);
-            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);
-        }
-    }
-    /**
-     * Structural equality (parse-time `warnings` excluded). Use to debounce
-     * upstream prop updates instead of re-parsing on every keystroke.
-     * @param {Document} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        _assertClass(other, Document);
-        const ret = wasm.document_equals(this.__wbg_ptr, other.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Render a Diagnostic as the canonical pretty-printed text (core's
-     * `Diagnostic::fmt_pretty`). Single source of truth so a Diagnostic looks
-     * identical no matter which consumer surfaces it.
-     * @param {Diagnostic} diag
-     * @returns {string}
-     */
-    static formatDiagnostic(diag) {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_formatDiagnostic(retptr, addHeapObject(diag));
-            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);
-        }
-    }
-    /**
-     * Authoring-format rules for the card-yaml markdown surface. The canonical
-     * text is core's (`quillmark_core::document::FORMAT_RULES`), re-exposed
-     * here for JS consumers so it matches any other surface that draws from the
-     * same source. Read once at startup and cache; the value never changes
-     * between calls.
-     * @returns {string}
-     */
-    static formatRules() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_formatRules(retptr);
-            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);
-        }
-    }
-    /**
-     * Reconstruct a `Document` from a versioned storage DTO string produced
-     * by [`toJson`](Document::to_json). Unknown `schema` tags are rejected.
-     * The result carries no parse-time warnings (`.warnings` is always empty).
-     *
-     * Throws if `json` is not a valid storage DTO (malformed JSON, unknown
-     * `schema`, missing fields, or unparseable quill reference).
-     * @param {string} json
-     * @returns {Document}
-     */
-    static fromJson(json) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_fromJson(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 Document.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Parse markdown into a typed Document. Throws on parse errors.
-     * @param {string} markdown
-     * @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.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 Document.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * The whole `$ext` map at `addr` (a card address, absent `card` = main), or
-     * `undefined` when the card carries none. The fine-grained `$ext` read:
-     * your own state without serializing the whole card. Throws on a present
-     * `field` (a card address takes only `card`) or an out-of-range card.
-     * @param {CardAddr} [addr]
-     * @returns {Record<string, unknown> | undefined}
-     */
-    getExt(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_getExt(retptr, this.__wbg_ptr, addHeapObject(addr));
-            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);
-        }
-    }
-    /**
-     * The value stored under `$ext[ns]` at `addr` (a card address, absent `card`
-     * = main), or `undefined`. The namespace-scoped `$ext` read: your own slot
-     * without a whole-card serialize, and non-destructive (unlike
-     * `removeExtNamespace`). Throws on a present `field` or an out-of-range card.
-     * @param {CardAddr} addr
-     * @param {string} ns
-     * @returns {unknown}
-     */
-    getExtNamespace(addr, ns) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(ns, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_getExtNamespace(retptr, this.__wbg_ptr, addHeapObject(addr), 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);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * The **body** markdown projection (the main body, or a composable card's
-     * body (`{ card }`)) the on-demand, lossy export (content-only marks do not
-     * survive markdown). A body's type is a format fact, not a schema fact, so
-     * this read stays quill-free; a body is never absent.
-     *
-     * `addr` is an optional **card address** (`{ card }`, absent = main). A
-     * present `field` throws: a field's markdown is read through the
-     * schema-plane `quill.reader(doc).get(field)`, which interprets by declared
-     * type. An out-of-range `addr.card` throws.
-     * @param {CardAddr} [addr]
-     * @returns {string}
-     */
-    getMarkdown(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_getMarkdown(retptr, this.__wbg_ptr, addHeapObject(addr));
-            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);
-        }
-    }
-    /**
-     * Read the **verbatim stored value** at `addr`: the raw payload value of a
-     * field, or the **body content** when `addr.field` is absent. A bare
-     * string is `Addr` shorthand for `{ field }`. Reads are total over the field
-     * axis: an absent field is `undefined`; only an out-of-range `addr.card`
-     * throws `edit::index_out_of_range`. Needs no schema, so it lives on
-     * `Document`: the read echo of the verbatim `store*` write, distinct from
-     * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
-     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
-     * `reader.get` (a field's declared type).
-     *
-     * **A content field at rest has one stored form per codec**: a `richtext`
-     * field holds the canonical content object, a `plaintext` field its literal
-     * string. A document that came through the bound door (`quill.parse` /
-     * `quill.conform`) is at rest, so this read no longer depends on which lane
-     * built it. A document that came through the transport door
-     * (`Document.fromMarkdown`, a legacy stored row) may rest as authored until
-     * it is conformed, and this read reports what is there. For the corpus
-     * either way, use the schema-plane `reader.getContent`, which decodes
-     * through the codec the field's declared type names.
-     * @param {Addr | string} addr
-     * @returns {unknown}
-     */
-    getStored(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_getStored(retptr, this.__wbg_ptr, addHeapObject(addr));
-            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);
-        }
-    }
-    /**
-     * Insert a card, the single insertion verb: `at` absent appends, a number
-     * inserts at that index (must be in `0..=cards.length`). Accepts a
-     * `CardInput`: a card read back (`cards` / `removeCard` / `quill.seedCard`),
-     * a [`makeCard`](Document::make_card) result, or a bare `{ kind, body }`
-     * (every returned `Card` is a valid `CardInput`). Throws if `card.kind` is
-     * not a valid kind name, or if `at` is out of range.
-     * @param {CardInput} card
-     * @param {number} [at]
-     */
-    insertCard(card, at) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_insertCard(retptr, this.__wbg_ptr, addHeapObject(card), isLikeNone(at) ? 0x100000001 : (at) >>> 0);
-            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);
-        }
-    }
-    /**
-     * **Install** a richtext value at `addr`: **value semantics**, content only.
-     * Stores exactly `rt` (a canonical `Content` content object); the identity
-     * anchors of any previous value are gone. An absent `addr.field` targets the
-     * body, an absent `addr.card` the main card. For "here's new markdown," use
-     * [`revise`](Document::revise); the cold-import path is spelled at the call
-     * site as `install(addr, importMarkdown(md))`, so anchor loss is visible in
-     * source.
-     *
-     * Throws on an out-of-range card, a malformed field name, or an `rt` that is
-     * not a canonical content object.
-     * @param {Addr | string} addr
-     * @param {Content} rt
-     */
-    install(addr, rt) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_install(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(rt));
-            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);
-        }
-    }
-    /**
-     * Whether the field at `addr` is marked `!must_fill`. A bare string is `Addr`
-     * shorthand for `{ field }`. `false` for an absent field (truthful: it isn't
-     * marked) and for a body address (a body is never a fill). Only an
-     * out-of-range `addr.card` throws.
-     * @param {Addr | string} addr
-     * @returns {boolean}
-     */
-    isFill(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_isFill(retptr, this.__wbg_ptr, addHeapObject(addr));
-            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 r0 !== 0;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Replace this document's contents **in place** from a versioned storage
-     * DTO string: the mutating twin of the static
-     * [`fromJson`](Document::from_json) constructor. Parse-time `warnings` are
-     * cleared. Throws (leaving the document unchanged) on an invalid DTO.
-     *
-     * The cross-WASM-memory `Document` bridge: mutate a document on a
-     * backend-memory clone, then write the mutated state back into the caller's
-     * canonical document with this, the one way to update a live handle across
-     * the linear-memory seam without the caller re-binding its variable.
-     * @param {string} json
-     */
-    loadJson(json) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_loadJson(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);
-        }
-    }
-    /**
-     * The document's main (entry) card. Allocates and serializes on each
-     * call: cache locally if read in a hot loop.
-     * @returns {Card}
-     */
-    get main() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_main(retptr, this.__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);
-        }
-    }
-    /**
-     * Build a fresh `Card` from a kind and a flat field map: the ergonomic
-     * constructor for `insertCard`. `fields` is an optional
-     * `Record<string, unknown>` (each entry becomes a card field, in
-     * insertion order); `body` defaults to `""`.
-     *
-     * Sugar, not a required step: `insertCard` takes any `Card` object, and
-     * `removeCard` returns one, so a card round-trips without passing through
-     * here.
-     *
-     * Checks only what a detached card can decide alone: field-name grammar
-     * and value depth. Kind validity is positional (`main` is right for the
-     * root, reserved for a composable card) so `insertCard` is its gate, and
-     * any kind string is accepted here.
-     * @param {string} kind
-     * @param {Record<string, unknown>} [fields]
-     * @param {string} [body]
-     * @returns {Card}
-     */
-    static makeCard(kind, fields, body) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            var ptr1 = isLikeNone(body) ? 0 : passStringToWasm0(body, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            var len1 = WASM_VECTOR_LEN;
-            wasm.document_makeCard(retptr, ptr0, len0, isLikeNone(fields) ? 0 : addHeapObject(fields), ptr1, len1);
-            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);
-        }
-    }
-    /**
-     * Move the card at `from` to position `to`. `from == to` is a no-op.
-     * @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);
-        }
-    }
-    /**
-     * `new Document(quillRef)`, a blank document: a main card carrying only
-     * `$quill`, an empty body, and no composable cards. The programmatic
-     * blank canvas: absent fields resolve at render time (`default`, else
-     * type-empty zero), so nothing the caller did not set reaches the
-     * output. For an example-filled starter use `Quill.seedDocument()`.
-     * Throws on an invalid quill reference. Mirrors Python `Document(quill_ref)`.
-     * @param {string} quill_ref
-     */
-    constructor(quill_ref) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(quill_ref, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_new(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);
-            }
-            this.__wbg_ptr = r0 >>> 0;
-            DocumentFinalization.register(this, this.__wbg_ptr, this);
-            return this;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * @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);
-        }
-    }
-    /**
-     * The canonical `$quill` reference grammar as author-facing text. Core is
-     * the single source of truth: drive schema `describe` and validation
-     * messages from this instead of re-stating the rule; it matches the
-     * `hint` on `parse::invalid_quill_reference`. Cache it; the value never
-     * changes.
-     * @returns {string}
-     */
-    static quillRefHint() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_quillRefHint(retptr);
-            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);
-        }
-    }
-    /**
-     * @param {number} index
-     * @returns {Card | undefined}
-     */
-    removeCard(index) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_removeCard(retptr, this.__wbg_ptr, index);
-            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);
-        }
-    }
-    /**
-     * Remove the `$ext` map on the card `addr` targets *entirely*, returning the
-     * previous map or `undefined`: a blunt escape hatch that discards every
-     * namespace at once (prefer `removeExtNamespace`). `addr` is a card address
-     * (absent = main). Throws on a present `field` or an out-of-range card.
-     * @param {CardAddr} [addr]
-     * @returns {Record<string, unknown> | undefined}
-     */
-    removeExt(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_removeExt(retptr, this.__wbg_ptr, addHeapObject(addr));
-            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);
-        }
-    }
-    /**
-     * Remove `$ext[ns]` on the card `addr` targets, returning its value or
-     * `undefined`; drops `$ext` once empty. `addr` is a card address (absent =
-     * main). Preserves sibling namespaces. Throws on a present `field` or an
-     * out-of-range card.
-     * @param {CardAddr} addr
-     * @param {string} ns
-     * @returns {any}
-     */
-    removeExtNamespace(addr, ns) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(ns, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_removeExtNamespace(retptr, this.__wbg_ptr, addHeapObject(addr), 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);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Remove a field at `addr`, returning the removed value or `undefined`. A
-     * bare string is `Addr` shorthand for `{ field }`. One `remove` verb serves
-     * every write lane. A body address throws; throws on an out-of-range card or
-     * a malformed name.
-     * @param {Addr | string} addr
-     * @returns {any}
-     */
-    removeField(addr) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_removeField(retptr, this.__wbg_ptr, addHeapObject(addr));
-            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);
-        }
-    }
-    /**
-     * Remove `cardKind` from the main card's `$seed` map, returning its
-     * overlay or `undefined`; drops `$seed` entirely once empty. Sibling kinds
-     * survive. `$seed` is main-only, so this takes no address.
-     * @param {string} card_kind
-     * @returns {any}
-     */
-    removeSeedNamespace(card_kind) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(card_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_removeSeedNamespace(retptr, this.__wbg_ptr, 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);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * **Revise** the richtext value at `addr` from a markdown string: **edit
-     * semantics**, the default write path, returning the text `Delta`. Imports
-     * the markdown, diffs it against the current value, rebases surviving
-     * identity anchors, and returns the change an editor bridge maps its own
-     * positions through (`mapPos`). An absent `addr.field` targets the body, an
-     * absent `addr.card` the main card; an absent field cold-imports from empty.
-     *
-     * Throws on an out-of-range card, a malformed field name, a present
-     * non-content field value, or an over-nested markdown input.
-     * @param {Addr | string} addr
-     * @param {string} markdown
-     * @returns {Delta}
-     */
-    revise(addr, 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.document_revise(retptr, this.__wbg_ptr, addHeapObject(addr), 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);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Read the `schema` version tag from a raw storage DTO string without a
-     * full parse, or `undefined`. Returns unknown future versions as-is:
-     * useful to distinguish "build too old" from "payload corrupt" when
-     * `fromJson` throws.
-     * @param {string} json
-     * @returns {string | undefined}
-     */
-    static schemaVersionOf(json) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_schemaVersionOf(retptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            let v2;
-            if (r0 !== 0) {
-                v2 = getStringFromWasm0(r0, r1).slice();
-                wasm.__wbindgen_export4(r0, r1 * 1, 1);
-            }
-            return v2;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * The main card's `$seed` overlay object for `kind` (the `$seed[kind]`
-     * entry), or `undefined` when absent. The cheap read that feeds
-     * `quill.seedCard(kind, overlay)` without serializing the whole main card
-     * via [`main`](Self::main) to fish out one key, and it keeps `seedCard`
-     * pure: the quill still never reads the document.
-     * @param {string} kind
-     * @returns {Record<string, unknown> | undefined}
-     */
-    seedOverlay(kind) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_seedOverlay(retptr, this.__wbg_ptr, 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);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Replace the kind of the card at `index`. Payload and body are untouched;
-     * schema-aware migration is the caller's responsibility.
-     * Throws if `index` is out of range or `newKind` is invalid.
-     * @param {number} index
-     * @param {string} new_kind
-     */
-    setCardKind(index, new_kind) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(new_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_setCardKind(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);
-        }
-    }
-    /**
-     * Replace the QUILL reference string. Throws if `ref_str` is invalid.
-     * @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);
-        }
-    }
-    /**
-     * Replace the opaque `$ext` map on the card `addr` targets (a card address,
-     * absent `card` = main). `value` must be a plain object. `$ext` carries
-     * out-of-band consumer state and never reaches the rendered output; pass
-     * `{}` for an explicit empty `$ext`. Quill-free and verbatim: an opaque
-     * `store` verb. Throws on a present `field` or an out-of-range card.
-     * @param {CardAddr} addr
-     * @param {any} value
-     */
-    storeExt(addr, value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_storeExt(retptr, this.__wbg_ptr, addHeapObject(addr), 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);
-        }
-    }
-    /**
-     * Merge `value` into `$ext[ns]` on the card `addr` targets, preserving
-     * sibling namespaces: the recommended `$ext` write. `addr` is a card
-     * address (absent = main). Quill-free and verbatim: an opaque `store` verb.
-     * Throws on a present `field` or an out-of-range card.
-     * @param {CardAddr} addr
-     * @param {string} ns
-     * @param {any} value
-     */
-    storeExtNamespace(addr, ns, value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(ns, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_storeExtNamespace(retptr, this.__wbg_ptr, addHeapObject(addr), 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);
-        }
-    }
-    /**
-     * Store a field verbatim at `addr`: the opaque store (**store** = verbatim,
-     * coercion deferred to render; the typed write is
-     * [`commitField`](Document::commit_field)). A bare string is `Addr`
-     * shorthand for `{ field }`, so `doc.storeField("qty", 3)` reads as written;
-     * `{ card: 2, field: "qty" }` targets a composable card. Clears any
-     * `!must_fill` marker. A body address (no `field`) throws: a body is never
-     * opaque; write it with `revise` / `install` / `writer.setBody`. Throws on
-     * an out-of-range card or a malformed name.
-     * @param {Addr | string} addr
-     * @param {any} value
-     */
-    storeField(addr, value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_storeField(retptr, this.__wbg_ptr, addHeapObject(addr), 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);
-        }
-    }
-    /**
-     * Store several fields verbatim and atomically on the card `addr` targets:
-     * the opaque store's batch. `addr` is a **card address** (`{ card }`, absent
-     * = main); a present `field` throws. The batch verb takes the address first
-     * and is never shape-overloaded, because `card` is a legal field name:
-     * `storeFields({}, fields)` is the main card, `storeFields({ card: 2 },
-     * fields)` a composable one, never ambiguous with "set field `card`".
-     * Nothing is applied on error; the thrown error's `diagnostics` carry one
-     * entry per offending field. Throws on an out-of-range card.
-     * @param {CardAddr} addr
-     * @param {Record<string, unknown>} fields
-     */
-    storeFields(addr, fields) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_storeFields(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(fields));
-            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);
-        }
-    }
-    /**
-     * Store a field verbatim at `addr` and mark it `!must_fill`: the opaque
-     * store's fill variant, card-capable (a bare string or `{ field }` for main,
-     * `{ card, field }` for a composable card). A body address throws. Same
-     * validation as [`storeField`](Document::store_field).
-     * @param {Addr | string} addr
-     * @param {any} value
-     */
-    storeFill(addr, value) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_storeFill(retptr, this.__wbg_ptr, addHeapObject(addr), 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);
-        }
-    }
-    /**
-     * Merge a card-kind's seed `overlay` into the **main** card's `$seed` map
-     * under `cardKind`, preserving sibling kinds: `$seed` lives on the main
-     * card by model, so this takes no address. Sets the starting values new
-     * cards of that kind spawn with. Quill-free and verbatim: an opaque `store`
-     * verb. Throws if `overlay` cannot be serialized or nests too deep.
-     * @param {string} card_kind
-     * @param {any} overlay
-     */
-    storeSeedNamespace(card_kind, overlay) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(card_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.document_storeSeedNamespace(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(overlay));
-            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);
-        }
-    }
-    /**
-     * Serialize this document to a versioned storage DTO string.
-     *
-     * Prefer this over `toMarkdown` for persistence across restarts or crate
-     * upgrades: the wire format is frozen per `schema` version. Parse-time
-     * `warnings` are excluded from the DTO.
-     *
-     * Output is **byte-deterministic** within a `schema` version: equal
-     * documents produce byte-equal output, safe for content-hash use cases.
-     * @returns {string}
-     */
-    toJson() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_toJson(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);
-        }
-    }
-    /**
-     * Emit canonical Quillmark Markdown. 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);
-        }
-    }
-    /**
-     * Like [`fromJson`](Document::from_json) but returns `undefined` instead
-     * of throwing when `json` is not a valid storage DTO: use to
-     * discriminate format without exceptions as control flow.
-     * `undefined` means "not a storage DTO"; `fromMarkdown` still throws on
-     * genuinely malformed markdown.
-     * @param {string} json
-     * @returns {Document | undefined}
-     */
-    static tryFromJson(json) {
-        const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.document_tryFromJson(ptr0, len0);
-        return ret === 0 ? undefined : Document.__wrap(ret);
-    }
-    /**
-     * The non-fatal diagnostics of the load that produced this document: parse
-     * warnings, plus the `conform::*` warnings when it came through
-     * `quill.parse`. Session state, not document value: `equals` and the
-     * storage DTO exclude it, and `fromJson` / `loadJson` clear it.
-     * @returns {Diagnostic[]}
-     */
-    get warnings() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_warnings(retptr, this.__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);
-        }
-    }
-}
-if (Symbol.dispose) Document.prototype[Symbol.dispose] = Document.prototype.free;
-
-/**
- * Live render session: reads (`render`, `paint`, `pageSize`, `regions`,
- * `fieldAt`, `positionAt`, `locate`) serve the current compile. `apply(doc)`
- * recompiles a whole document in place, transactionally (on throw every read
- * keeps serving the last-good compile). Geometry reads reflect the current
- * compile; anchoring a caret across edits is the editor's job: re-read
- * geometry after each committed `apply`.
- *
- * **Empty documents.** A zero-page document yields a valid session
- * (`pageCount === 0`); `paint(ctx, 0)` or `pageSize(0)` throws with
- * `"page index 0 out of range (pageCount=0)"`. Branch on `pageCount === 0`
- * rather than catching the error.
- */
-export class LiveSession {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(LiveSession.prototype);
-        obj.__wbg_ptr = ptr;
-        LiveSessionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        LiveSessionFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_livesession_free(ptr, 0);
-    }
-    /**
-     * Recompile the session against `doc`: the edit verb of a live preview.
-     * The document is compiled through the same schema pipeline as `open`
-     * (same quill), then applied transactionally: on throw every read
-     * (`render`, `paint`, `pageSize`, `regions`, `fieldAt`) keeps serving the last-good
-     * compile, and the session recovers on the next successful `apply`. On
-     * success reads serve the new compile; repaint `dirtyPages ∩ visible`.
-     * @param {Document} doc
-     * @returns {ChangeSet}
-     */
-    apply(doc) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(doc, Document);
-            wasm.livesession_apply(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);
-        }
-    }
-    /**
-     * The backend that produced this session (e.g. `"typst"`).
-     * @returns {string}
-     */
-    get backendId() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.livesession_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);
-        }
-    }
-    /**
-     * The schema field whose content is under a point on `page`, the
-     * forward (click → field) direction: hit-test a click against the
-     * compiled document and get back the `DocPath` field address to focus in
-     * the editor, or `undefined` off any field's ink. `x`/`y` are PDF points
-     * with a **bottom-left** origin, the same space as `FieldRegion.rect`,
-     * from a canvas click, invert the overlay transform documented on
-     * `FieldRegion`: `x = clickPx.x / renderScale`,
-     * `y = pageHeightPt - clickPx.y / renderScale`. Unlike `regions()`,
-     * *every* placement answers, not just the first.
-     * @param {number} page
-     * @param {number} x
-     * @param {number} y
-     * @returns {string | undefined}
-     */
-    fieldAt(page, x, y) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.livesession_fieldAt(retptr, this.__wbg_ptr, page, x, y);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            let v1;
-            if (r0 !== 0) {
-                v1 = getStringFromWasm0(r0, r1).slice();
-                wasm.__wbindgen_export4(r0, r1 * 1, 1);
-            }
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * The whole-field highlight boxes for `field`: one union rect per page,
-     * over the field's `span`-bearing content segments. The convenience that
-     * owns the union `regions()` leaves derived: it keeps `regions()` the
-     * low-level disjoint truth and folds the span-filter + per-page
-     * union here, so a "highlight the focused field" consumer stops
-     * reimplementing it. **Content only**: a field placed solely as a scalar
-     * reference or a bound widget carries no `span` and returns `[]`; its box
-     * is a single `regions()` rect. Reflects the current compile, like
-     * `regions()`.
-     * @param {string} field
-     * @returns {FieldRegion[]}
-     */
-    fieldBoxes(field) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(field, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.livesession_fieldBoxes(retptr, this.__wbg_ptr, 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);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * A content position → **caret rect**, the reverse of `positionAt`: given
-     * a field and a USV offset into its `Content`, return the box (in the
-     * same bottom-left PDF-point space as `FieldRegion.rect`) to draw a caret
-     * at, its `span` collapsed to `[pos, pos]`; `undefined` when the field
-     * places no tracked content or the offset maps to no drawn glyph.
-     * @param {string} field
-     * @param {number} pos
-     * @returns {FieldRegion | undefined}
-     */
-    locate(field, pos) {
-        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.livesession_locate(this.__wbg_ptr, ptr0, len0, pos);
-        return takeObject(ret);
-    }
-    /**
-     * @returns {number}
-     */
-    get pageCount() {
-        const ret = wasm.livesession_pageCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Page dimensions in points (1 pt = 1/72 inch).
-     * Throws if the backend has no canvas painter or `page` is out of range.
-     * @param {number} page
-     * @returns {PageSize}
-     */
-    pageSize(page) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.livesession_pageSize(retptr, this.__wbg_ptr, page);
-            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);
-        }
-    }
-    /**
-     * Paint `page` into a `CanvasRenderingContext2D` or
-     * `OffscreenCanvasRenderingContext2D`. The painter owns
-     * `canvas.width`/`height` (no `clearRect` needed); consumers own
-     * `canvas.style.*`. If `layoutScale * densityScale` exceeds 16384 px
-     * per side, `densityScale` is clamped: `PaintResult.clamped` reports it and
-     * `PaintResult.effectiveDensityScale` carries the density actually applied.
-     *
-     * `put_image_data` writes the whole backing store, bypassing the 2D
-     * context's transform, `globalAlpha`, and clip: the painter owns the entire
-     * canvas, so each visible page needs its own `<canvas>`; you cannot composite
-     * two pages, a sub-rect, or a context transform through this call.
-     *
-     * Throws if the backend has no canvas painter, `page` is out of range,
-     * `ctx` is the wrong type, or either scale is non-finite or `<= 0`.
-     * @param {CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D} ctx
-     * @param {number} page
-     * @param {PaintOptions | undefined} opts
-     * @returns {PaintResult}
-     */
-    paint(ctx, page, opts) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.livesession_paint(retptr, this.__wbg_ptr, addHeapObject(ctx), page, 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);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * A point → **content position**, the fine-grained click direction:
-     * hit-test a point and get back the field *and* a USV offset into its
-     * `Content` (for placing a caret or mapping a selection into the content
-     * model), or `undefined` off all content ink. `x`/`y` are PDF points,
-     * bottom-left origin: the same space as `fieldAt`. The offset is
-     * cluster-exact and degrades to the containing segment's start on
-     * origin-less ink (list markers, a code fence's interior). See
-     * `ContentHit`.
-     * @param {number} page
-     * @param {number} x
-     * @param {number} y
-     * @returns {ContentHit | undefined}
-     */
-    positionAt(page, x, y) {
-        const ret = wasm.livesession_positionAt(this.__wbg_ptr, page, x, y);
-        return takeObject(ret);
-    }
-    /**
-     * Schema-field geometry for this compiled session: each content field's
-     * **first placement** (one region per page it touches) plus widget and
-     * scalar-reference-site regions, keyed on the canonical `DocPath` address
-     * (`parseDocPath`-routable; the session resolves the backend's plate-space
-     * per-kind ordinal to it); a field may still appear more than once (group
-     * by `field`, see `FieldRegion`). A session-level query: no render, no byte
-     * artifact. An interactive preview reads it to scroll to / highlight the
-     * focused field over a `paint`-ed canvas; the click direction is `fieldAt`.
-     * Empty for backends that place no schema fields.
-     * @returns {FieldRegion[]}
-     */
-    regions() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.livesession_regions(retptr, this.__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);
-        }
-    }
-    /**
-     * @param {RenderOptions | null} [opts]
-     * @returns {RenderResult}
-     */
-    render(opts) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.livesession_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);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * `true` iff `paint` and `pageSize` will succeed for this session. Derived
-     * from the session's canvas seam, so it reflects exactly what `paint` will
-     * do: no separately captured flag.
-     * @returns {boolean}
-     */
-    get supportsCanvas() {
-        const ret = wasm.livesession_supportsCanvas(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Non-fatal diagnostics of the session's **current compile** (e.g. Typst
-     * font fallback): set at open and refreshed by each committed `apply`;
-     * a failed apply keeps the last-good compile's warnings. Also appended
-     * to `RenderResult.warnings` on each `render()` call.
-     * @returns {Diagnostic[]}
-     */
-    get warnings() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.livesession_warnings(retptr, this.__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);
-        }
-    }
-}
-if (Symbol.dispose) LiveSession.prototype[Symbol.dispose] = LiveSession.prototype.free;
-
-export class Quill {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Quill.prototype);
-        obj.__wbg_ptr = ptr;
-        QuillFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        QuillFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_quill_free(ptr, 0);
-    }
-    /**
-     * The *declared* backend identifier (`config.backend`, e.g. `"typst"`).
-     * Intent, not a resolved capability: capability (`supportedFormats` /
-     * `supportsCanvas`) is read from the engine.
-     * @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);
-        }
-    }
-    /**
-     * @returns {string}
-     */
-    get blueprint() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_blueprint(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);
-        }
-    }
-    /**
-     * Land `doc`'s declared content fields at their canonical rest **in
-     * place**, returning the `conform::*` diagnostics for the values that would
-     * not commit (an empty array when everything rested).
-     *
-     * The read-repair verb: a document that arrived through the transport door
-     * (`fromMarkdown`, `fromJson`, a stored row) converges here, and is then
-     * eligible for rewrite under its current schema tag. Idempotent, and a
-     * no-op on an already-canonical document: an equal value is not rewritten,
-     * so YAML comments and stored bytes survive.
-     *
-     * A `!must_fill` marker anywhere in a field's value skips that field (the
-     * marker is the state), and a value the strict write refuses stays as
-     * authored with a diagnostic. Throws when `doc` declares a different
-     * `$quill`, before any mutation.
-     * @param {Document} doc
-     * @returns {Diagnostic[]}
-     */
-    conform(doc) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(doc, Document);
-            wasm.quill_conform(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);
-        }
-    }
-    /**
-     * Build a quill from a file tree. Pure: no backend, no engine; the
-     * declared backend is resolved later, at render time.
-     *
-     * Accepts either a `Map<string, Uint8Array>` or a plain object
-     * (`Record<string, Uint8Array>`). Plain objects are walked via
-     * `Object.entries` at the boundary; the Rust side sees a single
-     * canonical shape.
-     * @param {Map<string, Uint8Array>} tree
-     * @returns {Quill}
-     */
-    static fromTree(tree) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_fromTree(retptr, addHeapObject(tree));
-            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 Quill.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Identity snapshot of the `quill:` section of `Quill.yaml` plus any extra
-     * `quill:` keys. Pure config: the backend's output formats are a
-     * resolved-backend capability read from the engine
-     * (`Quillmark.supportedFormats`), not part of this snapshot.
-     * @returns {QuillMetadata}
-     */
-    get metadata() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_metadata(retptr, this.__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);
-        }
-    }
-    /**
-     * Parse `markdown` and conform it against this quill: the **primary
-     * ingestion path**, and the bound twin of the schema-free
-     * `Document.fromMarkdown`. The returned document rests at its canonical
-     * form (a `richtext` field as a content object, a `plaintext` field as its
-     * literal string), so `getStored` no longer answers "corpus or string?"
-     * with "depends how this document was built".
-     *
-     * Parse warnings and the `conform::*` diagnostics both land on
-     * `doc.warnings`. Throws on a parse failure, or when `markdown` declares a
-     * `$quill` this quill does not answer to: nothing conforms under the wrong
-     * schema. To open a document whose `$quill` is stale, use the transport
-     * door (`Document.fromMarkdown`, `setQuillRef`, then `quill.conform`).
-     * @param {string} markdown
-     * @returns {Document}
-     */
-    parse(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.quill_parse(retptr, this.__wbg_ptr, 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 Document.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * The resolved-value view of `doc` against this quill's schema: for every
-     * declared field the value the render projection would use and the
-     * `FieldSource` rung it came from (`"authored" | "default" | "zero"`), in
-     * one call. The card body is a `body` sibling on its card (row `name`
-     * `"body"`), never a row in `fields`: `null` when the kind enables no body.
-     *
-     * Value and provenance only: completeness and errors stay `validate`'s
-     * (a consumer merges it with its own diagnostic producers regardless), and
-     * schema guidance reads from `Quill.schema`.
-     * @param {Document} doc
-     * @returns {Resolved}
-     */
-    resolve(doc) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(doc, Document);
-            wasm.quill_resolve(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);
-        }
-    }
-    /**
-     * Document schema for the quill: the user-fillable fields plus their
-     * `ui` hints (title / group / compact / multiline). The single
-     * field-metadata surface: drives form editors and LLM/MCP consumers
-     * alike. Key order in `fields`/`properties` is declaration order: the
-     * ordering contract. Returns the `QuillSchema` shape.
-     * @returns {QuillSchema}
-     */
-    get schema() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_schema(retptr, this.__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);
-        }
-    }
-    /**
-     * Seed a starter composable `Card` of the given kind (carries `$kind`),
-     * layering an optional per-kind seed `overlay` over the schema-example
-     * base (`overlay › example › absent`). Returns `undefined` if `cardKind`
-     * is not declared in this quill's schema, else a `Card` that feeds
-     * straight into `Document.insertCard`.
-     *
-     * Pass `document.seedOverlay(cardKind)` as `overlay` so a card added to a
-     * template-derived document inherits its curated starting values; omit it
-     * (or pass `undefined` / `null`) for the bare schema seed. `overlay` is a
-     * plain object: this reads the document, it does not mutate it.
-     * @param {string} card_kind
-     * @param {Record<string, unknown> | undefined} overlay
-     * @returns {Card | undefined}
-     */
-    seedCard(card_kind, overlay) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(card_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.quill_seedCard(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(overlay));
-            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);
-        }
-    }
-    /**
-     * Seed a starter `Document` from the schema, the main card plus one
-     * instance of each composable card kind, each committing its fields'
-     * `example:` values and leaving every other field absent (interpolated at
-     * render: `default:`, else type-empty zero). Illustration-first: a field
-     * with both an `example` and a `default` renders its example. See
-     * `prose/canon/SCHEMAS.md` § "Document seeding".
-     * @returns {Document}
-     */
-    seedDocument() {
-        const ret = wasm.quill_seedDocument(this.__wbg_ptr);
-        return Document.__wrap(ret);
-    }
-    /**
-     * Seed a starter main `Card` (carries `$quill`) from the schema: the
-     * `$kind: main` card of [`seedDocument`](Self::seed_document) in
-     * isolation, committing each field's `example:` value. Returns the same
-     * `Card` shape as the `Document.main` getter.
-     * @returns {Card}
-     */
-    seedMain() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.quill_seedMain(retptr, this.__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);
-        }
-    }
-    /**
-     * Flatten this quill back into its canonical file tree: the inverse of
-     * [`fromTree`](Self::from_tree). Round-trips: `Quill.fromTree(q.toTree())`
-     * reproduces an equivalent quill.
-     *
-     * This is how a quill crosses a WASM linear-memory boundary as data: a
-     * `Quill` built in one build (e.g. the Typst-less `@quillmark/wasm/core`)
-     * cannot be passed to an engine in another (separate linear memories), so
-     * `@quillmark/wasm/runtime` re-feeds this tree to the backend build's
-     * `Quill.fromTree` on demand. Keys are `"/"`-joined relative paths,
-     * matching what `fromTree` accepts.
-     * @returns {Map<string, Uint8Array>}
-     */
-    toTree() {
-        const ret = wasm.quill_toTree(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * Validate `doc` against this quill's schema, returning every diagnostic
-     * (an empty array when the document is valid).
-     *
-     * Forwards the canonical `validation::*` diagnostics (same `code`,
-     * `path`, and `hint` the engine emits) including the non-fatal
-     * `validation::must_fill` warning for each `!must_fill` marker left in
-     * the document. Field values, defaults, and order are not part of this
-     * surface: read them from the `Document` payload and `Quill.schema`
-     * (schema key order is display order).
-     * @param {Document} doc
-     * @returns {Diagnostic[]}
-     */
-    validate(doc) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(doc, Document);
-            wasm.quill_validate(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);
-        }
-    }
-}
-if (Symbol.dispose) Quill.prototype[Symbol.dispose] = Quill.prototype.free;
-
-/**
- * Render engine: a backend registry and render dispatcher. Render build only:
- * the core build constructs and validates quills without it.
- */
-export class Quillmark {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        QuillmarkFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_quillmark_free(ptr, 0);
-    }
-    constructor() {
-        const ret = wasm.quillmark_new();
-        this.__wbg_ptr = ret >>> 0;
-        QuillmarkFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Open a live render session for `doc` against `quill`'s backend.
-     * @param {Quill} quill
-     * @param {Document} doc
-     * @returns {LiveSession}
-     */
-    open(quill, doc) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            _assertClass(doc, Document);
-            wasm.quillmark_open(retptr, this.__wbg_ptr, quill.__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 LiveSession.__wrap(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Render `doc` against `quill` in one shot. Convenience over `open` +
-     * `LiveSession.render`: an unset `output_format` falls back to the
-     * backend's first supported format.
-     * @param {Quill} quill
-     * @param {Document} doc
-     * @param {RenderOptions | null} [opts]
-     * @returns {RenderResult}
-     */
-    render(quill, doc, opts) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            _assertClass(doc, Document);
-            wasm.quillmark_render(retptr, this.__wbg_ptr, quill.__wbg_ptr, doc.__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);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * The output formats `quill`'s backend can emit. Static capability:
-     * resolves the backend but compiles nothing. Throws `engine::backend_not_found`
-     * if no registered backend matches the quill's declared backend.
-     * @param {Quill} quill
-     * @returns {OutputFormat[]}
-     */
-    supportedFormats(quill) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(quill, Quill);
-            wasm.quillmark_supportedFormats(retptr, this.__wbg_ptr, quill.__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);
-        }
-    }
-    /**
-     * Pre-session hint: `true` iff `quill`'s backend can paint sessions to a
-     * canvas, derived from the backend's output formats; `false` when the
-     * backend is unsupported. Use as a cheap precondition probe before mounting
-     * a canvas-based preview UI; the authoritative answer is the session's
-     * `supportsCanvas` getter once `open()` has been called.
-     * @param {Quill} quill
-     * @returns {boolean}
-     */
-    supportsCanvas(quill) {
-        _assertClass(quill, Quill);
-        const ret = wasm.quillmark_supportsCanvas(this.__wbg_ptr, quill.__wbg_ptr);
-        return ret !== 0;
-    }
-}
-if (Symbol.dispose) Quillmark.prototype[Symbol.dispose] = Quillmark.prototype.free;
-
-/**
- * Export a canonical `Content` content to its markdown projection: the pure
- * on-demand codec behind `exportMarkdown(card.body)`. Throws if `rt` is not a
- * canonical content.
- * @param {Content} rt
- * @returns {string}
- */
-export function exportMarkdown(rt) {
-    let deferred2_0;
-    let deferred2_1;
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.exportMarkdown(retptr, addHeapObject(rt));
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        var ptr1 = r0;
-        var len1 = r1;
-        if (r3) {
-            ptr1 = 0; len1 = 0;
-            throw takeObject(r2);
-        }
-        deferred2_0 = ptr1;
-        deferred2_1 = len1;
-        return getStringFromWasm0(ptr1, len1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
-    }
-}
-
-/**
- * Serialize structured [`DocPathSeg`] segments back to the canonical path
- * string: the inverse of `parseDocPath`, for a consumer that builds a path
- * rather than reads one. Throws on a segment array the deserializer rejects,
- * and on an empty segment array (symmetric with `parseDocPath("")`, which
- * throws "empty path").
- * @param {DocPathSeg[]} segs
- * @returns {string}
- */
-export function formatDocPath(segs) {
-    let deferred2_0;
-    let deferred2_1;
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.formatDocPath(retptr, addHeapObject(segs));
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        var ptr1 = r0;
-        var len1 = r1;
-        if (r3) {
-            ptr1 = 0; len1 = 0;
-            throw takeObject(r2);
-        }
-        deferred2_0 = ptr1;
-        deferred2_1 = len1;
-        return getStringFromWasm0(ptr1, len1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
-    }
-}
-
-/**
- * Import a markdown string to a canonical `Content` content: the pure,
- * document-free codec. Pair with `install(addr, importMarkdown(md))` to spell
- * the cold (anchor-losing) write at the call site; prefer `revise` for edit
- * semantics. Throws on an over-nested input.
- * @param {string} markdown
- * @returns {Content}
- */
-export function importMarkdown(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.importMarkdown(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);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-}
-
-/**
- * Initialize the WASM module with panic hooks for better error messages
- */
-export function init() {
-    wasm.init();
-}
-
-/**
- * Map a base content position (a USV index into `Content.text`, not a UTF-16
- * offset) through a `delta` to its new USV position: the pure position-mapping
- * codec an editor bridge composes to hold a caret stable across a `revise`.
- * `assoc` decides the side of a same-position insertion (`"after"` moves past
- * it). Throws on a malformed `delta`.
- * @param {Delta} delta
- * @param {number} pos
- * @param {Assoc} assoc
- * @returns {number}
- */
-export function mapPos(delta, pos, assoc) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.mapPos(retptr, addHeapObject(delta), pos, addHeapObject(assoc));
-        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 r0 >>> 0;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-}
-
-/**
- * Parse a canonical document-model `Diagnostic.path`
- * (`cards.<kind>[<i>].<field>`, `main.body`, `recipients[0].name`) into its
- * structured [`DocPathSeg`] segments: the exported inverse of the engine's
- * one path serializer, so a consumer routes on segments instead of regexing
- * the string. Throws on a malformed path.
- * @param {string} path
- * @returns {DocPathSeg[]}
- */
-export function parseDocPath(path) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.parseDocPath(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);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-}
-
-/**
- * Rebase `markdown` onto a `base` content, the pure, document-free twin of
- * `revise`: cold-import + `diff_import`, returning the new `content` and the
- * text `delta` (its offsets USV indices into `Content.text`, surviving anchors
- * rebased). Use it to compute a revise without a document in hand; `revise(addr,
- * md)` fuses this with the store for atomicity. Throws on an over-nested
- * markdown input or a non-content `base`.
- * @param {Content} base
- * @param {string} markdown
- * @returns {{ content: Content; delta: Delta }}
- */
-export function rebase(base, 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.rebase(retptr, addHeapObject(base), 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);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-}
-export function __wbg_Error_960c155d3d49e4c2(arg0, arg1) {
-    const ret = Error(getStringFromWasm0(arg0, arg1));
-    return addHeapObject(ret);
-}
-export function __wbg_Number_32bf70a599af1d4b(arg0) {
-    const ret = Number(getObject(arg0));
-    return ret;
-}
-export function __wbg_String_8564e559799eccda(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);
-}
-export function __wbg___wbindgen_bigint_get_as_i64_3d3aba5d616c6a51(arg0, arg1) {
-    const v = getObject(arg1);
-    const ret = typeof(v) === 'bigint' ? v : undefined;
-    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-}
-export function __wbg___wbindgen_boolean_get_6ea149f0a8dcc5ff(arg0) {
-    const v = getObject(arg0);
-    const ret = typeof(v) === 'boolean' ? v : undefined;
-    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
-}
-export function __wbg___wbindgen_debug_string_ab4b34d23d6778bd(arg0, arg1) {
-    const ret = debugString(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);
-}
-export function __wbg___wbindgen_in_a5d8b22e52b24dd1(arg0, arg1) {
-    const ret = getObject(arg0) in getObject(arg1);
-    return ret;
-}
-export function __wbg___wbindgen_is_bigint_ec25c7f91b4d9e93(arg0) {
-    const ret = typeof(getObject(arg0)) === 'bigint';
-    return ret;
-}
-export function __wbg___wbindgen_is_function_3baa9db1a987f47d(arg0) {
-    const ret = typeof(getObject(arg0)) === 'function';
-    return ret;
-}
-export function __wbg___wbindgen_is_null_52ff4ec04186736f(arg0) {
-    const ret = getObject(arg0) === null;
-    return ret;
-}
-export function __wbg___wbindgen_is_object_63322ec0cd6ea4ef(arg0) {
-    const val = getObject(arg0);
-    const ret = typeof(val) === 'object' && val !== null;
-    return ret;
-}
-export function __wbg___wbindgen_is_string_6df3bf7ef1164ed3(arg0) {
-    const ret = typeof(getObject(arg0)) === 'string';
-    return ret;
-}
-export function __wbg___wbindgen_is_undefined_29a43b4d42920abd(arg0) {
-    const ret = getObject(arg0) === undefined;
-    return ret;
-}
-export function __wbg___wbindgen_jsval_eq_d3465d8a07697228(arg0, arg1) {
-    const ret = getObject(arg0) === getObject(arg1);
-    return ret;
-}
-export function __wbg___wbindgen_jsval_loose_eq_cac3565e89b4134c(arg0, arg1) {
-    const ret = getObject(arg0) == getObject(arg1);
-    return ret;
-}
-export function __wbg___wbindgen_number_get_c7f42aed0525c451(arg0, arg1) {
-    const obj = getObject(arg1);
-    const ret = typeof(obj) === 'number' ? obj : undefined;
-    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-}
-export function __wbg___wbindgen_string_get_7ed5322991caaec5(arg0, arg1) {
-    const obj = getObject(arg1);
-    const ret = typeof(obj) === 'string' ? obj : undefined;
-    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-    var len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-}
-export function __wbg___wbindgen_throw_6b64449b9b9ed33c(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-}
-export function __wbg_call_14b169f759b26747() { return handleError(function (arg0, arg1) {
-    const ret = getObject(arg0).call(getObject(arg1));
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_canvas_2c0c6d263d4c52ad(arg0) {
-    const ret = getObject(arg0).canvas;
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-}
-export function __wbg_canvas_374da9f3c5b3dd0e(arg0) {
-    const ret = getObject(arg0).canvas;
-    return addHeapObject(ret);
-}
-export function __wbg_done_9158f7cc8751ba32(arg0) {
-    const ret = getObject(arg0).done;
-    return ret;
-}
-export function __wbg_entries_2bf997cf82353e47(arg0) {
-    const ret = getObject(arg0).entries();
-    return addHeapObject(ret);
-}
-export function __wbg_entries_e0b73aa8571ddb56(arg0) {
-    const ret = Object.entries(getObject(arg0));
-    return addHeapObject(ret);
-}
-export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
-    let deferred0_0;
-    let deferred0_1;
-    try {
-        deferred0_0 = arg0;
-        deferred0_1 = arg1;
-        console.error(getStringFromWasm0(arg0, arg1));
-    } finally {
-        wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
-    }
-}
-export function __wbg_from_0dbf29f09e7fb200(arg0) {
-    const ret = Array.from(getObject(arg0));
-    return addHeapObject(ret);
-}
-export function __wbg_getTime_da7c55f52b71e8c6(arg0) {
-    const ret = getObject(arg0).getTime();
-    return ret;
-}
-export function __wbg_getUTCDate_5cd8b68e971333f7(arg0) {
-    const ret = getObject(arg0).getUTCDate();
-    return ret;
-}
-export function __wbg_getUTCFullYear_f3b3950a0ccb9165(arg0) {
-    const ret = getObject(arg0).getUTCFullYear();
-    return ret;
-}
-export function __wbg_getUTCMonth_62fa72a7522ef806(arg0) {
-    const ret = getObject(arg0).getUTCMonth();
-    return ret;
-}
-export function __wbg_get_1affdbdd5573b16a() { return handleError(function (arg0, arg1) {
-    const ret = Reflect.get(getObject(arg0), getObject(arg1));
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_get_8360291721e2339f(arg0, arg1) {
-    const ret = getObject(arg0)[arg1 >>> 0];
-    return addHeapObject(ret);
-}
-export function __wbg_get_unchecked_17f53dad852b9588(arg0, arg1) {
-    const ret = getObject(arg0)[arg1 >>> 0];
-    return addHeapObject(ret);
-}
-export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
-    const ret = getObject(arg0)[getObject(arg1)];
-    return addHeapObject(ret);
-}
-export function __wbg_instanceof_ArrayBuffer_7c8433c6ed14ffe3(arg0) {
-    let result;
-    try {
-        result = getObject(arg0) instanceof ArrayBuffer;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-}
-export function __wbg_instanceof_CanvasRenderingContext2d_24a3fe06e62b98d7(arg0) {
-    let result;
-    try {
-        result = getObject(arg0) instanceof CanvasRenderingContext2D;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-}
-export function __wbg_instanceof_Map_1b76fd4635be43eb(arg0) {
-    let result;
-    try {
-        result = getObject(arg0) instanceof Map;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-}
-export function __wbg_instanceof_Object_7c99480a1cdfb911(arg0) {
-    let result;
-    try {
-        result = getObject(arg0) instanceof Object;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-}
-export function __wbg_instanceof_OffscreenCanvasRenderingContext2d_285a274020b4f230(arg0) {
-    let result;
-    try {
-        result = getObject(arg0) instanceof OffscreenCanvasRenderingContext2D;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-}
-export function __wbg_instanceof_Uint8Array_152ba1f289edcf3f(arg0) {
-    let result;
-    try {
-        result = getObject(arg0) instanceof Uint8Array;
-    } catch (_) {
-        result = false;
-    }
-    const ret = result;
-    return ret;
-}
-export function __wbg_isArray_c3109d14ffc06469(arg0) {
-    const ret = Array.isArray(getObject(arg0));
-    return ret;
-}
-export function __wbg_isSafeInteger_4fc213d1989d6d2a(arg0) {
-    const ret = Number.isSafeInteger(getObject(arg0));
-    return ret;
-}
-export function __wbg_iterator_013bc09ec998c2a7() {
-    const ret = Symbol.iterator;
-    return addHeapObject(ret);
-}
-export function __wbg_keys_2fd1bfdda7e278ca(arg0) {
-    const ret = Object.keys(getObject(arg0));
-    return addHeapObject(ret);
-}
-export function __wbg_length_3d4ecd04bd8d22f1(arg0) {
-    const ret = getObject(arg0).length;
-    return ret;
-}
-export function __wbg_length_9f1775224cf1d815(arg0) {
-    const ret = getObject(arg0).length;
-    return ret;
-}
-export function __wbg_new_0_4d657201ced14de3() {
-    const ret = new Date();
-    return addHeapObject(ret);
-}
-export function __wbg_new_0c7403db6e782f19(arg0) {
-    const ret = new Uint8Array(getObject(arg0));
-    return addHeapObject(ret);
-}
-export function __wbg_new_227d7c05414eb861() {
-    const ret = new Error();
-    return addHeapObject(ret);
-}
-export function __wbg_new_34d45cc8e36aaead() {
-    const ret = new Map();
-    return addHeapObject(ret);
-}
-export function __wbg_new_5e360d2ff7b9e1c3(arg0, arg1) {
-    const ret = new Error(getStringFromWasm0(arg0, arg1));
-    return addHeapObject(ret);
-}
-export function __wbg_new_682678e2f47e32bc() {
-    const ret = new Array();
-    return addHeapObject(ret);
-}
-export function __wbg_new_7913666fe5070684(arg0) {
-    const ret = new Date(getObject(arg0));
-    return addHeapObject(ret);
-}
-export function __wbg_new_aa8d0fa9762c29bd() {
-    const ret = new Object();
-    return addHeapObject(ret);
-}
-export function __wbg_new_from_slice_b5ea43e23f6008c0(arg0, arg1) {
-    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
-    return addHeapObject(ret);
-}
-export function __wbg_new_with_u8_clamped_array_and_sh_fe957411824b5158() { return handleError(function (arg0, arg1, arg2, arg3) {
-    const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_next_0340c4ae324393c3() { return handleError(function (arg0) {
-    const ret = getObject(arg0).next();
-    return addHeapObject(ret);
-}, arguments); }
-export function __wbg_next_7646edaa39458ef7(arg0) {
-    const ret = getObject(arg0).next;
-    return addHeapObject(ret);
-}
-export function __wbg_now_a9b7df1cbee90986() {
-    const ret = Date.now();
-    return ret;
-}
-export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
-    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
-}
-export function __wbg_putImageData_c810e62ea70e761d() { return handleError(function (arg0, arg1, arg2, arg3) {
-    getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
-}, arguments); }
-export function __wbg_putImageData_cb4de9afd58963be() { return handleError(function (arg0, arg1, arg2, arg3) {
-    getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
-}, arguments); }
-export function __wbg_set_022bee52d0b05b19() { return handleError(function (arg0, arg1, arg2) {
-    const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
-    return ret;
-}, arguments); }
-export function __wbg_set_3bf1de9fab0cd644(arg0, arg1, arg2) {
-    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-}
-export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
-    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
-}
-export function __wbg_set_fde2cec06c23692b(arg0, arg1, arg2) {
-    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-    return addHeapObject(ret);
-}
-export function __wbg_set_height_24d07d982f176ac6(arg0, arg1) {
-    getObject(arg0).height = arg1 >>> 0;
-}
-export function __wbg_set_height_be9b2b920bd68401(arg0, arg1) {
-    getObject(arg0).height = arg1 >>> 0;
-}
-export function __wbg_set_width_5cda41d4d06a14dd(arg0, arg1) {
-    getObject(arg0).width = arg1 >>> 0;
-}
-export function __wbg_set_width_adc925bca9c5351a(arg0, arg1) {
-    getObject(arg0).width = arg1 >>> 0;
-}
-export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
-    const ret = getObject(arg1).stack;
-    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);
-}
-export function __wbg_value_ee3a06f4579184fa(arg0) {
-    const ret = getObject(arg0).value;
-    return addHeapObject(ret);
-}
-export function __wbg_values_1e6d547ce555ce44(arg0) {
-    const ret = getObject(arg0).values();
-    return addHeapObject(ret);
-}
-export function __wbg_values_301a77363cf6c773(arg0) {
-    const ret = Object.values(getObject(arg0));
-    return addHeapObject(ret);
-}
-export function __wbindgen_cast_0000000000000001(arg0) {
-    // Cast intrinsic for `F64 -> Externref`.
-    const ret = arg0;
-    return addHeapObject(ret);
-}
-export function __wbindgen_cast_0000000000000002(arg0) {
-    // Cast intrinsic for `I64 -> Externref`.
-    const ret = arg0;
-    return addHeapObject(ret);
-}
-export function __wbindgen_cast_0000000000000003(arg0, arg1) {
-    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-    const ret = getArrayU8FromWasm0(arg0, arg1);
-    return addHeapObject(ret);
-}
-export function __wbindgen_cast_0000000000000004(arg0, arg1) {
-    // Cast intrinsic for `Ref(String) -> Externref`.
-    const ret = getStringFromWasm0(arg0, arg1);
-    return addHeapObject(ret);
-}
-export function __wbindgen_cast_0000000000000005(arg0) {
-    // Cast intrinsic for `U64 -> Externref`.
-    const ret = BigInt.asUintN(64, arg0);
-    return addHeapObject(ret);
-}
-export function __wbindgen_object_clone_ref(arg0) {
-    const ret = getObject(arg0);
-    return addHeapObject(ret);
-}
-export function __wbindgen_object_drop_ref(arg0) {
-    takeObject(arg0);
-}
-const DocumentFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_document_free(ptr >>> 0, 1));
-const LiveSessionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_livesession_free(ptr >>> 0, 1));
-const QuillFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_quill_free(ptr >>> 0, 1));
-const QuillmarkFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_quillmark_free(ptr >>> 0, 1));
-
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = 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;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
-}
-
-function dropObject(idx) {
-    if (idx < 1028) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-function getClampedArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-let cachedDataViewMemory0 = null;
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-let cachedUint8ClampedArrayMemory0 = null;
-function getUint8ClampedArrayMemory0() {
-    if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) {
-        cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
-    }
-    return cachedUint8ClampedArrayMemory0;
-}
-
-function getObject(idx) { return heap[idx]; }
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_export3(addHeapObject(e));
-    }
-}
-
-let heap = new Array(1024).fill(undefined);
-heap.push(undefined, null, true, false);
-
-let heap_next = heap.length;
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
-    }
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    };
-}
-
-let WASM_VECTOR_LEN = 0;
-
-
-let wasm;
-export function __wbg_set_wasm(val) {
-    wasm = val;
-}