rte-builder 1.0.0 → 2.0.2

package/dist/index.js

@@ -34,2151 +34,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// node_modules/@tiptap/core/dist/index.js
-function createChainableState(config) {
-  const { state, transaction } = config;
-  let { selection } = transaction;
-  let { doc } = transaction;
-  let { storedMarks } = transaction;
-  return {
-    ...state,
-    apply: state.apply.bind(state),
-    applyTransaction: state.applyTransaction.bind(state),
-    plugins: state.plugins,
-    schema: state.schema,
-    reconfigure: state.reconfigure.bind(state),
-    toJSON: state.toJSON.bind(state),
-    get storedMarks() {
-      return storedMarks;
-    },
-    get selection() {
-      return selection;
-    },
-    get doc() {
-      return doc;
-    },
-    get tr() {
-      selection = transaction.selection;
-      doc = transaction.doc;
-      storedMarks = transaction.storedMarks;
-      return transaction;
-    }
-  };
-}
-function getExtensionField(extension, field, context) {
-  if (extension.config[field] === void 0 && extension.parent) {
-    return getExtensionField(extension.parent, field, context);
-  }
-  if (typeof extension.config[field] === "function") {
-    const value = extension.config[field].bind({
-      ...context,
-      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null
-    });
-    return value;
-  }
-  return extension.config[field];
-}
-function splitExtensions(extensions) {
-  const baseExtensions = extensions.filter((extension) => extension.type === "extension");
-  const nodeExtensions = extensions.filter((extension) => extension.type === "node");
-  const markExtensions = extensions.filter((extension) => extension.type === "mark");
-  return {
-    baseExtensions,
-    nodeExtensions,
-    markExtensions
-  };
-}
-function getNodeType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.nodes[nameOrType]) {
-      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.nodes[nameOrType];
-  }
-  return nameOrType;
-}
-function mergeAttributes(...objects) {
-  return objects.filter((item) => !!item).reduce((items, item) => {
-    const mergedAttributes = { ...items };
-    Object.entries(item).forEach(([key, value]) => {
-      const exists = mergedAttributes[key];
-      if (!exists) {
-        mergedAttributes[key] = value;
-        return;
-      }
-      if (key === "class") {
-        const valueClasses = value ? String(value).split(" ") : [];
-        const existingClasses = mergedAttributes[key] ? mergedAttributes[key].split(" ") : [];
-        const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
-        mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
-      } else if (key === "style") {
-        const newStyles = value ? value.split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style) => style.trim()).filter(Boolean) : [];
-        const styleMap = /* @__PURE__ */ new Map();
-        existingStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        newStyles.forEach((style) => {
-          const [property, val] = style.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
-      } else {
-        mergedAttributes[key] = value;
-      }
-    });
-    return mergedAttributes;
-  }, {});
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function callOrReturn(value, context = void 0, ...props) {
-  if (isFunction(value)) {
-    if (context) {
-      return value.bind(context)(...props);
-    }
-    return value(...props);
-  }
-  return value;
-}
-function isRegExp(value) {
-  return Object.prototype.toString.call(value) === "[object RegExp]";
-}
-function getType(value) {
-  return Object.prototype.toString.call(value).slice(8, -1);
-}
-function isPlainObject(value) {
-  if (getType(value) !== "Object") {
-    return false;
-  }
-  return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
-}
-function mergeDeep(target, source) {
-  const output = { ...target };
-  if (isPlainObject(target) && isPlainObject(source)) {
-    Object.keys(source).forEach((key) => {
-      if (isPlainObject(source[key]) && isPlainObject(target[key])) {
-        output[key] = mergeDeep(target[key], source[key]);
-      } else {
-        output[key] = source[key];
-      }
-    });
-  }
-  return output;
-}
-function getTextBetween(startNode, range, options) {
-  const { from, to } = range;
-  const { blockSeparator = "\n\n", textSerializers = {} } = options || {};
-  let text = "";
-  startNode.nodesBetween(from, to, (node, pos, parent, index) => {
-    var _a;
-    if (node.isBlock && pos > from) {
-      text += blockSeparator;
-    }
-    const textSerializer = textSerializers === null || textSerializers === void 0 ? void 0 : textSerializers[node.type.name];
-    if (textSerializer) {
-      if (parent) {
-        text += textSerializer({
-          node,
-          pos,
-          parent,
-          index,
-          range
-        });
-      }
-      return false;
-    }
-    if (node.isText) {
-      text += (_a = node === null || node === void 0 ? void 0 : node.text) === null || _a === void 0 ? void 0 : _a.slice(Math.max(from, pos) - pos, to - pos);
-    }
-  });
-  return text;
-}
-function getTextSerializersFromSchema(schema) {
-  return Object.fromEntries(Object.entries(schema.nodes).filter(([, node]) => node.spec.toText).map(([name, node]) => [name, node.spec.toText]));
-}
-function objectIncludes(object1, object2, options = { strict: true }) {
-  const keys = Object.keys(object2);
-  if (!keys.length) {
-    return true;
-  }
-  return keys.every((key) => {
-    if (options.strict) {
-      return object2[key] === object1[key];
-    }
-    if (isRegExp(object2[key])) {
-      return object2[key].test(object1[key]);
-    }
-    return object2[key] === object1[key];
-  });
-}
-function findMarkInSet(marks, type, attributes = {}) {
-  return marks.find((item) => {
-    return item.type === type && objectIncludes(
-      // Only check equality for the attributes that are provided
-      Object.fromEntries(Object.keys(attributes).map((k) => [k, item.attrs[k]])),
-      attributes
-    );
-  });
-}
-function isMarkInSet(marks, type, attributes = {}) {
-  return !!findMarkInSet(marks, type, attributes);
-}
-function getMarkRange($pos, type, attributes) {
-  var _a;
-  if (!$pos || !type) {
-    return;
-  }
-  let start = $pos.parent.childAfter($pos.parentOffset);
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    start = $pos.parent.childBefore($pos.parentOffset);
-  }
-  if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
-    return;
-  }
-  attributes = attributes || ((_a = start.node.marks[0]) === null || _a === void 0 ? void 0 : _a.attrs);
-  const mark = findMarkInSet([...start.node.marks], type, attributes);
-  if (!mark) {
-    return;
-  }
-  let startIndex = start.index;
-  let startPos = $pos.start() + start.offset;
-  let endIndex = startIndex + 1;
-  let endPos = startPos + start.node.nodeSize;
-  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
-    startIndex -= 1;
-    startPos -= $pos.parent.child(startIndex).nodeSize;
-  }
-  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
-    endPos += $pos.parent.child(endIndex).nodeSize;
-    endIndex += 1;
-  }
-  return {
-    from: startPos,
-    to: endPos
-  };
-}
-function getMarkType(nameOrType, schema) {
-  if (typeof nameOrType === "string") {
-    if (!schema.marks[nameOrType]) {
-      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`);
-    }
-    return schema.marks[nameOrType];
-  }
-  return nameOrType;
-}
-function isTextSelection(value) {
-  return value instanceof import_state.TextSelection;
-}
-function minMax(value = 0, min = 0, max = 0) {
-  return Math.min(Math.max(value, min), max);
-}
-function resolveFocusPosition(doc, position = null) {
-  if (!position) {
-    return null;
-  }
-  const selectionAtStart = import_state.Selection.atStart(doc);
-  const selectionAtEnd = import_state.Selection.atEnd(doc);
-  if (position === "start" || position === true) {
-    return selectionAtStart;
-  }
-  if (position === "end") {
-    return selectionAtEnd;
-  }
-  const minPos = selectionAtStart.from;
-  const maxPos = selectionAtEnd.to;
-  if (position === "all") {
-    return import_state.TextSelection.create(doc, minMax(0, minPos, maxPos), minMax(doc.content.size, minPos, maxPos));
-  }
-  return import_state.TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
-}
-function isAndroid() {
-  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
-}
-function isiOS() {
-  return [
-    "iPad Simulator",
-    "iPhone Simulator",
-    "iPod Simulator",
-    "iPad",
-    "iPhone",
-    "iPod"
-  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
-}
-function isSafari() {
-  return typeof navigator !== "undefined" ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : false;
-}
-function elementFromString(value) {
-  const wrappedValue = `<body>${value}</body>`;
-  const html = new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
-  return removeWhitespaces(html);
-}
-function createNodeFromContent(content, schema, options) {
-  if (content instanceof import_model.Node || content instanceof import_model.Fragment) {
-    return content;
-  }
-  options = {
-    slice: true,
-    parseOptions: {},
-    ...options
-  };
-  const isJSONContent = typeof content === "object" && content !== null;
-  const isTextContent = typeof content === "string";
-  if (isJSONContent) {
-    try {
-      const isArrayContent = Array.isArray(content) && content.length > 0;
-      if (isArrayContent) {
-        return import_model.Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
-      }
-      const node = schema.nodeFromJSON(content);
-      if (options.errorOnInvalidContent) {
-        node.check();
-      }
-      return node;
-    } catch (error) {
-      if (options.errorOnInvalidContent) {
-        throw new Error("[tiptap error]: Invalid JSON content", { cause: error });
-      }
-      console.warn("[tiptap warn]: Invalid content.", "Passed value:", content, "Error:", error);
-      return createNodeFromContent("", schema, options);
-    }
-  }
-  if (isTextContent) {
-    if (options.errorOnInvalidContent) {
-      let hasInvalidContent = false;
-      let invalidContent = "";
-      const contentCheckSchema = new import_model.Schema({
-        topNode: schema.spec.topNode,
-        marks: schema.spec.marks,
-        // Prosemirror's schemas are executed such that: the last to execute, matches last
-        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
-        nodes: schema.spec.nodes.append({
-          __tiptap__private__unknown__catch__all__node: {
-            content: "inline*",
-            group: "block",
-            parseDOM: [
-              {
-                tag: "*",
-                getAttrs: (e) => {
-                  hasInvalidContent = true;
-                  invalidContent = typeof e === "string" ? e : e.outerHTML;
-                  return null;
-                }
-              }
-            ]
-          }
-        })
-      });
-      if (options.slice) {
-        import_model.DOMParser.fromSchema(contentCheckSchema).parseSlice(elementFromString(content), options.parseOptions);
-      } else {
-        import_model.DOMParser.fromSchema(contentCheckSchema).parse(elementFromString(content), options.parseOptions);
-      }
-      if (options.errorOnInvalidContent && hasInvalidContent) {
-        throw new Error("[tiptap error]: Invalid HTML content", { cause: new Error(`Invalid element found: ${invalidContent}`) });
-      }
-    }
-    const parser = import_model.DOMParser.fromSchema(schema);
-    if (options.slice) {
-      return parser.parseSlice(elementFromString(content), options.parseOptions).content;
-    }
-    return parser.parse(elementFromString(content), options.parseOptions);
-  }
-  return createNodeFromContent("", schema, options);
-}
-function selectionToInsertionEnd(tr, startLen, bias) {
-  const last = tr.steps.length - 1;
-  if (last < startLen) {
-    return;
-  }
-  const step = tr.steps[last];
-  if (!(step instanceof import_transform.ReplaceStep || step instanceof import_transform.ReplaceAroundStep)) {
-    return;
-  }
-  const map = tr.mapping.maps[last];
-  let end = 0;
-  map.forEach((_from, _to, _newFrom, newTo) => {
-    if (end === 0) {
-      end = newTo;
-    }
-  });
-  tr.setSelection(import_state.Selection.near(tr.doc.resolve(end), bias));
-}
-function isMacOS() {
-  return typeof navigator !== "undefined" ? /Mac/.test(navigator.platform) : false;
-}
-function normalizeKeyName(name) {
-  const parts = name.split(/-(?!$)/);
-  let result = parts[parts.length - 1];
-  if (result === "Space") {
-    result = " ";
-  }
-  let alt;
-  let ctrl;
-  let shift;
-  let meta;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    const mod = parts[i];
-    if (/^(cmd|meta|m)$/i.test(mod)) {
-      meta = true;
-    } else if (/^a(lt)?$/i.test(mod)) {
-      alt = true;
-    } else if (/^(c|ctrl|control)$/i.test(mod)) {
-      ctrl = true;
-    } else if (/^s(hift)?$/i.test(mod)) {
-      shift = true;
-    } else if (/^mod$/i.test(mod)) {
-      if (isiOS() || isMacOS()) {
-        meta = true;
-      } else {
-        ctrl = true;
-      }
-    } else {
-      throw new Error(`Unrecognized modifier name: ${mod}`);
-    }
-  }
-  if (alt) {
-    result = `Alt-${result}`;
-  }
-  if (ctrl) {
-    result = `Ctrl-${result}`;
-  }
-  if (meta) {
-    result = `Meta-${result}`;
-  }
-  if (shift) {
-    result = `Shift-${result}`;
-  }
-  return result;
-}
-function isNodeActive(state, typeOrName, attributes = {}) {
-  const { from, to, empty } = state.selection;
-  const type = typeOrName ? getNodeType(typeOrName, state.schema) : null;
-  const nodeRanges = [];
-  state.doc.nodesBetween(from, to, (node, pos) => {
-    if (node.isText) {
-      return;
-    }
-    const relativeFrom = Math.max(from, pos);
-    const relativeTo = Math.min(to, pos + node.nodeSize);
-    nodeRanges.push({
-      node,
-      from: relativeFrom,
-      to: relativeTo
-    });
-  });
-  const selectionRange = to - from;
-  const matchedNodeRanges = nodeRanges.filter((nodeRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === nodeRange.node.type.name;
-  }).filter((nodeRange) => objectIncludes(nodeRange.node.attrs, attributes, { strict: false }));
-  if (empty) {
-    return !!matchedNodeRanges.length;
-  }
-  const range = matchedNodeRanges.reduce((sum, nodeRange) => sum + nodeRange.to - nodeRange.from, 0);
-  return range >= selectionRange;
-}
-function getSchemaTypeNameByName(name, schema) {
-  if (schema.nodes[name]) {
-    return "node";
-  }
-  if (schema.marks[name]) {
-    return "mark";
-  }
-  return null;
-}
-function deleteProps(obj, propOrProps) {
-  const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
-  return Object.keys(obj).reduce((newObj, prop) => {
-    if (!props.includes(prop)) {
-      newObj[prop] = obj[prop];
-    }
-    return newObj;
-  }, {});
-}
-function createDocument(content, schema, parseOptions = {}, options = {}) {
-  return createNodeFromContent(content, schema, {
-    slice: false,
-    parseOptions,
-    errorOnInvalidContent: options.errorOnInvalidContent
-  });
-}
-function getMarkAttributes(state, typeOrName) {
-  const type = getMarkType(typeOrName, state.schema);
-  const { from, to, empty } = state.selection;
-  const marks = [];
-  if (empty) {
-    if (state.storedMarks) {
-      marks.push(...state.storedMarks);
-    }
-    marks.push(...state.selection.$head.marks());
-  } else {
-    state.doc.nodesBetween(from, to, (node) => {
-      marks.push(...node.marks);
-    });
-  }
-  const mark = marks.find((markItem) => markItem.type.name === type.name);
-  if (!mark) {
-    return {};
-  }
-  return { ...mark.attrs };
-}
-function defaultBlockAt(match) {
-  for (let i = 0; i < match.edgeCount; i += 1) {
-    const { type } = match.edge(i);
-    if (type.isTextblock && !type.hasRequiredAttrs()) {
-      return type;
-    }
-  }
-  return null;
-}
-function findParentNodeClosestToPos($pos, predicate) {
-  for (let i = $pos.depth; i > 0; i -= 1) {
-    const node = $pos.node(i);
-    if (predicate(node)) {
-      return {
-        pos: i > 0 ? $pos.before(i) : 0,
-        start: $pos.start(i),
-        depth: i,
-        node
-      };
-    }
-  }
-}
-function findParentNode(predicate) {
-  return (selection) => findParentNodeClosestToPos(selection.$from, predicate);
-}
-function getSplittedAttributes(extensionAttributes, typeName, attributes) {
-  return Object.fromEntries(Object.entries(attributes).filter(([name]) => {
-    const extensionAttribute = extensionAttributes.find((item) => {
-      return item.type === typeName && item.name === name;
-    });
-    if (!extensionAttribute) {
-      return false;
-    }
-    return extensionAttribute.attribute.keepOnSplit;
-  }));
-}
-function isMarkActive(state, typeOrName, attributes = {}) {
-  const { empty, ranges } = state.selection;
-  const type = typeOrName ? getMarkType(typeOrName, state.schema) : null;
-  if (empty) {
-    return !!(state.storedMarks || state.selection.$from.marks()).filter((mark) => {
-      if (!type) {
-        return true;
-      }
-      return type.name === mark.type.name;
-    }).find((mark) => objectIncludes(mark.attrs, attributes, { strict: false }));
-  }
-  let selectionRange = 0;
-  const markRanges = [];
-  ranges.forEach(({ $from, $to }) => {
-    const from = $from.pos;
-    const to = $to.pos;
-    state.doc.nodesBetween(from, to, (node, pos) => {
-      if (!node.isText && !node.marks.length) {
-        return;
-      }
-      const relativeFrom = Math.max(from, pos);
-      const relativeTo = Math.min(to, pos + node.nodeSize);
-      const range2 = relativeTo - relativeFrom;
-      selectionRange += range2;
-      markRanges.push(...node.marks.map((mark) => ({
-        mark,
-        from: relativeFrom,
-        to: relativeTo
-      })));
-    });
-  });
-  if (selectionRange === 0) {
-    return false;
-  }
-  const matchedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return type.name === markRange.mark.type.name;
-  }).filter((markRange) => objectIncludes(markRange.mark.attrs, attributes, { strict: false })).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const excludedRange = markRanges.filter((markRange) => {
-    if (!type) {
-      return true;
-    }
-    return markRange.mark.type !== type && markRange.mark.type.excludes(type);
-  }).reduce((sum, markRange) => sum + markRange.to - markRange.from, 0);
-  const range = matchedRange > 0 ? matchedRange + excludedRange : matchedRange;
-  return range >= selectionRange;
-}
-function isList(name, extensions) {
-  const { nodeExtensions } = splitExtensions(extensions);
-  const extension = nodeExtensions.find((item) => item.name === name);
-  if (!extension) {
-    return false;
-  }
-  const context = {
-    name: extension.name,
-    options: extension.options,
-    storage: extension.storage
-  };
-  const group = callOrReturn(getExtensionField(extension, "group", context));
-  if (typeof group !== "string") {
-    return false;
-  }
-  return group.split(" ").includes("list");
-}
-function isNodeEmpty(node, { checkChildren = true, ignoreWhitespace = false } = {}) {
-  var _a;
-  if (ignoreWhitespace) {
-    if (node.type.name === "hardBreak") {
-      return true;
-    }
-    if (node.isText) {
-      return /^\s*$/m.test((_a = node.text) !== null && _a !== void 0 ? _a : "");
-    }
-  }
-  if (node.isText) {
-    return !node.text;
-  }
-  if (node.isAtom || node.isLeaf) {
-    return false;
-  }
-  if (node.content.childCount === 0) {
-    return true;
-  }
-  if (checkChildren) {
-    let isContentEmpty = true;
-    node.content.forEach((childNode) => {
-      if (isContentEmpty === false) {
-        return;
-      }
-      if (!isNodeEmpty(childNode, { ignoreWhitespace, checkChildren })) {
-        isContentEmpty = false;
-      }
-    });
-    return isContentEmpty;
-  }
-  return false;
-}
-function canSetMark(state, tr, newMarkType) {
-  var _a;
-  const { selection } = tr;
-  let cursor = null;
-  if (isTextSelection(selection)) {
-    cursor = selection.$cursor;
-  }
-  if (cursor) {
-    const currentMarks = (_a = state.storedMarks) !== null && _a !== void 0 ? _a : cursor.marks();
-    return !!newMarkType.isInSet(currentMarks) || !currentMarks.some((mark) => mark.type.excludes(newMarkType));
-  }
-  const { ranges } = selection;
-  return ranges.some(({ $from, $to }) => {
-    let someNodeSupportsMark = $from.depth === 0 ? state.doc.inlineContent && state.doc.type.allowsMarkType(newMarkType) : false;
-    state.doc.nodesBetween($from.pos, $to.pos, (node, _pos, parent) => {
-      if (someNodeSupportsMark) {
-        return false;
-      }
-      if (node.isInline) {
-        const parentAllowsMarkType = !parent || parent.type.allowsMarkType(newMarkType);
-        const currentMarksAllowMarkType = !!newMarkType.isInSet(node.marks) || !node.marks.some((otherMark) => otherMark.type.excludes(newMarkType));
-        someNodeSupportsMark = parentAllowsMarkType && currentMarksAllowMarkType;
-      }
-      return !someNodeSupportsMark;
-    });
-    return someNodeSupportsMark;
-  });
-}
-function ensureMarks(state, splittableMarks) {
-  const marks = state.storedMarks || state.selection.$to.parentOffset && state.selection.$from.marks();
-  if (marks) {
-    const filteredMarks = marks.filter((mark) => splittableMarks === null || splittableMarks === void 0 ? void 0 : splittableMarks.includes(mark.type.name));
-    state.tr.ensureMarks(filteredMarks);
-  }
-}
-var import_state, import_view, import_keymap, import_model, import_transform, import_commands, import_schema_list, CommandManager, Extension, ClipboardTextSerializer, blur, clearContent, clearNodes, command, createParagraphNear, cut, deleteCurrentNode, deleteNode, deleteRange, deleteSelection, enter, exitCode, extendMarkRange, first, focus, forEach, insertContent, removeWhitespaces, isFragment, insertContentAt, joinUp, joinDown, joinBackward, joinForward, joinItemBackward, joinItemForward, joinTextblockBackward, joinTextblockForward, keyboardShortcut, lift, liftEmptyBlock, liftListItem, newlineInCode, resetAttributes, scrollIntoView, selectAll, selectNodeBackward, selectNodeForward, selectParentNode, selectTextblockEnd, selectTextblockStart, setContent, setMark, setMeta, setNode, setNodeSelection, setTextSelection, sinkListItem, splitBlock, splitListItem, joinListBackwards, joinListForwards, toggleList, toggleMark, toggleNode, toggleWrap, undoInputRule, unsetAllMarks, unsetMark, updateAttributes, wrapIn, wrapInList, commands, Commands, Drop, Editable, focusEventsPluginKey, FocusEvents, Keymap, Paste, Tabindex, Node;
-var init_dist = __esm({
-  "node_modules/@tiptap/core/dist/index.js"() {
-    "use strict";
-    import_state = require("@tiptap/pm/state");
-    import_view = require("@tiptap/pm/view");
-    import_keymap = require("@tiptap/pm/keymap");
-    import_model = require("@tiptap/pm/model");
-    import_transform = require("@tiptap/pm/transform");
-    import_commands = require("@tiptap/pm/commands");
-    import_schema_list = require("@tiptap/pm/schema-list");
-    CommandManager = class {
-      constructor(props) {
-        this.editor = props.editor;
-        this.rawCommands = this.editor.extensionManager.commands;
-        this.customState = props.state;
-      }
-      get hasCustomState() {
-        return !!this.customState;
-      }
-      get state() {
-        return this.customState || this.editor.state;
-      }
-      get commands() {
-        const { rawCommands, editor, state } = this;
-        const { view } = editor;
-        const { tr } = state;
-        const props = this.buildProps(tr);
-        return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-          const method = (...args) => {
-            const callback = command2(...args)(props);
-            if (!tr.getMeta("preventDispatch") && !this.hasCustomState) {
-              view.dispatch(tr);
-            }
-            return callback;
-          };
-          return [name, method];
-        }));
-      }
-      get chain() {
-        return () => this.createChain();
-      }
-      get can() {
-        return () => this.createCan();
-      }
-      createChain(startTr, shouldDispatch = true) {
-        const { rawCommands, editor, state } = this;
-        const { view } = editor;
-        const callbacks = [];
-        const hasStartTransaction = !!startTr;
-        const tr = startTr || state.tr;
-        const run = () => {
-          if (!hasStartTransaction && shouldDispatch && !tr.getMeta("preventDispatch") && !this.hasCustomState) {
-            view.dispatch(tr);
-          }
-          return callbacks.every((callback) => callback === true);
-        };
-        const chain = {
-          ...Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-            const chainedCommand = (...args) => {
-              const props = this.buildProps(tr, shouldDispatch);
-              const callback = command2(...args)(props);
-              callbacks.push(callback);
-              return chain;
-            };
-            return [name, chainedCommand];
-          })),
-          run
-        };
-        return chain;
-      }
-      createCan(startTr) {
-        const { rawCommands, state } = this;
-        const dispatch = false;
-        const tr = startTr || state.tr;
-        const props = this.buildProps(tr, dispatch);
-        const formattedCommands = Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-          return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
-        }));
-        return {
-          ...formattedCommands,
-          chain: () => this.createChain(tr, dispatch)
-        };
-      }
-      buildProps(tr, shouldDispatch = true) {
-        const { rawCommands, editor, state } = this;
-        const { view } = editor;
-        const props = {
-          tr,
-          editor,
-          view,
-          state: createChainableState({
-            state,
-            transaction: tr
-          }),
-          dispatch: shouldDispatch ? () => void 0 : void 0,
-          chain: () => this.createChain(tr, shouldDispatch),
-          can: () => this.createCan(tr),
-          get commands() {
-            return Object.fromEntries(Object.entries(rawCommands).map(([name, command2]) => {
-              return [name, (...args) => command2(...args)(props)];
-            }));
-          }
-        };
-        return props;
-      }
-    };
-    Extension = class _Extension {
-      constructor(config = {}) {
-        this.type = "extension";
-        this.name = "extension";
-        this.parent = null;
-        this.child = null;
-        this.config = {
-          name: this.name,
-          defaultOptions: {}
-        };
-        this.config = {
-          ...this.config,
-          ...config
-        };
-        this.name = this.config.name;
-        if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-          console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-        }
-        this.options = this.config.defaultOptions;
-        if (this.config.addOptions) {
-          this.options = callOrReturn(getExtensionField(this, "addOptions", {
-            name: this.name
-          }));
-        }
-        this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-          name: this.name,
-          options: this.options
-        })) || {};
-      }
-      static create(config = {}) {
-        return new _Extension(config);
-      }
-      configure(options = {}) {
-        const extension = this.extend({
-          ...this.config,
-          addOptions: () => {
-            return mergeDeep(this.options, options);
-          }
-        });
-        extension.name = this.name;
-        extension.parent = this.parent;
-        return extension;
-      }
-      extend(extendedConfig = {}) {
-        const extension = new _Extension({ ...this.config, ...extendedConfig });
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-        if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-          console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-        }
-        extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-          name: extension.name
-        }));
-        extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-          name: extension.name,
-          options: extension.options
-        }));
-        return extension;
-      }
-    };
-    ClipboardTextSerializer = Extension.create({
-      name: "clipboardTextSerializer",
-      addOptions() {
-        return {
-          blockSeparator: void 0
-        };
-      },
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("clipboardTextSerializer"),
-            props: {
-              clipboardTextSerializer: () => {
-                const { editor } = this;
-                const { state, schema } = editor;
-                const { doc, selection } = state;
-                const { ranges } = selection;
-                const from = Math.min(...ranges.map((range2) => range2.$from.pos));
-                const to = Math.max(...ranges.map((range2) => range2.$to.pos));
-                const textSerializers = getTextSerializersFromSchema(schema);
-                const range = { from, to };
-                return getTextBetween(doc, range, {
-                  ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
-                  textSerializers
-                });
-              }
-            }
-          })
-        ];
-      }
-    });
-    blur = () => ({ editor, view }) => {
-      requestAnimationFrame(() => {
-        var _a;
-        if (!editor.isDestroyed) {
-          view.dom.blur();
-          (_a = window === null || window === void 0 ? void 0 : window.getSelection()) === null || _a === void 0 ? void 0 : _a.removeAllRanges();
-        }
-      });
-      return true;
-    };
-    clearContent = (emitUpdate = false) => ({ commands: commands2 }) => {
-      return commands2.setContent("", emitUpdate);
-    };
-    clearNodes = () => ({ state, tr, dispatch }) => {
-      const { selection } = tr;
-      const { ranges } = selection;
-      if (!dispatch) {
-        return true;
-      }
-      ranges.forEach(({ $from, $to }) => {
-        state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
-          if (node.type.isText) {
-            return;
-          }
-          const { doc, mapping } = tr;
-          const $mappedFrom = doc.resolve(mapping.map(pos));
-          const $mappedTo = doc.resolve(mapping.map(pos + node.nodeSize));
-          const nodeRange = $mappedFrom.blockRange($mappedTo);
-          if (!nodeRange) {
-            return;
-          }
-          const targetLiftDepth = (0, import_transform.liftTarget)(nodeRange);
-          if (node.type.isTextblock) {
-            const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
-            tr.setNodeMarkup(nodeRange.start, defaultType);
-          }
-          if (targetLiftDepth || targetLiftDepth === 0) {
-            tr.lift(nodeRange, targetLiftDepth);
-          }
-        });
-      });
-      return true;
-    };
-    command = (fn) => (props) => {
-      return fn(props);
-    };
-    createParagraphNear = () => ({ state, dispatch }) => {
-      return (0, import_commands.createParagraphNear)(state, dispatch);
-    };
-    cut = (originRange, targetPos) => ({ editor, tr }) => {
-      const { state } = editor;
-      const contentSlice = state.doc.slice(originRange.from, originRange.to);
-      tr.deleteRange(originRange.from, originRange.to);
-      const newPos = tr.mapping.map(targetPos);
-      tr.insert(newPos, contentSlice.content);
-      tr.setSelection(new import_state.TextSelection(tr.doc.resolve(Math.max(newPos - 1, 0))));
-      return true;
-    };
-    deleteCurrentNode = () => ({ tr, dispatch }) => {
-      const { selection } = tr;
-      const currentNode = selection.$anchor.node();
-      if (currentNode.content.size > 0) {
-        return false;
-      }
-      const $pos = tr.selection.$anchor;
-      for (let depth = $pos.depth; depth > 0; depth -= 1) {
-        const node = $pos.node(depth);
-        if (node.type === currentNode.type) {
-          if (dispatch) {
-            const from = $pos.before(depth);
-            const to = $pos.after(depth);
-            tr.delete(from, to).scrollIntoView();
-          }
-          return true;
-        }
-      }
-      return false;
-    };
-    deleteNode = (typeOrName) => ({ tr, state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const $pos = tr.selection.$anchor;
-      for (let depth = $pos.depth; depth > 0; depth -= 1) {
-        const node = $pos.node(depth);
-        if (node.type === type) {
-          if (dispatch) {
-            const from = $pos.before(depth);
-            const to = $pos.after(depth);
-            tr.delete(from, to).scrollIntoView();
-          }
-          return true;
-        }
-      }
-      return false;
-    };
-    deleteRange = (range) => ({ tr, dispatch }) => {
-      const { from, to } = range;
-      if (dispatch) {
-        tr.delete(from, to);
-      }
-      return true;
-    };
-    deleteSelection = () => ({ state, dispatch }) => {
-      return (0, import_commands.deleteSelection)(state, dispatch);
-    };
-    enter = () => ({ commands: commands2 }) => {
-      return commands2.keyboardShortcut("Enter");
-    };
-    exitCode = () => ({ state, dispatch }) => {
-      return (0, import_commands.exitCode)(state, dispatch);
-    };
-    extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      const type = getMarkType(typeOrName, state.schema);
-      const { doc, selection } = tr;
-      const { $from, from, to } = selection;
-      if (dispatch) {
-        const range = getMarkRange($from, type, attributes);
-        if (range && range.from <= from && range.to >= to) {
-          const newSelection = import_state.TextSelection.create(doc, range.from, range.to);
-          tr.setSelection(newSelection);
-        }
-      }
-      return true;
-    };
-    first = (commands2) => (props) => {
-      const items = typeof commands2 === "function" ? commands2(props) : commands2;
-      for (let i = 0; i < items.length; i += 1) {
-        if (items[i](props)) {
-          return true;
-        }
-      }
-      return false;
-    };
-    focus = (position = null, options = {}) => ({ editor, view, tr, dispatch }) => {
-      options = {
-        scrollIntoView: true,
-        ...options
-      };
-      const delayedFocus = () => {
-        if (isiOS() || isAndroid()) {
-          view.dom.focus();
-        }
-        requestAnimationFrame(() => {
-          if (!editor.isDestroyed) {
-            view.focus();
-            if (isSafari() && !isiOS() && !isAndroid()) {
-              view.dom.focus({ preventScroll: true });
-            }
-          }
-        });
-      };
-      if (view.hasFocus() && position === null || position === false) {
-        return true;
-      }
-      if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
-        delayedFocus();
-        return true;
-      }
-      const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection;
-      const isSameSelection = editor.state.selection.eq(selection);
-      if (dispatch) {
-        if (!isSameSelection) {
-          tr.setSelection(selection);
-        }
-        if (isSameSelection && tr.storedMarks) {
-          tr.setStoredMarks(tr.storedMarks);
-        }
-        delayedFocus();
-      }
-      return true;
-    };
-    forEach = (items, fn) => (props) => {
-      return items.every((item, index) => fn(item, { ...props, index }));
-    };
-    insertContent = (value, options) => ({ tr, commands: commands2 }) => {
-      return commands2.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options);
-    };
-    removeWhitespaces = (node) => {
-      const children = node.childNodes;
-      for (let i = children.length - 1; i >= 0; i -= 1) {
-        const child = children[i];
-        if (child.nodeType === 3 && child.nodeValue && /^(\n\s\s|\n)$/.test(child.nodeValue)) {
-          node.removeChild(child);
-        } else if (child.nodeType === 1) {
-          removeWhitespaces(child);
-        }
-      }
-      return node;
-    };
-    isFragment = (nodeOrFragment) => {
-      return !("type" in nodeOrFragment);
-    };
-    insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) => {
-      var _a;
-      if (dispatch) {
-        options = {
-          parseOptions: editor.options.parseOptions,
-          updateSelection: true,
-          applyInputRules: false,
-          applyPasteRules: false,
-          ...options
-        };
-        let content;
-        const emitContentError = (error) => {
-          editor.emit("contentError", {
-            editor,
-            error,
-            disableCollaboration: () => {
-              if (editor.storage.collaboration) {
-                editor.storage.collaboration.isDisabled = true;
-              }
-            }
-          });
-        };
-        const parseOptions = {
-          preserveWhitespace: "full",
-          ...options.parseOptions
-        };
-        if (!options.errorOnInvalidContent && !editor.options.enableContentCheck && editor.options.emitContentError) {
-          try {
-            createNodeFromContent(value, editor.schema, {
-              parseOptions,
-              errorOnInvalidContent: true
-            });
-          } catch (e) {
-            emitContentError(e);
-          }
-        }
-        try {
-          content = createNodeFromContent(value, editor.schema, {
-            parseOptions,
-            errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-          });
-        } catch (e) {
-          emitContentError(e);
-          return false;
-        }
-        let { from, to } = typeof position === "number" ? { from: position, to: position } : { from: position.from, to: position.to };
-        let isOnlyTextContent = true;
-        let isOnlyBlockContent = true;
-        const nodes = isFragment(content) ? content : [content];
-        nodes.forEach((node) => {
-          node.check();
-          isOnlyTextContent = isOnlyTextContent ? node.isText && node.marks.length === 0 : false;
-          isOnlyBlockContent = isOnlyBlockContent ? node.isBlock : false;
-        });
-        if (from === to && isOnlyBlockContent) {
-          const { parent } = tr.doc.resolve(from);
-          const isEmptyTextBlock = parent.isTextblock && !parent.type.spec.code && !parent.childCount;
-          if (isEmptyTextBlock) {
-            from -= 1;
-            to += 1;
-          }
-        }
-        let newContent;
-        if (isOnlyTextContent) {
-          if (Array.isArray(value)) {
-            newContent = value.map((v) => v.text || "").join("");
-          } else if (value instanceof import_model.Fragment) {
-            let text = "";
-            value.forEach((node) => {
-              if (node.text) {
-                text += node.text;
-              }
-            });
-            newContent = text;
-          } else if (typeof value === "object" && !!value && !!value.text) {
-            newContent = value.text;
-          } else {
-            newContent = value;
-          }
-          tr.insertText(newContent, from, to);
-        } else {
-          newContent = content;
-          tr.replaceWith(from, to, newContent);
-        }
-        if (options.updateSelection) {
-          selectionToInsertionEnd(tr, tr.steps.length - 1, -1);
-        }
-        if (options.applyInputRules) {
-          tr.setMeta("applyInputRules", { from, text: newContent });
-        }
-        if (options.applyPasteRules) {
-          tr.setMeta("applyPasteRules", { from, text: newContent });
-        }
-      }
-      return true;
-    };
-    joinUp = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinUp)(state, dispatch);
-    };
-    joinDown = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinDown)(state, dispatch);
-    };
-    joinBackward = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinBackward)(state, dispatch);
-    };
-    joinForward = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinForward)(state, dispatch);
-    };
-    joinItemBackward = () => ({ state, dispatch, tr }) => {
-      try {
-        const point = (0, import_transform.joinPoint)(state.doc, state.selection.$from.pos, -1);
-        if (point === null || point === void 0) {
-          return false;
-        }
-        tr.join(point, 2);
-        if (dispatch) {
-          dispatch(tr);
-        }
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    joinItemForward = () => ({ state, dispatch, tr }) => {
-      try {
-        const point = (0, import_transform.joinPoint)(state.doc, state.selection.$from.pos, 1);
-        if (point === null || point === void 0) {
-          return false;
-        }
-        tr.join(point, 2);
-        if (dispatch) {
-          dispatch(tr);
-        }
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    joinTextblockBackward = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinTextblockBackward)(state, dispatch);
-    };
-    joinTextblockForward = () => ({ state, dispatch }) => {
-      return (0, import_commands.joinTextblockForward)(state, dispatch);
-    };
-    keyboardShortcut = (name) => ({ editor, view, tr, dispatch }) => {
-      const keys = normalizeKeyName(name).split(/-(?!$)/);
-      const key = keys.find((item) => !["Alt", "Ctrl", "Meta", "Shift"].includes(item));
-      const event = new KeyboardEvent("keydown", {
-        key: key === "Space" ? " " : key,
-        altKey: keys.includes("Alt"),
-        ctrlKey: keys.includes("Ctrl"),
-        metaKey: keys.includes("Meta"),
-        shiftKey: keys.includes("Shift"),
-        bubbles: true,
-        cancelable: true
-      });
-      const capturedTransaction = editor.captureTransaction(() => {
-        view.someProp("handleKeyDown", (f) => f(view, event));
-      });
-      capturedTransaction === null || capturedTransaction === void 0 ? void 0 : capturedTransaction.steps.forEach((step) => {
-        const newStep = step.map(tr.mapping);
-        if (newStep && dispatch) {
-          tr.maybeStep(newStep);
-        }
-      });
-      return true;
-    };
-    lift = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      if (!isActive) {
-        return false;
-      }
-      return (0, import_commands.lift)(state, dispatch);
-    };
-    liftEmptyBlock = () => ({ state, dispatch }) => {
-      return (0, import_commands.liftEmptyBlock)(state, dispatch);
-    };
-    liftListItem = (typeOrName) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return (0, import_schema_list.liftListItem)(type)(state, dispatch);
-    };
-    newlineInCode = () => ({ state, dispatch }) => {
-      return (0, import_commands.newlineInCode)(state, dispatch);
-    };
-    resetAttributes = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
-      let nodeType = null;
-      let markType = null;
-      const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-      if (!schemaType) {
-        return false;
-      }
-      if (schemaType === "node") {
-        nodeType = getNodeType(typeOrName, state.schema);
-      }
-      if (schemaType === "mark") {
-        markType = getMarkType(typeOrName, state.schema);
-      }
-      if (dispatch) {
-        tr.selection.ranges.forEach((range) => {
-          state.doc.nodesBetween(range.$from.pos, range.$to.pos, (node, pos) => {
-            if (nodeType && nodeType === node.type) {
-              tr.setNodeMarkup(pos, void 0, deleteProps(node.attrs, attributes));
-            }
-            if (markType && node.marks.length) {
-              node.marks.forEach((mark) => {
-                if (markType === mark.type) {
-                  tr.addMark(pos, pos + node.nodeSize, markType.create(deleteProps(mark.attrs, attributes)));
-                }
-              });
-            }
-          });
-        });
-      }
-      return true;
-    };
-    scrollIntoView = () => ({ tr, dispatch }) => {
-      if (dispatch) {
-        tr.scrollIntoView();
-      }
-      return true;
-    };
-    selectAll = () => ({ tr, dispatch }) => {
-      if (dispatch) {
-        const selection = new import_state.AllSelection(tr.doc);
-        tr.setSelection(selection);
-      }
-      return true;
-    };
-    selectNodeBackward = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectNodeBackward)(state, dispatch);
-    };
-    selectNodeForward = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectNodeForward)(state, dispatch);
-    };
-    selectParentNode = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectParentNode)(state, dispatch);
-    };
-    selectTextblockEnd = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectTextblockEnd)(state, dispatch);
-    };
-    selectTextblockStart = () => ({ state, dispatch }) => {
-      return (0, import_commands.selectTextblockStart)(state, dispatch);
-    };
-    setContent = (content, emitUpdate = false, parseOptions = {}, options = {}) => ({ editor, tr, dispatch, commands: commands2 }) => {
-      var _a, _b;
-      const { doc } = tr;
-      if (parseOptions.preserveWhitespace !== "full") {
-        const document2 = createDocument(content, editor.schema, parseOptions, {
-          errorOnInvalidContent: (_a = options.errorOnInvalidContent) !== null && _a !== void 0 ? _a : editor.options.enableContentCheck
-        });
-        if (dispatch) {
-          tr.replaceWith(0, doc.content.size, document2).setMeta("preventUpdate", !emitUpdate);
-        }
-        return true;
-      }
-      if (dispatch) {
-        tr.setMeta("preventUpdate", !emitUpdate);
-      }
-      return commands2.insertContentAt({ from: 0, to: doc.content.size }, content, {
-        parseOptions,
-        errorOnInvalidContent: (_b = options.errorOnInvalidContent) !== null && _b !== void 0 ? _b : editor.options.enableContentCheck
-      });
-    };
-    setMark = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      const { selection } = tr;
-      const { empty, ranges } = selection;
-      const type = getMarkType(typeOrName, state.schema);
-      if (dispatch) {
-        if (empty) {
-          const oldAttributes = getMarkAttributes(state, type);
-          tr.addStoredMark(type.create({
-            ...oldAttributes,
-            ...attributes
-          }));
-        } else {
-          ranges.forEach((range) => {
-            const from = range.$from.pos;
-            const to = range.$to.pos;
-            state.doc.nodesBetween(from, to, (node, pos) => {
-              const trimmedFrom = Math.max(pos, from);
-              const trimmedTo = Math.min(pos + node.nodeSize, to);
-              const someHasMark = node.marks.find((mark) => mark.type === type);
-              if (someHasMark) {
-                node.marks.forEach((mark) => {
-                  if (type === mark.type) {
-                    tr.addMark(trimmedFrom, trimmedTo, type.create({
-                      ...mark.attrs,
-                      ...attributes
-                    }));
-                  }
-                });
-              } else {
-                tr.addMark(trimmedFrom, trimmedTo, type.create(attributes));
-              }
-            });
-          });
-        }
-      }
-      return canSetMark(state, tr, type);
-    };
-    setMeta = (key, value) => ({ tr }) => {
-      tr.setMeta(key, value);
-      return true;
-    };
-    setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      let attributesToCopy;
-      if (state.selection.$anchor.sameParent(state.selection.$head)) {
-        attributesToCopy = state.selection.$anchor.parent.attrs;
-      }
-      if (!type.isTextblock) {
-        console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
-        return false;
-      }
-      return chain().command(({ commands: commands2 }) => {
-        const canSetBlock = (0, import_commands.setBlockType)(type, { ...attributesToCopy, ...attributes })(state);
-        if (canSetBlock) {
-          return true;
-        }
-        return commands2.clearNodes();
-      }).command(({ state: updatedState }) => {
-        return (0, import_commands.setBlockType)(type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
-      }).run();
-    };
-    setNodeSelection = (position) => ({ tr, dispatch }) => {
-      if (dispatch) {
-        const { doc } = tr;
-        const from = minMax(position, 0, doc.content.size);
-        const selection = import_state.NodeSelection.create(doc, from);
-        tr.setSelection(selection);
-      }
-      return true;
-    };
-    setTextSelection = (position) => ({ tr, dispatch }) => {
-      if (dispatch) {
-        const { doc } = tr;
-        const { from, to } = typeof position === "number" ? { from: position, to: position } : position;
-        const minPos = import_state.TextSelection.atStart(doc).from;
-        const maxPos = import_state.TextSelection.atEnd(doc).to;
-        const resolvedFrom = minMax(from, minPos, maxPos);
-        const resolvedEnd = minMax(to, minPos, maxPos);
-        const selection = import_state.TextSelection.create(doc, resolvedFrom, resolvedEnd);
-        tr.setSelection(selection);
-      }
-      return true;
-    };
-    sinkListItem = (typeOrName) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return (0, import_schema_list.sinkListItem)(type)(state, dispatch);
-    };
-    splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor }) => {
-      const { selection, doc } = tr;
-      const { $from, $to } = selection;
-      const extensionAttributes = editor.extensionManager.attributes;
-      const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
-      if (selection instanceof import_state.NodeSelection && selection.node.isBlock) {
-        if (!$from.parentOffset || !(0, import_transform.canSplit)(doc, $from.pos)) {
-          return false;
-        }
-        if (dispatch) {
-          if (keepMarks) {
-            ensureMarks(state, editor.extensionManager.splittableMarks);
-          }
-          tr.split($from.pos).scrollIntoView();
-        }
-        return true;
-      }
-      if (!$from.parent.isBlock) {
-        return false;
-      }
-      const atEnd = $to.parentOffset === $to.parent.content.size;
-      const deflt = $from.depth === 0 ? void 0 : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));
-      let types = atEnd && deflt ? [
-        {
-          type: deflt,
-          attrs: newAttributes
-        }
-      ] : void 0;
-      let can = (0, import_transform.canSplit)(tr.doc, tr.mapping.map($from.pos), 1, types);
-      if (!types && !can && (0, import_transform.canSplit)(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : void 0)) {
-        can = true;
-        types = deflt ? [
-          {
-            type: deflt,
-            attrs: newAttributes
-          }
-        ] : void 0;
-      }
-      if (dispatch) {
-        if (can) {
-          if (selection instanceof import_state.TextSelection) {
-            tr.deleteSelection();
-          }
-          tr.split(tr.mapping.map($from.pos), 1, types);
-          if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
-            const first2 = tr.mapping.map($from.before());
-            const $first = tr.doc.resolve(first2);
-            if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
-              tr.setNodeMarkup(tr.mapping.map($from.before()), deflt);
-            }
-          }
-        }
-        if (keepMarks) {
-          ensureMarks(state, editor.extensionManager.splittableMarks);
-        }
-        tr.scrollIntoView();
-      }
-      return can;
-    };
-    splitListItem = (typeOrName, overrideAttrs = {}) => ({ tr, state, dispatch, editor }) => {
-      var _a;
-      const type = getNodeType(typeOrName, state.schema);
-      const { $from, $to } = state.selection;
-      const node = state.selection.node;
-      if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
-        return false;
-      }
-      const grandParent = $from.node(-1);
-      if (grandParent.type !== type) {
-        return false;
-      }
-      const extensionAttributes = editor.extensionManager.attributes;
-      if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
-        if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
-          return false;
-        }
-        if (dispatch) {
-          let wrap = import_model.Fragment.empty;
-          const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
-          for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
-            wrap = import_model.Fragment.from($from.node(d).copy(wrap));
-          }
-          const depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1 : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3;
-          const newNextTypeAttributes2 = {
-            ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-            ...overrideAttrs
-          };
-          const nextType2 = ((_a = type.contentMatch.defaultType) === null || _a === void 0 ? void 0 : _a.createAndFill(newNextTypeAttributes2)) || void 0;
-          wrap = wrap.append(import_model.Fragment.from(type.createAndFill(null, nextType2) || void 0));
-          const start = $from.before($from.depth - (depthBefore - 1));
-          tr.replace(start, $from.after(-depthAfter), new import_model.Slice(wrap, 4 - depthBefore, 0));
-          let sel = -1;
-          tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
-            if (sel > -1) {
-              return false;
-            }
-            if (n.isTextblock && n.content.size === 0) {
-              sel = pos + 1;
-            }
-          });
-          if (sel > -1) {
-            tr.setSelection(import_state.TextSelection.near(tr.doc.resolve(sel)));
-          }
-          tr.scrollIntoView();
-        }
-        return true;
-      }
-      const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null;
-      const newTypeAttributes = {
-        ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
-        ...overrideAttrs
-      };
-      const newNextTypeAttributes = {
-        ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
-        ...overrideAttrs
-      };
-      tr.delete($from.pos, $to.pos);
-      const types = nextType ? [
-        { type, attrs: newTypeAttributes },
-        { type: nextType, attrs: newNextTypeAttributes }
-      ] : [{ type, attrs: newTypeAttributes }];
-      if (!(0, import_transform.canSplit)(tr.doc, $from.pos, 2)) {
-        return false;
-      }
-      if (dispatch) {
-        const { selection, storedMarks } = state;
-        const { splittableMarks } = editor.extensionManager;
-        const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-        tr.split($from.pos, 2, types).scrollIntoView();
-        if (!marks || !dispatch) {
-          return true;
-        }
-        const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-        tr.ensureMarks(filteredMarks);
-      }
-      return true;
-    };
-    joinListBackwards = (tr, listType) => {
-      const list = findParentNode((node) => node.type === listType)(tr.selection);
-      if (!list) {
-        return true;
-      }
-      const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth);
-      if (before === void 0) {
-        return true;
-      }
-      const nodeBefore = tr.doc.nodeAt(before);
-      const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type) && (0, import_transform.canJoin)(tr.doc, list.pos);
-      if (!canJoinBackwards) {
-        return true;
-      }
-      tr.join(list.pos);
-      return true;
-    };
-    joinListForwards = (tr, listType) => {
-      const list = findParentNode((node) => node.type === listType)(tr.selection);
-      if (!list) {
-        return true;
-      }
-      const after = tr.doc.resolve(list.start).after(list.depth);
-      if (after === void 0) {
-        return true;
-      }
-      const nodeAfter = tr.doc.nodeAt(after);
-      const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type) && (0, import_transform.canJoin)(tr.doc, after);
-      if (!canJoinForwards) {
-        return true;
-      }
-      tr.join(after);
-      return true;
-    };
-    toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands: commands2, can }) => {
-      const { extensions, splittableMarks } = editor.extensionManager;
-      const listType = getNodeType(listTypeOrName, state.schema);
-      const itemType = getNodeType(itemTypeOrName, state.schema);
-      const { selection, storedMarks } = state;
-      const { $from, $to } = selection;
-      const range = $from.blockRange($to);
-      const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
-      if (!range) {
-        return false;
-      }
-      const parentList = findParentNode((node) => isList(node.type.name, extensions))(selection);
-      if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-        if (parentList.node.type === listType) {
-          return commands2.liftListItem(itemType);
-        }
-        if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
-          return chain().command(() => {
-            tr.setNodeMarkup(parentList.pos, listType);
-            return true;
-          }).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-        }
-      }
-      if (!keepMarks || !marks || !dispatch) {
-        return chain().command(() => {
-          const canWrapInList = can().wrapInList(listType, attributes);
-          if (canWrapInList) {
-            return true;
-          }
-          return commands2.clearNodes();
-        }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-      }
-      return chain().command(() => {
-        const canWrapInList = can().wrapInList(listType, attributes);
-        const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
-        tr.ensureMarks(filteredMarks);
-        if (canWrapInList) {
-          return true;
-        }
-        return commands2.clearNodes();
-      }).wrapInList(listType, attributes).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
-    };
-    toggleMark = (typeOrName, attributes = {}, options = {}) => ({ state, commands: commands2 }) => {
-      const { extendEmptyMarkRange = false } = options;
-      const type = getMarkType(typeOrName, state.schema);
-      const isActive = isMarkActive(state, type, attributes);
-      if (isActive) {
-        return commands2.unsetMark(type, { extendEmptyMarkRange });
-      }
-      return commands2.setMark(type, attributes);
-    };
-    toggleNode = (typeOrName, toggleTypeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const toggleType = getNodeType(toggleTypeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      let attributesToCopy;
-      if (state.selection.$anchor.sameParent(state.selection.$head)) {
-        attributesToCopy = state.selection.$anchor.parent.attrs;
-      }
-      if (isActive) {
-        return commands2.setNode(toggleType, attributesToCopy);
-      }
-      return commands2.setNode(type, { ...attributesToCopy, ...attributes });
-    };
-    toggleWrap = (typeOrName, attributes = {}) => ({ state, commands: commands2 }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      const isActive = isNodeActive(state, type, attributes);
-      if (isActive) {
-        return commands2.lift(type);
-      }
-      return commands2.wrapIn(type, attributes);
-    };
-    undoInputRule = () => ({ state, dispatch }) => {
-      const plugins = state.plugins;
-      for (let i = 0; i < plugins.length; i += 1) {
-        const plugin = plugins[i];
-        let undoable;
-        if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
-          if (dispatch) {
-            const tr = state.tr;
-            const toUndo = undoable.transform;
-            for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
-              tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
-            }
-            if (undoable.text) {
-              const marks = tr.doc.resolve(undoable.from).marks();
-              tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
-            } else {
-              tr.delete(undoable.from, undoable.to);
-            }
-          }
-          return true;
-        }
-      }
-      return false;
-    };
-    unsetAllMarks = () => ({ tr, dispatch }) => {
-      const { selection } = tr;
-      const { empty, ranges } = selection;
-      if (empty) {
-        return true;
-      }
-      if (dispatch) {
-        ranges.forEach((range) => {
-          tr.removeMark(range.$from.pos, range.$to.pos);
-        });
-      }
-      return true;
-    };
-    unsetMark = (typeOrName, options = {}) => ({ tr, state, dispatch }) => {
-      var _a;
-      const { extendEmptyMarkRange = false } = options;
-      const { selection } = tr;
-      const type = getMarkType(typeOrName, state.schema);
-      const { $from, empty, ranges } = selection;
-      if (!dispatch) {
-        return true;
-      }
-      if (empty && extendEmptyMarkRange) {
-        let { from, to } = selection;
-        const attrs = (_a = $from.marks().find((mark) => mark.type === type)) === null || _a === void 0 ? void 0 : _a.attrs;
-        const range = getMarkRange($from, type, attrs);
-        if (range) {
-          from = range.from;
-          to = range.to;
-        }
-        tr.removeMark(from, to, type);
-      } else {
-        ranges.forEach((range) => {
-          tr.removeMark(range.$from.pos, range.$to.pos, type);
-        });
-      }
-      tr.removeStoredMark(type);
-      return true;
-    };
-    updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
-      let nodeType = null;
-      let markType = null;
-      const schemaType = getSchemaTypeNameByName(typeof typeOrName === "string" ? typeOrName : typeOrName.name, state.schema);
-      if (!schemaType) {
-        return false;
-      }
-      if (schemaType === "node") {
-        nodeType = getNodeType(typeOrName, state.schema);
-      }
-      if (schemaType === "mark") {
-        markType = getMarkType(typeOrName, state.schema);
-      }
-      if (dispatch) {
-        tr.selection.ranges.forEach((range) => {
-          const from = range.$from.pos;
-          const to = range.$to.pos;
-          let lastPos;
-          let lastNode;
-          let trimmedFrom;
-          let trimmedTo;
-          if (tr.selection.empty) {
-            state.doc.nodesBetween(from, to, (node, pos) => {
-              if (nodeType && nodeType === node.type) {
-                trimmedFrom = Math.max(pos, from);
-                trimmedTo = Math.min(pos + node.nodeSize, to);
-                lastPos = pos;
-                lastNode = node;
-              }
-            });
-          } else {
-            state.doc.nodesBetween(from, to, (node, pos) => {
-              if (pos < from && nodeType && nodeType === node.type) {
-                trimmedFrom = Math.max(pos, from);
-                trimmedTo = Math.min(pos + node.nodeSize, to);
-                lastPos = pos;
-                lastNode = node;
-              }
-              if (pos >= from && pos <= to) {
-                if (nodeType && nodeType === node.type) {
-                  tr.setNodeMarkup(pos, void 0, {
-                    ...node.attrs,
-                    ...attributes
-                  });
-                }
-                if (markType && node.marks.length) {
-                  node.marks.forEach((mark) => {
-                    if (markType === mark.type) {
-                      const trimmedFrom2 = Math.max(pos, from);
-                      const trimmedTo2 = Math.min(pos + node.nodeSize, to);
-                      tr.addMark(trimmedFrom2, trimmedTo2, markType.create({
-                        ...mark.attrs,
-                        ...attributes
-                      }));
-                    }
-                  });
-                }
-              }
-            });
-          }
-          if (lastNode) {
-            if (lastPos !== void 0) {
-              tr.setNodeMarkup(lastPos, void 0, {
-                ...lastNode.attrs,
-                ...attributes
-              });
-            }
-            if (markType && lastNode.marks.length) {
-              lastNode.marks.forEach((mark) => {
-                if (markType === mark.type) {
-                  tr.addMark(trimmedFrom, trimmedTo, markType.create({
-                    ...mark.attrs,
-                    ...attributes
-                  }));
-                }
-              });
-            }
-          }
-        });
-      }
-      return true;
-    };
-    wrapIn = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return (0, import_commands.wrapIn)(type, attributes)(state, dispatch);
-    };
-    wrapInList = (typeOrName, attributes = {}) => ({ state, dispatch }) => {
-      const type = getNodeType(typeOrName, state.schema);
-      return (0, import_schema_list.wrapInList)(type, attributes)(state, dispatch);
-    };
-    commands = /* @__PURE__ */ Object.freeze({
-      __proto__: null,
-      blur,
-      clearContent,
-      clearNodes,
-      command,
-      createParagraphNear,
-      cut,
-      deleteCurrentNode,
-      deleteNode,
-      deleteRange,
-      deleteSelection,
-      enter,
-      exitCode,
-      extendMarkRange,
-      first,
-      focus,
-      forEach,
-      insertContent,
-      insertContentAt,
-      joinBackward,
-      joinDown,
-      joinForward,
-      joinItemBackward,
-      joinItemForward,
-      joinTextblockBackward,
-      joinTextblockForward,
-      joinUp,
-      keyboardShortcut,
-      lift,
-      liftEmptyBlock,
-      liftListItem,
-      newlineInCode,
-      resetAttributes,
-      scrollIntoView,
-      selectAll,
-      selectNodeBackward,
-      selectNodeForward,
-      selectParentNode,
-      selectTextblockEnd,
-      selectTextblockStart,
-      setContent,
-      setMark,
-      setMeta,
-      setNode,
-      setNodeSelection,
-      setTextSelection,
-      sinkListItem,
-      splitBlock,
-      splitListItem,
-      toggleList,
-      toggleMark,
-      toggleNode,
-      toggleWrap,
-      undoInputRule,
-      unsetAllMarks,
-      unsetMark,
-      updateAttributes,
-      wrapIn,
-      wrapInList
-    });
-    Commands = Extension.create({
-      name: "commands",
-      addCommands() {
-        return {
-          ...commands
-        };
-      }
-    });
-    Drop = Extension.create({
-      name: "drop",
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("tiptapDrop"),
-            props: {
-              handleDrop: (_, e, slice, moved) => {
-                this.editor.emit("drop", {
-                  editor: this.editor,
-                  event: e,
-                  slice,
-                  moved
-                });
-              }
-            }
-          })
-        ];
-      }
-    });
-    Editable = Extension.create({
-      name: "editable",
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("editable"),
-            props: {
-              editable: () => this.editor.options.editable
-            }
-          })
-        ];
-      }
-    });
-    focusEventsPluginKey = new import_state.PluginKey("focusEvents");
-    FocusEvents = Extension.create({
-      name: "focusEvents",
-      addProseMirrorPlugins() {
-        const { editor } = this;
-        return [
-          new import_state.Plugin({
-            key: focusEventsPluginKey,
-            props: {
-              handleDOMEvents: {
-                focus: (view, event) => {
-                  editor.isFocused = true;
-                  const transaction = editor.state.tr.setMeta("focus", { event }).setMeta("addToHistory", false);
-                  view.dispatch(transaction);
-                  return false;
-                },
-                blur: (view, event) => {
-                  editor.isFocused = false;
-                  const transaction = editor.state.tr.setMeta("blur", { event }).setMeta("addToHistory", false);
-                  view.dispatch(transaction);
-                  return false;
-                }
-              }
-            }
-          })
-        ];
-      }
-    });
-    Keymap = Extension.create({
-      name: "keymap",
-      addKeyboardShortcuts() {
-        const handleBackspace = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.undoInputRule(),
-          // maybe convert first text block node to default node
-          () => commands2.command(({ tr }) => {
-            const { selection, doc } = tr;
-            const { empty, $anchor } = selection;
-            const { pos, parent } = $anchor;
-            const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor;
-            const parentIsIsolating = $parentPos.parent.type.spec.isolating;
-            const parentPos = $anchor.pos - $anchor.parentOffset;
-            const isAtStart = parentIsIsolating && $parentPos.parent.childCount === 1 ? parentPos === $anchor.pos : import_state.Selection.atStart(doc).from === pos;
-            if (!empty || !parent.type.isTextblock || parent.textContent.length || !isAtStart || isAtStart && $anchor.parent.type.name === "paragraph") {
-              return false;
-            }
-            return commands2.clearNodes();
-          }),
-          () => commands2.deleteSelection(),
-          () => commands2.joinBackward(),
-          () => commands2.selectNodeBackward()
-        ]);
-        const handleDelete = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.deleteSelection(),
-          () => commands2.deleteCurrentNode(),
-          () => commands2.joinForward(),
-          () => commands2.selectNodeForward()
-        ]);
-        const handleEnter = () => this.editor.commands.first(({ commands: commands2 }) => [
-          () => commands2.newlineInCode(),
-          () => commands2.createParagraphNear(),
-          () => commands2.liftEmptyBlock(),
-          () => commands2.splitBlock()
-        ]);
-        const baseKeymap = {
-          Enter: handleEnter,
-          "Mod-Enter": () => this.editor.commands.exitCode(),
-          Backspace: handleBackspace,
-          "Mod-Backspace": handleBackspace,
-          "Shift-Backspace": handleBackspace,
-          Delete: handleDelete,
-          "Mod-Delete": handleDelete,
-          "Mod-a": () => this.editor.commands.selectAll()
-        };
-        const pcKeymap = {
-          ...baseKeymap
-        };
-        const macKeymap = {
-          ...baseKeymap,
-          "Ctrl-h": handleBackspace,
-          "Alt-Backspace": handleBackspace,
-          "Ctrl-d": handleDelete,
-          "Ctrl-Alt-Backspace": handleDelete,
-          "Alt-Delete": handleDelete,
-          "Alt-d": handleDelete,
-          "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
-          "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
-        };
-        if (isiOS() || isMacOS()) {
-          return macKeymap;
-        }
-        return pcKeymap;
-      },
-      addProseMirrorPlugins() {
-        return [
-          // With this plugin we check if the whole document was selected and deleted.
-          // In this case we will additionally call `clearNodes()` to convert e.g. a heading
-          // to a paragraph if necessary.
-          // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
-          // with many other commands.
-          new import_state.Plugin({
-            key: new import_state.PluginKey("clearDocument"),
-            appendTransaction: (transactions, oldState, newState) => {
-              if (transactions.some((tr2) => tr2.getMeta("composition"))) {
-                return;
-              }
-              const docChanges = transactions.some((transaction) => transaction.docChanged) && !oldState.doc.eq(newState.doc);
-              const ignoreTr = transactions.some((transaction) => transaction.getMeta("preventClearDocument"));
-              if (!docChanges || ignoreTr) {
-                return;
-              }
-              const { empty, from, to } = oldState.selection;
-              const allFrom = import_state.Selection.atStart(oldState.doc).from;
-              const allEnd = import_state.Selection.atEnd(oldState.doc).to;
-              const allWasSelected = from === allFrom && to === allEnd;
-              if (empty || !allWasSelected) {
-                return;
-              }
-              const isEmpty = isNodeEmpty(newState.doc);
-              if (!isEmpty) {
-                return;
-              }
-              const tr = newState.tr;
-              const state = createChainableState({
-                state: newState,
-                transaction: tr
-              });
-              const { commands: commands2 } = new CommandManager({
-                editor: this.editor,
-                state
-              });
-              commands2.clearNodes();
-              if (!tr.steps.length) {
-                return;
-              }
-              return tr;
-            }
-          })
-        ];
-      }
-    });
-    Paste = Extension.create({
-      name: "paste",
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("tiptapPaste"),
-            props: {
-              handlePaste: (_view, e, slice) => {
-                this.editor.emit("paste", {
-                  editor: this.editor,
-                  event: e,
-                  slice
-                });
-              }
-            }
-          })
-        ];
-      }
-    });
-    Tabindex = Extension.create({
-      name: "tabindex",
-      addProseMirrorPlugins() {
-        return [
-          new import_state.Plugin({
-            key: new import_state.PluginKey("tabindex"),
-            props: {
-              attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
-            }
-          })
-        ];
-      }
-    });
-    Node = class _Node {
-      constructor(config = {}) {
-        this.type = "node";
-        this.name = "node";
-        this.parent = null;
-        this.child = null;
-        this.config = {
-          name: this.name,
-          defaultOptions: {}
-        };
-        this.config = {
-          ...this.config,
-          ...config
-        };
-        this.name = this.config.name;
-        if (config.defaultOptions && Object.keys(config.defaultOptions).length > 0) {
-          console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`);
-        }
-        this.options = this.config.defaultOptions;
-        if (this.config.addOptions) {
-          this.options = callOrReturn(getExtensionField(this, "addOptions", {
-            name: this.name
-          }));
-        }
-        this.storage = callOrReturn(getExtensionField(this, "addStorage", {
-          name: this.name,
-          options: this.options
-        })) || {};
-      }
-      static create(config = {}) {
-        return new _Node(config);
-      }
-      configure(options = {}) {
-        const extension = this.extend({
-          ...this.config,
-          addOptions: () => {
-            return mergeDeep(this.options, options);
-          }
-        });
-        extension.name = this.name;
-        extension.parent = this.parent;
-        return extension;
-      }
-      extend(extendedConfig = {}) {
-        const extension = new _Node(extendedConfig);
-        extension.parent = this;
-        this.child = extension;
-        extension.name = extendedConfig.name ? extendedConfig.name : extension.parent.name;
-        if (extendedConfig.defaultOptions && Object.keys(extendedConfig.defaultOptions).length > 0) {
-          console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${extension.name}".`);
-        }
-        extension.options = callOrReturn(getExtensionField(extension, "addOptions", {
-          name: extension.name
-        }));
-        extension.storage = callOrReturn(getExtensionField(extension, "addStorage", {
-          name: extension.name,
-          options: extension.options
-        }));
-        return extension;
-      }
-    };
-  }
-});
-
 // src/extensions/FontSize.ts
