@vector-im/matrix-wysiwyg 2.37.13 → 2.38.0

package/node_modules/@vector-im/matrix-wysiwyg-wasm/pkg/wysiwyg_bg.js

@@ -0,0 +1,1889 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
+
+let cachedTextEncoder = new lTextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8Memory0().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 = getUint8Memory0();
+
+    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 = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32Memory0;
+}
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
+
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+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;
+}
+/**
+*/
+export function start() {
+    wasm.start();
+}
+
+/**
+* @returns {ComposerModel}
+*/
+export function new_composer_model() {
+    const ret = wasm.composermodel_new();
+    return ComposerModel.__wrap(ret);
+}
+
+/**
+* @param {string} html
+* @param {number} start_utf16_codeunit
+* @param {number} end_utf16_codeunit
+* @returns {ComposerModel}
+*/
+export function new_composer_model_from_html(html, start_utf16_codeunit, end_utf16_codeunit) {
+    const ptr0 = passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.new_composer_model_from_html(ptr0, len0, start_utf16_codeunit, end_utf16_codeunit);
+    return ComposerModel.__wrap(ret);
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+    return instance.ptr;
+}
+function __wbg_adapter_121(arg0, arg1, arg2, arg3, arg4) {
+    wasm.wasm_bindgen__convert__closures__invoke3_mut__h755216c79df6c7d9(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
+}
+
+function __wbg_adapter_124(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__h5427b2b10c47063d(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+/**
+*/
+export const PatternKeyType = Object.freeze({ At:0,"0":"At",Hash:1,"1":"Hash",Slash:2,"2":"Slash",Custom:3,"3":"Custom", });
+/**
+*/
+export const DomCreationError = Object.freeze({ HtmlParseError:0,"0":"HtmlParseError",MarkdownParseError:1,"1":"MarkdownParseError", });
+/**
+*/
+export const ComposerAction = Object.freeze({ Bold:0,"0":"Bold",Italic:1,"1":"Italic",StrikeThrough:2,"2":"StrikeThrough",Underline:3,"3":"Underline",InlineCode:4,"4":"InlineCode",Link:5,"5":"Link",Undo:6,"6":"Undo",Redo:7,"7":"Redo",OrderedList:8,"8":"OrderedList",UnorderedList:9,"9":"UnorderedList",Indent:10,"10":"Indent",Unindent:11,"11":"Unindent",CodeBlock:12,"12":"CodeBlock",Quote:13,"13":"Quote", });
+/**
+*/
+export const ActionState = Object.freeze({
+/**
+* The button can be clicked, and will perform its normal action
+* e.g. make something bold
+*/
+Enabled:0,"0":"Enabled",
+/**
+* The button can be clicked, and will perform the reverse of its
+* normal action e.g. stop something being bold
+*/
+Reversed:1,"1":"Reversed",
+/**
+* The button cannot be clicked
+*/
+Disabled:2,"2":"Disabled", });
+
+const ComposerModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_composermodel_free(ptr >>> 0));
+/**
+*/
+export class ComposerModel {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ComposerModel.prototype);
+        obj.__wbg_ptr = ptr;
+        ComposerModelFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ComposerModelFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_composermodel_free(ptr);
+    }
+    /**
+    * @returns {ComposerModel}
+    */
+    static new() {
+        const ret = wasm.composermodel_new();
+        return ComposerModel.__wrap(ret);
+    }
+    /**
+    * @param {string} text
+    * @returns {ComposerModel}
+    */
+    static from_example_format(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composermodel_from_example_format(ptr0, len0);
+        return ComposerModel.__wrap(ret);
+    }
+    /**
+    * @returns {string}
+    */
+    to_example_format() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.composermodel_to_example_format(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get_content_as_html() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.composermodel_get_content_as_html(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get_content_as_message_html() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.composermodel_get_content_as_message_html(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get_content_as_markdown() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.composermodel_get_content_as_markdown(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get_content_as_message_markdown() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.composermodel_get_content_as_message_markdown(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get_content_as_plain_text() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.composermodel_get_content_as_plain_text(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @returns {DomHandle}
+    */
+    document() {
+        const ret = wasm.composermodel_document(this.__wbg_ptr);
+        return DomHandle.__wrap(ret);
+    }
+    /**
+    * @returns {Map<any, any>}
+    */
+    action_states() {
+        const ret = wasm.composermodel_action_states(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @param {number} start_utf16_codeunit
+    * @param {number} end_utf16_codeunit
+    * @returns {ComposerUpdate}
+    */
+    select(start_utf16_codeunit, end_utf16_codeunit) {
+        const ret = wasm.composermodel_select(this.__wbg_ptr, start_utf16_codeunit, end_utf16_codeunit);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {number}
+    */
+    selection_start() {
+        const ret = wasm.composermodel_selection_start(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @returns {number}
+    */
+    selection_end() {
+        const ret = wasm.composermodel_selection_end(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {string} new_text
+    * @returns {ComposerUpdate}
+    */
+    replace_text(new_text) {
+        const ptr0 = passStringToWasm0(new_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composermodel_replace_text(this.__wbg_ptr, ptr0, len0);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @param {string} new_text
+    * @param {SuggestionPattern} suggestion
+    * @param {boolean} append_space
+    * @returns {ComposerUpdate}
+    */
+    replace_text_suggestion(new_text, suggestion, append_space) {
+        const ptr0 = passStringToWasm0(new_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(suggestion, SuggestionPattern);
+        const ret = wasm.composermodel_replace_text_suggestion(this.__wbg_ptr, ptr0, len0, suggestion.__wbg_ptr, append_space);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @param {string} text
+    * @returns {ComposerUpdate}
+    */
+    set_content_from_html(text) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.composermodel_set_content_from_html(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return ComposerUpdate.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {string} text
+    * @returns {ComposerUpdate}
+    */
+    set_content_from_markdown(text) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.composermodel_set_content_from_markdown(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return ComposerUpdate.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    clear() {
+        const ret = wasm.composermodel_clear(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    enter() {
+        const ret = wasm.composermodel_enter(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    backspace() {
+        const ret = wasm.composermodel_backspace(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    backspace_word() {
+        const ret = wasm.composermodel_backspace_word(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    delete() {
+        const ret = wasm.composermodel_delete(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    delete_word() {
+        const ret = wasm.composermodel_delete_word(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    bold() {
+        const ret = wasm.composermodel_bold(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    italic() {
+        const ret = wasm.composermodel_italic(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    strike_through() {
+        const ret = wasm.composermodel_strike_through(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    underline() {
+        const ret = wasm.composermodel_underline(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    quote() {
+        const ret = wasm.composermodel_quote(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    inline_code() {
+        const ret = wasm.composermodel_inline_code(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    code_block() {
+        const ret = wasm.composermodel_code_block(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    undo() {
+        const ret = wasm.composermodel_undo(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    redo() {
+        const ret = wasm.composermodel_redo(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    ordered_list() {
+        const ret = wasm.composermodel_ordered_list(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    unordered_list() {
+        const ret = wasm.composermodel_unordered_list(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    indent() {
+        const ret = wasm.composermodel_indent(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    unindent() {
+        const ret = wasm.composermodel_unindent(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {LinkAction}
+    */
+    get_link_action() {
+        const ret = wasm.composermodel_get_link_action(this.__wbg_ptr);
+        return LinkAction.__wrap(ret);
+    }
+    /**
+    * @param {string} url
+    * @param {Map<any, any>} attributes
+    * @returns {ComposerUpdate}
+    */
+    set_link(url, attributes) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composermodel_set_link(this.__wbg_ptr, ptr0, len0, addHeapObject(attributes));
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @param {string} url
+    * @param {string} text
+    * @param {Map<any, any>} attributes
+    * @returns {ComposerUpdate}
+    */
+    set_link_with_text(url, text, attributes) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.composermodel_set_link_with_text(this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(attributes));
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @param {Array<any>} custom_suggestion_patterns
+    */
+    set_custom_suggestion_patterns(custom_suggestion_patterns) {
+        wasm.composermodel_set_custom_suggestion_patterns(this.__wbg_ptr, addHeapObject(custom_suggestion_patterns));
+    }
+    /**
+    * Creates an at-room mention node and inserts it into the composer at the current selection
+    * @param {Map<any, any>} attributes
+    * @returns {ComposerUpdate}
+    */
+    insert_at_room_mention(attributes) {
+        const ret = wasm.composermodel_insert_at_room_mention(this.__wbg_ptr, addHeapObject(attributes));
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * Creates a mention node and inserts it into the composer at the current selection
+    * @param {string} url
+    * @param {string} text
+    * @param {Map<any, any>} attributes
+    * @returns {ComposerUpdate}
+    */
+    insert_mention(url, text, attributes) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.composermodel_insert_mention(this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(attributes));
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * Creates an at-room mention node and inserts it into the composer, replacing the
+    * text content defined by the suggestion
+    * @param {SuggestionPattern} suggestion
+    * @param {Map<any, any>} attributes
+    * @returns {ComposerUpdate}
+    */
+    insert_at_room_mention_at_suggestion(suggestion, attributes) {
+        _assertClass(suggestion, SuggestionPattern);
+        const ret = wasm.composermodel_insert_at_room_mention_at_suggestion(this.__wbg_ptr, suggestion.__wbg_ptr, addHeapObject(attributes));
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * Creates a mention node and inserts it into the composer, replacing the
+    * text content defined by the suggestion
+    * @param {string} url
+    * @param {string} text
+    * @param {SuggestionPattern} suggestion
+    * @param {Map<any, any>} attributes
+    * @returns {ComposerUpdate}
+    */
+    insert_mention_at_suggestion(url, text, suggestion, attributes) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        _assertClass(suggestion, SuggestionPattern);
+        const ret = wasm.composermodel_insert_mention_at_suggestion(this.__wbg_ptr, ptr0, len0, ptr1, len1, suggestion.__wbg_ptr, addHeapObject(attributes));
+        return ComposerUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {ComposerUpdate}
+    */
+    remove_links() {
+        const ret = wasm.composermodel_remove_links(this.__wbg_ptr);
+        return ComposerUpdate.__wrap(ret);
+    }
+}
+
+const ComposerUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_composerupdate_free(ptr >>> 0));
+/**
+*/
+export class ComposerUpdate {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ComposerUpdate.prototype);
+        obj.__wbg_ptr = ptr;
+        ComposerUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ComposerUpdateFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_composerupdate_free(ptr);
+    }
+    /**
+    * @returns {TextUpdate}
+    */
+    text_update() {
+        const ret = wasm.composerupdate_text_update(this.__wbg_ptr);
+        return TextUpdate.__wrap(ret);
+    }
+    /**
+    * @returns {MenuState}
+    */
+    menu_state() {
+        const ret = wasm.composerupdate_menu_state(this.__wbg_ptr);
+        return MenuState.__wrap(ret);
+    }
+    /**
+    * @returns {MenuAction}
+    */
+    menu_action() {
+        const ret = wasm.composerupdate_menu_action(this.__wbg_ptr);
+        return MenuAction.__wrap(ret);
+    }
+}
+
+const CreateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_create_free(ptr >>> 0));
+/**
+*/
+export class Create {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Create.prototype);
+        obj.__wbg_ptr = ptr;
+        CreateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CreateFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_create_free(ptr);
+    }
+}
+
+const CreateWithTextFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_createwithtext_free(ptr >>> 0));
+/**
+*/
+export class CreateWithText {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CreateWithText.prototype);
+        obj.__wbg_ptr = ptr;
+        CreateWithTextFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CreateWithTextFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_createwithtext_free(ptr);
+    }
+}
+
+const DisabledFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_disabled_free(ptr >>> 0));
+/**
+*/
+export class Disabled {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Disabled.prototype);
+        obj.__wbg_ptr = ptr;
+        DisabledFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DisabledFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_disabled_free(ptr);
+    }
+}
+
+const DomChildrenFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_domchildren_free(ptr >>> 0));
+/**
+* An iterator-like view of a DomHandle's children, written to work around
+* the lack of support for returning Vec<T> in wasm_bindgen.
+*/
+export class DomChildren {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DomChildren.prototype);
+        obj.__wbg_ptr = ptr;
+        DomChildrenFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DomChildrenFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_domchildren_free(ptr);
+    }
+    /**
+    * @returns {DomHandle | undefined}
+    */
+    next_child() {
+        const ret = wasm.domchildren_next_child(this.__wbg_ptr);
+        return ret === 0 ? undefined : DomHandle.__wrap(ret);
+    }
+}
+
+const DomHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_domhandle_free(ptr >>> 0));
+/**
+* Refers to a node in the composer model.
+*/
+export class DomHandle {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DomHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        DomHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DomHandleFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_domhandle_free(ptr);
+    }
+    /**
+    * Returns "container", "line_break", "text" or "zwsp" depending on the type of
+    * node we refer to.
+    * Panics if we are not a valid reference (because the model has changed
+    * since we were created, or because you passed in a different model
+    * from the one that created us.)
+    * @param {ComposerModel} model
+    * @returns {string}
+    */
+    node_type(model) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(model, ComposerModel);
+            wasm.domhandle_node_type(retptr, this.__wbg_ptr, model.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Returns a list of our children nodes, or an empty list if we refer
+    * to a text or line break node.
+    * Panics if we are not a valid reference (because the model has changed
+    * since we were created, or because you passed in a different model
+    * from the one that created us.)
+    * @param {ComposerModel} model
+    * @returns {DomChildren}
+    */
+    children(model) {
+        _assertClass(model, ComposerModel);
+        const ret = wasm.domhandle_children(this.__wbg_ptr, model.__wbg_ptr);
+        return DomChildren.__wrap(ret);
+    }
+    /**
+    * Returns the text of this node, or an empty string if this is a
+    * container or line break.
+    * Panics if we are not a valid reference (because the model has changed
+    * since we were created, or because you passed in a different model
+    * from the one that created us.)
+    * @param {ComposerModel} model
+    * @returns {string}
+    */
+    text(model) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(model, ComposerModel);
+            wasm.domhandle_text(retptr, this.__wbg_ptr, model.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Returns our tagname, or "-text-"/"-zwsp-" if we are a text/zwsp node.
+    * Panics if we are not a valid reference (because the model has changed
+    * since we were created, or because you passed in a different model
+    * from the one that created us.)
+    * @param {ComposerModel} model
+    * @returns {string}
+    */
+    tag(model) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(model, ComposerModel);
+            wasm.domhandle_tag(retptr, this.__wbg_ptr, model.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const EditFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_edit_free(ptr >>> 0));
+/**
+*/
+export class Edit {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Edit.prototype);
+        obj.__wbg_ptr = ptr;
+        EditFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EditFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_edit_free(ptr);
+    }
+    /**
+    * @returns {string}
+    */
+    get url() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_edit_url(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @param {string} arg0
+    */
+    set url(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_edit_url(this.__wbg_ptr, ptr0, len0);
+    }
+}
+
+const KeepFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_keep_free(ptr >>> 0));
+/**
+*/
+export class Keep {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Keep.prototype);
+        obj.__wbg_ptr = ptr;
+        KeepFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KeepFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_keep_free(ptr);
+    }
+}
+
+const LinkActionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_linkaction_free(ptr >>> 0));
+/**
+*/
+export class LinkAction {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(LinkAction.prototype);
+        obj.__wbg_ptr = ptr;
+        LinkActionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LinkActionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_linkaction_free(ptr);
+    }
+    /**
+    * @returns {CreateWithText | undefined}
+    */
+    get create_with_text() {
+        const ret = wasm.__wbg_get_linkaction_create_with_text(this.__wbg_ptr);
+        return ret === 0 ? undefined : CreateWithText.__wrap(ret);
+    }
+    /**
+    * @param {CreateWithText | undefined} [arg0]
+    */
+    set create_with_text(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, CreateWithText);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_linkaction_create_with_text(this.__wbg_ptr, ptr0);
+    }
+    /**
+    * @returns {Create | undefined}
+    */
+    get create() {
+        const ret = wasm.__wbg_get_linkaction_create(this.__wbg_ptr);
+        return ret === 0 ? undefined : Create.__wrap(ret);
+    }
+    /**
+    * @param {Create | undefined} [arg0]
+    */
+    set create(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Create);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_linkaction_create(this.__wbg_ptr, ptr0);
+    }
+    /**
+    * @returns {Edit | undefined}
+    */
+    get edit_link() {
+        const ret = wasm.__wbg_get_linkaction_edit_link(this.__wbg_ptr);
+        return ret === 0 ? undefined : Edit.__wrap(ret);
+    }
+    /**
+    * @param {Edit | undefined} [arg0]
+    */
+    set edit_link(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Edit);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_linkaction_edit_link(this.__wbg_ptr, ptr0);
+    }
+    /**
+    * @returns {Disabled | undefined}
+    */
+    get disabled() {
+        const ret = wasm.__wbg_get_linkaction_disabled(this.__wbg_ptr);
+        return ret === 0 ? undefined : Disabled.__wrap(ret);
+    }
+    /**
+    * @param {Disabled | undefined} [arg0]
+    */
+    set disabled(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Disabled);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_linkaction_disabled(this.__wbg_ptr, ptr0);
+    }
+}
+
+const MenuActionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_menuaction_free(ptr >>> 0));
+/**
+*/
+export class MenuAction {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MenuAction.prototype);
+        obj.__wbg_ptr = ptr;
+        MenuActionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MenuActionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_menuaction_free(ptr);
+    }
+    /**
+    * @returns {boolean}
+    */
+    keep() {
+        const ret = wasm.menuaction_keep(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * @returns {boolean}
+    */
+    none() {
+        const ret = wasm.menuaction_none(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * @returns {MenuActionSuggestion | undefined}
+    */
+    suggestion() {
+        const ret = wasm.menuaction_suggestion(this.__wbg_ptr);
+        return ret === 0 ? undefined : MenuActionSuggestion.__wrap(ret);
+    }
+}
+
+const MenuActionSuggestionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_menuactionsuggestion_free(ptr >>> 0));
+/**
+*/
+export class MenuActionSuggestion {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MenuActionSuggestion.prototype);
+        obj.__wbg_ptr = ptr;
+        MenuActionSuggestionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MenuActionSuggestionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_menuactionsuggestion_free(ptr);
+    }
+    /**
+    * @returns {SuggestionPattern}
+    */
+    get suggestion_pattern() {
+        const ret = wasm.__wbg_get_menuactionsuggestion_suggestion_pattern(this.__wbg_ptr);
+        return SuggestionPattern.__wrap(ret);
+    }
+    /**
+    * @param {SuggestionPattern} arg0
+    */
+    set suggestion_pattern(arg0) {
+        _assertClass(arg0, SuggestionPattern);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_menuactionsuggestion_suggestion_pattern(this.__wbg_ptr, ptr0);
+    }
+}
+
+const MenuStateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_menustate_free(ptr >>> 0));
+/**
+*/
+export class MenuState {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MenuState.prototype);
+        obj.__wbg_ptr = ptr;
+        MenuStateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MenuStateFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_menustate_free(ptr);
+    }
+    /**
+    * @returns {boolean}
+    */
+    keep() {
+        const ret = wasm.menustate_keep(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * @returns {MenuStateUpdate | undefined}
+    */
+    update() {
+        const ret = wasm.menustate_update(this.__wbg_ptr);
+        return ret === 0 ? undefined : MenuStateUpdate.__wrap(ret);
+    }
+}
+
+const MenuStateUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_menustateupdate_free(ptr >>> 0));
+/**
+*/
+export class MenuStateUpdate {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MenuStateUpdate.prototype);
+        obj.__wbg_ptr = ptr;
+        MenuStateUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MenuStateUpdateFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_menustateupdate_free(ptr);
+    }
+    /**
+    * @returns {Map<any, any>}
+    */
+    get action_states() {
+        const ret = wasm.__wbg_get_menustateupdate_action_states(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @param {Map<any, any>} arg0
+    */
+    set action_states(arg0) {
+        wasm.__wbg_set_menustateupdate_action_states(this.__wbg_ptr, addHeapObject(arg0));
+    }
+}
+
+const PatternKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_patternkey_free(ptr >>> 0));
+/**
+*/
+export class PatternKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PatternKey.prototype);
+        obj.__wbg_ptr = ptr;
+        PatternKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PatternKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_patternkey_free(ptr);
+    }
+    /**
+    * @returns {PatternKeyType}
+    */
+    get key_type() {
+        const ret = wasm.__wbg_get_patternkey_key_type(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+    * @param {PatternKeyType} arg0
+    */
+    set key_type(arg0) {
+        wasm.__wbg_set_patternkey_key_type(this.__wbg_ptr, arg0);
+    }
+    /**
+    * @returns {string | undefined}
+    */
+    get custom_key_value() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_patternkey_custom_key_value(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_free(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {string | undefined} [arg0]
+    */
+    set custom_key_value(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_patternkey_custom_key_value(this.__wbg_ptr, ptr0, len0);
+    }
+}
+
+const ReplaceAllFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_replaceall_free(ptr >>> 0));
+/**
+*/
+export class ReplaceAll {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ReplaceAll.prototype);
+        obj.__wbg_ptr = ptr;
+        ReplaceAllFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ReplaceAllFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_replaceall_free(ptr);
+    }
+    /**
+    * @returns {string}
+    */
+    get replacement_html() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_edit_url(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @param {string} arg0
+    */
+    set replacement_html(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_edit_url(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+    * @returns {number}
+    */
+    get start_utf16_codeunit() {
+        const ret = wasm.__wbg_get_replaceall_start_utf16_codeunit(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set start_utf16_codeunit(arg0) {
+        wasm.__wbg_set_replaceall_start_utf16_codeunit(this.__wbg_ptr, arg0);
+    }
+    /**
+    * @returns {number}
+    */
+    get end_utf16_codeunit() {
+        const ret = wasm.__wbg_get_replaceall_end_utf16_codeunit(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set end_utf16_codeunit(arg0) {
+        wasm.__wbg_set_replaceall_end_utf16_codeunit(this.__wbg_ptr, arg0);
+    }
+}
+
+const SelectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_selection_free(ptr >>> 0));
+/**
+*/
+export class Selection {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Selection.prototype);
+        obj.__wbg_ptr = ptr;
+        SelectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SelectionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_selection_free(ptr);
+    }
+    /**
+    * @returns {number}
+    */
+    get start_utf16_codeunit() {
+        const ret = wasm.__wbg_get_selection_start_utf16_codeunit(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set start_utf16_codeunit(arg0) {
+        wasm.__wbg_set_selection_start_utf16_codeunit(this.__wbg_ptr, arg0);
+    }
+    /**
+    * @returns {number}
+    */
+    get end_utf16_codeunit() {
+        const ret = wasm.__wbg_get_selection_end_utf16_codeunit(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set end_utf16_codeunit(arg0) {
+        wasm.__wbg_set_selection_end_utf16_codeunit(this.__wbg_ptr, arg0);
+    }
+}
+
+const SuggestionPatternFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_suggestionpattern_free(ptr >>> 0));
+/**
+*/
+export class SuggestionPattern {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SuggestionPattern.prototype);
+        obj.__wbg_ptr = ptr;
+        SuggestionPatternFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SuggestionPatternFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_suggestionpattern_free(ptr);
+    }
+    /**
+    * @returns {PatternKey}
+    */
+    get key() {
+        const ret = wasm.__wbg_get_suggestionpattern_key(this.__wbg_ptr);
+        return PatternKey.__wrap(ret);
+    }
+    /**
+    * @param {PatternKey} arg0
+    */
+    set key(arg0) {
+        _assertClass(arg0, PatternKey);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_suggestionpattern_key(this.__wbg_ptr, ptr0);
+    }
+    /**
+    * @returns {string}
+    */
+    get text() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_edit_url(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * @param {string} arg0
+    */
+    set text(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_edit_url(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+    * @returns {number}
+    */
+    get start() {
+        const ret = wasm.__wbg_get_suggestionpattern_start(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set start(arg0) {
+        wasm.__wbg_set_suggestionpattern_start(this.__wbg_ptr, arg0);
+    }
+    /**
+    * @returns {number}
+    */
+    get end() {
+        const ret = wasm.__wbg_get_suggestionpattern_end(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set end(arg0) {
+        wasm.__wbg_set_suggestionpattern_end(this.__wbg_ptr, arg0);
+    }
+}
+
+const TextUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_textupdate_free(ptr >>> 0));
+/**
+*/
+export class TextUpdate {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TextUpdate.prototype);
+        obj.__wbg_ptr = ptr;
+        TextUpdateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TextUpdateFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_textupdate_free(ptr);
+    }
+    /**
+    * @returns {Keep | undefined}
+    */
+    get keep() {
+        const ret = wasm.__wbg_get_textupdate_keep(this.__wbg_ptr);
+        return ret === 0 ? undefined : Keep.__wrap(ret);
+    }
+    /**
+    * @param {Keep | undefined} [arg0]
+    */
+    set keep(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Keep);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_textupdate_keep(this.__wbg_ptr, ptr0);
+    }
+    /**
+    * @returns {ReplaceAll | undefined}
+    */
+    get replace_all() {
+        const ret = wasm.__wbg_get_textupdate_replace_all(this.__wbg_ptr);
+        return ret === 0 ? undefined : ReplaceAll.__wrap(ret);
+    }
+    /**
+    * @param {ReplaceAll | undefined} [arg0]
+    */
+    set replace_all(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, ReplaceAll);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_textupdate_replace_all(this.__wbg_ptr, ptr0);
+    }
+    /**
+    * @returns {Selection | undefined}
+    */
+    get select() {
+        const ret = wasm.__wbg_get_textupdate_select(this.__wbg_ptr);
+        return ret === 0 ? undefined : Selection.__wrap(ret);
+    }
+    /**
+    * @param {Selection | undefined} [arg0]
+    */
+    set select(arg0) {
+        let ptr0 = 0;
+        if (!isLikeNone(arg0)) {
+            _assertClass(arg0, Selection);
+            ptr0 = arg0.__destroy_into_raw();
+        }
+        wasm.__wbg_set_textupdate_select(this.__wbg_ptr, ptr0);
+    }
+}
+
+export function __wbindgen_string_get(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+
+export function __wbg_new_d9bc3a0147634640() {
+    const ret = new Map();
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_string_new(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+export function __wbg_set_8417257aaedc936b(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+};
+
+export function __wbg_forEach_4cee849ec749be17(arg0, arg1, arg2) {
+    try {
+        var state0 = {a: arg1, b: arg2};
+        var cb0 = (arg0, arg1) => {
+            const a = state0.a;
+            state0.a = 0;
+            try {
+                return __wbg_adapter_124(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        getObject(arg0).forEach(cb0);
+    } finally {
+        state0.a = state0.b = 0;
+    }
+};
+
+export function __wbindgen_number_new(arg0) {
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+export function __wbg_forEach_2be8de7347d63332(arg0, arg1, arg2) {
+    try {
+        var state0 = {a: arg1, b: arg2};
+        var cb0 = (arg0, arg1, arg2) => {
+            const a = state0.a;
+            state0.a = 0;
+            try {
+                return __wbg_adapter_121(a, state0.b, arg0, arg1, arg2);
+            } finally {
+                state0.a = a;
+            }
+        };
+        getObject(arg0).forEach(cb0);
+    } finally {
+        state0.a = state0.b = 0;
+    }
+};
+
+export function __wbindgen_object_clone_ref(arg0) {
+    const ret = getObject(arg0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_abda76e883ba8a5f() {
+    const ret = new Error();
+    return addHeapObject(ret);
+};
+
+export function __wbg_stack_658279fe44541cf6(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+};
+
+export function __wbindgen_throw(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg_getAttribute_99bddb29274b29b9(arg0, arg1, arg2, arg3) {
+    const ret = getObject(arg1).getAttribute(getStringFromWasm0(arg2, arg3));
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+export function __wbg_nodeValue_0b5f7b2274265747(arg0, arg1) {
+    const ret = getObject(arg1).nodeValue;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+export function __wbg_new_aec969a21ad2fc71() { return handleError(function () {
+    const ret = new DOMParser();
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_parseFromString_656e5773ad0b3845() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = getObject(arg0).parseFromString(getStringFromWasm0(arg1, arg2), takeObject(arg3));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_body_edb1908d3ceff3a1(arg0) {
+    const ret = getObject(arg0).body;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_childNodes_118168e8b23bcb9b(arg0) {
+    const ret = getObject(arg0).childNodes;
+    return addHeapObject(ret);
+};
+
+export function __wbg_length_d0a802565d17eec4(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+};
+
+export function __wbg_get_8cd5eba00ab6304f(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_nodeName_149f7e29f80d1338(arg0, arg1) {
+    const ret = getObject(arg1).nodeName;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getInt32Memory0()[arg0 / 4 + 1] = len1;
+    getInt32Memory0()[arg0 / 4 + 0] = ptr1;
+};
+
+export function __wbg_hasAttribute_8340e1a2a46f10f3(arg0, arg1, arg2) {
+    const ret = getObject(arg0).hasAttribute(getStringFromWasm0(arg1, arg2));
+    return ret;
+};
+
+export function __wbg_nodeType_9dd609af1b555b54(arg0) {
+    const ret = getObject(arg0).nodeType;
+    return ret;
+};
+