rte-builder 2.0.0 → 2.0.2

package/dist/index.mjs

@@ -39,2150 +39,12 @@ 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
-import { Plugin, PluginKey, TextSelection, Selection, AllSelection, NodeSelection, EditorState } from "@tiptap/pm/state";
-import { EditorView } from "@tiptap/pm/view";
-import { keymap } from "@tiptap/pm/keymap";
-import { Schema, DOMSerializer, Fragment, Node as Node$1, DOMParser as DOMParser2, Slice } from "@tiptap/pm/model";
-import { liftTarget, ReplaceStep, ReplaceAroundStep, joinPoint, Transform, canSplit, canJoin, findWrapping } from "@tiptap/pm/transform";
-import { createParagraphNear as createParagraphNear$1, deleteSelection as deleteSelection$1, exitCode as exitCode$1, joinUp as joinUp$1, joinDown as joinDown$1, joinBackward as joinBackward$1, joinForward as joinForward$1, joinTextblockBackward as joinTextblockBackward$1, joinTextblockForward as joinTextblockForward$1, lift as lift$1, liftEmptyBlock as liftEmptyBlock$1, newlineInCode as newlineInCode$1, selectNodeBackward as selectNodeBackward$1, selectNodeForward as selectNodeForward$1, selectParentNode as selectParentNode$1, selectTextblockEnd as selectTextblockEnd$1, selectTextblockStart as selectTextblockStart$1, setBlockType, wrapIn as wrapIn$1 } from "@tiptap/pm/commands";
-import { liftListItem as liftListItem$1, sinkListItem as sinkListItem$1, wrapInList as wrapInList$1 } from "@tiptap/pm/schema-list";
-function createChainableState(config) {
-  const { state, transaction } = config;
-  let { selection } = transaction;
-  let { doc } = transaction;
-  let { storedMarks } = transaction;
-  return {
-    ...state,
-    apply: state.apply.bind(state),
-    applyTransaction: state.applyTransaction.bind(state),
-    plugins: state.plugins,
-    schema: state.schema,
-    reconfigure: state.reconfigure.bind(state),
-    toJSON: state.toJSON.bind(state),
-    get storedMarks() {
-      return storedMarks;
-    },
-    get selection() {
-      return selection;
-    },
-    get doc() {
-      return doc;
-    },
-    get tr() {
-      selection = transaction.selection;
-      doc = transaction.doc;
-      storedMarks = transaction.storedMarks;
-      return transaction;
-    }
-  };
-}
-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 TextSelection;
-}
-function minMax(value = 0, min = 0, max = 0) {
-  return Math.min(Math.max(value, min), max);
-}
-function resolveFocusPosition(doc, position = null) {
-  if (!position) {
-    return null;
-  }
-  const selectionAtStart = Selection.atStart(doc);
-  const selectionAtEnd = Selection.atEnd(doc);
-  if (position === "start" || position === true) {
-    return selectionAtStart;
-  }
-  if (position === "end") {
-    return selectionAtEnd;
-  }
-  const minPos = selectionAtStart.from;
-  const maxPos = selectionAtEnd.to;
-  if (position === "all") {
-    return TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
-  }
-  return TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
-}
-function isAndroid() {
-  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
-}
-function isiOS() {
-  return [
-    "iPad Simulator",
-    "iPhone Simulator",
-    "iPod Simulator",
-    "iPad",
-    "iPhone",
-    "iPod"
-  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
-}
-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 Node$1 || content instanceof Fragment) {
-    return content;
-  }
-  options = {
-    slice: true,
-    parseOptions: {},
-    ...options
-  };
-  const isJSONContent = typeof content === "object" && content !== null;
-  const isTextContent = typeof content === "string";
-  if (isJSONContent) {
-    try {
-      const isArrayContent = Array.isArray(content) && content.length > 0;
-      if (isArrayContent) {
-        return Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
-      }
-      const node = schema.nodeFromJSON(content);
-      if (options.errorOnInvalidContent) {
-        node.check();
-      }
-      return node;
-    } catch (error) {
-      if (options.errorOnInvalidContent) {
-        throw new Error("[tiptap error]: Invalid JSON content", { cause: error });
-      }
-      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
-      return createNodeFromContent("", schema, options);
-    }
-  }
-  if (isTextContent) {
-    if (options.errorOnInvalidContent) {
-      let hasInvalidContent = false;
-      let invalidContent = "";
-      const contentCheckSchema = new Schema({
-        topNode: schema.spec.topNode,
-        marks: schema.spec.marks,
-        // Prosemirror's schemas are executed such that: the last to execute, matches last
-        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
-        nodes: schema.spec.nodes.append({
-          __tiptap__private__unknown__catch__all__node: {
-            content: "inline*",
-            group: "block",
-            parseDOM: [
-              {
-                tag: "*",
-                getAttrs: (e) => {
-                  hasInvalidContent = true;
-                  invalidContent = typeof e === "string" ? e : e.outerHTML;
-                  return null;
-                }
-              }
-            ]
-          }
-        })
-      });
-      if (options.slice) {
-        DOMParser2.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
-      } else {
-        DOMParser2.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 = DOMParser2.fromSchema(schema);
-    if (options.slice) {
-      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
-    }
-    return parser.parse(elementFromString(content), options.parseOptions);
-  }
-  return createNodeFromContent("", schema, options);
-}
-function selectionToInsertionEnd(tr, startLen, bias) {
-  const last = tr.steps.length - 1;
-  if (last < startLen) {
-    return;
-  }
-  const step = tr.steps[last];
-  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
-    return;
-  }
-  const map = tr.mapping.maps[last];
-  let end = 0;
-  map.forEach((_from, _to, _newFrom, newTo) => {
-    if (end === 0) {
-      end = newTo;
-    }
-  });
-  tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
-}
-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 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";
-    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 Plugin({
-            key: new PluginKey("clipboardTextSerializer"),
-            props: {
-              clipboardTextSerializer: () => {
-                const { editor } = this;
-                const { state, schema } = editor;
-                const { doc, selection } = state;
-                const { ranges } = selection;
-                const from = Math.min(...ranges.map((range2) => range2.$from.pos));
-                const to = Math.max(...ranges.map((range2) => range2.$to.pos));
-                const textSerializers = getTextSerializersFromSchema(schema);
-                const range = { from, to };
-                return getTextBetween(doc, range, {
-                  ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
-                  textSerializers
-                });
-              }
-            }
-          })
-        ];
-      }
-    });
-    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 = 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 createParagraphNear$1(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 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 deleteSelection$1(state, dispatch);
-    };
-    enter = () => ({ commands: commands2 }) => {
-      return commands2.keyboardShortcut("Enter");
-    };
-    exitCode = () => ({ state, dispatch }) => {
-      return exitCode$1(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 = 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 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 joinUp$1(state, dispatch);
-    };
-    joinDown = () => ({ state, dispatch }) => {
-      return joinDown$1(state, dispatch);
-    };
-    joinBackward = () => ({ state, dispatch }) => {
-      return joinBackward$1(state, dispatch);
-    };
-    joinForward = () => ({ state, dispatch }) => {
-      return joinForward$1(state, dispatch);
-    };
-    joinItemBackward = () => ({ state, dispatch, tr }) => {
-      try {
-        const point = joinPoint(state.doc, state.selection.$from.pos, -1);
-        if (point === null || point === void 0) {
-          return false;
-        }
-        tr.join(point, 2);
-        if (dispatch) {
-          dispatch(tr);
-        }
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    joinItemForward = () => ({ state, dispatch, tr }) => {
-      try {
-        const point = joinPoint(state.doc, state.selection.$from.pos, 1);
-        if (point === null || point === void 0) {
-          return false;
-        }
-        tr.join(point, 2);
-        if (dispatch) {
-          dispatch(tr);
-        }
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    joinTextblockBackward = () => ({ state, dispatch }) => {
-      return joinTextblockBackward$1(state, dispatch);
-    };
-    joinTextblockForward = () => ({ state, dispatch }) => {
-      return joinTextblockForward$1(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 lift$1(state, dispatch);
-    };
-    liftEmptyBlock = () => ({ state, dispatch }) => {
-      return liftEmptyBlock$1(state, dispatch);
-    };
-    liftListItem = (typeOrName) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return liftListItem$1(type)(state, dispatch);
-    };
-    newlineInCode = () => ({ state, dispatch }) => {
-      return newlineInCode$1(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 AllSelection(tr.doc);
-        tr.setSelection(selection);
-      }
-      return true;
-    };
-    selectNodeBackward = () => ({ state, dispatch }) => {
-      return selectNodeBackward$1(state, dispatch);
-    };
-    selectNodeForward = () => ({ state, dispatch }) => {
-      return selectNodeForward$1(state, dispatch);
-    };
-    selectParentNode = () => ({ state, dispatch }) => {
-      return selectParentNode$1(state, dispatch);
-    };
-    selectTextblockEnd = () => ({ state, dispatch }) => {
-      return selectTextblockEnd$1(state, dispatch);
-    };
-    selectTextblockStart = () => ({ state, dispatch }) => {
-      return selectTextblockStart$1(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 = setBlockType(type, { ...attributesToCopy, ...attributes })(state);
-        if (canSetBlock) {
-          return true;
-        }
-        return commands2.clearNodes();
-      }).command(({ state: updatedState }) => {
-        return 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 = 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 = TextSelection.atStart(doc).from;
-        const maxPos = TextSelection.atEnd(doc).to;
-        const resolvedFrom = minMax(from, minPos, maxPos);
-        const resolvedEnd = minMax(to, minPos, maxPos);
-        const selection = TextSelection.create(doc, resolvedFrom, resolvedEnd);
-        tr.setSelection(selection);
-      }
-      return true;
-    };
-    sinkListItem = (typeOrName) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return sinkListItem$1(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 NodeSelection && selection.node.isBlock) {
-        if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
-          return false;
-        }
-        if (dispatch) {
-          if (keepMarks) {
-            ensureMarks(state, editor.extensionManager.splittableMarks);
-          }
-          tr.split($from.pos).scrollIntoView();
-        }
-        return true;
-      }
-      if (!$from.parent.isBlock) {
-        return false;
-      }
-      const atEnd = $to.parentOffset === $to.parent.content.size;
-      const deflt = $from.depth === 0 ? void 0 : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-      let types = atEnd && deflt ? [
-        {
-          type: deflt,
-          attrs: newAttributes
-        }
-      ] : void 0;
-      let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
-      if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
-        can = true;
-        types = deflt ? [
-          {
-            type: deflt,
-            attrs: newAttributes
-          }
-        ] : void 0;
-      }
-      if (dispatch) {
-        if (can) {
-          if (selection instanceof TextSelection) {
-            tr.deleteSelection();
-          }
-          tr.split(tr.mapping.map($from.pos), 1, types);
-          if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
-            const first2 = tr.mapping.map($from.before());
-            const $first = tr.doc.resolve(first2);
-            if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
-              tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
-            }
-          }
-        }
-        if (keepMarks) {
-          ensureMarks(state, editor.extensionManager.splittableMarks);
-        }
-        tr.scrollIntoView();
-      }
-      return can;
-    };
-    splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor }) => {
-      var _a;
-      const type = getNodeType(typeOrName, state.schema);
-      const { $from, $to } = state.selection;
-      const node = state.selection.node;
-      if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
-        return false;
-      }
-      const grandParent = $from.node(-1);
-      if (grandParent.type !== type) {
-        return false;
-      }
-      const extensionAttributes = editor.extensionManager.attributes;
-      if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-        if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
-          return false;
-        }
-        if (dispatch) {
-          let wrap = Fragment.empty;
-          const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
-          for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
-            wrap = Fragment.from($from.node(d).copy(wrap));
-          }
-          const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
-          const newNextTypeAttributes2 = {
-            ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-            ...overrideAttrs
-          };
-          const nextType2 = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
-          wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType2) || void 0));
-          const start = $from.before($from.depth - (depthBefore - 1));
-          tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
-          let sel = -1;
-          tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
-            if (sel > -1) {
-              return false;
-            }
-            if (n.isTextblock && n.content.size === 0) {
-              sel = pos + 1;
-            }
-          });
-          if (sel > -1) {
-            tr.setSelection(TextSelection.near(tr.doc.resolve(sel)));
-          }
-          tr.scrollIntoView();
-        }
-        return true;
-      }
-      const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-      const newTypeAttributes = {
-        ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
-        ...overrideAttrs
-      };
-      const newNextTypeAttributes = {
-        ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-        ...overrideAttrs
-      };
-      tr.delete($from.pos, $to.pos);
-      const types = nextType ? [
-        { type, attrs: newTypeAttributes },
-        { type: nextType, attrs: newNextTypeAttributes }
-      ] : [{ type, attrs: newTypeAttributes }];
-      if (!canSplit(tr.doc, $from.pos, 2)) {
-        return false;
-      }
-      if (dispatch) {
-        const { selection, storedMarks } = state;
-        const { splittableMarks } = editor.extensionManager;
-        const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-        tr.split($from.pos, 2, types).scrollIntoView();
-        if (!marks || !dispatch) {
-          return true;
-        }
-        const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-        tr.ensureMarks(filteredMarks);
-      }
-      return true;
-    };
-    joinListBackwards = (tr, listType) => {
-      const list = findParentNode((node) => node.type === listType)(tr.selection);
-      if (!list) {
-        return true;
-      }
-      const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
-      if (before === void 0) {
-        return true;
-      }
-      const nodeBefore = tr.doc.nodeAt(before);
-      const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type) && canJoin(tr.doc, list.pos);
-      if (!canJoinBackwards) {
-        return true;
-      }
-      tr.join(list.pos);
-      return true;
-    };
-    joinListForwards = (tr, listType) => {
-      const list = findParentNode((node) => node.type === listType)(tr.selection);
-      if (!list) {
-        return true;
-      }
-      const after = tr.doc.resolve(list.start).after(list.depth);
-      if (after === void 0) {
-        return true;
-      }
-      const nodeAfter = tr.doc.nodeAt(after);
-      const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type) && canJoin(tr.doc, after);
-      if (!canJoinForwards) {
-        return true;
-      }
-      tr.join(after);
-      return true;
-    };
-    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 wrapIn$1(type, attributes)(state, dispatch);
-    };
-    wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return wrapInList$1(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 Plugin({
-            key: new 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 Plugin({
-            key: new PluginKey("editable"),
-            props: {
-              editable: () => this.editor.options.editable
-            }
-          })
-        ];
-      }
-    });
-    focusEventsPluginKey = new PluginKey("focusEvents");
-    FocusEvents = Extension.create({
-      name: "focusEvents",
-      addProseMirrorPlugins() {
-        const { editor } = this;
-        return [
-          new Plugin({
-            key: focusEventsPluginKey,
-            props: {
-              handleDOMEvents: {
-                focus: (view, event) => {
-                  editor.isFocused = true;
-                  const transaction = editor.state.tr.setMeta("focus", { event }).setMeta("addToHistory", false);
-                  view.dispatch(transaction);
-                  return false;
-                },
-                blur: (view, event) => {
-                  editor.isFocused = false;
-                  const transaction = editor.state.tr.setMeta("blur", { event }).setMeta("addToHistory", false);
-                  view.dispatch(transaction);
-                  return false;
-                }
-              }
-            }
-          })
-        ];
-      }
-    });
-    Keymap = Extension.create({
-      name: "keymap",
-      addKeyboardShortcuts() {
-        const handleBackspace = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.undoInputRule(),
-          // maybe convert first text block node to default node
-          () => commands2.command(({ tr }) => {
-            const { selection, doc } = tr;
-            const { empty, $anchor } = selection;
-            const { pos, parent } = $anchor;
-            const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor;
-            const parentIsIsolating = $parentPos.parent.type.spec.isolating;
-            const parentPos = $anchor.pos - $anchor.parentOffset;
-            const isAtStart = parentIsIsolating && $parentPos.parent.childCount === 1 ? parentPos === $anchor.pos : Selection.atStart(doc).from === pos;
-            if (!empty || !parent.type.isTextblock || parent.textContent.length || !isAtStart || isAtStart && $anchor.parent.type.name === "paragraph") {
-              return false;
-            }
-            return commands2.clearNodes();
-          }),
-          () => commands2.deleteSelection(),
-          () => commands2.joinBackward(),
-          () => commands2.selectNodeBackward()
-        ]);
-        const handleDelete = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.deleteSelection(),
-          () => commands2.deleteCurrentNode(),
-          () => commands2.joinForward(),
-          () => commands2.selectNodeForward()
-        ]);
-        const handleEnter = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.newlineInCode(),
-          () => commands2.createParagraphNear(),
-          () => commands2.liftEmptyBlock(),
-          () => commands2.splitBlock()
-        ]);
-        const baseKeymap = {
-          Enter: handleEnter,
-          "Mod-Enter": () => this.editor.commands.exitCode(),
-          Backspace: handleBackspace,
-          "Mod-Backspace": handleBackspace,
-          "Shift-Backspace": handleBackspace,
-          Delete: handleDelete,
-          "Mod-Delete": handleDelete,
-          "Mod-a": () => this.editor.commands.selectAll()
-        };
-        const pcKeymap = {
-          ...baseKeymap
-        };
-        const macKeymap = {
-          ...baseKeymap,
-          "Ctrl-h": handleBackspace,
-          "Alt-Backspace": handleBackspace,
-          "Ctrl-d": handleDelete,
-          "Ctrl-Alt-Backspace": handleDelete,
-          "Alt-Delete": handleDelete,
-          "Alt-d": handleDelete,
-          "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
-          "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
-        };
-        if (isiOS() || isMacOS()) {
-          return macKeymap;
-        }
-        return pcKeymap;
-      },
-      addProseMirrorPlugins() {
-        return [
-          // With this plugin we check if the whole document was selected and deleted.
-          // In this case we will additionally call `clearNodes()` to convert e.g. a heading
-          // to a paragraph if necessary.
-          // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
-          // with many other commands.
-          new Plugin({
-            key: new PluginKey("clearDocument"),
-            appendTransaction: (transactions, oldState, newState) => {
-              if (transactions.some((tr2) => tr2.getMeta("composition"))) {
-                return;
-              }
-              const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-              const ignoreTr = transactions.some((transaction) => transaction.getMeta("preventClearDocument"));
-              if (!docChanges || ignoreTr) {
-                return;
-              }
-              const { empty, from, to } = oldState.selection;
-              const allFrom = Selection.atStart(oldState.doc).from;
-              const allEnd = Selection.atEnd(oldState.doc).to;
-              const allWasSelected = from === allFrom && to === allEnd;
-              if (empty || !allWasSelected) {
-                return;
-              }
-              const isEmpty = isNodeEmpty(newState.doc);
-              if (!isEmpty) {
-                return;
-              }
-              const tr = newState.tr;
-              const state = createChainableState({
-                state: newState,
-                transaction: tr
-              });
-              const { commands: commands2 } = new CommandManager({
-                editor: this.editor,
-                state
-              });
-              commands2.clearNodes();
-              if (!tr.steps.length) {
-                return;
-              }
-              return tr;
-            }
-          })
-        ];
-      }
-    });
-    Paste = Extension.create({
-      name: "paste",
-      addProseMirrorPlugins() {
-        return [
-          new Plugin({
-            key: new PluginKey("tiptapPaste"),
-            props: {
-              handlePaste: (_view, e, slice) => {
-                this.editor.emit("paste", {
-                  editor: this.editor,
-                  event: e,
-                  slice
-                });
-              }
-            }
-          })
-        ];
-      }
-    });
-    Tabindex = Extension.create({
-      name: "tabindex",
-      addProseMirrorPlugins() {
-        return [
-          new Plugin({
-            key: new 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
+import { Extension } from "@tiptap/core";
 var FontSize;
 var init_FontSize = __esm({
   "src/extensions/FontSize.ts"() {
     "use strict";
-    init_dist();
     FontSize = Extension.create({
       name: "fontSize",
       addOptions() {
@@ -2226,12 +88,12 @@ var init_FontSize = __esm({
 });
 
 // src/extensions/LineHeight.ts
+import { Extension as Extension2 } from "@tiptap/core";
 var LineHeight;
 var init_LineHeight = __esm({
   "src/extensions/LineHeight.ts"() {
     "use strict";
-    init_dist();
-    LineHeight = Extension.create({
+    LineHeight = Extension2.create({
       name: "lineHeight",
       addOptions() {
         return {
@@ -2262,14 +124,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")
             );
           }
         };
@@ -2279,11 +141,11 @@ var init_LineHeight = __esm({
 });
 
 // src/extensions/Video.ts
+import { Node, mergeAttributes } from "@tiptap/core";
 var Video;
 var init_Video = __esm({
   "src/extensions/Video.ts"() {
     "use strict";
-    init_dist();
     Video = Node.create({
       name: "video",
       addOptions() {
@@ -2338,8 +200,8 @@ var init_Video = __esm({
       },
       addCommands() {
         return {
-          setVideo: (options) => ({ commands: commands2 }) => {
-            return commands2.insertContent({
+          setVideo: (options) => ({ commands }) => {
+            return commands.insertContent({
               type: this.name,
               attrs: options
             });
@@ -2351,11 +213,11 @@ var init_Video = __esm({
 });
 
 // src/extensions/Emoji.ts
+import { Extension as Extension3 } from "@tiptap/core";
 var EMOJI_CATEGORIES, Emoji;
 var init_Emoji = __esm({
   "src/extensions/Emoji.ts"() {
     "use strict";
-    init_dist();
     EMOJI_CATEGORIES = {
       smileys: {
         label: "Smileys & People",
@@ -3364,7 +1226,7 @@ var init_Emoji = __esm({
         ]
       }
     };
-    Emoji = Extension.create({
+    Emoji = Extension3.create({
       name: "emoji",
       addOptions() {
         return {
@@ -3373,8 +1235,8 @@ var init_Emoji = __esm({
       },
       addCommands() {
         return {
-          insertEmoji: (emoji) => ({ commands: commands2 }) => {
-            return commands2.insertContent(emoji);
+          insertEmoji: (emoji) => ({ commands }) => {
+            return commands.insertContent(emoji);
           }
         };
       }
@@ -3383,12 +1245,12 @@ var init_Emoji = __esm({
 });
 
 // src/extensions/Fullscreen.ts
+import { Extension as Extension4 } from "@tiptap/core";
 var Fullscreen;
 var init_Fullscreen = __esm({
   "src/extensions/Fullscreen.ts"() {
     "use strict";
-    init_dist();
-    Fullscreen = Extension.create({
+    Fullscreen = Extension4.create({
       name: "fullscreen",
       addOptions() {
         return {
@@ -3454,11 +1316,11 @@ var init_Fullscreen = __esm({
 });
 
 // src/extensions/Print.ts
+import { Extension as Extension5 } from "@tiptap/core";
 var defaultPrintStyles, Print;
 var init_Print = __esm({
   "src/extensions/Print.ts"() {
     "use strict";
-    init_dist();
     defaultPrintStyles = `
   body {
     font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
@@ -3574,7 +1436,7 @@ var init_Print = __esm({
     }
   }
 `;
-    Print = Extension.create({
+    Print = Extension5.create({
       name: "print",
       addOptions() {
         return {
@@ -3632,12 +1494,12 @@ var init_Print = __esm({
 });
 
 // src/extensions/Indent.ts
+import { Extension as Extension6 } from "@tiptap/core";
 var Indent;
 var init_Indent = __esm({
   "src/extensions/Indent.ts"() {
     "use strict";
-    init_dist();
-    Indent = Extension.create({
+    Indent = Extension6.create({
       name: "indent",
       addOptions() {
         return {
@@ -4884,9 +2746,9 @@ var init_SlateToolbar = __esm({
       onToggleFullscreen,
       onPrint,
       isFullscreen = false,
-      toggleMark: toggleMark3,
+      toggleMark: toggleMark2,
       toggleBlock: toggleBlock2,
-      isMarkActive: isMarkActive3,
+      isMarkActive: isMarkActive2,
       isBlockActive: isBlockActive2
     }) => {
       const [showEmojiPicker, setShowEmojiPicker] = useState2(false);
@@ -5020,8 +2882,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ jsx3(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "bold"),
-                onClick: () => toggleMark3(editor, "bold"),
+                active: isMarkActive2(editor, "bold"),
+                onClick: () => toggleMark2(editor, "bold"),
                 title: "Bold (Ctrl+B)",
                 children: icons.bold
               },
@@ -5031,8 +2893,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ jsx3(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "italic"),
-                onClick: () => toggleMark3(editor, "italic"),
+                active: isMarkActive2(editor, "italic"),
+                onClick: () => toggleMark2(editor, "italic"),
                 title: "Italic (Ctrl+I)",
                 children: icons.italic
               },
@@ -5042,8 +2904,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ jsx3(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "underline"),
-                onClick: () => toggleMark3(editor, "underline"),
+                active: isMarkActive2(editor, "underline"),
+                onClick: () => toggleMark2(editor, "underline"),
                 title: "Underline (Ctrl+U)",
                 children: icons.underline
               },
@@ -5053,8 +2915,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ jsx3(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "strikethrough"),
-                onClick: () => toggleMark3(editor, "strikethrough"),
+                active: isMarkActive2(editor, "strikethrough"),
+                onClick: () => toggleMark2(editor, "strikethrough"),
                 title: "Strikethrough",
                 children: icons.strike
               },
@@ -5064,8 +2926,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ jsx3(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "code"),
-                onClick: () => toggleMark3(editor, "code"),
+                active: isMarkActive2(editor, "code"),
+                onClick: () => toggleMark2(editor, "code"),
                 title: "Code",
                 children: icons.code
               },
@@ -5086,8 +2948,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ jsx3(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "subscript"),
-                onClick: () => toggleMark3(editor, "subscript"),
+                active: isMarkActive2(editor, "subscript"),
+                onClick: () => toggleMark2(editor, "subscript"),
                 title: "Subscript",
                 children: icons.subscript
               },
@@ -5097,8 +2959,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ jsx3(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "superscript"),
-                onClick: () => toggleMark3(editor, "superscript"),
+                active: isMarkActive2(editor, "superscript"),
+                onClick: () => toggleMark2(editor, "superscript"),
                 title: "Superscript",
                 children: icons.superscript
               },
@@ -5479,10 +3341,10 @@ import {
   useRef as useRef3
 } from "react";
 import { createEditor, Editor as Editor2, Transforms as Transforms2, Text as Text2, Element as SlateElement2, Node as Node2 } from "slate";
-import { Slate, Editable as Editable2, withReact, ReactEditor as ReactEditor2 } from "slate-react";
+import { Slate, Editable, withReact, ReactEditor as ReactEditor2 } from "slate-react";
 import { withHistory, HistoryEditor } from "slate-history";
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-var import_is_hotkey, HOTKEYS, LIST_TYPES, TEXT_ALIGN_TYPES, isMarkActive2, isBlockActive, toggleMark2, toggleBlock, serializeToHtml, serializeNode, escapeHtml, deserializeFromHtml, deserializeElement, renderElement, renderLeaf, withInlines, SlateEditorComponent, SlateEditorComponent_default;
+var import_is_hotkey, 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";
@@ -5497,7 +3359,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 = Editor2.marks(editor);
       return marks ? marks[format] === true : false;
     };
@@ -5512,8 +3374,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) {
         Editor2.removeMark(editor, format);
       } else {
@@ -5526,7 +3388,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);
       Transforms2.unwrapNodes(editor, {
         match: (n) => !Editor2.isEditor(n) && SlateElement2.isElement(n) && LIST_TYPES.includes(n.type) && !TEXT_ALIGN_TYPES.includes(format),
         split: true
@@ -5538,11 +3400,11 @@ var init_SlateEditorComponent = __esm({
         };
       } else {
         newProperties = {
-          type: isActive ? "paragraph" : isList2 ? "list-item" : format
+          type: isActive ? "paragraph" : isList ? "list-item" : format
         };
       }
       Transforms2.setNodes(editor, newProperties);
-      if (!isActive && isList2) {
+      if (!isActive && isList) {
         const block = { type: format, children: [] };
         Transforms2.wrapNodes(editor, block);
       }
@@ -5829,7 +3691,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);
               }
             }
           },
@@ -5963,9 +3825,9 @@ var init_SlateEditorComponent = __esm({
                   onToggleFullscreen: handleToggleFullscreen,
                   onPrint: handlePrint,
                   isFullscreen,
-                  toggleMark: toggleMark2,
+                  toggleMark,
                   toggleBlock,
-                  isMarkActive: isMarkActive2,
+                  isMarkActive,
                   isBlockActive
                 }
               ),
@@ -5980,7 +3842,7 @@ var init_SlateEditorComponent = __esm({
                     overflow: "auto"
                   },
                   children: /* @__PURE__ */ jsx4(
-                    Editable2,
+                    Editable,
                     {
                       className: "rte-builder-content",
                       renderElement,
@@ -6589,7 +4451,7 @@ import {
   COMMAND_PRIORITY_CRITICAL
 } from "lexical";
 import { $generateHtmlFromNodes, $generateNodesFromDOM } from "@lexical/html";
-import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function onError(error) {
   console.error("Lexical Error:", error);
 }
@@ -6861,7 +4723,7 @@ var init_LexicalEditorComponent = __esm({
         getNativeEditor: () => editor
       }));
       const characterLimit = charCounterMax > 0 ? charCounterMax : null;
-      return /* @__PURE__ */ jsxs6(Fragment2, { children: [
+      return /* @__PURE__ */ jsxs6(Fragment, { children: [
         /* @__PURE__ */ jsx6(
           LexicalToolbar,
           {
@@ -9233,7 +7095,7 @@ function useCommentsOptional() {
 
 // src/comments/CommentsPanel.tsx
 import { useState as useState8 } from "react";
-import { Fragment as Fragment3, jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
 function formatRelativeTime(timestamp) {
   const now = Date.now();
   const diff = now - timestamp;
@@ -9383,7 +7245,7 @@ function ThreadItem({ thread }) {
           },
           comment.id
         )) }),
-        thread.status === "open" && /* @__PURE__ */ jsx13("div", { className: "rte-thread-reply", children: showReply ? /* @__PURE__ */ jsxs11(Fragment3, { children: [
+        thread.status === "open" && /* @__PURE__ */ jsx13("div", { className: "rte-thread-reply", children: showReply ? /* @__PURE__ */ jsxs11(Fragment2, { children: [
           /* @__PURE__ */ jsx13(
             "textarea",
             {
@@ -9771,7 +7633,7 @@ function useVersionHistoryOptional() {
 
 // src/history/VersionHistoryPanel.tsx
 import { useState as useState9 } from "react";
-import { Fragment as Fragment4, jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx15, jsxs as jsxs12 } from "react/jsx-runtime";
 function formatDate(timestamp) {
   const date = new Date(timestamp);
   const now = /* @__PURE__ */ new Date();
@@ -9994,7 +7856,7 @@ function VersionHistoryPanel({ position = "right", className = "" }) {
         onClose: handleCancelCompare
       }
     ),
-    !state.isComparing && /* @__PURE__ */ jsx15("div", { className: "rte-version-list", children: state.versions.length === 0 ? /* @__PURE__ */ jsx15("div", { className: "rte-version-empty", children: "No versions saved yet. Changes will be auto-saved periodically." }) : /* @__PURE__ */ jsxs12(Fragment4, { children: [
+    !state.isComparing && /* @__PURE__ */ jsx15("div", { className: "rte-version-list", children: state.versions.length === 0 ? /* @__PURE__ */ jsx15("div", { className: "rte-version-empty", children: "No versions saved yet. Changes will be auto-saved periodically." }) : /* @__PURE__ */ jsxs12(Fragment3, { children: [
       state.versions.some((v) => v.isPinned) && /* @__PURE__ */ jsxs12("div", { className: "rte-version-section", children: [
         /* @__PURE__ */ jsx15("div", { className: "rte-version-section-title", children: "\u{1F4CC} Pinned" }),
         state.versions.filter((v) => v.isPinned).map((version) => /* @__PURE__ */ jsx15(