@vector-im/matrix-wysiwyg 2.37.13 → 2.38.0

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

@@ -0,0 +1,1910 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TextUpdate = exports.SuggestionPattern = exports.Selection = exports.ReplaceAll = exports.PatternKeyType = exports.PatternKey = exports.MenuStateUpdate = exports.MenuState = exports.MenuActionSuggestion = exports.MenuAction = exports.LinkAction = exports.Keep = exports.Edit = exports.DomHandle = exports.DomCreationError = exports.DomChildren = exports.Disabled = exports.CreateWithText = exports.Create = exports.ComposerUpdate = exports.ComposerModel = exports.ComposerAction = exports.ActionState = void 0;
+exports.__wbg_body_edb1908d3ceff3a1 = __wbg_body_edb1908d3ceff3a1;
+exports.__wbg_childNodes_118168e8b23bcb9b = __wbg_childNodes_118168e8b23bcb9b;
+exports.__wbg_error_f851667af71bcfc6 = __wbg_error_f851667af71bcfc6;
+exports.__wbg_forEach_2be8de7347d63332 = __wbg_forEach_2be8de7347d63332;
+exports.__wbg_forEach_4cee849ec749be17 = __wbg_forEach_4cee849ec749be17;
+exports.__wbg_getAttribute_99bddb29274b29b9 = __wbg_getAttribute_99bddb29274b29b9;
+exports.__wbg_get_8cd5eba00ab6304f = __wbg_get_8cd5eba00ab6304f;
+exports.__wbg_hasAttribute_8340e1a2a46f10f3 = __wbg_hasAttribute_8340e1a2a46f10f3;
+exports.__wbg_length_d0a802565d17eec4 = __wbg_length_d0a802565d17eec4;
+exports.__wbg_new_abda76e883ba8a5f = __wbg_new_abda76e883ba8a5f;
+exports.__wbg_new_aec969a21ad2fc71 = __wbg_new_aec969a21ad2fc71;
+exports.__wbg_new_d9bc3a0147634640 = __wbg_new_d9bc3a0147634640;
+exports.__wbg_nodeName_149f7e29f80d1338 = __wbg_nodeName_149f7e29f80d1338;
+exports.__wbg_nodeType_9dd609af1b555b54 = __wbg_nodeType_9dd609af1b555b54;
+exports.__wbg_nodeValue_0b5f7b2274265747 = __wbg_nodeValue_0b5f7b2274265747;
+exports.__wbg_parseFromString_656e5773ad0b3845 = __wbg_parseFromString_656e5773ad0b3845;
+exports.__wbg_set_8417257aaedc936b = __wbg_set_8417257aaedc936b;
+exports.__wbg_set_wasm = __wbg_set_wasm;
+exports.__wbg_stack_658279fe44541cf6 = __wbg_stack_658279fe44541cf6;
+exports.__wbindgen_number_new = __wbindgen_number_new;
+exports.__wbindgen_object_clone_ref = __wbindgen_object_clone_ref;
+exports.__wbindgen_object_drop_ref = __wbindgen_object_drop_ref;
+exports.__wbindgen_string_get = __wbindgen_string_get;
+exports.__wbindgen_string_new = __wbindgen_string_new;
+exports.__wbindgen_throw = __wbindgen_throw;
+exports.new_composer_model = new_composer_model;
+exports.new_composer_model_from_html = new_composer_model_from_html;
+exports.start = start;
+let wasm;
+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;
+}
+/**
+*/
+function start() {
+  wasm.start();
+}
+
+/**
+* @returns {ComposerModel}
+*/
+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}
+*/
+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));
+  }
+}
+/**
+*/
+const PatternKeyType = exports.PatternKeyType = Object.freeze({
+  At: 0,
+  "0": "At",
+  Hash: 1,
+  "1": "Hash",
+  Slash: 2,
+  "2": "Slash",
+  Custom: 3,
+  "3": "Custom"
+});
+/**
+*/
+const DomCreationError = exports.DomCreationError = Object.freeze({
+  HtmlParseError: 0,
+  "0": "HtmlParseError",
+  MarkdownParseError: 1,
+  "1": "MarkdownParseError"
+});
+/**
+*/
+const ComposerAction = exports.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"
+});
+/**
+*/
+const ActionState = exports.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));
+/**
+*/
+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);
+  }
+}
+exports.ComposerModel = ComposerModel;
+const ComposerUpdateFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_composerupdate_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.ComposerUpdate = ComposerUpdate;
+const CreateFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_create_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.Create = Create;
+const CreateWithTextFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_createwithtext_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.CreateWithText = CreateWithText;
+const DisabledFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_disabled_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.Disabled = Disabled;
+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.
+*/
+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);
+  }
+}
+exports.DomChildren = DomChildren;
+const DomHandleFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_domhandle_free(ptr >>> 0));
+/**
+* Refers to a node in the composer model.
+*/
+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);
+    }
+  }
+}
+exports.DomHandle = DomHandle;
+const EditFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_edit_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.Edit = Edit;
+const KeepFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_keep_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.Keep = Keep;
+const LinkActionFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_linkaction_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.LinkAction = LinkAction;
+const MenuActionFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_menuaction_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.MenuAction = MenuAction;
+const MenuActionSuggestionFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_menuactionsuggestion_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.MenuActionSuggestion = MenuActionSuggestion;
+const MenuStateFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_menustate_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.MenuState = MenuState;
+const MenuStateUpdateFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_menustateupdate_free(ptr >>> 0));
+/**
+*/
+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));
+  }
+}
+exports.MenuStateUpdate = MenuStateUpdate;
+const PatternKeyFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_patternkey_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.PatternKey = PatternKey;
+const ReplaceAllFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_replaceall_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.ReplaceAll = ReplaceAll;
+const SelectionFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_selection_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.Selection = Selection;
+const SuggestionPatternFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_suggestionpattern_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.SuggestionPattern = SuggestionPattern;
+const TextUpdateFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_textupdate_free(ptr >>> 0));
+/**
+*/
+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);
+  }
+}
+exports.TextUpdate = TextUpdate;
+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;
+}
+;
+function __wbindgen_object_drop_ref(arg0) {
+  takeObject(arg0);
+}
+;
+function __wbg_new_d9bc3a0147634640() {
+  const ret = new Map();
+  return addHeapObject(ret);
+}
+;
+function __wbindgen_string_new(arg0, arg1) {
+  const ret = getStringFromWasm0(arg0, arg1);
+  return addHeapObject(ret);
+}
+;
+function __wbg_set_8417257aaedc936b(arg0, arg1, arg2) {
+  const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+  return addHeapObject(ret);
+}
+;
+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;
+  }
+}
+;
+function __wbindgen_number_new(arg0) {
+  const ret = arg0;
+  return addHeapObject(ret);
+}
+;
+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;
+  }
+}
+;
+function __wbindgen_object_clone_ref(arg0) {
+  const ret = getObject(arg0);
+  return addHeapObject(ret);
+}
+;
+function __wbg_new_abda76e883ba8a5f() {
+  const ret = new Error();
+  return addHeapObject(ret);
+}
+;
+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;
+}
+;
+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);
+  }
+}
+;
+function __wbindgen_throw(arg0, arg1) {
+  throw new Error(getStringFromWasm0(arg0, arg1));
+}
+;
+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;
+}
+;
+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;
+}
+;
+function __wbg_new_aec969a21ad2fc71() {
+  return handleError(function () {
+    const ret = new DOMParser();
+    return addHeapObject(ret);
+  }, arguments);
+}
+;
+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);
+}
+;
+function __wbg_body_edb1908d3ceff3a1(arg0) {
+  const ret = getObject(arg0).body;
+  return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}
+;
+function __wbg_childNodes_118168e8b23bcb9b(arg0) {
+  const ret = getObject(arg0).childNodes;
+  return addHeapObject(ret);
+}
+;
+function __wbg_length_d0a802565d17eec4(arg0) {
+  const ret = getObject(arg0).length;
+  return ret;
+}
+;
+function __wbg_get_8cd5eba00ab6304f(arg0, arg1) {
+  const ret = getObject(arg0)[arg1 >>> 0];
+  return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}
+;
+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;
+}
+;
+function __wbg_hasAttribute_8340e1a2a46f10f3(arg0, arg1, arg2) {
+  const ret = getObject(arg0).hasAttribute(getStringFromWasm0(arg1, arg2));
+  return ret;
+}
+;
+function __wbg_nodeType_9dd609af1b555b54(arg0) {
+  const ret = getObject(arg0).nodeType;
+  return ret;
+}
+;