rte-builder 2.0.0 → 2.0.2

package/dist/index.js

@@ -34,2151 +34,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// node_modules/@tiptap/core/dist/index.js
-function createChainableState(config) {
-  const { state, transaction } = config;
-  let { selection } = transaction;
-  let { doc } = transaction;
-  let { storedMarks } = transaction;
-  return {
-    ...state,
-    apply: state.apply.bind(state),
-    applyTransaction: state.applyTransaction.bind(state),
-    plugins: state.plugins,
-    schema: state.schema,
-    reconfigure: state.reconfigure.bind(state),
-    toJSON: state.toJSON.bind(state),
-    get storedMarks() {
-      return storedMarks;
-    },
-    get selection() {
-      return selection;
-    },
-    get doc() {
-      return doc;
-    },
-    get tr() {
-      selection = transaction.selection;
-      doc = transaction.doc;
-      storedMarks = transaction.storedMarks;
-      return transaction;
-    }
-  };
-}
-function getExtensionField(extension, field, context) {
-  if (extension.config[field] === void 0 && extension.parent) {
-    return getExtensionField(extension.parent, field, context);
-  }
-  if (typeof extension.config[field] === "function") {
-    const value = extension.config[field].bind({
-      ...context,
-      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null
-    });
-    return value;
-  }
-  return extension.config[field];
-}
-function splitExtensions(extensions) {
-  const baseExtensions = extensions.filter((extension) => extension.type === "extension");
-  const nodeExtensions = extensions.filter((extension) => extension.type === "node");
-  const markExtensions = extensions.filter((extension) => extension.type === "mark");
-  return {
-    baseExtensions,
-    nodeExtensions,
-    markExtensions
-  };
-}
-function getNodeType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.nodes[nameOrType]) {
-      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.nodes[nameOrType];
-  }
-  return nameOrType;
-}
-function mergeAttributes(...objects) {
-  return objects.filter((item) => !!item).reduce((items, item) => {
-    const mergedAttributes = { ...items };
-    Object.entries(item).forEach(([key, value]) => {
-      const exists = mergedAttributes[key];
-      if (!exists) {
-        mergedAttributes[key] = value;
-        return;
-      }
-      if (key === "class") {
-        const valueClasses = value ? String(value).split(" ") : [];
-        const existingClasses = mergedAttributes[key] ? mergedAttributes[key].split(" ") : [];
-        const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
-        mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
-      } else if (key === "style") {
-        const newStyles = value ? value.split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const styleMap = /* @__PURE__ */ new Map();
-        existingStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        newStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
-      } else {
-        mergedAttributes[key] = value;
-      }
-    });
-    return mergedAttributes;
-  }, {});
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function callOrReturn(value, context = void 0, ...props) {
-  if (isFunction(value)) {
-    if (context) {
-      return value.bind(context)(...props);
-    }
-    return value(...props);
-  }
-  return value;
-}
-function isRegExp(value) {
-  return Object.prototype.toString.call(value) === "[object RegExp]";
-}
-function getType(value) {
-  return Object.prototype.toString.call(value).slice(8, -1);
-}
-function isPlainObject(value) {
-  if (getType(value) !== "Object") {
-    return false;
-  }
-  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
-}
-function mergeDeep(target, source) {
-  const output = { ...target };
-  if (isPlainObject(target) && isPlainObject(source)) {
-    Object.keys(source).forEach((key) => {
-      if (isPlainObject(source[key]) && isPlainObject(target[key])) {
-        output[key] = mergeDeep(target[key], source[key]);
-      } else {
-        output[key] = source[key];
-      }
-    });
-  }
-  return output;
-}
-function getTextBetween(startNode, range, options) {
-  const { from, to } = range;
-  const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
-  let text = "";
-  startNode.nodesBetween(from, to, (node, pos, parent, index) => {
-    var _a;
-    if (node.isBlock && pos > from) {
-      text += blockSeparator;
-    }
-    const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node.type.name];
-    if (textSerializer) {
-      if (parent) {
-        text += textSerializer({
-          node,
-          pos,
-          parent,
-          index,
-          range
-        });
-      }
-      return false;
-    }
-    if (node.isText) {
-      text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
-    }
-  });
-  return text;
-}
-function getTextSerializersFromSchema(schema) {
-  return Object.fromEntries(Object.entries(schema.nodes).filter(([, node]) => node.spec.toText).map(([name, node]) => [name, node.spec.toText]));
-}
-function objectIncludes(object1, object2, options = { strict: true }) {
-  const keys = Object.keys(object2);
-  if (!keys.length) {
-    return true;
-  }
-  return keys.every((key) => {
-    if (options.strict) {
-      return object2[key] === object1[key];
-    }
-    if (isRegExp(object2[key])) {
-      return object2[key].test(object1[key]);
-    }
-    return object2[key] === object1[key];
-  });
-}
-function findMarkInSet(marks, type, attributes = {}) {
-  return marks.find((item) => {
-    return item.type === type && objectIncludes(
-      // Only check equality for the attributes that are provided
-      Object.fromEntries(Object.keys(attributes).map((k) => [k, item.attrs[k]])),
-      attributes
-    );
-  });
-}
-function isMarkInSet(marks, type, attributes = {}) {
-  return !!findMarkInSet(marks, type, attributes);
-}
-function getMarkRange($pos, type, attributes) {
-  var _a;
-  if (!$pos || !type) {
-    return;
-  }
-  let start = $pos.parent.childAfter($pos.parentOffset);
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    start = $pos.parent.childBefore($pos.parentOffset);
-  }
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    return;
-  }
-  attributes = attributes || ((_a = start.node.marks[0]) === null || _a === void 0 ? void 0 : _a.attrs);
-  const mark = findMarkInSet([...start.node.marks], type, attributes);
-  if (!mark) {
-    return;
-  }
-  let startIndex = start.index;
-  let startPos = $pos.start() + start.offset;
-  let endIndex = startIndex + 1;
-  let endPos = startPos + start.node.nodeSize;
-  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
-    startIndex -= 1;
-    startPos -= $pos.parent.child(startIndex).nodeSize;
-  }
-  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
-    endPos += $pos.parent.child(endIndex).nodeSize;
-    endIndex += 1;
-  }
-  return {
-    from: startPos,
-    to: endPos
-  };
-}
-function getMarkType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.marks[nameOrType]) {
-      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.marks[nameOrType];
-  }
-  return nameOrType;
-}
-function isTextSelection(value) {
-  return value instanceof import_state.TextSelection;
-}
-function minMax(value = 0, min = 0, max = 0) {
-  return Math.min(Math.max(value, min), max);
-}
-function resolveFocusPosition(doc, position = null) {
-  if (!position) {
-    return null;
-  }
-  const selectionAtStart = import_state.Selection.atStart(doc);
-  const selectionAtEnd = import_state.Selection.atEnd(doc);
-  if (position === "start" || position === true) {
-    return selectionAtStart;
-  }
-  if (position === "end") {
-    return selectionAtEnd;
-  }
-  const minPos = selectionAtStart.from;
-  const maxPos = selectionAtEnd.to;
-  if (position === "all") {
-    return import_state.TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
-  }
-  return import_state.TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
-}
-function isAndroid() {
-  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
-}
-function isiOS() {
-  return [
-    "iPad Simulator",
-    "iPhone Simulator",
-    "iPod Simulator",
-    "iPad",
-    "iPhone",
-    "iPod"
-  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
-}
-function isSafari() {
-  return typeof navigator !== "undefined" ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : false;
-}
-function elementFromString(value) {
-  const wrappedValue = `<body>${value}</body>`;
-  const html = new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
-  return removeWhitespaces(html);
-}
-function createNodeFromContent(content, schema, options) {
-  if (content instanceof import_model.Node || content instanceof import_model.Fragment) {
-    return content;
-  }
-  options = {
-    slice: true,
-    parseOptions: {},
-    ...options
-  };
-  const isJSONContent = typeof content === "object" && content !== null;
-  const isTextContent = typeof content === "string";
-  if (isJSONContent) {
-    try {
-      const isArrayContent = Array.isArray(content) && content.length > 0;
-      if (isArrayContent) {
-        return import_model.Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
-      }
-      const node = schema.nodeFromJSON(content);
-      if (options.errorOnInvalidContent) {
-        node.check();
-      }
-      return node;
-    } catch (error) {
-      if (options.errorOnInvalidContent) {
-        throw new Error("[tiptap error]: Invalid JSON content", { cause: error });
-      }
-      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
-      return createNodeFromContent("", schema, options);
-    }
-  }
-  if (isTextContent) {
-    if (options.errorOnInvalidContent) {
-      let hasInvalidContent = false;
-      let invalidContent = "";
-      const contentCheckSchema = new import_model.Schema({
-        topNode: schema.spec.topNode,
-        marks: schema.spec.marks,
-        // Prosemirror's schemas are executed such that: the last to execute, matches last
-        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
-        nodes: schema.spec.nodes.append({
-          __tiptap__private__unknown__catch__all__node: {
-            content: "inline*",
-            group: "block",
-            parseDOM: [
-              {
-                tag: "*",
-                getAttrs: (e) => {
-                  hasInvalidContent = true;
-                  invalidContent = typeof e === "string" ? e : e.outerHTML;
-                  return null;
-                }
-              }
-            ]
-          }
-        })
-      });
-      if (options.slice) {
-        import_model.DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
-      } else {
-        import_model.DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
-      }
-      if (options.errorOnInvalidContent && hasInvalidContent) {
-        throw new Error("[tiptap error]: Invalid HTML content", { cause: new Error(`Invalid element found: ${invalidContent}`) });
-      }
-    }
-    const parser = import_model.DOMParser.fromSchema(schema);
-    if (options.slice) {
-      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
-    }
-    return parser.parse(elementFromString(content), options.parseOptions);
-  }
-  return createNodeFromContent("", schema, options);
-}
-function selectionToInsertionEnd(tr, startLen, bias) {
-  const last = tr.steps.length - 1;
-  if (last < startLen) {
-    return;
-  }
-  const step = tr.steps[last];
-  if (!(step instanceof import_transform.ReplaceStep || step instanceof import_transform.ReplaceAroundStep)) {
-    return;
-  }
-  const map = tr.mapping.maps[last];
-  let end = 0;
-  map.forEach((_from, _to, _newFrom, newTo) => {
-    if (end === 0) {
-      end = newTo;
-    }
-  });
-  tr.setSelection(import_state.Selection.near(tr.doc.resolve(end), bias));
-}
-function isMacOS() {
-  return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
-}
-function normalizeKeyName(name) {
-  const parts = name.split(/-(?!$)/);
-  let result = parts[parts.length - 1];
-  if (result === "Space") {
-    result = " ";
-  }
-  let alt;
-  let ctrl;
-  let shift;
-  let meta;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    const mod = parts[i];
-    if (/^(cmd|meta|m)$/i.test(mod)) {
-      meta = true;
-    } else if (/^a(lt)?$/i.test(mod)) {
-      alt = true;
-    } else if (/^(c|ctrl|control)$/i.test(mod)) {
-      ctrl = true;
-    } else if (/^s(hift)?$/i.test(mod)) {
-      shift = true;
-    } else if (/^mod$/i.test(mod)) {
-      if (isiOS() || isMacOS()) {
-        meta = true;
-      } else {
-        ctrl = true;
-      }
-    } else {
-      throw new Error(`Unrecognized modifier name: ${mod}`);
-    }
-  }
-  if (alt) {
-    result = `Alt-${result}`;
-  }
-  if (ctrl) {
-    result = `Ctrl-${result}`;
-  }
-  if (meta) {
-    result = `Meta-${result}`;
-  }
-  if (shift) {
-    result = `Shift-${result}`;
-  }
-  return result;
-}
-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;
-}
-function getSchemaTypeNameByName(name, schema) {
-  if (schema.nodes[name]) {
-    return "node";
-  }
-  if (schema.marks[name]) {
-    return "mark";
-  }
-  return null;
-}
-function deleteProps(obj, propOrProps) {
-  const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
-  return Object.keys(obj).reduce((newObj, prop) => {
-    if (!props.includes(prop)) {
-      newObj[prop] = obj[prop];
-    }
-    return newObj;
-  }, {});
-}
-function createDocument(content, schema, parseOptions = {}, options = {}) {
-  return createNodeFromContent(content, schema, {
-    slice: false,
-    parseOptions,
-    errorOnInvalidContent: options.errorOnInvalidContent
-  });
-}
-function getMarkAttributes(state, typeOrName) {
-  const type = getMarkType(typeOrName, state.schema);
-  const { from, to, empty } = state.selection;
-  const marks = [];
-  if (empty) {
-    if (state.storedMarks) {
-      marks.push(...state.storedMarks);
-    }
-    marks.push(...state.selection.$head.marks());
-  } else {
-    state.doc.nodesBetween(from, to, (node) => {
-      marks.push(...node.marks);
-    });
-  }
-  const mark = marks.find((markItem) => markItem.type.name === type.name);
-  if (!mark) {
-    return {};
-  }
-  return { ...mark.attrs };
-}
-function defaultBlockAt(match) {
-  for (let i = 0; i < match.edgeCount; i += 1) {
-    const { type } = match.edge(i);
-    if (type.isTextblock && !type.hasRequiredAttrs()) {
-      return type;
-    }
-  }
-  return null;
-}
-function findParentNodeClosestToPos($pos, predicate) {
-  for (let i = $pos.depth; i > 0; i -= 1) {
-    const node = $pos.node(i);
-    if (predicate(node)) {
-      return {
-        pos: i > 0 ? $pos.before(i) : 0,
-        start: $pos.start(i),
-        depth: i,
-        node
-      };
-    }
-  }
-}
-function findParentNode(predicate) {
-  return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
-}
-function getSplittedAttributes(extensionAttributes, typeName, attributes) {
-  return Object.fromEntries(Object.entries(attributes).filter(([name]) => {
-    const extensionAttribute = extensionAttributes.find((item) => {
-      return item.type === typeName && item.name === name;
-    });
-    if (!extensionAttribute) {
-      return false;
-    }
-    return extensionAttribute.attribute.keepOnSplit;
-  }));
-}
-function isMarkActive(state, typeOrName, attributes = {}) {
-  const { empty, ranges } = state.selection;
-  const type = typeOrName ? getMarkType(typeOrName, state.schema) : null;
-  if (empty) {
-    return !!(state.storedMarks || state.selection.$from.marks()).filter((mark) => {
-      if (!type) {
-        return true;
-      }
-      return type.name === mark.type.name;
-    }).find((mark) => objectIncludes(mark.attrs, attributes, { strict: false }));
-  }
-  let selectionRange = 0;
-  const markRanges = [];
-  ranges.forEach(({ $from, $to }) => {
-    const from = $from.pos;
-    const to = $to.pos;
-    state.doc.nodesBetween(from, to, (node, pos) => {
-      if (!node.isText && !node.marks.length) {
-        return;
-      }
-      const relativeFrom = Math.max(from, pos);
-      const relativeTo = Math.min(to, pos + node.nodeSize);
-      const range2 = relativeTo - relativeFrom;
-      selectionRange += range2;
-      markRanges.push(...node.marks.map((mark) => ({
-        mark,
-        from: relativeFrom,
-        to: relativeTo
-      })));
-    });
-  });
-  if (selectionRange === 0) {
-    return false;
-  }
-  const matchedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === markRange.mark.type.name;
-  }).filter((markRange) => objectIncludes(markRange.mark.attrs, attributes, { strict: false })).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const excludedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return markRange.mark.type !== type && markRange.mark.type.excludes(type);
-  }).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const range = matchedRange > 0 ? matchedRange + excludedRange : matchedRange;
-  return range >= selectionRange;
-}
-function isList(name, extensions) {
-  const { nodeExtensions } = splitExtensions(extensions);
-  const extension = nodeExtensions.find((item) => item.name === name);
-  if (!extension) {
-    return false;
-  }
-  const context = {
-    name: extension.name,
-    options: extension.options,
-    storage: extension.storage
-  };
-  const group = callOrReturn(getExtensionField(extension, "group", context));
-  if (typeof group !== "string") {
-    return false;
-  }
-  return group.split(" ").includes("list");
-}
-function isNodeEmpty(node, { checkChildren = true, ignoreWhitespace = false } = {}) {
-  var _a;
-  if (ignoreWhitespace) {
-    if (node.type.name === "hardBreak") {
-      return true;
-    }
-    if (node.isText) {
-      return /^\s*$/m.test((_a = node.text) !== null && _a !== void 0 ? _a : "");
-    }
-  }
-  if (node.isText) {
-    return !node.text;
-  }
-  if (node.isAtom || node.isLeaf) {
-    return false;
-  }
-  if (node.content.childCount === 0) {
-    return true;
-  }
-  if (checkChildren) {
-    let isContentEmpty = true;
-    node.content.forEach((childNode) => {
-      if (isContentEmpty === false) {
-        return;
-      }
-      if (!isNodeEmpty(childNode, { ignoreWhitespace, checkChildren })) {
-        isContentEmpty = false;
-      }
-    });
-    return isContentEmpty;
-  }
-  return false;
-}
-function canSetMark(state, tr, newMarkType) {
-  var _a;
-  const { selection } = tr;
-  let cursor = null;
-  if (isTextSelection(selection)) {
-    cursor = selection.$cursor;
-  }
-  if (cursor) {
-    const currentMarks = (_a = state.storedMarks) !== null && _a !== void 0 ? _a : cursor.marks();
-    return !!newMarkType.isInSet(currentMarks) || !currentMarks.some((mark) => mark.type.excludes(newMarkType));
-  }
-  const { ranges } = selection;
-  return ranges.some(({ $from, $to }) => {
-    let someNodeSupportsMark = $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false;
-    state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
-      if (someNodeSupportsMark) {
-        return false;
-      }
-      if (node.isInline) {
-        const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
-        const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks) || !node.marks.some((otherMark) => otherMark.type.excludes(newMarkType));
-        someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
-      }
-      return !someNodeSupportsMark;
-    });
-    return someNodeSupportsMark;
-  });
-}
-function ensureMarks(state, splittableMarks) {
-  const marks = state.storedMarks || state.selection.$to.parentOffset && state.selection.$from.marks();
-  if (marks) {
-    const filteredMarks = marks.filter((mark) => splittableMarks === null || splittableMarks === void 0 ? void 0 : splittableMarks.includes(mark.type.name));
-    state.tr.ensureMarks(filteredMarks);
-  }
-}
-var import_state, import_view, import_keymap, import_model, import_transform, import_commands, import_schema_list, CommandManager, Extension, ClipboardTextSerializer, blur, clearContent, clearNodes, command, createParagraphNear, cut, deleteCurrentNode, deleteNode, deleteRange, deleteSelection, enter, exitCode, extendMarkRange, first, focus, forEach, insertContent, removeWhitespaces, isFragment, insertContentAt, joinUp, joinDown, joinBackward, joinForward, joinItemBackward, joinItemForward, joinTextblockBackward, joinTextblockForward, keyboardShortcut, lift, liftEmptyBlock, liftListItem, newlineInCode, resetAttributes, scrollIntoView, selectAll, selectNodeBackward, selectNodeForward, selectParentNode, selectTextblockEnd, selectTextblockStart, setContent, setMark, setMeta, setNode, setNodeSelection, setTextSelection, sinkListItem, splitBlock, splitListItem, joinListBackwards, joinListForwards, toggleList, toggleMark, toggleNode, toggleWrap, undoInputRule, unsetAllMarks, unsetMark, updateAttributes, wrapIn, wrapInList, commands, Commands, Drop, Editable, focusEventsPluginKey, FocusEvents, Keymap, Paste, Tabindex, Node;
-var init_dist = __esm({
-  "node_modules/@tiptap/core/dist/index.js"() {
-    "use strict";
-    import_state = require("@tiptap/pm/state");
-    import_view = require("@tiptap/pm/view");
-    import_keymap = require("@tiptap/pm/keymap");
-    import_model = require("@tiptap/pm/model");
-    import_transform = require("@tiptap/pm/transform");
-    import_commands = require("@tiptap/pm/commands");
-    import_schema_list = require("@tiptap/pm/schema-list");
-    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 run = () => {
-          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
-        };
-        return chain;
-      }
-      createCan(startTr) {
-        const { rawCommands, state } = this;
-        const dispatch = false;
-        const tr = startTr || state.tr;
-        const props = this.buildProps(tr, dispatch);
-        const formattedCommands = Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-          return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
-        }));
-        return {
-          ...formattedCommands,
-          chain: () => this.createChain(tr, dispatch)
-        };
-      }
-      buildProps(tr, shouldDispatch = true) {
-        const { rawCommands, editor, state } = this;
-        const { view } = editor;
-        const props = {
-          tr,
-          editor,
-          view,
-          state: createChainableState({
-            state,
-            transaction: tr
-          }),
-          dispatch: shouldDispatch ? () => void 0 : void 0,
-          chain: () => this.createChain(tr, shouldDispatch),
-          can: () => this.createCan(tr),
-          get commands() {
-            return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-              return [name, (...args) => command2(...args)(props)];
-            }));
-          }
-        };
-        return props;
-      }
-    };
-    Extension = class _Extension {
-      constructor(config = {}) {
-        this.type = "extension";
-        this.name = "extension";
-        this.parent = null;
-        this.child = null;
-        this.config = {
-          name: this.name,
-          defaultOptions: {}
-        };
-        this.config = {
-          ...this.config,
-          ...config
-        };
-        this.name = this.config.name;
-        if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-          console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-        }
-        this.options = this.config.defaultOptions;
-        if (this.config.addOptions) {
-          this.options = callOrReturn(getExtensionField(this, "addOptions", {
-            name: this.name
-          }));
-        }
-        this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-          name: this.name,
-          options: this.options
-        })) || {};
-      }
-      static create(config = {}) {
-        return new _Extension(config);
-      }
-      configure(options = {}) {
-        const extension = this.extend({
-          ...this.config,
-          addOptions: () => {
-            return mergeDeep(this.options, options);
-          }
-        });
-        extension.name = this.name;
-        extension.parent = this.parent;
-        return extension;
-      }
-      extend(extendedConfig = {}) {
-        const extension = new _Extension({ ...this.config, ...extendedConfig });
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-        if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-          console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-        }
-        extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-          name: extension.name
-        }));
-        extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-          name: extension.name,
-          options: extension.options
-        }));
-        return extension;
-      }
-    };
-    ClipboardTextSerializer = Extension.create({
-      name: "clipboardTextSerializer",
-      addOptions() {
-        return {
-          blockSeparator: void 0
-        };
-      },
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("clipboardTextSerializer"),
-            props: {
-              clipboardTextSerializer: () => {
-                const { editor } = this;
-                const { state, schema } = editor;
-                const { doc, selection } = state;
-                const { ranges } = selection;
-                const from = Math.min(...ranges.map((range2) => range2.$from.pos));
-                const to = Math.max(...ranges.map((range2) => range2.$to.pos));
-                const textSerializers = getTextSerializersFromSchema(schema);
-                const range = { from, to };
-                return getTextBetween(doc, range, {
-                  ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
-                  textSerializers
-                });
-              }
-            }
-          })
-        ];
-      }
-    });
-    blur = () => ({ editor, view }) => {
-      requestAnimationFrame(() => {
-        var _a;
-        if (!editor.isDestroyed) {
-          view.dom.blur();
-          (_a = window === null || window === void 0 ? void 0 : window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
-        }
-      });
-      return true;
-    };
-    clearContent = (emitUpdate = false) => ({ commands: commands2 }) => {
-      return commands2.setContent("", emitUpdate);
-    };
-    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 = (0, import_transform.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;
-    };
-    command = (fn) => (props) => {
-      return fn(props);
-    };
-    createParagraphNear = () => ({ state, dispatch }) => {
-      return (0, import_commands.createParagraphNear)(state, dispatch);
-    };
-    cut = (originRange, targetPos) => ({ editor, tr }) => {
-      const { state } = editor;
-      const contentSlice = state.doc.slice(originRange.from, originRange.to);
-      tr.deleteRange(originRange.from, originRange.to);
-      const newPos = tr.mapping.map(targetPos);
-      tr.insert(newPos, contentSlice.content);
-      tr.setSelection(new import_state.TextSelection(tr.doc.resolve(Math.max(newPos - 1, 0))));
-      return true;
-    };
-    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;
-    };
-    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;
-    };
-    deleteRange = (range) => ({ tr, dispatch }) => {
-      const { from, to } = range;
-      if (dispatch) {
-        tr.delete(from, to);
-      }
-      return true;
-    };
-    deleteSelection = () => ({ state, dispatch }) => {
-      return (0, import_commands.deleteSelection)(state, dispatch);
-    };
-    enter = () => ({ commands: commands2 }) => {
-      return commands2.keyboardShortcut("Enter");
-    };
-    exitCode = () => ({ state, dispatch }) => {
-      return (0, import_commands.exitCode)(state, dispatch);
-    };
-    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 = import_state.TextSelection.create(doc, range.from, range.to);
-          tr.setSelection(newSelection);
-        }
-      }
-      return true;
-    };
-    first = (commands2) => (props) => {
-      const items = typeof commands2 === "function" ? commands2(props) : commands2;
-      for (let i = 0; i < items.length; i += 1) {
-        if (items[i](props)) {
-          return true;
-        }
-      }
-      return false;
-    };
-    focus = (position = null, options = {}) => ({ editor, view, tr, dispatch }) => {
-      options = {
-        scrollIntoView: true,
-        ...options
-      };
-      const delayedFocus = () => {
-        if (isiOS() || isAndroid()) {
-          view.dom.focus();
-        }
-        requestAnimationFrame(() => {
-          if (!editor.isDestroyed) {
-            view.focus();
-            if (isSafari() && !isiOS() && !isAndroid()) {
-              view.dom.focus({ preventScroll: true });
-            }
-          }
-        });
-      };
-      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;
-    };
-    forEach = (items, fn) => (props) => {
-      return items.every((item, index) => fn(item, { ...props, index }));
-    };
-    insertContent = (value, options) => ({ tr, commands: commands2 }) => {
-      return commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
-    };
-    removeWhitespaces = (node) => {
-      const children = node.childNodes;
-      for (let i = children.length - 1; i >= 0; i -= 1) {
-        const child = children[i];
-        if (child.nodeType === 3 && child.nodeValue && /^(\n\s\s|\n)$/.test(child.nodeValue)) {
-          node.removeChild(child);
-        } else if (child.nodeType === 1) {
-          removeWhitespaces(child);
-        }
-      }
-      return node;
-    };
-    isFragment = (nodeOrFragment) => {
-      return !("type" in nodeOrFragment);
-    };
-    insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
-      var _a;
-      if (dispatch) {
-        options = {
-          parseOptions: editor.options.parseOptions,
-          updateSelection: true,
-          applyInputRules: false,
-          applyPasteRules: false,
-          ...options
-        };
-        let content;
-        const emitContentError = (error) => {
-          editor.emit("contentError", {
-            editor,
-            error,
-            disableCollaboration: () => {
-              if (editor.storage.collaboration) {
-                editor.storage.collaboration.isDisabled = true;
-              }
-            }
-          });
-        };
-        const parseOptions = {
-          preserveWhitespace: "full",
-          ...options.parseOptions
-        };
-        if (!options.errorOnInvalidContent && !editor.options.enableContentCheck && editor.options.emitContentError) {
-          try {
-            createNodeFromContent(value, editor.schema, {
-              parseOptions,
-              errorOnInvalidContent: true
-            });
-          } catch (e) {
-            emitContentError(e);
-          }
-        }
-        try {
-          content = createNodeFromContent(value, editor.schema, {
-            parseOptions,
-            errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-          });
-        } catch (e) {
-          emitContentError(e);
-          return false;
-        }
-        let { from, to } = typeof position === "number" ? { from: position, to: position } : { from: position.from, to: position.to };
-        let isOnlyTextContent = true;
-        let isOnlyBlockContent = true;
-        const nodes = isFragment(content) ? content : [content];
-        nodes.forEach((node) => {
-          node.check();
-          isOnlyTextContent = isOnlyTextContent ? node.isText && node.marks.length === 0 : false;
-          isOnlyBlockContent = isOnlyBlockContent ? node.isBlock : false;
-        });
-        if (from === to && isOnlyBlockContent) {
-          const { parent } = tr.doc.resolve(from);
-          const isEmptyTextBlock = parent.isTextblock && !parent.type.spec.code && !parent.childCount;
-          if (isEmptyTextBlock) {
-            from -= 1;
-            to += 1;
-          }
-        }
-        let newContent;
-        if (isOnlyTextContent) {
-          if (Array.isArray(value)) {
-            newContent = value.map((v) => v.text || "").join("");
-          } else if (value instanceof import_model.Fragment) {
-            let text = "";
-            value.forEach((node) => {
-              if (node.text) {
-                text += node.text;
-              }
-            });
-            newContent = text;
-          } else if (typeof value === "object" && !!value && !!value.text) {
-            newContent = value.text;
-          } else {
-            newContent = value;
-          }
-          tr.insertText(newContent, from, to);
-        } else {
-          newContent = content;
-          tr.replaceWith(from, to, newContent);
-        }
-        if (options.updateSelection) {
-          selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-        }
-        if (options.applyInputRules) {
-          tr.setMeta("applyInputRules", { from, text: newContent });
-        }
-        if (options.applyPasteRules) {
-          tr.setMeta("applyPasteRules", { from, text: newContent });
-        }
-      }
-      return true;
-    };
-    joinUp = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinUp)(state, dispatch);
-    };
-    joinDown = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinDown)(state, dispatch);
-    };
-    joinBackward = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinBackward)(state, dispatch);
-    };
-    joinForward = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinForward)(state, dispatch);
-    };
-    joinItemBackward = () => ({ state, dispatch, tr }) => {
-      try {
-        const point = (0, import_transform.joinPoint)(state.doc, state.selection.$from.pos, -1);
-        if (point === null || point === void 0) {
-          return false;
-        }
-        tr.join(point, 2);
-        if (dispatch) {
-          dispatch(tr);
-        }
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    joinItemForward = () => ({ state, dispatch, tr }) => {
-      try {
-        const point = (0, import_transform.joinPoint)(state.doc, state.selection.$from.pos, 1);
-        if (point === null || point === void 0) {
-          return false;
-        }
-        tr.join(point, 2);
-        if (dispatch) {
-          dispatch(tr);
-        }
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    joinTextblockBackward = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinTextblockBackward)(state, dispatch);
-    };
-    joinTextblockForward = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinTextblockForward)(state, dispatch);
-    };
-    keyboardShortcut = (name) => ({ editor, view, tr, dispatch }) => {
-      const keys = normalizeKeyName(name).split(/-(?!$)/);
-      const key = keys.find((item) => !["Alt", "Ctrl", "Meta", "Shift"].includes(item));
-      const event = new KeyboardEvent("keydown", {
-        key: key === "Space" ? " " : key,
-        altKey: keys.includes("Alt"),
-        ctrlKey: keys.includes("Ctrl"),
-        metaKey: keys.includes("Meta"),
-        shiftKey: keys.includes("Shift"),
-        bubbles: true,
-        cancelable: true
-      });
-      const capturedTransaction = editor.captureTransaction(() => {
-        view.someProp("handleKeyDown", (f) => f(view, event));
-      });
-      capturedTransaction === null || capturedTransaction === void 0 ? void 0 : capturedTransaction.steps.forEach((step) => {
-        const newStep = step.map(tr.mapping);
-        if (newStep && dispatch) {
-          tr.maybeStep(newStep);
-        }
-      });
-      return true;
-    };
-    lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      if (!isActive) {
-        return false;
-      }
-      return (0, import_commands.lift)(state, dispatch);
-    };
-    liftEmptyBlock = () => ({ state, dispatch }) => {
-      return (0, import_commands.liftEmptyBlock)(state, dispatch);
-    };
-    liftListItem = (typeOrName) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return (0, import_schema_list.liftListItem)(type)(state, dispatch);
-    };
-    newlineInCode = () => ({ state, dispatch }) => {
-      return (0, import_commands.newlineInCode)(state, dispatch);
-    };
-    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;
-    };
-    scrollIntoView = () => ({ tr, dispatch }) => {
-      if (dispatch) {
-        tr.scrollIntoView();
-      }
-      return true;
-    };
-    selectAll = () => ({ tr, dispatch }) => {
-      if (dispatch) {
-        const selection = new import_state.AllSelection(tr.doc);
-        tr.setSelection(selection);
-      }
-      return true;
-    };
-    selectNodeBackward = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectNodeBackward)(state, dispatch);
-    };
-    selectNodeForward = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectNodeForward)(state, dispatch);
-    };
-    selectParentNode = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectParentNode)(state, dispatch);
-    };
-    selectTextblockEnd = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectTextblockEnd)(state, dispatch);
-    };
-    selectTextblockStart = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectTextblockStart)(state, dispatch);
-    };
-    setContent = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({ editor, tr, dispatch, commands: commands2 }) => {
-      var _a, _b;
-      const { doc } = tr;
-      if (parseOptions.preserveWhitespace !== "full") {
-        const document2 = createDocument(content, editor.schema, parseOptions, {
-          errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-        });
-        if (dispatch) {
-          tr.replaceWith(0, doc.content.size, document2).setMeta("preventUpdate", !emitUpdate);
-        }
-        return true;
-      }
-      if (dispatch) {
-        tr.setMeta("preventUpdate", !emitUpdate);
-      }
-      return commands2.insertContentAt({ from: 0, to: doc.content.size }, content, {
-        parseOptions,
-        errorOnInvalidContent: (_b = options.errorOnInvalidContent) !== null && _b !== void 0 ? _b : editor.options.enableContentCheck
-      });
-    };
-    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);
-    };
-    setMeta = (key, value) => ({ tr }) => {
-      tr.setMeta(key, value);
-      return true;
-    };
-    setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      let attributesToCopy;
-      if (state.selection.$anchor.sameParent(state.selection.$head)) {
-        attributesToCopy = state.selection.$anchor.parent.attrs;
-      }
-      if (!type.isTextblock) {
-        console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
-        return false;
-      }
-      return chain().command(({ commands: commands2 }) => {
-        const canSetBlock = (0, import_commands.setBlockType)(type, { ...attributesToCopy, ...attributes })(state);
-        if (canSetBlock) {
-          return true;
-        }
-        return commands2.clearNodes();
-      }).command(({ state: updatedState }) => {
-        return (0, import_commands.setBlockType)(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
-      }).run();
-    };
-    setNodeSelection = (position) => ({ tr, dispatch }) => {
-      if (dispatch) {
-        const { doc } = tr;
-        const from = minMax(position, 0, doc.content.size);
-        const selection = import_state.NodeSelection.create(doc, from);
-        tr.setSelection(selection);
-      }
-      return true;
-    };
-    setTextSelection = (position) => ({ tr, dispatch }) => {
-      if (dispatch) {
-        const { doc } = tr;
-        const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
-        const minPos = import_state.TextSelection.atStart(doc).from;
-        const maxPos = import_state.TextSelection.atEnd(doc).to;
-        const resolvedFrom = minMax(from, minPos, maxPos);
-        const resolvedEnd = minMax(to, minPos, maxPos);
-        const selection = import_state.TextSelection.create(doc, resolvedFrom, resolvedEnd);
-        tr.setSelection(selection);
-      }
-      return true;
-    };
-    sinkListItem = (typeOrName) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return (0, import_schema_list.sinkListItem)(type)(state, dispatch);
-    };
-    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 import_state.NodeSelection && selection.node.isBlock) {
-        if (!$from.parentOffset || !(0, import_transform.canSplit)(doc, $from.pos)) {
-          return false;
-        }
-        if (dispatch) {
-          if (keepMarks) {
-            ensureMarks(state, editor.extensionManager.splittableMarks);
-          }
-          tr.split($from.pos).scrollIntoView();
-        }
-        return true;
-      }
-      if (!$from.parent.isBlock) {
-        return false;
-      }
-      const atEnd = $to.parentOffset === $to.parent.content.size;
-      const deflt = $from.depth === 0 ? void 0 : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-      let types = atEnd && deflt ? [
-        {
-          type: deflt,
-          attrs: newAttributes
-        }
-      ] : void 0;
-      let can = (0, import_transform.canSplit)(tr.doc, tr.mapping.map($from.pos), 1, types);
-      if (!types && !can && (0, import_transform.canSplit)(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
-        can = true;
-        types = deflt ? [
-          {
-            type: deflt,
-            attrs: newAttributes
-          }
-        ] : void 0;
-      }
-      if (dispatch) {
-        if (can) {
-          if (selection instanceof import_state.TextSelection) {
-            tr.deleteSelection();
-          }
-          tr.split(tr.mapping.map($from.pos), 1, types);
-          if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
-            const first2 = tr.mapping.map($from.before());
-            const $first = tr.doc.resolve(first2);
-            if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
-              tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
-            }
-          }
-        }
-        if (keepMarks) {
-          ensureMarks(state, editor.extensionManager.splittableMarks);
-        }
-        tr.scrollIntoView();
-      }
-      return can;
-    };
-    splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor }) => {
-      var _a;
-      const type = getNodeType(typeOrName, state.schema);
-      const { $from, $to } = state.selection;
-      const node = state.selection.node;
-      if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
-        return false;
-      }
-      const grandParent = $from.node(-1);
-      if (grandParent.type !== type) {
-        return false;
-      }
-      const extensionAttributes = editor.extensionManager.attributes;
-      if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-        if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
-          return false;
-        }
-        if (dispatch) {
-          let wrap = import_model.Fragment.empty;
-          const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
-          for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
-            wrap = import_model.Fragment.from($from.node(d).copy(wrap));
-          }
-          const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
-          const newNextTypeAttributes2 = {
-            ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-            ...overrideAttrs
-          };
-          const nextType2 = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
-          wrap = wrap.append(import_model.Fragment.from(type.createAndFill(null, nextType2) || void 0));
-          const start = $from.before($from.depth - (depthBefore - 1));
-          tr.replace(start, $from.after(-depthAfter), new import_model.Slice(wrap, 4 - depthBefore, 0));
-          let sel = -1;
-          tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
-            if (sel > -1) {
-              return false;
-            }
-            if (n.isTextblock && n.content.size === 0) {
-              sel = pos + 1;
-            }
-          });
-          if (sel > -1) {
-            tr.setSelection(import_state.TextSelection.near(tr.doc.resolve(sel)));
-          }
-          tr.scrollIntoView();
-        }
-        return true;
-      }
-      const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-      const newTypeAttributes = {
-        ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
-        ...overrideAttrs
-      };
-      const newNextTypeAttributes = {
-        ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-        ...overrideAttrs
-      };
-      tr.delete($from.pos, $to.pos);
-      const types = nextType ? [
-        { type, attrs: newTypeAttributes },
-        { type: nextType, attrs: newNextTypeAttributes }
-      ] : [{ type, attrs: newTypeAttributes }];
-      if (!(0, import_transform.canSplit)(tr.doc, $from.pos, 2)) {
-        return false;
-      }
-      if (dispatch) {
-        const { selection, storedMarks } = state;
-        const { splittableMarks } = editor.extensionManager;
-        const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-        tr.split($from.pos, 2, types).scrollIntoView();
-        if (!marks || !dispatch) {
-          return true;
-        }
-        const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-        tr.ensureMarks(filteredMarks);
-      }
-      return true;
-    };
-    joinListBackwards = (tr, listType) => {
-      const list = findParentNode((node) => node.type === listType)(tr.selection);
-      if (!list) {
-        return true;
-      }
-      const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
-      if (before === void 0) {
-        return true;
-      }
-      const nodeBefore = tr.doc.nodeAt(before);
-      const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type) && (0, import_transform.canJoin)(tr.doc, list.pos);
-      if (!canJoinBackwards) {
-        return true;
-      }
-      tr.join(list.pos);
-      return true;
-    };
-    joinListForwards = (tr, listType) => {
-      const list = findParentNode((node) => node.type === listType)(tr.selection);
-      if (!list) {
-        return true;
-      }
-      const after = tr.doc.resolve(list.start).after(list.depth);
-      if (after === void 0) {
-        return true;
-      }
-      const nodeAfter = tr.doc.nodeAt(after);
-      const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type) && (0, import_transform.canJoin)(tr.doc, after);
-      if (!canJoinForwards) {
-        return true;
-      }
-      tr.join(after);
-      return true;
-    };
-    toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands: commands2, can }) => {
-      const { extensions, splittableMarks } = editor.extensionManager;
-      const listType = getNodeType(listTypeOrName, state.schema);
-      const itemType = getNodeType(itemTypeOrName, state.schema);
-      const { selection, storedMarks } = state;
-      const { $from, $to } = selection;
-      const range = $from.blockRange($to);
-      const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-      if (!range) {
-        return false;
-      }
-      const parentList = findParentNode((node) => isList(node.type.name, extensions))(selection);
-      if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-        if (parentList.node.type === listType) {
-          return commands2.liftListItem(itemType);
-        }
-        if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
-          return chain().command(() => {
-            tr.setNodeMarkup(parentList.pos, listType);
-            return true;
-          }).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-        }
-      }
-      if (!keepMarks || !marks || !dispatch) {
-        return chain().command(() => {
-          const canWrapInList = can().wrapInList(listType, attributes);
-          if (canWrapInList) {
-            return true;
-          }
-          return commands2.clearNodes();
-        }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-      }
-      return chain().command(() => {
-        const canWrapInList = can().wrapInList(listType, attributes);
-        const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-        tr.ensureMarks(filteredMarks);
-        if (canWrapInList) {
-          return true;
-        }
-        return commands2.clearNodes();
-      }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-    };
-    toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands: commands2 }) => {
-      const { extendEmptyMarkRange = false } = options;
-      const type = getMarkType(typeOrName, state.schema);
-      const isActive = isMarkActive(state, type, attributes);
-      if (isActive) {
-        return commands2.unsetMark(type, { extendEmptyMarkRange });
-      }
-      return commands2.setMark(type, attributes);
-    };
-    toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const toggleType = getNodeType(toggleTypeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      let attributesToCopy;
-      if (state.selection.$anchor.sameParent(state.selection.$head)) {
-        attributesToCopy = state.selection.$anchor.parent.attrs;
-      }
-      if (isActive) {
-        return commands2.setNode(toggleType, attributesToCopy);
-      }
-      return commands2.setNode(type, { ...attributesToCopy, ...attributes });
-    };
-    toggleWrap = (typeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      if (isActive) {
-        return commands2.lift(type);
-      }
-      return commands2.wrapIn(type, attributes);
-    };
-    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;
-    };
-    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;
-    };
-    unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
-      var _a;
-      const { extendEmptyMarkRange = false } = options;
-      const { selection } = tr;
-      const type = getMarkType(typeOrName, state.schema);
-      const { $from, empty, ranges } = selection;
-      if (!dispatch) {
-        return true;
-      }
-      if (empty && extendEmptyMarkRange) {
-        let { from, to } = selection;
-        const attrs = (_a = $from.marks().find((mark) => mark.type === type)) === null || _a === void 0 ? void 0 : _a.attrs;
-        const range = getMarkRange($from, type, attrs);
-        if (range) {
-          from = range.from;
-          to = range.to;
-        }
-        tr.removeMark(from, to, type);
-      } else {
-        ranges.forEach((range) => {
-          tr.removeMark(range.$from.pos, range.$to.pos, type);
-        });
-      }
-      tr.removeStoredMark(type);
-      return true;
-    };
-    updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      let nodeType = null;
-      let markType = null;
-      const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-      if (!schemaType) {
-        return false;
-      }
-      if (schemaType === "node") {
-        nodeType = getNodeType(typeOrName, state.schema);
-      }
-      if (schemaType === "mark") {
-        markType = getMarkType(typeOrName, state.schema);
-      }
-      if (dispatch) {
-        tr.selection.ranges.forEach((range) => {
-          const from = range.$from.pos;
-          const to = range.$to.pos;
-          let lastPos;
-          let lastNode;
-          let trimmedFrom;
-          let trimmedTo;
-          if (tr.selection.empty) {
-            state.doc.nodesBetween(from, to, (node, pos) => {
-              if (nodeType && nodeType === node.type) {
-                trimmedFrom = Math.max(pos, from);
-                trimmedTo = Math.min(pos + node.nodeSize, to);
-                lastPos = pos;
-                lastNode = node;
-              }
-            });
-          } else {
-            state.doc.nodesBetween(from, to, (node, pos) => {
-              if (pos < from && nodeType && nodeType === node.type) {
-                trimmedFrom = Math.max(pos, from);
-                trimmedTo = Math.min(pos + node.nodeSize, to);
-                lastPos = pos;
-                lastNode = node;
-              }
-              if (pos >= from && pos <= to) {
-                if (nodeType && nodeType === node.type) {
-                  tr.setNodeMarkup(pos, void 0, {
-                    ...node.attrs,
-                    ...attributes
-                  });
-                }
-                if (markType && node.marks.length) {
-                  node.marks.forEach((mark) => {
-                    if (markType === mark.type) {
-                      const trimmedFrom2 = Math.max(pos, from);
-                      const trimmedTo2 = Math.min(pos + node.nodeSize, to);
-                      tr.addMark(trimmedFrom2, trimmedTo2, markType.create({
-                        ...mark.attrs,
-                        ...attributes
-                      }));
-                    }
-                  });
-                }
-              }
-            });
-          }
-          if (lastNode) {
-            if (lastPos !== void 0) {
-              tr.setNodeMarkup(lastPos, void 0, {
-                ...lastNode.attrs,
-                ...attributes
-              });
-            }
-            if (markType && lastNode.marks.length) {
-              lastNode.marks.forEach((mark) => {
-                if (markType === mark.type) {
-                  tr.addMark(trimmedFrom, trimmedTo, markType.create({
-                    ...mark.attrs,
-                    ...attributes
-                  }));
-                }
-              });
-            }
-          }
-        });
-      }
-      return true;
-    };
-    wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return (0, import_commands.wrapIn)(type, attributes)(state, dispatch);
-    };
-    wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return (0, import_schema_list.wrapInList)(type, attributes)(state, dispatch);
-    };
-    commands = /* @__PURE__ */ Object.freeze({
-      __proto__: null,
-      blur,
-      clearContent,
-      clearNodes,
-      command,
-      createParagraphNear,
-      cut,
-      deleteCurrentNode,
-      deleteNode,
-      deleteRange,
-      deleteSelection,
-      enter,
-      exitCode,
-      extendMarkRange,
-      first,
-      focus,
-      forEach,
-      insertContent,
-      insertContentAt,
-      joinBackward,
-      joinDown,
-      joinForward,
-      joinItemBackward,
-      joinItemForward,
-      joinTextblockBackward,
-      joinTextblockForward,
-      joinUp,
-      keyboardShortcut,
-      lift,
-      liftEmptyBlock,
-      liftListItem,
-      newlineInCode,
-      resetAttributes,
-      scrollIntoView,
-      selectAll,
-      selectNodeBackward,
-      selectNodeForward,
-      selectParentNode,
-      selectTextblockEnd,
-      selectTextblockStart,
-      setContent,
-      setMark,
-      setMeta,
-      setNode,
-      setNodeSelection,
-      setTextSelection,
-      sinkListItem,
-      splitBlock,
-      splitListItem,
-      toggleList,
-      toggleMark,
-      toggleNode,
-      toggleWrap,
-      undoInputRule,
-      unsetAllMarks,
-      unsetMark,
-      updateAttributes,
-      wrapIn,
-      wrapInList
-    });
-    Commands = Extension.create({
-      name: "commands",
-      addCommands() {
-        return {
-          ...commands
-        };
-      }
-    });
-    Drop = Extension.create({
-      name: "drop",
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("tiptapDrop"),
-            props: {
-              handleDrop: (_, e, slice, moved) => {
-                this.editor.emit("drop", {
-                  editor: this.editor,
-                  event: e,
-                  slice,
-                  moved
-                });
-              }
-            }
-          })
-        ];
-      }
-    });
-    Editable = Extension.create({
-      name: "editable",
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("editable"),
-            props: {
-              editable: () => this.editor.options.editable
-            }
-          })
-        ];
-      }
-    });
-    focusEventsPluginKey = new import_state.PluginKey("focusEvents");
-    FocusEvents = Extension.create({
-      name: "focusEvents",
-      addProseMirrorPlugins() {
-        const { editor } = this;
-        return [
-          new import_state.Plugin({
-            key: focusEventsPluginKey,
-            props: {
-              handleDOMEvents: {
-                focus: (view, event) => {
-                  editor.isFocused = true;
-                  const transaction = editor.state.tr.setMeta("focus", { event }).setMeta("addToHistory", false);
-                  view.dispatch(transaction);
-                  return false;
-                },
-                blur: (view, event) => {
-                  editor.isFocused = false;
-                  const transaction = editor.state.tr.setMeta("blur", { event }).setMeta("addToHistory", false);
-                  view.dispatch(transaction);
-                  return false;
-                }
-              }
-            }
-          })
-        ];
-      }
-    });
-    Keymap = Extension.create({
-      name: "keymap",
-      addKeyboardShortcuts() {
-        const handleBackspace = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.undoInputRule(),
-          // maybe convert first text block node to default node
-          () => commands2.command(({ tr }) => {
-            const { selection, doc } = tr;
-            const { empty, $anchor } = selection;
-            const { pos, parent } = $anchor;
-            const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor;
-            const parentIsIsolating = $parentPos.parent.type.spec.isolating;
-            const parentPos = $anchor.pos - $anchor.parentOffset;
-            const isAtStart = parentIsIsolating && $parentPos.parent.childCount === 1 ? parentPos === $anchor.pos : import_state.Selection.atStart(doc).from === pos;
-            if (!empty || !parent.type.isTextblock || parent.textContent.length || !isAtStart || isAtStart && $anchor.parent.type.name === "paragraph") {
-              return false;
-            }
-            return commands2.clearNodes();
-          }),
-          () => commands2.deleteSelection(),
-          () => commands2.joinBackward(),
-          () => commands2.selectNodeBackward()
-        ]);
-        const handleDelete = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.deleteSelection(),
-          () => commands2.deleteCurrentNode(),
-          () => commands2.joinForward(),
-          () => commands2.selectNodeForward()
-        ]);
-        const handleEnter = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.newlineInCode(),
-          () => commands2.createParagraphNear(),
-          () => commands2.liftEmptyBlock(),
-          () => commands2.splitBlock()
-        ]);
-        const baseKeymap = {
-          Enter: handleEnter,
-          "Mod-Enter": () => this.editor.commands.exitCode(),
-          Backspace: handleBackspace,
-          "Mod-Backspace": handleBackspace,
-          "Shift-Backspace": handleBackspace,
-          Delete: handleDelete,
-          "Mod-Delete": handleDelete,
-          "Mod-a": () => this.editor.commands.selectAll()
-        };
-        const pcKeymap = {
-          ...baseKeymap
-        };
-        const macKeymap = {
-          ...baseKeymap,
-          "Ctrl-h": handleBackspace,
-          "Alt-Backspace": handleBackspace,
-          "Ctrl-d": handleDelete,
-          "Ctrl-Alt-Backspace": handleDelete,
-          "Alt-Delete": handleDelete,
-          "Alt-d": handleDelete,
-          "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
-          "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
-        };
-        if (isiOS() || isMacOS()) {
-          return macKeymap;
-        }
-        return pcKeymap;
-      },
-      addProseMirrorPlugins() {
-        return [
-          // With this plugin we check if the whole document was selected and deleted.
-          // In this case we will additionally call `clearNodes()` to convert e.g. a heading
-          // to a paragraph if necessary.
-          // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
-          // with many other commands.
-          new import_state.Plugin({
-            key: new import_state.PluginKey("clearDocument"),
-            appendTransaction: (transactions, oldState, newState) => {
-              if (transactions.some((tr2) => tr2.getMeta("composition"))) {
-                return;
-              }
-              const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-              const ignoreTr = transactions.some((transaction) => transaction.getMeta("preventClearDocument"));
-              if (!docChanges || ignoreTr) {
-                return;
-              }
-              const { empty, from, to } = oldState.selection;
-              const allFrom = import_state.Selection.atStart(oldState.doc).from;
-              const allEnd = import_state.Selection.atEnd(oldState.doc).to;
-              const allWasSelected = from === allFrom && to === allEnd;
-              if (empty || !allWasSelected) {
-                return;
-              }
-              const isEmpty = isNodeEmpty(newState.doc);
-              if (!isEmpty) {
-                return;
-              }
-              const tr = newState.tr;
-              const state = createChainableState({
-                state: newState,
-                transaction: tr
-              });
-              const { commands: commands2 } = new CommandManager({
-                editor: this.editor,
-                state
-              });
-              commands2.clearNodes();
-              if (!tr.steps.length) {
-                return;
-              }
-              return tr;
-            }
-          })
-        ];
-      }
-    });
-    Paste = Extension.create({
-      name: "paste",
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("tiptapPaste"),
-            props: {
-              handlePaste: (_view, e, slice) => {
-                this.editor.emit("paste", {
-                  editor: this.editor,
-                  event: e,
-                  slice
-                });
-              }
-            }
-          })
-        ];
-      }
-    });
-    Tabindex = Extension.create({
-      name: "tabindex",
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("tabindex"),
-            props: {
-              attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
-            }
-          })
-        ];
-      }
-    });
-    Node = class _Node {
-      constructor(config = {}) {
-        this.type = "node";
-        this.name = "node";
-        this.parent = null;
-        this.child = null;
-        this.config = {
-          name: this.name,
-          defaultOptions: {}
-        };
-        this.config = {
-          ...this.config,
-          ...config
-        };
-        this.name = this.config.name;
-        if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-          console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-        }
-        this.options = this.config.defaultOptions;
-        if (this.config.addOptions) {
-          this.options = callOrReturn(getExtensionField(this, "addOptions", {
-            name: this.name
-          }));
-        }
-        this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-          name: this.name,
-          options: this.options
-        })) || {};
-      }
-      static create(config = {}) {
-        return new _Node(config);
-      }
-      configure(options = {}) {
-        const extension = this.extend({
-          ...this.config,
-          addOptions: () => {
-            return mergeDeep(this.options, options);
-          }
-        });
-        extension.name = this.name;
-        extension.parent = this.parent;
-        return extension;
-      }
-      extend(extendedConfig = {}) {
-        const extension = new _Node(extendedConfig);
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-        if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-          console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-        }
-        extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-          name: extension.name
-        }));
-        extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-          name: extension.name,
-          options: extension.options
-        }));
-        return extension;
-      }
-    };
-  }
-});
-
 // src/extensions/FontSize.ts
