@docen/docx 0.3.2 → 0.3.4

package/dist/blockquote-DY80QC06.d.mts

@@ -0,0 +1,21 @@
+//#region src/extensions/blockquote.d.ts
+/**
+ * Blockquote extension — owns the DOCX expression of a blockquote.
+ *
+ * DOCX has no blockquote element; the convention is a left indent plus a left
+ * border on each contained paragraph. This module owns that signature; the
+ * DocxManager walks the blockquote's child paragraphs and applies it to each.
+ */
+/** Left indent (twips, ~0.5 inch) marking a blockquote. */
+declare const BLOCKQUOTE_INDENT_LEFT = 720;
+/** Left border marking a blockquote. */
+declare const BLOCKQUOTE_BORDER: {
+  readonly style: "single";
+  readonly size: 18;
+  readonly space: 12;
+  readonly color: "CCCCCC";
+};
+/** Apply the blockquote signature (left indent + left border) to paragraph opts. */
+declare function applyBlockquoteStyle(paraObj: Record<string, unknown>): void;
+//#endregion
+export { BLOCKQUOTE_INDENT_LEFT as n, applyBlockquoteStyle as r, BLOCKQUOTE_BORDER as t };

package/dist/bullet-list-DF60pnSL.d.mts

@@ -0,0 +1,12 @@
+//#region src/extensions/bullet-list.d.ts
+/**
+ * BulletList — carries the source DOCX abstractNum reference (when the list came
+ * from parseDOCX) so the round-trip reuses the original numbering definition
+ * (custom bullet glyph/font/indent, e.g. a Wingdings marker) instead of
+ * regenerating the default. The `numbering` attr is DOCX-only (not rendered
+ * to HTML); lists created in the editor carry null and compile to the default
+ * bullet.
+ */
+declare const BulletList: import("@tiptap/core").Node<import("@tiptap/extension-bullet-list").BulletListOptions, any>;
+//#endregion
+export { BulletList as t };

package/dist/converters/docx.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent } from "../core-C9VunJ8o.mjs";
+import { a as JSONContent } from "../core-DC0_-WcE.mjs";
 import { PrepareStep } from "./prepare.mjs";
 import { DocumentOptions, OutputByType, OutputType, PackerOptions, parseDocument } from "@office-open/docx";
 
