@docen/docx 0.3.5 → 0.4.0

package/dist/{core-BnF8XhVE.mjs → core-wNNPJiKr.mjs}

@@ -1,14 +1,16 @@
-import { Blockquote, Bold, Code, CodeBlockLowlight, Details, DetailsContent, DetailsSummary, Emoji, HardBreak, Highlight, HorizontalRule, Italic, ListItem, Mathematics, Mention, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign, Underline } from "./extensions/tiptap.mjs";
-import "./extensions/blockquote.mjs";
+import { attrNative, floatAnchorScope, floatingToStyles, normalizeColorToHex, renderRunStyles } from "./extensions/utils.mjs";
+import { buildTextBlock, cleanAttrs, mergeTextNodes } from "./converters/styles.mjs";
+import { Blockquote } from "./extensions/blockquote.mjs";
 import { BulletList } from "./extensions/bullet-list.mjs";
 import { CodeBlock } from "./extensions/code-block.mjs";
-import "./extensions/details.mjs";
-import { attrNative, floatAnchorScope, floatingToStyles, normalizeColorToHex, renderRunStyles } from "./extensions/utils.mjs";
+import { Details, DetailsContent as DetailsContentBase, DetailsSummary as DetailsSummaryBase } from "./extensions/details.mjs";
 import { Document } from "./extensions/document.mjs";
-import { Heading } from "./extensions/heading.mjs";
+import { Heading, detectHeadingLevel } from "./extensions/heading.mjs";
 import { Image } from "./extensions/image.mjs";
 import { Link } from "./extensions/link.mjs";
-import "./extensions/mention.mjs";
+import { TaskItem as TaskItemBase, isTaskCheckbox, readCheckboxState } from "./extensions/task-item.mjs";
+import { Bold, Code, Highlight, Italic, Subscript, Superscript, Underline } from "./extensions/marks.mjs";
+import { Mention } from "./extensions/mention.mjs";
 import { OrderedList } from "./extensions/ordered-list.mjs";
 import { Paragraph } from "./extensions/paragraph.mjs";
 import { Strike } from "./extensions/strike.mjs";
@@ -16,9 +18,17 @@ import { Table } from "./extensions/table.mjs";
 import { TableCell } from "./extensions/table-cell.mjs";
 import { TableHeader } from "./extensions/table-header.mjs";
 import { TableRow } from "./extensions/table-row.mjs";
-import "./extensions/task-item.mjs";
 import { TextStyle } from "./extensions/text-style.mjs";
 import { Editor, Extension, Mark, Node } from "@tiptap/core";
