@fewangsit/wangsvue 1.5.219-alpha.2 → 1.5.219-alpha.4

package/vendor/@tiptap/core/dist/index.es.js

@@ -1,4362 +0,0 @@
-import { N as NodeSelection, E as EditorState, P as Plugin, a as PluginKey, S as Selection, T as TextSelection, A as AllSelection } from "../../../prosemirror-state/dist/index.es.js";
-import { E as EditorView } from "../../../prosemirror-view/dist/index.es.js";
-import { k as keymap } from "../../../prosemirror-keymap/dist/index.es.js";
-import { D as DOMSerializer, S as Schema, F as Fragment, N as Node$1, a as DOMParser, b as Slice } from "../../../prosemirror-model/dist/index.es.js";
-import { f as findWrapping, c as canJoin, T as Transform, a as canSplit, j as joinPoint, l as liftTarget, R as ReplaceStep, b as ReplaceAroundStep } from "../../../prosemirror-transform/dist/index.es.js";
-import { w as wrapIn$1, s as setBlockType, a as selectTextblockStart$1, b as selectTextblockEnd$1, c as selectParentNode$1, d as selectNodeForward$1, e as selectNodeBackward$1, n as newlineInCode$1, l as liftEmptyBlock$1, f as lift$1, j as joinUp$1, g as joinTextblockForward$1, h as joinTextblockBackward$1, i as joinForward$1, k as joinDown$1, m as joinBackward$1, o as exitCode$1, p as deleteSelection$1, q as createParagraphNear$1 } from "../../../prosemirror-commands/dist/index.es.js";
-import { w as wrapInList$1, s as sinkListItem$1, l as liftListItem$1 } from "../../../prosemirror-schema-list/dist/index.es.js";
-function createChainableState(config) {
-  const { state, transaction } = config;
-  let { selection } = transaction;
-  let { doc } = transaction;
-  let { storedMarks } = transaction;
-  return {
-    ...state,
-    apply: state.apply.bind(state),
-    applyTransaction: state.applyTransaction.bind(state),
-    plugins: state.plugins,
-    schema: state.schema,
-    reconfigure: state.reconfigure.bind(state),
-    toJSON: state.toJSON.bind(state),
-    get storedMarks() {
-      return storedMarks;
-    },
-    get selection() {
-      return selection;
-    },
-    get doc() {
-      return doc;
-    },
-    get tr() {
-      selection = transaction.selection;
-      doc = transaction.doc;
-      storedMarks = transaction.storedMarks;
-      return transaction;
-    }
-  };
-}
-class CommandManager {
-  constructor(props) {
-    this.editor = props.editor;
-    this.rawCommands = this.editor.extensionManager.commands;
-    this.customState = props.state;
-  }
-  get hasCustomState() {
-    return !!this.customState;
-  }
-  get state() {
-    return this.customState || this.editor.state;
-  }
-  get commands() {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const { tr } = state;
-    const props = this.buildProps(tr);
-    return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-      const method = (...args) => {
-        const callback = command2(...args)(props);
-        if (!tr.getMeta("preventDispatch") && !this.hasCustomState) {
-          view.dispatch(tr);
-        }
-        return callback;
-      };
-      return [name, method];
-    }));
-  }
-  get chain() {
-    return () => this.createChain();
-  }
-  get can() {
-    return () => this.createCan();
-  }
-  createChain(startTr, shouldDispatch = true) {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const callbacks = [];
-    const hasStartTransaction = !!startTr;
-    const tr = startTr || state.tr;
-    const run2 = () => {
-      if (!hasStartTransaction && shouldDispatch && !tr.getMeta("preventDispatch") && !this.hasCustomState) {
-        view.dispatch(tr);
-      }
-      return callbacks.every((callback) => callback === true);
-    };
-    const chain = {
-      ...Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-        const chainedCommand = (...args) => {
-          const props = this.buildProps(tr, shouldDispatch);
-          const callback = command2(...args)(props);
-          callbacks.push(callback);
-          return chain;
-        };
-        return [name, chainedCommand];
-      })),
-      run: run2
-    };
-    return chain;
-  }
-  createCan(startTr) {
-    const { rawCommands, state } = this;
-    const dispatch = false;
-    const tr = startTr || state.tr;
-    const props = this.buildProps(tr, dispatch);
-    const formattedCommands = Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-      return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
-    }));
-    return {
-      ...formattedCommands,
-      chain: () => this.createChain(tr, dispatch)
-    };
-  }
-  buildProps(tr, shouldDispatch = true) {
-    const { rawCommands, editor, state } = this;
-    const { view } = editor;
-    const props = {
-      tr,
-      editor,
-      view,
-      state: createChainableState({
-        state,
-        transaction: tr
-      }),
-      dispatch: shouldDispatch ? () => void 0 : void 0,
-      chain: () => this.createChain(tr, shouldDispatch),
-      can: () => this.createCan(tr),
-      get commands() {
-        return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-          return [name, (...args) => command2(...args)(props)];
-        }));
-      }
-    };
-    return props;
-  }
-}
-class EventEmitter {
-  constructor() {
-    this.callbacks = {};
-  }
-  on(event, fn) {
-    if (!this.callbacks[event]) {
-      this.callbacks[event] = [];
-    }
-    this.callbacks[event].push(fn);
-    return this;
-  }
-  emit(event, ...args) {
-    const callbacks = this.callbacks[event];
-    if (callbacks) {
-      callbacks.forEach((callback) => callback.apply(this, args));
-    }
-    return this;
-  }
-  off(event, fn) {
-    const callbacks = this.callbacks[event];
-    if (callbacks) {
-      if (fn) {
-        this.callbacks[event] = callbacks.filter((callback) => callback !== fn);
-      } else {
-        delete this.callbacks[event];
-      }
-    }
-    return this;
-  }
-  once(event, fn) {
-    const onceFn = (...args) => {
-      this.off(event, onceFn);
-      fn.apply(this, args);
-    };
-    return this.on(event, onceFn);
-  }
-  removeAllListeners() {
-    this.callbacks = {};
-  }
-}
-function getExtensionField(extension, field, context) {
-  if (extension.config[field] === void 0 && extension.parent) {
-    return getExtensionField(extension.parent, field, context);
-  }
-  if (typeof extension.config[field] === "function") {
-    const value = extension.config[field].bind({
-      ...context,
-      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null
-    });
-    return value;
-  }
-  return extension.config[field];
-}
-function splitExtensions(extensions) {
-  const baseExtensions = extensions.filter((extension) => extension.type === "extension");
-  const nodeExtensions = extensions.filter((extension) => extension.type === "node");
-  const markExtensions = extensions.filter((extension) => extension.type === "mark");
-  return {
-    baseExtensions,
-    nodeExtensions,
-    markExtensions
-  };
-}
-function getAttributesFromExtensions(extensions) {
-  const extensionAttributes = [];
-  const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-  const nodeAndMarkExtensions = [...nodeExtensions, ...markExtensions];
-  const defaultAttribute = {
-    default: null,
-    rendered: true,
-    renderHTML: null,
-    parseHTML: null,
-    keepOnSplit: true,
-    isRequired: false
-  };
-  extensions.forEach((extension) => {
-    const context = {
-      name: extension.name,
-      options: extension.options,
-      storage: extension.storage,
-      extensions: nodeAndMarkExtensions
-    };
-    const addGlobalAttributes = getExtensionField(extension, "addGlobalAttributes", context);
-    if (!addGlobalAttributes) {
-      return;
-    }
-    const globalAttributes = addGlobalAttributes();
-    globalAttributes.forEach((globalAttribute) => {
-      globalAttribute.types.forEach((type) => {
-        Object.entries(globalAttribute.attributes).forEach(([name, attribute]) => {
-          extensionAttributes.push({
-            type,
-            name,
-            attribute: {
-              ...defaultAttribute,
-              ...attribute
-            }
-          });
-        });
-      });
-    });
-  });
-  nodeAndMarkExtensions.forEach((extension) => {
-    const context = {
-      name: extension.name,
-      options: extension.options,
-      storage: extension.storage
-    };
-    const addAttributes = getExtensionField(extension, "addAttributes", context);
-    if (!addAttributes) {
-      return;
-    }
-    const attributes = addAttributes();
-    Object.entries(attributes).forEach(([name, attribute]) => {
-      const mergedAttr = {
-        ...defaultAttribute,
-        ...attribute
-      };
-      if (typeof (mergedAttr === null || mergedAttr === void 0 ? void 0 : mergedAttr.default) === "function") {
-        mergedAttr.default = mergedAttr.default();
-      }
-      if ((mergedAttr === null || mergedAttr === void 0 ? void 0 : mergedAttr.isRequired) && (mergedAttr === null || mergedAttr === void 0 ? void 0 : mergedAttr.default) === void 0) {
-        delete mergedAttr.default;
-      }
-      extensionAttributes.push({
-        type: extension.name,
-        name,
-        attribute: mergedAttr
-      });
-    });
-  });
-  return extensionAttributes;
-}
-function getNodeType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.nodes[nameOrType]) {
-      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.nodes[nameOrType];
-  }
-  return nameOrType;
-}
-function mergeAttributes(...objects) {
-  return objects.filter((item) => !!item).reduce((items, item) => {
-    const mergedAttributes = { ...items };
-    Object.entries(item).forEach(([key, value]) => {
-      const exists = mergedAttributes[key];
-      if (!exists) {
-        mergedAttributes[key] = value;
-        return;
-      }
-      if (key === "class") {
-        const valueClasses = value ? String(value).split(" ") : [];
-        const existingClasses = mergedAttributes[key] ? mergedAttributes[key].split(" ") : [];
-        const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
-        mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
-      } else if (key === "style") {
-        const newStyles = value ? value.split(";").map((style2) => style2.trim()).filter(Boolean) : [];
-        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style2) => style2.trim()).filter(Boolean) : [];
-        const styleMap = /* @__PURE__ */ new Map();
-        existingStyles.forEach((style2) => {
-          const [property, val] = style2.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        newStyles.forEach((style2) => {
-          const [property, val] = style2.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
-      } else {
-        mergedAttributes[key] = value;
-      }
-    });
-    return mergedAttributes;
-  }, {});
-}
-function getRenderedAttributes(nodeOrMark, extensionAttributes) {
-  return extensionAttributes.filter((attribute) => attribute.type === nodeOrMark.type.name).filter((item) => item.attribute.rendered).map((item) => {
-    if (!item.attribute.renderHTML) {
-      return {
-        [item.name]: nodeOrMark.attrs[item.name]
-      };
-    }
-    return item.attribute.renderHTML(nodeOrMark.attrs) || {};
-  }).reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {});
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function callOrReturn(value, context = void 0, ...props) {
-  if (isFunction(value)) {
-    if (context) {
-      return value.bind(context)(...props);
-    }
-    return value(...props);
-  }
-  return value;
-}
-function isEmptyObject(value = {}) {
-  return Object.keys(value).length === 0 && value.constructor === Object;
-}
-function fromString(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  if (value.match(/^[+-]?(?:\d*\.)?\d+$/)) {
-    return Number(value);
-  }
-  if (value === "true") {
-    return true;
-  }
-  if (value === "false") {
-    return false;
-  }
-  return value;
-}
-function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
-  if ("style" in parseRule) {
-    return parseRule;
-  }
-  return {
-    ...parseRule,
-    getAttrs: (node) => {
-      const oldAttributes = parseRule.getAttrs ? parseRule.getAttrs(node) : parseRule.attrs;
-      if (oldAttributes === false) {
-        return false;
-      }
-      const newAttributes = extensionAttributes.reduce((items, item) => {
-        const value = item.attribute.parseHTML ? item.attribute.parseHTML(node) : fromString(node.getAttribute(item.name));
-        if (value === null || value === void 0) {
-          return items;
-        }
-        return {
-          ...items,
-          [item.name]: value
-        };
-      }, {});
-      return { ...oldAttributes, ...newAttributes };
-    }
-  };
-}
-function cleanUpSchemaItem(data) {
-  return Object.fromEntries(
-    // @ts-ignore
-    Object.entries(data).filter(([key, value]) => {
-      if (key === "attrs" && isEmptyObject(value)) {
-        return false;
-      }
-      return value !== null && value !== void 0;
-    })
-  );
-}
-function getSchemaByResolvedExtensions(extensions, editor) {
-  var _a;
-  const allAttributes = getAttributesFromExtensions(extensions);
-  const { nodeExtensions, markExtensions } = splitExtensions(extensions);
-  const topNode = (_a = nodeExtensions.find((extension) => getExtensionField(extension, "topNode"))) === null || _a === void 0 ? void 0 : _a.name;
-  const nodes = Object.fromEntries(nodeExtensions.map((extension) => {
-    const extensionAttributes = allAttributes.filter((attribute) => attribute.type === extension.name);
-    const context = {
-      name: extension.name,
-      options: extension.options,
-      storage: extension.storage,
-      editor
-    };
-    const extraNodeFields = extensions.reduce((fields, e) => {
-      const extendNodeSchema = getExtensionField(e, "extendNodeSchema", context);
-      return {
-        ...fields,
-        ...extendNodeSchema ? extendNodeSchema(extension) : {}
-      };
-    }, {});
-    const schema = cleanUpSchemaItem({
-      ...extraNodeFields,
-      content: callOrReturn(getExtensionField(extension, "content", context)),
-      marks: callOrReturn(getExtensionField(extension, "marks", context)),
-      group: callOrReturn(getExtensionField(extension, "group", context)),
-      inline: callOrReturn(getExtensionField(extension, "inline", context)),
-      atom: callOrReturn(getExtensionField(extension, "atom", context)),
-      selectable: callOrReturn(getExtensionField(extension, "selectable", context)),
-      draggable: callOrReturn(getExtensionField(extension, "draggable", context)),
-      code: callOrReturn(getExtensionField(extension, "code", context)),
-      whitespace: callOrReturn(getExtensionField(extension, "whitespace", context)),
-      linebreakReplacement: callOrReturn(getExtensionField(extension, "linebreakReplacement", context)),
-      defining: callOrReturn(getExtensionField(extension, "defining", context)),
-      isolating: callOrReturn(getExtensionField(extension, "isolating", context)),
-      attrs: Object.fromEntries(extensionAttributes.map((extensionAttribute) => {
-        var _a2;
-        return [extensionAttribute.name, { default: (_a2 = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a2 === void 0 ? void 0 : _a2.default }];
-      }))
-    });
-    const parseHTML = callOrReturn(getExtensionField(extension, "parseHTML", context));
-    if (parseHTML) {
-      schema.parseDOM = parseHTML.map((parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-    }
-    const renderHTML = getExtensionField(extension, "renderHTML", context);
-    if (renderHTML) {
-      schema.toDOM = (node) => renderHTML({
-        node,
-        HTMLAttributes: getRenderedAttributes(node, extensionAttributes)
-      });
-    }
-    const renderText = getExtensionField(extension, "renderText", context);
-    if (renderText) {
-      schema.toText = renderText;
-    }
-    return [extension.name, schema];
-  }));
-  const marks = Object.fromEntries(markExtensions.map((extension) => {
-    const extensionAttributes = allAttributes.filter((attribute) => attribute.type === extension.name);
-    const context = {
-      name: extension.name,
-      options: extension.options,
-      storage: extension.storage,
-      editor
-    };
-    const extraMarkFields = extensions.reduce((fields, e) => {
-      const extendMarkSchema = getExtensionField(e, "extendMarkSchema", context);
-      return {
-        ...fields,
-        ...extendMarkSchema ? extendMarkSchema(extension) : {}
-      };
-    }, {});
-    const schema = cleanUpSchemaItem({
-      ...extraMarkFields,
-      inclusive: callOrReturn(getExtensionField(extension, "inclusive", context)),
-      excludes: callOrReturn(getExtensionField(extension, "excludes", context)),
-      group: callOrReturn(getExtensionField(extension, "group", context)),
-      spanning: callOrReturn(getExtensionField(extension, "spanning", context)),
-      code: callOrReturn(getExtensionField(extension, "code", context)),
-      attrs: Object.fromEntries(extensionAttributes.map((extensionAttribute) => {
-        var _a2;
-        return [extensionAttribute.name, { default: (_a2 = extensionAttribute === null || extensionAttribute === void 0 ? void 0 : extensionAttribute.attribute) === null || _a2 === void 0 ? void 0 : _a2.default }];
-      }))
-    });
-    const parseHTML = callOrReturn(getExtensionField(extension, "parseHTML", context));
-    if (parseHTML) {
-      schema.parseDOM = parseHTML.map((parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
-    }
-    const renderHTML = getExtensionField(extension, "renderHTML", context);
-    if (renderHTML) {
-      schema.toDOM = (mark) => renderHTML({
-        mark,
-        HTMLAttributes: getRenderedAttributes(mark, extensionAttributes)
-      });
-    }
-    return [extension.name, schema];
-  }));
-  return new Schema({
-    topNode,
-    nodes,
-    marks
-  });
-}
-function getSchemaTypeByName(name, schema) {
-  return schema.nodes[name] || schema.marks[name] || null;
-}
-function isExtensionRulesEnabled(extension, enabled) {
-  if (Array.isArray(enabled)) {
-    return enabled.some((enabledExtension) => {
-      const name = typeof enabledExtension === "string" ? enabledExtension : enabledExtension.name;
-      return name === extension.name;
-    });
-  }
-  return enabled;
-}
-function getHTMLFromFragment(fragment, schema) {
-  const documentFragment = DOMSerializer.fromSchema(schema).serializeFragment(fragment);
-  const temporaryDocument = document.implementation.createHTMLDocument();
-  const container = temporaryDocument.createElement("div");
-  container.appendChild(documentFragment);
-  return container.innerHTML;
-}
-const getTextContentFromNodes = ($from, maxMatch = 500) => {
-  let textBefore = "";
-  const sliceEndPos = $from.parentOffset;
-  $from.parent.nodesBetween(Math.max(0, sliceEndPos - maxMatch), sliceEndPos, (node, pos, parent, index) => {
-    var _a, _b;
-    const chunk = ((_b = (_a = node.type.spec).toText) === null || _b === void 0 ? void 0 : _b.call(_a, {
-      node,
-      pos,
-      parent,
-      index
-    })) || node.textContent || "%leaf%";
-    textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos));
-  });
-  return textBefore;
-};
-function isRegExp(value) {
-  return Object.prototype.toString.call(value) === "[object RegExp]";
-}
-class InputRule {
-  constructor(config) {
-    this.find = config.find;
-    this.handler = config.handler;
-  }
-}
-const inputRuleMatcherHandler = (text, find) => {
-  if (isRegExp(find)) {
-    return find.exec(text);
-  }
-  const inputRuleMatch = find(text);
-  if (!inputRuleMatch) {
-    return null;
-  }
-  const result = [inputRuleMatch.text];
-  result.index = inputRuleMatch.index;
-  result.input = text;
-  result.data = inputRuleMatch.data;
-  if (inputRuleMatch.replaceWith) {
-    if (!inputRuleMatch.text.includes(inputRuleMatch.replaceWith)) {
-      console.warn('[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".');
-    }
-    result.push(inputRuleMatch.replaceWith);
-  }
-  return result;
-};
-function run$1(config) {
-  var _a;
-  const { editor, from, to, text, rules, plugin } = config;
-  const { view } = editor;
-  if (view.composing) {
-    return false;
-  }
-  const $from = view.state.doc.resolve(from);
-  if (
-    // check for code node
-    $from.parent.type.spec.code || !!((_a = $from.nodeBefore || $from.nodeAfter) === null || _a === void 0 ? void 0 : _a.marks.find((mark) => mark.type.spec.code))
-  ) {
-    return false;
-  }
-  let matched = false;
-  const textBefore = getTextContentFromNodes($from) + text;
-  rules.forEach((rule) => {
-    if (matched) {
-      return;
-    }
-    const match = inputRuleMatcherHandler(textBefore, rule.find);
-    if (!match) {
-      return;
-    }
-    const tr = view.state.tr;
-    const state = createChainableState({
-      state: view.state,
-      transaction: tr
-    });
-    const range = {
-      from: from - (match[0].length - text.length),
-      to
-    };
-    const { commands: commands2, chain, can } = new CommandManager({
-      editor,
-      state
-    });
-    const handler = rule.handler({
-      state,
-      range,
-      match,
-      commands: commands2,
-      chain,
-      can
-    });
-    if (handler === null || !tr.steps.length) {
-      return;
-    }
-    tr.setMeta(plugin, {
-      transform: tr,
-      from,
-      to,
-      text
-    });
-    view.dispatch(tr);
-    matched = true;
-  });
-  return matched;
-}
-function inputRulesPlugin(props) {
-  const { editor, rules } = props;
-  const plugin = new Plugin({
-    state: {
-      init() {
-        return null;
-      },
-      apply(tr, prev, state) {
-        const stored = tr.getMeta(plugin);
-        if (stored) {
-          return stored;
-        }
-        const simulatedInputMeta = tr.getMeta("applyInputRules");
-        const isSimulatedInput = !!simulatedInputMeta;
-        if (isSimulatedInput) {
-          setTimeout(() => {
-            let { text } = simulatedInputMeta;
-            if (typeof text === "string") {
-              text = text;
-            } else {
-              text = getHTMLFromFragment(Fragment.from(text), state.schema);
-            }
-            const { from } = simulatedInputMeta;
-            const to = from + text.length;
-            run$1({
-              editor,
-              from,
-              to,
-              text,
-              rules,
-              plugin
-            });
-          });
-        }
-        return tr.selectionSet || tr.docChanged ? null : prev;
-      }
-    },
-    props: {
-      handleTextInput(view, from, to, text) {
-        return run$1({
-          editor,
-          from,
-          to,
-          text,
-          rules,
-          plugin
-        });
-      },
-      handleDOMEvents: {
-        compositionend: (view) => {
-          setTimeout(() => {
-            const { $cursor } = view.state.selection;
-            if ($cursor) {
-              run$1({
-                editor,
-                from: $cursor.pos,
-                to: $cursor.pos,
-                text: "",
-                rules,
-                plugin
-              });
-            }
-          });
-          return false;
-        }
-      },
-      // add support for input rules to trigger on enter
-      // this is useful for example for code blocks
-      handleKeyDown(view, event) {
-        if (event.key !== "Enter") {
-          return false;
-        }
-        const { $cursor } = view.state.selection;
-        if ($cursor) {
-          return run$1({
-            editor,
-            from: $cursor.pos,
-            to: $cursor.pos,
-            text: "\n",
-            rules,
-            plugin
-          });
-        }
-        return false;
-      }
-    },
-    // @ts-ignore
-    isInputRules: true
-  });
-  return plugin;
-}
-function getType(value) {
-  return Object.prototype.toString.call(value).slice(8, -1);
-}
-function isPlainObject(value) {
-  if (getType(value) !== "Object") {
-    return false;
-  }
-  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
-}
-function mergeDeep(target, source) {
-  const output = { ...target };
-  if (isPlainObject(target) && isPlainObject(source)) {
-    Object.keys(source).forEach((key) => {
-      if (isPlainObject(source[key]) && isPlainObject(target[key])) {
-        output[key] = mergeDeep(target[key], source[key]);
-      } else {
-        output[key] = source[key];
-      }
-    });
-  }
-  return output;
-}
-class Mark {
-  constructor(config = {}) {
-    this.type = "mark";
-    this.name = "mark";
-    this.parent = null;
-    this.child = null;
-    this.config = {
-      name: this.name,
-      defaultOptions: {}
-    };
-    this.config = {
-      ...this.config,
-      ...config
-    };
-    this.name = this.config.name;
-    if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-    }
-    this.options = this.config.defaultOptions;
-    if (this.config.addOptions) {
-      this.options = callOrReturn(getExtensionField(this, "addOptions", {
-        name: this.name
-      }));
-    }
-    this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-      name: this.name,
-      options: this.options
-    })) || {};
-  }
-  static create(config = {}) {
-    return new Mark(config);
-  }
-  configure(options = {}) {
-    const extension = this.extend({
-      ...this.config,
-      addOptions: () => {
-        return mergeDeep(this.options, options);
-      }
-    });
-    extension.name = this.name;
-    extension.parent = this.parent;
-    return extension;
-  }
-  extend(extendedConfig = {}) {
-    const extension = new Mark(extendedConfig);
-    extension.parent = this;
-    this.child = extension;
-    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-    if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-    }
-    extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-      name: extension.name
-    }));
-    extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-      name: extension.name,
-      options: extension.options
-    }));
-    return extension;
-  }
-  static handleExit({ editor, mark }) {
-    const { tr } = editor.state;
-    const currentPos = editor.state.selection.$from;
-    const isAtEnd = currentPos.pos === currentPos.end();
-    if (isAtEnd) {
-      const currentMarks = currentPos.marks();
-      const isInMark = !!currentMarks.find((m) => (m === null || m === void 0 ? void 0 : m.type.name) === mark.name);
-      if (!isInMark) {
-        return false;
-      }
-      const removeMark = currentMarks.find((m) => (m === null || m === void 0 ? void 0 : m.type.name) === mark.name);
-      if (removeMark) {
-        tr.removeStoredMark(removeMark);
-      }
-      tr.insertText(" ", currentPos.pos);
-      editor.view.dispatch(tr);
-      return true;
-    }
-    return false;
-  }
-}
-function isNumber(value) {
-  return typeof value === "number";
-}
-class PasteRule {
-  constructor(config) {
-    this.find = config.find;
-    this.handler = config.handler;
-  }
-}
-const pasteRuleMatcherHandler = (text, find, event) => {
-  if (isRegExp(find)) {
-    return [...text.matchAll(find)];
-  }
-  const matches = find(text, event);
-  if (!matches) {
-    return [];
-  }
-  return matches.map((pasteRuleMatch) => {
-    const result = [pasteRuleMatch.text];
-    result.index = pasteRuleMatch.index;
-    result.input = text;
-    result.data = pasteRuleMatch.data;
-    if (pasteRuleMatch.replaceWith) {
-      if (!pasteRuleMatch.text.includes(pasteRuleMatch.replaceWith)) {
-        console.warn('[tiptap warn]: "pasteRuleMatch.replaceWith" must be part of "pasteRuleMatch.text".');
-      }
-      result.push(pasteRuleMatch.replaceWith);
-    }
-    return result;
-  });
-};
-function run(config) {
-  const { editor, state, from, to, rule, pasteEvent, dropEvent } = config;
-  const { commands: commands2, chain, can } = new CommandManager({
-    editor,
-    state
-  });
-  const handlers = [];
-  state.doc.nodesBetween(from, to, (node, pos) => {
-    if (!node.isTextblock || node.type.spec.code) {
-      return;
-    }
-    const resolvedFrom = Math.max(from, pos);
-    const resolvedTo = Math.min(to, pos + node.content.size);
-    const textToMatch = node.textBetween(resolvedFrom - pos, resolvedTo - pos, void 0, "");
-    const matches = pasteRuleMatcherHandler(textToMatch, rule.find, pasteEvent);
-    matches.forEach((match) => {
-      if (match.index === void 0) {
-        return;
-      }
-      const start = resolvedFrom + match.index + 1;
-      const end = start + match[0].length;
-      const range = {
-        from: state.tr.mapping.map(start),
-        to: state.tr.mapping.map(end)
-      };
-      const handler = rule.handler({
-        state,
-        range,
-        match,
-        commands: commands2,
-        chain,
-        can,
-        pasteEvent,
-        dropEvent
-      });
-      handlers.push(handler);
-    });
-  });
-  const success = handlers.every((handler) => handler !== null);
-  return success;
-}
-let tiptapDragFromOtherEditor = null;
-const createClipboardPasteEvent = (text) => {
-  var _a;
-  const event = new ClipboardEvent("paste", {
-    clipboardData: new DataTransfer()
-  });
-  (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.setData("text/html", text);
-  return event;
-};
-function pasteRulesPlugin(props) {
-  const { editor, rules } = props;
-  let dragSourceElement = null;
-  let isPastedFromProseMirror = false;
-  let isDroppedFromProseMirror = false;
-  let pasteEvent = typeof ClipboardEvent !== "undefined" ? new ClipboardEvent("paste") : null;
-  let dropEvent;
-  try {
-    dropEvent = typeof DragEvent !== "undefined" ? new DragEvent("drop") : null;
-  } catch {
-    dropEvent = null;
-  }
-  const processEvent = ({ state, from, to, rule, pasteEvt }) => {
-    const tr = state.tr;
-    const chainableState = createChainableState({
-      state,
-      transaction: tr
-    });
-    const handler = run({
-      editor,
-      state: chainableState,
-      from: Math.max(from - 1, 0),
-      to: to.b - 1,
-      rule,
-      pasteEvent: pasteEvt,
-      dropEvent
-    });
-    if (!handler || !tr.steps.length) {
-      return;
-    }
-    try {
-      dropEvent = typeof DragEvent !== "undefined" ? new DragEvent("drop") : null;
-    } catch {
-      dropEvent = null;
-    }
-    pasteEvent = typeof ClipboardEvent !== "undefined" ? new ClipboardEvent("paste") : null;
-    return tr;
-  };
-  const plugins = rules.map((rule) => {
-    return new Plugin({
-      // we register a global drag handler to track the current drag source element
-      view(view) {
-        const handleDragstart = (event) => {
-          var _a;
-          dragSourceElement = ((_a = view.dom.parentElement) === null || _a === void 0 ? void 0 : _a.contains(event.target)) ? view.dom.parentElement : null;
-          if (dragSourceElement) {
-            tiptapDragFromOtherEditor = editor;
-          }
-        };
-        const handleDragend = () => {
-          if (tiptapDragFromOtherEditor) {
-            tiptapDragFromOtherEditor = null;
-          }
-        };
-        window.addEventListener("dragstart", handleDragstart);
-        window.addEventListener("dragend", handleDragend);
-        return {
-          destroy() {
-            window.removeEventListener("dragstart", handleDragstart);
-            window.removeEventListener("dragend", handleDragend);
-          }
-        };
-      },
-      props: {
-        handleDOMEvents: {
-          drop: (view, event) => {
-            isDroppedFromProseMirror = dragSourceElement === view.dom.parentElement;
-            dropEvent = event;
-            if (!isDroppedFromProseMirror) {
-              const dragFromOtherEditor = tiptapDragFromOtherEditor;
-              if (dragFromOtherEditor) {
-                setTimeout(() => {
-                  const selection = dragFromOtherEditor.state.selection;
-                  if (selection) {
-                    dragFromOtherEditor.commands.deleteRange({ from: selection.from, to: selection.to });
-                  }
-                }, 10);
-              }
-            }
-            return false;
-          },
-          paste: (_view, event) => {
-            var _a;
-            const html = (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.getData("text/html");
-            pasteEvent = event;
-            isPastedFromProseMirror = !!(html === null || html === void 0 ? void 0 : html.includes("data-pm-slice"));
-            return false;
-          }
-        }
-      },
-      appendTransaction: (transactions, oldState, state) => {
-        const transaction = transactions[0];
-        const isPaste = transaction.getMeta("uiEvent") === "paste" && !isPastedFromProseMirror;
-        const isDrop = transaction.getMeta("uiEvent") === "drop" && !isDroppedFromProseMirror;
-        const simulatedPasteMeta = transaction.getMeta("applyPasteRules");
-        const isSimulatedPaste = !!simulatedPasteMeta;
-        if (!isPaste && !isDrop && !isSimulatedPaste) {
-          return;
-        }
-        if (isSimulatedPaste) {
-          let { text } = simulatedPasteMeta;
-          if (typeof text === "string") {
-            text = text;
-          } else {
-            text = getHTMLFromFragment(Fragment.from(text), state.schema);
-          }
-          const { from: from2 } = simulatedPasteMeta;
-          const to2 = from2 + text.length;
-          const pasteEvt = createClipboardPasteEvent(text);
-          return processEvent({
-            rule,
-            state,
-            from: from2,
-            to: { b: to2 },
-            pasteEvt
-          });
-        }
-        const from = oldState.doc.content.findDiffStart(state.doc.content);
-        const to = oldState.doc.content.findDiffEnd(state.doc.content);
-        if (!isNumber(from) || !to || from === to.b) {
-          return;
-        }
-        return processEvent({
-          rule,
-          state,
-          from,
-          to,
-          pasteEvt: pasteEvent
-        });
-      }
-    });
-  });
-  return plugins;
-}
-function findDuplicates(items) {
-  const filtered = items.filter((el, index) => items.indexOf(el) !== index);
-  return Array.from(new Set(filtered));
-}
-class ExtensionManager {
-  constructor(extensions, editor) {
-    this.splittableMarks = [];
-    this.editor = editor;
-    this.extensions = ExtensionManager.resolve(extensions);
-    this.schema = getSchemaByResolvedExtensions(this.extensions, editor);
-    this.setupExtensions();
-  }
-  /**
-   * Returns a flattened and sorted extension list while
-   * also checking for duplicated extensions and warns the user.
-   * @param extensions An array of Tiptap extensions
-   * @returns An flattened and sorted array of Tiptap extensions
-   */
-  static resolve(extensions) {
-    const resolvedExtensions = ExtensionManager.sort(ExtensionManager.flatten(extensions));
-    const duplicatedNames = findDuplicates(resolvedExtensions.map((extension) => extension.name));
-    if (duplicatedNames.length) {
-      console.warn(`[tiptap warn]: Duplicate extension names found: [${duplicatedNames.map((item) => `'${item}'`).join(", ")}]. This can lead to issues.`);
-    }
-    return resolvedExtensions;
-  }
-  /**
-   * Create a flattened array of extensions by traversing the `addExtensions` field.
-   * @param extensions An array of Tiptap extensions
-   * @returns A flattened array of Tiptap extensions
-   */
-  static flatten(extensions) {
-    return extensions.map((extension) => {
-      const context = {
-        name: extension.name,
-        options: extension.options,
-        storage: extension.storage
-      };
-      const addExtensions = getExtensionField(extension, "addExtensions", context);
-      if (addExtensions) {
-        return [extension, ...this.flatten(addExtensions())];
-      }
-      return extension;
-    }).flat(10);
-  }
-  /**
-   * Sort extensions by priority.
-   * @param extensions An array of Tiptap extensions
-   * @returns A sorted array of Tiptap extensions by priority
-   */
-  static sort(extensions) {
-    const defaultPriority = 100;
-    return extensions.sort((a, b) => {
-      const priorityA = getExtensionField(a, "priority") || defaultPriority;
-      const priorityB = getExtensionField(b, "priority") || defaultPriority;
-      if (priorityA > priorityB) {
-        return -1;
-      }
-      if (priorityA < priorityB) {
-        return 1;
-      }
-      return 0;
-    });
-  }
-  /**
-   * Get all commands from the extensions.
-   * @returns An object with all commands where the key is the command name and the value is the command function
-   */
-  get commands() {
-    return this.extensions.reduce((commands2, extension) => {
-      const context = {
-        name: extension.name,
-        options: extension.options,
-        storage: extension.storage,
-        editor: this.editor,
-        type: getSchemaTypeByName(extension.name, this.schema)
-      };
-      const addCommands = getExtensionField(extension, "addCommands", context);
-      if (!addCommands) {
-        return commands2;
-      }
-      return {
-        ...commands2,
-        ...addCommands()
-      };
-    }, {});
-  }
-  /**
-   * Get all registered Prosemirror plugins from the extensions.
-   * @returns An array of Prosemirror plugins
-   */
-  get plugins() {
-    const { editor } = this;
-    const extensions = ExtensionManager.sort([...this.extensions].reverse());
-    const inputRules = [];
-    const pasteRules = [];
-    const allPlugins = extensions.map((extension) => {
-      const context = {
-        name: extension.name,
-        options: extension.options,
-        storage: extension.storage,
-        editor,
-        type: getSchemaTypeByName(extension.name, this.schema)
-      };
-      const plugins = [];
-      const addKeyboardShortcuts = getExtensionField(extension, "addKeyboardShortcuts", context);
-      let defaultBindings = {};
-      if (extension.type === "mark" && getExtensionField(extension, "exitable", context)) {
-        defaultBindings.ArrowRight = () => Mark.handleExit({ editor, mark: extension });
-      }
-      if (addKeyboardShortcuts) {
-        const bindings = Object.fromEntries(Object.entries(addKeyboardShortcuts()).map(([shortcut, method]) => {
-          return [shortcut, () => method({ editor })];
-        }));
-        defaultBindings = { ...defaultBindings, ...bindings };
-      }
-      const keyMapPlugin = keymap(defaultBindings);
-      plugins.push(keyMapPlugin);
-      const addInputRules = getExtensionField(extension, "addInputRules", context);
-      if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
-        inputRules.push(...addInputRules());
-      }
-      const addPasteRules = getExtensionField(extension, "addPasteRules", context);
-      if (isExtensionRulesEnabled(extension, editor.options.enablePasteRules) && addPasteRules) {
-        pasteRules.push(...addPasteRules());
-      }
-      const addProseMirrorPlugins = getExtensionField(extension, "addProseMirrorPlugins", context);
-      if (addProseMirrorPlugins) {
-        const proseMirrorPlugins = addProseMirrorPlugins();
-        plugins.push(...proseMirrorPlugins);
-      }
-      return plugins;
-    }).flat();
-    return [
-      inputRulesPlugin({
-        editor,
-        rules: inputRules
-      }),
-      ...pasteRulesPlugin({
-        editor,
-        rules: pasteRules
-      }),
-      ...allPlugins
-    ];
-  }
-  /**
-   * Get all attributes from the extensions.
-   * @returns An array of attributes
-   */
-  get attributes() {
-    return getAttributesFromExtensions(this.extensions);
-  }
-  /**
-   * Get all node views from the extensions.
-   * @returns An object with all node views where the key is the node name and the value is the node view function
-   */
-  get nodeViews() {
-    const { editor } = this;
-    const { nodeExtensions } = splitExtensions(this.extensions);
-    return Object.fromEntries(nodeExtensions.filter((extension) => !!getExtensionField(extension, "addNodeView")).map((extension) => {
-      const extensionAttributes = this.attributes.filter((attribute) => attribute.type === extension.name);
-      const context = {
-        name: extension.name,
-        options: extension.options,
-        storage: extension.storage,
-        editor,
-        type: getNodeType(extension.name, this.schema)
-      };
-      const addNodeView = getExtensionField(extension, "addNodeView", context);
-      if (!addNodeView) {
-        return [];
-      }
-      const nodeview = (node, view, getPos, decorations, innerDecorations) => {
-        const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
-        return addNodeView()({
-          // pass-through
-          node,
-          view,
-          getPos,
-          decorations,
-          innerDecorations,
-          // tiptap-specific
-          editor,
-          extension,
-          HTMLAttributes
-        });
-      };
-      return [extension.name, nodeview];
-    }));
-  }
-  /**
-   * Go through all extensions, create extension storages & setup marks
-   * & bind editor event listener.
-   */
-  setupExtensions() {
-    this.extensions.forEach((extension) => {
-      var _a;
-      this.editor.extensionStorage[extension.name] = extension.storage;
-      const context = {
-        name: extension.name,
-        options: extension.options,
-        storage: extension.storage,
-        editor: this.editor,
-        type: getSchemaTypeByName(extension.name, this.schema)
-      };
-      if (extension.type === "mark") {
-        const keepOnSplit = (_a = callOrReturn(getExtensionField(extension, "keepOnSplit", context))) !== null && _a !== void 0 ? _a : true;
-        if (keepOnSplit) {
-          this.splittableMarks.push(extension.name);
-        }
-      }
-      const onBeforeCreate = getExtensionField(extension, "onBeforeCreate", context);
-      const onCreate = getExtensionField(extension, "onCreate", context);
-      const onUpdate = getExtensionField(extension, "onUpdate", context);
-      const onSelectionUpdate = getExtensionField(extension, "onSelectionUpdate", context);
-      const onTransaction = getExtensionField(extension, "onTransaction", context);
-      const onFocus = getExtensionField(extension, "onFocus", context);
-      const onBlur = getExtensionField(extension, "onBlur", context);
-      const onDestroy = getExtensionField(extension, "onDestroy", context);
-      if (onBeforeCreate) {
-        this.editor.on("beforeCreate", onBeforeCreate);
-      }
-      if (onCreate) {
-        this.editor.on("create", onCreate);
-      }
-      if (onUpdate) {
-        this.editor.on("update", onUpdate);
-      }
-      if (onSelectionUpdate) {
-        this.editor.on("selectionUpdate", onSelectionUpdate);
-      }
-      if (onTransaction) {
-        this.editor.on("transaction", onTransaction);
-      }
-      if (onFocus) {
-        this.editor.on("focus", onFocus);
-      }
-      if (onBlur) {
-        this.editor.on("blur", onBlur);
-      }
-      if (onDestroy) {
-        this.editor.on("destroy", onDestroy);
-      }
-    });
-  }
-}
-class Extension {
-  constructor(config = {}) {
-    this.type = "extension";
-    this.name = "extension";
-    this.parent = null;
-    this.child = null;
-    this.config = {
-      name: this.name,
-      defaultOptions: {}
-    };
-    this.config = {
-      ...this.config,
-      ...config
-    };
-    this.name = this.config.name;
-    if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-    }
-    this.options = this.config.defaultOptions;
-    if (this.config.addOptions) {
-      this.options = callOrReturn(getExtensionField(this, "addOptions", {
-        name: this.name
-      }));
-    }
-    this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-      name: this.name,
-      options: this.options
-    })) || {};
-  }
-  static create(config = {}) {
-    return new Extension(config);
-  }
-  configure(options = {}) {
-    const extension = this.extend({
-      ...this.config,
-      addOptions: () => {
-        return mergeDeep(this.options, options);
-      }
-    });
-    extension.name = this.name;
-    extension.parent = this.parent;
-    return extension;
-  }
-  extend(extendedConfig = {}) {
-    const extension = new Extension({ ...this.config, ...extendedConfig });
-    extension.parent = this;
-    this.child = extension;
-    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-    if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-    }
-    extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-      name: extension.name
-    }));
-    extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-      name: extension.name,
-      options: extension.options
-    }));
-    return extension;
-  }
-}
-function getTextBetween(startNode, range, options) {
-  const { from, to } = range;
-  const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
-  let text = "";
-  startNode.nodesBetween(from, to, (node, pos, parent, index) => {
-    var _a;
-    if (node.isBlock && pos > from) {
-      text += blockSeparator;
-    }
-    const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node.type.name];
-    if (textSerializer) {
-      if (parent) {
-        text += textSerializer({
-          node,
-          pos,
-          parent,
-          index,
-          range
-        });
-      }
-      return false;
-    }
-    if (node.isText) {
-      text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
-    }
-  });
-  return text;
-}
-function getTextSerializersFromSchema(schema) {
-  return Object.fromEntries(Object.entries(schema.nodes).filter(([, node]) => node.spec.toText).map(([name, node]) => [name, node.spec.toText]));
-}
-const ClipboardTextSerializer = Extension.create({
-  name: "clipboardTextSerializer",
-  addOptions() {
-    return {
-      blockSeparator: void 0
-    };
-  },
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("clipboardTextSerializer"),
-        props: {
-          clipboardTextSerializer: () => {
-            const { editor } = this;
-            const { state, schema } = editor;
-            const { doc, selection } = state;
-            const { ranges } = selection;
-            const from = Math.min(...ranges.map((range2) => range2.$from.pos));
-            const to = Math.max(...ranges.map((range2) => range2.$to.pos));
-            const textSerializers = getTextSerializersFromSchema(schema);
-            const range = { from, to };
-            return getTextBetween(doc, range, {
-              ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
-              textSerializers
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-const blur = () => ({ editor, view }) => {
-  requestAnimationFrame(() => {
-    var _a;
-    if (!editor.isDestroyed) {
-      view.dom.blur();
-      (_a = window === null || window === void 0 ? void 0 : window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
-    }
-  });
-  return true;
-};
-const clearContent = (emitUpdate = false) => ({ commands: commands2 }) => {
-  return commands2.setContent("", emitUpdate);
-};
-const clearNodes = () => ({ state, tr, dispatch }) => {
-  const { selection } = tr;
-  const { ranges } = selection;
-  if (!dispatch) {
-    return true;
-  }
-  ranges.forEach(({ $from, $to }) => {
-    state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
-      if (node.type.isText) {
-        return;
-      }
-      const { doc, mapping } = tr;
-      const $mappedFrom = doc.resolve(mapping.map(pos));
-      const $mappedTo = doc.resolve(mapping.map(pos + node.nodeSize));
-      const nodeRange = $mappedFrom.blockRange($mappedTo);
-      if (!nodeRange) {
-        return;
-      }
-      const targetLiftDepth = liftTarget(nodeRange);
-      if (node.type.isTextblock) {
-        const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
-        tr.setNodeMarkup(nodeRange.start, defaultType);
-      }
-      if (targetLiftDepth || targetLiftDepth === 0) {
-        tr.lift(nodeRange, targetLiftDepth);
-      }
-    });
-  });
-  return true;
-};
-const command = (fn) => (props) => {
-  return fn(props);
-};
-const createParagraphNear = () => ({ state, dispatch }) => {
-  return createParagraphNear$1(state, dispatch);
-};
-const cut = (originRange, targetPos) => ({ editor, tr }) => {
-  const { state } = editor;
-  const contentSlice = state.doc.slice(originRange.from, originRange.to);
-  tr.deleteRange(originRange.from, originRange.to);
-  const newPos = tr.mapping.map(targetPos);
-  tr.insert(newPos, contentSlice.content);
-  tr.setSelection(new TextSelection(tr.doc.resolve(newPos - 1)));
-  return true;
-};
-const deleteCurrentNode = () => ({ tr, dispatch }) => {
-  const { selection } = tr;
-  const currentNode = selection.$anchor.node();
-  if (currentNode.content.size > 0) {
-    return false;
-  }
-  const $pos = tr.selection.$anchor;
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node = $pos.node(depth);
-    if (node.type === currentNode.type) {
-      if (dispatch) {
-        const from = $pos.before(depth);
-        const to = $pos.after(depth);
-        tr.delete(from, to).scrollIntoView();
-      }
-      return true;
-    }
-  }
-  return false;
-};
-const deleteNode = (typeOrName) => ({ tr, state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const $pos = tr.selection.$anchor;
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
-    const node = $pos.node(depth);
-    if (node.type === type) {
-      if (dispatch) {
-        const from = $pos.before(depth);
-        const to = $pos.after(depth);
-        tr.delete(from, to).scrollIntoView();
-      }
-      return true;
-    }
-  }
-  return false;
-};
-const deleteRange = (range) => ({ tr, dispatch }) => {
-  const { from, to } = range;
-  if (dispatch) {
-    tr.delete(from, to);
-  }
-  return true;
-};
-const deleteSelection = () => ({ state, dispatch }) => {
-  return deleteSelection$1(state, dispatch);
-};
-const enter = () => ({ commands: commands2 }) => {
-  return commands2.keyboardShortcut("Enter");
-};
-const exitCode = () => ({ state, dispatch }) => {
-  return exitCode$1(state, dispatch);
-};
-function objectIncludes(object1, object2, options = { strict: true }) {
-  const keys = Object.keys(object2);
-  if (!keys.length) {
-    return true;
-  }
-  return keys.every((key) => {
-    if (options.strict) {
-      return object2[key] === object1[key];
-    }
-    if (isRegExp(object2[key])) {
-      return object2[key].test(object1[key]);
-    }
-    return object2[key] === object1[key];
-  });
-}
-function findMarkInSet(marks, type, attributes = {}) {
-  return marks.find((item) => {
-    return item.type === type && objectIncludes(
-      // Only check equality for the attributes that are provided
-      Object.fromEntries(Object.keys(attributes).map((k) => [k, item.attrs[k]])),
-      attributes
-    );
-  });
-}
-function isMarkInSet(marks, type, attributes = {}) {
-  return !!findMarkInSet(marks, type, attributes);
-}
-function getMarkRange($pos, type, attributes) {
-  var _a;
-  if (!$pos || !type) {
-    return;
-  }
-  let start = $pos.parent.childAfter($pos.parentOffset);
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    start = $pos.parent.childBefore($pos.parentOffset);
-  }
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    return;
-  }
-  attributes = attributes || ((_a = start.node.marks[0]) === null || _a === void 0 ? void 0 : _a.attrs);
-  const mark = findMarkInSet([...start.node.marks], type, attributes);
-  if (!mark) {
-    return;
-  }
-  let startIndex = start.index;
-  let startPos = $pos.start() + start.offset;
-  let endIndex = startIndex + 1;
-  let endPos = startPos + start.node.nodeSize;
-  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
-    startIndex -= 1;
-    startPos -= $pos.parent.child(startIndex).nodeSize;
-  }
-  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
-    endPos += $pos.parent.child(endIndex).nodeSize;
-    endIndex += 1;
-  }
-  return {
-    from: startPos,
-    to: endPos
-  };
-}
-function getMarkType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.marks[nameOrType]) {
-      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.marks[nameOrType];
-  }
-  return nameOrType;
-}
-const extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  const type = getMarkType(typeOrName, state.schema);
-  const { doc, selection } = tr;
-  const { $from, from, to } = selection;
-  if (dispatch) {
-    const range = getMarkRange($from, type, attributes);
-    if (range && range.from <= from && range.to >= to) {
-      const newSelection = TextSelection.create(doc, range.from, range.to);
-      tr.setSelection(newSelection);
-    }
-  }
-  return true;
-};
-const first = (commands2) => (props) => {
-  const items = typeof commands2 === "function" ? commands2(props) : commands2;
-  for (let i = 0; i < items.length; i += 1) {
-    if (items[i](props)) {
-      return true;
-    }
-  }
-  return false;
-};
-function isTextSelection(value) {
-  return value instanceof TextSelection;
-}
-function minMax(value = 0, min = 0, max = 0) {
-  return Math.min(Math.max(value, min), max);
-}
-function resolveFocusPosition(doc, position = null) {
-  if (!position) {
-    return null;
-  }
-  const selectionAtStart = Selection.atStart(doc);
-  const selectionAtEnd = Selection.atEnd(doc);
-  if (position === "start" || position === true) {
-    return selectionAtStart;
-  }
-  if (position === "end") {
-    return selectionAtEnd;
-  }
-  const minPos = selectionAtStart.from;
-  const maxPos = selectionAtEnd.to;
-  if (position === "all") {
-    return TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
-  }
-  return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
-}
-function isAndroid() {
-  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
-}
-function isiOS() {
-  return [
-    "iPad Simulator",
-    "iPhone Simulator",
-    "iPod Simulator",
-    "iPad",
-    "iPhone",
-    "iPod"
-  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
-}
-const focus = (position = null, options = {}) => ({ editor, view, tr, dispatch }) => {
-  options = {
-    scrollIntoView: true,
-    ...options
-  };
-  const delayedFocus = () => {
-    if (isiOS() || isAndroid()) {
-      view.dom.focus();
-    }
-    requestAnimationFrame(() => {
-      if (!editor.isDestroyed) {
-        view.focus();
-        if (options === null || options === void 0 ? void 0 : options.scrollIntoView) {
-          editor.commands.scrollIntoView();
-        }
-      }
-    });
-  };
-  if (view.hasFocus() && position === null || position === false) {
-    return true;
-  }
-  if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-    delayedFocus();
-    return true;
-  }
-  const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection;
-  const isSameSelection = editor.state.selection.eq(selection);
-  if (dispatch) {
-    if (!isSameSelection) {
-      tr.setSelection(selection);
-    }
-    if (isSameSelection && tr.storedMarks) {
-      tr.setStoredMarks(tr.storedMarks);
-    }
-    delayedFocus();
-  }
-  return true;
-};
-const forEach = (items, fn) => (props) => {
-  return items.every((item, index) => fn(item, { ...props, index }));
-};
-const insertContent = (value, options) => ({ tr, commands: commands2 }) => {
-  return commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
-};
-const removeWhitespaces = (node) => {
-  const children = node.childNodes;
-  for (let i = children.length - 1; i >= 0; i -= 1) {
-    const child = children[i];
-    if (child.nodeType === 3 && child.nodeValue && /^(\n\s\s|\n)$/.test(child.nodeValue)) {
-      node.removeChild(child);
-    } else if (child.nodeType === 1) {
-      removeWhitespaces(child);
-    }
-  }
-  return node;
-};
-function elementFromString(value) {
-  const wrappedValue = `<body>${value}</body>`;
-  const html = new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
-  return removeWhitespaces(html);
-}
-function createNodeFromContent(content, schema, options) {
-  if (content instanceof Node$1 || content instanceof Fragment) {
-    return content;
-  }
-  options = {
-    slice: true,
-    parseOptions: {},
-    ...options
-  };
-  const isJSONContent = typeof content === "object" && content !== null;
-  const isTextContent = typeof content === "string";
-  if (isJSONContent) {
-    try {
-      const isArrayContent = Array.isArray(content) && content.length > 0;
-      if (isArrayContent) {
-        return Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
-      }
-      const node = schema.nodeFromJSON(content);
-      if (options.errorOnInvalidContent) {
-        node.check();
-      }
-      return node;
-    } catch (error) {
-      if (options.errorOnInvalidContent) {
-        throw new Error("[tiptap error]: Invalid JSON content", { cause: error });
-      }
-      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
-      return createNodeFromContent("", schema, options);
-    }
-  }
-  if (isTextContent) {
-    if (options.errorOnInvalidContent) {
-      let hasInvalidContent = false;
-      let invalidContent = "";
-      const contentCheckSchema = new Schema({
-        topNode: schema.spec.topNode,
-        marks: schema.spec.marks,
-        // Prosemirror's schemas are executed such that: the last to execute, matches last
-        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
-        nodes: schema.spec.nodes.append({
-          __tiptap__private__unknown__catch__all__node: {
-            content: "inline*",
-            group: "block",
-            parseDOM: [
-              {
-                tag: "*",
-                getAttrs: (e) => {
-                  hasInvalidContent = true;
-                  invalidContent = typeof e === "string" ? e : e.outerHTML;
-                  return null;
-                }
-              }
-            ]
-          }
-        })
-      });
-      if (options.slice) {
-        DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
-      } else {
-        DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
-      }
-      if (options.errorOnInvalidContent && hasInvalidContent) {
-        throw new Error("[tiptap error]: Invalid HTML content", { cause: new Error(`Invalid element found: ${invalidContent}`) });
-      }
-    }
-    const parser = DOMParser.fromSchema(schema);
-    if (options.slice) {
-      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
-    }
-    return parser.parse(elementFromString(content), options.parseOptions);
-  }
-  return createNodeFromContent("", schema, options);
-}
-function selectionToInsertionEnd(tr, startLen, bias) {
-  const last = tr.steps.length - 1;
-  if (last < startLen) {
-    return;
-  }
-  const step = tr.steps[last];
-  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
-    return;
-  }
-  const map = tr.mapping.maps[last];
-  let end = 0;
-  map.forEach((_from, _to, _newFrom, newTo) => {
-    if (end === 0) {
-      end = newTo;
-    }
-  });
-  tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
-}
-const isFragment = (nodeOrFragment) => {
-  return !("type" in nodeOrFragment);
-};
-const insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
-  var _a;
-  if (dispatch) {
-    options = {
-      parseOptions: editor.options.parseOptions,
-      updateSelection: true,
-      applyInputRules: false,
-      applyPasteRules: false,
-      ...options
-    };
-    let content;
-    try {
-      content = createNodeFromContent(value, editor.schema, {
-        parseOptions: {
-          preserveWhitespace: "full",
-          ...options.parseOptions
-        },
-        errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-      });
-    } catch (e) {
-      editor.emit("contentError", {
-        editor,
-        error: e,
-        disableCollaboration: () => {
-          if (editor.storage.collaboration) {
-            editor.storage.collaboration.isDisabled = true;
-          }
-        }
-      });
-      return false;
-    }
-    let { from, to } = typeof position === "number" ? { from: position, to: position } : { from: position.from, to: position.to };
-    let isOnlyTextContent = true;
-    let isOnlyBlockContent = true;
-    const nodes = isFragment(content) ? content : [content];
-    nodes.forEach((node) => {
-      node.check();
-      isOnlyTextContent = isOnlyTextContent ? node.isText && node.marks.length === 0 : false;
-      isOnlyBlockContent = isOnlyBlockContent ? node.isBlock : false;
-    });
-    if (from === to && isOnlyBlockContent) {
-      const { parent } = tr.doc.resolve(from);
-      const isEmptyTextBlock = parent.isTextblock && !parent.type.spec.code && !parent.childCount;
-      if (isEmptyTextBlock) {
-        from -= 1;
-        to += 1;
-      }
-    }
-    let newContent;
-    if (isOnlyTextContent) {
-      if (Array.isArray(value)) {
-        newContent = value.map((v) => v.text || "").join("");
-      } else if (value instanceof Fragment) {
-        let text = "";
-        value.forEach((node) => {
-          if (node.text) {
-            text += node.text;
-          }
-        });
-        newContent = text;
-      } else if (typeof value === "object" && !!value && !!value.text) {
-        newContent = value.text;
-      } else {
-        newContent = value;
-      }
-      tr.insertText(newContent, from, to);
-    } else {
-      newContent = content;
-      tr.replaceWith(from, to, newContent);
-    }
-    if (options.updateSelection) {
-      selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-    }
-    if (options.applyInputRules) {
-      tr.setMeta("applyInputRules", { from, text: newContent });
-    }
-    if (options.applyPasteRules) {
-      tr.setMeta("applyPasteRules", { from, text: newContent });
-    }
-  }
-  return true;
-};
-const joinUp = () => ({ state, dispatch }) => {
-  return joinUp$1(state, dispatch);
-};
-const joinDown = () => ({ state, dispatch }) => {
-  return joinDown$1(state, dispatch);
-};
-const joinBackward = () => ({ state, dispatch }) => {
-  return joinBackward$1(state, dispatch);
-};
-const joinForward = () => ({ state, dispatch }) => {
-  return joinForward$1(state, dispatch);
-};
-const joinItemBackward = () => ({ state, dispatch, tr }) => {
-  try {
-    const point = joinPoint(state.doc, state.selection.$from.pos, -1);
-    if (point === null || point === void 0) {
-      return false;
-    }
-    tr.join(point, 2);
-    if (dispatch) {
-      dispatch(tr);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-};
-const joinItemForward = () => ({ state, dispatch, tr }) => {
-  try {
-    const point = joinPoint(state.doc, state.selection.$from.pos, 1);
-    if (point === null || point === void 0) {
-      return false;
-    }
-    tr.join(point, 2);
-    if (dispatch) {
-      dispatch(tr);
-    }
-    return true;
-  } catch {
-    return false;
-  }
-};
-const joinTextblockBackward = () => ({ state, dispatch }) => {
-  return joinTextblockBackward$1(state, dispatch);
-};
-const joinTextblockForward = () => ({ state, dispatch }) => {
-  return joinTextblockForward$1(state, dispatch);
-};
-function isMacOS() {
-  return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
-}
-function normalizeKeyName(name) {
-  const parts = name.split(/-(?!$)/);
-  let result = parts[parts.length - 1];
-  if (result === "Space") {
-    result = " ";
-  }
-  let alt;
-  let ctrl;
-  let shift;
-  let meta;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    const mod = parts[i];
-    if (/^(cmd|meta|m)$/i.test(mod)) {
-      meta = true;
-    } else if (/^a(lt)?$/i.test(mod)) {
-      alt = true;
-    } else if (/^(c|ctrl|control)$/i.test(mod)) {
-      ctrl = true;
-    } else if (/^s(hift)?$/i.test(mod)) {
-      shift = true;
-    } else if (/^mod$/i.test(mod)) {
-      if (isiOS() || isMacOS()) {
-        meta = true;
-      } else {
-        ctrl = true;
-      }
-    } else {
-      throw new Error(`Unrecognized modifier name: ${mod}`);
-    }
-  }
-  if (alt) {
-    result = `Alt-${result}`;
-  }
-  if (ctrl) {
-    result = `Ctrl-${result}`;
-  }
-  if (meta) {
-    result = `Meta-${result}`;
-  }
-  if (shift) {
-    result = `Shift-${result}`;
-  }
-  return result;
-}
-const keyboardShortcut = (name) => ({ editor, view, tr, dispatch }) => {
-  const keys = normalizeKeyName(name).split(/-(?!$)/);
-  const key = keys.find((item) => !["Alt", "Ctrl", "Meta", "Shift"].includes(item));
-  const event = new KeyboardEvent("keydown", {
-    key: key === "Space" ? " " : key,
-    altKey: keys.includes("Alt"),
-    ctrlKey: keys.includes("Ctrl"),
-    metaKey: keys.includes("Meta"),
-    shiftKey: keys.includes("Shift"),
-    bubbles: true,
-    cancelable: true
-  });
-  const capturedTransaction = editor.captureTransaction(() => {
-    view.someProp("handleKeyDown", (f) => f(view, event));
-  });
-  capturedTransaction === null || capturedTransaction === void 0 ? void 0 : capturedTransaction.steps.forEach((step) => {
-    const newStep = step.map(tr.mapping);
-    if (newStep && dispatch) {
-      tr.maybeStep(newStep);
-    }
-  });
-  return true;
-};
-function isNodeActive(state, typeOrName, attributes = {}) {
-  const { from, to, empty } = state.selection;
-  const type = typeOrName ? getNodeType(typeOrName, state.schema) : null;
-  const nodeRanges = [];
-  state.doc.nodesBetween(from, to, (node, pos) => {
-    if (node.isText) {
-      return;
-    }
-    const relativeFrom = Math.max(from, pos);
-    const relativeTo = Math.min(to, pos + node.nodeSize);
-    nodeRanges.push({
-      node,
-      from: relativeFrom,
-      to: relativeTo
-    });
-  });
-  const selectionRange = to - from;
-  const matchedNodeRanges = nodeRanges.filter((nodeRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === nodeRange.node.type.name;
-  }).filter((nodeRange) => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }));
-  if (empty) {
-    return !!matchedNodeRanges.length;
-  }
-  const range = matchedNodeRanges.reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0);
-  return range >= selectionRange;
-}
-const lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const isActive2 = isNodeActive(state, type, attributes);
-  if (!isActive2) {
-    return false;
-  }
-  return lift$1(state, dispatch);
-};
-const liftEmptyBlock = () => ({ state, dispatch }) => {
-  return liftEmptyBlock$1(state, dispatch);
-};
-const liftListItem = (typeOrName) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return liftListItem$1(type)(state, dispatch);
-};
-const newlineInCode = () => ({ state, dispatch }) => {
-  return newlineInCode$1(state, dispatch);
-};
-function getSchemaTypeNameByName(name, schema) {
-  if (schema.nodes[name]) {
-    return "node";
-  }
-  if (schema.marks[name]) {
-    return "mark";
-  }
-  return null;
-}
-function deleteProps(obj, propOrProps) {
-  const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
-  return Object.keys(obj).reduce((newObj, prop) => {
-    if (!props.includes(prop)) {
-      newObj[prop] = obj[prop];
-    }
-    return newObj;
-  }, {});
-}
-const resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-  let nodeType = null;
-  let markType = null;
-  const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-  if (!schemaType) {
-    return false;
-  }
-  if (schemaType === "node") {
-    nodeType = getNodeType(typeOrName, state.schema);
-  }
-  if (schemaType === "mark") {
-    markType = getMarkType(typeOrName, state.schema);
-  }
-  if (dispatch) {
-    tr.selection.ranges.forEach((range) => {
-      state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-        if (nodeType && nodeType === node.type) {
-          tr.setNodeMarkup(pos, void 0, deleteProps(node.attrs, attributes));
-        }
-        if (markType && node.marks.length) {
-          node.marks.forEach((mark) => {
-            if (markType === mark.type) {
-              tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
-            }
-          });
-        }
-      });
-    });
-  }
-  return true;
-};
-const scrollIntoView = () => ({ tr, dispatch }) => {
-  if (dispatch) {
-    tr.scrollIntoView();
-  }
-  return true;
-};
-const selectAll = () => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const selection = new AllSelection(tr.doc);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-const selectNodeBackward = () => ({ state, dispatch }) => {
-  return selectNodeBackward$1(state, dispatch);
-};
-const selectNodeForward = () => ({ state, dispatch }) => {
-  return selectNodeForward$1(state, dispatch);
-};
-const selectParentNode = () => ({ state, dispatch }) => {
-  return selectParentNode$1(state, dispatch);
-};
-const selectTextblockEnd = () => ({ state, dispatch }) => {
-  return selectTextblockEnd$1(state, dispatch);
-};
-const selectTextblockStart = () => ({ state, dispatch }) => {
-  return selectTextblockStart$1(state, dispatch);
-};
-function createDocument(content, schema, parseOptions = {}, options = {}) {
-  return createNodeFromContent(content, schema, {
-    slice: false,
-    parseOptions,
-    errorOnInvalidContent: options.errorOnInvalidContent
-  });
-}
-const setContent = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({ editor, tr, dispatch, commands: commands2 }) => {
-  var _a, _b;
-  const { doc } = tr;
-  if (parseOptions.preserveWhitespace !== "full") {
-    const document2 = createDocument(content, editor.schema, parseOptions, {
-      errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-    });
-    if (dispatch) {
-      tr.replaceWith(0, doc.content.size, document2).setMeta("preventUpdate", !emitUpdate);
-    }
-    return true;
-  }
-  if (dispatch) {
-    tr.setMeta("preventUpdate", !emitUpdate);
-  }
-  return commands2.insertContentAt({ from: 0, to: doc.content.size }, content, {
-    parseOptions,
-    errorOnInvalidContent: (_b = options.errorOnInvalidContent) !== null && _b !== void 0 ? _b : editor.options.enableContentCheck
-  });
-};
-function getMarkAttributes(state, typeOrName) {
-  const type = getMarkType(typeOrName, state.schema);
-  const { from, to, empty } = state.selection;
-  const marks = [];
-  if (empty) {
-    if (state.storedMarks) {
-      marks.push(...state.storedMarks);
-    }
-    marks.push(...state.selection.$head.marks());
-  } else {
-    state.doc.nodesBetween(from, to, (node) => {
-      marks.push(...node.marks);
-    });
-  }
-  const mark = marks.find((markItem) => markItem.type.name === type.name);
-  if (!mark) {
-    return {};
-  }
-  return { ...mark.attrs };
-}
-function combineTransactionSteps(oldDoc, transactions) {
-  const transform = new Transform(oldDoc);
-  transactions.forEach((transaction) => {
-    transaction.steps.forEach((step) => {
-      transform.step(step);
-    });
-  });
-  return transform;
-}
-function defaultBlockAt(match) {
-  for (let i = 0; i < match.edgeCount; i += 1) {
-    const { type } = match.edge(i);
-    if (type.isTextblock && !type.hasRequiredAttrs()) {
-      return type;
-    }
-  }
-  return null;
-}
-function findChildrenInRange(node, range, predicate) {
-  const nodesWithPos = [];
-  node.nodesBetween(range.from, range.to, (child, pos) => {
-    if (predicate(child)) {
-      nodesWithPos.push({
-        node: child,
-        pos
-      });
-    }
-  });
-  return nodesWithPos;
-}
-function findParentNodeClosestToPos($pos, predicate) {
-  for (let i = $pos.depth; i > 0; i -= 1) {
-    const node = $pos.node(i);
-    if (predicate(node)) {
-      return {
-        pos: i > 0 ? $pos.before(i) : 0,
-        start: $pos.start(i),
-        depth: i,
-        node
-      };
-    }
-  }
-}
-function findParentNode(predicate) {
-  return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
-}
-function getText(node, options) {
-  const range = {
-    from: 0,
-    to: node.content.size
-  };
-  return getTextBetween(node, range, options);
-}
-function getNodeAttributes(state, typeOrName) {
-  const type = getNodeType(typeOrName, state.schema);
-  const { from, to } = state.selection;
-  const nodes = [];
-  state.doc.nodesBetween(from, to, (node2) => {
-    nodes.push(node2);
-  });
-  const node = nodes.reverse().find((nodeItem) => nodeItem.type.name === type.name);
-  if (!node) {
-    return {};
-  }
-  return { ...node.attrs };
-}
-function getAttributes(state, typeOrName) {
-  const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-  if (schemaType === "node") {
-    return getNodeAttributes(state, typeOrName);
-  }
-  if (schemaType === "mark") {
-    return getMarkAttributes(state, typeOrName);
-  }
-  return {};
-}
-function removeDuplicates(array, by = JSON.stringify) {
-  const seen = {};
-  return array.filter((item) => {
-    const key = by(item);
-    return Object.prototype.hasOwnProperty.call(seen, key) ? false : seen[key] = true;
-  });
-}
-function simplifyChangedRanges(changes) {
-  const uniqueChanges = removeDuplicates(changes);
-  return uniqueChanges.length === 1 ? uniqueChanges : uniqueChanges.filter((change, index) => {
-    const rest = uniqueChanges.filter((_, i) => i !== index);
-    return !rest.some((otherChange) => {
-      return change.oldRange.from >= otherChange.oldRange.from && change.oldRange.to <= otherChange.oldRange.to && change.newRange.from >= otherChange.newRange.from && change.newRange.to <= otherChange.newRange.to;
-    });
-  });
-}
-function getChangedRanges(transform) {
-  const { mapping, steps } = transform;
-  const changes = [];
-  mapping.maps.forEach((stepMap, index) => {
-    const ranges = [];
-    if (!stepMap.ranges.length) {
-      const { from, to } = steps[index];
-      if (from === void 0 || to === void 0) {
-        return;
-      }
-      ranges.push({ from, to });
-    } else {
-      stepMap.forEach((from, to) => {
-        ranges.push({ from, to });
-      });
-    }
-    ranges.forEach(({ from, to }) => {
-      const newStart = mapping.slice(index).map(from, -1);
-      const newEnd = mapping.slice(index).map(to);
-      const oldStart = mapping.invert().map(newStart, -1);
-      const oldEnd = mapping.invert().map(newEnd);
-      changes.push({
-        oldRange: {
-          from: oldStart,
-          to: oldEnd
-        },
-        newRange: {
-          from: newStart,
-          to: newEnd
-        }
-      });
-    });
-  });
-  return simplifyChangedRanges(changes);
-}
-function getMarksBetween(from, to, doc) {
-  const marks = [];
-  if (from === to) {
-    doc.resolve(from).marks().forEach((mark) => {
-      const $pos = doc.resolve(from);
-      const range = getMarkRange($pos, mark.type);
-      if (!range) {
-        return;
-      }
-      marks.push({
-        mark,
-        ...range
-      });
-    });
-  } else {
-    doc.nodesBetween(from, to, (node, pos) => {
-      if (!node || (node === null || node === void 0 ? void 0 : node.nodeSize) === void 0) {
-        return;
-      }
-      marks.push(...node.marks.map((mark) => ({
-        from: pos,
-        to: pos + node.nodeSize,
-        mark
-      })));
-    });
-  }
-  return marks;
-}
-function getSplittedAttributes(extensionAttributes, typeName, attributes) {
-  return Object.fromEntries(Object.entries(attributes).filter(([name]) => {
-    const extensionAttribute = extensionAttributes.find((item) => {
-      return item.type === typeName && item.name === name;
-    });
-    if (!extensionAttribute) {
-      return false;
-    }
-    return extensionAttribute.attribute.keepOnSplit;
-  }));
-}
-function isMarkActive(state, typeOrName, attributes = {}) {
-  const { empty, ranges } = state.selection;
-  const type = typeOrName ? getMarkType(typeOrName, state.schema) : null;
-  if (empty) {
-    return !!(state.storedMarks || state.selection.$from.marks()).filter((mark) => {
-      if (!type) {
-        return true;
-      }
-      return type.name === mark.type.name;
-    }).find((mark) => objectIncludes(mark.attrs, attributes, { strict: false }));
-  }
-  let selectionRange = 0;
-  const markRanges = [];
-  ranges.forEach(({ $from, $to }) => {
-    const from = $from.pos;
-    const to = $to.pos;
-    state.doc.nodesBetween(from, to, (node, pos) => {
-      if (!node.isText && !node.marks.length) {
-        return;
-      }
-      const relativeFrom = Math.max(from, pos);
-      const relativeTo = Math.min(to, pos + node.nodeSize);
-      const range2 = relativeTo - relativeFrom;
-      selectionRange += range2;
-      markRanges.push(...node.marks.map((mark) => ({
-        mark,
-        from: relativeFrom,
-        to: relativeTo
-      })));
-    });
-  });
-  if (selectionRange === 0) {
-    return false;
-  }
-  const matchedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === markRange.mark.type.name;
-  }).filter((markRange) => objectIncludes(markRange.mark.attrs, attributes, { strict: false })).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const excludedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return markRange.mark.type !== type && markRange.mark.type.excludes(type);
-  }).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const range = matchedRange > 0 ? matchedRange + excludedRange : matchedRange;
-  return range >= selectionRange;
-}
-function isActive(state, name, attributes = {}) {
-  if (!name) {
-    return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes);
-  }
-  const schemaType = getSchemaTypeNameByName(name, state.schema);
-  if (schemaType === "node") {
-    return isNodeActive(state, name, attributes);
-  }
-  if (schemaType === "mark") {
-    return isMarkActive(state, name, attributes);
-  }
-  return false;
-}
-function isList(name, extensions) {
-  const { nodeExtensions } = splitExtensions(extensions);
-  const extension = nodeExtensions.find((item) => item.name === name);
-  if (!extension) {
-    return false;
-  }
-  const context = {
-    name: extension.name,
-    options: extension.options,
-    storage: extension.storage
-  };
-  const group = callOrReturn(getExtensionField(extension, "group", context));
-  if (typeof group !== "string") {
-    return false;
-  }
-  return group.split(" ").includes("list");
-}
-function isNodeEmpty(node, { checkChildren = true, ignoreWhitespace = false } = {}) {
-  var _a;
-  if (ignoreWhitespace) {
-    if (node.type.name === "hardBreak") {
-      return true;
-    }
-    if (node.isText) {
-      return /^\s*$/m.test((_a = node.text) !== null && _a !== void 0 ? _a : "");
-    }
-  }
-  if (node.isText) {
-    return !node.text;
-  }
-  if (node.isAtom || node.isLeaf) {
-    return false;
-  }
-  if (node.content.childCount === 0) {
-    return true;
-  }
-  if (checkChildren) {
-    let isContentEmpty = true;
-    node.content.forEach((childNode) => {
-      if (isContentEmpty === false) {
-        return;
-      }
-      if (!isNodeEmpty(childNode, { ignoreWhitespace, checkChildren })) {
-        isContentEmpty = false;
-      }
-    });
-    return isContentEmpty;
-  }
-  return false;
-}
-function isNodeSelection(value) {
-  return value instanceof NodeSelection;
-}
-function posToDOMRect(view, from, to) {
-  const minPos = 0;
-  const maxPos = view.state.doc.content.size;
-  const resolvedFrom = minMax(from, minPos, maxPos);
-  const resolvedEnd = minMax(to, minPos, maxPos);
-  const start = view.coordsAtPos(resolvedFrom);
-  const end = view.coordsAtPos(resolvedEnd, -1);
-  const top = Math.min(start.top, end.top);
-  const bottom = Math.max(start.bottom, end.bottom);
-  const left = Math.min(start.left, end.left);
-  const right = Math.max(start.right, end.right);
-  const width = right - left;
-  const height = bottom - top;
-  const x = left;
-  const y = top;
-  const data = {
-    top,
-    bottom,
-    left,
-    right,
-    width,
-    height,
-    x,
-    y
-  };
-  return {
-    ...data,
-    toJSON: () => data
-  };
-}
-function canSetMark(state, tr, newMarkType) {
-  var _a;
-  const { selection } = tr;
-  let cursor = null;
-  if (isTextSelection(selection)) {
-    cursor = selection.$cursor;
-  }
-  if (cursor) {
-    const currentMarks = (_a = state.storedMarks) !== null && _a !== void 0 ? _a : cursor.marks();
-    return !!newMarkType.isInSet(currentMarks) || !currentMarks.some((mark) => mark.type.excludes(newMarkType));
-  }
-  const { ranges } = selection;
-  return ranges.some(({ $from, $to }) => {
-    let someNodeSupportsMark = $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false;
-    state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
-      if (someNodeSupportsMark) {
-        return false;
-      }
-      if (node.isInline) {
-        const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
-        const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks) || !node.marks.some((otherMark) => otherMark.type.excludes(newMarkType));
-        someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
-      }
-      return !someNodeSupportsMark;
-    });
-    return someNodeSupportsMark;
-  });
-}
-const setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  const { selection } = tr;
-  const { empty, ranges } = selection;
-  const type = getMarkType(typeOrName, state.schema);
-  if (dispatch) {
-    if (empty) {
-      const oldAttributes = getMarkAttributes(state, type);
-      tr.addStoredMark(type.create({
-        ...oldAttributes,
-        ...attributes
-      }));
-    } else {
-      ranges.forEach((range) => {
-        const from = range.$from.pos;
-        const to = range.$to.pos;
-        state.doc.nodesBetween(from, to, (node, pos) => {
-          const trimmedFrom = Math.max(pos, from);
-          const trimmedTo = Math.min(pos + node.nodeSize, to);
-          const someHasMark = node.marks.find((mark) => mark.type === type);
-          if (someHasMark) {
-            node.marks.forEach((mark) => {
-              if (type === mark.type) {
-                tr.addMark(trimmedFrom, trimmedTo, type.create({
-                  ...mark.attrs,
-                  ...attributes
-                }));
-              }
-            });
-          } else {
-            tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
-          }
-        });
-      });
-    }
-  }
-  return canSetMark(state, tr, type);
-};
-const setMeta = (key, value) => ({ tr }) => {
-  tr.setMeta(key, value);
-  return true;
-};
-const setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  let attributesToCopy;
-  if (state.selection.$anchor.sameParent(state.selection.$head)) {
-    attributesToCopy = state.selection.$anchor.parent.attrs;
-  }
-  if (!type.isTextblock) {
-    console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
-    return false;
-  }
-  return chain().command(({ commands: commands2 }) => {
-    const canSetBlock = setBlockType(type, { ...attributesToCopy, ...attributes })(state);
-    if (canSetBlock) {
-      return true;
-    }
-    return commands2.clearNodes();
-  }).command(({ state: updatedState }) => {
-    return setBlockType(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
-  }).run();
-};
-const setNodeSelection = (position) => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr;
-    const from = minMax(position, 0, doc.content.size);
-    const selection = NodeSelection.create(doc, from);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-const setTextSelection = (position) => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr;
-    const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
-    const minPos = TextSelection.atStart(doc).from;
-    const maxPos = TextSelection.atEnd(doc).to;
-    const resolvedFrom = minMax(from, minPos, maxPos);
-    const resolvedEnd = minMax(to, minPos, maxPos);
-    const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-const sinkListItem = (typeOrName) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return sinkListItem$1(type)(state, dispatch);
-};
-function ensureMarks(state, splittableMarks) {
-  const marks = state.storedMarks || state.selection.$to.parentOffset && state.selection.$from.marks();
-  if (marks) {
-    const filteredMarks = marks.filter((mark) => splittableMarks === null || splittableMarks === void 0 ? void 0 : splittableMarks.includes(mark.type.name));
-    state.tr.ensureMarks(filteredMarks);
-  }
-}
-const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor }) => {
-  const { selection, doc } = tr;
-  const { $from, $to } = selection;
-  const extensionAttributes = editor.extensionManager.attributes;
-  const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-  if (selection instanceof NodeSelection && selection.node.isBlock) {
-    if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
-      return false;
-    }
-    if (dispatch) {
-      if (keepMarks) {
-        ensureMarks(state, editor.extensionManager.splittableMarks);
-      }
-      tr.split($from.pos).scrollIntoView();
-    }
-    return true;
-  }
-  if (!$from.parent.isBlock) {
-    return false;
-  }
-  const atEnd = $to.parentOffset === $to.parent.content.size;
-  const deflt = $from.depth === 0 ? void 0 : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-  let types = atEnd && deflt ? [
-    {
-      type: deflt,
-      attrs: newAttributes
-    }
-  ] : void 0;
-  let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
-  if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
-    can = true;
-    types = deflt ? [
-      {
-        type: deflt,
-        attrs: newAttributes
-      }
-    ] : void 0;
-  }
-  if (dispatch) {
-    if (can) {
-      if (selection instanceof TextSelection) {
-        tr.deleteSelection();
-      }
-      tr.split(tr.mapping.map($from.pos), 1, types);
-      if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
-        const first2 = tr.mapping.map($from.before());
-        const $first = tr.doc.resolve(first2);
-        if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
-          tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
-        }
-      }
-    }
-    if (keepMarks) {
-      ensureMarks(state, editor.extensionManager.splittableMarks);
-    }
-    tr.scrollIntoView();
-  }
-  return can;
-};
-const splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor }) => {
-  var _a;
-  const type = getNodeType(typeOrName, state.schema);
-  const { $from, $to } = state.selection;
-  const node = state.selection.node;
-  if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
-    return false;
-  }
-  const grandParent = $from.node(-1);
-  if (grandParent.type !== type) {
-    return false;
-  }
-  const extensionAttributes = editor.extensionManager.attributes;
-  if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-    if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
-      return false;
-    }
-    if (dispatch) {
-      let wrap = Fragment.empty;
-      const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
-      for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
-        wrap = Fragment.from($from.node(d).copy(wrap));
-      }
-      const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
-      const newNextTypeAttributes2 = {
-        ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-        ...overrideAttrs
-      };
-      const nextType2 = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
-      wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType2) || void 0));
-      const start = $from.before($from.depth - (depthBefore - 1));
-      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
-      let sel = -1;
-      tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
-        if (sel > -1) {
-          return false;
-        }
-        if (n.isTextblock && n.content.size === 0) {
-          sel = pos + 1;
-        }
-      });
-      if (sel > -1) {
-        tr.setSelection(TextSelection.near(tr.doc.resolve(sel)));
-      }
-      tr.scrollIntoView();
-    }
-    return true;
-  }
-  const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-  const newTypeAttributes = {
-    ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
-    ...overrideAttrs
-  };
-  const newNextTypeAttributes = {
-    ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-    ...overrideAttrs
-  };
-  tr.delete($from.pos, $to.pos);
-  const types = nextType ? [
-    { type, attrs: newTypeAttributes },
-    { type: nextType, attrs: newNextTypeAttributes }
-  ] : [{ type, attrs: newTypeAttributes }];
-  if (!canSplit(tr.doc, $from.pos, 2)) {
-    return false;
-  }
-  if (dispatch) {
-    const { selection, storedMarks } = state;
-    const { splittableMarks } = editor.extensionManager;
-    const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-    tr.split($from.pos, 2, types).scrollIntoView();
-    if (!marks || !dispatch) {
-      return true;
-    }
-    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-    tr.ensureMarks(filteredMarks);
-  }
-  return true;
-};
-const joinListBackwards = (tr, listType) => {
-  const list = findParentNode((node) => node.type === listType)(tr.selection);
-  if (!list) {
-    return true;
-  }
-  const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
-  if (before === void 0) {
-    return true;
-  }
-  const nodeBefore = tr.doc.nodeAt(before);
-  const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type) && canJoin(tr.doc, list.pos);
-  if (!canJoinBackwards) {
-    return true;
-  }
-  tr.join(list.pos);
-  return true;
-};
-const joinListForwards = (tr, listType) => {
-  const list = findParentNode((node) => node.type === listType)(tr.selection);
-  if (!list) {
-    return true;
-  }
-  const after = tr.doc.resolve(list.start).after(list.depth);
-  if (after === void 0) {
-    return true;
-  }
-  const nodeAfter = tr.doc.nodeAt(after);
-  const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type) && canJoin(tr.doc, after);
-  if (!canJoinForwards) {
-    return true;
-  }
-  tr.join(after);
-  return true;
-};
-const toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands: commands2, can }) => {
-  const { extensions, splittableMarks } = editor.extensionManager;
-  const listType = getNodeType(listTypeOrName, state.schema);
-  const itemType = getNodeType(itemTypeOrName, state.schema);
-  const { selection, storedMarks } = state;
-  const { $from, $to } = selection;
-  const range = $from.blockRange($to);
-  const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-  if (!range) {
-    return false;
-  }
-  const parentList = findParentNode((node) => isList(node.type.name, extensions))(selection);
-  if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-    if (parentList.node.type === listType) {
-      return commands2.liftListItem(itemType);
-    }
-    if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
-      return chain().command(() => {
-        tr.setNodeMarkup(parentList.pos, listType);
-        return true;
-      }).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-    }
-  }
-  if (!keepMarks || !marks || !dispatch) {
-    return chain().command(() => {
-      const canWrapInList = can().wrapInList(listType, attributes);
-      if (canWrapInList) {
-        return true;
-      }
-      return commands2.clearNodes();
-    }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-  }
-  return chain().command(() => {
-    const canWrapInList = can().wrapInList(listType, attributes);
-    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-    tr.ensureMarks(filteredMarks);
-    if (canWrapInList) {
-      return true;
-    }
-    return commands2.clearNodes();
-  }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-};
-const toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands: commands2 }) => {
-  const { extendEmptyMarkRange = false } = options;
-  const type = getMarkType(typeOrName, state.schema);
-  const isActive2 = isMarkActive(state, type, attributes);
-  if (isActive2) {
-    return commands2.unsetMark(type, { extendEmptyMarkRange });
-  }
-  return commands2.setMark(type, attributes);
-};
-const toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const toggleType = getNodeType(toggleTypeOrName, state.schema);
-  const isActive2 = isNodeActive(state, type, attributes);
-  let attributesToCopy;
-  if (state.selection.$anchor.sameParent(state.selection.$head)) {
-    attributesToCopy = state.selection.$anchor.parent.attrs;
-  }
-  if (isActive2) {
-    return commands2.setNode(toggleType, attributesToCopy);
-  }
-  return commands2.setNode(type, { ...attributesToCopy, ...attributes });
-};
-const toggleWrap = (typeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const isActive2 = isNodeActive(state, type, attributes);
-  if (isActive2) {
-    return commands2.lift(type);
-  }
-  return commands2.wrapIn(type, attributes);
-};
-const undoInputRule = () => ({ state, dispatch }) => {
-  const plugins = state.plugins;
-  for (let i = 0; i < plugins.length; i += 1) {
-    const plugin = plugins[i];
-    let undoable;
-    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
-      if (dispatch) {
-        const tr = state.tr;
-        const toUndo = undoable.transform;
-        for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
-          tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
-        }
-        if (undoable.text) {
-          const marks = tr.doc.resolve(undoable.from).marks();
-          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
-        } else {
-          tr.delete(undoable.from, undoable.to);
-        }
-      }
-      return true;
-    }
-  }
-  return false;
-};
-const unsetAllMarks = () => ({ tr, dispatch }) => {
-  const { selection } = tr;
-  const { empty, ranges } = selection;
-  if (empty) {
-    return true;
-  }
-  if (dispatch) {
-    ranges.forEach((range) => {
-      tr.removeMark(range.$from.pos, range.$to.pos);
-    });
-  }
-  return true;
-};
-const unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
-  var _a;
-  const { extendEmptyMarkRange = false } = options;
-  const { selection } = tr;
-  const type = getMarkType(typeOrName, state.schema);
-  const { $from, empty, ranges } = selection;
-  if (!dispatch) {
-    return true;
-  }
-  if (empty && extendEmptyMarkRange) {
-    let { from, to } = selection;
-    const attrs = (_a = $from.marks().find((mark) => mark.type === type)) === null || _a === void 0 ? void 0 : _a.attrs;
-    const range = getMarkRange($from, type, attrs);
-    if (range) {
-      from = range.from;
-      to = range.to;
-    }
-    tr.removeMark(from, to, type);
-  } else {
-    ranges.forEach((range) => {
-      tr.removeMark(range.$from.pos, range.$to.pos, type);
-    });
-  }
-  tr.removeStoredMark(type);
-  return true;
-};
-const updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-  let nodeType = null;
-  let markType = null;
-  const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-  if (!schemaType) {
-    return false;
-  }
-  if (schemaType === "node") {
-    nodeType = getNodeType(typeOrName, state.schema);
-  }
-  if (schemaType === "mark") {
-    markType = getMarkType(typeOrName, state.schema);
-  }
-  if (dispatch) {
-    tr.selection.ranges.forEach((range) => {
-      const from = range.$from.pos;
-      const to = range.$to.pos;
-      let lastPos;
-      let lastNode;
-      let trimmedFrom;
-      let trimmedTo;
-      if (tr.selection.empty) {
-        state.doc.nodesBetween(from, to, (node, pos) => {
-          if (nodeType && nodeType === node.type) {
-            trimmedFrom = Math.max(pos, from);
-            trimmedTo = Math.min(pos + node.nodeSize, to);
-            lastPos = pos;
-            lastNode = node;
-          }
-        });
-      } else {
-        state.doc.nodesBetween(from, to, (node, pos) => {
-          if (pos < from && nodeType && nodeType === node.type) {
-            trimmedFrom = Math.max(pos, from);
-            trimmedTo = Math.min(pos + node.nodeSize, to);
-            lastPos = pos;
-            lastNode = node;
-          }
-          if (pos >= from && pos <= to) {
-            if (nodeType && nodeType === node.type) {
-              tr.setNodeMarkup(pos, void 0, {
-                ...node.attrs,
-                ...attributes
-              });
-            }
-            if (markType && node.marks.length) {
-              node.marks.forEach((mark) => {
-                if (markType === mark.type) {
-                  const trimmedFrom2 = Math.max(pos, from);
-                  const trimmedTo2 = Math.min(pos + node.nodeSize, to);
-                  tr.addMark(trimmedFrom2, trimmedTo2, markType.create({
-                    ...mark.attrs,
-                    ...attributes
-                  }));
-                }
-              });
-            }
-          }
-        });
-      }
-      if (lastNode) {
-        if (lastPos !== void 0) {
-          tr.setNodeMarkup(lastPos, void 0, {
-            ...lastNode.attrs,
-            ...attributes
-          });
-        }
-        if (markType && lastNode.marks.length) {
-          lastNode.marks.forEach((mark) => {
-            if (markType === mark.type) {
-              tr.addMark(trimmedFrom, trimmedTo, markType.create({
-                ...mark.attrs,
-                ...attributes
-              }));
-            }
-          });
-        }
-      }
-    });
-  }
-  return true;
-};
-const wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return wrapIn$1(type, attributes)(state, dispatch);
-};
-const wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return wrapInList$1(type, attributes)(state, dispatch);
-};
-var commands = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  blur,
-  clearContent,
-  clearNodes,
-  command,
-  createParagraphNear,
-  cut,
-  deleteCurrentNode,
-  deleteNode,
-  deleteRange,
-  deleteSelection,
-  enter,
-  exitCode,
-  extendMarkRange,
-  first,
-  focus,
-  forEach,
-  insertContent,
-  insertContentAt,
-  joinBackward,
-  joinDown,
-  joinForward,
-  joinItemBackward,
-  joinItemForward,
-  joinTextblockBackward,
-  joinTextblockForward,
-  joinUp,
-  keyboardShortcut,
-  lift,
-  liftEmptyBlock,
-  liftListItem,
-  newlineInCode,
-  resetAttributes,
-  scrollIntoView,
-  selectAll,
-  selectNodeBackward,
-  selectNodeForward,
-  selectParentNode,
-  selectTextblockEnd,
-  selectTextblockStart,
-  setContent,
-  setMark,
-  setMeta,
-  setNode,
-  setNodeSelection,
-  setTextSelection,
-  sinkListItem,
-  splitBlock,
-  splitListItem,
-  toggleList,
-  toggleMark,
-  toggleNode,
-  toggleWrap,
-  undoInputRule,
-  unsetAllMarks,
-  unsetMark,
-  updateAttributes,
-  wrapIn,
-  wrapInList
-});
-const Commands = Extension.create({
-  name: "commands",
-  addCommands() {
-    return {
-      ...commands
-    };
-  }
-});
-const Drop = Extension.create({
-  name: "drop",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tiptapDrop"),
-        props: {
-          handleDrop: (_, e, slice, moved) => {
-            this.editor.emit("drop", {
-              editor: this.editor,
-              event: e,
-              slice,
-              moved
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-const Editable = Extension.create({
-  name: "editable",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("editable"),
-        props: {
-          editable: () => this.editor.options.editable
-        }
-      })
-    ];
-  }
-});
-const focusEventsPluginKey = new PluginKey("focusEvents");
-const FocusEvents = Extension.create({
-  name: "focusEvents",
-  addProseMirrorPlugins() {
-    const { editor } = this;
-    return [
-      new Plugin({
-        key: focusEventsPluginKey,
-        props: {
-          handleDOMEvents: {
-            focus: (view, event) => {
-              editor.isFocused = true;
-              const transaction = editor.state.tr.setMeta("focus", { event }).setMeta("addToHistory", false);
-              view.dispatch(transaction);
-              return false;
-            },
-            blur: (view, event) => {
-              editor.isFocused = false;
-              const transaction = editor.state.tr.setMeta("blur", { event }).setMeta("addToHistory", false);
-              view.dispatch(transaction);
-              return false;
-            }
-          }
-        }
-      })
-    ];
-  }
-});
-const Keymap = Extension.create({
-  name: "keymap",
-  addKeyboardShortcuts() {
-    const handleBackspace = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.undoInputRule(),
-      // maybe convert first text block node to default node
-      () => commands2.command(({ tr }) => {
-        const { selection, doc } = tr;
-        const { empty, $anchor } = selection;
-        const { pos, parent } = $anchor;
-        const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor;
-        const parentIsIsolating = $parentPos.parent.type.spec.isolating;
-        const parentPos = $anchor.pos - $anchor.parentOffset;
-        const isAtStart = parentIsIsolating && $parentPos.parent.childCount === 1 ? parentPos === $anchor.pos : Selection.atStart(doc).from === pos;
-        if (!empty || !parent.type.isTextblock || parent.textContent.length || !isAtStart || isAtStart && $anchor.parent.type.name === "paragraph") {
-          return false;
-        }
-        return commands2.clearNodes();
-      }),
-      () => commands2.deleteSelection(),
-      () => commands2.joinBackward(),
-      () => commands2.selectNodeBackward()
-    ]);
-    const handleDelete = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.deleteSelection(),
-      () => commands2.deleteCurrentNode(),
-      () => commands2.joinForward(),
-      () => commands2.selectNodeForward()
-    ]);
-    const handleEnter = () => this.editor.commands.first(({ commands: commands2 }) => [
-      () => commands2.newlineInCode(),
-      () => commands2.createParagraphNear(),
-      () => commands2.liftEmptyBlock(),
-      () => commands2.splitBlock()
-    ]);
-    const baseKeymap = {
-      Enter: handleEnter,
-      "Mod-Enter": () => this.editor.commands.exitCode(),
-      Backspace: handleBackspace,
-      "Mod-Backspace": handleBackspace,
-      "Shift-Backspace": handleBackspace,
-      Delete: handleDelete,
-      "Mod-Delete": handleDelete,
-      "Mod-a": () => this.editor.commands.selectAll()
-    };
-    const pcKeymap = {
-      ...baseKeymap
-    };
-    const macKeymap = {
-      ...baseKeymap,
-      "Ctrl-h": handleBackspace,
-      "Alt-Backspace": handleBackspace,
-      "Ctrl-d": handleDelete,
-      "Ctrl-Alt-Backspace": handleDelete,
-      "Alt-Delete": handleDelete,
-      "Alt-d": handleDelete,
-      "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
-      "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
-    };
-    if (isiOS() || isMacOS()) {
-      return macKeymap;
-    }
-    return pcKeymap;
-  },
-  addProseMirrorPlugins() {
-    return [
-      // With this plugin we check if the whole document was selected and deleted.
-      // In this case we will additionally call `clearNodes()` to convert e.g. a heading
-      // to a paragraph if necessary.
-      // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
-      // with many other commands.
-      new Plugin({
-        key: new PluginKey("clearDocument"),
-        appendTransaction: (transactions, oldState, newState) => {
-          if (transactions.some((tr2) => tr2.getMeta("composition"))) {
-            return;
-          }
-          const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-          const ignoreTr = transactions.some((transaction) => transaction.getMeta("preventClearDocument"));
-          if (!docChanges || ignoreTr) {
-            return;
-          }
-          const { empty, from, to } = oldState.selection;
-          const allFrom = Selection.atStart(oldState.doc).from;
-          const allEnd = Selection.atEnd(oldState.doc).to;
-          const allWasSelected = from === allFrom && to === allEnd;
-          if (empty || !allWasSelected) {
-            return;
-          }
-          const isEmpty = isNodeEmpty(newState.doc);
-          if (!isEmpty) {
-            return;
-          }
-          const tr = newState.tr;
-          const state = createChainableState({
-            state: newState,
-            transaction: tr
-          });
-          const { commands: commands2 } = new CommandManager({
-            editor: this.editor,
-            state
-          });
-          commands2.clearNodes();
-          if (!tr.steps.length) {
-            return;
-          }
-          return tr;
-        }
-      })
-    ];
-  }
-});
-const Paste = Extension.create({
-  name: "paste",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tiptapPaste"),
-        props: {
-          handlePaste: (_view, e, slice) => {
-            this.editor.emit("paste", {
-              editor: this.editor,
-              event: e,
-              slice
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-const Tabindex = Extension.create({
-  name: "tabindex",
-  addProseMirrorPlugins() {
-    return [
-      new Plugin({
-        key: new PluginKey("tabindex"),
-        props: {
-          attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
-        }
-      })
-    ];
-  }
-});
-class NodePos {
-  get name() {
-    return this.node.type.name;
-  }
-  constructor(pos, editor, isBlock = false, node = null) {
-    this.currentNode = null;
-    this.actualDepth = null;
-    this.isBlock = isBlock;
-    this.resolvedPos = pos;
-    this.editor = editor;
-    this.currentNode = node;
-  }
-  get node() {
-    return this.currentNode || this.resolvedPos.node();
-  }
-  get element() {
-    return this.editor.view.domAtPos(this.pos).node;
-  }
-  get depth() {
-    var _a;
-    return (_a = this.actualDepth) !== null && _a !== void 0 ? _a : this.resolvedPos.depth;
-  }
-  get pos() {
-    return this.resolvedPos.pos;
-  }
-  get content() {
-    return this.node.content;
-  }
-  set content(content) {
-    let from = this.from;
-    let to = this.to;
-    if (this.isBlock) {
-      if (this.content.size === 0) {
-        console.error(`You can’t set content on a block node. Tried to set content on ${this.name} at ${this.pos}`);
-        return;
-      }
-      from = this.from + 1;
-      to = this.to - 1;
-    }
-    this.editor.commands.insertContentAt({ from, to }, content);
-  }
-  get attributes() {
-    return this.node.attrs;
-  }
-  get textContent() {
-    return this.node.textContent;
-  }
-  get size() {
-    return this.node.nodeSize;
-  }
-  get from() {
-    if (this.isBlock) {
-      return this.pos;
-    }
-    return this.resolvedPos.start(this.resolvedPos.depth);
-  }
-  get range() {
-    return {
-      from: this.from,
-      to: this.to
-    };
-  }
-  get to() {
-    if (this.isBlock) {
-      return this.pos + this.size;
-    }
-    return this.resolvedPos.end(this.resolvedPos.depth) + (this.node.isText ? 0 : 1);
-  }
-  get parent() {
-    if (this.depth === 0) {
-      return null;
-    }
-    const parentPos = this.resolvedPos.start(this.resolvedPos.depth - 1);
-    const $pos = this.resolvedPos.doc.resolve(parentPos);
-    return new NodePos($pos, this.editor);
-  }
-  get before() {
-    let $pos = this.resolvedPos.doc.resolve(this.from - (this.isBlock ? 1 : 2));
-    if ($pos.depth !== this.depth) {
-      $pos = this.resolvedPos.doc.resolve(this.from - 3);
-    }
-    return new NodePos($pos, this.editor);
-  }
-  get after() {
-    let $pos = this.resolvedPos.doc.resolve(this.to + (this.isBlock ? 2 : 1));
-    if ($pos.depth !== this.depth) {
-      $pos = this.resolvedPos.doc.resolve(this.to + 3);
-    }
-    return new NodePos($pos, this.editor);
-  }
-  get children() {
-    const children = [];
-    this.node.content.forEach((node, offset) => {
-      const isBlock = node.isBlock && !node.isTextblock;
-      const isNonTextAtom = node.isAtom && !node.isText;
-      const targetPos = this.pos + offset + (isNonTextAtom ? 0 : 1);
-      const $pos = this.resolvedPos.doc.resolve(targetPos);
-      if (!isBlock && $pos.depth <= this.depth) {
-        return;
-      }
-      const childNodePos = new NodePos($pos, this.editor, isBlock, isBlock ? node : null);
-      if (isBlock) {
-        childNodePos.actualDepth = this.depth + 1;
-      }
-      children.push(new NodePos($pos, this.editor, isBlock, isBlock ? node : null));
-    });
-    return children;
-  }
-  get firstChild() {
-    return this.children[0] || null;
-  }
-  get lastChild() {
-    const children = this.children;
-    return children[children.length - 1] || null;
-  }
-  closest(selector, attributes = {}) {
-    let node = null;
-    let currentNode = this.parent;
-    while (currentNode && !node) {
-      if (currentNode.node.type.name === selector) {
-        if (Object.keys(attributes).length > 0) {
-          const nodeAttributes = currentNode.node.attrs;
-          const attrKeys = Object.keys(attributes);
-          for (let index = 0; index < attrKeys.length; index += 1) {
-            const key = attrKeys[index];
-            if (nodeAttributes[key] !== attributes[key]) {
-              break;
-            }
-          }
-        } else {
-          node = currentNode;
-        }
-      }
-      currentNode = currentNode.parent;
-    }
-    return node;
-  }
-  querySelector(selector, attributes = {}) {
-    return this.querySelectorAll(selector, attributes, true)[0] || null;
-  }
-  querySelectorAll(selector, attributes = {}, firstItemOnly = false) {
-    let nodes = [];
-    if (!this.children || this.children.length === 0) {
-      return nodes;
-    }
-    const attrKeys = Object.keys(attributes);
-    this.children.forEach((childPos) => {
-      if (firstItemOnly && nodes.length > 0) {
-        return;
-      }
-      if (childPos.node.type.name === selector) {
-        const doesAllAttributesMatch = attrKeys.every((key) => attributes[key] === childPos.node.attrs[key]);
-        if (doesAllAttributesMatch) {
-          nodes.push(childPos);
-        }
-      }
-      if (firstItemOnly && nodes.length > 0) {
-        return;
-      }
-      nodes = nodes.concat(childPos.querySelectorAll(selector, attributes, firstItemOnly));
-    });
-    return nodes;
-  }
-  setAttribute(attributes) {
-    const { tr } = this.editor.state;
-    tr.setNodeMarkup(this.from, void 0, {
-      ...this.node.attrs,
-      ...attributes
-    });
-    this.editor.view.dispatch(tr);
-  }
-}
-const style = `.ProseMirror {
-  position: relative;
-}
-
-.ProseMirror {
-  word-wrap: break-word;
-  white-space: pre-wrap;
-  white-space: break-spaces;
-  -webkit-font-variant-ligatures: none;
-  font-variant-ligatures: none;
-  font-feature-settings: "liga" 0; /* the above doesn't seem to work in Edge */
-}
-
-.ProseMirror [contenteditable="false"] {
-  white-space: normal;
-}
-
-.ProseMirror [contenteditable="false"] [contenteditable="true"] {
-  white-space: pre-wrap;
-}
-
-.ProseMirror pre {
-  white-space: pre-wrap;
-}
-
-img.ProseMirror-separator {
-  display: inline !important;
-  border: none !important;
-  margin: 0 !important;
-  width: 0 !important;
-  height: 0 !important;
-}
-
-.ProseMirror-gapcursor {
-  display: none;
-  pointer-events: none;
-  position: absolute;
-  margin: 0;
-}
-
-.ProseMirror-gapcursor:after {
-  content: "";
-  display: block;
-  position: absolute;
-  top: -2px;
-  width: 20px;
-  border-top: 1px solid black;
-  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
-}
-
-@keyframes ProseMirror-cursor-blink {
-  to {
-    visibility: hidden;
-  }
-}
-
-.ProseMirror-hideselection *::selection {
-  background: transparent;
-}
-
-.ProseMirror-hideselection *::-moz-selection {
-  background: transparent;
-}
-
-.ProseMirror-hideselection * {
-  caret-color: transparent;
-}
-
-.ProseMirror-focused .ProseMirror-gapcursor {
-  display: block;
-}
-
-.tippy-box[data-animation=fade][data-state=hidden] {
-  opacity: 0
-}`;
-function createStyleTag(style2, nonce, suffix) {
-  const tiptapStyleTag = document.querySelector(`style[data-tiptap-style${""}]`);
-  if (tiptapStyleTag !== null) {
-    return tiptapStyleTag;
-  }
-  const styleNode = document.createElement("style");
-  if (nonce) {
-    styleNode.setAttribute("nonce", nonce);
-  }
-  styleNode.setAttribute(`data-tiptap-style${""}`, "");
-  styleNode.innerHTML = style2;
-  document.getElementsByTagName("head")[0].appendChild(styleNode);
-  return styleNode;
-}
-let Editor$1 = class Editor extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.isFocused = false;
-    this.isInitialized = false;
-    this.extensionStorage = {};
-    this.options = {
-      element: document.createElement("div"),
-      content: "",
-      injectCSS: true,
-      injectNonce: void 0,
-      extensions: [],
-      autofocus: false,
-      editable: true,
-      editorProps: {},
-      parseOptions: {},
-      coreExtensionOptions: {},
-      enableInputRules: true,
-      enablePasteRules: true,
-      enableCoreExtensions: true,
-      enableContentCheck: false,
-      onBeforeCreate: () => null,
-      onCreate: () => null,
-      onUpdate: () => null,
-      onSelectionUpdate: () => null,
-      onTransaction: () => null,
-      onFocus: () => null,
-      onBlur: () => null,
-      onDestroy: () => null,
-      onContentError: ({ error }) => {
-        throw error;
-      },
-      onPaste: () => null,
-      onDrop: () => null
-    };
-    this.isCapturingTransaction = false;
-    this.capturedTransaction = null;
-    this.setOptions(options);
-    this.createExtensionManager();
-    this.createCommandManager();
-    this.createSchema();
-    this.on("beforeCreate", this.options.onBeforeCreate);
-    this.emit("beforeCreate", { editor: this });
-    this.on("contentError", this.options.onContentError);
-    this.createView();
-    this.injectCSS();
-    this.on("create", this.options.onCreate);
-    this.on("update", this.options.onUpdate);
-    this.on("selectionUpdate", this.options.onSelectionUpdate);
-    this.on("transaction", this.options.onTransaction);
-    this.on("focus", this.options.onFocus);
-    this.on("blur", this.options.onBlur);
-    this.on("destroy", this.options.onDestroy);
-    this.on("drop", ({ event, slice, moved }) => this.options.onDrop(event, slice, moved));
-    this.on("paste", ({ event, slice }) => this.options.onPaste(event, slice));
-    window.setTimeout(() => {
-      if (this.isDestroyed) {
-        return;
-      }
-      this.commands.focus(this.options.autofocus);
-      this.emit("create", { editor: this });
-      this.isInitialized = true;
-    }, 0);
-  }
-  /**
-   * Returns the editor storage.
-   */
-  get storage() {
-    return this.extensionStorage;
-  }
-  /**
-   * An object of all registered commands.
-   */
-  get commands() {
-    return this.commandManager.commands;
-  }
-  /**
-   * Create a command chain to call multiple commands at once.
-   */
-  chain() {
-    return this.commandManager.chain();
-  }
-  /**
-   * Check if a command or a command chain can be executed. Without executing it.
-   */
-  can() {
-    return this.commandManager.can();
-  }
-  /**
-   * Inject CSS styles.
-   */
-  injectCSS() {
-    if (this.options.injectCSS && document) {
-      this.css = createStyleTag(style, this.options.injectNonce);
-    }
-  }
-  /**
-   * Update editor options.
-   *
-   * @param options A list of options
-   */
-  setOptions(options = {}) {
-    this.options = {
-      ...this.options,
-      ...options
-    };
-    if (!this.view || !this.state || this.isDestroyed) {
-      return;
-    }
-    if (this.options.editorProps) {
-      this.view.setProps(this.options.editorProps);
-    }
-    this.view.updateState(this.state);
-  }
-  /**
-   * Update editable state of the editor.
-   */
-  setEditable(editable, emitUpdate = true) {
-    this.setOptions({ editable });
-    if (emitUpdate) {
-      this.emit("update", { editor: this, transaction: this.state.tr });
-    }
-  }
-  /**
-   * Returns whether the editor is editable.
-   */
-  get isEditable() {
-    return this.options.editable && this.view && this.view.editable;
-  }
-  /**
-   * Returns the editor state.
-   */
-  get state() {
-    return this.view.state;
-  }
-  /**
-   * Register a ProseMirror plugin.
-   *
-   * @param plugin A ProseMirror plugin
-   * @param handlePlugins Control how to merge the plugin into the existing plugins.
-   * @returns The new editor state
-   */
-  registerPlugin(plugin, handlePlugins) {
-    const plugins = isFunction(handlePlugins) ? handlePlugins(plugin, [...this.state.plugins]) : [...this.state.plugins, plugin];
-    const state = this.state.reconfigure({ plugins });
-    this.view.updateState(state);
-    return state;
-  }
-  /**
-   * Unregister a ProseMirror plugin.
-   *
-   * @param nameOrPluginKeyToRemove The plugins name
-   * @returns The new editor state or undefined if the editor is destroyed
-   */
-  unregisterPlugin(nameOrPluginKeyToRemove) {
-    if (this.isDestroyed) {
-      return void 0;
-    }
-    const prevPlugins = this.state.plugins;
-    let plugins = prevPlugins;
-    [].concat(nameOrPluginKeyToRemove).forEach((nameOrPluginKey) => {
-      const name = typeof nameOrPluginKey === "string" ? `${nameOrPluginKey}$` : nameOrPluginKey.key;
-      plugins = plugins.filter((plugin) => !plugin.key.startsWith(name));
-    });
-    if (prevPlugins.length === plugins.length) {
-      return void 0;
-    }
-    const state = this.state.reconfigure({
-      plugins
-    });
-    this.view.updateState(state);
-    return state;
-  }
-  /**
-   * Creates an extension manager.
-   */
-  createExtensionManager() {
-    var _a, _b;
-    const coreExtensions = this.options.enableCoreExtensions ? [
-      Editable,
-      ClipboardTextSerializer.configure({
-        blockSeparator: (_b = (_a = this.options.coreExtensionOptions) === null || _a === void 0 ? void 0 : _a.clipboardTextSerializer) === null || _b === void 0 ? void 0 : _b.blockSeparator
-      }),
-      Commands,
-      FocusEvents,
-      Keymap,
-      Tabindex,
-      Drop,
-      Paste
-    ].filter((ext) => {
-      if (typeof this.options.enableCoreExtensions === "object") {
-        return this.options.enableCoreExtensions[ext.name] !== false;
-      }
-      return true;
-    }) : [];
-    const allExtensions = [...coreExtensions, ...this.options.extensions].filter((extension) => {
-      return ["extension", "node", "mark"].includes(extension === null || extension === void 0 ? void 0 : extension.type);
-    });
-    this.extensionManager = new ExtensionManager(allExtensions, this);
-  }
-  /**
-   * Creates an command manager.
-   */
-  createCommandManager() {
-    this.commandManager = new CommandManager({
-      editor: this
-    });
-  }
-  /**
-   * Creates a ProseMirror schema.
-   */
-  createSchema() {
-    this.schema = this.extensionManager.schema;
-  }
-  /**
-   * Creates a ProseMirror view.
-   */
-  createView() {
-    var _a;
-    let doc;
-    try {
-      doc = createDocument(this.options.content, this.schema, this.options.parseOptions, { errorOnInvalidContent: this.options.enableContentCheck });
-    } catch (e) {
-      if (!(e instanceof Error) || !["[tiptap error]: Invalid JSON content", "[tiptap error]: Invalid HTML content"].includes(e.message)) {
-        throw e;
-      }
-      this.emit("contentError", {
-        editor: this,
-        error: e,
-        disableCollaboration: () => {
-          if (this.storage.collaboration) {
-            this.storage.collaboration.isDisabled = true;
-          }
-          this.options.extensions = this.options.extensions.filter((extension) => extension.name !== "collaboration");
-          this.createExtensionManager();
-        }
-      });
-      doc = createDocument(this.options.content, this.schema, this.options.parseOptions, { errorOnInvalidContent: false });
-    }
-    const selection = resolveFocusPosition(doc, this.options.autofocus);
-    this.view = new EditorView(this.options.element, {
-      ...this.options.editorProps,
-      attributes: {
-        // add `role="textbox"` to the editor element
-        role: "textbox",
-        ...(_a = this.options.editorProps) === null || _a === void 0 ? void 0 : _a.attributes
-      },
-      dispatchTransaction: this.dispatchTransaction.bind(this),
-      state: EditorState.create({
-        doc,
-        selection: selection || void 0
-      })
-    });
-    const newState = this.state.reconfigure({
-      plugins: this.extensionManager.plugins
-    });
-    this.view.updateState(newState);
-    this.createNodeViews();
-    this.prependClass();
-    const dom = this.view.dom;
-    dom.editor = this;
-  }
-  /**
-   * Creates all node views.
-   */
-  createNodeViews() {
-    if (this.view.isDestroyed) {
-      return;
-    }
-    this.view.setProps({
-      nodeViews: this.extensionManager.nodeViews
-    });
-  }
-  /**
-   * Prepend class name to element.
-   */
-  prependClass() {
-    this.view.dom.className = `tiptap ${this.view.dom.className}`;
-  }
-  captureTransaction(fn) {
-    this.isCapturingTransaction = true;
-    fn();
-    this.isCapturingTransaction = false;
-    const tr = this.capturedTransaction;
-    this.capturedTransaction = null;
-    return tr;
-  }
-  /**
-   * The callback over which to send transactions (state updates) produced by the view.
-   *
-   * @param transaction An editor state transaction
-   */
-  dispatchTransaction(transaction) {
-    if (this.view.isDestroyed) {
-      return;
-    }
-    if (this.isCapturingTransaction) {
-      if (!this.capturedTransaction) {
-        this.capturedTransaction = transaction;
-        return;
-      }
-      transaction.steps.forEach((step) => {
-        var _a;
-        return (_a = this.capturedTransaction) === null || _a === void 0 ? void 0 : _a.step(step);
-      });
-      return;
-    }
-    const state = this.state.apply(transaction);
-    const selectionHasChanged = !this.state.selection.eq(state.selection);
-    this.emit("beforeTransaction", {
-      editor: this,
-      transaction,
-      nextState: state
-    });
-    this.view.updateState(state);
-    this.emit("transaction", {
-      editor: this,
-      transaction
-    });
-    if (selectionHasChanged) {
-      this.emit("selectionUpdate", {
-        editor: this,
-        transaction
-      });
-    }
-    const focus2 = transaction.getMeta("focus");
-    const blur2 = transaction.getMeta("blur");
-    if (focus2) {
-      this.emit("focus", {
-        editor: this,
-        event: focus2.event,
-        transaction
-      });
-    }
-    if (blur2) {
-      this.emit("blur", {
-        editor: this,
-        event: blur2.event,
-        transaction
-      });
-    }
-    if (!transaction.docChanged || transaction.getMeta("preventUpdate")) {
-      return;
-    }
-    this.emit("update", {
-      editor: this,
-      transaction
-    });
-  }
-  /**
-   * Get attributes of the currently selected node or mark.
-   */
-  getAttributes(nameOrType) {
-    return getAttributes(this.state, nameOrType);
-  }
-  isActive(nameOrAttributes, attributesOrUndefined) {
-    const name = typeof nameOrAttributes === "string" ? nameOrAttributes : null;
-    const attributes = typeof nameOrAttributes === "string" ? attributesOrUndefined : nameOrAttributes;
-    return isActive(this.state, name, attributes);
-  }
-  /**
-   * Get the document as JSON.
-   */
-  getJSON() {
-    return this.state.doc.toJSON();
-  }
-  /**
-   * Get the document as HTML.
-   */
-  getHTML() {
-    return getHTMLFromFragment(this.state.doc.content, this.schema);
-  }
-  /**
-   * Get the document as text.
-   */
-  getText(options) {
-    const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
-    return getText(this.state.doc, {
-      blockSeparator,
-      textSerializers: {
-        ...getTextSerializersFromSchema(this.schema),
-        ...textSerializers
-      }
-    });
-  }
-  /**
-   * Check if there is no content.
-   */
-  get isEmpty() {
-    return isNodeEmpty(this.state.doc);
-  }
-  /**
-   * Get the number of characters for the current document.
-   *
-   * @deprecated
-   */
-  getCharacterCount() {
-    console.warn('[tiptap warn]: "editor.getCharacterCount()" is deprecated. Please use "editor.storage.characterCount.characters()" instead.');
-    return this.state.doc.content.size - 2;
-  }
-  /**
-   * Destroy the editor.
-   */
-  destroy() {
-    this.emit("destroy");
-    if (this.view) {
-      const dom = this.view.dom;
-      if (dom && dom.editor) {
-        delete dom.editor;
-      }
-      this.view.destroy();
-    }
-    this.removeAllListeners();
-  }
-  /**
-   * Check if the editor is already destroyed.
-   */
-  get isDestroyed() {
-    var _a;
-    return !((_a = this.view) === null || _a === void 0 ? void 0 : _a.docView);
-  }
-  $node(selector, attributes) {
-    var _a;
-    return ((_a = this.$doc) === null || _a === void 0 ? void 0 : _a.querySelector(selector, attributes)) || null;
-  }
-  $nodes(selector, attributes) {
-    var _a;
-    return ((_a = this.$doc) === null || _a === void 0 ? void 0 : _a.querySelectorAll(selector, attributes)) || null;
-  }
-  $pos(pos) {
-    const $pos = this.state.doc.resolve(pos);
-    return new NodePos($pos, this);
-  }
-  get $doc() {
-    return this.$pos(0);
-  }
-};
-function markInputRule(config) {
-  return new InputRule({
-    find: config.find,
-    handler: ({ state, range, match }) => {
-      const attributes = callOrReturn(config.getAttributes, void 0, match);
-      if (attributes === false || attributes === null) {
-        return null;
-      }
-      const { tr } = state;
-      const captureGroup = match[match.length - 1];
-      const fullMatch = match[0];
-      if (captureGroup) {
-        const startSpaces = fullMatch.search(/\S/);
-        const textStart = range.from + fullMatch.indexOf(captureGroup);
-        const textEnd = textStart + captureGroup.length;
-        const excludedMarks = getMarksBetween(range.from, range.to, state.doc).filter((item) => {
-          const excluded = item.mark.type.excluded;
-          return excluded.find((type) => type === config.type && type !== item.mark.type);
-        }).filter((item) => item.to > textStart);
-        if (excludedMarks.length) {
-          return null;
-        }
-        if (textEnd < range.to) {
-          tr.delete(textEnd, range.to);
-        }
-        if (textStart > range.from) {
-          tr.delete(range.from + startSpaces, textStart);
-        }
-        const markEnd = range.from + startSpaces + captureGroup.length;
-        tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
-        tr.removeStoredMark(config.type);
-      }
-    }
-  });
-}
-function nodeInputRule(config) {
-  return new InputRule({
-    find: config.find,
-    handler: ({ state, range, match }) => {
-      const attributes = callOrReturn(config.getAttributes, void 0, match) || {};
-      const { tr } = state;
-      const start = range.from;
-      let end = range.to;
-      const newNode = config.type.create(attributes);
-      if (match[1]) {
-        const offset = match[0].lastIndexOf(match[1]);
-        let matchStart = start + offset;
-        if (matchStart > end) {
-          matchStart = end;
-        } else {
-          end = matchStart + match[1].length;
-        }
-        const lastChar = match[0][match[0].length - 1];
-        tr.insertText(lastChar, start + match[0].length - 1);
-        tr.replaceWith(matchStart, end, newNode);
-      } else if (match[0]) {
-        const insertionStart = config.type.isInline ? start : start - 1;
-        tr.insert(insertionStart, config.type.create(attributes)).delete(tr.mapping.map(start), tr.mapping.map(end));
-      }
-      tr.scrollIntoView();
-    }
-  });
-}
-function textblockTypeInputRule(config) {
-  return new InputRule({
-    find: config.find,
-    handler: ({ state, range, match }) => {
-      const $start = state.doc.resolve(range.from);
-      const attributes = callOrReturn(config.getAttributes, void 0, match) || {};
-      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), config.type)) {
-        return null;
-      }
-      state.tr.delete(range.from, range.to).setBlockType(range.from, range.from, config.type, attributes);
-    }
-  });
-}
-function wrappingInputRule(config) {
-  return new InputRule({
-    find: config.find,
-    handler: ({ state, range, match, chain }) => {
-      const attributes = callOrReturn(config.getAttributes, void 0, match) || {};
-      const tr = state.tr.delete(range.from, range.to);
-      const $start = tr.doc.resolve(range.from);
-      const blockRange = $start.blockRange();
-      const wrapping = blockRange && findWrapping(blockRange, config.type, attributes);
-      if (!wrapping) {
-        return null;
-      }
-      tr.wrap(blockRange, wrapping);
-      if (config.keepMarks && config.editor) {
-        const { selection, storedMarks } = state;
-        const { splittableMarks } = config.editor.extensionManager;
-        const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-        if (marks) {
-          const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-          tr.ensureMarks(filteredMarks);
-        }
-      }
-      if (config.keepAttributes) {
-        const nodeType = config.type.name === "bulletList" || config.type.name === "orderedList" ? "listItem" : "taskList";
-        chain().updateAttributes(nodeType, attributes).run();
-      }
-      const before = tr.doc.resolve(range.from - 1).nodeBefore;
-      if (before && before.type === config.type && canJoin(tr.doc, range.from - 1) && (!config.joinPredicate || config.joinPredicate(match, before))) {
-        tr.join(range.from - 1);
-      }
-    }
-  });
-}
-class Node {
-  constructor(config = {}) {
-    this.type = "node";
-    this.name = "node";
-    this.parent = null;
-    this.child = null;
-    this.config = {
-      name: this.name,
-      defaultOptions: {}
-    };
-    this.config = {
-      ...this.config,
-      ...config
-    };
-    this.name = this.config.name;
-    if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-    }
-    this.options = this.config.defaultOptions;
-    if (this.config.addOptions) {
-      this.options = callOrReturn(getExtensionField(this, "addOptions", {
-        name: this.name
-      }));
-    }
-    this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-      name: this.name,
-      options: this.options
-    })) || {};
-  }
-  static create(config = {}) {
-    return new Node(config);
-  }
-  configure(options = {}) {
-    const extension = this.extend({
-      ...this.config,
-      addOptions: () => {
-        return mergeDeep(this.options, options);
-      }
-    });
-    extension.name = this.name;
-    extension.parent = this.parent;
-    return extension;
-  }
-  extend(extendedConfig = {}) {
-    const extension = new Node(extendedConfig);
-    extension.parent = this;
-    this.child = extension;
-    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-    if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-      console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-    }
-    extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-      name: extension.name
-    }));
-    extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-      name: extension.name,
-      options: extension.options
-    }));
-    return extension;
-  }
-}
-class NodeView {
-  constructor(component, props, options) {
-    this.isDragging = false;
-    this.component = component;
-    this.editor = props.editor;
-    this.options = {
-      stopEvent: null,
-      ignoreMutation: null,
-      ...options
-    };
-    this.extension = props.extension;
-    this.node = props.node;
-    this.decorations = props.decorations;
-    this.innerDecorations = props.innerDecorations;
-    this.view = props.view;
-    this.HTMLAttributes = props.HTMLAttributes;
-    this.getPos = props.getPos;
-    this.mount();
-  }
-  mount() {
-    return;
-  }
-  get dom() {
-    return this.editor.view.dom;
-  }
-  get contentDOM() {
-    return null;
-  }
-  onDragStart(event) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const { view } = this.editor;
-    const target = event.target;
-    const dragHandle = target.nodeType === 3 ? (_a = target.parentElement) === null || _a === void 0 ? void 0 : _a.closest("[data-drag-handle]") : target.closest("[data-drag-handle]");
-    if (!this.dom || ((_b = this.contentDOM) === null || _b === void 0 ? void 0 : _b.contains(target)) || !dragHandle) {
-      return;
-    }
-    let x = 0;
-    let y = 0;
-    if (this.dom !== dragHandle) {
-      const domBox = this.dom.getBoundingClientRect();
-      const handleBox = dragHandle.getBoundingClientRect();
-      const offsetX = (_c = event.offsetX) !== null && _c !== void 0 ? _c : (_d = event.nativeEvent) === null || _d === void 0 ? void 0 : _d.offsetX;
-      const offsetY = (_e = event.offsetY) !== null && _e !== void 0 ? _e : (_f = event.nativeEvent) === null || _f === void 0 ? void 0 : _f.offsetY;
-      x = handleBox.x - domBox.x + offsetX;
-      y = handleBox.y - domBox.y + offsetY;
-    }
-    const clonedNode = this.dom.cloneNode(true);
-    (_g = event.dataTransfer) === null || _g === void 0 ? void 0 : _g.setDragImage(clonedNode, x, y);
-    const pos = this.getPos();
-    if (typeof pos !== "number") {
-      return;
-    }
-    const selection = NodeSelection.create(view.state.doc, pos);
-    const transaction = view.state.tr.setSelection(selection);
-    view.dispatch(transaction);
-  }
-  stopEvent(event) {
-    var _a;
-    if (!this.dom) {
-      return false;
-    }
-    if (typeof this.options.stopEvent === "function") {
-      return this.options.stopEvent({ event });
-    }
-    const target = event.target;
-    const isInElement = this.dom.contains(target) && !((_a = this.contentDOM) === null || _a === void 0 ? void 0 : _a.contains(target));
-    if (!isInElement) {
-      return false;
-    }
-    const isDragEvent = event.type.startsWith("drag");
-    const isDropEvent = event.type === "drop";
-    const isInput = ["INPUT", "BUTTON", "SELECT", "TEXTAREA"].includes(target.tagName) || target.isContentEditable;
-    if (isInput && !isDropEvent && !isDragEvent) {
-      return true;
-    }
-    const { isEditable } = this.editor;
-    const { isDragging } = this;
-    const isDraggable = !!this.node.type.spec.draggable;
-    const isSelectable = NodeSelection.isSelectable(this.node);
-    const isCopyEvent = event.type === "copy";
-    const isPasteEvent = event.type === "paste";
-    const isCutEvent = event.type === "cut";
-    const isClickEvent = event.type === "mousedown";
-    if (!isDraggable && isSelectable && isDragEvent && event.target === this.dom) {
-      event.preventDefault();
-    }
-    if (isDraggable && isDragEvent && !isDragging && event.target === this.dom) {
-      event.preventDefault();
-      return false;
-    }
-    if (isDraggable && isEditable && !isDragging && isClickEvent) {
-      const dragHandle = target.closest("[data-drag-handle]");
-      const isValidDragHandle = dragHandle && (this.dom === dragHandle || this.dom.contains(dragHandle));
-      if (isValidDragHandle) {
-        this.isDragging = true;
-        document.addEventListener("dragend", () => {
-          this.isDragging = false;
-        }, { once: true });
-        document.addEventListener("drop", () => {
-          this.isDragging = false;
-        }, { once: true });
-        document.addEventListener("mouseup", () => {
-          this.isDragging = false;
-        }, { once: true });
-      }
-    }
-    if (isDragging || isDropEvent || isCopyEvent || isPasteEvent || isCutEvent || isClickEvent && isSelectable) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Called when a DOM [mutation](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver) or a selection change happens within the view.
-   * @return `false` if the editor should re-read the selection or re-parse the range around the mutation
-   * @return `true` if it can safely be ignored.
-   */
-  ignoreMutation(mutation) {
-    if (!this.dom || !this.contentDOM) {
-      return true;
-    }
-    if (typeof this.options.ignoreMutation === "function") {
-      return this.options.ignoreMutation({ mutation });
-    }
-    if (this.node.isLeaf || this.node.isAtom) {
-      return true;
-    }
-    if (mutation.type === "selection") {
-      return false;
-    }
-    if (this.dom.contains(mutation.target) && mutation.type === "childList" && (isiOS() || isAndroid()) && this.editor.isFocused) {
-      const changedNodes = [
-        ...Array.from(mutation.addedNodes),
-        ...Array.from(mutation.removedNodes)
-      ];
-      if (changedNodes.every((node) => node.isContentEditable)) {
-        return false;
-      }
-    }
-    if (this.contentDOM === mutation.target && mutation.type === "attributes") {
-      return true;
-    }
-    if (this.contentDOM.contains(mutation.target)) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Update the attributes of the prosemirror node.
-   */
-  updateAttributes(attributes) {
-    this.editor.commands.command(({ tr }) => {
-      const pos = this.getPos();
-      if (typeof pos !== "number") {
-        return false;
-      }
-      tr.setNodeMarkup(pos, void 0, {
-        ...this.node.attrs,
-        ...attributes
-      });
-      return true;
-    });
-  }
-  /**
-   * Delete the node.
-   */
-  deleteNode() {
-    const from = this.getPos();
-    if (typeof from !== "number") {
-      return;
-    }
-    const to = from + this.node.nodeSize;
-    this.editor.commands.deleteRange({ from, to });
-  }
-}
-function markPasteRule(config) {
-  return new PasteRule({
-    find: config.find,
-    handler: ({ state, range, match, pasteEvent }) => {
-      const attributes = callOrReturn(config.getAttributes, void 0, match, pasteEvent);
-      if (attributes === false || attributes === null) {
-        return null;
-      }
-      const { tr } = state;
-      const captureGroup = match[match.length - 1];
-      const fullMatch = match[0];
-      let markEnd = range.to;
-      if (captureGroup) {
-        const startSpaces = fullMatch.search(/\S/);
-        const textStart = range.from + fullMatch.indexOf(captureGroup);
-        const textEnd = textStart + captureGroup.length;
-        const excludedMarks = getMarksBetween(range.from, range.to, state.doc).filter((item) => {
-          const excluded = item.mark.type.excluded;
-          return excluded.find((type) => type === config.type && type !== item.mark.type);
-        }).filter((item) => item.to > textStart);
-        if (excludedMarks.length) {
-          return null;
-        }
-        if (textEnd < range.to) {
-          tr.delete(textEnd, range.to);
-        }
-        if (textStart > range.from) {
-          tr.delete(range.from + startSpaces, textStart);
-        }
-        markEnd = range.from + startSpaces + captureGroup.length;
-        tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
-        tr.removeStoredMark(config.type);
-      }
-    }
-  });
-}
-function escapeForRegEx(string) {
-  return string.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-}
-export {
-  Extension as E,
-  Mark as M,
-  Node as N,
-  markPasteRule as a,
-  markInputRule as b,
-  isNodeSelection as c,
-  getTextSerializersFromSchema as d,
-  combineTransactionSteps as e,
-  getChangedRanges as f,
-  getText as g,
-  findChildrenInRange as h,
-  isTextSelection as i,
-  getMarksBetween as j,
-  getAttributes as k,
-  isNodeEmpty as l,
-  mergeAttributes as m,
-  nodeInputRule as n,
-  escapeForRegEx as o,
-  posToDOMRect as p,
-  NodeView as q,
-  Editor$1 as r,
-  textblockTypeInputRule as t,
-  wrappingInputRule as w
-};