@4399ywkf/editor 0.1.2 → 0.3.0

package/dist/doc-runtime.js

@@ -0,0 +1,774 @@
+// src/doc-runtime/litexml.ts
+var NODE_TAG = {
+  paragraph: "p",
+  bulletList: "ul",
+  orderedList: "ol",
+  listItem: "li",
+  taskList: "tasks",
+  taskItem: "task",
+  blockquote: "quote",
+  codeBlock: "code",
+  horizontalRule: "hr",
+  table: "table",
+  tableRow: "tr",
+  tableCell: "td",
+  tableHeader: "th",
+  image: "img",
+  video: "video",
+  audio: "audio",
+  fileAttachment: "file",
+  columns: "cols",
+  column: "col",
+  tocNode: "toc",
+  mediaUploadPlaceholder: "uploading",
+  imageUpload: "uploading"
+};
+var TYPE_BY_TAG = Object.fromEntries(
+  Object.entries(NODE_TAG).map(([type, tag]) => [tag, type])
+);
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "hr",
+  "img",
+  "video",
+  "audio",
+  "file",
+  "toc",
+  "uploading"
+]);
+var READONLY_TAGS = /* @__PURE__ */ new Set(["toc", "uploading"]);
+var ATTR_ALIAS = {
+  textAlign: "align",
+  nodeTextAlign: "align",
+  nodeVerticalAlign: "valign",
+  backgroundColor: "bg",
+  language: "lang"
+};
+var ATTR_UNALIAS = {
+  align: "textAlign",
+  valign: "nodeVerticalAlign",
+  bg: "backgroundColor",
+  lang: "language"
+};
+var NOISE_ATTRS = /* @__PURE__ */ new Set(["data-toc-id"]);
+var NUM_ATTRS = /* @__PURE__ */ new Set(["level", "indent", "colspan", "rowspan"]);
+var BOOL_ATTRS = /* @__PURE__ */ new Set(["checked"]);
+var MARK_TAG = {
+  bold: "b",
+  italic: "i",
+  underline: "u",
+  strike: "s",
+  code: "c",
+  superscript: "sup",
+  subscript: "sub"
+};
+var MARK_BY_TAG = Object.fromEntries(
+  Object.entries(MARK_TAG).map(([mark, tag]) => [tag, mark])
+);
+var FORMATTABLE = Object.keys(MARK_TAG);
+var esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function attrsToXml(node) {
+  const out = [];
+  const attrs = node.attrs ?? {};
+  if (attrs.id) out.push(` id="${esc(attrs.id)}"`);
+  for (const [k, v] of Object.entries(attrs)) {
+    if (k === "id" || v === null || v === void 0 || v === "" || v === 0 || v === false) continue;
+    if (NOISE_ATTRS.has(k)) continue;
+    if ((k === "colspan" || k === "rowspan") && v === 1) continue;
+    const name = ATTR_ALIAS[k] ?? k;
+    if (name === "id") continue;
+    out.push(` ${name}="${esc(Array.isArray(v) ? v.join(",") : v)}"`);
+  }
+  return out.join("");
+}
+function inlineToXml(nodes = []) {
+  return nodes.map((n) => {
+    if (n.type === "text") {
+      let out = esc(n.text ?? "");
+      for (const m of n.marks ?? []) {
+        const tag = MARK_TAG[m.type];
+        if (tag) out = `<${tag}>${out}</${tag}>`;
+        else if (m.type === "link") out = `<a href="${esc(m.attrs?.href ?? "")}">${out}</a>`;
+        else if (m.type === "highlight")
+          out = `<mark${m.attrs?.color ? ` color="${esc(m.attrs.color)}"` : ""}>${out}</mark>`;
+        else if (m.type === "textStyle" && m.attrs?.color)
+          out = `<color v="${esc(m.attrs.color)}">${out}</color>`;
+      }
+      return out;
+    }
+    if (n.type === "hardBreak") return "<br/>";
+    return `<node type="${esc(n.type)}"${attrsToXml(n)}/>`;
+  }).join("");
+}
+function isBlock(n) {
+  return Boolean(n.type && NODE_TAG[n.type]) || n.type === "heading";
+}
+function nodeToXml(node, depth = 0) {
+  const pad = "  ".repeat(depth);
+  const attrs = attrsToXml(node);
+  if (node.type === "heading") {
+    const lv = node.attrs?.level ?? 1;
+    const a = attrs.replace(/ level="\d+"/, "");
+    return `${pad}<h${lv}${a}>${inlineToXml(node.content)}</h${lv}>`;
+  }
+  const tag = node.type ? NODE_TAG[node.type] : void 0;
+  if (!tag) return `${pad}<node type="${esc(node.type)}"${attrs}/>`;
+  if (VOID_TAGS.has(tag)) return `${pad}<${tag}${attrs}/>`;
+  const kids = node.content ?? [];
+  if (kids.some(isBlock)) {
+    const inner = kids.map((c) => nodeToXml(c, depth + 1)).join("\n");
+    return `${pad}<${tag}${attrs}>
+${inner}
+${pad}</${tag}>`;
+  }
+  return `${pad}<${tag}${attrs}>${inlineToXml(kids)}</${tag}>`;
+}
+function docToXml(doc) {
+  return (doc.content ?? []).map((n) => nodeToXml(n, 0)).join("\n");
+}
+function coerce(name, raw) {
+  if (NUM_ATTRS.has(name)) {
+    const n = Number(raw);
+    return Number.isNaN(n) ? raw : n;
+  }
+  if (BOOL_ATTRS.has(name)) return raw === "true" || raw === "";
+  if (name === "colwidth")
+    return raw.split(",").map(Number).filter((n) => !Number.isNaN(n));
+  return raw;
+}
+function childElements(el) {
+  const out = [];
+  const kids = el.childNodes;
+  for (let i = 0; i < kids.length; i++) {
+    const n = kids.item(i);
+    if (n && n.nodeType === 1) out.push(n);
+  }
+  return out;
+}
+function xmlAttrsToPm(el, skip = /* @__PURE__ */ new Set()) {
+  const attrs = {};
+  const list = el.attributes;
+  for (let i = 0; i < list.length; i++) {
+    const a = list.item(i);
+    if (!a) continue;
+    const name = ATTR_UNALIAS[a.name] ?? a.name;
+    if (skip.has(name)) continue;
+    attrs[name] = coerce(name, a.value);
+  }
+  return attrs;
+}
+function xmlInlineToPm(el) {
+  const out = [];
+  const kids = el.childNodes;
+  for (let i = 0; i < kids.length; i++) {
+    const child = kids.item(i);
+    if (!child) continue;
+    if (child.nodeType === 3) {
+      if (child.nodeValue) out.push({ type: "text", text: child.nodeValue });
+      continue;
+    }
+    if (child.nodeType !== 1) continue;
+    const childEl = child;
+    const tag = childEl.tagName.toLowerCase();
+    if (tag === "br") {
+      out.push({ type: "hardBreak" });
+      continue;
+    }
+    if (tag === "node") {
+      const type = childEl.getAttribute("type");
+      if (!type) throw new Error("<node> 必须带 type 属性");
+      out.push({ type, attrs: xmlAttrsToPm(childEl, /* @__PURE__ */ new Set(["type"])) });
+      continue;
+    }
+    let mark = null;
+    if (MARK_BY_TAG[tag]) mark = { type: MARK_BY_TAG[tag] };
+    else if (tag === "a")
+      mark = { type: "link", attrs: { href: childEl.getAttribute("href") ?? "" } };
+    else if (tag === "mark")
+      mark = { type: "highlight", attrs: { color: childEl.getAttribute("color") ?? null } };
+    else if (tag === "color")
+      mark = { type: "textStyle", attrs: { color: childEl.getAttribute("v") ?? null } };
+    const inner = xmlInlineToPm(childEl);
+    if (!mark) {
+      out.push(...inner);
+      continue;
+    }
+    for (const t of inner) {
+      if (t.type === "text") t.marks = [...t.marks ?? [], mark];
+      out.push(t);
+    }
+  }
+  return out;
+}
+function xmlElToPm(el) {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "node") {
+    const type2 = el.getAttribute("type");
+    if (!type2) throw new Error("<node> 必须带 type 属性");
+    return { type: type2, attrs: xmlAttrsToPm(el, /* @__PURE__ */ new Set(["type"])) };
+  }
+  const hm = /^h([1-6])$/.exec(tag);
+  if (hm) {
+    return {
+      type: "heading",
+      attrs: { level: Number(hm[1]), ...xmlAttrsToPm(el) },
+      content: xmlInlineToPm(el)
+    };
+  }
+  const type = TYPE_BY_TAG[tag];
+  if (!type) {
+    throw new Error(
+      `未知标签 <${tag}>。可用：${Object.values(NODE_TAG).join(" ")} h1-h6 node，内联：${Object.values(MARK_TAG).join(" ")} a mark color br`
+    );
+  }
+  if (READONLY_TAGS.has(tag)) {
+    throw new Error(`<${tag}> 由扩展自动维护，不能直接写入`);
+  }
+  const attrs = xmlAttrsToPm(el);
+  if (VOID_TAGS.has(tag)) return { type, attrs };
+  const blockKids = childElements(el).filter((c) => {
+    const t = c.tagName.toLowerCase();
+    return Boolean(TYPE_BY_TAG[t]) || /^h[1-6]$/.test(t);
+  });
+  if (blockKids.length > 0) {
+    return { type, attrs, content: blockKids.map(xmlElToPm) };
+  }
+  const inline = xmlInlineToPm(el);
+  return inline.length ? { type, attrs, content: inline } : { type, attrs };
+}
+function parseXmlFragment(xml, opts = {}) {
+  const g = globalThis;
+  const Parser = opts.DOMParser ?? g.DOMParser;
+  if (!Parser) {
+    throw new Error(
+      "没有可用的 XML 解析器：浏览器外请通过 opts.DOMParser 注入（如 @xmldom/xmldom）"
+    );
+  }
+  let doc;
+  try {
+    doc = new Parser().parseFromString(`<root>${xml}</root>`, "text/xml");
+  } catch (e) {
+    throw new Error(`XML 解析失败：${String(e.message ?? e).slice(0, 200)}`);
+  }
+  const err = doc.getElementsByTagName("parsererror")[0];
+  if (err) throw new Error(`XML 解析失败：${err.textContent?.slice(0, 200)}`);
+  const root = doc.documentElement;
+  if (!root) throw new Error("XML 解析失败：没有根元素");
+  return childElements(root).map(xmlElToPm);
+}
+function mergeParsedNode(originalAttrs, parsed) {
+  const incoming = Object.fromEntries(
+    Object.entries(parsed.attrs ?? {}).filter(([, v]) => v !== null && v !== void 0)
+  );
+  return { ...parsed, attrs: { ...originalAttrs, ...incoming } };
+}
+
+// src/doc-runtime/operations.ts
+function findById(editor, id) {
+  let hit = null;
+  editor.state.doc.descendants((node, pos) => {
+    if (hit) return false;
+    if (node.attrs?.id === id) {
+      hit = { node, pos };
+      return false;
+    }
+    return true;
+  });
+  return hit;
+}
+function findCell(editor, tableId, row, col) {
+  const t = findById(editor, tableId);
+  if (!t) throw new Error(`找不到表格 id="${tableId}"`);
+  if (t.node.type.name !== "table")
+    throw new Error(`id="${tableId}" 不是表格，是 ${t.node.type.name}`);
+  if (row < 0 || row >= t.node.childCount)
+    throw new Error(`表格只有 ${t.node.childCount} 行，取不到第 ${row} 行（0-based）`);
+  const rowNode = t.node.child(row);
+  if (col < 0 || col >= rowNode.childCount)
+    throw new Error(`第 ${row} 行只有 ${rowNode.childCount} 列，取不到第 ${col} 列（0-based）`);
+  const cellNode = rowNode.child(col);
+  let pos = t.pos + 1;
+  for (let r = 0; r < row; r++) pos += t.node.child(r).nodeSize;
+  pos += 1;
+  for (let c = 0; c < col; c++) pos += rowNode.child(c).nodeSize;
+  return { node: cellNode, pos, table: t };
+}
+function textOffsetMap(node, pos) {
+  const segs = [];
+  let textOffset = 0;
+  node.descendants((child, childPos) => {
+    if (child.isText) {
+      const len = child.text?.length ?? 0;
+      segs.push({ textStart: textOffset, from: pos + 1 + childPos, len });
+      textOffset += len;
+    }
+    return true;
+  });
+  return {
+    start(offset) {
+      for (const s of segs) {
+        if (offset < s.textStart + s.len) return s.from + (offset - s.textStart);
+      }
+      const last = segs[segs.length - 1];
+      return last ? last.from + last.len : pos + 1;
+    },
+    end(offset) {
+      for (const s of segs) {
+        if (offset <= s.textStart + s.len) return s.from + (offset - s.textStart);
+      }
+      return pos + 1 + node.content.size;
+    }
+  };
+}
+function applyOperations(editor, operations, parseOpts = {}) {
+  const results = [];
+  const touchedIds = [];
+  for (const op of operations) {
+    try {
+      if (op.action === "remove") {
+        const hit = findById(editor, op.id);
+        if (!hit) throw new Error(`找不到 id="${op.id}"`);
+        editor.chain().command(({ tr }) => {
+          tr.delete(hit.pos, hit.pos + hit.node.nodeSize);
+          return true;
+        }).run();
+        results.push({ action: "remove", success: true, id: op.id });
+        continue;
+      }
+      if (op.action === "insert") {
+        const anchorId = op.afterId ?? op.beforeId;
+        if (!anchorId) throw new Error("insert 必须给 afterId 或 beforeId");
+        const hit = findById(editor, anchorId);
+        if (!hit) throw new Error(`找不到锚点 id="${anchorId}"`);
+        const nodes = parseXmlFragment(op.litexml, parseOpts);
+        const at = op.afterId ? hit.pos + hit.node.nodeSize : hit.pos;
+        editor.chain().insertContentAt(at, nodes).run();
+        results.push({ action: "insert", success: true, anchor: anchorId, count: nodes.length });
+        continue;
+      }
+      if (op.action === "modify") {
+        const xmls = Array.isArray(op.litexml) ? op.litexml : [op.litexml];
+        const modifiedIds = [];
+        for (const xml of xmls) {
+          for (const parsed of parseXmlFragment(xml, parseOpts)) {
+            const id = parsed.attrs?.id;
+            if (!id) throw new Error("modify 的 litexml 必须带 id 属性");
+            const hit = findById(editor, id);
+            if (!hit) throw new Error(`找不到 id="${id}"`);
+            editor.chain().command(({ tr, state }) => {
+              const merged = mergeParsedNode(hit.node.attrs, parsed);
+              tr.replaceWith(
+                hit.pos,
+                hit.pos + hit.node.nodeSize,
+                state.schema.nodeFromJSON(merged)
+              );
+              return true;
+            }).run();
+            modifiedIds.push(id);
+            touchedIds.push(id);
+          }
+        }
+        results.push({ action: "modify", success: true, count: xmls.length, modifiedIds });
+        continue;
+      }
+      throw new Error(`未知 action: ${op.action}`);
+    } catch (e) {
+      results.push({
+        action: op.action,
+        success: false,
+        error: String(e.message ?? e)
+      });
+    }
+  }
+  return {
+    results,
+    successCount: results.filter((r) => r.success).length,
+    totalCount: results.length,
+    touchedIds
+  };
+}
+function replaceText(editor, { searchText, newText, nodeIds, replaceAll = false }) {
+  if (!searchText) throw new Error("searchText 不能为空");
+  const targets = [];
+  editor.state.doc.descendants((node, pos) => {
+    if (!node.isTextblock) return true;
+    if (nodeIds?.length && !nodeIds.includes(node.attrs?.id)) return true;
+    targets.push({ node, pos, id: node.attrs?.id });
+    return true;
+  });
+  const replaceInBlock = (t) => {
+    const text = t.node.textContent;
+    const offsets = [];
+    let i = text.indexOf(searchText);
+    while (i !== -1) {
+      offsets.push(i);
+      if (!replaceAll) break;
+      i = text.indexOf(searchText, i + searchText.length);
+    }
+    if (!offsets.length) return 0;
+    const map = textOffsetMap(t.node, t.pos);
+    for (const off of offsets.reverse()) {
+      const from = map.start(off);
+      const to = map.end(off + searchText.length);
+      editor.chain().command(({ tr }) => {
+        tr.insertText(newText, from, to);
+        return true;
+      }).run();
+    }
+    return offsets.length;
+  };
+  if (!replaceAll) {
+    const first = targets.find((t) => t.node.textContent.includes(searchText));
+    if (!first) return { replacementCount: 0, modifiedNodeIds: [] };
+    const n = replaceInBlock(first);
+    return { replacementCount: n, modifiedNodeIds: first.id ? [first.id] : [] };
+  }
+  const modified = [];
+  let count = 0;
+  for (const t of [...targets].reverse()) {
+    if (!t.node.textContent.includes(searchText)) continue;
+    count += replaceInBlock(t);
+    if (t.id) modified.push(t.id);
+  }
+  modified.reverse();
+  return { replacementCount: count, modifiedNodeIds: modified };
+}
+function formatText(editor, { nodeId, searchText, marks, remove = false, occurrence = 1 }) {
+  const bad = (marks ?? []).filter((m) => !FORMATTABLE.includes(m));
+  if (bad.length) throw new Error(`不支持的标记 ${bad.join(",")}；可用：${FORMATTABLE.join(" / ")}`);
+  const hit = findById(editor, nodeId);
+  if (!hit) throw new Error(`找不到 id="${nodeId}"`);
+  const text = hit.node.textContent;
+  let idx = -1;
+  for (let n = 0; n < occurrence; n++) {
+    idx = text.indexOf(searchText, idx + 1);
+    if (idx === -1) break;
+  }
+  if (idx === -1)
+    throw new Error(
+      `块 ${nodeId} 里找不到第 ${occurrence} 处 "${searchText}"（内容：${text.slice(0, 80)}）`
+    );
+  const map = textOffsetMap(hit.node, hit.pos);
+  const from = map.start(idx);
+  const to = map.end(idx + searchText.length);
+  let chain = editor.chain().setTextSelection({ from, to });
+  for (const m of marks) chain = remove ? chain.unsetMark(m) : chain.setMark(m);
+  chain.run();
+  return { nodeId, marks, removed: remove, matched: searchText };
+}
+var TABLE_COMMANDS = {
+  insert_row_after: "addRowAfter",
+  insert_row_before: "addRowBefore",
+  insert_col_after: "addColumnAfter",
+  insert_col_before: "addColumnBefore",
+  delete_row: "deleteRow",
+  delete_col: "deleteColumn",
+  toggle_header_row: "toggleHeaderRow",
+  merge_cells: "mergeCells",
+  split_cell: "splitCell"
+};
+function tableEdit(editor, { tableId, action, row, col, values }) {
+  const t = findById(editor, tableId);
+  if (!t) throw new Error(`找不到表格 id="${tableId}"`);
+  if (action === "set_cells") {
+    if (!Array.isArray(values)) throw new Error("set_cells 需要 values: [{row, col, text}]");
+    const sorted = [...values].sort((a, b) => b.row - a.row || b.col - a.col);
+    for (const v of sorted) {
+      const cell2 = findCell(editor, tableId, v.row, v.col);
+      const para = cell2.node.firstChild;
+      const from = cell2.pos + 1 + 1;
+      const to = from + (para ? para.content.size : 0);
+      editor.chain().command(({ tr }) => {
+        tr.insertText(String(v.text), from, to);
+        return true;
+      }).run();
+    }
+    return { tableId, updated: values.length };
+  }
+  if (row == null || col == null) {
+    throw new Error(
+      `${action} 必须显式指定 row 和 col（0-based，表头是第 0 行）作为锚点单元格。该表格共 ${t.node.childCount} 行。例如要在最后一行后面加一行：row=${t.node.childCount - 1}, col=0`
+    );
+  }
+  const cmd = TABLE_COMMANDS[action];
+  if (!cmd)
+    throw new Error(
+      `未知 action: ${action}；可用 ${Object.keys(TABLE_COMMANDS).join(" / ")} / set_cells`
+    );
+  const cell = findCell(editor, tableId, row, col);
+  editor.chain().setTextSelection(cell.pos + 2).run();
+  const chain = editor.chain().focus();
+  const ok = chain[cmd]().run();
+  return { tableId, action, ok };
+}
+function findTextInDoc(editor, query, limit = 20) {
+  if (!query) throw new Error("query 不能为空");
+  const hits = [];
+  editor.state.doc.descendants((node) => {
+    if (hits.length >= limit) return false;
+    if (!node.isTextblock) return true;
+    const text = node.textContent;
+    let i = text.indexOf(query);
+    while (i !== -1 && hits.length < limit) {
+      hits.push({
+        nodeId: node.attrs?.id ?? null,
+        nodeType: node.type.name,
+        contextBefore: text.slice(Math.max(0, i - 30), i),
+        match: query,
+        contextAfter: text.slice(i + query.length, i + query.length + 30)
+      });
+      i = text.indexOf(query, i + query.length);
+    }
+    return true;
+  });
+  return { hits, total: hits.length };
+}
+function getSelection(editor) {
+  const { from, to, empty } = editor.state.selection;
+  if (empty) return { selection: null, note: "本轮无选区，不要从历史推断" };
+  const blocks = [];
+  editor.state.doc.nodesBetween(from, to, (node) => {
+    if (node.attrs?.id) blocks.push({ id: node.attrs.id, type: node.type.name });
+    return true;
+  });
+  return { selection: { text: editor.state.doc.textBetween(from, to, "\n"), blocks } };
+}
+function docSchema(editor) {
+  const idTypes = editor.extensionManager.extensions.find((e) => e.name === "uniqueID")?.options?.types ?? [];
+  return {
+    nodeTypes: Object.keys(editor.schema.nodes),
+    markTypes: Object.keys(editor.schema.marks),
+    litexmlTags: NODE_TAG,
+    readonlyTags: [...READONLY_TAGS],
+    idBearingTypes: idTypes,
+    note: "只有 idBearingTypes 里的节点带稳定 id，可被直接寻址。表格单元格的结构性改动用 doc_table_edit 的 (tableId,row,col) 定位。"
+  };
+}
+function docStats(editor) {
+  const nodes = {};
+  const marks = {};
+  const headings = {};
+  let textLength = 0;
+  editor.state.doc.descendants((n) => {
+    nodes[n.type.name] = (nodes[n.type.name] ?? 0) + 1;
+    if (n.type.name === "heading") {
+      const l = `h${n.attrs.level}`;
+      headings[l] = (headings[l] ?? 0) + 1;
+    }
+    if (n.isText) {
+      textLength += n.text?.length ?? 0;
+      for (const m of n.marks) marks[m.type.name] = (marks[m.type.name] ?? 0) + 1;
+    }
+    return true;
+  });
+  return { nodes, marks, headings, textLength, topLevelBlocks: editor.state.doc.childCount };
+}
+
+// src/doc-runtime/runtime.ts
+function base64ToBytes(b64) {
+  const bin = atob(b64.replace(/^data:[^,]*,/, ""));
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function sanitizeFilename(name) {
+  if (!name) return null;
+  const base = name.split(/[/\\]/).pop()?.trim();
+  if (!base || base === "." || base === "..") return null;
+  return /\.docx$/i.test(base) ? base : `${base}.docx`;
+}
+function domFlash(id) {
+  if (typeof document === "undefined") return;
+  requestAnimationFrame(() => {
+    const sel = typeof CSS !== "undefined" && CSS.escape ? CSS.escape(id) : id;
+    const el = document.querySelector(`[data-id="${sel}"], #${sel}`);
+    if (!el) return;
+    el.classList.add("ai-flash");
+    setTimeout(() => el.classList.remove("ai-flash"), 1400);
+  });
+}
+var DocRuntime = class {
+  editor;
+  highlight;
+  parseOpts;
+  constructor(options = {}) {
+    this.editor = options.editor ?? null;
+    this.highlight = options.highlight === false ? null : options.highlight ?? domFlash;
+    this.parseOpts = options.DOMParser ? { DOMParser: options.DOMParser } : {};
+  }
+  /** 编辑器实例就绪 / 卸载时调用。配合 `<NotionEditor onEditorReady>` 用。 */
+  setEditor(editor) {
+    this.editor = editor;
+  }
+  isReady() {
+    return Boolean(this.editor && !this.editor.isDestroyed);
+  }
+  use() {
+    if (!this.editor) throw new Error("编辑器尚未就绪：先调 setEditor(editor)");
+    if (this.editor.isDestroyed) throw new Error("编辑器实例已销毁");
+    return this.editor;
+  }
+  flash(ids) {
+    if (!this.highlight) return;
+    for (const id of ids) this.highlight(id);
+  }
+  /* ------------------------------ 读 ------------------------------ */
+  /** 读全文。要编辑之前必须先调它拿 id。 */
+  getPageContent({ format = "xml" } = {}) {
+    const editor = this.use();
+    const out = {
+      blockCount: editor.state.doc.childCount
+    };
+    if (format === "xml" || format === "both") out.xml = docToXml(editor.getJSON());
+    if (format === "json" || format === "both") out.json = editor.getJSON();
+    return out;
+  }
+  /** 运行时反射出的节点·标记·标签映射·哪些类型带 id。永不与实现漂移。 */
+  getSchema() {
+    return docSchema(this.use());
+  }
+  /** 按节点类型点数，用来和导入源做对账。 */
+  getStats() {
+    return docStats(this.use());
+  }
+  /** 检索，返回可直接回填给写工具的 nodeId。 */
+  find(args) {
+    return findTextInDoc(this.use(), args.query, args.limit);
+  }
+  /** 用户此刻的选区；无选区时显式声明「不要沿用历史」。 */
+  getSelection() {
+    return getSelection(this.use());
+  }
+  /* ------------------------------ 写 ------------------------------ */
+  /** 块内文本替换（细粒度改动首选）。 */
+  replaceText(args) {
+    const result = replaceText(this.use(), args);
+    this.flash(result.modifiedNodeIds);
+    return result;
+  }
+  /** 对某段文字加/去 bold·italic·underline·strike·code·sup·sub（改格式首选）。 */
+  formatText(args) {
+    const result = formatText(this.use(), args);
+    this.flash([result.nodeId]);
+    return result;
+  }
+  /** 结构化 insert / remove / modify，一次提交多个操作。 */
+  modifyNodes(args) {
+    const result = applyOperations(this.use(), args.operations ?? [], this.parseOpts);
+    this.flash(result.touchedIds);
+    return result;
+  }
+  /** 表格：增删行列、合并拆分、批量写值。 */
+  tableEdit(args) {
+    const result = tableEdit(this.use(), args);
+    this.flash([args.tableId]);
+    return result;
+  }
+  /* ---------------------------- 导入 / 导出 ---------------------------- */
+  /**
+   * 导出成 .docx，返回 base64。
+   *
+   * 走 `editor.commands.exportDocx` 而不是直接调 `serializeDocx`：页眉页脚的原始
+   * 部件存在 `editor.storage.importDocx.section` 上，表格列宽的换算基准要量
+   * `editor.view.dom` —— 这两样只有命令那条路会自动接上，绕过去就会丢页眉、
+   * 并且把表格导得超出页面。
+   *
+   * base64 是**给传输层的**，不是给模型看的。hub 收到后落盘、只把路径回给模型；
+   * 一份带图的 docx 几 MB，塞进上下文会直接把窗口撑爆。
+   */
+  exportDocx(args = {}) {
+    const editor = this.use();
+    const run = editor.commands.exportDocx;
+    if (typeof run !== "function") {
+      throw new Error(
+        "编辑器没装 ExportDocx 扩展：从 @4399ywkf/editor/docx 引入 ExportDocx，通过 <NotionEditor extensions={[ExportDocx]}> 注册后再试"
+      );
+    }
+    let payload = null;
+    run({
+      exportType: "string",
+      // base64
+      onCompleteExport: (result, meta2) => {
+        payload = { base64: String(result), meta: meta2 };
+      }
+    });
+    if (!payload) throw new Error("导出失败：exportDocx 没有回调（多半是序列化时抛了异常）");
+    const { base64, meta } = payload;
+    return {
+      filename: sanitizeFilename(args.filename) ?? "document.docx",
+      base64,
+      bytes: meta?.bytes ?? 0,
+      stats: meta?.stats ?? {},
+      warnings: meta?.warnings ?? []
+    };
+  }
+  /**
+   * 把一份 .docx 灌进编辑器，**整篇替换**当前内容。
+   *
+   * 同样走命令：`ImportDocx` 会按宿主 schema 降级未知节点、量版心换算表格列宽、
+   * 把页眉页脚记进 storage 供导出时写回。
+   */
+  importDocx(args) {
+    const editor = this.use();
+    const run = editor.commands.importDocx;
+    if (typeof run !== "function") {
+      throw new Error(
+        "编辑器没装 ImportDocx 扩展：从 @4399ywkf/editor/docx 引入 ImportDocx，通过 <NotionEditor extensions={[ImportDocx]}> 注册后再试"
+      );
+    }
+    if (!args?.base64) throw new Error("importDocx 需要 base64（hub 会把 path 读成 base64 再转发）");
+    return new Promise((resolve, reject) => {
+      run({
+        file: base64ToBytes(args.base64),
+        onImport: (ctx) => {
+          if (ctx.error) {
+            reject(ctx.error);
+            return;
+          }
+          ctx.setEditorContent();
+          resolve({
+            blockCount: this.editor?.state.doc.childCount ?? 0,
+            recovered: ctx.recovered ?? {},
+            warnings: ctx.warnings ?? []
+          });
+        }
+      });
+    });
+  }
+  /* ---------------------------- 统一入口 ---------------------------- */
+  /**
+   * 工具名 → 方法。给传输层（MCP 桥、agent executor）用的单一分发口，
+   * 这样加一个工具只需要改这里，不需要每个传输各写一遍 switch。
+   */
+  async call(tool, args = {}) {
+    switch (tool) {
+      case "doc_read":
+        return this.getPageContent(args);
+      case "doc_schema":
+        return this.getSchema();
+      case "doc_stats":
+        return this.getStats();
+      case "doc_find":
+        return this.find(args);
+      case "doc_get_selection":
+        return this.getSelection();
+      case "doc_replace_text":
+        return this.replaceText(args);
+      case "doc_format_text":
+        return this.formatText(args);
+      case "doc_modify_nodes":
+        return this.modifyNodes(args);
+      case "doc_table_edit":
+        return this.tableEdit(args);
+      case "doc_export_docx":
+        return this.exportDocx(args);
+      case "doc_import_docx":
+        return this.importDocx(args);
+      default:
+        throw new Error(`未知工具 ${tool}`);
+    }
+  }
+};
+
+export { DocRuntime, FORMATTABLE, MARK_TAG, NODE_TAG, READONLY_TAGS, VOID_TAGS, applyOperations, docSchema, docStats, docToXml, findById, findTextInDoc, formatText, getSelection, mergeParsedNode, nodeToXml, parseXmlFragment, replaceText, tableEdit, xmlElToPm };
+//# sourceMappingURL=doc-runtime.js.map
+//# sourceMappingURL=doc-runtime.js.map