@godcreator/word-report 0.4.0 → 0.4.1

package/dist/mdx-4Rs1N1nv.mjs

@@ -0,0 +1,1289 @@
+import { a as walk, r as stableValue, s as ReportContentError, t as assembleDocument } from "./assemble-BpllQNVY.mjs";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { parse, stringify } from "yaml";
+//#region src/core/mdx/parse.ts
+const mdxParser = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkMdx).use(remarkGfm).use(remarkMath);
+/** 源位置写成「行:列」，放在 ReportContentError 的 pointer 里 */
+const positionOf = (node) => node.position ? `${node.position.start.line}:${node.position.start.column}` : "";
+/** 只解析、不执行 MDX：标签没闭合、正文里裸的 < 与 { 这类语法错在这里报出，补上文件与行列再抛 */
+function parseMdx(text, file) {
+	try {
+		return mdxParser.parse(text);
+	} catch (error) {
+		const place = error;
+		const at = place.line ? `${place.line}:${place.column ?? 1}` : "";
+		throw new ReportContentError(`MDX 语法错误：${place.reason ?? place.message ?? String(error)}`, file, at);
+	}
+}
+//#endregion
+//#region src/core/mdx/context.ts
+function located(context, node, source) {
+	context.locations.set(node, {
+		file: context.file,
+		pointer: positionOf(source)
+	});
+	return node;
+}
+function failAt(context, source, message) {
+	throw new ReportContentError(message, context.file, positionOf(source));
+}
+/** 只含注释的花括号表达式（MDX 里写注释的唯一办法）：解析后的程序体是空的 */
+function isCommentOnlyExpression(node) {
+	return (node.type === "mdxFlowExpression" || node.type === "mdxTextExpression") && node.data?.estree?.body?.length === 0;
+}
+//#endregion
+//#region src/core/mdx/ids.ts
+const ID_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+/** 编译器生成的 id 都以它开头；手写的 id 不许用，两边就不会撞 */
+const GENERATED_ID_PREFIX = "auto-";
+/** 手写的 id：规则照 docreport，另外不许占用生成 id 的前缀 */
+function explicitIdOf(raw, file, at) {
+	if (!ID_PATTERN.test(raw)) throw new ReportContentError(`id「${raw}」不合规则：要以字母开头，只用字母、数字、_ 与 -，最长 64 个字符`, file, at);
+	if (raw.startsWith("auto-")) throw new ReportContentError(`id「${raw}」以 ${GENERATED_ID_PREFIX} 开头：这个前缀留给编译器生成的 id，手写的 id 换个名字`, file, at);
+	return raw;
+}
+function fnv1a36(text) {
+	let hash = 2166136261;
+	for (let i = 0; i < text.length; i++) {
+		hash ^= text.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function withoutIds(value) {
+	if (Array.isArray(value)) return value.map(withoutIds);
+	if (value && typeof value === "object") {
+		const copy = {};
+		for (const [key, child] of Object.entries(value)) if (key !== "id") copy[key] = withoutIds(child);
+		return copy;
+	}
+	return value;
+}
+/**
+* 没写 id 的节点先登记，整份文档转完后一次分配：`auto-<种类>-<指纹>`，指纹取种类加去掉所有 id 的节点内容
+* （节只取标题：节里改了字，标题的锚点与目录链接不跟着变），同一份内容每次编译得到同一个 id；内容相同的按登记先后加 -2、-3
+*/
+var GeneratedIds = class {
+	pending = [];
+	/** signature 不给就用整个节点（去掉 id）；登记时节点的子内容可以还没填完，分配时才取指纹 */
+	request(node, kind, signature) {
+		this.pending.push({
+			node,
+			kind,
+			signature
+		});
+		return node;
+	}
+	assignAll() {
+		const occurrences = /* @__PURE__ */ new Map();
+		for (const { node, kind, signature } of this.pending) {
+			const base = `${GENERATED_ID_PREFIX}${kind}-${fnv1a36(`${kind}:${stableValue(withoutIds(signature ?? node))}`)}`;
+			const occurrence = (occurrences.get(base) ?? 0) + 1;
+			occurrences.set(base, occurrence);
+			node.id = occurrence === 1 ? base : `${base}-${occurrence}`;
+		}
+	}
+};
+//#endregion
+//#region src/core/mdx/jsx.ts
+/** 组件属性只收字符串字面量：写成 {…} 表达式、展开、没列出的属性、缺必填的属性都报错 */
+function attributesOf(context, element, spec) {
+	const values = {};
+	for (const attribute of element.attributes) {
+		if (attribute.type !== "mdxJsxAttribute") failAt(context, element, `<${element.name}> 上不能写 {…} 展开属性`);
+		const name = attribute.name;
+		if (!Object.hasOwn(spec, name)) {
+			const allowed = Object.keys(spec);
+			failAt(context, element, `<${element.name}> 没有属性 ${name}${allowed.length ? `；能写的只有 ${allowed.join("、")}` : "；它不收任何属性"}`);
+		}
+		if (typeof attribute.value !== "string") failAt(context, element, `<${element.name}> 的 ${name} 要写成字符串，如 ${name}="…"，不写成 {…} 也不省略值`);
+		if (Object.hasOwn(values, name)) failAt(context, element, `<${element.name}> 的 ${name} 写了两次`);
+		values[name] = attribute.value;
+	}
+	for (const [name, need] of Object.entries(spec)) if (need === "required" && !Object.hasOwn(values, name)) failAt(context, element, `<${element.name}> 缺少属性 ${name}`);
+	return values;
+}
+function positiveIntegerOf(context, element, name, raw) {
+	if (!/^[1-9]\d*$/.test(raw)) failAt(context, element, `<${element.name}> 的 ${name} 要是正整数，这里写的是「${raw}」`);
+	return Number(raw);
+}
+const isWhitespaceText$1 = (node) => node.type === "text" && !String(node.value).trim();
+/**
+* 组件的子元素：标签各占一行时是块级元素，写在同一行时被包进一个段落成了行内元素；两种写法都认，
+* 去掉空白与纯注释后只剩元素，别的内容报错
+*/
+function elementChildrenOf(context, element) {
+	const children = [];
+	const collect = (nodes) => {
+		for (const node of nodes) {
+			if (isWhitespaceText$1(node) || isCommentOnlyExpression(node)) continue;
+			if (node.type === "paragraph") collect(node.children);
+			else if (node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") children.push(node);
+			else failAt(context, node, `<${element.name}> 里只能放组件，这里出现了 ${node.type}`);
+		}
+	};
+	collect(element.children);
+	return children;
+}
+const FLOW_TYPES = /* @__PURE__ */ new Set([
+	"paragraph",
+	"heading",
+	"list",
+	"code",
+	"math",
+	"table",
+	"blockquote",
+	"thematicBreak",
+	"html",
+	"mdxJsxFlowElement",
+	"mdxFlowExpression",
+	"footnoteDefinition",
+	"definition"
+]);
+/** 组件里的一行文字（图题、表题、小标题）：标签在同一行时直接是行内内容，各占一行时包在一个段落里 */
+function phrasingChildrenOf(context, element) {
+	const children = element.children.filter((node) => !isCommentOnlyExpression(node));
+	if (children.length === 1 && children[0].type === "paragraph") return children[0].children;
+	if (children.every((node) => !FLOW_TYPES.has(node.type))) return children;
+	return failAt(context, element, `<${element.name}> 里只能写一段文字`);
+}
+//#endregion
+//#region src/core/mdx/inline.ts
+const MARK_ORDER = [
+	"strong",
+	"em",
+	"sub",
+	"sup",
+	"code"
+];
+const MARK_ELEMENTS = {
+	strong: "strong",
+	em: "em",
+	sub: "sub",
+	sup: "sup"
+};
+/** 只能单独成段的组件：写进一段文字中间时报错 */
+const BLOCK_COMPONENTS = /* @__PURE__ */ new Set([
+	"Figure",
+	"Figures",
+	"Table",
+	"Abstract",
+	"Bibliography",
+	"Reference",
+	"Caption",
+	"Panel",
+	"table",
+	"tr",
+	"th",
+	"td"
+]);
+/** 一段行内 MDX → docreport 行内节点：相邻、标记相同的文字合并，软换行按两侧字符连上或换成空格 */
+function inlinesOf(context, nodes) {
+	const collected = [];
+	collectInlines(context, nodes, [], collected);
+	return joinedSoftBreaks(mergedAdjacentTexts(collected));
+}
+function textWithMarks(text, marks) {
+	const sorted = MARK_ORDER.filter((mark) => marks.includes(mark));
+	return sorted.length ? {
+		type: "text",
+		text,
+		marks: sorted
+	} : {
+		type: "text",
+		text
+	};
+}
+function idTargetsOf(context, element, raw) {
+	const targets = raw.split(/\s+/).filter(Boolean);
+	if (!targets.length) failAt(context, element, `<${element.name}> 的 to 不能空`);
+	return targets.map((target) => explicitIdOf(target, context.file, positionOf(element)));
+}
+function rejectChildren(context, element) {
+	if (element.children.some((child) => !isCommentOnlyExpression(child))) failAt(context, element, `<${element.name}> 不收子内容，写成 <${element.name} … />`);
+}
+function collectInlines(context, nodes, marks, out) {
+	for (const node of nodes) switch (node.type) {
+		case "text":
+			out.push(located(context, textWithMarks(node.value, marks), node));
+			break;
+		case "emphasis":
+			collectInlines(context, node.children, [...marks, "em"], out);
+			break;
+		case "strong":
+			collectInlines(context, node.children, [...marks, "strong"], out);
+			break;
+		case "inlineCode":
+			out.push(located(context, textWithMarks(node.value, [...marks, "code"]), node));
+			break;
+		case "inlineMath":
+			out.push(located(context, context.ids.request({
+				type: "math",
+				id: "",
+				latex: node.value
+			}, "m"), node));
+			break;
+		case "break":
+			out.push(located(context, { type: "break" }, node));
+			break;
+		case "link":
+			out.push(located(context, context.ids.request({
+				type: "link",
+				id: "",
+				text: linkTextOf(context, node),
+				href: node.url
+			}, "link"), node));
+			break;
+		case "footnoteReference":
+			out.push(located(context, context.ids.request({
+				type: "note_ref",
+				id: "",
+				target: explicitIdOf(node.label ?? node.identifier, context.file, positionOf(node))
+			}, "fn"), node));
+			break;
+		case "mdxJsxTextElement":
+			collectElement(context, node, marks, out);
+			break;
+		case "mdxTextExpression":
+			if (!isCommentOnlyExpression(node)) failAt(context, node, "正文里不能写 {…} 表达式；只想写花括号就写成 \\{ \\}，注释写成 {/* … */}");
+			break;
+		case "image":
+		case "imageReference": failAt(context, node, "Markdown 图片 ![…](…) 不收：图写成 <Figure src=\"assets/…\">图题</Figure>");
+		case "linkReference": failAt(context, node, "不支持引用式链接 [文字][名字]：链接写成 [文字](https://…)");
+		case "delete": failAt(context, node, "不支持删除线 ~~…~~");
+		case "html": failAt(context, node, "不支持原始 HTML");
+		default: failAt(context, node, `这里不能写 ${node.type}`);
+	}
+}
+function collectElement(context, element, marks, out) {
+	const name = element.name;
+	if (name !== null && Object.hasOwn(MARK_ELEMENTS, name)) {
+		attributesOf(context, element, {});
+		collectInlines(context, element.children, [...marks, MARK_ELEMENTS[name]], out);
+		return;
+	}
+	switch (name) {
+		case "Ref": {
+			const attributes = attributesOf(context, element, {
+				to: "required",
+				show: "optional"
+			});
+			rejectChildren(context, element);
+			if (/\s/.test(attributes["to"].trim())) failAt(context, element, "<Ref> 的 to 只能写一个 id");
+			const [target] = idTargetsOf(context, element, attributes["to"]);
+			const show = attributes["show"];
+			if (show !== void 0 && show !== "number" && show !== "title") failAt(context, element, `<Ref> 的 show 只能是 number 或 title（不写就显示「图 3-2」这种全称），这里写的是「${show}」`);
+			const display = show ?? "label";
+			out.push(located(context, context.ids.request({
+				type: "ref",
+				id: "",
+				target,
+				display
+			}, "ref"), element));
+			return;
+		}
+		case "Cite": {
+			const attributes = attributesOf(context, element, { to: "required" });
+			rejectChildren(context, element);
+			out.push(located(context, context.ids.request({
+				type: "cite",
+				id: "",
+				targets: idTargetsOf(context, element, attributes["to"])
+			}, "cite"), element));
+			return;
+		}
+		case "br":
+			attributesOf(context, element, {});
+			rejectChildren(context, element);
+			out.push(located(context, { type: "break" }, element));
+			return;
+		default:
+			if (name !== null && BLOCK_COMPONENTS.has(name)) failAt(context, element, `<${name}> 要单独成段，前后空一行，不写在一段文字中间`);
+			failAt(context, element, `认不出组件 <${name ?? ""}>：行内只能用 Ref、Cite、sub、sup、strong、em、br`);
+	}
+}
+function linkTextOf(context, link) {
+	const inlines = [];
+	collectInlines(context, link.children, [], inlines);
+	if (inlines.some((inline) => inline.type !== "text" || inline.marks)) failAt(context, link, "链接文字只能是纯文字");
+	return inlines.map((inline) => inline.text).join("");
+}
+const sameMarks = (a, b) => (a.marks ?? []).join() === (b.marks ?? []).join();
+function mergedAdjacentTexts(inlines) {
+	const merged = [];
+	for (const inline of inlines) {
+		const previous = merged.at(-1);
+		if (inline.type === "text" && previous?.type === "text" && sameMarks(previous, inline)) previous.text += inline.text;
+		else merged.push(inline);
+	}
+	return merged;
+}
+/** 中日韩文字、全角标点与全角符号：软换行两侧都是它们时直接连上，不留空格 */
+const CJK = /[⺀-⿿　-〿぀-ヿ㄀-ㇿ㐀-䶿一-鿿豈-﫿︰-﹏＀-￯]/;
+function joinedSoftBreaks(inlines) {
+	const lastCharOf = (inline) => inline?.type === "text" ? inline.text.at(-1) : void 0;
+	const firstCharOf = (inline) => inline?.type === "text" ? inline.text[0] : void 0;
+	inlines.forEach((inline, index) => {
+		if (inline.type !== "text") return;
+		inline.text = inline.text.replace(/[ \t]*\r?\n[ \t]*/g, (match, offset, whole) => {
+			const before = offset > 0 ? whole[offset - 1] : lastCharOf(inlines[index - 1]);
+			const after = offset + match.length < whole.length ? whole[offset + match.length] : firstCharOf(inlines[index + 1]);
+			return before !== void 0 && after !== void 0 && CJK.test(before) && CJK.test(after) ? "" : " ";
+		});
+	});
+	return inlines.filter((inline) => inline.type !== "text" || inline.text !== "");
+}
+/** 图题这类行内内容的纯文字：图不写 alt 时拿它当 alt */
+function plainTextOf(inlines) {
+	return inlines.map((inline) => {
+		switch (inline.type) {
+			case "text": return inline.text;
+			case "math": return `$${inline.latex}$`;
+			case "link": return inline.text;
+			case "break": return " ";
+			default: return "";
+		}
+	}).join("").trim();
+}
+//#endregion
+//#region src/core/mdx/blocks.ts
+const ALLOWED_BLOCKS = {
+	top: /* @__PURE__ */ new Set([
+		"paragraph",
+		"list",
+		"figure",
+		"table",
+		"equation",
+		"code",
+		"bibliography",
+		"abstract"
+	]),
+	listItem: /* @__PURE__ */ new Set(["paragraph", "list"]),
+	cell: /* @__PURE__ */ new Set([
+		"paragraph",
+		"list",
+		"figure",
+		"table",
+		"equation",
+		"code"
+	]),
+	note: /* @__PURE__ */ new Set([
+		"paragraph",
+		"list",
+		"code"
+	]),
+	abstract: /* @__PURE__ */ new Set(["paragraph"])
+};
+const BLOCK_NAMES = {
+	paragraph: "段落",
+	list: "列表",
+	figure: "图",
+	table: "表",
+	equation: "公式",
+	code: "代码块",
+	bibliography: "<Bibliography />",
+	abstract: "<Abstract>"
+};
+const PLACE_NAMES = {
+	top: "正文",
+	listItem: "列表项",
+	cell: "表格单元格",
+	note: "脚注",
+	abstract: "<Abstract>"
+};
+const explicitOrRequested = (context, node, rawId, source, kind) => {
+	if (rawId !== void 0) node.id = explicitIdOf(rawId, context.file, positionOf(source));
+	else context.ids.request(node, kind);
+	return located(context, node, source);
+};
+/** 一个文件最外层的内容：按标题建节（# 是章），标题之间的块放进最近的节 */
+function sectionsOf(context, root, fileNumbering) {
+	const top = [];
+	const open = [];
+	for (const node of root.children) {
+		if (node.type === "yaml") continue;
+		if (node.type === "heading") {
+			while (open.length && open.at(-1).depth >= node.depth) open.pop();
+			const parent = open.at(-1);
+			const parentDepth = parent?.depth ?? 0;
+			if (node.depth !== parentDepth + 1) failAt(context, node, parentDepth === 0 ? `这里是文件里最外层的标题，要写成一级标题 #，写成了 ${node.depth} 级` : `标题跳级：上一级是 ${parentDepth} 级，这里写了 ${node.depth} 级`);
+			const section = sectionOf(context, node, !parent ? fileNumbering : parent.section.numbering === "none" ? "none" : "decimal");
+			(parent?.section.children ?? top).push(section);
+			open.push({
+				depth: node.depth,
+				section
+			});
+			continue;
+		}
+		(open.at(-1)?.section.children ?? top).push(...blocksOf(context, [node], "top"));
+	}
+	return top;
+}
+function sectionOf(context, heading, numbering) {
+	if (heading.children.some((child) => child.type !== "text")) failAt(context, heading, "标题里只能写文字（不能有公式、加粗、链接、组件）");
+	const raw = heading.children.map((child) => child.value).join("");
+	const anchor = /\s*\[#([^\]]*)\]\s*$/.exec(raw);
+	const title = (anchor ? raw.slice(0, anchor.index) : raw).trim();
+	if (!title) failAt(context, heading, "标题不能空");
+	const section = {
+		type: "section",
+		id: "",
+		title,
+		numbering,
+		children: []
+	};
+	if (anchor) {
+		section.id = explicitIdOf(anchor[1], context.file, positionOf(heading));
+		return located(context, section, heading);
+	}
+	context.ids.request(section, "sec", title);
+	return located(context, section, heading);
+}
+/** 一串块级 MDX → docreport 块；放在不允许的位置的块报错 */
+function blocksOf(context, nodes, place) {
+	const blocks = [];
+	for (const node of nodes) for (const block of blockOf(context, node, place)) {
+		if (!ALLOWED_BLOCKS[place].has(block.type)) failAt(context, node, `${PLACE_NAMES[place]}里不能放${BLOCK_NAMES[block.type] ?? block.type}`);
+		blocks.push(block);
+	}
+	return blocks;
+}
+const isWhitespaceText = (node) => node.type === "text" && !String(node.value).trim();
+function blockOf(context, node, place) {
+	switch (node.type) {
+		case "paragraph": {
+			const meaningful = node.children.filter((child) => !isCommentOnlyExpression(child) && !isWhitespaceText(child));
+			if (meaningful.length === 0) return [];
+			const only = meaningful.length === 1 ? meaningful[0] : void 0;
+			if (only?.type === "mdxJsxTextElement" && BLOCK_COMPONENTS.has(only.name)) return [componentOf(context, only, place)];
+			return [paragraphOf(context, node.children, node)];
+		}
+		case "list": return [listOf(context, node)];
+		case "code": return [codeOf(context, node)];
+		case "math":
+			if (node.meta) failAt(context, node, "$$ 公式不编号、不写 id；要编号或被引用就写成 ```math <id> 代码块");
+			return [located(context, context.ids.request({
+				type: "equation",
+				id: "",
+				latex: node.value,
+				numbered: false
+			}, "eq"), node)];
+		case "table": return [tableFromGfm(context, node, false, void 0, void 0)];
+		case "mdxJsxFlowElement": return [componentOf(context, node, place)];
+		case "mdxFlowExpression":
+			if (!isCommentOnlyExpression(node)) failAt(context, node, "正文里不能写 {…} 表达式；注释写成 {/* … */}");
+			return [];
+		case "footnoteDefinition": {
+			const id = explicitIdOf(node.label ?? node.identifier, context.file, positionOf(node));
+			context.notes.push(located(context, {
+				id,
+				blocks: blocksOf(context, node.children, "note")
+			}, node));
+			return [];
+		}
+		case "heading": return failAt(context, node, "标题只能写在文件的最外层，不能写进列表、组件或脚注");
+		case "mdxjsEsm": return failAt(context, node, "报告里不写 import / export：组件都是内置的");
+		case "blockquote": return failAt(context, node, "不支持引用块 >");
+		case "thematicBreak": return failAt(context, node, "不支持分隔线");
+		case "html": return failAt(context, node, "不支持原始 HTML");
+		case "definition": return failAt(context, node, "不支持链接定义 [名字]: 地址");
+		case "yaml": return failAt(context, node, "文件头只能写在文件开头");
+		default: return failAt(context, node, `这里不能写 ${node.type}`);
+	}
+}
+function paragraphOf(context, children, source) {
+	return located(context, context.ids.request({
+		type: "paragraph",
+		id: "",
+		content: inlinesOf(context, children)
+	}, "p"), source);
+}
+function listOf(context, node) {
+	const ordered = Boolean(node.ordered);
+	const list = {
+		type: "list",
+		id: "",
+		ordered,
+		items: []
+	};
+	if (ordered && typeof node.start === "number" && node.start !== 1) list.start = node.start;
+	for (const item of node.children) {
+		if (item.checked !== null && item.checked !== void 0) failAt(context, item, "不支持任务列表 [ ] / [x]");
+		list.items.push(located(context, context.ids.request({
+			id: "",
+			blocks: blocksOf(context, item.children, "listItem")
+		}, "li"), item));
+	}
+	return located(context, context.ids.request(list, "list"), node);
+}
+function codeOf(context, node) {
+	if (node.lang === "math") {
+		const meta = (node.meta ?? "").trim();
+		if (/\s/.test(meta)) failAt(context, node, "```math 后面只能写一个 id");
+		return explicitOrRequested(context, {
+			type: "equation",
+			id: "",
+			latex: node.value,
+			numbered: true
+		}, meta || void 0, node, "eq");
+	}
+	if (node.meta) failAt(context, node, `代码块的语言名 ${node.lang} 后面不能再写别的`);
+	return located(context, context.ids.request({
+		type: "code",
+		id: "",
+		language: node.lang ?? "text",
+		text: node.value
+	}, "code"), node);
+}
+function componentOf(context, element, place) {
+	switch (element.name) {
+		case "Figure": return figureOf(context, element);
+		case "Figures": return multiFigureOf(context, element);
+		case "Table": return numberedTableOf(context, element);
+		case "Abstract": return abstractOf(context, element, place);
+		case "Bibliography":
+			attributesOf(context, element, {});
+			if (element.children.some((child) => !isCommentOnlyExpression(child))) failAt(context, element, "<Bibliography /> 不收子内容");
+			return located(context, context.ids.request({
+				type: "bibliography",
+				id: ""
+			}, "bib"), element);
+		case "Reference": return failAt(context, element, "<Reference> 只能写在报告目录的 references.mdx 里");
+		case "Caption": return failAt(context, element, "<Caption> 只能写在 <Table> 或 <Figures> 里");
+		case "Panel": return failAt(context, element, "<Panel> 只能写在 <Figures> 里");
+		case "table":
+		case "tr":
+		case "th":
+		case "td": return failAt(context, element, `<${element.name}> 只能写在 <Table> 里：不编号的简单表格直接写 GFM 表格`);
+		default: return failAt(context, element, `认不出组件 <${element.name ?? ""}>：块级只能用 Figure、Figures、Table、Abstract、Bibliography`);
+	}
+}
+function captionOf(context, element, what) {
+	const caption = inlinesOf(context, phrasingChildrenOf(context, element));
+	if (!caption.length) failAt(context, element, `${what}不能空`);
+	return caption;
+}
+function figureOf(context, element) {
+	const attributes = attributesOf(context, element, {
+		id: "optional",
+		src: "required",
+		alt: "optional"
+	});
+	const caption = captionOf(context, element, "<Figure> 的图题");
+	return explicitOrRequested(context, {
+		type: "figure",
+		id: "",
+		src: attributes["src"],
+		caption,
+		alt: attributes["alt"] ?? plainTextOf(caption)
+	}, attributes["id"], element, "fig");
+}
+function multiFigureOf(context, element) {
+	const attributes = attributesOf(context, element, {
+		id: "optional",
+		rows: "required",
+		columns: "required"
+	});
+	const children = elementChildrenOf(context, element);
+	const captions = children.filter((child) => child.name === "Caption");
+	if (captions.length !== 1) failAt(context, element, "<Figures> 里要有且只有一个 <Caption> 写整个图的图题");
+	for (const child of children) if (child.name !== "Caption" && child.name !== "Panel") failAt(context, child, `<Figures> 里只能放 <Caption> 与 <Panel>，不能放 <${child.name}>`);
+	attributesOf(context, captions[0], {});
+	const caption = captionOf(context, captions[0], "<Figures> 的图题");
+	const panels = children.filter((child) => child.name === "Panel").map((panel) => panelOf(context, panel));
+	const figure = {
+		type: "figure",
+		id: "",
+		caption,
+		rows: positiveIntegerOf(context, element, "rows", attributes["rows"]),
+		columns: positiveIntegerOf(context, element, "columns", attributes["columns"]),
+		panels
+	};
+	return explicitOrRequested(context, figure, attributes["id"], element, "fig");
+}
+function panelOf(context, element) {
+	const attributes = attributesOf(context, element, {
+		id: "optional",
+		row: "required",
+		column: "required",
+		label: "required",
+		src: "required",
+		alt: "optional"
+	});
+	const caption = inlinesOf(context, phrasingChildrenOf(context, element));
+	const alt = attributes["alt"] ?? plainTextOf(caption);
+	if (!alt) failAt(context, element, "<Panel> 没有小标题时要写 alt");
+	const panel = {
+		id: "",
+		row: positiveIntegerOf(context, element, "row", attributes["row"]),
+		column: positiveIntegerOf(context, element, "column", attributes["column"]),
+		label: attributes["label"],
+		src: attributes["src"],
+		alt
+	};
+	if (caption.length) panel.caption = caption;
+	return explicitOrRequested(context, panel, attributes["id"], element, "panel");
+}
+function numberedTableOf(context, element) {
+	const attributes = attributesOf(context, element, { id: "optional" });
+	const parts = element.children.filter((child) => !isCommentOnlyExpression(child) && !isWhitespaceText(child)).flatMap((child) => child.type === "paragraph" ? child.children.filter((inner) => !isWhitespaceText(inner)) : [child]);
+	let caption;
+	if (parts[0]?.name === "Caption") {
+		attributesOf(context, parts[0], {});
+		caption = captionOf(context, parts.shift(), "<Caption> 的表题");
+	}
+	const body = parts[0];
+	if (parts.length !== 1 || !body || !(body.type === "table" || body.name === "table")) failAt(context, element, "<Table> 里先写可省的 <Caption>，再写一张表（GFM 表格或 <table>），别的不放");
+	return body.type === "table" ? tableFromGfm(context, body, true, caption, attributes["id"] ?? null, element) : tableFromJsx(context, body, caption, attributes["id"] ?? null, element);
+}
+function finishedTable(context, table, caption, rawId, source) {
+	if (caption) table.caption = caption;
+	return explicitOrRequested(context, table, rawId ?? void 0, source, "tbl");
+}
+function cellOf(context, blocks, source, spans = {}) {
+	return located(context, context.ids.request({
+		id: "",
+		...spans,
+		blocks
+	}, "cell"), source);
+}
+const columnsOf = (context, count) => Array.from({ length: count }, () => context.ids.request({ id: "" }, "col"));
+function tableFromGfm(context, node, numbered, caption, rawId, source = node) {
+	const rows = node.children;
+	const width = rows[0].children.length;
+	return finishedTable(context, {
+		type: "table",
+		id: "",
+		numbered,
+		headerRows: 1,
+		columns: columnsOf(context, width),
+		rows: rows.map((row) => {
+			if (row.children.length !== width) failAt(context, row, `这一行有 ${row.children.length} 格，表头有 ${width} 格：每行格数要和表头一样`);
+			return located(context, context.ids.request({
+				id: "",
+				cells: row.children.map((cell) => cellOf(context, [paragraphOf(context, cell.children, cell)], cell))
+			}, "row"), row);
+		})
+	}, caption, rawId, source);
+}
+function spanOf(context, cell, attributes, name) {
+	return attributes[name] === void 0 ? void 0 : positiveIntegerOf(context, cell, name, attributes[name]);
+}
+function jsxCellOf(context, cell) {
+	const attributes = attributesOf(context, cell, {
+		rowSpan: "optional",
+		colSpan: "optional"
+	});
+	const spans = {};
+	const rowSpan = spanOf(context, cell, attributes, "rowSpan"), colSpan = spanOf(context, cell, attributes, "colSpan");
+	if (rowSpan !== void 0) spans.rowSpan = rowSpan;
+	if (colSpan !== void 0) spans.colSpan = colSpan;
+	const children = cell.children.filter((child) => !isCommentOnlyExpression(child) && !isWhitespaceText(child));
+	return cellOf(context, children.length === 0 || cell.type === "mdxJsxTextElement" ? [paragraphOf(context, children, cell)] : blocksOf(context, children, "cell"), cell, spans);
+}
+function tableFromJsx(context, element, caption, rawId, source) {
+	attributesOf(context, element, {});
+	const rowElements = elementChildrenOf(context, element);
+	if (!rowElements.length) failAt(context, element, "<table> 里至少要有一行 <tr>");
+	let headerRows = 0, headerEnded = false;
+	const rows = rowElements.map((row) => {
+		if (row.name !== "tr") failAt(context, row, `<table> 里只能放 <tr>，不能放 <${row.name}>`);
+		attributesOf(context, row, {});
+		const cellElements = elementChildrenOf(context, row);
+		if (!cellElements.length) failAt(context, row, "<tr> 里至少要有一格");
+		for (const cell of cellElements) if (cell.name !== "th" && cell.name !== "td") failAt(context, cell, `<tr> 里只能放 <th> 与 <td>，不能放 <${cell.name}>`);
+		if (cellElements.every((cell) => cell.name === "th") && !headerEnded) headerRows++;
+		else {
+			headerEnded = true;
+			const header = cellElements.find((cell) => cell.name === "th");
+			if (header) failAt(context, header, "<th> 只能用在表格开头连续的表头行里");
+		}
+		return located(context, context.ids.request({
+			id: "",
+			cells: cellElements.map((cell) => jsxCellOf(context, cell))
+		}, "row"), row);
+	});
+	const width = rows[0].cells.reduce((sum, cell) => sum + (cell.colSpan ?? 1), 0);
+	return finishedTable(context, {
+		type: "table",
+		id: "",
+		numbered: true,
+		headerRows,
+		columns: columnsOf(context, width),
+		rows
+	}, caption, rawId, source);
+}
+function abstractOf(context, element, place) {
+	if (context.role !== "index" || place !== "top") failAt(context, element, "<Abstract> 只能写在 index.mdx 的正文最前面");
+	const attributes = attributesOf(context, element, {
+		keywords: "required",
+		title: "optional"
+	});
+	const keywords = attributes["keywords"].split("；").map((keyword) => keyword.trim());
+	if (keywords.some((keyword) => !keyword)) failAt(context, element, "<Abstract> 的 keywords 用全角分号「；」隔开，每个关键词都不能空");
+	const abstract = {
+		type: "abstract",
+		id: "",
+		paragraphs: blocksOf(context, element.children.filter((child) => !isWhitespaceText(child)), "abstract"),
+		keywords
+	};
+	if (attributes["title"] !== void 0) abstract["title"] = attributes["title"];
+	return located(context, context.ids.request(abstract, "abs"), element);
+}
+//#endregion
+//#region src/core/mdx/frontmatter.ts
+function frontmatterOf(root, file) {
+	const node = root.children.find((child) => child.type === "yaml");
+	if (!node) return void 0;
+	const at = positionOf(node);
+	let value;
+	try {
+		value = parse(node.value, { uniqueKeys: true });
+	} catch (error) {
+		throw new ReportContentError(`文件头不是合法的 YAML：${error.message}`, file, at);
+	}
+	if (value === null || value === void 0) return {
+		fields: {},
+		at
+	};
+	if (typeof value !== "object" || Array.isArray(value)) throw new ReportContentError("文件头要写成「键: 值」的映射", file, at);
+	return {
+		fields: value,
+		at
+	};
+}
+function rejectUnknownKeys(fields, allowed, file, at) {
+	for (const key of Object.keys(fields)) if (!allowed.includes(key)) throw new ReportContentError(`文件头认不出「${key}」：这里只能写 ${allowed.join("、")}`, file, at);
+}
+function stringField(fields, key, file, at) {
+	const value = fields[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new ReportContentError(`文件头的 ${key} 要是字符串`, file, at);
+	return value;
+}
+function stringListField(fields, key, file, at) {
+	const value = fields[key];
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new ReportContentError(`文件头的 ${key} 要是字符串列表`, file, at);
+	return value;
+}
+const INDEX_KEYS = [
+	"title",
+	"shortTitle",
+	"language",
+	"authors",
+	"date",
+	"revision",
+	"fields",
+	"chapters"
+];
+/** 入口 index.mdx 的文件头：报告元数据与章节列表 */
+function indexFrontmatterOf(root, file) {
+	const frontmatter = frontmatterOf(root, file);
+	if (!frontmatter) throw new ReportContentError("index.mdx 要有文件头（--- 包起来的 YAML），至少写 title 与 language", file, "1:1");
+	const { fields, at } = frontmatter;
+	rejectUnknownKeys(fields, INDEX_KEYS, file, at);
+	const title = stringField(fields, "title", file, at);
+	const language = stringField(fields, "language", file, at);
+	if (title === void 0) throw new ReportContentError("文件头缺少 title", file, at);
+	if (language === void 0) throw new ReportContentError("文件头缺少 language（中文报告写 zh-CN）", file, at);
+	const metadata = {
+		title,
+		language
+	};
+	const shortTitle = stringField(fields, "shortTitle", file, at);
+	const authors = stringListField(fields, "authors", file, at);
+	const date = stringField(fields, "date", file, at);
+	const revision = stringField(fields, "revision", file, at);
+	if (shortTitle !== void 0) metadata.shortTitle = shortTitle;
+	if (authors !== void 0) metadata.authors = authors;
+	if (date !== void 0) metadata.date = date;
+	if (revision !== void 0) metadata.revision = revision;
+	if (fields["fields"] !== void 0) metadata.fields = metadataFieldsOf(fields["fields"], file, at);
+	return {
+		metadata,
+		chapters: checkedChapterNames(stringListField(fields, "chapters", file, at) ?? [], file, at)
+	};
+}
+function metadataFieldsOf(value, file, at) {
+	const shapeError = new ReportContentError("文件头的 fields 要是列表，每项写 id、label、value 三个字符串", file, at);
+	if (!Array.isArray(value)) throw shapeError;
+	return value.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) throw shapeError;
+		const entry = item;
+		if (Object.keys(entry).some((key) => ![
+			"id",
+			"label",
+			"value"
+		].includes(key))) throw shapeError;
+		const [id, label, fieldValue] = [
+			entry["id"],
+			entry["label"],
+			entry["value"]
+		];
+		if (typeof id !== "string" || typeof label !== "string" || typeof fieldValue !== "string") throw shapeError;
+		return {
+			id,
+			label,
+			value: fieldValue
+		};
+	});
+}
+const RESERVED_FILE_NAMES = ["index.mdx", "references.mdx"];
+/** 章文件都放在报告目录根上：只收文件名，不收子目录与上级目录 */
+function checkedChapterNames(chapters, file, at) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const chapter of chapters) {
+		if (!/^[^\\/:*?"<>|\x00-\x1f]+\.mdx$/.test(chapter) || chapter.startsWith(".")) throw new ReportContentError(`chapters 里的「${chapter}」要是报告目录根上的 .mdx 文件名，不带目录`, file, at);
+		if (RESERVED_FILE_NAMES.includes(chapter)) throw new ReportContentError(`chapters 里不能写 ${chapter}`, file, at);
+		if (seen.has(chapter)) throw new ReportContentError(`chapters 里「${chapter}」写了两次`, file, at);
+		seen.add(chapter);
+	}
+	return chapters;
+}
+/** 章文件头只认 numbering，管这个文件里的一级标题；不写就是 decimal */
+function chapterNumberingOf(root, file) {
+	const frontmatter = frontmatterOf(root, file);
+	if (!frontmatter) return "decimal";
+	const { fields, at } = frontmatter;
+	rejectUnknownKeys(fields, ["numbering"], file, at);
+	const numbering = stringField(fields, "numbering", file, at) ?? "decimal";
+	if (numbering !== "decimal" && numbering !== "appendix" && numbering !== "none") throw new ReportContentError(`numbering 只能是 decimal、appendix 或 none，这里写的是「${numbering}」`, file, at);
+	return numbering;
+}
+function rejectFrontmatter(root, file, why) {
+	const node = root.children.find((child) => child.type === "yaml");
+	if (node) throw new ReportContentError(`${why}不写文件头`, file, positionOf(node));
+}
+//#endregion
+//#region src/core/mdx/compile.ts
+/** 报告目录里固定名字的两个文件 */
+const MDX_ENTRY_NAME = "index.mdx";
+const MDX_REFERENCES_NAME = "references.mdx";
+const directoryOf = (file) => file.includes("/") ? file.slice(0, file.lastIndexOf("/")) : "";
+const inDirectory = (directory, name) => directory ? `${directory}/${name}` : name;
+/** 读入口原文就知道还要读哪些文件：章按 chapters 的顺序，文献列表 references.mdx 有没有由调用方看磁盘 */
+function mdxReportInputsOf(indexText, entry) {
+	const { chapters } = indexFrontmatterOf(parseMdx(indexText, entry), entry);
+	return {
+		chapters: chapters.map((chapter) => inDirectory(directoryOf(entry), chapter)),
+		references: inDirectory(directoryOf(entry), MDX_REFERENCES_NAME)
+	};
+}
+function referencesOf(context, root) {
+	rejectFrontmatter(root, context.file, "references.mdx ");
+	const entries = [];
+	for (const node of root.children) {
+		if (isCommentOnlyExpression(node)) continue;
+		const element = node.type === "paragraph" && node.children.length === 1 ? node.children[0] : node;
+		if (element.type !== "mdxJsxFlowElement" && element.type !== "mdxJsxTextElement" || element.name !== "Reference") failAt(context, node, "references.mdx 里只能写 <Reference id=\"…\" url=\"…\">著录文字</Reference>，一条一段");
+		const attributes = attributesOf(context, element, {
+			id: "required",
+			url: "optional"
+		});
+		const text = inlinesOf(context, phrasingChildrenOf(context, element));
+		if (text.length !== 1 || text[0].type !== "text" || text[0].marks) failAt(context, element, "<Reference> 的著录文字只能是一行纯文字");
+		const entry = {
+			id: explicitIdOf(attributes["id"], context.file, positionOf(element)),
+			text: text[0].text
+		};
+		if (attributes["url"] !== void 0) entry.url = attributes["url"];
+		entries.push(located(context, entry, element));
+	}
+	return entries;
+}
+function locationsByPointer(document, locations) {
+	const sources = Object.create(null);
+	const byPointer = /* @__PURE__ */ new Map();
+	for (const { node, pointer } of walk(document)) {
+		const location = locations.get(node);
+		if (!location) continue;
+		byPointer.set(pointer, location);
+		if (typeof node.id === "string") sources[node.id] = location;
+	}
+	const locate = (pointer) => {
+		for (let current = pointer;; current = current.slice(0, current.lastIndexOf("/"))) {
+			const location = byPointer.get(current);
+			if (location) return location;
+			if (!current) return void 0;
+		}
+	};
+	return {
+		sources,
+		locate
+	};
+}
+/** 整份 MDX 报告 → 一份 docreport 文档（入口正文在前，各章按 chapters 的顺序接在后面）；只解析、不执行 MDX */
+function compileMdxReport({ reportId, entry, files }) {
+	if (!/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(reportId)) throw new ReportContentError(`报告目录名「${reportId}」不能当文档 id：MDX 报告的目录名要以字母开头`, entry);
+	const textOf = (file) => {
+		if (!Object.hasOwn(files, file)) throw new ReportContentError("找不到这个文件", file);
+		return files[file];
+	};
+	const ids = new GeneratedIds();
+	const locations = /* @__PURE__ */ new WeakMap();
+	const notes = [];
+	const contextFor = (file, role) => ({
+		file,
+		role,
+		ids,
+		locations,
+		notes
+	});
+	const indexRoot = parseMdx(textOf(entry), entry);
+	const { metadata, chapters } = indexFrontmatterOf(indexRoot, entry);
+	const blocks = sectionsOf(contextFor(entry, "index"), indexRoot, "decimal");
+	const chapterFiles = chapters.map((chapter) => inDirectory(directoryOf(entry), chapter));
+	for (const file of chapterFiles) {
+		const root = parseMdx(textOf(file), file);
+		blocks.push(...sectionsOf(contextFor(file, "chapter"), root, chapterNumberingOf(root, file)));
+	}
+	const referencesFile = inDirectory(directoryOf(entry), MDX_REFERENCES_NAME);
+	const hasReferences = Object.hasOwn(files, referencesFile);
+	const references = hasReferences ? referencesOf(contextFor(referencesFile, "references"), parseMdx(files[referencesFile], referencesFile)) : [];
+	ids.assignAll();
+	const document = {
+		format: "docreport",
+		schemaVersion: 1,
+		id: reportId,
+		metadata,
+		blocks
+	};
+	if (notes.length) document.notes = notes;
+	if (references.length) document.references = references;
+	return {
+		document,
+		...locationsByPointer(document, locations),
+		files: [
+			entry,
+			...chapterFiles,
+			...hasReferences ? [referencesFile] : []
+		]
+	};
+}
+function rawMessageOf(error) {
+	const prefix = `${error.file}${error.pointer ? ":" + error.pointer : ""}${error.file || error.pointer ? ": " : ""}`;
+	return error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message;
+}
+/** 组装报的错指着编译结果里的 JSON 指针：换成 MDX 文件与行列再抛 */
+function relocated(error, compiled, entry) {
+	if (!(error instanceof ReportContentError) || error.file !== entry) return error;
+	const location = compiled.locate(error.pointer);
+	return location ? new ReportContentError(rawMessageOf(error), location.file, location.pointer) : error;
+}
+/** 编译并组装一份 MDX 报告：结果和 JSON 报告的组装结果同形，sources 指向 MDX 的行列，dependencies 是编进来的 MDX 文件 */
+function assembleMdxReport(input, options = {}) {
+	const compiled = compileMdxReport(input);
+	let result;
+	try {
+		result = assembleDocument(input.entry, { [input.entry]: compiled.document }, options);
+	} catch (error) {
+		throw relocated(error, compiled, input.entry);
+	}
+	return {
+		...result,
+		sources: {
+			...result.sources,
+			...compiled.sources
+		},
+		dependencies: compiled.files
+	};
+}
+//#endregion
+//#region src/core/mdx/emit.ts
+const UNICODE_PUNCTUATION = /[\p{P}\p{S}]/u;
+const MARK_WRAP_ORDER = [
+	"code",
+	"sub",
+	"sup",
+	"em",
+	"strong"
+];
+/** Markdown 与 MDX 的特殊字符一律加反斜杠；GFM 会把网址与邮箱自动变成链接，冒号、点与 @ 也拆开 */
+function escapedText(text) {
+	return text.replace(/[\\`*_{}[\]<>$|~&#@]/g, (character) => `\\${character}`).replace(/:\/\//g, "\\://").replace(/www\./gi, (match) => `${match.slice(0, 3)}\\.`);
+}
+/** 一段的开头像列表、标题、引用的，再加一层转义 */
+function escapedLineStart(line) {
+	return line.replace(/^(\d+)([.)])/, "$1\\$2").replace(/^([-+])(\s|$)/, "\\$1$2");
+}
+function codeSpan(text) {
+	const longest = Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length));
+	const fence = "`".repeat(longest + 1);
+	const padding = text.startsWith("`") || text.endsWith("`") ? " " : "";
+	return `${fence}${padding}${text}${padding}${fence}`;
+}
+/** 加粗、斜体在内容首尾不是空白与标点时用 ** 与 *（中文旁边才认得出），否则用 <strong> 与 <em> */
+function wrappedWithMark(inner, plain, mark) {
+	if (mark === "sub" || mark === "sup") return `<${mark}>${inner}</${mark}>`;
+	const first = plain[0], last = plain.at(-1);
+	if (first !== void 0 && last !== void 0 && !/\s/.test(first) && !/\s/.test(last) && !UNICODE_PUNCTUATION.test(first) && !UNICODE_PUNCTUATION.test(last)) return mark === "strong" ? `**${inner}**` : `*${inner}*`;
+	return `<${mark}>${inner}</${mark}>`;
+}
+function attributeOf(name, value, problems, at) {
+	if (!value.includes("\"")) return ` ${name}="${value}"`;
+	if (!value.includes("'")) return ` ${name}='${value}'`;
+	problems.push(`${at}：${name} 里同时有单引号和双引号，写不成组件属性`);
+	return "";
+}
+var MdxWriter = class {
+	problems = [];
+	images = Object.create(null);
+	keptIds;
+	assets;
+	constructor(keptIds, assets) {
+		this.keptIds = keptIds;
+		this.assets = assets;
+	}
+	idAttribute(id, at) {
+		return id !== void 0 && this.keptIds.has(id) ? attributeOf("id", id, this.problems, at) : "";
+	}
+	/** 图片按文件名放进新报告的 assets/：同名不同图报错 */
+	imagePath(src, at) {
+		const original = this.assets[src] ?? src;
+		const name = original.slice(original.lastIndexOf("/") + 1);
+		const previous = this.images[name];
+		if (previous !== void 0 && previous !== src) this.problems.push(`${at}：图片 ${name} 和 ${previous} 同名，放进同一个 assets/ 会互相覆盖`);
+		this.images[name] = src;
+		return `assets/${name}`;
+	}
+	inlines(inlines, at) {
+		let previousWasMath = false;
+		return inlines.map((inline, index) => {
+			const here = `${at}/${index}`;
+			if (inline.type === "math" && previousWasMath) this.problems.push(`${here}：两个行内公式紧挨着，写成 $…$$…$ 会被读成一个`);
+			previousWasMath = inline.type === "math";
+			switch (inline.type) {
+				case "text": {
+					let written = (inline.marks ?? []).includes("code") ? codeSpan(inline.text) : escapedText(inline.text);
+					for (const mark of MARK_WRAP_ORDER) if (mark !== "code" && inline.marks?.includes(mark)) written = wrappedWithMark(written, inline.text, mark);
+					return written;
+				}
+				case "math":
+					if (inline.latex.includes("$") || /[\r\n]/.test(inline.latex)) this.problems.push(`${here}：行内公式里有 $ 或换行，写不成 $…$`);
+					return `$${inline.latex}$`;
+				case "ref": return `<Ref to="${inline.target}"${inline.display === "label" ? "" : ` show="${inline.display}"`} />`;
+				case "cite": return `<Cite to="${inline.targets.join(" ")}" />`;
+				case "link": return `[${escapedText(inline.text)}](${/[\s()<>]/.test(inline.href) ? `<${inline.href}>` : inline.href})`;
+				case "note_ref": return `[^${inline.target}]`;
+				case "break": return "<br />";
+			}
+		}).join("");
+	}
+	/** 段落各占一行写出；表格单元格里的段落不在行首，不用防它被读成列表，空段落就是空格子 */
+	paragraph(content, at, insideCell = false) {
+		if (!content.length && !insideCell) this.problems.push(`${at}：没有内容的段落在 MDX 里写不出来`);
+		const written = this.inlines(content, `${at}/content`);
+		return insideCell ? written : escapedLineStart(written);
+	}
+	/** 一个单元格：只有一段（含空段，即空格子）写成行内内容，否则 null（要写成块）；没有块的格子编译回来是一个空段 */
+	cellInline(blocks, at) {
+		if (blocks.length === 0) return "";
+		const only = blocks.length === 1 ? blocks[0] : void 0;
+		return only?.type === "paragraph" ? this.paragraph(only.content, `${at}/blocks/0`, true) : null;
+	}
+	/** 块之间空一行；相邻两个同类列表中间放一个注释，否则会并成一个列表 */
+	blocks(blocks, at, depth, parentNumbering) {
+		const lines = [];
+		blocks.forEach((block, index) => {
+			const previous = blocks[index - 1];
+			if (block.type === "list" && previous?.type === "list" && previous.ordered === block.ordered) lines.push("{/* 两个列表的分界 */}");
+			lines.push(this.block(block, `${at}/${index}`, depth, parentNumbering));
+		});
+		return lines;
+	}
+	block(block, at, depth, parentNumbering) {
+		switch (block.type) {
+			case "section": return this.section(block, at, depth, parentNumbering);
+			case "paragraph": return this.paragraph(block.content, at);
+			case "list": return this.list(block, at, "");
+			case "figure": return this.figure(block, at);
+			case "table": return this.table(block, at);
+			case "equation": {
+				if (!block.numbered) {
+					if (block.latex.includes("$$")) this.problems.push(`${at}：公式里有 $$，写不成 $$ 块`);
+					if (this.keptIds.has(block.id)) this.problems.push(`${at}：不编号的公式被引用或写在 layout.json 里，MDX 里不编号的公式没有 id`);
+					return `$$\n${block.latex}\n$$`;
+				}
+				const fence = "`".repeat(Math.max(3, ...(block.latex.match(/`{3,}/g) ?? []).map((run) => run.length + 1)));
+				return `${fence}math${this.keptIds.has(block.id) ? ` ${block.id}` : ""}\n${block.latex}\n${fence}`;
+			}
+			case "code": {
+				if (block.language === "math") this.problems.push(`${at}：语言是 math 的代码块在 MDX 里会被当成编号公式`);
+				const fence = "`".repeat(Math.max(3, ...(block.text.match(/`{3,}/g) ?? []).map((run) => run.length + 1)));
+				return `${fence}${block.language}\n${block.text}\n${fence}`;
+			}
+			case "bibliography":
+				this.problems.push(`${at}：<Bibliography /> 只能放在文末（不写时组装会补上）`);
+				return "";
+			case "abstract": return this.abstract(block, at);
+		}
+	}
+	abstract(block, at) {
+		if (block.keywords.some((keyword) => keyword.includes("；"))) this.problems.push(`${at}：关键词里有全角分号，<Abstract keywords> 用它分隔`);
+		const title = block.title !== void 0 ? attributeOf("title", block.title, this.problems, at) : "";
+		const paragraphs = block.paragraphs.map((paragraph, index) => this.paragraph(paragraph.content, `${at}/paragraphs/${index}`));
+		return `<Abstract keywords="${block.keywords.join("；")}"${title}>\n\n${paragraphs.join("\n\n")}\n\n</Abstract>`;
+	}
+	section(section, at, depth, parentNumbering) {
+		if (depth > 6) this.problems.push(`${at}：标题超过六级`);
+		const expected = parentNumbering === "none" ? "none" : "decimal";
+		if (depth > 1 && section.numbering !== expected) this.problems.push(`${at}：${parentNumbering} 节下面的 ${section.numbering} 子节在 MDX 里写不出来（子节跟着上级编号）`);
+		if (/\[#[^\]]*\]\s*$/.test(section.title)) this.problems.push(`${at}：标题末尾的 [#…] 会被当成节的 id`);
+		return [`${"#".repeat(depth)} ${escapedText(section.title)}${this.keptIds.has(section.id) ? ` [#${section.id}]` : ""}`, ...this.blocks(section.children, `${at}/children`, depth + 1, section.numbering)].join("\n\n");
+	}
+	list(list, at, indent) {
+		return list.items.map((item, index) => {
+			const marker = list.ordered ? `${(list.start ?? 1) + index}. ` : "- ";
+			const continuation = indent + " ".repeat(marker.length);
+			return item.blocks.map((block, blockIndex) => {
+				const here = `${at}/items/${index}/blocks/${blockIndex}`;
+				return block.type === "list" ? this.list(block, here, continuation) : this.paragraph(block.content, here);
+			}).map((part, partIndex) => partIndex === 0 ? `${indent}${marker}${part.trimStart()}` : part.startsWith(continuation) ? part : `${continuation}${part}`).join("\n\n");
+		}).join("\n");
+	}
+	figure(figure, at) {
+		const caption = this.inlines(figure.caption, `${at}/caption`);
+		if (!figure.panels) {
+			const alt = figure.alt === plainTextOf(figure.caption) ? "" : attributeOf("alt", figure.alt, this.problems, at);
+			return `<Figure${this.idAttribute(figure.id, at)} src="${this.imagePath(figure.src, at)}"${alt}>${caption}</Figure>`;
+		}
+		const panels = figure.panels.map((panel, index) => {
+			const here = `${at}/panels/${index}`;
+			const panelCaption = panel.caption ? this.inlines(panel.caption, `${here}/caption`) : "";
+			const alt = panel.caption && panel.alt === plainTextOf(panel.caption) ? "" : attributeOf("alt", panel.alt, this.problems, here);
+			const open = `  <Panel${this.idAttribute(panel.id, here)} row="${panel.row}" column="${panel.column}"${attributeOf("label", panel.label, this.problems, here)} src="${this.imagePath(panel.src, here)}"${alt}`;
+			return panelCaption ? `${open}>${panelCaption}</Panel>` : `${open} />`;
+		});
+		return [
+			`<Figures${this.idAttribute(figure.id, at)} rows="${figure.rows}" columns="${figure.columns}">`,
+			`  <Caption>${caption}</Caption>`,
+			...panels,
+			"</Figures>"
+		].join("\n");
+	}
+	table(table, at) {
+		const caption = table.caption ? this.inlines(table.caption, `${at}/caption`) : void 0;
+		if (!table.numbered) {
+			if (caption !== void 0) this.problems.push(`${at}：带表题的不编号表格在 MDX 里写不出来`);
+			if (!this.fitsGfm(table)) this.problems.push(`${at}：不编号的表格只能写成 GFM 表格，这张有合并单元格、多行表头或多段内容`);
+			return this.gfmTable(table, at);
+		}
+		const body = this.fitsGfm(table) ? this.gfmTable(table, at) : this.jsxTable(table, at);
+		return [
+			`<Table${this.idAttribute(table.id, at)}>`,
+			...caption !== void 0 ? [`  <Caption>${caption}</Caption>`] : [],
+			"",
+			body,
+			"",
+			"</Table>"
+		].join("\n");
+	}
+	fitsGfm(table) {
+		const fitsOneGfmCell = (blocks) => blocks.length === 0 || blocks.length === 1 && blocks[0].type === "paragraph" && blocks[0].content.every((inline) => inline.type !== "break" && (inline.type !== "math" || !inline.latex.includes("|")));
+		return table.headerRows === 1 && table.rows.every((row) => row.cells.length === table.columns.length && row.cells.every((cell) => !cell.rowSpan && !cell.colSpan && fitsOneGfmCell(cell.blocks)));
+	}
+	gfmTable(table, at) {
+		const lines = table.rows.map((row, rowIndex) => `| ${row.cells.map((cell, cellIndex) => this.cellInline(cell.blocks, `${at}/rows/${rowIndex}/cells/${cellIndex}`) ?? "").join(" | ")} |`);
+		lines.splice(1, 0, `| ${table.columns.map(() => "---").join(" | ")} |`);
+		return lines.join("\n");
+	}
+	jsxTable(table, at) {
+		return [
+			"<table>",
+			...table.rows.map((row, rowIndex) => {
+				const tag = rowIndex < table.headerRows ? "th" : "td";
+				return `  <tr>${row.cells.map((cell, cellIndex) => {
+					const here = `${at}/rows/${rowIndex}/cells/${cellIndex}`;
+					const spans = `${cell.rowSpan ? ` rowSpan="${cell.rowSpan}"` : ""}${cell.colSpan ? ` colSpan="${cell.colSpan}"` : ""}`;
+					const inline = this.cellInline(cell.blocks, here);
+					if (inline !== null) return `<${tag}${spans}>${inline}</${tag}>`;
+					return `<${tag}${spans}>\n\n${this.blocks(cell.blocks, `${here}/blocks`, 7, "decimal").join("\n\n")}\n\n</${tag}>`;
+				}).join("")}</tr>`;
+			}),
+			"</table>"
+		].join("\n");
+	}
+};
+const isGeneratedBibliography = (block, document) => block.type === "bibliography" && block.id === `${document.id.slice(0, 48)}_bibliography`;
+/** 哪些 id 要写出来：被 ref 指到的、layout.json 的键、文献与脚注（它们本来就靠 id 对应） */
+function keptIdsOf(document, layoutKeys) {
+	const kept = new Set(layoutKeys);
+	for (const { node } of walk(document)) if (node.type === "ref") kept.add(node.target);
+	for (const reference of document.references ?? []) kept.add(reference.id);
+	for (const note of document.notes ?? []) kept.add(note.id);
+	return kept;
+}
+function chapterFileNames(sections) {
+	const taken = /* @__PURE__ */ new Set([MDX_ENTRY_NAME, MDX_REFERENCES_NAME]);
+	return sections.map((section, index) => {
+		const preferred = /^[a-z0-9][a-z0-9-]{0,40}$/.test(section.id) ? `${section.id}.mdx` : `chapter-${index + 1}.mdx`;
+		const name = taken.has(preferred) ? `chapter-${index + 1}.mdx` : preferred;
+		taken.add(name);
+		return name;
+	});
+}
+/** GFM 只认同一个文件里的脚注定义：每条脚注的定义写进引用它的那个文件（入口正文或某一章）的末尾 */
+function notesByFile(document, frontBlocks, sections, names, writer) {
+	const fileOfNote = /* @__PURE__ */ new Map();
+	const collect = (value, file) => {
+		for (const { node } of walk(value)) if (node.type === "note_ref") fileOfNote.set(node.target, file);
+	};
+	collect(frontBlocks, MDX_ENTRY_NAME);
+	sections.forEach((section, index) => collect(section, names[index]));
+	const byFile = /* @__PURE__ */ new Map();
+	(document.notes ?? []).forEach((note, index) => {
+		const at = `/notes/${index}`;
+		const [first, ...rest] = note.blocks;
+		if (first?.type !== "paragraph" || rest.length) writer.problems.push(`${at}：脚注只转一段文字的，这条有 ${note.blocks.length} 块`);
+		const file = fileOfNote.get(note.id) ?? "index.mdx";
+		byFile.set(file, [...byFile.get(file) ?? [], `[^${note.id}]: ${first?.type === "paragraph" ? writer.paragraph(first.content, `${at}/blocks/0`) : ""}`]);
+	});
+	return byFile;
+}
+/** 组装好的文档 → MDX 报告。assets 是组装结果的 assets（图在组装结果里的路径 → 原图路径） */
+function mdxReportPlanOf(document, assets, layoutKeys) {
+	const keptIds = keptIdsOf(document, layoutKeys);
+	const writer = new MdxWriter(keptIds, assets);
+	const firstSection = document.blocks.findIndex((block) => block.type === "section");
+	const frontBlocks = (firstSection < 0 ? document.blocks : document.blocks.slice(0, firstSection)).filter((block, index, all) => !(firstSection < 0 && index === all.length - 1 && isGeneratedBibliography(block, document)));
+	const sections = [];
+	document.blocks.forEach((block, index) => {
+		if (index < firstSection || firstSection < 0) return;
+		if (block.type === "section") sections.push(block);
+		else if (!(index === document.blocks.length - 1 && isGeneratedBibliography(block, document))) writer.problems.push(`/blocks/${index}：第一章之后的顶层 ${block.type} 在 MDX 里写不出来（顶层内容只能写在 index.mdx 的正文、第一章之前）`);
+	});
+	const names = chapterFileNames(sections);
+	const notesOf = notesByFile(document, frontBlocks, sections, names, writer);
+	const files = Object.create(null);
+	for (const [index, section] of sections.entries()) {
+		const at = `/blocks/${firstSection + index}`;
+		const frontmatter = section.numbering === "decimal" ? "" : `---\nnumbering: ${section.numbering}\n---\n\n`;
+		files[names[index]] = `${frontmatter}${[writer.section(section, at, 1, "decimal"), ...notesOf.get(names[index]) ?? []].join("\n\n")}\n`;
+	}
+	const { metadata } = document;
+	const header = { title: metadata.title };
+	if (metadata.shortTitle !== void 0) header["shortTitle"] = metadata.shortTitle;
+	header["language"] = metadata.language;
+	if (metadata.authors !== void 0) header["authors"] = metadata.authors;
+	if (metadata.date !== void 0) header["date"] = metadata.date;
+	if (metadata.revision !== void 0) header["revision"] = metadata.revision;
+	if (metadata.fields !== void 0) header["fields"] = metadata.fields;
+	if (names.length) header["chapters"] = names;
+	const body = [...writer.blocks(frontBlocks, "/blocks", 1, "decimal"), ...notesOf.get("index.mdx") ?? []].join("\n\n");
+	files[MDX_ENTRY_NAME] = `---\n${stringify(header, { lineWidth: 0 })}---\n${body ? `\n${body}\n` : ""}`;
+	if (document.references?.length) files[MDX_REFERENCES_NAME] = `${document.references.map((reference, index) => `<Reference${attributeOf("id", reference.id, writer.problems, `/references/${index}`)}${reference.url !== void 0 ? attributeOf("url", reference.url, writer.problems, `/references/${index}`) : ""}>${escapedText(reference.text)}</Reference>`).join("\n\n")}\n`;
+	return {
+		files,
+		images: writer.images,
+		keptIds,
+		problems: writer.problems
+	};
+}
+//#endregion
+export { assembleMdxReport as a, GENERATED_ID_PREFIX as c, MDX_REFERENCES_NAME as i, mdxReportPlanOf as n, compileMdxReport as o, MDX_ENTRY_NAME as r, mdxReportInputsOf as s, keptIdsOf as t };