@quillmark/wasm 0.133.0 → 0.134.1

package/core/wasm.js

@@ -100,9 +100,9 @@ export class Document {
     /**
      * Batched twin of [`commitField`](Document::commit_field): typed-commit
      * several fields on the card `addr` targets atomically. `addr` is a **card
-     * address** (absent = main; a present `field` throws). Same per-field
-     * diagnostic contract as [`storeFields`](Document::store_fields) — nothing
-     * applied on error, one `diagnostics` entry per offending field, including
+     * address** (absent = main; a present `field` throws). Nothing is
+     * applied on error, and the thrown error carries one `diagnostics` entry per
+     * offending field, including
      * `edit::unknown_field` for undeclared names. Throws on an out-of-range
      * card. Returns [`commitField`](Document::commit_field)'s warnings for
      * every field, in batch order.
@@ -127,6 +127,73 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The ABI under `writer.hashAt`: the body's hash, or a field's through its
+     * schema (a `richtext` field its content however it rests, a `text` field
+     * its literal text, any other type its stored value), the `baseHash` the
+     * writer's `reviseBody` / `reviseField` check. An undeclared name throws
+     * `edit::unknown_field`, an out-of-range card throws.
+     * @param {Quill} quill
+     * @param {Addr | string} addr
+     * @returns {string}
+     */
+    _hashAt(quill, addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            wasm.document__hashAt(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);
+            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);
+        }
+    }
+    /**
+     * The ABI under `writer.hash`: the hash of the document as `quill`
+     * conforms it, the `baseHash` `writer.reviseDocument` checks. Throws when
+     * the document declares a `$quill` this quill does not answer to.
+     * @param {Quill} quill
+     * @returns {string}
+     */
+    _hash(quill) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            wasm.document__hash(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);
+            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);
+        }
+    }
     /**
      * Interpreted **`Content`** read of a value nested inside the composite
      * field at `addr`: the stable ABI under the runtime `reader.getContentAt`,
@@ -249,15 +316,16 @@ export class Document {
      * does not answer to, before any mutation.
      * @param {Quill} quill
      * @param {string} markdown
+     * @param {any} opts
      * @returns {DocumentRevised}
      */
