@docen/docx 0.3.5 → 0.4.0

package/dist/converters/docx.mjs

@@ -1,30 +1,16 @@
-import { BLOCKQUOTE_BORDER, applyBlockquoteStyle } from "../extensions/blockquote.mjs";
-import { renderDocx } from "../extensions/code-block.mjs";
+import { alignmentFromCss } from "../extensions/utils.mjs";
+import { buildTextBlock } from "./styles.mjs";
+import { applyBlockquoteStyle } from "../extensions/blockquote.mjs";
+import { h as docxExtensions } from "../core-wNNPJiKr.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 { createTaskCheckbox } from "../extensions/task-item.mjs";
+import { createMention } 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 { flattenExtensions, getExtensionField, getSchema } from "@tiptap/core";
 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. */
@@ -37,6 +23,14 @@ function sameCellMargins(a, b) {
 		"left"
 	].every((k) => sz(a, k) === sz(b, k));
 }
+/** True when two single-side borders match on style/size/color — used to detect
+*  a cell side that merely echoes the table's insideHorizontal/insideVertical
+*  so it can be dropped for a near-identity round-trip (resolveTable pushes
+*  those table-level grid lines onto cell sides lacking their own tcBorder). */
+function sameBorder(a, b) {
+	if (!a || !b) return false;
+	return a.style === b.style && a.size === b.size && a.color === b.color;
+}
 /** Keys round-tripped between DocumentOptions core properties and `doc.attrs.core`. */
 const CORE_PROPERTY_KEYS = [
 	"title",
@@ -55,7 +49,7 @@ const CORE_PROPERTY_KEYS = [
 * carries in dedicated attrs (styles/background/core). Excluded from the
 * documentExtras pass-through so they aren't duplicated.
 */
-const COMPILE_OWNED_KEYS = new Set([
+const COMPILE_OWNED_KEYS = /* @__PURE__ */ new Set([
 	"sections",
 	"numbering",
 	"styles",
@@ -72,21 +66,6 @@ function extractCoreProperties(docOpts) {
 	}
 	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).
 *
@@ -97,6 +76,63 @@ var DocxManager = class {
 	numberingConfigs = [];
 	orderedInstanceCounter = 0;
 	resolveStyles;
+	resolveNumberingLookup;
+	markRender = /* @__PURE__ */ new Map();
+	markParse = [];
+	nodeRender = /* @__PURE__ */ new Map();
+	nodeParse = /* @__PURE__ */ new Map();
+	blockRules = [];
+	inlineRules = [];
+	paragraphRules = [];
+	aggregatorRules = [];
+	resolveCtx;
+	constructor(extensions = docxExtensions) {
+		const schema = getSchema(extensions);
+		for (const ext of flattenExtensions(extensions)) {
+			const name = ext.name;
+			if (!name) continue;
+			if (schema.marks[name]) {
+				const render = getExtensionField(ext, "renderDocx");
+				const parse = getExtensionField(ext, "parseDocx");
+				if (render) this.markRender.set(name, render);
+				if (parse) this.markParse.push({
+					name,
+					parse
+				});
+			} else if (schema.nodes[name]) {
+				const render = getExtensionField(ext, "renderDocx");
+				const parse = getExtensionField(ext, "parseDocx");
+				if (render) this.nodeRender.set(name, render);
+				if (parse) this.nodeParse.set(name, parse);
+				const blockRule = getExtensionField(ext, "parseDocxBlock");
+				if (blockRule) this.blockRules.push({
+					name,
+					rule: blockRule
+				});
+				const paraRule = getExtensionField(ext, "parseDocxParagraph");
+				if (paraRule) this.paragraphRules.push({
+					name,
+					rule: paraRule
+				});
+			}
+			const inlineRule = getExtensionField(ext, "parseDocxInline");
+			if (inlineRule) this.inlineRules.push({
+				name,
+				rule: inlineRule
+			});
+			const aggregator = getExtensionField(ext, "parseDocxAggregator");
+			if (aggregator) this.aggregatorRules.push({
+				name,
+				rule: aggregator
+			});
+		}
+	}
+	/** Reflective node renderDocx lookup: the node's DOCX opts, or {} when the
+	*  node type has no renderDocx hook (degrades to a plain paragraph). node.type
+	*  is optional on JSONContent — an absent type simply misses the map. */
+	renderNodeOpts(node) {
+		return this.nodeRender.get(node.type ?? "")?.(node) ?? {};
+	}
 	compile(json) {
 		this.numberingConfigs = [];
 		this.orderedInstanceCounter = 0;
@@ -170,7 +206,7 @@ var DocxManager = class {
 	* Resolve a section's header/footer group (SectionChild[] per slot) into
 	* Tiptap JSON slots. Returns null when no slot has content.
 	*/
-	resolveHeaderFooter(group, numberingLookup) {
+	resolveHeaderFooter(group) {
 		if (!group) return null;
 		const slots = {};
 		for (const slot of [
@@ -179,7 +215,7 @@ var DocxManager = class {
 			"even"
 		]) {
 			const children = group[slot];
-			if (children?.length) slots[slot] = this.resolveSectionChildren(children, numberingLookup);
+			if (children?.length) slots[slot] = this.resolveSectionChildren(children);
 		}
 		return Object.keys(slots).length > 0 ? slots : null;
 	}
@@ -190,17 +226,29 @@ var DocxManager = class {
 			type: "doc",
 			content: [{ type: "paragraph" }]
 		};
-		const numberingLookup = this.buildNumberingLookup(docOpts);
+		this.resolveNumberingLookup = this.buildNumberingLookup(docOpts);
+		const styles = this.resolveStyles;
+		this.resolveCtx = {
+			resolveBlockStream: (children) => this.resolveSectionChildren(children),
+			resolveBlock: (child) => this.resolveSectionChild(child),
+			resolveInlineContent: (para) => this.resolveInlineContent(para),
+			resolveInlineChildren: (children) => this.resolveParagraphChildren(children),
+			resolveParagraph: (para) => this.resolveParagraph(para),
+			parseNodeAttrs: (type, opts) => this.nodeParse.get(type)?.(opts) ?? {},
+			resolveMarks: (opts) => this.resolveMarks(opts),
+			styles,
+			numberingLookup: this.resolveNumberingLookup
+		};
 		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);
+			const sectionContent = this.resolveSectionChildren(section.children ?? []);
 			if (i < lastIndex) {
 				const sectAttrs = {
 					sectionProperties: section.properties ?? null,
-					sectionHeaders: this.resolveHeaderFooter(section.headers, numberingLookup),
-					sectionFooters: this.resolveHeaderFooter(section.footers, numberingLookup)
+					sectionHeaders: this.resolveHeaderFooter(section.headers),
+					sectionFooters: this.resolveHeaderFooter(section.footers)
 				};
 				const last = sectionContent[sectionContent.length - 1];
 				if (last?.type === "paragraph") last.attrs = {
@@ -226,9 +274,9 @@ var DocxManager = class {
 		if (core) attrs.core = core;
 		const lastSection = sections[lastIndex];
 		if (lastSection.properties) attrs.sectionProperties = lastSection.properties;
-		const lastHeaders = this.resolveHeaderFooter(lastSection.headers, numberingLookup);
+		const lastHeaders = this.resolveHeaderFooter(lastSection.headers);
 		if (lastHeaders) attrs.sectionHeaders = lastHeaders;
-		const lastFooters = this.resolveHeaderFooter(lastSection.footers, numberingLookup);
+		const lastFooters = this.resolveHeaderFooter(lastSection.footers);
 		if (lastFooters) attrs.sectionFooters = lastFooters;
 		const documentExtras = {};
 		for (const [k, v] of Object.entries(docOpts)) {
@@ -255,7 +303,7 @@ var DocxManager = class {
 				return items.length > 0 ? items : null;
 			}
 			case "codeBlock": {
-				const opts = renderDocx(node);
+				const opts = this.renderNodeOpts(node);
 				const childList = this.compileInlineContent(node.content);
 				if (childList.length > 0) opts.children = childList;
 				return { paragraph: this.simplifyParagraph(opts) };
@@ -263,7 +311,7 @@ var DocxManager = class {
 			case "horizontalRule": return { paragraph: { thematicBreak: true } };
 			case "table": return { table: this.compileTableNode(node) };
 			case "image": {
-				const imageRun = renderDocx$2(node);
+				const imageRun = this.nodeRender.get(node.type)?.(node) ?? null;
 				if (!imageRun) return null;
 				return { paragraph: { children: [imageRun] } };
 			}
@@ -297,13 +345,13 @@ var DocxManager = class {
 		}
 	}
 	compileParagraphNode(node) {
-		const opts = renderDocx$3(node);
+		const opts = this.renderNodeOpts(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 opts = this.renderNodeOpts(node);
 		const childList = this.compileInlineContent(node.content);
 		if (childList.length > 0) opts.children = childList;
 		return this.simplifyParagraph(opts);
@@ -321,14 +369,17 @@ var DocxManager = class {
 		return opts;
 	}
 	compileTableNode(node) {
-		const opts = renderDocx$5(node);
+		const opts = this.renderNodeOpts(node);
 		const colCount = this.getTableColumnCount(node);
 		const tableCellMargins = opts.cellMargin ?? opts.margins ?? null;
+		const tableBorders = opts.borders ?? null;
+		const insideH = tableBorders?.insideHorizontal ?? null;
+		const insideV = tableBorders?.insideVertical ?? null;
 		const rows = [];
 		let activeSpans = [];
 		for (const rowNode of node.content ?? []) {
 			if (rowNode.type !== "tableRow") continue;
-			const rowOpts = renderDocx$8(rowNode);
+			const rowOpts = this.nodeRender.get(rowNode.type)?.(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 = [];
@@ -349,7 +400,7 @@ var DocxManager = class {
 					colIdx += span.colspan;
 					spanIdx++;
 				} else {
-					const cell = this.compileTableCellNode(pmCells[cellIdx], tableCellMargins);
+					const cell = this.compileTableCellNode(pmCells[cellIdx], tableCellMargins, insideH, insideV);
 					const cs = cell.columnSpan ?? 1;
 					const rs = cell.rowSpan ?? 1;
 					if (rs > 1) {
@@ -446,16 +497,35 @@ var DocxManager = class {
 			}
 		};
 	}
-	compileTableCellNode(cellNode, tableMargins) {
-		const cellOpts = cellNode.type === "tableHeader" ? renderDocx$7(cellNode) : renderDocx$6(cellNode);
+	compileTableCellNode(cellNode, tableMargins, insideH, insideV) {
+		const cellOpts = this.renderNodeOpts(cellNode);
 		if (tableMargins && cellOpts.margins && sameCellMargins(cellOpts.margins, tableMargins)) delete cellOpts.margins;
-		const cellAlign = cellNode.attrs?.align ?? null;
+		if ((insideH || insideV) && cellOpts.borders) {
+			const b = cellOpts.borders;
+			if (insideH && sameBorder(b.top, insideH)) delete b.top;
+			if (insideH && sameBorder(b.bottom, insideH)) delete b.bottom;
+			if (insideV && sameBorder(b.left, insideV)) delete b.left;
+			if (insideV && sameBorder(b.right, insideV)) delete b.right;
+			if (Object.keys(b).length === 0) delete cellOpts.borders;
+		}
+		const cellAlign = alignmentFromCss(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 });
+		const pushChild = (child) => {
+			if (cellAlign && typeof child === "object" && child !== null && "paragraph" in child) {
+				const p = child.paragraph;
+				if (typeof p === "string") child.paragraph = {
+					text: p,
+					alignment: cellAlign
+				};
+				else if (p && typeof p === "object" && !p.alignment) p.alignment = cellAlign;
+			}
+			cellChildren.push(child);
+		};
+		for (const childNode of cellNode.content ?? []) {
+			const compiled = this.compileSectionChild(childNode);
+			if (compiled == null) continue;
+			if (Array.isArray(compiled)) compiled.forEach(pushChild);
+			else pushChild(compiled);
 		}
 		if (cellChildren.length > 0) cellOpts.children = cellChildren;
 		return cellOpts;
@@ -582,7 +652,7 @@ var DocxManager = class {
 				break;
 			}
 			case "image": {
-				const imageRun = renderDocx$2(node);
+				const imageRun = this.nodeRender.get(node.type)?.(node) ?? null;
 				if (imageRun) children.push(imageRun);
 				break;
 			}
@@ -630,69 +700,65 @@ var DocxManager = class {
 	/** 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;
+		for (const mark of marks ?? []) {
+			switch (mark.type) {
+				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;
 				}
-				break;
+				case "insertion":
+				case "deletion":
+					children.push(this.compileTrackedChangeRun(mark.type, mark.attrs, text, runOpts));
+					return;
 			}
+			const render = this.markRender.get(mark.type);
+			if (render) Object.assign(runOpts, render(mark.attrs ?? {}));
 		}
 		children.push(runOpts);
 	}
+	/**
+	* Wrap a run back into a w:ins/w:del container — the reverse of
+	* resolveTrackedChange. A literal-key ternary (`{insertion: body}` /
+	* `{deletion: body}`) lets TS narrow to the ParagraphChild branch without a
+	* cast, and `typeof` guards read `attrs` type-safely (no `as number/string`).
+	* stringifyDeletedRun emits `<w:delText>` automatically for deletion children.
+	*/
+	compileTrackedChangeRun(type, attrs, text, runOpts) {
+		const { text: _, ...runWithoutText } = runOpts;
+		const trackChildren = [];
+		if (text) trackChildren.push({
+			...runWithoutText,
+			text
+		});
+		const body = {
+			id: typeof attrs?.id === "number" ? attrs.id : 0,
+			author: typeof attrs?.author === "string" ? attrs.author : "",
+			date: typeof attrs?.date === "string" ? attrs.date : "",
+			children: trackChildren
+		};
+		return type === "insertion" ? { insertion: body } : { deletion: body };
+	}
 	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);
+		const ctx = this.resolveCtx;
+		for (const { rule } of this.blockRules) if (rule.match(child, ctx)) {
+			const node = rule.convert(child, ctx);
+			if (node) return node;
 		}
-		if ("toc" in child) return this.resolveToc(child.toc);
+		if ("paragraph" in child) return this.resolveParagraph(child.paragraph);
 		return this.resolvePassthrough(child);
 	}
 	/** Wrap an opaque SectionChild in a passthrough atom (attrs.data = JSON). */
@@ -702,116 +768,15 @@ var DocxManager = class {
 			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;
+		const ctx = this.resolveCtx;
+		for (const { rule } of this.paragraphRules) if (rule.match(resolved, ctx)) {
+			const node = rule.convert(resolved, ctx);
+			if (node) return node;
 		}
+		return buildTextBlock("paragraph", resolved, ctx);
 	}
 	/** reference → level-0 format/start, for classifying numbering paragraphs. */
 	buildNumberingLookup(docOpts) {
@@ -827,309 +792,43 @@ var DocxManager = class {
 		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.
+	* Walk a SectionChild[] block stream — a section's body, a header/footer
+	* slot, or a table cell's children (a cell is just another block stream). An
+	* aggregator rule (list/blockquote) claims consecutive paragraphs sharing its
+	* predicate and rebuilds them as a composite; everything else resolves
+	* individually via resolveSectionChild. The manager owns only the generic
+	* group-by loop — the predicate (belongs) + builder (build) come from each
+	* rule, so a custom composite plugs in by declaring parseDocxAggregator.
 	*/
-	resolveSectionChildren(children, numberingLookup) {
+	resolveSectionChildren(children) {
+		const ctx = this.resolveCtx;
 		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)) {
+			if (firstPara && typeof firstPara !== "string") {
+				const rule = this.aggregatorRules.find((r) => r.rule.belongs(firstPara, ctx));
+				if (rule) {
 					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;
+						if (typeof para === "string" || !rule.rule.belongs(para, ctx)) break;
 						group.push(para);
 						i++;
 					}
-					content.push(this.buildBlockquote(group));
+					content.push(...rule.rule.build(group, ctx));
 					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));
+			const node = this.resolveSectionChild(child);
+			if (node) content.push(node);
+			i++;
 		}
 		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";
-		} 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]
-				};
-				const listAttrs = {};
-				if (listType === "orderedList" && info.level === 0 && typeof info.start === "number" && info.start !== 1) listAttrs.start = info.start;
-				if (info.reference) listAttrs.numbering = info.reference;
-				if (Object.keys(listAttrs).length > 0) newList.attrs = listAttrs;
-				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 }`
@@ -1168,70 +867,17 @@ var DocxManager = class {
 		return nodes;
 	}
 	resolveParagraphChild(child) {
-		if ("tab" in child) return { type: "tab" };
-		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) {
-			const ws = child.wpsShape;
-			const content = [];
-			if (ws?.children) for (const para of ws.children) {
-				if (typeof para !== "object" || para === null) {
-					const node = this.resolveParagraph(para);
-					if (node) content.push(node);
-					continue;
-				}
-				const defRPr = para.run ?? {};
-				const children = Array.isArray(para.children) ? para.children.map((c) => typeof c !== "object" || c === null ? {
-					...defRPr,
-					text: c
-				} : {
-					...defRPr,
-					...c
-				}) : void 0;
-				const node = this.resolveParagraph({
-					...para,
-					run: void 0,
-					...children ? { children } : {}
-				});
-				if (node) content.push(node);
-			}
-			if (content.length === 0) content.push({ type: "paragraph" });
-			const { children: _omit, ...geometry } = ws ?? {};
-			const node = {
-				type: "wpsShape",
-				content
-			};
-			const cleanGeometry = cleanAttrs(geometry);
-			if (Object.keys(cleanGeometry).length > 0) node.attrs = { wpsShape: cleanGeometry };
-			return node;
+		const ctx = this.resolveCtx;
+		for (const { rule } of this.inlineRules) if (rule.match(child, ctx)) {
+			const node = rule.convert(child, ctx);
+			if (node) return node;
 		}
-		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" };
+		if ("text" in child || "children" in child || "break" in child) return this.resolveRun(child);
 		return {
 			type: "inlinePassthrough",
 			attrs: { data: JSON.stringify(child) }
 		};
 	}
-	/** 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;
@@ -1253,18 +899,21 @@ var DocxManager = class {
 			};
 			for (const c of opts.children) if (typeof c === "string") parts.push(c);
 			else if (c && typeof c === "object") {
-				if ("pageBreak" in c) {
-					flushText();
-					nodes.push({ type: "pageBreak" });
-				} else if ("columnBreak" in c) {
-					flushText();
-					nodes.push({ type: "columnBreak" });
-				} else if ("break" in c) {
+				const ctx = this.resolveCtx;
+				let handled = false;
+				for (const { rule } of this.inlineRules) if (rule.match(c, ctx)) {
+					const node = rule.convert(c, ctx);
+					if (node) {
+						flushText();
+						nodes.push(...Array.isArray(node) ? node : [node]);
+						handled = true;
+						break;
+					}
+				}
+				if (handled) continue;
+				if ("break" in c) {
 					flushText();
 					nodes.push({ type: "hardBreak" });
-				} else if ("tab" in c) {
-					flushText();
-					nodes.push({ type: "tab" });
 				}
 			}
 			flushText();
@@ -1287,98 +936,32 @@ var DocxManager = class {
 	}
 	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;
+		for (const { name, parse } of this.markParse) {
+			const attrs = parse(opts);
+			if (attrs === null) continue;
+			marks.push(Object.keys(attrs).length ? {
+				type: name,
+				attrs
+			} : { type: name });
 		}
-		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: href.startsWith("#") ? null : "_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(docxExtensions);
+/** Resolve a DocxManager for a conversion call: the shared default singleton
+*  when no extensions are given, or a fresh instance bound to custom extensions
+*  so user-supplied marks/nodes plug into compile/resolve without a fork. */
+function getDocxManager(extensions) {
+	return extensions ? new DocxManager(extensions) : defaultManager;
 }
-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));
+function parseDOCX(data, extensions) {
+	return getDocxManager(extensions).resolve(parseDocument(data));
 }
 /**
 * Merge {@link DocxGenerateOptions.document} into the `DocumentOptions`
@@ -1409,9 +992,9 @@ function applyDocumentOptions(base, document) {
 * in place (http image URLs become embedded data URLs).
 */
 async function generateDOCX(json, options) {
-	const { prepare = true, packer, document } = options ?? {};
+	const { prepare = true, packer, document, extensions } = options ?? {};
 	if (prepare !== false) await prepareDocument(json, prepare === true ? void 0 : prepare);
-	return generateDocument(applyDocumentOptions(compileDocument(json), document), packer);
+	return generateDocument(applyDocumentOptions(compileDocument(json, extensions), document), packer);
 }
 /**
 * Generate a DOCX file synchronously — fastest throughput, blocks the event loop.
@@ -1421,8 +1004,8 @@ async function generateDOCX(json, options) {
 * 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);
+	const { packer, document, extensions } = options ?? {};
+	return generateDocumentSync(applyDocumentOptions(compileDocument(json, extensions), document), packer);
 }
 /**
 * Generate a DOCX file as a `ReadableStream<Uint8Array>` — for large documents
@@ -1432,21 +1015,21 @@ function generateDOCXSync(json, options) {
 * `DocxManager.compile` → `generateDocumentStream`. Async due to preparation.
 */
 async function generateDOCXStream(json, options) {
-	const { prepare = true, packer, document } = options ?? {};
+	const { prepare = true, packer, document, extensions } = options ?? {};
 	if (prepare !== false) await prepareDocument(json, prepare === true ? void 0 : prepare);
-	return generateDocumentStream(applyDocumentOptions(compileDocument(json), document), packer);
+	return generateDocumentStream(applyDocumentOptions(compileDocument(json, extensions), document), packer);
 }
 /**
 * Convert DocumentOptions (persistence model) to Tiptap JSON (runtime model).
 */
-function resolveDocument(docOpts) {
-	return defaultManager.resolve(docOpts);
+function resolveDocument(docOpts, extensions) {
+	return getDocxManager(extensions).resolve(docOpts);
 }
 /**
 * Convert Tiptap JSON (runtime model) to DocumentOptions (persistence model).
 */
-function compileDocument(json) {
-	return defaultManager.compile(json);
+function compileDocument(json, extensions) {
+	return getDocxManager(extensions).compile(json);
 }
 //#endregion
 export { DocxManager, compileDocument, generateDOCX, generateDOCXStream, generateDOCXSync, parseDOCX, resolveDocument };