-var FontSize;
+var import_core, FontSize;
 var init_FontSize = __esm({
   "src/extensions/FontSize.ts"() {
     "use strict";
-    init_dist();
-    FontSize = Extension.create({
+    import_core = require("@tiptap/core");
+    FontSize = import_core.Extension.create({
       name: "fontSize",
       addOptions() {
         return {
@@ -2221,12 +83,12 @@ var init_FontSize = __esm({
 });
 
 // src/extensions/LineHeight.ts
-var LineHeight;
+var import_core2, LineHeight;
 var init_LineHeight = __esm({
   "src/extensions/LineHeight.ts"() {
     "use strict";
-    init_dist();
-    LineHeight = Extension.create({
+    import_core2 = require("@tiptap/core");
+    LineHeight = import_core2.Extension.create({
       name: "lineHeight",
       addOptions() {
         return {
@@ -2257,14 +119,14 @@ var init_LineHeight = __esm({
       },
       addCommands() {
         return {
-          setLineHeight: (lineHeight) => ({ commands: commands2 }) => {
+          setLineHeight: (lineHeight) => ({ commands }) => {
             return this.options.types.every(
-              (type) => commands2.updateAttributes(type, { lineHeight })
+              (type) => commands.updateAttributes(type, { lineHeight })
             );
           },
-          unsetLineHeight: () => ({ commands: commands2 }) => {
+          unsetLineHeight: () => ({ commands }) => {
             return this.options.types.every(
-              (type) => commands2.resetAttributes(type, "lineHeight")
+              (type) => commands.resetAttributes(type, "lineHeight")
             );
           }
         };
@@ -2274,12 +136,12 @@ var init_LineHeight = __esm({
 });
 
 // src/extensions/Video.ts
-var Video;
+var import_core3, Video;
 var init_Video = __esm({
   "src/extensions/Video.ts"() {
     "use strict";
-    init_dist();
-    Video = Node.create({
+    import_core3 = require("@tiptap/core");
+    Video = import_core3.Node.create({
       name: "video",
       addOptions() {
         return {
@@ -2327,14 +189,14 @@ var init_Video = __esm({
       renderHTML({ HTMLAttributes }) {
         return [
           "video",
-          mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+          (0, import_core3.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes),
           ["source", { src: HTMLAttributes.src }]
         ];
       },
       addCommands() {
         return {
-          setVideo: (options) => ({ commands: commands2 }) => {
-            return commands2.insertContent({
+          setVideo: (options) => ({ commands }) => {
+            return commands.insertContent({
               type: this.name,
               attrs: options
             });
@@ -2346,11 +208,11 @@ var init_Video = __esm({
 });
 
 // src/extensions/Emoji.ts
-var EMOJI_CATEGORIES, Emoji;
+var import_core4, EMOJI_CATEGORIES, Emoji;
 var init_Emoji = __esm({
   "src/extensions/Emoji.ts"() {
     "use strict";
-    init_dist();
+    import_core4 = require("@tiptap/core");
     EMOJI_CATEGORIES = {
       smileys: {
         label: "Smileys & People",
@@ -3359,7 +1221,7 @@ var init_Emoji = __esm({
         ]
       }
     };
-    Emoji = Extension.create({
+    Emoji = import_core4.Extension.create({
       name: "emoji",
       addOptions() {
         return {
@@ -3368,8 +1230,8 @@ var init_Emoji = __esm({
       },
       addCommands() {
         return {
-          insertEmoji: (emoji) => ({ commands: commands2 }) => {
-            return commands2.insertContent(emoji);
+          insertEmoji: (emoji) => ({ commands }) => {
+            return commands.insertContent(emoji);
           }
         };
       }
@@ -3378,12 +1240,12 @@ var init_Emoji = __esm({
 });
 
 // src/extensions/Fullscreen.ts
-var Fullscreen;
+var import_core5, Fullscreen;
 var init_Fullscreen = __esm({
   "src/extensions/Fullscreen.ts"() {
     "use strict";
-    init_dist();
-    Fullscreen = Extension.create({
+    import_core5 = require("@tiptap/core");
+    Fullscreen = import_core5.Extension.create({
       name: "fullscreen",
       addOptions() {
         return {
@@ -3449,11 +1311,11 @@ var init_Fullscreen = __esm({
 });
 
 // src/extensions/Print.ts
-var defaultPrintStyles, Print;
+var import_core6, defaultPrintStyles, Print;
 var init_Print = __esm({
   "src/extensions/Print.ts"() {
     "use strict";
-    init_dist();
+    import_core6 = require("@tiptap/core");
     defaultPrintStyles = `
   body {
     font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
@@ -3569,7 +1431,7 @@ var init_Print = __esm({
     }
   }
 `;
-    Print = Extension.create({
+    Print = import_core6.Extension.create({
       name: "print",
       addOptions() {
         return {
@@ -3627,12 +1489,12 @@ var init_Print = __esm({
 });
 
 // src/extensions/Indent.ts
-var Indent;
+var import_core7, Indent;
 var init_Indent = __esm({
   "src/extensions/Indent.ts"() {
     "use strict";
-    init_dist();
-    Indent = Extension.create({
+    import_core7 = require("@tiptap/core");
+    Indent = import_core7.Extension.create({
       name: "indent",
       addOptions() {
         return {
@@ -4879,9 +2741,9 @@ var init_SlateToolbar = __esm({
       onToggleFullscreen,
       onPrint,
       isFullscreen = false,
-      toggleMark: toggleMark3,
+      toggleMark: toggleMark2,
       toggleBlock: toggleBlock2,
-      isMarkActive: isMarkActive3,
+      isMarkActive: isMarkActive2,
       isBlockActive: isBlockActive2
     }) => {
       const [showEmojiPicker, setShowEmojiPicker] = (0, import_react4.useState)(false);
@@ -5015,8 +2877,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "bold"),
-                onClick: () => toggleMark3(editor, "bold"),
+                active: isMarkActive2(editor, "bold"),
+                onClick: () => toggleMark2(editor, "bold"),
                 title: "Bold (Ctrl+B)",
                 children: icons.bold
               },
@@ -5026,8 +2888,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "italic"),
-                onClick: () => toggleMark3(editor, "italic"),
+                active: isMarkActive2(editor, "italic"),
+                onClick: () => toggleMark2(editor, "italic"),
                 title: "Italic (Ctrl+I)",
                 children: icons.italic
               },
@@ -5037,8 +2899,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "underline"),
-                onClick: () => toggleMark3(editor, "underline"),
+                active: isMarkActive2(editor, "underline"),
+                onClick: () => toggleMark2(editor, "underline"),
                 title: "Underline (Ctrl+U)",
                 children: icons.underline
               },
@@ -5048,8 +2910,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "strikethrough"),
-                onClick: () => toggleMark3(editor, "strikethrough"),
+                active: isMarkActive2(editor, "strikethrough"),
+                onClick: () => toggleMark2(editor, "strikethrough"),
                 title: "Strikethrough",
                 children: icons.strike
               },
@@ -5059,8 +2921,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "code"),
-                onClick: () => toggleMark3(editor, "code"),
+                active: isMarkActive2(editor, "code"),
+                onClick: () => toggleMark2(editor, "code"),
                 title: "Code",
                 children: icons.code
               },
@@ -5081,8 +2943,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "subscript"),
-                onClick: () => toggleMark3(editor, "subscript"),
+                active: isMarkActive2(editor, "subscript"),
+                onClick: () => toggleMark2(editor, "subscript"),
                 title: "Subscript",
                 children: icons.subscript
               },
@@ -5092,8 +2954,8 @@ var init_SlateToolbar = __esm({
             return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               ToolbarButton,
               {
-                active: isMarkActive3(editor, "superscript"),
-                onClick: () => toggleMark3(editor, "superscript"),
+                active: isMarkActive2(editor, "superscript"),
+                onClick: () => toggleMark2(editor, "superscript"),
                 title: "Superscript",
                 children: icons.superscript
               },
@@ -5464,7 +3326,7 @@ __export(SlateEditorComponent_exports, {
   SlateEditorComponent: () => SlateEditorComponent,
   default: () => SlateEditorComponent_default
 });
-var import_react5, import_slate2, import_slate_react2, import_slate_history, import_is_hotkey, import_jsx_runtime4, HOTKEYS, LIST_TYPES, TEXT_ALIGN_TYPES, isMarkActive2, isBlockActive, toggleMark2, toggleBlock, serializeToHtml, serializeNode, escapeHtml, deserializeFromHtml, deserializeElement, renderElement, renderLeaf, withInlines, SlateEditorComponent, SlateEditorComponent_default;
+var import_react5, import_slate2, import_slate_react2, import_slate_history, import_is_hotkey, import_jsx_runtime4, HOTKEYS, LIST_TYPES, TEXT_ALIGN_TYPES, isMarkActive, isBlockActive, toggleMark, toggleBlock, serializeToHtml, serializeNode, escapeHtml, deserializeFromHtml, deserializeElement, renderElement, renderLeaf, withInlines, SlateEditorComponent, SlateEditorComponent_default;
 var init_SlateEditorComponent = __esm({
   "src/adapters/slate/SlateEditorComponent.tsx"() {
     "use strict";
@@ -5484,7 +3346,7 @@ var init_SlateEditorComponent = __esm({
     };
     LIST_TYPES = ["numbered-list", "bulleted-list"];
     TEXT_ALIGN_TYPES = ["left", "center", "right", "justify"];
-    isMarkActive2 = (editor, format) => {
+    isMarkActive = (editor, format) => {
       const marks = import_slate2.Editor.marks(editor);
       return marks ? marks[format] === true : false;
     };
@@ -5499,8 +3361,8 @@ var init_SlateEditorComponent = __esm({
       );
       return !!match;
     };
-    toggleMark2 = (editor, format) => {
-      const isActive = isMarkActive2(editor, format);
+    toggleMark = (editor, format) => {
+      const isActive = isMarkActive(editor, format);
       if (isActive) {
         import_slate2.Editor.removeMark(editor, format);
       } else {
@@ -5513,7 +3375,7 @@ var init_SlateEditorComponent = __esm({
         format,
         TEXT_ALIGN_TYPES.includes(format) ? "align" : "type"
       );
-      const isList2 = LIST_TYPES.includes(format);
+      const isList = LIST_TYPES.includes(format);
       import_slate2.Transforms.unwrapNodes(editor, {
         match: (n) => !import_slate2.Editor.isEditor(n) && import_slate2.Element.isElement(n) && LIST_TYPES.includes(n.type) && !TEXT_ALIGN_TYPES.includes(format),
         split: true
@@ -5525,11 +3387,11 @@ var init_SlateEditorComponent = __esm({
         };
       } else {
         newProperties = {
-          type: isActive ? "paragraph" : isList2 ? "list-item" : format
+          type: isActive ? "paragraph" : isList ? "list-item" : format
         };
       }
       import_slate2.Transforms.setNodes(editor, newProperties);
-      if (!isActive && isList2) {
+      if (!isActive && isList) {
         const block = { type: format, children: [] };
         import_slate2.Transforms.wrapNodes(editor, block);
       }
@@ -5816,7 +3678,7 @@ var init_SlateEditorComponent = __esm({
               if ((0, import_is_hotkey.default)(hotkey, event)) {
                 event.preventDefault();
                 const mark = HOTKEYS[hotkey];
-                toggleMark2(editor, mark);
+                toggleMark(editor, mark);
               }
             }
           },
@@ -5950,9 +3812,9 @@ var init_SlateEditorComponent = __esm({
                   onToggleFullscreen: handleToggleFullscreen,
                   onPrint: handlePrint,
                   isFullscreen,
-                  toggleMark: toggleMark2,
+                  toggleMark,
                   toggleBlock,
-                  isMarkActive: isMarkActive2,
+                  isMarkActive,
                   isBlockActive
                 }
               ),
@@ -6971,7 +4833,11 @@ var init_LexicalEditorComponent = __esm({
 // src/index.tsx
 var index_exports = {};
 __export(index_exports, {
+  CollaborationProvider: () => CollaborationProvider,
+  CommentsPanel: () => CommentsPanel,
+  CommentsProvider: () => CommentsProvider,
   DEFAULT_FEATURES: () => DEFAULT_FEATURES,
+  DEFAULT_REACTION_EMOJIS: () => DEFAULT_REACTION_EMOJIS,
   EMOJI_CATEGORIES: () => EMOJI_CATEGORIES,
   EditorRegistry: () => EditorRegistry,
   Emoji: () => Emoji,
@@ -6979,12 +4845,15 @@ __export(index_exports, {
   Fullscreen: () => Fullscreen,
   Indent: () => Indent,
   LineHeight: () => LineHeight,
+  PresenceIndicator: () => PresenceIndicator,
   Print: () => Print,
   RichTextEditor: () => RichTextEditor,
   TipTapAdapter: () => TipTapAdapter,
   TipTapEditorComponent: () => TipTapEditorComponent,
   TipTapToolbar: () => TipTapToolbar,
   UnifiedEditor: () => UnifiedEditor,
+  VersionHistoryPanel: () => VersionHistoryPanel,
+  VersionHistoryProvider: () => VersionHistoryProvider,
   Video: () => Video,
   blogToolbar: () => blogToolbar,
   codeToolbar: () => codeToolbar,
@@ -7006,7 +4875,13 @@ __export(index_exports, {
   registerAdapter: () => registerAdapter,
   simpleToolbar: () => simpleToolbar,
   toolbarPresets: () => toolbarPresets,
-  unregisterAdapter: () => unregisterAdapter
+  unregisterAdapter: () => unregisterAdapter,
+  useCollaboration: () => useCollaboration,
+  useCollaborationOptional: () => useCollaborationOptional,
+  useComments: () => useComments,
+  useCommentsOptional: () => useCommentsOptional,
+  useVersionHistory: () => useVersionHistory,
+  useVersionHistoryOptional: () => useVersionHistoryOptional
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -8675,9 +6550,1382 @@ init_Emoji();
 init_Fullscreen();
 init_Print();
 init_Indent();
+
+// src/collaboration/CollaborationContext.tsx
+var import_react12 = require("react");
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var initialState = {
+  status: "disconnected",
+  users: [],
+  error: void 0,
+  isHost: false
+};
+function collaborationReducer(state, action) {
+  switch (action.type) {
+    case "SET_STATUS":
+      return { ...state, status: action.status, error: action.status === "error" ? state.error : void 0 };
+    case "SET_USERS":
+      return { ...state, users: action.users };
+    case "ADD_USER":
+      if (state.users.find((u) => u.id === action.user.id)) {
+        return {
+          ...state,
+          users: state.users.map((u) => u.id === action.user.id ? action.user : u)
+        };
+      }
+      return { ...state, users: [...state.users, action.user] };
+    case "REMOVE_USER":
+      return { ...state, users: state.users.filter((u) => u.id !== action.userId) };
+    case "UPDATE_CURSOR":
+      return {
+        ...state,
+        users: state.users.map(
+          (u) => u.id === action.userId ? { ...u, cursor: action.cursor, lastActive: Date.now() } : u
+        )
+      };
+    case "SET_ERROR":
+      return { ...state, status: "error", error: action.error };
+    case "CLEAR_ERROR":
+      return { ...state, error: void 0 };
+    case "SET_HOST":
+      return { ...state, isHost: action.isHost };
+    default:
+      return state;
+  }
+}
+var CollaborationContext = (0, import_react12.createContext)(null);
+function generateUserColor() {
+  const colors = [
+    "#f87171",
+    "#fb923c",
+    "#fbbf24",
+    "#a3e635",
+    "#4ade80",
+    "#2dd4bf",
+    "#22d3ee",
+    "#60a5fa",
+    "#a78bfa",
+    "#e879f9"
+  ];
+  return colors[Math.floor(Math.random() * colors.length)];
+}
+function CollaborationProvider({
+  children,
+  config,
+  onStatusChange,
+  onUsersChange
+}) {
+  const [state, dispatch] = (0, import_react12.useReducer)(collaborationReducer, initialState);
+  const wsRef = (0, import_react12.useRef)(null);
+  const reconnectTimeoutRef = (0, import_react12.useRef)(null);
+  const reconnectAttemptsRef = (0, import_react12.useRef)(0);
+  (0, import_react12.useEffect)(() => {
+    onStatusChange?.(state.status);
+  }, [state.status, onStatusChange]);
+  (0, import_react12.useEffect)(() => {
+    onUsersChange?.(state.users);
+  }, [state.users, onUsersChange]);
+  const connect = (0, import_react12.useCallback)(async () => {
+    if (!config) return;
+    dispatch({ type: "SET_STATUS", status: "connecting" });
+    try {
+      if (config.provider === "websocket" && config.serverUrl) {
+        const url = new URL(config.serverUrl);
+        url.searchParams.set("room", config.roomId);
+        if (config.token) {
+          url.searchParams.set("token", config.token);
+        }
+        const ws = new WebSocket(url.toString());
+        wsRef.current = ws;
+        ws.onopen = () => {
+          dispatch({ type: "SET_STATUS", status: "connected" });
+          reconnectAttemptsRef.current = 0;
+          ws.send(JSON.stringify({
+            type: "join",
+            user: {
+              id: config.user.id,
+              name: config.user.name,
+              avatar: config.user.avatar,
+              color: config.user.color || generateUserColor()
+            }
+          }));
+        };
+        ws.onmessage = (event) => {
+          try {
+            const message = JSON.parse(event.data);
+            handleCollaborationEvent(message);
+          } catch {
+            console.error("Failed to parse collaboration message");
+          }
+        };
+        ws.onclose = () => {
+          dispatch({ type: "SET_STATUS", status: "disconnected" });
+          handleReconnect();
+        };
+        ws.onerror = () => {
+          dispatch({ type: "SET_ERROR", error: "Connection error" });
+        };
+      } else if (config.provider === "webrtc") {
+        dispatch({ type: "SET_ERROR", error: "WebRTC provider not yet implemented" });
+      } else if (config.provider === "custom") {
+        dispatch({ type: "SET_STATUS", status: "connected" });
+      }
+    } catch (error) {
+      dispatch({ type: "SET_ERROR", error: error instanceof Error ? error.message : "Connection failed" });
+    }
+  }, [config]);
+  const handleCollaborationEvent = (0, import_react12.useCallback)((event) => {
+    switch (event.type) {
+      case "user-joined":
+        dispatch({ type: "ADD_USER", user: event.user });
+        break;
+      case "user-left":
+        dispatch({ type: "REMOVE_USER", userId: event.userId });
+        break;
+      case "cursor-moved":
+        dispatch({ type: "UPDATE_CURSOR", userId: event.userId, cursor: event.cursor });
+        break;
+      case "status-changed":
+        dispatch({ type: "SET_STATUS", status: event.status });
+        break;
+      case "error":
+        dispatch({ type: "SET_ERROR", error: event.message });
+        break;
+    }
+  }, []);
+  const handleReconnect = (0, import_react12.useCallback)(() => {
+    if (!config?.autoReconnect) return;
+    const maxAttempts = config.maxReconnectAttempts ?? 5;
+    const interval = config.reconnectInterval ?? 3e3;
+    if (reconnectAttemptsRef.current >= maxAttempts) {
+      dispatch({ type: "SET_ERROR", error: "Max reconnection attempts reached" });
+      return;
+    }
+    dispatch({ type: "SET_STATUS", status: "reconnecting" });
+    reconnectAttemptsRef.current++;
+    reconnectTimeoutRef.current = setTimeout(() => {
+      connect();
+    }, interval);
+  }, [config, connect]);
+  const disconnect = (0, import_react12.useCallback)(() => {
+    if (reconnectTimeoutRef.current) {
+      clearTimeout(reconnectTimeoutRef.current);
+    }
+    if (wsRef.current) {
+      wsRef.current.close();
+      wsRef.current = null;
+    }
+    dispatch({ type: "SET_STATUS", status: "disconnected" });
+    dispatch({ type: "SET_USERS", users: [] });
+  }, []);
+  const updateCursor = (0, import_react12.useCallback)((cursor) => {
+    if (!config || !wsRef.current || wsRef.current.readyState !== WebSocket.OPEN) return;
+    wsRef.current.send(JSON.stringify({
+      type: "cursor",
+      userId: config.user.id,
+      cursor
+    }));
+  }, [config]);
+  (0, import_react12.useEffect)(() => {
+    return () => {
+      disconnect();
+    };
+  }, [disconnect]);
+  const value = {
+    state,
+    config: config ?? null,
+    connect,
+    disconnect,
+    updateCursor,
+    isEnabled: !!config
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(CollaborationContext.Provider, { value, children });
+}
+function useCollaboration() {
+  const context = (0, import_react12.useContext)(CollaborationContext);
+  if (!context) {
+    throw new Error("useCollaboration must be used within a CollaborationProvider");
+  }
+  return context;
+}
+function useCollaborationOptional() {
+  return (0, import_react12.useContext)(CollaborationContext);
+}
+
+// src/collaboration/PresenceIndicator.tsx
+var import_jsx_runtime11 = require("react/jsx-runtime");
+function getInitials(name) {
+  return name.split(" ").map((n) => n[0]).join("").toUpperCase().slice(0, 2);
+}
+function UserAvatar({ user, showName }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(
+    "div",
+    {
+      className: "rte-presence-avatar",
+      style: { borderColor: user.color },
+      title: user.name,
+      children: [
+        user.avatar ? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("img", { src: user.avatar, alt: user.name }) : /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { style: { backgroundColor: user.color }, children: getInitials(user.name) }),
+        user.isActive && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { className: "rte-presence-active-dot" }),
+        showName && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { className: "rte-presence-name", children: user.name })
+      ]
+    }
+  );
+}
+function StatusBadge({ status }) {
+  const statusConfig = {
+    connected: { label: "Connected", color: "#22c55e" },
+    connecting: { label: "Connecting...", color: "#eab308" },
+    reconnecting: { label: "Reconnecting...", color: "#f97316" },
+    disconnected: { label: "Disconnected", color: "#6b7280" },
+    error: { label: "Error", color: "#ef4444" }
+  };
+  const config = statusConfig[status] || statusConfig.disconnected;
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "rte-presence-status", style: { color: config.color }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { className: "rte-presence-status-dot", style: { backgroundColor: config.color } }),
+    config.label
+  ] });
+}
+function PresenceIndicator({
+  maxAvatars = 5,
+  showNames = false,
+  className = ""
+}) {
+  const collaboration = useCollaborationOptional();
+  if (!collaboration?.isEnabled) {
+    return null;
+  }
+  const { state } = collaboration;
+  const visibleUsers = state.users.slice(0, maxAvatars);
+  const remainingCount = Math.max(0, state.users.length - maxAvatars);
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: `rte-presence-indicator ${className}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(StatusBadge, { status: state.status }),
+    state.users.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "rte-presence-avatars", children: [
+      visibleUsers.map((user) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(UserAvatar, { user, showName: showNames }, user.id)),
+      remainingCount > 0 && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "rte-presence-avatar rte-presence-more", children: [
+        "+",
+        remainingCount
+      ] })
+    ] }),
+    state.error && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { className: "rte-presence-error", title: state.error, children: "!" })
+  ] });
+}
+
+// src/comments/types.ts
+var DEFAULT_REACTION_EMOJIS = ["\u{1F44D}", "\u{1F44E}", "\u2764\uFE0F", "\u{1F389}", "\u{1F604}", "\u{1F615}", "\u{1F440}", "\u{1F680}"];
+
+// src/comments/CommentsContext.tsx
+var import_react13 = require("react");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var initialState2 = {
+  threads: [],
+  activeThreadId: null,
+  isPanelOpen: false,
+  filter: "all",
+  currentUser: null
+};
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function commentsReducer(state, action) {
+  switch (action.type) {
+    case "SET_THREADS":
+      return { ...state, threads: action.threads };
+    case "ADD_THREAD":
+      return { ...state, threads: [...state.threads, action.thread] };
+    case "DELETE_THREAD":
+      return {
+        ...state,
+        threads: state.threads.filter((t) => t.id !== action.threadId),
+        activeThreadId: state.activeThreadId === action.threadId ? null : state.activeThreadId
+      };
+    case "RESOLVE_THREAD":
+      return {
+        ...state,
+        threads: state.threads.map(
+          (t) => t.id === action.threadId ? { ...t, status: "resolved", resolvedAt: Date.now(), resolvedBy: action.resolvedBy } : t
+        )
+      };
+    case "REOPEN_THREAD":
+      return {
+        ...state,
+        threads: state.threads.map(
+          (t) => t.id === action.threadId ? { ...t, status: "open", resolvedAt: void 0, resolvedBy: void 0 } : t
+        )
+      };
+    case "ADD_COMMENT":
+      return {
+        ...state,
+        threads: state.threads.map(
+          (t) => t.id === action.threadId ? { ...t, comments: [...t.comments, action.comment] } : t
+        )
+      };
+    case "UPDATE_COMMENT":
+      return {
+        ...state,
+        threads: state.threads.map(
+          (t) => t.id === action.threadId ? {
+            ...t,
+            comments: t.comments.map(
+              (c) => c.id === action.comment.id ? action.comment : c
+            )
+          } : t
+        )
+      };
+    case "DELETE_COMMENT":
+      return {
+        ...state,
+        threads: state.threads.map(
+          (t) => t.id === action.threadId ? { ...t, comments: t.comments.filter((c) => c.id !== action.commentId) } : t
+        )
+      };
+    case "ADD_REACTION":
+      return {
+        ...state,
+        threads: state.threads.map(
+          (t) => t.id === action.threadId ? {
+            ...t,
+            comments: t.comments.map((c) => {
+              if (c.id !== action.commentId) return c;
+              const reactions = c.reactions || [];
+              const existingReaction = reactions.find((r) => r.emoji === action.emoji);
+              if (existingReaction) {
+                return {
+                  ...c,
+                  reactions: reactions.map(
+                    (r) => r.emoji === action.emoji ? { ...r, users: [...r.users, action.user] } : r
+                  )
+                };
+              }
+              return {
+                ...c,
+                reactions: [...reactions, { emoji: action.emoji, users: [action.user] }]
+              };
+            })
+          } : t
+        )
+      };
+    case "REMOVE_REACTION":
+      return {
+        ...state,
+        threads: state.threads.map(
+          (t) => t.id === action.threadId ? {
+            ...t,
+            comments: t.comments.map((c) => {
+              if (c.id !== action.commentId) return c;
+              return {
+                ...c,
+                reactions: (c.reactions || []).map(
+                  (r) => r.emoji === action.emoji ? { ...r, users: r.users.filter((u) => u.id !== action.userId) } : r
+                ).filter((r) => r.users.length > 0)
+              };
+            })
+          } : t
+        )
+      };
+    case "SET_ACTIVE_THREAD":
+      return { ...state, activeThreadId: action.threadId };
+    case "TOGGLE_PANEL":
+      return { ...state, isPanelOpen: action.isOpen ?? !state.isPanelOpen };
+    case "SET_FILTER":
+      return { ...state, filter: action.filter };
+    case "SET_CURRENT_USER":
+      return { ...state, currentUser: action.user };
+    default:
+      return state;
+  }
+}
+var CommentsContext = (0, import_react13.createContext)(null);
+function CommentsProvider({
+  children,
+  config,
+  initialThreads = [],
+  onThreadsChange
+}) {
+  const [state, dispatch] = (0, import_react13.useReducer)(commentsReducer, {
+    ...initialState2,
+    threads: initialThreads,
+    currentUser: config?.currentUser ?? null
+  });
+  const subscribersRef = { current: /* @__PURE__ */ new Set() };
+  (0, import_react13.useEffect)(() => {
+    if (config?.onLoad) {
+      config.onLoad().then((threads) => {
+        dispatch({ type: "SET_THREADS", threads });
+      });
+    }
+  }, [config]);
+  (0, import_react13.useEffect)(() => {
+    onThreadsChange?.(state.threads);
+    if (config?.onSave) {
+      config.onSave(state.threads);
+    }
+  }, [state.threads, onThreadsChange, config]);
+  (0, import_react13.useEffect)(() => {
+    if (config?.currentUser) {
+      dispatch({ type: "SET_CURRENT_USER", user: config.currentUser });
+    }
+  }, [config?.currentUser]);
+  const emitEvent = (0, import_react13.useCallback)((event) => {
+    subscribersRef.current.forEach((callback) => callback(event));
+  }, []);
+  const createThread = (0, import_react13.useCallback)((range, initialComment) => {
+    if (!state.currentUser) return null;
+    const threadId = generateId();
+    const commentId = generateId();
+    const now = Date.now();
+    const comment = {
+      id: commentId,
+      threadId,
+      content: initialComment,
+      author: state.currentUser,
+      createdAt: now,
+      isEdited: false
+    };
+    const thread = {
+      id: threadId,
+      range,
+      comments: [comment],
+      status: "open",
+      createdAt: now
+    };
+    dispatch({ type: "ADD_THREAD", thread });
+    emitEvent({ type: "thread-created", thread });
+    return thread;
+  }, [state.currentUser, emitEvent]);
+  const deleteThread = (0, import_react13.useCallback)((threadId) => {
+    if (config?.allowDelete === false) return;
+    dispatch({ type: "DELETE_THREAD", threadId });
+    emitEvent({ type: "thread-deleted", threadId });
+  }, [config, emitEvent]);
+  const resolveThread = (0, import_react13.useCallback)((threadId) => {
+    if (!state.currentUser || config?.allowResolve === false) return;
+    dispatch({ type: "RESOLVE_THREAD", threadId, resolvedBy: state.currentUser });
+    emitEvent({ type: "thread-resolved", threadId, resolvedBy: state.currentUser });
+  }, [state.currentUser, config, emitEvent]);
+  const reopenThread = (0, import_react13.useCallback)((threadId) => {
+    dispatch({ type: "REOPEN_THREAD", threadId });
+    emitEvent({ type: "thread-reopened", threadId });
+  }, [emitEvent]);
+  const addComment = (0, import_react13.useCallback)((threadId, content) => {
+    if (!state.currentUser) return null;
+    const comment = {
+      id: generateId(),
+      threadId,
+      content,
+      author: state.currentUser,
+      createdAt: Date.now(),
+      isEdited: false
+    };
+    dispatch({ type: "ADD_COMMENT", threadId, comment });
+    emitEvent({ type: "comment-added", threadId, comment });
+    return comment;
+  }, [state.currentUser, emitEvent]);
+  const updateComment = (0, import_react13.useCallback)((threadId, commentId, content) => {
+    if (config?.allowEdit === false) return;
+    const thread = state.threads.find((t) => t.id === threadId);
+    const existingComment = thread?.comments.find((c) => c.id === commentId);
+    if (!existingComment) return;
+    const updatedComment = {
+      ...existingComment,
+      content,
+      updatedAt: Date.now(),
+      isEdited: true
+    };
+    dispatch({ type: "UPDATE_COMMENT", threadId, comment: updatedComment });
+    emitEvent({ type: "comment-updated", threadId, comment: updatedComment });
+  }, [state.threads, config, emitEvent]);
+  const deleteComment = (0, import_react13.useCallback)((threadId, commentId) => {
+    if (config?.allowDelete === false) return;
+    dispatch({ type: "DELETE_COMMENT", threadId, commentId });
+    emitEvent({ type: "comment-deleted", threadId, commentId });
+  }, [config, emitEvent]);
+  const addReaction = (0, import_react13.useCallback)((threadId, commentId, emoji) => {
+    if (!state.currentUser || config?.allowReactions === false) return;
+    const allowedEmojis = config?.reactionEmojis ?? DEFAULT_REACTION_EMOJIS;
+    if (!allowedEmojis.includes(emoji)) return;
+    dispatch({ type: "ADD_REACTION", threadId, commentId, emoji, user: state.currentUser });
+    emitEvent({ type: "reaction-added", threadId, commentId, emoji, user: state.currentUser });
+  }, [state.currentUser, config, emitEvent]);
+  const removeReaction = (0, import_react13.useCallback)((threadId, commentId, emoji) => {
+    if (!state.currentUser) return;
+    dispatch({ type: "REMOVE_REACTION", threadId, commentId, emoji, userId: state.currentUser.id });
+    emitEvent({ type: "reaction-removed", threadId, commentId, emoji, userId: state.currentUser.id });
+  }, [state.currentUser, emitEvent]);
+  const setActiveThread = (0, import_react13.useCallback)((threadId) => {
+    dispatch({ type: "SET_ACTIVE_THREAD", threadId });
+  }, []);
+  const togglePanel = (0, import_react13.useCallback)((isOpen) => {
+    dispatch({ type: "TOGGLE_PANEL", isOpen });
+  }, []);
+  const setFilter = (0, import_react13.useCallback)((filter) => {
+    dispatch({ type: "SET_FILTER", filter });
+  }, []);
+  const getThreadByRange = (0, import_react13.useCallback)((from, to) => {
+    return state.threads.find((t) => t.range.from === from && t.range.to === to);
+  }, [state.threads]);
+  const getFilteredThreads = (0, import_react13.useCallback)(() => {
+    if (state.filter === "all") return state.threads;
+    return state.threads.filter((t) => t.status === state.filter);
+  }, [state.threads, state.filter]);
+  const subscribe = (0, import_react13.useCallback)((callback) => {
+    subscribersRef.current.add(callback);
+    return () => {
+      subscribersRef.current.delete(callback);
+    };
+  }, []);
+  const value = {
+    state,
+    config: config ?? null,
+    createThread,
+    deleteThread,
+    resolveThread,
+    reopenThread,
+    addComment,
+    updateComment,
+    deleteComment,
+    addReaction,
+    removeReaction,
+    setActiveThread,
+    togglePanel,
+    setFilter,
+    getThreadByRange,
+    getFilteredThreads,
+    subscribe,
+    isEnabled: !!config
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CommentsContext.Provider, { value, children });
+}
+function useComments() {
+  const context = (0, import_react13.useContext)(CommentsContext);
+  if (!context) {
+    throw new Error("useComments must be used within a CommentsProvider");
+  }
+  return context;
+}
+function useCommentsOptional() {
+  return (0, import_react13.useContext)(CommentsContext);
+}
+
+// src/comments/CommentsPanel.tsx
+var import_react14 = require("react");
+var import_jsx_runtime13 = require("react/jsx-runtime");
+function formatRelativeTime(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const minutes = Math.floor(diff / 6e4);
+  const hours = Math.floor(diff / 36e5);
+  const days = Math.floor(diff / 864e5);
+  if (minutes < 1) return "Just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  if (days < 7) return `${days}d ago`;
+  return new Date(timestamp).toLocaleDateString();
+}
+function CommentItem({
+  comment,
+  threadId,
+  isFirst
+}) {
+  const comments = useCommentsOptional();
+  const [isEditing, setIsEditing] = (0, import_react14.useState)(false);
+  const [editContent, setEditContent] = (0, import_react14.useState)(comment.content);
+  const [showReactions, setShowReactions] = (0, import_react14.useState)(false);
+  if (!comments) return null;
+  const { config, updateComment, deleteComment, addReaction, removeReaction, state } = comments;
+  const canEdit = config?.allowEdit !== false && comment.author.id === state.currentUser?.id;
+  const canDelete = config?.allowDelete !== false && comment.author.id === state.currentUser?.id;
+  const canReact = config?.allowReactions !== false;
+  const reactionEmojis = config?.reactionEmojis ?? DEFAULT_REACTION_EMOJIS;
+  const handleSaveEdit = () => {
+    updateComment(threadId, comment.id, editContent);
+    setIsEditing(false);
+  };
+  const handleToggleReaction = (emoji) => {
+    const reaction = comment.reactions?.find((r) => r.emoji === emoji);
+    const hasReacted = reaction?.users.some((u) => u.id === state.currentUser?.id);
+    if (hasReacted) {
+      removeReaction(threadId, comment.id, emoji);
+    } else {
+      addReaction(threadId, comment.id, emoji);
+    }
+    setShowReactions(false);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: `rte-comment ${isFirst ? "rte-comment-first" : ""}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-comment-header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-comment-author", children: [
+        comment.author.avatar ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("img", { src: comment.author.avatar, alt: comment.author.name, className: "rte-comment-avatar" }) : /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-comment-avatar-placeholder", children: comment.author.name.charAt(0).toUpperCase() }),
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("span", { className: "rte-comment-author-name", children: comment.author.name })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("span", { className: "rte-comment-time", children: [
+        formatRelativeTime(comment.createdAt),
+        comment.isEdited && " (edited)"
+      ] })
+    ] }),
+    isEditing ? /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-comment-edit", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+        "textarea",
+        {
+          value: editContent,
+          onChange: (e) => setEditContent(e.target.value),
+          className: "rte-comment-edit-input"
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-comment-edit-actions", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: handleSaveEdit, className: "rte-comment-btn-save", children: "Save" }),
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: () => setIsEditing(false), className: "rte-comment-btn-cancel", children: "Cancel" })
+      ] })
+    ] }) : /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-comment-content", dangerouslySetInnerHTML: { __html: comment.content } }),
+    comment.reactions && comment.reactions.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-comment-reactions", children: comment.reactions.map((reaction) => /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+      "button",
+      {
+        className: `rte-comment-reaction ${reaction.users.some((u) => u.id === state.currentUser?.id) ? "active" : ""}`,
+        onClick: () => handleToggleReaction(reaction.emoji),
+        title: reaction.users.map((u) => u.name).join(", "),
+        children: [
+          reaction.emoji,
+          " ",
+          reaction.users.length
+        ]
+      },
+      reaction.emoji
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-comment-actions", children: [
+      canReact && /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-comment-reaction-picker", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+          "button",
+          {
+            className: "rte-comment-action-btn",
+            onClick: () => setShowReactions(!showReactions),
+            children: "\u{1F60A}"
+          }
+        ),
+        showReactions && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-comment-reaction-dropdown", children: reactionEmojis.map((emoji) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: () => handleToggleReaction(emoji), children: emoji }, emoji)) })
+      ] }),
+      canEdit && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { className: "rte-comment-action-btn", onClick: () => setIsEditing(true), children: "Edit" }),
+      canDelete && !isFirst && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+        "button",
+        {
+          className: "rte-comment-action-btn rte-comment-action-delete",
+          onClick: () => deleteComment(threadId, comment.id),
+          children: "Delete"
+        }
+      )
+    ] })
+  ] });
+}
+function ThreadItem({ thread }) {
+  const comments = useCommentsOptional();
+  const [replyContent, setReplyContent] = (0, import_react14.useState)("");
+  const [showReply, setShowReply] = (0, import_react14.useState)(false);
+  if (!comments) return null;
+  const { state, setActiveThread, addComment, resolveThread, reopenThread, deleteThread, config } = comments;
+  const isActive = state.activeThreadId === thread.id;
+  const canResolve = config?.allowResolve !== false;
+  const handleReply = () => {
+    if (replyContent.trim()) {
+      addComment(thread.id, replyContent);
+      setReplyContent("");
+      setShowReply(false);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+    "div",
+    {
+      className: `rte-thread ${isActive ? "rte-thread-active" : ""} ${thread.status === "resolved" ? "rte-thread-resolved" : ""}`,
+      onClick: () => setActiveThread(thread.id),
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-thread-header", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-thread-quote", children: [
+            '"',
+            thread.range.text.slice(0, 50),
+            '..."'
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-thread-meta", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("span", { className: `rte-thread-status rte-thread-status-${thread.status}`, children: thread.status }),
+            /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("span", { className: "rte-thread-count", children: [
+              thread.comments.length,
+              " comment",
+              thread.comments.length !== 1 ? "s" : ""
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-thread-comments", children: thread.comments.map((comment, index) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+          CommentItem,
+          {
+            comment,
+            threadId: thread.id,
+            isFirst: index === 0
+          },
+          comment.id
+        )) }),
+        thread.status === "open" && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-thread-reply", children: showReply ? /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(import_jsx_runtime13.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+            "textarea",
+            {
+              value: replyContent,
+              onChange: (e) => setReplyContent(e.target.value),
+              placeholder: "Write a reply...",
+              className: "rte-thread-reply-input"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-thread-reply-actions", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: handleReply, className: "rte-btn-primary", disabled: !replyContent.trim(), children: "Reply" }),
+            /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: () => setShowReply(false), className: "rte-btn-secondary", children: "Cancel" })
+          ] })
+        ] }) : /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: () => setShowReply(true), className: "rte-thread-reply-btn", children: "Reply" }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-thread-actions", children: [
+          canResolve && thread.status === "open" && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: () => resolveThread(thread.id), className: "rte-btn-resolve", children: "\u2713 Resolve" }),
+          thread.status === "resolved" && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: () => reopenThread(thread.id), className: "rte-btn-reopen", children: "Reopen" }),
+          /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+            "button",
+            {
+              onClick: (e) => {
+                e.stopPropagation();
+                deleteThread(thread.id);
+              },
+              className: "rte-btn-delete-thread",
+              children: "Delete"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function CommentsPanel({ position = "right", className = "" }) {
+  const comments = useCommentsOptional();
+  if (!comments?.isEnabled || !comments.state.isPanelOpen) {
+    return null;
+  }
+  const { state, togglePanel, setFilter, getFilteredThreads } = comments;
+  const filteredThreads = getFilteredThreads();
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: `rte-comments-panel rte-comments-panel-${position} ${className}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "rte-comments-panel-header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("h3", { children: "Comments" }),
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { onClick: () => togglePanel(false), className: "rte-comments-close-btn", children: "\xD7" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-comments-filters", children: ["all", "open", "resolved"].map((filter) => /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(
+      "button",
+      {
+        className: `rte-comments-filter ${state.filter === filter ? "active" : ""}`,
+        onClick: () => setFilter(filter),
+        children: [
+          filter.charAt(0).toUpperCase() + filter.slice(1),
+          /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("span", { className: "rte-comments-filter-count", children: filter === "all" ? state.threads.length : state.threads.filter((t) => t.status === filter).length })
+        ]
+      },
+      filter
+    )) }),
+    /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-comments-list", children: filteredThreads.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { className: "rte-comments-empty", children: state.filter === "all" ? "No comments yet. Select text and add a comment." : `No ${state.filter} comments.` }) : filteredThreads.map((thread) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ThreadItem, { thread }, thread.id)) })
+  ] });
+}
+
+// src/history/VersionHistoryContext.tsx
+var import_react15 = require("react");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var initialState3 = {
+  versions: [],
+  viewingVersionId: null,
+  isPanelOpen: false,
+  isComparing: false,
+  compareFromId: null,
+  compareToId: null,
+  autoSaveEnabled: true,
+  autoSaveInterval: 6e4
+};
+function generateId2() {
+  return `v-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function versionHistoryReducer(state, action) {
+  switch (action.type) {
+    case "SET_VERSIONS":
+      return { ...state, versions: action.versions };
+    case "ADD_VERSION":
+      return {
+        ...state,
+        versions: [action.version, ...state.versions]
+      };
+    case "DELETE_VERSION":
+      return {
+        ...state,
+        versions: state.versions.filter((v) => v.id !== action.versionId),
+        viewingVersionId: state.viewingVersionId === action.versionId ? null : state.viewingVersionId
+      };
+    case "PIN_VERSION":
+      return {
+        ...state,
+        versions: state.versions.map(
+          (v) => v.id === action.versionId ? { ...v, isPinned: true } : v
+        )
+      };
+    case "UNPIN_VERSION":
+      return {
+        ...state,
+        versions: state.versions.map(
+          (v) => v.id === action.versionId ? { ...v, isPinned: false } : v
+        )
+      };
+    case "RENAME_VERSION":
+      return {
+        ...state,
+        versions: state.versions.map(
+          (v) => v.id === action.versionId ? { ...v, title: action.title } : v
+        )
+      };
+    case "SET_VIEWING_VERSION":
+      return { ...state, viewingVersionId: action.versionId };
+    case "TOGGLE_PANEL":
+      return { ...state, isPanelOpen: action.isOpen ?? !state.isPanelOpen };
+    case "START_COMPARE":
+      return {
+        ...state,
+        isComparing: true,
+        compareFromId: action.fromId,
+        compareToId: action.toId
+      };
+    case "STOP_COMPARE":
+      return {
+        ...state,
+        isComparing: false,
+        compareFromId: null,
+        compareToId: null
+      };
+    case "SET_AUTO_SAVE":
+      return { ...state, autoSaveEnabled: action.enabled };
+    case "SET_AUTO_SAVE_INTERVAL":
+      return { ...state, autoSaveInterval: action.interval };
+    default:
+      return state;
+  }
+}
+function countWords(text) {
+  return text.trim().split(/\s+/).filter(Boolean).length;
+}
+function computeDiff(oldText, newText) {
+  const changes = [];
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  let i = 0;
+  let j = 0;
+  while (i < oldLines.length || j < newLines.length) {
+    if (i >= oldLines.length) {
+      changes.push({
+        type: "addition",
+        content: newLines[j],
+        position: j
+      });
+      j++;
+    } else if (j >= newLines.length) {
+      changes.push({
+        type: "deletion",
+        content: oldLines[i],
+        position: i
+      });
+      i++;
+    } else if (oldLines[i] === newLines[j]) {
+      i++;
+      j++;
+    } else {
+      const oldLineInNew = newLines.indexOf(oldLines[i], j);
+      const newLineInOld = oldLines.indexOf(newLines[j], i);
+      if (oldLineInNew === -1 && newLineInOld === -1) {
+        changes.push({
+          type: "modification",
+          content: `${oldLines[i]} -> ${newLines[j]}`,
+          position: i
+        });
+        i++;
+        j++;
+      } else if (oldLineInNew === -1) {
+        changes.push({
+          type: "deletion",
+          content: oldLines[i],
+          position: i
+        });
+        i++;
+      } else {
+        changes.push({
+          type: "addition",
+          content: newLines[j],
+          position: j
+        });
+        j++;
+      }
+    }
+  }
+  return changes;
+}
+var VersionHistoryContext = (0, import_react15.createContext)(null);
+function VersionHistoryProvider({
+  children,
+  config,
+  initialVersions = [],
+  onVersionsChange,
+  getCurrentContent
+}) {
+  const [state, dispatch] = (0, import_react15.useReducer)(versionHistoryReducer, {
+    ...initialState3,
+    versions: initialVersions,
+    autoSaveEnabled: config?.autoSave ?? true,
+    autoSaveInterval: config?.autoSaveInterval ?? 6e4
+  });
+  const subscribersRef = (0, import_react15.useRef)(/* @__PURE__ */ new Set());
+  const autoSaveTimerRef = (0, import_react15.useRef)(null);
+  const lastContentRef = (0, import_react15.useRef)("");
+  const versionNumberRef = (0, import_react15.useRef)(initialVersions.length);
+  (0, import_react15.useEffect)(() => {
+    if (config?.onLoad) {
+      config.onLoad().then((versions) => {
+        dispatch({ type: "SET_VERSIONS", versions });
+        versionNumberRef.current = versions.length;
+      });
+    }
+  }, [config]);
+  (0, import_react15.useEffect)(() => {
+    onVersionsChange?.(state.versions);
+    if (config?.onSave) {
+      config.onSave(state.versions);
+    }
+  }, [state.versions, onVersionsChange, config]);
+  (0, import_react15.useEffect)(() => {
+    if (!state.autoSaveEnabled || !config || !getCurrentContent) return;
+    autoSaveTimerRef.current = setInterval(() => {
+      const { html, json } = getCurrentContent();
+      if (html !== lastContentRef.current) {
+        lastContentRef.current = html;
+        createVersion(html, json, { isAutoSave: true });
+      }
+    }, state.autoSaveInterval);
+    return () => {
+      if (autoSaveTimerRef.current) {
+        clearInterval(autoSaveTimerRef.current);
+      }
+    };
+  }, [state.autoSaveEnabled, state.autoSaveInterval, config, getCurrentContent]);
+  const emitEvent = (0, import_react15.useCallback)((event) => {
+    subscribersRef.current.forEach((callback) => callback(event));
+  }, []);
+  const createVersion = (0, import_react15.useCallback)((content, jsonContent, options) => {
+    if (!config?.currentUser) return null;
+    const maxVersions = config.maxVersions ?? 100;
+    let versions = state.versions;
+    if (versions.length >= maxVersions) {
+      const oldestUnpinned = [...versions].reverse().find((v) => !v.isPinned);
+      if (oldestUnpinned) {
+        versions = versions.filter((v) => v.id !== oldestUnpinned.id);
+      }
+    }
+    versionNumberRef.current++;
+    const textContent = content.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+    const version = {
+      id: generateId2(),
+      number: versionNumberRef.current,
+      title: options?.title,
+      content,
+      jsonContent,
+      textContent,
+      author: config.currentUser,
+      createdAt: Date.now(),
+      wordCount: countWords(textContent),
+      characterCount: textContent.length,
+      isAutoSave: options?.isAutoSave ?? false,
+      isPinned: false
+    };
+    dispatch({ type: "ADD_VERSION", version });
+    emitEvent({ type: "version-created", version });
+    return version;
+  }, [config, state.versions, emitEvent]);
+  const deleteVersion = (0, import_react15.useCallback)((versionId) => {
+    dispatch({ type: "DELETE_VERSION", versionId });
+    emitEvent({ type: "version-deleted", versionId });
+  }, [emitEvent]);
+  const restoreVersion = (0, import_react15.useCallback)((versionId) => {
+    const version = state.versions.find((v) => v.id === versionId);
+    if (!version) return null;
+    config?.onRestore?.(version);
+    emitEvent({ type: "version-restored", versionId });
+    return version.content;
+  }, [state.versions, config, emitEvent]);
+  const pinVersion = (0, import_react15.useCallback)((versionId) => {
+    dispatch({ type: "PIN_VERSION", versionId });
+    emitEvent({ type: "version-pinned", versionId });
+  }, [emitEvent]);
+  const unpinVersion = (0, import_react15.useCallback)((versionId) => {
+    dispatch({ type: "UNPIN_VERSION", versionId });
+    emitEvent({ type: "version-unpinned", versionId });
+  }, [emitEvent]);
+  const renameVersion = (0, import_react15.useCallback)((versionId, title) => {
+    dispatch({ type: "RENAME_VERSION", versionId, title });
+    emitEvent({ type: "version-renamed", versionId, title });
+  }, [emitEvent]);
+  const viewVersion = (0, import_react15.useCallback)((versionId) => {
+    dispatch({ type: "SET_VIEWING_VERSION", versionId });
+  }, []);
+  const getVersionContent = (0, import_react15.useCallback)((versionId) => {
+    const version = state.versions.find((v) => v.id === versionId);
+    return version?.content ?? null;
+  }, [state.versions]);
+  const compareVersions = (0, import_react15.useCallback)((fromId, toId) => {
+    const fromVersion = state.versions.find((v) => v.id === fromId);
+    const toVersion = state.versions.find((v) => v.id === toId);
+    if (!fromVersion || !toVersion) return null;
+    const changes = computeDiff(fromVersion.textContent, toVersion.textContent);
+    return {
+      fromVersionId: fromId,
+      toVersionId: toId,
+      changes,
+      stats: {
+        additions: changes.filter((c) => c.type === "addition").length,
+        deletions: changes.filter((c) => c.type === "deletion").length,
+        modifications: changes.filter((c) => c.type === "modification").length
+      }
+    };
+  }, [state.versions]);
+  const startCompare = (0, import_react15.useCallback)((fromId, toId) => {
+    dispatch({ type: "START_COMPARE", fromId, toId });
+  }, []);
+  const stopCompare = (0, import_react15.useCallback)(() => {
+    dispatch({ type: "STOP_COMPARE" });
+  }, []);
+  const togglePanel = (0, import_react15.useCallback)((isOpen) => {
+    dispatch({ type: "TOGGLE_PANEL", isOpen });
+  }, []);
+  const setAutoSave = (0, import_react15.useCallback)((enabled) => {
+    dispatch({ type: "SET_AUTO_SAVE", enabled });
+    emitEvent({ type: "auto-save-toggled", enabled });
+  }, [emitEvent]);
+  const getVersion = (0, import_react15.useCallback)((versionId) => {
+    return state.versions.find((v) => v.id === versionId);
+  }, [state.versions]);
+  const getLatestVersion = (0, import_react15.useCallback)(() => {
+    return state.versions[0];
+  }, [state.versions]);
+  const getPinnedVersions = (0, import_react15.useCallback)(() => {
+    return state.versions.filter((v) => v.isPinned);
+  }, [state.versions]);
+  const subscribe = (0, import_react15.useCallback)((callback) => {
+    subscribersRef.current.add(callback);
+    return () => {
+      subscribersRef.current.delete(callback);
+    };
+  }, []);
+  const value = {
+    state,
+    config: config ?? null,
+    createVersion,
+    deleteVersion,
+    restoreVersion,
+    pinVersion,
+    unpinVersion,
+    renameVersion,
+    viewVersion,
+    getVersionContent,
+    compareVersions,
+    startCompare,
+    stopCompare,
+    togglePanel,
+    setAutoSave,
+    getVersion,
+    getLatestVersion,
+    getPinnedVersions,
+    subscribe,
+    isEnabled: !!config
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(VersionHistoryContext.Provider, { value, children });
+}
+function useVersionHistory() {
+  const context = (0, import_react15.useContext)(VersionHistoryContext);
+  if (!context) {
+    throw new Error("useVersionHistory must be used within a VersionHistoryProvider");
+  }
+  return context;
+}
+function useVersionHistoryOptional() {
+  return (0, import_react15.useContext)(VersionHistoryContext);
+}
+
+// src/history/VersionHistoryPanel.tsx
+var import_react16 = require("react");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+function formatDate(timestamp) {
+  const date = new Date(timestamp);
+  const now = /* @__PURE__ */ new Date();
+  const isToday = date.toDateString() === now.toDateString();
+  if (isToday) {
+    return `Today at ${date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`;
+  }
+  const yesterday = new Date(now);
+  yesterday.setDate(yesterday.getDate() - 1);
+  if (date.toDateString() === yesterday.toDateString()) {
+    return `Yesterday at ${date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}`;
+  }
+  return date.toLocaleDateString([], {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function VersionItem({
+  version,
+  isViewing,
+  isCompareFrom,
+  isCompareTo,
+  onView,
+  onRestore,
+  onPin,
+  onRename,
+  onDelete,
+  onCompareSelect
+}) {
+  const [isRenaming, setIsRenaming] = (0, import_react16.useState)(false);
+  const [newTitle, setNewTitle] = (0, import_react16.useState)(version.title || "");
+  const handleRename = () => {
+    onRename(newTitle);
+    setIsRenaming(false);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+    "div",
+    {
+      className: `rte-version-item ${isViewing ? "rte-version-viewing" : ""} ${isCompareFrom ? "rte-version-compare-from" : ""} ${isCompareTo ? "rte-version-compare-to" : ""}`,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-header", onClick: onView, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-info", children: [
+            isRenaming ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+              "input",
+              {
+                type: "text",
+                value: newTitle,
+                onChange: (e) => setNewTitle(e.target.value),
+                onBlur: handleRename,
+                onKeyDown: (e) => e.key === "Enter" && handleRename(),
+                className: "rte-version-rename-input",
+                onClick: (e) => e.stopPropagation(),
+                autoFocus: true
+              }
+            ) : /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("span", { className: "rte-version-title", children: [
+              version.title || `Version ${version.number}`,
+              version.isPinned && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "rte-version-pin-icon", children: "\u{1F4CC}" }),
+              version.isAutoSave && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "rte-version-auto-badge", children: "Auto" })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "rte-version-time", children: formatDate(version.createdAt) })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-author", children: [
+            version.author.avatar ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("img", { src: version.author.avatar, alt: version.author.name, className: "rte-version-avatar" }) : /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "rte-version-avatar-placeholder", children: version.author.name.charAt(0).toUpperCase() }),
+            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { children: version.author.name })
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-stats", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("span", { children: [
+            version.wordCount,
+            " words"
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("span", { children: [
+            version.characterCount,
+            " chars"
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-actions", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { onClick: onRestore, className: "rte-version-btn", title: "Restore this version", children: "\u21BA Restore" }),
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { onClick: onCompareSelect, className: "rte-version-btn", title: "Compare with another version", children: "\u21C4 Compare" }),
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { onClick: onPin, className: "rte-version-btn", title: version.isPinned ? "Unpin" : "Pin", children: version.isPinned ? "\u{1F4CC} Unpin" : "\u{1F4CC} Pin" }),
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+            "button",
+            {
+              onClick: () => setIsRenaming(true),
+              className: "rte-version-btn",
+              title: "Rename version",
+              children: "\u270F\uFE0F"
+            }
+          ),
+          !version.isPinned && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { onClick: onDelete, className: "rte-version-btn rte-version-btn-delete", title: "Delete", children: "\u{1F5D1}\uFE0F" })
+        ] })
+      ]
+    }
+  );
+}
+function ComparisonView({
+  fromVersion,
+  toVersion,
+  onClose
+}) {
+  const versionHistory = useVersionHistoryOptional();
+  if (!versionHistory) return null;
+  const comparison = versionHistory.compareVersions(fromVersion.id, toVersion.id);
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-comparison", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-comparison-header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("h4", { children: "Comparing Versions" }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { onClick: onClose, className: "rte-version-comparison-close", children: "\xD7" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-comparison-info", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-comparison-from", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "rte-version-comparison-label", children: "From:" }),
+        fromVersion.title || `Version ${fromVersion.number}`
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "rte-version-comparison-arrow", children: "\u2192" }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-comparison-to", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "rte-version-comparison-label", children: "To:" }),
+        toVersion.title || `Version ${toVersion.number}`
+      ] })
+    ] }),
+    comparison && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-comparison-stats", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("span", { className: "rte-comparison-stat rte-comparison-additions", children: [
+        "+",
+        comparison.stats.additions,
+        " additions"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("span", { className: "rte-comparison-stat rte-comparison-deletions", children: [
+        "-",
+        comparison.stats.deletions,
+        " deletions"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("span", { className: "rte-comparison-stat rte-comparison-modifications", children: [
+        "~",
+        comparison.stats.modifications,
+        " modifications"
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "rte-version-comparison-diff", children: comparison?.changes.map((change, index) => /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: `rte-diff-line rte-diff-${change.type}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "rte-diff-indicator", children: change.type === "addition" ? "+" : change.type === "deletion" ? "-" : "~" }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "rte-diff-content", children: change.content })
+    ] }, index)) })
+  ] });
+}
+function VersionHistoryPanel({ position = "right", className = "" }) {
+  const versionHistory = useVersionHistoryOptional();
+  const [compareFromId, setCompareFromId] = (0, import_react16.useState)(null);
+  if (!versionHistory?.isEnabled || !versionHistory.state.isPanelOpen) {
+    return null;
+  }
+  const {
+    state,
+    togglePanel,
+    viewVersion,
+    restoreVersion,
+    pinVersion,
+    unpinVersion,
+    renameVersion,
+    deleteVersion,
+    setAutoSave,
+    getVersion,
+    createVersion,
+    stopCompare
+  } = versionHistory;
+  const handleRestore = (versionId) => {
+    const content = restoreVersion(versionId);
+    if (content) {
+      viewVersion(null);
+    }
+  };
+  const handleCompareSelect = (versionId) => {
+    if (!compareFromId) {
+      setCompareFromId(versionId);
+    } else {
+      versionHistory.startCompare(compareFromId, versionId);
+      setCompareFromId(null);
+    }
+  };
+  const handleCancelCompare = () => {
+    setCompareFromId(null);
+    stopCompare();
+  };
+  const compareFromVersion = state.compareFromId ? getVersion(state.compareFromId) : void 0;
+  const compareToVersion = state.compareToId ? getVersion(state.compareToId) : void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: `rte-version-panel rte-version-panel-${position} ${className}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-panel-header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("h3", { children: "Version History" }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { onClick: () => togglePanel(false), className: "rte-version-close-btn", children: "\xD7" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-autosave", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("label", { className: "rte-version-autosave-label", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          "input",
+          {
+            type: "checkbox",
+            checked: state.autoSaveEnabled,
+            onChange: (e) => setAutoSave(e.target.checked)
+          }
+        ),
+        "Auto-save versions"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+        "button",
+        {
+          onClick: () => createVersion("", void 0, { isAutoSave: false }),
+          className: "rte-version-save-btn",
+          children: "Save Now"
+        }
+      )
+    ] }),
+    compareFromId && !state.isComparing && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-compare-mode", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { children: "Select another version to compare" }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { onClick: handleCancelCompare, children: "Cancel" })
+    ] }),
+    state.isComparing && compareFromVersion && compareToVersion && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      ComparisonView,
+      {
+        fromVersion: compareFromVersion,
+        toVersion: compareToVersion,
+        onClose: handleCancelCompare
+      }
+    ),
+    !state.isComparing && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "rte-version-list", children: state.versions.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "rte-version-empty", children: "No versions saved yet. Changes will be auto-saved periodically." }) : /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_jsx_runtime15.Fragment, { children: [
+      state.versions.some((v) => v.isPinned) && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-section", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "rte-version-section-title", children: "\u{1F4CC} Pinned" }),
+        state.versions.filter((v) => v.isPinned).map((version) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          VersionItem,
+          {
+            version,
+            isViewing: state.viewingVersionId === version.id,
+            isCompareFrom: compareFromId === version.id,
+            isCompareTo: false,
+            onView: () => viewVersion(version.id),
+            onRestore: () => handleRestore(version.id),
+            onPin: () => unpinVersion(version.id),
+            onRename: (title) => renameVersion(version.id, title),
+            onDelete: () => deleteVersion(version.id),
+            onCompareSelect: () => handleCompareSelect(version.id)
+          },
+          version.id
+        ))
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-section", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "rte-version-section-title", children: "Recent" }),
+        state.versions.filter((v) => !v.isPinned).map((version) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+          VersionItem,
+          {
+            version,
+            isViewing: state.viewingVersionId === version.id,
+            isCompareFrom: compareFromId === version.id,
+            isCompareTo: false,
+            onView: () => viewVersion(version.id),
+            onRestore: () => handleRestore(version.id),
+            onPin: () => pinVersion(version.id),
+            onRename: (title) => renameVersion(version.id, title),
+            onDelete: () => deleteVersion(version.id),
+            onCompareSelect: () => handleCompareSelect(version.id)
+          },
+          version.id
+        ))
+      ] })
+    ] }) }),
+    state.viewingVersionId && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "rte-version-viewing-indicator", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("span", { children: [
+        "Viewing: ",
+        getVersion(state.viewingVersionId)?.title || `Version ${getVersion(state.viewingVersionId)?.number}`
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { onClick: () => viewVersion(null), className: "rte-version-back-btn", children: "\u2190 Back to current" })
+    ] })
+  ] });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CollaborationProvider,
+  CommentsPanel,
+  CommentsProvider,
   DEFAULT_FEATURES,
+  DEFAULT_REACTION_EMOJIS,
   EMOJI_CATEGORIES,
   EditorRegistry,
   Emoji,
@@ -8685,12 +7933,15 @@ init_Indent();
   Fullscreen,
   Indent,
   LineHeight,
+  PresenceIndicator,
   Print,
   RichTextEditor,
   TipTapAdapter,
   TipTapEditorComponent,
   TipTapToolbar,
   UnifiedEditor,
+  VersionHistoryPanel,
+  VersionHistoryProvider,
   Video,
   blogToolbar,
   codeToolbar,
@@ -8712,6 +7963,12 @@ init_Indent();
   registerAdapter,
   simpleToolbar,
   toolbarPresets,
-  unregisterAdapter
+  unregisterAdapter,
+  useCollaboration,
+  useCollaborationOptional,
+  useComments,
+  useCommentsOptional,
+  useVersionHistory,
+  useVersionHistoryOptional
 });
 //# sourceMappingURL=index.js.map