@vector-im/matrix-wysiwyg 2.38.2 → 2.38.4

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

@@ -4,23 +4,38 @@ export function __wbg_set_wasm(val) {
 }
 
 
-const heap = new Array(128).fill(undefined);
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
 
-heap.push(undefined, null, true, false);
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_1.set(idx, obj);
+    return idx;
+}
 
-function getObject(idx) { return heap[idx]; }
+const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
 
-let WASM_VECTOR_LEN = 0;
+let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
 
-let cachedUint8Memory0 = null;
+let cachedUint8ArrayMemory0 = null;
 
-function getUint8Memory0() {
-    if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
-        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
     }
-    return cachedUint8Memory0;
+    return cachedUint8ArrayMemory0;
 }
 
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+let WASM_VECTOR_LEN = 0;
+
 const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
 
 let cachedTextEncoder = new lTextEncoder('utf-8');
@@ -43,7 +58,7 @@ 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);
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
         WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
@@ -51,7 +66,7 @@ function passStringToWasm0(arg, malloc, realloc) {
     let len = arg.length;
     let ptr = malloc(len, 1) >>> 0;
 
-    const mem = getUint8Memory0();
+    const mem = getUint8ArrayMemory0();
 
     let offset = 0;
 
@@ -66,7 +81,7 @@ function passStringToWasm0(arg, malloc, realloc) {
             arg = arg.slice(offset);
         }
         ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
         const ret = encodeString(arg, view);
 
         offset += ret.written;
@@ -77,72 +92,42 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-let cachedInt32Memory0 = null;
+let cachedDataViewMemory0 = null;
 
-function getInt32Memory0() {
-    if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
-        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
     }
-    return 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;
+    return cachedDataViewMemory0;
 }
 
-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 handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
 }
 
-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}
-*/
+ * @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}
-*/
+ * @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;
@@ -154,55 +139,82 @@ 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 takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_1.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+function __wbg_adapter_123(arg0, arg1, arg2, arg3, arg4) {
+    wasm.closure98_externref_shim(arg0, arg1, arg2, arg3, arg4);
 }
 
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_exn_store(addHeapObject(e));
-    }
+function __wbg_adapter_126(arg0, arg1, arg2, arg3) {
+    wasm.closure101_externref_shim(arg0, arg1, arg2, arg3);
 }
+
 /**
-*/
-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", });
-/**
-*/
+ * @enum {0 | 1 | 2}
+ */
 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",
+});
 /**
-* The button can be clicked, and will perform its normal action
-* e.g. make something bold
-*/
-Enabled:0,"0":"Enabled",
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13}
+ */
+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",
+});
 /**
-* The button can be clicked, and will perform the reverse of its
-* normal action e.g. stop something being bold
-*/
-Reversed:1,"1":"Reversed",
+ * @enum {0 | 1}
+ */
+export const DomCreationError = Object.freeze({
+    HtmlParseError: 0, "0": "HtmlParseError",
+    MarkdownParseError: 1, "1": "MarkdownParseError",
+});
 /**
-* The button cannot be clicked
-*/
-Disabled:2,"2":"Disabled", });
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const PatternKeyType = Object.freeze({
+    At: 0, "0": "At",
+    Hash: 1, "1": "Hash",
+    Slash: 2, "2": "Slash",
+    Custom: 3, "3": "Custom",
+});
+
+const __wbindgen_enum_SupportedType = ["text/html", "text/xml", "application/xml", "application/xhtml+xml", "image/svg+xml"];
 
 const ComposerModelFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_composermodel_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_composermodel_free(ptr >>> 0, 1));
