@spacecorexdev/core 0.0.4 → 0.0.5

package/src/ui/UIFilePreview/WordEditor/style.ts

@@ -0,0 +1,1213 @@
+import { Document, Style } from "@eigenpal/docx-editor-core";
+import { createEmptyDocument } from "@eigenpal/docx-editor-react";
+
+const W_NS = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+
+// 自定义字体列表 - 显示在字体下拉菜单中
+// 注意：@eigenpal/docx-editor-core 的 buildFontString 只使用 fontFamily 中的首个字体名，
+// 然后根据 category 自动追加系统级的回退字体栈。因此 fontFamily 的第一个名字必须是
+// macOS/Windows 都可识别的系统字体名（如 STFangsong），而不是仅限 Windows 的名字（如 FangSong）。
+export const CUSTOM_FONT_FAMILIES = [
+  // 中文字体
+  { name: '宋体', fontFamily: 'STSong', category: 'serif' as const },
+  { name: '黑体', fontFamily: 'STHeiti', category: 'sans-serif' as const },
+  { name: '微软雅黑', fontFamily: '"Microsoft YaHei"', category: 'sans-serif' as const },
+  { name: '楷体', fontFamily: 'STKaiti', category: 'serif' as const },
+  { name: '仿宋', fontFamily: 'STFangsong', category: 'serif' as const },
+  { name: '华文宋体', fontFamily: 'STSong', category: 'serif' as const },
+  { name: '华文黑体', fontFamily: 'STHeiti', category: 'sans-serif' as const },
+  { name: '华文楷体', fontFamily: 'STKaiti', category: 'serif' as const },
+  { name: '华文仿宋', fontFamily: 'STFangsong', category: 'serif' as const },
+  // 英文字体
+  { name: 'Arial', fontFamily: 'Arial', category: 'sans-serif' as const },
+  { name: 'Times New Roman', fontFamily: '"Times New Roman"', category: 'serif' as const },
+  { name: 'Courier New', fontFamily: '"Courier New"', category: 'monospace' as const },
+  { name: 'Georgia', fontFamily: 'Georgia', category: 'serif' as const },
+  { name: 'Verdana', fontFamily: 'Verdana', category: 'sans-serif' as const },
+  { name: 'Tahoma', fontFamily: 'Tahoma', category: 'sans-serif' as const },
+  { name: 'Helvetica', fontFamily: 'Helvetica', category: 'sans-serif' as const },
+];
+
+// 预设样式定义
+export const PRESET_STYLES: Style[] = [
+  // 正文样式（默认）
+  {
+    styleId: 'Normal',
+    type: 'paragraph',
+    name: '正文',
+    default: true,
+    qFormat: true,
+    rPr: {
+      fontSize: 30, // 15pt
+      bold: false,
+      fontFamily: { ascii: 'STFangsong', hAnsi: 'STFangsong', eastAsia: 'STFangsong' },
+    },
+    pPr: {
+      lineSpacing: 360,
+      lineSpacingRule: 'auto',
+    },
+  },
+  // 标题 1
+  {
+    styleId: 'Heading1',
+    type: 'paragraph',
+    name: '标题 1',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 9,
+    pPr: {
+      lineSpacing: 320,
+      lineSpacingRule: 'exact',
+      spaceBefore: 320,
+      spaceAfter: 320,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      outlineLevel: 1,
+    },
+    rPr: {
+      fontSize: 32, // 16pt
+      bold: true,
+      fontFamily: { ascii: 'STHeiti', hAnsi: 'STHeiti', eastAsia: 'STHeiti' },
+    },
+  },
+  // 标题 2
+  {
+    styleId: 'Heading2',
+    type: 'paragraph',
+    name: '标题 2',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 9,
+    pPr: {
+      lineSpacing: 450,
+      lineSpacingRule: 'exact',
+      spaceBefore: 150,
+      spaceAfter: 150,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      outlineLevel: 2,
+    },
+    rPr: {
+      fontSize: 30, // 15pt
+      bold: true,
+      fontFamily: { ascii: 'STKaiti', hAnsi: 'STKaiti', eastAsia: 'STKaiti' },
+    },
+  },
+  // 标题 3
+  {
+    styleId: 'Heading3',
+    type: 'paragraph',
+    name: '标题 3',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 9,
+    pPr: {
+      lineSpacing: 450,
+      lineSpacingRule: 'exact',
+      spaceBefore: 150,
+      spaceAfter: 120,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      outlineLevel: 3,
+    },
+    rPr: {
+      fontSize: 30, // 15pt
+      bold: true,
+      fontFamily: { ascii: 'STFangsong', hAnsi: 'STFangsong', eastAsia: 'STFangsong' },
+    },
+  },
+  // 标题 4
+  {
+    styleId: 'Heading4',
+    type: 'paragraph',
+    name: '标题 4',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 9,
+    pPr: {
+      lineSpacing: 450,
+      lineSpacingRule: 'exact',
+      spaceBefore: 150,
+      spaceAfter: 100,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      outlineLevel: 4,
+    },
+    rPr: {
+      fontSize: 30, // 15pt
+      bold: true,
+      fontFamily: { ascii: 'STKaiti', hAnsi: 'STKaiti', eastAsia: 'STKaiti' },
+    },
+  },
+  // 标题
+  {
+    styleId: 'Title',
+    type: 'paragraph',
+    name: '标题',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 10,
+    pPr: {
+      spaceBefore: 240,
+      spaceAfter: 240,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      alignment: 'center',
+    },
+    rPr: {
+      fontSize: 44, // 22pt
+      bold: true,
+      fontFamily: { ascii: 'STHeiti', hAnsi: 'STHeiti', eastAsia: 'STHeiti' },
+    },
+  },
+  // 副标题
+  {
+    styleId: 'Subtitle',
+    type: 'paragraph',
+    name: '副标题',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 11,
+    pPr: {
+      spaceBefore: 200,
+      spaceAfter: 200,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      alignment: 'center',
+    },
+    rPr: {
+      fontSize: 32, // 16pt
+      color: { rgb: '666666' },
+      fontFamily: { ascii: 'STKaiti', hAnsi: 'STKaiti', eastAsia: 'STKaiti' },
+    },
+  },
+  // 引用
+  {
+    styleId: 'Quote',
+    type: 'paragraph',
+    name: '引用',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 29,
+    pPr: {
+      spaceBefore: 200,
+      spaceAfter: 200,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      indentLeft: 720, // 0.5 inch
+    },
+    rPr: {
+      fontSize: 22, // 11pt
+      italic: true,
+      color: { rgb: '404040' },
+      fontFamily: { ascii: 'STKaiti', hAnsi: 'STKaiti', eastAsia: 'STKaiti' },
+    },
+  },
+  // 强调
+  {
+    styleId: 'IntenseQuote',
+    type: 'paragraph',
+    name: '强调引用',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 30,
+    pPr: {
+      spaceBefore: 200,
+      spaceAfter: 200,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      indentLeft: 720,
+    },
+    rPr: {
+      fontSize: 22,
+      italic: true,
+      bold: true,
+      color: { rgb: '000080' },
+      fontFamily: { ascii: 'STKaiti', hAnsi: 'STKaiti', eastAsia: 'STKaiti' },
+    },
+  },
+  // 红头（党政机关公文红头标题：方正小标宋/居中/砖红色大字号）
+  {
+    styleId: 'HongTou',
+    type: 'paragraph',
+    name: '红头',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 8,
+    pPr: {
+      alignment: 'center',
+      lineSpacing: 360,
+      lineSpacingRule: 'auto',
+      spaceBefore: 240,
+      spaceAfter: 200,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+    },
+    rPr: {
+      // 68 half-point = 34pt ≈ 45px：比普通「标题」样式（44=22pt≈29px）更大，
+      // 符合截图里红头占据页面最醒目位置的视觉比例。
+      fontSize: 68,
+      // 小标宋本身是设计好的显示字体，但在缺失方正小标宋/华文中宋的系统上，
+      // 回退到的宋体系列需要加粗才能撑住红头的厚重感，所以统一 bold=true。
+      bold: true,
+      // 贴近截图中国网文件头的橘红/砖红
+      color: { rgb: 'FF0000' },
+      fontFamily: {
+        ascii: 'Times New Roman',
+        hAnsi: 'Times New Roman',
+        // 主字体：方正小标宋（FZXiaoBiaoSong-B05）— 党政机关红头文件标准字体
+        // 回退：华文中宋 STZhongsong → 宋体 STSong → 仿宋 STFangsong（兜底显示）
+        eastAsia: 'FZXiaoBiaoSong-B05',
+      },
+    },
+  },
+  // 红头分隔线（文号下面那条红色单实线底边，公文字体居中，带合适段间距）
+  {
+    styleId: 'HongTouSeparator',
+    type: 'paragraph',
+    name: '红头分隔线',
+    basedOn: 'Normal',
+    next: 'Normal',
+    qFormat: true,
+    uiPriority: 8, // 和红头排在一起
+    pPr: {
+      alignment: 'center', // 文号如「专纪〔2025〕8号」都是居中
+      lineSpacing: 360,
+      lineSpacingRule: 'auto',
+      // 段前适中：红头 (spaceAfter 200 ≈ 10pt) 与文号之间不要太挤
+      spaceBefore: 160,
+      // 段后适中：文号分隔线与正文日期段落之间保持一点呼吸感
+      spaceAfter: 240,
+      beforeAutospacing: false,
+      afterAutospacing: false,
+      spacingExplicit: { before: true, after: true },
+      // 段落底边框 = 红头下面的红色分隔线
+      // 对应 Word 里的 <w:pBdr><w:top w:val="none"/><w:left w:val="none"/><w:right w:val="none"/>
+      //                  <w:bottom w:val="single" w:sz="12" w:space="1" w:color="FF0000"/></w:pBdr>
+      //
+      // 注意：必须显式把 top / left / right 标为 'none'。
+      // 原因：@eigenpal/docx-editor-core 在把 paragraph.attrs.borders 转成 CSS border-* 时，
+      // 如果其他三边是 undefined，它的 fallback 逻辑会复制已有边（bottom）的值上去，
+      // 导致明明只想要「底横线」结果画出「四边框」（用户截图里文字周围一圈红框就是这个 bug）。
+      // 写死 style: 'none' 就一定不会画，从根上断掉 fallback。
+      borders: {
+        // —— WPS 兼容加固：top/left/right 三边不仅写 style:'none'，
+        //    还要显式补 sz:0 + color:auto。
+        //    OOXML 标准下写 <w:top w:val="nil" w:sz="0" w:color="auto"/> 最稳，
+        //    WPS 部分老版本在 style.xml 里读到仅 <w:top w:val="none"/> 时
+        //    会"退化成 fallback"（把 bottom 的属性复制到其他三边），
+        //    导致出现一圈红框。这里 4 边信息齐全，彻底堵死 fallback。
+        top: { style: 'none' as const, size: 0, color: { rgb: 'auto' as any } },
+        left: { style: 'none' as const, size: 0, color: { rgb: 'auto' as any } },
+        right: { style: 'none' as const, size: 0, color: { rgb: 'auto' as any } },
+        bottom: {
+          style: 'single', // 单实线，公文分隔线最标准样式
+          // size 单位是 1/8 pt：12 / 8 = 1.5pt，和国标公文常用横线厚度一致
+          // （0.75pt 太细打印不显，2pt 太粗，1.5pt 是最常用的折中值）
+          size: 12,
+          // space = 1pt：线与文字之间留 1pt 间距，不会贴在文字底下
+          space: 1,
+          color: { rgb: 'FF0000' }, // 与红头同色，保持统一的红头视觉语言
+        },
+      },
+    },
+    rPr: {
+      // 文号字号和正文保持一致：30 half-point = 15pt ≈ 20px
+      fontSize: 30,
+      bold: false, // 文号不用加粗（和截图里「专纪〔2025〕8号」一致）
+      // 公文字体：正文仿宋 GB2312 / STFangsong，和默认「正文」样式一致
+      fontFamily: { ascii: 'STFangsong', hAnsi: 'STFangsong', eastAsia: 'STFangsong' },
+      color: { rgb: '000000' }, // 文号是黑色，只有底边框是红色
+    },
+  },
+];
+
+// 创建带有预设样式的空文档
+export function createDocumentWithStyles(): Document {
+  const doc = createEmptyDocument();
+
+  // 使用与 applyPresetStylesToDocument 相同的合并策略（按 styleId + name 去重），
+  // 避免 createEmptyDocument() 自带的默认样式与预设样式重复
+  applyPresetStylesToDocument(doc);
+
+  return doc;
+}
+
+/**
+ * 将预设样式应用到已解析的文档中。
+ * 合并策略：
+ * 1. 从现有样式中删除所有与任一预设"名称相同（规范化后）"或"styleId 相同"的冲突样式
+ *    （同时解决原文档 styleId=1/name=标题1 与 styleId=Heading1/name=Heading1 两套共存的重复问题）
+ * 2. 在样式列表末尾统一追加一份完整的预设样式集合
+ * 这样可以确保我们的预设样式（如仿宋正文、黑体标题等）始终作为可用样式存在，且无重复。
+ */
+export function applyPresetStylesToDocument(doc: Document): Document {
+  if (!doc.package) return doc;
+
+  const existingStyles = doc.package.styles?.styles || [];
+
+  const presetStyleIds = new Set(PRESET_STYLES.map(p => p.styleId));
+  const presetNormalizedNames = new Set(
+    PRESET_STYLES.filter(p => p.name).map(p => normalizeStyleName(p.name!)),
+  );
+
+  // 第一步：过滤掉与预设冲突的现有样式（按 name 或 styleId 任一匹配即视为冲突）
+  const keptStyles = existingStyles.filter(s => {
+    const hitByName = s.name && presetNormalizedNames.has(normalizeStyleName(s.name));
+    const hitById = presetStyleIds.has(s.styleId);
+    return !(hitByName || hitById);
+  });
+
+  // 第二步：在末尾统一追加所有预设样式
+  const finalStyles = [...keptStyles, ...PRESET_STYLES];
+
+  doc.package.styles = {
+    docDefaults: doc.package.styles?.docDefaults,
+    styles: finalStyles,
+  };
+
+  return doc;
+}
+
+// ============================================================================
+// 文档网格（w:docGrid）行距对齐
+//
+// @eigenpal/docx-editor-core 的布局引擎（dist/chunk-LNHPDJCA.js 的 Ue/Ze）虽然会
+// 解析 docGrid，但从不消费它：段落没有显式行距时，行高 = 字号 × 字体 singleLineRatio
+// （simsun=1.15），导致带 <w:docGrid w:type="lines" w:linePitch="312"/> 的
+// 中文公文在编辑器里行距（~26pt@小四）明显小于 WPS（2 格网格 = 31.2pt）。
+//
+// Word/WPS 的真实规则：每行占整数个网格，units=ceil(字体自然行高 / linePitch)。
+// 宋体/新宋体/仿宋/楷体/黑体等传统中文字体 Word 行高度量(winAscent+winDescent)
+// ≈ 1.32em，12pt(小四)自然高 15.84pt > 15.6pt → 占 2 格=31.2pt；五号10.5pt 占 1 格。
+// 该规则与只读预览的渲染器补丁（scripts/patch-docx-grid.cjs）完全一致，两处必须同步演进。
+//
+// 做法：parseDocx 之后，对「无显式行距」的段落注入 atLeast 网格行距（数值单位 twips，
+// 与 OOXML <w:spacing w:line w:lineRule> 一致；编辑器布局层 atLeast 走 max(行距, 自然行高)，
+// 语义和 Word 网格一致——大字号/图片行仍可继续撑高）。已有显式行距的段落（exact/atLeast/倍数）
+// 一律不动；保存时编辑器会把 w:line/w:lineRule 原样序列化回 document.xml，Word/WPS 打开同样生效。
+// ============================================================================
+
+const DOC_GRID_CJK_FONT_RE = /simsun|nsimsun|fangsong|kaiti|simhei|microsoft yahei|dengxian|宋体|仿宋|楷体|黑体|雅黑|等线|mingliu|pmingliu|microsoft jhenghei/i;
+const DOC_GRID_CJK_FACTOR = 1.32;
+const DOC_GRID_OTHER_FACTOR = 1.2;
+// 缺省字号：五号半磅值 = 24（12pt）。
+const DOC_GRID_DEFAULT_HALF_FONT_SIZE = 24;
+
+interface DocGridFontFamily {
+  ascii?: string;
+  hAnsi?: string;
+  eastAsia?: string;
+  cs?: string;
+}
+interface DocGridTextFormatting {
+  fontSize?: number;
+  fontFamily?: DocGridFontFamily | null;
+}
+/** 段落 / run / 表格 / 单元格共用的结构外形（按需字段，不参与的节点缺省）。 */
+interface DocGridNode {
+  type?: string;
+  formatting?: DocGridTextFormatting & {
+    lineSpacing?: number;
+    lineSpacingRule?: string;
+    styleId?: string;
+    runProperties?: DocGridTextFormatting;
+  };
+  content?: DocGridNode[];
+  rows?: Array<{ cells?: Array<{ content?: DocGridNode[] }> }>;
+}
+
+type StyleChainResolver = (styleId?: string) => Style[];
+
+/** 收集段落内参与字号判定的全部半磅字号（run 内联 > 段落标记 rPr > 样式链 rPr > 缺省 12pt），取最大。 */
+function resolveParagraphHalfFontSize(p: DocGridNode, resolveStyleChain: StyleChainResolver): number {
+  let size = 0;
+  for (const run of p.content ?? []) {
+    if (run.type === 'run' && run.formatting?.fontSize) {
+      size = Math.max(size, run.formatting.fontSize);
+    }
+  }
+  size = Math.max(size, p.formatting?.runProperties?.fontSize ?? 0);
+  for (const style of resolveStyleChain(p.formatting?.styleId)) {
+    if (style.rPr?.fontSize) {
+      size = Math.max(size, style.rPr.fontSize);
+      break;
+    }
+  }
+  return size || DOC_GRID_DEFAULT_HALF_FONT_SIZE;
+}
+
+/** 收集段落涉及的字体名（run 内联 / 段落标记 rPr / 样式链 rPr 的 ascii/hAnsi/eastAsia/cs）。 */
+function collectParagraphFontFamilies(p: DocGridNode, resolveStyleChain: StyleChainResolver): string[] {
+  const names: Array<string | undefined> = [];
+  const pushFamily = (family?: DocGridFontFamily | null) => {
+    if (!family) return;
+    names.push(family.eastAsia, family.ascii, family.hAnsi, family.cs);
+  };
+  for (const run of p.content ?? []) {
+    if (run.type === 'run') pushFamily(run.formatting?.fontFamily);
+  }
+  pushFamily(p.formatting?.runProperties?.fontFamily);
+  for (const style of resolveStyleChain(p.formatting?.styleId)) {
+    pushFamily(style.rPr?.fontFamily as DocGridFontFamily | undefined);
+  }
+  return names.filter((n): n is string => typeof n === 'string' && n.length > 0);
+}
+
+/** 递归遍历段落 / 表格（含嵌套表格）/ SDT 等块级节点，对每个段落回调。 */
+function walkDocGridBlocks(nodes: DocGridNode[] | undefined, onParagraph: (p: DocGridNode) => void): void {
+  if (!Array.isArray(nodes)) return;
+  for (const node of nodes) {
+    if (!node || typeof node !== 'object') continue;
+    if (node.type === 'paragraph') onParagraph(node);
+    if (Array.isArray(node.content)) walkDocGridBlocks(node.content, onParagraph);
+    if (Array.isArray(node.rows)) {
+      for (const row of node.rows) {
+        if (Array.isArray(row?.cells)) {
+          for (const cell of row.cells) walkDocGridBlocks(cell.content, onParagraph);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 按节 docGrid 设置，为缺少显式行距的段落注入「整数格对齐」的 atLeast 行距。
+ * 必须在 parseDocx 之后、文档交给 <DocxEditor> 之前调用。幂等：已有显式行距的段落不动。
+ */
+export function applyDocGridLineSpacing(doc: Document): Document {
+  const documentModel = doc.package?.document as unknown as {
+    sections?: Array<{
+      properties?: { docGrid?: { type?: string; linePitch?: number } };
+      content?: DocGridNode[];
+      headers?: Map<unknown, { content?: DocGridNode[] }>;
+      footers?: Map<unknown, { content?: DocGridNode[] }>;
+    }>;
+  } | undefined;
+  const sections = documentModel?.sections;
+  if (!Array.isArray(sections)) return doc;
+
+  const styles: Style[] = doc.package?.styles?.styles ?? [];
+  const resolveStyleChain: StyleChainResolver = (styleId) => {
+    const chain: Style[] = [];
+    const seen = new Set<string>();
+    let current = styleId;
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const style = styles.find(s => s.styleId === current);
+      if (!style) break;
+      chain.push(style);
+      current = style.basedOn;
+    }
+    return chain;
+  };
+
+  for (const section of sections) {
+    const grid = section.properties?.docGrid;
+    const pitch = grid?.linePitch;
+    // type 为 lines / linesAndChars 时行网格才生效（default 是仅页边距网格、snapToChars 是字符网格）。
+    if (!pitch || (grid?.type !== 'lines' && grid?.type !== 'linesAndChars')) continue;
+
+    const applyToParagraph = (p: DocGridNode) => {
+      const formatting = p.formatting ?? (p.formatting = {});
+      // 已有显式行距（exact / atLeast / 倍数）一律保留，作者意图优先。
+      if (formatting.lineSpacing !== undefined && formatting.lineSpacing !== null) return;
+
+      const halfFontSize = resolveParagraphHalfFontSize(p, resolveStyleChain);
+      const fontNames = collectParagraphFontFamilies(p, resolveStyleChain);
+      const cjk = fontNames.some(name => DOC_GRID_CJK_FONT_RE.test(name));
+      const factor = cjk ? DOC_GRID_CJK_FACTOR : DOC_GRID_OTHER_FACTOR;
+      // 自然行高（twips）= 字号(pt) × 系数 × 20；字号(pt) = 半磅值 / 2
+      const naturalTwips = halfFontSize * factor * 10;
+      const units = Math.max(1, Math.ceil(naturalTwips / pitch - 1e-6));
+      formatting.lineSpacing = Math.round(units * pitch);
+      formatting.lineSpacingRule = 'atLeast';
+    };
+
+    walkDocGridBlocks(section.content, applyToParagraph);
+    for (const furnitureMap of [section.headers, section.footers]) {
+      if (furnitureMap instanceof Map) {
+        for (const furniture of furnitureMap.values()) {
+          walkDocGridBlocks(furniture?.content, applyToParagraph);
+        }
+      }
+    }
+  }
+
+  return doc;
+}
+
+// ============================================================================
+// 中日韩字体回写：让在线编辑与只读预览字体一致
+//
+// 根因：@eigenpal/docx-editor-core 在把 run 的 rFonts 转成 CSS 时只取
+// ascii/hAnsi（layout-bridge 的 toFlowBlocks、prosemirror 的 fontFamily mark
+// toDOM 都是 `ascii || hAnsi`），**完全忽略 w:eastAsia**；而只读预览器
+// (docx-preview) 走 eastAsianFontFamilyStack，优先用 eastAsia。
+// 中文文档普遍是 ascii/hAnsi=Calibri/Times New Roman + eastAsia=宋体，
+// 于是预览是宋体、编辑器却回退成系统无衬线字体（macOS 上是苹方）。
+//
+// 修复：parseDocx 之后，把 eastAsia 是中日韩字体的 fontFamily 的
+// ascii/hAnsi 也指向同一个字体，使编辑器解析出的字体栈与预览一致
+// （预览本来就优先 eastAsia，因此这不会让编辑器「多」出预览没有的效果）。
+// 必须在 setInitialDocument / 交给 <DocxEditor> 之前调用；幂等。
+// ============================================================================
+
+const CJK_EAST_ASIA_FONT_RE =
+  /simsun|nsimsun|songti|宋体|宋體|fangsong|仿宋|kaiti|楷体|楷體|simhei|黑体|黑體|heiti|yahei|雅黑|dengxian|等线|等線|mingliu|pmingliu|細明體|细明体|microsoft jhenghei|微軟正黑體|微软正黑体|stsong|stheiti|stkaiti|stfangsong|stzhongsong|华文|方正|fangzheng/i;
+
+function applyCjkEastAsiaFont(family?: DocGridFontFamily | null): void {
+  if (!family) return;
+  const eastAsia = family.eastAsia?.trim();
+  if (!eastAsia || !CJK_EAST_ASIA_FONT_RE.test(eastAsia)) return;
+  family.ascii = eastAsia;
+  family.hAnsi = eastAsia;
+}
+
+/** 递归遍历段落 / run / 表格 / SDT 等节点，处理所有 fontFamily。 */
+function walkFontFamilyNodes(nodes: DocGridNode[] | undefined, onNode: (node: DocGridNode) => void): void {
+  if (!Array.isArray(nodes)) return;
+  for (const node of nodes) {
+    if (!node || typeof node !== 'object') continue;
+    onNode(node);
+    if (Array.isArray(node.content)) walkFontFamilyNodes(node.content, onNode);
+    if (Array.isArray(node.rows)) {
+      for (const row of node.rows) {
+        if (Array.isArray(row?.cells)) {
+          for (const cell of row.cells) walkFontFamilyNodes(cell.content, onNode);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * 把中日韩文档的 eastAsia 字体回写到 ascii/hAnsi，修正在线编辑器「忽略了
+ * w:eastAsia 导致中文字体与预览不一致」的问题。同时在段落 run 与 styles.xml
+ * （含 docDefaults）上生效，保证继承链路的任一层都能拿到正确字体。
+ */
+export function applyCjkFontFallbackToDocument(doc: Document): Document {
+  const documentModel = doc.package?.document as unknown as {
+    sections?: Array<{
+      content?: DocGridNode[];
+      headers?: Map<unknown, { content?: DocGridNode[] }>;
+      footers?: Map<unknown, { content?: DocGridNode[] }>;
+    }>;
+  } | undefined;
+
+  const handleNode = (node: DocGridNode) => {
+    applyCjkEastAsiaFont(node.formatting?.fontFamily);
+    applyCjkEastAsiaFont(node.formatting?.runProperties?.fontFamily);
+  };
+
+  for (const section of documentModel?.sections ?? []) {
+    walkFontFamilyNodes(section.content, handleNode);
+    for (const furnitureMap of [section.headers, section.footers]) {
+      if (furnitureMap instanceof Map) {
+        for (const furniture of furnitureMap.values()) {
+          walkFontFamilyNodes(furniture?.content, handleNode);
+        }
+      }
+    }
+  }
+
+  const styleDefinitions = doc.package?.styles;
+  applyCjkEastAsiaFont(styleDefinitions?.docDefaults?.rPr?.fontFamily);
+  for (const style of styleDefinitions?.styles ?? []) {
+    applyCjkEastAsiaFont(style.rPr?.fontFamily);
+  }
+
+  return doc;
+}
+
+// ============================================================================
+// 预设样式 → styles.xml 合并
+//
+// 背景：docx-editor 的 repack / selective save 均不写 styles.xml（保持原文件不动），
+// 而 applyPresetStylesToDocument 在 parseDocx 之后才覆盖内存中的样式，已无法影响
+// 已解析段落的渲染。这导致外部 docx（其 styles.xml 中 Heading1 没有 spaceBefore/
+// spaceAfter）在保存→重载后，标题样式的段间距丢失，必须重新应用样式才生效。
+//
+// 修复：在 parseDocx 之前，将预设样式合并进 styles.xml，使解析器读到正确的样式定义，
+// 段落才能继承到 spaceBefore/spaceAfter 等属性；同时 repack 会保留这份修正后的
+// styles.xml，保证保存后再次打开依然生效。
+// ============================================================================
+
+const escapeXmlAttr = (value: string) =>
+  value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+
+/** 将预设样式的 pPr 序列化为 OOXML <w:pPr> 片段（仅处理预设用到的字段）。 */
+function serializePPrToXml(pPr: NonNullable<Style['pPr']>): string {
+  const children: string[] = [];
+  // OOXML CT_PPrBase 子元素顺序：spacing → ind → jc → outlineLvl
+  const hasSpacing =
+    pPr.spaceBefore !== undefined ||
+    pPr.spaceAfter !== undefined ||
+    pPr.lineSpacing !== undefined ||
+    pPr.lineSpacingRule !== undefined ||
+    pPr.beforeAutospacing !== undefined ||
+    pPr.afterAutospacing !== undefined;
+  if (hasSpacing) {
+    const attrs: string[] = [];
+    if (pPr.spaceBefore !== undefined) attrs.push(`w:before="${pPr.spaceBefore}"`);
+    if (pPr.spaceAfter !== undefined) attrs.push(`w:after="${pPr.spaceAfter}"`);
+    if (pPr.lineSpacing !== undefined) attrs.push(`w:line="${pPr.lineSpacing}"`);
+    if (pPr.lineSpacingRule !== undefined) attrs.push(`w:lineRule="${pPr.lineSpacingRule}"`);
+    if (pPr.beforeAutospacing !== undefined) attrs.push(`w:beforeAutospacing="${pPr.beforeAutospacing ? 1 : 0}"`);
+    if (pPr.afterAutospacing !== undefined) attrs.push(`w:afterAutospacing="${pPr.afterAutospacing ? 1 : 0}"`);
+    children.push(`<w:spacing ${attrs.join(' ')}/>`);
+  }
+  if (pPr.indentLeft !== undefined || pPr.indentRight !== undefined || pPr.indentFirstLine !== undefined) {
+    const attrs: string[] = [];
+    if (pPr.indentLeft !== undefined) attrs.push(`w:left="${pPr.indentLeft}"`);
+    if (pPr.indentRight !== undefined) attrs.push(`w:right="${pPr.indentRight}"`);
+    if (pPr.indentFirstLine !== undefined) {
+      if (pPr.hangingIndent) attrs.push(`w:hanging="${Math.abs(pPr.indentFirstLine)}"`);
+      else attrs.push(`w:firstLine="${pPr.indentFirstLine}"`);
+    }
+    children.push(`<w:ind ${attrs.join(' ')}/>`);
+  }
+  if (pPr.alignment !== undefined) children.push(`<w:jc w:val="${pPr.alignment}"/>`);
+  if (pPr.outlineLevel !== undefined) children.push(`<w:outlineLvl w:val="${pPr.outlineLevel}"/>`);
+  // spacingExplicit 是运行时字段，不属于 OOXML，不序列化
+  return children.length ? `<w:pPr>${children.join('')}</w:pPr>` : '';
+}
+
+/** 将预设样式的 rPr 序列化为 OOXML <w:rPr> 片段（仅处理预设用到的字段）。 */
+function serializeRPrToXml(rPr: NonNullable<Style['rPr']>): string {
+  const children: string[] = [];
+  // OOXML CT_RPr 子元素顺序：rFonts → b → bCs → i → iCs → color → sz → szCs
+  if (rPr.fontFamily) {
+    const attrs: string[] = [];
+    if (rPr.fontFamily.ascii) attrs.push(`w:ascii="${escapeXmlAttr(rPr.fontFamily.ascii)}"`);
+    if (rPr.fontFamily.hAnsi) attrs.push(`w:hAnsi="${escapeXmlAttr(rPr.fontFamily.hAnsi)}"`);
+    if (rPr.fontFamily.eastAsia) attrs.push(`w:eastAsia="${escapeXmlAttr(rPr.fontFamily.eastAsia)}"`);
+    if (rPr.fontFamily.cs) attrs.push(`w:cs="${escapeXmlAttr(rPr.fontFamily.cs)}"`);
+    if (attrs.length) children.push(`<w:rFonts ${attrs.join(' ')}/>`);
+  }
+  if (rPr.bold) children.push('<w:b/>');
+  if (rPr.boldCs) children.push('<w:bCs/>');
+  if (rPr.italic) children.push('<w:i/>');
+  if (rPr.italicCs) children.push('<w:iCs/>');
+  if (rPr.color) {
+    const rgb = typeof rPr.color === 'string' ? rPr.color : rPr.color.rgb;
+    if (rgb) children.push(`<w:color w:val="${rgb}"/>`);
+  }
+  if (rPr.fontSize !== undefined) children.push(`<w:sz w:val="${rPr.fontSize}"/>`);
+  if (rPr.fontSizeCs !== undefined) children.push(`<w:szCs w:val="${rPr.fontSizeCs}"/>`);
+  return children.length ? `<w:rPr>${children.join('')}</w:rPr>` : '';
+}
+
+/** 将单个预设样式序列化为 OOXML <w:style> 元素字符串。 */
+function serializeStyleToXml(style: Style): string {
+  const parts: string[] = [];
+  const typeAttr = style.type ? ` w:type="${style.type}"` : '';
+  const styleIdAttr = style.styleId ? ` w:styleId="${escapeXmlAttr(style.styleId)}"` : '';
+  const defaultAttr = style.default ? ' w:default="1"' : '';
+  parts.push(`<w:style${typeAttr}${styleIdAttr}${defaultAttr}>`);
+
+  if (style.name !== undefined) parts.push(`<w:name w:val="${escapeXmlAttr(style.name)}"/>`);
+  if (style.basedOn !== undefined) parts.push(`<w:basedOn w:val="${escapeXmlAttr(style.basedOn)}"/>`);
+  if (style.next !== undefined) parts.push(`<w:next w:val="${escapeXmlAttr(style.next)}"/>`);
+  if (style.link !== undefined) parts.push(`<w:link w:val="${escapeXmlAttr(style.link)}"/>`);
+  if (style.uiPriority !== undefined) parts.push(`<w:uiPriority w:val="${style.uiPriority}"/>`);
+  if (style.qFormat) parts.push('<w:qFormat/>');
+  if (style.hidden) parts.push('<w:hidden/>');
+  if (style.semiHidden) parts.push('<w:semiHidden/>');
+  if (style.unhideWhenUsed) parts.push('<w:unhideWhenUsed/>');
+
+  if (style.pPr) {
+    const pPrXml = serializePPrToXml(style.pPr);
+    if (pPrXml) parts.push(pPrXml);
+  }
+  if (style.rPr) {
+    const rPrXml = serializeRPrToXml(style.rPr);
+    if (rPrXml) parts.push(rPrXml);
+  }
+
+  parts.push('</w:style>');
+  return parts.join('');
+}
+
+/**
+ * 规范化样式名称用于「去重/等值比较」。
+ *
+ * 注意：这是强归一化函数，不仅去空格/转小写，还做：
+ *   1) 全角数字/字母/符号 → 半角
+ *   2) 中文全角空格 → 半角空格 → 最终所有空格全部剥离
+ *   3) 中文前缀同义词归一：「标题 N」= 「headingN」= 「heading N」（因为文件自带的
+ *      Normal/Heading1 等 style 在中文环境里 name 可能是"标题 1"，在英文环境里
+ *      name 是 "Heading 1"，两套 name 实际指向同一个公文里的"标题 1"语义）
+ *
+ * 只有经过这么彻底的归一，才能把原 docx 里 styleId 数字 1/name=标题１（全角）、
+ * styleId 数字 1/name=Heading 1、preset styleId Heading1/name=标题 1（半角）
+ * 这三个本质上是同一个样式的不同表达都识别成等价项，不会在样式下拉框里出现
+ * 三个重复项。
+ */
+export function normalizeStyleName(name: string | undefined | null): string {
+  if (!name) return '';
+  let s = String(name);
+
+  // —— 1) 全角 → 半角
+  //    全角 Unicode 范围：U+FF01..U+FF5E 对应 ASCII !..~ 差 0xFEE0
+  //    全角空格 U+3000 → 半角空格
+  s = s.replace(/[\uFF01-\uFF5E]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 0xfee0));
+  s = s.replace(/\u3000/g, ' ');
+
+  // —— 2) 统一小写 + 去所有空白
+  s = s.toLowerCase().replace(/\s+/g, '');
+
+  // —— 3) 中文前缀同义词归一化
+  //    "标题1" ↔ "heading1"；"标题2" ↔ "heading2"；最多支持到标题 9（公文里最多 9 级标题）
+  //    同时兼容"第1章/第1节"这类模板写法，这里只合并最常见的「标题」↔ Heading。
+  for (let i = 1; i <= 9; i++) {
+    const chineseVariant = `标题${i}`;
+    const englishVariant = `heading${i}`;
+    // 如果字符串包含 "标题{数字}"，就把 "标题{数字}" 子串整体替换成 "heading{数字}"
+    // （反之如果字符串是 "heading{数字}" 不变，最后两边都统一成 heading{数字}）
+    if (s.includes(chineseVariant)) {
+      s = s.replace(chineseVariant, englishVariant);
+    }
+  }
+
+  // —— 4) 正文 / default / normal 同义
+  if (s === '正文' || s === 'default' || s === 'standard') s = 'normal';
+
+  return s;
+}
+
+/**
+ * 将预设样式合并进 styles.xml 内容：
+ * 1. 扫描现有样式，删除所有与任一预设"名称相同（规范化后）"或"styleId 相同"的旧样式定义
+ *    （这一步同时解决：原文件用 styleId=1/name=标题1 与 styleId=Heading1/name=Heading1 两套共存的重复问题）
+ * 2. 在 </w:styles> 前统一追加一份完整的预设样式定义
+ *
+ * 返回合并后的 styles.xml 字符串。若原内容已经包含正确的预设集合且无冲突，返回原值。
+ *
+ * 使用纯字符串替换，避免 DOMParser/XMLSerializer 破坏 OOXML 结构。
+ */
+export function mergePresetStylesIntoStylesXml(stylesXml: string): string {
+  // 第一阶段：收集现有样式
+  const existingStyles: Array<{ styleId: string; name: string; normalizedName: string; matchStart: number; matchEnd: number }> = [];
+  {
+    const styleRegex = /<w:style\b[^>]*w:styleId="([^"]+)"[^>]*>[\s\S]*?<\/w:style>/g;
+    let match: RegExpExecArray | null;
+    while ((match = styleRegex.exec(stylesXml))) {
+      const styleXml = match[0];
+      const styleId = match[1];
+      const nameMatch = styleXml.match(/<w:name\s+w:val="([^"]*)"[^>]*>/);
+      const name = nameMatch ? nameMatch[1] : '';
+      existingStyles.push({
+        styleId,
+        name,
+        normalizedName: normalizeStyleName(name),
+        matchStart: match.index,
+        matchEnd: match.index + styleXml.length,
+      });
+    }
+  }
+
+  if (existingStyles.length === 0) {
+    return stylesXml.replace('</w:styles>', `${PRESET_STYLES.map(serializeStyleToXml).join('\n')}\n</w:styles>`);
+  }
+
+  const presetStyleIds = new Set(PRESET_STYLES.map(p => p.styleId));
+  const presetNormalizedNames = new Set(
+    PRESET_STYLES.filter(p => p.name).map(p => normalizeStyleName(p.name!)),
+  );
+
+  // 第二阶段：找出所有与预设冲突的现有样式（按 name 匹配 或 按 styleId 匹配，都需要删掉）
+  const replaceRanges: Array<{ start: number; end: number }> = [];
+  for (const existing of existingStyles) {
+    const hitByName = existing.normalizedName && presetNormalizedNames.has(existing.normalizedName);
+    const hitById = presetStyleIds.has(existing.styleId);
+    if (hitByName || hitById) {
+      replaceRanges.push({ start: existing.matchStart, end: existing.matchEnd });
+    }
+  }
+
+  // 第三阶段：从后往前删除冲突区间（避免位置偏移）
+  let result = stylesXml;
+  if (replaceRanges.length > 0) {
+    replaceRanges.sort((a, b) => b.start - a.start);
+    for (const { start, end } of replaceRanges) {
+      result = result.slice(0, start) + result.slice(end);
+    }
+  }
+
+  // 第四阶段：在 </w:styles> 前追加所有预设样式
+  const newStylesXml = PRESET_STYLES.map(serializeStyleToXml).join('\n');
+  result = result.replace('</w:styles>', `${newStylesXml}\n</w:styles>`);
+
+  // 若最终结果与原值相同（不可能，因为我们总会追加预设），则返回原值
+  return result;
+}
+
+// ============================================================================
+// DRAWING GUARD：drawing / pict / shape 等富媒体元素的「保护套」工具
+//
+// 背景：ensureInlineSpacingInDocumentXml / ensureHongTouSeparatorBorderInDocumentXml
+//       用纯字符串正则匹配 <w:pPr>…</w:pPr> 并替换，虽然正则是非贪婪模式，
+//       理论上只会匹配"从一个开标签到最近一个闭标签"的最小块，但：
+//       - Word 会在 drawing 内嵌 <pic:nvPicPr><pic:cNvPr descr="描述文字"/>
+//         等带任意字符串的属性，如果用户把"</w:pPr>"写进图片描述（极端但合法），
+//         非贪婪就会在错误位置截断；
+//       - 更常见的情况：OOXML 里 drawing/pict（VML）是「跨 paragraph 的浮动元素」
+//         （例如文档末尾页脚区域的绝对定位骑缝章），正则会把 drawing 里某段
+//         子结构误识别成"新的 pPr 块的一部分"，replace 后 drawing 的 XML
+//         byte 被改动（哪怕只是前后拼接多了些字符），导致 parseDocx 时
+//         drawing → a:blip r:embed 关联断裂，最终渲染成一个「<img src= width=192
+//         height=192 style=position absolute...>」的破损占位图。
+//
+// 防御原则：**彻底隔离富媒体元素与 <w:pPr> 正则处理**。每次开始处理 document.xml
+// 前，先把所有 drawing/pict/vml-shape 整块换成一个"不含 XML 标签特征"的字符串
+// 占位符（例如 `__VEN_DRAWING_0__`），这样 <w:pPr> 正则永远不会碰到这些
+// 富媒体的 byte，100% 不会误伤；等 <w:pPr> 处理完成后，再按序把占位符还原
+// 回原始 drawing XML 片段；最后再跑 sanity check 确保 drawing 数量不变，
+// 任何异常就直接回滚原 documentXml 不做任何修改（宁可不注入内联 spacing/
+// pBdr，也不能把用户的页脚签章图片搞坏）。
+// ============================================================================
+
+// 所有需要「保护套」的富媒体开/闭标签对（OOXML 常用的 3 种图片容器）：
+const DRAWING_TAG_PAIRS: Array<{ open: RegExp; close: string; guardPrefix: string }> = [
+  // OOXML drawing（Word 2007+ 主流，图片/形状/Chart 都会包一层 w:drawing）
+  { open: /<w:drawing(\s|>)/i, close: '</w:drawing>', guardPrefix: 'VEN_DRAWING' },
+  // 兼容旧版 Word 的绘图对象（mc:AlternateContent 里的 w:pict）
+  { open: /<w:pict(\s|>)/i, close: '</w:pict>', guardPrefix: 'VEN_PICT' },
+  // VML 形状（页眉页脚水印图，WPS 很喜欢写 <v:shape id=...>...</v:shape>）
+  { open: /<v:shape(\s|>)/i, close: '</v:shape>', guardPrefix: 'VEN_VML' },
+];
+
+/** 统计某个标签（区分大小写但允许 <tag 开空格/>）在 xml 中出现的次数 */
+function countOccurrences(xml: string, openRegex: RegExp, closeTag: string): number {
+  // 开标签：<tag<space 或 <tag>
+  let openCount = 0;
+  const openG = new RegExp(openRegex.source, openRegex.flags.includes('i') ? 'gi' : 'g');
+  while (openG.exec(xml) !== null) openCount++;
+  // 闭标签
+  const closeG = new RegExp(closeTag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
+  let closeCount = 0;
+  while (closeG.exec(xml) !== null) closeCount++;
+  return Math.min(openCount, closeCount);
+}
+/**
+ * 把所有富媒体块替换成占位符，返回替换后的 xml 以及一个按顺序可还原的片段数组。
+ * 匹配规则：对每类 tag pair，从左到右扫描，每次找到第一个开标签，然后找
+ * "对应的最近一个闭标签"（做嵌套深度计数：遇到开标签 depth++，遇到
+ * 同名闭标签 depth--，depth 回到 0 时截断整块）。嵌套处理能防止 drawing
+ * 里又包了子 drawing/VML 的复杂情况（虽然 OOXML 很少见，但要稳）。
+ */
+function protectDrawings(xml: string): { guarded: string; drawings: string[]; placeholderReg: RegExp } {
+  const drawings: string[] = [];
+  let guarded = xml;
+
+  for (const pair of DRAWING_TAG_PAIRS) {
+    // 为每类 tag 构建开标签全局正则（保证能 exec 多次推进 lastIndex）
+    const openG = new RegExp(pair.open.source, pair.open.flags.includes('i') ? 'gi' : 'g');
+
+    // 多轮扫描：每轮找到一个 pair 整块替换成占位符，继续扫剩余字符串
+    // （每次把结果重新塞回 guarded；注意：每轮占位符前缀+索引是全局递增 drawings 数组的 index）
+    // 为了支持"不同 tag pair 之间也不冲突"，我们实际一次只处理一种 tag 类型，
+    // 处理方式：迭代式地做字符串拼接，避免正则 replace 回调里难以做嵌套计数。
+    let result = '';
+    let cursor = 0;
+    let match: RegExpExecArray | null;
+    while ((match = openG.exec(guarded)) !== null) {
+      const openStart = match.index;
+      const openEnd = openStart + match[0].length; // 开标签结束位置（<w:drawing 的 '>' 后面）
+      // 现在从 openEnd 往后找 depth 归 0 的 pair.close 位置
+      // 为了正确匹配"同名闭标签 + 同名开标签嵌套"，做嵌套深度计数 +
+      // 开/闭标签位置交替前进（depth 归 0 时截断整块）
+      let depth = 1;
+      // 正则：开标签（<tagname<space|>） 和 闭标签（</tagname>）
+      const innerOpenG = new RegExp(pair.open.source, pair.open.flags.includes('i') ? 'gi' : 'g');
+      innerOpenG.lastIndex = openEnd;
+      const closeG = new RegExp(pair.close.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
+      closeG.lastIndex = openEnd;
+
+      let nextOpen = innerOpenG.exec(guarded);
+      let nextClose = closeG.exec(guarded);
+      while (depth > 0) {
+        // 选 nextOpen 和 nextClose 里位置更靠前的那个
+        if (nextClose === null) break; // 没闭标签 → 结构异常，退出循环，不替换这块
+        const openPos = nextOpen ? nextOpen.index : Infinity;
+        const closePos = nextClose.index;
+        if (closePos < openPos) {
+          // 先遇到闭标签 → depth--
+          depth--;
+          if (depth === 0) {
+            const blockEnd = closePos + pair.close.length;
+            const block = guarded.slice(openStart, blockEnd);
+            const placeholder = `__${pair.guardPrefix}_${drawings.length}__`;
+            drawings.push(block);
+            // 拼接：[cursor, openStart) + placeholder + new search
+            result += guarded.slice(cursor, openStart) + placeholder;
+            cursor = blockEnd;
+            break;
+          }
+          nextClose = closeG.exec(guarded);
+        } else {
+          // 先遇到开标签 → depth++（嵌套）
+          depth++;
+          // 推进 nextOpen（不能让它停在原地，否则死循环）
+          nextOpen = innerOpenG.exec(guarded);
+        }
+      }
+      // 如果循环是因为"没找到闭标签"跳出 → 保持 cursor 不动，openG 会自动推进 lastIndex 继续找下一个
+    }
+    result += guarded.slice(cursor);
+    guarded = result;
+    // 处理下一类 tag pair（此时 drawing 占位符已经在 guarded 里，不会再被新 pair 匹配）
+  }
+
+  // 还原占位符用的正则：匹配 __VEN_DRAWING_N__ / __VEN_PICT_N__ / __VEN_VML_N__
+  const placeholderReg = /__(VEN_DRAWING|VEN_PICT|VEN_VML)_(\d+)__/g;
+  return { guarded, drawings, placeholderReg };
+}
+
+/** 把 protectDrawings 生成的占位符还原成原始 drawing XML 片段 */
+function restoreDrawings(guarded: string, drawings: string[], placeholderReg: RegExp): string {
+  // 重置 lastIndex，防止外部用过这个正则
+  placeholderReg.lastIndex = 0;
+  return guarded.replace(placeholderReg, (_full, _prefix: string, idxStr: string) => {
+    const idx = Number(idxStr);
+    if (Number.isNaN(idx) || idx < 0 || idx >= drawings.length) return _full;
+    return drawings[idx];
+  });
+}
+
+/**
+ * 高阶工具：对 document.xml 做任何会改写其内容的字符串操作前，先套一层
+ * DRAWING GUARD（保护富媒体元素不被误伤），并做 sanity check：
+ *   - 若处理前后 drawing 数量不一致 → 直接返回原值，不应用修改
+ * 这样即使未来再增加 <w:pPr> 之外的新正则修改，也不会损坏图片。
+ */
+function runWithDrawingGuard(
+  documentXml: string,
+  worker: (guardedBodyXml: string) => { result: string; modified: boolean },
+): string {
+  // 保存 xml decl 拆分（和 ensureInlineSpacingInDocumentXml 一致）
+  const xmlDeclMatch = documentXml.match(/^<\?xml[^?]*\?>\s*/);
+  const xmlDecl = xmlDeclMatch ? xmlDeclMatch[0] : '';
+  const bodyXml = xmlDeclMatch ? documentXml.slice(xmlDeclMatch[0].length) : documentXml;
+
+  // —— 处理前 sanity snapshot：drawing/pict/vml 计数
+  const beforeCounts = DRAWING_TAG_PAIRS.map(p => countOccurrences(bodyXml, p.open, p.close));
+  const totalBefore = beforeCounts.reduce((a, b) => a + b, 0);
+
+  // —— 1) 保护 drawings
+  const { guarded, drawings, placeholderReg } = protectDrawings(bodyXml);
+
+  // —— 2) 实际 worker 干活（worker 内只会碰 guarded，里面所有富媒体都是 __VEN_XXX_N__
+  //        纯字母数字下划线占位符，没有任何 <...> XML 特征，pPr 正则不可能命中）
+  const { result: guardedResult, modified } = worker(guarded);
+  if (!modified) return documentXml; // 没改，直接返回原始 documentXml
+
+  // —— 3) 还原 drawings
+  const bodyResult = restoreDrawings(guardedResult, drawings, placeholderReg);
+
+  // —— 4) 处理后 sanity check：drawing 数量必须与处理前完全一致
+  const afterCounts = DRAWING_TAG_PAIRS.map(p => countOccurrences(bodyResult, p.open, p.close));
+  const totalAfter = afterCounts.reduce((a, b) => a + b, 0);
+  if (totalBefore !== totalAfter) {
+    // 理论上 protectDrawings 已经隔离了富媒体，这里不应触发。
+    // 万一触发（比如 worker 内部不小心把 __VEN_XXX 占位符改了/删了），
+    // 直接回滚原始值，坚决不输出损坏的 document.xml。
+    return documentXml;
+  }
+
+  return xmlDecl + bodyResult;
+}
+
+// ============================================================================
+// document.xml 内联间距注入
+//
+// 背景：布局引擎的 spacingExplicit 机制会折叠未标记为显式的样式继承间距。
+// 当段落仅通过 <w:pStyle> 引用 Heading1 等样式时，间距来自样式继承，
+// parseDocx 不会为这些继承值设置 spacingExplicit 标志，导致重载后
+// spaceBefore/spaceAfter 不生效。
+//
+// 之前尝试在 parseDocx 后遍历 Document 对象设置 spacingExplicit，但发现
+// Document 的 Paragraph 接口中不含 styleId 字段（styleId 只存在于
+// ProseMirror 的 ParagraphAttrs 中），导致该遍历完全无效。
+//
+// 修复：直接在 document.xml 层面，为引用了带间距样式的段落添加内联
+// <w:spacing> 标签。parseDocx 解析内联 <w:spacing> 时会自动设置
+// spacingExplicit 标志，确保间距在重载后生效。
+// ============================================================================
+
+/**
+ * 确保 document.xml 中引用了带间距样式的段落有内联 <w:spacing> 标签。
+ *
+ * 规则：
+ * - 仅对引用了 PRESET_STYLES 中带间距样式（如 Heading1）的段落处理
+ * - 如果段落已有 <w:spacing>，只补充缺失的属性（不覆盖用户手动设置的值）
+ * - 如果段落没有 <w:spacing>，创建并插入到 <w:pStyle> 之后
+ *   （遵循 OOXML CT_PPr 子元素顺序：pStyle → ... → spacing → ind → jc）
+ *
+ * 使用字符串操作而非 DOM API，避免 XMLSerializer 丢失 XML 声明、
+ * 命名空间处理不一致等问题。
+ */
+export function ensureInlineSpacingInDocumentXml(documentXml: string): string {
+  // —— 0) 预计算 spacing attrs map（不依赖 bodyXml，可以放在 guard 外层）
+  const spacingAttrsByStyleId = new Map<string, string>();
+  for (const style of PRESET_STYLES) {
+    if (!style.pPr) continue;
+    if (
+      style.pPr.spaceBefore === undefined &&
+      style.pPr.spaceAfter === undefined &&
+      style.pPr.lineSpacing === undefined
+    )
+      continue;
+    const attrs: string[] = [];
+    if (style.pPr.spaceBefore !== undefined) attrs.push(`w:before="${style.pPr.spaceBefore}"`);
+    if (style.pPr.spaceAfter !== undefined) attrs.push(`w:after="${style.pPr.spaceAfter}"`);
+    if (style.pPr.lineSpacing !== undefined) attrs.push(`w:line="${style.pPr.lineSpacing}"`);
+    if (style.pPr.lineSpacingRule !== undefined) attrs.push(`w:lineRule="${style.pPr.lineSpacingRule}"`);
+    spacingAttrsByStyleId.set(style.styleId, attrs.join(' '));
+  }
+  if (spacingAttrsByStyleId.size === 0) return documentXml;
+
+  // —— 1) 套上 DRAWING GUARD，worker 里跑正则，永远不会误伤 drawing/pict/vml
+  return runWithDrawingGuard(documentXml, (guardedBodyXml) => {
+    let modified = false;
+    const result = guardedBodyXml.replace(/(<w:pPr\b[^>]*>)([\s\S]*?)<\/w:pPr>/g, (fullMatch, openTag: string, inner: string) => {
+      const pStyleMatch = inner.match(/<w:pStyle\s+w:val=(?:"([^"]+)"|'([^']+)')[^>]*?(?:\/>|><\/w:pStyle>)/);
+      if (!pStyleMatch) return fullMatch;
+
+      const styleId = pStyleMatch[1] || pStyleMatch[2];
+      if (!styleId) return fullMatch;
+
+      const spacingAttrs = spacingAttrsByStyleId.get(styleId);
+      if (!spacingAttrs) return fullMatch;
+
+      if (/<w:spacing[\s/>]/.test(inner)) {
+        const newSpacingTag = `<w:spacing ${spacingAttrs}/>`;
+        const updatedInner = inner.replace(/<w:spacing\b[^>]*\/>/, newSpacingTag);
+        if (updatedInner !== inner) modified = true;
+        return `${openTag}${updatedInner}</w:pPr>`;
+      }
+
+      const spacingTag = `<w:spacing ${spacingAttrs}/>`;
+      const updatedInner = inner.replace(pStyleMatch[0], pStyleMatch[0] + spacingTag);
+      modified = true;
+      return `${openTag}${updatedInner}</w:pPr>`;
+    });
+    return { result, modified };
+  });
+}
+
+// ============================================================================
+// document.xml 红头分隔线底边框「解继承」注入（WPS 兼容终极方案）
+//
+// 根因：WPS 打开 docx 时，对 <w:style styleId="HongTouSeparator"> 里定义的
+//       <w:pPr><w:pBdr><w:bottom w:val="single" w:color="FF0000" w:sz="12" .../>
+//       </w:pBdr></w:pPr> 这种"style 级继承边框"读取很不稳定：
+//       - WPS 2019/2021 部分版本不读 style 上的 pBdr，只读 <w:p> 元素上
+//         内联的 <w:pPr><w:pBdr>...</w:pBdr></w:pPr>
+//       - Word/Microsoft 365 能正确继承 style 级 pBdr，所以我们编辑器里
+//         预览、保存后 Word 打开都没问题，只有 WPS 不显示红线。
+//
+// 修复策略（100% 命中，不依赖任何客户端实现）：在把 docx 写出前，直接
+//   遍历 document.xml 所有 <w:p>，找到 <w:pStyle w:val="HongTouSeparator"/>
+//   的段落，给其 <w:pPr> 强制补一段完整的「内联 4 边 <w:pBdr>」：
+//     <w:pBdr>
+//       <w:top w:val="nil" w:sz="0" w:space="0" w:color="auto"/>
+//       <w:left w:val="nil" w:sz="0" w:space="0" w:color="auto"/>
+//       <w:right w:val="nil" w:sz="0" w:space="0" w:color="auto"/>
+//       <w:bottom w:val="single" w:sz="12" w:space="1" w:color="FF0000"/>
+//     </w:pBdr>
+//   —— 这就是国标党政机关公文「红头分隔线」在 OOXML 里最标准、兼容性最好
+//   的写法，Word/WPS/永中 Office/Google Docs 全都会渲染出一条横贯整段宽的
+//   红色单实线，不会有任何兼容性问题。
+// ============================================================================
+
+// 给 HongTouSeparator 段落使用的「标准 4 边 pBdr 字符串」：
+//  - nil 等价于 none，在 WPS 里比 'none' 更稳
+//  - 顶/左/右 sz=0 + color=auto，彻底锁死其他三边无颜色、无宽度
+//  - bottom w:val="single" w:sz="12" (= 1.5pt) w:space="1" w:color="FF0000"
+//    对应预设样式里的 size 12、space 1、color FF0000
+const HONGTOU_SEP_PBDR_XML = `<w:pBdr><w:top w:val="nil" w:sz="0" w:space="0" w:color="auto"/><w:left w:val="nil" w:sz="0" w:space="0" w:color="auto"/><w:right w:val="nil" w:sz="0" w:space="0" w:color="auto"/><w:bottom w:val="single" w:sz="12" w:space="1" w:color="FF0000"/></w:pBdr>`;
+
+/**
+ * 在 document.xml 中为所有引用了 styleId=HongTouSeparator 的段落，
+ * 强制注入/替换一段完整的 4 边内联 <w:pBdr>，保证 WPS 打开也能显示红线。
+ */
+export function ensureHongTouSeparatorBorderInDocumentXml(documentXml: string): string {
+  const HONGTOU_STYLE_ID = 'HongTouSeparator';
+
+  // 快速短路：文档里完全没有出现 HongTouSeparator 就原样返回
+  if (!documentXml.includes(HONGTOU_STYLE_ID)) {
+    return documentXml;
+  }
+
+  // —— 套上 DRAWING GUARD，worker 里的 pPr 正则永远不会误伤 drawing/pict/vml
+  return runWithDrawingGuard(documentXml, (guardedBodyXml) => {
+    let modified = false;
+
+    // 匹配每个 <w:pPr> 块（与 ensureInlineSpacingInDocumentXml 同模式）
+    const result = guardedBodyXml.replace(/(<w:pPr\b[^>]*>)([\s\S]*?)<\/w:pPr>/g, (fullMatch, openTag: string, inner: string) => {
+      // 检查这段 pPr 里是否引用了 HongTouSeparator 样式
+      const pStyleMatch = inner.match(/<w:pStyle\s+w:val=(?:"([^"]+)"|'([^']+)')[^>]*?(?:\/>|><\/w:pStyle>)/);
+      if (!pStyleMatch) return fullMatch;
+      const styleId = pStyleMatch[1] || pStyleMatch[2];
+      if (styleId !== HONGTOU_STYLE_ID) return fullMatch;
+
+      let newInner: string;
+
+      // 情况 1：已有 <w:pBdr>...</w:pBdr> → 整块替换成标准 4 边版本
+      if (/<w:pBdr\b[^>]*>[\s\S]*?<\/w:pBdr>/.test(inner)) {
+        newInner = inner.replace(/<w:pBdr\b[^>]*>[\s\S]*?<\/w:pBdr>/, HONGTOU_SEP_PBDR_XML);
+        if (newInner !== inner) modified = true;
+        return `${openTag}${newInner}</w:pPr>`;
+      }
+
+      // 情况 2：没有 <w:pBdr> → 按 OOXML CT_PPr 顺序插入（优先在 spacing/ind/jc 前插）
+      const insertionHints = [
+        { re: /<w:spacing[\s/>]/ },
+        { re: /<w:ind[\s/>]/ },
+        { re: /<w:jc[\s/>]/ },
+      ];
+      let insertPos = -1;
+      for (const h of insertionHints) {
+        const m = inner.match(h.re);
+        if (m && m.index !== undefined) {
+          insertPos = m.index;
+          break;
+        }
+      }
+
+      if (insertPos >= 0) {
+        newInner = inner.slice(0, insertPos) + HONGTOU_SEP_PBDR_XML + inner.slice(insertPos);
+      } else {
+        newInner = inner + HONGTOU_SEP_PBDR_XML;
+      }
+      if (newInner !== inner) modified = true;
+      return `${openTag}${newInner}</w:pPr>`;
+    });
+
+    return { result, modified };
+  });
+}