@liveblocks/node-prosemirror 2.18.3 → 2.18.4-uns2

package/dist/index.js

@@ -1,3091 +1,21 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/index.ts
-var _core = require('@liveblocks/core');
-
-// src/version.ts
-var PKG_NAME = "@liveblocks/node-prosemirror";
-var PKG_VERSION = "2.18.3";
-var PKG_FORMAT = "cjs";
-
-// ../../node_modules/@tiptap/core/dist/index.js
-var _state = require('@tiptap/pm/state');
-var _view2 = require('@tiptap/pm/view');
-var _keymap = require('@tiptap/pm/keymap');
-var _model = require('@tiptap/pm/model');
-var _transform = require('@tiptap/pm/transform');
-var _commands = require('@tiptap/pm/commands');
-var _schemalist = require('@tiptap/pm/schema-list');
-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;
-    }
-  };
-}
-var CommandManager = class {
-  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;
-  }
-};
-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 ? 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((style) => style.trim()).filter(Boolean) : [];
-        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const styleMap = /* @__PURE__ */ new Map();
-        existingStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        newStyles.forEach((style) => {
-          const [property, val] = style.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 (0, _model.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 = _model.DOMSerializer.fromSchema(schema).serializeFragment(fragment);
-  const temporaryDocument = document.implementation.createHTMLDocument();
-  const container = temporaryDocument.createElement("div");
-  container.appendChild(documentFragment);
-  return container.innerHTML;
-}
-var 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]";
-}
-var 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 (0, _state.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(_model.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;
-}
-var Mark = 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";
-}
-var 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, "\uFFFC");
-    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;
-}
-var 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 (e) {
-    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 (e) {
-      dropEvent = null;
-    }
-    pasteEvent = typeof ClipboardEvent !== "undefined" ? new ClipboardEvent("paste") : null;
-    return tr;
-  };
-  const plugins = rules.map((rule) => {
-    return new (0, _state.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;
-        };
-        window.addEventListener("dragstart", handleDragstart);
-        return {
-          destroy() {
-            window.removeEventListener("dragstart", handleDragstart);
-          }
-        };
-      },
-      props: {
-        handleDOMEvents: {
-          drop: (view, event) => {
-            isDroppedFromProseMirror = dragSourceElement === view.dom.parentElement;
-            dropEvent = event;
-            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(_model.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));
-}
-var ExtensionManager = 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.keymap.call(void 0, 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);
-      }
-    });
-  }
-};
-var Extension = 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]));
-}
-var ClipboardTextSerializer = Extension.create({
-  name: "clipboardTextSerializer",
-  addOptions() {
-    return {
-      blockSeparator: void 0
-    };
-  },
-  addProseMirrorPlugins() {
-    return [
-      new (0, _state.Plugin)({
-        key: new (0, _state.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
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var 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;
-};
-var clearContent = (emitUpdate = false) => ({ commands: commands2 }) => {
-  return commands2.setContent("", emitUpdate);
-};
-var 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 = _transform.liftTarget.call(void 0, 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;
-};
-var command = (fn) => (props) => {
-  return fn(props);
-};
-var createParagraphNear = () => ({ state, dispatch }) => {
-  return _commands.createParagraphNear.call(void 0, state, dispatch);
-};
-var 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 (0, _state.TextSelection)(tr.doc.resolve(newPos - 1)));
-  return true;
-};
-var 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;
-};
-var 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;
-};
-var deleteRange = (range) => ({ tr, dispatch }) => {
-  const { from, to } = range;
-  if (dispatch) {
-    tr.delete(from, to);
-  }
-  return true;
-};
-var deleteSelection = () => ({ state, dispatch }) => {
-  return _commands.deleteSelection.call(void 0, state, dispatch);
-};
-var enter = () => ({ commands: commands2 }) => {
-  return commands2.keyboardShortcut("Enter");
-};
-var exitCode = () => ({ state, dispatch }) => {
-  return _commands.exitCode.call(void 0, 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;
-}
-var 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 = _state.TextSelection.create(doc, range.from, range.to);
-      tr.setSelection(newSelection);
-    }
-  }
-  return true;
-};
-var 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 _state.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 = _state.Selection.atStart(doc);
-  const selectionAtEnd = _state.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 _state.TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
-  }
-  return _state.TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
-}
-function isiOS() {
-  return [
-    "iPad Simulator",
-    "iPhone Simulator",
-    "iPod Simulator",
-    "iPad",
-    "iPhone",
-    "iPod"
-  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
-}
-var focus = (position = null, options = {}) => ({ editor, view, tr, dispatch }) => {
-  options = {
-    scrollIntoView: true,
-    ...options
-  };
-  const delayedFocus = () => {
-    if (isiOS()) {
-      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;
-};
-var forEach = (items, fn) => (props) => {
-  return items.every((item, index) => fn(item, { ...props, index }));
-};
-var insertContent = (value, options) => ({ tr, commands: commands2 }) => {
-  return commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
-};
-var 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 _model.Node || content instanceof _model.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 _model.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 (0, _model.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) {
-        _model.DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
-      } else {
-        _model.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 = _model.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 _transform.ReplaceStep || step instanceof _transform.ReplaceAroundStep)) {
-    return;
-  }
-  const map = tr.mapping.maps[last];
-  let end = 0;
-  map.forEach((_from, _to, _newFrom, newTo) => {
-    if (end === 0) {
-      end = newTo;
-    }
-  });
-  tr.setSelection(_state.Selection.near(tr.doc.resolve(end), bias));
-}
-var isFragment = (nodeOrFragment) => {
-  return !("type" in nodeOrFragment);
-};
-var 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 _model.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;
-};
-var joinUp = () => ({ state, dispatch }) => {
-  return _commands.joinUp.call(void 0, state, dispatch);
-};
-var joinDown = () => ({ state, dispatch }) => {
-  return _commands.joinDown.call(void 0, state, dispatch);
-};
-var joinBackward = () => ({ state, dispatch }) => {
-  return _commands.joinBackward.call(void 0, state, dispatch);
-};
-var joinForward = () => ({ state, dispatch }) => {
-  return _commands.joinForward.call(void 0, state, dispatch);
-};
-var joinItemBackward = () => ({ state, dispatch, tr }) => {
-  try {
-    const point = _transform.joinPoint.call(void 0, 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 (e) {
-    return false;
-  }
-};
-var joinItemForward = () => ({ state, dispatch, tr }) => {
-  try {
-    const point = _transform.joinPoint.call(void 0, 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 (e) {
-    return false;
-  }
-};
-var joinTextblockBackward = () => ({ state, dispatch }) => {
-  return _commands.joinTextblockBackward.call(void 0, state, dispatch);
-};
-var joinTextblockForward = () => ({ state, dispatch }) => {
-  return _commands.joinTextblockForward.call(void 0, 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;
-}
-var 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;
-}
-var lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  if (!isActive) {
-    return false;
-  }
-  return _commands.lift.call(void 0, state, dispatch);
-};
-var liftEmptyBlock = () => ({ state, dispatch }) => {
-  return _commands.liftEmptyBlock.call(void 0, state, dispatch);
-};
-var liftListItem = (typeOrName) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return _schemalist.liftListItem.call(void 0, type)(state, dispatch);
-};
-var newlineInCode = () => ({ state, dispatch }) => {
-  return _commands.newlineInCode.call(void 0, 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;
-  }, {});
-}
-var 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;
-};
-var scrollIntoView = () => ({ tr, dispatch }) => {
-  if (dispatch) {
-    tr.scrollIntoView();
-  }
-  return true;
-};
-var selectAll = () => ({ tr, commands: commands2 }) => {
-  return commands2.setTextSelection({
-    from: 0,
-    to: tr.doc.content.size
-  });
-};
-var selectNodeBackward = () => ({ state, dispatch }) => {
-  return _commands.selectNodeBackward.call(void 0, state, dispatch);
-};
-var selectNodeForward = () => ({ state, dispatch }) => {
-  return _commands.selectNodeForward.call(void 0, state, dispatch);
-};
-var selectParentNode = () => ({ state, dispatch }) => {
-  return _commands.selectParentNode.call(void 0, state, dispatch);
-};
-var selectTextblockEnd = () => ({ state, dispatch }) => {
-  return _commands.selectTextblockEnd.call(void 0, state, dispatch);
-};
-var selectTextblockStart = () => ({ state, dispatch }) => {
-  return _commands.selectTextblockStart.call(void 0, state, dispatch);
-};
-function createDocument(content, schema, parseOptions = {}, options = {}) {
-  return createNodeFromContent(content, schema, {
-    slice: false,
-    parseOptions,
-    errorOnInvalidContent: options.errorOnInvalidContent
-  });
-}
-var 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 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 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 getSchema(extensions, editor) {
-  const resolvedExtensions = ExtensionManager.resolve(extensions);
-  return getSchemaByResolvedExtensions(resolvedExtensions, editor);
-}
-function getText(node, options) {
-  const range = {
-    from: 0,
-    to: node.content.size
-  };
-  return getTextBetween(node, range, options);
-}
-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 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 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;
-  });
-}
-var 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);
-};
-var setMeta = (key, value) => ({ tr }) => {
-  tr.setMeta(key, value);
-  return true;
-};
-var 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 = _commands.setBlockType.call(void 0, type, { ...attributesToCopy, ...attributes })(state);
-    if (canSetBlock) {
-      return true;
-    }
-    return commands2.clearNodes();
-  }).command(({ state: updatedState }) => {
-    return _commands.setBlockType.call(void 0, type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
-  }).run();
-};
-var setNodeSelection = (position) => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr;
-    const from = minMax(position, 0, doc.content.size);
-    const selection = _state.NodeSelection.create(doc, from);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-var setTextSelection = (position) => ({ tr, dispatch }) => {
-  if (dispatch) {
-    const { doc } = tr;
-    const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
-    const minPos = _state.TextSelection.atStart(doc).from;
-    const maxPos = _state.TextSelection.atEnd(doc).to;
-    const resolvedFrom = minMax(from, minPos, maxPos);
-    const resolvedEnd = minMax(to, minPos, maxPos);
-    const selection = _state.TextSelection.create(doc, resolvedFrom, resolvedEnd);
-    tr.setSelection(selection);
-  }
-  return true;
-};
-var sinkListItem = (typeOrName) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return _schemalist.sinkListItem.call(void 0, 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);
-  }
-}
-var 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 _state.NodeSelection && selection.node.isBlock) {
-    if (!$from.parentOffset || !_transform.canSplit.call(void 0, 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 = _transform.canSplit.call(void 0, tr.doc, tr.mapping.map($from.pos), 1, types);
-  if (!types && !can && _transform.canSplit.call(void 0, 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 _state.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;
-};
-var 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 = _model.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 = _model.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(_model.Fragment.from(type.createAndFill(null, nextType2) || void 0));
-      const start = $from.before($from.depth - (depthBefore - 1));
-      tr.replace(start, $from.after(-depthAfter), new (0, _model.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(_state.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 (!_transform.canSplit.call(void 0, 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;
-};
-var 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) && _transform.canJoin.call(void 0, tr.doc, list.pos);
-  if (!canJoinBackwards) {
-    return true;
-  }
-  tr.join(list.pos);
-  return true;
-};
-var 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) && _transform.canJoin.call(void 0, tr.doc, after);
-  if (!canJoinForwards) {
-    return true;
-  }
-  tr.join(after);
-  return true;
-};
-var 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();
-};
-var toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands: commands2 }) => {
-  const { extendEmptyMarkRange = false } = options;
-  const type = getMarkType(typeOrName, state.schema);
-  const isActive = isMarkActive(state, type, attributes);
-  if (isActive) {
-    return commands2.unsetMark(type, { extendEmptyMarkRange });
-  }
-  return commands2.setMark(type, attributes);
-};
-var toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const toggleType = getNodeType(toggleTypeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  let attributesToCopy;
-  if (state.selection.$anchor.sameParent(state.selection.$head)) {
-    attributesToCopy = state.selection.$anchor.parent.attrs;
-  }
-  if (isActive) {
-    return commands2.setNode(toggleType, attributesToCopy);
-  }
-  return commands2.setNode(type, { ...attributesToCopy, ...attributes });
-};
-var toggleWrap = (typeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  const isActive = isNodeActive(state, type, attributes);
-  if (isActive) {
-    return commands2.lift(type);
-  }
-  return commands2.wrapIn(type, attributes);
-};
-var 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;
-};
-var 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;
-};
-var 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;
-};
-var 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;
-};
-var wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return _commands.wrapIn.call(void 0, type, attributes)(state, dispatch);
-};
-var wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-  const type = getNodeType(typeOrName, state.schema);
-  return _schemalist.wrapInList.call(void 0, 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
-});
-var Commands = Extension.create({
-  name: "commands",
-  addCommands() {
-    return {
-      ...commands
-    };
-  }
-});
-var Drop = Extension.create({
-  name: "drop",
-  addProseMirrorPlugins() {
-    return [
-      new (0, _state.Plugin)({
-        key: new (0, _state.PluginKey)("tiptapDrop"),
-        props: {
-          handleDrop: (_, e, slice, moved) => {
-            this.editor.emit("drop", {
-              editor: this.editor,
-              event: e,
-              slice,
-              moved
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var Editable = Extension.create({
-  name: "editable",
-  addProseMirrorPlugins() {
-    return [
-      new (0, _state.Plugin)({
-        key: new (0, _state.PluginKey)("editable"),
-        props: {
-          editable: () => this.editor.options.editable
-        }
-      })
-    ];
-  }
-});
-var FocusEvents = Extension.create({
-  name: "focusEvents",
-  addProseMirrorPlugins() {
-    const { editor } = this;
-    return [
-      new (0, _state.Plugin)({
-        key: new (0, _state.PluginKey)("focusEvents"),
-        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;
-            }
-          }
-        }
-      })
-    ];
-  }
-});
-var 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 : _state.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 (0, _state.Plugin)({
-        key: new (0, _state.PluginKey)("clearDocument"),
-        appendTransaction: (transactions, oldState, newState) => {
-          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 = _state.Selection.atStart(oldState.doc).from;
-          const allEnd = _state.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;
-        }
-      })
-    ];
-  }
-});
-var Paste = Extension.create({
-  name: "paste",
-  addProseMirrorPlugins() {
-    return [
-      new (0, _state.Plugin)({
-        key: new (0, _state.PluginKey)("tiptapPaste"),
-        props: {
-          handlePaste: (_view, e, slice) => {
-            this.editor.emit("paste", {
-              editor: this.editor,
-              event: e,
-              slice
-            });
-          }
-        }
-      })
-    ];
-  }
-});
-var Tabindex = Extension.create({
-  name: "tabindex",
-  addProseMirrorPlugins() {
-    return [
-      new (0, _state.Plugin)({
-        key: new (0, _state.PluginKey)("tabindex"),
-        props: {
-          attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
-        }
-      })
-    ];
-  }
-});
-var Node = 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;
-  }
-};
+// src/index.ts
+import { detectDupes } from "@liveblocks/core";
 
-// src/document.ts
+// src/version.ts
+var PKG_NAME = "@liveblocks/node-prosemirror";
+var PKG_VERSION = "2.18.4-uns2";
+var PKG_FORMAT = "esm";
 
-var _starterkit = require('@tiptap/starter-kit'); var _starterkit2 = _interopRequireDefault(_starterkit);
-var _prosemirrormarkdown = require('prosemirror-markdown');
-var _yprosemirror = require('y-prosemirror');
-var _yjs = require('yjs');
+// src/document.ts
+import { getSchema, getText } from "@tiptap/core";
+import { EditorState } from "@tiptap/pm/state";
+import StarterKit from "@tiptap/starter-kit";
+import { defaultMarkdownSerializer } from "prosemirror-markdown";
+import { initProseMirrorDoc, updateYFragment } from "y-prosemirror";
+import { applyUpdate, Doc, encodeStateAsUpdate, encodeStateVector } from "yjs";
 
 // src/comment.ts
+import { Mark, mergeAttributes } from "@tiptap/core";
 var LIVEBLOCKS_COMMENT_MARK_TYPE = "liveblocksCommentMark";
 var CommentExtension = Mark.create({
   name: LIVEBLOCKS_COMMENT_MARK_TYPE,
@@ -3125,6 +55,7 @@ var CommentExtension = Mark.create({
 });
 
 // src/mention.ts
+import { mergeAttributes as mergeAttributes2, Node } from "@tiptap/core";
 var LIVEBLOCKS_MENTION_TYPE = "liveblocksMention";
 var MentionExtension = Node.create({
   name: LIVEBLOCKS_MENTION_TYPE,
@@ -3141,7 +72,7 @@ var MentionExtension = Node.create({
     ];
   },
   renderHTML({ HTMLAttributes }) {
-    return ["liveblocks-mention", mergeAttributes(HTMLAttributes)];
+    return ["liveblocks-mention", mergeAttributes2(HTMLAttributes)];
   },
   addAttributes() {
     return {
@@ -3177,7 +108,7 @@ var MentionExtension = Node.create({
 
 // src/document.ts
 var DEFAULT_SCHEMA = getSchema([
-  _starterkit2.default,
+  StarterKit,
   CommentExtension,
   MentionExtension
 ]);
@@ -3185,11 +116,11 @@ var getLiveblocksDocumentState = async (roomId, client, schema, field) => {
   const update = new Uint8Array(
     await client.getYjsDocumentAsBinaryUpdate(roomId)
   );
-  const ydoc = new (0, _yjs.Doc)();
-  _yjs.applyUpdate.call(void 0, ydoc, update);
-  const fragment = ydoc.getXmlFragment(_nullishCoalesce(field, () => ( "default")));
-  const { mapping, doc } = _yprosemirror.initProseMirrorDoc.call(void 0, fragment, schema);
-  const state = _state.EditorState.create({
+  const ydoc = new Doc();
+  applyUpdate(ydoc, update);
+  const fragment = ydoc.getXmlFragment(field ?? "default");
+  const { mapping, doc } = initProseMirrorDoc(fragment, schema);
+  const state = EditorState.create({
     schema,
     doc
   });
@@ -3215,12 +146,12 @@ var createDocumentFromContent = (content, schema) => {
   }
 };
 async function withProsemirrorDocument({ roomId, schema: maybeSchema, client, field }, callback) {
-  const schema = _nullishCoalesce(maybeSchema, () => ( DEFAULT_SCHEMA));
+  const schema = maybeSchema ?? DEFAULT_SCHEMA;
   let liveblocksState = await getLiveblocksDocumentState(
     roomId,
     client,
     schema,
-    _nullishCoalesce(field, () => ( "default"))
+    field ?? "default"
   );
   const val = await callback({
     /**
@@ -3231,7 +162,7 @@ async function withProsemirrorDocument({ roomId, schema: maybeSchema, client, fi
         roomId,
         client,
         schema,
-        _nullishCoalesce(field, () => ( "default"))
+        field ?? "default"
       );
     },
     /**
@@ -3239,12 +170,12 @@ async function withProsemirrorDocument({ roomId, schema: maybeSchema, client, fi
      */
     async update(modifyFn) {
       const { ydoc, fragment, state, mapping } = liveblocksState;
-      const beforeVector = _yjs.encodeStateVector.call(void 0, ydoc);
+      const beforeVector = encodeStateVector(ydoc);
       const afterState = state.apply(modifyFn(state.doc, state.tr));
       ydoc.transact(() => {
-        _yprosemirror.updateYFragment.call(void 0, ydoc, fragment, afterState.doc, mapping);
+        updateYFragment(ydoc, fragment, afterState.doc, mapping);
       });
-      const diffUpdate = _yjs.encodeStateAsUpdate.call(void 0, ydoc, beforeVector);
+      const diffUpdate = encodeStateAsUpdate(ydoc, beforeVector);
       await client.sendYjsBinaryUpdate(roomId, diffUpdate);
       await this.refresh();
     },
@@ -3296,7 +227,7 @@ async function withProsemirrorDocument({ roomId, schema: maybeSchema, client, fi
      * Helper function to return editor state as Markdown. By default it uses the defaultMarkdownSerializer from prosemirror-markdown, but you may pass your own
      */
     toMarkdown(serializer) {
-      return (_nullishCoalesce(serializer, () => ( _prosemirrormarkdown.defaultMarkdownSerializer))).serialize(
+      return (serializer ?? defaultMarkdownSerializer).serialize(
         liveblocksState.state.doc
       );
     },
@@ -3311,8 +242,8 @@ async function withProsemirrorDocument({ roomId, schema: maybeSchema, client, fi
 }
 
 // src/index.ts
-_core.detectDupes.call(void 0, PKG_NAME, PKG_VERSION, PKG_FORMAT);
-
-
-exports.withProsemirrorDocument = withProsemirrorDocument;
+detectDupes(PKG_NAME, PKG_VERSION, PKG_FORMAT);
+export {
+  withProsemirrorDocument
+};
 //# sourceMappingURL=index.js.map