@godcreator/word-report 0.4.0 → 0.5.0

package/dist/mdx-C1RVv6E-.mjs

@@ -0,0 +1,1031 @@
+import { a as walk, r as stableValue, s as ReportContentError, t as assembleDocument } from "./assemble-BEt9_xsB.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 } 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([
+	"WordFigure",
+	"WordFigures",
+	"WordTable",
+	"WordAbstract",
+	"WordBibliography",
+	"WordReference",
+	"WordCaption",
+	"WordPanel",
+	"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 图片 ![…](…) 不收：图写成 <WordFigure src=\"assets/…\">图题</WordFigure>");
+		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 "WordRef": {
+			const attributes = attributesOf(context, element, {
+				to: "required",
+				show: "optional"
+			});
+			rejectChildren(context, element);
+			if (/\s/.test(attributes["to"].trim())) failAt(context, element, "<WordRef> 的 to 只能写一个 id");
+			const [target] = idTargetsOf(context, element, attributes["to"]);
+			const show = attributes["show"];
+			if (show !== void 0 && show !== "number" && show !== "title") failAt(context, element, `<WordRef> 的 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 "WordCite": {
+			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 "WordPlainMath": {
+			const attributes = attributesOf(context, element, { tex: "required" });
+			const plainText = plainMathRunsOf(context, element);
+			out.push(located(context, context.ids.request({
+				type: "math",
+				id: "",
+				latex: attributes["tex"],
+				plainText
+			}, "m"), 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 ?? ""}>：行内只能用 WordRef、WordCite、WordPlainMath、sub、sup、strong、em、br`);
+	}
+}
+const PLAIN_MATH_MARKS = [
+	"em",
+	"sub",
+	"sup"
+];
+/** <WordPlainMath> 里写给 Word 的文字：只收文字、斜体、下标、上标 */
+function plainMathRunsOf(context, element) {
+	const usage = "<WordPlainMath tex=\"…\"> 里写 Word 用的文字，只能用文字、*斜体*、<sub>、<sup>";
+	const inlines = inlinesOf(context, element.children);
+	if (!inlines.length) failAt(context, element, `${usage}，这里是空的`);
+	return inlines.map((inline) => {
+		if (inline.type !== "text") failAt(context, element, `${usage}，这里出现了 ${inline.type}`);
+		const marks = inline.marks ?? [];
+		const unsupported = marks.find((mark) => !PLAIN_MATH_MARKS.includes(mark));
+		if (unsupported !== void 0) failAt(context, element, `${usage}，这里出现了 ${unsupported}`);
+		if (marks.includes("sub") && marks.includes("sup")) failAt(context, element, "<WordPlainMath> 里同一段文字不能既是下标又是上标");
+		return marks.length ? {
+			text: inline.text,
+			marks
+		} : { text: inline.text };
+	});
+}
+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.plainText ? inline.plainText.map((run) => run.text).join("") : `$${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: "<WordBibliography />",
+	abstract: "<WordAbstract>"
+};
+const PLACE_NAMES = {
+	top: "正文",
+	listItem: "列表项",
+	cell: "表格单元格",
+	note: "脚注",
+	abstract: "<WordAbstract>"
+};
+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 "WordFigure": return figureOf(context, element);
+		case "WordFigures": return multiFigureOf(context, element);
+		case "WordTable": return numberedTableOf(context, element);
+		case "WordAbstract": return abstractOf(context, element, place);
+		case "WordBibliography":
+			attributesOf(context, element, {});
+			if (element.children.some((child) => !isCommentOnlyExpression(child))) failAt(context, element, "<WordBibliography /> 不收子内容");
+			return located(context, context.ids.request({
+				type: "bibliography",
+				id: ""
+			}, "bib"), element);
+		case "WordReference": return failAt(context, element, "<WordReference> 只能写在报告目录的 references.mdx 里");
+		case "WordCaption": return failAt(context, element, "<WordCaption> 只能写在 <WordTable> 或 <WordFigures> 里");
+		case "WordPanel": return failAt(context, element, "<WordPanel> 只能写在 <WordFigures> 里");
+		case "table":
+		case "tr":
+		case "th":
+		case "td": return failAt(context, element, `<${element.name}> 只能写在 <WordTable> 里：不编号的简单表格直接写 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, "<WordFigure> 的图题");
+	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 === "WordCaption");
+	if (captions.length !== 1) failAt(context, element, "<WordFigures> 里要有且只有一个 <WordCaption> 写整个图的图题");
+	for (const child of children) if (child.name !== "WordCaption" && child.name !== "WordPanel") failAt(context, child, `<WordFigures> 里只能放 <WordCaption> 与 <WordPanel>，不能放 <${child.name}>`);
+	attributesOf(context, captions[0], {});
+	const caption = captionOf(context, captions[0], "<WordFigures> 的图题");
+	const panels = children.filter((child) => child.name === "WordPanel").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, "<WordPanel> 没有小标题时要写 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 === "WordCaption") {
+		attributesOf(context, parts[0], {});
+		caption = captionOf(context, parts.shift(), "<WordCaption> 的表题");
+	}
+	const body = parts[0];
+	if (parts.length !== 1 || !body || !(body.type === "table" || body.name === "table")) failAt(context, element, "<WordTable> 里先写可省的 <WordCaption>，再写一张表（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, "<WordAbstract> 只能写在 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, "<WordAbstract> 的 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 !== "WordReference") failAt(context, node, "references.mdx 里只能写 <WordReference id=\"…\" url=\"…\">著录文字</WordReference>，一条一段");
+		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, "<WordReference> 的著录文字只能是一行纯文字");
+		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
+export { mdxReportInputsOf as a, compileMdxReport as i, MDX_REFERENCES_NAME as n, GENERATED_ID_PREFIX as o, assembleMdxReport as r, MDX_ENTRY_NAME as t };