@cyberyozh/text-editor 0.1.1

package/dist/render.js

@@ -0,0 +1,2521 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/render/index.ts
+var render_exports = {};
+__export(render_exports, {
+  TiptapRender: () => TiptapRender
+});
+module.exports = __toCommonJS(render_exports);
+
+// src/render/tiptap-render.tsx
+var import_react2 = require("@tiptap/static-renderer/pm/react");
+
+// src/extensions/render/get-render-extensions.ts
+var import_extension_mathematics = require("@tiptap/extension-mathematics");
+var import_extension_table = require("@tiptap/extension-table");
+
+// src/utils/handle-exit-node.ts
+var import_state = require("@tiptap/pm/state");
+function handleExitNode(editor, nodeName) {
+  const { view, schema } = editor;
+  const { state } = view;
+  const { selection } = state;
+  const $pos = selection.$from;
+  const currentNode = $pos.node();
+  let depth = $pos.depth;
+  let isInsideTargetNode = false;
+  let targetNodeDepth = 0;
+  while (depth > 0) {
+    const parentNode = $pos.node(depth);
+    if (parentNode.type.name === nodeName) {
+      isInsideTargetNode = true;
+      targetNodeDepth = depth;
+      break;
+    }
+    depth--;
+  }
+  const isCurrentNodeEmptyParagraph = currentNode.type.name === "paragraph" && currentNode.content.size === 0;
+  if (!isInsideTargetNode || !isCurrentNodeEmptyParagraph) {
+    return false;
+  }
+  const { tr } = state;
+  const posAfterTargetNode = $pos.after(targetNodeDepth);
+  const targetNode = $pos.node(targetNodeDepth);
+  let newPosAfterTargetNode = posAfterTargetNode;
+  if (targetNode.childCount > 1) {
+    const emptyParagraphStart = $pos.before();
+    const emptyParagraphEnd = $pos.after();
+    const deletionLength = emptyParagraphEnd - emptyParagraphStart;
+    tr.delete(emptyParagraphStart, emptyParagraphEnd);
+    newPosAfterTargetNode = posAfterTargetNode - deletionLength;
+  }
+  const paragraphNode = schema.nodes.paragraph.createAndFill();
+  if (!paragraphNode) return false;
+  tr.insert(newPosAfterTargetNode, paragraphNode);
+  tr.setSelection(import_state.TextSelection.create(tr.doc, newPosAfterTargetNode + 1));
+  view.dispatch(tr);
+  return true;
+}
+
+// src/utils/migrate-legacy-callouts.ts
+var legacyTypeMap = {
+  question: "info",
+  idea: "warning",
+  info: "success",
+  error: "error"
+};
+function migrateLegacyCallouts(editor) {
+  const { doc, schema } = editor.state;
+  const calloutsToMigrate = [];
+  doc.descendants((node, pos) => {
+    if (node.type.name === "callout" && node.attrs.calloutType) {
+      calloutsToMigrate.push({ node, pos });
+    }
+  });
+  if (calloutsToMigrate.length === 0) return;
+  const tr = editor.state.tr;
+  calloutsToMigrate.sort((a, b) => b.pos - a.pos);
+  for (const { node, pos } of calloutsToMigrate) {
+    const oldType = node.attrs.calloutType;
+    const newType = legacyTypeMap[oldType] || oldType;
+    const hasInlineContent = node.content.size > 0 && !node.firstChild?.isBlock;
+    if (hasInlineContent) {
+      const paragraph = schema.nodes.paragraph?.create(null, node.content);
+      const newContent = paragraph ? [paragraph] : [];
+      tr.replaceRangeWith(
+        pos,
+        pos + node.nodeSize,
+        schema.nodes.callout.create(
+          {
+            type: newType,
+            calloutType: null,
+            callout: null
+          },
+          newContent
+        )
+      );
+    } else {
+      tr.setNodeMarkup(pos, void 0, {
+        ...node.attrs,
+        type: newType,
+        calloutType: null,
+        callout: null
+      });
+    }
+  }
+  editor.view.dispatch(tr);
+}
+
+// src/extensions/base/callout.ts
+var import_core = require("@tiptap/core");
+var legacyTypeMap2 = {
+  question: "info",
+  idea: "warning",
+  info: "success",
+  error: "error"
+};
+var BaseCallout = import_core.Node.create({
+  name: "callout",
+  group: "block",
+  content: "block+",
+  draggable: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      type: {
+        default: "info",
+        parseHTML: (element) => {
+          if (typeof element === "string") return "info";
+          const dataCallout = element.getAttribute("data-callout");
+          if (dataCallout) {
+            return dataCallout;
+          }
+          const legacyType = element.getAttribute("calloutType");
+          if (legacyType) {
+            return legacyTypeMap2[legacyType];
+          }
+          if (element.classList) {
+            if (element.classList.contains("callout--error")) return "error";
+            if (element.classList.contains("callout--question")) return "info";
+            if (element.classList.contains("callout--idea")) return "warning";
+            if (element.classList.contains("callout--info")) return "success";
+          }
+          return "info";
+        },
+        renderHTML: (attributes) => {
+          return {
+            "data-callout": attributes.type
+          };
+        }
+      },
+      bgColor: {
+        default: null,
+        parseHTML: (element) => {
+          if (typeof element === "string") return null;
+          return element.getAttribute("data-bg-color");
+        },
+        renderHTML: (attributes) => {
+          if (!attributes.bgColor) return {};
+          return {
+            "data-bg-color": attributes.bgColor
+          };
+        }
+      },
+      emoji: {
+        default: null,
+        parseHTML: (element) => {
+          if (typeof element === "string") return null;
+          return element.getAttribute("data-emoji");
+        },
+        renderHTML: (attributes) => {
+          if (!attributes.emoji) return {};
+          return {
+            "data-emoji": attributes.emoji
+          };
+        }
+      },
+      calloutType: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("calloutType"),
+        renderHTML: () => ({})
+      },
+      callout: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("callout"),
+        renderHTML: () => ({})
+      }
+    };
+  },
+  onCreate() {
+    migrateLegacyCallouts(this.editor);
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => handleExitNode(this.editor, this.name)
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-callout]"
+      },
+      {
+        tag: "callout",
+        priority: 51
+      },
+      {
+        tag: "div",
+        priority: 50,
+        getAttrs: (element) => {
+          if (typeof element === "string") return false;
+          if (element.classList.contains("callout") || element.classList.contains("callout--error") || element.classList.contains("callout--question") || element.classList.contains("callout--idea") || element.classList.contains("callout--info")) {
+            return {};
+          }
+          return false;
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core.mergeAttributes)(HTMLAttributes), 0];
+  }
+});
+
+// src/extensions/base/code-block.ts
+var import_extension_code_block_lowlight = require("@tiptap/extension-code-block-lowlight");
+var import_xml = __toESM(require("highlight.js/lib/languages/xml"));
+var import_lowlight = require("lowlight");
+var lowlight = (0, import_lowlight.createLowlight)(import_lowlight.common);
+lowlight.register("html", import_xml.default);
+var BaseCodeBlock = import_extension_code_block_lowlight.CodeBlockLowlight.configure({
+  lowlight
+}).extend({
+  selectable: false,
+  draggable: true,
+  addAttributes() {
+    return {
+      language: {
+        default: null,
+        parseHTML: (element) => {
+          return element.querySelector("code")?.getAttribute("data-language") || "bash";
+        }
+      }
+    };
+  }
+});
+
+// src/extensions/base/copyable-text.ts
+var import_core2 = require("@tiptap/core");
+var CopyableText = import_core2.Mark.create({
+  name: "copyable-text",
+  addOptions() {
+    return {
+      HTMLAttributes: {
+        class: "copyable"
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span",
+        getAttrs: (element) => element.classList.contains("copyable") ? {} : false
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", (0, import_core2.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      setCopyable: (attributes) => ({ commands }) => {
+        return commands.setMark(this.name, attributes);
+      },
+      toggleCopyable: (attributes) => ({ commands }) => {
+        return commands.toggleMark(this.name, attributes);
+      },
+      unsetCopyable: () => ({ commands }) => {
+        return commands.unsetMark(this.name);
+      }
+    };
+  }
+});
+
+// src/extensions/base/custom-quote.ts
+var import_core3 = require("@tiptap/core");
+var import_state2 = require("@tiptap/pm/state");
+var BaseCustomQuote = import_core3.Node.create({
+  name: "customQuote",
+  group: "block",
+  content: "customQuoteText customQuoteAuthor customQuoteSign",
+  selectable: false,
+  draggable: true,
+  isolating: true,
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => {
+        const { view, schema } = this.editor;
+        const { state } = view;
+        const { selection } = state;
+        const $pos = selection.$from;
+        let depth = $pos.depth;
+        let isInsideCustomQuote = false;
+        while (depth > 0) {
+          const parentNode = $pos.node(depth);
+          if (parentNode.type.name === this.name) {
+            isInsideCustomQuote = true;
+            break;
+          }
+          depth--;
+        }
+        if (!isInsideCustomQuote) {
+          return false;
+        }
+        const { tr } = state;
+        const posAfter = $pos.after(depth);
+        const paragraphNode = schema.nodes.paragraph.createAndFill();
+        if (!paragraphNode) return false;
+        tr.insert(posAfter, paragraphNode);
+        tr.setSelection(import_state2.TextSelection.create(tr.doc, posAfter + 1));
+        view.dispatch(tr);
+        return true;
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-custom-quote]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core3.mergeAttributes)(HTMLAttributes, { "data-custom-quote": "" }), 0];
+  }
+});
+var BaseCustomQuoteText = import_core3.Node.create({
+  name: "customQuoteText",
+  group: "block",
+  content: "inline*",
+  draggable: false,
+  selectable: true,
+  addAttributes() {
+    return {
+      open: {
+        default: true
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => {
+        const { view, state } = this.editor;
+        const { tr, selection } = state;
+        const { $from } = selection;
+        if ($from.parent.type.name !== "customQuoteText") {
+          return false;
+        }
+        const posAfter = $from.after();
+        const nextNode = state.doc.nodeAt(posAfter);
+        if (!nextNode || nextNode.type.name !== "customQuoteAuthor") return false;
+        const nextNodeEnd = posAfter + nextNode.nodeSize - 1;
+        tr.setSelection(import_state2.TextSelection.create(tr.doc, nextNodeEnd));
+        view.dispatch(tr);
+        return true;
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-custom-quote-text]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core3.mergeAttributes)(HTMLAttributes, { "data-custom-quote-text": "" }), 0];
+  }
+});
+var BaseCustomQuoteAuthor = import_core3.Node.create({
+  name: "customQuoteAuthor",
+  group: "block",
+  content: "inline*",
+  selectable: true,
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => {
+        const { view, state } = this.editor;
+        const { tr, selection } = state;
+        const { $from } = selection;
+        if ($from.parent.type.name !== "customQuoteAuthor") {
+          return false;
+        }
+        const posAfter = $from.after();
+        const nextNode = state.doc.nodeAt(posAfter);
+        if (!nextNode || nextNode.type.name !== "customQuoteSign") return false;
+        const nextNodeEnd = posAfter + nextNode.nodeSize - 1;
+        tr.setSelection(import_state2.TextSelection.create(tr.doc, nextNodeEnd));
+        view.dispatch(tr);
+        return true;
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-custom-quote-author]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core3.mergeAttributes)(HTMLAttributes, { "data-custom-quote-author": "" }), 0];
+  }
+});
+var BaseCustomQuoteSign = import_core3.Node.create({
+  name: "customQuoteSign",
+  group: "block",
+  content: "inline*",
+  selectable: true,
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-custom-quote-sign]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core3.mergeAttributes)(HTMLAttributes, { "data-custom-quote-sign": "" }), 0];
+  }
+});
+
+// src/extensions/base/link.ts
+var import_extension_link = __toESM(require("@tiptap/extension-link"));
+var LinkExtension = import_extension_link.default.extend({
+  addOptions() {
+    return {
+      ...this.parent?.(),
+      openOnClick: false,
+      linkOnPaste: true,
+      autolink: true,
+      protocols: ["http", "https", "mailto", "tel"]
+    };
+  }
+}).configure({
+  openOnClick: false,
+  linkOnPaste: true,
+  autolink: true,
+  protocols: ["http", "https", "mailto", "tel"]
+});
+
+// src/extensions/base/myth-reality.ts
+var import_core4 = require("@tiptap/core");
+var BaseMythRealityBlock = import_core4.Node.create({
+  name: "mythRealityBlock",
+  group: "block",
+  content: "block+",
+  parseHTML() {
+    return [{ tag: "div[data-myth-reality-block]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      (0, import_core4.mergeAttributes)(HTMLAttributes, { "data-myth-reality-block": "" }),
+      ["div", { class: "myth-reality-block-content" }, 0]
+    ];
+  }
+});
+var BaseMythReality = import_core4.Node.create({
+  name: "mythReality",
+  group: "block",
+  content: "(mythRealityBlock) (mythRealityBlock)",
+  draggable: true,
+  isolating: true,
+  parseHTML() {
+    return [{ tag: "div[data-myth-reality]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core4.mergeAttributes)(HTMLAttributes, { "data-myth-reality": "" }), 0];
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => handleExitNode(this.editor, this.name)
+    };
+  }
+});
+
+// src/extensions/base/prompt.ts
+var import_core5 = require("@tiptap/core");
+var import_state3 = require("@tiptap/pm/state");
+var BasePrompt = import_core5.Node.create({
+  name: "prompt",
+  group: "block",
+  content: "(promptHeader | promptV2Header) (promptContent | promptV2Content)",
+  selectable: false,
+  draggable: true,
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => {
+        const { view, schema } = this.editor;
+        const { state } = view;
+        const { selection } = state;
+        const $pos = selection.$from;
+        let depth = $pos.depth;
+        let isInsidePrompt = false;
+        while (depth > 0) {
+          const parentNode = $pos.node(depth);
+          if (parentNode.type.name === this.name) {
+            isInsidePrompt = true;
+            break;
+          }
+          depth--;
+        }
+        if (!isInsidePrompt) {
+          return false;
+        }
+        const { tr } = state;
+        const posAfter = $pos.after(depth);
+        const paragraphNode = schema.nodes.paragraph.createAndFill();
+        if (!paragraphNode) return false;
+        tr.insert(posAfter, paragraphNode);
+        tr.setSelection(import_state3.TextSelection.create(tr.doc, posAfter + 1));
+        view.dispatch(tr);
+        return true;
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-prompt]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core5.mergeAttributes)(HTMLAttributes, { "data-prompt": "" }), 0];
+  }
+});
+var BasePromptHeader = import_core5.Node.create({
+  name: "promptHeader",
+  group: "block",
+  content: "inline*",
+  selectable: true,
+  draggable: false,
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-prompt-header]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core5.mergeAttributes)(HTMLAttributes, { "data-prompt-header": "" }), 0];
+  }
+  // addNodeView() {
+  //   return ReactNodeViewRenderer(PromptHeaderView);
+  // },
+});
+var BasePromptContent = import_core5.Node.create({
+  name: "promptContent",
+  group: "block",
+  content: "text*",
+  draggable: false,
+  selectable: true,
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-prompt-content]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core5.mergeAttributes)(HTMLAttributes, { "data-prompt-content": "" }), 0];
+  }
+  // addNodeView() {
+  //   return ReactNodeViewRenderer(PromptContentView);
+  // },
+});
+
+// src/extensions/base/video.ts
+var import_core6 = require("@tiptap/core");
+var BaseVideo = import_core6.Node.create({
+  name: "video",
+  group: "block",
+  selectable: true,
+  draggable: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      src: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "video-embed"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["video-embed", HTMLAttributes];
+  }
+});
+
+// src/extensions/base/figure.ts
+var import_core7 = require("@tiptap/core");
+var import_extension_image = __toESM(require("@tiptap/extension-image"));
+
+// src/utils/image-src-resolver.ts
+function resolveImageSrc(attrs, options) {
+  const { fileId, src } = attrs;
+  const { getImageById } = options || {};
+  if (fileId && getImageById) {
+    const resolvedSrc = getImageById(fileId);
+    if (resolvedSrc) {
+      return resolvedSrc;
+    }
+    console.warn(`Failed to resolve fileId: ${fileId}`);
+    return "";
+  }
+  if (src) {
+    return src;
+  }
+  if (fileId) {
+    console.warn("fileId provided but no getImageById function - cannot resolve image");
+    return "";
+  }
+  return "";
+}
+
+// src/extensions/base/figure.ts
+var BaseFigure = import_extension_image.default.extend({
+  name: "image",
+  group: "block",
+  content: "",
+  draggable: true,
+  isolating: true,
+  selectable: false,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      getImageById: void 0,
+      onFigureClick: void 0
+    };
+  },
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      fileId: {
+        default: null,
+        parseHTML: (element) => {
+          const img = element.querySelector("img") || element;
+          return img.getAttribute("data-file-id") || element.getAttribute("data-file-id");
+        },
+        renderHTML: (attributes) => {
+          if (!attributes.fileId) return {};
+          return { "data-file-id": attributes.fileId };
+        }
+      },
+      caption: {
+        default: null,
+        parseHTML: (element) => element.querySelector("figcaption")?.textContent || null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "figure",
+        getAttrs: (element) => {
+          if (typeof element === "string") return false;
+          const img = element.querySelector("img");
+          return img ? {} : false;
+        }
+      },
+      {
+        tag: "img[src]",
+        getAttrs: (element) => {
+          if (typeof element === "string") return false;
+          return {};
+        }
+      }
+    ];
+  },
+  renderHTML({ node }) {
+    const resolvedSrc = resolveImageSrc(
+      {
+        fileId: node.attrs.fileId,
+        src: node.attrs.src
+      },
+      { getImageById: this.options.getImageById }
+    );
+    const figureAttrs = (0, import_core7.mergeAttributes)(this.options.HTMLAttributes);
+    const imgAttrs = {
+      src: resolvedSrc
+    };
+    if (node.attrs.fileId) imgAttrs["data-file-id"] = node.attrs.fileId;
+    if (node.attrs.alt) imgAttrs.alt = node.attrs.alt;
+    if (node.attrs.title) imgAttrs.title = node.attrs.title;
+    if (node.attrs.width) imgAttrs.width = node.attrs.width;
+    if (node.attrs.height) imgAttrs.height = node.attrs.height;
+    const hasCaption = node.attrs.caption && node.attrs.caption.trim().length > 0;
+    const figcaptionContent = hasCaption ? ["figcaption", {}, node.attrs.caption] : null;
+    return [
+      "figure",
+      figureAttrs,
+      ["img", imgAttrs],
+      ...figcaptionContent ? [figcaptionContent] : []
+    ];
+  },
+  addCommands() {
+    return {
+      ...this.parent?.(),
+      setFigure: (options) => ({ commands }) => {
+        return commands.insertContent({
+          type: this.name,
+          attrs: options
+        });
+      },
+      updateFigure: (options) => ({ commands }) => {
+        return commands.updateAttributes(this.name, options);
+      }
+    };
+  },
+  addPasteRules() {
+    return [
+      (0, import_core7.nodePasteRule)({
+        find: /!\[(.*?)\]\((.*?)(?:\s+"(.*?)")?\)/g,
+        type: this.type,
+        getAttributes: (match) => {
+          const [, alt, src, title] = match;
+          return { src, alt, title };
+        }
+      })
+    ];
+  }
+});
+
+// src/utils/get-shared-extensions.ts
+var import_starter_kit = __toESM(require("@tiptap/starter-kit"));
+var import_extension_details = require("@tiptap/extension-details");
+var import_extension_highlight = __toESM(require("@tiptap/extension-highlight"));
+var import_extension_subscript = __toESM(require("@tiptap/extension-subscript"));
+var import_extension_superscript = __toESM(require("@tiptap/extension-superscript"));
+var import_extension_text_align = __toESM(require("@tiptap/extension-text-align"));
+
+// node_modules/@tiptap/extension-text-style/dist/index.js
+var import_core8 = require("@tiptap/core");
+var import_core9 = require("@tiptap/core");
+var import_core10 = require("@tiptap/core");
+var import_core11 = require("@tiptap/core");
+var import_core12 = require("@tiptap/core");
+var import_core13 = require("@tiptap/core");
+var import_core14 = require("@tiptap/core");
+var MAX_FIND_CHILD_SPAN_DEPTH = 20;
+var findChildSpans = (element, depth = 0) => {
+  const childSpans = [];
+  if (!element.children.length || depth > MAX_FIND_CHILD_SPAN_DEPTH) {
+    return childSpans;
+  }
+  Array.from(element.children).forEach((child) => {
+    if (child.tagName === "SPAN") {
+      childSpans.push(child);
+    } else if (child.children.length) {
+      childSpans.push(...findChildSpans(child, depth + 1));
+    }
+  });
+  return childSpans;
+};
+var mergeNestedSpanStyles = (element) => {
+  if (!element.children.length) {
+    return;
+  }
+  const childSpans = findChildSpans(element);
+  if (!childSpans) {
+    return;
+  }
+  childSpans.forEach((childSpan) => {
+    var _a, _b;
+    const childStyle = childSpan.getAttribute("style");
+    const closestParentSpanStyleOfChild = (_b = (_a = childSpan.parentElement) == null ? void 0 : _a.closest("span")) == null ? void 0 : _b.getAttribute("style");
+    childSpan.setAttribute("style", `${closestParentSpanStyleOfChild};${childStyle}`);
+  });
+};
+var TextStyle = import_core8.Mark.create({
+  name: "textStyle",
+  priority: 101,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      mergeNestedSpanStyles: true
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span",
+        consuming: false,
+        getAttrs: (element) => {
+          const hasStyles = element.hasAttribute("style");
+          if (!hasStyles) {
+            return false;
+          }
+          if (this.options.mergeNestedSpanStyles) {
+            mergeNestedSpanStyles(element);
+          }
+          return {};
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", (0, import_core8.mergeAttributes)(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  addCommands() {
+    return {
+      toggleTextStyle: (attributes) => ({ commands }) => {
+        return commands.toggleMark(this.name, attributes);
+      },
+      removeEmptyTextStyle: () => ({ tr }) => {
+        const { selection } = tr;
+        tr.doc.nodesBetween(selection.from, selection.to, (node, pos) => {
+          if (node.isTextblock) {
+            return true;
+          }
+          if (!node.marks.filter((mark) => mark.type === this.type).some((mark) => Object.values(mark.attrs).some((value) => !!value))) {
+            tr.removeMark(pos, pos + node.nodeSize, this.type);
+          }
+        });
+        return true;
+      }
+    };
+  }
+});
+var BackgroundColor = import_core9.Extension.create({
+  name: "backgroundColor",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          backgroundColor: {
+            default: null,
+            parseHTML: (element) => {
+              var _a;
+              const styleAttr = element.getAttribute("style");
+              if (styleAttr) {
+                const decls = styleAttr.split(";").map((s) => s.trim()).filter(Boolean);
+                for (let i = decls.length - 1; i >= 0; i -= 1) {
+                  const parts = decls[i].split(":");
+                  if (parts.length >= 2) {
+                    const prop = parts[0].trim().toLowerCase();
+                    const val = parts.slice(1).join(":").trim();
+                    if (prop === "background-color") {
+                      return val.replace(/['"]+/g, "");
+                    }
+                  }
+                }
+              }
+              return (_a = element.style.backgroundColor) == null ? void 0 : _a.replace(/['"]+/g, "");
+            },
+            renderHTML: (attributes) => {
+              if (!attributes.backgroundColor) {
+                return {};
+              }
+              return {
+                style: `background-color: ${attributes.backgroundColor}`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setBackgroundColor: (backgroundColor) => ({ chain }) => {
+        return chain().setMark("textStyle", { backgroundColor }).run();
+      },
+      unsetBackgroundColor: () => ({ chain }) => {
+        return chain().setMark("textStyle", { backgroundColor: null }).removeEmptyTextStyle().run();
+      }
+    };
+  }
+});
+var Color = import_core10.Extension.create({
+  name: "color",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          color: {
+            default: null,
+            parseHTML: (element) => {
+              var _a;
+              const styleAttr = element.getAttribute("style");
+              if (styleAttr) {
+                const decls = styleAttr.split(";").map((s) => s.trim()).filter(Boolean);
+                for (let i = decls.length - 1; i >= 0; i -= 1) {
+                  const parts = decls[i].split(":");
+                  if (parts.length >= 2) {
+                    const prop = parts[0].trim().toLowerCase();
+                    const val = parts.slice(1).join(":").trim();
+                    if (prop === "color") {
+                      return val.replace(/['"]+/g, "");
+                    }
+                  }
+                }
+              }
+              return (_a = element.style.color) == null ? void 0 : _a.replace(/['"]+/g, "");
+            },
+            renderHTML: (attributes) => {
+              if (!attributes.color) {
+                return {};
+              }
+              return {
+                style: `color: ${attributes.color}`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setColor: (color) => ({ chain }) => {
+        return chain().setMark("textStyle", { color }).run();
+      },
+      unsetColor: () => ({ chain }) => {
+        return chain().setMark("textStyle", { color: null }).removeEmptyTextStyle().run();
+      }
+    };
+  }
+});
+var FontFamily = import_core11.Extension.create({
+  name: "fontFamily",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontFamily: {
+            default: null,
+            parseHTML: (element) => element.style.fontFamily,
+            renderHTML: (attributes) => {
+              if (!attributes.fontFamily) {
+                return {};
+              }
+              return {
+                style: `font-family: ${attributes.fontFamily}`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontFamily: (fontFamily) => ({ chain }) => {
+        return chain().setMark("textStyle", { fontFamily }).run();
+      },
+      unsetFontFamily: () => ({ chain }) => {
+        return chain().setMark("textStyle", { fontFamily: null }).removeEmptyTextStyle().run();
+      }
+    };
+  }
+});
+var FontSize = import_core12.Extension.create({
+  name: "fontSize",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            default: null,
+            parseHTML: (element) => element.style.fontSize,
+            renderHTML: (attributes) => {
+              if (!attributes.fontSize) {
+                return {};
+              }
+              return {
+                style: `font-size: ${attributes.fontSize}`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontSize: (fontSize) => ({ chain }) => {
+        return chain().setMark("textStyle", { fontSize }).run();
+      },
+      unsetFontSize: () => ({ chain }) => {
+        return chain().setMark("textStyle", { fontSize: null }).removeEmptyTextStyle().run();
+      }
+    };
+  }
+});
+var LineHeight = import_core13.Extension.create({
+  name: "lineHeight",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          lineHeight: {
+            default: null,
+            parseHTML: (element) => element.style.lineHeight,
+            renderHTML: (attributes) => {
+              if (!attributes.lineHeight) {
+                return {};
+              }
+              return {
+                style: `line-height: ${attributes.lineHeight}`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setLineHeight: (lineHeight) => ({ chain }) => {
+        return chain().setMark("textStyle", { lineHeight }).run();
+      },
+      unsetLineHeight: () => ({ chain }) => {
+        return chain().setMark("textStyle", { lineHeight: null }).removeEmptyTextStyle().run();
+      }
+    };
+  }
+});
+var TextStyleKit = import_core14.Extension.create({
+  name: "textStyleKit",
+  addExtensions() {
+    const extensions = [];
+    if (this.options.backgroundColor !== false) {
+      extensions.push(BackgroundColor.configure(this.options.backgroundColor));
+    }
+    if (this.options.color !== false) {
+      extensions.push(Color.configure(this.options.color));
+    }
+    if (this.options.fontFamily !== false) {
+      extensions.push(FontFamily.configure(this.options.fontFamily));
+    }
+    if (this.options.fontSize !== false) {
+      extensions.push(FontSize.configure(this.options.fontSize));
+    }
+    if (this.options.lineHeight !== false) {
+      extensions.push(LineHeight.configure(this.options.lineHeight));
+    }
+    if (this.options.textStyle !== false) {
+      extensions.push(TextStyle.configure(this.options.textStyle));
+    }
+    return extensions;
+  }
+});
+
+// src/extensions/base/compatibility.ts
+var import_core15 = require("@tiptap/core");
+var import_state4 = require("@tiptap/pm/state");
+var import_extension_image2 = __toESM(require("@tiptap/extension-image"));
+var BaseLegacyBookAlert = import_core15.Node.create({
+  name: "calloutAlert",
+  group: "block",
+  content: "block+",
+  draggable: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      type: {
+        default: "error"
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'div[data-type="callout-alert"]'
+      }
+    ];
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => handleExitNode(this.editor, this.name)
+    };
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core15.mergeAttributes)(HTMLAttributes, { "data-type": "callout-alert" }), 0];
+  }
+});
+var BaseLegacyBookTip = import_core15.Node.create({
+  name: "calloutTip",
+  group: "block",
+  content: "block+",
+  draggable: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      type: {
+        default: "info"
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'div[data-type="callout-tip"]'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core15.mergeAttributes)(HTMLAttributes, { "data-type": "callout-tip" }), 0];
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => handleExitNode(this.editor, this.name)
+    };
+  }
+});
+var BaseLegacySEQuote = import_core15.Node.create({
+  name: "customQuoteV2",
+  group: "block",
+  content: "customQuoteText customQuoteAuthor customQuoteSign",
+  selectable: false,
+  draggable: true,
+  isolating: true,
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => {
+        const { view, schema } = this.editor;
+        const { state } = view;
+        const { selection } = state;
+        const $pos = selection.$from;
+        let depth = $pos.depth;
+        let isInsideCustomQuoteV2 = false;
+        while (depth > 0) {
+          const parentNode = $pos.node(depth);
+          if (parentNode.type.name === this.name) {
+            isInsideCustomQuoteV2 = true;
+            break;
+          }
+          depth--;
+        }
+        if (!isInsideCustomQuoteV2) {
+          return false;
+        }
+        const { tr } = state;
+        const posAfter = $pos.after(depth);
+        const paragraphNode = schema.nodes.paragraph.createAndFill();
+        if (!paragraphNode) return false;
+        tr.insert(posAfter, paragraphNode);
+        tr.setSelection(import_state4.TextSelection.create(tr.doc, posAfter + 1));
+        view.dispatch(tr);
+        return true;
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-custom-quote-v2]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core15.mergeAttributes)(HTMLAttributes, { "data-custom-quote-v2": "" }), 0];
+  }
+});
+var BaseLegacyPromptSE = import_core15.Node.create({
+  name: "promptV2",
+  group: "block",
+  content: "(promptHeader | promptV2Header) (promptContent | promptV2Content)",
+  selectable: false,
+  draggable: true,
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => {
+        const { view, schema } = this.editor;
+        const { state } = view;
+        const { selection } = state;
+        const $pos = selection.$from;
+        let depth = $pos.depth;
+        let isInsidePromptV2 = false;
+        while (depth > 0) {
+          const parentNode = $pos.node(depth);
+          if (parentNode.type.name === this.name) {
+            isInsidePromptV2 = true;
+            break;
+          }
+          depth--;
+        }
+        if (!isInsidePromptV2) {
+          return false;
+        }
+        const { tr } = state;
+        const posAfter = $pos.after(depth);
+        const paragraphNode = schema.nodes.paragraph.createAndFill();
+        if (!paragraphNode) return false;
+        tr.insert(posAfter, paragraphNode);
+        tr.setSelection(import_state4.TextSelection.create(tr.doc, posAfter + 1));
+        view.dispatch(tr);
+        return true;
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-prompt-v2]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core15.mergeAttributes)(HTMLAttributes, { "data-prompt": "" }), 0];
+  }
+});
+var BaseLegacyPromptSEHeader = import_core15.Node.create({
+  name: "promptV2Header",
+  group: "block",
+  content: "inline*",
+  selectable: true,
+  draggable: false,
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-prompt-v2-header]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core15.mergeAttributes)(HTMLAttributes, { "data-prompt-header": "" }), 0];
+  }
+  // addNodeView() {
+  //   return ReactNodeViewRenderer(PromptHeaderView);
+  // },
+});
+var BaseLegacyPromptSEContent = import_core15.Node.create({
+  name: "promptV2Content",
+  group: "block",
+  content: "text*",
+  draggable: false,
+  selectable: true,
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-prompt-v2-content]"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", (0, import_core15.mergeAttributes)(HTMLAttributes, { "data-prompt-content": "" }), 0];
+  }
+});
+var BaseLegacyCustomBlockquote = import_core15.Node.create({
+  name: "customBlockquote",
+  group: "block",
+  content: "block+",
+  draggable: true,
+  parseHTML() {
+    return [
+      {
+        tag: 'div[data-type="custom-blockquote"]'
+      }
+    ];
+  },
+  renderHTML() {
+    return ["blockquote", 0];
+  }
+});
+var BaseLegacyYouTube = import_core15.Node.create({
+  name: "youtube",
+  group: "block",
+  selectable: true,
+  draggable: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      src: {
+        default: null
+      },
+      width: {
+        default: 640
+      },
+      height: {
+        default: 480
+      },
+      start: {
+        default: 0
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'iframe[src*="youtube.com"]'
+      },
+      {
+        tag: 'iframe[src*="youtu.be"]'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["video-embed", { src: HTMLAttributes.src }];
+  }
+});
+var LegacyInlineLatexSE = import_core15.Node.create({
+  name: "inlineLatex",
+  group: "inline",
+  inline: true,
+  content: "text*",
+  atom: true,
+  addAttributes() {
+    return {
+      latex: {
+        default: "",
+        parseHTML: (element) => element.getAttribute("data-latex") || element.textContent || ""
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span.inline-latex"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["code", (0, import_core15.mergeAttributes)(HTMLAttributes, { class: "inline-latex" }), 0];
+  }
+});
+var BaseLegacyFigure = import_extension_image2.default.extend({
+  name: "figure",
+  group: "block",
+  content: "inline*",
+  draggable: true,
+  isolating: true,
+  selectable: false,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      getImageById: void 0
+    };
+  },
+  addAttributes() {
+    return {
+      ...this.parent?.(),
+      fileId: {
+        default: null,
+        parseHTML: (element) => {
+          const img = element.querySelector("img");
+          const fileIdFromImg = img?.getAttribute("fileId") || img?.getAttribute("data-file-id");
+          const fileIdFromFigure = element.getAttribute("fileId") || element.getAttribute("data-file-id");
+          return fileIdFromImg ?? fileIdFromFigure;
+        },
+        renderHTML: (attributes) => {
+          if (!attributes.fileId) return {};
+          return { "data-file-id": attributes.fileId };
+        }
+      },
+      src: {
+        default: null,
+        parseHTML: (element) => {
+          const img = element.querySelector("img") || element;
+          return img.getAttribute("src");
+        }
+      },
+      alt: {
+        default: null,
+        parseHTML: (element) => {
+          const img = element.querySelector("img") || element;
+          return img.getAttribute("alt");
+        }
+      },
+      title: {
+        default: null,
+        parseHTML: (element) => {
+          const img = element.querySelector("img") || element;
+          return img.getAttribute("title");
+        }
+      },
+      caption: {
+        default: null,
+        parseHTML: (element) => {
+          const caption = element.querySelector("figcaption");
+          return caption ? caption.innerText : null;
+        }
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "figure",
+        getAttrs: (element) => {
+          if (typeof element === "string") return false;
+          const img = element.querySelector("img");
+          return img ? {} : false;
+        }
+      },
+      {
+        tag: "img[src]"
+      }
+    ];
+  },
+  renderHTML({ node }) {
+    const resolvedSrc = resolveImageSrc(
+      {
+        fileId: node.attrs.fileId,
+        src: node.attrs.src
+      },
+      { getImageById: this.options.getImageById }
+    );
+    const figureAttrs = (0, import_core15.mergeAttributes)(this.options.HTMLAttributes);
+    const imgAttrs = {
+      src: resolvedSrc
+    };
+    if (node.attrs.fileId) imgAttrs["data-file-id"] = node.attrs.fileId;
+    if (node.attrs.alt) imgAttrs.alt = node.attrs.alt;
+    if (node.attrs.title) imgAttrs.title = node.attrs.title;
+    if (node.attrs.width) imgAttrs.width = node.attrs.width;
+    if (node.attrs.height) imgAttrs.height = node.attrs.height;
+    const hasCaption = node.attrs.caption && node.attrs.caption.trim().length > 0;
+    const figcaptionContent = hasCaption ? ["figcaption", {}, node.attrs.caption] : null;
+    return [
+      "figure",
+      figureAttrs,
+      ["img", imgAttrs],
+      ...figcaptionContent ? [figcaptionContent] : []
+    ];
+  }
+});
+
+// src/utils/get-shared-extensions.ts
+function getSharedExtensions() {
+  return [
+    import_starter_kit.default.configure({
+      codeBlock: false,
+      link: false
+    }),
+    import_extension_highlight.default.configure({ multicolor: true }),
+    LinkExtension,
+    import_extension_superscript.default,
+    import_extension_subscript.default,
+    import_extension_text_align.default.configure({
+      types: ["heading", "paragraph"]
+    }),
+    TextStyleKit.configure({
+      color: {
+        types: ["textStyle"]
+      }
+    }),
+    import_extension_details.Details.configure({
+      persist: true,
+      HTMLAttributes: {
+        class: "details"
+      }
+    }),
+    import_extension_details.DetailsSummary,
+    import_extension_details.DetailsContent,
+    BaseMythReality,
+    BaseMythRealityBlock,
+    LegacyInlineLatexSE
+  ];
+}
+
+// src/extensions/render/get-render-extensions.ts
+function getRenderExtensions() {
+  const sharedExtensions = getSharedExtensions();
+  return [
+    ...sharedExtensions,
+    CopyableText,
+    BaseCallout,
+    BaseCodeBlock,
+    BaseCustomQuote,
+    BaseCustomQuoteText,
+    BaseCustomQuoteAuthor,
+    BaseCustomQuoteSign,
+    BasePrompt,
+    BasePromptHeader,
+    BasePromptContent,
+    BaseVideo,
+    BaseFigure,
+    // Need to update
+    import_extension_table.TableKit.configure({
+      table: { resizable: false }
+    }),
+    import_extension_mathematics.Mathematics.configure({
+      katexOptions: {
+        throwOnError: false
+      }
+    }),
+    // ========================================================================
+    // Legacy Extensions (Deprecated - for backward compatibility only)
+    // ========================================================================
+    BaseLegacyBookAlert,
+    BaseLegacyBookTip,
+    BaseLegacySEQuote,
+    BaseLegacyPromptSE,
+    BaseLegacyPromptSEHeader,
+    BaseLegacyPromptSEContent,
+    BaseLegacyCustomBlockquote,
+    BaseLegacyYouTube,
+    BaseLegacyFigure
+    // Update
+  ];
+}
+
+// src/render/static-renderer-config.tsx
+var import_katex = __toESM(require("katex"));
+var import_common = __toESM(require("highlight.js/lib/common"));
+
+// src/icons/color/TiptapCalloutError.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var SvgTiptapCalloutError = (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 20 20", ...props, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("g", { clipPath: "url(#tiptap-callout-error_svg__a)", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "path",
+      {
+        fill: "#E03757",
+        d: "M10 0C4.477 0 0 4.477 0 10s4.477 10 10 10 10-4.477 10-10S15.523 0 10 0"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "path",
+      {
+        fill: "#F04760",
+        d: "M4.692 15.603c6.011 0 10.885-4.874 10.885-10.885a10.9 10.9 0 0 0-.525-3.35A9.95 9.95 0 0 0 10 0C4.477 0 0 4.477 0 10a9.95 9.95 0 0 0 1.394 5.094c1.066.338 2.179.51 3.298.509"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "path",
+      {
+        fill: "#fff",
+        d: "M9.996 16.783a1.626 1.626 0 1 1 0-3.251 1.626 1.626 0 0 1 0 3.251m1.575-5.598c-.027.252-.14.486-.321.663a1.13 1.13 0 0 1-.674.315h-.008q-.239.027-.48.027a6 6 0 0 1-.575-.027h-.007a1.13 1.13 0 0 1-.674-.315 1.1 1.1 0 0 1-.321-.663c-.04-.366-.059-2.914-.059-3.481 0-.568.02-3.122.059-3.488.027-.252.14-.487.32-.665.183-.177.42-.289.675-.315h.007q.287-.029.576-.017.24-.012.479.017h.008c.254.027.492.14.674.319.18.177.294.412.321.664.04.366.059 2.92.059 3.488 0 .567-.02 3.113-.059 3.478"
+      }
+    )
+  ] }),
+  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("defs", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("clipPath", { id: "tiptap-callout-error_svg__a", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { fill: "#fff", d: "M0 0h20v20H0z" }) }) })
+] });
+var TiptapCalloutError_default = SvgTiptapCalloutError;
+
+// src/icons/color/TiptapCalloutInfo.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var SvgTiptapCalloutInfo = (props) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 20 20", ...props, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "path",
+    {
+      fill: "#FE9738",
+      d: "m11.654 11.196 3.51-2.75.549-4.789-4.06-2.234-1.647 2.264a2.79 2.79 0 0 1 1.531 2.28 2.8 2.8 0 0 1-1.85 2.84 3.96 3.96 0 0 0-2.624 3.728v.72c0 .937.76 1.697 1.696 1.697h2.482zm-4.895-3.32H4.277c-.937 0-1.697-.76-1.697-1.697q0-.432.06-.86C3.084 2.135 5.954-.196 9.172.015h2.482L9.888 1.797m1.353 14.796H8.759c-.937 0-1.696.76-1.696 1.696v.014c0 .938.76 1.697 1.696 1.697h2.18"
+    }
+  ),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "path",
+    {
+      fill: "#FFD15B",
+      d: "M11.241 14.951c-.937 0-1.697-.76-1.697-1.697v-.72a3.955 3.955 0 0 1 2.625-3.727 2.8 2.8 0 0 0 1.85-2.84A2.79 2.79 0 0 0 11.432 3.4a2.8 2.8 0 0 0-2.976 2.78 1.697 1.697 0 0 1-3.394 0q0-.434.06-.86C5.566 2.133 8.435-.198 11.654.014c3.055.2 5.527 2.653 5.75 5.706a6.2 6.2 0 0 1-4.104 6.286.56.56 0 0 0-.362.529v.72c0 .936-.76 1.696-1.697 1.696m0 5.05c-.937 0-1.697-.76-1.697-1.698v-.014a1.697 1.697 0 0 1 3.394 0v.014c0 .937-.76 1.697-1.697 1.697"
+    }
+  ),
+  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "path",
+    {
+      fill: "#FFC344",
+      d: "M6.622 5.32q-.06.427-.06.86c0 .667.386 1.245.947 1.521A1.697 1.697 0 0 1 5.062 6.18q0-.432.06-.86C5.566 2.134 8.436-.197 11.654.014q.173.012.343.033C9.273.382 7.012 2.521 6.622 5.32m7.047 3.486a3.96 3.96 0 0 0-2.625 3.729v.72c0 .667.386 1.245.947 1.521a1.696 1.696 0 0 1-2.447-1.522v-.72a3.955 3.955 0 0 1 2.625-3.728 2.8 2.8 0 0 0 1.85-2.839 2.79 2.79 0 0 0-2.022-2.47 2.786 2.786 0 0 1 3.522 2.47 2.8 2.8 0 0 1-1.85 2.84m-1.678 11.02a1.696 1.696 0 0 1-2.447-1.522v-.015a1.697 1.697 0 0 1 2.448-1.523 1.7 1.7 0 0 0-.948 1.523v.014c0 .668.386 1.246.947 1.522"
+    }
+  )
+] });
+var TiptapCalloutInfo_default = SvgTiptapCalloutInfo;
+
+// src/icons/color/TiptapCalloutSuccess.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var SvgTiptapCalloutSuccess = (props) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 20 20", ...props, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("g", { clipPath: "url(#tiptap-callout-success_svg__a)", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#35495E",
+        d: "M1.972 18.004.06 7.138a2.4 2.4 0 0 1-.035-.317 2.47 2.47 0 0 1 2.073-2.493l3.693-.652-.1 14.328z"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#2C3E50",
+        d: "M16.186 17.528a.69.69 0 0 1-.548.517l-10.87 1.917a2.42 2.42 0 0 1-2.83-2.276 2.46 2.46 0 0 1 1.934-2.462l3.045.855h-.003l-2.742.487a1.037 1.037 0 0 0-.786 1.396 1.066 1.066 0 0 0 1.186.635l8.307-1.466z"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#F9EAB0",
+        d: "m6.914 16.08-2.742.486a1.035 1.035 0 0 0-.786 1.396 1.066 1.066 0 0 0 1.186.635l8.307-1.466z"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#E64C3C",
+        d: "M4.423 11.438 6.339.571a.695.695 0 0 1 .799-.559l10.785 1.902a2.47 2.47 0 0 1 2.074 2.495 3 3 0 0 1-.034.316l-1.917 10.867z"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#3F5C6C",
+        d: "M15.668 3.612a.4.4 0 0 1-.06-.005l-7.81-1.378a.345.345 0 0 1 .12-.677l7.81 1.375a.345.345 0 0 1-.06.685M14.01 5.069a.3.3 0 0 1-.06-.005l-5.094-.897a.345.345 0 0 1 .12-.68l5.094.897a.345.345 0 0 1-.06.685"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#ECF0F1",
+        d: "m14.727 6.608-7.131-1.26a.345.345 0 0 0-.4.28l-.6 3.395a.345.345 0 0 0 .28.4l7.13 1.26a.345.345 0 0 0 .4-.28l.6-3.396a.345.345 0 0 0-.28-.4"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#C03A2B",
+        d: "M19.997 4.407a2 2 0 0 1-.035.317L18.045 15.59l-2.659-.81 1.542-8.738.365-2.063.373-2.11.258.045a2.47 2.47 0 0 1 2.073 2.493"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#802F34",
+        d: "M16.007 12.78 5.22 10.88a.69.69 0 0 0-.238 1.358l10.865 1.914a1.038 1.038 0 0 1 .783 1.4 1.06 1.06 0 0 1-1.183.63L4.624 14.277a.69.69 0 0 0-.241 1.359l10.869 1.913a2.416 2.416 0 0 0 2.83-2.272 2.474 2.474 0 0 0-2.075-2.496"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        fill: "#F9EAB0",
+        d: "M16.63 15.552a1.06 1.06 0 0 1-1.182.63L4.624 14.277l.359-2.038 10.865 1.914a1.04 1.04 0 0 1 .783 1.4"
+      }
+    )
+  ] }),
+  /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("defs", { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("clipPath", { id: "tiptap-callout-success_svg__a", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("path", { fill: "#fff", d: "M0 0h20v20H0z" }) }) })
+] });
+var TiptapCalloutSuccess_default = SvgTiptapCalloutSuccess;
+
+// src/icons/color/TiptapCalloutWarning.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var SvgTiptapCalloutWarning = (props) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 20 20", ...props, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "path",
+    {
+      fill: "#FFF59D",
+      fillOpacity: 0.6,
+      d: "M1.667 9.167a8.333 8.333 0 1 0 16.666 0 8.333 8.333 0 0 0-16.666 0"
+    }
+  ),
+  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "path",
+    {
+      fill: "#FBC02D",
+      d: "M15.417 9.167c0-3.209-2.75-5.75-6.042-5.375-2.5.291-4.5 2.291-4.75 4.791a5.27 5.27 0 0 0 1.917 4.709c.583.5.958 1.208.958 2v.125h5v-.042c0-.75.333-1.5.917-2 1.208-1 2-2.5 2-4.208"
+    }
+  ),
+  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "path",
+    {
+      fill: "#FFF59D",
+      d: "m12.75 8.417-1.25-.834a.45.45 0 0 0-.458 0L10 8.25l-1-.667a.45.45 0 0 0-.458 0l-1.25.834c-.084.083-.167.166-.167.291s0 .25.083.334L8.792 11v4.417h.833v-4.584c0-.083-.042-.166-.083-.25L8.167 8.875l.625-.417 1 .667a.45.45 0 0 0 .458 0l1-.667.625.417-1.375 1.708a.6.6 0 0 0-.083.25v4.584h.833V11l1.583-1.958a.32.32 0 0 0 .084-.334c-.042-.125-.084-.25-.167-.291"
+    }
+  ),
+  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("path", { fill: "#5C6BC0", d: "M8.75 18.334a1.25 1.25 0 1 0 2.5 0 1.25 1.25 0 0 0-2.5 0" }),
+  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "path",
+    {
+      fill: "#9FA8DA",
+      d: "M10.833 18.75H9.167C8.25 18.75 7.5 18 7.5 17.083V15h5v2.083c0 .917-.75 1.667-1.667 1.667"
+    }
+  ),
+  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "path",
+    {
+      fill: "#5C6BC0",
+      d: "m12.5 17.083-4.833.667c.125.291.375.583.666.75l3.917-.542q.25-.375.25-.875m-5-.958v.833l5-.708v-.834z"
+    }
+  )
+] });
+var TiptapCalloutWarning_default = SvgTiptapCalloutWarning;
+
+// src/utils/custom-emoji.ts
+var calloutIconComponents = {
+  "callout-info": TiptapCalloutInfo_default,
+  "callout-success": TiptapCalloutSuccess_default,
+  "callout-warning": TiptapCalloutWarning_default,
+  "callout-error": TiptapCalloutError_default
+};
+
+// src/extensions/views/components/callout.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var calloutIcons = {
+  info: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TiptapCalloutInfo_default, {}),
+  warning: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TiptapCalloutWarning_default, {}),
+  success: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TiptapCalloutSuccess_default, {}),
+  error: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TiptapCalloutError_default, {})
+};
+var legacyTypeMap3 = {
+  question: "info",
+  idea: "warning",
+  info: "success",
+  error: "error"
+};
+var Callout = ({ type, bgColor, emoji, children, iconWrapper, calloutType }) => {
+  const isLegacySECallout = !!calloutType;
+  const finalType = isLegacySECallout ? legacyTypeMap3[calloutType] : type;
+  const hasCustomColor = !!bgColor;
+  const className = hasCustomColor ? "callout-node" : `callout-node callout-${finalType}`;
+  const style = hasCustomColor ? { backgroundColor: bgColor } : void 0;
+  let icon;
+  if (emoji) {
+    if (emoji in calloutIconComponents) {
+      const IconComponent = calloutIconComponents[emoji];
+      icon = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(IconComponent, {});
+    } else {
+      icon = emoji;
+    }
+  } else {
+    icon = calloutIcons[finalType];
+  }
+  const iconContent = iconWrapper ? iconWrapper(icon) : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "callout-icon", children: icon });
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+    "div",
+    {
+      className,
+      "data-callout-type": hasCustomColor ? void 0 : type,
+      "data-bg-color": bgColor || void 0,
+      "data-emoji": emoji || void 0,
+      style,
+      children: [
+        iconContent,
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "callout-content-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "callout-content", children }) })
+      ]
+    }
+  );
+};
+
+// src/extensions/views/components/code-block.tsx
+var import_react = require("react");
+var import_xml2 = __toESM(require("highlight.js/lib/languages/xml"));
+var import_lowlight2 = require("lowlight");
+
+// src/icons/Check.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var SvgCheck = (props) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 24 24", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+  "path",
+  {
+    fill: "currentColor",
+    fillRule: "evenodd",
+    d: "M20.707 5.293a1 1 0 0 1 0 1.414l-11 11a1 1 0 0 1-1.414 0l-5-5a1 1 0 1 1 1.414-1.414L9 15.586 19.293 5.293a1 1 0 0 1 1.414 0",
+    clipRule: "evenodd"
+  }
+) });
+var Check_default = SvgCheck;
+
+// src/icons/Copy.tsx
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var SvgCopy = (props) => /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 20 20", ...props, children: [
+  /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("g", { fill: "currentColor", fillRule: "evenodd", clipPath: "url(#copy_svg__a)", clipRule: "evenodd", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("path", { d: "M9.167 8.333a.833.833 0 0 0-.834.833v7.5c0 .46.373.834.833.834h7.5c.46 0 .834-.373.834-.834v-7.5a.833.833 0 0 0-.834-.833zm-2.5.833a2.5 2.5 0 0 1 2.5-2.5h7.5a2.5 2.5 0 0 1 2.5 2.5v7.5a2.5 2.5 0 0 1-2.5 2.5h-7.5a2.5 2.5 0 0 1-2.5-2.5z" }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("path", { d: "M3.334 2.5a.833.833 0 0 0-.834.833v7.5a.833.833 0 0 0 .833.834h.834a.833.833 0 0 1 0 1.667h-.833a2.5 2.5 0 0 1-2.5-2.5v-7.5a2.5 2.5 0 0 1 2.5-2.5h7.5a2.5 2.5 0 0 1 2.5 2.5v.833a.833.833 0 1 1-1.667 0v-.833a.834.834 0 0 0-.833-.834z" })
+  ] }),
+  /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("defs", { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("clipPath", { id: "copy_svg__a", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("path", { fill: "currentColor", d: "M0 0h20v20H0z" }) }) })
+] });
+var Copy_default = SvgCopy;
+
+// src/icons/DragIcon.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+
+// src/icons/Edit.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var SvgEdit = (props) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("svg", { fill: "none", viewBox: "0 0 18 18", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+  "path",
+  {
+    fill: "currentColor",
+    fillRule: "evenodd",
+    d: "M11.745.91a.833.833 0 0 1 1.179 0l4.167 4.167a.833.833 0 0 1 0 1.179L6.257 17.089a.83.83 0 0 1-.589.244H1.501a.833.833 0 0 1-.833-.833v-4.167c0-.22.088-.433.244-.589zM2.335 12.68v2.988h2.988l10-10-2.988-2.988z",
+    clipRule: "evenodd"
+  }
+) });
+var Edit_default = SvgEdit;
+
+// src/icons/Quote.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var SvgQuote = (props) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("svg", { xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 48 48", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+  "path",
+  {
+    fill: "currentColor",
+    d: "M19.284 11.242c1.2-.504 1.703-1.937 1.161-3.098l-1.897-3.989c-.542-1.122-1.859-1.626-3.02-1.122-3.292 1.394-6.119 3.214-8.364 5.42-2.75 2.595-4.608 5.577-5.615 8.868C.542 20.65 0 25.18 0 30.95v11.888a2.33 2.33 0 0 0 2.323 2.323h15.218a2.33 2.33 0 0 0 2.323-2.323V27.62a2.33 2.33 0 0 0-2.323-2.323h-7.28c.078-3.912 1.007-7.048 2.71-9.41 1.395-1.897 3.486-3.446 6.313-4.646m27.337 0c1.2-.504 1.703-1.937 1.162-3.098l-1.898-3.95a2.315 2.315 0 0 0-3.02-1.122c-3.253 1.394-6.04 3.214-8.325 5.382-2.75 2.633-4.647 5.615-5.654 8.906q-1.51 4.879-1.51 13.591V42.84a2.33 2.33 0 0 0 2.324 2.323h15.217a2.33 2.33 0 0 0 2.324-2.323V27.62a2.33 2.33 0 0 0-2.324-2.323H37.6c.077-3.911 1.007-7.047 2.71-9.41 1.394-1.897 3.485-3.446 6.312-4.646"
+  }
+) });
+var Quote_default = SvgQuote;
+
+// src/icons/X.tsx
+var import_jsx_runtime11 = require("react/jsx-runtime");
+
+// src/icons/menu/AddImage.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+
+// src/icons/menu/AlignCenter.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+
+// src/icons/menu/AlignLeft.tsx
+var import_jsx_runtime14 = require("react/jsx-runtime");
+
+// src/icons/menu/AlignRight.tsx
+var import_jsx_runtime15 = require("react/jsx-runtime");
+
+// src/icons/menu/ArrowDown.tsx
+var import_jsx_runtime16 = require("react/jsx-runtime");
+
+// src/icons/menu/ArrowLeft.tsx
+var import_jsx_runtime17 = require("react/jsx-runtime");
+
+// src/icons/menu/ArrowRight.tsx
+var import_jsx_runtime18 = require("react/jsx-runtime");
+
+// src/icons/menu/ArrowUp.tsx
+var import_jsx_runtime19 = require("react/jsx-runtime");
+
+// src/icons/menu/Blockquote.tsx
+var import_jsx_runtime20 = require("react/jsx-runtime");
+
+// src/icons/menu/Bold.tsx
+var import_jsx_runtime21 = require("react/jsx-runtime");
+
+// src/icons/menu/BulletList.tsx
+var import_jsx_runtime22 = require("react/jsx-runtime");
+
+// src/icons/menu/CalloutError.tsx
+var import_jsx_runtime23 = require("react/jsx-runtime");
+
+// src/icons/menu/CalloutInfo.tsx
+var import_jsx_runtime24 = require("react/jsx-runtime");
+
+// src/icons/menu/CalloutSuccess.tsx
+var import_jsx_runtime25 = require("react/jsx-runtime");
+
+// src/icons/menu/CalloutWarning.tsx
+var import_jsx_runtime26 = require("react/jsx-runtime");
+
+// src/icons/menu/ClearFormatting.tsx
+var import_jsx_runtime27 = require("react/jsx-runtime");
+
+// src/icons/menu/CodeBlock.tsx
+var import_jsx_runtime28 = require("react/jsx-runtime");
+
+// src/icons/menu/Copyable.tsx
+var import_jsx_runtime29 = require("react/jsx-runtime");
+
+// src/icons/menu/CustomQuote.tsx
+var import_jsx_runtime30 = require("react/jsx-runtime");
+
+// src/icons/menu/DeleteColumn.tsx
+var import_jsx_runtime31 = require("react/jsx-runtime");
+
+// src/icons/menu/DeleteRow.tsx
+var import_jsx_runtime32 = require("react/jsx-runtime");
+
+// src/icons/menu/Details.tsx
+var import_jsx_runtime33 = require("react/jsx-runtime");
+
+// src/icons/menu/H2.tsx
+var import_jsx_runtime34 = require("react/jsx-runtime");
+
+// src/icons/menu/H3.tsx
+var import_jsx_runtime35 = require("react/jsx-runtime");
+
+// src/icons/menu/H4.tsx
+var import_jsx_runtime36 = require("react/jsx-runtime");
+
+// src/icons/menu/H5.tsx
+var import_jsx_runtime37 = require("react/jsx-runtime");
+
+// src/icons/menu/H6.tsx
+var import_jsx_runtime38 = require("react/jsx-runtime");
+
+// src/icons/menu/Highlight.tsx
+var import_jsx_runtime39 = require("react/jsx-runtime");
+
+// src/icons/menu/HorizontalRule.tsx
+var import_jsx_runtime40 = require("react/jsx-runtime");
+
+// src/icons/menu/Italic.tsx
+var import_jsx_runtime41 = require("react/jsx-runtime");
+
+// src/icons/menu/LinkOff.tsx
+var import_jsx_runtime42 = require("react/jsx-runtime");
+
+// src/icons/menu/Link.tsx
+var import_jsx_runtime43 = require("react/jsx-runtime");
+
+// src/icons/menu/Math.tsx
+var import_jsx_runtime44 = require("react/jsx-runtime");
+
+// src/icons/menu/MergeCells.tsx
+var import_jsx_runtime45 = require("react/jsx-runtime");
+
+// src/icons/menu/MythReality.tsx
+var import_jsx_runtime46 = require("react/jsx-runtime");
+
+// src/icons/menu/OrderedList.tsx
+var import_jsx_runtime47 = require("react/jsx-runtime");
+
+// src/icons/menu/Prompt.tsx
+var import_jsx_runtime48 = require("react/jsx-runtime");
+
+// src/icons/menu/Redo.tsx
+var import_jsx_runtime49 = require("react/jsx-runtime");
+
+// src/icons/menu/SplitCells.tsx
+var import_jsx_runtime50 = require("react/jsx-runtime");
+
+// src/icons/menu/Strikethrough.tsx
+var import_jsx_runtime51 = require("react/jsx-runtime");
+
+// src/icons/menu/Subscript.tsx
+var import_jsx_runtime52 = require("react/jsx-runtime");
+
+// src/icons/menu/Superscript.tsx
+var import_jsx_runtime53 = require("react/jsx-runtime");
+
+// src/icons/menu/TableColumnHeading.tsx
+var import_jsx_runtime54 = require("react/jsx-runtime");
+
+// src/icons/menu/TableRowHeading.tsx
+var import_jsx_runtime55 = require("react/jsx-runtime");
+
+// src/icons/menu/Table.tsx
+var import_jsx_runtime56 = require("react/jsx-runtime");
+
+// src/icons/menu/TextColor.tsx
+var import_jsx_runtime57 = require("react/jsx-runtime");
+
+// src/icons/menu/Underline.tsx
+var import_jsx_runtime58 = require("react/jsx-runtime");
+
+// src/icons/menu/Undo.tsx
+var import_jsx_runtime59 = require("react/jsx-runtime");
+
+// src/icons/menu/Video.tsx
+var import_jsx_runtime60 = require("react/jsx-runtime");
+
+// src/extensions/views/components/copy-button.tsx
+var import_jsx_runtime61 = require("react/jsx-runtime");
+var CopyButton = ({ iconSize = 16, color = "black" }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime61.jsxs)(
+    "button",
+    {
+      className: `copy-button copy-icon-${color}`,
+      "data-copy-action": "copy",
+      type: "button",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(
+          "span",
+          {
+            className: "copy-icon",
+            "data-copy-icon": "default",
+            children: /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(
+              Copy_default,
+              {
+                width: iconSize,
+                height: iconSize
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(
+          "span",
+          {
+            className: "copy-icon-success",
+            "data-copy-icon": "success",
+            style: { display: "none" },
+            children: /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(
+              Check_default,
+              {
+                width: iconSize,
+                height: iconSize
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/extensions/views/components/code-block.tsx
+var import_jsx_runtime62 = require("react/jsx-runtime");
+var CodeBlock = ({
+  language,
+  isEditable,
+  onLanguageChange,
+  children,
+  translations
+}) => {
+  const languagesList = (0, import_react.useMemo)(() => {
+    const lowlight2 = (0, import_lowlight2.createLowlight)(import_lowlight2.common);
+    lowlight2.register("html", import_xml2.default);
+    const list = lowlight2.listLanguages();
+    return list.sort();
+  }, []);
+  const handleChange = (e) => {
+    onLanguageChange?.(e.target.value);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime62.jsxs)("div", { className: "tiptap-code-block-wrapper", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime62.jsxs)("div", { className: "tiptap-code-block-header", children: [
+      isEditable ? /* @__PURE__ */ (0, import_jsx_runtime62.jsxs)(
+        "select",
+        {
+          className: "tiptap-code-block-language-select",
+          value: language,
+          onChange: handleChange,
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime62.jsx)("option", { value: "", children: translations?.codeBlock.selectLanguage }),
+            languagesList.map((lang) => /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(
+              "option",
+              {
+                value: lang,
+                children: lang
+              },
+              lang
+            ))
+          ]
+        }
+      ) : /* @__PURE__ */ (0, import_jsx_runtime62.jsx)("span", { className: "tiptap-code-block-language-text", children: language || translations?.codeBlock.selectLanguage }),
+      /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(
+        CopyButton,
+        {
+          iconSize: 20,
+          color: "white"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime62.jsx)("pre", { className: "tiptap-code-block", children: /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(
+      "code",
+      {
+        className: "tiptap-code-block-content",
+        "data-copy-content": true,
+        children
+      }
+    ) })
+  ] });
+};
+
+// src/extensions/views/components/copyable-text.tsx
+var import_jsx_runtime63 = require("react/jsx-runtime");
+var CopyableText2 = ({ children }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime63.jsxs)("span", { className: "copyable", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime63.jsx)("span", { "data-copy-content": true, children }),
+    /* @__PURE__ */ (0, import_jsx_runtime63.jsx)(CopyButton, { iconSize: 16 })
+  ] });
+};
+
+// src/extensions/views/components/custom-quote.tsx
+var import_jsx_runtime64 = require("react/jsx-runtime");
+var CustomQuote = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime64.jsxs)("div", { "data-custom-quote": "", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime64.jsx)("div", { className: "custom-quote-divider" }),
+  /* @__PURE__ */ (0, import_jsx_runtime64.jsx)("div", { className: "custom-quote-svg-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(Quote_default, {}) }),
+  children
+] });
+var CustomQuoteText = ({ children, isEmpty, placeholder }) => /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(
+  "div",
+  {
+    "data-custom-quote-text": true,
+    className: isEmpty ? "is-empty" : "",
+    "data-placeholder": placeholder,
+    children
+  }
+);
+var CustomQuoteAuthor = ({ children, isEmpty, placeholder }) => /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(
+  "div",
+  {
+    "data-custom-quote-author": "",
+    className: isEmpty ? "is-empty" : "",
+    "data-placeholder": placeholder,
+    children
+  }
+);
+var CustomQuoteSign = ({ children, isEmpty, placeholder }) => /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(
+  "div",
+  {
+    "data-custom-quote-sign": "",
+    className: isEmpty ? "is-empty" : "",
+    "data-placeholder": placeholder,
+    children
+  }
+);
+
+// src/extensions/views/components/figure.tsx
+var import_jsx_runtime65 = require("react/jsx-runtime");
+var Figure = ({
+  src,
+  alt,
+  title,
+  caption,
+  width,
+  height,
+  isEditable,
+  onEditClick,
+  children,
+  fileId,
+  getImageById
+}) => {
+  const resolvedSrc = resolveImageSrc({ fileId, src }, { getImageById });
+  return /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)("figure", { children: [
+    resolvedSrc && /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)("div", { className: "figure-image-container", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+        "img",
+        {
+          src: resolvedSrc,
+          alt: alt || "",
+          title,
+          width: width || void 0,
+          height: height || void 0
+        }
+      ),
+      isEditable && onEditClick && /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+        "button",
+        {
+          type: "button",
+          className: "figure-edit-button",
+          onClick: onEditClick,
+          contentEditable: false,
+          "aria-label": "\u0420\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0438\u0437\u043E\u0431\u0440\u0430\u0436\u0435\u043D\u0438\u0435",
+          children: /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(Edit_default, {})
+        }
+      )
+    ] }),
+    caption && /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("figcaption", { children: caption }),
+    children
+  ] });
+};
+
+// src/extensions/views/components/prompt.tsx
+var import_jsx_runtime66 = require("react/jsx-runtime");
+var PromptHeader = ({ children, isEmpty, placeholder }) => /* @__PURE__ */ (0, import_jsx_runtime66.jsxs)("div", { className: "prompt-header-wrapper", children: [
+  /* @__PURE__ */ (0, import_jsx_runtime66.jsx)(
+    "div",
+    {
+      className: isEmpty ? "is-empty" : "",
+      "data-placeholder": placeholder,
+      children
+    }
+  ),
+  /* @__PURE__ */ (0, import_jsx_runtime66.jsx)("span", { className: "prompt-copy-icon-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime66.jsx)(
+    CopyButton,
+    {
+      iconSize: 16,
+      color: "prompt"
+    }
+  ) })
+] });
+var PromptContent = ({ children, isEmpty, placeholder }) => /* @__PURE__ */ (0, import_jsx_runtime66.jsx)("div", { className: "prompt-content-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime66.jsx)(
+  "div",
+  {
+    className: isEmpty ? "is-empty" : "",
+    "data-placeholder": placeholder,
+    "data-copy-content": true,
+    children
+  }
+) });
+
+// src/utils/detect-video-hosting.ts
+var VIDEO_PATTERNS = {
+  youtube: /(?:https?:\/\/)?(?:www\.)?(?:youtube\.com|youtu\.be)\/(?:watch\?v=|shorts\/)?([a-zA-Z0-9_-]{11})/,
+  youtubeEmbed: /(?:https?:\/\/)?(?:www\.)?(?:youtube\.com|youtube-nocookie\.com)\/embed\/([a-zA-Z0-9_-]{11})/,
+  vimeo: /(?:http|https)?:\/\/(?:www\.)?vimeo\.com\/(?:channels\/(?:\w+\/)?|groups\/(?:[^/]*)?\/videos\/)?(\d+)(?:|\/\?)/,
+  rutube: /^https:\/\/rutube\.ru\/video\/([\w-]+)/,
+  vk: /(?:https?:\/\/)?(?:vk\.com|vkvideo\.ru)\/video(-?\d+)_(\d+)/
+};
+var detectVideoHosting = (src) => {
+  if (!src || typeof src !== "string") {
+    return null;
+  }
+  const cleanSrc = src.trim();
+  if (!cleanSrc) {
+    return null;
+  }
+  try {
+    const youTubeEmbedMatch = VIDEO_PATTERNS.youtubeEmbed.exec(cleanSrc);
+    if (youTubeEmbedMatch?.[1]) {
+      const videoId = youTubeEmbedMatch[1];
+      return {
+        hosting: "youtube" /* Youtube */,
+        videoId,
+        embedUrl: `https://www.youtube-nocookie.com/embed/${videoId}`
+      };
+    }
+    const youTubeMatch = VIDEO_PATTERNS.youtube.exec(cleanSrc);
+    if (youTubeMatch?.[1]) {
+      const videoId = youTubeMatch[1];
+      return {
+        hosting: "youtube" /* Youtube */,
+        videoId,
+        embedUrl: `https://www.youtube-nocookie.com/embed/${videoId}`
+      };
+    }
+    const vimeoMatch = VIDEO_PATTERNS.vimeo.exec(cleanSrc);
+    if (vimeoMatch?.[1]) {
+      const videoId = vimeoMatch[1];
+      const hashRegex = /\/(\d+)\/([a-fA-F0-9]+)/;
+      const hashMatch = hashRegex.exec(cleanSrc);
+      const hash = hashMatch?.[2] || null;
+      const hashParam = hash ? `?h=${hash}` : "";
+      return {
+        hosting: "vimeo" /* Vimeo */,
+        videoId,
+        embedUrl: `https://player.vimeo.com/video/${videoId}${hashParam}`
+      };
+    }
+    const ruTubeMatch = VIDEO_PATTERNS.rutube.exec(cleanSrc);
+    if (ruTubeMatch?.[1]) {
+      const videoId = ruTubeMatch[1];
+      return {
+        hosting: "rutube" /* Rutube */,
+        videoId,
+        embedUrl: `https://rutube.ru/play/embed/${videoId}`
+      };
+    }
+    const vkMatch = VIDEO_PATTERNS.vk.exec(cleanSrc);
+    if (vkMatch?.[1] && vkMatch?.[2]) {
+      const videoId = `${vkMatch[1]}_${vkMatch[2]}`;
+      return {
+        hosting: "vk" /* VK */,
+        videoId,
+        embedUrl: `https://vk.com/video_ext.php?oid=${vkMatch[1]}&id=${vkMatch[2]}`
+      };
+    }
+  } catch {
+  }
+  return null;
+};
+
+// src/extensions/views/components/video.tsx
+var import_jsx_runtime67 = require("react/jsx-runtime");
+var Video = ({ src, children }) => {
+  const videoInfo = detectVideoHosting(src);
+  if (!videoInfo?.embedUrl) {
+    return /* @__PURE__ */ (0, import_jsx_runtime67.jsxs)("div", { className: "video-node", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime67.jsx)("div", { className: "video-error", children: /* @__PURE__ */ (0, import_jsx_runtime67.jsx)("span", { children: "Unsupported or invalid video URL" }) }),
+      children
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime67.jsxs)(
+    "div",
+    {
+      className: "video-node",
+      "data-video": "",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime67.jsx)("div", { className: "video-player-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(
+          "iframe",
+          {
+            className: "video-iframe",
+            src: videoInfo?.embedUrl,
+            title: "Video Player",
+            allow: "autoplay; encrypted-media",
+            allowFullScreen: true
+          }
+        ) }),
+        children
+      ]
+    }
+  );
+};
+
+// src/render/static-renderer-config.tsx
+var import_jsx_runtime68 = require("react/jsx-runtime");
+var getNodeMapping = (getImageById) => ({
+  callout({ node, children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(Callout, { ...node.attrs, children });
+  },
+  codeBlock({ node, children }) {
+    const language = node.attrs.language || "";
+    let codeText = "";
+    if (Array.isArray(children)) {
+      codeText = children.map((child) => {
+        if (child?.props?.node?.text) {
+          return child.props.node.text;
+        }
+        return "";
+      }).join("");
+    }
+    let highlightedHtml = "";
+    try {
+      if (!language) {
+        highlightedHtml = import_common.default.highlightAuto(codeText).value;
+      } else {
+        highlightedHtml = import_common.default.highlight(codeText, { language }).value;
+      }
+    } catch (error) {
+      console.warn(`Failed to highlight code for language "${language}":`, error);
+      highlightedHtml = codeText.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(
+      CodeBlock,
+      {
+        language,
+        isEditable: false,
+        children: /* @__PURE__ */ (0, import_jsx_runtime68.jsx)("code", { dangerouslySetInnerHTML: { __html: highlightedHtml } })
+      }
+    );
+  },
+  customQuote({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(CustomQuote, { children });
+  },
+  customQuoteText({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(CustomQuoteText, { children });
+  },
+  customQuoteAuthor({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(CustomQuoteAuthor, { children });
+  },
+  customQuoteSign({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(CustomQuoteSign, { children });
+  },
+  promptHeader({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(PromptHeader, { children });
+  },
+  promptContent({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(PromptContent, { children });
+  },
+  video({ node }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(Video, { src: node.attrs.src });
+  },
+  figure({ node }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(Figure, { ...node.attrs, getImageById });
+  },
+  image({ node }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(Figure, { ...node.attrs, getImageById });
+  },
+  inlineMath({ node }) {
+    const latex = node.attrs.latex || "";
+    let html3 = "";
+    try {
+      html3 = import_katex.default.renderToString(latex, {
+        throwOnError: false,
+        output: "html"
+      });
+    } catch (error) {
+      console.warn("KaTeX rendering error for inline math:", error);
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(
+      "span",
+      {
+        className: "react-renderer node-inlineMath",
+        dangerouslySetInnerHTML: { __html: html3 || latex }
+      }
+    );
+  },
+  // Block math (KaTeX) - from @tiptap/extension-mathematics
+  blockMath({ node }) {
+    const latex = node.attrs.latex || "";
+    let html3 = "";
+    try {
+      html3 = import_katex.default.renderToString(latex, {
+        throwOnError: false,
+        output: "html",
+        displayMode: true
+      });
+    } catch (error) {
+      console.warn("KaTeX rendering error for block math:", error);
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)("div", { className: "react-renderer node-blockMath", children: /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(
+      "div",
+      {
+        className: "tiptap-mathematics-render",
+        "data-type": "math",
+        "data-mode": "block",
+        dangerouslySetInnerHTML: { __html: html3 || latex }
+      }
+    ) });
+  },
+  inlineLatex({ node }) {
+    const latex = node.attrs.latex || "";
+    let html3 = "";
+    try {
+      html3 = import_katex.default.renderToString(latex, {
+        throwOnError: false,
+        output: "html"
+      });
+    } catch (error) {
+      console.warn("KaTeX rendering error for inline latex:", error);
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(
+      "span",
+      {
+        className: "react-renderer node-inlineLatex inline-latex",
+        dangerouslySetInnerHTML: { __html: html3 || latex }
+      }
+    );
+  },
+  /*
+    COMPATABILITY
+  */
+  calloutAlert({ node, children }) {
+    const type = node.attrs.type || "info";
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(Callout, { type, children });
+  },
+  calloutTip({ node, children }) {
+    const type = node.attrs.type || "info";
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(Callout, { type, children });
+  },
+  customQuoteV2({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(CustomQuote, { children });
+  },
+  promptV2Header({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(PromptHeader, { children });
+  },
+  promptV2Content({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(PromptContent, { children });
+  }
+});
+var nodeMapping = getNodeMapping();
+var markMapping = {
+  "copyable-text"({ children }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(CopyableText2, { children });
+  }
+};
+
+// src/render/tiptap-render.tsx
+var import_github_dark = require("highlight.js/styles/github-dark.css");
+var import_katex_min = require("katex/dist/katex.min.css");
+var import_jsx_runtime69 = require("react/jsx-runtime");
+function renderTiptapToReact(content, getImageById) {
+  let parsedContent;
+  try {
+    if (typeof content === "string") {
+      parsedContent = JSON.parse(content);
+    } else {
+      parsedContent = content;
+    }
+  } catch (error) {
+    console.warn("Failed to parse Tiptap content:", error);
+    parsedContent = { type: "doc", content: [{ type: "paragraph" }] };
+  }
+  const rendered = (0, import_react2.renderToReactElement)({
+    extensions: getRenderExtensions(),
+    content: parsedContent,
+    options: {
+      nodeMapping: getNodeMapping(getImageById),
+      markMapping
+    }
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime69.jsx)(
+    "div",
+    {
+      className: "tiptap",
+      "data-tiptap-render": true,
+      children: rendered
+    }
+  );
+}
+function TiptapRender({ content, getImageById }) {
+  return renderTiptapToReact(content, getImageById);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TiptapRender
+});
+//# sourceMappingURL=render.js.map