-    _reviseDocument(quill, markdown) {
+    _reviseDocument(quill, markdown, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             _assertClass(quill, Quill);
             const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len0 = WASM_VECTOR_LEN;
-            wasm.document__reviseDocument(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0);
+            wasm.document__reviseDocument(retptr, this.__wbg_ptr, quill.__wbg_ptr, ptr0, len0, 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);
@@ -284,15 +352,16 @@ export class Document {
      * @param {Quill} quill
      * @param {Addr | string} addr
      * @param {string} text
+     * @param {any} opts
      * @returns {Revised}
      */
-    _reviseField(quill, addr, text) {
+    _reviseField(quill, addr, text, opts) {
         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);
+            wasm.document__reviseField(retptr, this.__wbg_ptr, quill.__wbg_ptr, addHeapObject(addr), ptr0, len0, 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);
@@ -305,32 +374,166 @@ export class Document {
         }
     }
     /**
-     * **Apply** a committed content edit `bundle` at `addr`, the editor splice:
-     * text delta first, then island ops, then line ops, then mark ops (mark
-     * ranges in final-text coordinates), all-or-nothing. An absent `addr.field`
-     * targets the body, an absent `addr.card` the main card. The island channel
-     * moves an island alone, so anchors elsewhere in the field survive an edit
-     * `overwrite` would clear.
+     * The ABI under `writer.reviseBody`: **revise** the richtext value at
+     * `addr` from a markdown string. Imports the markdown, diffs it against the current
+     * value, rebases surviving identity anchors, and returns the `Revised`
+     * receipt: the text `delta` an editor bridge maps its own positions through,
+     * and a `parse::dropped_construct` warning per construct the
+     * import dropped, its `path` the address written. 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 field that is not richtext, a malformed
-     * bundle, or an op that applies out of bounds; the value is unchanged on a
-     * failed apply.
+     * `opts` names what the writer read (`BaseOptions`): a stale `baseHash`
+     * throws `edit::stale_base`, and a `baseMarkdown` the value has moved on
+     * from merges, throwing `edit::rebase_conflict` where both changed a line.
      *
-     * Each text-moving channel rebases the marks already in the field, by the
-     * rule on `ChangeBundle`; `mapMarks` answers where they land, so a caller
-     * building `markOps` need not predict it.
+     * 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 {ChangeBundle} bundle
+     * @param {string} markdown
+     * @param {BaseOptions} [opts]
+     * @returns {Revised}
      */
-    applyChange(addr, bundle) {
+    _revise(addr, markdown, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_applyChange(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(bundle));
+            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, addHeapObject(opts));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            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 context of the anchor `id`, or `undefined` where no body or
+     * content value holds one.
+     * @param {string} id
+     * @returns {AnchorContext | undefined}
+     */
+    anchorContext(id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.document_anchorContext(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);
+        }
+    }
+    /**
+     * Every anchor of every body and content value with its context, a table
+     * cell's or a note's included, in the order `toAnnotatedMarkdown` lists
+     * anchors: the selector a host stores beside a comment thread and hands
+     * back to `reattach`.
+     * @returns {AnchorContext[]}
+     */
+    anchorContexts() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_anchorContexts(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);
+        }
+    }
+    /**
+     * The annotated read of the body or richtext field at `addr` alone: the
+     * scoped twin of `toAnnotatedMarkdown`, what a revise at `addr` reads
+     * back and the `baseMarkdown` it merges against. Each anchor names `addr`'s
+     * path. An absent field reads as the empty content. Throws as `hashAt`.
+     * @param {Addr | string} addr
+     * @returns {AnnotatedMarkdown}
+     */
+    annotatedAt(addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_annotatedAt(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 markdown at `addr` with a `qm-*` tag for each anchor and island id
+     * its lines can hold: what `revise` reads back. Throws as `read`.
+     * @param {Addr | string} addr
+     * @returns {string}
+     */
+    annotated(addr) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_annotated(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);
+            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);
+        }
+    }
+    /**
+     * **Apply** `change` to the value at `addr`, all its steps or none, and
+     * answer the `Receipt`. `opts.base` is the hash the writer read
+     * (`hash(addr)`), and the change's offsets are into the value it names:
+     * one the value has moved on from rebases the change over the change
+     * since, throwing `edit::rebase_conflict` where they touch the same text or
+     * record and `edit::stale_base` where the document no longer holds the change
+     * since. A refused change throws `edit::content_apply` and writes
+     * nothing.
+     * @param {Addr | string} addr
+     * @param {Change} change
+     * @param {WriteOptions} [opts]
+     * @returns {Receipt}
+     */
+    apply(addr, change, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_apply(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(change), 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);
         }
@@ -442,11 +645,10 @@ export class Document {
     }
     /**
      * The newest storage version this build writes via
-     * [`toStored`](Document::to_stored): a document spelling a font mark, a
-     * `table` element, a merged table cell or a table head 0.130 cannot draw
-     * carries it, every other the tag before it, which a 0.130 build reads.
-     * The tag advances only when the wire format changes, not on every
-     * release.
+     * [`toStored`](Document::to_stored): a document holding a composable
+     * card, each carrying its `$id`, carries it. A document of the main card
+     * alone carries the oldest tag that holds its content. The tag advances
+     * only when the wire format changes, not on every release.
      * @returns {string}
      */
     static currentStorageVersion() {
@@ -499,7 +701,7 @@ export class Document {
     }
     /**
      * Reconstruct a `Document` from a versioned storage DTO string produced by
-     * [`toStored`](Document::to_stored). The result carries no parse-time warnings.
+     * [`toStored`](Document::to_stored), with no `warnings`.
      * Throws if `json` is not a valid storage DTO (malformed JSON, unknown
      * `schema`, missing fields, or unparseable quill reference).
      * @param {string} json
@@ -582,41 +784,85 @@ export class Document {
         }
     }
     /**
-     * Insert a card: `at` absent appends, a number inserts at that index (in
-     * `0..=cards.length`). Accepts any `CardInput`, including a card read back
-     * out of a document. Throws if `card.kind` is not a valid kind name, if
-     * `at` is out of range, or `edit::too_many_cards` if the document holds
-     * 1,000 cards.
-     * @param {CardInput} card
-     * @param {number} [at]
+     * The hash of the body or richtext field at `addr`, the `baseHash` a
+     * revise at `addr` checks: the hash of its content, an absent field the
+     * empty content. An absent `addr.field` reads the body, an absent
+     * `addr.card` the main card. Richtext only; the
+     * typed `writer.hashAt` reads a field of any type through its schema.
+     * Throws on an out-of-range card, a malformed field name, or a present
+     * non-content field value.
+     * @param {Addr | string} addr
+     * @returns {string}
      */
-    insertCard(card, at) {
+    hashAt(addr) {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_insertCard(retptr, this.__wbg_ptr, addHeapObject(card), isLikeNone(at) ? Number.MAX_SAFE_INTEGER : (at) >>> 0);
+            wasm.document_hashAt(retptr, this.__wbg_ptr, addHeapObject(addr));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            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);
         }
     }
     /**
-     * Replace this document's contents **in place** from a versioned storage DTO
-     * string: the mutating twin of [`fromStored`](Document::from_stored).
-     * Parse-time `warnings` are cleared. Throws on an invalid DTO, leaving the
-     * document unchanged. A caller holding the document need not re-bind its
-     * variable.
-     * @param {string} json
+     * With no `addr`, the hash of the document's stored form, the quill-free
+     * twin of `writer.hash()`: equal documents hash alike, whatever order a
+     * store kept their keys in. With one, the hash of the `Content` at
+     * `addr`, the `base` a write to it names. Throws as `read`.
+     * @param {Addr | string} [addr]
+     * @returns {string}
      */
