@tiptap/core 2.0.0-beta.21 → 2.0.0-beta.210

package/dist/index.js

@@ -0,0 +1,4311 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/helpers/createChainableState.ts
+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),
+    filterTransaction: state.filterTransaction,
+    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;
+    }
+  };
+}
+
+// src/CommandManager.ts
+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 run3 = () => {
+      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: run3
+    };
+    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;
+    if (state.storedMarks) {
+      tr.setStoredMarks(state.storedMarks);
+    }
+    const props = {
+      tr,
+      editor,
+      view,
+      state: createChainableState({
+        state,
+        transaction: tr
+      }),
+      dispatch: shouldDispatch ? () => void 0 : void 0,
+      chain: () => this.createChain(tr),
+      can: () => this.createCan(tr),
+      get commands() {
+        return Object.fromEntries(
+          Object.entries(rawCommands).map(([name, command2]) => {
+            return [name, (...args) => command2(...args)(props)];
+          })
+        );
+      }
+    };
+    return props;
+  }
+};
+
+// src/Editor.ts
+import {
+  EditorState as EditorState4
+} from "@tiptap/pm/state";
+import { EditorView } from "@tiptap/pm/view";
+
+// src/EventEmitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.callbacks = {};
+  }
+  on(event, fn) {
+    if (!this.callbacks[event]) {
+      this.callbacks[event] = [];
+    }
+    this.callbacks[event].push(fn);
+    return this;
+  }
+  emit(event, ...args) {
+    const callbacks = this.callbacks[event];
+    if (callbacks) {
+      callbacks.forEach((callback) => callback.apply(this, args));
+    }
+    return this;
+  }
+  off(event, fn) {
+    const callbacks = this.callbacks[event];
+    if (callbacks) {
+      if (fn) {
+        this.callbacks[event] = callbacks.filter((callback) => callback !== fn);
+      } else {
+        delete this.callbacks[event];
+      }
+    }
+    return this;
+  }
+  removeAllListeners() {
+    this.callbacks = {};
+  }
+};
+
+// src/ExtensionManager.ts
+import { keymap } from "@tiptap/pm/keymap";
+
+// src/helpers/getExtensionField.ts
+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];
+}
+
+// src/helpers/splitExtensions.ts
+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
+  };
+}
+
+// src/helpers/getAttributesFromExtensions.ts
+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
+    };
+    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 ((attribute == null ? void 0 : attribute.isRequired) && (attribute == null ? void 0 : attribute.default) === void 0) {
+        delete mergedAttr.default;
+      }
+      extensionAttributes.push({
+        type: extension.name,
+        name,
+        attribute: mergedAttr
+      });
+    });
+  });
+  return extensionAttributes;
+}
+
+// src/helpers/getNodeType.ts
+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;
+}
+
+// src/utilities/mergeAttributes.ts
+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") {
+        mergedAttributes[key] = [mergedAttributes[key], value].join(" ");
+      } else if (key === "style") {
+        mergedAttributes[key] = [mergedAttributes[key], value].join("; ");
+      } else {
+        mergedAttributes[key] = value;
+      }
+    });
+    return mergedAttributes;
+  }, {});
+}
+
+// src/helpers/getRenderedAttributes.ts
+function getRenderedAttributes(nodeOrMark, extensionAttributes) {
+  return extensionAttributes.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), {});
+}
+
+// src/helpers/getSchemaByResolvedExtensions.ts
+import { Schema } from "@tiptap/pm/model";
+
+// src/utilities/isFunction.ts
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// src/utilities/callOrReturn.ts
+function callOrReturn(value, context = void 0, ...props) {
+  if (isFunction(value)) {
+    if (context) {
+      return value.bind(context)(...props);
+    }
+    return value(...props);
+  }
+  return value;
+}
+
+// src/utilities/isEmptyObject.ts
+function isEmptyObject(value = {}) {
+  return Object.keys(value).length === 0 && value.constructor === Object;
+}
+
+// src/utilities/fromString.ts
+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;
+}
+
+// src/helpers/injectExtensionAttributesToParseRule.ts
+function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
+  if (parseRule.style) {
+    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 };
+    }
+  };
+}
+
+// src/helpers/getSchemaByResolvedExtensions.ts
+function cleanUpSchemaItem(data) {
+  return Object.fromEntries(
+    Object.entries(data).filter(([key, value]) => {
+      if (key === "attrs" && isEmptyObject(value)) {
+        return false;
+      }
+      return value !== null && value !== void 0;
+    })
+  );
+}
+function getSchemaByResolvedExtensions(extensions) {
+  var _a;
+  const allAttributes = getAttributesFromExtensions(extensions);
+  const { nodeExtensions, markExtensions } = splitExtensions(extensions);
+  const topNode = (_a = nodeExtensions.find((extension) => getExtensionField(extension, "topNode"))) == null ? 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
+      };
+      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)),
+        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 ? void 0 : extensionAttribute.attribute) == null ? 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
+      };
+      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 ? void 0 : extensionAttribute.attribute) == null ? void 0 : _a2.default }];
+          })
+        )
+      });
+      const parseHTML = callOrReturn(
+        getExtensionField(extension, "parseHTML", context)
+      );
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map((parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes));
+      }
+      const renderHTML = getExtensionField(
+        extension,
+        "renderHTML",
+        context
+      );
+      if (renderHTML) {
+        schema.toDOM = (mark) => renderHTML({
+          mark,
+          HTMLAttributes: getRenderedAttributes(mark, extensionAttributes)
+        });
+      }
+      return [extension.name, schema];
+    })
+  );
+  return new Schema({
+    topNode,
+    nodes,
+    marks
+  });
+}
+
+// src/helpers/getSchemaTypeByName.ts
+function getSchemaTypeByName(name, schema) {
+  return schema.nodes[name] || schema.marks[name] || null;
+}
+
+// src/helpers/isExtensionRulesEnabled.ts
+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;
+}
+
+// src/InputRule.ts
+import { Plugin } from "@tiptap/pm/state";
+
+// src/helpers/getTextContentFromNodes.ts
+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 ? void 0 : _b.call(_a, {
+        node,
+        pos,
+        parent,
+        index
+      })) || node.textContent || "%leaf%";
+      textBefore += chunk.slice(0, Math.max(0, sliceEndPos - pos));
+    }
+  );
+  return textBefore;
+};
+
+// src/utilities/isRegExp.ts
+function isRegExp(value) {
+  return Object.prototype.toString.call(value) === "[object RegExp]";
+}
+
+// src/InputRule.ts
+var InputRule = class {
+  constructor(config) {
+    this.find = config.find;
+    this.handler = config.handler;
+  }
+};
+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(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 ($from.parent.type.spec.code || !!((_a = $from.nodeBefore || $from.nodeAfter) == null ? 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, chain, can } = new CommandManager({
+      editor,
+      state
+    });
+    const handler = rule.handler({
+      state,
+      range,
+      match,
+      commands,
+      chain,
+      can
+    });
+    if (handler === null || !tr.steps.length) {
+      return;
+    }
+    tr.setMeta(plugin, {
+      transform: tr,
+      from,
+      to,
+      text
+    });
+    view.dispatch(tr);
+    matched = true;
+  });
+  return matched;
+}
+function inputRulesPlugin(props) {
+  const { editor, rules } = props;
+  const plugin = new Plugin({
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr, prev) {
+        const stored = tr.getMeta(plugin);
+        if (stored) {
+          return stored;
+        }
+        return tr.selectionSet || tr.docChanged ? null : prev;
+      }
+    },
+    props: {
+      handleTextInput(view, from, to, text) {
+        return run({
+          editor,
+          from,
+          to,
+          text,
+          rules,
+          plugin
+        });
+      },
+      handleDOMEvents: {
+        compositionend: (view) => {
+          setTimeout(() => {
+            const { $cursor } = view.state.selection;
+            if ($cursor) {
+              run({
+                editor,
+                from: $cursor.pos,
+                to: $cursor.pos,
+                text: "",
+                rules,
+                plugin
+              });
+            }
+          });
+          return false;
+        }
+      },
+      handleKeyDown(view, event) {
+        if (event.key !== "Enter") {
+          return false;
+        }
+        const { $cursor } = view.state.selection;
+        if ($cursor) {
+          return run({
+            editor,
+            from: $cursor.pos,
+            to: $cursor.pos,
+            text: "\n",
+            rules,
+            plugin
+          });
+        }
+        return false;
+      }
+    },
+    isInputRules: true
+  });
+  return plugin;
+}
+
+// src/PasteRule.ts
+import { Plugin as Plugin2 } from "@tiptap/pm/state";
+
+// src/utilities/isNumber.ts
+function isNumber(value) {
+  return typeof value === "number";
+}
+
+// src/PasteRule.ts
+var PasteRule = class {
+  constructor(config) {
+    this.find = config.find;
+    this.handler = config.handler;
+  }
+};
+var pasteRuleMatcherHandler = (text, find) => {
+  if (isRegExp(find)) {
+    return [...text.matchAll(find)];
+  }
+  const matches = find(text);
+  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 run2(config) {
+  const {
+    editor,
+    state,
+    from,
+    to,
+    rule
+  } = config;
+  const { commands, 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);
+    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,
+        chain,
+        can
+      });
+      handlers.push(handler);
+    });
+  });
+  const success = handlers.every((handler) => handler !== null);
+  return success;
+}
+function pasteRulesPlugin(props) {
+  const { editor, rules } = props;
+  let dragSourceElement = null;
+  let isPastedFromProseMirror = false;
+  let isDroppedFromProseMirror = false;
+  const plugins = rules.map((rule) => {
+    return new Plugin2({
+      view(view) {
+        const handleDragstart = (event) => {
+          var _a;
+          dragSourceElement = ((_a = view.dom.parentElement) == null ? void 0 : _a.contains(event.target)) ? view.dom.parentElement : null;
+        };
+        window.addEventListener("dragstart", handleDragstart);
+        return {
+          destroy() {
+            window.removeEventListener("dragstart", handleDragstart);
+          }
+        };
+      },
+      props: {
+        handleDOMEvents: {
+          drop: (view) => {
+            isDroppedFromProseMirror = dragSourceElement === view.dom.parentElement;
+            return false;
+          },
+          paste: (view, event) => {
+            var _a;
+            const html = (_a = event.clipboardData) == null ? void 0 : _a.getData("text/html");
+            isPastedFromProseMirror = !!(html == null ? 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;
+        if (!isPaste && !isDrop) {
+          return;
+        }
+        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;
+        }
+        const tr = state.tr;
+        const chainableState = createChainableState({
+          state,
+          transaction: tr
+        });
+        const handler = run2({
+          editor,
+          state: chainableState,
+          from: Math.max(from - 1, 0),
+          to: to.b - 1,
+          rule
+        });
+        if (!handler || !tr.steps.length) {
+          return;
+        }
+        return tr;
+      }
+    });
+  });
+  return plugins;
+}
+
+// src/utilities/findDuplicates.ts
+function findDuplicates(items) {
+  const filtered = items.filter((el, index) => items.indexOf(el) !== index);
+  return [...new Set(filtered)];
+}
+
+// src/ExtensionManager.ts
+var ExtensionManager = class {
+  constructor(extensions, editor) {
+    this.splittableMarks = [];
+    this.editor = editor;
+    this.extensions = ExtensionManager.resolve(extensions);
+    this.schema = getSchemaByResolvedExtensions(this.extensions);
+    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 : true;
+        if (keepOnSplit) {
+          this.splittableMarks.push(extension.name);
+        }
+      }
+      const onBeforeCreate = getExtensionField(
+        extension,
+        "onBeforeCreate",
+        context
+      );
+      if (onBeforeCreate) {
+        this.editor.on("beforeCreate", onBeforeCreate);
+      }
+      const onCreate = getExtensionField(extension, "onCreate", context);
+      if (onCreate) {
+        this.editor.on("create", onCreate);
+      }
+      const onUpdate = getExtensionField(extension, "onUpdate", context);
+      if (onUpdate) {
+        this.editor.on("update", onUpdate);
+      }
+      const onSelectionUpdate = getExtensionField(
+        extension,
+        "onSelectionUpdate",
+        context
+      );
+      if (onSelectionUpdate) {
+        this.editor.on("selectionUpdate", onSelectionUpdate);
+      }
+      const onTransaction = getExtensionField(
+        extension,
+        "onTransaction",
+        context
+      );
+      if (onTransaction) {
+        this.editor.on("transaction", onTransaction);
+      }
+      const onFocus = getExtensionField(extension, "onFocus", context);
+      if (onFocus) {
+        this.editor.on("focus", onFocus);
+      }
+      const onBlur = getExtensionField(extension, "onBlur", context);
+      if (onBlur) {
+        this.editor.on("blur", onBlur);
+      }
+      const onDestroy = getExtensionField(extension, "onDestroy", context);
+      if (onDestroy) {
+        this.editor.on("destroy", onDestroy);
+      }
+    });
+  }
+  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;
+  }
+  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);
+  }
+  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 commands() {
+    return this.extensions.reduce((commands, 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 commands;
+      }
+      return {
+        ...commands,
+        ...addCommands()
+      };
+    }, {});
+  }
+  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" && extension.config.exitable) {
+        defaultBindings.ArrowRight = () => Mark.handleExit({ editor, mark: extension });
+      }
+      if (addKeyboardShortcuts) {
+        const bindings = Object.fromEntries(
+          Object.entries(addKeyboardShortcuts()).map(([shortcut, method]) => {
+            return [shortcut, () => method({ editor })];
+          })
+        );
+        defaultBindings = { ...defaultBindings, ...bindings };
+      }
+      const keyMapPlugin = keymap(defaultBindings);
+      plugins.push(keyMapPlugin);
+      const addInputRules = getExtensionField(
+        extension,
+        "addInputRules",
+        context
+      );
+      if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
+        inputRules.push(...addInputRules());
+      }
+      const addPasteRules = getExtensionField(
+        extension,
+        "addPasteRules",
+        context
+      );
+      if (isExtensionRulesEnabled(extension, editor.options.enablePasteRules) && addPasteRules) {
+        pasteRules.push(...addPasteRules());
+      }
+      const addProseMirrorPlugins = getExtensionField(
+        extension,
+        "addProseMirrorPlugins",
+        context
+      );
+      if (addProseMirrorPlugins) {
+        const proseMirrorPlugins = addProseMirrorPlugins();
+        plugins.push(...proseMirrorPlugins);
+      }
+      return plugins;
+    }).flat();
+    return [
+      inputRulesPlugin({
+        editor,
+        rules: inputRules
+      }),
+      ...pasteRulesPlugin({
+        editor,
+        rules: pasteRules
+      }),
+      ...allPlugins
+    ];
+  }
+  get attributes() {
+    return getAttributesFromExtensions(this.extensions);
+  }
+  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) => {
+          const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
+          return addNodeView()({
+            editor,
+            node,
+            getPos,
+            decorations,
+            HTMLAttributes,
+            extension
+          });
+        };
+        return [extension.name, nodeview];
+      })
+    );
+  }
+};
+
+// src/extensions/index.ts
+var extensions_exports = {};
+__export(extensions_exports, {
+  ClipboardTextSerializer: () => ClipboardTextSerializer,
+  Commands: () => Commands,
+  Editable: () => Editable,
+  FocusEvents: () => FocusEvents,
+  Keymap: () => Keymap,
+  Tabindex: () => Tabindex
+});
+
+// src/extensions/clipboardTextSerializer.ts
+import { Plugin as Plugin3, PluginKey } from "@tiptap/pm/state";
+
+// src/utilities/isPlainObject.ts
+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;
+}
+
+// src/utilities/mergeDeep.ts
+function mergeDeep(target, source) {
+  const output = { ...target };
+  if (isPlainObject(target) && isPlainObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isPlainObject(source[key])) {
+        if (!(key in target)) {
+          Object.assign(output, { [key]: source[key] });
+        } else {
+          output[key] = mergeDeep(target[key], source[key]);
+        }
+      } else {
+        Object.assign(output, { [key]: source[key] });
+      }
+    });
+  }
+  return output;
+}
+
+// src/Extension.ts
+var Extension = class {
+  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) {
+      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();
+    extension.options = mergeDeep(this.options, options);
+    extension.storage = callOrReturn(
+      getExtensionField(extension, "addStorage", {
+        name: extension.name,
+        options: extension.options
+      })
+    );
+    return extension;
+  }
+  extend(extendedConfig = {}) {
+    const extension = new Extension(extendedConfig);
+    extension.parent = this;
+    this.child = extension;
+    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
+    if (extendedConfig.defaultOptions) {
+      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/helpers/getTextBetween.ts
+function getTextBetween(startNode, range, options) {
+  const { from, to } = range;
+  const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
+  let text = "";
+  let separated = true;
+  startNode.nodesBetween(from, to, (node, pos, parent, index) => {
+    var _a;
+    const textSerializer = textSerializers == null ? void 0 : textSerializers[node.type.name];
+    if (textSerializer) {
+      if (node.isBlock && !separated) {
+        text += blockSeparator;
+        separated = true;
+      }
+      if (parent) {
+        text += textSerializer({
+          node,
+          pos,
+          parent,
+          index,
+          range
+        });
+      }
+    } else if (node.isText) {
+      text += (_a = node == null ? void 0 : node.text) == null ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
+      separated = false;
+    } else if (node.isBlock && !separated) {
+      text += blockSeparator;
+      separated = true;
+    }
+  });
+  return text;
+}
+
+// src/helpers/getTextSerializersFromSchema.ts
+function getTextSerializersFromSchema(schema) {
+  return Object.fromEntries(
+    Object.entries(schema.nodes).filter(([, node]) => node.spec.toText).map(([name, node]) => [name, node.spec.toText])
+  );
+}
+
+// src/extensions/clipboardTextSerializer.ts
+var ClipboardTextSerializer = Extension.create({
+  name: "clipboardTextSerializer",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin3({
+        key: new PluginKey("clipboardTextSerializer"),
+        props: {
+          clipboardTextSerializer: () => {
+            const { editor } = this;
+            const { state, schema } = editor;
+            const { doc, selection } = state;
+            const { ranges } = selection;
+            const from = Math.min(...ranges.map((range2) => range2.$from.pos));
+            const to = Math.max(...ranges.map((range2) => range2.$to.pos));
+            const textSerializers = getTextSerializersFromSchema(schema);
+            const range = { from, to };
+            return getTextBetween(doc, range, {
+              textSerializers
+            });
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/commands/index.ts
+var commands_exports = {};
+__export(commands_exports, {
+  blur: () => blur,
+  clearContent: () => clearContent,
+  clearNodes: () => clearNodes,
+  command: () => command,
+  createParagraphNear: () => createParagraphNear,
+  deleteCurrentNode: () => deleteCurrentNode,
+  deleteNode: () => deleteNode,
+  deleteRange: () => deleteRange,
+  deleteSelection: () => deleteSelection,
+  enter: () => enter,
+  exitCode: () => exitCode,
+  extendMarkRange: () => extendMarkRange,
+  first: () => first,
+  focus: () => focus,
+  forEach: () => forEach,
+  insertContent: () => insertContent,
+  insertContentAt: () => insertContentAt,
+  joinBackward: () => joinBackward,
+  joinDown: () => joinDown,
+  joinForward: () => joinForward,
+  joinUp: () => joinUp,
+  keyboardShortcut: () => keyboardShortcut,
+  lift: () => lift,
+  liftEmptyBlock: () => liftEmptyBlock,
+  liftListItem: () => liftListItem,
+  newlineInCode: () => newlineInCode,
+  resetAttributes: () => resetAttributes,
+  scrollIntoView: () => scrollIntoView,
+  selectAll: () => selectAll,
+  selectNodeBackward: () => selectNodeBackward,
+  selectNodeForward: () => selectNodeForward,
+  selectParentNode: () => selectParentNode,
+  selectTextblockEnd: () => selectTextblockEnd,
+  selectTextblockStart: () => selectTextblockStart,
+  setContent: () => setContent,
+  setMark: () => setMark,
+  setMeta: () => setMeta,
+  setNode: () => setNode,
+  setNodeSelection: () => setNodeSelection,
+  setTextSelection: () => setTextSelection,
+  sinkListItem: () => sinkListItem,
+  splitBlock: () => splitBlock,
+  splitListItem: () => splitListItem,
+  toggleList: () => toggleList,
+  toggleMark: () => toggleMark,
+  toggleNode: () => toggleNode,
+  toggleWrap: () => toggleWrap,
+  undoInputRule: () => undoInputRule,
+  unsetAllMarks: () => unsetAllMarks,
+  unsetMark: () => unsetMark,
+  updateAttributes: () => updateAttributes,
+  wrapIn: () => wrapIn,
+  wrapInList: () => wrapInList
+});
+
+// src/commands/blur.ts
+var blur = () => ({ editor, view }) => {
+  requestAnimationFrame(() => {
+    var _a;
+    if (!editor.isDestroyed) {
+      view.dom.blur();
+      (_a = window == null ? void 0 : window.getSelection()) == null ? void 0 : _a.removeAllRanges();
+    }
+  });
+  return true;
+};
+
+// src/commands/clearContent.ts
+var clearContent = (emitUpdate = false) => ({ commands }) => {
+  return commands.setContent("", emitUpdate);
+};
+
+// src/commands/clearNodes.ts
+import { liftTarget } from "@tiptap/pm/transform";
+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 = liftTarget(nodeRange);
+      if (node.type.isTextblock) {
+        const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
+        tr.setNodeMarkup(nodeRange.start, defaultType);
+      }
+      if (targetLiftDepth || targetLiftDepth === 0) {
+        tr.lift(nodeRange, targetLiftDepth);
+      }
+    });
+  });
+  return true;
+};
+
+// src/commands/command.ts
+var command = (fn) => (props) => {
+  return fn(props);
+};
+
+// src/commands/createParagraphNear.ts
+import { createParagraphNear as originalCreateParagraphNear } from "@tiptap/pm/commands";
+var createParagraphNear = () => ({ state, dispatch }) => {
+  return originalCreateParagraphNear(state, dispatch);
+};
+
+// src/commands/deleteCurrentNode.ts
+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;
+};
+
+// src/commands/deleteNode.ts
+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;
+};
+
+// src/commands/deleteRange.ts
+var deleteRange = (range) => ({ tr, dispatch }) => {
+  const { from, to } = range;
+  if (dispatch) {
+    tr.delete(from, to);
+  }
+  return true;
+};
+
+// src/commands/deleteSelection.ts
+import { deleteSelection as originalDeleteSelection } from "@tiptap/pm/commands";
+var deleteSelection = () => ({ state, dispatch }) => {
+  return originalDeleteSelection(state, dispatch);
+};
+
+// src/commands/enter.ts
+var enter = () => ({ commands }) => {
+  return commands.keyboardShortcut("Enter");
+};
+
+// src/commands/exitCode.ts
+import { exitCode as originalExitCode } from "@tiptap/pm/commands";
+var exitCode = () => ({ state, dispatch }) => {
+  return originalExitCode(state, dispatch);
+};
+
+// src/commands/extendMarkRange.ts
+import { TextSelection as TextSelection2 } from "@tiptap/pm/state";
+
+// src/utilities/objectIncludes.ts
+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];
+  });
+}
+
+// src/helpers/getMarkRange.ts
+function findMarkInSet(marks, type, attributes = {}) {
+  return marks.find((item) => {
+    return item.type === type && objectIncludes(item.attrs, attributes);
+  });
+}
+function isMarkInSet(marks, type, attributes = {}) {
+  return !!findMarkInSet(marks, type, attributes);
+}
+function getMarkRange($pos, type, attributes = {}) {
+  if (!$pos || !type) {
+    return;
+  }
+  let start = $pos.parent.childAfter($pos.parentOffset);
+  if ($pos.parentOffset === start.offset && start.offset !== 0) {
+    start = $pos.parent.childBefore($pos.parentOffset);
+  }
+  if (!start.node) {
+    return;
+  }
+  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;
+  findMarkInSet([...start.node.marks], type, attributes);
+  while (startIndex > 0 && mark.isInSet($pos.parent.child(startIndex - 1).marks)) {
+    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
+  };
+}
+
+// src/helpers/getMarkType.ts
+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;
+}
+
+// src/commands/extendMarkRange.ts
+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 = TextSelection2.create(doc, range.from, range.to);
+      tr.setSelection(newSelection);
+    }
+  }
+  return true;
+};
+
+// src/commands/first.ts
+var first = (commands) => (props) => {
+  const items = typeof commands === "function" ? commands(props) : commands;
+  for (let i = 0; i < items.length; i += 1) {
+    if (items[i](props)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// src/helpers/isTextSelection.ts
+import { TextSelection as TextSelection3 } from "@tiptap/pm/state";
+function isTextSelection(value) {
+  return value instanceof TextSelection3;
+}
+
+// src/helpers/resolveFocusPosition.ts
+import { Selection, TextSelection as TextSelection4 } from "@tiptap/pm/state";
+
+// src/utilities/minMax.ts
+function minMax(value = 0, min = 0, max = 0) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/helpers/resolveFocusPosition.ts
+function resolveFocusPosition(doc, position = null) {
+  if (!position) {
+    return null;
+  }
+  const selectionAtStart = Selection.atStart(doc);
+  const selectionAtEnd = Selection.atEnd(doc);
+  if (position === "start" || position === true) {
+    return selectionAtStart;
+  }
+  if (position === "end") {
+    return selectionAtEnd;
+  }
+  const minPos = selectionAtStart.from;
+  const maxPos = selectionAtEnd.to;
+  if (position === "all") {
+    return TextSelection4.create(
+      doc,
+      minMax(0, minPos, maxPos),
+      minMax(doc.content.size, minPos, maxPos)
+    );
+  }
+  return TextSelection4.create(
+    doc,
+    minMax(position, minPos, maxPos),
+    minMax(position, minPos, maxPos)
+  );
+}
+
+// src/utilities/isiOS.ts
+function isiOS() {
+  return [
+    "iPad Simulator",
+    "iPhone Simulator",
+    "iPod Simulator",
+    "iPad",
+    "iPhone",
+    "iPod"
+  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
+}
+
+// src/commands/focus.ts
+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 ? 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;
+};
+
+// src/commands/forEach.ts
+var forEach = (items, fn) => (props) => {
+  return items.every((item, index) => fn(item, { ...props, index }));
+};
+
+// src/commands/insertContent.ts
+var insertContent = (value, options) => ({ tr, commands }) => {
+  return commands.insertContentAt(
+    { from: tr.selection.from, to: tr.selection.to },
+    value,
+    options
+  );
+};
+
+// src/helpers/createNodeFromContent.ts
+import {
+  DOMParser,
+  Fragment
+} from "@tiptap/pm/model";
+
+// src/utilities/elementFromString.ts
+function elementFromString(value) {
+  const wrappedValue = `<body>${value}</body>`;
+  return new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
+}
+
+// src/helpers/createNodeFromContent.ts
+function createNodeFromContent(content, schema, options) {
+  options = {
+    slice: true,
+    parseOptions: {},
+    ...options
+  };
+  if (typeof content === "object" && content !== null) {
+    try {
+      if (Array.isArray(content)) {
+        return Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
+      }
+      return schema.nodeFromJSON(content);
+    } catch (error) {
+      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
+      return createNodeFromContent("", schema, options);
+    }
+  }
+  if (typeof content === "string") {
+    const parser = DOMParser.fromSchema(schema);
+    return options.slice ? parser.parseSlice(elementFromString(content), options.parseOptions).content : parser.parse(elementFromString(content), options.parseOptions);
+  }
+  return createNodeFromContent("", schema, options);
+}
+
+// src/helpers/selectionToInsertionEnd.ts
+import { Selection as Selection2 } from "@tiptap/pm/state";
+import { ReplaceAroundStep, ReplaceStep } from "@tiptap/pm/transform";
+function selectionToInsertionEnd(tr, startLen, bias) {
+  const last = tr.steps.length - 1;
+  if (last < startLen) {
+    return;
+  }
+  const step = tr.steps[last];
+  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
+    return;
+  }
+  const map = tr.mapping.maps[last];
+  let end = 0;
+  map.forEach((_from, _to, _newFrom, newTo) => {
+    if (end === 0) {
+      end = newTo;
+    }
+  });
+  tr.setSelection(Selection2.near(tr.doc.resolve(end), bias));
+}
+
+// src/commands/insertContentAt.ts
+var isFragment = (nodeOrFragment) => {
+  return nodeOrFragment.toString().startsWith("<");
+};
+var insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
+  if (dispatch) {
+    options = {
+      parseOptions: {},
+      updateSelection: true,
+      ...options
+    };
+    const content = createNodeFromContent(value, editor.schema, {
+      parseOptions: {
+        preserveWhitespace: "full",
+        ...options.parseOptions
+      }
+    });
+    if (content.toString() === "<>") {
+      return true;
+    }
+    let { from, to } = typeof position === "number" ? { from: position, to: position } : position;
+    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;
+      }
+    }
+    if (isOnlyTextContent) {
+      tr.insertText(value, from, to);
+    } else {
+      tr.replaceWith(from, to, content);
+    }
+    if (options.updateSelection) {
+      selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
+    }
+  }
+  return true;
+};
+
+// src/commands/join.ts
+import {
+  joinBackward as originalJoinBackward,
+  joinDown as originalJoinDown,
+  joinForward as originalJoinForward,
+  joinUp as originalJoinUp
+} from "@tiptap/pm/commands";
+var joinUp = () => ({ state, dispatch }) => {
+  return originalJoinUp(state, dispatch);
+};
+var joinDown = () => ({ state, dispatch }) => {
+  return originalJoinDown(state, dispatch);
+};
+var joinBackward = () => ({ state, dispatch }) => {
+  return originalJoinBackward(state, dispatch);
+};
+var joinForward = () => ({ state, dispatch }) => {
+  return originalJoinForward(state, dispatch);
+};
+
+// src/utilities/isMacOS.ts
+function isMacOS() {
+  return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
+}
+
+// src/commands/keyboardShortcut.ts
+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 ? void 0 : capturedTransaction.steps.forEach((step) => {
+    const newStep = step.map(tr.mapping);
+    if (newStep && dispatch) {
+      tr.maybeStep(newStep);
+    }
+  });
+  return true;
+};
+
+// src/commands/lift.ts
+import { lift as originalLift } from "@tiptap/pm/commands";
+
+// src/helpers/isNodeActive.ts
+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;
+}
+
+// src/commands/lift.ts
+var lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  if (!isActive2) {
+    return false;
+  }
+  return originalLift(state, dispatch);
+};
+
+// src/commands/liftEmptyBlock.ts
+import { liftEmptyBlock as originalLiftEmptyBlock } from "@tiptap/pm/commands";
+var liftEmptyBlock = () => ({ state, dispatch }) => {
+  return originalLiftEmptyBlock(state, dispatch);
+};
+
+// src/commands/liftListItem.ts
+import { liftListItem as originalLiftListItem } from "@tiptap/pm/schema-list";
+var liftListItem = (typeOrName) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return originalLiftListItem(type)(state, dispatch);
+};
+
+// src/commands/newlineInCode.ts
+import { newlineInCode as originalNewlineInCode } from "@tiptap/pm/commands";
+var newlineInCode = () => ({ state, dispatch }) => {
+  return originalNewlineInCode(state, dispatch);
+};
+
+// src/helpers/getSchemaTypeNameByName.ts
+function getSchemaTypeNameByName(name, schema) {
+  if (schema.nodes[name]) {
+    return "node";
+  }
+  if (schema.marks[name]) {
+    return "mark";
+  }
+  return null;
+}
+
+// src/utilities/deleteProps.ts
+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;
+  }, {});
+}
+
+// src/commands/resetAttributes.ts
+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;
+};
+
+// src/commands/scrollIntoView.ts
+var scrollIntoView = () => ({ tr, dispatch }) => {
+  if (dispatch) {
+    tr.scrollIntoView();
+  }
+  return true;
+};
+
+// src/commands/selectAll.ts
+var selectAll = () => ({ tr, commands }) => {
+  return commands.setTextSelection({
+    from: 0,
+    to: tr.doc.content.size
+  });
+};
+
+// src/commands/selectNodeBackward.ts
+import { selectNodeBackward as originalSelectNodeBackward } from "@tiptap/pm/commands";
+var selectNodeBackward = () => ({ state, dispatch }) => {
+  return originalSelectNodeBackward(state, dispatch);
+};
+
+// src/commands/selectNodeForward.ts
+import { selectNodeForward as originalSelectNodeForward } from "@tiptap/pm/commands";
+var selectNodeForward = () => ({ state, dispatch }) => {
+  return originalSelectNodeForward(state, dispatch);
+};
+
+// src/commands/selectParentNode.ts
+import { selectParentNode as originalSelectParentNode } from "@tiptap/pm/commands";
+var selectParentNode = () => ({ state, dispatch }) => {
+  return originalSelectParentNode(state, dispatch);
+};
+
+// src/commands/selectTextblockEnd.ts
+import { selectTextblockEnd as originalSelectTextblockEnd } from "@tiptap/pm/commands";
+var selectTextblockEnd = () => ({ state, dispatch }) => {
+  return originalSelectTextblockEnd(state, dispatch);
+};
+
+// src/commands/selectTextblockStart.ts
+import { selectTextblockStart as originalSelectTextblockStart } from "@tiptap/pm/commands";
+var selectTextblockStart = () => ({ state, dispatch }) => {
+  return originalSelectTextblockStart(state, dispatch);
+};
+
+// src/helpers/createDocument.ts
+function createDocument(content, schema, parseOptions = {}) {
+  return createNodeFromContent(content, schema, { slice: false, parseOptions });
+}
+
+// src/commands/setContent.ts
+var setContent = (content, emitUpdate = false, parseOptions = {}) => ({ tr, editor, dispatch }) => {
+  const { doc } = tr;
+  const document2 = createDocument(content, editor.schema, parseOptions);
+  if (dispatch) {
+    tr.replaceWith(0, doc.content.size, document2).setMeta("preventUpdate", !emitUpdate);
+  }
+  return true;
+};
+
+// src/helpers/combineTransactionSteps.ts
+import { Transform } from "@tiptap/pm/transform";
+function combineTransactionSteps(oldDoc, transactions) {
+  const transform = new Transform(oldDoc);
+  transactions.forEach((transaction) => {
+    transaction.steps.forEach((step) => {
+      transform.step(step);
+    });
+  });
+  return transform;
+}
+
+// src/helpers/defaultBlockAt.ts
+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;
+}
+
+// src/helpers/findChildren.ts
+function findChildren(node, predicate) {
+  const nodesWithPos = [];
+  node.descendants((child, pos) => {
+    if (predicate(child)) {
+      nodesWithPos.push({
+        node: child,
+        pos
+      });
+    }
+  });
+  return nodesWithPos;
+}
+
+// src/helpers/findChildrenInRange.ts
+function findChildrenInRange(node, range, predicate) {
+  const nodesWithPos = [];
+  node.nodesBetween(range.from, range.to, (child, pos) => {
+    if (predicate(child)) {
+      nodesWithPos.push({
+        node: child,
+        pos
+      });
+    }
+  });
+  return nodesWithPos;
+}
+
+// src/helpers/findParentNodeClosestToPos.ts
+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
+      };
+    }
+  }
+}
+
+// src/helpers/findParentNode.ts
+function findParentNode(predicate) {
+  return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
+}
+
+// src/helpers/generateHTML.ts
+import { Node } from "@tiptap/pm/model";
+
+// src/helpers/getHTMLFromFragment.ts
+import { DOMSerializer } from "@tiptap/pm/model";
+function getHTMLFromFragment(fragment, schema) {
+  const documentFragment = DOMSerializer.fromSchema(schema).serializeFragment(fragment);
+  const temporaryDocument = document.implementation.createHTMLDocument();
+  const container = temporaryDocument.createElement("div");
+  container.appendChild(documentFragment);
+  return container.innerHTML;
+}
+
+// src/helpers/getSchema.ts
+function getSchema(extensions) {
+  const resolvedExtensions = ExtensionManager.resolve(extensions);
+  return getSchemaByResolvedExtensions(resolvedExtensions);
+}
+
+// src/helpers/generateHTML.ts
+function generateHTML(doc, extensions) {
+  const schema = getSchema(extensions);
+  const contentNode = Node.fromJSON(schema, doc);
+  return getHTMLFromFragment(contentNode.content, schema);
+}
+
+// src/helpers/generateJSON.ts
+import { DOMParser as DOMParser2 } from "@tiptap/pm/model";
+function generateJSON(html, extensions) {
+  const schema = getSchema(extensions);
+  const dom = elementFromString(html);
+  return DOMParser2.fromSchema(schema).parse(dom).toJSON();
+}
+
+// src/helpers/generateText.ts
+import { Node as Node2 } from "@tiptap/pm/model";
+
+// src/helpers/getText.ts
+function getText(node, options) {
+  const range = {
+    from: 0,
+    to: node.content.size
+  };
+  return getTextBetween(node, range, options);
+}
+
+// src/helpers/generateText.ts
+function generateText(doc, extensions, options) {
+  const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
+  const schema = getSchema(extensions);
+  const contentNode = Node2.fromJSON(schema, doc);
+  return getText(contentNode, {
+    blockSeparator,
+    textSerializers: {
+      ...getTextSerializersFromSchema(schema),
+      ...textSerializers
+    }
+  });
+}
+
+// src/helpers/getMarkAttributes.ts
+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 };
+}
+
+// src/helpers/getNodeAttributes.ts
+function getNodeAttributes(state, typeOrName) {
+  const type = getNodeType(typeOrName, state.schema);
+  const { from, to } = state.selection;
+  const nodes = [];
+  state.doc.nodesBetween(from, to, (node2) => {
+    nodes.push(node2);
+  });
+  const node = nodes.reverse().find((nodeItem) => nodeItem.type.name === type.name);
+  if (!node) {
+    return {};
+  }
+  return { ...node.attrs };
+}
+
+// src/helpers/getAttributes.ts
+function getAttributes(state, typeOrName) {
+  const schemaType = getSchemaTypeNameByName(
+    typeof typeOrName === "string" ? typeOrName : typeOrName.name,
+    state.schema
+  );
+  if (schemaType === "node") {
+    return getNodeAttributes(state, typeOrName);
+  }
+  if (schemaType === "mark") {
+    return getMarkAttributes(state, typeOrName);
+  }
+  return {};
+}
+
+// src/utilities/removeDuplicates.ts
+function removeDuplicates(array, by = JSON.stringify) {
+  const seen = {};
+  return array.filter((item) => {
+    const key = by(item);
+    return Object.prototype.hasOwnProperty.call(seen, key) ? false : seen[key] = true;
+  });
+}
+
+// src/helpers/getChangedRanges.ts
+function simplifyChangedRanges(changes) {
+  const uniqueChanges = removeDuplicates(changes);
+  return uniqueChanges.length === 1 ? uniqueChanges : uniqueChanges.filter((change, index) => {
+    const rest = uniqueChanges.filter((_, i) => i !== index);
+    return !rest.some((otherChange) => {
+      return change.oldRange.from >= otherChange.oldRange.from && change.oldRange.to <= otherChange.oldRange.to && change.newRange.from >= otherChange.newRange.from && change.newRange.to <= otherChange.newRange.to;
+    });
+  });
+}
+function getChangedRanges(transform) {
+  const { mapping, steps } = transform;
+  const changes = [];
+  mapping.maps.forEach((stepMap, index) => {
+    const ranges = [];
+    if (!stepMap.ranges.length) {
+      const { from, to } = steps[index];
+      if (from === void 0 || to === void 0) {
+        return;
+      }
+      ranges.push({ from, to });
+    } else {
+      stepMap.forEach((from, to) => {
+        ranges.push({ from, to });
+      });
+    }
+    ranges.forEach(({ from, to }) => {
+      const newStart = mapping.slice(index).map(from, -1);
+      const newEnd = mapping.slice(index).map(to);
+      const oldStart = mapping.invert().map(newStart, -1);
+      const oldEnd = mapping.invert().map(newEnd);
+      changes.push({
+        oldRange: {
+          from: oldStart,
+          to: oldEnd
+        },
+        newRange: {
+          from: newStart,
+          to: newEnd
+        }
+      });
+    });
+  });
+  return simplifyChangedRanges(changes);
+}
+
+// src/helpers/getDebugJSON.ts
+function getDebugJSON(node, startOffset = 0) {
+  const isTopNode = node.type === node.type.schema.topNodeType;
+  const increment = isTopNode ? 0 : 1;
+  const from = startOffset;
+  const to = from + node.nodeSize;
+  const marks = node.marks.map((mark) => {
+    const output2 = {
+      type: mark.type.name
+    };
+    if (Object.keys(mark.attrs).length) {
+      output2.attrs = { ...mark.attrs };
+    }
+    return output2;
+  });
+  const attrs = { ...node.attrs };
+  const output = {
+    type: node.type.name,
+    from,
+    to
+  };
+  if (Object.keys(attrs).length) {
+    output.attrs = attrs;
+  }
+  if (marks.length) {
+    output.marks = marks;
+  }
+  if (node.content.childCount) {
+    output.content = [];
+    node.forEach((child, offset) => {
+      var _a;
+      (_a = output.content) == null ? void 0 : _a.push(getDebugJSON(child, startOffset + offset + increment));
+    });
+  }
+  if (node.text) {
+    output.text = node.text;
+  }
+  return output;
+}
+
+// src/helpers/getMarksBetween.ts
+function getMarksBetween(from, to, doc) {
+  const marks = [];
+  if (from === to) {
+    doc.resolve(from).marks().forEach((mark) => {
+      const $pos = doc.resolve(from - 1);
+      const range = getMarkRange($pos, mark.type);
+      if (!range) {
+        return;
+      }
+      marks.push({
+        mark,
+        ...range
+      });
+    });
+  } else {
+    doc.nodesBetween(from, to, (node, pos) => {
+      marks.push(
+        ...node.marks.map((mark) => ({
+          from: pos,
+          to: pos + node.nodeSize,
+          mark
+        }))
+      );
+    });
+  }
+  return marks;
+}
+
+// src/helpers/isMarkActive.ts
+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;
+}
+
+// src/helpers/isActive.ts
+function isActive(state, name, attributes = {}) {
+  if (!name) {
+    return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes);
+  }
+  const schemaType = getSchemaTypeNameByName(name, state.schema);
+  if (schemaType === "node") {
+    return isNodeActive(state, name, attributes);
+  }
+  if (schemaType === "mark") {
+    return isMarkActive(state, name, attributes);
+  }
+  return false;
+}
+
+// src/helpers/isList.ts
+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");
+}
+
+// src/helpers/isNodeEmpty.ts
+function isNodeEmpty(node) {
+  var _a;
+  const defaultContent = (_a = node.type.createAndFill()) == null ? void 0 : _a.toJSON();
+  const content = node.toJSON();
+  return JSON.stringify(defaultContent) === JSON.stringify(content);
+}
+
+// src/helpers/isNodeSelection.ts
+import { NodeSelection } from "@tiptap/pm/state";
+function isNodeSelection(value) {
+  return value instanceof NodeSelection;
+}
+
+// src/helpers/posToDOMRect.ts
+function posToDOMRect(view, from, to) {
+  const minPos = 0;
+  const maxPos = view.state.doc.content.size;
+  const resolvedFrom = minMax(from, minPos, maxPos);
+  const resolvedEnd = minMax(to, minPos, maxPos);
+  const start = view.coordsAtPos(resolvedFrom);
+  const end = view.coordsAtPos(resolvedEnd, -1);
+  const top = Math.min(start.top, end.top);
+  const bottom = Math.max(start.bottom, end.bottom);
+  const left = Math.min(start.left, end.left);
+  const right = Math.max(start.right, end.right);
+  const width = right - left;
+  const height = bottom - top;
+  const x = left;
+  const y = top;
+  const data = {
+    top,
+    bottom,
+    left,
+    right,
+    width,
+    height,
+    x,
+    y
+  };
+  return {
+    ...data,
+    toJSON: () => data
+  };
+}
+
+// src/commands/setMark.ts
+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 : 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);
+};
+
+// src/commands/setMeta.ts
+var setMeta = (key, value) => ({ tr }) => {
+  tr.setMeta(key, value);
+  return true;
+};
+
+// src/commands/setNode.ts
+import { setBlockType } from "@tiptap/pm/commands";
+var setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  if (!type.isTextblock) {
+    console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
+    return false;
+  }
+  return chain().command(({ commands }) => {
+    const canSetBlock = setBlockType(type, attributes)(state);
+    if (canSetBlock) {
+      return true;
+    }
+    return commands.clearNodes();
+  }).command(({ state: updatedState }) => {
+    return setBlockType(type, attributes)(updatedState, dispatch);
+  }).run();
+};
+
+// src/commands/setNodeSelection.ts
+import { NodeSelection as NodeSelection2 } from "@tiptap/pm/state";
+var setNodeSelection = (position) => ({ tr, dispatch }) => {
+  if (dispatch) {
+    const { doc } = tr;
+    const from = minMax(position, 0, doc.content.size);
+    const selection = NodeSelection2.create(doc, from);
+    tr.setSelection(selection);
+  }
+  return true;
+};
+
+// src/commands/setTextSelection.ts
+import { TextSelection as TextSelection5 } from "@tiptap/pm/state";
+var setTextSelection = (position) => ({ tr, dispatch }) => {
+  if (dispatch) {
+    const { doc } = tr;
+    const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
+    const minPos = TextSelection5.atStart(doc).from;
+    const maxPos = TextSelection5.atEnd(doc).to;
+    const resolvedFrom = minMax(from, minPos, maxPos);
+    const resolvedEnd = minMax(to, minPos, maxPos);
+    const selection = TextSelection5.create(doc, resolvedFrom, resolvedEnd);
+    tr.setSelection(selection);
+  }
+  return true;
+};
+
+// src/commands/sinkListItem.ts
+import { sinkListItem as originalSinkListItem } from "@tiptap/pm/schema-list";
+var sinkListItem = (typeOrName) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return originalSinkListItem(type)(state, dispatch);
+};
+
+// src/commands/splitBlock.ts
+import { NodeSelection as NodeSelection3, TextSelection as TextSelection6 } from "@tiptap/pm/state";
+import { canSplit } from "@tiptap/pm/transform";
+
+// src/helpers/getSplittedAttributes.ts
+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;
+  }));
+}
+
+// src/commands/splitBlock.ts
+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 ? 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 NodeSelection3 && selection.node.isBlock) {
+    if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
+      return false;
+    }
+    if (dispatch) {
+      if (keepMarks) {
+        ensureMarks(state, editor.extensionManager.splittableMarks);
+      }
+      tr.split($from.pos).scrollIntoView();
+    }
+    return true;
+  }
+  if (!$from.parent.isBlock) {
+    return false;
+  }
+  if (dispatch) {
+    const atEnd = $to.parentOffset === $to.parent.content.size;
+    if (selection instanceof TextSelection6) {
+      tr.deleteSelection();
+    }
+    const deflt = $from.depth === 0 ? void 0 : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
+    let types = atEnd && deflt ? [
+      {
+        type: deflt,
+        attrs: newAttributes
+      }
+    ] : void 0;
+    let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
+    if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
+      can = true;
+      types = deflt ? [
+        {
+          type: deflt,
+          attrs: newAttributes
+        }
+      ] : void 0;
+    }
+    if (can) {
+      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 true;
+};
+
+// src/commands/splitListItem.ts
+import {
+  Fragment as Fragment3,
+  Slice
+} from "@tiptap/pm/model";
+import { TextSelection as TextSelection7 } from "@tiptap/pm/state";
+import { canSplit as canSplit2 } from "@tiptap/pm/transform";
+var splitListItem = (typeOrName) => ({
+  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 = Fragment3.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 = Fragment3.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
+      );
+      const nextType2 = ((_a = type.contentMatch.defaultType) == null ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
+      wrap = wrap.append(Fragment3.from(type.createAndFill(null, nextType2) || void 0));
+      const start = $from.before($from.depth - (depthBefore - 1));
+      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
+      let sel = -1;
+      tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
+        if (sel > -1) {
+          return false;
+        }
+        if (n.isTextblock && n.content.size === 0) {
+          sel = pos + 1;
+        }
+      });
+      if (sel > -1) {
+        tr.setSelection(TextSelection7.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
+  );
+  const newNextTypeAttributes = getSplittedAttributes(
+    extensionAttributes,
+    $from.node().type.name,
+    $from.node().attrs
+  );
+  tr.delete($from.pos, $to.pos);
+  const types = nextType ? [
+    { type, attrs: newTypeAttributes },
+    { type: nextType, attrs: newNextTypeAttributes }
+  ] : [{ type, attrs: newTypeAttributes }];
+  if (!canSplit2(tr.doc, $from.pos, 2)) {
+    return false;
+  }
+  if (dispatch) {
+    tr.split($from.pos, 2, types).scrollIntoView();
+  }
+  return true;
+};
+
+// src/commands/toggleList.ts
+import { canJoin } from "@tiptap/pm/transform";
+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 ? void 0 : nodeBefore.type) && canJoin(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 ? void 0 : nodeAfter.type) && canJoin(tr.doc, after);
+  if (!canJoinForwards) {
+    return true;
+  }
+  tr.join(after);
+  return true;
+};
+var toggleList = (listTypeOrName, itemTypeOrName) => ({
+  editor,
+  tr,
+  state,
+  dispatch,
+  chain,
+  commands,
+  can
+}) => {
+  const { extensions } = editor.extensionManager;
+  const listType = getNodeType(listTypeOrName, state.schema);
+  const itemType = getNodeType(itemTypeOrName, state.schema);
+  const { selection } = state;
+  const { $from, $to } = selection;
+  const range = $from.blockRange($to);
+  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 commands.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();
+    }
+  }
+  return chain().command(() => {
+    const canWrapInList = can().wrapInList(listType);
+    if (canWrapInList) {
+      return true;
+    }
+    return commands.clearNodes();
+  }).wrapInList(listType).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
+};
+
+// src/commands/toggleMark.ts
+var toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands }) => {
+  const { extendEmptyMarkRange = false } = options;
+  const type = getMarkType(typeOrName, state.schema);
+  const isActive2 = isMarkActive(state, type, attributes);
+  if (isActive2) {
+    return commands.unsetMark(type, { extendEmptyMarkRange });
+  }
+  return commands.setMark(type, attributes);
+};
+
+// src/commands/toggleNode.ts
+var toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const toggleType = getNodeType(toggleTypeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  if (isActive2) {
+    return commands.setNode(toggleType);
+  }
+  return commands.setNode(type, attributes);
+};
+
+// src/commands/toggleWrap.ts
+var toggleWrap = (typeOrName, attributes = {}) => ({ state, commands }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  if (isActive2) {
+    return commands.lift(type);
+  }
+  return commands.wrapIn(type, attributes);
+};
+
+// src/commands/undoInputRule.ts
+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;
+};
+
+// src/commands/unsetAllMarks.ts
+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;
+};
+
+// src/commands/unsetMark.ts
+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 ? 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;
+};
+
+// src/commands/updateAttributes.ts
+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;
+      state.doc.nodesBetween(from, to, (node, pos) => {
+        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 trimmedFrom = Math.max(pos, from);
+              const trimmedTo = Math.min(pos + node.nodeSize, to);
+              tr.addMark(
+                trimmedFrom,
+                trimmedTo,
+                markType.create({
+                  ...mark.attrs,
+                  ...attributes
+                })
+              );
+            }
+          });
+        }
+      });
+    });
+  }
+  return true;
+};
+
+// src/commands/wrapIn.ts
+import { wrapIn as originalWrapIn } from "@tiptap/pm/commands";
+var wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return originalWrapIn(type, attributes)(state, dispatch);
+};
+
+// src/commands/wrapInList.ts
+import { wrapInList as originalWrapInList } from "@tiptap/pm/schema-list";
+var wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return originalWrapInList(type, attributes)(state, dispatch);
+};
+
+// src/extensions/commands.ts
+var Commands = Extension.create({
+  name: "commands",
+  addCommands() {
+    return {
+      ...commands_exports
+    };
+  }
+});
+
+// src/extensions/editable.ts
+import { Plugin as Plugin4, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+var Editable = Extension.create({
+  name: "editable",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin4({
+        key: new PluginKey2("editable"),
+        props: {
+          editable: () => this.editor.options.editable
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/focusEvents.ts
+import { Plugin as Plugin5, PluginKey as PluginKey3 } from "@tiptap/pm/state";
+var FocusEvents = Extension.create({
+  name: "focusEvents",
+  addProseMirrorPlugins() {
+    const { editor } = this;
+    return [
+      new Plugin5({
+        key: new PluginKey3("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;
+            }
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/keymap.ts
+import { Plugin as Plugin6, PluginKey as PluginKey4, Selection as Selection3 } from "@tiptap/pm/state";
+var Keymap = Extension.create({
+  name: "keymap",
+  addKeyboardShortcuts() {
+    const handleBackspace = () => this.editor.commands.first(({ commands }) => [
+      () => commands.undoInputRule(),
+      () => commands.command(({ tr }) => {
+        const { selection, doc } = tr;
+        const { empty, $anchor } = selection;
+        const { pos, parent } = $anchor;
+        const isAtStart = Selection3.atStart(doc).from === pos;
+        if (!empty || !isAtStart || !parent.type.isTextblock || parent.textContent.length) {
+          return false;
+        }
+        return commands.clearNodes();
+      }),
+      () => commands.deleteSelection(),
+      () => commands.joinBackward(),
+      () => commands.selectNodeBackward()
+    ]);
+    const handleDelete = () => this.editor.commands.first(({ commands }) => [
+      () => commands.deleteSelection(),
+      () => commands.deleteCurrentNode(),
+      () => commands.joinForward(),
+      () => commands.selectNodeForward()
+    ]);
+    const handleEnter = () => this.editor.commands.first(({ commands }) => [
+      () => commands.newlineInCode(),
+      () => commands.createParagraphNear(),
+      () => commands.liftEmptyBlock(),
+      () => commands.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 [
+      new Plugin6({
+        key: new PluginKey4("clearDocument"),
+        appendTransaction: (transactions, oldState, newState) => {
+          const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
+          if (!docChanges) {
+            return;
+          }
+          const { empty, from, to } = oldState.selection;
+          const allFrom = Selection3.atStart(oldState.doc).from;
+          const allEnd = Selection3.atEnd(oldState.doc).to;
+          const allWasSelected = from === allFrom && to === allEnd;
+          const isEmpty = newState.doc.textBetween(0, newState.doc.content.size, " ", " ").length === 0;
+          if (empty || !allWasSelected || !isEmpty) {
+            return;
+          }
+          const tr = newState.tr;
+          const state = createChainableState({
+            state: newState,
+            transaction: tr
+          });
+          const { commands } = new CommandManager({
+            editor: this.editor,
+            state
+          });
+          commands.clearNodes();
+          if (!tr.steps.length) {
+            return;
+          }
+          return tr;
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/tabindex.ts
+import { Plugin as Plugin7, PluginKey as PluginKey5 } from "@tiptap/pm/state";
+var Tabindex = Extension.create({
+  name: "tabindex",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin7({
+        key: new PluginKey5("tabindex"),
+        props: {
+          attributes: this.editor.isEditable ? { tabindex: "0" } : {}
+        }
+      })
+    ];
+  }
+});
+
+// src/style.ts
+var style = `.ProseMirror {
+  position: relative;
+}
+
+.ProseMirror {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  white-space: break-spaces;
+  -webkit-font-variant-ligatures: none;
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0; /* the above doesn't seem to work in Edge */
+}
+
+.ProseMirror [contenteditable="false"] {
+  white-space: normal;
+}
+
+.ProseMirror [contenteditable="false"] [contenteditable="true"] {
+  white-space: pre-wrap;
+}
+
+.ProseMirror pre {
+  white-space: pre-wrap;
+}
+
+img.ProseMirror-separator {
+  display: inline !important;
+  border: none !important;
+  margin: 0 !important;
+  width: 1px !important;
+  height: 1px !important;
+}
+
+.ProseMirror-gapcursor {
+  display: none;
+  pointer-events: none;
+  position: absolute;
+  margin: 0;
+}
+
+.ProseMirror-gapcursor:after {
+  content: "";
+  display: block;
+  position: absolute;
+  top: -2px;
+  width: 20px;
+  border-top: 1px solid black;
+  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
+}
+
+@keyframes ProseMirror-cursor-blink {
+  to {
+    visibility: hidden;
+  }
+}
+
+.ProseMirror-hideselection *::selection {
+  background: transparent;
+}
+
+.ProseMirror-hideselection *::-moz-selection {
+  background: transparent;
+}
+
+.ProseMirror-hideselection * {
+  caret-color: transparent;
+}
+
+.ProseMirror-focused .ProseMirror-gapcursor {
+  display: block;
+}
+
+.tippy-box[data-animation=fade][data-state=hidden] {
+  opacity: 0
+}`;
+
+// src/utilities/createStyleTag.ts
+function createStyleTag(style2, nonce) {
+  const tipTapStyleTag = document.querySelector("style[data-tiptap-style]");
+  if (tipTapStyleTag !== null) {
+    return tipTapStyleTag;
+  }
+  const styleNode = document.createElement("style");
+  if (nonce) {
+    styleNode.setAttribute("nonce", nonce);
+  }
+  styleNode.setAttribute("data-tiptap-style", "");
+  styleNode.innerHTML = style2;
+  document.getElementsByTagName("head")[0].appendChild(styleNode);
+  return styleNode;
+}
+
+// src/Editor.ts
+var Editor = class extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.isFocused = false;
+    this.extensionStorage = {};
+    this.options = {
+      element: document.createElement("div"),
+      content: "",
+      injectCSS: true,
+      injectNonce: void 0,
+      extensions: [],
+      autofocus: false,
+      editable: true,
+      editorProps: {},
+      parseOptions: {},
+      enableInputRules: true,
+      enablePasteRules: true,
+      enableCoreExtensions: true,
+      onBeforeCreate: () => null,
+      onCreate: () => null,
+      onUpdate: () => null,
+      onSelectionUpdate: () => null,
+      onTransaction: () => null,
+      onFocus: () => null,
+      onBlur: () => null,
+      onDestroy: () => null
+    };
+    this.isCapturingTransaction = false;
+    this.capturedTransaction = null;
+    this.setOptions(options);
+    this.createExtensionManager();
+    this.createCommandManager();
+    this.createSchema();
+    this.on("beforeCreate", this.options.onBeforeCreate);
+    this.emit("beforeCreate", { editor: this });
+    this.createView();
+    this.injectCSS();
+    this.on("create", this.options.onCreate);
+    this.on("update", this.options.onUpdate);
+    this.on("selectionUpdate", this.options.onSelectionUpdate);
+    this.on("transaction", this.options.onTransaction);
+    this.on("focus", this.options.onFocus);
+    this.on("blur", this.options.onBlur);
+    this.on("destroy", this.options.onDestroy);
+    window.setTimeout(() => {
+      if (this.isDestroyed) {
+        return;
+      }
+      this.commands.focus(this.options.autofocus);
+      this.emit("create", { editor: this });
+    }, 0);
+  }
+  get storage() {
+    return this.extensionStorage;
+  }
+  get commands() {
+    return this.commandManager.commands;
+  }
+  chain() {
+    return this.commandManager.chain();
+  }
+  can() {
+    return this.commandManager.can();
+  }
+  injectCSS() {
+    if (this.options.injectCSS && document) {
+      this.css = createStyleTag(style, this.options.injectNonce);
+    }
+  }
+  setOptions(options = {}) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    if (!this.view || !this.state || this.isDestroyed) {
+      return;
+    }
+    if (this.options.editorProps) {
+      this.view.setProps(this.options.editorProps);
+    }
+    this.view.updateState(this.state);
+  }
+  setEditable(editable, emitUpdate = true) {
+    this.setOptions({ editable });
+    if (emitUpdate) {
+      this.emit("update", { editor: this, transaction: this.state.tr });
+    }
+  }
+  get isEditable() {
+    return this.options.editable && this.view && this.view.editable;
+  }
+  get state() {
+    return this.view.state;
+  }
+  registerPlugin(plugin, handlePlugins) {
+    const plugins = isFunction(handlePlugins) ? handlePlugins(plugin, [...this.state.plugins]) : [...this.state.plugins, plugin];
+    const state = this.state.reconfigure({ plugins });
+    this.view.updateState(state);
+  }
+  unregisterPlugin(nameOrPluginKey) {
+    if (this.isDestroyed) {
+      return;
+    }
+    const name = typeof nameOrPluginKey === "string" ? `${nameOrPluginKey}$` : nameOrPluginKey.key;
+    const state = this.state.reconfigure({
+      plugins: this.state.plugins.filter((plugin) => !plugin.key.startsWith(name))
+    });
+    this.view.updateState(state);
+  }
+  createExtensionManager() {
+    const coreExtensions = this.options.enableCoreExtensions ? Object.values(extensions_exports) : [];
+    const allExtensions = [...coreExtensions, ...this.options.extensions].filter((extension) => {
+      return ["extension", "node", "mark"].includes(extension == null ? void 0 : extension.type);
+    });
+    this.extensionManager = new ExtensionManager(allExtensions, this);
+  }
+  createCommandManager() {
+    this.commandManager = new CommandManager({
+      editor: this
+    });
+  }
+  createSchema() {
+    this.schema = this.extensionManager.schema;
+  }
+  createView() {
+    const doc = createDocument(this.options.content, this.schema, this.options.parseOptions);
+    const selection = resolveFocusPosition(doc, this.options.autofocus);
+    this.view = new EditorView(this.options.element, {
+      ...this.options.editorProps,
+      dispatchTransaction: this.dispatchTransaction.bind(this),
+      state: EditorState4.create({
+        doc,
+        selection: selection || void 0
+      })
+    });
+    const newState = this.state.reconfigure({
+      plugins: this.extensionManager.plugins
+    });
+    this.view.updateState(newState);
+    this.createNodeViews();
+    const dom = this.view.dom;
+    dom.editor = this;
+  }
+  createNodeViews() {
+    this.view.setProps({
+      nodeViews: this.extensionManager.nodeViews
+    });
+  }
+  captureTransaction(fn) {
+    this.isCapturingTransaction = true;
+    fn();
+    this.isCapturingTransaction = false;
+    const tr = this.capturedTransaction;
+    this.capturedTransaction = null;
+    return tr;
+  }
+  dispatchTransaction(transaction) {
+    if (this.isCapturingTransaction) {
+      if (!this.capturedTransaction) {
+        this.capturedTransaction = transaction;
+        return;
+      }
+      transaction.steps.forEach((step) => {
+        var _a;
+        return (_a = this.capturedTransaction) == null ? void 0 : _a.step(step);
+      });
+      return;
+    }
+    const state = this.state.apply(transaction);
+    const selectionHasChanged = !this.state.selection.eq(state.selection);
+    this.view.updateState(state);
+    this.emit("transaction", {
+      editor: this,
+      transaction
+    });
+    if (selectionHasChanged) {
+      this.emit("selectionUpdate", {
+        editor: this,
+        transaction
+      });
+    }
+    const focus2 = transaction.getMeta("focus");
+    const blur2 = transaction.getMeta("blur");
+    if (focus2) {
+      this.emit("focus", {
+        editor: this,
+        event: focus2.event,
+        transaction
+      });
+    }
+    if (blur2) {
+      this.emit("blur", {
+        editor: this,
+        event: blur2.event,
+        transaction
+      });
+    }
+    if (!transaction.docChanged || transaction.getMeta("preventUpdate")) {
+      return;
+    }
+    this.emit("update", {
+      editor: this,
+      transaction
+    });
+  }
+  getAttributes(nameOrType) {
+    return getAttributes(this.state, nameOrType);
+  }
+  isActive(nameOrAttributes, attributesOrUndefined) {
+    const name = typeof nameOrAttributes === "string" ? nameOrAttributes : null;
+    const attributes = typeof nameOrAttributes === "string" ? attributesOrUndefined : nameOrAttributes;
+    return isActive(this.state, name, attributes);
+  }
+  getJSON() {
+    return this.state.doc.toJSON();
+  }
+  getHTML() {
+    return getHTMLFromFragment(this.state.doc.content, this.schema);
+  }
+  getText(options) {
+    const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
+    return getText(this.state.doc, {
+      blockSeparator,
+      textSerializers: {
+        ...textSerializers,
+        ...getTextSerializersFromSchema(this.schema)
+      }
+    });
+  }
+  get isEmpty() {
+    return isNodeEmpty(this.state.doc);
+  }
+  getCharacterCount() {
+    console.warn(
+      '[tiptap warn]: "editor.getCharacterCount()" is deprecated. Please use "editor.storage.characterCount.characters()" instead.'
+    );
+    return this.state.doc.content.size - 2;
+  }
+  destroy() {
+    this.emit("destroy");
+    if (this.view) {
+      this.view.destroy();
+    }
+    this.removeAllListeners();
+  }
+  get isDestroyed() {
+    var _a;
+    return !((_a = this.view) == null ? void 0 : _a.docView);
+  }
+};
+
+// src/inputRules/markInputRule.ts
+function markInputRule(config) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      const attributes = callOrReturn(config.getAttributes, void 0, match);
+      if (attributes === false || attributes === null) {
+        return null;
+      }
+      const { tr } = state;
+      const captureGroup = match[match.length - 1];
+      const fullMatch = match[0];
+      let markEnd = range.to;
+      if (captureGroup) {
+        const startSpaces = fullMatch.search(/\S/);
+        const textStart = range.from + fullMatch.indexOf(captureGroup);
+        const textEnd = textStart + captureGroup.length;
+        const excludedMarks = getMarksBetween(range.from, range.to, state.doc).filter((item) => {
+          const excluded = item.mark.type.excluded;
+          return excluded.find((type) => type === config.type && type !== item.mark.type);
+        }).filter((item) => item.to > textStart);
+        if (excludedMarks.length) {
+          return null;
+        }
+        if (textEnd < range.to) {
+          tr.delete(textEnd, range.to);
+        }
+        if (textStart > range.from) {
+          tr.delete(range.from + startSpaces, textStart);
+        }
+        markEnd = range.from + startSpaces + captureGroup.length;
+        tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
+        tr.removeStoredMark(config.type);
+      }
+    }
+  });
+}
+
+// src/inputRules/nodeInputRule.ts
+function nodeInputRule(config) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      const attributes = callOrReturn(config.getAttributes, void 0, match) || {};
+      const { tr } = state;
+      const start = range.from;
+      let end = range.to;
+      if (match[1]) {
+        const offset = match[0].lastIndexOf(match[1]);
+        let matchStart = start + offset;
+        if (matchStart > end) {
+          matchStart = end;
+        } else {
+          end = matchStart + match[1].length;
+        }
+        const lastChar = match[0][match[0].length - 1];
+        tr.insertText(lastChar, start + match[0].length - 1);
+        tr.replaceWith(matchStart, end, config.type.create(attributes));
+      } else if (match[0]) {
+        tr.replaceWith(start, end, config.type.create(attributes));
+      }
+    }
+  });
+}
+
+// src/inputRules/textblockTypeInputRule.ts
+function textblockTypeInputRule(config) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      const $start = state.doc.resolve(range.from);
+      const attributes = callOrReturn(config.getAttributes, void 0, match) || {};
+      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), config.type)) {
+        return null;
+      }
+      state.tr.delete(range.from, range.to).setBlockType(range.from, range.from, config.type, attributes);
+    }
+  });
+}
+
+// src/inputRules/textInputRule.ts
+function textInputRule(config) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      let insert = config.replace;
+      let start = range.from;
+      const end = range.to;
+      if (match[1]) {
+        const offset = match[0].lastIndexOf(match[1]);
+        insert += match[0].slice(offset + match[1].length);
+        start += offset;
+        const cutOff = start - end;
+        if (cutOff > 0) {
+          insert = match[0].slice(offset - cutOff, offset) + insert;
+          start = end;
+        }
+      }
+      state.tr.insertText(insert, start, end);
+    }
+  });
+}
+
+// src/inputRules/wrappingInputRule.ts
+import { canJoin as canJoin2, findWrapping } from "@tiptap/pm/transform";
+function wrappingInputRule(config) {
+  return new InputRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      const attributes = callOrReturn(config.getAttributes, void 0, match) || {};
+      const tr = state.tr.delete(range.from, range.to);
+      const $start = tr.doc.resolve(range.from);
+      const blockRange = $start.blockRange();
+      const wrapping = blockRange && findWrapping(blockRange, config.type, attributes);
+      if (!wrapping) {
+        return null;
+      }
+      tr.wrap(blockRange, wrapping);
+      const before = tr.doc.resolve(range.from - 1).nodeBefore;
+      if (before && before.type === config.type && canJoin2(tr.doc, range.from - 1) && (!config.joinPredicate || config.joinPredicate(match, before))) {
+        tr.join(range.from - 1);
+      }
+    }
+  });
+}
+
+// src/Mark.ts
+var Mark = class {
+  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) {
+      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();
+    extension.options = mergeDeep(this.options, options);
+    extension.storage = callOrReturn(
+      getExtensionField(extension, "addStorage", {
+        name: extension.name,
+        options: extension.options
+      })
+    );
+    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) {
+      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 ? void 0 : m.type.name) === mark.name);
+      if (!isInMark) {
+        return false;
+      }
+      const removeMark = currentMarks.find((m) => (m == null ? void 0 : m.type.name) === mark.name);
+      if (removeMark) {
+        tr.removeStoredMark(removeMark);
+      }
+      tr.insertText(" ", currentPos.pos);
+      editor.view.dispatch(tr);
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/Node.ts
+var Node3 = class {
+  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) {
+      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 Node3(config);
+  }
+  configure(options = {}) {
+    const extension = this.extend();
+    extension.options = mergeDeep(this.options, options);
+    extension.storage = callOrReturn(
+      getExtensionField(extension, "addStorage", {
+        name: extension.name,
+        options: extension.options
+      })
+    );
+    return extension;
+  }
+  extend(extendedConfig = {}) {
+    const extension = new Node3(extendedConfig);
+    extension.parent = this;
+    this.child = extension;
+    extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
+    if (extendedConfig.defaultOptions) {
+      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/NodeView.ts
+import { NodeSelection as NodeSelection4 } from "@tiptap/pm/state";
+var NodeView = class {
+  constructor(component, props, options) {
+    this.isDragging = false;
+    this.component = component;
+    this.editor = props.editor;
+    this.options = {
+      stopEvent: null,
+      ignoreMutation: null,
+      ...options
+    };
+    this.extension = props.extension;
+    this.node = props.node;
+    this.decorations = props.decorations;
+    this.getPos = props.getPos;
+    this.mount();
+  }
+  mount() {
+    return;
+  }
+  get dom() {
+    return this.editor.view.dom;
+  }
+  get contentDOM() {
+    return null;
+  }
+  onDragStart(event) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const { view } = this.editor;
+    const target = event.target;
+    const dragHandle = target.nodeType === 3 ? (_a = target.parentElement) == null ? void 0 : _a.closest("[data-drag-handle]") : target.closest("[data-drag-handle]");
+    if (!this.dom || ((_b = this.contentDOM) == null ? void 0 : _b.contains(target)) || !dragHandle) {
+      return;
+    }
+    let x = 0;
+    let y = 0;
+    if (this.dom !== dragHandle) {
+      const domBox = this.dom.getBoundingClientRect();
+      const handleBox = dragHandle.getBoundingClientRect();
+      const offsetX = (_d = event.offsetX) != null ? _d : (_c = event.nativeEvent) == null ? void 0 : _c.offsetX;
+      const offsetY = (_f = event.offsetY) != null ? _f : (_e = event.nativeEvent) == null ? void 0 : _e.offsetY;
+      x = handleBox.x - domBox.x + offsetX;
+      y = handleBox.y - domBox.y + offsetY;
+    }
+    (_g = event.dataTransfer) == null ? void 0 : _g.setDragImage(this.dom, x, y);
+    const selection = NodeSelection4.create(view.state.doc, this.getPos());
+    const transaction = view.state.tr.setSelection(selection);
+    view.dispatch(transaction);
+  }
+  stopEvent(event) {
+    var _a;
+    if (!this.dom) {
+      return false;
+    }
+    if (typeof this.options.stopEvent === "function") {
+      return this.options.stopEvent({ event });
+    }
+    const target = event.target;
+    const isInElement = this.dom.contains(target) && !((_a = this.contentDOM) == null ? void 0 : _a.contains(target));
+    if (!isInElement) {
+      return false;
+    }
+    const isDropEvent = event.type === "drop";
+    const isInput = ["INPUT", "BUTTON", "SELECT", "TEXTAREA"].includes(target.tagName) || target.isContentEditable;
+    if (isInput && !isDropEvent) {
+      return true;
+    }
+    const { isEditable } = this.editor;
+    const { isDragging } = this;
+    const isDraggable = !!this.node.type.spec.draggable;
+    const isSelectable = NodeSelection4.isSelectable(this.node);
+    const isCopyEvent = event.type === "copy";
+    const isPasteEvent = event.type === "paste";
+    const isCutEvent = event.type === "cut";
+    const isClickEvent = event.type === "mousedown";
+    const isDragEvent = event.type.startsWith("drag");
+    if (!isDraggable && isSelectable && isDragEvent) {
+      event.preventDefault();
+    }
+    if (isDraggable && isDragEvent && !isDragging) {
+      event.preventDefault();
+      return false;
+    }
+    if (isDraggable && isEditable && !isDragging && isClickEvent) {
+      const dragHandle = target.closest("[data-drag-handle]");
+      const isValidDragHandle = dragHandle && (this.dom === dragHandle || this.dom.contains(dragHandle));
+      if (isValidDragHandle) {
+        this.isDragging = true;
+        document.addEventListener(
+          "dragend",
+          () => {
+            this.isDragging = false;
+          },
+          { once: true }
+        );
+        document.addEventListener(
+          "mouseup",
+          () => {
+            this.isDragging = false;
+          },
+          { once: true }
+        );
+      }
+    }
+    if (isDragging || isDropEvent || isCopyEvent || isPasteEvent || isCutEvent || isClickEvent && isSelectable) {
+      return false;
+    }
+    return true;
+  }
+  ignoreMutation(mutation) {
+    if (!this.dom || !this.contentDOM) {
+      return true;
+    }
+    if (typeof this.options.ignoreMutation === "function") {
+      return this.options.ignoreMutation({ mutation });
+    }
+    if (this.node.isLeaf || this.node.isAtom) {
+      return true;
+    }
+    if (mutation.type === "selection") {
+      return false;
+    }
+    if (this.dom.contains(mutation.target) && mutation.type === "childList" && isiOS() && this.editor.isFocused) {
+      const changedNodes = [
+        ...Array.from(mutation.addedNodes),
+        ...Array.from(mutation.removedNodes)
+      ];
+      if (changedNodes.every((node) => node.isContentEditable)) {
+        return false;
+      }
+    }
+    if (this.contentDOM === mutation.target && mutation.type === "attributes") {
+      return true;
+    }
+    if (this.contentDOM.contains(mutation.target)) {
+      return false;
+    }
+    return true;
+  }
+  updateAttributes(attributes) {
+    this.editor.commands.command(({ tr }) => {
+      const pos = this.getPos();
+      tr.setNodeMarkup(pos, void 0, {
+        ...this.node.attrs,
+        ...attributes
+      });
+      return true;
+    });
+  }
+  deleteNode() {
+    const from = this.getPos();
+    const to = from + this.node.nodeSize;
+    this.editor.commands.deleteRange({ from, to });
+  }
+};
+
+// src/pasteRules/markPasteRule.ts
+function markPasteRule(config) {
+  return new PasteRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      const attributes = callOrReturn(config.getAttributes, void 0, match);
+      if (attributes === false || attributes === null) {
+        return null;
+      }
+      const { tr } = state;
+      const captureGroup = match[match.length - 1];
+      const fullMatch = match[0];
+      let markEnd = range.to;
+      if (captureGroup) {
+        const startSpaces = fullMatch.search(/\S/);
+        const textStart = range.from + fullMatch.indexOf(captureGroup);
+        const textEnd = textStart + captureGroup.length;
+        const excludedMarks = getMarksBetween(range.from, range.to, state.doc).filter((item) => {
+          const excluded = item.mark.type.excluded;
+          return excluded.find((type) => type === config.type && type !== item.mark.type);
+        }).filter((item) => item.to > textStart);
+        if (excludedMarks.length) {
+          return null;
+        }
+        if (textEnd < range.to) {
+          tr.delete(textEnd, range.to);
+        }
+        if (textStart > range.from) {
+          tr.delete(range.from + startSpaces, textStart);
+        }
+        markEnd = range.from + startSpaces + captureGroup.length;
+        tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
+        tr.removeStoredMark(config.type);
+      }
+    }
+  });
+}
+
+// src/utilities/escapeForRegEx.ts
+function escapeForRegEx(string) {
+  return string.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+
+// src/utilities/isString.ts
+function isString(value) {
+  return typeof value === "string";
+}
+
+// src/pasteRules/nodePasteRule.ts
+function nodePasteRule(config) {
+  return new PasteRule({
+    find: config.find,
+    handler({ match, chain, range }) {
+      const attributes = callOrReturn(config.getAttributes, void 0, match);
+      if (attributes === false || attributes === null) {
+        return null;
+      }
+      if (match.input) {
+        chain().deleteRange(range).insertContentAt(range.from, {
+          type: config.type.name,
+          attrs: attributes
+        });
+      }
+    }
+  });
+}
+
+// src/pasteRules/textPasteRule.ts
+function textPasteRule(config) {
+  return new PasteRule({
+    find: config.find,
+    handler: ({ state, range, match }) => {
+      let insert = config.replace;
+      let start = range.from;
+      const end = range.to;
+      if (match[1]) {
+        const offset = match[0].lastIndexOf(match[1]);
+        insert += match[0].slice(offset + match[1].length);
+        start += offset;
+        const cutOff = start - end;
+        if (cutOff > 0) {
+          insert = match[0].slice(offset - cutOff, offset) + insert;
+          start = end;
+        }
+      }
+      state.tr.insertText(insert, start, end);
+    }
+  });
+}
+
+// src/Tracker.ts
+var Tracker = class {
+  constructor(transaction) {
+    this.transaction = transaction;
+    this.currentStep = this.transaction.steps.length;
+  }
+  map(position) {
+    let deleted = false;
+    const mappedPosition = this.transaction.steps.slice(this.currentStep).reduce((newPosition, step) => {
+      const mapResult = step.getMap().mapResult(newPosition);
+      if (mapResult.deleted) {
+        deleted = true;
+      }
+      return mapResult.pos;
+    }, position);
+    return {
+      position: mappedPosition,
+      deleted
+    };
+  }
+};
+export {
+  CommandManager,
+  Editor,
+  Extension,
+  InputRule,
+  Mark,
+  Node3 as Node,
+  NodeView,
+  PasteRule,
+  Tracker,
+  callOrReturn,
+  combineTransactionSteps,
+  createStyleTag,
+  defaultBlockAt,
+  deleteProps,
+  elementFromString,
+  escapeForRegEx,
+  extensions_exports as extensions,
+  findChildren,
+  findChildrenInRange,
+  findDuplicates,
+  findParentNode,
+  findParentNodeClosestToPos,
+  fromString,
+  generateHTML,
+  generateJSON,
+  generateText,
+  getAttributes,
+  getChangedRanges,
+  getDebugJSON,
+  getExtensionField,
+  getHTMLFromFragment,
+  getMarkAttributes,
+  getMarkRange,
+  getMarkType,
+  getMarksBetween,
+  getNodeAttributes,
+  getNodeType,
+  getSchema,
+  getText,
+  getTextBetween,
+  getTextContentFromNodes,
+  getTextSerializersFromSchema,
+  inputRulesPlugin,
+  isActive,
+  isEmptyObject,
+  isFunction,
+  isList,
+  isMacOS,
+  isMarkActive,
+  isNodeActive,
+  isNodeEmpty,
+  isNodeSelection,
+  isNumber,
+  isPlainObject,
+  isRegExp,
+  isString,
+  isTextSelection,
+  isiOS,
+  markInputRule,
+  markPasteRule,
+  mergeAttributes,
+  mergeDeep,
+  minMax,
+  nodeInputRule,
+  nodePasteRule,
+  objectIncludes,
+  pasteRulesPlugin,
+  posToDOMRect,
+  removeDuplicates,
+  textInputRule,
+  textPasteRule,
+  textblockTypeInputRule,
+  wrappingInputRule
+};