@elia-ori/editor 0.1.0

package/dist/index.js

@@ -0,0 +1,4893 @@
+// src/EliaEditor.tsx
+import { useRef as useRef2, useEffect, useCallback } from "react";
+import { useEditor, EditorContent } from "@tiptap/react";
+import StarterKit from "@tiptap/starter-kit";
+import Placeholder from "@tiptap/extension-placeholder";
+import Underline from "@tiptap/extension-underline";
+import TextAlign from "@tiptap/extension-text-align";
+import Link from "@tiptap/extension-link";
+import { TextStyle } from "@tiptap/extension-text-style";
+import { Color } from "@tiptap/extension-color";
+import { Highlight } from "@tiptap/extension-highlight";
+import Subscript from "@tiptap/extension-subscript";
+import Superscript from "@tiptap/extension-superscript";
+import TaskList from "@tiptap/extension-task-list";
+import TaskItem from "@tiptap/extension-task-item";
+import { Table } from "@tiptap/extension-table";
+import { TableRow } from "@tiptap/extension-table-row";
+import { TableHeader } from "@tiptap/extension-table-header";
+import { TableCell } from "@tiptap/extension-table-cell";
+import ImageResize from "tiptap-extension-resize-image";
+
+// node_modules/@tiptap/core/dist/index.js
+import { liftTarget } from "@tiptap/pm/transform";
+import { createParagraphNear as originalCreateParagraphNear } from "@tiptap/pm/commands";
+import { TextSelection } from "@tiptap/pm/state";
+import { deleteSelection as originalDeleteSelection } from "@tiptap/pm/commands";
+import { exitCode as originalExitCode } from "@tiptap/pm/commands";
+import { TextSelection as TextSelection2 } from "@tiptap/pm/state";
+import { TextSelection as TextSelection3 } from "@tiptap/pm/state";
+import { Selection, TextSelection as TextSelection4 } from "@tiptap/pm/state";
+import { Fragment as Fragment2 } from "@tiptap/pm/model";
+import { DOMParser, Fragment, Node as ProseMirrorNode, Schema } from "@tiptap/pm/model";
+import { Selection as Selection2 } from "@tiptap/pm/state";
+import { ReplaceAroundStep, ReplaceStep } from "@tiptap/pm/transform";
+import {
+  joinBackward as originalJoinBackward,
+  joinDown as originalJoinDown,
+  joinForward as originalJoinForward,
+  joinUp as originalJoinUp
+} from "@tiptap/pm/commands";
+import { joinPoint } from "@tiptap/pm/transform";
+import { joinPoint as joinPoint2 } from "@tiptap/pm/transform";
+import { joinTextblockBackward as originalCommand } from "@tiptap/pm/commands";
+import { joinTextblockForward as originalCommand2 } from "@tiptap/pm/commands";
+import { lift as originalLift } from "@tiptap/pm/commands";
+import { liftEmptyBlock as originalLiftEmptyBlock } from "@tiptap/pm/commands";
+import { liftListItem as originalLiftListItem } from "@tiptap/pm/schema-list";
+import { newlineInCode as originalNewlineInCode } from "@tiptap/pm/commands";
+import { AllSelection } from "@tiptap/pm/state";
+import { selectNodeBackward as originalSelectNodeBackward } from "@tiptap/pm/commands";
+import { selectNodeForward as originalSelectNodeForward } from "@tiptap/pm/commands";
+import { selectParentNode as originalSelectParentNode } from "@tiptap/pm/commands";
+import { selectTextblockEnd as originalSelectTextblockEnd } from "@tiptap/pm/commands";
+import { selectTextblockStart as originalSelectTextblockStart } from "@tiptap/pm/commands";
+import { Transform } from "@tiptap/pm/transform";
+import { Node } from "@tiptap/pm/model";
+import { DOMSerializer } from "@tiptap/pm/model";
+import { Schema as Schema2 } from "@tiptap/pm/model";
+import { DOMParser as DOMParser2 } from "@tiptap/pm/model";
+import { Node as Node2 } from "@tiptap/pm/model";
+import { NodeSelection } from "@tiptap/pm/state";
+import { setBlockType } from "@tiptap/pm/commands";
+import { NodeSelection as NodeSelection2 } from "@tiptap/pm/state";
+import { TextSelection as TextSelection5 } from "@tiptap/pm/state";
+import { sinkListItem as originalSinkListItem } from "@tiptap/pm/schema-list";
+import { NodeSelection as NodeSelection3, TextSelection as TextSelection6 } from "@tiptap/pm/state";
+import { canSplit } from "@tiptap/pm/transform";
+import { Fragment as Fragment3, Slice } from "@tiptap/pm/model";
+import { TextSelection as TextSelection7 } from "@tiptap/pm/state";
+import { canSplit as canSplit2 } from "@tiptap/pm/transform";
+import { canJoin } from "@tiptap/pm/transform";
+import { wrapIn as originalWrapIn } from "@tiptap/pm/commands";
+import { wrapInList as originalWrapInList } from "@tiptap/pm/schema-list";
+import { EditorState } from "@tiptap/pm/state";
+import { EditorView } from "@tiptap/pm/view";
+import { keymap } from "@tiptap/pm/keymap";
+import { Fragment as Fragment4 } from "@tiptap/pm/model";
+import { Plugin } from "@tiptap/pm/state";
+import { Fragment as Fragment5 } from "@tiptap/pm/model";
+import { Plugin as Plugin2 } from "@tiptap/pm/state";
+import { Plugin as Plugin3, PluginKey } from "@tiptap/pm/state";
+import { RemoveMarkStep } from "@tiptap/pm/transform";
+import { Plugin as Plugin4, PluginKey as PluginKey2 } from "@tiptap/pm/state";
+import { Plugin as Plugin5, PluginKey as PluginKey3 } from "@tiptap/pm/state";
+import { Plugin as Plugin6, PluginKey as PluginKey4 } from "@tiptap/pm/state";
+import { Plugin as Plugin7, PluginKey as PluginKey5, Selection as Selection3 } from "@tiptap/pm/state";
+import { Plugin as Plugin8, PluginKey as PluginKey6 } from "@tiptap/pm/state";
+import { Plugin as Plugin9, PluginKey as PluginKey7 } from "@tiptap/pm/state";
+import { Plugin as Plugin10, PluginKey as PluginKey8 } from "@tiptap/pm/state";
+import { canJoin as canJoin2, findWrapping } from "@tiptap/pm/transform";
+import { NodeSelection as NodeSelection4 } from "@tiptap/pm/state";
+import { NodeSelection as NodeSelection5 } from "@tiptap/pm/state";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function createChainableState(config) {
+  const { state, transaction } = config;
+  let { selection } = transaction;
+  let { doc } = transaction;
+  let { storedMarks } = transaction;
+  return {
+    ...state,
+    apply: state.apply.bind(state),
+    applyTransaction: state.applyTransaction.bind(state),
+    plugins: state.plugins,
+    schema: state.schema,
+    reconfigure: state.reconfigure.bind(state),
+    toJSON: state.toJSON.bind(state),
+    get storedMarks() {
+      return storedMarks;
+    },
+    get selection() {
+      return selection;
+    },
+    get doc() {
+      return doc;
+    },
+    get tr() {
+      selection = transaction.selection;
+      doc = transaction.doc;
+      storedMarks = transaction.storedMarks;
+      return transaction;
+    }
+  };
+}
+var CommandManager = class {
+  constructor(props) {
+    this.editor = props.editor;
+    this.rawCommands = this.editor.extensionManager.commands;
+    this.customState = props.state;
+  }
+  get hasCustomState() {
+    return !!this.customState;
+  }
+  get state() {
+    return this.customState || this.editor.state;
+  }
+  get commands() {
+    const { rawCommands, editor, state } = this;
+    const { view } = editor;
+    const { tr } = state;
+    const props = this.buildProps(tr);
+    return Object.fromEntries(
+      Object.entries(rawCommands).map(([name, command2]) => {
+        const method = (...args) => {
+          const callback = command2(...args)(props);
+          if (!tr.getMeta("preventDispatch") && !this.hasCustomState) {
+            view.dispatch(tr);
+          }
+          return callback;
+        };
+        return [name, method];
+      })
+    );
+  }
+  get chain() {
+    return () => this.createChain();
+  }
+  get can() {
+    return () => this.createCan();
+  }
+  createChain(startTr, shouldDispatch = true) {
+    const { rawCommands, editor, state } = this;
+    const { view } = editor;
+    const callbacks = [];
+    const hasStartTransaction = !!startTr;
+    const tr = startTr || state.tr;
+    const run3 = () => {
+      if (!hasStartTransaction && shouldDispatch && !tr.getMeta("preventDispatch") && !this.hasCustomState) {
+        view.dispatch(tr);
+      }
+      return callbacks.every((callback) => callback === true);
+    };
+    const chain = {
+      ...Object.fromEntries(
+        Object.entries(rawCommands).map(([name, command2]) => {
+          const chainedCommand = (...args) => {
+            const props = this.buildProps(tr, shouldDispatch);
+            const callback = command2(...args)(props);
+            callbacks.push(callback);
+            return chain;
+          };
+          return [name, chainedCommand];
+        })
+      ),
+      run: run3
+    };
+    return chain;
+  }
+  createCan(startTr) {
+    const { rawCommands, state } = this;
+    const dispatch = false;
+    const tr = startTr || state.tr;
+    const props = this.buildProps(tr, dispatch);
+    const formattedCommands = Object.fromEntries(
+      Object.entries(rawCommands).map(([name, command2]) => {
+        return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
+      })
+    );
+    return {
+      ...formattedCommands,
+      chain: () => this.createChain(tr, dispatch)
+    };
+  }
+  buildProps(tr, shouldDispatch = true) {
+    const { rawCommands, editor, state } = this;
+    const { view } = editor;
+    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;
+  }
+};
+var commands_exports = {};
+__export(commands_exports, {
+  blur: () => blur,
+  clearContent: () => clearContent,
+  clearNodes: () => clearNodes,
+  command: () => command,
+  createParagraphNear: () => createParagraphNear,
+  cut: () => cut,
+  deleteCurrentNode: () => deleteCurrentNode,
+  deleteNode: () => deleteNode,
+  deleteRange: () => deleteRange,
+  deleteSelection: () => deleteSelection,
+  enter: () => enter,
+  exitCode: () => exitCode,
+  extendMarkRange: () => extendMarkRange,
+  first: () => first,
+  focus: () => focus,
+  forEach: () => forEach,
+  insertContent: () => insertContent,
+  insertContentAt: () => insertContentAt,
+  joinBackward: () => joinBackward,
+  joinDown: () => joinDown,
+  joinForward: () => joinForward,
+  joinItemBackward: () => joinItemBackward,
+  joinItemForward: () => joinItemForward,
+  joinTextblockBackward: () => joinTextblockBackward,
+  joinTextblockForward: () => joinTextblockForward,
+  joinUp: () => joinUp,
+  keyboardShortcut: () => keyboardShortcut,
+  lift: () => lift,
+  liftEmptyBlock: () => liftEmptyBlock,
+  liftListItem: () => liftListItem,
+  newlineInCode: () => newlineInCode,
+  resetAttributes: () => resetAttributes,
+  scrollIntoView: () => scrollIntoView,
+  selectAll: () => selectAll,
+  selectNodeBackward: () => selectNodeBackward,
+  selectNodeForward: () => selectNodeForward,
+  selectParentNode: () => selectParentNode,
+  selectTextblockEnd: () => selectTextblockEnd,
+  selectTextblockStart: () => selectTextblockStart,
+  setContent: () => setContent,
+  setMark: () => setMark,
+  setMeta: () => setMeta,
+  setNode: () => setNode,
+  setNodeSelection: () => setNodeSelection,
+  setTextDirection: () => setTextDirection,
+  setTextSelection: () => setTextSelection,
+  sinkListItem: () => sinkListItem,
+  splitBlock: () => splitBlock,
+  splitListItem: () => splitListItem,
+  toggleList: () => toggleList,
+  toggleMark: () => toggleMark,
+  toggleNode: () => toggleNode,
+  toggleWrap: () => toggleWrap,
+  undoInputRule: () => undoInputRule,
+  unsetAllMarks: () => unsetAllMarks,
+  unsetMark: () => unsetMark,
+  unsetTextDirection: () => unsetTextDirection,
+  updateAttributes: () => updateAttributes,
+  wrapIn: () => wrapIn,
+  wrapInList: () => wrapInList
+});
+var blur = () => ({ editor, view }) => {
+  requestAnimationFrame(() => {
+    var _a;
+    if (!editor.isDestroyed) {
+      ;
+      view.dom.blur();
+      (_a = window == null ? void 0 : window.getSelection()) == null ? void 0 : _a.removeAllRanges();
+    }
+  });
+  return true;
+};
+var clearContent = (emitUpdate = true) => ({ commands }) => {
+  return commands.setContent("", { emitUpdate });
+};
+var clearNodes = () => ({ state, tr, dispatch }) => {
+  const { selection } = tr;
+  const { ranges } = selection;
+  if (!dispatch) {
+    return true;
+  }
+  ranges.forEach(({ $from, $to }) => {
+    state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+      if (node.type.isText) {
+        return;
+      }
+      const { doc, mapping } = tr;
+      const $mappedFrom = doc.resolve(mapping.map(pos));
+      const $mappedTo = doc.resolve(mapping.map(pos + node.nodeSize));
+      const nodeRange = $mappedFrom.blockRange($mappedTo);
+      if (!nodeRange) {
+        return;
+      }
+      const targetLiftDepth = 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;
+};
+var command = (fn) => (props) => {
+  return fn(props);
+};
+var createParagraphNear = () => ({ state, dispatch }) => {
+  return originalCreateParagraphNear(state, dispatch);
+};
+var cut = (originRange, targetPos) => ({ editor, tr }) => {
+  const { state } = editor;
+  const contentSlice = state.doc.slice(originRange.from, originRange.to);
+  tr.deleteRange(originRange.from, originRange.to);
+  const newPos = tr.mapping.map(targetPos);
+  tr.insert(newPos, contentSlice.content);
+  tr.setSelection(new TextSelection(tr.doc.resolve(Math.max(newPos - 1, 0))));
+  return true;
+};
+var deleteCurrentNode = () => ({ tr, dispatch }) => {
+  const { selection } = tr;
+  const currentNode = selection.$anchor.node();
+  if (currentNode.content.size > 0) {
+    return false;
+  }
+  const $pos = tr.selection.$anchor;
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type === currentNode.type) {
+      if (dispatch) {
+        const from = $pos.before(depth);
+        const to = $pos.after(depth);
+        tr.delete(from, to).scrollIntoView();
+      }
+      return true;
+    }
+  }
+  return false;
+};
+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;
+}
+var deleteNode = (typeOrName) => ({ tr, state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const $pos = tr.selection.$anchor;
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type === type) {
+      if (dispatch) {
+        const from = $pos.before(depth);
+        const to = $pos.after(depth);
+        tr.delete(from, to).scrollIntoView();
+      }
+      return true;
+    }
+  }
+  return false;
+};
+var deleteRange = (range) => ({ tr, dispatch }) => {
+  const { from, to } = range;
+  if (dispatch) {
+    tr.delete(from, to);
+  }
+  return true;
+};
+var deleteSelection = () => ({ state, dispatch }) => {
+  return originalDeleteSelection(state, dispatch);
+};
+var enter = () => ({ commands }) => {
+  return commands.keyboardShortcut("Enter");
+};
+var exitCode = () => ({ state, dispatch }) => {
+  return originalExitCode(state, dispatch);
+};
+function isRegExp(value) {
+  return Object.prototype.toString.call(value) === "[object RegExp]";
+}
+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 ? void 0 : _a.attrs);
+  const mark = findMarkInSet([...start.node.marks], type, attributes);
+  if (!mark) {
+    return;
+  }
+  let startIndex = start.index;
+  let startPos = $pos.start() + start.offset;
+  let endIndex = startIndex + 1;
+  let endPos = startPos + start.node.nodeSize;
+  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
+    startIndex -= 1;
+    startPos -= $pos.parent.child(startIndex).nodeSize;
+  }
+  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
+    endPos += $pos.parent.child(endIndex).nodeSize;
+    endIndex += 1;
+  }
+  return {
+    from: startPos,
+    to: endPos
+  };
+}
+function getMarkType(nameOrType, schema) {
+  if (typeof nameOrType === "string") {
+    if (!schema.marks[nameOrType]) {
+      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
+    }
+    return schema.marks[nameOrType];
+  }
+  return nameOrType;
+}
+var extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+  const type = getMarkType(typeOrName, state.schema);
+  const { doc, selection } = tr;
+  const { $from, from, to } = selection;
+  if (dispatch) {
+    const range = getMarkRange($from, type, attributes);
+    if (range && range.from <= from && range.to >= to) {
+      const newSelection = TextSelection2.create(doc, range.from, range.to);
+      tr.setSelection(newSelection);
+    }
+  }
+  return true;
+};
+var first = (commands) => (props) => {
+  const items = typeof commands === "function" ? commands(props) : commands;
+  for (let i = 0; i < items.length; i += 1) {
+    if (items[i](props)) {
+      return true;
+    }
+  }
+  return false;
+};
+function isTextSelection(value) {
+  return value instanceof TextSelection3;
+}
+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 TextSelection4.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
+  }
+  return TextSelection4.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
+}
+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) || // iPad on iOS 13 detection
+  navigator.userAgent.includes("Mac") && "ontouchend" in document;
+}
+function isSafari() {
+  return typeof navigator !== "undefined" ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : false;
+}
+var focus = (position = null, options = {}) => ({ editor, view, tr, dispatch }) => {
+  options = {
+    scrollIntoView: true,
+    ...options
+  };
+  const delayedFocus = () => {
+    if (isiOS() || isAndroid()) {
+      ;
+      view.dom.focus();
+    }
+    if (isSafari() && !isiOS() && !isAndroid()) {
+      ;
+      view.dom.focus({ preventScroll: true });
+    }
+    requestAnimationFrame(() => {
+      if (!editor.isDestroyed) {
+        view.focus();
+        if (options == null ? void 0 : options.scrollIntoView) {
+          editor.commands.scrollIntoView();
+        }
+      }
+    });
+  };
+  if (view.hasFocus() && position === null || position === false) {
+    return true;
+  }
+  if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
+    delayedFocus();
+    return true;
+  }
+  const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection;
+  const isSameSelection = editor.state.selection.eq(selection);
+  if (dispatch) {
+    if (!isSameSelection) {
+      tr.setSelection(selection);
+    }
+    if (isSameSelection && tr.storedMarks) {
+      tr.setStoredMarks(tr.storedMarks);
+    }
+    delayedFocus();
+  }
+  return true;
+};
+var forEach = (items, fn) => (props) => {
+  return items.every((item, index) => fn(item, { ...props, index }));
+};
+var insertContent = (value, options) => ({ tr, commands }) => {
+  return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
+};
+var removeWhitespaces = (node) => {
+  const children = node.childNodes;
+  for (let i = children.length - 1; i >= 0; i -= 1) {
+    const child = children[i];
+    if (child.nodeType === 3 && child.nodeValue && /^(\n\s\s|\n)$/.test(child.nodeValue)) {
+      node.removeChild(child);
+    } else if (child.nodeType === 1) {
+      removeWhitespaces(child);
+    }
+  }
+  return node;
+};
+function elementFromString(value) {
+  if (typeof window === "undefined") {
+    throw new Error("[tiptap error]: there is no window object available, so this function cannot be used");
+  }
+  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 ProseMirrorNode || content instanceof Fragment) {
+    return content;
+  }
+  options = {
+    slice: true,
+    parseOptions: {},
+    ...options
+  };
+  const isJSONContent = typeof content === "object" && content !== null;
+  const isTextContent = typeof content === "string";
+  if (isJSONContent) {
+    try {
+      const isArrayContent = Array.isArray(content) && content.length > 0;
+      if (isArrayContent) {
+        return Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
+      }
+      const node = schema.nodeFromJSON(content);
+      if (options.errorOnInvalidContent) {
+        node.check();
+      }
+      return node;
+    } catch (error) {
+      if (options.errorOnInvalidContent) {
+        throw new Error("[tiptap error]: Invalid JSON content", { cause: error });
+      }
+      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
+      return createNodeFromContent("", schema, options);
+    }
+  }
+  if (isTextContent) {
+    if (options.errorOnInvalidContent) {
+      let hasInvalidContent = false;
+      let invalidContent = "";
+      const contentCheckSchema = new Schema({
+        topNode: schema.spec.topNode,
+        marks: schema.spec.marks,
+        // Prosemirror's schemas are executed such that: the last to execute, matches last
+        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
+        nodes: schema.spec.nodes.append({
+          __tiptap__private__unknown__catch__all__node: {
+            content: "inline*",
+            group: "block",
+            parseDOM: [
+              {
+                tag: "*",
+                getAttrs: (e) => {
+                  hasInvalidContent = true;
+                  invalidContent = typeof e === "string" ? e : e.outerHTML;
+                  return null;
+                }
+              }
+            ]
+          }
+        })
+      });
+      if (options.slice) {
+        DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
+      } else {
+        DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
+      }
+      if (options.errorOnInvalidContent && hasInvalidContent) {
+        throw new Error("[tiptap error]: Invalid HTML content", {
+          cause: new Error(`Invalid element found: ${invalidContent}`)
+        });
+      }
+    }
+    const parser = DOMParser.fromSchema(schema);
+    if (options.slice) {
+      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
+    }
+    return parser.parse(elementFromString(content), options.parseOptions);
+  }
+  return createNodeFromContent("", schema, options);
+}
+function selectionToInsertionEnd(tr, startLen, bias) {
+  const last = tr.steps.length - 1;
+  if (last < startLen) {
+    return;
+  }
+  const step = tr.steps[last];
+  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
+    return;
+  }
+  const map = tr.mapping.maps[last];
+  let end = 0;
+  map.forEach((_from, _to, _newFrom, newTo) => {
+    if (end === 0) {
+      end = newTo;
+    }
+  });
+  tr.setSelection(Selection2.near(tr.doc.resolve(end), bias));
+}
+var isFragment = (nodeOrFragment) => {
+  return !("type" in nodeOrFragment);
+};
+var insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
+  var _a;
+  if (dispatch) {
+    options = {
+      parseOptions: editor.options.parseOptions,
+      updateSelection: true,
+      applyInputRules: false,
+      applyPasteRules: false,
+      ...options
+    };
+    let content;
+    const emitContentError = (error) => {
+      editor.emit("contentError", {
+        editor,
+        error,
+        disableCollaboration: () => {
+          if ("collaboration" in editor.storage && typeof editor.storage.collaboration === "object" && 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 : 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 Fragment2) {
+        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;
+      const $from = tr.doc.resolve(from);
+      const $fromNode = $from.node();
+      const fromSelectionAtStart = $from.parentOffset === 0;
+      const isTextSelection2 = $fromNode.isText || $fromNode.isTextblock;
+      const hasContent = $fromNode.content.size > 0;
+      if (fromSelectionAtStart && isTextSelection2 && hasContent) {
+        from = Math.max(0, from - 1);
+      }
+      tr.replaceWith(from, to, newContent);
+    }
+    if (options.updateSelection) {
+      selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
+    }
+    if (options.applyInputRules) {
+      tr.setMeta("applyInputRules", { from, text: newContent });
+    }
+    if (options.applyPasteRules) {
+      tr.setMeta("applyPasteRules", { from, text: newContent });
+    }
+  }
+  return true;
+};
+var joinUp = () => ({ state, dispatch }) => {
+  return originalJoinUp(state, dispatch);
+};
+var joinDown = () => ({ state, dispatch }) => {
+  return originalJoinDown(state, dispatch);
+};
+var joinBackward = () => ({ state, dispatch }) => {
+  return originalJoinBackward(state, dispatch);
+};
+var joinForward = () => ({ state, dispatch }) => {
+  return originalJoinForward(state, dispatch);
+};
+var 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;
+  }
+};
+var joinItemForward = () => ({ state, dispatch, tr }) => {
+  try {
+    const point = joinPoint2(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;
+  }
+};
+var joinTextblockBackward = () => ({ state, dispatch }) => {
+  return originalCommand(state, dispatch);
+};
+var joinTextblockForward = () => ({ state, dispatch }) => {
+  return originalCommand2(state, dispatch);
+};
+function isMacOS() {
+  return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
+}
+function normalizeKeyName(name) {
+  const parts = name.split(/-(?!$)/);
+  let result = parts[parts.length - 1];
+  if (result === "Space") {
+    result = " ";
+  }
+  let alt;
+  let ctrl;
+  let shift;
+  let meta;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    const mod = parts[i];
+    if (/^(cmd|meta|m)$/i.test(mod)) {
+      meta = true;
+    } else if (/^a(lt)?$/i.test(mod)) {
+      alt = true;
+    } else if (/^(c|ctrl|control)$/i.test(mod)) {
+      ctrl = true;
+    } else if (/^s(hift)?$/i.test(mod)) {
+      shift = true;
+    } else if (/^mod$/i.test(mod)) {
+      if (isiOS() || isMacOS()) {
+        meta = true;
+      } else {
+        ctrl = true;
+      }
+    } else {
+      throw new Error(`Unrecognized modifier name: ${mod}`);
+    }
+  }
+  if (alt) {
+    result = `Alt-${result}`;
+  }
+  if (ctrl) {
+    result = `Ctrl-${result}`;
+  }
+  if (meta) {
+    result = `Meta-${result}`;
+  }
+  if (shift) {
+    result = `Shift-${result}`;
+  }
+  return result;
+}
+var keyboardShortcut = (name) => ({ editor, view, tr, dispatch }) => {
+  const keys = normalizeKeyName(name).split(/-(?!$)/);
+  const key = keys.find((item) => !["Alt", "Ctrl", "Meta", "Shift"].includes(item));
+  const event = new KeyboardEvent("keydown", {
+    key: key === "Space" ? " " : key,
+    altKey: keys.includes("Alt"),
+    ctrlKey: keys.includes("Ctrl"),
+    metaKey: keys.includes("Meta"),
+    shiftKey: keys.includes("Shift"),
+    bubbles: true,
+    cancelable: true
+  });
+  const capturedTransaction = editor.captureTransaction(() => {
+    view.someProp("handleKeyDown", (f) => f(view, event));
+  });
+  capturedTransaction == null ? void 0 : capturedTransaction.steps.forEach((step) => {
+    const newStep = step.map(tr.mapping);
+    if (newStep && dispatch) {
+      tr.maybeStep(newStep);
+    }
+  });
+  return true;
+};
+function isNodeActive(state, typeOrName, attributes = {}) {
+  const { from, to, empty } = state.selection;
+  const type = typeOrName ? getNodeType(typeOrName, state.schema) : null;
+  const nodeRanges = [];
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.isText) {
+      return;
+    }
+    const relativeFrom = Math.max(from, pos);
+    const relativeTo = Math.min(to, pos + node.nodeSize);
+    nodeRanges.push({
+      node,
+      from: relativeFrom,
+      to: relativeTo
+    });
+  });
+  const selectionRange = to - from;
+  const matchedNodeRanges = nodeRanges.filter((nodeRange) => {
+    if (!type) {
+      return true;
+    }
+    return type.name === nodeRange.node.type.name;
+  }).filter((nodeRange) => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }));
+  if (empty) {
+    return !!matchedNodeRanges.length;
+  }
+  const range = matchedNodeRanges.reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0);
+  return range >= selectionRange;
+}
+var lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  if (!isActive2) {
+    return false;
+  }
+  return originalLift(state, dispatch);
+};
+var liftEmptyBlock = () => ({ state, dispatch }) => {
+  return originalLiftEmptyBlock(state, dispatch);
+};
+var liftListItem = (typeOrName) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return originalLiftListItem(type)(state, dispatch);
+};
+var newlineInCode = () => ({ state, dispatch }) => {
+  return originalNewlineInCode(state, dispatch);
+};
+function getSchemaTypeNameByName(name, schema) {
+  if (schema.nodes[name]) {
+    return "node";
+  }
+  if (schema.marks[name]) {
+    return "mark";
+  }
+  return null;
+}
+function deleteProps(obj, propOrProps) {
+  const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
+  return Object.keys(obj).reduce((newObj, prop) => {
+    if (!props.includes(prop)) {
+      newObj[prop] = obj[prop];
+    }
+    return newObj;
+  }, {});
+}
+var resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
+  let nodeType = null;
+  let markType = null;
+  const schemaType = getSchemaTypeNameByName(
+    typeof typeOrName === "string" ? typeOrName : typeOrName.name,
+    state.schema
+  );
+  if (!schemaType) {
+    return false;
+  }
+  if (schemaType === "node") {
+    nodeType = getNodeType(typeOrName, state.schema);
+  }
+  if (schemaType === "mark") {
+    markType = getMarkType(typeOrName, state.schema);
+  }
+  let canReset = false;
+  tr.selection.ranges.forEach((range) => {
+    state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
+      if (nodeType && nodeType === node.type) {
+        canReset = true;
+        if (dispatch) {
+          tr.setNodeMarkup(pos, void 0, deleteProps(node.attrs, attributes));
+        }
+      }
+      if (markType && node.marks.length) {
+        node.marks.forEach((mark) => {
+          if (markType === mark.type) {
+            canReset = true;
+            if (dispatch) {
+              tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
+            }
+          }
+        });
+      }
+    });
+  });
+  return canReset;
+};
+var scrollIntoView = () => ({ tr, dispatch }) => {
+  if (dispatch) {
+    tr.scrollIntoView();
+  }
+  return true;
+};
+var selectAll = () => ({ tr, dispatch }) => {
+  if (dispatch) {
+    const selection = new AllSelection(tr.doc);
+    tr.setSelection(selection);
+  }
+  return true;
+};
+var selectNodeBackward = () => ({ state, dispatch }) => {
+  return originalSelectNodeBackward(state, dispatch);
+};
+var selectNodeForward = () => ({ state, dispatch }) => {
+  return originalSelectNodeForward(state, dispatch);
+};
+var selectParentNode = () => ({ state, dispatch }) => {
+  return originalSelectParentNode(state, dispatch);
+};
+var selectTextblockEnd = () => ({ state, dispatch }) => {
+  return originalSelectTextblockEnd(state, dispatch);
+};
+var selectTextblockStart = () => ({ state, dispatch }) => {
+  return originalSelectTextblockStart(state, dispatch);
+};
+function createDocument(content, schema, parseOptions = {}, options = {}) {
+  return createNodeFromContent(content, schema, {
+    slice: false,
+    parseOptions,
+    errorOnInvalidContent: options.errorOnInvalidContent
+  });
+}
+var setContent = (content, { errorOnInvalidContent, emitUpdate = true, parseOptions = {} } = {}) => ({ editor, tr, dispatch, commands }) => {
+  const { doc } = tr;
+  if (parseOptions.preserveWhitespace !== "full") {
+    const document2 = createDocument(content, editor.schema, parseOptions, {
+      errorOnInvalidContent: errorOnInvalidContent != null ? errorOnInvalidContent : editor.options.enableContentCheck
+    });
+    if (dispatch) {
+      tr.replaceWith(0, doc.content.size, document2).setMeta("preventUpdate", !emitUpdate);
+    }
+    return true;
+  }
+  if (dispatch) {
+    tr.setMeta("preventUpdate", !emitUpdate);
+  }
+  return commands.insertContentAt({ from: 0, to: doc.content.size }, content, {
+    parseOptions,
+    errorOnInvalidContent: errorOnInvalidContent != null ? errorOnInvalidContent : editor.options.enableContentCheck
+  });
+};
+function getMarkAttributes(state, typeOrName) {
+  const type = getMarkType(typeOrName, state.schema);
+  const { from, to, empty } = state.selection;
+  const marks = [];
+  if (empty) {
+    if (state.storedMarks) {
+      marks.push(...state.storedMarks);
+    }
+    marks.push(...state.selection.$head.marks());
+  } else {
+    state.doc.nodesBetween(from, to, (node) => {
+      marks.push(...node.marks);
+    });
+  }
+  const mark = marks.find((markItem) => markItem.type.name === type.name);
+  if (!mark) {
+    return {};
+  }
+  return { ...mark.attrs };
+}
+function combineTransactionSteps(oldDoc, transactions) {
+  const transform = new Transform(oldDoc);
+  transactions.forEach((transaction) => {
+    transaction.steps.forEach((step) => {
+      transform.step(step);
+    });
+  });
+  return transform;
+}
+function defaultBlockAt(match) {
+  for (let i = 0; i < match.edgeCount; i += 1) {
+    const { type } = match.edge(i);
+    if (type.isTextblock && !type.hasRequiredAttrs()) {
+      return type;
+    }
+  }
+  return null;
+}
+function 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 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 flattenExtensions(extensions) {
+  return extensions.map((extension) => {
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage
+    };
+    const addExtensions = getExtensionField(extension, "addExtensions", context);
+    if (addExtensions) {
+      return [extension, ...flattenExtensions(addExtensions())];
+    }
+    return extension;
+  }).flat(10);
+}
+function getHTMLFromFragment(fragment, schema) {
+  const documentFragment = DOMSerializer.fromSchema(schema).serializeFragment(fragment);
+  const temporaryDocument = document.implementation.createHTMLDocument();
+  const container = temporaryDocument.createElement("div");
+  container.appendChild(documentFragment);
+  return container.innerHTML;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function callOrReturn(value, context = void 0, ...props) {
+  if (isFunction(value)) {
+    if (context) {
+      return value.bind(context)(...props);
+    }
+    return value(...props);
+  }
+  return value;
+}
+function isEmptyObject(value = {}) {
+  return Object.keys(value).length === 0 && value.constructor === Object;
+}
+function splitExtensions(extensions) {
+  const baseExtensions = extensions.filter((extension) => extension.type === "extension");
+  const nodeExtensions = extensions.filter((extension) => extension.type === "node");
+  const markExtensions = extensions.filter((extension) => extension.type === "mark");
+  return {
+    baseExtensions,
+    nodeExtensions,
+    markExtensions
+  };
+}
+function getAttributesFromExtensions(extensions) {
+  const extensionAttributes = [];
+  const { nodeExtensions, markExtensions } = splitExtensions(extensions);
+  const nodeAndMarkExtensions = [...nodeExtensions, ...markExtensions];
+  const defaultAttribute = {
+    default: null,
+    validate: void 0,
+    rendered: true,
+    renderHTML: null,
+    parseHTML: null,
+    keepOnSplit: true,
+    isRequired: false
+  };
+  extensions.forEach((extension) => {
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage,
+      extensions: nodeAndMarkExtensions
+    };
+    const addGlobalAttributes = getExtensionField(
+      extension,
+      "addGlobalAttributes",
+      context
+    );
+    if (!addGlobalAttributes) {
+      return;
+    }
+    const globalAttributes = addGlobalAttributes();
+    globalAttributes.forEach((globalAttribute) => {
+      globalAttribute.types.forEach((type) => {
+        Object.entries(globalAttribute.attributes).forEach(([name, attribute]) => {
+          extensionAttributes.push({
+            type,
+            name,
+            attribute: {
+              ...defaultAttribute,
+              ...attribute
+            }
+          });
+        });
+      });
+    });
+  });
+  nodeAndMarkExtensions.forEach((extension) => {
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage
+    };
+    const addAttributes = getExtensionField(
+      extension,
+      "addAttributes",
+      context
+    );
+    if (!addAttributes) {
+      return;
+    }
+    const attributes = addAttributes();
+    Object.entries(attributes).forEach(([name, attribute]) => {
+      const mergedAttr = {
+        ...defaultAttribute,
+        ...attribute
+      };
+      if (typeof (mergedAttr == null ? void 0 : mergedAttr.default) === "function") {
+        mergedAttr.default = mergedAttr.default();
+      }
+      if ((mergedAttr == null ? void 0 : mergedAttr.isRequired) && (mergedAttr == null ? void 0 : mergedAttr.default) === void 0) {
+        delete mergedAttr.default;
+      }
+      extensionAttributes.push({
+        type: extension.name,
+        name,
+        attribute: mergedAttr
+      });
+    });
+  });
+  return extensionAttributes;
+}
+function mergeAttributes(...objects) {
+  return objects.filter((item) => !!item).reduce((items, item) => {
+    const mergedAttributes = { ...items };
+    Object.entries(item).forEach(([key, value]) => {
+      const exists = mergedAttributes[key];
+      if (!exists) {
+        mergedAttributes[key] = value;
+        return;
+      }
+      if (key === "class") {
+        const valueClasses = value ? String(value).split(" ") : [];
+        const existingClasses = mergedAttributes[key] ? mergedAttributes[key].split(" ") : [];
+        const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
+        mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
+      } else if (key === "style") {
+        const newStyles = value ? value.split(";").map((style2) => style2.trim()).filter(Boolean) : [];
+        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style2) => style2.trim()).filter(Boolean) : [];
+        const styleMap = /* @__PURE__ */ new Map();
+        existingStyles.forEach((style2) => {
+          const [property, val] = style2.split(":").map((part) => part.trim());
+          styleMap.set(property, val);
+        });
+        newStyles.forEach((style2) => {
+          const [property, val] = style2.split(":").map((part) => part.trim());
+          styleMap.set(property, val);
+        });
+        mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
+      } else {
+        mergedAttributes[key] = value;
+      }
+    });
+    return mergedAttributes;
+  }, {});
+}
+function getRenderedAttributes(nodeOrMark, extensionAttributes) {
+  return extensionAttributes.filter((attribute) => attribute.type === nodeOrMark.type.name).filter((item) => item.attribute.rendered).map((item) => {
+    if (!item.attribute.renderHTML) {
+      return {
+        [item.name]: nodeOrMark.attrs[item.name]
+      };
+    }
+    return item.attribute.renderHTML(nodeOrMark.attrs) || {};
+  }).reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {});
+}
+function fromString(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  if (value.match(/^[+-]?(?:\d*\.)?\d+$/)) {
+    return Number(value);
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  return value;
+}
+function injectExtensionAttributesToParseRule(parseRule, extensionAttributes) {
+  if ("style" in parseRule) {
+    return parseRule;
+  }
+  return {
+    ...parseRule,
+    getAttrs: (node) => {
+      const oldAttributes = parseRule.getAttrs ? parseRule.getAttrs(node) : parseRule.attrs;
+      if (oldAttributes === false) {
+        return false;
+      }
+      const newAttributes = extensionAttributes.reduce((items, item) => {
+        const value = item.attribute.parseHTML ? item.attribute.parseHTML(node) : fromString(node.getAttribute(item.name));
+        if (value === null || value === void 0) {
+          return items;
+        }
+        return {
+          ...items,
+          [item.name]: value
+        };
+      }, {});
+      return { ...oldAttributes, ...newAttributes };
+    }
+  };
+}
+function cleanUpSchemaItem(data) {
+  return Object.fromEntries(
+    // @ts-ignore
+    Object.entries(data).filter(([key, value]) => {
+      if (key === "attrs" && isEmptyObject(value)) {
+        return false;
+      }
+      return value !== null && value !== void 0;
+    })
+  );
+}
+function buildAttributeSpec(extensionAttribute) {
+  var _a, _b;
+  const spec = {};
+  if (!((_a = extensionAttribute == null ? void 0 : extensionAttribute.attribute) == null ? void 0 : _a.isRequired) && "default" in ((extensionAttribute == null ? void 0 : extensionAttribute.attribute) || {})) {
+    spec.default = extensionAttribute.attribute.default;
+  }
+  if (((_b = extensionAttribute == null ? void 0 : extensionAttribute.attribute) == null ? void 0 : _b.validate) !== void 0) {
+    spec.validate = extensionAttribute.attribute.validate;
+  }
+  return [extensionAttribute.name, spec];
+}
+function getSchemaByResolvedExtensions(extensions, editor) {
+  var _a;
+  const allAttributes = getAttributesFromExtensions(extensions);
+  const { nodeExtensions, markExtensions } = splitExtensions(extensions);
+  const topNode = (_a = nodeExtensions.find((extension) => getExtensionField(extension, "topNode"))) == null ? void 0 : _a.name;
+  const nodes = Object.fromEntries(
+    nodeExtensions.map((extension) => {
+      const extensionAttributes = allAttributes.filter((attribute) => attribute.type === extension.name);
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+        editor
+      };
+      const extraNodeFields = extensions.reduce((fields, e) => {
+        const extendNodeSchema = getExtensionField(e, "extendNodeSchema", context);
+        return {
+          ...fields,
+          ...extendNodeSchema ? extendNodeSchema(extension) : {}
+        };
+      }, {});
+      const schema = cleanUpSchemaItem({
+        ...extraNodeFields,
+        content: callOrReturn(getExtensionField(extension, "content", context)),
+        marks: callOrReturn(getExtensionField(extension, "marks", context)),
+        group: callOrReturn(getExtensionField(extension, "group", context)),
+        inline: callOrReturn(getExtensionField(extension, "inline", context)),
+        atom: callOrReturn(getExtensionField(extension, "atom", context)),
+        selectable: callOrReturn(getExtensionField(extension, "selectable", context)),
+        draggable: callOrReturn(getExtensionField(extension, "draggable", context)),
+        code: callOrReturn(getExtensionField(extension, "code", context)),
+        whitespace: callOrReturn(getExtensionField(extension, "whitespace", context)),
+        linebreakReplacement: callOrReturn(
+          getExtensionField(extension, "linebreakReplacement", context)
+        ),
+        defining: callOrReturn(getExtensionField(extension, "defining", context)),
+        isolating: callOrReturn(getExtensionField(extension, "isolating", context)),
+        attrs: Object.fromEntries(extensionAttributes.map(buildAttributeSpec))
+      });
+      const parseHTML = callOrReturn(getExtensionField(extension, "parseHTML", context));
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map(
+          (parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes)
+        );
+      }
+      const renderHTML = getExtensionField(extension, "renderHTML", context);
+      if (renderHTML) {
+        schema.toDOM = (node) => renderHTML({
+          node,
+          HTMLAttributes: getRenderedAttributes(node, extensionAttributes)
+        });
+      }
+      const renderText = getExtensionField(extension, "renderText", context);
+      if (renderText) {
+        schema.toText = renderText;
+      }
+      return [extension.name, schema];
+    })
+  );
+  const marks = Object.fromEntries(
+    markExtensions.map((extension) => {
+      const extensionAttributes = allAttributes.filter((attribute) => attribute.type === extension.name);
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+        editor
+      };
+      const extraMarkFields = extensions.reduce((fields, e) => {
+        const extendMarkSchema = getExtensionField(e, "extendMarkSchema", context);
+        return {
+          ...fields,
+          ...extendMarkSchema ? extendMarkSchema(extension) : {}
+        };
+      }, {});
+      const schema = cleanUpSchemaItem({
+        ...extraMarkFields,
+        inclusive: callOrReturn(getExtensionField(extension, "inclusive", context)),
+        excludes: callOrReturn(getExtensionField(extension, "excludes", context)),
+        group: callOrReturn(getExtensionField(extension, "group", context)),
+        spanning: callOrReturn(getExtensionField(extension, "spanning", context)),
+        code: callOrReturn(getExtensionField(extension, "code", context)),
+        attrs: Object.fromEntries(extensionAttributes.map(buildAttributeSpec))
+      });
+      const parseHTML = callOrReturn(getExtensionField(extension, "parseHTML", context));
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map(
+          (parseRule) => injectExtensionAttributesToParseRule(parseRule, extensionAttributes)
+        );
+      }
+      const renderHTML = getExtensionField(extension, "renderHTML", context);
+      if (renderHTML) {
+        schema.toDOM = (mark) => renderHTML({
+          mark,
+          HTMLAttributes: getRenderedAttributes(mark, extensionAttributes)
+        });
+      }
+      return [extension.name, schema];
+    })
+  );
+  return new Schema2({
+    topNode,
+    nodes,
+    marks
+  });
+}
+function findDuplicates(items) {
+  const filtered = items.filter((el, index) => items.indexOf(el) !== index);
+  return Array.from(new Set(filtered));
+}
+function sortExtensions(extensions) {
+  const defaultPriority = 100;
+  return extensions.sort((a, b) => {
+    const priorityA = getExtensionField(a, "priority") || defaultPriority;
+    const priorityB = getExtensionField(b, "priority") || defaultPriority;
+    if (priorityA > priorityB) {
+      return -1;
+    }
+    if (priorityA < priorityB) {
+      return 1;
+    }
+    return 0;
+  });
+}
+function resolveExtensions(extensions) {
+  const resolvedExtensions = sortExtensions(flattenExtensions(extensions));
+  const duplicatedNames = findDuplicates(resolvedExtensions.map((extension) => extension.name));
+  if (duplicatedNames.length) {
+    console.warn(
+      `[tiptap warn]: Duplicate extension names found: [${duplicatedNames.map((item) => `'${item}'`).join(", ")}]. This can lead to issues.`
+    );
+  }
+  return resolvedExtensions;
+}
+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 ? 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 ? void 0 : node.text) == null ? 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 removeDuplicates(array, by = JSON.stringify) {
+  const seen = {};
+  return array.filter((item) => {
+    const key = by(item);
+    return Object.prototype.hasOwnProperty.call(seen, key) ? false : seen[key] = true;
+  });
+}
+function simplifyChangedRanges(changes) {
+  const uniqueChanges = removeDuplicates(changes);
+  return uniqueChanges.length === 1 ? uniqueChanges : uniqueChanges.filter((change, index) => {
+    const rest = uniqueChanges.filter((_, i) => i !== index);
+    return !rest.some((otherChange) => {
+      return change.oldRange.from >= otherChange.oldRange.from && change.oldRange.to <= otherChange.oldRange.to && change.newRange.from >= otherChange.newRange.from && change.newRange.to <= otherChange.newRange.to;
+    });
+  });
+}
+function getChangedRanges(transform) {
+  const { mapping, steps } = transform;
+  const changes = [];
+  mapping.maps.forEach((stepMap, index) => {
+    const ranges = [];
+    if (!stepMap.ranges.length) {
+      const { from, to } = steps[index];
+      if (from === void 0 || to === void 0) {
+        return;
+      }
+      ranges.push({ from, to });
+    } else {
+      stepMap.forEach((from, to) => {
+        ranges.push({ from, to });
+      });
+    }
+    ranges.forEach(({ from, to }) => {
+      const newStart = mapping.slice(index).map(from, -1);
+      const newEnd = mapping.slice(index).map(to);
+      const oldStart = mapping.invert().map(newStart, -1);
+      const oldEnd = mapping.invert().map(newEnd);
+      changes.push({
+        oldRange: {
+          from: oldStart,
+          to: oldEnd
+        },
+        newRange: {
+          from: newStart,
+          to: newEnd
+        }
+      });
+    });
+  });
+  return simplifyChangedRanges(changes);
+}
+function getSchemaTypeByName(name, schema) {
+  return schema.nodes[name] || schema.marks[name] || null;
+}
+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;
+    })
+  );
+}
+var getTextContentFromNodes = ($from, maxMatch = 500) => {
+  let textBefore = "";
+  const sliceEndPos = $from.parentOffset;
+  $from.parent.nodesBetween(Math.max(0, sliceEndPos - maxMatch), sliceEndPos, (node, pos, parent, index) => {
+    var _a, _b;
+    const chunk = ((_b = (_a = node.type.spec).toText) == null ? void 0 : _b.call(_a, {
+      node,
+      pos,
+      parent,
+      index
+    })) || node.textContent || "%leaf%";
+    textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos));
+  });
+  return textBefore;
+};
+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 isExtensionRulesEnabled(extension, enabled) {
+  if (Array.isArray(enabled)) {
+    return enabled.some((enabledExtension) => {
+      const name = typeof enabledExtension === "string" ? enabledExtension : enabledExtension.name;
+      return name === extension.name;
+    });
+  }
+  return enabled;
+}
+function 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 : "");
+    }
+  }
+  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 : cursor.marks();
+    const parentAllowsMarkType = cursor.parent.type.allowsMarkType(newMarkType);
+    return parentAllowsMarkType && (!!newMarkType.isInSet(currentMarks) || !currentMarks.some((mark) => mark.type.excludes(newMarkType)));
+  }
+  const { ranges } = selection;
+  return ranges.some(({ $from, $to }) => {
+    let someNodeSupportsMark = $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false;
+    state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
+      if (someNodeSupportsMark) {
+        return false;
+      }
+      if (node.isInline) {
+        const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
+        const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks) || !node.marks.some((otherMark) => otherMark.type.excludes(newMarkType));
+        someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
+      }
+      return !someNodeSupportsMark;
+    });
+    return someNodeSupportsMark;
+  });
+}
+var setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+  const { selection } = tr;
+  const { empty, ranges } = selection;
+  const type = getMarkType(typeOrName, state.schema);
+  if (dispatch) {
+    if (empty) {
+      const oldAttributes = getMarkAttributes(state, type);
+      tr.addStoredMark(
+        type.create({
+          ...oldAttributes,
+          ...attributes
+        })
+      );
+    } else {
+      ranges.forEach((range) => {
+        const from = range.$from.pos;
+        const to = range.$to.pos;
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          const trimmedFrom = Math.max(pos, from);
+          const trimmedTo = Math.min(pos + node.nodeSize, to);
+          const someHasMark = node.marks.find((mark) => mark.type === type);
+          if (someHasMark) {
+            node.marks.forEach((mark) => {
+              if (type === mark.type) {
+                tr.addMark(
+                  trimmedFrom,
+                  trimmedTo,
+                  type.create({
+                    ...mark.attrs,
+                    ...attributes
+                  })
+                );
+              }
+            });
+          } else {
+            tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
+          }
+        });
+      });
+    }
+  }
+  return canSetMark(state, tr, type);
+};
+var setMeta = (key, value) => ({ tr }) => {
+  tr.setMeta(key, value);
+  return true;
+};
+var setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  let attributesToCopy;
+  if (state.selection.$anchor.sameParent(state.selection.$head)) {
+    attributesToCopy = state.selection.$anchor.parent.attrs;
+  }
+  if (!type.isTextblock) {
+    console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
+    return false;
+  }
+  return chain().command(({ commands }) => {
+    const canSetBlock = setBlockType(type, { ...attributesToCopy, ...attributes })(state);
+    if (canSetBlock) {
+      return true;
+    }
+    return commands.clearNodes();
+  }).command(({ state: updatedState }) => {
+    return setBlockType(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
+  }).run();
+};
+var setNodeSelection = (position) => ({ tr, dispatch }) => {
+  if (dispatch) {
+    const { doc } = tr;
+    const from = minMax(position, 0, doc.content.size);
+    const selection = NodeSelection2.create(doc, from);
+    tr.setSelection(selection);
+  }
+  return true;
+};
+var setTextDirection = (direction, position) => ({ tr, state, dispatch }) => {
+  const { selection } = state;
+  let from;
+  let to;
+  if (typeof position === "number") {
+    from = position;
+    to = position;
+  } else if (position && "from" in position && "to" in position) {
+    from = position.from;
+    to = position.to;
+  } else {
+    from = selection.from;
+    to = selection.to;
+  }
+  if (dispatch) {
+    tr.doc.nodesBetween(from, to, (node, pos) => {
+      if (node.isText) {
+        return;
+      }
+      tr.setNodeMarkup(pos, void 0, {
+        ...node.attrs,
+        dir: direction
+      });
+    });
+  }
+  return true;
+};
+var setTextSelection = (position) => ({ tr, dispatch }) => {
+  if (dispatch) {
+    const { doc } = tr;
+    const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
+    const minPos = TextSelection5.atStart(doc).from;
+    const maxPos = TextSelection5.atEnd(doc).to;
+    const resolvedFrom = minMax(from, minPos, maxPos);
+    const resolvedEnd = minMax(to, minPos, maxPos);
+    const selection = TextSelection5.create(doc, resolvedFrom, resolvedEnd);
+    tr.setSelection(selection);
+  }
+  return true;
+};
+var sinkListItem = (typeOrName) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return originalSinkListItem(type)(state, dispatch);
+};
+function ensureMarks(state, splittableMarks) {
+  const marks = state.storedMarks || state.selection.$to.parentOffset && state.selection.$from.marks();
+  if (marks) {
+    const filteredMarks = marks.filter((mark) => splittableMarks == null ? void 0 : splittableMarks.includes(mark.type.name));
+    state.tr.ensureMarks(filteredMarks);
+  }
+}
+var splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor }) => {
+  const { selection, doc } = tr;
+  const { $from, $to } = selection;
+  const extensionAttributes = editor.extensionManager.attributes;
+  const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
+  if (selection instanceof NodeSelection3 && selection.node.isBlock) {
+    if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
+      return false;
+    }
+    if (dispatch) {
+      if (keepMarks) {
+        ensureMarks(state, editor.extensionManager.splittableMarks);
+      }
+      tr.split($from.pos).scrollIntoView();
+    }
+    return true;
+  }
+  if (!$from.parent.isBlock) {
+    return false;
+  }
+  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 TextSelection6) {
+        tr.deleteSelection();
+      }
+      tr.split(tr.mapping.map($from.pos), 1, types);
+      if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
+        const first2 = tr.mapping.map($from.before());
+        const $first = tr.doc.resolve(first2);
+        if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
+          tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
+        }
+      }
+    }
+    if (keepMarks) {
+      ensureMarks(state, editor.extensionManager.splittableMarks);
+    }
+    tr.scrollIntoView();
+  }
+  return can;
+};
+var splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor }) => {
+  var _a;
+  const type = getNodeType(typeOrName, state.schema);
+  const { $from, $to } = state.selection;
+  const node = state.selection.node;
+  if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
+    return false;
+  }
+  const grandParent = $from.node(-1);
+  if (grandParent.type !== type) {
+    return false;
+  }
+  const extensionAttributes = editor.extensionManager.attributes;
+  if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
+    if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
+      return false;
+    }
+    if (dispatch) {
+      let wrap = Fragment3.empty;
+      const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
+      for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
+        wrap = Fragment3.from($from.node(d).copy(wrap));
+      }
+      const depthAfter = (
+        // eslint-disable-next-line no-nested-ternary
+        $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 ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
+      wrap = wrap.append(Fragment3.from(type.createAndFill(null, nextType2) || void 0));
+      const start = $from.before($from.depth - (depthBefore - 1));
+      tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
+      let sel = -1;
+      tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
+        if (sel > -1) {
+          return false;
+        }
+        if (n.isTextblock && n.content.size === 0) {
+          sel = pos + 1;
+        }
+      });
+      if (sel > -1) {
+        tr.setSelection(TextSelection7.near(tr.doc.resolve(sel)));
+      }
+      tr.scrollIntoView();
+    }
+    return true;
+  }
+  const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
+  const newTypeAttributes = {
+    ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
+    ...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 (!canSplit2(tr.doc, $from.pos, 2)) {
+    return false;
+  }
+  if (dispatch) {
+    const { selection, storedMarks } = state;
+    const { splittableMarks } = editor.extensionManager;
+    const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
+    tr.split($from.pos, 2, types).scrollIntoView();
+    if (!marks || !dispatch) {
+      return true;
+    }
+    const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
+    tr.ensureMarks(filteredMarks);
+  }
+  return true;
+};
+var joinListBackwards = (tr, listType) => {
+  const list = findParentNode((node) => node.type === listType)(tr.selection);
+  if (!list) {
+    return true;
+  }
+  const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
+  if (before === void 0) {
+    return true;
+  }
+  const nodeBefore = tr.doc.nodeAt(before);
+  const canJoinBackwards = list.node.type === (nodeBefore == null ? void 0 : nodeBefore.type) && canJoin(tr.doc, list.pos);
+  if (!canJoinBackwards) {
+    return true;
+  }
+  tr.join(list.pos);
+  return true;
+};
+var joinListForwards = (tr, listType) => {
+  const list = findParentNode((node) => node.type === listType)(tr.selection);
+  if (!list) {
+    return true;
+  }
+  const after = tr.doc.resolve(list.start).after(list.depth);
+  if (after === void 0) {
+    return true;
+  }
+  const nodeAfter = tr.doc.nodeAt(after);
+  const canJoinForwards = list.node.type === (nodeAfter == null ? void 0 : nodeAfter.type) && canJoin(tr.doc, after);
+  if (!canJoinForwards) {
+    return true;
+  }
+  tr.join(after);
+  return true;
+};
+var toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands, 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 commands.liftListItem(itemType);
+    }
+    if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
+      return chain().command(() => {
+        tr.setNodeMarkup(parentList.pos, listType);
+        return true;
+      }).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
+    }
+  }
+  if (!keepMarks || !marks || !dispatch) {
+    return chain().command(() => {
+      const canWrapInList = can().wrapInList(listType, attributes);
+      if (canWrapInList) {
+        return true;
+      }
+      return commands.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 commands.clearNodes();
+  }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
+};
+var toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands }) => {
+  const { extendEmptyMarkRange = false } = options;
+  const type = getMarkType(typeOrName, state.schema);
+  const isActive2 = isMarkActive(state, type, attributes);
+  if (isActive2) {
+    return commands.unsetMark(type, { extendEmptyMarkRange });
+  }
+  return commands.setMark(type, attributes);
+};
+var toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const toggleType = getNodeType(toggleTypeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  let attributesToCopy;
+  if (state.selection.$anchor.sameParent(state.selection.$head)) {
+    attributesToCopy = state.selection.$anchor.parent.attrs;
+  }
+  if (isActive2) {
+    return commands.setNode(toggleType, attributesToCopy);
+  }
+  return commands.setNode(type, { ...attributesToCopy, ...attributes });
+};
+var toggleWrap = (typeOrName, attributes = {}) => ({ state, commands }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  const isActive2 = isNodeActive(state, type, attributes);
+  if (isActive2) {
+    return commands.lift(type);
+  }
+  return commands.wrapIn(type, attributes);
+};
+var undoInputRule = () => ({ state, dispatch }) => {
+  const plugins = state.plugins;
+  for (let i = 0; i < plugins.length; i += 1) {
+    const plugin = plugins[i];
+    let undoable;
+    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+      if (dispatch) {
+        const tr = state.tr;
+        const toUndo = undoable.transform;
+        for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
+          tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+        }
+        if (undoable.text) {
+          const marks = tr.doc.resolve(undoable.from).marks();
+          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
+        } else {
+          tr.delete(undoable.from, undoable.to);
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+};
+var unsetAllMarks = () => ({ tr, dispatch }) => {
+  const { selection } = tr;
+  const { empty, ranges } = selection;
+  if (empty) {
+    return true;
+  }
+  if (dispatch) {
+    ranges.forEach((range) => {
+      tr.removeMark(range.$from.pos, range.$to.pos);
+    });
+  }
+  return true;
+};
+var unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
+  var _a;
+  const { extendEmptyMarkRange = false } = options;
+  const { selection } = tr;
+  const type = getMarkType(typeOrName, state.schema);
+  const { $from, empty, ranges } = selection;
+  if (!dispatch) {
+    return true;
+  }
+  if (empty && extendEmptyMarkRange) {
+    let { from, to } = selection;
+    const attrs = (_a = $from.marks().find((mark) => mark.type === type)) == null ? void 0 : _a.attrs;
+    const range = getMarkRange($from, type, attrs);
+    if (range) {
+      from = range.from;
+      to = range.to;
+    }
+    tr.removeMark(from, to, type);
+  } else {
+    ranges.forEach((range) => {
+      tr.removeMark(range.$from.pos, range.$to.pos, type);
+    });
+  }
+  tr.removeStoredMark(type);
+  return true;
+};
+var unsetTextDirection = (position) => ({ tr, state, dispatch }) => {
+  const { selection } = state;
+  let from;
+  let to;
+  if (typeof position === "number") {
+    from = position;
+    to = position;
+  } else if (position && "from" in position && "to" in position) {
+    from = position.from;
+    to = position.to;
+  } else {
+    from = selection.from;
+    to = selection.to;
+  }
+  if (dispatch) {
+    tr.doc.nodesBetween(from, to, (node, pos) => {
+      if (node.isText) {
+        return;
+      }
+      const newAttrs = { ...node.attrs };
+      delete newAttrs.dir;
+      tr.setNodeMarkup(pos, void 0, newAttrs);
+    });
+  }
+  return true;
+};
+var updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+  let nodeType = null;
+  let markType = null;
+  const schemaType = getSchemaTypeNameByName(
+    typeof typeOrName === "string" ? typeOrName : typeOrName.name,
+    state.schema
+  );
+  if (!schemaType) {
+    return false;
+  }
+  if (schemaType === "node") {
+    nodeType = getNodeType(typeOrName, state.schema);
+  }
+  if (schemaType === "mark") {
+    markType = getMarkType(typeOrName, state.schema);
+  }
+  let canUpdate = false;
+  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) {
+          canUpdate = true;
+          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) {
+          canUpdate = true;
+          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) {
+            canUpdate = true;
+            if (dispatch) {
+              tr.setNodeMarkup(pos, void 0, {
+                ...node.attrs,
+                ...attributes
+              });
+            }
+          }
+          if (markType && node.marks.length) {
+            node.marks.forEach((mark) => {
+              if (markType === mark.type) {
+                canUpdate = true;
+                if (dispatch) {
+                  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 && dispatch) {
+        tr.setNodeMarkup(lastPos, void 0, {
+          ...lastNode.attrs,
+          ...attributes
+        });
+      }
+      if (markType && lastNode.marks.length) {
+        lastNode.marks.forEach((mark) => {
+          if (markType === mark.type && dispatch) {
+            tr.addMark(
+              trimmedFrom,
+              trimmedTo,
+              markType.create({
+                ...mark.attrs,
+                ...attributes
+              })
+            );
+          }
+        });
+      }
+    }
+  });
+  return canUpdate;
+};
+var wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return originalWrapIn(type, attributes)(state, dispatch);
+};
+var wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
+  const type = getNodeType(typeOrName, state.schema);
+  return originalWrapInList(type, attributes)(state, dispatch);
+};
+var inputRuleMatcherHandler = (text, find) => {
+  if (isRegExp(find)) {
+    return find.exec(text);
+  }
+  const inputRuleMatch = find(text);
+  if (!inputRuleMatch) {
+    return null;
+  }
+  const result = [inputRuleMatch.text];
+  result.index = inputRuleMatch.index;
+  result.input = text;
+  result.data = inputRuleMatch.data;
+  if (inputRuleMatch.replaceWith) {
+    if (!inputRuleMatch.text.includes(inputRuleMatch.replaceWith)) {
+      console.warn('[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".');
+    }
+    result.push(inputRuleMatch.replaceWith);
+  }
+  return result;
+};
+function run(config) {
+  var _a;
+  const { editor, from, to, text, rules, plugin } = config;
+  const { view } = editor;
+  if (view.composing) {
+    return false;
+  }
+  const $from = view.state.doc.resolve(from);
+  if (
+    // check for code node
+    $from.parent.type.spec.code || // check for code mark
+    !!((_a = $from.nodeBefore || $from.nodeAfter) == null ? void 0 : _a.marks.find((mark) => mark.type.spec.code))
+  ) {
+    return false;
+  }
+  let matched = false;
+  const textBefore = getTextContentFromNodes($from) + text;
+  rules.forEach((rule) => {
+    if (matched) {
+      return;
+    }
+    const match = inputRuleMatcherHandler(textBefore, rule.find);
+    if (!match) {
+      return;
+    }
+    const tr = view.state.tr;
+    const state = createChainableState({
+      state: view.state,
+      transaction: tr
+    });
+    const range = {
+      from: from - (match[0].length - text.length),
+      to
+    };
+    const { commands, chain, can } = new CommandManager({
+      editor,
+      state
+    });
+    const handler = rule.handler({
+      state,
+      range,
+      match,
+      commands,
+      chain,
+      can
+    });
+    if (handler === null || !tr.steps.length) {
+      return;
+    }
+    if (rule.undoable) {
+      tr.setMeta(plugin, {
+        transform: tr,
+        from,
+        to,
+        text
+      });
+    }
+    view.dispatch(tr);
+    matched = true;
+  });
+  return matched;
+}
+function inputRulesPlugin(props) {
+  const { editor, rules } = props;
+  const plugin = new Plugin({
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr, prev, state) {
+        const stored = tr.getMeta(plugin);
+        if (stored) {
+          return stored;
+        }
+        const simulatedInputMeta = tr.getMeta("applyInputRules");
+        const isSimulatedInput = !!simulatedInputMeta;
+        if (isSimulatedInput) {
+          setTimeout(() => {
+            let { text } = simulatedInputMeta;
+            if (typeof text === "string") {
+              text = text;
+            } else {
+              text = getHTMLFromFragment(Fragment4.from(text), state.schema);
+            }
+            const { from } = simulatedInputMeta;
+            const to = from + text.length;
+            run({
+              editor,
+              from,
+              to,
+              text,
+              rules,
+              plugin
+            });
+          });
+        }
+        return tr.selectionSet || tr.docChanged ? null : prev;
+      }
+    },
+    props: {
+      handleTextInput(view, from, to, text) {
+        return run({
+          editor,
+          from,
+          to,
+          text,
+          rules,
+          plugin
+        });
+      },
+      handleDOMEvents: {
+        compositionend: (view) => {
+          setTimeout(() => {
+            const { $cursor } = view.state.selection;
+            if ($cursor) {
+              run({
+                editor,
+                from: $cursor.pos,
+                to: $cursor.pos,
+                text: "",
+                rules,
+                plugin
+              });
+            }
+          });
+          return false;
+        }
+      },
+      // add support for input rules to trigger on enter
+      // this is useful for example for code blocks
+      handleKeyDown(view, event) {
+        if (event.key !== "Enter") {
+          return false;
+        }
+        const { $cursor } = view.state.selection;
+        if ($cursor) {
+          return run({
+            editor,
+            from: $cursor.pos,
+            to: $cursor.pos,
+            text: "\n",
+            rules,
+            plugin
+          });
+        }
+        return false;
+      }
+    },
+    // @ts-ignore
+    isInputRules: true
+  });
+  return plugin;
+}
+function getType(value) {
+  return Object.prototype.toString.call(value).slice(8, -1);
+}
+function isPlainObject(value) {
+  if (getType(value) !== "Object") {
+    return false;
+  }
+  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
+}
+function mergeDeep(target, source) {
+  const output = { ...target };
+  if (isPlainObject(target) && isPlainObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isPlainObject(source[key]) && isPlainObject(target[key])) {
+        output[key] = mergeDeep(target[key], source[key]);
+      } else {
+        output[key] = source[key];
+      }
+    });
+  }
+  return output;
+}
+var Extendable = class {
+  constructor(config = {}) {
+    this.type = "extendable";
+    this.parent = null;
+    this.child = null;
+    this.name = "";
+    this.config = {
+      name: this.name
+    };
+    this.config = {
+      ...this.config,
+      ...config
+    };
+    this.name = this.config.name;
+  }
+  get options() {
+    return {
+      ...callOrReturn(
+        getExtensionField(this, "addOptions", {
+          name: this.name
+        })
+      ) || {}
+    };
+  }
+  get storage() {
+    return {
+      ...callOrReturn(
+        getExtensionField(this, "addStorage", {
+          name: this.name,
+          options: this.options
+        })
+      ) || {}
+    };
+  }
+  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 this.constructor({ ...this.config, ...extendedConfig });
+    extension.parent = this;
+    this.child = extension;
+    extension.name = "name" in extendedConfig ? extendedConfig.name : extension.parent.name;
+    return extension;
+  }
+};
+var Mark = class _Mark extends Extendable {
+  constructor() {
+    super(...arguments);
+    this.type = "mark";
+  }
+  /**
+   * Create a new Mark instance
+   * @param config - Mark configuration object or a function that returns a configuration object
+   */
+  static create(config = {}) {
+    const resolvedConfig = typeof config === "function" ? config() : config;
+    return new _Mark(resolvedConfig);
+  }
+  static handleExit({ editor, mark }) {
+    const { tr } = editor.state;
+    const currentPos = editor.state.selection.$from;
+    const isAtEnd = currentPos.pos === currentPos.end();
+    if (isAtEnd) {
+      const currentMarks = currentPos.marks();
+      const isInMark = !!currentMarks.find((m) => (m == null ? void 0 : m.type.name) === mark.name);
+      if (!isInMark) {
+        return false;
+      }
+      const removeMark = currentMarks.find((m) => (m == null ? void 0 : m.type.name) === mark.name);
+      if (removeMark) {
+        tr.removeStoredMark(removeMark);
+      }
+      tr.insertText(" ", currentPos.pos);
+      editor.view.dispatch(tr);
+      return true;
+    }
+    return false;
+  }
+  configure(options) {
+    return super.configure(options);
+  }
+  extend(extendedConfig) {
+    const resolvedConfig = typeof extendedConfig === "function" ? extendedConfig() : extendedConfig;
+    return super.extend(resolvedConfig);
+  }
+};
+function isNumber(value) {
+  return typeof value === "number";
+}
+var pasteRuleMatcherHandler = (text, find, event) => {
+  if (isRegExp(find)) {
+    return [...text.matchAll(find)];
+  }
+  const matches = find(text, event);
+  if (!matches) {
+    return [];
+  }
+  return matches.map((pasteRuleMatch) => {
+    const result = [pasteRuleMatch.text];
+    result.index = pasteRuleMatch.index;
+    result.input = text;
+    result.data = pasteRuleMatch.data;
+    if (pasteRuleMatch.replaceWith) {
+      if (!pasteRuleMatch.text.includes(pasteRuleMatch.replaceWith)) {
+        console.warn('[tiptap warn]: "pasteRuleMatch.replaceWith" must be part of "pasteRuleMatch.text".');
+      }
+      result.push(pasteRuleMatch.replaceWith);
+    }
+    return result;
+  });
+};
+function run2(config) {
+  const { editor, state, from, to, rule, pasteEvent, dropEvent } = config;
+  const { commands, chain, can } = new CommandManager({
+    editor,
+    state
+  });
+  const handlers = [];
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    var _a, _b, _c, _d, _e;
+    if (((_b = (_a = node.type) == null ? void 0 : _a.spec) == null ? void 0 : _b.code) || !(node.isText || node.isTextblock || node.isInline)) {
+      return;
+    }
+    const contentSize = (_e = (_d = (_c = node.content) == null ? void 0 : _c.size) != null ? _d : node.nodeSize) != null ? _e : 0;
+    const resolvedFrom = Math.max(from, pos);
+    const resolvedTo = Math.min(to, pos + contentSize);
+    if (resolvedFrom >= resolvedTo) {
+      return;
+    }
+    const textToMatch = node.isText ? node.text || "" : node.textBetween(resolvedFrom - pos, resolvedTo - pos, void 0, "\uFFFC");
+    const matches = pasteRuleMatcherHandler(textToMatch, rule.find, pasteEvent);
+    matches.forEach((match) => {
+      if (match.index === void 0) {
+        return;
+      }
+      const start = resolvedFrom + match.index + 1;
+      const end = start + match[0].length;
+      const range = {
+        from: state.tr.mapping.map(start),
+        to: state.tr.mapping.map(end)
+      };
+      const handler = rule.handler({
+        state,
+        range,
+        match,
+        commands,
+        chain,
+        can,
+        pasteEvent,
+        dropEvent
+      });
+      handlers.push(handler);
+    });
+  });
+  const success = handlers.every((handler) => handler !== null);
+  return success;
+}
+var tiptapDragFromOtherEditor = null;
+var createClipboardPasteEvent = (text) => {
+  var _a;
+  const event = new ClipboardEvent("paste", {
+    clipboardData: new DataTransfer()
+  });
+  (_a = event.clipboardData) == null ? void 0 : _a.setData("text/html", text);
+  return event;
+};
+function pasteRulesPlugin(props) {
+  const { editor, rules } = props;
+  let dragSourceElement = null;
+  let isPastedFromProseMirror = false;
+  let isDroppedFromProseMirror = false;
+  let pasteEvent = typeof ClipboardEvent !== "undefined" ? new ClipboardEvent("paste") : null;
+  let dropEvent;
+  try {
+    dropEvent = typeof DragEvent !== "undefined" ? new DragEvent("drop") : null;
+  } catch {
+    dropEvent = null;
+  }
+  const processEvent = ({
+    state,
+    from,
+    to,
+    rule,
+    pasteEvt
+  }) => {
+    const tr = state.tr;
+    const chainableState = createChainableState({
+      state,
+      transaction: tr
+    });
+    const handler = run2({
+      editor,
+      state: chainableState,
+      from: Math.max(from - 1, 0),
+      to: to.b - 1,
+      rule,
+      pasteEvent: pasteEvt,
+      dropEvent
+    });
+    if (!handler || !tr.steps.length) {
+      return;
+    }
+    try {
+      dropEvent = typeof DragEvent !== "undefined" ? new DragEvent("drop") : null;
+    } catch {
+      dropEvent = null;
+    }
+    pasteEvent = typeof ClipboardEvent !== "undefined" ? new ClipboardEvent("paste") : null;
+    return tr;
+  };
+  const plugins = rules.map((rule) => {
+    return new Plugin2({
+      // we register a global drag handler to track the current drag source element
+      view(view) {
+        const handleDragstart = (event) => {
+          var _a;
+          dragSourceElement = ((_a = view.dom.parentElement) == null ? void 0 : _a.contains(event.target)) ? view.dom.parentElement : null;
+          if (dragSourceElement) {
+            tiptapDragFromOtherEditor = editor;
+          }
+        };
+        const handleDragend = () => {
+          if (tiptapDragFromOtherEditor) {
+            tiptapDragFromOtherEditor = null;
+          }
+        };
+        window.addEventListener("dragstart", handleDragstart);
+        window.addEventListener("dragend", handleDragend);
+        return {
+          destroy() {
+            window.removeEventListener("dragstart", handleDragstart);
+            window.removeEventListener("dragend", handleDragend);
+          }
+        };
+      },
+      props: {
+        handleDOMEvents: {
+          drop: (view, event) => {
+            isDroppedFromProseMirror = dragSourceElement === view.dom.parentElement;
+            dropEvent = event;
+            if (!isDroppedFromProseMirror) {
+              const dragFromOtherEditor = tiptapDragFromOtherEditor;
+              if (dragFromOtherEditor == null ? void 0 : dragFromOtherEditor.isEditable) {
+                setTimeout(() => {
+                  const selection = dragFromOtherEditor.state.selection;
+                  if (selection) {
+                    dragFromOtherEditor.commands.deleteRange({ from: selection.from, to: selection.to });
+                  }
+                }, 10);
+              }
+            }
+            return false;
+          },
+          paste: (_view, event) => {
+            var _a;
+            const html = (_a = event.clipboardData) == null ? void 0 : _a.getData("text/html");
+            pasteEvent = event;
+            isPastedFromProseMirror = !!(html == null ? void 0 : html.includes("data-pm-slice"));
+            return false;
+          }
+        }
+      },
+      appendTransaction: (transactions, oldState, state) => {
+        const transaction = transactions[0];
+        const isPaste = transaction.getMeta("uiEvent") === "paste" && !isPastedFromProseMirror;
+        const isDrop = transaction.getMeta("uiEvent") === "drop" && !isDroppedFromProseMirror;
+        const simulatedPasteMeta = transaction.getMeta("applyPasteRules");
+        const isSimulatedPaste = !!simulatedPasteMeta;
+        if (!isPaste && !isDrop && !isSimulatedPaste) {
+          return;
+        }
+        if (isSimulatedPaste) {
+          let { text } = simulatedPasteMeta;
+          if (typeof text === "string") {
+            text = text;
+          } else {
+            text = getHTMLFromFragment(Fragment5.from(text), state.schema);
+          }
+          const { from: from2 } = simulatedPasteMeta;
+          const to2 = from2 + text.length;
+          const pasteEvt = createClipboardPasteEvent(text);
+          return processEvent({
+            rule,
+            state,
+            from: from2,
+            to: { b: to2 },
+            pasteEvt
+          });
+        }
+        const from = oldState.doc.content.findDiffStart(state.doc.content);
+        const to = oldState.doc.content.findDiffEnd(state.doc.content);
+        if (!isNumber(from) || !to || from === to.b) {
+          return;
+        }
+        return processEvent({
+          rule,
+          state,
+          from,
+          to,
+          pasteEvt: pasteEvent
+        });
+      }
+    });
+  });
+  return plugins;
+}
+var ExtensionManager = class {
+  constructor(extensions, editor) {
+    this.splittableMarks = [];
+    this.editor = editor;
+    this.baseExtensions = extensions;
+    this.extensions = resolveExtensions(extensions);
+    this.schema = getSchemaByResolvedExtensions(this.extensions, editor);
+    this.setupExtensions();
+  }
+  /**
+   * Get all commands from the extensions.
+   * @returns An object with all commands where the key is the command name and the value is the command function
+   */
+  get commands() {
+    return this.extensions.reduce((commands, extension) => {
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: this.editor.extensionStorage[extension.name],
+        editor: this.editor,
+        type: getSchemaTypeByName(extension.name, this.schema)
+      };
+      const addCommands = getExtensionField(extension, "addCommands", context);
+      if (!addCommands) {
+        return commands;
+      }
+      return {
+        ...commands,
+        ...addCommands()
+      };
+    }, {});
+  }
+  /**
+   * Get all registered Prosemirror plugins from the extensions.
+   * @returns An array of Prosemirror plugins
+   */
+  get plugins() {
+    const { editor } = this;
+    const extensions = sortExtensions([...this.extensions].reverse());
+    const allPlugins = extensions.flatMap((extension) => {
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: this.editor.extensionStorage[extension.name],
+        editor,
+        type: getSchemaTypeByName(extension.name, this.schema)
+      };
+      const plugins = [];
+      const addKeyboardShortcuts = getExtensionField(
+        extension,
+        "addKeyboardShortcuts",
+        context
+      );
+      let defaultBindings = {};
+      if (extension.type === "mark" && getExtensionField(extension, "exitable", context)) {
+        defaultBindings.ArrowRight = () => Mark.handleExit({ editor, mark: extension });
+      }
+      if (addKeyboardShortcuts) {
+        const bindings = Object.fromEntries(
+          Object.entries(addKeyboardShortcuts()).map(([shortcut, method]) => {
+            return [shortcut, () => method({ editor })];
+          })
+        );
+        defaultBindings = { ...defaultBindings, ...bindings };
+      }
+      const keyMapPlugin = keymap(defaultBindings);
+      plugins.push(keyMapPlugin);
+      const addInputRules = getExtensionField(extension, "addInputRules", context);
+      if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
+        const rules = addInputRules();
+        if (rules && rules.length) {
+          const inputResult = inputRulesPlugin({
+            editor,
+            rules
+          });
+          const inputPlugins = Array.isArray(inputResult) ? inputResult : [inputResult];
+          plugins.push(...inputPlugins);
+        }
+      }
+      const addPasteRules = getExtensionField(extension, "addPasteRules", context);
+      if (isExtensionRulesEnabled(extension, editor.options.enablePasteRules) && addPasteRules) {
+        const rules = addPasteRules();
+        if (rules && rules.length) {
+          const pasteRules = pasteRulesPlugin({ editor, rules });
+          plugins.push(...pasteRules);
+        }
+      }
+      const addProseMirrorPlugins = getExtensionField(
+        extension,
+        "addProseMirrorPlugins",
+        context
+      );
+      if (addProseMirrorPlugins) {
+        const proseMirrorPlugins = addProseMirrorPlugins();
+        plugins.push(...proseMirrorPlugins);
+      }
+      return plugins;
+    });
+    return allPlugins;
+  }
+  /**
+   * Get all attributes from the extensions.
+   * @returns An array of attributes
+   */
+  get attributes() {
+    return getAttributesFromExtensions(this.extensions);
+  }
+  /**
+   * Get all node views from the extensions.
+   * @returns An object with all node views where the key is the node name and the value is the node view function
+   */
+  get nodeViews() {
+    const { editor } = this;
+    const { nodeExtensions } = splitExtensions(this.extensions);
+    return Object.fromEntries(
+      nodeExtensions.filter((extension) => !!getExtensionField(extension, "addNodeView")).map((extension) => {
+        const extensionAttributes = this.attributes.filter((attribute) => attribute.type === extension.name);
+        const context = {
+          name: extension.name,
+          options: extension.options,
+          storage: this.editor.extensionStorage[extension.name],
+          editor,
+          type: getNodeType(extension.name, this.schema)
+        };
+        const addNodeView = getExtensionField(extension, "addNodeView", context);
+        if (!addNodeView) {
+          return [];
+        }
+        const nodeViewResult = addNodeView();
+        if (!nodeViewResult) {
+          return [];
+        }
+        const nodeview = (node, view, getPos, decorations, innerDecorations) => {
+          const HTMLAttributes = getRenderedAttributes(node, extensionAttributes);
+          return nodeViewResult({
+            // pass-through
+            node,
+            view,
+            getPos,
+            decorations,
+            innerDecorations,
+            // tiptap-specific
+            editor,
+            extension,
+            HTMLAttributes
+          });
+        };
+        return [extension.name, nodeview];
+      })
+    );
+  }
+  /**
+   * Get the composed dispatchTransaction function from all extensions.
+   * @param baseDispatch The base dispatch function (e.g. from the editor or user props)
+   * @returns A composed dispatch function
+   */
+  dispatchTransaction(baseDispatch) {
+    const { editor } = this;
+    const extensions = sortExtensions([...this.extensions].reverse());
+    return extensions.reduceRight((next, extension) => {
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: this.editor.extensionStorage[extension.name],
+        editor,
+        type: getSchemaTypeByName(extension.name, this.schema)
+      };
+      const dispatchTransaction = getExtensionField(
+        extension,
+        "dispatchTransaction",
+        context
+      );
+      if (!dispatchTransaction) {
+        return next;
+      }
+      return (transaction) => {
+        dispatchTransaction.call(context, { transaction, next });
+      };
+    }, baseDispatch);
+  }
+  get markViews() {
+    const { editor } = this;
+    const { markExtensions } = splitExtensions(this.extensions);
+    return Object.fromEntries(
+      markExtensions.filter((extension) => !!getExtensionField(extension, "addMarkView")).map((extension) => {
+        const extensionAttributes = this.attributes.filter((attribute) => attribute.type === extension.name);
+        const context = {
+          name: extension.name,
+          options: extension.options,
+          storage: this.editor.extensionStorage[extension.name],
+          editor,
+          type: getMarkType(extension.name, this.schema)
+        };
+        const addMarkView = getExtensionField(extension, "addMarkView", context);
+        if (!addMarkView) {
+          return [];
+        }
+        const markView = (mark, view, inline) => {
+          const HTMLAttributes = getRenderedAttributes(mark, extensionAttributes);
+          return addMarkView()({
+            // pass-through
+            mark,
+            view,
+            inline,
+            // tiptap-specific
+            editor,
+            extension,
+            HTMLAttributes,
+            updateAttributes: (attrs) => {
+              updateMarkViewAttributes(mark, editor, attrs);
+            }
+          });
+        };
+        return [extension.name, markView];
+      })
+    );
+  }
+  /**
+   * Go through all extensions, create extension storages & setup marks
+   * & bind editor event listener.
+   */
+  setupExtensions() {
+    const extensions = this.extensions;
+    this.editor.extensionStorage = Object.fromEntries(
+      extensions.map((extension) => [extension.name, extension.storage])
+    );
+    extensions.forEach((extension) => {
+      var _a;
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: this.editor.extensionStorage[extension.name],
+        editor: this.editor,
+        type: getSchemaTypeByName(extension.name, this.schema)
+      };
+      if (extension.type === "mark") {
+        const keepOnSplit = (_a = callOrReturn(getExtensionField(extension, "keepOnSplit", context))) != null ? _a : true;
+        if (keepOnSplit) {
+          this.splittableMarks.push(extension.name);
+        }
+      }
+      const onBeforeCreate = getExtensionField(extension, "onBeforeCreate", context);
+      const onCreate = getExtensionField(extension, "onCreate", context);
+      const onUpdate = getExtensionField(extension, "onUpdate", context);
+      const onSelectionUpdate = getExtensionField(
+        extension,
+        "onSelectionUpdate",
+        context
+      );
+      const onTransaction = getExtensionField(extension, "onTransaction", context);
+      const onFocus = getExtensionField(extension, "onFocus", context);
+      const onBlur = getExtensionField(extension, "onBlur", context);
+      const onDestroy = getExtensionField(extension, "onDestroy", context);
+      if (onBeforeCreate) {
+        this.editor.on("beforeCreate", onBeforeCreate);
+      }
+      if (onCreate) {
+        this.editor.on("create", onCreate);
+      }
+      if (onUpdate) {
+        this.editor.on("update", onUpdate);
+      }
+      if (onSelectionUpdate) {
+        this.editor.on("selectionUpdate", onSelectionUpdate);
+      }
+      if (onTransaction) {
+        this.editor.on("transaction", onTransaction);
+      }
+      if (onFocus) {
+        this.editor.on("focus", onFocus);
+      }
+      if (onBlur) {
+        this.editor.on("blur", onBlur);
+      }
+      if (onDestroy) {
+        this.editor.on("destroy", onDestroy);
+      }
+    });
+  }
+};
+ExtensionManager.resolve = resolveExtensions;
+ExtensionManager.sort = sortExtensions;
+ExtensionManager.flatten = flattenExtensions;
+var extensions_exports = {};
+__export(extensions_exports, {
+  ClipboardTextSerializer: () => ClipboardTextSerializer,
+  Commands: () => Commands,
+  Delete: () => Delete,
+  Drop: () => Drop,
+  Editable: () => Editable,
+  FocusEvents: () => FocusEvents,
+  Keymap: () => Keymap,
+  Paste: () => Paste,
+  Tabindex: () => Tabindex,
+  TextDirection: () => TextDirection,
+  focusEventsPluginKey: () => focusEventsPluginKey
+});
+var Extension = class _Extension extends Extendable {
+  constructor() {
+    super(...arguments);
+    this.type = "extension";
+  }
+  /**
+   * Create a new Extension instance
+   * @param config - Extension configuration object or a function that returns a configuration object
+   */
+  static create(config = {}) {
+    const resolvedConfig = typeof config === "function" ? config() : config;
+    return new _Extension(resolvedConfig);
+  }
+  configure(options) {
+    return super.configure(options);
+  }
+  extend(extendedConfig) {
+    const resolvedConfig = typeof extendedConfig === "function" ? extendedConfig() : extendedConfig;
+    return super.extend(resolvedConfig);
+  }
+};
+var ClipboardTextSerializer = Extension.create({
+  name: "clipboardTextSerializer",
+  addOptions() {
+    return {
+      blockSeparator: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin3({
+        key: new PluginKey("clipboardTextSerializer"),
+        props: {
+          clipboardTextSerializer: () => {
+            const { editor } = this;
+            const { state, schema } = editor;
+            const { doc, selection } = state;
+            const { ranges } = selection;
+            const from = Math.min(...ranges.map((range2) => range2.$from.pos));
+            const to = Math.max(...ranges.map((range2) => range2.$to.pos));
+            const textSerializers = getTextSerializersFromSchema(schema);
+            const range = { from, to };
+            return getTextBetween(doc, range, {
+              ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
+              textSerializers
+            });
+          }
+        }
+      })
+    ];
+  }
+});
+var Commands = Extension.create({
+  name: "commands",
+  addCommands() {
+    return {
+      ...commands_exports
+    };
+  }
+});
+var Delete = Extension.create({
+  name: "delete",
+  onUpdate({ transaction, appendedTransactions }) {
+    var _a, _b, _c;
+    const callback = () => {
+      var _a2, _b2, _c2, _d;
+      if ((_d = (_c2 = (_b2 = (_a2 = this.editor.options.coreExtensionOptions) == null ? void 0 : _a2.delete) == null ? void 0 : _b2.filterTransaction) == null ? void 0 : _c2.call(_b2, transaction)) != null ? _d : transaction.getMeta("y-sync$")) {
+        return;
+      }
+      const nextTransaction = combineTransactionSteps(transaction.before, [transaction, ...appendedTransactions]);
+      const changes = getChangedRanges(nextTransaction);
+      changes.forEach((change) => {
+        if (nextTransaction.mapping.mapResult(change.oldRange.from).deletedAfter && nextTransaction.mapping.mapResult(change.oldRange.to).deletedBefore) {
+          nextTransaction.before.nodesBetween(change.oldRange.from, change.oldRange.to, (node, from) => {
+            const to = from + node.nodeSize - 2;
+            const isFullyWithinRange = change.oldRange.from <= from && to <= change.oldRange.to;
+            this.editor.emit("delete", {
+              type: "node",
+              node,
+              from,
+              to,
+              newFrom: nextTransaction.mapping.map(from),
+              newTo: nextTransaction.mapping.map(to),
+              deletedRange: change.oldRange,
+              newRange: change.newRange,
+              partial: !isFullyWithinRange,
+              editor: this.editor,
+              transaction,
+              combinedTransform: nextTransaction
+            });
+          });
+        }
+      });
+      const mapping = nextTransaction.mapping;
+      nextTransaction.steps.forEach((step, index) => {
+        var _a3, _b3;
+        if (step instanceof RemoveMarkStep) {
+          const newStart = mapping.slice(index).map(step.from, -1);
+          const newEnd = mapping.slice(index).map(step.to);
+          const oldStart = mapping.invert().map(newStart, -1);
+          const oldEnd = mapping.invert().map(newEnd);
+          const foundBeforeMark = (_a3 = nextTransaction.doc.nodeAt(newStart - 1)) == null ? void 0 : _a3.marks.some((mark) => mark.eq(step.mark));
+          const foundAfterMark = (_b3 = nextTransaction.doc.nodeAt(newEnd)) == null ? void 0 : _b3.marks.some((mark) => mark.eq(step.mark));
+          this.editor.emit("delete", {
+            type: "mark",
+            mark: step.mark,
+            from: step.from,
+            to: step.to,
+            deletedRange: {
+              from: oldStart,
+              to: oldEnd
+            },
+            newRange: {
+              from: newStart,
+              to: newEnd
+            },
+            partial: Boolean(foundAfterMark || foundBeforeMark),
+            editor: this.editor,
+            transaction,
+            combinedTransform: nextTransaction
+          });
+        }
+      });
+    };
+    if ((_c = (_b = (_a = this.editor.options.coreExtensionOptions) == null ? void 0 : _a.delete) == null ? void 0 : _b.async) != null ? _c : true) {
+      setTimeout(callback, 0);
+    } else {
+      callback();
+    }
+  }
+});
+var Drop = Extension.create({
+  name: "drop",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin4({
+        key: new PluginKey2("tiptapDrop"),
+        props: {
+          handleDrop: (_, e, slice, moved) => {
+            this.editor.emit("drop", {
+              editor: this.editor,
+              event: e,
+              slice,
+              moved
+            });
+          }
+        }
+      })
+    ];
+  }
+});
+var Editable = Extension.create({
+  name: "editable",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin5({
+        key: new PluginKey3("editable"),
+        props: {
+          editable: () => this.editor.options.editable
+        }
+      })
+    ];
+  }
+});
+var focusEventsPluginKey = new PluginKey4("focusEvents");
+var FocusEvents = Extension.create({
+  name: "focusEvents",
+  addProseMirrorPlugins() {
+    const { editor } = this;
+    return [
+      new Plugin6({
+        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;
+            }
+          }
+        }
+      })
+    ];
+  }
+});
+var Keymap = Extension.create({
+  name: "keymap",
+  addKeyboardShortcuts() {
+    const handleBackspace = () => this.editor.commands.first(({ commands }) => [
+      () => commands.undoInputRule(),
+      // maybe convert first text block node to default node
+      () => commands.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 : Selection3.atStart(doc).from === pos;
+        if (!empty || !parent.type.isTextblock || parent.textContent.length || !isAtStart || isAtStart && $anchor.parent.type.name === "paragraph") {
+          return false;
+        }
+        return commands.clearNodes();
+      }),
+      () => commands.deleteSelection(),
+      () => commands.joinBackward(),
+      () => commands.selectNodeBackward()
+    ]);
+    const handleDelete = () => this.editor.commands.first(({ commands }) => [
+      () => commands.deleteSelection(),
+      () => commands.deleteCurrentNode(),
+      () => commands.joinForward(),
+      () => commands.selectNodeForward()
+    ]);
+    const handleEnter = () => this.editor.commands.first(({ commands }) => [
+      () => commands.newlineInCode(),
+      () => commands.createParagraphNear(),
+      () => commands.liftEmptyBlock(),
+      () => commands.splitBlock()
+    ]);
+    const baseKeymap = {
+      Enter: handleEnter,
+      "Mod-Enter": () => this.editor.commands.exitCode(),
+      Backspace: handleBackspace,
+      "Mod-Backspace": handleBackspace,
+      "Shift-Backspace": handleBackspace,
+      Delete: handleDelete,
+      "Mod-Delete": handleDelete,
+      "Mod-a": () => this.editor.commands.selectAll()
+    };
+    const pcKeymap = {
+      ...baseKeymap
+    };
+    const macKeymap = {
+      ...baseKeymap,
+      "Ctrl-h": handleBackspace,
+      "Alt-Backspace": handleBackspace,
+      "Ctrl-d": handleDelete,
+      "Ctrl-Alt-Backspace": handleDelete,
+      "Alt-Delete": handleDelete,
+      "Alt-d": handleDelete,
+      "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
+      "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
+    };
+    if (isiOS() || isMacOS()) {
+      return macKeymap;
+    }
+    return pcKeymap;
+  },
+  addProseMirrorPlugins() {
+    return [
+      // 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 Plugin7({
+        key: new PluginKey5("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 = Selection3.atStart(oldState.doc).from;
+          const allEnd = Selection3.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 } = new CommandManager({
+            editor: this.editor,
+            state
+          });
+          commands.clearNodes();
+          if (!tr.steps.length) {
+            return;
+          }
+          return tr;
+        }
+      })
+    ];
+  }
+});
+var Paste = Extension.create({
+  name: "paste",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin8({
+        key: new PluginKey6("tiptapPaste"),
+        props: {
+          handlePaste: (_view, e, slice) => {
+            this.editor.emit("paste", {
+              editor: this.editor,
+              event: e,
+              slice
+            });
+          }
+        }
+      })
+    ];
+  }
+});
+var Tabindex = Extension.create({
+  name: "tabindex",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin9({
+        key: new PluginKey7("tabindex"),
+        props: {
+          attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
+        }
+      })
+    ];
+  }
+});
+var TextDirection = Extension.create({
+  name: "textDirection",
+  addOptions() {
+    return {
+      direction: void 0
+    };
+  },
+  addGlobalAttributes() {
+    if (!this.options.direction) {
+      return [];
+    }
+    const { nodeExtensions } = splitExtensions(this.extensions);
+    return [
+      {
+        types: nodeExtensions.filter((extension) => extension.name !== "text").map((extension) => extension.name),
+        attributes: {
+          dir: {
+            default: this.options.direction,
+            parseHTML: (element) => {
+              const dir = element.getAttribute("dir");
+              if (dir && (dir === "ltr" || dir === "rtl" || dir === "auto")) {
+                return dir;
+              }
+              return this.options.direction;
+            },
+            renderHTML: (attributes) => {
+              if (!attributes.dir) {
+                return {};
+              }
+              return {
+                dir: attributes.dir
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin10({
+        key: new PluginKey8("textDirection"),
+        props: {
+          attributes: () => {
+            const direction = this.options.direction;
+            if (!direction) {
+              return {};
+            }
+            return {
+              dir: direction
+            };
+          }
+        }
+      })
+    ];
+  }
+});
+var markdown_exports = {};
+__export(markdown_exports, {
+  createAtomBlockMarkdownSpec: () => createAtomBlockMarkdownSpec,
+  createBlockMarkdownSpec: () => createBlockMarkdownSpec,
+  createInlineMarkdownSpec: () => createInlineMarkdownSpec,
+  parseAttributes: () => parseAttributes,
+  parseIndentedBlocks: () => parseIndentedBlocks,
+  renderNestedMarkdownContent: () => renderNestedMarkdownContent,
+  serializeAttributes: () => serializeAttributes
+});
+function parseAttributes(attrString) {
+  if (!(attrString == null ? void 0 : attrString.trim())) {
+    return {};
+  }
+  const attributes = {};
+  const quotedStrings = [];
+  const tempString = attrString.replace(/["']([^"']*)["']/g, (match) => {
+    quotedStrings.push(match);
+    return `__QUOTED_${quotedStrings.length - 1}__`;
+  });
+  const classMatches = tempString.match(/(?:^|\s)\.([a-zA-Z][\w-]*)/g);
+  if (classMatches) {
+    const classes = classMatches.map((match) => match.trim().slice(1));
+    attributes.class = classes.join(" ");
+  }
+  const idMatch = tempString.match(/(?:^|\s)#([a-zA-Z][\w-]*)/);
+  if (idMatch) {
+    attributes.id = idMatch[1];
+  }
+  const kvRegex = /([a-zA-Z][\w-]*)\s*=\s*(__QUOTED_\d+__)/g;
+  const kvMatches = Array.from(tempString.matchAll(kvRegex));
+  kvMatches.forEach(([, key, quotedRef]) => {
+    var _a;
+    const quotedIndex = parseInt(((_a = quotedRef.match(/__QUOTED_(\d+)__/)) == null ? void 0 : _a[1]) || "0", 10);
+    const quotedValue = quotedStrings[quotedIndex];
+    if (quotedValue) {
+      attributes[key] = quotedValue.slice(1, -1);
+    }
+  });
+  const cleanString = tempString.replace(/(?:^|\s)\.([a-zA-Z][\w-]*)/g, "").replace(/(?:^|\s)#([a-zA-Z][\w-]*)/g, "").replace(/([a-zA-Z][\w-]*)\s*=\s*__QUOTED_\d+__/g, "").trim();
+  if (cleanString) {
+    const booleanAttrs = cleanString.split(/\s+/).filter(Boolean);
+    booleanAttrs.forEach((attr) => {
+      if (attr.match(/^[a-zA-Z][\w-]*$/)) {
+        attributes[attr] = true;
+      }
+    });
+  }
+  return attributes;
+}
+function serializeAttributes(attributes) {
+  if (!attributes || Object.keys(attributes).length === 0) {
+    return "";
+  }
+  const parts = [];
+  if (attributes.class) {
+    const classes = String(attributes.class).split(/\s+/).filter(Boolean);
+    classes.forEach((cls) => parts.push(`.${cls}`));
+  }
+  if (attributes.id) {
+    parts.push(`#${attributes.id}`);
+  }
+  Object.entries(attributes).forEach(([key, value]) => {
+    if (key === "class" || key === "id") {
+      return;
+    }
+    if (value === true) {
+      parts.push(key);
+    } else if (value !== false && value != null) {
+      parts.push(`${key}="${String(value)}"`);
+    }
+  });
+  return parts.join(" ");
+}
+function createAtomBlockMarkdownSpec(options) {
+  const {
+    nodeName,
+    name: markdownName,
+    parseAttributes: parseAttributes2 = parseAttributes,
+    serializeAttributes: serializeAttributes2 = serializeAttributes,
+    defaultAttributes = {},
+    requiredAttributes = [],
+    allowedAttributes
+  } = options;
+  const blockName = markdownName || nodeName;
+  const filterAttributes = (attrs) => {
+    if (!allowedAttributes) {
+      return attrs;
+    }
+    const filtered = {};
+    allowedAttributes.forEach((key) => {
+      if (key in attrs) {
+        filtered[key] = attrs[key];
+      }
+    });
+    return filtered;
+  };
+  return {
+    parseMarkdown: (token, h2) => {
+      const attrs = { ...defaultAttributes, ...token.attributes };
+      return h2.createNode(nodeName, attrs, []);
+    },
+    markdownTokenizer: {
+      name: nodeName,
+      level: "block",
+      start(src) {
+        var _a;
+        const regex = new RegExp(`^:::${blockName}(?:\\s|$)`, "m");
+        const index = (_a = src.match(regex)) == null ? void 0 : _a.index;
+        return index !== void 0 ? index : -1;
+      },
+      tokenize(src, _tokens, _lexer) {
+        const regex = new RegExp(`^:::${blockName}(?:\\s+\\{([^}]*)\\})?\\s*:::(?:\\n|$)`);
+        const match = src.match(regex);
+        if (!match) {
+          return void 0;
+        }
+        const attrString = match[1] || "";
+        const attributes = parseAttributes2(attrString);
+        const missingRequired = requiredAttributes.find((required) => !(required in attributes));
+        if (missingRequired) {
+          return void 0;
+        }
+        return {
+          type: nodeName,
+          raw: match[0],
+          attributes
+        };
+      }
+    },
+    renderMarkdown: (node) => {
+      const filteredAttrs = filterAttributes(node.attrs || {});
+      const attrs = serializeAttributes2(filteredAttrs);
+      const attrString = attrs ? ` {${attrs}}` : "";
+      return `:::${blockName}${attrString} :::`;
+    }
+  };
+}
+function createBlockMarkdownSpec(options) {
+  const {
+    nodeName,
+    name: markdownName,
+    getContent,
+    parseAttributes: parseAttributes2 = parseAttributes,
+    serializeAttributes: serializeAttributes2 = serializeAttributes,
+    defaultAttributes = {},
+    content = "block",
+    allowedAttributes
+  } = options;
+  const blockName = markdownName || nodeName;
+  const filterAttributes = (attrs) => {
+    if (!allowedAttributes) {
+      return attrs;
+    }
+    const filtered = {};
+    allowedAttributes.forEach((key) => {
+      if (key in attrs) {
+        filtered[key] = attrs[key];
+      }
+    });
+    return filtered;
+  };
+  return {
+    parseMarkdown: (token, h2) => {
+      let nodeContent;
+      if (getContent) {
+        const contentResult = getContent(token);
+        nodeContent = typeof contentResult === "string" ? [{ type: "text", text: contentResult }] : contentResult;
+      } else if (content === "block") {
+        nodeContent = h2.parseChildren(token.tokens || []);
+      } else {
+        nodeContent = h2.parseInline(token.tokens || []);
+      }
+      const attrs = { ...defaultAttributes, ...token.attributes };
+      return h2.createNode(nodeName, attrs, nodeContent);
+    },
+    markdownTokenizer: {
+      name: nodeName,
+      level: "block",
+      start(src) {
+        var _a;
+        const regex = new RegExp(`^:::${blockName}`, "m");
+        const index = (_a = src.match(regex)) == null ? void 0 : _a.index;
+        return index !== void 0 ? index : -1;
+      },
+      tokenize(src, _tokens, lexer) {
+        var _a;
+        const openingRegex = new RegExp(`^:::${blockName}(?:\\s+\\{([^}]*)\\})?\\s*\\n`);
+        const openingMatch = src.match(openingRegex);
+        if (!openingMatch) {
+          return void 0;
+        }
+        const [openingTag, attrString = ""] = openingMatch;
+        const attributes = parseAttributes2(attrString);
+        let level = 1;
+        const position = openingTag.length;
+        let matchedContent = "";
+        const blockPattern = /^:::([\w-]*)(\s.*)?/gm;
+        const remaining = src.slice(position);
+        blockPattern.lastIndex = 0;
+        for (; ; ) {
+          const match = blockPattern.exec(remaining);
+          if (match === null) {
+            break;
+          }
+          const matchPos = match.index;
+          const blockType = match[1];
+          if ((_a = match[2]) == null ? void 0 : _a.endsWith(":::")) {
+            continue;
+          }
+          if (blockType) {
+            level += 1;
+          } else {
+            level -= 1;
+            if (level === 0) {
+              const rawContent = remaining.slice(0, matchPos);
+              matchedContent = rawContent.trim();
+              const fullMatch = src.slice(0, position + matchPos + match[0].length);
+              let contentTokens = [];
+              if (matchedContent) {
+                if (content === "block") {
+                  contentTokens = lexer.blockTokens(rawContent);
+                  contentTokens.forEach((token) => {
+                    if (token.text && (!token.tokens || token.tokens.length === 0)) {
+                      token.tokens = lexer.inlineTokens(token.text);
+                    }
+                  });
+                  while (contentTokens.length > 0) {
+                    const lastToken = contentTokens[contentTokens.length - 1];
+                    if (lastToken.type === "paragraph" && (!lastToken.text || lastToken.text.trim() === "")) {
+                      contentTokens.pop();
+                    } else {
+                      break;
+                    }
+                  }
+                } else {
+                  contentTokens = lexer.inlineTokens(matchedContent);
+                }
+              }
+              return {
+                type: nodeName,
+                raw: fullMatch,
+                attributes,
+                content: matchedContent,
+                tokens: contentTokens
+              };
+            }
+          }
+        }
+        return void 0;
+      }
+    },
+    renderMarkdown: (node, h2) => {
+      const filteredAttrs = filterAttributes(node.attrs || {});
+      const attrs = serializeAttributes2(filteredAttrs);
+      const attrString = attrs ? ` {${attrs}}` : "";
+      const renderedContent = h2.renderChildren(node.content || [], "\n\n");
+      return `:::${blockName}${attrString}
+
+${renderedContent}
+
+:::`;
+    }
+  };
+}
+function parseShortcodeAttributes(attrString) {
+  if (!attrString.trim()) {
+    return {};
+  }
+  const attributes = {};
+  const regex = /(\w+)=(?:"([^"]*)"|'([^']*)')/g;
+  let match = regex.exec(attrString);
+  while (match !== null) {
+    const [, key, doubleQuoted, singleQuoted] = match;
+    attributes[key] = doubleQuoted || singleQuoted;
+    match = regex.exec(attrString);
+  }
+  return attributes;
+}
+function serializeShortcodeAttributes(attrs) {
+  return Object.entries(attrs).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}="${value}"`).join(" ");
+}
+function createInlineMarkdownSpec(options) {
+  const {
+    nodeName,
+    name: shortcodeName,
+    getContent,
+    parseAttributes: parseAttributes2 = parseShortcodeAttributes,
+    serializeAttributes: serializeAttributes2 = serializeShortcodeAttributes,
+    defaultAttributes = {},
+    selfClosing = false,
+    allowedAttributes
+  } = options;
+  const shortcode = shortcodeName || nodeName;
+  const filterAttributes = (attrs) => {
+    if (!allowedAttributes) {
+      return attrs;
+    }
+    const filtered = {};
+    allowedAttributes.forEach((attr) => {
+      const attrName = typeof attr === "string" ? attr : attr.name;
+      const skipIfDefault = typeof attr === "string" ? void 0 : attr.skipIfDefault;
+      if (attrName in attrs) {
+        const value = attrs[attrName];
+        if (skipIfDefault !== void 0 && value === skipIfDefault) {
+          return;
+        }
+        filtered[attrName] = value;
+      }
+    });
+    return filtered;
+  };
+  const escapedShortcode = shortcode.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return {
+    parseMarkdown: (token, h2) => {
+      const attrs = { ...defaultAttributes, ...token.attributes };
+      if (selfClosing) {
+        return h2.createNode(nodeName, attrs);
+      }
+      const content = getContent ? getContent(token) : token.content || "";
+      if (content) {
+        return h2.createNode(nodeName, attrs, [h2.createTextNode(content)]);
+      }
+      return h2.createNode(nodeName, attrs, []);
+    },
+    markdownTokenizer: {
+      name: nodeName,
+      level: "inline",
+      start(src) {
+        const startPattern = selfClosing ? new RegExp(`\\[${escapedShortcode}\\s*[^\\]]*\\]`) : new RegExp(`\\[${escapedShortcode}\\s*[^\\]]*\\][\\s\\S]*?\\[\\/${escapedShortcode}\\]`);
+        const match = src.match(startPattern);
+        const index = match == null ? void 0 : match.index;
+        return index !== void 0 ? index : -1;
+      },
+      tokenize(src, _tokens, _lexer) {
+        const tokenPattern = selfClosing ? new RegExp(`^\\[${escapedShortcode}\\s*([^\\]]*)\\]`) : new RegExp(`^\\[${escapedShortcode}\\s*([^\\]]*)\\]([\\s\\S]*?)\\[\\/${escapedShortcode}\\]`);
+        const match = src.match(tokenPattern);
+        if (!match) {
+          return void 0;
+        }
+        let content = "";
+        let attrString = "";
+        if (selfClosing) {
+          const [, attrs] = match;
+          attrString = attrs;
+        } else {
+          const [, attrs, contentMatch] = match;
+          attrString = attrs;
+          content = contentMatch || "";
+        }
+        const attributes = parseAttributes2(attrString.trim());
+        return {
+          type: nodeName,
+          raw: match[0],
+          content: content.trim(),
+          attributes
+        };
+      }
+    },
+    renderMarkdown: (node) => {
+      let content = "";
+      if (getContent) {
+        content = getContent(node);
+      } else if (node.content && node.content.length > 0) {
+        content = node.content.filter((child) => child.type === "text").map((child) => child.text).join("");
+      }
+      const filteredAttrs = filterAttributes(node.attrs || {});
+      const attrs = serializeAttributes2(filteredAttrs);
+      const attrString = attrs ? ` ${attrs}` : "";
+      if (selfClosing) {
+        return `[${shortcode}${attrString}]`;
+      }
+      return `[${shortcode}${attrString}]${content}[/${shortcode}]`;
+    }
+  };
+}
+function parseIndentedBlocks(src, config, lexer) {
+  var _a, _b, _c, _d;
+  const lines = src.split("\n");
+  const items = [];
+  let totalRaw = "";
+  let i = 0;
+  const baseIndentSize = config.baseIndentSize || 2;
+  while (i < lines.length) {
+    const currentLine = lines[i];
+    const itemMatch = currentLine.match(config.itemPattern);
+    if (!itemMatch) {
+      if (items.length > 0) {
+        break;
+      } else if (currentLine.trim() === "") {
+        i += 1;
+        totalRaw = `${totalRaw}${currentLine}
+`;
+        continue;
+      } else {
+        return void 0;
+      }
+    }
+    const itemData = config.extractItemData(itemMatch);
+    const { indentLevel, mainContent } = itemData;
+    totalRaw = `${totalRaw}${currentLine}
+`;
+    const itemContent = [mainContent];
+    i += 1;
+    while (i < lines.length) {
+      const nextLine = lines[i];
+      if (nextLine.trim() === "") {
+        const nextNonEmptyIndex = lines.slice(i + 1).findIndex((l) => l.trim() !== "");
+        if (nextNonEmptyIndex === -1) {
+          break;
+        }
+        const nextNonEmpty = lines[i + 1 + nextNonEmptyIndex];
+        const nextIndent2 = ((_b = (_a = nextNonEmpty.match(/^(\s*)/)) == null ? void 0 : _a[1]) == null ? void 0 : _b.length) || 0;
+        if (nextIndent2 > indentLevel) {
+          itemContent.push(nextLine);
+          totalRaw = `${totalRaw}${nextLine}
+`;
+          i += 1;
+          continue;
+        } else {
+          break;
+        }
+      }
+      const nextIndent = ((_d = (_c = nextLine.match(/^(\s*)/)) == null ? void 0 : _c[1]) == null ? void 0 : _d.length) || 0;
+      if (nextIndent > indentLevel) {
+        itemContent.push(nextLine);
+        totalRaw = `${totalRaw}${nextLine}
+`;
+        i += 1;
+      } else {
+        break;
+      }
+    }
+    let nestedTokens;
+    const nestedContent = itemContent.slice(1);
+    if (nestedContent.length > 0) {
+      const dedentedNested = nestedContent.map((nestedLine) => nestedLine.slice(indentLevel + baseIndentSize)).join("\n");
+      if (dedentedNested.trim()) {
+        if (config.customNestedParser) {
+          nestedTokens = config.customNestedParser(dedentedNested);
+        } else {
+          nestedTokens = lexer.blockTokens(dedentedNested);
+        }
+      }
+    }
+    const token = config.createToken(itemData, nestedTokens);
+    items.push(token);
+  }
+  if (items.length === 0) {
+    return void 0;
+  }
+  return {
+    items,
+    raw: totalRaw
+  };
+}
+function renderNestedMarkdownContent(node, h2, prefixOrGenerator, ctx) {
+  if (!node || !Array.isArray(node.content)) {
+    return "";
+  }
+  const prefix = typeof prefixOrGenerator === "function" ? prefixOrGenerator(ctx) : prefixOrGenerator;
+  const [content, ...children] = node.content;
+  const mainContent = h2.renderChildren([content]);
+  const output = [`${prefix}${mainContent}`];
+  if (children && children.length > 0) {
+    children.forEach((child) => {
+      const childContent = h2.renderChildren([child]);
+      if (childContent) {
+        const indentedChild = childContent.split("\n").map((line) => line ? h2.indent(line) : "").join("\n");
+        output.push(indentedChild);
+      }
+    });
+  }
+  return output.join("\n");
+}
+function updateMarkViewAttributes(checkMark, editor, attrs = {}) {
+  const { state } = editor;
+  const { doc, tr } = state;
+  const thisMark = checkMark;
+  doc.descendants((node, pos) => {
+    const from = tr.mapping.map(pos);
+    const to = tr.mapping.map(pos) + node.nodeSize;
+    let foundMark = null;
+    node.marks.forEach((mark) => {
+      if (mark !== thisMark) {
+        return false;
+      }
+      foundMark = mark;
+    });
+    if (!foundMark) {
+      return;
+    }
+    let needsUpdate = false;
+    Object.keys(attrs).forEach((k) => {
+      if (attrs[k] !== foundMark.attrs[k]) {
+        needsUpdate = true;
+      }
+    });
+    if (needsUpdate) {
+      const updatedMark = checkMark.type.create({
+        ...checkMark.attrs,
+        ...attrs
+      });
+      tr.removeMark(from, to, checkMark.type);
+      tr.addMark(from, to, updatedMark);
+    }
+  });
+  if (tr.docChanged) {
+    editor.view.dispatch(tr);
+  }
+}
+var Node3 = class _Node extends Extendable {
+  constructor() {
+    super(...arguments);
+    this.type = "node";
+  }
+  /**
+   * Create a new Node instance
+   * @param config - Node configuration object or a function that returns a configuration object
+   */
+  static create(config = {}) {
+    const resolvedConfig = typeof config === "function" ? config() : config;
+    return new _Node(resolvedConfig);
+  }
+  configure(options) {
+    return super.configure(options);
+  }
+  extend(extendedConfig) {
+    const resolvedConfig = typeof extendedConfig === "function" ? extendedConfig() : extendedConfig;
+    return super.extend(resolvedConfig);
+  }
+};
+
+// src/extensions/callout.ts
+var CALLOUT_ARIA_LABELS = {
+  success: "\u6210\u529F\u63D0\u793A",
+  warning: "\u8B66\u544A\u63D0\u793A",
+  error: "\u932F\u8AA4\u63D0\u793A",
+  info: "\u8CC7\u8A0A\u63D0\u793A"
+};
+var Callout = Node3.create({
+  name: "callout",
+  group: "block",
+  content: "block+",
+  defining: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return {
+      type: {
+        default: "info",
+        parseHTML: (element) => element.getAttribute("data-type"),
+        renderHTML: (attributes) => ({
+          "data-type": attributes.type
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-callout]"
+      }
+    ];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const type = node.attrs.type || "info";
+    return [
+      "div",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-callout": "",
+        "class": `callout callout-${type}`,
+        "role": "note",
+        "aria-label": CALLOUT_ARIA_LABELS[type]
+      }),
+      0
+    ];
+  },
+  addCommands() {
+    return {
+      setCallout: (attributes) => ({ commands }) => {
+        return commands.wrapIn(this.name, attributes);
+      },
+      toggleCallout: (attributes) => ({ commands }) => {
+        return commands.toggleWrap(this.name, attributes);
+      },
+      unsetCallout: () => ({ commands }) => {
+        return commands.lift(this.name);
+      }
+    };
+  }
+});
+
+// src/components/Toolbar.tsx
+import { useRef } from "react";
+
+// src/ui/button.tsx
+import * as React from "react";
+
+// src/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/ui/button.tsx
+import { jsx } from "react/jsx-runtime";
+var Button = React.forwardRef(
+  ({ className, variant = "default", size = "default", ...props }, ref) => {
+    const variantStyles = {
+      default: "bg-[var(--background)] text-[var(--foreground)] hover:bg-[var(--accent)]",
+      ghost: "hover:bg-[var(--accent)] hover:text-[var(--accent-foreground)]",
+      outline: "border border-[var(--border)] bg-transparent hover:bg-[var(--accent)]"
+    };
+    const sizeStyles = {
+      default: "h-9 px-4 py-2",
+      sm: "h-8 px-3 text-xs",
+      lg: "h-10 px-8"
+    };
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        className: cn(
+          "inline-flex items-center justify-center rounded-md text-sm font-medium transition-colors",
+          "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--ring)]",
+          "disabled:pointer-events-none disabled:opacity-50",
+          variantStyles[variant],
+          sizeStyles[size],
+          className
+        ),
+        ref,
+        ...props
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+
+// src/ui/toggle.tsx
+import * as React2 from "react";
+import * as TogglePrimitive from "@radix-ui/react-toggle";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Toggle = React2.forwardRef(
+  ({ className, size = "default", ...props }, ref) => {
+    const sizeStyles = {
+      default: "h-9 px-3",
+      sm: "h-8 px-2"
+    };
+    return /* @__PURE__ */ jsx2(
+      TogglePrimitive.Root,
+      {
+        ref,
+        className: cn(
+          "inline-flex items-center justify-center rounded-md text-sm font-medium transition-colors",
+          "hover:bg-[var(--accent)] hover:text-[var(--accent-foreground)]",
+          "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--ring)]",
+          "disabled:pointer-events-none disabled:opacity-50",
+          "data-[state=on]:bg-[var(--accent)] data-[state=on]:text-[var(--accent-foreground)]",
+          sizeStyles[size],
+          className
+        ),
+        ...props
+      }
+    );
+  }
+);
+Toggle.displayName = TogglePrimitive.Root.displayName;
+
+// src/components/ToolbarButton.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function ToolbarButton({
+  pressed,
+  onPressedChange,
+  disabled,
+  children,
+  title
+}) {
+  return /* @__PURE__ */ jsx3(
+    Toggle,
+    {
+      size: "sm",
+      pressed,
+      onPressedChange,
+      disabled,
+      title,
+      className: "h-9 w-9 p-0 border-0 bg-transparent rounded-lg hover:bg-muted data-[state=on]:bg-zinc-900 data-[state=on]:text-white dark:data-[state=on]:bg-zinc-100 dark:data-[state=on]:text-zinc-900 disabled:opacity-30",
+      children
+    }
+  );
+}
+
+// src/components/ToolbarDivider.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function ToolbarDivider() {
+  return /* @__PURE__ */ jsx4("div", { className: "w-px h-5 bg-border mx-1.5" });
+}
+
+// src/ui/dropdown-menu.tsx
+import * as React3 from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var DropdownMenu = DropdownMenuPrimitive.Root;
+var DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
+var DropdownMenuContent = React3.forwardRef(({ className, sideOffset = 4, ...props }, ref) => /* @__PURE__ */ jsx5(DropdownMenuPrimitive.Portal, { children: /* @__PURE__ */ jsx5(
+  DropdownMenuPrimitive.Content,
+  {
+    ref,
+    sideOffset,
+    className: cn(
+      "z-50 min-w-[8rem] overflow-hidden rounded-md border border-[var(--border)] bg-[var(--popover)] p-1 text-[var(--popover-foreground)] shadow-md",
+      "data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95",
+      "data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+      className
+    ),
+    ...props
+  }
+) }));
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
+var DropdownMenuItem = React3.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5(
+  DropdownMenuPrimitive.Item,
+  {
+    ref,
+    className: cn(
+      "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors",
+      "focus:bg-[var(--accent)] focus:text-[var(--accent-foreground)]",
+      "data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
+      className
+    ),
+    ...props
+  }
+));
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
+var DropdownMenuSeparator = React3.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx5(
+  DropdownMenuPrimitive.Separator,
+  {
+    ref,
+    className: cn("-mx-1 my-1 h-px bg-[var(--border)]", className),
+    ...props
+  }
+));
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+
+// src/components/HeadingDropdown.tsx
+import { ChevronDown, Heading1, Heading2, Heading3 } from "lucide-react";
+import { jsx as jsx6, jsxs } from "react/jsx-runtime";
+function HeadingDropdown({ editor, iconSize = "h-4 w-4" }) {
+  return /* @__PURE__ */ jsxs(DropdownMenu, { children: [
+    /* @__PURE__ */ jsx6(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(Button, { variant: "ghost", size: "sm", className: "h-8 px-2 gap-1 font-normal", children: [
+      /* @__PURE__ */ jsx6("span", { className: "text-sm font-semibold", children: "H" }),
+      /* @__PURE__ */ jsx6(ChevronDown, { className: "h-3 w-3" })
+    ] }) }),
+    /* @__PURE__ */ jsxs(DropdownMenuContent, { align: "start", children: [
+      /* @__PURE__ */ jsxs(DropdownMenuItem, { onClick: () => editor.chain().focus().toggleHeading({ level: 1 }).run(), children: [
+        /* @__PURE__ */ jsx6(Heading1, { className: cn(iconSize, "mr-2") }),
+        "\u6A19\u984C 1"
+      ] }),
+      /* @__PURE__ */ jsxs(DropdownMenuItem, { onClick: () => editor.chain().focus().toggleHeading({ level: 2 }).run(), children: [
+        /* @__PURE__ */ jsx6(Heading2, { className: cn(iconSize, "mr-2") }),
+        "\u6A19\u984C 2"
+      ] }),
+      /* @__PURE__ */ jsxs(DropdownMenuItem, { onClick: () => editor.chain().focus().toggleHeading({ level: 3 }).run(), children: [
+        /* @__PURE__ */ jsx6(Heading3, { className: cn(iconSize, "mr-2") }),
+        "\u6A19\u984C 3"
+      ] }),
+      /* @__PURE__ */ jsx6(DropdownMenuItem, { onClick: () => editor.chain().focus().setParagraph().run(), children: "\u5167\u6587" })
+    ] })
+  ] });
+}
+
+// src/components/ListDropdown.tsx
+import { ChevronDown as ChevronDown2, List, ListOrdered, ListTodo } from "lucide-react";
+import { jsx as jsx7, jsxs as jsxs2 } from "react/jsx-runtime";
+function ListDropdown({ editor, iconSize = "h-4 w-4" }) {
+  return /* @__PURE__ */ jsxs2(DropdownMenu, { children: [
+    /* @__PURE__ */ jsx7(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs2(Button, { variant: "ghost", size: "sm", className: "h-8 px-2 gap-1", children: [
+      /* @__PURE__ */ jsx7(List, { className: iconSize }),
+      /* @__PURE__ */ jsx7(ChevronDown2, { className: "h-3 w-3" })
+    ] }) }),
+    /* @__PURE__ */ jsxs2(DropdownMenuContent, { align: "start", children: [
+      /* @__PURE__ */ jsxs2(DropdownMenuItem, { onClick: () => editor.chain().focus().toggleBulletList().run(), children: [
+        /* @__PURE__ */ jsx7(List, { className: cn(iconSize, "mr-2") }),
+        "\u9805\u76EE\u6E05\u55AE"
+      ] }),
+      /* @__PURE__ */ jsxs2(DropdownMenuItem, { onClick: () => editor.chain().focus().toggleOrderedList().run(), children: [
+        /* @__PURE__ */ jsx7(ListOrdered, { className: cn(iconSize, "mr-2") }),
+        "\u7DE8\u865F\u6E05\u55AE"
+      ] }),
+      /* @__PURE__ */ jsxs2(DropdownMenuItem, { onClick: () => editor.chain().focus().toggleTaskList().run(), children: [
+        /* @__PURE__ */ jsx7(ListTodo, { className: cn(iconSize, "mr-2") }),
+        "\u4EFB\u52D9\u6E05\u55AE"
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/TableDropdown.tsx
+import { ChevronDown as ChevronDown3, Plus, Trash2, Table as TableIcon } from "lucide-react";
+import { jsx as jsx8, jsxs as jsxs3 } from "react/jsx-runtime";
+function TableDropdown({ editor, iconSize = "h-4 w-4" }) {
+  return /* @__PURE__ */ jsxs3(DropdownMenu, { children: [
+    /* @__PURE__ */ jsx8(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs3(Button, { variant: "ghost", size: "sm", className: "h-8 px-2 gap-1", children: [
+      /* @__PURE__ */ jsx8(TableIcon, { className: iconSize }),
+      /* @__PURE__ */ jsx8(ChevronDown3, { className: "h-3 w-3" })
+    ] }) }),
+    /* @__PURE__ */ jsxs3(DropdownMenuContent, { align: "start", children: [
+      /* @__PURE__ */ jsxs3(
+        DropdownMenuItem,
+        {
+          onClick: () => editor.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run(),
+          children: [
+            /* @__PURE__ */ jsx8(Plus, { className: cn(iconSize, "mr-2") }),
+            "\u63D2\u5165\u8868\u683C (3x3)"
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx8(DropdownMenuSeparator, {}),
+      /* @__PURE__ */ jsx8(
+        DropdownMenuItem,
+        {
+          onClick: () => editor.chain().focus().addColumnAfter().run(),
+          disabled: !editor.can().addColumnAfter(),
+          children: "\u65B0\u589E\u6B04"
+        }
+      ),
+      /* @__PURE__ */ jsx8(
+        DropdownMenuItem,
+        {
+          onClick: () => editor.chain().focus().addRowAfter().run(),
+          disabled: !editor.can().addRowAfter(),
+          children: "\u65B0\u589E\u5217"
+        }
+      ),
+      /* @__PURE__ */ jsx8(DropdownMenuSeparator, {}),
+      /* @__PURE__ */ jsx8(
+        DropdownMenuItem,
+        {
+          onClick: () => editor.chain().focus().deleteColumn().run(),
+          disabled: !editor.can().deleteColumn(),
+          children: "\u522A\u9664\u6B04"
+        }
+      ),
+      /* @__PURE__ */ jsx8(
+        DropdownMenuItem,
+        {
+          onClick: () => editor.chain().focus().deleteRow().run(),
+          disabled: !editor.can().deleteRow(),
+          children: "\u522A\u9664\u5217"
+        }
+      ),
+      /* @__PURE__ */ jsx8(DropdownMenuSeparator, {}),
+      /* @__PURE__ */ jsxs3(
+        DropdownMenuItem,
+        {
+          onClick: () => editor.chain().focus().deleteTable().run(),
+          disabled: !editor.can().deleteTable(),
+          className: "text-destructive",
+          children: [
+            /* @__PURE__ */ jsx8(Trash2, { className: cn(iconSize, "mr-2") }),
+            "\u522A\u9664\u8868\u683C"
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/components/CalloutDropdown.tsx
+import { useState } from "react";
+import { ChevronDown as ChevronDown4, MessageSquare } from "lucide-react";
+import { jsx as jsx9, jsxs as jsxs4 } from "react/jsx-runtime";
+function CalloutDropdown({ editor, iconSize = "h-4 w-4" }) {
+  const [open, setOpen] = useState(false);
+  return /* @__PURE__ */ jsxs4(DropdownMenu, { open, onOpenChange: setOpen, modal: false, children: [
+    /* @__PURE__ */ jsx9(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsxs4(Button, { variant: "ghost", size: "sm", className: "h-8 px-2 gap-1", children: [
+      /* @__PURE__ */ jsx9(MessageSquare, { className: iconSize }),
+      /* @__PURE__ */ jsx9(ChevronDown4, { className: "h-3 w-3" })
+    ] }) }),
+    /* @__PURE__ */ jsx9(DropdownMenuContent, { align: "start", className: "min-w-0 p-1.5", children: /* @__PURE__ */ jsxs4("div", { className: "flex gap-1", children: [
+      /* @__PURE__ */ jsx9(
+        "button",
+        {
+          type: "button",
+          className: "w-6 h-6 rounded bg-emerald-100 border border-emerald-300 hover:scale-110 transition-transform",
+          onClick: () => {
+            setOpen(false);
+            setTimeout(() => {
+              editor.chain().focus().setCallout({ type: "success" }).run();
+            }, 0);
+          },
+          title: "\u6210\u529F\u63D0\u793A",
+          "aria-label": "\u6210\u529F\u63D0\u793A"
+        }
+      ),
+      /* @__PURE__ */ jsx9(
+        "button",
+        {
+          type: "button",
+          className: "w-6 h-6 rounded bg-amber-100 border border-amber-300 hover:scale-110 transition-transform",
+          onClick: () => {
+            setOpen(false);
+            setTimeout(() => {
+              editor.chain().focus().setCallout({ type: "warning" }).run();
+            }, 0);
+          },
+          title: "\u8B66\u544A\u63D0\u793A",
+          "aria-label": "\u8B66\u544A\u63D0\u793A"
+        }
+      ),
+      /* @__PURE__ */ jsx9(
+        "button",
+        {
+          type: "button",
+          className: "w-6 h-6 rounded bg-red-100 border border-red-300 hover:scale-110 transition-transform",
+          onClick: () => {
+            setOpen(false);
+            setTimeout(() => {
+              editor.chain().focus().setCallout({ type: "error" }).run();
+            }, 0);
+          },
+          title: "\u932F\u8AA4\u63D0\u793A",
+          "aria-label": "\u932F\u8AA4\u63D0\u793A"
+        }
+      ),
+      /* @__PURE__ */ jsx9(
+        "button",
+        {
+          type: "button",
+          className: "w-6 h-6 rounded bg-sky-100 border border-sky-300 hover:scale-110 transition-transform",
+          onClick: () => {
+            setOpen(false);
+            setTimeout(() => {
+              editor.chain().focus().setCallout({ type: "info" }).run();
+            }, 0);
+          },
+          title: "\u8CC7\u8A0A\u63D0\u793A",
+          "aria-label": "\u8CC7\u8A0A\u63D0\u793A"
+        }
+      )
+    ] }) })
+  ] });
+}
+
+// src/components/ColorPicker.tsx
+import { Palette, X } from "lucide-react";
+import { jsx as jsx10, jsxs as jsxs5 } from "react/jsx-runtime";
+var COLOR_PALETTE = [
+  { name: "\u9ED1\u8272", value: "#000000" },
+  { name: "\u7070\u8272", value: "#6B7280" },
+  { name: "\u7D05\u8272", value: "#EF4444" },
+  { name: "\u6A59\u8272", value: "#F97316" },
+  { name: "\u9EC3\u8272", value: "#EAB308" },
+  { name: "\u7DA0\u8272", value: "#22C55E" },
+  { name: "\u85CD\u8272", value: "#3B82F6" },
+  { name: "\u7D2B\u8272", value: "#8B5CF6" }
+];
+function ColorPicker({ editor, iconSize = "h-4 w-4" }) {
+  return /* @__PURE__ */ jsxs5(DropdownMenu, { children: [
+    /* @__PURE__ */ jsx10(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx10(Button, { variant: "ghost", size: "sm", className: "h-8 px-2 gap-1", title: "\u984F\u8272", children: /* @__PURE__ */ jsx10(Palette, { className: iconSize }) }) }),
+    /* @__PURE__ */ jsx10(DropdownMenuContent, { align: "start", className: "w-72", children: /* @__PURE__ */ jsxs5("div", { className: "p-2", children: [
+      /* @__PURE__ */ jsx10("div", { className: "text-xs font-medium text-muted-foreground mb-2", children: "\u6587\u5B57\u984F\u8272" }),
+      /* @__PURE__ */ jsxs5("div", { className: "flex gap-1.5 mb-3", children: [
+        COLOR_PALETTE.map((color) => /* @__PURE__ */ jsx10(
+          "button",
+          {
+            type: "button",
+            className: "w-6 h-6 rounded border border-border dark:border-zinc-600 hover:scale-110 transition-transform",
+            style: { backgroundColor: color.value },
+            onClick: () => editor.chain().focus().setColor(color.value).run(),
+            title: color.name,
+            "aria-label": `\u6587\u5B57\u984F\u8272\uFF1A${color.name}`
+          },
+          `text-${color.value}`
+        )),
+        /* @__PURE__ */ jsx10(
+          "button",
+          {
+            type: "button",
+            className: "w-6 h-6 rounded border border-border dark:border-zinc-600 hover:scale-110 transition-transform flex items-center justify-center bg-background",
+            onClick: () => editor.chain().focus().unsetColor().run(),
+            title: "\u6E05\u9664\u6587\u5B57\u984F\u8272",
+            "aria-label": "\u6E05\u9664\u6587\u5B57\u984F\u8272",
+            children: /* @__PURE__ */ jsx10(X, { className: "h-3 w-3" })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx10(DropdownMenuSeparator, {}),
+      /* @__PURE__ */ jsx10("div", { className: "text-xs font-medium text-muted-foreground mb-2 mt-2", children: "\u80CC\u666F\u8272" }),
+      /* @__PURE__ */ jsxs5("div", { className: "flex gap-1.5", children: [
+        COLOR_PALETTE.map((color) => /* @__PURE__ */ jsx10(
+          "button",
+          {
+            type: "button",
+            className: "w-6 h-6 rounded border border-border dark:border-zinc-600 hover:scale-110 transition-transform",
+            style: { backgroundColor: color.value },
+            onClick: () => editor.chain().focus().toggleHighlight({ color: color.value }).run(),
+            title: color.name,
+            "aria-label": `\u80CC\u666F\u8272\uFF1A${color.name}`
+          },
+          `bg-${color.value}`
+        )),
+        /* @__PURE__ */ jsx10(
+          "button",
+          {
+            type: "button",
+            className: "w-6 h-6 rounded border border-border dark:border-zinc-600 hover:scale-110 transition-transform flex items-center justify-center bg-background",
+            onClick: () => editor.chain().focus().unsetHighlight().run(),
+            title: "\u6E05\u9664\u80CC\u666F\u8272",
+            "aria-label": "\u6E05\u9664\u80CC\u666F\u8272",
+            children: /* @__PURE__ */ jsx10(X, { className: "h-3 w-3" })
+          }
+        )
+      ] })
+    ] }) })
+  ] });
+}
+
+// src/components/Toolbar.tsx
+import {
+  Bold,
+  Italic,
+  Code,
+  Underline as UnderlineIcon,
+  Link as LinkIcon,
+  Superscript as SuperscriptIcon,
+  Subscript as SubscriptIcon,
+  AlignLeft,
+  AlignCenter,
+  AlignRight,
+  ImagePlus,
+  Sun,
+  Moon
+} from "lucide-react";
+import { Fragment as Fragment6, jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+var ICON_SIZE = "h-4 w-4";
+var TEXT_FORMAT_BUTTONS = [
+  { key: "bold", icon: Bold, title: "\u7C97\u9AD4", isActive: (e) => e.isActive("bold"), action: (e) => e.chain().focus().toggleBold().run() },
+  { key: "italic", icon: Italic, title: "\u659C\u9AD4", isActive: (e) => e.isActive("italic"), action: (e) => e.chain().focus().toggleItalic().run() },
+  { key: "code", icon: Code, title: "\u884C\u5167\u7A0B\u5F0F\u78BC", isActive: (e) => e.isActive("code"), action: (e) => e.chain().focus().toggleCode().run() },
+  { key: "underline", icon: UnderlineIcon, title: "\u5E95\u7DDA", isActive: (e) => e.isActive("underline"), action: (e) => e.chain().focus().toggleUnderline().run() }
+];
+var SCRIPT_BUTTONS = [
+  { key: "superscript", icon: SuperscriptIcon, title: "\u4E0A\u6A19", isActive: (e) => e.isActive("superscript"), action: (e) => e.chain().focus().toggleSuperscript().run() },
+  { key: "subscript", icon: SubscriptIcon, title: "\u4E0B\u6A19", isActive: (e) => e.isActive("subscript"), action: (e) => e.chain().focus().toggleSubscript().run() }
+];
+var ALIGN_BUTTONS = [
+  { key: "left", icon: AlignLeft, title: "\u9760\u5DE6\u5C0D\u9F4A", isActive: (e) => e.isActive({ textAlign: "left" }), action: (e) => e.chain().focus().setTextAlign("left").run() },
+  { key: "center", icon: AlignCenter, title: "\u7F6E\u4E2D\u5C0D\u9F4A", isActive: (e) => e.isActive({ textAlign: "center" }), action: (e) => e.chain().focus().setTextAlign("center").run() },
+  { key: "right", icon: AlignRight, title: "\u9760\u53F3\u5C0D\u9F4A", isActive: (e) => e.isActive({ textAlign: "right" }), action: (e) => e.chain().focus().setTextAlign("right").run() }
+];
+function ToolbarButtonGroup({ buttons, editor }) {
+  return /* @__PURE__ */ jsx11(Fragment6, { children: buttons.map(({ key, icon: Icon, title, isActive, action }) => /* @__PURE__ */ jsx11(
+    ToolbarButton,
+    {
+      pressed: isActive(editor),
+      onPressedChange: () => action(editor),
+      title,
+      children: /* @__PURE__ */ jsx11(Icon, { className: ICON_SIZE })
+    },
+    key
+  )) });
+}
+function normalizeConfig(config) {
+  if (config === "none") return [];
+  if (config === "all" || !config) {
+    return [
+      ["heading", "list", "table", "callout"],
+      ["format", "link", "color"],
+      ["script"],
+      ["align"],
+      ["image"],
+      ["themeToggle"]
+    ];
+  }
+  if (Array.isArray(config)) {
+    if (config.length > 0 && Array.isArray(config[0])) {
+      return config;
+    }
+    return [config];
+  }
+  return [];
+}
+function Toolbar({
+  editor,
+  config,
+  toolbarStart,
+  toolbarEnd,
+  theme,
+  onThemeToggle,
+  onImageUpload
+}) {
+  const fileInputRef = useRef(null);
+  if (!editor) return null;
+  const groups = normalizeConfig(config);
+  const setLink = () => {
+    const previousUrl = editor.getAttributes("link").href;
+    const url = window.prompt("\u8F38\u5165\u9023\u7D50\u7DB2\u5740", previousUrl);
+    if (url === null) return;
+    if (url === "") {
+      editor.chain().focus().extendMarkRange("link").unsetLink().run();
+      return;
+    }
+    editor.chain().focus().extendMarkRange("link").setLink({ href: url }).run();
+  };
+  const handleImageUpload = (e) => {
+    const file = e.target.files?.[0];
+    if (!file) return;
+    const MAX_SIZE = 5 * 1024 * 1024;
+    if (file.size > MAX_SIZE) {
+      alert("\u5716\u7247\u5927\u5C0F\u4E0D\u53EF\u8D85\u904E 5MB");
+      e.target.value = "";
+      return;
+    }
+    if (onImageUpload) {
+      onImageUpload(file);
+    } else {
+      const reader = new FileReader();
+      reader.onload = () => {
+        const base64 = reader.result;
+        editor.chain().focus().setImage({ src: base64 }).run();
+      };
+      reader.onerror = () => {
+        console.error("\u5716\u7247\u8B80\u53D6\u5931\u6557");
+      };
+      reader.readAsDataURL(file);
+    }
+    e.target.value = "";
+  };
+  const renderToolbarItem = (item) => {
+    switch (item) {
+      case "heading":
+        return /* @__PURE__ */ jsx11(HeadingDropdown, { editor, iconSize: ICON_SIZE }, "heading");
+      case "list":
+        return /* @__PURE__ */ jsx11(ListDropdown, { editor, iconSize: ICON_SIZE }, "list");
+      case "table":
+        return /* @__PURE__ */ jsx11(TableDropdown, { editor, iconSize: ICON_SIZE }, "table");
+      case "callout":
+        return /* @__PURE__ */ jsx11(CalloutDropdown, { editor, iconSize: ICON_SIZE }, "callout");
+      case "format":
+        return /* @__PURE__ */ jsx11(ToolbarButtonGroup, { buttons: TEXT_FORMAT_BUTTONS, editor }, "format");
+      case "link":
+        return /* @__PURE__ */ jsx11(
+          ToolbarButton,
+          {
+            pressed: editor.isActive("link"),
+            onPressedChange: setLink,
+            title: "\u9023\u7D50",
+            children: /* @__PURE__ */ jsx11(LinkIcon, { className: ICON_SIZE })
+          },
+          "link"
+        );
+      case "color":
+        return /* @__PURE__ */ jsx11(ColorPicker, { editor, iconSize: ICON_SIZE }, "color");
+      case "script":
+        return /* @__PURE__ */ jsx11(ToolbarButtonGroup, { buttons: SCRIPT_BUTTONS, editor }, "script");
+      case "align":
+        return /* @__PURE__ */ jsx11(ToolbarButtonGroup, { buttons: ALIGN_BUTTONS, editor }, "align");
+      case "image":
+        return /* @__PURE__ */ jsx11(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "h-8 px-2 gap-1",
+            onClick: () => fileInputRef.current?.click(),
+            title: "\u63D2\u5165\u5716\u7247",
+            children: /* @__PURE__ */ jsx11(ImagePlus, { className: ICON_SIZE })
+          },
+          "image"
+        );
+      case "themeToggle":
+        return onThemeToggle ? /* @__PURE__ */ jsx11(
+          Button,
+          {
+            variant: "ghost",
+            size: "sm",
+            className: "h-8 w-8 p-0",
+            onClick: onThemeToggle,
+            title: theme === "dark" ? "\u5207\u63DB\u6DFA\u8272\u6A21\u5F0F" : "\u5207\u63DB\u6DF1\u8272\u6A21\u5F0F",
+            children: theme === "dark" ? /* @__PURE__ */ jsx11(Moon, { className: ICON_SIZE }) : /* @__PURE__ */ jsx11(Sun, { className: ICON_SIZE })
+          },
+          "themeToggle"
+        ) : null;
+      default:
+        return null;
+    }
+  };
+  return /* @__PURE__ */ jsx11("div", { className: "flex items-center justify-center mb-2 relative", children: /* @__PURE__ */ jsxs6("div", { className: "flex items-center justify-between px-2 py-1.5 bg-white dark:bg-zinc-900 rounded-lg shadow-sm w-full max-w-7xl mx-auto", children: [
+    /* @__PURE__ */ jsxs6("div", { className: "flex items-center gap-0.5", children: [
+      /* @__PURE__ */ jsx11(
+        "input",
+        {
+          ref: fileInputRef,
+          type: "file",
+          accept: "image/*",
+          className: "hidden",
+          onChange: handleImageUpload,
+          "aria-label": "\u4E0A\u50B3\u5716\u7247"
+        }
+      ),
+      toolbarStart,
+      groups.map((group, groupIndex) => /* @__PURE__ */ jsxs6("div", { className: "flex items-center gap-0.5", children: [
+        groupIndex > 0 && /* @__PURE__ */ jsx11(ToolbarDivider, {}),
+        group.map((item) => renderToolbarItem(item))
+      ] }, groupIndex))
+    ] }),
+    /* @__PURE__ */ jsx11("div", { className: "flex items-center gap-0.5", children: toolbarEnd })
+  ] }) });
+}
+
+// src/EliaEditor.tsx
+import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
+function EliaEditor({
+  content = "",
+  onChange,
+  placeholder = "\u958B\u59CB\u5BEB\u4F5C...",
+  toolbar = "all",
+  header,
+  toolbarStart,
+  toolbarEnd,
+  footer,
+  className,
+  editorClassName,
+  autofocus = false,
+  readOnly = false,
+  theme,
+  onThemeToggle,
+  onImageUpload
+}) {
+  const isInternalUpdate = useRef2(false);
+  const handleUpdate = useCallback(
+    ({ editor: editor2 }) => {
+      isInternalUpdate.current = true;
+      onChange?.(editor2.getHTML());
+    },
+    [onChange]
+  );
+  const editor = useEditor({
+    extensions: [
+      StarterKit.configure({
+        heading: {
+          levels: [1, 2, 3]
+        }
+      }),
+      Placeholder.configure({
+        placeholder
+      }),
+      Underline,
+      TextAlign.configure({
+        types: ["heading", "paragraph"]
+      }),
+      Link.configure({
+        openOnClick: false,
+        HTMLAttributes: {
+          class: "text-primary underline underline-offset-4"
+        }
+      }),
+      TextStyle,
+      Color,
+      Highlight.configure({
+        multicolor: true
+      }),
+      Subscript,
+      Superscript,
+      TaskList,
+      TaskItem.configure({
+        nested: true
+      }),
+      Table.configure({
+        resizable: true
+      }),
+      TableRow,
+      TableHeader,
+      TableCell,
+      ImageResize.configure({
+        allowBase64: true
+      }),
+      Callout
+    ],
+    content,
+    autofocus,
+    editable: !readOnly,
+    editorProps: {
+      attributes: {
+        class: cn(
+          "tiptap-editor min-h-[300px] p-4 focus:outline-none",
+          editorClassName
+        )
+      }
+    },
+    onUpdate: handleUpdate
+  });
+  useEffect(() => {
+    if (editor && !isInternalUpdate.current && content !== editor.getHTML()) {
+      editor.commands.setContent(content);
+    }
+    isInternalUpdate.current = false;
+  }, [content, editor]);
+  useEffect(() => {
+    if (editor) {
+      editor.setEditable(!readOnly);
+    }
+  }, [readOnly, editor]);
+  return /* @__PURE__ */ jsxs7("div", { className: cn("elia-editor", className), children: [
+    header && /* @__PURE__ */ jsx12("div", { className: "elia-editor-header", children: header }),
+    /* @__PURE__ */ jsx12(
+      Toolbar,
+      {
+        editor,
+        config: toolbar,
+        toolbarStart,
+        toolbarEnd,
+        theme,
+        onThemeToggle,
+        onImageUpload
+      }
+    ),
+    /* @__PURE__ */ jsx12(EditorContent, { editor }),
+    footer && /* @__PURE__ */ jsx12("div", { className: "elia-editor-footer", children: footer })
+  ] });
+}
+export {
+  Button,
+  Callout,
+  CalloutDropdown,
+  ColorPicker,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+  EliaEditor,
+  HeadingDropdown,
+  ListDropdown,
+  TableDropdown,
+  Toggle,
+  Toolbar,
+  ToolbarButton,
+  ToolbarDivider,
+  cn
+};
+//# sourceMappingURL=index.js.map