-    loadStored(json) {
+    hash(addr) {
+        let deferred2_0;
+        let deferred2_1;
         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_loadStored(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.document_hash(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);
+            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);
+        }
+    }
+    /**
+     * Insert a card: `at` absent appends, a number inserts at that index (in
+     * `0..=cards.length`). Accepts any `CardInput`, including a card read back
+     * out of a document. Throws if `card.kind` is not a valid kind name, if
+     * `at` is out of range, or `edit::too_many_cards` if the document holds
+     * 1,000 cards.
+     * @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) ? Number.MAX_SAFE_INTEGER : (at) >>> 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -645,27 +891,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * The Quillmark Markdown rules, re-exposed from core. Constant across
-     * calls; read once and cache.
-     * @returns {string}
-     */
-    static markdownRules() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_markdownRules(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);
-        }
-    }
     /**
      * Move the card at `from` to position `to`. `from == to` is a no-op.
      * @param {number} from
@@ -711,32 +936,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * **Overwrite** the content value at `addr` with exactly `rt`: value
-     * semantics, so the identity anchors of any previous value are gone. By
-     * anchor fate `overwrite` destroys, [`revise`](Document::revise) and
-     * [`reviseContent`](Document::revise_content) rebase, and
-     * [`applyChange`](Document::apply_change) preserves. An absent
-     * `addr.field` targets the body, an absent `addr.card` the main card.
-     *
-     * 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
-     */
-    overwrite(addr, rt) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_overwrite(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);
-        }
-    }
     /**
      * `addr`'s canonical `DocPath` string, the anchor `Diagnostic.path` carries:
      * `pathFor()` is `main.body`, `pathFor("intro")` `main.intro`,
@@ -750,7 +949,7 @@ export class Document {
      * **Total on the index axis**, unlike the `Addr` reads, which throw there:
      * an out-of-range `{card: 7, field: "from"}` renders `cards[7].from`, which
      * parses back and resolves to nothing rather than mis-targeting. Only a
-     * malformed address throws.
+     * malformed address throws, or a card id no card holds.
      * @param {Addr | string} addr
      * @returns {string}
      */
