mardora 1.2.0

package/dist/chunk-MLBEBFHB.cjs

@@ -0,0 +1,2971 @@
+'use strict';
+
+var chunkWFVCG4LD_cjs = require('./chunk-WFVCG4LD.cjs');
+var state = require('@codemirror/state');
+var view = require('@codemirror/view');
+var langMarkdown = require('@codemirror/lang-markdown');
+var language = require('@codemirror/language');
+var highlight = require('@lezer/highlight');
+var commands = require('@codemirror/commands');
+var languageData = require('@codemirror/language-data');
+var styleMod = require('style-mod');
+
+var mardoraBaseTheme = view.EditorView.theme({
+  // Container styles - only apply when view plugin is enabled
+  "&.cm-mardora": {
+    fontSize: "16px",
+    lineHeight: "1.6",
+    minHeight: "100%",
+    backgroundColor: "transparent !important"
+  },
+  "&.cm-mardora.cm-focused": {
+    outline: "none"
+  },
+  "&.cm-mardora .cm-scroller": {
+    minHeight: "100%"
+  },
+  "&.cm-mardora .cm-content": {
+    width: "100%",
+    maxWidth: "48rem",
+    padding: "0 0.5rem",
+    margin: "0 auto",
+    fontFamily: "var(--font-sans, sans-serif)",
+    fontSize: "16px",
+    lineHeight: "1.6"
+  },
+  "&.cm-mardora .cm-content .cm-line": {
+    paddingInline: 0
+  },
+  "&.cm-mardora .cm-content .cm-widgetBuffer": {
+    display: "none !important"
+  }
+});
+var markdownResetStyle = language.HighlightStyle.define([
+  {
+    tag: [
+      highlight.tags.heading,
+      highlight.tags.strong,
+      highlight.tags.emphasis,
+      highlight.tags.strikethrough,
+      highlight.tags.link,
+      highlight.tags.url,
+      highlight.tags.quote,
+      highlight.tags.list,
+      highlight.tags.meta,
+      highlight.tags.contentSeparator,
+      highlight.tags.labelName
+    ],
+    color: "inherit",
+    fontWeight: "inherit",
+    fontStyle: "inherit",
+    textDecoration: "none"
+  }
+]);
+var markdownResetExtension = language.syntaxHighlighting(markdownResetStyle, { fallback: false });
+
+// src/editor/view-plugin.ts
+var MardoraPluginsFacet = state.Facet.define({
+  combine: (values) => values.flat()
+});
+var mardoraOnNodesChangeFacet = state.Facet.define({
+  combine: (values) => values.find((v) => v !== void 0)
+});
+var mardoraThemeFacet = state.Facet.define({
+  combine: (values) => values.find((v) => v !== void 0) || "auto" /* AUTO */
+});
+function buildDecorations(view, plugins = []) {
+  const builder = new state.RangeSetBuilder();
+  const decorations = [];
+  if (plugins.length > 0) {
+    const ctx = {
+      view,
+      decorations,
+      selectionOverlapsRange: (from, to) => chunkWFVCG4LD_cjs.selectionOverlapsRange(view, from, to),
+      cursorInRange: (from, to) => chunkWFVCG4LD_cjs.cursorInRange(view, from, to)
+    };
+    const sortedPlugins = [...plugins].sort((a, b) => a.decorationPriority - b.decorationPriority);
+    for (const plugin of sortedPlugins) {
+      try {
+        plugin.buildDecorations(ctx);
+      } catch {
+      }
+    }
+  }
+  decorations.sort((a, b) => a.from - b.from || a.value.startSide - b.value.startSide);
+  for (const decoration of decorations) {
+    builder.add(decoration.from, decoration.to, decoration.value);
+  }
+  return builder.finish();
+}
+var mardoraViewPluginClass = class {
+  decorations;
+  plugins;
+  onNodesChange;
+  constructor(view) {
+    this.plugins = view.state.facet(MardoraPluginsFacet);
+    this.onNodesChange = view.state.facet(mardoraOnNodesChangeFacet);
+    this.decorations = buildDecorations(view, this.plugins);
+    for (const plugin of this.plugins) {
+      plugin.onViewReady(view);
+    }
+    if (this.onNodesChange && typeof this.onNodesChange === "function") {
+      this.onNodesChange(this.buildNodes(view));
+    }
+  }
+  update(update) {
+    this.plugins = update.view.state.facet(MardoraPluginsFacet);
+    this.onNodesChange = update.view.state.facet(mardoraOnNodesChangeFacet);
+    for (const plugin of this.plugins) {
+      plugin.onViewUpdate(update);
+    }
+    if (update.docChanged || update.selectionSet || update.viewportChanged) {
+      this.decorations = buildDecorations(update.view, this.plugins);
+      if (this.onNodesChange) {
+        this.onNodesChange(this.buildNodes(update.view));
+      }
+    }
+  }
+  buildNodes(view) {
+    const tree = language.syntaxTree(view.state);
+    const roots = [];
+    const stack = [];
+    tree.iterate({
+      enter: (nodeRef) => {
+        const node = {
+          from: nodeRef.from,
+          to: nodeRef.to,
+          name: nodeRef.name,
+          children: [],
+          isSelected: chunkWFVCG4LD_cjs.selectionOverlapsRange(view, nodeRef.from, nodeRef.to)
+        };
+        if (stack.length > 0) {
+          stack[stack.length - 1].children.push(node);
+        } else {
+          roots.push(node);
+        }
+        stack.push(node);
+      },
+      leave: () => {
+        stack.pop();
+      }
+    });
+    return roots;
+  }
+};
+var mardoraViewPlugin = view.ViewPlugin.fromClass(mardoraViewPluginClass, {
+  decorations: (v) => v.decorations,
+  provide: () => []
+});
+var mardoraEditorClass = view.EditorView.editorAttributes.of({ class: "cm-mardora" });
+function createMardoraViewExtension(theme = "auto" /* AUTO */, baseStyles = true, plugins = [], onNodesChange) {
+  return [
+    mardoraEditorClass,
+    MardoraPluginsFacet.of(plugins),
+    mardoraOnNodesChangeFacet.of(onNodesChange),
+    mardoraThemeFacet.of(theme),
+    mardoraViewPlugin,
+    ...baseStyles ? [mardoraBaseTheme] : []
+  ];
+}
+
+// src/editor/slash/query.ts
+var slashLinePattern = /^\/([^\s]*)$/;
+function detectSlashQuery(documentText, cursorPosition) {
+  const safeCursor = Math.max(0, Math.min(cursorPosition, documentText.length));
+  const lineStart = documentText.lastIndexOf("\n", safeCursor - 1) + 1;
+  const lineTextBeforeCursor = documentText.slice(lineStart, safeCursor);
+  const match = lineTextBeforeCursor.match(slashLinePattern);
+  if (!match) {
+    return null;
+  }
+  return {
+    from: lineStart,
+    to: safeCursor,
+    query: match[1] ?? ""
+  };
+}
+function filterSlashCommands(commands, query) {
+  const normalizedQuery = query.trim().toLocaleLowerCase();
+  if (!normalizedQuery) {
+    return [...commands];
+  }
+  return commands.filter((command) => {
+    const searchable = [command.title, command.id, command.hint, ...command.aliases].join(" ").toLocaleLowerCase();
+    return searchable.includes(normalizedQuery);
+  });
+}
+
+// src/editor/slash/insertions.ts
+function buildSlashReplacement(template, query) {
+  return {
+    changes: {
+      from: query.from,
+      to: query.to,
+      insert: template.marker
+    },
+    selectionAnchor: query.from + template.cursorOffset
+  };
+}
+
+// src/editor/slash/default-commands.ts
+var commandCopy = {
+  "zh-CN": {
+    paragraph: { title: "\u6587\u672C", aliases: ["text", "plain", "wenben"] },
+    "heading-1": { title: "\u6807\u9898 1", aliases: ["h1", "heading", "heading1", "biaoti", "\u6807\u9898"] },
+    "heading-2": { title: "\u6807\u9898 2", aliases: ["h2", "heading", "heading2", "biaoti", "\u6807\u9898"] },
+    "heading-3": { title: "\u6807\u9898 3", aliases: ["h3", "heading", "heading3", "biaoti", "\u6807\u9898"] },
+    "heading-4": { title: "\u6807\u9898 4", aliases: ["h4", "heading", "heading4", "biaoti", "\u6807\u9898"] },
+    "heading-5": { title: "\u6807\u9898 5", aliases: ["h5", "heading", "heading5", "biaoti", "\u6807\u9898"] },
+    "heading-6": { title: "\u6807\u9898 6", aliases: ["h6", "heading", "heading6", "biaoti", "\u6807\u9898"] },
+    quote: { title: "\u5F15\u7528", aliases: ["quote", "blockquote", "yinyong"] },
+    "callout-note": {
+      title: "\u8BF4\u660E Callout",
+      aliases: ["callout", "note", "info", "\u544A\u8B66", "\u8BF4\u660E", "\u63D0\u793A", "shuoming", "tishi"]
+    },
+    "callout-tip": {
+      title: "\u6280\u5DE7 Callout",
+      aliases: ["callout", "tip", "hint", "\u544A\u8B66", "\u6280\u5DE7", "\u63D0\u793A", "jiqiao", "tishi"]
+    },
+    "callout-important": { title: "\u91CD\u8981 Callout", aliases: ["callout", "important", "\u544A\u8B66", "\u91CD\u8981", "zhongyao"] },
+    "callout-warning": { title: "\u8B66\u544A Callout", aliases: ["callout", "warning", "warn", "\u544A\u8B66", "\u8B66\u544A", "jinggao"] },
+    "callout-caution": {
+      title: "\u4E25\u91CD\u8B66\u544A Callout",
+      aliases: ["callout", "caution", "danger", "\u544A\u8B66", "\u4E25\u91CD", "\u98CE\u9669", "yanzhong", "fengxian"]
+    },
+    "code-block": { title: "\u4EE3\u7801\u5757", aliases: ["code", "codeblock", "fence", "\u4EE3\u7801", "\u4EE3\u7801\u5757", "daima"] },
+    "ordered-list": { title: "\u6709\u5E8F\u5217\u8868", aliases: ["ol", "ordered", "numbered", "youxu", "\u6709\u5E8F"] },
+    "unordered-list": { title: "\u9879\u76EE\u7B26\u53F7\u5217\u8868", aliases: ["ul", "bullet", "unordered", "bulleted", "wuxu", "\u65E0\u5E8F"] },
+    "task-list": { title: "\u5F85\u529E\u6E05\u5355", aliases: ["todo", "task", "check", "daiban", "\u5F85\u529E"] },
+    table: { title: "\u8868\u683C", aliases: ["table", "biaoge"] },
+    divider: { title: "\u5206\u9694\u7EBF", aliases: ["hr", "divider", "line", "fengexian", "\u5206\u9694"] },
+    link: { title: "\u94FE\u63A5", aliases: ["link", "url", "lianjie"] },
+    file: { title: "\u6587\u4EF6", aliases: ["file", "wenjian"] },
+    image: { title: "\u56FE\u7247", aliases: ["image", "img", "tu", "tupian", "\u56FE\u7247"] },
+    video: { title: "\u89C6\u9891", aliases: ["video", "shipin"] },
+    audio: { title: "\u97F3\u9891", aliases: ["audio", "music", "yinpin"] }
+  },
+  "en-US": {
+    paragraph: { title: "Text", aliases: ["\u6587\u672C", "text", "plain", "wenben"] },
+    "heading-1": { title: "Heading 1", aliases: ["\u6807\u9898", "h1", "heading", "heading1", "biaoti"] },
+    "heading-2": { title: "Heading 2", aliases: ["\u6807\u9898", "h2", "heading", "heading2", "biaoti"] },
+    "heading-3": { title: "Heading 3", aliases: ["\u6807\u9898", "h3", "heading", "heading3", "biaoti"] },
+    "heading-4": { title: "Heading 4", aliases: ["\u6807\u9898", "h4", "heading", "heading4", "biaoti"] },
+    "heading-5": { title: "Heading 5", aliases: ["\u6807\u9898", "h5", "heading", "heading5", "biaoti"] },
+    "heading-6": { title: "Heading 6", aliases: ["\u6807\u9898", "h6", "heading", "heading6", "biaoti"] },
+    quote: { title: "Quote", aliases: ["\u5F15\u7528", "quote", "blockquote", "yinyong"] },
+    "callout-note": { title: "Note callout", aliases: ["\u8BF4\u660E", "\u63D0\u793A", "\u544A\u8B66", "callout", "note", "info"] },
+    "callout-tip": { title: "Tip callout", aliases: ["\u6280\u5DE7", "\u63D0\u793A", "\u544A\u8B66", "callout", "tip", "hint"] },
+    "callout-important": { title: "Important callout", aliases: ["\u91CD\u8981", "\u544A\u8B66", "callout", "important"] },
+    "callout-warning": { title: "Warning callout", aliases: ["\u8B66\u544A", "\u544A\u8B66", "callout", "warning", "warn"] },
+    "callout-caution": { title: "Caution callout", aliases: ["\u4E25\u91CD", "\u98CE\u9669", "\u544A\u8B66", "callout", "caution", "danger"] },
+    "code-block": { title: "Code block", aliases: ["\u4EE3\u7801", "\u4EE3\u7801\u5757", "code", "codeblock", "fence", "daima"] },
+    "ordered-list": { title: "Numbered list", aliases: ["\u6709\u5E8F", "ol", "ordered", "numbered", "youxu"] },
+    "unordered-list": { title: "Bulleted list", aliases: ["\u65E0\u5E8F", "ul", "bullet", "unordered", "bulleted", "wuxu"] },
+    "task-list": { title: "To-do list", aliases: ["\u5F85\u529E", "todo", "task", "check", "daiban"] },
+    table: { title: "Table", aliases: ["\u8868\u683C", "table", "biaoge"] },
+    divider: { title: "Divider", aliases: ["\u5206\u9694", "hr", "divider", "line", "fengexian"] },
+    link: { title: "Link", aliases: ["\u94FE\u63A5", "link", "url", "lianjie"] },
+    file: { title: "File", aliases: ["\u6587\u4EF6", "file", "wenjian"] },
+    image: { title: "Image", aliases: ["\u56FE\u7247", "image", "img", "tu", "tupian"] },
+    video: { title: "Video", aliases: ["\u89C6\u9891", "video", "shipin"] },
+    audio: { title: "Audio", aliases: ["\u97F3\u9891", "audio", "music", "yinpin"] }
+  }
+};
+function commandMeta(locale, id, group, icon, hint) {
+  const copy = commandCopy[locale][id];
+  if (!copy) {
+    throw new Error(`Missing slash command copy: ${locale}:${id}`);
+  }
+  return {
+    id,
+    group,
+    title: copy.title,
+    aliases: copy.aliases,
+    icon,
+    hint
+  };
+}
+function markdownCommand(command, marker, cursorOffset = marker.length) {
+  return {
+    ...command,
+    run: ({ view, queryRange }) => {
+      const replacement = buildSlashReplacement({ marker, cursorOffset }, { ...queryRange});
+      view.dispatch({
+        changes: replacement.changes,
+        selection: { anchor: replacement.selectionAnchor },
+        scrollIntoView: true
+      });
+      view.focus();
+      return true;
+    }
+  };
+}
+function calloutCommand(locale, id, icon, type) {
+  return markdownCommand(commandMeta(locale, id, "basic", icon, `[!${type}]`), `> [!${type}]
+> `);
+}
+function mediaCommand(command, kind) {
+  return {
+    ...command,
+    run: (context) => {
+      if (context.requestAttachment?.(kind, context)) {
+        return true;
+      }
+      const fallbackByKind = {
+        image: "![image](url)",
+        video: '<video src="url" controls></video>',
+        audio: '<audio src="url" controls></audio>',
+        file: "[filename](url)"
+      };
+      const fallback = fallbackByKind[kind];
+      const replacement = buildSlashReplacement(
+        { marker: fallback, cursorOffset: kind === "file" ? 1 : fallback.indexOf("url") },
+        { ...context.queryRange}
+      );
+      context.view.dispatch({
+        changes: replacement.changes,
+        selection: { anchor: replacement.selectionAnchor },
+        scrollIntoView: true
+      });
+      context.view.focus();
+      return true;
+    }
+  };
+}
+function getDefaultSlashCommands(locale = "zh-CN") {
+  return [
+    markdownCommand(commandMeta(locale, "paragraph", "basic", "type", ""), "", 0),
+    markdownCommand(commandMeta(locale, "heading-1", "basic", "heading-1", "#"), "# "),
+    markdownCommand(commandMeta(locale, "heading-2", "basic", "heading-2", "##"), "## "),
+    markdownCommand(commandMeta(locale, "heading-3", "basic", "heading-3", "###"), "### "),
+    markdownCommand(commandMeta(locale, "heading-4", "basic", "heading-4", "####"), "#### "),
+    markdownCommand(commandMeta(locale, "heading-5", "basic", "heading-5", "#####"), "##### "),
+    markdownCommand(commandMeta(locale, "heading-6", "basic", "heading-6", "######"), "###### "),
+    markdownCommand(commandMeta(locale, "quote", "basic", "text-quote", ">"), "> "),
+    calloutCommand(locale, "callout-note", "info", "NOTE"),
+    calloutCommand(locale, "callout-tip", "lightbulb", "TIP"),
+    calloutCommand(locale, "callout-important", "badge-alert", "IMPORTANT"),
+    calloutCommand(locale, "callout-warning", "triangle-alert", "WARNING"),
+    calloutCommand(locale, "callout-caution", "octagon-alert", "CAUTION"),
+    markdownCommand(commandMeta(locale, "code-block", "basic", "code-xml", "```"), "```\n\n```", 4),
+    markdownCommand(commandMeta(locale, "ordered-list", "basic", "list-ordered", "1."), "1. "),
+    markdownCommand(commandMeta(locale, "unordered-list", "basic", "list", "-"), "- "),
+    markdownCommand(commandMeta(locale, "task-list", "basic", "list-todo", "[]"), "- [ ] "),
+    markdownCommand(
+      commandMeta(locale, "table", "basic", "table", "| |"),
+      "| Column 1 | Column 2 |\n| --- | --- |\n|  |  |\n",
+      2
+    ),
+    markdownCommand(commandMeta(locale, "divider", "basic", "minus", "---"), "---\n"),
+    markdownCommand(commandMeta(locale, "link", "basic", "link", "[]()"), "[]()", 1),
+    mediaCommand(commandMeta(locale, "file", "media", "file", "file"), "file"),
+    mediaCommand(commandMeta(locale, "image", "media", "image", "img"), "image"),
+    mediaCommand(commandMeta(locale, "video", "media", "play", "video"), "video"),
+    mediaCommand(commandMeta(locale, "audio", "media", "music-2", "audio"), "audio")
+  ];
+}
+var defaultSlashCommands = getDefaultSlashCommands("zh-CN");
+
+// src/editor/slash/menu.ts
+var slashMessages = {
+  "zh-CN": {
+    groups: {
+      basic: "\u57FA\u672C\u533A\u5757",
+      media: "\u5A92\u4F53"
+    },
+    empty: "\u6CA1\u6709\u5339\u914D\u7684\u547D\u4EE4",
+    close: "\u5173\u95ED\u83DC\u5355",
+    closeHint: "esc"
+  },
+  "en-US": {
+    groups: {
+      basic: "Basic blocks",
+      media: "Media"
+    },
+    empty: "No matching commands",
+    close: "Close menu",
+    closeHint: "esc"
+  }
+};
+function getSlashMessages(locale) {
+  return slashMessages[locale];
+}
+function createSlashMenuElement(state, callbacks) {
+  const { messages } = state;
+  const root = document.createElement("div");
+  root.className = "cm-mardora-slash-menu";
+  root.setAttribute("role", "listbox");
+  const list = document.createElement("div");
+  list.className = "cm-mardora-slash-list";
+  root.addEventListener(
+    "wheel",
+    (event) => {
+      list.scrollTop += event.deltaY;
+      event.preventDefault();
+      event.stopPropagation();
+    },
+    { capture: true, passive: false }
+  );
+  if (state.commands.length === 0) {
+    const empty = document.createElement("div");
+    empty.className = "cm-mardora-slash-empty";
+    empty.textContent = messages.empty;
+    list.appendChild(empty);
+    root.appendChild(list);
+    return root;
+  }
+  let currentGroup = null;
+  for (const [index, command] of state.commands.entries()) {
+    if (command.group !== currentGroup) {
+      currentGroup = command.group;
+      const label = document.createElement("div");
+      label.className = "cm-mardora-slash-group";
+      label.textContent = messages.groups[currentGroup];
+      list.appendChild(label);
+    }
+    const item = document.createElement("button");
+    item.type = "button";
+    item.className = index === state.activeIndex ? "cm-mardora-slash-item cm-mardora-slash-item-active" : "cm-mardora-slash-item";
+    item.dataset.mardoraSlashIndex = String(index);
+    item.setAttribute("role", "option");
+    item.setAttribute("aria-selected", String(index === state.activeIndex));
+    item.addEventListener("mouseenter", () => callbacks.onHover(index));
+    item.addEventListener("mousedown", (event) => {
+      event.preventDefault();
+      callbacks.onSelect(index);
+    });
+    const icon = document.createElement("span");
+    icon.className = "cm-mardora-slash-icon";
+    const svgIcon = chunkWFVCG4LD_cjs.createMardoraIcon(command.icon);
+    if (svgIcon) {
+      icon.appendChild(svgIcon);
+    } else {
+      icon.textContent = command.icon;
+    }
+    const title = document.createElement("span");
+    title.className = "cm-mardora-slash-title";
+    title.textContent = command.title;
+    const hint = document.createElement("span");
+    hint.className = "cm-mardora-slash-hint";
+    hint.textContent = command.hint;
+    item.append(icon, title, hint);
+    list.appendChild(item);
+  }
+  const footer = document.createElement("div");
+  footer.className = "cm-mardora-slash-footer";
+  footer.innerHTML = `<span>${messages.close}</span><span>${messages.closeHint}</span>`;
+  root.append(list, footer);
+  return root;
+}
+var slashMenuTheme = view.EditorView.baseTheme({
+  ".cm-mardora-slash-menu": {
+    position: "fixed",
+    display: "flex",
+    flexDirection: "column",
+    zIndex: "1000",
+    width: "328px",
+    maxHeight: "420px",
+    overflow: "hidden",
+    border: "1px solid rgba(120, 113, 108, 0.22)",
+    borderRadius: "12px",
+    background: "var(--mardora-slash-bg, #ffffff)",
+    boxShadow: "0 18px 48px rgba(15, 23, 42, 0.16)",
+    padding: "8px 0 0",
+    caretColor: "transparent",
+    cursor: "default",
+    fontFamily: "var(--font-sans, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif)",
+    userSelect: "none"
+  },
+  ".cm-mardora-slash-open .cm-cursor": {
+    visibility: "hidden"
+  },
+  ".cm-mardora-slash-open .cm-content": {
+    caretColor: "transparent"
+  },
+  ".cm-mardora-slash-list": {
+    flex: "1 1 auto",
+    minHeight: "0",
+    overflowY: "auto"
+  },
+  ".cm-mardora-slash-group": {
+    padding: "8px 14px 6px",
+    color: "var(--mardora-slash-muted, #a8a29e)",
+    fontSize: "12px",
+    fontWeight: "500"
+  },
+  ".cm-mardora-slash-item": {
+    display: "grid",
+    gridTemplateColumns: "34px 1fr auto",
+    alignItems: "center",
+    width: "100%",
+    minHeight: "34px",
+    border: "0",
+    padding: "0 14px",
+    background: "transparent",
+    color: "var(--mardora-slash-fg, #27272a)",
+    textAlign: "left",
+    cursor: "default"
+  },
+  ".cm-mardora-slash-item-active": {
+    background: "var(--mardora-slash-active, #f4f4f5)"
+  },
+  ".cm-mardora-slash-icon": {
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    color: "var(--mardora-slash-icon, #3f3f46)",
+    fontSize: "13px",
+    fontWeight: "400",
+    textAlign: "center"
+  },
+  ".cm-mardora-slash-icon svg": {
+    display: "block",
+    width: "17px",
+    height: "17px",
+    strokeWidth: "1.9"
+  },
+  ".cm-mardora-slash-title": {
+    overflow: "hidden",
+    color: "inherit",
+    fontSize: "14px",
+    fontWeight: "400",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap"
+  },
+  ".cm-mardora-slash-hint": {
+    marginLeft: "12px",
+    color: "var(--mardora-slash-muted, #a8a29e)",
+    fontSize: "12px",
+    fontWeight: "400"
+  },
+  ".cm-mardora-slash-footer": {
+    display: "flex",
+    flex: "0 0 auto",
+    alignItems: "center",
+    justifyContent: "space-between",
+    minHeight: "40px",
+    borderTop: "1px solid rgba(120, 113, 108, 0.18)",
+    background: "var(--mardora-slash-bg, #ffffff)",
+    padding: "0 14px",
+    color: "var(--mardora-slash-fg, #27272a)",
+    fontSize: "14px"
+  },
+  ".cm-mardora-slash-footer span:last-child": {
+    color: "var(--mardora-slash-muted, #a8a29e)",
+    fontSize: "12px",
+    fontWeight: "400"
+  },
+  ".cm-mardora-slash-empty": {
+    padding: "14px",
+    color: "var(--mardora-slash-muted, #a8a29e)",
+    fontSize: "13px"
+  },
+  "&dark .cm-mardora-slash-menu": {
+    "--mardora-slash-bg": "#18181b",
+    "--mardora-slash-fg": "#f4f4f5",
+    "--mardora-slash-muted": "#a1a1aa",
+    "--mardora-slash-active": "#27272a",
+    "--mardora-slash-icon": "#e4e4e7"
+  }
+});
+
+// src/editor/attachments/format.ts
+function detectAttachmentKind(file) {
+  if (file.type.startsWith("image/")) return "image";
+  if (file.type.startsWith("video/")) return "video";
+  if (file.type.startsWith("audio/")) return "audio";
+  return "file";
+}
+function isAcceptedAttachment(file, acceptRules) {
+  if (acceptRules.includes("*/*")) return true;
+  return acceptRules.some((rule) => {
+    if (rule.endsWith("/*")) {
+      return file.type.startsWith(rule.slice(0, -1));
+    }
+    if (rule.startsWith(".")) {
+      return file.name.toLocaleLowerCase().endsWith(rule.toLocaleLowerCase());
+    }
+    return file.type === rule;
+  });
+}
+function createUploadMarker(input) {
+  if (input.state === "failed") {
+    return `[Upload failed: ${input.name}](mardora-upload://${input.taskId})`;
+  }
+  if (input.kind === "image") {
+    return `![${input.name}](mardora-upload://${input.taskId})`;
+  }
+  return `[Uploading ${input.name}](mardora-upload://${input.taskId})`;
+}
+function formatAttachmentMarkdown(kind, result) {
+  const name = result.name || "attachment";
+  if (kind === "image") {
+    return result.title ? `![${name}](${result.url} "${result.title}")` : `![${name}](${result.url})`;
+  }
+  if (kind === "video") {
+    return `<video src="${result.url}" controls></video>`;
+  }
+  if (kind === "audio") {
+    return `<audio src="${result.url}" controls></audio>`;
+  }
+  return `[${name}](${result.url})`;
+}
+var uploadSequence = 0;
+function nextUploadTaskId() {
+  uploadSequence += 1;
+  return `task-${Date.now()}-${uploadSequence}`;
+}
+function findMarkerRange(view, taskId) {
+  const doc = view.state.doc.toString();
+  const marker = `mardora-upload://${taskId}`;
+  const markerIndex = doc.indexOf(marker);
+  if (markerIndex === -1) {
+    return null;
+  }
+  const line = view.state.doc.lineAt(markerIndex);
+  return { from: line.from, to: line.to };
+}
+async function uploadAttachmentFile(view, file, options) {
+  const kind = options.kind ?? detectAttachmentKind(file);
+  const range = options.range ?? {
+    from: view.state.selection.main.from,
+    to: view.state.selection.main.to
+  };
+  const taskId = nextUploadTaskId();
+  const marker = createUploadMarker({ taskId, kind, name: file.name, state: "uploading" });
+  view.dispatch({
+    changes: { from: range.from, to: range.to, insert: marker },
+    selection: { anchor: range.from + marker.length },
+    scrollIntoView: true
+  });
+  try {
+    const result = await options.uploader(file, {
+      kind,
+      source: options.source,
+      documentText: view.state.doc.toString(),
+      selection: { from: range.from, to: range.from + marker.length }
+    });
+    const markerRange = findMarkerRange(view, taskId);
+    if (!markerRange) {
+      return;
+    }
+    const output = formatAttachmentMarkdown(kind, {
+      ...result,
+      name: result.name ?? file.name,
+      mimeType: result.mimeType ?? file.type
+    });
+    view.dispatch({
+      changes: { from: markerRange.from, to: markerRange.to, insert: output },
+      selection: { anchor: markerRange.from + output.length },
+      scrollIntoView: true
+    });
+  } catch {
+    const markerRange = findMarkerRange(view, taskId);
+    if (!markerRange) {
+      return;
+    }
+    const failedMarker = createUploadMarker({ taskId, kind, name: file.name, state: "failed" });
+    view.dispatch({
+      changes: { from: markerRange.from, to: markerRange.to, insert: failedMarker },
+      selection: { anchor: markerRange.from + failedMarker.length },
+      scrollIntoView: true
+    });
+  }
+}
+function getFilesFromEvent(event) {
+  const files = event.type === "paste" ? event.clipboardData?.files : event.dataTransfer?.files;
+  return files ? Array.from(files) : [];
+}
+function uploadFilesFromEvent(view, event, source, config) {
+  const files = getFilesFromEvent(event);
+  if (files.length === 0) {
+    return false;
+  }
+  event.preventDefault();
+  for (const file of files) {
+    const kind = detectAttachmentKind(file);
+    const acceptRules = config.accept?.[kind] ?? ["*/*"];
+    if (!isAcceptedAttachment(file, acceptRules)) {
+      continue;
+    }
+    void uploadAttachmentFile(view, file, {
+      kind,
+      source,
+      uploader: config.uploader
+    });
+  }
+  return true;
+}
+function attachments(config = {}) {
+  if (config.enabled === false || !config.uploader) {
+    return [];
+  }
+  const normalizedConfig = {
+    enablePaste: true,
+    enableDrop: true,
+    ...config,
+    uploader: config.uploader
+  };
+  return [
+    view.EditorView.domEventHandlers({
+      paste(event, view) {
+        if (!normalizedConfig.enablePaste) {
+          return false;
+        }
+        return uploadFilesFromEvent(view, event, "paste", normalizedConfig);
+      },
+      drop(event, view) {
+        if (!normalizedConfig.enableDrop) {
+          return false;
+        }
+        return uploadFilesFromEvent(view, event, "drop", normalizedConfig);
+      }
+    })
+  ];
+}
+
+// src/editor/i18n.ts
+var defaultMardoraLocale = "zh-CN";
+var supportedMardoraLocales = /* @__PURE__ */ new Set(["zh-CN", "en-US"]);
+function resolveMardoraLocale(locale) {
+  return locale && supportedMardoraLocales.has(locale) ? locale : defaultMardoraLocale;
+}
+
+// src/editor/slash/position.ts
+var menuWidth = 328;
+var menuMaxHeight = 420;
+var viewportPadding = 8;
+var anchorGap = 6;
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function computeSlashMenuLayout(input) {
+  const maxLeft = Math.max(viewportPadding, input.viewport.width - menuWidth - viewportPadding);
+  const left = clamp(input.anchor.left, viewportPadding, maxLeft);
+  const availableBelow = Math.max(1, input.viewport.height - input.anchor.bottom - anchorGap - viewportPadding);
+  const availableAbove = Math.max(1, input.anchor.top - anchorGap - viewportPadding);
+  const placement = availableBelow >= menuMaxHeight || availableBelow >= availableAbove ? "bottom" : "top";
+  if (placement === "bottom") {
+    return {
+      placement,
+      left,
+      top: input.anchor.bottom + anchorGap,
+      bottom: null,
+      maxHeight: Math.min(menuMaxHeight, availableBelow)
+    };
+  }
+  return {
+    placement,
+    left,
+    top: null,
+    bottom: input.viewport.height - input.anchor.top + anchorGap,
+    maxHeight: Math.min(menuMaxHeight, availableAbove)
+  };
+}
+
+// src/editor/slash/extension.ts
+function createSlashRuntimeConfig(config = {}) {
+  const locale = resolveMardoraLocale(config.locale ?? config.inheritedLocale);
+  return {
+    ...config,
+    locale,
+    commands: config.commands ?? getDefaultSlashCommands(locale),
+    messages: getSlashMessages(locale)
+  };
+}
+function requestFile(kind) {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = kind === "image" ? "image/*" : kind === "video" ? "video/*" : kind === "audio" ? "audio/*" : "*/*";
+    input.addEventListener("change", () => resolve(input.files?.[0] ?? null), { once: true });
+    input.click();
+  });
+}
+var SlashCommandViewPlugin = class {
+  constructor(view, config) {
+    this.view = view;
+    this.config = config;
+    this.view.dom.ownerDocument.addEventListener("keydown", this.handleDocumentKeydown, true);
+    this.updateState();
+  }
+  view;
+  config;
+  query = null;
+  commands = [];
+  activeIndex = 0;
+  menu = null;
+  renderVersion = 0;
+  previousCaretColor = null;
+  update(update) {
+    if (update.docChanged || update.selectionSet || update.viewportChanged) {
+      this.updateState();
+    }
+  }
+  destroy() {
+    this.view.dom.ownerDocument.removeEventListener("keydown", this.handleDocumentKeydown, true);
+    this.renderVersion += 1;
+    this.removeMenu();
+  }
+  move(delta) {
+    if (!this.query || this.commands.length === 0) return false;
+    this.activeIndex = (this.activeIndex + delta + this.commands.length) % this.commands.length;
+    this.syncActiveItem("center");
+    return true;
+  }
+  close() {
+    if (!this.query) return false;
+    this.query = null;
+    this.commands = [];
+    this.renderVersion += 1;
+    this.removeMenu();
+    return true;
+  }
+  selectActive() {
+    if (!this.query || this.commands.length === 0) return false;
+    return this.select(this.activeIndex);
+  }
+  handleKeydown(event) {
+    if (event.key === "ArrowDown") {
+      return this.move(1);
+    }
+    if (event.key === "ArrowUp") {
+      return this.move(-1);
+    }
+    if (event.key === "Enter") {
+      return this.selectActive();
+    }
+    if (event.key === "Escape") {
+      return this.close();
+    }
+    return false;
+  }
+  select(index) {
+    const command = this.commands[index];
+    if (!this.query || !command) return false;
+    const queryRange = { from: this.query.from, to: this.query.to };
+    this.close();
+    return command.run({
+      view: this.view,
+      queryRange,
+      requestAttachment: (kind, context) => this.requestAttachment(kind, context.queryRange)
+    });
+  }
+  requestAttachment(kind, queryRange) {
+    if (!this.config.attachmentUploader) {
+      return false;
+    }
+    void requestFile(kind).then((file) => {
+      if (!file || !this.config.attachmentUploader) return;
+      void uploadAttachmentFile(this.view, file, {
+        kind,
+        source: "slash",
+        range: queryRange,
+        uploader: this.config.attachmentUploader
+      });
+    });
+    return true;
+  }
+  handleDocumentKeydown = (event) => {
+    if (!this.query || event.defaultPrevented) return;
+    const handled = this.handleKeydown(event);
+    if (!handled) return;
+    event.preventDefault();
+    event.stopPropagation();
+  };
+  updateState() {
+    const cursor = this.view.state.selection.main.head;
+    const query = detectSlashQuery(this.view.state.doc.toString(), cursor);
+    if (!query) {
+      this.query = null;
+      this.commands = [];
+      this.renderVersion += 1;
+      this.removeMenu();
+      return;
+    }
+    if (!this.query || this.query.query !== query.query || this.query.from !== query.from) {
+      this.activeIndex = 0;
+    }
+    this.query = query;
+    this.commands = filterSlashCommands(this.config.commands, query.query);
+    this.activeIndex = Math.min(this.activeIndex, Math.max(0, this.commands.length - 1));
+    this.renderMenu();
+  }
+  renderMenu() {
+    if (!this.query) return;
+    const renderVersion = ++this.renderVersion;
+    const queryFrom = this.query.from;
+    this.removeMenu();
+    this.view.requestMeasure({
+      read: (view) => view.coordsAtPos(queryFrom),
+      write: (coords) => {
+        if (renderVersion !== this.renderVersion || !this.query || !coords) return;
+        this.removeMenu();
+        this.menu = createSlashMenuElement(
+          { commands: this.commands, activeIndex: this.activeIndex, messages: this.config.messages },
+          {
+            onHover: (index) => {
+              this.activeIndex = index;
+              this.syncActiveItem("nearest");
+            },
+            onSelect: (index) => {
+              this.select(index);
+            }
+          }
+        );
+        const layout = computeSlashMenuLayout({
+          anchor: { left: coords.left, top: coords.top, bottom: coords.bottom },
+          viewport: {
+            width: this.view.dom.ownerDocument.defaultView?.innerWidth ?? window.innerWidth,
+            height: this.view.dom.ownerDocument.defaultView?.innerHeight ?? window.innerHeight
+          }
+        });
+        this.menu.dataset.mardoraSlashPlacement = layout.placement;
+        this.menu.style.left = `${layout.left}px`;
+        this.menu.style.maxHeight = `${layout.maxHeight}px`;
+        this.menu.style.top = layout.top === null ? "" : `${layout.top}px`;
+        this.menu.style.bottom = layout.bottom === null ? "" : `${layout.bottom}px`;
+        this.view.dom.classList.add("cm-mardora-slash-open");
+        this.hideEditorCaret();
+        this.view.dom.appendChild(this.menu);
+        this.syncActiveItem("nearest");
+      }
+    });
+  }
+  syncActiveItem(scrollMode) {
+    if (!this.menu) return;
+    const items = this.menu.querySelectorAll(".cm-mardora-slash-item");
+    let activeItem = null;
+    items.forEach((item) => {
+      const itemIndex = Number(item.dataset.mardoraSlashIndex);
+      const isActive = itemIndex === this.activeIndex;
+      item.classList.toggle("cm-mardora-slash-item-active", isActive);
+      item.setAttribute("aria-selected", String(isActive));
+      if (isActive) {
+        activeItem = item;
+      }
+    });
+    if (activeItem) {
+      this.scrollActiveItemIntoView(activeItem, scrollMode);
+    }
+  }
+  scrollActiveItemIntoView(activeItem, mode) {
+    const list = this.menu?.querySelector(".cm-mardora-slash-list");
+    if (!list) return;
+    const itemTop = activeItem.offsetTop;
+    const itemBottom = itemTop + activeItem.offsetHeight;
+    const visibleTop = list.scrollTop;
+    const visibleBottom = visibleTop + list.clientHeight;
+    if (mode === "center") {
+      list.scrollTop = itemTop - (list.clientHeight - activeItem.offsetHeight) / 2;
+      return;
+    }
+    if (itemTop < visibleTop) {
+      list.scrollTop = itemTop;
+      return;
+    }
+    if (itemBottom > visibleBottom) {
+      list.scrollTop = itemBottom - list.clientHeight;
+    }
+  }
+  hideEditorCaret() {
+    if (this.previousCaretColor === null) {
+      this.previousCaretColor = this.view.contentDOM.style.caretColor;
+    }
+    this.view.contentDOM.style.caretColor = "transparent";
+  }
+  restoreEditorCaret() {
+    if (this.previousCaretColor === null) return;
+    this.view.contentDOM.style.caretColor = this.previousCaretColor;
+    this.previousCaretColor = null;
+  }
+  removeMenu() {
+    this.menu?.remove();
+    this.menu = null;
+    this.view.dom.classList.remove("cm-mardora-slash-open");
+    this.restoreEditorCaret();
+  }
+};
+function slashCommands(config = {}) {
+  if (config.enabled === false) {
+    return [];
+  }
+  const normalizedConfig = createSlashRuntimeConfig(config);
+  const plugin = view.ViewPlugin.define((view) => new SlashCommandViewPlugin(view, normalizedConfig));
+  return [
+    slashMenuTheme,
+    plugin,
+    state.Prec.highest(
+      view.EditorView.domEventHandlers({
+        keydown(event, view) {
+          const value = view.plugin(plugin);
+          if (!value) return false;
+          const handled = value.handleKeydown(event);
+          if (handled) event.preventDefault();
+          return handled;
+        }
+      })
+    )
+  ];
+}
+
+// src/editor/selection-toolbar/position.ts
+var viewportPadding2 = 8;
+var anchorGap2 = 8;
+function clamp2(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function computeSelectionToolbarLayout(input) {
+  const selectionCenter = (input.anchor.left + input.anchor.right) / 2;
+  const boundary = input.boundary ?? {
+    left: viewportPadding2,
+    right: input.viewport.width - viewportPadding2,
+    top: viewportPadding2,
+    bottom: input.viewport.height - viewportPadding2
+  };
+  const minLeft = Math.max(viewportPadding2, boundary.left);
+  const maxLeft = Math.max(minLeft, Math.min(input.viewport.width - input.floating.width - viewportPadding2, boundary.right - input.floating.width));
+  const left = clamp2(Math.round(selectionCenter - input.floating.width / 2), minLeft, maxLeft);
+  const topLimit = Math.max(viewportPadding2, boundary.top);
+  const bottomLimit = Math.min(input.viewport.height - viewportPadding2, boundary.bottom);
+  const availableAbove = Math.max(1, input.anchor.top - anchorGap2 - topLimit);
+  const availableBelow = Math.max(1, bottomLimit - input.anchor.bottom - anchorGap2);
+  const placement = availableAbove >= input.floating.height || availableAbove >= availableBelow ? "top" : "bottom";
+  if (placement === "top") {
+    return {
+      placement,
+      left,
+      top: Math.max(topLimit, Math.round(input.anchor.top - anchorGap2 - input.floating.height)),
+      maxHeight: availableAbove
+    };
+  }
+  return {
+    placement,
+    left,
+    top: Math.round(input.anchor.bottom + anchorGap2),
+    maxHeight: availableBelow
+  };
+}
+
+// src/editor/selection-toolbar/commands.ts
+var markdownLinkPattern = /^\[([^\]]*)\]\(([^)]*)\)$/;
+var urlPattern = /^(https?:\/\/|www\.)[^\s]+$/i;
+var listMarkerPattern = /^(\s*)([-*+]|\d+\.)\s(\[[ xX]\]\s)?/;
+var headingMarkerPattern = /^(\s*)(#{1,6})(?:[ \t]+|$)/;
+function selectedText(input) {
+  return input.doc.slice(input.from, input.to);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildHtmlWrapper(input) {
+  if (input.htmlTag) {
+    return { open: `<${input.htmlTag}>`, close: `</${input.htmlTag}>` };
+  }
+  if (input.spanStyle) {
+    return { open: `<span style="${input.spanStyle.property}: ${input.spanStyle.value}">`, close: "</span>" };
+  }
+  const marker = input.marker ?? "";
+  return { open: marker, close: marker };
+}
+function buildInlineFormatChange(input) {
+  const text = selectedText(input);
+  const { open, close } = buildHtmlWrapper(input);
+  if (input.clear) {
+    const tagPattern = input.spanStyle ? new RegExp(
+      `^<span style="${escapeRegExp(input.spanStyle.property)}: ${input.spanStyle.value ? escapeRegExp(input.spanStyle.value) : "#[0-9a-fA-F]{6}"}">([\\s\\S]*)<\\/span>$`
+    ) : input.htmlTag ? new RegExp(`^<${input.htmlTag}>([\\s\\S]*)<\\/${input.htmlTag}>$`) : null;
+    const match = tagPattern ? text.match(tagPattern) : null;
+    const insert2 = match?.[1] ?? text;
+    return {
+      changes: { from: input.from, to: input.to, insert: insert2 },
+      selection: { anchor: input.from, head: input.from + insert2.length }
+    };
+  }
+  const beforeFrom = Math.max(0, input.from - open.length);
+  const afterTo = Math.min(input.doc.length, input.to + close.length);
+  const before = input.doc.slice(beforeFrom, input.from);
+  const after = input.doc.slice(input.to, afterTo);
+  if (before === open && after === close) {
+    return {
+      changes: [
+        { from: beforeFrom, to: input.from, insert: "" },
+        { from: input.to, to: afterTo, insert: "" }
+      ],
+      selection: { anchor: beforeFrom, head: beforeFrom + text.length }
+    };
+  }
+  const insert = `${open}${text}${close}`;
+  return {
+    changes: { from: input.from, to: input.to, insert },
+    selection: { anchor: input.from + open.length, head: input.from + open.length + text.length }
+  };
+}
+function parseSelectedLink(text) {
+  const linkMatch = text.match(markdownLinkPattern);
+  if (linkMatch) {
+    return { kind: "markdown-link", title: linkMatch[1] ?? "", url: linkMatch[2] ?? "" };
+  }
+  if (urlPattern.test(text)) {
+    return { kind: "url", title: "", url: text };
+  }
+  return { kind: "text", title: text, url: "" };
+}
+function buildLinkChange(input) {
+  if (input.remove) {
+    return {
+      changes: { from: input.from, to: input.to, insert: input.title },
+      selection: { anchor: input.from, head: input.from + input.title.length }
+    };
+  }
+  if (!input.url.trim()) {
+    throw new Error("Link URL is required");
+  }
+  const insert = `[${input.title}](${input.url})`;
+  return {
+    changes: { from: input.from, to: input.to, insert },
+    selection: { anchor: input.from, head: input.from + insert.length }
+  };
+}
+function lineRanges(doc, from, to) {
+  const ranges = [];
+  let position = 0;
+  for (const text of doc.split("\n")) {
+    const lineFrom = position;
+    const lineTo = position + text.length;
+    if (lineTo >= from && lineFrom <= to) {
+      ranges.push({ from: lineFrom, text });
+    }
+    position = lineTo + 1;
+  }
+  return ranges;
+}
+function markerFor(kind, order) {
+  if (kind === "ordered") return `${order}. `;
+  if (kind === "task") return "- [ ] ";
+  return "- ";
+}
+function buildListChange(input) {
+  const changes = [];
+  let order = 1;
+  for (const line of lineRanges(input.doc, input.from, input.to)) {
+    const match = line.text.match(listMarkerPattern);
+    const actualMarker = markerFor(input.kind, order);
+    if (match) {
+      const indent = match[1] ?? "";
+      const isOrdered = /^\d+\.$/.test(match[2] ?? "");
+      const isUnordered = /^[-*+]$/.test(match[2] ?? "");
+      const hasTask = !!match[3];
+      const same = input.kind === "ordered" && isOrdered && !hasTask || input.kind === "unordered" && isUnordered && !hasTask || input.kind === "task" && hasTask;
+      changes.push({
+        from: line.from,
+        to: line.from + match[0].length,
+        insert: same ? indent : indent + actualMarker
+      });
+    } else {
+      const indentLength = line.text.match(/^(\s*)/)?.[1]?.length ?? 0;
+      changes.push({ from: line.from + indentLength, to: line.from + indentLength, insert: actualMarker });
+    }
+    if (input.kind === "ordered") order += 1;
+  }
+  return { changes };
+}
+function headingLevelForLine(text) {
+  return text.match(headingMarkerPattern)?.[2]?.length ?? 0;
+}
+function escapePlainTextBlockStart(text) {
+  if (/^\d+[.)]\s/.test(text)) {
+    return text.replace(/^(\d+)([.)])/, "$1\\$2");
+  }
+  if (/^[-*+]\s/.test(text) || /^#{1,6}(\s|$)/.test(text) || /^>\s?/.test(text)) {
+    return `\\${text}`;
+  }
+  return text;
+}
+function unescapePlainTextBlockStart(text) {
+  if (/^\d+\\[.)]\s/.test(text)) {
+    return text.replace(/^(\d+)\\([.)])/, "$1$2");
+  }
+  if (/^\\([-*+#>])/.test(text)) {
+    return text.slice(1);
+  }
+  return text;
+}
+function detectSelectionBlockType(input) {
+  const line = lineRanges(input.doc, input.from, input.to)[0];
+  const level = line ? headingLevelForLine(line.text) : 0;
+  return level > 0 ? `heading-${level}` : "text";
+}
+function buildBlockTypeChange(input) {
+  const changes = [];
+  const lines = lineRanges(input.doc, input.from, input.to);
+  let accumulatedDelta = 0;
+  let selectionAnchor = null;
+  let selectionHead = null;
+  for (const line of lines) {
+    const lineTo = line.from + line.text.length;
+    const headingMatch = line.text.match(headingMarkerPattern);
+    const indent = headingMatch?.[1] ?? line.text.match(/^(\s*)/)?.[1] ?? "";
+    const oldPrefixLength = headingMatch ? headingMatch[0].length : indent.length;
+    const content = line.text.slice(oldPrefixLength);
+    if (input.level === 0 && headingMatch) {
+      const escapedContent = escapePlainTextBlockStart(content);
+      if (escapedContent !== content) {
+        const insert = `${indent}${escapedContent}`;
+        const delta2 = insert.length - line.text.length;
+        changes.push({
+          from: line.from,
+          to: lineTo,
+          insert
+        });
+        const newContentFrom2 = line.from + accumulatedDelta + indent.length;
+        const newContentTo2 = lineTo + accumulatedDelta + delta2;
+        selectionAnchor ??= newContentFrom2;
+        selectionHead = newContentTo2;
+        accumulatedDelta += delta2;
+        continue;
+      }
+    }
+    const newPrefix = input.level === 0 ? indent : `${indent}${"#".repeat(input.level)} `;
+    const delta = newPrefix.length - oldPrefixLength;
+    const headingContent = input.level > 0 ? unescapePlainTextBlockStart(content) : content;
+    if (input.level > 0 && headingContent !== content) {
+      const insert = `${newPrefix}${headingContent}`;
+      const lineDelta = insert.length - line.text.length;
+      changes.push({
+        from: line.from,
+        to: lineTo,
+        insert
+      });
+      const newContentFrom2 = line.from + accumulatedDelta + newPrefix.length;
+      const newContentTo2 = lineTo + accumulatedDelta + lineDelta;
+      selectionAnchor ??= newContentFrom2;
+      selectionHead = newContentTo2;
+      accumulatedDelta += lineDelta;
+      continue;
+    }
+    if (newPrefix !== line.text.slice(0, oldPrefixLength)) {
+      changes.push({
+        from: line.from,
+        to: line.from + oldPrefixLength,
+        insert: newPrefix
+      });
+    }
+    const newContentFrom = line.from + accumulatedDelta + newPrefix.length;
+    const newContentTo = lineTo + accumulatedDelta + delta;
+    selectionAnchor ??= newContentFrom;
+    selectionHead = newContentTo;
+    accumulatedDelta += delta;
+  }
+  return {
+    changes,
+    selection: {
+      anchor: selectionAnchor ?? input.from,
+      head: selectionHead ?? input.to
+    }
+  };
+}
+
+// src/editor/selection-toolbar/menu.ts
+function iconButton(button, callbacks) {
+  const element = document.createElement("button");
+  element.type = "button";
+  element.className = button.active ? "cm-mardora-selection-toolbar-button cm-mardora-selection-toolbar-button-active" : "cm-mardora-selection-toolbar-button";
+  element.setAttribute("aria-label", button.label);
+  element.setAttribute("aria-pressed", String(!!button.active));
+  element.dataset.mardoraSelectionAction = button.id;
+  element.addEventListener("mousedown", (event) => {
+    event.preventDefault();
+    callbacks.onAction(button.id);
+  });
+  if (button.text) {
+    element.classList.add("cm-mardora-selection-toolbar-block-button");
+    const label = document.createElement("span");
+    label.className = "cm-mardora-selection-toolbar-button-text";
+    label.textContent = button.text;
+    element.appendChild(label);
+  } else if (button.id === "block-type") {
+    element.classList.add("cm-mardora-selection-toolbar-block-button");
+    const icon = chunkWFVCG4LD_cjs.createMardoraIcon(button.icon);
+    if (icon) element.appendChild(icon);
+  } else {
+    const icon = chunkWFVCG4LD_cjs.createMardoraIcon(button.icon);
+    if (icon) {
+      element.appendChild(icon);
+    } else {
+      element.textContent = button.label;
+    }
+  }
+  return element;
+}
+function blockTypeIcon(type) {
+  const icon = document.createElement("span");
+  icon.className = "cm-mardora-selection-toolbar-block-menu-icon";
+  if (type === "text") {
+    const svg = chunkWFVCG4LD_cjs.createMardoraIcon("text-align-start");
+    if (svg) icon.appendChild(svg);
+  } else {
+    icon.textContent = `H${type.slice("heading-".length)}`;
+  }
+  return icon;
+}
+function appendBlockTypePanel(root, state, callbacks) {
+  const list = document.createElement("div");
+  list.className = "cm-mardora-selection-toolbar-block-menu";
+  list.setAttribute("role", "menu");
+  for (const item of state.blockTypes) {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = item.type === state.blockType ? "cm-mardora-selection-toolbar-block-item cm-mardora-selection-toolbar-block-item-active" : "cm-mardora-selection-toolbar-block-item";
+    button.setAttribute("aria-label", item.label);
+    button.setAttribute("aria-pressed", String(item.type === state.blockType));
+    button.setAttribute("role", "menuitemradio");
+    button.dataset.mardoraBlockType = item.type;
+    button.addEventListener("mousedown", (event) => {
+      event.preventDefault();
+      callbacks.onBlockType(item.type);
+    });
+    const label = document.createElement("span");
+    label.className = "cm-mardora-selection-toolbar-block-menu-label";
+    label.textContent = item.label;
+    button.append(blockTypeIcon(item.type), label);
+    list.appendChild(button);
+  }
+  root.appendChild(list);
+}
+function divider() {
+  const element = document.createElement("span");
+  element.className = "cm-mardora-selection-toolbar-divider";
+  element.setAttribute("aria-hidden", "true");
+  return element;
+}
+function appendToolbarButtons(root, buttons, callbacks) {
+  const groups = [buttons.slice(0, 1), buttons.slice(1, 8), buttons.slice(8, 9), buttons.slice(9)];
+  groups.forEach((group, index) => {
+    if (group.length === 0) return;
+    if (index > 0) root.appendChild(divider());
+    for (const button of group) root.appendChild(iconButton(button, callbacks));
+  });
+}
+function paletteButton(item, className, callback) {
+  const element = document.createElement("button");
+  element.type = "button";
+  element.className = className;
+  element.setAttribute("aria-label", item.label);
+  element.title = item.label;
+  element.dataset.mardoraSwatch = item.id;
+  if (item.value) element.style.setProperty("--mardora-swatch-color", item.value);
+  element.addEventListener("mousedown", (event) => {
+    event.preventDefault();
+    callback(item.value);
+  });
+  return element;
+}
+function appendPalette(root, title, items, callback) {
+  const group = document.createElement("div");
+  group.className = "cm-mardora-selection-toolbar-palette-group";
+  const label = document.createElement("div");
+  label.className = "cm-mardora-selection-toolbar-palette-label";
+  label.textContent = title;
+  group.appendChild(label);
+  const grid = document.createElement("div");
+  grid.className = "cm-mardora-selection-toolbar-swatch-grid";
+  for (const item of items) {
+    grid.appendChild(paletteButton(item, "cm-mardora-selection-toolbar-swatch", callback));
+  }
+  group.appendChild(grid);
+  root.appendChild(group);
+}
+function appendLinkAction(actions, label, iconName, callback, danger = false) {
+  const button = document.createElement("button");
+  button.type = "button";
+  button.className = danger ? "cm-mardora-selection-toolbar-link-button cm-mardora-selection-toolbar-link-button-danger" : "cm-mardora-selection-toolbar-link-button";
+  button.setAttribute("aria-label", label);
+  const svg = chunkWFVCG4LD_cjs.createMardoraIcon(iconName);
+  if (svg) button.appendChild(svg);
+  button.addEventListener("mousedown", (event) => {
+    event.preventDefault();
+    callback();
+  });
+  actions.appendChild(button);
+}
+function appendLinkPanel(root, state, callbacks) {
+  const title = document.createElement("input");
+  title.className = "cm-mardora-selection-toolbar-link-input";
+  title.setAttribute("aria-label", state.messages.link.title);
+  title.value = state.link.title;
+  title.addEventListener("input", () => callbacks.onLinkInput("title", title.value));
+  title.addEventListener("keydown", (event) => {
+    if (event.key === "Enter") callbacks.onLinkSubmit();
+    if (event.key === "Escape") callbacks.onCancelPanel();
+  });
+  const url = document.createElement("input");
+  url.className = "cm-mardora-selection-toolbar-link-input";
+  url.setAttribute("aria-label", state.messages.link.url);
+  url.value = state.link.url;
+  url.addEventListener("input", () => callbacks.onLinkInput("url", url.value));
+  url.addEventListener("keydown", (event) => {
+    if (event.key === "Enter") callbacks.onLinkSubmit();
+    if (event.key === "Escape") callbacks.onCancelPanel();
+  });
+  const actions = document.createElement("div");
+  actions.className = "cm-mardora-selection-toolbar-link-actions";
+  appendLinkAction(actions, state.link.copied ? state.messages.link.copied : state.messages.link.copy, "copy", callbacks.onLinkCopy);
+  appendLinkAction(actions, state.messages.link.open, "external-link", callbacks.onLinkOpen);
+  if (state.link.canRemove) appendLinkAction(actions, state.messages.link.remove, "trash-2", callbacks.onLinkRemove, true);
+  root.append(title, url);
+  if (state.link.error) {
+    const error = document.createElement("div");
+    error.className = "cm-mardora-selection-toolbar-error";
+    error.textContent = state.link.error;
+    root.appendChild(error);
+  }
+  root.appendChild(actions);
+  queueMicrotask(() => {
+    title.focus();
+    title.select();
+  });
+}
+function createSelectionToolbarElement(state, callbacks) {
+  const root = document.createElement("div");
+  root.className = state.panel === "toolbar" || state.panel === "block-type" ? "cm-mardora-selection-toolbar" : "cm-mardora-selection-toolbar cm-mardora-selection-toolbar-panel";
+  root.setAttribute("role", "toolbar");
+  root.addEventListener("mousedown", (event) => {
+    const target = event.target;
+    if (target instanceof HTMLElement && target.closest(".cm-mardora-selection-toolbar-link-input")) return;
+    event.preventDefault();
+  });
+  if (state.panel === "toolbar" || state.panel === "block-type") {
+    appendToolbarButtons(root, state.buttons, callbacks);
+    if (state.panel === "block-type") appendBlockTypePanel(root, state, callbacks);
+  } else if (state.panel === "link") {
+    appendLinkPanel(root, state, callbacks);
+  } else if (state.panel === "color") {
+    appendPalette(root, state.messages.panels.textColor, state.textColors, callbacks.onColor);
+  } else {
+    appendPalette(root, state.messages.panels.highlightColor, state.highlightColors, callbacks.onHighlight);
+  }
+  return root;
+}
+var selectionToolbarTheme = view.EditorView.baseTheme({
+  ".cm-mardora-selection-toolbar": {
+    position: "fixed",
+    zIndex: "1001",
+    display: "inline-flex",
+    alignItems: "center",
+    gap: "2px",
+    border: "1px solid rgba(24, 24, 27, 0.14)",
+    borderRadius: "10px",
+    background: "var(--mardora-selection-toolbar-bg, #ffffff)",
+    boxShadow: "0 14px 38px rgba(15, 23, 42, 0.16)",
+    padding: "4px",
+    color: "var(--mardora-selection-toolbar-fg, #18181b)",
+    fontFamily: "var(--font-sans, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif)",
+    userSelect: "none"
+  },
+  ".cm-mardora-selection-toolbar-panel": {
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "stretch",
+    width: "336px",
+    gap: "6px",
+    padding: "8px"
+  },
+  ".cm-mardora-selection-toolbar-block-button": {
+    minWidth: "44px",
+    width: "44px",
+    fontWeight: "400"
+  },
+  ".cm-mardora-selection-toolbar-button-text": {
+    fontSize: "13px",
+    lineHeight: "1"
+  },
+  ".cm-mardora-selection-toolbar-button, .cm-mardora-selection-toolbar-link-button": {
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: "30px",
+    height: "30px",
+    border: "0",
+    borderRadius: "7px",
+    background: "transparent",
+    color: "inherit",
+    cursor: "default",
+    padding: "0"
+  },
+  ".cm-mardora-selection-toolbar-button:hover, .cm-mardora-selection-toolbar-button-active": {
+    background: "var(--mardora-selection-toolbar-active, #f4f4f5)"
+  },
+  ".cm-mardora-selection-toolbar-button svg, .cm-mardora-selection-toolbar-link-button svg": {
+    width: "16px",
+    height: "16px",
+    strokeWidth: "2"
+  },
+  ".cm-mardora-selection-toolbar-divider": {
+    width: "1px",
+    height: "22px",
+    margin: "0 4px",
+    background: "var(--mardora-selection-toolbar-border, #e4e4e7)"
+  },
+  ".cm-mardora-selection-toolbar-block-menu": {
+    position: "absolute",
+    left: "0",
+    zIndex: "1002",
+    display: "flex",
+    flexDirection: "column",
+    gap: "1px",
+    boxSizing: "border-box",
+    width: "168px",
+    maxHeight: "var(--mardora-selection-toolbar-popover-max-height, 240px)",
+    overflowY: "auto",
+    border: "1px solid rgba(24, 24, 27, 0.14)",
+    borderRadius: "8px",
+    background: "var(--mardora-selection-toolbar-bg, #ffffff)",
+    boxShadow: "0 12px 28px rgba(15, 23, 42, 0.14)",
+    padding: "5px"
+  },
+  '.cm-mardora-selection-toolbar[data-mardora-selection-placement="bottom"] .cm-mardora-selection-toolbar-block-menu': {
+    top: "calc(100% + 6px)"
+  },
+  '.cm-mardora-selection-toolbar[data-mardora-selection-placement="top"] .cm-mardora-selection-toolbar-block-menu': {
+    bottom: "calc(100% + 6px)"
+  },
+  ".cm-mardora-selection-toolbar-block-item": {
+    display: "flex",
+    alignItems: "center",
+    gap: "8px",
+    border: "0",
+    borderRadius: "6px",
+    background: "transparent",
+    color: "inherit",
+    cursor: "default",
+    font: "inherit",
+    minHeight: "28px",
+    padding: "4px 8px",
+    textAlign: "left"
+  },
+  ".cm-mardora-selection-toolbar-block-item:hover, .cm-mardora-selection-toolbar-block-item-active": {
+    background: "var(--mardora-selection-toolbar-active, #f4f4f5)"
+  },
+  ".cm-mardora-selection-toolbar-block-menu-icon": {
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: "22px",
+    color: "inherit",
+    fontSize: "12px",
+    fontWeight: "400",
+    lineHeight: "1"
+  },
+  ".cm-mardora-selection-toolbar-block-menu-label": {
+    fontSize: "13px",
+    lineHeight: "1.1"
+  },
+  ".cm-mardora-selection-toolbar-link-input": {
+    boxSizing: "border-box",
+    width: "100%",
+    border: "0",
+    borderRadius: "7px",
+    background: "var(--mardora-selection-toolbar-input, #f4f4f5)",
+    color: "inherit",
+    font: "inherit",
+    fontSize: "14px",
+    outline: "none",
+    padding: "8px 10px"
+  },
+  ".cm-mardora-selection-toolbar-link-actions": {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "flex-end",
+    gap: "6px"
+  },
+  ".cm-mardora-selection-toolbar-link-button:hover": {
+    background: "var(--mardora-selection-toolbar-active, #f4f4f5)"
+  },
+  ".cm-mardora-selection-toolbar-link-button-danger": {
+    color: "var(--mardora-selection-toolbar-danger, #dc2626)"
+  },
+  ".cm-mardora-selection-toolbar-link-button-danger:hover": {
+    background: "var(--mardora-selection-toolbar-danger-bg, #fee2e2)"
+  },
+  ".cm-mardora-selection-toolbar-error": {
+    color: "var(--mardora-selection-toolbar-danger, #dc2626)",
+    fontSize: "12px",
+    padding: "0 2px"
+  },
+  ".cm-mardora-selection-toolbar-palette-label": {
+    color: "var(--mardora-selection-toolbar-muted, #71717a)",
+    fontSize: "12px",
+    padding: "0 2px 4px"
+  },
+  ".cm-mardora-selection-toolbar-swatch-grid": {
+    display: "grid",
+    gridTemplateColumns: "repeat(8, 24px)",
+    gap: "6px"
+  },
+  ".cm-mardora-selection-toolbar-swatch": {
+    width: "24px",
+    height: "24px",
+    border: "1px solid var(--mardora-selection-toolbar-border, #e4e4e7)",
+    borderRadius: "6px",
+    background: "var(--mardora-swatch-color, transparent)",
+    boxShadow: "inset 0 0 0 1px rgba(255, 255, 255, 0.72)",
+    cursor: "default",
+    outline: "none",
+    padding: "0",
+    transition: "border-color 120ms ease, box-shadow 120ms ease, transform 120ms ease"
+  },
+  ".cm-mardora-selection-toolbar-swatch:hover": {
+    borderColor: "var(--mardora-selection-toolbar-swatch-hover-border, #a1a1aa)",
+    boxShadow: "0 0 0 3px var(--mardora-selection-toolbar-swatch-hover-ring, rgba(24, 24, 27, 0.08)), inset 0 0 0 1px rgba(255, 255, 255, 0.72)",
+    transform: "translateY(-1px)"
+  },
+  ".cm-mardora-selection-toolbar-swatch:focus-visible": {
+    borderColor: "var(--mardora-selection-toolbar-swatch-hover-border, #71717a)",
+    boxShadow: "0 0 0 3px var(--mardora-selection-toolbar-swatch-hover-ring, rgba(24, 24, 27, 0.12)), inset 0 0 0 1px rgba(255, 255, 255, 0.72)"
+  },
+  "&dark .cm-mardora-selection-toolbar": {
+    "--mardora-selection-toolbar-bg": "#18181b",
+    "--mardora-selection-toolbar-fg": "#f4f4f5",
+    "--mardora-selection-toolbar-active": "#27272a",
+    "--mardora-selection-toolbar-border": "#3f3f46",
+    "--mardora-selection-toolbar-input": "#27272a",
+    "--mardora-selection-toolbar-muted": "#a1a1aa",
+    "--mardora-selection-toolbar-link": "#60a5fa",
+    "--mardora-selection-toolbar-danger": "#f87171",
+    "--mardora-selection-toolbar-danger-bg": "rgba(248, 113, 113, 0.18)",
+    "--mardora-selection-toolbar-swatch-hover-border": "#71717a",
+    "--mardora-selection-toolbar-swatch-hover-ring": "rgba(244, 244, 245, 0.12)"
+  }
+});
+
+// src/editor/selection-toolbar/i18n.ts
+var selectionToolbarMessages = {
+  "zh-CN": {
+    buttons: {
+      blockType: "\u5757\u7C7B\u578B",
+      bold: "\u52A0\u7C97",
+      italic: "\u659C\u4F53",
+      strike: "\u5220\u9664\u7EBF",
+      underline: "\u4E0B\u5212\u7EBF",
+      code: "\u884C\u5185\u4EE3\u7801",
+      highlight: "\u9AD8\u4EAE",
+      color: "\u6587\u5B57\u989C\u8272",
+      link: "\u94FE\u63A5",
+      orderedList: "\u6709\u5E8F\u5217\u8868",
+      unorderedList: "\u65E0\u5E8F\u5217\u8868",
+      taskList: "\u4EFB\u52A1\u5217\u8868"
+    },
+    panels: {
+      textColor: "\u6587\u5B57\u989C\u8272",
+      highlightColor: "\u9AD8\u4EAE\u989C\u8272"
+    },
+    link: {
+      title: "\u94FE\u63A5\u6807\u9898",
+      url: "\u94FE\u63A5 URL",
+      copy: "\u590D\u5236\u94FE\u63A5",
+      copied: "\u5DF2\u590D\u5236",
+      open: "\u6253\u5F00\u94FE\u63A5",
+      remove: "\u79FB\u9664\u94FE\u63A5",
+      invalid: "\u8BF7\u8F93\u5165\u6709\u6548\u94FE\u63A5"
+    },
+    blockTypes: {
+      text: "\u6587\u672C",
+      "heading-1": "\u6807\u9898 1",
+      "heading-2": "\u6807\u9898 2",
+      "heading-3": "\u6807\u9898 3",
+      "heading-4": "\u6807\u9898 4",
+      "heading-5": "\u6807\u9898 5",
+      "heading-6": "\u6807\u9898 6"
+    },
+    colors: {
+      defaultText: "\u9ED8\u8BA4\u6587\u5B57\u989C\u8272",
+      gray: "\u7070\u8272",
+      red: "\u7EA2\u8272",
+      orange: "\u6A59\u8272",
+      yellow: "\u9EC4\u8272",
+      green: "\u7EFF\u8272",
+      blue: "\u84DD\u8272",
+      purple: "\u7D2B\u8272",
+      defaultHighlight: "\u9ED8\u8BA4\u9AD8\u4EAE",
+      yellowHighlight: "\u9EC4\u8272\u9AD8\u4EAE",
+      greenHighlight: "\u7EFF\u8272\u9AD8\u4EAE",
+      blueHighlight: "\u84DD\u8272\u9AD8\u4EAE",
+      pinkHighlight: "\u7C89\u8272\u9AD8\u4EAE",
+      purpleHighlight: "\u7D2B\u8272\u9AD8\u4EAE"
+    }
+  },
+  "en-US": {
+    buttons: {
+      blockType: "Block type",
+      bold: "Bold",
+      italic: "Italic",
+      strike: "Strikethrough",
+      underline: "Underline",
+      code: "Inline code",
+      highlight: "Highlight",
+      color: "Text color",
+      link: "Link",
+      orderedList: "Numbered list",
+      unorderedList: "Bulleted list",
+      taskList: "To-do list"
+    },
+    panels: {
+      textColor: "Text color",
+      highlightColor: "Highlight color"
+    },
+    link: {
+      title: "Link title",
+      url: "Link URL",
+      copy: "Copy link",
+      copied: "Copied",
+      open: "Open link",
+      remove: "Remove link",
+      invalid: "Enter a valid link"
+    },
+    blockTypes: {
+      text: "Text",
+      "heading-1": "Heading 1",
+      "heading-2": "Heading 2",
+      "heading-3": "Heading 3",
+      "heading-4": "Heading 4",
+      "heading-5": "Heading 5",
+      "heading-6": "Heading 6"
+    },
+    colors: {
+      defaultText: "Default text color",
+      gray: "Gray",
+      red: "Red",
+      orange: "Orange",
+      yellow: "Yellow",
+      green: "Green",
+      blue: "Blue",
+      purple: "Purple",
+      defaultHighlight: "Default highlight",
+      yellowHighlight: "Yellow highlight",
+      greenHighlight: "Green highlight",
+      blueHighlight: "Blue highlight",
+      pinkHighlight: "Pink highlight",
+      purpleHighlight: "Purple highlight"
+    }
+  }
+};
+function getSelectionToolbarMessages(locale) {
+  return selectionToolbarMessages[locale];
+}
+
+// src/editor/selection-toolbar/activation.ts
+var excludedClassPrefixes = [
+  "cm-mardora-code-block",
+  "cm-mardora-code-caption",
+  "cm-mardora-code-copy",
+  "cm-mardora-code-diff",
+  "cm-mardora-code-fence",
+  "cm-mardora-code-header",
+  "cm-mardora-code-line",
+  "cm-mardora-image-",
+  "cm-mardora-math-",
+  "cm-mardora-mermaid-"
+];
+var excludedSyntaxNodeNames = /* @__PURE__ */ new Set(["FencedCode", "MermaidBlock", "MathBlock", "InlineMath", "Image"]);
+function canActivateFromNativeSelection(input) {
+  return !input.nativeSelectionCollapsed && input.anchorInEditor && input.focusInEditor && input.rangeCount > 0 && !input.anchorExcluded && !input.focusExcluded;
+}
+function hasSelectionToolbarExcludedAncestor(target, root) {
+  let current = toElementLike(target);
+  while (current) {
+    if (hasExcludedClass(current)) {
+      return true;
+    }
+    if (current === root) {
+      return false;
+    }
+    current = toElementLike(current.parentElement);
+  }
+  return false;
+}
+function selectionOverlapsExcludedSyntaxNode(input) {
+  return excludedSyntaxNodeNames.has(input.nodeName) && input.selectionFrom < input.nodeTo && input.selectionTo > input.nodeFrom;
+}
+function toElementLike(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const element = value;
+  if (hasClassData(element)) {
+    return element;
+  }
+  return toElementLike(element.parentElement);
+}
+function hasClassData(value) {
+  return value.className !== void 0 || value.classList !== void 0 || value.parentElement !== void 0;
+}
+function hasExcludedClass(element) {
+  for (const className of classNamesFrom(element)) {
+    if (excludedClassPrefixes.some((prefix) => className.startsWith(prefix))) {
+      return true;
+    }
+  }
+  return false;
+}
+function classNamesFrom(element) {
+  const classList = element.classList;
+  if (isClassListLike(classList)) {
+    const classNames = [];
+    for (let index = 0; index < classList.length; index += 1) {
+      const item = classList.item(index);
+      if (item) classNames.push(item);
+    }
+    return classNames;
+  }
+  return typeof element.className === "string" ? element.className.split(/\s+/).filter(Boolean) : [];
+}
+function isClassListLike(value) {
+  return !!value && typeof value === "object" && typeof value.length === "number" && typeof value.item === "function";
+}
+
+// src/editor/selection-toolbar/extension.ts
+var toolbarWidth = 448;
+var toolbarHeight = 40;
+var panelWidth = 336;
+var blockTypePanelHeight = 300;
+var linkPanelHeight = 138;
+var palettePanelHeight = 72;
+var popoverGap = 6;
+function textColors(messages) {
+  return [
+    { id: "default", label: messages.colors.defaultText, value: null },
+    { id: "gray", label: messages.colors.gray, value: "#71717a" },
+    { id: "red", label: messages.colors.red, value: "#dc2626" },
+    { id: "orange", label: messages.colors.orange, value: "#ea580c" },
+    { id: "yellow", label: messages.colors.yellow, value: "#ca8a04" },
+    { id: "green", label: messages.colors.green, value: "#16a34a" },
+    { id: "blue", label: messages.colors.blue, value: "#2563eb" },
+    { id: "purple", label: messages.colors.purple, value: "#7c3aed" }
+  ];
+}
+function highlightColors(messages) {
+  return [
+    { id: "default", label: messages.colors.defaultHighlight, value: null },
+    { id: "yellow", label: messages.colors.yellowHighlight, value: "#fef08a" },
+    { id: "green", label: messages.colors.greenHighlight, value: "#bbf7d0" },
+    { id: "blue", label: messages.colors.blueHighlight, value: "#bfdbfe" },
+    { id: "pink", label: messages.colors.pinkHighlight, value: "#fbcfe8" },
+    { id: "purple", label: messages.colors.purpleHighlight, value: "#ddd6fe" }
+  ];
+}
+function blockTypeOptions(messages) {
+  return [
+    { type: "text", label: messages.blockTypes.text, icon: "text-align-start" },
+    { type: "heading-1", label: messages.blockTypes["heading-1"], icon: "heading-1" },
+    { type: "heading-2", label: messages.blockTypes["heading-2"], icon: "heading-2" },
+    { type: "heading-3", label: messages.blockTypes["heading-3"], icon: "heading-3" },
+    { type: "heading-4", label: messages.blockTypes["heading-4"], icon: "heading-4" },
+    { type: "heading-5", label: messages.blockTypes["heading-5"], icon: "heading-5" },
+    { type: "heading-6", label: messages.blockTypes["heading-6"], icon: "heading-6" }
+  ];
+}
+function blockButton(blockType, messages) {
+  return blockType === "text" ? { id: "block-type", label: messages.buttons.blockType, icon: "text-align-start" } : {
+    id: "block-type",
+    label: messages.buttons.blockType,
+    icon: blockType,
+    text: `H${blockType.slice("heading-".length)}`
+  };
+}
+function defaultButtons(messages, blockType) {
+  return [
+    blockButton(blockType, messages),
+    { id: "bold", label: messages.buttons.bold, icon: "bold" },
+    { id: "italic", label: messages.buttons.italic, icon: "italic" },
+    { id: "strike", label: messages.buttons.strike, icon: "strikethrough" },
+    { id: "underline", label: messages.buttons.underline, icon: "underline" },
+    { id: "code", label: messages.buttons.code, icon: "code" },
+    { id: "highlight", label: messages.buttons.highlight, icon: "highlighter" },
+    { id: "color", label: messages.buttons.color, icon: "baseline" },
+    { id: "link", label: messages.buttons.link, icon: "link" },
+    { id: "ordered-list", label: messages.buttons.orderedList, icon: "list-ordered" },
+    { id: "unordered-list", label: messages.buttons.unorderedList, icon: "list" },
+    { id: "task-list", label: messages.buttons.taskList, icon: "list-todo" }
+  ];
+}
+function isValidUrl(value) {
+  return /^(https?:\/\/|www\.)[^\s]+$/i.test(value);
+}
+function normalizedUrl(value) {
+  return value.startsWith("http") ? value : `https://${value}`;
+}
+function floatingSizeForPanel(panel) {
+  if (panel === "toolbar" || panel === "block-type") return { width: toolbarWidth, height: toolbarHeight };
+  if (panel === "link") return { width: panelWidth, height: linkPanelHeight };
+  return { width: panelWidth, height: palettePanelHeight };
+}
+function boundaryFromRect(rect) {
+  return {
+    left: rect.left,
+    right: rect.right,
+    top: rect.top,
+    bottom: rect.bottom
+  };
+}
+var SelectionToolbarViewPlugin = class {
+  constructor(view, config) {
+    this.view = view;
+    this.config = config;
+    const locale = resolveMardoraLocale(config.locale ?? config.inheritedLocale);
+    this.messages = getSelectionToolbarMessages(locale);
+    this.view.dom.ownerDocument.addEventListener("mousedown", this.handleDocumentMouseDown, true);
+    this.view.dom.ownerDocument.addEventListener("selectionchange", this.handleDocumentSelectionChange);
+    this.updateState();
+  }
+  view;
+  config;
+  menu = null;
+  panel = "toolbar";
+  savedRange = null;
+  selectionAnchor = null;
+  link = { title: "", url: "", canRemove: false };
+  renderVersion = 0;
+  messages;
+  update(update) {
+    if (update.docChanged || update.selectionSet || update.viewportChanged || update.focusChanged) {
+      this.updateState();
+    }
+  }
+  destroy() {
+    this.view.dom.ownerDocument.removeEventListener("mousedown", this.handleDocumentMouseDown, true);
+    this.view.dom.ownerDocument.removeEventListener("selectionchange", this.handleDocumentSelectionChange);
+    this.removeMenu();
+  }
+  closeFromKeyboard() {
+    if (!this.menu) return false;
+    if (this.panel !== "toolbar") {
+      this.panel = "toolbar";
+      this.renderMenu();
+      return true;
+    }
+    this.close();
+    return true;
+  }
+  handleDocumentMouseDown = (event) => {
+    if (!this.menu) return;
+    const target = event.target;
+    if (target instanceof Node && (this.menu.contains(target) || this.view.dom.contains(target))) return;
+    this.close();
+  };
+  handleDocumentSelectionChange = () => {
+    const doc = this.view.dom.ownerDocument;
+    const activeElement = doc.activeElement;
+    if (this.menu && activeElement instanceof Node && this.menu.contains(activeElement)) return;
+    if (!this.view.hasFocus || this.view.dom.classList.contains("cm-mardora-slash-open")) return;
+    const selection = doc.getSelection();
+    if (!selection || !selection.anchorNode || !selection.focusNode) return;
+    if (!canActivateFromNativeSelection({
+      editorSelectionEmpty: this.view.state.selection.main.empty,
+      nativeSelectionCollapsed: selection.isCollapsed,
+      anchorInEditor: this.view.contentDOM.contains(selection.anchorNode),
+      focusInEditor: this.view.contentDOM.contains(selection.focusNode),
+      rangeCount: selection.rangeCount,
+      anchorExcluded: hasSelectionToolbarExcludedAncestor(selection.anchorNode, this.view.contentDOM),
+      focusExcluded: hasSelectionToolbarExcludedAncestor(selection.focusNode, this.view.contentDOM)
+    })) {
+      return;
+    }
+    let anchor;
+    let head;
+    try {
+      anchor = this.view.posAtDOM(selection.anchorNode, selection.anchorOffset);
+      head = this.view.posAtDOM(selection.focusNode, selection.focusOffset);
+    } catch {
+      return;
+    }
+    const from = Math.min(anchor, head);
+    const to = Math.max(anchor, head);
+    if (from === to) return;
+    if (this.selectionTouchesExcludedSyntax(from, to)) return;
+    const rect = selection.getRangeAt(0).getBoundingClientRect();
+    this.savedRange = {
+      from,
+      to,
+      text: this.view.state.sliceDoc(from, to)
+    };
+    this.selectionAnchor = {
+      left: rect.left,
+      right: rect.right,
+      top: rect.top,
+      bottom: rect.bottom
+    };
+    this.renderMenu();
+  };
+  updateState() {
+    const selection = this.view.state.selection.main;
+    if (this.view.dom.classList.contains("cm-mardora-slash-open")) {
+      this.close();
+      return;
+    }
+    if (!this.view.hasFocus) {
+      if (this.isMenuActive() && this.savedRange) return;
+      this.close();
+      return;
+    }
+    if (selection.empty) {
+      this.close();
+      return;
+    }
+    if (this.selectionTouchesExcludedSyntax(selection.from, selection.to)) {
+      this.close();
+      return;
+    }
+    this.savedRange = {
+      from: selection.from,
+      to: selection.to,
+      text: this.view.state.sliceDoc(selection.from, selection.to)
+    };
+    this.selectionAnchor = null;
+    this.renderMenu();
+  }
+  isMenuActive() {
+    const activeElement = this.view.dom.ownerDocument.activeElement;
+    return !!this.menu && activeElement instanceof Node && this.menu.contains(activeElement);
+  }
+  selectionTouchesExcludedSyntax(from, to) {
+    let excluded = false;
+    language.syntaxTree(this.view.state).iterate({
+      from,
+      to,
+      enter: (node) => {
+        if (selectionOverlapsExcludedSyntaxNode({
+          selectionFrom: from,
+          selectionTo: to,
+          nodeFrom: node.from,
+          nodeTo: node.to,
+          nodeName: node.name
+        })) {
+          excluded = true;
+          return false;
+        }
+        return void 0;
+      }
+    });
+    return excluded;
+  }
+  close() {
+    this.panel = "toolbar";
+    this.savedRange = null;
+    this.selectionAnchor = null;
+    this.removeMenu();
+  }
+  removeMenu() {
+    this.renderVersion += 1;
+    this.detachMenu();
+  }
+  detachMenu() {
+    this.menu?.remove();
+    this.menu = null;
+  }
+  menuState() {
+    const range = this.savedRange;
+    const blockType = range ? detectSelectionBlockType({ doc: this.view.state.doc.toString(), from: range.from, to: range.to }) : "text";
+    return {
+      panel: this.panel,
+      buttons: defaultButtons(this.messages, blockType),
+      blockType,
+      blockTypes: blockTypeOptions(this.messages),
+      textColors: textColors(this.messages),
+      highlightColors: highlightColors(this.messages),
+      link: this.link,
+      messages: this.messages
+    };
+  }
+  renderMenu() {
+    const range = this.savedRange;
+    if (!range) return;
+    const renderVersion = ++this.renderVersion;
+    const floating = floatingSizeForPanel(this.panel);
+    this.detachMenu();
+    const anchorFromSelection = this.selectionAnchor;
+    this.view.requestMeasure({
+      read: (view) => {
+        const boundary = boundaryFromRect(view.dom.getBoundingClientRect());
+        if (anchorFromSelection) return { anchor: anchorFromSelection, boundary };
+        const from = view.coordsAtPos(range.from);
+        const to = view.coordsAtPos(range.to);
+        if (!from || !to) return null;
+        const anchor = {
+          left: Math.min(from.left, to.left),
+          right: Math.max(from.right, to.right),
+          top: Math.min(from.top, to.top),
+          bottom: Math.max(from.bottom, to.bottom)
+        };
+        return { anchor, boundary };
+      },
+      write: (measure) => {
+        if (renderVersion !== this.renderVersion || !measure) return;
+        const win = this.view.dom.ownerDocument.defaultView ?? window;
+        const layout = computeSelectionToolbarLayout({
+          anchor: measure.anchor,
+          viewport: { width: win.innerWidth, height: win.innerHeight },
+          boundary: measure.boundary,
+          floating
+        });
+        this.menu = createSelectionToolbarElement(this.menuState(), {
+          onAction: (id) => this.handleAction(id),
+          onBlockType: (type) => this.applyBlockType(type),
+          onColor: (value) => this.applyColor(value),
+          onHighlight: (value) => this.applyHighlight(value),
+          onLinkInput: (field, value) => {
+            const next = { ...this.link, [field]: value };
+            delete next.error;
+            this.link = next;
+          },
+          onLinkSubmit: () => this.submitLink(),
+          onLinkCopy: () => void this.copyLink(),
+          onLinkOpen: () => this.openLink(),
+          onLinkRemove: () => this.removeLink(),
+          onCancelPanel: () => {
+            this.panel = "toolbar";
+            this.renderMenu();
+          }
+        });
+        this.menu.style.left = `${layout.left}px`;
+        this.menu.style.top = `${layout.top}px`;
+        this.menu.style.maxHeight = `${layout.maxHeight}px`;
+        this.menu.dataset.mardoraSelectionPlacement = layout.placement;
+        if (this.panel === "block-type") {
+          const opensDown = layout.placement === "bottom";
+          const available = opensDown ? measure.boundary.bottom - (layout.top + toolbarHeight) - popoverGap : layout.top - measure.boundary.top - popoverGap;
+          this.menu.style.setProperty(
+            "--mardora-selection-toolbar-popover-max-height",
+            `${Math.max(96, Math.min(blockTypePanelHeight, Math.floor(available)))}px`
+          );
+        }
+        this.view.dom.appendChild(this.menu);
+      }
+    });
+  }
+  dispatchResult(result) {
+    if (!this.isSavedRangeCurrent()) {
+      this.close();
+      return;
+    }
+    this.view.dispatch({
+      changes: result.changes,
+      selection: result.selection,
+      scrollIntoView: true
+    });
+    this.view.focus();
+    this.close();
+  }
+  isSavedRangeCurrent() {
+    if (!this.savedRange) return false;
+    return this.view.state.sliceDoc(this.savedRange.from, this.savedRange.to) === this.savedRange.text;
+  }
+  handleAction(id) {
+    const range = this.savedRange;
+    if (!range) return;
+    const doc = this.view.state.doc.toString();
+    if (id === "link") {
+      const parsed = parseSelectedLink(range.text);
+      this.link = { title: parsed.title || range.text, url: parsed.url, canRemove: parsed.kind === "markdown-link" };
+      this.panel = "link";
+      this.renderMenu();
+      return;
+    }
+    if (id === "block-type") {
+      this.panel = "block-type";
+      this.renderMenu();
+      return;
+    }
+    if (id === "color") {
+      this.panel = "color";
+      this.renderMenu();
+      return;
+    }
+    if (id === "highlight") {
+      this.panel = "highlight";
+      this.renderMenu();
+      return;
+    }
+    if (id === "ordered-list" || id === "unordered-list" || id === "task-list") {
+      const kind = id === "ordered-list" ? "ordered" : id === "task-list" ? "task" : "unordered";
+      this.dispatchResult(buildListChange({ doc, from: range.from, to: range.to, kind }));
+      return;
+    }
+    if (id === "underline") {
+      this.dispatchResult(buildInlineFormatChange({ doc, from: range.from, to: range.to, htmlTag: "u" }));
+      return;
+    }
+    const marker = id === "bold" ? "**" : id === "italic" ? "*" : id === "strike" ? "~~" : id === "code" ? "`" : null;
+    if (!marker) return;
+    const result = buildInlineFormatChange({ doc, from: range.from, to: range.to, marker });
+    this.dispatchResult(result);
+  }
+  applyBlockType(type) {
+    const range = this.savedRange;
+    if (!range) return;
+    const level = type === "text" ? 0 : Number(type.slice("heading-".length));
+    if (level < 0 || level > 6) return;
+    this.dispatchResult(
+      buildBlockTypeChange({
+        doc: this.view.state.doc.toString(),
+        from: range.from,
+        to: range.to,
+        level
+      })
+    );
+  }
+  applyColor(value) {
+    const range = this.savedRange;
+    if (!range) return;
+    this.dispatchResult(
+      buildInlineFormatChange({
+        doc: this.view.state.doc.toString(),
+        from: range.from,
+        to: range.to,
+        spanStyle: { property: "color", value: value ?? "" },
+        clear: value === null
+      })
+    );
+  }
+  applyHighlight(value) {
+    const range = this.savedRange;
+    if (!range) return;
+    const result = value ? buildInlineFormatChange({
+      doc: this.view.state.doc.toString(),
+      from: range.from,
+      to: range.to,
+      spanStyle: { property: "background-color", value }
+    }) : buildInlineFormatChange({ doc: this.view.state.doc.toString(), from: range.from, to: range.to, marker: "==" });
+    this.dispatchResult(result);
+  }
+  submitLink() {
+    const range = this.savedRange;
+    if (!range) return;
+    if (!this.link.url || !isValidUrl(this.link.url)) {
+      this.link = { ...this.link, error: this.messages.link.invalid };
+      this.renderMenu();
+      return;
+    }
+    const title = this.link.title || range.text || this.link.url;
+    this.dispatchResult(buildLinkChange({ from: range.from, to: range.to, title, url: this.link.url }));
+  }
+  removeLink() {
+    const range = this.savedRange;
+    if (!range) return;
+    this.dispatchResult(
+      buildLinkChange({ from: range.from, to: range.to, title: this.link.title || range.text, url: "", remove: true })
+    );
+  }
+  async copyLink() {
+    if (!this.link.url) return;
+    await this.view.dom.ownerDocument.defaultView?.navigator.clipboard?.writeText(this.link.url);
+    this.link = { ...this.link, copied: true };
+    this.renderMenu();
+  }
+  openLink() {
+    if (!this.link.url || !isValidUrl(this.link.url)) return;
+    this.view.dom.ownerDocument.defaultView?.open(normalizedUrl(this.link.url), "_blank", "noopener,noreferrer");
+  }
+};
+function selectionToolbar(config = {}) {
+  if (config.enabled === false) return [];
+  const plugin = view.ViewPlugin.define((view) => new SelectionToolbarViewPlugin(view, config));
+  return [
+    selectionToolbarTheme,
+    plugin,
+    state.Prec.highest(
+      view.EditorView.domEventHandlers({
+        keydown(event, view) {
+          const value = view.plugin(plugin);
+          if (!value || event.key !== "Escape") return false;
+          const handled = value.closeFromKeyboard();
+          if (handled) event.preventDefault();
+          return handled;
+        }
+      })
+    )
+  ];
+}
+
+// src/editor/heading-fold/config.ts
+var minSupportedLevel = 2;
+var maxSupportedLevel = 5;
+function clampLevel(level) {
+  return Math.min(Math.max(level, minSupportedLevel), maxSupportedLevel);
+}
+function resolveHeadingFoldConfig(config = {}) {
+  const requestedMinLevel = clampLevel(config.minLevel ?? minSupportedLevel);
+  const requestedMaxLevel = clampLevel(config.maxLevel ?? maxSupportedLevel);
+  const minLevel = Math.min(requestedMinLevel, requestedMaxLevel);
+  const maxLevel = Math.max(requestedMinLevel, requestedMaxLevel);
+  return {
+    enabled: config.enabled !== false,
+    minLevel,
+    maxLevel
+  };
+}
+var headingPattern = /^ATXHeading([1-6])$/;
+var headingFoldParseTimeout = 100;
+function headingLevel(node) {
+  const match = headingPattern.exec(node.name);
+  return match ? Number(match[1]) : null;
+}
+function canFoldLevel(level, minLevel, maxLevel) {
+  return level >= minLevel && level <= maxLevel;
+}
+function collectHeadings(state) {
+  const headings = [];
+  const tree = language.ensureSyntaxTree(state, state.doc.length, headingFoldParseTimeout) ?? language.syntaxTree(state);
+  tree.iterate({
+    enter: (node) => {
+      const level = headingLevel(node);
+      if (!level) return;
+      const text = chunkWFVCG4LD_cjs.stripMarkdownHeadingText(state.sliceDoc(node.from, node.to));
+      if (!text) return;
+      headings.push({ level, text, from: node.from, to: node.to });
+    }
+  });
+  return headings;
+}
+function findFoldEnd(state, headings, index) {
+  const heading = headings[index];
+  const nextBoundary = headings.slice(index + 1).find((candidate) => candidate.level <= heading.level);
+  if (!nextBoundary) return state.doc.length;
+  return state.doc.lineAt(nextBoundary.from).from;
+}
+function findFoldStart(state, heading) {
+  const headingLine = state.doc.lineAt(heading.from);
+  if (headingLine.number >= state.doc.lines) return headingLine.to;
+  return state.doc.line(headingLine.number + 1).from;
+}
+function extractHeadingFoldRangesFromState(state, config = {}) {
+  const resolved = resolveHeadingFoldConfig(config);
+  if (!resolved.enabled) return [];
+  const headings = collectHeadings(state);
+  const ranges = [];
+  headings.forEach((heading, index) => {
+    if (!canFoldLevel(heading.level, resolved.minLevel, resolved.maxLevel)) return;
+    const line = state.doc.lineAt(heading.from);
+    const foldFrom = findFoldStart(state, heading);
+    const foldTo = findFoldEnd(state, headings, index);
+    if (foldTo <= foldFrom) return;
+    ranges.push({
+      level: heading.level,
+      text: heading.text,
+      headingFrom: heading.from,
+      headingTo: heading.to,
+      headingLineFrom: line.from,
+      headingLineTo: line.to,
+      foldFrom,
+      foldTo
+    });
+  });
+  return ranges;
+}
+var headingFoldTheme = view.EditorView.baseTheme({
+  ".cm-mardora-heading-fold-line": {
+    position: "relative"
+  },
+  ".cm-mardora-heading-fold-toggle": {
+    alignItems: "center",
+    background: "transparent",
+    border: "0",
+    borderRadius: "4px",
+    color: "var(--mardora-heading-fold-muted, #a1a1aa)",
+    cursor: "pointer",
+    display: "inline-flex",
+    font: "600 0.7rem/1 var(--font-sans, sans-serif)",
+    height: "1rem",
+    justifyContent: "center",
+    marginLeft: "-2.55rem",
+    marginRight: "0.45rem",
+    padding: "0",
+    transform: "translateY(-0.52em)",
+    verticalAlign: "middle",
+    width: "2rem"
+  },
+  ".cm-mardora-heading-fold-toggle:hover, .cm-mardora-heading-fold-toggle:focus-visible": {
+    color: "var(--mardora-heading-fold-active, #52525b)"
+  },
+  ".cm-mardora-heading-fold-toggle:focus-visible": {
+    outline: "2px solid var(--mardora-heading-fold-focus, #a1a1aa)",
+    outlineOffset: "2px"
+  },
+  ".cm-mardora-heading-fold-level": {
+    display: "inline-flex"
+  },
+  ".cm-mardora-heading-fold-arrow": {
+    display: "none",
+    height: "0.55rem",
+    position: "relative",
+    width: "0.55rem"
+  },
+  ".cm-mardora-heading-fold-arrow::before": {
+    borderBottom: "1.5px solid currentColor",
+    borderRight: "1.5px solid currentColor",
+    content: '""',
+    display: "block",
+    height: "0.28rem",
+    left: "0.08rem",
+    position: "absolute",
+    top: "0.03rem",
+    transform: "rotate(45deg)",
+    width: "0.28rem"
+  },
+  ".cm-mardora-heading-fold-toggle[data-mardora-heading-fold-folded='true'] .cm-mardora-heading-fold-arrow::before": {
+    left: "0.03rem",
+    top: "0.11rem",
+    transform: "rotate(-45deg)"
+  },
+  ".cm-mardora-heading-fold-line:hover .cm-mardora-heading-fold-level, .cm-mardora-heading-fold-line-active .cm-mardora-heading-fold-level, .cm-mardora-heading-fold-toggle:hover .cm-mardora-heading-fold-level, .cm-mardora-heading-fold-toggle:focus-visible .cm-mardora-heading-fold-level, .cm-mardora-heading-fold-toggle[data-mardora-heading-fold-folded='true'] .cm-mardora-heading-fold-level": {
+    display: "none"
+  },
+  ".cm-mardora-heading-fold-line:hover .cm-mardora-heading-fold-arrow, .cm-mardora-heading-fold-line-active .cm-mardora-heading-fold-arrow, .cm-mardora-heading-fold-toggle:hover .cm-mardora-heading-fold-arrow, .cm-mardora-heading-fold-toggle:focus-visible .cm-mardora-heading-fold-arrow, .cm-mardora-heading-fold-toggle[data-mardora-heading-fold-folded='true'] .cm-mardora-heading-fold-arrow": {
+    display: "inline-block"
+  },
+  ".cm-mardora-heading-fold-placeholder": {
+    color: "var(--mardora-heading-fold-muted, #a1a1aa)",
+    font: "600 0.9rem/1.4 var(--font-sans, sans-serif)",
+    padding: "0.1rem 0 0.35rem 0.25rem"
+  },
+  "&dark .cm-mardora-heading-fold-toggle, &dark .cm-mardora-heading-fold-placeholder": {
+    "--mardora-heading-fold-muted": "#71717a",
+    "--mardora-heading-fold-active": "#d4d4d8",
+    "--mardora-heading-fold-focus": "#71717a"
+  }
+});
+var toggleHeadingFoldEffect = state.StateEffect.define();
+var headingFoldConfigFacet = state.Facet.define({
+  combine: (values) => values[values.length - 1] ?? {}
+});
+function nextFoldedHeadings(value, transaction) {
+  const next = /* @__PURE__ */ new Set();
+  if (transaction.docChanged) {
+    for (const position of value) {
+      next.add(transaction.changes.mapPos(position, 1));
+    }
+  } else {
+    for (const position of value) next.add(position);
+  }
+  for (const effect of transaction.effects) {
+    if (!effect.is(toggleHeadingFoldEffect)) continue;
+    if (next.has(effect.value)) {
+      next.delete(effect.value);
+    } else {
+      next.add(effect.value);
+    }
+  }
+  return Array.from(next).sort((a, b) => a - b);
+}
+var HeadingFoldWidget = class extends view.WidgetType {
+  constructor(range, folded) {
+    super();
+    this.range = range;
+    this.folded = folded;
+  }
+  range;
+  folded;
+  eq(other) {
+    return other.range.headingFrom === this.range.headingFrom && other.folded === this.folded;
+  }
+  toDOM() {
+    const button = document.createElement("button");
+    button.type = "button";
+    button.className = "cm-mardora-heading-fold-toggle";
+    button.setAttribute("aria-label", `${this.folded ? "Expand" : "Collapse"} H${this.range.level} section`);
+    button.dataset.mardoraHeadingFoldFolded = String(this.folded);
+    button.dataset.mardoraHeadingFoldFrom = String(this.range.headingFrom);
+    const level = document.createElement("span");
+    level.className = "cm-mardora-heading-fold-level";
+    level.textContent = `H${this.range.level}`;
+    const arrow = document.createElement("span");
+    arrow.className = "cm-mardora-heading-fold-arrow";
+    arrow.setAttribute("aria-hidden", "true");
+    button.append(level, arrow);
+    return button;
+  }
+  ignoreEvent(event) {
+    return event.type === "mousedown" || event.type === "click";
+  }
+};
+var FoldPlaceholderWidget = class _FoldPlaceholderWidget extends view.WidgetType {
+  eq(other) {
+    return other instanceof _FoldPlaceholderWidget;
+  }
+  toDOM() {
+    const placeholder = document.createElement("span");
+    placeholder.className = "cm-mardora-heading-fold-placeholder";
+    placeholder.setAttribute("aria-hidden", "true");
+    placeholder.textContent = "...";
+    return placeholder;
+  }
+};
+function selectionTouchesHeading(state, range) {
+  return state.selection.ranges.some((selection) => {
+    const line = state.doc.lineAt(selection.head);
+    return line.from === range.headingLineFrom;
+  });
+}
+function readHeadingFoldButtonPosition(target, view) {
+  if (!(target instanceof Element)) return null;
+  const button = target.closest(".cm-mardora-heading-fold-toggle");
+  if (!(button instanceof HTMLElement) || !view.dom.contains(button)) return null;
+  const position = Number(button.dataset.mardoraHeadingFoldFrom);
+  return Number.isFinite(position) ? position : null;
+}
+function toggleHeadingFoldAt(view, position) {
+  view.dispatch({ effects: toggleHeadingFoldEffect.of(position) });
+  view.focus();
+}
+var headingFoldDomHandlers = view.EditorView.domEventHandlers({
+  mousedown: (event, view) => {
+    if (event.button !== 0) return false;
+    const position = readHeadingFoldButtonPosition(event.target, view);
+    if (position === null) return false;
+    event.preventDefault();
+    event.stopPropagation();
+    toggleHeadingFoldAt(view, position);
+    return true;
+  },
+  click: (event, view) => {
+    if (event.detail !== 0) return false;
+    const position = readHeadingFoldButtonPosition(event.target, view);
+    if (position === null) return false;
+    event.preventDefault();
+    event.stopPropagation();
+    toggleHeadingFoldAt(view, position);
+    return true;
+  }
+});
+function __buildHeadingFoldDecorations(state, config, foldedHeadings) {
+  const folded = new Set(foldedHeadings);
+  const decorations = [];
+  for (const range of extractHeadingFoldRangesFromState(state, config)) {
+    const isFolded = folded.has(range.headingFrom);
+    const active = selectionTouchesHeading(state, range);
+    const lineClass = [
+      "cm-mardora-heading-fold-line",
+      active ? "cm-mardora-heading-fold-line-active" : "",
+      isFolded ? "cm-mardora-heading-fold-line-folded" : ""
+    ].filter(Boolean).join(" ");
+    decorations.push(view.Decoration.line({ class: lineClass }).range(range.headingLineFrom));
+    decorations.push(
+      view.Decoration.widget({
+        widget: new HeadingFoldWidget(range, isFolded),
+        side: -1
+      }).range(range.headingFrom)
+    );
+    if (isFolded) {
+      decorations.push(
+        view.Decoration.widget({
+          widget: new FoldPlaceholderWidget(),
+          side: 1,
+          mardoraHeadingFoldRole: "placeholder"
+        }).range(range.headingTo)
+      );
+      decorations.push(
+        view.Decoration.replace({
+          mardoraHeadingFoldRole: "hidden-content"
+        }).range(range.foldFrom, range.foldTo)
+      );
+    }
+  }
+  return view.Decoration.set(decorations, true);
+}
+var headingFoldStateField = state.StateField.define({
+  create: (state) => {
+    const foldedHeadings = [];
+    return {
+      foldedHeadings,
+      decorations: __buildHeadingFoldDecorations(state, state.facet(headingFoldConfigFacet), foldedHeadings)
+    };
+  },
+  update: (value, transaction) => {
+    const foldedHeadings = nextFoldedHeadings(value.foldedHeadings, transaction);
+    return {
+      foldedHeadings,
+      decorations: __buildHeadingFoldDecorations(transaction.state, transaction.state.facet(headingFoldConfigFacet), foldedHeadings)
+    };
+  },
+  provide: (field) => view.EditorView.decorations.from(field, (value) => value.decorations)
+});
+var HeadingFoldViewPlugin = class {
+  constructor(view, _config) {
+    this.view = view;
+    this.view.dom.addEventListener("pointerdown", this.handlePointerDown, true);
+    this.view.dom.addEventListener("mousedown", this.handleMouseDown, true);
+    this.view.dom.addEventListener("click", this.handleClick, true);
+  }
+  view;
+  suppressNextMouseDown = false;
+  update(_update) {
+  }
+  destroy() {
+    this.view.dom.removeEventListener("pointerdown", this.handlePointerDown, true);
+    this.view.dom.removeEventListener("mousedown", this.handleMouseDown, true);
+    this.view.dom.removeEventListener("click", this.handleClick, true);
+  }
+  handlePointerDown = (event) => {
+    if (event.button !== 0) return;
+    if (readHeadingFoldButtonPosition(event.target, this.view) !== null) this.suppressNextMouseDown = true;
+    this.handleToggleEvent(event);
+  };
+  handleMouseDown = (event) => {
+    if (event.button !== 0) return;
+    if (this.suppressNextMouseDown) {
+      this.suppressNextMouseDown = false;
+      return;
+    }
+    this.handleToggleEvent(event);
+  };
+  handleClick = (event) => {
+    if (event.detail !== 0) return;
+    this.handleToggleEvent(event);
+  };
+  handleToggleEvent(event) {
+    const position = readHeadingFoldButtonPosition(event.target, this.view);
+    if (position === null) return;
+    event.preventDefault();
+    event.stopPropagation();
+    toggleHeadingFoldAt(this.view, position);
+  }
+};
+function headingFold(config = {}) {
+  if (config.enabled === false) return [];
+  return [
+    headingFoldConfigFacet.of(config),
+    headingFoldStateField,
+    headingFoldTheme,
+    headingFoldDomHandlers,
+    view.ViewPlugin.define((view) => new HeadingFoldViewPlugin(view, config))
+  ];
+}
+
+// src/editor/mardora.ts
+function mardora(config = {}) {
+  const {
+    locale: configLocale,
+    i18n: configI18n = {},
+    theme: configTheme = "auto" /* AUTO */,
+    baseStyles = true,
+    plugins = [],
+    extensions = [],
+    keymap: configKeymap = [],
+    disableViewPlugin = false,
+    defaultKeybindings = true,
+    history: configHistory = true,
+    indentWithTab: configIndentWithTab = true,
+    highlightActiveLine: configHighlightActiveLine = true,
+    lineWrapping: configLineWrapping = true,
+    onNodesChange: configOnNodesChange = void 0,
+    slashCommands: configSlashCommands = { enabled: true },
+    attachments: configAttachments = { enabled: false },
+    selectionToolbar: configSelectionToolbar = { enabled: true },
+    toc: configToc = { enabled: true },
+    headingFold: configHeadingFold = { enabled: true }
+  } = config;
+  const resolvedLocale = resolveMardoraLocale(configSlashCommands.locale ?? configI18n.locale ?? configLocale);
+  const allPlugins = [...plugins];
+  const pluginExtensions = [];
+  const pluginKeymaps = [];
+  const markdownExtensions = [];
+  const pluginContext = { config };
+  if (!disableViewPlugin) {
+    for (const plugin of allPlugins) {
+      plugin.onRegister(pluginContext);
+      const exts = plugin.getExtensions();
+      if (exts.length > 0) {
+        pluginExtensions.push(...exts);
+      }
+      const keys = plugin.getKeymap();
+      if (keys.length > 0) {
+        pluginKeymaps.push(...keys);
+      }
+      const theme = plugin.theme;
+      if (baseStyles && theme && typeof theme === "function") {
+        pluginExtensions.push(view.EditorView.theme(theme(configTheme)));
+      }
+      const md = plugin.getMarkdownConfig();
+      if (md) {
+        markdownExtensions.push(md);
+      }
+    }
+  }
+  if (config.markdown) {
+    markdownExtensions.push(...config.markdown);
+  }
+  const markdownSupport = langMarkdown.markdown({
+    base: langMarkdown.markdownLanguage,
+    codeLanguages: languageData.languages,
+    extensions: markdownExtensions,
+    addKeymap: true,
+    completeHTMLTags: true,
+    pasteURLAsLink: true
+  });
+  const baseExtensions = [
+    ...defaultKeybindings ? [view.keymap.of(commands.defaultKeymap)] : [],
+    ...configHistory ? [commands.history(), view.keymap.of(commands.historyKeymap)] : [],
+    ...configIndentWithTab ? [language.indentOnInput(), view.keymap.of([commands.indentWithTab])] : [],
+    ...configHighlightActiveLine && disableViewPlugin ? [view.highlightActiveLine()] : []
+  ];
+  const mardoraExtensions = [];
+  if (!disableViewPlugin) {
+    mardoraExtensions.push(createMardoraViewExtension(configTheme, baseStyles, allPlugins, configOnNodesChange));
+    mardoraExtensions.push(state.Prec.highest(markdownResetExtension));
+  }
+  if (!disableViewPlugin || configLineWrapping) mardoraExtensions.push(view.EditorView.lineWrapping);
+  const composedExtensions = [
+    // Core markdown support (highest priority)
+    state.Prec.high(markdownSupport),
+    state.Prec.high(view.keymap.of(langMarkdown.markdownKeymap)),
+    // mardora view plugin for rich rendering
+    mardoraExtensions,
+    // Core CodeMirror extensions
+    baseExtensions,
+    // Mardora editor commands and browser attachments
+    slashCommands({
+      ...configSlashCommands,
+      inheritedLocale: resolvedLocale,
+      attachmentUploader: configAttachments.uploader
+    }),
+    attachments(configAttachments),
+    selectionToolbar({
+      ...configSelectionToolbar,
+      inheritedLocale: resolvedLocale
+    }),
+    chunkWFVCG4LD_cjs.tableOfContents(configToc),
+    ...!disableViewPlugin ? headingFold(configHeadingFold) : [],
+    // Plugin extensions & keymaps
+    pluginExtensions,
+    pluginKeymaps.length > 0 ? view.keymap.of(pluginKeymaps) : [],
+    // Config keymaps & extensions
+    configKeymap.length > 0 ? view.keymap.of(configKeymap) : [],
+    extensions
+  ];
+  return composedExtensions;
+}
+var MardoraPlugin = class {
+  /** Decoration priority (higher = applied later) */
+  decorationPriority = 100;
+  /** Plugin dependencies - names of required plugins */
+  dependencies = [];
+  /** Node types this plugin handles for decorations and preview rendering */
+  requiredNodes = [];
+  /** Private configuration storage */
+  _config = {};
+  /** Protected context - accessible to subclasses */
+  _context = null;
+  /** Get plugin configuration */
+  get config() {
+    return this._config;
+  }
+  /** Set plugin configuration */
+  set config(value) {
+    this._config = value;
+  }
+  /** Get plugin context */
+  get context() {
+    return this._context;
+  }
+  /** Plugin theme */
+  get theme() {
+    return chunkWFVCG4LD_cjs.createTheme({
+      default: {},
+      dark: {},
+      light: {}
+    });
+  }
+  // ============================================
+  // EXTENSION METHODS (overridable by subclasses)
+  // ============================================
+  /**
+   * Return CodeMirror extensions for this plugin
+   * Override to provide custom extensions
+   */
+  getExtensions() {
+    return [];
+  }
+  /**
+   * Return markdown parser extensions
+   * Override to extend markdown parsing
+   */
+  getMarkdownConfig() {
+    return null;
+  }
+  /**
+   * Return keybindings for this plugin
+   * Override to add custom keyboard shortcuts
+   */
+  getKeymap() {
+    return [];
+  }
+  // ============================================
+  // DECORATION METHODS (overridable by subclasses)
+  // ============================================
+  /**
+   * Build decorations for the current view state
+   * Override to contribute decorations to the editor
+   *
+   * @param ctx - Decoration context with view and decoration array
+   */
+  buildDecorations(_ctx) {
+  }
+  // ============================================
+  // LIFECYCLE HOOKS (overridable by subclasses)
+  // ============================================
+  /**
+   * Called when plugin is registered with mardora
+   * Override to perform initialization
+   *
+   * @param context - Plugin context with configuration
+   */
+  onRegister(context) {
+    this._context = context;
+  }
+  /**
+   * Called when plugin is unregistered
+   * Override to perform cleanup
+   */
+  onUnregister() {
+    this._context = null;
+  }
+  /**
+   * Called when EditorView is created and ready
+   * Override to perform view-specific initialization
+   *
+   * @param view - The EditorView instance
+   */
+  onViewReady(_view) {
+  }
+  /**
+   * Called on view updates (document changes, selection changes, etc.)
+   * Override to react to editor changes
+   *
+   * @param update - The ViewUpdate with change information
+   */
+  onViewUpdate(_update) {
+  }
+  // ============================================
+  // PROTECTED UTILITIES (for subclasses)
+  // ============================================
+  /**
+   * Helper to get current editor state
+   * @param view - The EditorView instance
+   */
+  getState(view) {
+    return view.state;
+  }
+  /**
+   * Helper to get current document
+   * @param view - The EditorView instance
+   */
+  getDocument(view) {
+    return view.state.doc;
+  }
+  /**
+   * Get CSS styles for preview mode
+   * Override to provide custom CSS for preview rendering
+   *
+   * @param theme - Current theme enum
+   * @returns CSS string for preview styles
+   */
+  getPreviewStyles(theme, wrapperClass) {
+    const themeStyles = this.theme(theme);
+    return this.transformToCss(themeStyles, wrapperClass);
+  }
+  /**
+   * Transform ThemeStyle object to CSS string for preview
+   * Uses cssClassMap to convert CM selectors to semantic selectors
+   */
+  transformToCss(themeStyles, wrapperClass) {
+    const styleMod$1 = new styleMod.StyleModule(themeStyles, {
+      finish: (sel) => {
+        return `.${wrapperClass} ${sel}`;
+      }
+    });
+    return styleMod$1.getRules();
+  }
+};
+var DecorationPlugin = class extends MardoraPlugin {
+  /**
+   * Decoration priority - lower than default for decoration plugins
+   * Override to customize
+   */
+  decorationPriority = 50;
+};
+var SyntaxPlugin = class extends MardoraPlugin {
+};
+
+Object.defineProperty(exports, "Compartment", {
+  enumerable: true,
+  get: function () { return state.Compartment; }
+});
+Object.defineProperty(exports, "EditorSelection", {
+  enumerable: true,
+  get: function () { return state.EditorSelection; }
+});
+Object.defineProperty(exports, "EditorState", {
+  enumerable: true,
+  get: function () { return state.EditorState; }
+});
+Object.defineProperty(exports, "StateEffect", {
+  enumerable: true,
+  get: function () { return state.StateEffect; }
+});
+Object.defineProperty(exports, "StateField", {
+  enumerable: true,
+  get: function () { return state.StateField; }
+});
+Object.defineProperty(exports, "EditorView", {
+  enumerable: true,
+  get: function () { return view.EditorView; }
+});
+Object.defineProperty(exports, "highlightActiveLine", {
+  enumerable: true,
+  get: function () { return view.highlightActiveLine; }
+});
+Object.defineProperty(exports, "keymap", {
+  enumerable: true,
+  get: function () { return view.keymap; }
+});
+exports.DecorationPlugin = DecorationPlugin;
+exports.MardoraPlugin = MardoraPlugin;
+exports.SyntaxPlugin = SyntaxPlugin;
+exports.attachments = attachments;
+exports.buildBlockTypeChange = buildBlockTypeChange;
+exports.buildInlineFormatChange = buildInlineFormatChange;
+exports.buildLinkChange = buildLinkChange;
+exports.buildListChange = buildListChange;
+exports.buildSlashReplacement = buildSlashReplacement;
+exports.computeSelectionToolbarLayout = computeSelectionToolbarLayout;
+exports.createSelectionToolbarElement = createSelectionToolbarElement;
+exports.createSlashMenuElement = createSlashMenuElement;
+exports.createSlashRuntimeConfig = createSlashRuntimeConfig;
+exports.createUploadMarker = createUploadMarker;
+exports.defaultMardoraLocale = defaultMardoraLocale;
+exports.defaultSlashCommands = defaultSlashCommands;
+exports.detectAttachmentKind = detectAttachmentKind;
+exports.detectSelectionBlockType = detectSelectionBlockType;
+exports.detectSlashQuery = detectSlashQuery;
+exports.extractHeadingFoldRangesFromState = extractHeadingFoldRangesFromState;
+exports.filterSlashCommands = filterSlashCommands;
+exports.formatAttachmentMarkdown = formatAttachmentMarkdown;
+exports.getDefaultSlashCommands = getDefaultSlashCommands;
+exports.getSelectionToolbarMessages = getSelectionToolbarMessages;
+exports.getSlashMessages = getSlashMessages;
+exports.headingFold = headingFold;
+exports.headingFoldTheme = headingFoldTheme;
+exports.isAcceptedAttachment = isAcceptedAttachment;
+exports.mardora = mardora;
+exports.mardoraBaseTheme = mardoraBaseTheme;
+exports.markdownResetExtension = markdownResetExtension;
+exports.parseSelectedLink = parseSelectedLink;
+exports.resolveHeadingFoldConfig = resolveHeadingFoldConfig;
+exports.resolveMardoraLocale = resolveMardoraLocale;
+exports.selectionToolbar = selectionToolbar;
+exports.selectionToolbarTheme = selectionToolbarTheme;
+exports.slashCommands = slashCommands;
+exports.slashMenuTheme = slashMenuTheme;
+exports.uploadAttachmentFile = uploadAttachmentFile;
+//# sourceMappingURL=chunk-MLBEBFHB.cjs.map
+//# sourceMappingURL=chunk-MLBEBFHB.cjs.map