@docen/docx 0.3.1 → 0.3.3

package/dist/converters/docx.mjs

@@ -1,2 +1,1353 @@
-import { a as generateDOCXSync, i as generateDOCXStream, n as compileDocument, o as parseDOCX, r as generateDOCX, s as resolveDocument, t as DocxManager } from "../docx-CONyAedl.mjs";
+import { BLOCKQUOTE_BORDER, applyBlockquoteStyle } from "../extensions/blockquote.mjs";
+import { renderDocx } from "../extensions/code-block.mjs";
+import { DETAILS_SUMMARY_STYLE, DETAILS_TAG } from "../extensions/details.mjs";
+import { parseDocx, renderDocx as renderDocx$1 } from "../extensions/heading.mjs";
+import { parseDocx as parseDocx$1, renderDocx as renderDocx$2 } from "../extensions/image.mjs";
+import { createMention, isMention, readMention } from "../extensions/mention.mjs";
+import { ORDERED_REFERENCE_PREFIX, buildOrderedLevels } from "../extensions/ordered-list.mjs";
+import { parseDocx as parseDocx$2, renderDocx as renderDocx$3 } from "../extensions/paragraph.mjs";
+import { parseDocx as parseDocx$3, renderDocx as renderDocx$4 } from "../extensions/strike.mjs";
+import { parseDocx as parseDocx$4, renderDocx as renderDocx$5 } from "../extensions/table.mjs";
+import { parseDocx as parseDocx$5, renderDocx as renderDocx$6 } from "../extensions/table-cell.mjs";
+import { parseDocx as parseDocx$6, renderDocx as renderDocx$7 } from "../extensions/table-header.mjs";
+import { parseDocx as parseDocx$7, renderDocx as renderDocx$8 } from "../extensions/table-row.mjs";
+import { createTaskCheckbox, isTaskCheckbox, readCheckboxState } from "../extensions/task-item.mjs";
+import { parseDocx as parseDocx$8, renderDocx as renderDocx$9 } from "../extensions/text-style.mjs";
+import { prepareDocument } from "./prepare.mjs";
+import { indexParagraphStyles } from "./styles.mjs";
+import { emojis, shortcodeToEmoji } from "@tiptap/extension-emoji";
+import { generateDocument, generateDocumentStream, generateDocumentSync, parseDocument } from "@office-open/docx";
+import { encodeBase64 } from "@office-open/core";
+//#region src/converters/docx.ts
+/** Remove keys with null/undefined values */
+function cleanAttrs(attrs) {
+	const result = {};
+	for (const [key, value] of Object.entries(attrs)) if (value !== null && value !== void 0) result[key] = value;
+	return result;
+}
+/** True when two cell-margin sets (w:tcMar / w:tblCellMar) match on every side's
+*  size — used to detect a cell that merely echoes the table's default so its
+*  redundant tcMar can be dropped for a near-identity round-trip. */
+function sameCellMargins(a, b) {
+	const sz = (m, k) => m[k]?.size ?? null;
+	return [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	].every((k) => sz(a, k) === sz(b, k));
+}
+/** Keys round-tripped between DocumentOptions core properties and `doc.attrs.core`. */
+const CORE_PROPERTY_KEYS = [
+	"title",
+	"subject",
+	"creator",
+	"keywords",
+	"description",
+	"lastModifiedBy",
+	"lastPrinted",
+	"created",
+	"modified",
+	"revision"
+];
+/**
+* DocumentOptions keys that DocxManager reconstructs (sections/numbering) or
+* carries in dedicated attrs (styles/background/core). Excluded from the
+* documentExtras pass-through so they aren't duplicated.
+*/
+const COMPILE_OWNED_KEYS = new Set([
+	"sections",
+	"numbering",
+	"styles",
+	"background",
+	...CORE_PROPERTY_KEYS
+]);
+/** Collect core properties present on DocumentOptions into a plain object. */
+function extractCoreProperties(docOpts) {
+	const source = docOpts;
+	const core = {};
+	for (const key of CORE_PROPERTY_KEYS) {
+		const value = source[key];
+		if (value !== void 0 && value !== null) core[key] = value;
+	}
+	return Object.keys(core).length > 0 ? core : null;
+}
+/** Merge consecutive text nodes with same marks */
+function mergeTextNodes(nodes) {
+	const result = [];
+	for (const node of nodes) {
+		if (node.type === "text" && result.length > 0 && result[result.length - 1].type === "text") {
+			const prev = result[result.length - 1];
+			if (JSON.stringify(prev.marks) === JSON.stringify(node.marks)) {
+				prev.text = (prev.text ?? "") + (node.text ?? "");
+				continue;
+			}
+		}
+		result.push({ ...node });
+	}
+	return result;
+}
+/**
+* Manages DOCX serialization (Tiptap JSON ↔ DocumentOptions).
+*
+* Each extension provides renderDocx/parseDocx for its own attrs mapping.
+* DocxManager handles tree walking, child assembly, and dispatching.
+*/
+var DocxManager = class {
+	numberingConfigs = [];
+	orderedInstanceCounter = 0;
+	resolveStyles;
+	compile(json) {
+		this.numberingConfigs = [];
+		this.orderedInstanceCounter = 0;
+		const sections = [];
+		let currentChildren = [];
+		if (json.content) for (const node of json.content) {
+			const child = this.compileSectionChild(node);
+			if (child) if (Array.isArray(child)) currentChildren.push(...child);
+			else currentChildren.push(child);
+			if (node.type === "paragraph") {
+				const na = node.attrs ?? {};
+				if (na.sectionProperties != null) {
+					sections.push(this.buildSection(currentChildren, na.sectionProperties, this.compileHeaderFooter(na.sectionHeaders ?? null), this.compileHeaderFooter(na.sectionFooters ?? null)));
+					currentChildren = [];
+				}
+			}
+		}
+		const docAttrs = json.attrs ?? {};
+		sections.push(this.buildSection(currentChildren, docAttrs.sectionProperties ?? null, this.compileHeaderFooter(docAttrs.sectionHeaders ?? null), this.compileHeaderFooter(docAttrs.sectionFooters ?? null)));
+		const styles = docAttrs.styles ?? void 0;
+		const core = docAttrs.core ?? void 0;
+		const background = docAttrs.background ?? void 0;
+		const documentExtras = docAttrs.documentExtras ?? void 0;
+		return {
+			sections,
+			...styles ? { styles } : {},
+			...core,
+			...background ? { background } : {},
+			...documentExtras,
+			...this.numberingConfigs.length > 0 ? { numbering: { config: this.numberingConfigs } } : {}
+		};
+	}
+	/** Assemble a SectionOptions from compiled children + optional layout/headers/footers. */
+	buildSection(children, properties, headers, footers) {
+		return {
+			children,
+			...properties ? { properties } : {},
+			...headers ? { headers } : {},
+			...footers ? { footers } : {}
+		};
+	}
+	/**
+	* Compile resolved header/footer slots (JSONContent[] per slot) back into
+	* SectionChild[] per slot. Returns undefined when no slot has content.
+	*/
+	compileHeaderFooter(slots) {
+		if (!slots) return void 0;
+		const group = {};
+		for (const slot of [
+			"default",
+			"first",
+			"even"
+		]) {
+			const json = slots[slot];
+			if (!json?.length) continue;
+			const children = [];
+			for (const node of json) {
+				const child = this.compileSectionChild(node);
+				if (!child) continue;
+				if (Array.isArray(child)) children.push(...child);
+				else children.push(child);
+			}
+			if (children.length > 0) group[slot] = children;
+		}
+		return Object.keys(group).length > 0 ? group : void 0;
+	}
+	/**
+	* Resolve a section's header/footer group (SectionChild[] per slot) into
+	* Tiptap JSON slots. Returns null when no slot has content.
+	*/
+	resolveHeaderFooter(group, numberingLookup) {
+		if (!group) return null;
+		const slots = {};
+		for (const slot of [
+			"default",
+			"first",
+			"even"
+		]) {
+			const children = group[slot];
+			if (children?.length) slots[slot] = this.resolveSectionChildren(children, numberingLookup);
+		}
+		return Object.keys(slots).length > 0 ? slots : null;
+	}
+	resolve(docOpts) {
+		this.resolveStyles = docOpts.styles ?? void 0;
+		const sections = docOpts.sections ?? [];
+		if (sections.length === 0) return {
+			type: "doc",
+			content: [{ type: "paragraph" }]
+		};
+		const numberingLookup = this.buildNumberingLookup(docOpts);
+		const content = [];
+		const lastIndex = sections.length - 1;
+		for (let i = 0; i < sections.length; i++) {
+			const section = sections[i];
+			const sectionContent = this.resolveSectionChildren(section.children ?? [], numberingLookup);
+			if (i < lastIndex) {
+				const sectAttrs = {
+					sectionProperties: section.properties ?? null,
+					sectionHeaders: this.resolveHeaderFooter(section.headers, numberingLookup),
+					sectionFooters: this.resolveHeaderFooter(section.footers, numberingLookup)
+				};
+				const last = sectionContent[sectionContent.length - 1];
+				if (last?.type === "paragraph") last.attrs = {
+					...last.attrs,
+					...sectAttrs
+				};
+				else sectionContent.push({
+					type: "paragraph",
+					attrs: sectAttrs
+				});
+			}
+			content.push(...sectionContent);
+		}
+		const doc = {
+			type: "doc",
+			content: content.length > 0 ? content : [{ type: "paragraph" }]
+		};
+		const attrs = {};
+		if (docOpts.styles) attrs.styles = docOpts.styles;
+		if (docOpts.background) attrs.background = docOpts.background;
+		const core = extractCoreProperties(docOpts);
+		if (core) attrs.core = core;
+		const lastSection = sections[lastIndex];
+		if (lastSection.properties) attrs.sectionProperties = lastSection.properties;
+		const lastHeaders = this.resolveHeaderFooter(lastSection.headers, numberingLookup);
+		if (lastHeaders) attrs.sectionHeaders = lastHeaders;
+		const lastFooters = this.resolveHeaderFooter(lastSection.footers, numberingLookup);
+		if (lastFooters) attrs.sectionFooters = lastFooters;
+		const documentExtras = {};
+		for (const [k, v] of Object.entries(docOpts)) {
+			if (COMPILE_OWNED_KEYS.has(k)) continue;
+			if (v === void 0 || v === null) continue;
+			documentExtras[k] = v;
+		}
+		if (Object.keys(documentExtras).length > 0) attrs.documentExtras = documentExtras;
+		if (Object.keys(attrs).length > 0) doc.attrs = attrs;
+		return doc;
+	}
+	compileSectionChild(node) {
+		switch (node.type) {
+			case "paragraph": return { paragraph: this.compileParagraphNode(node) };
+			case "heading": return { paragraph: this.compileHeadingNode(node) };
+			case "blockquote": {
+				const items = [];
+				for (const child of node.content ?? []) if (child.type === "paragraph" || child.type === "heading") {
+					const para = child.type === "heading" ? this.compileHeadingNode(child) : this.compileParagraphNode(child);
+					const paraObj = typeof para === "string" ? { text: para } : para;
+					applyBlockquoteStyle(paraObj);
+					items.push({ paragraph: paraObj });
+				}
+				return items.length > 0 ? items : null;
+			}
+			case "codeBlock": {
+				const opts = renderDocx(node);
+				const childList = this.compileInlineContent(node.content);
+				if (childList.length > 0) opts.children = childList;
+				return { paragraph: this.simplifyParagraph(opts) };
+			}
+			case "horizontalRule": return { paragraph: { thematicBreak: true } };
+			case "table": return { table: this.compileTableNode(node) };
+			case "image": {
+				const imageRun = renderDocx$2(node);
+				if (!imageRun) return null;
+				return { paragraph: { children: [imageRun] } };
+			}
+			case "bulletList":
+			case "orderedList":
+			case "taskList": return this.compileListFromNode(node, 0);
+			case "details": return this.compileDetailsNode(node);
+			case "tocField": {
+				const options = node.attrs?.options ?? {};
+				const entries = [];
+				for (const child of node.content ?? []) {
+					const compiled = this.compileSectionChild(child);
+					if (!compiled) continue;
+					if (Array.isArray(compiled)) entries.push(...compiled);
+					else entries.push(compiled);
+				}
+				return { toc: {
+					...options,
+					entries
+				} };
+			}
+			case "passthrough": {
+				const data = node.attrs?.data ?? "{}";
+				try {
+					return JSON.parse(data);
+				} catch {
+					return null;
+				}
+			}
+			default: return null;
+		}
+	}
+	compileParagraphNode(node) {
+		const opts = renderDocx$3(node);
+		const childList = this.compileInlineContent(node.content);
+		if (childList.length > 0) opts.children = childList;
+		return this.simplifyParagraph(opts);
+	}
+	compileHeadingNode(node) {
+		const opts = renderDocx$1(node);
+		const childList = this.compileInlineContent(node.content);
+		if (childList.length > 0) opts.children = childList;
+		return this.simplifyParagraph(opts);
+	}
+	/** Simple text optimization: merge plain runs into text field */
+	simplifyParagraph(opts) {
+		const children = opts.children;
+		if (!children || children.length === 0) return opts;
+		if (children.every((c) => typeof c === "object" && c !== null && "text" in c && Object.keys(c).length === 1)) {
+			const combined = children.map((c) => c.text).join("");
+			delete opts.children;
+			if (combined && Object.keys(opts).length === 0) return combined;
+			if (combined) opts.text = combined;
+		}
+		return opts;
+	}
+	compileTableNode(node) {
+		const opts = renderDocx$5(node);
+		const colCount = this.getTableColumnCount(node);
+		const tableCellMargins = opts.cellMargin ?? opts.margins ?? null;
+		const rows = [];
+		let activeSpans = [];
+		for (const rowNode of node.content ?? []) {
+			if (rowNode.type !== "tableRow") continue;
+			const rowOpts = renderDocx$8(rowNode);
+			const pmCells = (rowNode.content ?? []).filter((c) => c.type === "tableCell" || c.type === "tableHeader");
+			const currentSpans = [...activeSpans].sort((a, b) => a.colStart - b.colStart);
+			const newSpans = [];
+			const compiledCells = [];
+			let colIdx = 0;
+			let cellIdx = 0;
+			let spanIdx = 0;
+			while (spanIdx < currentSpans.length || cellIdx < pmCells.length) {
+				const nextSpanCol = spanIdx < currentSpans.length ? currentSpans[spanIdx].colStart : Infinity;
+				if (colIdx >= nextSpanCol) {
+					const span = currentSpans[spanIdx];
+					compiledCells.push({
+						verticalMerge: "continue",
+						columnSpan: span.colspan,
+						children: [{ paragraph: "" }]
+					});
+					colIdx += span.colspan;
+					spanIdx++;
+				} else {
+					const cell = this.compileTableCellNode(pmCells[cellIdx], tableCellMargins);
+					const cs = cell.columnSpan ?? 1;
+					const rs = cell.rowSpan ?? 1;
+					if (rs > 1) {
+						delete cell.rowSpan;
+						cell.verticalMerge = "restart";
+						newSpans.push({
+							colStart: colIdx,
+							colspan: cs,
+							remainingRows: rs - 1
+						});
+					}
+					compiledCells.push(cell);
+					colIdx += cs;
+					cellIdx++;
+				}
+			}
+			rowOpts.cells = compiledCells;
+			rows.push(rowOpts);
+			for (const span of currentSpans) span.remainingRows--;
+			activeSpans = [...currentSpans.filter((s) => s.remainingRows > 0), ...newSpans];
+		}
+		opts.rows = rows;
+		if (colCount > 0) {
+			const { columnWidths, tableWidth } = this.computeColumnWidths(node, colCount, opts);
+			opts.columnWidths = columnWidths;
+			if (!opts.width) opts.width = tableWidth;
+			if (!opts.layout) opts.layout = "autofit";
+		}
+		return opts;
+	}
+	/** Count grid columns from the first table row (summing colspan). */
+	getTableColumnCount(tableNode) {
+		for (const rowNode of tableNode.content ?? []) {
+			if (rowNode.type !== "tableRow") continue;
+			let count = 0;
+			for (const cell of rowNode.content ?? []) if (cell.type === "tableCell" || cell.type === "tableHeader") count += cell.attrs?.colspan ?? 1;
+			return count;
+		}
+		return 0;
+	}
+	/**
+	* Compute tblGrid column widths (twips) from first-row cell colwidth attrs.
+	* Returns columnWidths array and the appropriate tableWidth.
+	*/
+	computeColumnWidths(tableNode, colCount, _opts) {
+		const DEFAULT_CONTENT_TWIPS = 9026;
+		const tableColWidths = tableNode.attrs?.columnWidths;
+		if (tableColWidths && tableColWidths.length > 0) {
+			const filled = tableColWidths.slice(0, colCount);
+			while (filled.length < colCount) filled.push(filled[filled.length - 1] ?? Math.floor(DEFAULT_CONTENT_TWIPS / colCount));
+			return {
+				columnWidths: filled,
+				tableWidth: {
+					size: filled.reduce((a, b) => a + b, 0),
+					type: "dxa"
+				}
+			};
+		}
+		const widths = Array.from({ length: colCount }, () => null);
+		for (const rowNode of tableNode.content ?? []) {
+			if (rowNode.type !== "tableRow") continue;
+			let colIdx = 0;
+			for (const cell of rowNode.content ?? []) {
+				if (cell.type !== "tableCell" && cell.type !== "tableHeader") continue;
+				const colspan = cell.attrs?.colspan ?? 1;
+				const colwidth = cell.attrs?.colwidth;
+				if (colwidth) for (let i = 0; i < colspan && colIdx + i < colCount; i++) {
+					const px = colwidth[i] ?? colwidth[0];
+					if (px) widths[colIdx + i] = px * 15;
+				}
+				colIdx += colspan;
+			}
+			break;
+		}
+		if (!widths.some((w) => w !== null)) {
+			const equal = Math.floor(DEFAULT_CONTENT_TWIPS / colCount);
+			return {
+				columnWidths: Array(colCount).fill(equal),
+				tableWidth: {
+					size: 5e3,
+					type: "pct"
+				}
+			};
+		}
+		const explicit = widths.filter((w) => w !== null);
+		const avg = Math.floor(explicit.reduce((a, b) => a + b, 0) / explicit.length);
+		const filled = widths.map((w) => w ?? avg);
+		return {
+			columnWidths: filled,
+			tableWidth: {
+				size: filled.reduce((a, b) => a + b, 0),
+				type: "dxa"
+			}
+		};
+	}
+	compileTableCellNode(cellNode, tableMargins) {
+		const cellOpts = cellNode.type === "tableHeader" ? renderDocx$7(cellNode) : renderDocx$6(cellNode);
+		if (tableMargins && cellOpts.margins && sameCellMargins(cellOpts.margins, tableMargins)) delete cellOpts.margins;
+		const cellAlign = cellNode.attrs?.align ?? null;
+		const cellChildren = [];
+		for (const paraNode of cellNode.content ?? []) {
+			const para = this.compileParagraphNode(paraNode);
+			const paraObj = typeof para === "string" ? { text: para } : para;
+			if (cellAlign && !paraObj.alignment) paraObj.alignment = cellAlign;
+			cellChildren.push({ paragraph: paraObj });
+		}
+		if (cellChildren.length > 0) cellOpts.children = cellChildren;
+		return cellOpts;
+	}
+	compileListFromNode(node, level) {
+		const items = [];
+		const isOrdered = node.type === "orderedList";
+		const isTask = node.type === "taskList";
+		let ordered;
+		if (isOrdered) ordered = this.registerOrderedNumbering(node);
+		for (const listItem of node.content ?? []) {
+			if (listItem.type !== "listItem" && listItem.type !== "taskItem") continue;
+			const checked = Boolean(listItem.attrs?.checked);
+			for (const child of listItem.content ?? []) if (child.type === "paragraph" || child.type === "heading") {
+				const para = child.type === "heading" ? this.compileHeadingNode(child) : this.compileParagraphNode(child);
+				const paraObj = typeof para === "string" ? { text: para } : para;
+				if (ordered) paraObj.numbering = {
+					reference: ordered.reference,
+					instance: ordered.instance,
+					level
+				};
+				else paraObj.bullet = { level };
+				if (isTask) this.injectTaskCheckbox(paraObj, checked);
+				items.push({ paragraph: paraObj });
+			} else if (child.type === "bulletList" || child.type === "orderedList" || child.type === "taskList") {
+				const nested = this.compileListFromNode(child, level + 1);
+				if (nested) items.push(...nested);
+			}
+		}
+		return items.length > 0 ? items : null;
+	}
+	/**
+	* Register (or reuse) an abstractNum for an ordered list's `start`, and
+	* return a fresh instance so this list counts independently of other lists
+	* that share the same definition.
+	*/
+	registerOrderedNumbering(node) {
+		const start = Number(node.attrs?.start ?? 1) || 1;
+		let entry = this.numberingConfigs.find((c) => Number(c.levels[0]?.start ?? 1) === start);
+		if (!entry) {
+			entry = {
+				reference: `${ORDERED_REFERENCE_PREFIX}-${this.numberingConfigs.length + 1}`,
+				levels: buildOrderedLevels(start)
+			};
+			this.numberingConfigs.push(entry);
+		}
+		this.orderedInstanceCounter += 1;
+		return {
+			reference: entry.reference,
+			instance: this.orderedInstanceCounter
+		};
+	}
+	/**
+	* Prepend an inline checkbox SDT to a task paragraph. The SDT is tagged
+	* "docen-task" so resolve can tell task items apart from ordinary paragraphs
+	* that happen to contain an SDT.
+	*/
+	injectTaskCheckbox(paraObj, checked) {
+		let existing = [];
+		if (Array.isArray(paraObj.children)) existing = paraObj.children;
+		else if (typeof paraObj.text === "string") {
+			if (paraObj.text) existing = [{ text: paraObj.text }];
+			delete paraObj.text;
+		}
+		paraObj.children = [createTaskCheckbox(checked), ...existing];
+	}
+	/**
+	* details → block-level group-SDT. The summary paragraph is tagged with a
+	* fixed style so resolve can split it back out; content blocks flatten in
+	* after it. (No native collapse in DOCX — structure round-trips, the view
+	* stays expanded.)
+	*/
+	compileDetailsNode(node) {
+		const sdtChildren = [];
+		for (const child of node.content ?? []) if (child.type === "detailsSummary") {
+			const inline = this.compileInlineContent(child.content);
+			const summaryPara = { style: DETAILS_SUMMARY_STYLE };
+			if (inline.length > 0) summaryPara.children = inline;
+			sdtChildren.push({ paragraph: summaryPara });
+		} else if (child.type === "detailsContent") for (const block of child.content ?? []) {
+			const compiled = this.compileSectionChild(block);
+			if (!compiled) continue;
+			if (Array.isArray(compiled)) sdtChildren.push(...compiled);
+			else sdtChildren.push(compiled);
+		}
+		return { sdt: {
+			properties: {
+				tag: DETAILS_TAG,
+				group: true
+			},
+			children: sdtChildren
+		} };
+	}
+	compileInlineContent(content) {
+		if (!content) return [];
+		const children = [];
+		for (const node of content) switch (node.type) {
+			case "text":
+				this.compileTextNode(node, children);
+				break;
+			case "hardBreak":
+				children.push({ break: 1 });
+				break;
+			case "pageBreak":
+				children.push({ pageBreak: true });
+				break;
+			case "columnBreak":
+				children.push({ columnBreak: true });
+				break;
+			case "image": {
+				const imageRun = renderDocx$2(node);
+				if (imageRun) children.push(imageRun);
+				break;
+			}
+			case "wpgGroup": {
+				const wpgGroup = node.attrs?.wpgGroup;
+				if (wpgGroup) children.push({ wpgGroup });
+				break;
+			}
+			case "wpsShape": {
+				const wpsShape = node.attrs?.wpsShape;
+				if (wpsShape) children.push({ wpsShape });
+				break;
+			}
+			case "mention":
+				children.push(createMention(String(node.attrs?.id ?? ""), String(node.attrs?.label ?? "")));
+				break;
+			case "emoji": {
+				const name = String(node.attrs?.name ?? "");
+				const text = (name ? shortcodeToEmoji(name, emojis)?.emoji : void 0) ?? (name ? `:${name}:` : "");
+				if (text) children.push({ text });
+				break;
+			}
+		}
+		return children;
+	}
+	compileTextNode(node, children) {
+		const text = node.text ?? "";
+		if (!text) return;
+		const segments = text.split("\n");
+		for (let i = 0; i < segments.length; i++) {
+			if (i > 0) children.push({ break: 1 });
+			if (segments[i]) this.compileTextRun(segments[i], node.marks, children);
+		}
+	}
+	/** Emit a single run for `text` with all inline marks applied. */
+	compileTextRun(text, marks, children) {
+		const runOpts = { text };
+		for (const mark of marks ?? []) switch (mark.type) {
+			case "bold":
+				runOpts.bold = true;
+				break;
+			case "italic":
+				runOpts.italic = true;
+				break;
+			case "underline":
+				runOpts.underline = { type: "single" };
+				break;
+			case "strike": {
+				const strikeProps = renderDocx$4(mark.attrs ?? {});
+				Object.assign(runOpts, strikeProps);
+				break;
+			}
+			case "subscript":
+				runOpts.subScript = true;
+				break;
+			case "superscript":
+				runOpts.superScript = true;
+				break;
+			case "highlight":
+				runOpts.highlight = mark.attrs?.color ?? "yellow";
+				break;
+			case "code":
+				runOpts.style = "CodeChar";
+				runOpts.font = "Consolas";
+				break;
+			case "textStyle": {
+				const tsProps = renderDocx$9(mark.attrs ?? {});
+				Object.assign(runOpts, tsProps);
+				break;
+			}
+			case "link": {
+				const href = mark.attrs?.href;
+				if (href) {
+					const { text: _, ...runWithoutText } = runOpts;
+					const linkChildren = [];
+					if (text) linkChildren.push({
+						...runWithoutText,
+						text
+					});
+					children.push({ hyperlink: {
+						link: href.startsWith("#") ? void 0 : href,
+						anchor: href.startsWith("#") ? href.slice(1) : void 0,
+						children: linkChildren
+					} });
+					return;
+				}
+				break;
+			}
+		}
+		children.push(runOpts);
+	}
+	resolveSectionChild(child) {
+		if ("paragraph" in child) return this.resolveParagraph(child.paragraph);
+		if ("table" in child) return this.resolveTable(child.table);
+		if ("sdt" in child) {
+			const sdt = child.sdt;
+			if (sdt.properties?.tag === "docen-details") return this.resolveDetailsSdt(sdt);
+			return this.resolvePassthrough(child);
+		}
+		if ("toc" in child) return this.resolveToc(child.toc);
+		return this.resolvePassthrough(child);
+	}
+	/** Wrap an opaque SectionChild in a passthrough atom (attrs.data = JSON). */
+	resolvePassthrough(child) {
+		return {
+			type: "passthrough",
+			attrs: { data: JSON.stringify(child) }
+		};
+	}
+	/**
+	* Resolve a table of contents into an editable `tableOfContents` container:
+	* `attrs.options` carries the field switches, `content` is the entry
+	* paragraphs. Each entry's inner HYPERLINK field has content-less runs that
+	* office-open parses as `null`; resolving the entries through
+	* `resolveSectionChild` → `resolveParagraphChildren` drops those nulls, so the
+	* TOC no longer reaches the generate path as an opaque blob of nulls (the
+	* `stringifyRunInline(null).break` crash). When `entries` is absent/empty
+	* (a fresh, unrendered TOC), keep the node valid for `content: "block+"` with
+	* a placeholder empty paragraph.
+	*/
+	resolveToc(toc) {
+		const { entries, ...options } = toc;
+		const content = [];
+		for (const entry of entries ?? []) {
+			const node = this.resolveSectionChild(entry);
+			if (!node) continue;
+			if (Array.isArray(node)) content.push(...node);
+			else content.push(node);
+		}
+		if (content.length === 0) content.push({ type: "paragraph" });
+		const node = {
+			type: "tocField",
+			content
+		};
+		const cleanOptions = cleanAttrs(options);
+		if (Object.keys(cleanOptions).length > 0) node.attrs = { options: cleanOptions };
+		return node;
+	}
+	/**
+	* Resolve a details group-SDT: the summary-style paragraph becomes
+	* detailsSummary, the remaining blocks fold into detailsContent.
+	*/
+	resolveDetailsSdt(sdt) {
+		const content = [];
+		let summary = null;
+		for (const child of sdt.children ?? []) {
+			if ("paragraph" in child) {
+				const para = child.paragraph;
+				if (para.style === "DocenDetailsSummary") {
+					summary = this.resolveInlineContent(para);
+					continue;
+				}
+			}
+			const node = this.resolveSectionChild(child);
+			if (!node) continue;
+			if (Array.isArray(node)) content.push(...node);
+			else content.push(node);
+		}
+		const details = {
+			type: "details",
+			content: []
+		};
+		if (summary !== null) details.content.push({
+			type: "detailsSummary",
+			content: summary
+		});
+		if (content.length > 0) details.content.push({
+			type: "detailsContent",
+			content
+		});
+		return details;
+	}
+	resolveParagraph(opts) {
+		const resolved = typeof opts === "string" ? { text: opts } : opts;
+		if (resolved.thematicBreak) return { type: "horizontalRule" };
+		if (resolved.style === "Code") return this.resolveCodeBlock(resolved);
+		const headingLevel = this.detectHeadingLevel(resolved);
+		const nodeType = headingLevel ? "heading" : "paragraph";
+		const attrs = headingLevel ? parseDocx(resolved) : parseDocx$2(resolved);
+		if (headingLevel && attrs.level == null) attrs.level = headingLevel;
+		const content = this.resolveInlineContent(resolved);
+		const cleanAttrsObj = cleanAttrs(attrs);
+		const node = { type: nodeType };
+		if (Object.keys(cleanAttrsObj).length > 0) node.attrs = cleanAttrsObj;
+		if (content.length > 0) node.content = content;
+		return node;
+	}
+	/** Heading level (1-9) for a paragraph, or undefined when it isn't a heading.
+	*  DOCX marks a heading several ways, checked in priority order:
+	*  1. office-open lifts a HeadingLevel pStyle ("Heading1".."Title") into `heading`.
+	*  2. An explicit `outlineLevel` (0-8 → 1-9) — Word's outline/TOC key off this
+	*     even without a heading pStyle; the Heading1-9 styles carry outlineLvl 0-8.
+	*  3. A pStyle that names a heading style: directly ("Heading7", which stays on
+	*     `style` because office-open's HeadingLevel type caps at 6), by localized
+	*     NAME ("heading 1"/"标题 1"), or via the `basedOn` chain (a custom style
+	*     "MyTitle" basedOn="Heading1"). `heading` and `style` carry the same pStyle.
+	*  `outlineLevel` is read loosely — office-open's public type omits the field
+	*  even though it round-trips (w:outlineLvl) at runtime. */
+	detectHeadingLevel(resolved) {
+		if (resolved.heading) {
+			const lvl = HEADING_LEVEL_MAP[resolved.heading];
+			if (lvl) return lvl;
+		}
+		const outline = resolved.outlineLevel;
+		if (typeof outline === "number" && outline >= 0 && outline <= 8) return outline + 1;
+		const styleId = resolved.style;
+		if (!styleId || !this.resolveStyles) return void 0;
+		const byId = indexParagraphStyles(this.resolveStyles);
+		const visited = /* @__PURE__ */ new Set();
+		let curId = styleId;
+		while (curId && !visited.has(curId)) {
+			visited.add(curId);
+			if (HEADING_LEVEL_MAP[curId]) return HEADING_LEVEL_MAP[curId];
+			const style = byId.get(curId);
+			if (!style) break;
+			const lvl = headingLevelFromName(style.name);
+			if (lvl) return lvl;
+			curId = style.basedOn ?? void 0;
+		}
+	}
+	/** reference → level-0 format/start, for classifying numbering paragraphs. */
+	buildNumberingLookup(docOpts) {
+		const lookup = /* @__PURE__ */ new Map();
+		const config = docOpts.numbering?.config;
+		if (config) for (const entry of config) {
+			const lvl0 = entry.levels[0];
+			lookup.set(entry.reference, {
+				format: lvl0?.format,
+				start: lvl0?.start
+			});
+		}
+		return lookup;
+	}
+	/**
+	* Walk section children, grouping consecutive list paragraphs into nested
+	* Tiptap lists. Non-list children resolve individually. DOCX flattens lists
+	* to a paragraph sequence (depth carried by `level`); this rebuilds the tree.
+	*/
+	resolveSectionChildren(children, numberingLookup) {
+		const content = [];
+		let i = 0;
+		while (i < children.length) {
+			const child = children[i];
+			const firstPara = "paragraph" in child ? child.paragraph : null;
+			if (!(firstPara && typeof firstPara !== "string" ? this.detectList(firstPara, numberingLookup) : null)) {
+				if (firstPara && typeof firstPara !== "string" && this.detectBlockquote(firstPara)) {
+					const group = [];
+					while (i < children.length) {
+						const member = children[i];
+						if (!("paragraph" in member)) break;
+						const para = member.paragraph;
+						if (typeof para === "string" || !this.detectBlockquote(para)) break;
+						group.push(para);
+						i++;
+					}
+					content.push(this.buildBlockquote(group));
+					continue;
+				}
+				const node = this.resolveSectionChild(child);
+				if (node) content.push(node);
+				i++;
+				continue;
+			}
+			const group = [];
+			while (i < children.length) {
+				const member = children[i];
+				if (!("paragraph" in member)) break;
+				const para = member.paragraph;
+				if (typeof para === "string") break;
+				const info = this.detectList(para, numberingLookup);
+				if (!info) break;
+				group.push({
+					para,
+					info
+				});
+				i++;
+			}
+			content.push(...this.buildListTree(group));
+		}
+		return content;
+	}
+	/** Classify a paragraph as a list item, or null if it isn't one. */
+	detectList(para, lookup) {
+		const p = para;
+		const numbering = p.numbering;
+		const bullet = p.bullet;
+		let kind;
+		let level;
+		let reference;
+		let start;
+		if (numbering) {
+			reference = numbering.reference;
+			level = numbering.level ?? 0;
+			const cfg = reference ? lookup.get(reference) : void 0;
+			if (cfg && cfg.format && cfg.format !== "bullet") {
+				kind = "ordered";
+				start = cfg.start;
+			} else {
+				kind = "bullet";
+				reference = void 0;
+			}
+		} else if (bullet) {
+			kind = "bullet";
+			level = bullet.level ?? 0;
+		} else return null;
+		const first = p.children?.[0];
+		return {
+			kind: isTaskCheckbox(first) ? "task" : kind,
+			level,
+			reference,
+			start,
+			checked: readCheckboxState(first)
+		};
+	}
+	/**
+	* Rebuild nested Tiptap lists from a flat run of list paragraphs. Stack-based:
+	* each frame is an active list at a given depth; the `key` (level:type:
+	* reference) decides whether a paragraph continues the top list, starts a
+	* nested list, or splits off a new sibling list.
+	*/
+	buildListTree(group) {
+		const topLevel = [];
+		const stack = [];
+		for (const { para, info } of group) {
+			const listType = info.kind === "ordered" ? "orderedList" : info.kind === "task" ? "taskList" : "bulletList";
+			const itemType = info.kind === "task" ? "taskItem" : "listItem";
+			const key = `${info.level}:${listType}:${info.reference ?? ""}`;
+			while (stack.length > 0) {
+				const top = stack[stack.length - 1];
+				if (top.level > info.level || top.level === info.level && top.key !== key) {
+					stack.pop();
+					continue;
+				}
+				break;
+			}
+			const newItem = {
+				type: itemType,
+				content: [this.resolveListItemParagraph(para, info)]
+			};
+			if (itemType === "taskItem") newItem.attrs = { checked: info.checked };
+			const top = stack[stack.length - 1];
+			if (top && top.level === info.level && top.key === key) {
+				top.listNode.content.push(newItem);
+				top.currentItem = newItem;
+			} else {
+				const newList = {
+					type: listType,
+					content: [newItem]
+				};
+				if (listType === "orderedList" && info.level === 0 && typeof info.start === "number" && info.start !== 1) newList.attrs = { start: info.start };
+				if (top) top.currentItem.content.push(newList);
+				else topLevel.push(newList);
+				stack.push({
+					level: info.level,
+					key,
+					listNode: newList,
+					currentItem: newItem
+				});
+			}
+		}
+		return topLevel;
+	}
+	/** Classify a paragraph as a blockquote member by its signature. */
+	detectBlockquote(para) {
+		const p = para;
+		const indent = p.indent;
+		const border = p.border;
+		if (!indent || indent.left !== 720) return false;
+		const bl = border?.left;
+		if (!bl) return false;
+		const sig = BLOCKQUOTE_BORDER;
+		return bl.style === sig.style && bl.size === sig.size && bl.space === sig.space && bl.color === sig.color;
+	}
+	/**
+	* Rebuild a blockquote node from a run of signature-carrying paragraphs,
+	* stripping the indent/border signature so child paragraphs render clean.
+	*/
+	buildBlockquote(group) {
+		const content = [];
+		for (const para of group) {
+			const node = this.resolveParagraph(para);
+			const attrs = node.attrs;
+			if (attrs) {
+				if (attrs.indent) {
+					const indent = { ...attrs.indent };
+					delete indent.left;
+					attrs.indent = Object.keys(indent).length > 0 ? indent : void 0;
+				}
+				if (attrs.border) {
+					const border = { ...attrs.border };
+					delete border.left;
+					attrs.border = Object.keys(border).length > 0 ? border : void 0;
+				}
+				const cleaned = cleanAttrs(attrs);
+				if (Object.keys(cleaned).length > 0) node.attrs = cleaned;
+				else delete node.attrs;
+			}
+			content.push(node);
+		}
+		return {
+			type: "blockquote",
+			content
+		};
+	}
+	/**
+	* Resolve a list-item paragraph to a Tiptap paragraph/heading node, stripping
+	* the list marker (bullet/numbering) and the leading task checkbox — those
+	* are expressed at the list/item level, not inside the paragraph.
+	*/
+	resolveListItemParagraph(para, info) {
+		const resolved = typeof para === "string" ? { text: para } : para;
+		const headingLevel = this.detectHeadingLevel(resolved);
+		const nodeType = headingLevel ? "heading" : "paragraph";
+		const attrs = headingLevel ? parseDocx(resolved) : parseDocx$2(resolved);
+		if (headingLevel && attrs.level == null) attrs.level = headingLevel;
+		const stripped = info.kind === "task" ? this.stripTaskCheckbox(resolved) : resolved;
+		const content = this.resolveInlineContent(stripped);
+		const node = { type: nodeType };
+		const cleanAttrsObj = cleanAttrs(attrs);
+		if (Object.keys(cleanAttrsObj).length > 0) node.attrs = cleanAttrsObj;
+		if (content.length > 0) node.content = content;
+		return node;
+	}
+	/** Return a copy of `para` with its leading docen-task checkbox SDT removed. */
+	stripTaskCheckbox(para) {
+		const children = para.children;
+		if (Array.isArray(children) && children.length > 0 && isTaskCheckbox(children[0])) return {
+			...para,
+			children: children.slice(1)
+		};
+		return para;
+	}
+	resolveCodeBlock(opts) {
+		const children = opts.children;
+		const content = [];
+		if (children) {
+			for (const child of children) if (typeof child === "string") {
+				if (child) content.push({
+					type: "text",
+					text: child
+				});
+			} else if (typeof child === "object" && child !== null) {
+				if ("break" in child) {
+					const prev = content[content.length - 1];
+					if (prev && prev.type === "text") prev.text = (prev.text ?? "") + "\n";
+					else content.push({
+						type: "text",
+						text: "\n"
+					});
+				} else if ("text" in child) {
+					const marks = this.resolveMarks(child);
+					const textNode = {
+						type: "text",
+						text: child.text
+					};
+					if (marks) textNode.marks = marks;
+					content.push(textNode);
+				}
+			}
+		} else if (opts.text) content.push({
+			type: "text",
+			text: opts.text
+		});
+		const node = { type: "codeBlock" };
+		if (content.length > 0) node.content = content;
+		return node;
+	}
+	resolveTable(tableOpts) {
+		const attrs = parseDocx$4(tableOpts);
+		const rows = tableOpts.rows ?? [];
+		const content = [];
+		const tableCellMargins = tableOpts.cellMargin ?? tableOpts.margins ?? null;
+		let activeSpans = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const rowAttrs = parseDocx$7(row);
+			const cells = row.cells ?? [];
+			const cellNodes = [];
+			const nextActiveSpans = /* @__PURE__ */ new Map();
+			let colIdx = 0;
+			for (const cell of cells) {
+				const cellColspan = cell.columnSpan ?? 1;
+				const vMerge = cell.verticalMerge;
+				if (vMerge === "continue") {
+					const owner = activeSpans.get(colIdx);
+					if (owner) {
+						const ownerAttrs = owner.attrs ??= {};
+						ownerAttrs.rowspan = (ownerAttrs.rowspan ?? 1) + 1;
+						for (let c = colIdx; c < colIdx + cellColspan; c++) nextActiveSpans.set(c, owner);
+					}
+					colIdx += cellColspan;
+					continue;
+				}
+				const isHeader = row.tableHeader;
+				const cellAttrs = isHeader ? parseDocx$6(cell) : parseDocx$5(cell);
+				delete cellAttrs.verticalMerge;
+				if (!cellAttrs.margins && tableCellMargins) cellAttrs.margins = tableCellMargins;
+				const cellChildren = cell.children ?? [];
+				const cellContent = [];
+				for (const cc of cellChildren) {
+					const resolved = this.resolveSectionChild(cc);
+					if (resolved) cellContent.push(resolved);
+				}
+				const cellNode = { type: isHeader ? "tableHeader" : "tableCell" };
+				if (Object.keys(cellAttrs).length > 0) cellNode.attrs = cleanAttrs(cellAttrs);
+				if (cellContent.length > 0) cellNode.content = cellContent;
+				else cellNode.content = [{ type: "paragraph" }];
+				if (vMerge === "restart") for (let c = colIdx; c < colIdx + cellColspan; c++) nextActiveSpans.set(c, cellNode);
+				cellNodes.push(cellNode);
+				colIdx += cellColspan;
+			}
+			const gridAfter = row.gridAfter ?? 0;
+			if (gridAfter > 0) {
+				const trailingType = row.tableHeader ? "tableHeader" : "tableCell";
+				const nilBorders = {
+					top: { style: "nil" },
+					right: { style: "nil" },
+					bottom: { style: "nil" },
+					left: { style: "nil" }
+				};
+				for (let c = 0; c < gridAfter; c++) cellNodes.push({
+					type: trailingType,
+					attrs: { borders: nilBorders },
+					content: [{ type: "paragraph" }]
+				});
+				colIdx += gridAfter;
+			}
+			activeSpans = nextActiveSpans;
+			const rowNode = { type: "tableRow" };
+			if (Object.keys(rowAttrs).length > 0) rowNode.attrs = cleanAttrs(rowAttrs);
+			if (cellNodes.length > 0) rowNode.content = cellNodes;
+			content.push(rowNode);
+		}
+		const node = { type: "table" };
+		if (Object.keys(attrs).length > 0) node.attrs = cleanAttrs(attrs);
+		if (content.length > 0) node.content = content;
+		return node;
+	}
+	/**
+	* Resolve a paragraph's inline content. @office-open collapses a plain-text
+	* paragraph (a single run with no properties) to a bare string or a `{ text }`
+	* object with no `children` — recover that text here so it round-trips back to
+	* a text node instead of being dropped.
+	*/
+	resolveInlineContent(opts) {
+		const content = this.resolveParagraphChildren(opts.children);
+		if (content.length === 0 && opts.text) {
+			const marks = this.resolveMarks(opts);
+			const node = {
+				type: "text",
+				text: opts.text
+			};
+			if (marks) node.marks = marks;
+			return [node];
+		}
+		return content;
+	}
+	resolveParagraphChildren(children) {
+		if (!children || children.length === 0) return [];
+		const nodes = [];
+		for (const child of children) {
+			if (typeof child === "string") {
+				if (child) nodes.push({
+					type: "text",
+					text: child
+				});
+				continue;
+			}
+			if (typeof child === "object" && child !== null) {
+				const resolved = this.resolveParagraphChild(child);
+				if (resolved) nodes.push(...Array.isArray(resolved) ? resolved : [resolved]);
+			}
+		}
+		return nodes;
+	}
+	resolveParagraphChild(child) {
+		if ("text" in child || "children" in child || "break" in child) return this.resolveRun(child);
+		if ("image" in child) return this.resolveImage(child.image);
+		if ("wpgGroup" in child) return {
+			type: "wpgGroup",
+			attrs: { wpgGroup: child.wpgGroup }
+		};
+		if ("wpsShape" in child) return {
+			type: "wpsShape",
+			attrs: { wpsShape: child.wpsShape }
+		};
+		if ("sdt" in child) return this.resolveInlineSdt(child);
+		if ("hyperlink" in child) return this.resolveHyperlink(child.hyperlink);
+		if ("pageBreak" in child) return { type: "pageBreak" };
+		if ("columnBreak" in child) return { type: "columnBreak" };
+		return null;
+	}
+	/** Resolve an inline SDT (mention carrier; other inline SDTs unsupported). */
+	resolveInlineSdt(child) {
+		if (isMention(child)) {
+			const { id, label } = readMention(child);
+			return {
+				type: "mention",
+				attrs: {
+					id,
+					label
+				}
+			};
+		}
+		return null;
+	}
+	resolveRun(opts) {
+		if (opts.break && opts.text === void 0 && !opts.children) return { type: "hardBreak" };
+		const text = opts.text;
+		if (text === void 0 && !opts.children) return null;
+		if (opts.children && !text) {
+			const parts = [];
+			for (const c of opts.children) if (typeof c === "string") parts.push(c);
+			if (parts.length === 0) return null;
+			return {
+				type: "text",
+				text: parts.join(""),
+				marks: this.resolveMarks(opts)
+			};
+		}
+		return {
+			type: "text",
+			text: text ?? "",
+			marks: this.resolveMarks(opts)
+		};
+	}
+	resolveMarks(opts) {
+		const marks = [];
+		if (opts.bold) marks.push({ type: "bold" });
+		if (opts.italic) marks.push({ type: "italic" });
+		if (opts.underline) marks.push({ type: "underline" });
+		if (opts.strike) {
+			const strikeAttrs = parseDocx$3(opts);
+			marks.push({
+				type: "strike",
+				attrs: { doubleStrike: strikeAttrs.doubleStrike ?? null }
+			});
+		}
+		if (opts.subScript) marks.push({ type: "subscript" });
+		if (opts.superScript) marks.push({ type: "superscript" });
+		if (opts.highlight) marks.push({
+			type: "highlight",
+			attrs: { color: opts.highlight }
+		});
+		if (opts.style === "CodeChar") marks.push({ type: "code" });
+		const textStyleAttrs = parseDocx$8(opts);
+		if (opts.style === "CodeChar") {
+			delete textStyleAttrs.font;
+			delete textStyleAttrs.styleId;
+		}
+		if (Object.keys(textStyleAttrs).length > 0) marks.push({
+			type: "textStyle",
+			attrs: textStyleAttrs
+		});
+		return marks.length > 0 ? marks : void 0;
+	}
+	resolveImage(imageOpts) {
+		const attrs = parseDocx$1(imageOpts);
+		const data = imageOpts.data;
+		const type = imageOpts.type;
+		if (data && type) attrs.src = `data:image/${type};base64,${encodeBase64(data instanceof ArrayBuffer ? new Uint8Array(data) : data)}`;
+		return {
+			type: "image",
+			attrs
+		};
+	}
+	resolveHyperlink(hyperlink) {
+		const href = hyperlink.link ?? (hyperlink.anchor ? `#${hyperlink.anchor}` : "");
+		if (!href) return null;
+		const content = this.resolveParagraphChildren((hyperlink.children ?? []).map((c) => c));
+		if (content.length > 0) {
+			const merged = mergeTextNodes(content);
+			for (const node of merged) if (node.type === "text") node.marks = [...node.marks ?? [], {
+				type: "link",
+				attrs: {
+					href,
+					target: "_blank",
+					rel: "noopener noreferrer nofollow",
+					class: null,
+					title: hyperlink.tooltip ?? null
+				}
+			}];
+			return merged;
+		}
+		return null;
+	}
+};
+const HEADING_LEVEL_MAP = {
+	Heading1: 1,
+	Heading2: 2,
+	Heading3: 3,
+	Heading4: 4,
+	Heading5: 5,
+	Heading6: 6,
+	Heading7: 7,
+	Heading8: 8,
+	Heading9: 9,
+	Title: 1
+};
+/** Heading level (1-9) from a localized style NAME: "heading 1"/"标题 1" → 1,
+*  "title" → 1. office-open's built-in names are English ("heading 1"), but
+*  zh-CN Word labels the same styles "标题 1"; both map to the same level. */
+function headingLevelFromName(name) {
+	if (!name) return void 0;
+	const m = /^heading\s+(\d)$/i.exec(name) ?? /^标题\s*(\d)$/.exec(name);
+	if (m) {
+		const lvl = Number(m[1]);
+		if (lvl >= 1 && lvl <= 9) return lvl;
+	}
+	return /^title$/i.test(name) ? 1 : void 0;
+}
+const defaultManager = new DocxManager();
+/**
+* Parse a DOCX file into Tiptap JSON (runtime model).
+*
+* Combines @office-open/docx's `parseDocument` (DOCX binary → DocumentOptions)
+* with `DocxManager.resolve` (DocumentOptions → Tiptap JSON).
+*/
+function parseDOCX(data) {
+	return defaultManager.resolve(parseDocument(data));
+}
+/**
+* Merge {@link DocxGenerateOptions.document} into the `DocumentOptions`
+* compiled from Tiptap JSON.
+*
+* - `sections`/`numbering`: compile-owned (excluded from `document`, never
+*   overridden).
+* - `styles`/`externalStyles`: option wins over `json.attrs.styles`; the two
+*   are mutually exclusive, so `externalStyles` clears compiled `styles`.
+* - Everything else (core properties, background, features, …): injected.
+*/
+function applyDocumentOptions(base, document) {
+	if (!document) return base;
+	const merged = {
+		...base,
+		...document
+	};
+	if (document.externalStyles !== void 0) delete merged.styles;
+	return merged;
+}
+/**
+* Generate a DOCX file from Tiptap JSON (runtime model), asynchronously.
+*
+* Pipeline: `prepareDocument` (default: fetch http images, in place) →
+* `DocxManager.compile` → @office-open/docx's `generateDocument`. `packer.type`
+* controls the output format (default: `"nodebuffer"` → Buffer). Non-blocking
+* (fflate Web Workers). With the default `prepare`, the input `json` is mutated
+* in place (http image URLs become embedded data URLs).
+*/
+async function generateDOCX(json, options) {
+	const { prepare = true, packer, document } = options ?? {};
+	if (prepare !== false) await prepareDocument(json, prepare === true ? void 0 : prepare);
+	return generateDocument(applyDocumentOptions(compileDocument(json), document), packer);
+}
+/**
+* Generate a DOCX file synchronously — fastest throughput, blocks the event loop.
+*
+* Pipeline: `DocxManager.compile` → `generateDocumentSync`. Does **not** run
+* `prepareDocument` (it is async); call `await prepareDocument(json)` first
+* when http images need embedding. `options.document` is still applied.
+*/
+function generateDOCXSync(json, options) {
+	const { packer, document } = options ?? {};
+	return generateDocumentSync(applyDocumentOptions(compileDocument(json), document), packer);
+}
+/**
+* Generate a DOCX file as a `ReadableStream<Uint8Array>` — for large documents
+* or streaming HTTP responses.
+*
+* Pipeline: `prepareDocument` (default: fetch http images, in place) →
+* `DocxManager.compile` → `generateDocumentStream`. Async due to preparation.
+*/
+async function generateDOCXStream(json, options) {
+	const { prepare = true, packer, document } = options ?? {};
+	if (prepare !== false) await prepareDocument(json, prepare === true ? void 0 : prepare);
+	return generateDocumentStream(applyDocumentOptions(compileDocument(json), document), packer);
+}
+/**
+* Convert DocumentOptions (persistence model) to Tiptap JSON (runtime model).
+*/
+function resolveDocument(docOpts) {
+	return defaultManager.resolve(docOpts);
+}
+/**
+* Convert Tiptap JSON (runtime model) to DocumentOptions (persistence model).
+*/
+function compileDocument(json) {
+	return defaultManager.compile(json);
+}
+//#endregion
 export { DocxManager, compileDocument, generateDOCX, generateDOCXStream, generateDOCXSync, parseDOCX, resolveDocument };