@v1hz/md2docx 1.6.0 → 2.0.1

package/dist/index.js

@@ -0,0 +1,1272 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { CommanderError } from "commander";
+import { realpathSync } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { resolve as resolve5 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/cli.ts
+import { Command } from "commander";
+function createProgram(version, actions) {
+  const program = new Command;
+  program.name("md2docx").description("将 Markdown 转换为 Word 文档").version(version, "-v, --version", "显示版本号").helpOption("-h, --help", "显示帮助").addHelpCommand(false).showHelpAfterError("使用 --help 查看帮助").showSuggestionAfterError().enablePositionalOptions().option("-f, --file <path>", "Markdown 文件").option("-c, --config <path>", "自定义配置文件").option("-s, --style <path>", "自定义样式文件").option("-o, --output <path>", "输出 DOCX 文件").option("--force", "覆盖已有文件").action(async function(options) {
+    if (!options.file)
+      this.help();
+    await actions.convert(options);
+  });
+  program.exitOverride();
+  const exportCommand = program.command("export").description("导出默认配置或样式").helpOption("-h, --help", "显示帮助").addHelpCommand(false).action(function() {
+    this.help({ error: true });
+  });
+  exportCommand.exitOverride();
+  const exportConfigCommand = exportCommand.command("config").description("导出默认配置").helpOption("-h, --help", "显示帮助").option("-o, --output <path>", "输出 JSON 文件，默认 ./config.json").option("--force", "覆盖已有文件").action(actions.exportConfig);
+  exportConfigCommand.exitOverride();
+  const exportStyleCommand = exportCommand.command("style").description("导出默认样式，或从 DOCX 提取样式").helpOption("-h, --help", "显示帮助").option("-f, --file <path>", "用于提取样式的 DOCX 文件").option("-o, --output <path>", "输出 JSON 文件").option("--force", "覆盖已有文件").action(actions.exportStyle);
+  exportStyleCommand.exitOverride();
+  const formatCommand = program.command("format").description("预处理并格式化 Markdown").helpOption("-h, --help", "显示帮助").requiredOption("-f, --file <path>", "Markdown 文件").option("-c, --config <path>", "自定义配置文件").option("-o, --output <path>", "输出 Markdown 文件").option("--force", "覆盖已有文件").action(actions.format);
+  formatCommand.exitOverride();
+  return program;
+}
+
+// src/commands/convert.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { spawn } from "node:child_process";
+import { parse as parse2, resolve as resolve3 } from "node:path";
+
+// src/config.ts
+import { access, readFile } from "node:fs/promises";
+async function loadConfig(path) {
+  try {
+    await access(path);
+  } catch {
+    throw new Error(`找不到配置文件：${path}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(await readFile(path, "utf-8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`配置文件不是有效的 JSON：${path}
+${message}`);
+  }
+  validateConfig(raw, path);
+  delete raw.$schema;
+  return raw;
+}
+function validateConfig(value, path) {
+  const root = expectRecord(value, path, "配置");
+  validateCaption(root.figureCaption, path, "figureCaption");
+  validateCaption(root.tableCaption, path, "tableCaption");
+  validateEnabled(root.normalizeHeadings, path, "normalizeHeadings");
+  const numbering = expectRecord(root.numberHeadings, path, "numberHeadings");
+  expectBoolean(numbering.enabled, path, "numberHeadings.enabled");
+  expectBoolean(numbering.detectExisting, path, "numberHeadings.detectExisting");
+  if (numbering.existingPattern !== undefined) {
+    expectString(numbering.existingPattern, path, "numberHeadings.existingPattern");
+  }
+  if (numbering.useBuiltinRules !== undefined) {
+    expectBoolean(numbering.useBuiltinRules, path, "numberHeadings.useBuiltinRules");
+  }
+  const mermaid = expectRecord(root.renderMermaid, path, "renderMermaid");
+  expectBoolean(mermaid.enabled, path, "renderMermaid.enabled");
+  expectString(mermaid.theme, path, "renderMermaid.theme");
+  if (!Number.isInteger(mermaid.density) || mermaid.density < 72) {
+    invalidConfig(path, "renderMermaid.density", "必须是不小于 72 的整数");
+  }
+  const title = expectRecord(root.detectTitle, path, "detectTitle");
+  expectBoolean(title.enabled, path, "detectTitle.enabled");
+  const strategy = expectString(title.strategy, path, "detectTitle.strategy");
+  if (!["first-h1", "single-h1", "filename", "none"].includes(strategy)) {
+    invalidConfig(path, "detectTitle.strategy", "不是支持的标题提取策略");
+  }
+}
+function validateCaption(value, path, field) {
+  const caption = expectRecord(value, path, field);
+  expectBoolean(caption.enabled, path, `${field}.enabled`);
+  expectString(caption.format, path, `${field}.format`);
+  expectString(caption.separator, path, `${field}.separator`);
+}
+function validateEnabled(value, path, field) {
+  const config = expectRecord(value, path, field);
+  expectBoolean(config.enabled, path, `${field}.enabled`);
+}
+function expectRecord(value, path, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    invalidConfig(path, field, "必须是对象");
+  }
+  return value;
+}
+function expectBoolean(value, path, field) {
+  if (typeof value !== "boolean")
+    invalidConfig(path, field, "必须是 boolean");
+  return value;
+}
+function expectString(value, path, field) {
+  if (typeof value !== "string")
+    invalidConfig(path, field, "必须是字符串");
+  return value;
+}
+function invalidConfig(path, field, reason) {
+  throw new Error(`配置文件无效：${path}
+位置：${field}
+原因：${reason}`);
+}
+
+// src/paths.ts
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var PKG_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+var CONFIG_PATH = resolve(PKG_DIR, "config/config.json");
+var CONFIG_SCHEMA_PATH = resolve(PKG_DIR, "config/config.schema.json");
+var TMP_DIR = "tmp";
+function preprocessDir(baseName) {
+  return `${TMP_DIR}/preprocess/${baseName}`;
+}
+function formattedMdPath(baseName) {
+  return `${preprocessDir(baseName)}/${baseName}_formatted.md`;
+}
+var STYLE_DIR = `${TMP_DIR}/style`;
+var STYLE_CONFIG = resolve(PKG_DIR, "config/style.json");
+function styleTemplateDocx(hash) {
+  return `${STYLE_DIR}/${hash}.docx`;
+}
+
+// src/output.ts
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { dirname as dirname2, extname, resolve as resolve2 } from "node:path";
+function resolveInputPath(path, extensions, label) {
+  const resolved = resolve2(path);
+  if (!existsSync(resolved))
+    throw new Error(`找不到${label}：${resolved}`);
+  if (!statSync(resolved).isFile())
+    throw new Error(`${label}不是文件：${resolved}`);
+  assertExtension(resolved, extensions, label);
+  return resolved;
+}
+function resolveOutputPath(path, defaultName, extensions, label) {
+  const resolved = resolve2(path ?? defaultName);
+  assertExtension(resolved, extensions, label);
+  return resolved;
+}
+function prepareOutput(path, force) {
+  if (existsSync(path) && !force) {
+    throw new Error(`输出文件已存在：${path}
+使用 --force 覆盖现有文件`);
+  }
+  mkdirSync(dirname2(path), { recursive: true });
+}
+function assertExtension(path, extensions, label) {
+  const extension = extname(path).toLowerCase();
+  if (!extensions.includes(extension)) {
+    throw new Error(`${label}扩展名必须是 ${extensions.join(" 或 ")}：${path}`);
+  }
+}
+
+// src/preprocess/index.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import remarkGfm from "remark-gfm";
+import remarkFrontmatter from "remark-frontmatter";
+import { visit } from "unist-util-visit";
+
+// src/preprocess/title.ts
+import { parse } from "node:path";
+function addTitle(fileName, root, headings, config) {
+  const { enabled, strategy } = config;
+  if (!enabled || strategy === "none")
+    return;
+  const hasFrontmatterTitle = root.children.some((c) => c.type === "yaml" && /^title:/m.test(c.value));
+  if (hasFrontmatterTitle)
+    return;
+  if (strategy === "filename") {
+    addYamlTitle(root, fallbackTitle(fileName));
+    return;
+  }
+  const depth1 = headings.filter((n) => n.depth === 1);
+  const firstDepth1 = depth1[0];
+  if (strategy === "single-h1") {
+    if (firstDepth1 != null && depth1.length === 1) {
+      extractHeadingAsTitle(root, headings, firstDepth1);
+      return;
+    }
+  }
+  if (firstDepth1 != null && depth1.length === 1 && firstDepth1 === headings[0]) {
+    extractHeadingAsTitle(root, headings, firstDepth1);
+    return;
+  }
+  addYamlTitle(root, fallbackTitle(fileName));
+}
+function extractHeadingAsTitle(root, headings, heading) {
+  const title = textContent(heading);
+  const rootIndex = root.children.indexOf(heading);
+  if (rootIndex !== -1)
+    root.children.splice(rootIndex, 1);
+  const headingIndex = headings.indexOf(heading);
+  if (headingIndex !== -1)
+    headings.splice(headingIndex, 1);
+  addYamlTitle(root, title);
+}
+function textContent(node) {
+  if (node === null || typeof node !== "object")
+    return "";
+  const value = node;
+  if ((value.type === "text" || value.type === "inlineCode") && typeof value.value === "string") {
+    return value.value;
+  }
+  if ((value.type === "image" || value.type === "imageReference") && typeof value.alt === "string") {
+    return value.alt;
+  }
+  return value.children?.map(textContent).join("") ?? "";
+}
+function fallbackTitle(fileName) {
+  return parse(fileName).name;
+}
+function addYamlTitle(root, title) {
+  root.children.unshift({ type: "yaml", value: `title: ${JSON.stringify(title)}` });
+}
+function normalizeHeadings(nodes) {
+  if (nodes.length === 0)
+    return;
+  let minDepth = 6;
+  for (const node of nodes) {
+    minDepth = Math.min(minDepth, node.depth);
+  }
+  const offset = minDepth - 1;
+  for (let i = 0;i < nodes.length; i++) {
+    nodes[i].depth -= offset;
+  }
+  for (let i = 1;i < nodes.length; i++) {
+    if (nodes[i].depth > nodes[i - 1].depth + 1) {
+      nodes[i].depth = nodes[i - 1].depth + 1;
+    }
+  }
+}
+function numberHeadings(nodes, config) {
+  if (nodes.length === 0)
+    return;
+  const { detectExisting, existingPattern } = config;
+  const counter = [0, 0, 0, 0, 0, 0];
+  for (let i = 0;i <= nodes[0].depth - 2; ++i) {
+    counter[i] = 1;
+  }
+  for (const node of nodes) {
+    const d = node.depth;
+    counter[d - 1]++;
+    counter.fill(0, d);
+    const prefix = buildPrefix(counter);
+    const first = node.children[0];
+    if (first?.type === "text") {
+      const text = detectExisting ? stripHeadingNum(first.value, existingPattern, config?.useBuiltinRules) : first.value;
+      first.value = text ? `${prefix} ${text}` : prefix;
+    } else {
+      node.children.unshift({
+        type: "text",
+        value: prefix
+      });
+    }
+  }
+}
+function buildPrefix(counter) {
+  const end = counter.findLastIndex((x) => x !== 0);
+  return counter.slice(0, end + 1).join(".");
+}
+var RE_DOT_NUM = /^\d+(\.\d+)+\.?\s*/;
+var RE_CN_PAREN = /^[（(][一二三四五六七八九十百千]+[）)]\s*/;
+var RE_CN_NUM = /^[一二三四五六七八九十百千]+[、.]\s*/;
+var RE_CN_DUN = /^[一二三四五六七八九十百千]+(?:、[一二三四五六七八九十百千]+)+、?\s*/;
+function stripHeadingNum(text, customPattern, useBuiltinRules) {
+  let result = text;
+  if (customPattern) {
+    result = result.replace(new RegExp(`^${customPattern}`), "");
+  }
+  if (useBuiltinRules !== false) {
+    result = result.replace(new RegExp(`^(?:${[RE_CN_DUN.source, RE_CN_PAREN.source, RE_CN_NUM.source, RE_DOT_NUM.source].join("|")})`), "");
+  }
+  return result;
+}
+
+// src/preprocess/caption.ts
+function numberTables(root, config) {
+  const {
+    tableCaption: { format, separator }
+  } = config;
+  let counter = 0;
+  const inserts = [];
+  const used = new Set;
+  for (let i = 0;i < root.children.length; i++) {
+    const child = root.children[i];
+    if (child?.type !== "table")
+      continue;
+    counter++;
+    const label = format.replace("{n}", String(counter));
+    const prevIdx = i - 1;
+    const prev = prevIdx >= 0 ? root.children[prevIdx] : undefined;
+    if (prev && isCaption(prev) && !used.has(prevIdx)) {
+      used.add(prevIdx);
+      const existing = stripTableNum(captionText(prev), format);
+      const first = prev.children[0];
+      first.value = `Table: ${label}${existing ? `${separator}${existing}` : ""}`;
+      continue;
+    }
+    const nextIdx = i + 1;
+    const next = nextIdx < root.children.length ? root.children[nextIdx] : undefined;
+    if (next && isCaption(next) && !used.has(nextIdx)) {
+      used.add(nextIdx);
+      const existing = stripTableNum(captionText(next), format);
+      const first = next.children[0];
+      first.value = `Table: ${label}${existing ? `${separator}${existing}` : ""}`;
+      continue;
+    }
+    inserts.push({ at: i + 1, text: `Table: ${label}` });
+  }
+  for (let j = inserts.length - 1;j >= 0; j--) {
+    const { at, text } = inserts[j];
+    root.children.splice(at, 0, {
+      type: "paragraph",
+      children: [{ type: "text", value: text }]
+    });
+  }
+}
+function numberPictures(root, config) {
+  const {
+    figureCaption: { format, separator }
+  } = config;
+  let counter = 0;
+  for (let i = 0;i < root.children.length; i++) {
+    const child = root.children[i];
+    if (child?.type === "paragraph" && child.children.length === 1 && child.children[0]?.type === "image") {
+      counter++;
+      const img = child.children[0];
+      const cleaned = stripPictureNum(img.title ?? img.alt ?? "", format);
+      const label = cleaned || fileNameFromUrl(img.url) || "";
+      const prefix = format.replace("{n}", String(counter));
+      img.alt = `${prefix}${label ? `${separator}${label}` : ""}`;
+    }
+  }
+}
+function fileNameFromUrl(url) {
+  const match = url.match(/\/([^/]+?)(?:\.[^/.]+)?$/);
+  return match ? match[1] : null;
+}
+function isCaption(node) {
+  return node != null && typeof node === "object" && node.type === "paragraph" && node.children?.length === 1 && node.children[0]?.type === "text" && (node.children[0]?.value ?? "").startsWith("Table: ");
+}
+function captionText(node) {
+  const first = node.children[0];
+  if (first?.type === "text") {
+    return first.value.replace(/^Table: /, "");
+  }
+  return "";
+}
+function stripTableNum(text, format) {
+  const escaped = format.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&").replace("{n}", "\\d+");
+  return text.replace(new RegExp(`^${escaped}`), "");
+}
+function stripPictureNum(text, format) {
+  const escaped = format.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&").replace("{n}", "\\d+");
+  return text.replace(new RegExp(`^${escaped}`), "");
+}
+
+// src/preprocess/mermaid.ts
+import { writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join } from "path";
+import { renderMermaidSVG, THEMES } from "beautiful-mermaid";
+import sharp from "sharp";
+async function renderMermaid(root, outDir, theme, density, assetUrlDir = outDir) {
+  const mermaidTheme = THEMES[theme] ?? THEMES["tokyo-night-light"];
+  let counter = 0;
+  for (let i = 0;i < root.children.length; i++) {
+    const child = root.children[i];
+    if (child?.type !== "code" || child.lang !== "mermaid")
+      continue;
+    counter++;
+    const fileName = `mermaid_${counter}.png`;
+    const pngFile = join(outDir, fileName);
+    const title = getMermaidTitle(child.meta);
+    try {
+      let svg = renderMermaidSVG(child.value, mermaidTheme);
+      svg = resolveCSSVars(svg);
+      const png = await sharp(Buffer.from(svg), {
+        density
+      }).png().toBuffer();
+      mkdirSync2(outDir, { recursive: true });
+      writeFileSync(pngFile, png);
+    } catch (err) {
+      console.error(`mermaid 渲染失败 (#${counter}):`, err);
+      continue;
+    }
+    root.children[i] = {
+      type: "paragraph",
+      children: [
+        {
+          type: "image",
+          url: join(assetUrlDir, fileName).replaceAll("\\", "/"),
+          title: title ?? undefined,
+          alt: title ?? ""
+        }
+      ]
+    };
+  }
+}
+function getMermaidTitle(meta) {
+  if (!meta)
+    return null;
+  const match = meta.match(/title\s*=\s*["']([^"']+)["']/);
+  return match ? match[1] : null;
+}
+function resolveCSSVars(svg) {
+  const vars = {};
+  const styleAttr = svg.match(/<svg[^>]*style="([^"]+)"/)?.[1];
+  if (!styleAttr)
+    return svg;
+  styleAttr.replace(/--([\w-]+)\s*:\s*([^;]+)/g, (_, n, v) => {
+    vars[n] = v.trim();
+    return "";
+  });
+  const styleBlock = svg.match(/<style>([\s\S]*?)<\/style>/)?.[1];
+  if (styleBlock) {
+    const svgRules = styleBlock.match(/svg\s*\{([^}]+)\}/)?.[1];
+    if (svgRules) {
+      svgRules.replace(/--([\w-]+)\s*:\s*([^;]+)/g, (_, n, v) => {
+        vars[n] = v.trim();
+        return "";
+      });
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const key of Object.keys(vars)) {
+      const newVal = vars[key].replace(/var\(--([\w-]+)\)/g, (_, name) => {
+        const resolved = vars[name];
+        if (resolved) {
+          changed = true;
+          return resolved;
+        }
+        return `var(--${name})`;
+      });
+      vars[key] = newVal;
+    }
+  }
+  function resolveColorMix(expr) {
+    const colors = getMixColors(expr);
+    if (!colors)
+      return expr;
+    return blendColors(colors.c1, colors.c2, colors.pct);
+  }
+  for (const key of Object.keys(vars)) {
+    vars[key] = vars[key].replace(/color-mix\([^)]+\)/g, (m) => resolveColorMix(m));
+  }
+  return svg.replace(/var\(--([\w-]+)\)/g, (_, name) => {
+    return vars[name] ?? `var(--${name})`;
+  });
+}
+function getMixColors(expr) {
+  const match = expr.match(/color-mix\(\s*in\s+srgb\s*,\s*(#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3})\s+(\d+(?:\.\d+)?)%\s*,\s*(#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3})\s*\)/);
+  if (!match)
+    return null;
+  return { c1: match[1], c2: match[3], pct: parseFloat(match[2]) / 100 };
+}
+function blendColors(c1, c2, pct) {
+  const r1 = Number.parseInt(c1.slice(1, 3), 16);
+  const g1 = Number.parseInt(c1.slice(3, 5), 16);
+  const b1 = Number.parseInt(c1.slice(5, 7), 16);
+  const r2 = Number.parseInt(c2.slice(1, 3), 16);
+  const g2 = Number.parseInt(c2.slice(3, 5), 16);
+  const b2 = Number.parseInt(c2.slice(5, 7), 16);
+  const r = Math.round(r1 * pct + r2 * (1 - pct));
+  const g = Math.round(g1 * pct + g2 * (1 - pct));
+  const b = Math.round(b1 * pct + b2 * (1 - pct));
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+
+// src/preprocess/index.ts
+async function preprocess(mdPath, cfg, outDir, assetUrlDir = outDir) {
+  const md = await readFile2(mdPath, "utf-8");
+  const processor = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkStringify, { resourceLink: true, bullet: "-" });
+  const ast = processor.parse(md);
+  const headings = [];
+  visit(ast, "heading", (heading) => {
+    headings.push(heading);
+  });
+  addTitle(mdPath, ast, headings, cfg.detectTitle);
+  if (cfg.normalizeHeadings.enabled || cfg.numberHeadings.enabled) {
+    normalizeHeadings(headings);
+  }
+  if (cfg.numberHeadings.enabled) {
+    numberHeadings(headings, cfg.numberHeadings);
+  }
+  if (cfg.tableCaption.enabled) {
+    numberTables(ast, cfg);
+  }
+  if (cfg.renderMermaid.enabled) {
+    await renderMermaid(ast, outDir, cfg.renderMermaid.theme, cfg.renderMermaid.density, assetUrlDir);
+  }
+  if (cfg.figureCaption.enabled) {
+    numberPictures(ast, cfg);
+  }
+  return processor.stringify(ast);
+}
+
+// src/style/generate.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { Document, Packer } from "docx";
+import { dirname as dirname3 } from "path";
+async function generateTemplateDocx(styleJsonPath, outputPath) {
+  const raw = JSON.parse(readFileSync(styleJsonPath, "utf-8"));
+  const tableStylesXml = raw.tableStylesXml;
+  const { tableStylesXml: _, ...styles } = raw;
+  const doc = new Document({
+    styles,
+    sections: []
+  });
+  const buf = await Packer.toBuffer(doc);
+  mkdirSync3(dirname3(outputPath), { recursive: true });
+  if (tableStylesXml) {
+    const PizZip = (await import("pizzip")).default;
+    const zip = new PizZip(buf);
+    const stylesFile = zip.file("word/styles.xml");
+    if (stylesFile) {
+      const originalXml = stylesFile.asText();
+      const injectedXml = originalXml.replace("</w:styles>", tableStylesXml + "</w:styles>");
+      zip.file("word/styles.xml", injectedXml);
+      const modifiedBuf = zip.generate({ type: "nodebuffer" });
+      await writeFile(outputPath, modifiedBuf);
+      return;
+    }
+  }
+  await writeFile(outputPath, buf);
+}
+var generatePromises = new Map;
+async function ensureTemplateDocx(styleJsonPath) {
+  const raw = readFileSync(styleJsonPath);
+  const hash = createHash("sha256").update(raw).digest("hex").slice(0, 16);
+  const outputPath = styleTemplateDocx(hash);
+  if (!existsSync2(outputPath)) {
+    let promise = generatePromises.get(outputPath);
+    if (!promise) {
+      promise = generateTemplateDocx(styleJsonPath, outputPath).catch((error) => {
+        generatePromises.delete(outputPath);
+        throw error;
+      });
+      generatePromises.set(outputPath, promise);
+    }
+    await promise;
+  }
+  return outputPath;
+}
+
+// src/commands/convert.ts
+async function convertMarkdown(options) {
+  if (!options.file)
+    throw new Error("缺少必填参数：--file");
+  const input = resolveInputPath(options.file, [".md", ".markdown"], "Markdown 文件");
+  const configPath = options.config ? resolveInputPath(options.config, [".json"], "配置文件") : CONFIG_PATH;
+  const stylePath = options.style ? resolveInputPath(options.style, [".json"], "样式文件") : STYLE_CONFIG;
+  const baseName = parse2(input).name;
+  const output = resolveOutputPath(options.output, `${baseName}.docx`, [".docx"], "DOCX 输出文件");
+  prepareOutput(output, options.force ?? false);
+  const config = await loadConfig(configPath);
+  const outDir = resolve3(preprocessDir(baseName));
+  mkdirSync4(outDir, { recursive: true });
+  const formatted = await preprocess(input, config, outDir);
+  const markdownOutput = resolve3(formattedMdPath(baseName));
+  writeFileSync2(markdownOutput, formatted, "utf-8");
+  const templatePath = await ensureTemplateDocx(stylePath);
+  const luaFilter = resolve3(PKG_DIR, "config/lua/add-inline-code.lua");
+  const pandocArgs = [
+    markdownOutput,
+    "-o",
+    output,
+    `--reference-doc=${templatePath}`,
+    ...existsSync3(luaFilter) ? [`--lua-filter=${luaFilter}`] : []
+  ];
+  const { exitCode, stderr } = await runProcess("pandoc", pandocArgs);
+  if (exitCode !== 0) {
+    throw new Error(`pandoc 转换失败 (exit code ${exitCode})：${stderr.trim()}`);
+  }
+  console.log(`已生成：${output}`);
+}
+function runProcess(command, args) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(command, args, { stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+    let stderr = "";
+    child.stderr.setEncoding("utf-8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", reject);
+    child.once("close", (exitCode) => resolve4({ exitCode: exitCode ?? 1, stderr }));
+  });
+}
+
+// src/commands/export.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { copyFile } from "node:fs/promises";
+import { parse as parse3 } from "node:path";
+
+// src/style/extract.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { DOMParser } from "@xmldom/xmldom";
+import { useNamespaces } from "xpath";
+import PizZip from "pizzip";
+var W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+var x = useNamespaces({ w: W });
+function one(node, expr) {
+  const result = x(expr, node);
+  if (!result)
+    return null;
+  if (Array.isArray(result))
+    return result[0] ?? null;
+  return result;
+}
+function all(node, expr) {
+  const result = x(expr, node);
+  if (!result)
+    return [];
+  if (Array.isArray(result))
+    return result;
+  return [result];
+}
+function wAttr(el, local) {
+  if (!el)
+    return null;
+  return el.getAttributeNS(W, local) ?? null;
+}
+function wNumber(el, local = "val") {
+  const value = wAttr(el, local);
+  if (value === null || value.trim() === "")
+    return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+function wBool(el, local) {
+  if (!el)
+    return null;
+  const found = one(el, `w:${local}`);
+  if (!found)
+    return null;
+  const v = wAttr(found, "val");
+  return v === null || !["0", "false", "off", "no"].includes(v.toLowerCase());
+}
+function mapShd(shd) {
+  if (!shd)
+    return;
+  const sh = {};
+  for (const a of [
+    "val",
+    "color",
+    "fill",
+    "themeColor",
+    "themeTint",
+    "themeFill",
+    "themeFillShade",
+    "themeShade"
+  ]) {
+    const v = wAttr(shd, a);
+    if (v !== null)
+      sh[a] = v;
+  }
+  return Object.keys(sh).length > 0 ? sh : undefined;
+}
+function mapBorder(bdr) {
+  if (!bdr)
+    return;
+  const b = {};
+  for (const a of ["val", "color", "sz", "space", "themeColor", "themeShade"]) {
+    const v = wAttr(bdr, a);
+    if (v !== null)
+      b[a] = /^\d+$/.test(v) ? Number(v) : v;
+  }
+  return Object.keys(b).length > 0 ? b : undefined;
+}
+function mapRunProps(rPr) {
+  if (!rPr)
+    return {};
+  const out = {};
+  const rFonts = one(rPr, "w:rFonts");
+  if (rFonts) {
+    const font = {};
+    for (const a of [
+      "ascii",
+      "hAnsi",
+      "cs",
+      "eastAsia",
+      "asciiTheme",
+      "hAnsiTheme",
+      "eastAsiaTheme",
+      "cstheme"
+    ]) {
+      const v = wAttr(rFonts, a);
+      if (v)
+        font[a] = v;
+    }
+    if (Object.keys(font).length)
+      out.font = font;
+  }
+  const sz = one(rPr, "w:sz");
+  if (sz) {
+    const v = wNumber(sz);
+    if (v !== null)
+      out.size = v;
+  }
+  const szCs = one(rPr, "w:szCs");
+  if (szCs) {
+    const v = wNumber(szCs);
+    if (v !== null)
+      out.sizeComplexScript = v;
+  }
+  const color = one(rPr, "w:color");
+  if (color) {
+    const v = wAttr(color, "val");
+    if (v)
+      out.color = v.toUpperCase();
+  }
+  const boolMap = [
+    ["b", "bold"],
+    ["bCs", "boldComplexScript"],
+    ["i", "italics"],
+    ["iCs", "italicsComplexScript"],
+    ["strike", "strike"],
+    ["dstrike", "doubleStrike"],
+    ["smallCaps", "smallCaps"],
+    ["caps", "allCaps"],
+    ["vanish", "vanish"],
+    ["emboss", "emboss"],
+    ["imprint", "imprint"]
+  ];
+  for (const [tag, key] of boolMap) {
+    const v = wBool(rPr, tag);
+    if (v !== null)
+      out[key] = v;
+  }
+  const va = one(rPr, "w:vertAlign");
+  if (va) {
+    const v = wAttr(va, "val");
+    if (v === "superscript")
+      out.superScript = true;
+    else if (v === "subscript")
+      out.subScript = true;
+  }
+  const u = one(rPr, "w:u");
+  if (u) {
+    const ul = {};
+    const ut = wAttr(u, "val");
+    if (ut)
+      ul.type = ut;
+    const uc = wAttr(u, "color");
+    if (uc)
+      ul.color = uc;
+    out.underline = ul;
+  }
+  const sp = one(rPr, "w:spacing");
+  if (sp) {
+    const v = wNumber(sp);
+    if (v !== null)
+      out.characterSpacing = v;
+  }
+  const lang = one(rPr, "w:lang");
+  if (lang) {
+    const lo = {};
+    for (const a of ["val", "eastAsia", "bidi"]) {
+      const v = wAttr(lang, a);
+      if (v)
+        lo[a] = v;
+    }
+    if (Object.keys(lo).length)
+      out.language = lo;
+  }
+  const shd = mapShd(one(rPr, "w:shd"));
+  if (shd)
+    out.shading = shd;
+  const bdr = one(rPr, "w:bdr");
+  if (bdr) {
+    const b = mapBorder(bdr);
+    if (b)
+      out.border = b;
+  }
+  if (one(rPr, "w:noProof"))
+    out.noProof = true;
+  return out;
+}
+function mapParagraphProps(pPr) {
+  if (!pPr)
+    return {};
+  const out = {};
+  const ALIGN_MAP = {
+    left: "left",
+    center: "center",
+    right: "right",
+    both: "both",
+    start: "start",
+    end: "end"
+  };
+  const jc = one(pPr, "w:jc");
+  if (jc) {
+    const v = wAttr(jc, "val");
+    if (v && v in ALIGN_MAP)
+      out.alignment = ALIGN_MAP[v];
+  }
+  const spacing = one(pPr, "w:spacing");
+  if (spacing) {
+    const sp = {};
+    for (const [tag, key] of [
+      ["before", "before"],
+      ["after", "after"],
+      ["line", "line"]
+    ]) {
+      const v = wNumber(spacing, tag);
+      if (v !== null)
+        sp[key] = v;
+    }
+    const lr = wAttr(spacing, "lineRule");
+    if (lr !== null)
+      sp.lineRule = lr;
+    for (const tag of ["beforeLines", "afterLines", "beforeAutospacing", "afterAutospacing"]) {
+      const v = wAttr(spacing, tag);
+      if (v !== null)
+        sp[tag] = v;
+    }
+    if (Object.keys(sp).length)
+      out.spacing = sp;
+  }
+  const ind = one(pPr, "w:ind");
+  if (ind) {
+    const id = {};
+    for (const a of [
+      "left",
+      "right",
+      "firstLine",
+      "hanging",
+      "start",
+      "end",
+      "leftChars",
+      "rightChars",
+      "firstLineChars",
+      "hangingChars"
+    ]) {
+      const v = wNumber(ind, a);
+      if (v !== null)
+        id[a] = v;
+    }
+    if (Object.keys(id).length)
+      out.indent = id;
+  }
+  for (const tag of [
+    "keepNext",
+    "keepLines",
+    "pageBreakBefore",
+    "widowControl",
+    "contextualSpacing",
+    "wordWrap",
+    "suppressLineNumbers",
+    "suppressAutoHyphens"
+  ]) {
+    const v = wBool(pPr, tag);
+    if (v !== null)
+      out[tag] = v;
+  }
+  const ol = one(pPr, "w:outlineLvl");
+  if (ol) {
+    const v = wNumber(ol);
+    if (v !== null)
+      out.outlineLevel = v;
+  }
+  const shd = mapShd(one(pPr, "w:shd"));
+  if (shd)
+    out.shading = shd;
+  const pBdr = one(pPr, "w:pBdr");
+  if (pBdr) {
+    const borders = {};
+    for (const side of ["top", "left", "bottom", "right"]) {
+      const b = mapBorder(one(pBdr, `w:${side}`));
+      if (b)
+        borders[side] = b;
+    }
+    if (Object.keys(borders).length)
+      out.border = borders;
+  }
+  const tabs = one(pPr, "w:tabs");
+  if (tabs) {
+    const tabList = [];
+    for (const tab of all(tabs, "w:tab")) {
+      const t = {};
+      const v = wAttr(tab, "val");
+      const pos = wNumber(tab, "pos");
+      if (v)
+        t.val = v;
+      if (pos !== null)
+        t.pos = pos;
+      if (Object.keys(t).length)
+        tabList.push(t);
+    }
+    if (tabList.length)
+      out.tabs = tabList;
+  }
+  return out;
+}
+function mapTableProps(tblPr) {
+  if (!tblPr)
+    return;
+  const out = {};
+  const jc = one(tblPr, "w:jc");
+  if (jc) {
+    const v = wAttr(jc, "val");
+    if (v)
+      out.alignment = v;
+  }
+  const tblInd = one(tblPr, "w:tblInd");
+  if (tblInd) {
+    const id = {};
+    const w = wNumber(tblInd, "w");
+    if (w !== null)
+      id.width = w;
+    const t = wAttr(tblInd, "type");
+    if (t !== null)
+      id.type = t;
+    if (Object.keys(id).length)
+      out.indent = id;
+  }
+  const tblBorders = one(tblPr, "w:tblBorders");
+  if (tblBorders) {
+    const borders = {};
+    for (const side of ["top", "left", "bottom", "right", "insideH", "insideV"]) {
+      const b = mapBorder(one(tblBorders, `w:${side}`));
+      if (b)
+        borders[side] = b;
+    }
+    if (Object.keys(borders).length)
+      out.borders = borders;
+  }
+  const tblCellMar = one(tblPr, "w:tblCellMar");
+  if (tblCellMar) {
+    const margins = {};
+    for (const side of ["top", "left", "bottom", "right"]) {
+      const v = wNumber(one(tblCellMar, `w:${side}`), "w");
+      if (v !== null)
+        margins[side] = v;
+    }
+    if (Object.keys(margins).length)
+      out.cellMargin = margins;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+function mapTableStylePr(tblStylePr) {
+  if (!tblStylePr)
+    return;
+  const type = wAttr(tblStylePr, "type");
+  const out = {};
+  if (type)
+    out.type = type;
+  const rPr = mapRunProps(one(tblStylePr, "w:rPr"));
+  if (Object.keys(rPr).length)
+    out.run = rPr;
+  const pPr = mapParagraphProps(one(tblStylePr, "w:pPr"));
+  if (Object.keys(pPr).length)
+    out.paragraph = pPr;
+  const tblPr = one(tblStylePr, "w:tblPr");
+  if (tblPr) {
+    const tbl = mapTableProps(tblPr);
+    if (tbl)
+      out.table = tbl;
+  }
+  const tcPr = one(tblStylePr, "w:tcPr");
+  if (tcPr) {
+    const tc = {};
+    const tcBorders = one(tcPr, "w:tcBorders");
+    if (tcBorders) {
+      const borders = {};
+      for (const side of ["top", "left", "bottom", "right", "insideH", "insideV"]) {
+        const b = mapBorder(one(tcBorders, `w:${side}`));
+        if (b)
+          borders[side] = b;
+      }
+      if (Object.keys(borders).length)
+        tc.borders = borders;
+    }
+    const vAlign = one(tcPr, "w:vAlign");
+    if (vAlign) {
+      const v = wAttr(vAlign, "val");
+      if (v)
+        tc.verticalAlign = v;
+    }
+    if (Object.keys(tc).length)
+      out.cell = tc;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+function serializeElement(el) {
+  let result = "<" + el.tagName;
+  for (let i = 0;i < el.attributes.length; i++) {
+    const attr = el.attributes[i];
+    result += ` ${attr.name}="${attr.value.replace(/"/g, "&quot;")}"`;
+  }
+  if (el.childNodes.length === 0) {
+    result += "/>";
+  } else {
+    result += ">";
+    for (let i = 0;i < el.childNodes.length; i++) {
+      const child = el.childNodes[i];
+      if (child.nodeType === 1) {
+        result += serializeElement(child);
+      } else if (child.nodeType === 3) {
+        result += child.data;
+      }
+    }
+    result += "</" + el.tagName + ">";
+  }
+  return result;
+}
+var BUILTIN_PARA = {
+  Title: "title",
+  Heading1: "heading1",
+  Heading2: "heading2",
+  Heading3: "heading3",
+  Heading4: "heading4",
+  Heading5: "heading5",
+  Heading6: "heading6",
+  Strong: "strong",
+  ListParagraph: "listParagraph",
+  FootnoteText: "footnoteText",
+  EndnoteText: "endnoteText"
+};
+var BUILTIN_CHAR = {
+  Hyperlink: "hyperlink",
+  FootnoteReference: "footnoteReference",
+  FootnoteTextChar: "footnoteTextChar",
+  EndnoteReference: "endnoteReference",
+  EndnoteTextChar: "endnoteTextChar"
+};
+function extractStylesFromDocx(docxPath) {
+  const zip = new PizZip(readFileSync2(docxPath));
+  const stylesFile = zip.file("word/styles.xml");
+  if (!stylesFile)
+    throw new Error("word/styles.xml not found in docx");
+  const xml = stylesFile.asText();
+  const doc = new DOMParser().parseFromString(xml, "text/xml");
+  const parseError = doc.getElementsByTagName("parsererror").item(0);
+  if (parseError)
+    throw new Error(`Invalid word/styles.xml: ${parseError.textContent}`);
+  const defaultDoc = {};
+  const defaultOverrides = {};
+  const paragraphStyles = [];
+  const characterStyles = [];
+  const tableStyles = [];
+  const xmlDocument = doc;
+  const dd = one(xmlDocument, "//w:docDefaults");
+  if (dd) {
+    const rPrDef = one(dd, "w:rPrDefault/w:rPr");
+    if (rPrDef) {
+      const run = mapRunProps(rPrDef);
+      if (Object.keys(run).length)
+        defaultDoc.run = run;
+    }
+    const pPrDef = one(dd, "w:pPrDefault/w:pPr");
+    if (pPrDef) {
+      const para = mapParagraphProps(pPrDef);
+      if (Object.keys(para).length)
+        defaultDoc.paragraph = para;
+    }
+  }
+  for (const style of all(xmlDocument, "//w:style")) {
+    const styleId = wAttr(style, "styleId") ?? "";
+    const styleType = wAttr(style, "type") ?? "";
+    if (!styleId || !["paragraph", "character", "table"].includes(styleType))
+      continue;
+    const name = wAttr(one(style, "w:name"), "val") ?? styleId;
+    if (styleType !== "table" && ["Normal", "DefaultParagraphFont", "TableNormal"].includes(styleId))
+      continue;
+    if (styleId.endsWith("Tok") && styleType === "character")
+      continue;
+    const entry = { id: styleId, name };
+    const bo = one(style, "w:basedOn");
+    if (bo) {
+      const v = wAttr(bo, "val");
+      if (v && !["Normal", "DefaultParagraphFont"].includes(v))
+        entry.basedOn = v;
+    }
+    const next = one(style, "w:next");
+    if (next) {
+      const v = wAttr(next, "val");
+      if (v && v !== styleId)
+        entry.next = v;
+    }
+    const link = one(style, "w:link");
+    if (link) {
+      const v = wAttr(link, "val");
+      if (v)
+        entry.link = v;
+    }
+    if (one(style, "w:qFormat"))
+      entry.quickFormat = true;
+    if (one(style, "w:semiHidden"))
+      entry.semiHidden = true;
+    if (one(style, "w:unhideWhenUsed"))
+      entry.unhideWhenUsed = true;
+    const ui = one(style, "w:uiPriority");
+    if (ui) {
+      const v = wNumber(ui);
+      if (v !== null)
+        entry.uiPriority = v;
+    }
+    if (styleType !== "table") {
+      const run = mapRunProps(one(style, "w:rPr"));
+      if (Object.keys(run).length)
+        entry.run = run;
+      const para = mapParagraphProps(one(style, "w:pPr"));
+      if (Object.keys(para).length)
+        entry.paragraph = para;
+    }
+    if (styleType === "table") {
+      const tblPr = one(style, "w:tblPr");
+      if (tblPr) {
+        const tbl = mapTableProps(tblPr);
+        if (tbl)
+          entry.table = tbl;
+      }
+      const parts = [];
+      for (const tsp of all(style, "w:tblStylePr")) {
+        const mapped = mapTableStylePr(tsp);
+        if (mapped)
+          parts.push(mapped);
+      }
+      if (parts.length)
+        entry.tableStyleParts = parts;
+      const run = mapRunProps(one(style, "w:rPr"));
+      if (Object.keys(run).length)
+        entry.run = run;
+      const pPr = mapParagraphProps(one(style, "w:pPr"));
+      if (Object.keys(pPr).length)
+        entry.paragraph = pPr;
+    }
+    if (styleType === "paragraph") {
+      const key = BUILTIN_PARA[styleId];
+      if (key) {
+        const { id: _, ...rest } = entry;
+        defaultOverrides[key] = rest;
+      } else {
+        paragraphStyles.push(entry);
+      }
+    } else if (styleType === "character") {
+      const key = BUILTIN_CHAR[styleId];
+      if (key) {
+        const { id: _, ...rest } = entry;
+        defaultOverrides[key] = rest;
+      } else {
+        characterStyles.push(entry);
+      }
+    } else if (styleType === "table") {
+      tableStyles.push(entry);
+    }
+  }
+  let tableXmlFragments = "";
+  for (const el of all(xmlDocument, "//w:style[@w:type='table' and not(@w:default='1') and @w:customStyle='1']")) {
+    const xmlStr = serializeElement(el);
+    tableXmlFragments += xmlStr;
+  }
+  const result = {};
+  if (Object.keys(defaultDoc).length > 0 || Object.keys(defaultOverrides).length > 0) {
+    result.default = {
+      ...Object.keys(defaultDoc).length > 0 ? { document: defaultDoc } : {},
+      ...defaultOverrides
+    };
+  }
+  if (paragraphStyles.length)
+    result.paragraphStyles = paragraphStyles;
+  if (characterStyles.length)
+    result.characterStyles = characterStyles;
+  if (tableStyles.length)
+    result.tableStyles = tableStyles;
+  if (tableXmlFragments)
+    result.tableStylesXml = tableXmlFragments;
+  return result;
+}
+
+// src/commands/export.ts
+async function exportConfig(options) {
+  const output = resolveOutputPath(options.output, "config.json", [".json"], "配置输出文件");
+  prepareOutput(output, options.force ?? false);
+  await copyFile(CONFIG_PATH, output);
+  console.log(`已导出配置：${output}`);
+}
+async function exportStyle(options) {
+  const source = options.file ? resolveInputPath(options.file, [".docx"], "DOCX 文件") : undefined;
+  const defaultName = source ? `${parse3(source).name}_style.json` : "style.json";
+  const output = resolveOutputPath(options.output, defaultName, [".json"], "样式输出文件");
+  prepareOutput(output, options.force ?? false);
+  if (source) {
+    const styles = extractStylesFromDocx(source);
+    writeFileSync3(output, `${JSON.stringify(styles, null, 2)}
+`, "utf-8");
+  } else {
+    writeFileSync3(output, readFileSync3(STYLE_CONFIG));
+  }
+  console.log(`已导出样式：${output}`);
+}
+
+// src/commands/format.ts
+import { existsSync as existsSync4, rmSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { basename, dirname as dirname4, parse as parse4, resolve as resolve4 } from "node:path";
+async function formatMarkdown(options) {
+  const input = resolveInputPath(options.file, [".md", ".markdown"], "Markdown 文件");
+  const configPath = options.config ? resolveInputPath(options.config, [".json"], "配置文件") : CONFIG_PATH;
+  const defaultName = `${parse4(input).name}_formatted.md`;
+  const output = resolveOutputPath(options.output, defaultName, [".md", ".markdown"], "Markdown 输出文件");
+  const force = options.force ?? false;
+  prepareOutput(output, force);
+  const config = await loadConfig(configPath);
+  const outputName = parse4(output).name;
+  const assetsName = `${outputName}_assets`;
+  const assetsDir = resolve4(dirname4(output), assetsName);
+  if (config.renderMermaid.enabled && existsSync4(assetsDir)) {
+    if (!force) {
+      throw new Error(`资源目录已存在：${assetsDir}
+使用 --force 覆盖现有目录`);
+    }
+    const parent = resolve4(dirname4(output));
+    if (dirname4(assetsDir) !== parent)
+      throw new Error(`拒绝清理非输出目录：${assetsDir}`);
+    rmSync(assetsDir, { recursive: true, force: true });
+  }
+  const formatted = await preprocess(input, config, assetsDir, basename(assetsDir));
+  writeFileSync4(output, formatted, "utf-8");
+  console.log(`已格式化：${output}`);
+}
+
+// src/index.ts
+async function run(args) {
+  const { version } = JSON.parse(await readFile3(resolve5(PKG_DIR, "package.json"), "utf-8"));
+  const program = createProgram(version, {
+    convert: convertMarkdown,
+    format: formatMarkdown,
+    exportConfig,
+    exportStyle
+  });
+  program.exitOverride();
+  try {
+    await program.parseAsync(args, { from: "user" });
+    return 0;
+  } catch (error) {
+    if (error instanceof CommanderError)
+      return error.exitCode;
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`错误：${message}`);
+    console.error("使用 --help 查看帮助");
+    return 1;
+  }
+}
+var entryPath = process.argv[1];
+if (entryPath && realpathSync(entryPath) === realpathSync(fileURLToPath2(import.meta.url))) {
+  process.exitCode = await run(process.argv.slice(2));
+}
+export {
+  run
+};