@@ -819,6 +1018,65 @@ export class Document {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * The `Content` at `addr`: an absent `addr.field` reads the body, an
+     * absent `addr.card` the main card, and an absent field the empty
+     * content. Throws on an out-of-range card, a malformed field name, or a
+     * present field value that is not content.
+     * @param {Addr | string} addr
+     * @returns {Content}
+     */
+    read(addr) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_read(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);
+        }
+    }
+    /**
+     * Re-add anchors a write dropped, each at the `path` its selector names,
+     * where its `quote` is found exactly once with its context agreeing: four
+     * scalar values of quote or more, or a table's slot alone, eight of
+     * context on each side or the whole context where the value's edge cut
+     * it, and an empty quote a point where the two meet. Never a nearest match. Returns the `Reattached`
+     * receipt.
+     *
+     * A path naming no body or content value orphans its selector, and
+     * nothing remaps a card index. An id live anywhere in the document, a
+     * table cell's included, is answered as reattached and not written. Each
+     * id is answered once, by its first selector. `deltas` maps a path to the
+     * `delta` of the revise that dropped its anchors, and a match there must
+     * overlap text that revise inserted.
+     *
+     * Throws on a selector or delta that is not one, or a `path` that does
+     * not parse.
+     * @param {AnchorContext[]} selectors
+     * @param {Record<string, Delta>} [deltas]
+     * @returns {Reattached}
+     */
+    reattach(selectors, deltas) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.document_reattach(retptr, this.__wbg_ptr, addHeapObject(selectors), addHeapObject(deltas));
+            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 {number} index
      * @returns {Card | undefined}
@@ -906,28 +1164,19 @@ export class Document {
         }
     }
     /**
-     * **Revise** the richtext value at `addr` to `rt`, keeping each stored prose
-     * anchor whose id `rt` does not hold: the content twin of
-     * [`revise`](Document::revise), for a value built elsewhere such as a
-     * merge's projection. Diffs `rt` against the current value, carries those
-     * anchors through the diff, and returns the
-     * `Revised` receipt, whose `delta` an editor bridge maps its own positions
-     * through and whose `warnings` is empty. `rt`'s own anchors and island ids
-     * land as they are. An absent `addr.field` targets the body, an absent
-     * `addr.card` the main card; an absent field diffs from empty. Richtext
-     * only: a `text` field takes `overwrite`.
-     *
-     * Throws on an out-of-range card, a malformed field name, a present
-     * non-content field value, or an `rt` that is not a canonical content
-     * object.
+     * Write `content` over the value at `addr`, carrying each anchor it does
+     * not name where a diff keeps its text and reporting the rest in
+     * `droppedAnchors`. Throws as `apply`, and on a `content` that is not a
+     * `Content`.
      * @param {Addr | string} addr
-     * @param {Content} rt
-     * @returns {Revised}
+     * @param {Content} content
+     * @param {WriteOptions} [opts]
+     * @returns {Receipt}
      */
-    reviseContent(addr, rt) {
+    replace(addr, content, opts) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.document_reviseContent(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(rt));
+            wasm.document_replace(retptr, this.__wbg_ptr, addHeapObject(addr), addHeapObject(content), 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);
@@ -940,27 +1189,22 @@ export class Document {
         }
     }
     /**
-     * **Revise** the richtext value at `addr` from a markdown string: the
-     * default write path. Imports the markdown, diffs it against the current
-     * value, rebases surviving identity anchors, and returns the `Revised`
-     * receipt: the text `delta` an editor bridge maps its own positions through
-     * (`mapPos`), and a `parse::dropped_construct` warning per construct the
-     * import dropped, its `path` the address written. 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.
+     * Rewrite the value at `addr` as `markdown`: the anchors and islands
+     * whose `qm-*` tags it keeps (`annotated(addr)` spells them) stay put,
+     * and the rest keeps what a word-aligned diff keeps. Answers the
+     * `Receipt`, its `warnings` the import's. Throws as `apply`, and on an
+     * over-nested markdown input.
      * @param {Addr | string} addr
      * @param {string} markdown
-     * @returns {Revised}
+     * @param {WriteOptions} [opts]
+     * @returns {Receipt}
      */