-var FontSize;
+var import_core, FontSize;
 var init_FontSize = __esm({
   "src/extensions/FontSize.ts"() {
     "use strict";
-    init_dist();
-    FontSize = Extension.create({
+    import_core = require("@tiptap/core");
+    FontSize = import_core.Extension.create({
       name: "fontSize",
       addOptions() {
         return {
@@ -2221,12 +83,12 @@ var init_FontSize = __esm({
 });
 
 // src/extensions/LineHeight.ts
-var LineHeight;
+var import_core2, LineHeight;
 var init_LineHeight = __esm({
   "src/extensions/LineHeight.ts"() {
     "use strict";
-    init_dist();
-    LineHeight = Extension.create({
+    import_core2 = require("@tiptap/core");
+    LineHeight = import_core2.Extension.create({
       name: "lineHeight",
       addOptions() {
         return {
@@ -2257,14 +119,14 @@ var init_LineHeight = __esm({
       },
       addCommands() {
         return {
-          setLineHeight: (lineHeight) => ({ commands: commands2 }) => {
+          setLineHeight: (lineHeight) => ({ commands }) => {
             return this.options.types.every(
-              (type) => commands2.updateAttributes(type, { lineHeight })
+              (type) => commands.updateAttributes(type, { lineHeight })
             );
           },
-          unsetLineHeight: () => ({ commands: commands2 }) => {
+          unsetLineHeight: () => ({ commands }) => {
             return this.options.types.every(
-              (type) => commands2.resetAttributes(type, "lineHeight")
+              (type) => commands.resetAttributes(type, "lineHeight")
             );
           }
         };
@@ -2274,12 +136,12 @@ var init_LineHeight = __esm({
 });
 
 // src/extensions/Video.ts
-var Video;
+var import_core3, Video;
 var init_Video = __esm({
   "src/extensions/Video.ts"() {
     "use strict";
-    init_dist();
-    Video = Node.create({
+    import_core3 = require("@tiptap/core");
+    Video = import_core3.Node.create({
       name: "video",
       addOptions() {
         return {
@@ -2327,14 +189,14 @@ var init_Video = __esm({
       renderHTML({ HTMLAttributes }) {
         return [
           "video",
-          mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+          (0, import_core3.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes),
           ["source", { src: HTMLAttributes.src }]
         ];
       },
       addCommands() {
         return {
-          setVideo: (options) => ({ commands: commands2 }) => {
-            return commands2.insertContent({
+          setVideo: (options) => ({ commands }) => {
+            return commands.insertContent({
               type: this.name,
               attrs: options
             });
@@ -2346,11 +208,11 @@ var init_Video = __esm({
 });
 
 // src/extensions/Emoji.ts
-var EMOJI_CATEGORIES, Emoji;
+var import_core4, EMOJI_CATEGORIES, Emoji;
 var init_Emoji = __esm({
   "src/extensions/Emoji.ts"() {
     "use strict";
-    init_dist();
+    import_core4 = require("@tiptap/core");
     EMOJI_CATEGORIES = {
       smileys: {
         label: "Smileys & People",
@@ -3359,7 +1221,7 @@ var init_Emoji = __esm({
         ]
       }
     };
-    Emoji = Extension.create({
+    Emoji = import_core4.Extension.create({
       name: "emoji",
       addOptions() {
         return {
@@ -3368,8 +1230,8 @@ var init_Emoji = __esm({
       },
       addCommands() {
         return {
-          insertEmoji: (emoji) => ({ commands: commands2 }) => {
-            return commands2.insertContent(emoji);
+          insertEmoji: (emoji) => ({ commands }) => {
+            return commands.insertContent(emoji);
           }
         };
       }
@@ -3378,12 +1240,12 @@ var init_Emoji = __esm({
 });
 
 // src/extensions/Fullscreen.ts
-var Fullscreen;
+var import_core5, Fullscreen;
 var init_Fullscreen = __esm({
   "src/extensions/Fullscreen.ts"() {
     "use strict";
-    init_dist();
-    Fullscreen = Extension.create({
+    import_core5 = require("@tiptap/core");
+    Fullscreen = import_core5.Extension.create({
       name: "fullscreen",
       addOptions() {
         return {
@@ -3449,11 +1311,11 @@ var init_Fullscreen = __esm({
 });
 
 // src/extensions/Print.ts
-var defaultPrintStyles, Print;
+var import_core6, defaultPrintStyles, Print;
 var init_Print = __esm({
   "src/extensions/Print.ts"() {
     "use strict";
-    init_dist();
+    import_core6 = require("@tiptap/core");
     defaultPrintStyles = `
   body {
     font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
@@ -3569,7 +1431,7 @@ var init_Print = __esm({
     }
   }
 `;
-    Print = Extension.create({
+    Print = import_core6.Extension.create({
       name: "print",
       addOptions() {
         return {
@@ -3627,12 +1489,12 @@ var init_Print = __esm({
 });
 
 // src/extensions/Indent.ts
-var Indent;
+var import_core7, Indent;
 var init_Indent = __esm({
   "src/extensions/Indent.ts"() {
     "use strict";
-    init_dist();
-    Indent = Extension.create({
+    import_core7 = require("@tiptap/core");
+    Indent = import_core7.Extension.create({
       name: "indent",
       addOptions() {
         return {
@@ -4879,9 +2741,9 @@ var init_SlateToolbar = __esm({
       onToggleFullscreen,
       onPrint,
       isFullscreen = false,
-      toggleMark: toggleMark3,
+      toggleMark: toggleMark2,
       toggleBlock: toggleBlock2,
-      isMarkActive: isMarkActive3,
+      isMarkActive: isMarkActive2,
       isBlockActive: isBlockActive2
     }) => {
       const [showEmojiPicker, setShowEmojiPicker] = (0, import_react4.useState)(false);
@@ -5015,8 +2877,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "bold"),
-                onClick: () => toggleMark3(editor, "bold"),
+                active: isMarkActive2(editor, "bold"),
+                onClick: () => toggleMark2(editor, "bold"),
                 title: "Bold (Ctrl+B)",
                 children: icons.bold
               },
@@ -5026,8 +2888,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "italic"),
-                onClick: () => toggleMark3(editor, "italic"),
+                active: isMarkActive2(editor, "italic"),
+                onClick: () => toggleMark2(editor, "italic"),
                 title: "Italic (Ctrl+I)",
                 children: icons.italic
               },
@@ -5037,8 +2899,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "underline"),
-                onClick: () => toggleMark3(editor, "underline"),
+                active: isMarkActive2(editor, "underline"),
+                onClick: () => toggleMark2(editor, "underline"),
                 title: "Underline (Ctrl+U)",
                 children: icons.underline
               },
@@ -5048,8 +2910,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "strikethrough"),
-                onClick: () => toggleMark3(editor, "strikethrough"),
+                active: isMarkActive2(editor, "strikethrough"),
+                onClick: () => toggleMark2(editor, "strikethrough"),
                 title: "Strikethrough",
                 children: icons.strike
               },
@@ -5059,8 +2921,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "code"),
-                onClick: () => toggleMark3(editor, "code"),
+                active: isMarkActive2(editor, "code"),
+                onClick: () => toggleMark2(editor, "code"),
                 title: "Code",
                 children: icons.code
               },
@@ -5081,8 +2943,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "subscript"),
-                onClick: () => toggleMark3(editor, "subscript"),
+                active: isMarkActive2(editor, "subscript"),
+                onClick: () => toggleMark2(editor, "subscript"),
                 title: "Subscript",
                 children: icons.subscript
               },
@@ -5092,8 +2954,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "superscript"),
-                onClick: () => toggleMark3(editor, "superscript"),
+                active: isMarkActive2(editor, "superscript"),
+                onClick: () => toggleMark2(editor, "superscript"),
                 title: "Superscript",
                 children: icons.superscript
               },
@@ -5464,7 +3326,7 @@ __export(SlateEditorComponent_exports, {
   SlateEditorComponent: () => SlateEditorComponent,
   default: () => SlateEditorComponent_default
 });
-var import_react5, import_slate2, import_slate_react2, import_slate_history, import_is_hotkey, import_jsx_runtime4, HOTKEYS, LIST_TYPES, TEXT_ALIGN_TYPES, isMarkActive2, isBlockActive, toggleMark2, toggleBlock, serializeToHtml, serializeNode, escapeHtml, deserializeFromHtml, deserializeElement, renderElement, renderLeaf, withInlines, SlateEditorComponent, SlateEditorComponent_default;
+var import_react5, import_slate2, import_slate_react2, import_slate_history, import_is_hotkey, import_jsx_runtime4, HOTKEYS, LIST_TYPES, TEXT_ALIGN_TYPES, isMarkActive, isBlockActive, toggleMark, toggleBlock, serializeToHtml, serializeNode, escapeHtml, deserializeFromHtml, deserializeElement, renderElement, renderLeaf, withInlines, SlateEditorComponent, SlateEditorComponent_default;
 var init_SlateEditorComponent = __esm({
   "src/adapters/slate/SlateEditorComponent.tsx"() {
     "use strict";
@@ -5484,7 +3346,7 @@ var init_SlateEditorComponent = __esm({
     };
     LIST_TYPES = ["numbered-list", "bulleted-list"];
     TEXT_ALIGN_TYPES = ["left", "center", "right", "justify"];
-    isMarkActive2 = (editor, format) => {
+    isMarkActive = (editor, format) => {
       const marks = import_slate2.Editor.marks(editor);
       return marks ? marks[format] === true : false;
     };
@@ -5499,8 +3361,8 @@ var init_SlateEditorComponent = __esm({
       );
       return !!match;
     };
-    toggleMark2 = (editor, format) => {
-      const isActive = isMarkActive2(editor, format);
+    toggleMark = (editor, format) => {
+      const isActive = isMarkActive(editor, format);
       if (isActive) {
         import_slate2.Editor.removeMark(editor, format);
       } else {
@@ -5513,7 +3375,7 @@ var init_SlateEditorComponent = __esm({
         format,
         TEXT_ALIGN_TYPES.includes(format) ? "align" : "type"
       );
-      const isList2 = LIST_TYPES.includes(format);
+      const isList = LIST_TYPES.includes(format);
       import_slate2.Transforms.unwrapNodes(editor, {
         match: (n) => !import_slate2.Editor.isEditor(n) && import_slate2.Element.isElement(n) && LIST_TYPES.includes(n.type) && !TEXT_ALIGN_TYPES.includes(format),
         split: true
@@ -5525,11 +3387,11 @@ var init_SlateEditorComponent = __esm({
         };
       } else {
         newProperties = {
-          type: isActive ? "paragraph" : isList2 ? "list-item" : format
+          type: isActive ? "paragraph" : isList ? "list-item" : format
         };
       }
       import_slate2.Transforms.setNodes(editor, newProperties);
-      if (!isActive && isList2) {
+      if (!isActive && isList) {
         const block = { type: format, children: [] };
         import_slate2.Transforms.wrapNodes(editor, block);
       }
@@ -5816,7 +3678,7 @@ var init_SlateEditorComponent = __esm({
               if ((0, import_is_hotkey.default)(hotkey, event)) {
                 event.preventDefault();
                 const mark = HOTKEYS[hotkey];
-                toggleMark2(editor, mark);
+                toggleMark(editor, mark);
               }
             }
           },
@@ -5950,9 +3812,9 @@ var init_SlateEditorComponent = __esm({
                   onToggleFullscreen: handleToggleFullscreen,
                   onPrint: handlePrint,
                   isFullscreen,
-                  toggleMark: toggleMark2,
+                  toggleMark,
                   toggleBlock,
-                  isMarkActive: isMarkActive2,
+                  isMarkActive,
                   isBlockActive
                 }
               ),