+import { CodeBlockLowlight, CodeBlockLowlight as CodeBlockLowlight$1 } from "@tiptap/extension-code-block-lowlight";
+import { Emoji, Emoji as Emoji$1 } from "@tiptap/extension-emoji";
+import { HardBreak, HardBreak as HardBreak$1 } from "@tiptap/extension-hard-break";
+import { HorizontalRule, HorizontalRule as HorizontalRule$1 } from "@tiptap/extension-horizontal-rule";
+import { ListItem, ListItem as ListItem$1 } from "@tiptap/extension-list-item";
+import { Mathematics, Mathematics as Mathematics$1 } from "@tiptap/extension-mathematics";
+import { TaskList, TaskList as TaskList$1 } from "@tiptap/extension-task-list";
+import { Text, Text as Text$1 } from "@tiptap/extension-text";
+import { TextAlign, TextAlign as TextAlign$1 } from "@tiptap/extension-text-align";
 import { all, createLowlight } from "lowlight";
 import { Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
 import { Decoration, DecorationSet } from "@tiptap/pm/view";
@@ -33,13 +43,14 @@ import { convertEmuToPixels, encodeBase64 } from "@office-open/core";
 * layout (paged.js multi-column) is a future concern; the node preserves the
 * break losslessly regardless.
 *
-* The DOCX payload (`{ columnBreak: true }`) is inlined in DocxManager — a
-* one-liner with no per-node variance, so no extension helper for it.
-*
 * `setColumnBreak` only inserts the atom (no paragraph split): a column break
 * does not start a new page, and there is no column layout to reflow yet, so
 * the node is purely for round-trip fidelity until multi-column lands.
 */
+const parseDocxInline$4 = {
+	match: (child) => "columnBreak" in child,
+	convert: () => ({ type: "columnBreak" })
+};
 const ColumnBreak = Node.create({
 	name: "columnBreak",
 	inline: true,
@@ -54,6 +65,7 @@ const ColumnBreak = Node.create({
 			style: "break-after:column"
 		}];
 	},
+	parseDocxInline: parseDocxInline$4,
 	addCommands() {
 		return { setColumnBreak: () => ({ commands }) => commands.insertContent({ type: "columnBreak" }) };
 	}
@@ -146,6 +158,119 @@ const FormattingMarks = Extension.create({
 	}
 });
 //#endregion
+//#region src/extensions/list-aggregator.ts
+/** Classify a paragraph as a list item, or null if it isn't one. */
+function detectList(para, ctx) {
+	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 ? ctx.numberingLookup?.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)
+	};
+}
+/** 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. */
+function resolveListItemParagraph(para, info, ctx) {
+	const resolved = typeof para === "string" ? { text: para } : para;
+	const headingLevel = detectHeadingLevel(resolved, ctx.styles);
+	return buildTextBlock(headingLevel ? "heading" : "paragraph", resolved, ctx, headingLevel, info.kind === "task" ? stripTaskCheckbox(resolved) : resolved);
+}
+/** Return a copy of `para` with its leading docen-task checkbox SDT removed. */
+function stripTaskCheckbox(para) {
+	const children = para.children;
+	if (Array.isArray(children) && children.length > 0 && isTaskCheckbox(children[0])) return {
+		...para,
+		children: children.slice(1)
+	};
+	return para;
+}
+/**
+* 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.
+*/
+function buildListTree(group, ctx) {
+	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: [resolveListItemParagraph(para, info, ctx)]
+		};
+		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;
+}
+const parseDocxAggregator = {
+	belongs: (para, ctx) => detectList(para, ctx) != null,
+	build: (group, ctx) => {
+		return buildListTree(group.map((para) => ({
+			para,
+			info: detectList(para, ctx)
+		})).filter((x) => x.info != null), ctx);
+	}
+};
+const ListAggregator = Extension.create({
+	name: "listAggregator",
+	parseDocxAggregator
+});
+//#endregion
 //#region src/extensions/page-break.ts
 /**
 * PageBreak — inline atom node for DOCX page breaks (`<w:br w:type="page"/>`).
@@ -166,6 +291,10 @@ const FormattingMarks = Extension.create({
 * the paginator's `forcesPageBreakAfter` moves it to the next page (matching
 * Word's Ctrl+Enter behavior).
 */