-    revise(addr, markdown) {
+    revise(addr, markdown, opts) {
         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);
+            wasm.document_revise(retptr, this.__wbg_ptr, addHeapObject(addr), ptr0, len0, 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);
@@ -1070,7 +1314,7 @@ export class Document {
      * write is [`commitField`](Document::commit_field). A bare string is `Addr`
      * shorthand for `{ field }`; `{ card: 2, field: "qty" }` targets a
      * composable card. A body address throws:
-     * write a body with `revise` / `overwrite`. Throws on an out-of-range card
+     * write a body with `writer.reviseBody` / `replace`. Throws on an out-of-range card
      * or a malformed name.
      * @param {Addr | string} addr
      * @param {any} value
@@ -1088,28 +1332,6 @@ export class Document {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Store several fields verbatim and atomically on the card `addr` targets.
-     * `addr` is a **card address** (`{ card }`, absent = main) and comes first
-     * because `card` is itself a legal field name; a present `field` throws.
-     * Nothing is applied on error, and 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);
-        }
-    }
     /**
      * Merge a card-kind's seed `overlay` into the **main** card's `$seed` map
      * under `cardKind`, preserving sibling kinds; `$seed` is main-only, so this
@@ -1135,10 +1357,11 @@ export class Document {
     }
     /**
      * `toMarkdown` with each prose anchor of every body and content field
-     * spelled read-only at its start where its line can hold the tag, and
-     * listed with its field's path and line either way. An import drops every
-     * tag, so `writer.reviseDocument` with the markdown keeps the anchors it keeps
-     * with `toMarkdown`'s.
+     * spelled at its start where its line can hold the tag, every anchor,
+     * a cell's too, listed with its field's path and line, and each island whose markdown
+     * does not read back spelled as its token. `writer.reviseDocument` reads
+     * both back: a kept tag pins its anchor, and a token keeps its island as
+     * stored.
      * @returns {AnnotatedMarkdown}
      */
     toAnnotatedMarkdown() {
@@ -1206,7 +1429,8 @@ export class Document {
      * The non-fatal diagnostics of the load that produced this document: parse
      * warnings, plus `conform::*` warnings when it came through `quill.parse`.
      * Session state, not document value: `equals` and the storage DTO exclude
-     * it, and `fromStored` / `loadStored` / `writer.reviseDocument` clear it.
+     * it. `fromStored` sets it to the stored value's anchor id
+     * collisions, and `writer.reviseDocument` clears it.
      * @returns {Diagnostic[]}
      */
     get warnings() {
@@ -1555,26 +1779,6 @@ export class Quill {
         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) alone.
-     * @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);
-        }
-    }
     /**
      * `doc` as an authoring document: every field in the values form (each
      * content leaf its codec's text), every body as Markdown, each card
@@ -1684,6 +1888,55 @@ export class Quill {
 }
 if (Symbol.dispose) Quill.prototype[Symbol.dispose] = Quill.prototype.free;
 
+/**
+ * Deleting `[start, end)`: the splice, and where the range runs from a
+ * block's start into a later block, the `setBlock` giving the block that
+ * keeps the text the shape of the block the range ends in.
+ * @param {Content} content
+ * @param {number} start
+ * @param {number} end
+ * @returns {Change}
+ */
+export function deleteRange(content, start, end) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.deleteRange(retptr, addHeapObject(content), start, end);
+        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 change taking `before` to `after`, word-aligned, for a writer with no
+ * steps of its own. Throws `edit::content_apply` where `after` is not a
+ * valid value.
+ * @param {Content} before
+ * @param {Content} after
+ * @returns {Change}
+ */
+export function diff(before, after) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.diff(retptr, addHeapObject(before), addHeapObject(after));
+        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 canonical `Content` to its markdown projection. Throws if `rt` is not
  * canonical content.