+
 export class ComposerModel {
 
     static __wrap(ptr) {
@@ -222,19 +234,19 @@ export class ComposerModel {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_composermodel_free(ptr);
+        wasm.__wbg_composermodel_free(ptr, 0);
     }
     /**
-    * @returns {ComposerModel}
-    */
+     * @returns {ComposerModel}
+     */
     static new() {
         const ret = wasm.composermodel_new();
         return ComposerModel.__wrap(ret);
     }
     /**
-    * @param {string} text
-    * @returns {ComposerModel}
-    */
+     * @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;
@@ -242,160 +254,136 @@ export class ComposerModel {
         return ComposerModel.__wrap(ret);
     }
     /**
-    * @returns {string}
-    */
+     * @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);
+            const ret = wasm.composermodel_to_example_format(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @returns {string}
-    */
+     * @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);
+            const ret = wasm.composermodel_get_content_as_html(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @returns {string}
-    */
+     * @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);
+            const ret = wasm.composermodel_get_content_as_message_html(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @returns {string}
-    */
+     * @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);
+            const ret = wasm.composermodel_get_content_as_markdown(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @returns {string}
-    */
+     * @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);
+            const ret = wasm.composermodel_get_content_as_message_markdown(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @returns {string}
-    */
+     * @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);
+            const ret = wasm.composermodel_get_content_as_plain_text(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @returns {DomHandle}
-    */
+     * @returns {DomHandle}
+     */
     document() {
         const ret = wasm.composermodel_document(this.__wbg_ptr);
         return DomHandle.__wrap(ret);
     }
     /**
-    * @returns {Map<any, any>}
-    */
+     * @returns {Map<any, any>}
+     */
     action_states() {
         const ret = wasm.composermodel_action_states(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
-    * @param {number} start_utf16_codeunit
-    * @param {number} end_utf16_codeunit
-    * @returns {ComposerUpdate}
-    */
+     * @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}
-    */
+     * @returns {number}
+     */
     selection_start() {
         const ret = wasm.composermodel_selection_start(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-    * @returns {number}
-    */
+     * @returns {number}
+     */
     selection_end() {
         const ret = wasm.composermodel_selection_end(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-    * @param {string} new_text
-    * @returns {ComposerUpdate}
-    */
+     * @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;
@@ -403,11 +391,11 @@ export class ComposerModel {
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @param {string} new_text
-    * @param {SuggestionPattern} suggestion
-    * @param {boolean} append_space
-    * @returns {ComposerUpdate}
-    */
+     * @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;
@@ -416,275 +404,259 @@ export class ComposerModel {
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @param {string} text
-    * @returns {ComposerUpdate}
-    */
+     * @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);
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composermodel_set_content_from_html(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return ComposerUpdate.__wrap(ret[0]);
     }
     /**
-    * @param {string} text
-    * @returns {ComposerUpdate}
-    */
+     * @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);
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.composermodel_set_content_from_markdown(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
         }
+        return ComposerUpdate.__wrap(ret[0]);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     clear() {
         const ret = wasm.composermodel_clear(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     enter() {
         const ret = wasm.composermodel_enter(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     backspace() {
         const ret = wasm.composermodel_backspace(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     backspace_word() {
         const ret = wasm.composermodel_backspace_word(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     delete() {
         const ret = wasm.composermodel_delete(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     delete_word() {
         const ret = wasm.composermodel_delete_word(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     bold() {
         const ret = wasm.composermodel_bold(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     italic() {
         const ret = wasm.composermodel_italic(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     strike_through() {
         const ret = wasm.composermodel_strike_through(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     underline() {
         const ret = wasm.composermodel_underline(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     quote() {
         const ret = wasm.composermodel_quote(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     inline_code() {
         const ret = wasm.composermodel_inline_code(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     code_block() {
         const ret = wasm.composermodel_code_block(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     undo() {
         const ret = wasm.composermodel_undo(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     redo() {
         const ret = wasm.composermodel_redo(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     ordered_list() {
         const ret = wasm.composermodel_ordered_list(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     unordered_list() {
         const ret = wasm.composermodel_unordered_list(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     indent() {
         const ret = wasm.composermodel_indent(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     unindent() {
         const ret = wasm.composermodel_unindent(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {LinkAction}
-    */
+     * @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}
-    */
+     * @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));
+        const ret = wasm.composermodel_set_link(this.__wbg_ptr, ptr0, len0, attributes);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @param {string} url
-    * @param {string} text
-    * @param {Map<any, any>} attributes
-    * @returns {ComposerUpdate}
-    */
+     * @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));
+        const ret = wasm.composermodel_set_link_with_text(this.__wbg_ptr, ptr0, len0, ptr1, len1, attributes);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @param {Array<any>} custom_suggestion_patterns
-    */
+     * @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));
+        wasm.composermodel_set_custom_suggestion_patterns(this.__wbg_ptr, 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}
-    */
+     * 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));
+        const ret = wasm.composermodel_insert_at_room_mention(this.__wbg_ptr, 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}
-    */
+     * 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));
+        const ret = wasm.composermodel_insert_mention(this.__wbg_ptr, ptr0, len0, ptr1, len1, 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}
-    */
+     * 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));
+        const ret = wasm.composermodel_insert_at_room_mention_at_suggestion(this.__wbg_ptr, suggestion.__wbg_ptr, 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}
-    */
+     * 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));
+        const ret = wasm.composermodel_insert_mention_at_suggestion(this.__wbg_ptr, ptr0, len0, ptr1, len1, suggestion.__wbg_ptr, attributes);
         return ComposerUpdate.__wrap(ret);
     }
     /**
-    * @returns {ComposerUpdate}
-    */
+     * @returns {ComposerUpdate}
+     */
     remove_links() {
         const ret = wasm.composermodel_remove_links(this.__wbg_ptr);
         return ComposerUpdate.__wrap(ret);
@@ -693,9 +665,8 @@ export class ComposerModel {
 
 const ComposerUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_composerupdate_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_composerupdate_free(ptr >>> 0, 1));
+
 export class ComposerUpdate {
 
     static __wrap(ptr) {
@@ -715,25 +686,25 @@ export class ComposerUpdate {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_composerupdate_free(ptr);
+        wasm.__wbg_composerupdate_free(ptr, 0);
     }
     /**
-    * @returns {TextUpdate}
-    */
+     * @returns {TextUpdate}
+     */
     text_update() {
         const ret = wasm.composerupdate_text_update(this.__wbg_ptr);
         return TextUpdate.__wrap(ret);
     }
     /**
-    * @returns {MenuState}
-    */
+     * @returns {MenuState}
+     */
     menu_state() {
         const ret = wasm.composerupdate_menu_state(this.__wbg_ptr);
         return MenuState.__wrap(ret);
     }
     /**
-    * @returns {MenuAction}
-    */
+     * @returns {MenuAction}
+     */
     menu_action() {
         const ret = wasm.composerupdate_menu_action(this.__wbg_ptr);
         return MenuAction.__wrap(ret);
@@ -742,9 +713,8 @@ export class ComposerUpdate {
 
 const CreateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_create_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_create_free(ptr >>> 0, 1));
+
 export class Create {
 
     static __wrap(ptr) {
@@ -764,15 +734,14 @@ export class Create {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_create_free(ptr);
+        wasm.__wbg_create_free(ptr, 0);
     }
 }
 
 const CreateWithTextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_createwithtext_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_createwithtext_free(ptr >>> 0, 1));
+
 export class CreateWithText {
 
     static __wrap(ptr) {
@@ -792,15 +761,14 @@ export class CreateWithText {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_createwithtext_free(ptr);
+        wasm.__wbg_createwithtext_free(ptr, 0);
     }
 }
 
 const DisabledFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_disabled_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_disabled_free(ptr >>> 0, 1));
+
 export class Disabled {
 
     static __wrap(ptr) {
@@ -820,17 +788,17 @@ export class Disabled {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_disabled_free(ptr);
+        wasm.__wbg_disabled_free(ptr, 0);
     }
 }
 
 const DomChildrenFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_domchildren_free(ptr >>> 0));
+    : new FinalizationRegistry(ptr => wasm.__wbg_domchildren_free(ptr >>> 0, 1));
 /**
-* An iterator-like view of a DomHandle's children, written to work around
-* the lack of support for returning Vec<T> in wasm_bindgen.
-*/
+ * 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) {
@@ -850,11 +818,11 @@ export class DomChildren {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_domchildren_free(ptr);
+        wasm.__wbg_domchildren_free(ptr, 0);
     }
     /**
-    * @returns {DomHandle | undefined}
-    */
+     * @returns {DomHandle | undefined}
+     */
     next_child() {
         const ret = wasm.domchildren_next_child(this.__wbg_ptr);
         return ret === 0 ? undefined : DomHandle.__wrap(ret);
@@ -863,10 +831,10 @@ export class DomChildren {
 
 const DomHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_domhandle_free(ptr >>> 0));
+    : new FinalizationRegistry(ptr => wasm.__wbg_domhandle_free(ptr >>> 0, 1));
 /**
-* Refers to a node in the composer model.
-*/
+ * Refers to a node in the composer model.
+ */
 export class DomHandle {
 
     static __wrap(ptr) {
@@ -886,96 +854,84 @@ export class DomHandle {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_domhandle_free(ptr);
+        wasm.__wbg_domhandle_free(ptr, 0);
     }
     /**
-    * 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}
-    */
+     * 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);
+            const ret = wasm.domhandle_node_type(this.__wbg_ptr, model.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } 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}
-    */
+     * 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}
-    */
+     * 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);
+            const ret = wasm.domhandle_text(this.__wbg_ptr, model.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } 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}
-    */
+     * 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);
+            const ret = wasm.domhandle_tag(this.__wbg_ptr, model.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
@@ -983,9 +939,8 @@ export class DomHandle {
 
 const EditFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_edit_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_edit_free(ptr >>> 0, 1));
+
 export class Edit {
 
     static __wrap(ptr) {
@@ -1005,30 +960,26 @@ export class Edit {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_edit_free(ptr);
+        wasm.__wbg_edit_free(ptr, 0);
     }
     /**
-    * @returns {string}
-    */
+     * @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);
+            const ret = wasm.__wbg_get_edit_url(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @param {string} arg0
-    */
+     * @param {string} arg0
+     */
     set url(arg0) {
         const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
@@ -1038,9 +989,8 @@ export class Edit {
 
 const KeepFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_keep_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_keep_free(ptr >>> 0, 1));
+
 export class Keep {
 
     static __wrap(ptr) {
@@ -1060,15 +1010,14 @@ export class Keep {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_keep_free(ptr);
+        wasm.__wbg_keep_free(ptr, 0);
     }
 }
 
 const LinkActionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_linkaction_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_linkaction_free(ptr >>> 0, 1));
+
 export class LinkAction {
 
     static __wrap(ptr) {
@@ -1088,18 +1037,18 @@ export class LinkAction {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_linkaction_free(ptr);
+        wasm.__wbg_linkaction_free(ptr, 0);
     }
     /**
-    * @returns {CreateWithText | undefined}
-    */
+     * @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]
-    */
+     * @param {CreateWithText | null} [arg0]
+     */
     set create_with_text(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
@@ -1109,15 +1058,15 @@ export class LinkAction {
         wasm.__wbg_set_linkaction_create_with_text(this.__wbg_ptr, ptr0);
     }
     /**
-    * @returns {Create | undefined}
-    */
+     * @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]
-    */
+     * @param {Create | null} [arg0]
+     */
     set create(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
@@ -1127,15 +1076,15 @@ export class LinkAction {
         wasm.__wbg_set_linkaction_create(this.__wbg_ptr, ptr0);
     }
     /**
-    * @returns {Edit | undefined}
-    */
+     * @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]
-    */
+     * @param {Edit | null} [arg0]
+     */
     set edit_link(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
@@ -1145,15 +1094,15 @@ export class LinkAction {
         wasm.__wbg_set_linkaction_edit_link(this.__wbg_ptr, ptr0);
     }
     /**
-    * @returns {Disabled | undefined}
-    */
+     * @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]
-    */
+     * @param {Disabled | null} [arg0]
+     */
     set disabled(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
@@ -1166,9 +1115,8 @@ export class LinkAction {
 
 const MenuActionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_menuaction_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_menuaction_free(ptr >>> 0, 1));
+
 export class MenuAction {
 
     static __wrap(ptr) {
@@ -1188,25 +1136,25 @@ export class MenuAction {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_menuaction_free(ptr);
+        wasm.__wbg_menuaction_free(ptr, 0);
     }
     /**
-    * @returns {boolean}
-    */
+     * @returns {boolean}
+     */
     keep() {
         const ret = wasm.menuaction_keep(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-    * @returns {boolean}
-    */
+     * @returns {boolean}
+     */
     none() {
         const ret = wasm.menuaction_none(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-    * @returns {MenuActionSuggestion | undefined}
-    */
+     * @returns {MenuActionSuggestion | undefined}
+     */
     suggestion() {
         const ret = wasm.menuaction_suggestion(this.__wbg_ptr);
         return ret === 0 ? undefined : MenuActionSuggestion.__wrap(ret);
@@ -1215,9 +1163,8 @@ export class MenuAction {
 
 const MenuActionSuggestionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_menuactionsuggestion_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_menuactionsuggestion_free(ptr >>> 0, 1));
+
 export class MenuActionSuggestion {
 
     static __wrap(ptr) {
@@ -1237,18 +1184,18 @@ export class MenuActionSuggestion {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_menuactionsuggestion_free(ptr);
+        wasm.__wbg_menuactionsuggestion_free(ptr, 0);
     }
     /**
-    * @returns {SuggestionPattern}
-    */
+     * @returns {SuggestionPattern}
+     */
     get suggestion_pattern() {
         const ret = wasm.__wbg_get_menuactionsuggestion_suggestion_pattern(this.__wbg_ptr);
         return SuggestionPattern.__wrap(ret);
     }
     /**
-    * @param {SuggestionPattern} arg0
-    */
+     * @param {SuggestionPattern} arg0
+     */
     set suggestion_pattern(arg0) {
         _assertClass(arg0, SuggestionPattern);
         var ptr0 = arg0.__destroy_into_raw();
@@ -1258,9 +1205,8 @@ export class MenuActionSuggestion {
 
 const MenuStateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_menustate_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_menustate_free(ptr >>> 0, 1));
+
 export class MenuState {
 
     static __wrap(ptr) {
@@ -1280,18 +1226,18 @@ export class MenuState {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_menustate_free(ptr);
+        wasm.__wbg_menustate_free(ptr, 0);
     }
     /**
-    * @returns {boolean}
-    */
+     * @returns {boolean}
+     */
     keep() {
         const ret = wasm.menustate_keep(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
-    * @returns {MenuStateUpdate | undefined}
-    */
+     * @returns {MenuStateUpdate | undefined}
+     */
     update() {
         const ret = wasm.menustate_update(this.__wbg_ptr);
         return ret === 0 ? undefined : MenuStateUpdate.__wrap(ret);
@@ -1300,9 +1246,8 @@ export class MenuState {
 
 const MenuStateUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_menustateupdate_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_menustateupdate_free(ptr >>> 0, 1));
+
 export class MenuStateUpdate {
 
     static __wrap(ptr) {
@@ -1322,28 +1267,27 @@ export class MenuStateUpdate {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_menustateupdate_free(ptr);
+        wasm.__wbg_menustateupdate_free(ptr, 0);
     }
     /**
-    * @returns {Map<any, any>}
-    */
+     * @returns {Map<any, any>}
+     */
     get action_states() {
         const ret = wasm.__wbg_get_menustateupdate_action_states(this.__wbg_ptr);
-        return takeObject(ret);
+        return ret;
     }
     /**
-    * @param {Map<any, any>} arg0
-    */
+     * @param {Map<any, any>} arg0
+     */
     set action_states(arg0) {
-        wasm.__wbg_set_menustateupdate_action_states(this.__wbg_ptr, addHeapObject(arg0));
+        wasm.__wbg_set_menustateupdate_action_states(this.__wbg_ptr, arg0);
     }
 }
 
 const PatternKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_patternkey_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_patternkey_free(ptr >>> 0, 1));
+
 export class PatternKey {
 
     static __wrap(ptr) {
@@ -1363,43 +1307,36 @@ export class PatternKey {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_patternkey_free(ptr);
+        wasm.__wbg_patternkey_free(ptr, 0);
     }
     /**
-    * @returns {PatternKeyType}
-    */
+     * @returns {PatternKeyType}
+     */
     get key_type() {
         const ret = wasm.__wbg_get_patternkey_key_type(this.__wbg_ptr);
         return ret;
     }
     /**
-    * @param {PatternKeyType} arg0
-    */
+     * @param {PatternKeyType} arg0
+     */
     set key_type(arg0) {
         wasm.__wbg_set_patternkey_key_type(this.__wbg_ptr, arg0);
     }
     /**
-    * @returns {string | undefined}
-    */
+     * @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);
+        const ret = wasm.__wbg_get_patternkey_custom_key_value(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         }
+        return v1;
     }
     /**
-    * @param {string | undefined} [arg0]
-    */
+     * @param {string | null} [arg0]
+     */
     set custom_key_value(arg0) {
         var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
@@ -1409,9 +1346,8 @@ export class PatternKey {
 
 const ReplaceAllFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_replaceall_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_replaceall_free(ptr >>> 0, 1));
+
 export class ReplaceAll {
 
     static __wrap(ptr) {
@@ -1431,58 +1367,54 @@ export class ReplaceAll {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_replaceall_free(ptr);
+        wasm.__wbg_replaceall_free(ptr, 0);
     }
     /**
-    * @returns {string}
-    */
+     * @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);
+            const ret = wasm.__wbg_get_replaceall_replacement_html(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @param {string} arg0
-    */
+     * @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}
-    */
+     * @returns {number}
+     */
     get start_utf16_codeunit() {
         const ret = wasm.__wbg_get_replaceall_start_utf16_codeunit(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-    * @param {number} arg0
-    */
+     * @param {number} arg0
+     */
     set start_utf16_codeunit(arg0) {
         wasm.__wbg_set_replaceall_start_utf16_codeunit(this.__wbg_ptr, arg0);
     }
     /**
-    * @returns {number}
-    */
+     * @returns {number}
+     */
     get end_utf16_codeunit() {
         const ret = wasm.__wbg_get_replaceall_end_utf16_codeunit(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-    * @param {number} arg0
-    */
+     * @param {number} arg0
+     */
     set end_utf16_codeunit(arg0) {
         wasm.__wbg_set_replaceall_end_utf16_codeunit(this.__wbg_ptr, arg0);
     }
@@ -1490,9 +1422,8 @@ export class ReplaceAll {
 
 const SelectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_selection_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_selection_free(ptr >>> 0, 1));
+
 export class Selection {
 
     static __wrap(ptr) {
@@ -1512,31 +1443,31 @@ export class Selection {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_selection_free(ptr);
+        wasm.__wbg_selection_free(ptr, 0);
     }
     /**
-    * @returns {number}
-    */
+     * @returns {number}
+     */
     get start_utf16_codeunit() {
         const ret = wasm.__wbg_get_selection_start_utf16_codeunit(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-    * @param {number} arg0
-    */
+     * @param {number} arg0
+     */
     set start_utf16_codeunit(arg0) {
         wasm.__wbg_set_selection_start_utf16_codeunit(this.__wbg_ptr, arg0);
     }
     /**
-    * @returns {number}
-    */
+     * @returns {number}
+     */
     get end_utf16_codeunit() {
         const ret = wasm.__wbg_get_selection_end_utf16_codeunit(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-    * @param {number} arg0
-    */
+     * @param {number} arg0
+     */
     set end_utf16_codeunit(arg0) {
         wasm.__wbg_set_selection_end_utf16_codeunit(this.__wbg_ptr, arg0);
     }
@@ -1544,9 +1475,8 @@ export class Selection {
 
 const SuggestionPatternFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_suggestionpattern_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_suggestionpattern_free(ptr >>> 0, 1));
+
 export class SuggestionPattern {
 
     static __wrap(ptr) {
@@ -1566,73 +1496,69 @@ export class SuggestionPattern {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_suggestionpattern_free(ptr);
+        wasm.__wbg_suggestionpattern_free(ptr, 0);
     }
     /**
-    * @returns {PatternKey}
-    */
+     * @returns {PatternKey}
+     */
     get key() {
         const ret = wasm.__wbg_get_suggestionpattern_key(this.__wbg_ptr);
         return PatternKey.__wrap(ret);
     }
     /**
-    * @param {PatternKey} arg0
-    */
+     * @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}
-    */
+     * @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);
+            const ret = wasm.__wbg_get_suggestionpattern_text(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * @param {string} arg0
-    */
+     * @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}
-    */
+     * @returns {number}
+     */
     get start() {
         const ret = wasm.__wbg_get_suggestionpattern_start(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-    * @param {number} arg0
-    */
+     * @param {number} arg0
+     */
     set start(arg0) {
         wasm.__wbg_set_suggestionpattern_start(this.__wbg_ptr, arg0);
     }
     /**
-    * @returns {number}
-    */
+     * @returns {number}
+     */
     get end() {
         const ret = wasm.__wbg_get_suggestionpattern_end(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-    * @param {number} arg0
-    */
+     * @param {number} arg0
+     */
     set end(arg0) {
         wasm.__wbg_set_suggestionpattern_end(this.__wbg_ptr, arg0);
     }
@@ -1640,9 +1566,8 @@ export class SuggestionPattern {
 
 const TextUpdateFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_textupdate_free(ptr >>> 0));
-/**
-*/
+    : new FinalizationRegistry(ptr => wasm.__wbg_textupdate_free(ptr >>> 0, 1));
+
 export class TextUpdate {
 
     static __wrap(ptr) {
@@ -1662,18 +1587,18 @@ export class TextUpdate {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_textupdate_free(ptr);
+        wasm.__wbg_textupdate_free(ptr, 0);
     }
     /**
-    * @returns {Keep | undefined}
-    */
+     * @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]
-    */
+     * @param {Keep | null} [arg0]
+     */
     set keep(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
@@ -1683,15 +1608,15 @@ export class TextUpdate {
         wasm.__wbg_set_textupdate_keep(this.__wbg_ptr, ptr0);
     }
     /**
-    * @returns {ReplaceAll | undefined}
-    */
+     * @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]
-    */
+     * @param {ReplaceAll | null} [arg0]
+     */
     set replace_all(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
@@ -1701,15 +1626,15 @@ export class TextUpdate {
         wasm.__wbg_set_textupdate_replace_all(this.__wbg_ptr, ptr0);
     }
     /**
-    * @returns {Selection | undefined}
-    */
+     * @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]
-    */
+     * @param {Selection | null} [arg0]
+     */
     set select(arg0) {
         let ptr0 = 0;
         if (!isLikeNone(arg0)) {
@@ -1720,170 +1645,172 @@ export class TextUpdate {
     }
 }
 
-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 __wbg_body_942ea927546a04ba(arg0) {
+    const ret = arg0.body;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
 };
 
-export function __wbindgen_string_new(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
-    return addHeapObject(ret);
+export function __wbg_childNodes_c4423003f3a9441f(arg0) {
+    const ret = arg0.childNodes;
+    return ret;
 };
 
-export function __wbg_set_8417257aaedc936b(arg0, arg1, arg2) {
-    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
-    return addHeapObject(ret);
+export function __wbg_error_7534b8e9a36f1ab4(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 __wbg_forEach_4cee849ec749be17(arg0, arg1, arg2) {
+export function __wbg_forEach_d6a05ca96422eff9(arg0, arg1, arg2) {
     try {
         var state0 = {a: arg1, b: arg2};
-        var cb0 = (arg0, arg1) => {
+        var cb0 = (arg0, arg1, arg2) => {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_124(a, state0.b, arg0, arg1);
+                return __wbg_adapter_123(a, state0.b, arg0, arg1, arg2);
             } finally {
                 state0.a = a;
             }
         };
-        getObject(arg0).forEach(cb0);
+        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) {
+export function __wbg_forEach_e1cf6f7c8ecb7dae(arg0, arg1, arg2) {
     try {
         var state0 = {a: arg1, b: arg2};
-        var cb0 = (arg0, arg1, arg2) => {
+        var cb0 = (arg0, arg1) => {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_121(a, state0.b, arg0, arg1, arg2);
+                return __wbg_adapter_126(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
         };
-        getObject(arg0).forEach(cb0);
+        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_getAttribute_ea5166be2deba45e(arg0, arg1, arg2, arg3) {
+    const ret = arg1.getAttribute(getStringFromWasm0(arg2, arg3));
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_new_abda76e883ba8a5f() {
-    const ret = new Error();
-    return addHeapObject(ret);
+export function __wbg_get_e27dfaeb6f46bd45(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(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_hasAttribute_db31090c2e646f57(arg0, arg1, arg2) {
+    const ret = arg0.hasAttribute(getStringFromWasm0(arg1, arg2));
+    return ret;
 };
 
-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 __wbg_length_49b2ba67f0897e97(arg0) {
+    const ret = arg0.length;
+    return ret;
 };
 
-export function __wbindgen_throw(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
+export function __wbg_new_363ae9575a2aba54() { return handleError(function () {
+    const ret = new DOMParser();
+    return ret;
+}, arguments) };
+
+export function __wbg_new_5e0be73521bc8c17() {
+    const ret = new Map();
+    return ret;
 };
 
-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_new_8a6f238a6ece86ea() {
+    const ret = new Error();
+    return ret;
+};
+
+export function __wbg_nodeName_ff3aa439a5af6311(arg0, arg1) {
+    const ret = arg1.nodeName;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_nodeValue_0b5f7b2274265747(arg0, arg1) {
-    const ret = getObject(arg1).nodeValue;
+export function __wbg_nodeType_5e1153141daac26a(arg0) {
+    const ret = arg0.nodeType;
+    return ret;
+};
+
+export function __wbg_nodeValue_6ff4f14870c43bd9(arg0, arg1) {
+    const ret = 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;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-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);
+export function __wbg_parseFromString_91cbec9ba27a222a() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg0.parseFromString(getStringFromWasm0(arg1, arg2), __wbindgen_enum_SupportedType[arg3]);
+    return ret;
 }, arguments) };
 
-export function __wbg_body_edb1908d3ceff3a1(arg0) {
-    const ret = getObject(arg0).body;
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+export function __wbg_set_8fc6bf8a5b1071d1(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
 };
 
-export function __wbg_childNodes_118168e8b23bcb9b(arg0) {
-    const ret = getObject(arg0).childNodes;
-    return addHeapObject(ret);
+export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
+    const ret = arg1.stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_length_d0a802565d17eec4(arg0) {
-    const ret = getObject(arg0).length;
-    return ret;
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_export_1;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
 };
 
-export function __wbg_get_8cd5eba00ab6304f(arg0, arg1) {
-    const ret = getObject(arg0)[arg1 >>> 0];
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+export function __wbindgen_number_new(arg0) {
+    const ret = arg0;
+    return 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 __wbindgen_string_get(arg0, arg1) {
+    const obj = 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;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
-export function __wbg_hasAttribute_8340e1a2a46f10f3(arg0, arg1, arg2) {
-    const ret = getObject(arg0).hasAttribute(getStringFromWasm0(arg1, arg2));
+export function __wbindgen_string_new(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 };
 
-export function __wbg_nodeType_9dd609af1b555b54(arg0) {
-    const ret = getObject(arg0).nodeType;
-    return ret;
+export function __wbindgen_throw(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
 };