@@ -68,15 +68,36 @@ declare class DocxManager {
   private resolveSectionChild;
   /** Wrap an opaque SectionChild in a passthrough atom (attrs.data = JSON). */
   private resolvePassthrough;
+  /**
+   * 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.
+   */
+  private resolveToc;
   /**
    * Resolve a details group-SDT: the summary-style paragraph becomes
    * detailsSummary, the remaining blocks fold into detailsContent.
    */
   private resolveDetailsSdt;
   private resolveParagraph;
-  /** Look up a paragraph style's NAME from its styleId, via the styles table
-   *  carried on the current resolve(). Returns undefined outside resolve. */
-  private styleNameOf;
+  /** 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. */
+  private detectHeadingLevel;
   /** reference → level-0 format/start, for classifying numbering paragraphs. */
   private buildNumberingLookup;
   /**

package/dist/converters/docx.mjs

@@ -14,6 +14,7 @@ import { parseDocx as parseDocx$7, renderDocx as renderDocx$8 } from "../extensi
 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";
@@ -119,13 +120,16 @@ var DocxManager = class {
 		const core = docAttrs.core ?? void 0;
 		const background = docAttrs.background ?? void 0;
 		const documentExtras = docAttrs.documentExtras ?? void 0;
+		const origNumberingConfig = docAttrs.numbering?.config ?? [];
+		const regeneratedRefs = new Set(this.numberingConfigs.map((c) => c.reference));
+		const numberingConfig = [...origNumberingConfig.filter((c) => !regeneratedRefs.has(c.reference)), ...this.numberingConfigs];
 		return {
 			sections,
 			...styles ? { styles } : {},
 			...core,
 			...background ? { background } : {},
 			...documentExtras,
-			...this.numberingConfigs.length > 0 ? { numbering: { config: this.numberingConfigs } } : {}
+			...numberingConfig.length > 0 ? { numbering: { config: numberingConfig } } : {}
 		};
 	}
 	/** Assemble a SectionOptions from compiled children + optional layout/headers/footers. */
@@ -217,6 +221,7 @@ var DocxManager = class {
 		const attrs = {};
 		if (docOpts.styles) attrs.styles = docOpts.styles;
 		if (docOpts.background) attrs.background = docOpts.background;
+		if (docOpts.numbering) attrs.numbering = docOpts.numbering;
 		const core = extractCoreProperties(docOpts);
 		if (core) attrs.core = core;
 		const lastSection = sections[lastIndex];
@@ -266,6 +271,20 @@ var DocxManager = class {
 			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 {
@@ -443,15 +462,20 @@ var DocxManager = class {
 		const items = [];
 		const isOrdered = node.type === "orderedList";
 		const isTask = node.type === "taskList";
+		const numbering = node.attrs?.numbering;
 		let ordered;
-		if (isOrdered) ordered = this.registerOrderedNumbering(node);
+		if (isOrdered && !numbering) 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 = {
+				if (numbering) paraObj.numbering = {
+					reference: numbering,
+					level
+				};
+				else if (ordered) paraObj.numbering = {
 					reference: ordered.reference,
 					instance: ordered.instance,
 					level
@@ -544,6 +568,17 @@ var DocxManager = class {
 			case "columnBreak":
 				children.push({ columnBreak: true });
 				break;
+			case "tab":
+				children.push({ tab: true });
+				break;
+			case "inlinePassthrough": {
+				const data = node.attrs?.data ?? "{}";
+				try {
+					const parsed = JSON.parse(data);
+					if (parsed) children.push(parsed);
+				} catch {}
+				break;
+			}
 			case "image": {
 				const imageRun = renderDocx$2(node);
 				if (imageRun) children.push(imageRun);
@@ -555,8 +590,18 @@ var DocxManager = class {
 				break;
 			}
 			case "wpsShape": {
-				const wpsShape = node.attrs?.wpsShape;
-				if (wpsShape) children.push({ wpsShape });
+				const geometry = node.attrs?.wpsShape ?? {};
+				const body = [];
+				for (const child of node.content ?? []) {
+					const compiled = this.compileSectionChild(child);
+					if (!compiled) continue;
+					const items = Array.isArray(compiled) ? compiled : [compiled];
+					for (const it of items) if (it && typeof it === "object" && "paragraph" in it) body.push(it.paragraph);
+				}
+				children.push({ wpsShape: {
+					...geometry,
+					children: body
+				} });
 				break;
 			}
 			case "mention":
@@ -645,6 +690,7 @@ var DocxManager = class {
 			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). */
@@ -655,6 +701,35 @@ var DocxManager = class {
 		};
 	}
 	/**
+	* 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.
 	*/
@@ -692,20 +767,10 @@ var DocxManager = class {
 		const resolved = typeof opts === "string" ? { text: opts } : opts;
 		if (resolved.thematicBreak) return { type: "horizontalRule" };
 		if (resolved.style === "Code") return this.resolveCodeBlock(resolved);
-		let headingLevel = resolved.heading ? HEADING_LEVEL_MAP[resolved.heading] : void 0;
-		if (!headingLevel && resolved.style) {
-			const name = this.styleNameOf(resolved.style);
-			if (name) {
-				const m = /^heading\s+(\d)$/i.exec(name);
-				if (m) {
-					const lvl = Number(m[1]);
-					if (lvl >= 1 && lvl <= 6) headingLevel = lvl;
-				} else if (/^title$/i.test(name)) headingLevel = 1;
-			}
-		}
-		if (headingLevel && !resolved.heading) resolved.heading = `Heading${headingLevel}`;
+		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 };
@@ -713,10 +778,38 @@ var DocxManager = class {
 		if (content.length > 0) node.content = content;
 		return node;
 	}
-	/** Look up a paragraph style's NAME from its styleId, via the styles table
-	*  carried on the current resolve(). Returns undefined outside resolve. */
-	styleNameOf(styleId) {
-		return this.resolveStyles?.paragraphStyles?.find((p) => p.id === styleId)?.name;
+	/** 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) {
@@ -795,10 +888,7 @@ var DocxManager = class {
 			if (cfg && cfg.format && cfg.format !== "bullet") {
 				kind = "ordered";
 				start = cfg.start;
-			} else {
-				kind = "bullet";
-				reference = void 0;
-			}
+			} else kind = "bullet";
 		} else if (bullet) {
 			kind = "bullet";
 			level = bullet.level ?? 0;
@@ -847,7 +937,10 @@ var DocxManager = class {
 					type: listType,
 					content: [newItem]
 				};
-				if (listType === "orderedList" && info.level === 0 && typeof info.start === "number" && info.start !== 1) newList.attrs = { start: info.start };
+				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({
@@ -909,9 +1002,10 @@ var DocxManager = class {
 	*/
 	resolveListItemParagraph(para, info) {
 		const resolved = typeof para === "string" ? { text: para } : para;
-		const headingLevel = resolved.heading ? HEADING_LEVEL_MAP[resolved.heading] : void 0;
+		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 };
@@ -1072,21 +1166,55 @@ 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) return {
-			type: "wpsShape",
-			attrs: { wpsShape: child.wpsShape }
-		};
+		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;
+		}
 		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;
+		return {
+			type: "inlinePassthrough",
+			attrs: { data: JSON.stringify(child) }
+		};
 	}
 	/** Resolve an inline SDT (mention carrier; other inline SDTs unsupported). */
 	resolveInlineSdt(child) {
@@ -1106,15 +1234,48 @@ var DocxManager = class {
 		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)
+		if (opts.children) {
+			const marks = this.resolveMarks(opts);
+			const nodes = [];
+			let parts = [];
+			const flushText = () => {
+				if (parts.length > 0) {
+					const node = {
+						type: "text",
+						text: parts.join("")
+					};
+					if (marks) node.marks = marks;
+					nodes.push(node);
+					parts = [];
+				}
 			};
+			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) {
+					flushText();
+					nodes.push({ type: "hardBreak" });
+				} else if ("tab" in c) {
+					flushText();
+					nodes.push({ type: "tab" });
+				}
+			}
+			flushText();
+			if (text !== void 0) {
+				const node = {
+					type: "text",
+					text,
+					marks
+				};
+				nodes.push(node);
+			}
+			if (nodes.length === 0) return null;
+			return nodes.length === 1 ? nodes[0] : nodes;
 		}
 		return {
 			type: "text",
@@ -1172,7 +1333,7 @@ var DocxManager = class {
 				type: "link",
 				attrs: {
 					href,
-					target: "_blank",
+					target: href.startsWith("#") ? null : "_blank",
 					rel: "noopener noreferrer nofollow",
 					class: null,
 					title: hyperlink.tooltip ?? null
@@ -1190,8 +1351,23 @@ const HEADING_LEVEL_MAP = {
 	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).

package/dist/converters/html.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent, i as Extensions } from "../core-C9VunJ8o.mjs";
+import { a as JSONContent, i as Extensions } from "../core-DC0_-WcE.mjs";
 import { ParseOptions } from "@tiptap/pm/model";
 
 //#region src/converters/html.d.ts

package/dist/converters/html.mjs

@@ -1,4 +1,4 @@
-import { s as docxExtensions } from "../core-DT9IrTzN.mjs";
+import { o as docxExtensions } from "../core-BnF8XhVE.mjs";
 import { sectionLinePitchCss, sectionMarginCss } from "../extensions/utils.mjs";
 import { getSchema } from "@tiptap/core";
 import { encodeBase64 } from "@office-open/core";

package/dist/converters/markdown.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent } from "../core-C9VunJ8o.mjs";
+import { a as JSONContent } from "../core-DC0_-WcE.mjs";
 
 //#region src/converters/markdown.d.ts
 /**

package/dist/converters/markdown.mjs

@@ -1,4 +1,4 @@
-import { s as docxExtensions } from "../core-DT9IrTzN.mjs";
+import { o as docxExtensions } from "../core-BnF8XhVE.mjs";
 import { Markdown, MarkdownManager } from "@tiptap/markdown";
 //#region src/converters/markdown.ts
 const markdownManager = new MarkdownManager({ extensions: [...docxExtensions, Markdown] });

package/dist/converters/patch.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent } from "../core-C9VunJ8o.mjs";
+import { a as JSONContent } from "../core-DC0_-WcE.mjs";
 import { PrepareStep } from "./prepare.mjs";
 import { OutputByType, OutputType, patchDocument } from "@office-open/docx";
 

package/dist/converters/prepare.d.mts

@@ -1,4 +1,4 @@
-import { a as JSONContent } from "../core-C9VunJ8o.mjs";
+import { a as JSONContent } from "../core-DC0_-WcE.mjs";
 
 //#region src/converters/prepare.d.ts
 /**

package/dist/converters/prepare.mjs

@@ -67,15 +67,12 @@ async function prepareDocument(json, steps = DEFAULT_STEPS) {
 }
 async function toDataUrl(src, handler) {
 	const data = await handler(src);
-	return `data:${{
-		jpg: "image/jpeg",
-		jpeg: "image/jpeg",
-		png: "image/png",
-		gif: "image/gif",
-		bmp: "image/bmp",
-		svg: "image/svg+xml",
-		webp: "image/webp"
-	}[src.split(".").pop()?.toLowerCase() ?? "png"] ?? "image/png"};base64,${encodeBase64(data)}`;
+	let mime = "image/png";
+	try {
+		const type = imageMeta(data).type;
+		if (type) mime = type === "jpg" ? "image/jpeg" : `image/${type}`;
+	} catch {}
+	return `data:${mime};base64,${encodeBase64(data)}`;
 }
 async function walkImages(node, handler) {
 	if (node.type === "image" && node.attrs) {

package/dist/converters/styles.d.mts

@@ -2,6 +2,11 @@ import { JSONContent } from "@tiptap/core";
 import { StylesOptions } from "@office-open/docx";
 
 //#region src/converters/styles.d.ts
+/** A named style entry as office-open models it: BaseParagraphStyleOptions or
+ *  BaseCharacterStyleOptions (both extend the internal StyleOptions, carrying
+ *  name/uiPriority/quickFormat). Derived from the public StylesOptions — not
+ *  imported — because StyleOptions is not a public export of @office-open/docx. */
+type StyleEntry = NonNullable<StylesOptions["paragraphStyles"]>[number] | NonNullable<StylesOptions["characterStyles"]>[number];
 /** The styleId of the document's default paragraph style (`w:default="1"`
  *  type="paragraph") — the implicit style applied to every paragraph WITHOUT an
  *  explicit pStyle. OOXML renders a pStyle-less paragraph as this style (usually
@@ -29,6 +34,7 @@ declare function defaultParagraphStyleId(styles: StylesOptions | null | undefine
  * carries its full ancestor chain rather than relying on source order.
  */
 declare function stylesToCss(styles: StylesOptions | null | undefined, scope: string): string;
+declare function indexParagraphStyles(styles: StylesOptions): Map<string, StyleEntry>;
 /** A gallery-ready paragraph-style entry for the Styles combobox. */
 interface QuickStyleEntry {
   id: string;
@@ -82,4 +88,4 @@ declare function effectiveRunProps(styles: StylesOptions | null | undefined, sty
  */
 declare function inlineStyles(json: JSONContent, styles?: StylesOptions | null): JSONContent;
 //#endregion
-export { QuickStyleEntry, type StylesOptions, defaultParagraphStyleId, effectiveRunProps, inlineStyles, quickStyles, stylesToCss };
+export { QuickStyleEntry, StyleEntry, type StylesOptions, defaultParagraphStyleId, effectiveRunProps, indexParagraphStyles, inlineStyles, quickStyles, stylesToCss };

package/dist/converters/styles.mjs

@@ -85,7 +85,10 @@ function stylesToCss(styles, scope) {
 *  (key → pStyle id via pStyleIdFromKey). `document` is docDefaults, not a
 *  named style, so it is excluded. A built-in that also appears in
 *  paragraphStyles is deduped by id (paragraphStyles wins on insertion order). */
+const styleIndexCache = /* @__PURE__ */ new WeakMap();
 function indexParagraphStyles(styles) {
+	const cached = styleIndexCache.get(styles);
+	if (cached) return cached;
 	const byId = /* @__PURE__ */ new Map();
 	for (const ps of styles.paragraphStyles ?? []) byId.set(ps.id, ps);
 	const defaults = styles.default;
@@ -93,14 +96,34 @@ function indexParagraphStyles(styles) {
 		if (key === "document" || !style) continue;
 		byId.set(pStyleIdFromKey(key), style);
 	}
+	styleIndexCache.set(styles, byId);
 	return byId;
 }
+/** Whether `v` is a plain object — an OOXML property group (spacing/indent/
+*  border/shading/font) that merges key by key — as opposed to an array
+*  (tabStops) or scalar, which replace. */
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/** Deep-merge `source` into `target` (mutates target) per the OOXML `basedOn`
+*  model: nested property groups merge key by key (a child's spacing.before
+*  merges with, not replaces, the parent's spacing.line); arrays and scalars
+*  replace. Nullish source values are skipped so an unset child key doesn't
+*  clobber an inherited value. */
+function deepMergeInto(target, source) {
+	for (const [key, srcVal] of Object.entries(source)) {
+		if (srcVal === null || srcVal === void 0) continue;
+		const tgtVal = target[key];
+		target[key] = isPlainObject(srcVal) && isPlainObject(tgtVal) ? deepMergeInto({ ...tgtVal }, srcVal) : isPlainObject(srcVal) ? { ...srcVal } : srcVal;
+	}
+	return target;
+}
 /** Merge a paragraph style's run/paragraph properties with its `basedOn` chain
-*  (root first, child overrides per-property) — the OOXML inheritance model. A
-*  flat property-level merge: a child property overrides the parent's; an unset
-*  property is inherited. Shared by stylesToCss (rendering) and
-*  effectiveRunProps (the caret resolver) so the gallery box and the rendered
-*  page resolve identical values. */
+*  (root first, child overrides per-property) — the OOXML inheritance model.
+*  Nested property groups (spacing/indent/border/font) merge key by key; arrays
+*  and scalars replace. Shared by stylesToCss (rendering) and effectiveRunProps
+*  (the caret resolver) so the gallery box and the rendered page resolve
+*  identical values. */
 function mergeStyleChain(byId, styleId) {
 	const chain = [];
 	const visited = /* @__PURE__ */ new Set();
@@ -116,8 +139,8 @@ function mergeStyleChain(byId, styleId) {
 	const paragraph = {};
 	for (const style of chain) {
 		const s = style;
-		if (s.run) Object.assign(run, s.run);
-		if (s.paragraph) Object.assign(paragraph, s.paragraph);
+		if (s.run) deepMergeInto(run, s.run);
+		if (s.paragraph) deepMergeInto(paragraph, s.paragraph);
 	}
 	return {
 		run,
@@ -282,4 +305,4 @@ function inlineStyles(json, styles) {
 	return resolveNode(json, indexParagraphStyles(docStyles), indexCharacterRunStyles(docStyles));
 }
 //#endregion
-export { defaultParagraphStyleId, effectiveRunProps, inlineStyles, quickStyles, stylesToCss };
+export { defaultParagraphStyleId, effectiveRunProps, indexParagraphStyles, inlineStyles, quickStyles, stylesToCss };