+const parseDocxInline$3 = {
+	match: (child) => "pageBreak" in child,
+	convert: () => ({ type: "pageBreak" })
+};
 const PageBreak = Node.create({
 	name: "pageBreak",
 	inline: true,
@@ -180,6 +309,7 @@ const PageBreak = Node.create({
 			style: "break-after:page"
 		}];
 	},
+	parseDocxInline: parseDocxInline$3,
 	addProseMirrorPlugins() {
 		return [new Plugin({ appendTransaction: (transactions, _oldState, newState) => {
 			if (!transactions.some((tr) => tr.docChanged)) return null;
@@ -396,6 +526,10 @@ const SectionBreak = Extension.create({
 * marks where a tab leader (e.g. a TOC's dotted leader) renders. compile turns it
 * back into `{ tab: true }`.
 */
+const parseDocxInline$2 = {
+	match: (child) => "tab" in child,
+	convert: () => ({ type: "tab" })
+};
 const Tab = Node.create({
 	name: "tab",
 	group: "inline",
@@ -409,7 +543,8 @@ const Tab = Node.create({
 			class: "docx-tab",
 			contenteditable: "false"
 		}];
-	}
+	},
+	parseDocxInline: parseDocxInline$2
 });
 //#endregion
 //#region src/extensions/toc-field.ts
@@ -431,14 +566,44 @@ const Tab = Node.create({
 * whose content-less runs (fldChar begin/separate/end) office-open parses as
 * `null`. As opaque passthrough those nulls survived verbatim to
 * `generateDocument`, where office-open's `stringifyRunInline(null).break`
-* crashed. Resolving the entries through `resolveParagraphChildren` drops the
-* nulls (the existing `child !== null` guard), so compile rebuilds clean entries
-* and the generate path never sees a null — no office-open change required.
-*
-* DOCX serialization is inlined in DocxManager (resolve/compile read/write
-* `attrs.options` + the entry content directly), so no renderDocx/parseDocx is
-* needed here — the same pattern as the details extension.
+* crashed. The `parseDocxBlock` rule resolves the entries through the shared
+* block-stream path, which drops the nulls (the `child !== null` guard), so
+* compile rebuilds clean entries and the generate path never sees a null — no
+* office-open change required.
 */
+/**
+* Declarative block parse rule: recognize a table of contents SectionChild and
+* rebuild it as an editable `tocField` container. DocxManager dispatches every
+* SectionChild through this rule before the paragraph/passthrough fallbacks. */
+const parseDocxBlock = {
+	match: (child) => "toc" in child,
+	convert: (child, ctx) => resolveToc(child.toc, ctx)
+};
+/** Resolve a table of contents into an editable `tocField` 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 the shared
+*  block-stream path drops those 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. */
+function resolveToc(toc, ctx) {
+	const { entries, ...options } = toc;
+	const content = [];
+	for (const entry of entries ?? []) {
+		const node = ctx.resolveBlock(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;
+}
 const TocField = Node.create({
 	name: "tocField",
 	group: "block",
@@ -455,6 +620,119 @@ const TocField = Node.create({
 			{ class: "docx-toc" },
 			0
 		];
+	},
+	parseDocxBlock
+});
+//#endregion
+//#region src/extensions/track-change.ts
+/**
+* Track Changes marks (Word revision tracking).
+*
+* OOXML records inline revisions as `<w:ins>` / `<w:del>` containers wrapping
+* runs (carrying w:author / w:date / w:id metadata). office-open models these
+* as `ParagraphChild.insertion` / `.deletion` — `{ id, author, date, children }`
+* — structurally identical to `hyperlink` (an inline container with attrs +
+* child runs). docen mirrors that as two Tiptap marks applied to the contained
+* text:
+*
+*  - `insertion` — text added by a reviewer (Word renders colored + underlined)
+*  - `deletion`  — text marked for removal (Word renders colored + strikethrough;
+*    the text stays visible until the change is accepted/rejected)
+*
+* Container-level, NOT rPr-level: like `link`, these wrap child runs, so resolve
+* is declared via parseDocxInline (resolveTrackedChange) and compile via
+* compileTrackedChangeRun (compileTextRun pushes `{insertion|deletion:{...}}`).
+* They do NOT use the renderDocx/parseDocx mark hook — that is for rPr-level
+* marks like strike/bold. The attrs (id/author/date) are round-tripped via
+* resolve/compile and kept out of HTML (`rendered:false`): HTML paste loses
+* the metadata but keeps the native `<ins>`/`<del>` tag (the class is a CSS
+* hook); DOCX round-trip is byte-faithful.
+*
+* HTML tags: `<ins>`/`<del>` are HTML's native editorial-revision elements, so
+* they are used instead of a bare span — semantic, accessible, and matching
+* browser defaults (underlined / struck-through). `<ins>` has no competing
+* mark, so both the classed tag and a bare pasted `<ins>` are claimed. `<del>`
+* is also matched by the base Strike mark, so only the classed tag is claimed
+* to avoid shadowing strike on a bare `<del>`.
+*
+* P1 scope: render + round-trip only. accept/reject commands, nested
+* revisions, block-level revisions, and format-revision (markChange) are out
+* of scope (office-open parses inline w:ins/w:del only).
+*/
+const trackChangeAttrs = () => ({
+	id: {
+		default: null,
+		rendered: false
+	},
+	author: {
+		default: null,
+		rendered: false
+	},
+	date: {
+		default: null,
+		rendered: false
+	}
+});
+/** ParagraphChild `{ insertion|deletion: {...} }` → text[] carrying the mark.
+*  Mirrors the old DocxManager.resolveTrackedChange: recurse the container's
+*  runs via ctx, merge adjacent text, then stamp every text node with the
+*  revision mark alongside any existing rPr marks. Returns null for an empty
+*  container. */
+function resolveTrackedChange(opts, type, ctx) {
+	const content = ctx.resolveInlineChildren((opts.children ?? []).map((c) => c));
+	if (content.length === 0) return null;
+	const merged = mergeTextNodes(content);
+	const mark = {
+		type,
+		attrs: {
+			id: opts.id ?? null,
+			author: opts.author ?? null,
+			date: opts.date ?? null
+		}
+	};
+	for (const node of merged) if (node.type === "text") node.marks = [...node.marks ?? [], mark];
+	return merged;
+}
+const Insertion = Mark.create({
+	name: "insertion",
+	inclusive: false,
+	addAttributes() {
+		return trackChangeAttrs();
+	},
+	renderHTML() {
+		return [
+			"ins",
+			{ class: "docen-insertion" },
+			0
+		];
+	},
+	parseHTML() {
+		return [{ tag: "ins.docen-insertion" }, { tag: "ins" }];
+	},
+	parseDocxInline: {
+		match: (child) => "insertion" in child,
+		convert: (child, ctx) => resolveTrackedChange(child.insertion, "insertion", ctx)
+	}
+});
+const Deletion = Mark.create({
+	name: "deletion",
+	inclusive: false,
+	addAttributes() {
+		return trackChangeAttrs();
+	},
+	renderHTML() {
+		return [
+			"del",
+			{ class: "docen-deletion" },
+			0
+		];
+	},
+	parseHTML() {
+		return [{ tag: "del.docen-deletion" }];
+	},
+	parseDocxInline: {
+		match: (child) => "deletion" in child,
+		convert: (child, ctx) => resolveTrackedChange(child.deletion, "deletion", ctx)
 	}
 });
 //#endregion
@@ -698,6 +976,13 @@ const attrWpgGroup = () => ({
 		}
 	}
 });
+const parseDocxInline$1 = {
+	match: (child) => "wpgGroup" in child,
+	convert: (child) => ({
+		type: "wpgGroup",
+		attrs: { wpgGroup: child.wpgGroup }
+	})
+};
 const WpgGroup = Node.create({
 	name: "wpgGroup",
 	group: "inline",
@@ -718,7 +1003,8 @@ const WpgGroup = Node.create({
 			`height:${h}px`
 		].join(";"), floatAnchorScope(wpg.floating) === "paragraph" ? { "data-float-anchor": "paragraph" } : void 0);
 		return renderGroup(wpg, w, h);
-	}
+	},
+	parseDocxInline: parseDocxInline$1
 });
 //#endregion
 //#region src/extensions/wps-shape.ts
@@ -745,6 +1031,48 @@ const attrWpsShape = () => ({
 		}
 	}
 });
+/** ParagraphChild `{ wpsShape: {...} }` → wpsShape node. Mirrors the old
+*  DocxManager wpsShape branch: the shape's text body (children) becomes PM
+*  content (one node per paragraph); geometry/styling ride on attrs.wpsShape.
+*  Each paragraph's defRPr (para.run) is merged into its runs then dropped — it
+*  is the box's default run-properties, not the ¶-mark rPr (see inline note). */
+function resolveWpsShape(ws, ctx) {
+	const content = [];
+	if (ws?.children) for (const para of ws.children) {
+		if (typeof para !== "object" || para === null) {
+			const node = ctx.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 = ctx.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 parseDocxInline = {
+	match: (child) => "wpsShape" in child,
+	convert: (child, ctx) => resolveWpsShape(child.wpsShape, ctx)
+};
 const WpsShape = Node.create({
 	name: "wpsShape",
 	group: "inline",
@@ -778,7 +1106,8 @@ const WpsShape = Node.create({
 				0
 			]
 		];
-	}
+	},
+	parseDocxInline
 });
 //#endregion
 //#region src/extensions/extensions.ts
@@ -800,8 +1129,8 @@ const tiptapNodeExtensions = [
 	ListItem,
 	CodeBlock.configure({ lowlight: createLowlight(all) }),
 	Details,
-	DetailsSummary,
-	DetailsContent,
+	DetailsSummaryBase,
+	DetailsContentBase,
 	Emoji,
 	HorizontalRule,
 	Image.configure({ inline: true }),
@@ -814,14 +1143,16 @@ const tiptapNodeExtensions = [
 	TableCell,
 	TableHeader,
 	TaskList,
-	TaskItem,
+	TaskItemBase,
 	Heading,
 	TextAlign.configure({ types: ["heading", "paragraph"] })
 ];
 const tiptapMarkExtensions = [
 	Bold,
 	Code,
+	Deletion,
 	Highlight,
+	Insertion,
 	Italic,
 	Link,
 	Strike,
@@ -833,7 +1164,8 @@ const tiptapMarkExtensions = [
 const docxExtensions = [
 	...tiptapNodeExtensions,
 	...tiptapMarkExtensions,
-	FormattingMarks
+	FormattingMarks,
+	ListAggregator
 ];
 const DocxKit = Extension.create({
 	name: "docxKit",
@@ -863,4 +1195,4 @@ const DocxKit = Extension.create({
 	}
 });
 //#endregion
-export { ColumnBreak as C, FormattingMarks as S, Tab as _, DocxKit as a, Passthrough as b, tiptapNodeExtensions as c, renderWpsInterior as d, renderWpsText as f, TocField as g, wpsShapeStyles as h, Node as i, WpsShape as l, wpsRotationVert as m, Extension as n, docxExtensions as o, wpsInnerStyle as p, Mark as r, tiptapMarkExtensions as s, Editor as t, WpgGroup as u, SectionBreak as v, PageBreak as x, InlinePassthrough as y };
+export { parseDocxBlock as A, FormattingMarks as B, renderWpsText as C, Deletion as D, wpsShapeStyles as E, Passthrough as F, parseDocxInline$4 as H, PageBreak as I, parseDocxInline$3 as L, parseDocxInline$2 as M, SectionBreak as N, Insertion as O, InlinePassthrough as P, ListAggregator as R, renderWpsInterior as S, wpsRotationVert as T, ColumnBreak as V, tiptapNodeExtensions as _, CodeBlockLowlight$1 as a, WpgGroup as b, HardBreak$1 as c, Mathematics$1 as d, TaskList$1 as f, tiptapMarkExtensions as g, docxExtensions as h, Node as i, Tab as j, TocField as k, HorizontalRule$1 as l, TextAlign$1 as m, Extension as n, DocxKit as o, Text$1 as p, Mark as r, Emoji$1 as s, Editor as t, ListItem$1 as u, WpsShape as v, wpsInnerStyle as w, parseDocxInline$1 as x, parseDocxInline as y, parseDocxAggregator as z };

package/dist/core.d.mts

@@ -1,2 +1,2 @@
-import { a as JSONContent, i as Extensions, n as Editor, o as Mark, r as Extension, s as Node, t as AnyExtension, u as docxExtensions } from "./core-DC0_-WcE.mjs";
+import { a as JSONContent, i as Extensions, n as Editor, o as Mark, r as Extension, s as Node, t as AnyExtension, y as docxExtensions } from "./core-BqyLL84S.mjs";
 export { type AnyExtension, Editor, Extension, type Extensions, type JSONContent, Mark, Node, docxExtensions };

package/dist/core.mjs

@@ -1,2 +1,2 @@
-import { i as Node, n as Extension, o as docxExtensions, r as Mark, t as Editor } from "./core-BnF8XhVE.mjs";
+import { h as docxExtensions, i as Node, n as Extension, r as Mark, t as Editor } from "./core-wNNPJiKr.mjs";
 export { Editor, Extension, Mark, Node, docxExtensions };

package/dist/details-DsJhDP5K.d.mts

@@ -0,0 +1,31 @@
+import { ParseBlockRule } from "./extensions/types.mjs";
+import { DetailsContent as DetailsContentBase, DetailsSummary as DetailsSummaryBase } from "@tiptap/extension-details";
+
+//#region src/extensions/details.d.ts
+/**
+ * Details extension — owns the DOCX expression of a collapsible details block.
+ *
+ * DOCX has no native collapsible region, but a block-level group-SDT is a
+ * reversible container. The details maps to one group-SDT tagged "docen-
+ * details"; the summary paragraph is marked with a fixed style so resolve can
+ * split it back out from the content paragraphs. Structure round-trips fully
+ * (summary + content); Word shows it expanded (no collapse) — an inherent
+ * DOCX limitation, not data loss.
+ *
+ * The `parseDocxBlock` rule (below) recognizes a details group-SDT during
+ * resolve and rebuilds the details/detailsSummary/detailsContent nodes; the
+ * extensions themselves carry no DOCX attrs of their own.
+ */
+/** SDT tag marking a details group content control. */
+declare const DETAILS_TAG = "docen-details";
+/** Paragraph style marking the summary line within a details group-SDT. */
+declare const DETAILS_SUMMARY_STYLE = "DocenDetailsSummary";
+/**
+ * Declarative block parse rule: recognize a group-SDT tagged "docen-details"
+ * and rebuild it as a details node (summary + content). DocxManager dispatches
+ * every SectionChild through this rule before the paragraph/passthrough
+ * fallbacks; a non-details SDT falls through to passthrough. */
+declare const parseDocxBlock: ParseBlockRule;
+declare const Details$1: import("@tiptap/core").Node<import("@tiptap/extension-details").DetailsOptions, any>;
+//#endregion
+export { DetailsSummaryBase as a, DetailsContentBase as i, DETAILS_TAG as n, parseDocxBlock as o, Details$1 as r, DETAILS_SUMMARY_STYLE as t };

package/dist/editor.d.mts

@@ -1,4 +1,4 @@
-import { n as Editor, t as AnyExtension } from "./core-DC0_-WcE.mjs";
+import { n as Editor, t as AnyExtension } from "./core-BqyLL84S.mjs";
 
 //#region src/editor.d.ts
 interface DocxEditorOptions {

package/dist/editor.mjs

@@ -1,4 +1,4 @@
-import { o as docxExtensions, t as Editor } from "./core-BnF8XhVE.mjs";
+import { h as docxExtensions, t as Editor } from "./core-wNNPJiKr.mjs";
 //#region src/editor.ts
 /**
 * Create a Tiptap editor configured for DOCX editing.

package/dist/extensions/blockquote.d.mts

@@ -1,3 +1,2 @@
-import { t as Blockquote } from "../tiptap-BKqn41uT.mjs";
-import { n as BLOCKQUOTE_INDENT_LEFT, r as applyBlockquoteStyle, t as BLOCKQUOTE_BORDER } from "../blockquote-DY80QC06.mjs";
-export { BLOCKQUOTE_BORDER, BLOCKQUOTE_INDENT_LEFT, Blockquote, applyBlockquoteStyle };
+import { a as parseDocxAggregator, i as applyBlockquoteStyle, n as BLOCKQUOTE_INDENT_LEFT, r as Blockquote, t as BLOCKQUOTE_BORDER } from "../blockquote-D-1aSxEn.mjs";
+export { BLOCKQUOTE_BORDER, BLOCKQUOTE_INDENT_LEFT, Blockquote, applyBlockquoteStyle, parseDocxAggregator };

package/dist/extensions/blockquote.mjs

@@ -1,4 +1,5 @@
-import { Blockquote } from "./tiptap.mjs";
+import { cleanAttrs } from "../converters/styles.mjs";
+import { Blockquote as Blockquote$1 } from "@tiptap/extension-blockquote";
 //#region src/extensions/blockquote.ts
 /**
 * Blockquote extension — owns the DOCX expression of a blockquote.
@@ -27,5 +28,52 @@ function applyBlockquoteStyle(paraObj) {
 		left: BLOCKQUOTE_BORDER
 	};
 }
+/** Classify a paragraph as a blockquote member by its signature (left indent
+*  + left border). compile stamps this via applyBlockquoteStyle; this is the
+*  reverse predicate. Pure: reads only the paragraph opts. */
+function 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. */
+function buildBlockquote(group, ctx) {
+	const content = [];
+	for (const para of group) {
+		const node = ctx.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
+	}];
+}
+const parseDocxAggregator = {
+	belongs: (para) => detectBlockquote(para),
+	build: (group, ctx) => buildBlockquote(group, ctx)
+};
+const Blockquote = Blockquote$1.extend({ parseDocxAggregator });
 //#endregion
-export { BLOCKQUOTE_BORDER, BLOCKQUOTE_INDENT_LEFT, Blockquote, applyBlockquoteStyle };
+export { BLOCKQUOTE_BORDER, BLOCKQUOTE_INDENT_LEFT, Blockquote, applyBlockquoteStyle, parseDocxAggregator };

package/dist/extensions/bullet-list.mjs

@@ -1,4 +1,4 @@
-import { BulletList as BulletList$1 } from "./tiptap.mjs";
+import { BulletList as BulletList$1 } from "@tiptap/extension-bullet-list";
 //#region src/extensions/bullet-list.ts
 /**
 * BulletList — carries the source DOCX abstractNum reference (when the list came

package/dist/extensions/code-block.d.mts

@@ -1,2 +1,2 @@
-import { I as CodeBlock, L as renderDocx } from "../core-DC0_-WcE.mjs";
-export { CodeBlock, renderDocx };
+import { et as CodeBlock, nt as renderDocx, tt as parseDocxParagraph } from "../core-BqyLL84S.mjs";
+export { CodeBlock, parseDocxParagraph, renderDocx };