@@ -1786,10 +2039,10 @@ export function formatDocPath(segs) {
 }
 
 /**
- * Import a markdown string: the pure, document-free codec. Returns the
+ * Import a markdown string: the markdown codec's import, pure and document-free. Returns the
  * canonical `content` and a `parse::dropped_construct` warning per construct
- * the import dropped, with no `path`. `overwrite(addr, importMarkdown(md).content)`
- * spells the cold, anchor-losing write; prefer `revise` for edit semantics.
+ * the import dropped, with no `path`. `replace(addr, importMarkdown(md).content)`
+ * spells the cold write; prefer `revise` for edit semantics.
  * Throws on an over-nested input.
  * @param {string} markdown
  * @returns {Imported}
@@ -1812,6 +2065,83 @@ export function importMarkdown(markdown) {
     }
 }
 
+/**
+ * Tab over the blocks `first` to `last` (`first` alone when absent): the
+ * change nesting their items under the item before them. Throws
+ * `edit::content_apply` where `first` is in no item, the range leaves its
+ * list, or its first item is the list's first.
+ * @param {Content} content
+ * @param {string} first
+ * @param {string | null} [last]
+ * @returns {Change}
+ */
+export function indent(content, first, last) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(first, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(last) ? 0 : passStringToWasm0(last, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len1 = WASM_VECTOR_LEN;
+        wasm.indent(retptr, addHeapObject(content), ptr0, len0, 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);
+    }
+}
+
+/**
+ * Typing at `at`: the formatting the typed text carries, for a splice's
+ * `marks`, in canonical order. Throws `edit::content_apply` where `at` is
+ * past the text.
+ * @param {Content} content
+ * @param {number} at
+ * @returns {ContentMarkKind[]}
+ */
+export function inheritedMarks(content, at) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.inheritedMarks(retptr, addHeapObject(content), at);
+        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 change that undoes `change` on `before`. Throws `edit::content_apply`
+ * where `change` does not apply to `before`.
+ * @param {Change} change
+ * @param {Content} before
+ * @returns {Change}
+ */
+export function invert(change, before) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.invert(retptr, addHeapObject(change), addHeapObject(before));
+        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);
+    }
+}
+
 /**
  * Whether `content` satisfies the one-line constraint of `text` and
  * `richtext`: one `Para` line, in no container, with no islands. Judged on
@@ -1861,26 +2191,19 @@ export function isPlain(content) {
 }
 
 /**
- * Where `bundle`'s text-moving channels (`delta`, then `islandOps`, then
- * `lineOps`) leave `content`'s marks: the final-text coordinates the bundle's
- * `markOps` are written in, under the rebase rule stated on `ChangeBundle`.
- * The document-free read an editor diffs against to decide which `markOps` to
- * emit, rather than reproducing that rule in its own language.
- *
- * `bundle.markOps` are ignored. The answer is normalized, as the store's is:
- * marks a text move drops (out of range, zero-width formatting) are absent,
- * and same-kind runs a move left adjacent arrive already unioned, so a bundle
- * carrying no `markOps` names the marks the field will hold.
- * Throws on a non-content `content`, a malformed bundle, or an op that applies
- * out of bounds: `applyChange`'s errors on the same ops.
+ * Backspace at the start of block `id`: the change joining it onto the block
+ * before it, under that block's record. Throws `edit::content_apply` for the
+ * first block or an id no block holds.
  * @param {Content} content
- * @param {ChangeBundle} bundle
- * @returns {ContentMark[]}
+ * @param {string} id
+ * @returns {Change}
  */
