@xlxz/markdown-editor 2.0.0

package/dist/index.cjs

@@ -0,0 +1,1806 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  themePlugin: () => themePlugin,
+  tablePlugin: () => tablePlugin,
+  tableContinuationPlugin: () => tableContinuationPlugin,
+  suggestPlugin: () => suggestPlugin,
+  onChangePlugin: () => onChangePlugin,
+  markdownLanguagePlugin: () => markdownLanguagePlugin,
+  livePreviewPlugin: () => livePreviewPlugin,
+  listContinuationPlugin: () => listContinuationPlugin,
+  linkHandlerPlugin: () => linkHandlerPlugin,
+  lineNumbersPlugin: () => lineNumbersPlugin,
+  keymapPlugin: () => keymapPlugin,
+  indentGuidePlugin: () => indentGuidePlugin,
+  hangingIndentPlugin: () => hangingIndentPlugin,
+  foldPlugin: () => foldPlugin,
+  expandTextPlugin: () => expandTextPlugin,
+  createEditor: () => createEditor,
+  closeBracketsPlugin: () => closeBracketsPlugin,
+  baseExtensionsPlugin: () => baseExtensionsPlugin,
+  autoLoad: () => autoLoad,
+  attachmentPlugin: () => attachmentPlugin
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/defaults.ts
+var defaultBackend = {
+  resolveLinkPath() {
+    return null;
+  },
+  getResourceUrl(path) {
+    return path;
+  },
+  async listLinkTargets() {
+    return [];
+  },
+  async readFile() {
+    return "";
+  },
+  openFile() {},
+  async saveAttachment() {
+    return "";
+  }
+};
+var defaultOptions = {
+  tabSize: 4,
+  useTab: true,
+  readableLineWidth: true,
+  showLineNumber: true,
+  showIndentGuide: true,
+  foldHeading: true,
+  foldIndent: true,
+  autoPairBrackets: true,
+  autoPairMarkdown: true,
+  spellcheck: false,
+  theme: "dark",
+  cssVariables: {}
+};
+
+// src/mocks.ts
+function createMockOwner(filePath) {
+  return {
+    file: {
+      path: filePath || "untitled.md",
+      name: (filePath || "untitled.md").split("/").pop(),
+      basename: (filePath || "untitled.md").split("/").pop().replace(/\.md$/, ""),
+      extension: "md"
+    },
+    saveImmediately(fn) {
+      if (fn)
+        fn();
+    }
+  };
+}
+function createMockApp(backend, opts) {
+  return {
+    vault: {
+      getConfig(key) {
+        const configs = {
+          tabSize: opts.tabSize,
+          useTab: opts.useTab,
+          readableLineLength: opts.readableLineWidth,
+          showFrontmatter: false,
+          livePreview: true,
+          autoPairBrackets: opts.autoPairBrackets,
+          autoPairMarkdown: opts.autoPairMarkdown,
+          rightToLeft: false,
+          spellcheck: opts.spellcheck,
+          showLineNumber: opts.showLineNumber,
+          showIndentGuide: opts.showIndentGuide,
+          foldHeading: opts.foldHeading,
+          foldIndent: opts.foldIndent
+        };
+        return configs[key];
+      },
+      adapter: {
+        getResourcePath(p) {
+          return backend.getResourceUrl(p);
+        }
+      },
+      on() {
+        return { id: 0 };
+      },
+      off() {},
+      offref() {}
+    },
+    workspace: {
+      openLinkText(link) {
+        backend.openFile(link);
+      },
+      getLeaf() {
+        return { openLinkText(link) {
+          backend.openFile(link);
+        } };
+      },
+      on() {
+        return { id: 0 };
+      },
+      off() {},
+      offref() {}
+    },
+    metadataCache: {
+      getFirstLinkpathDest(link, sourcePath) {
+        const resolved = backend.resolveLinkPath(link, sourcePath);
+        return resolved ? { path: resolved } : null;
+      },
+      on() {
+        return { id: 0 };
+      },
+      off() {},
+      offref() {}
+    }
+  };
+}
+function createMockEditor(mockApp, mockOwner, view, editorEl) {
+  return {
+    app: mockApp,
+    get path() {
+      return mockOwner.file?.path || "";
+    },
+    get file() {
+      return mockOwner.file;
+    },
+    cm: view,
+    editorEl,
+    owner: mockOwner,
+    addChild(c) {
+      return c;
+    },
+    removeChild(_c) {},
+    editTableCell(table, cell) {
+      return this.tableCell ||= {
+        table,
+        cell,
+        editor: { cm: view },
+        cm: view,
+        setReadonly() {},
+        onContextMenu() {}
+      };
+    },
+    destroyTableCell() {
+      this.tableCell = null;
+    },
+    tableCell: null
+  };
+}
+
+// src/plugins/live-preview.ts
+var livePreviewPlugin = {
+  id: "live-preview",
+  deps: ["base-extensions"],
+  install(ctx) {
+    const { livePreview: KB } = window.__stateFields;
+    const __kH = window.__kH;
+    if (!KB || !__kH) {
+      console.warn("[live-preview] Obsidian runtime not available");
+      return [];
+    }
+    const mockEditor = ctx.getState("__mockEditor");
+    const extensions = [];
+    extensions.push(KB.init(() => true));
+    const livePreviewExts = __kH(mockEditor, ctx.view);
+    if (livePreviewExts) {
+      extensions.push(livePreviewExts);
+    }
+    return extensions;
+  }
+};
+// src/plugins/markdown-language.ts
+var markdownLanguagePlugin = {
+  id: "markdown-language",
+  install(_ctx) {
+    const lang = window.__language;
+    if (!lang) {
+      console.warn("[markdown-language] Obsidian language extension not available");
+      return [];
+    }
+    return lang;
+  }
+};
+// src/plugins/hanging-indent.ts
+var hangingIndentPlugin = {
+  id: "hanging-indent",
+  install(_ctx) {
+    const ext = window.__hangingIndent;
+    if (!ext) {
+      console.warn("[hanging-indent] Extension not available");
+      return [];
+    }
+    return ext;
+  }
+};
+// src/plugins/list-continuation.ts
+var LIST_REGEX = /^([>\s]*)(([*+-] |(\d+)([.)] ))(?:\[(.)\] )?)?/;
+var listContinuationPlugin = {
+  id: "list-continuation",
+  install(ctx) {
+    const { keymap, Prec } = window.__cm6;
+    const __newlineAndIndent = window.__commands?.newlineAndIndent;
+    return Prec.high(keymap.of([
+      {
+        key: "Enter",
+        run(v) {
+          const state = v.state;
+          const { head } = state.selection.main;
+          const line = state.doc.lineAt(head);
+          const match = LIST_REGEX.exec(line.text);
+          if (!match)
+            return false;
+          const prefix = match[0];
+          const blockquote = match[1] || "";
+          const listMarker = match[2] || "";
+          if (!blockquote && !listMarker)
+            return false;
+          if (line.text.slice(prefix.length).trim() === "") {
+            v.dispatch({
+              changes: { from: line.from, to: line.to, insert: "" },
+              userEvent: "input.type"
+            });
+            return true;
+          }
+          if (listMarker) {
+            let newMarker = listMarker;
+            const ordNum = match[4];
+            if (ordNum) {
+              const sep = match[5];
+              newMarker = parseInt(ordNum) + 1 + sep;
+            }
+            const checkbox = match[6] !== undefined ? "[ ] " : "";
+            if (checkbox)
+              newMarker = newMarker.replace(/\[.\] $/, "");
+            const insert = `
+` + blockquote + newMarker + checkbox;
+            v.dispatch({
+              changes: { from: head, insert },
+              selection: { anchor: head + insert.length },
+              userEvent: "input.type"
+            });
+          } else {
+            const insert = `
+` + blockquote;
+            v.dispatch({
+              changes: { from: head, insert },
+              selection: { anchor: head + insert.length },
+              userEvent: "input.type"
+            });
+          }
+          return true;
+        },
+        shift(v) {
+          if (__newlineAndIndent)
+            return __newlineAndIndent(v);
+          return false;
+        },
+        preventDefault: true
+      }
+    ]));
+  }
+};
+// src/plugins/close-brackets.ts
+var closeBracketsPlugin = {
+  id: "close-brackets",
+  install(ctx) {
+    const { EditorState, keymap } = window.__cm6;
+    const closeBrackets = window.__closeBrackets;
+    if (!closeBrackets) {
+      console.warn("[close-brackets] Obsidian closeBrackets extension not available");
+      return [];
+    }
+    const { inputHandler: pT, stateField: lT, keymap: fT, markdownSurround: iB } = closeBrackets;
+    if (!pT || !lT || !fT)
+      return [];
+    const opts = ctx.options;
+    const brackets = [];
+    if (opts.autoPairBrackets !== false)
+      brackets.push("(", "[", "{", "'", '"');
+    if (opts.autoPairMarkdown !== false)
+      brackets.push("*", "_", "`", "```");
+    const extensions = [
+      pT,
+      lT,
+      keymap.of(fT),
+      EditorState.languageData.of(() => [{ closeBrackets: { brackets } }])
+    ];
+    if (iB)
+      extensions.push(iB);
+    const frontmatterHandler = window.__frontmatterHandler;
+    if (frontmatterHandler)
+      extensions.push(frontmatterHandler);
+    return extensions;
+  }
+};
+// src/plugins/expand-text.ts
+var RULES = [
+  { regex: /(！)?【【$/, replace: (m) => m[1] ? "![[" : "[[" },
+  { regex: /】】$/, replace: () => "]]" },
+  { regex: /···$/, replace: () => "```" }
+];
+var expandTextPlugin = {
+  id: "expand-text",
+  install(ctx) {
+    const { EditorView } = window.__cm6;
+    return EditorView.updateListener.of((update) => {
+      if (!update.docChanged)
+        return;
+      const isUserInput = update.transactions.some((tr) => tr.isUserEvent("input"));
+      if (!isUserInput)
+        return;
+      const state = update.state;
+      const cursor = state.selection.main.head;
+      const line = state.doc.lineAt(cursor);
+      const textBefore = line.text.slice(0, cursor - line.from);
+      for (const rule of RULES) {
+        const match = textBefore.match(rule.regex);
+        if (match) {
+          const replaceText = rule.replace(match);
+          const from = cursor - match[0].length;
+          setTimeout(() => {
+            ctx.view.dispatch({
+              changes: { from, to: cursor, insert: replaceText },
+              selection: { anchor: from + replaceText.length },
+              userEvent: "input.type"
+            });
+          }, 0);
+          break;
+        }
+      }
+    });
+  }
+};
+// src/plugins/fold.ts
+var foldPlugin = {
+  id: "fold",
+  install(ctx) {
+    const opts = ctx.options;
+    if (!opts.foldHeading && !opts.foldIndent)
+      return [];
+    const foldGutter = window.__foldGutter;
+    const foldExtensions = window.__foldExtensions;
+    const foldHeading = window.__foldHeading;
+    const foldIndent = window.__foldIndent;
+    const foldEffect = window.__foldEffect;
+    if (!foldGutter || !foldExtensions) {
+      console.warn("[fold] Fold extensions not available");
+      return [];
+    }
+    const extensions = [];
+    extensions.push(foldGutter());
+    extensions.push(...foldExtensions);
+    if (opts.foldHeading && foldHeading)
+      extensions.push(foldHeading);
+    if (opts.foldIndent && foldIndent)
+      extensions.push(foldIndent);
+    if (foldEffect)
+      extensions.push(foldEffect);
+    const container = ctx.view.dom?.parentElement;
+    if (container)
+      container.classList.add("is-folding");
+    return extensions;
+  }
+};
+// src/plugins/line-numbers.ts
+var lineNumbersPlugin = {
+  id: "line-numbers",
+  install(_ctx) {
+    const __lineNumbers = window.__lineNumbers;
+    const __activeLineGutter = window.__activeLineGutter;
+    const __highlightActiveLineGutter = window.__highlightActiveLineGutter;
+    if (!__lineNumbers) {
+      console.warn("[line-numbers] lineNumbers extension not available");
+      return [];
+    }
+    const extensions = [__lineNumbers({ fixed: false })];
+    if (__activeLineGutter)
+      extensions.push(__activeLineGutter);
+    if (__highlightActiveLineGutter)
+      extensions.push(__highlightActiveLineGutter());
+    return extensions;
+  }
+};
+// src/plugins/indent-guide.ts
+var indentGuidePlugin = {
+  id: "indent-guide",
+  install(_ctx) {
+    const ext = window.__indentGuide;
+    if (!ext) {
+      console.warn("[indent-guide] indentGuide extension not available");
+      return [];
+    }
+    return ext;
+  }
+};
+// src/plugins/suggest.ts
+function escapeHtml(str) {
+  const div = document.createElement("div");
+  div.appendChild(document.createTextNode(str));
+  return div.innerHTML;
+}
+var suggestPlugin = {
+  id: "suggest",
+  install(ctx) {
+    const { EditorView, Prec, keymap, StateEffect } = window.__cm6;
+    const { view } = ctx;
+    const providers = [];
+    let suggestEl = null;
+    let suggestItems = [];
+    let selectedIdx = 0;
+    let triggerFrom = -1;
+    let activeProvider = null;
+    function createSuggestEl() {
+      if (suggestEl)
+        return suggestEl;
+      suggestEl = document.createElement("div");
+      suggestEl.className = "xlxz-suggest";
+      suggestEl.style.cssText = "position:fixed;z-index:1000;" + "background:var(--background-secondary,#252526);" + "border:1px solid var(--background-modifier-border,#454545);" + "border-radius:4px;max-height:200px;overflow-y:auto;min-width:200px;" + "box-shadow:0 2px 8px rgba(0,0,0,0.3);font-size:13px;display:none;";
+      document.body.appendChild(suggestEl);
+      suggestEl.addEventListener("mousedown", (e) => e.preventDefault());
+      suggestEl.addEventListener("click", (e) => {
+        const itemEl = e.target.closest("[data-idx]");
+        if (itemEl)
+          acceptSuggestion(parseInt(itemEl.getAttribute("data-idx")));
+      });
+      return suggestEl;
+    }
+    function showSuggest(coords, items) {
+      const el = createSuggestEl();
+      suggestItems = items;
+      selectedIdx = 0;
+      el.innerHTML = items.map((item, i) => `<div data-idx="${i}" style="padding:4px 8px;cursor:pointer;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;${i === 0 ? "background:var(--background-modifier-hover,#04395e);" : ""}">${escapeHtml(item.label)}</div>`).join("");
+      el.style.left = coords.left + "px";
+      el.style.top = coords.bottom + 2 + "px";
+      el.style.display = "block";
+    }
+    function hideSuggest() {
+      if (suggestEl)
+        suggestEl.style.display = "none";
+      suggestItems = [];
+      triggerFrom = -1;
+      activeProvider = null;
+    }
+    function isVisible() {
+      return suggestEl && suggestEl.style.display !== "none";
+    }
+    function updateSelection(idx) {
+      if (!suggestEl)
+        return;
+      selectedIdx = Math.max(0, Math.min(idx, suggestItems.length - 1));
+      const items = suggestEl.querySelectorAll("[data-idx]");
+      items.forEach((el, i) => {
+        el.style.background = i === selectedIdx ? "var(--background-modifier-hover,#04395e)" : "";
+      });
+      items[selectedIdx]?.scrollIntoView({ block: "nearest" });
+    }
+    function acceptSuggestion(idx) {
+      if (idx < 0 || idx >= suggestItems.length || !activeProvider)
+        return;
+      const item = suggestItems[idx];
+      const cursor = view.state.selection.main.head;
+      const insertText = item.insertText + (activeProvider.suffix || "");
+      view.dispatch({
+        changes: { from: triggerFrom, to: cursor, insert: insertText },
+        selection: { anchor: triggerFrom + insertText.length },
+        userEvent: "input.type"
+      });
+      const provider = activeProvider;
+      hideSuggest();
+      view.focus();
+      if (provider.onAccept)
+        provider.onAccept(item);
+    }
+    function getCoords(update) {
+      const cursor = update.state.selection.main.head;
+      let coords = update.view.coordsAtPos(cursor);
+      if (!coords) {
+        const sel = window.getSelection();
+        if (sel && sel.rangeCount > 0) {
+          const rect = sel.getRangeAt(0).getBoundingClientRect();
+          if (rect.height > 0)
+            coords = { left: rect.left, bottom: rect.bottom };
+        }
+      }
+      if (!coords) {
+        const cursorEl = update.view.dom.querySelector(".cm-cursor");
+        if (cursorEl) {
+          const r = cursorEl.getBoundingClientRect();
+          coords = { left: r.left, bottom: r.bottom };
+        }
+      }
+      if (!coords) {
+        const r = update.view.dom.getBoundingClientRect();
+        coords = { left: r.left + 50, bottom: r.top + 30 };
+      }
+      return coords;
+    }
+    const listener = EditorView.updateListener.of((update) => {
+      if (!update.docChanged && !update.selectionSet)
+        return;
+      if (providers.length === 0) {
+        hideSuggest();
+        return;
+      }
+      const state = update.state;
+      const cursor = state.selection.main.head;
+      const line = state.doc.lineAt(cursor);
+      const textBefore = line.text.slice(0, cursor - line.from);
+      let matched = false;
+      for (const provider of providers) {
+        const match = textBefore.match(provider.trigger);
+        if (match) {
+          matched = true;
+          const query = match[1] || "";
+          triggerFrom = cursor - query.length;
+          activeProvider = provider;
+          const result = provider.getSuggestions(query);
+          const handleItems = (items) => {
+            if (items.length === 0) {
+              hideSuggest();
+              return;
+            }
+            const coords = getCoords(update);
+            showSuggest(coords, items);
+          };
+          if (result instanceof Promise) {
+            result.then(handleItems);
+          } else {
+            handleItems(result);
+          }
+          break;
+        }
+      }
+      if (!matched)
+        hideSuggest();
+    });
+    const suggestKeymap = Prec.highest(keymap.of([
+      {
+        key: "ArrowDown",
+        run() {
+          if (!isVisible())
+            return false;
+          updateSelection(selectedIdx + 1);
+          return true;
+        }
+      },
+      {
+        key: "ArrowUp",
+        run() {
+          if (!isVisible())
+            return false;
+          updateSelection(selectedIdx - 1);
+          return true;
+        }
+      },
+      {
+        key: "Enter",
+        run() {
+          if (!isVisible())
+            return false;
+          acceptSuggestion(selectedIdx);
+          return true;
+        }
+      },
+      {
+        key: "Tab",
+        run() {
+          if (!isVisible())
+            return false;
+          acceptSuggestion(selectedIdx);
+          return true;
+        }
+      },
+      {
+        key: "Escape",
+        run() {
+          if (!isVisible())
+            return false;
+          hideSuggest();
+          return true;
+        }
+      }
+    ]));
+    const suggestState = {
+      providers,
+      addProvider(provider) {
+        providers.push(provider);
+        return () => this.removeProvider(provider.id);
+      },
+      removeProvider(id) {
+        const idx = providers.findIndex((p) => p.id === id);
+        if (idx !== -1)
+          providers.splice(idx, 1);
+      },
+      destroy() {
+        providers.length = 0;
+        if (suggestEl) {
+          suggestEl.remove();
+          suggestEl = null;
+        }
+      }
+    };
+    ctx.setState("suggest", suggestState);
+    return [listener, suggestKeymap];
+  },
+  uninstall(ctx) {
+    const state = ctx.getState("suggest");
+    if (state)
+      state.destroy();
+  }
+};
+// src/plugins/link-handler.ts
+var linkHandlerPlugin = {
+  id: "link-handler",
+  install(ctx) {
+    const { EditorView } = window.__cm6;
+    const { options: opts, backend: be, view } = ctx;
+    const editorEl = view.dom?.parentElement || view.dom;
+    const handler = (e) => {
+      const target = e.target;
+      if (!target?.closest)
+        return;
+      const internalLink = target.closest(".internal-link, .cm-hmd-internal-link");
+      if (internalLink) {
+        e.preventDefault();
+        e.stopPropagation();
+        const linkText = internalLink.getAttribute("data-href") || internalLink.getAttribute("href") || internalLink.textContent?.trim() || "";
+        if (linkText) {
+          if (opts.onLinkClick) {
+            opts.onLinkClick(linkText, opts.filePath || "");
+          } else {
+            be.openFile(linkText);
+          }
+        }
+        return;
+      }
+      const externalLink = target.closest(".external-link");
+      if (externalLink) {
+        const href = externalLink.getAttribute("href") || externalLink.getAttribute("data-href") || "";
+        if (href && /^https?:|^mailto:/.test(href)) {
+          e.preventDefault();
+          e.stopPropagation();
+          if (opts.onExternalLinkClick) {
+            opts.onExternalLinkClick(href);
+          } else {
+            window.open(href, "_blank");
+          }
+        }
+        return;
+      }
+      const underline = target.closest(".cm-underline");
+      if (underline) {
+        const linkParent = underline.closest(".cm-hmd-internal-link");
+        if (linkParent) {
+          e.preventDefault();
+          e.stopPropagation();
+          const pos = view.posAtDOM(underline);
+          const doc = view.state.doc.toString();
+          const before = doc.lastIndexOf("[[", pos);
+          if (before !== -1 && before >= pos - 200) {
+            const after = doc.indexOf("]]", before + 2);
+            if (after !== -1 && after < pos + 200) {
+              const content = doc.slice(before + 2, after);
+              const pipeIdx = content.indexOf("|");
+              const linkContent = pipeIdx !== -1 ? content.slice(0, pipeIdx) : content;
+              if (opts.onLinkClick) {
+                opts.onLinkClick(linkContent, opts.filePath || "");
+              } else {
+                be.openFile(linkContent);
+              }
+            }
+          }
+          return;
+        }
+        const extParent = underline.closest(".cm-link");
+        if (extParent) {
+          e.preventDefault();
+          e.stopPropagation();
+          const urlEl = extParent.parentElement?.querySelector(".cm-url, .cm-string");
+          let url = "";
+          if (urlEl) {
+            url = urlEl.textContent?.replace(/^\(|\)$/g, "") || "";
+          }
+          if (!url || !/^https?:/.test(url)) {
+            const pos = view.posAtDOM(underline);
+            const line = view.state.doc.lineAt(pos);
+            const linkMatch = line.text.match(/\[([^\]]*)\]\(([^)]+)\)/g);
+            if (linkMatch) {
+              for (const m of linkMatch) {
+                const urlMatch = m.match(/\(([^)]+)\)/);
+                if (urlMatch && /^https?:/.test(urlMatch[1])) {
+                  url = urlMatch[1];
+                  break;
+                }
+              }
+            }
+          }
+          if (/^https?:/.test(url)) {
+            if (opts.onExternalLinkClick) {
+              opts.onExternalLinkClick(url);
+            } else {
+              window.open(url, "_blank");
+            }
+          }
+        }
+      }
+    };
+    editorEl.addEventListener("click", handler);
+    ctx.setState("link-handler", { cleanup: () => editorEl.removeEventListener("click", handler) });
+    return [];
+  },
+  uninstall(ctx) {
+    const state = ctx.getState("link-handler");
+    if (state?.cleanup)
+      state.cleanup();
+  }
+};
+// src/plugins/attachment.ts
+var attachmentPlugin = {
+  id: "attachment",
+  install(ctx) {
+    const { EditorView } = window.__cm6;
+    const { backend: be, view } = ctx;
+    const editorEl = view.dom?.parentElement || view.dom;
+    return EditorView.domEventHandlers({
+      dragover(e) {
+        e.preventDefault();
+        editorEl.classList.add("is-drop-target");
+      },
+      dragleave(_e) {
+        editorEl.classList.remove("is-drop-target");
+      },
+      async drop(e) {
+        editorEl.classList.remove("is-drop-target");
+        const files = e.dataTransfer?.files;
+        if (!files || files.length === 0)
+          return;
+        e.preventDefault();
+        for (const file of Array.from(files)) {
+          const buf = await file.arrayBuffer();
+          const savedPath = await be.saveAttachment(file.name, buf);
+          if (savedPath) {
+            const insert = file.type.startsWith("image/") ? `![${savedPath}](${savedPath})` : `[[${savedPath}]]`;
+            const { from, to } = view.state.selection.main;
+            view.dispatch({
+              changes: { from, to, insert },
+              selection: { anchor: from + insert.length },
+              userEvent: "input.drop"
+            });
+          }
+        }
+      },
+      paste(e) {
+        const items = e.clipboardData?.items;
+        if (items) {
+          for (const item of Array.from(items)) {
+            if (item.type.startsWith("image/")) {
+              e.preventDefault();
+              const blob = item.getAsFile();
+              if (!blob)
+                return;
+              blob.arrayBuffer().then(async (buf) => {
+                const name = "paste-" + Date.now() + "." + (blob.type.split("/")[1] || "png");
+                const savedPath = await be.saveAttachment(name, buf);
+                if (savedPath) {
+                  const insert = `![${savedPath}](${savedPath})`;
+                  const { from, to } = view.state.selection.main;
+                  view.dispatch({
+                    changes: { from, to, insert },
+                    selection: { anchor: from + insert.length },
+                    userEvent: "input.paste"
+                  });
+                }
+              });
+              return;
+            }
+          }
+        }
+        const html = e.clipboardData?.getData("text/html");
+        if (!html)
+          return;
+        if (!window.TurndownService)
+          return;
+        try {
+          const td = new window.TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+          const md = td.turndown(html);
+          if (!md || !md.trim())
+            return;
+          e.preventDefault();
+          const { from, to } = view.state.selection.main;
+          view.dispatch({
+            changes: { from, to, insert: md },
+            selection: { anchor: from + md.length },
+            userEvent: "input.paste"
+          });
+        } catch (err) {
+          console.warn("Paste conversion failed:", err);
+        }
+      }
+    });
+  }
+};
+// src/table/detect.ts
+function isTableLine(text) {
+  const trimmed = text.trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|") && trimmed.length > 1;
+}
+function isSeparatorLine(text) {
+  return /^\|(\s*:?-+:?\s*\|)+$/.test(text.trim());
+}
+function findTableRanges(doc) {
+  const ranges = [];
+  let blockStart = null;
+  let blockFirstLine = 0;
+  let blockLastLine = 0;
+  let hasSeparator = false;
+  const lineCount = doc.lines;
+  for (let i = 1;i <= lineCount; i++) {
+    const line = doc.line(i);
+    if (isTableLine(line.text)) {
+      if (blockStart === null) {
+        blockStart = line.from;
+        blockFirstLine = i;
+      }
+      blockLastLine = i;
+      if (isSeparatorLine(line.text)) {
+        hasSeparator = true;
+      }
+    } else {
+      if (blockStart !== null && hasSeparator && blockLastLine - blockFirstLine >= 1) {
+        ranges.push({
+          from: blockStart,
+          to: doc.line(blockLastLine).to,
+          firstLine: blockFirstLine,
+          lastLine: blockLastLine
+        });
+      }
+      blockStart = null;
+      hasSeparator = false;
+    }
+  }
+  if (blockStart !== null && hasSeparator && blockLastLine - blockFirstLine >= 1) {
+    ranges.push({
+      from: blockStart,
+      to: doc.line(blockLastLine).to,
+      firstLine: blockFirstLine,
+      lastLine: blockLastLine
+    });
+  }
+  return ranges;
+}
+function cursorInTable(state, table) {
+  for (const range of state.selection.ranges) {
+    if (range.from <= table.to && range.to >= table.from)
+      return true;
+  }
+  return false;
+}
+
+// ../../node_modules/.bun/ansi-regex@6.2.2/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? undefined : "g");
+}
+
+// ../../node_modules/.bun/strip-ansi@7.2.0/node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("›")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup-data.js
+var ambiguousMinimalCodePoint = 161;
+var ambiguousMaximumCodePoint = 1114109;
+var ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+var fullwidthMinimalCodePoint = 12288;
+var fullwidthMaximumCodePoint = 65510;
+var fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+var wideMinimalCodePoint = 4352;
+var wideMaximumCodePoint = 262141;
+var wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128728, 128732, 128735, 128747, 128748, 128756, 128764, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129674, 129678, 129734, 129736, 129736, 129741, 129756, 129759, 129770, 129775, 129784, 131072, 196605, 196608, 262141];
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/utilities.js
+var isInRange = (ranges, codePoint) => {
+  let low = 0;
+  let high = Math.floor(ranges.length / 2) - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const i = mid * 2;
+    if (codePoint < ranges[i]) {
+      high = mid - 1;
+    } else if (codePoint > ranges[i + 1]) {
+      low = mid + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup.js
+var commonCjkCodePoint = 19968;
+var [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0];
+  let fastPathEnd = ranges[1];
+  for (let index = 0;index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) {
+      return [start, end];
+    }
+    if (end - start > fastPathEnd - fastPathStart) {
+      fastPathStart = start;
+      fastPathEnd = end;
+    }
+  }
+  return [fastPathStart, fastPathEnd];
+}
+var isAmbiguous = (codePoint) => {
+  if (codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+};
+var isFullWidth = (codePoint) => {
+  if (codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+};
+var isWide = (codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+};
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+
+// ../../node_modules/.bun/string-width@8.2.1/node_modules/string-width/index.js
+var segmenter = new Intl.Segmenter;
+var zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})+$/v;
+var leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+var rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+var extendedPictographicRegex = /\p{Extended_Pictographic}/gu;
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+  if (segment.length > 50) {
+    return false;
+  }
+  if (unqualifiedKeycapRegex.test(segment)) {
+    return true;
+  }
+  if (segment.includes("‍")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+  return false;
+}
+function baseVisible(segment) {
+  return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+  return zeroWidthClusterRegex.test(segment);
+}
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (zeroWidthClusterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return;
+  }
+  let width = 0;
+  for (let index = 0;index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return;
+      }
+      for (let remaining = index;remaining < codePoints.length; remaining++) {
+        width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+      }
+      return width;
+    }
+    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+      width += 2;
+      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
+  let extra = 0;
+  let first = true;
+  for (const character of visibleSegment) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    if (character >= "＀" && character <= "￯") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return extra;
+}
+function stringWidth(input, options = {}) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string = input;
+  if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("›"))) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  if (/^[\u0020-\u007E]*$/.test(string)) {
+    return string.length;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string)) {
+    if (isZeroWidthCluster(segment)) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+      width += 2;
+      continue;
+    }
+    const visibleSegment = baseVisible(segment);
+    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+    if (hangulWidth !== undefined) {
+      width += hangulWidth;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions);
+  }
+  return width;
+}
+
+// src/table/format.ts
+function parseCells(text) {
+  return text.trim().split("|").slice(1, -1);
+}
+function cellContent(cell) {
+  return cell.trim();
+}
+function isSeparatorCell(text) {
+  return /^:?-+:?$/.test(text.trim());
+}
+function formatSeparatorCell(text, width) {
+  const trimmed = text.trim();
+  const leftColon = trimmed.startsWith(":");
+  const rightColon = trimmed.endsWith(":");
+  const dashCount = width - (leftColon ? 1 : 0) - (rightColon ? 1 : 0);
+  return (leftColon ? ":" : "") + "-".repeat(Math.max(1, dashCount)) + (rightColon ? ":" : "");
+}
+function padEndVisual(str, targetWidth) {
+  const currentWidth = stringWidth(str);
+  const diff = targetWidth - currentWidth;
+  if (diff <= 0)
+    return str;
+  return str + " ".repeat(diff);
+}
+function formatTable(doc, table) {
+  const lines = [];
+  for (let i = table.firstLine;i <= table.lastLine; i++) {
+    lines.push(doc.line(i).text);
+  }
+  const rows = lines.map((l) => parseCells(l).map(cellContent));
+  if (rows.length < 2)
+    return null;
+  const colCount = rows[0].length;
+  if (colCount === 0)
+    return null;
+  const colWidths = [];
+  for (let col = 0;col < colCount; col++) {
+    let maxW = 3;
+    for (const row of rows) {
+      const cell = row[col] || "";
+      if (!isSeparatorCell(cell)) {
+        maxW = Math.max(maxW, stringWidth(cell));
+      }
+    }
+    colWidths.push(maxW);
+  }
+  const formatted = rows.map((row, rowIdx) => {
+    const cells = [];
+    for (let col = 0;col < colCount; col++) {
+      const raw = row[col] || "";
+      const width = colWidths[col];
+      if (isSeparatorLine(lines[rowIdx])) {
+        cells.push(" " + formatSeparatorCell(raw, width) + " ");
+      } else {
+        cells.push(" " + padEndVisual(raw, width) + " ");
+      }
+    }
+    return "|" + cells.join("|") + "|";
+  });
+  const newText = formatted.join(`
+`);
+  const oldText = doc.sliceString(table.from, table.to);
+  if (newText === oldText)
+    return null;
+  return { from: table.from, to: table.to, insert: newText };
+}
+
+// src/table/copy-widget.ts
+function createCopyButtonWidgetClass(WidgetType) {
+  return class CopyButtonWidget extends WidgetType {
+    tableFrom;
+    tableTo;
+    constructor(tableFrom, tableTo) {
+      super();
+      this.tableFrom = tableFrom;
+      this.tableTo = tableTo;
+    }
+    toDOM(view) {
+      const btn = document.createElement("button");
+      btn.className = "cm-table-copy-btn";
+      btn.title = "复制表格（Tab 分隔）";
+      btn.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>`;
+      btn.addEventListener("click", (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        const doc = view.state.doc;
+        const text = doc.sliceString(this.tableFrom, this.tableTo);
+        const tsv = text.split(`
+`).filter((l) => !isSeparatorLine(l)).map((l) => parseCells(l).map(cellContent).join("\t")).join(`
+`);
+        navigator.clipboard.writeText(tsv);
+        btn.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="20 6 9 17 4 12"></polyline></svg>`;
+        btn.style.color = "var(--text-success)";
+        setTimeout(() => {
+          btn.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>`;
+          btn.style.color = "";
+        }, 1500);
+      });
+      return btn;
+    }
+    eq(other) {
+      return this.tableFrom === other.tableFrom && this.tableTo === other.tableTo;
+    }
+    ignoreEvent() {
+      return true;
+    }
+  };
+}
+
+// src/table/theme.ts
+function createTableTheme(EditorView) {
+  return EditorView.baseTheme({
+    ".cm-table-header, .cm-table-separator, .cm-table-row-even, .cm-table-row-odd": {
+      fontFamily: "var(--font-monospace)",
+      position: "relative"
+    },
+    ".cm-table-header": {
+      backgroundColor: "var(--table-header-bg, rgba(80, 120, 200, 0.15))",
+      fontWeight: "600"
+    },
+    ".cm-table-separator": {
+      backgroundColor: "var(--table-separator-bg, rgba(80, 120, 200, 0.04))",
+      color: "var(--text-faint)"
+    },
+    ".cm-table-active.cm-table-separator": {
+      backgroundColor: "var(--table-separator-bg, rgba(80, 120, 200, 0.04))",
+      color: "var(--text-muted)"
+    },
+    ".cm-table-row-even": {
+      backgroundColor: "var(--table-row-even-bg, rgba(80, 140, 220, 0.06))"
+    },
+    ".cm-table-row-odd": {
+      backgroundColor: "var(--table-row-odd-bg, rgba(80, 140, 220, 0.12))"
+    },
+    ".cm-table-active.cm-table-header": {
+      backgroundColor: "rgba(80, 120, 200, 0.10)"
+    },
+    ".cm-table-active.cm-table-row-even": {
+      backgroundColor: "rgba(80, 140, 220, 0.04)"
+    },
+    ".cm-table-active.cm-table-row-odd": {
+      backgroundColor: "rgba(80, 140, 220, 0.08)"
+    },
+    ".cm-table-copy-btn": {
+      position: "absolute",
+      right: "6px",
+      top: "6px",
+      zIndex: "1",
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      padding: "var(--size-4-1) var(--size-4-2)",
+      borderRadius: "var(--code-radius, 4px)",
+      border: "none",
+      backgroundColor: "transparent",
+      color: "var(--text-muted)",
+      cursor: "var(--cursor)",
+      fontSize: "var(--font-ui-smaller)",
+      fontFamily: "var(--font-interface)",
+      opacity: "0",
+      transition: "opacity 0.15s"
+    },
+    ".cm-table-header:hover .cm-table-copy-btn": {
+      opacity: "1"
+    },
+    ".cm-table-copy-btn:hover": {
+      opacity: "1",
+      backgroundColor: "var(--background-modifier-hover)"
+    },
+    '.cm-table-header span[class*="cm-hmd-table-sep"], .cm-table-separator span[class*="cm-hmd-table-sep"], .cm-table-row-even span[class*="cm-hmd-table-sep"], .cm-table-row-odd span[class*="cm-hmd-table-sep"]': {
+      color: "var(--text-faint)"
+    },
+    '.cm-table-active span[class*="cm-hmd-table-sep"]': {
+      color: "var(--text-muted)"
+    }
+  });
+}
+
+// src/table/index.ts
+function createTableExtension() {
+  const { EditorView, ViewPlugin, Decoration, WidgetType } = window.__cm6;
+  const CopyButtonWidget = createCopyButtonWidgetClass(WidgetType);
+  const tableHeaderDeco = Decoration.line({ class: "cm-table-header" });
+  const tableSepDeco = Decoration.line({ class: "cm-table-separator" });
+  const tableRowEvenDeco = Decoration.line({ class: "cm-table-row-even" });
+  const tableRowOddDeco = Decoration.line({ class: "cm-table-row-odd" });
+  const tableHeaderActiveDeco = Decoration.line({ class: "cm-table-header cm-table-active" });
+  const tableSepActiveDeco = Decoration.line({ class: "cm-table-separator cm-table-active" });
+  const tableRowEvenActiveDeco = Decoration.line({ class: "cm-table-row-even cm-table-active" });
+  const tableRowOddActiveDeco = Decoration.line({ class: "cm-table-row-odd cm-table-active" });
+  const tablePlugin = ViewPlugin.fromClass(class {
+    decorations;
+    formatPending = false;
+    constructor(view) {
+      this.decorations = this.buildDecorations(view);
+    }
+    update(update) {
+      if (update.docChanged || update.selectionSet || update.viewportChanged) {
+        this.decorations = this.buildDecorations(update.view);
+      }
+      if (update.selectionSet && !update.docChanged && !this.formatPending) {
+        this.formatPending = true;
+        const view = update.view;
+        requestAnimationFrame(() => {
+          this.formatPending = false;
+          this.maybeFormatTables(view);
+        });
+      }
+    }
+    maybeFormatTables(view) {
+      const { state } = view;
+      const doc = state.doc;
+      const tables = findTableRanges(doc);
+      const changes = [];
+      for (const table of tables) {
+        if (!cursorInTable(state, table)) {
+          const change = formatTable(doc, table);
+          if (change)
+            changes.push(change);
+        }
+      }
+      if (changes.length > 0) {
+        view.dispatch({ changes });
+      }
+    }
+    buildDecorations(view) {
+      const { state } = view;
+      const doc = state.doc;
+      const tables = findTableRanges(doc);
+      const builder = [];
+      for (const table of tables) {
+        const isActive = cursorInTable(state, table);
+        let bodyRowIndex = 0;
+        for (let lineNum = table.firstLine;lineNum <= table.lastLine; lineNum++) {
+          const line = doc.line(lineNum);
+          const text = line.text;
+          if (lineNum === table.firstLine) {
+            builder.push((isActive ? tableHeaderActiveDeco : tableHeaderDeco).range(line.from));
+          } else if (isSeparatorLine(text)) {
+            builder.push((isActive ? tableSepActiveDeco : tableSepDeco).range(line.from));
+          } else {
+            const even = bodyRowIndex % 2 === 0;
+            const deco = isActive ? even ? tableRowEvenActiveDeco : tableRowOddActiveDeco : even ? tableRowEvenDeco : tableRowOddDeco;
+            builder.push(deco.range(line.from));
+            bodyRowIndex++;
+          }
+        }
+        if (!isActive) {
+          const widget = Decoration.widget({
+            widget: new CopyButtonWidget(table.from, table.to),
+            side: 1
+          });
+          builder.push(widget.range(doc.line(table.firstLine).from));
+        }
+      }
+      builder.sort((a, b) => a.from - b.from);
+      return Decoration.set(builder);
+    }
+  }, {
+    decorations: (v) => v.decorations
+  });
+  const tableTheme = createTableTheme(EditorView);
+  return [tablePlugin, tableTheme];
+}
+
+// src/plugins/table.ts
+var tablePlugin = {
+  id: "table",
+  install(_ctx) {
+    return createTableExtension();
+  }
+};
+// src/plugins/table-continuation.ts
+function isEmptyRow(text) {
+  if (!isTableLine(text))
+    return false;
+  if (isSeparatorLine(text))
+    return false;
+  const cells = text.trim().split("|").slice(1, -1);
+  return cells.every((c) => c.trim() === "");
+}
+function getColumnCount(doc, table) {
+  const headerText = doc.line(table.firstLine).text;
+  return headerText.trim().split("|").slice(1, -1).length;
+}
+function getCellWidths(text) {
+  const cells = text.trim().split("|").slice(1, -1);
+  return cells.map((c) => Math.max(c.length, 3));
+}
+function buildEmptyRow(colCount, widths) {
+  const cells = [];
+  for (let i = 0;i < colCount; i++) {
+    const w = widths[i] || 3;
+    cells.push(" ".repeat(w));
+  }
+  return "|" + cells.join("|") + "|";
+}
+var tableContinuationPlugin = {
+  id: "table-continuation",
+  deps: ["table"],
+  install(_ctx) {
+    const { keymap, Prec } = window.__cm6;
+    return Prec.high(keymap.of([
+      {
+        key: "Enter",
+        run(view) {
+          const state = view.state;
+          const { head } = state.selection.main;
+          const line = state.doc.lineAt(head);
+          const text = line.text;
+          if (!isTableLine(text))
+            return false;
+          const tables = findTableRanges(state.doc);
+          const table = tables.find((t) => line.number >= t.firstLine && line.number <= t.lastLine);
+          if (!table)
+            return false;
+          if (isEmptyRow(text)) {
+            view.dispatch({
+              changes: { from: line.from, to: line.to, insert: "" },
+              userEvent: "input.type"
+            });
+            return true;
+          }
+          const colCount = getColumnCount(state.doc, table);
+          const widths = getCellWidths(text);
+          const emptyRow = buildEmptyRow(colCount, widths);
+          const insert = `
+` + emptyRow;
+          view.dispatch({
+            changes: { from: line.to, insert },
+            selection: { anchor: line.to + insert.length },
+            userEvent: "input.type"
+          });
+          requestAnimationFrame(() => {
+            const newState = view.state;
+            const newTables = findTableRanges(newState.doc);
+            const cursor = newState.selection.main.head;
+            const curLine = newState.doc.lineAt(cursor);
+            const targetTable = newTables.find((t) => curLine.number >= t.firstLine && curLine.number <= t.lastLine);
+            if (targetTable) {
+              const cursorLineNum = curLine.number;
+              const change = formatTable(newState.doc, targetTable);
+              if (change) {
+                view.dispatch({ changes: change });
+                const restoredLine = view.state.doc.line(cursorLineNum);
+                view.dispatch({
+                  selection: { anchor: restoredLine.to }
+                });
+              }
+            }
+          });
+          return true;
+        },
+        preventDefault: true
+      }
+    ]));
+  }
+};
+// src/plugins/theme.ts
+var themePlugin = {
+  id: "theme",
+  install(ctx) {
+    const { EditorView } = window.__cm6;
+    const opts = ctx.options;
+    const editorEl = ctx.view.dom?.parentElement || ctx.view.dom;
+    if (!editorEl.classList.contains("markdown-source-view")) {
+      editorEl.classList.add("markdown-source-view", "mod-cm6", "is-live-preview");
+    }
+    if (opts.readableLineWidth) {
+      editorEl.classList.add("is-readable-line-width");
+    }
+    if (opts.theme === "light") {
+      editorEl.classList.add("theme-light");
+      editorEl.classList.remove("theme-dark");
+    } else {
+      editorEl.classList.add("theme-dark");
+      editorEl.classList.remove("theme-light");
+    }
+    if (opts.cssVariables) {
+      for (const [key, value] of Object.entries(opts.cssVariables)) {
+        const prop = key.startsWith("--") ? key : `--${key}`;
+        editorEl.style.setProperty(prop, value);
+      }
+    }
+    return EditorView.contentAttributes.of({
+      spellcheck: String(opts.spellcheck ?? false),
+      autocorrect: "on",
+      autocapitalize: "on",
+      contenteditable: "true"
+    });
+  }
+};
+// src/plugins/base-extensions.ts
+var baseExtensionsPlugin = {
+  id: "base-extensions",
+  install(ctx) {
+    const { EditorState } = window.__cm6;
+    const { editor: jB, owner: WB } = window.__stateFields;
+    const { base: ZB } = window.__compartments;
+    const __indentUnit = window.__indentUnit;
+    const opts = ctx.options;
+    const extensions = [];
+    if (jB) {
+      const mockEditor = ctx.getState("__mockEditor");
+      if (mockEditor)
+        extensions.push(jB.init(() => mockEditor));
+    }
+    if (WB) {
+      const mockOwner = ctx.getState("__mockOwner");
+      if (mockOwner)
+        extensions.push(WB.init(() => mockOwner));
+    }
+    const tabSize = opts.tabSize ?? 4;
+    const indent = opts.useTab !== false ? "\t" : " ".repeat(Math.min(Math.max(tabSize, 2), 4));
+    extensions.push(EditorState.tabSize.of(tabSize));
+    if (__indentUnit)
+      extensions.push(__indentUnit.of(indent));
+    if (window.__baseExtensions && ZB) {
+      extensions.push(ZB.of(window.__baseExtensions));
+    }
+    return extensions;
+  }
+};
+// src/plugins/keymap.ts
+var keymapPlugin = {
+  id: "keymap",
+  install(ctx) {
+    const { keymap } = window.__cm6;
+    const __indentMore = window.__commands?.indentMore;
+    const __indentLess = window.__commands?.indentLess;
+    const opts = ctx.options;
+    return keymap.of([
+      {
+        key: "Tab",
+        run(v) {
+          if (__indentMore)
+            return __indentMore(v);
+          return false;
+        },
+        shift(v) {
+          if (__indentLess)
+            return __indentLess(v);
+          return false;
+        }
+      },
+      {
+        key: "Mod-s",
+        run(v) {
+          if (opts.onSave)
+            opts.onSave(v.state.doc.toString());
+          return true;
+        },
+        preventDefault: true
+      }
+    ]);
+  }
+};
+// src/plugins/on-change.ts
+var onChangePlugin = {
+  id: "on-change",
+  install(ctx) {
+    const { EditorView } = window.__cm6;
+    const opts = ctx.options;
+    return EditorView.updateListener.of((update) => {
+      if (update.docChanged && opts.onChange) {
+        opts.onChange(update.state.doc.toString());
+      }
+    });
+  }
+};
+// src/plugin-defaults.ts
+function getDefaultPlugins(opts) {
+  const plugins = [];
+  plugins.push(baseExtensionsPlugin);
+  plugins.push(themePlugin);
+  plugins.push(markdownLanguagePlugin);
+  plugins.push(hangingIndentPlugin);
+  plugins.push(livePreviewPlugin);
+  plugins.push(listContinuationPlugin);
+  plugins.push(keymapPlugin);
+  plugins.push(expandTextPlugin);
+  if (opts.autoPairBrackets !== false || opts.autoPairMarkdown !== false) {
+    plugins.push(closeBracketsPlugin);
+  }
+  if (opts.showLineNumber !== false) {
+    plugins.push(lineNumbersPlugin);
+  }
+  if (opts.showIndentGuide !== false) {
+    plugins.push(indentGuidePlugin);
+  }
+  if (opts.foldHeading !== false || opts.foldIndent !== false) {
+    plugins.push(foldPlugin);
+  }
+  plugins.push(suggestPlugin);
+  plugins.push(linkHandlerPlugin);
+  plugins.push(attachmentPlugin);
+  plugins.push(tablePlugin);
+  plugins.push(tableContinuationPlugin);
+  plugins.push(onChangePlugin);
+  return plugins;
+}
+
+// src/auto-load.ts
+var SCRIPT_ORDER = [
+  "lib/i18next.min.js",
+  "lib/codemirror.js",
+  "lib/meta.min.js",
+  "lib/modes.min.js",
+  "lib/markdown.js",
+  "lib/turndown.js",
+  "enhance.js",
+  "mock.js",
+  "obsidian-app.patched.js"
+];
+var MATH_SCRIPTS = [
+  "lib/mathjax/tex-chtml-full.js"
+];
+function autoLoad(options = {}) {
+  const base = options.basePath || "/vendor/";
+  const overrides = options.overrides || {};
+  const scripts = [...SCRIPT_ORDER];
+  if (options.math) {
+    scripts.push(...MATH_SCRIPTS);
+  }
+  return scripts.reduce((promise, script) => {
+    return promise.then(() => {
+      return new Promise((resolve, reject) => {
+        const src = overrides[script] || base + script;
+        const el = document.createElement("script");
+        el.src = src;
+        el.onload = () => resolve();
+        el.onerror = () => reject(new Error("Failed to load: " + src));
+        document.head.appendChild(el);
+      });
+    });
+  }, Promise.resolve());
+}
+
+// src/kernel.ts
+function createEditor(container, options = {}, backend = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const be = { ...defaultBackend, ...backend };
+  if (!window.__cm6 || !window.__cm6.EditorView) {
+    throw new Error("xlxz-markdown-editor: Obsidian runtime not loaded. " + "Ensure vendor scripts are included before calling createEditor().");
+  }
+  const { EditorView, EditorState, StateEffect } = window.__cm6;
+  const view = new EditorView({ parent: container });
+  const mockOwner = createMockOwner(opts.filePath);
+  const mockApp = createMockApp(be, opts);
+  const mockEditor = createMockEditor(mockApp, mockOwner, view, container);
+  const pluginStates = new Map;
+  const activePlugins = new Map;
+  pluginStates.set("__mockEditor", mockEditor);
+  pluginStates.set("__mockOwner", mockOwner);
+  function makeContext() {
+    return {
+      view,
+      options: opts,
+      backend: be,
+      getState(pluginId) {
+        return pluginStates.get(pluginId);
+      },
+      setState(pluginId, state) {
+        pluginStates.set(pluginId, state);
+      }
+    };
+  }
+  function use(plugin) {
+    if (activePlugins.has(plugin.id)) {
+      console.warn(`Plugin "${plugin.id}" is already registered.`);
+      return;
+    }
+    if (plugin.deps) {
+      for (const dep of plugin.deps) {
+        if (!activePlugins.has(dep)) {
+          console.warn(`Plugin "${plugin.id}" depends on "${dep}" which is not registered.`);
+        }
+      }
+    }
+    const ctx = makeContext();
+    const ext = plugin.install(ctx);
+    if (ext) {
+      const exts = Array.isArray(ext) ? ext : [ext];
+      if (exts.length > 0) {
+        view.dispatch({ effects: StateEffect.appendConfig.of(exts) });
+      }
+    }
+    activePlugins.set(plugin.id, plugin);
+  }
+  function unuse(pluginId) {
+    const plugin = activePlugins.get(pluginId);
+    if (!plugin)
+      return;
+    if (plugin.uninstall) {
+      plugin.uninstall(makeContext());
+    }
+    activePlugins.delete(pluginId);
+    pluginStates.delete(pluginId);
+  }
+  const defaultPlugins = getDefaultPlugins(opts);
+  const initialExtensions = [];
+  for (const plugin of defaultPlugins) {
+    if (activePlugins.has(plugin.id))
+      continue;
+    const ctx = makeContext();
+    const ext = plugin.install(ctx);
+    if (ext) {
+      const exts = Array.isArray(ext) ? ext : [ext];
+      initialExtensions.push(...exts);
+    }
+    activePlugins.set(plugin.id, plugin);
+  }
+  const fullState = EditorState.create({
+    doc: opts.doc || "",
+    extensions: initialExtensions
+  });
+  view.setState(fullState);
+  (function forceRebuild() {
+    const { syntaxTree, Transaction } = window.__cm6;
+    view.dispatch({ annotations: Transaction.addToHistory.of(false) });
+    const tree = syntaxTree(view.state);
+    if (tree.length < view.state.doc.length) {
+      setTimeout(forceRebuild, 50);
+    }
+  })();
+  function registerSuggest(config) {
+    const suggestState = pluginStates.get("suggest");
+    if (!suggestState) {
+      console.warn("registerSuggest: suggest plugin not installed. Call editor.use(suggestPlugin) first.");
+      return () => {};
+    }
+    const provider = {
+      id: `suggest-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+      trigger: config.trigger,
+      getSuggestions: config.getSuggestions,
+      onAccept: config.onAccept,
+      suffix: config.suffix
+    };
+    return suggestState.addProvider(provider);
+  }
+  const instance = {
+    view,
+    getDoc() {
+      return view.state.doc.toString();
+    },
+    setDoc(content) {
+      view.dispatch({
+        changes: { from: 0, to: view.state.doc.length, insert: content }
+      });
+    },
+    getSelection() {
+      const { from, to } = view.state.selection.main;
+      return view.state.doc.sliceString(from, to);
+    },
+    destroy() {
+      const ids = [...activePlugins.keys()].reverse();
+      for (const id of ids)
+        unuse(id);
+      view.destroy();
+      container.innerHTML = "";
+      pluginStates.clear();
+    },
+    focus() {
+      view.focus();
+    },
+    use,
+    unuse,
+    registerSuggest
+  };
+  return instance;
+}