-export function mapMarks(content, bundle) {
+export function joinBlocks(content, id) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.mapMarks(retptr, addHeapObject(content), addHeapObject(bundle));
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.joinBlocks(retptr, addHeapObject(content), 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);
@@ -1894,39 +2217,35 @@ export function mapMarks(content, bundle) {
 }
 
 /**
- * Map a base content position (a USV index into `Content.text`, not a UTF-16
- * offset) through a `delta` to its new position, holding a caret stable across
- * a `revise`. `assoc` decides the side of a same-position insertion (`"after"`
- * moves past it). Throws on a malformed `delta`.
- *
- * This maps a position the *caller* holds. For the marks already in a field,
- * `mapMarks` applies the store's own assoc rule across every channel of a
- * `ChangeBundle`.
- * @param {Delta} delta
- * @param {number} pos
- * @param {Assoc} assoc
- * @returns {number}
+ * Where `pos` lands after `change`, and what around it the change deleted;
+ * `assoc` (`"after"` by default) picks the side of text inserted at it.
+ * Throws `edit::content_apply` where a splice deletes an island and names
+ * none in `removed`, as the receipt's `applied` always does.
+ * @param {Change} change
+ * @param {Pos} pos
+ * @param {"before" | "after"} [assoc]
+ * @returns {MapResult}
  */
-export function mapPos(delta, pos, assoc) {
+export function mapPos(change, pos, assoc) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.mapPos(retptr, addHeapObject(delta), pos, addHeapObject(assoc));
+        wasm.mapPos(retptr, addHeapObject(change), addHeapObject(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;
+        return takeObject(r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
- * The canonical form of `rt`: the content `overwrite` stores from it, read
+ * The canonical form of `rt`: the content `replace` stores from it, read
  * without a document. Normalizing rewrites structure, never the text, so the
- * answer's `text` is `rt.text`. Throws where `overwrite` would, with the same
+ * answer's `text` is `rt.text`. Throws where `replace` would, with the same
  * error under this verb's name.
  * @param {Content} rt
  * @returns {Content}
@@ -1947,6 +2266,36 @@ export function normalize(rt) {
     }
 }
 
+/**
+ * Shift-Tab over the blocks `first` to `last` (`first` alone when absent):
+ * the change lifting them out of the innermost item or quote holding
+ * `first`. Throws `edit::content_apply` where `first` is in neither or the
+ * range leaves it.
+ * @param {Content} content
+ * @param {string} first
+ * @param {string | null} [last]
+ * @returns {Change}
+ */
+export function outdent(content, first, last) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(first, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(last) ? 0 : passStringToWasm0(last, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len1 = WASM_VECTOR_LEN;
+        wasm.outdent(retptr, addHeapObject(content), ptr0, len0, 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);
+    }
+}
+
 /**
  * Parse a canonical document-model `Diagnostic.path` (`cards.<kind>[<i>].<field>`,
  * `main.body`, `recipients[0].name`) into structured `DocPathSeg` segments, so
@@ -1974,21 +2323,43 @@ export function parseDocPath(path) {
 }
 
 /**
- * Rebase `markdown` onto a `base` content: the document-free twin of `revise`,
- * returning the new `content`, the text `delta` (offsets are USV indices into
- * `Content.text`, surviving anchors rebased), and the import's
- * `parse::dropped_construct` warnings, with no `path`. Throws on an
- * over-nested markdown input or a non-content `base`.
- * @param {Content} base
- * @param {string} markdown
- * @returns {{ content: Content; delta: Delta; warnings: Diagnostic[] }}
+ * The valid value every peer holding the merged state `raw` reads, and what
+ * was mended to reach it: total and deterministic, every id it mints derived
+ * from the ids involved. Throws only on a `raw` not shaped as content.
+ * @param {RawContent} raw
+ * @returns {Repaired}
  */
-export function rebase(base, markdown) {
+export function repair(raw) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        wasm.repair(retptr, addHeapObject(raw));
+        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);
+    }
+}
+
+/**
+ * Enter at `at`: the change splitting the block holding `at` there, the new
+ * block `newId` and the text keeping its id. Throws `edit::content_apply`
+ * where `at` is past the text.
+ * @param {Content} content
+ * @param {number} at
+ * @param {string} newId
+ * @returns {Change}
+ */
+export function splitBlock(content, at, newId) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(newId, wasm.__wbindgen_export, wasm.__wbindgen_export2);
         const len0 = WASM_VECTOR_LEN;
-        wasm.rebase(retptr, addHeapObject(base), ptr0, len0);
+        wasm.splitBlock(retptr, addHeapObject(content), at, 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);
@@ -2009,6 +2380,36 @@ export function rebase(base, markdown) {
 export function start() {
     wasm.start();
 }
+
+/**
+ * The change wrapping the blocks `first` to `last` in a quote or a list,
+ * around the children of their innermost shared item or quote that the range
+ * touches; a list the range sits in is wrapped whole.
+ * @param {Content} content
+ * @param {string} first
+ * @param {string} last
+ * @param {WrapKind} kind
+ * @returns {Change}
+ */
+export function wrap(content, first, last, kind) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(first, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(last, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wrap(retptr, addHeapObject(content), ptr0, len0, ptr1, len1, addHeapObject(kind));
+        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);
+    }
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -2146,6 +2547,10 @@ function __wbg_get_imports() {
             const ret = Reflect.getPrototypeOf(getObject(arg0));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_get_31af05bd4842a84f: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_get_658f6698067d9515: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
@@ -2162,6 +2567,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0)[getObject(arg1)];
             return addHeapObject(ret);
         },
+        __wbg_has_5d6706e5209576c1: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.has(getObject(arg0), getObject(arg1));
+            return ret;
+        }, arguments); },
         __wbg_instanceof_ArrayBuffer_a99f175873e5d9b8: function(arg0) {
             let result;
             try {