@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -0,0 +1,1550 @@
+import { OUTLINE_STYLE_CSS_ALIASES } from "../../types/documentEnumValues.js";
+import { ShapeOutlineStyleSchema, narrowEnum } from "../../docx/parserEnums.js";
+import { pixelsToEmu } from "../../utils/units.js";
+import { numPrEqual } from "../../docx/numberingParser.js";
+import { directionToBidi } from "../paragraphDirection.js";
+import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectMathAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../attrs/index.js";
+import { autospacingMatchesBase, hasAutospacingBaseSide } from "../autospacingBase.js";
+import { runShadingAttrsToShading } from "./runShadingMark.js";
+import { assertValidProseMirrorDocument } from "../validation.js";
+//#region src/prosemirror/conversion/fromProseDoc.ts
+function normalizeShapeOutlineStyle(style) {
+	if (!style) return;
+	if (style in OUTLINE_STYLE_CSS_ALIASES) return OUTLINE_STYLE_CSS_ALIASES[style];
+	return narrowEnum(style, ShapeOutlineStyleSchema);
+}
+function parseTransformAttr(transformStr) {
+	if (!transformStr) return;
+	const transform = {};
+	const rotateMatch = /rotate\((?<deg>[-\d.]+)deg\)/u.exec(transformStr);
+	if (rotateMatch) {
+		const rotation = Number.parseFloat(rotateMatch.groups["deg"]);
+		if (Number.isFinite(rotation)) transform.rotation = rotation;
+	}
+	if (transformStr.includes("scaleX(-1)")) transform.flipH = true;
+	if (transformStr.includes("scaleY(-1)")) transform.flipV = true;
+	if (transform.rotation === void 0 && !transform.flipH && !transform.flipV) return;
+	return transform;
+}
+function imagePositionFromAttrs(attrs) {
+	const horizontalPosition = attrs?.horizontal;
+	const verticalPosition = attrs?.vertical;
+	if (!horizontalPosition || !verticalPosition) return;
+	const horizontal = { relativeTo: horizontalPosition.relativeTo || "column" };
+	if (horizontalPosition.align) horizontal.alignment = horizontalPosition.align;
+	if (horizontalPosition.posOffset !== void 0) horizontal.posOffset = horizontalPosition.posOffset;
+	const vertical = { relativeTo: verticalPosition.relativeTo || "paragraph" };
+	if (verticalPosition.align) vertical.alignment = verticalPosition.align;
+	if (verticalPosition.posOffset !== void 0) vertical.posOffset = verticalPosition.posOffset;
+	return {
+		horizontal,
+		vertical
+	};
+}
+function textBoxWrapFromAttrs(attrs) {
+	if (!(attrs.wrapType !== void 0 && attrs.wrapType !== "inline" || attrs.wrapText !== void 0 || attrs.distTop !== void 0 || attrs.distBottom !== void 0 || attrs.distLeft !== void 0 || attrs.distRight !== void 0)) return;
+	const wrap = { type: attrs.wrapType ?? "inline" };
+	if (attrs.wrapText !== void 0) wrap.wrapText = attrs.wrapText;
+	if (attrs.distTop !== void 0) wrap.distT = pixelsToEmu(attrs.distTop);
+	if (attrs.distBottom !== void 0) wrap.distB = pixelsToEmu(attrs.distBottom);
+	if (attrs.distLeft !== void 0) wrap.distL = pixelsToEmu(attrs.distLeft);
+	if (attrs.distRight !== void 0) wrap.distR = pixelsToEmu(attrs.distRight);
+	return wrap;
+}
+/**
+* Convert a ProseMirror document to our Document type
+*/
+function fromProseDoc(pmDoc, baseDocument) {
+	assertValidProseMirrorDocument(pmDoc, "Cannot convert invalid ProseMirror document to DOCX model");
+	const documentBody = { content: extractBlocks(pmDoc) };
+	if (baseDocument?.package.document.finalSectionProperties) documentBody.finalSectionProperties = baseDocument.package.document.finalSectionProperties;
+	if (baseDocument?.package.document.sections) documentBody.sections = baseDocument.package.document.sections;
+	if (baseDocument?.package.document.comments) documentBody.comments = baseDocument.package.document.comments;
+	if (baseDocument) return {
+		...baseDocument,
+		package: {
+			...baseDocument.package,
+			document: documentBody
+		}
+	};
+	return { package: { document: documentBody } };
+}
+/**
+* Extract block content (paragraphs, tables, block SDTs) from a ProseMirror
+* document.
+*/
+function extractBlocks(pmDoc) {
+	const blocks = [];
+	const documentCounts = buildDocumentTrackedChangeCounts(pmDoc);
+	let pendingPageBreaks = 0;
+	let previousStandaloneTextBox = null;
+	const flushPendingPageBreaks = () => {
+		for (let index = 0; index < pendingPageBreaks; index += 1) blocks.push(createPageBreakParagraph());
+		pendingPageBreaks = 0;
+	};
+	const appendPendingPageBreaksToPreviousParagraph = () => {
+		const previousBlock = blocks.at(-1);
+		if (previousBlock?.type !== "paragraph") return false;
+		appendPageBreaks(previousBlock, pendingPageBreaks);
+		pendingPageBreaks = 0;
+		return true;
+	};
+	pmDoc.forEach((node) => {
+		if (node.type.name === "pageBreak") {
+			pendingPageBreaks += 1;
+			previousStandaloneTextBox = null;
+			return;
+		}
+		if (node.type.name === "paragraph") {
+			const paragraph = convertPMParagraph(node, documentCounts);
+			prependPageBreaks(paragraph, pendingPageBreaks);
+			pendingPageBreaks = 0;
+			blocks.push(paragraph);
+			previousStandaloneTextBox = null;
+		} else if (node.type.name === "table") {
+			if (pendingPageBreaks > 0 && !appendPendingPageBreaksToPreviousParagraph()) flushPendingPageBreaks();
+			blocks.push(convertPMTable(node, documentCounts));
+			previousStandaloneTextBox = null;
+		} else if (node.type.name === "textBox") {
+			previousStandaloneTextBox = appendTextBoxBlock(blocks, node, {
+				pendingPageBreaks,
+				previousStandaloneTextBox
+			});
+			pendingPageBreaks = 0;
+		} else if (node.type.name === "blockSdt") {
+			if (pendingPageBreaks > 0 && !appendPendingPageBreaksToPreviousParagraph()) flushPendingPageBreaks();
+			blocks.push(convertPMBlockSdt(node));
+			previousStandaloneTextBox = null;
+		}
+	});
+	if (pendingPageBreaks > 0 && !appendPendingPageBreaksToPreviousParagraph()) flushPendingPageBreaks();
+	return blocks;
+}
+function convertPMBlockSdt(node) {
+	const attrs = expectBlockSdtAttrs(node);
+	const properties = { sdtType: attrs.sdtType };
+	if (attrs.alias) properties.alias = attrs.alias;
+	if (attrs.tag) properties.tag = attrs.tag;
+	if (typeof attrs.id === "number") properties.id = attrs.id;
+	if (attrs.lock) properties.lock = attrs.lock;
+	if (attrs.placeholder) properties.placeholder = attrs.placeholder;
+	if (attrs.showingPlaceholder !== void 0) properties.showingPlaceholder = attrs.showingPlaceholder;
+	if (attrs.dateFormat) properties.dateFormat = attrs.dateFormat;
+	if (attrs.dateValueISO) properties.dateValueISO = attrs.dateValueISO;
+	if (attrs.listItems) {
+		const items = parseListItemsJson(attrs.listItems);
+		if (items) properties.listItems = items;
+	}
+	if (typeof attrs.dropdownLastValue === "string") properties.dropdownLastValue = attrs.dropdownLastValue;
+	if (typeof attrs.checked === "boolean") properties.checked = attrs.checked;
+	if (attrs.rawPropertiesXml) properties.rawPropertiesXml = attrs.rawPropertiesXml;
+	if (attrs.rawEndPropertiesXml) properties.rawEndPropertiesXml = attrs.rawEndPropertiesXml;
+	if (attrs.rawSdtChildrenBeforeContent) properties.rawSdtChildrenBeforeContent = attrs.rawSdtChildrenBeforeContent;
+	if (attrs.rawSdtChildrenAfterContent) properties.rawSdtChildrenAfterContent = attrs.rawSdtChildrenAfterContent;
+	const extracted = extractBlocks(node.type.schema.node("doc", null, node.content));
+	return {
+		type: "blockSdt",
+		properties,
+		content: attrs._originallyEmpty === true && isStillSyntheticFiller(extracted) ? [] : extracted
+	};
+}
+function isStillSyntheticFiller(blocks) {
+	if (blocks.length !== 1) return false;
+	const block = blocks[0];
+	if (!block || block.type !== "paragraph") return false;
+	if (block.content.length !== 0) return false;
+	if (block.formatting !== void 0) return false;
+	if (block.sectionProperties !== void 0) return false;
+	if (block.propertyChanges !== void 0) return false;
+	if (block.pPrMark !== void 0) return false;
+	return true;
+}
+function parseListItemsJson(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return;
+		const items = [];
+		for (const entry of parsed) if (entry !== null && typeof entry === "object" && "displayText" in entry && "value" in entry && typeof entry.displayText === "string" && typeof entry.value === "string") items.push(entry);
+		return items.length > 0 ? items : void 0;
+	} catch {
+		return;
+	}
+}
+function appendTextBoxBlock(blocks, node, options) {
+	const attrs = expectTextBoxAttrs(node);
+	const paragraph = convertPMTextBox(node);
+	const previousBlock = blocks.at(-1);
+	if (attrs._docxPlacement === "inlineWithPrevious" && previousBlock?.type === "paragraph") {
+		appendPageBreaks(previousBlock, options.pendingPageBreaks);
+		previousBlock.content.push(...paragraph.content);
+		return null;
+	}
+	if (attrs._docxPlacement === "standalone" && attrs._docxGroupId && options.previousStandaloneTextBox?.groupId === attrs._docxGroupId) {
+		options.previousStandaloneTextBox.paragraph.content.push(...paragraph.content);
+		return options.previousStandaloneTextBox;
+	}
+	prependPageBreaks(paragraph, options.pendingPageBreaks);
+	blocks.push(paragraph);
+	return attrs._docxPlacement === "standalone" && attrs._docxGroupId ? {
+		paragraph,
+		groupId: attrs._docxGroupId
+	} : null;
+}
+/**
+* Inverse of toProseDoc's listRendering → list* attrs flattening. Markdown
+* export (`toMarkdown`) and re-layout of the rebuilt Document key off
+* `paragraph.listRendering`; without this, every edited document loses its
+* list markers on the way out of the editor.
+*/
+function listRenderingFromAttrs(attrs) {
+	const numId = attrs.numPr?.numId;
+	if (numId === void 0 || numId === 0) return;
+	if (!(attrs.listMarker != null || attrs.listIsBullet || attrs.listNumFmt != null)) return;
+	return {
+		marker: attrs.listMarker ?? "",
+		level: attrs.numPr?.ilvl ?? 0,
+		numId,
+		isBullet: attrs.listIsBullet ?? false,
+		...attrs.listIsLegal != null && { isLegal: attrs.listIsLegal },
+		...attrs.listNumFmt != null && { numFmt: attrs.listNumFmt },
+		...attrs.listMarkerHidden != null && { markerHidden: attrs.listMarkerHidden },
+		...attrs.listMarkerFontFamily != null && { markerFontFamily: attrs.listMarkerFontFamily },
+		...attrs.listMarkerFontSize != null && { markerFontSize: attrs.listMarkerFontSize },
+		...attrs.listMarkerSuffix != null && { markerSuffix: attrs.listMarkerSuffix },
+		...attrs.listMarkerAllCaps != null && { markerAllCaps: attrs.listMarkerAllCaps },
+		...attrs.listImplicitChildLevelAdvances != null && { implicitChildLevelAdvances: attrs.listImplicitChildLevelAdvances },
+		...attrs.listMarkerSecondSlotOffsetTwips != null && { markerSecondSlotOffsetTwips: attrs.listMarkerSecondSlotOffsetTwips },
+		...attrs.listLevelNumFmts != null && { levelNumFmts: attrs.listLevelNumFmts },
+		...attrs.listAbstractNumId != null && { abstractNumId: attrs.listAbstractNumId },
+		...attrs.listStartOverride != null && { startOverride: attrs.listStartOverride }
+	};
+}
+/**
+* Create a paragraph containing only a page break run (for DOCX serialization)
+*/
+function createPageBreakParagraph() {
+	return {
+		type: "paragraph",
+		content: [{
+			type: "run",
+			content: [{
+				type: "break",
+				breakType: "page"
+			}]
+		}]
+	};
+}
+function createPageBreakRun() {
+	return {
+		type: "run",
+		content: [{
+			type: "break",
+			breakType: "page"
+		}]
+	};
+}
+function prependPageBreaks(paragraph, count) {
+	for (let index = 0; index < count; index += 1) paragraph.content.unshift(createPageBreakRun());
+}
+function appendPageBreaks(paragraph, count) {
+	for (let index = 0; index < count; index += 1) paragraph.content.push(createPageBreakRun());
+}
+/**
+* Convert a ProseMirror paragraph node to our Paragraph type
+*/
+function convertPMParagraph(node, documentCounts) {
+	const attrs = expectParagraphAttrs(node);
+	let content = extractParagraphContent(node, documentCounts, attrs._emptyHyperlinks ?? void 0);
+	const bookmarks = attrs.bookmarks;
+	if (bookmarks && bookmarks.length > 0) {
+		const starts = bookmarks.map((b) => ({
+			type: "bookmarkStart",
+			id: b.id,
+			name: b.name
+		}));
+		const ends = bookmarks.map((b) => ({
+			type: "bookmarkEnd",
+			id: b.id
+		}));
+		content = [
+			...starts,
+			...content,
+			...ends
+		];
+	}
+	const paragraph = {
+		type: "paragraph",
+		content
+	};
+	if (attrs.paraId) paragraph.paraId = attrs.paraId;
+	if (attrs.textId) paragraph.textId = attrs.textId;
+	const pFormatting = paragraphAttrsToFormatting(attrs);
+	if (pFormatting) paragraph.formatting = pFormatting;
+	const listRendering = listRenderingFromAttrs(attrs);
+	if (listRendering) paragraph.listRendering = listRendering;
+	if (attrs.renderedPageBreakBefore) paragraph.renderedPageBreakBefore = true;
+	if (attrs._sectionProperties) paragraph.sectionProperties = attrs._sectionProperties;
+	else if (attrs.sectionBreakType) paragraph.sectionProperties = { sectionStart: attrs.sectionBreakType };
+	if (Array.isArray(attrs._propertyChanges) && attrs._propertyChanges.length > 0) paragraph.propertyChanges = [...attrs._propertyChanges];
+	if (attrs.pPrMark) paragraph.pPrMark = attrs.pPrMark;
+	return paragraph;
+}
+/**
+* Whether the paragraph's numbering still comes verbatim from its style —
+* serialize no direct `<w:numPr>` then. The moment a list command changes
+* `numPr` the values diverge and the numbering serializes as direct
+* formatting, so a stale provenance value can never swallow a user edit.
+*/
+function isStyleSourcedNumPr(attrs) {
+	return attrs.numPrFromStyle != null && attrs.numPr != null && numPrEqual(attrs.numPr, attrs.numPrFromStyle);
+}
+function assignBooleanToggle(result, attrs, orig, key) {
+	const value = attrs[key] ?? void 0;
+	if (value === (orig[key] ?? void 0)) return;
+	if (value === void 0) Reflect.deleteProperty(result, key);
+	else result[key] = value;
+}
+function paragraphAttrsToFormatting(attrs) {
+	const spaceBefore = Reflect.get(attrs, "spaceBefore");
+	const spaceAfter = Reflect.get(attrs, "spaceAfter");
+	const beforeHasAutospacingBase = hasAutospacingBaseSide(attrs._autospacingBase, "before");
+	const afterHasAutospacingBase = hasAutospacingBaseSide(attrs._autospacingBase, "after");
+	const beforeOriginalAutospacing = attrs._originalFormatting?.beforeAutospacing === true;
+	const afterOriginalAutospacing = attrs._originalFormatting?.afterAutospacing === true;
+	const beforeAutospacingEdited = beforeHasAutospacingBase ? !autospacingMatchesBase(attrs._autospacingBase, "before", spaceBefore) : beforeOriginalAutospacing && attrs._autospacingBase == null;
+	const afterAutospacingEdited = afterHasAutospacingBase ? !autospacingMatchesBase(attrs._autospacingBase, "after", spaceAfter) : afterOriginalAutospacing && attrs._autospacingBase == null;
+	const shouldSerializeSpaceBefore = typeof spaceBefore === "number" && (!beforeHasAutospacingBase || beforeAutospacingEdited);
+	const shouldSerializeSpaceAfter = typeof spaceAfter === "number" && (!afterHasAutospacingBase || afterAutospacingEdited);
+	if (attrs._originalFormatting) {
+		const orig = attrs._originalFormatting;
+		const result = { ...orig };
+		if (beforeAutospacingEdited) {
+			result.beforeAutospacing = false;
+			if (typeof spaceBefore === "number") result.spaceBefore = spaceBefore;
+			else delete result.spaceBefore;
+		}
+		if (afterAutospacingEdited) {
+			result.afterAutospacing = false;
+			if (typeof spaceAfter === "number") result.spaceAfter = spaceAfter;
+			else delete result.spaceAfter;
+		}
+		if (attrs.alignment !== (orig.alignment ?? void 0)) if (attrs.alignment) result.alignment = attrs.alignment;
+		else delete result.alignment;
+		if (isStyleSourcedNumPr(attrs)) {
+			delete result.numPr;
+			delete result.numPrFromStyle;
+		} else if (attrs.numPr !== orig.numPr && !numPrEqual(attrs.numPr, orig.numPr)) {
+			if (attrs.numPr) result.numPr = attrs.numPr;
+			else delete result.numPr;
+			delete result.numPrFromStyle;
+		}
+		if (attrs.styleId !== (orig.styleId ?? void 0)) if (attrs.styleId) result.styleId = attrs.styleId;
+		else delete result.styleId;
+		assignBooleanToggle(result, attrs, orig, "pageBreakBefore");
+		if (attrs.spacingExplicit !== orig.spacingExplicit) if (attrs.spacingExplicit) result.spacingExplicit = attrs.spacingExplicit;
+		else delete result.spacingExplicit;
+		const bidi = directionToBidi(attrs.direction);
+		if (bidi !== (orig.bidi ?? void 0)) if (bidi === void 0) delete result.bidi;
+		else result.bidi = bidi;
+		return result;
+	}
+	const outlineLevel = Reflect.get(attrs, "outlineLevel");
+	const bidi = directionToBidi(attrs.direction);
+	if (!(attrs.alignment || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || attrs.lineSpacing || attrs.indentLeft || attrs.indentRight || attrs.indentFirstLine || attrs.numPr || attrs.styleId || attrs.borders || attrs.shading || attrs.tabs || typeof outlineLevel === "number" || attrs.contextualSpacing || attrs.spacingExplicit || bidi != null || attrs.pageBreakBefore != null)) return;
+	const f = {};
+	if (attrs.alignment) f.alignment = attrs.alignment;
+	if (shouldSerializeSpaceBefore) f.spaceBefore = spaceBefore;
+	if (beforeAutospacingEdited) f.beforeAutospacing = false;
+	if (shouldSerializeSpaceAfter) f.spaceAfter = spaceAfter;
+	if (afterAutospacingEdited) f.afterAutospacing = false;
+	if (attrs.lineSpacing) f.lineSpacing = attrs.lineSpacing;
+	if (attrs.lineSpacingRule) f.lineSpacingRule = attrs.lineSpacingRule;
+	if (attrs.spacingExplicit) f.spacingExplicit = attrs.spacingExplicit;
+	if (attrs.indentLeft) f.indentLeft = attrs.indentLeft;
+	if (attrs.indentRight) f.indentRight = attrs.indentRight;
+	if (attrs.indentFirstLine) f.indentFirstLine = attrs.indentFirstLine;
+	if (attrs.hangingIndent) f.hangingIndent = attrs.hangingIndent;
+	if (attrs.numPr && !isStyleSourcedNumPr(attrs)) f.numPr = attrs.numPr;
+	if (attrs.styleId) f.styleId = attrs.styleId;
+	if (attrs.borders) f.borders = attrs.borders;
+	if (attrs.shading) f.shading = attrs.shading;
+	if (attrs.tabs) f.tabs = attrs.tabs;
+	if (typeof outlineLevel === "number") f.outlineLevel = outlineLevel;
+	if (attrs.contextualSpacing) f.contextualSpacing = attrs.contextualSpacing;
+	if (bidi != null) f.bidi = bidi;
+	if (attrs.pageBreakBefore != null) f.pageBreakBefore = attrs.pageBreakBefore;
+	return f;
+}
+/**
+* Extract paragraph content (runs, hyperlinks) from ProseMirror paragraph
+*
+* Coalesces consecutive text with the same marks into single Runs
+* for efficient DOCX representation.
+*/
+function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks) {
+	const content = [];
+	const sortedEmptyHyperlinks = (emptyHyperlinks ?? []).map((attrs, order) => ({
+		attrs,
+		order
+	})).toSorted((left, right) => left.attrs.offset - right.attrs.offset || left.order - right.order);
+	let nextEmptyHyperlink = 0;
+	let currentRun = null;
+	let currentMarksKey = null;
+	let currentHyperlink = null;
+	let currentHyperlinkKey = null;
+	const openedComments = /* @__PURE__ */ new Set();
+	const commentLastOffset = /* @__PURE__ */ new Map();
+	paragraph.forEach((node, offset) => {
+		for (const commentId of getCommentMarkIds(node.marks)) commentLastOffset.set(commentId, offset);
+	});
+	const flushCurrentInline = () => {
+		if (currentRun) {
+			content.push(currentRun);
+			currentRun = null;
+			currentMarksKey = null;
+		}
+		if (currentHyperlink) {
+			content.push(currentHyperlink);
+			currentHyperlink = null;
+			currentHyperlinkKey = null;
+		}
+	};
+	const syncCommentRanges = (node, offset) => {
+		const nodeCommentIds = getCommentMarkIds(node.marks);
+		const toClose = [];
+		for (const commentId of openedComments) {
+			const lastOffset = commentLastOffset.get(commentId) ?? offset;
+			if (!nodeCommentIds.has(commentId) && lastOffset <= offset) toClose.push(commentId);
+		}
+		const toOpen = [];
+		for (const commentId of nodeCommentIds) if (!openedComments.has(commentId)) toOpen.push(commentId);
+		if (toClose.length === 0 && toOpen.length === 0) return;
+		flushCurrentInline();
+		for (const commentId of toClose.toSorted((a, b) => a - b)) {
+			content.push({
+				type: "commentRangeEnd",
+				id: commentId
+			});
+			openedComments.delete(commentId);
+		}
+		for (const commentId of toOpen.toSorted((a, b) => a - b)) {
+			content.push({
+				type: "commentRangeStart",
+				id: commentId
+			});
+			openedComments.add(commentId);
+		}
+	};
+	const flushEmptyHyperlinksThroughOffset = (offset) => {
+		while (nextEmptyHyperlink < sortedEmptyHyperlinks.length) {
+			const item = sortedEmptyHyperlinks[nextEmptyHyperlink];
+			if (!item || item.attrs.offset > offset) break;
+			nextEmptyHyperlink += 1;
+			flushCurrentInline();
+			content.push(createEmptyHyperlink(item.attrs));
+		}
+	};
+	const processInlineNode = (node, offset) => {
+		syncCommentRanges(node, offset);
+		const linkMark = node.marks.find((m) => m.type.name === "hyperlink");
+		const noteRefMark = node.marks.find((m) => m.type.name === "footnoteRef");
+		if (noteRefMark && !linkMark) {
+			flushCurrentInline();
+			content.push(createNoteReferenceRun(noteRefMark, node.marks));
+			return;
+		}
+		const insertionMark = node.marks.find((m) => m.type.name === "insertion");
+		const deletionMark = node.marks.find((m) => m.type.name === "deletion");
+		if (insertionMark || deletionMark) {
+			flushCurrentInline();
+			const changeMark = insertionMark ?? deletionMark;
+			if (!changeMark) return;
+			const changeAttrs = expectTrackedChangeMarkAttrs(changeMark);
+			const run = createTrackedChangeRun(node, node.marks.filter((m) => m.type.name !== "insertion" && m.type.name !== "deletion"));
+			if (!run) return;
+			const info = {
+				id: changeAttrs.revisionId,
+				author: changeAttrs.author || "Unknown"
+			};
+			if (changeAttrs.date) info.date = changeAttrs.date;
+			if (insertionMark) if (changeAttrs.moveKind === "moveTo") content.push({
+				type: "moveTo",
+				info,
+				content: [run]
+			});
+			else content.push({
+				type: "insertion",
+				info,
+				content: [run]
+			});
+			else if (changeAttrs.moveKind === "moveFrom") content.push({
+				type: "moveFrom",
+				info,
+				content: [run]
+			});
+			else content.push({
+				type: "deletion",
+				info,
+				content: [run]
+			});
+			return;
+		}
+		if (linkMark) {
+			const linkKey = getLinkKey(linkMark);
+			if (currentHyperlink && currentHyperlinkKey === linkKey) addNodeToHyperlink(currentHyperlink, node);
+			else {
+				flushCurrentInline();
+				currentHyperlink = createHyperlink(linkMark);
+				currentHyperlinkKey = linkKey;
+				addNodeToHyperlink(currentHyperlink, node);
+			}
+			return;
+		}
+		if (currentHyperlink) flushCurrentInline();
+		if (node.isText) {
+			const marksKey = getMarksKey(node.marks);
+			if (currentRun && currentMarksKey === marksKey) appendTextToRun(currentRun, node.text || "");
+			else {
+				if (currentRun) content.push(currentRun);
+				currentRun = createRunFromText(node.text || "", node.marks);
+				currentMarksKey = marksKey;
+			}
+		} else if (node.type.name === "hardBreak") {
+			flushCurrentInline();
+			content.push(createBreakRun(readHardBreakType(node)));
+		} else if (node.type.name === "image") {
+			flushCurrentInline();
+			content.push(createImageRun(node));
+		} else if (node.type.name === "shape") {
+			flushCurrentInline();
+			content.push(createShapeRun(node));
+		} else if (node.type.name === "tab") {
+			flushCurrentInline();
+			content.push(createTabRun());
+		} else if (node.type.name === "field") {
+			flushCurrentInline();
+			content.push(createFieldFromNode(node, node.marks));
+		} else if (node.type.name === "sdt") {
+			flushCurrentInline();
+			content.push(createInlineSdtFromNode(node));
+		} else if (node.type.name === "math") {
+			flushCurrentInline();
+			content.push(createMathFromNode(node));
+		}
+	};
+	paragraph.forEach((node, offset) => {
+		flushEmptyHyperlinksThroughOffset(offset);
+		if (node.isText && node.text) {
+			let consumed = 0;
+			const textEndOffset = offset + node.nodeSize;
+			while (nextEmptyHyperlink < sortedEmptyHyperlinks.length) {
+				const item = sortedEmptyHyperlinks[nextEmptyHyperlink];
+				if (!item || item.attrs.offset >= textEndOffset) break;
+				const splitOffset = Math.max(item.attrs.offset - offset, consumed);
+				const segment = node.text.slice(consumed, splitOffset);
+				if (segment) processInlineNode(node.type.schema.text(segment, node.marks), offset);
+				flushCurrentInline();
+				content.push(createEmptyHyperlink(item.attrs));
+				nextEmptyHyperlink += 1;
+				consumed = splitOffset;
+			}
+			const remainder = node.text.slice(consumed);
+			if (remainder) processInlineNode(node.type.schema.text(remainder, node.marks), offset);
+			return;
+		}
+		processInlineNode(node, offset);
+	});
+	flushEmptyHyperlinksThroughOffset(Number.POSITIVE_INFINITY);
+	flushCurrentInline();
+	for (const commentId of openedComments) content.push({
+		type: "commentRangeEnd",
+		id: commentId
+	});
+	return content;
+}
+function createTrackedChangeRun(node, marks) {
+	if (node.isText) {
+		const formatting = marksToTextFormatting(marks);
+		return {
+			type: "run",
+			content: node.text ? [{
+				type: "text",
+				text: node.text
+			}] : [],
+			...Object.keys(formatting).length > 0 ? { formatting } : {}
+		};
+	}
+	if (node.type.name === "hardBreak") return createBreakRun(readHardBreakType(node));
+	if (node.type.name === "image") return createImageRun(node);
+	if (node.type.name === "shape") return createShapeRun(node);
+	if (node.type.name === "tab") return createTabRun();
+	return null;
+}
+function createEmptyHyperlink(attrs) {
+	const hyperlink = {
+		type: "hyperlink",
+		children: []
+	};
+	if (attrs.href !== void 0) hyperlink.href = attrs.href;
+	if (attrs.anchor !== void 0) hyperlink.anchor = attrs.anchor;
+	if (attrs.tooltip !== void 0) hyperlink.tooltip = attrs.tooltip;
+	if (attrs.rId !== void 0) hyperlink.rId = attrs.rId;
+	return hyperlink;
+}
+function getCommentMarkIds(marks) {
+	const commentIds = /* @__PURE__ */ new Set();
+	for (const mark of marks) if (mark.type.name === "comment") commentIds.add(expectCommentMarkAttrs(mark).commentId);
+	return commentIds;
+}
+/**
+* Build document-wide tracked change counts by scanning all nodes.
+* Used for cross-paragraph move pair detection (moveFrom in one paragraph,
+* moveTo in another).
+*/
+function buildDocumentTrackedChangeCounts(pmDoc) {
+	const insertionById = /* @__PURE__ */ new Map();
+	const deletionById = /* @__PURE__ */ new Map();
+	pmDoc.descendants((node) => {
+		const insertionMark = node.marks.find((m) => m.type.name === "insertion");
+		const deletionMark = node.marks.find((m) => m.type.name === "deletion");
+		if (insertionMark) {
+			const { revisionId } = expectTrackedChangeMarkAttrs(insertionMark);
+			insertionById.set(revisionId, (insertionById.get(revisionId) ?? 0) + 1);
+		}
+		if (deletionMark) {
+			const { revisionId } = expectTrackedChangeMarkAttrs(deletionMark);
+			deletionById.set(revisionId, (deletionById.get(revisionId) ?? 0) + 1);
+		}
+	});
+	return {
+		insertionById,
+		deletionById
+	};
+}
+/**
+* Create a unique key for a link mark
+*/
+function getLinkKey(mark) {
+	const attrs = expectHyperlinkMarkAttrs(mark);
+	return [
+		attrs.href,
+		attrs.rId ?? "",
+		attrs.tooltip ?? "",
+		attrs._docxHyperlinkIndex ?? ""
+	].join("\0");
+}
+/**
+* Create a unique key for a set of marks (excluding hyperlink)
+*/
+function getMarksKey(marks) {
+	const nonLinkMarks = marks.filter((m) => m.type.name !== "hyperlink");
+	if (nonLinkMarks.length === 0) return "";
+	return nonLinkMarks.map((m) => `${m.type.name}:${JSON.stringify(m.attrs)}`).toSorted().join("|");
+}
+/**
+* Create a Hyperlink from a link mark
+*/
+function createHyperlink(linkMark) {
+	const attrs = expectHyperlinkMarkAttrs(linkMark);
+	const href = attrs.href;
+	if (href.startsWith("#")) {
+		const hyperlink = {
+			type: "hyperlink",
+			anchor: href.slice(1),
+			children: []
+		};
+		if (attrs.tooltip) hyperlink.tooltip = attrs.tooltip;
+		return hyperlink;
+	}
+	const hyperlink = {
+		type: "hyperlink",
+		href,
+		children: []
+	};
+	if (attrs.tooltip) hyperlink.tooltip = attrs.tooltip;
+	if (attrs.rId) hyperlink.rId = attrs.rId;
+	return hyperlink;
+}
+/**
+* Add a node to a hyperlink
+*/
+function addNodeToHyperlink(hyperlink, node) {
+	const noteRefMark = node.marks.find((m) => m.type.name === "footnoteRef");
+	if (noteRefMark) {
+		hyperlink.children.push(createNoteReferenceRun(noteRefMark, node.marks));
+		return;
+	}
+	const nonLinkMarks = node.marks.filter((m) => m.type.name !== "hyperlink");
+	if (node.isText && node.text) {
+		const run = createRunFromText(node.text, nonLinkMarks);
+		hyperlink.children.push(run);
+		return;
+	}
+	if (node.type.name === "hardBreak") {
+		hyperlink.children.push(createBreakRun(readHardBreakType(node), nonLinkMarks));
+		return;
+	}
+	if (node.type.name === "tab") {
+		hyperlink.children.push(createTabRun(nonLinkMarks));
+		return;
+	}
+	if (node.type.name === "image") {
+		hyperlink.children.push(createImageRun(node));
+		return;
+	}
+	if (node.type.name === "shape") hyperlink.children.push(createShapeRun(node));
+}
+function getNoteReferenceVertAlign(noteAttrs, marks) {
+	if (marks.some((mark) => mark.type.name === "subscript")) return "subscript";
+	if (marks.some((mark) => mark.type.name === "superscript")) return "superscript";
+	if (noteAttrs.vertAlign === "baseline" || noteAttrs.vertAlign === "superscript") return noteAttrs.vertAlign;
+}
+function createNoteReferenceRun(noteRefMark, marks) {
+	const noteAttrs = expectFootnoteRefMarkAttrs(noteRefMark);
+	const run = {
+		type: "run",
+		content: [{
+			type: noteAttrs.noteType === "endnote" ? "endnoteRef" : "footnoteRef",
+			id: typeof noteAttrs.id === "string" ? Number.parseInt(noteAttrs.id, 10) || 0 : noteAttrs.id
+		}]
+	};
+	const vertAlign = getNoteReferenceVertAlign(noteAttrs, marks);
+	if (vertAlign) run.formatting = { vertAlign };
+	return run;
+}
+/**
+* Create a Run from text and marks
+*/
+function createRunFromText(text, marks) {
+	const formatting = getRunFormattingFromMarks(marks);
+	const run = {
+		type: "run",
+		content: [{
+			type: "text",
+			text
+		}]
+	};
+	if (formatting) run.formatting = formatting;
+	return run;
+}
+function getRunFormattingFromMarks(marks) {
+	if (!marks || marks.length === 0) return;
+	const formatting = marksToTextFormatting(marks);
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+/**
+* Append text to an existing run
+*/
+function appendTextToRun(run, text) {
+	const lastContent = run.content.at(-1);
+	if (lastContent && lastContent.type === "text") lastContent.text += text;
+	else run.content.push({
+		type: "text",
+		text
+	});
+}
+/**
+* Create a Run containing a line break
+*/
+function createBreakRun(breakType = "textWrapping", marks) {
+	const run = {
+		type: "run",
+		content: [{
+			type: "break",
+			breakType
+		}]
+	};
+	const formatting = getRunFormattingFromMarks(marks);
+	if (formatting) run.formatting = formatting;
+	return run;
+}
+function readHardBreakType(node) {
+	return expectHardBreakAttrs(node).breakType ?? "textWrapping";
+}
+/**
+* Create a Run containing a tab
+*/
+function createTabRun(marks) {
+	const run = {
+		type: "run",
+		content: [{ type: "tab" }]
+	};
+	const formatting = getRunFormattingFromMarks(marks);
+	if (formatting) run.formatting = formatting;
+	return run;
+}
+/**
+* Create a SimpleField or ComplexField from a PM field node
+*/
+function createFieldFromNode(node, marks) {
+	const attrs = expectFieldAttrs(node);
+	const formatting = marks && marks.length > 0 ? marksToTextFormatting(marks) : void 0;
+	let displayText = attrs.displayText || "";
+	if (!displayText) switch (attrs.fieldType) {
+		case "PAGE":
+			displayText = "1";
+			break;
+		case "NUMPAGES":
+			displayText = "1";
+			break;
+		default:
+			displayText = " ";
+			break;
+	}
+	const displayRun = {
+		type: "run",
+		content: [{
+			type: "text",
+			text: displayText
+		}],
+		...formatting && Object.keys(formatting).length > 0 ? { formatting } : {}
+	};
+	if (attrs.fieldKind === "complex") {
+		const complex = {
+			type: "complexField",
+			instruction: attrs.instruction,
+			fieldType: attrs.fieldType,
+			fieldCode: [],
+			fieldResult: [displayRun]
+		};
+		if (attrs.fldLock) complex.fldLock = true;
+		if (attrs.dirty) complex.dirty = true;
+		return complex;
+	}
+	const simple = {
+		type: "simpleField",
+		instruction: attrs.instruction,
+		fieldType: attrs.fieldType,
+		content: [displayRun]
+	};
+	if (attrs.fldLock) simple.fldLock = true;
+	if (attrs.dirty) simple.dirty = true;
+	return simple;
+}
+/**
+* Create a MathEquation from a PM math node
+*/
+function createMathFromNode(node) {
+	const attrs = expectMathAttrs(node);
+	const math = {
+		type: "mathEquation",
+		display: attrs.display ?? "inline",
+		ommlXml: attrs.ommlXml
+	};
+	if (attrs.plainText) math.plainText = attrs.plainText;
+	return math;
+}
+/**
+* Create an InlineSdt from a PM sdt node
+*/
+function createInlineSdtFromNode(node) {
+	const attrs = expectSdtAttrs(node);
+	const properties = { sdtType: attrs.sdtType };
+	if (attrs.alias) properties.alias = attrs.alias;
+	if (attrs.tag) properties.tag = attrs.tag;
+	if (typeof attrs.id === "number") properties.id = attrs.id;
+	if (attrs.lock) properties.lock = attrs.lock;
+	if (attrs.placeholder) properties.placeholder = attrs.placeholder;
+	if (attrs.showingPlaceholder !== void 0) properties.showingPlaceholder = attrs.showingPlaceholder;
+	if (attrs.dateFormat) properties.dateFormat = attrs.dateFormat;
+	if (attrs.dateValueISO) properties.dateValueISO = attrs.dateValueISO;
+	if (attrs.listItems) properties.listItems = parseSdtListItems(attrs.listItems);
+	if (typeof attrs.dropdownLastValue === "string") properties.dropdownLastValue = attrs.dropdownLastValue;
+	if (typeof attrs.checked === "boolean") properties.checked = attrs.checked;
+	if (attrs.rawPropertiesXml) properties.rawPropertiesXml = attrs.rawPropertiesXml;
+	if (attrs.rawEndPropertiesXml) properties.rawEndPropertiesXml = attrs.rawEndPropertiesXml;
+	return {
+		type: "inlineSdt",
+		properties,
+		content: extractParagraphContent(node).filter((c) => c.type === "run" || c.type === "hyperlink" || c.type === "simpleField" || c.type === "complexField" || c.type === "inlineSdt" || c.type === "mathEquation")
+	};
+}
+function parseSdtListItems(rawItems) {
+	const parsed = JSON.parse(rawItems);
+	if (!Array.isArray(parsed)) throw new TypeError("Invalid ProseMirror sdt attrs: listItems is not an array");
+	return parsed.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) throw new TypeError("Invalid ProseMirror sdt attrs: listItems contains an invalid item");
+		const itemAttrs = item;
+		if (typeof itemAttrs.displayText !== "string" || typeof itemAttrs.value !== "string") throw new TypeError("Invalid ProseMirror sdt attrs: listItems contains an invalid item");
+		return {
+			displayText: itemAttrs.displayText,
+			value: itemAttrs.value
+		};
+	});
+}
+/**
+* Create a Run containing an image
+*/
+function createImageRun(node) {
+	const attrs = expectImageAttrs(node);
+	const wrap = { type: attrs.wrapType || "inline" };
+	if (attrs.distTop !== void 0) wrap.distT = pixelsToEmu(attrs.distTop);
+	if (attrs.distBottom !== void 0) wrap.distB = pixelsToEmu(attrs.distBottom);
+	if (attrs.distLeft !== void 0) wrap.distL = pixelsToEmu(attrs.distLeft);
+	if (attrs.distRight !== void 0) wrap.distR = pixelsToEmu(attrs.distRight);
+	if (attrs.wrapText) wrap.wrapText = attrs.wrapText;
+	const image = {
+		type: "image",
+		rId: attrs.rId || "",
+		src: attrs.src,
+		size: {
+			width: pixelsToEmu(attrs.width || 0),
+			height: pixelsToEmu(attrs.height || 0)
+		},
+		wrap
+	};
+	if (attrs.alt) image.alt = attrs.alt;
+	if (attrs.title) image.title = attrs.title;
+	const imageTransform = parseTransformAttr(attrs.transform);
+	if (imageTransform) image.transform = imageTransform;
+	if (attrs.opacity != null) image.opacity = attrs.opacity;
+	const imagePosition = imagePositionFromAttrs(attrs.position);
+	if (imagePosition) image.position = imagePosition;
+	if (attrs.borderWidth && attrs.borderWidth > 0) {
+		const outline = {
+			width: pixelsToEmu(attrs.borderWidth),
+			style: attrs.borderStyle ? {
+				solid: "solid",
+				dotted: "dot",
+				dashed: "dash",
+				double: "solid",
+				groove: "solid",
+				ridge: "solid",
+				inset: "solid",
+				outset: "solid"
+			}[attrs.borderStyle] || "solid" : "solid"
+		};
+		if (attrs.borderColor) outline.color = { rgb: attrs.borderColor.replace("#", "") };
+		image.outline = outline;
+	}
+	if (attrs.hlinkHref) image.hlinkHref = attrs.hlinkHref;
+	const cropTop = attrs.cropTop != null && attrs.cropTop > 0 ? attrs.cropTop : void 0;
+	const cropRight = attrs.cropRight != null && attrs.cropRight > 0 ? attrs.cropRight : void 0;
+	const cropBottom = attrs.cropBottom != null && attrs.cropBottom > 0 ? attrs.cropBottom : void 0;
+	const cropLeft = attrs.cropLeft != null && attrs.cropLeft > 0 ? attrs.cropLeft : void 0;
+	if (cropTop !== void 0 || cropRight !== void 0 || cropBottom !== void 0 || cropLeft !== void 0) {
+		const crop = {};
+		if (cropTop !== void 0) crop.top = cropTop;
+		if (cropRight !== void 0) crop.right = cropRight;
+		if (cropBottom !== void 0) crop.bottom = cropBottom;
+		if (cropLeft !== void 0) crop.left = cropLeft;
+		image.crop = crop;
+	}
+	const drawingContent = {
+		type: "drawing",
+		image
+	};
+	if (attrs._docxRawXml) drawingContent.rawXml = attrs._docxRawXml;
+	return {
+		type: "run",
+		content: [drawingContent]
+	};
+}
+/**
+* Create a Run from a ProseMirror shape node
+*/
+function createShapeRun(node) {
+	const attrs = expectShapeAttrs(node);
+	const shape = {
+		type: "shape",
+		shapeType: attrs.shapeType || "rect",
+		size: {
+			width: attrs.width ? pixelsToEmu(attrs.width) : 0,
+			height: attrs.height ? pixelsToEmu(attrs.height) : 0
+		}
+	};
+	if (attrs.shapeId) shape.id = attrs.shapeId;
+	const shapeTransform = parseTransformAttr(attrs.transform);
+	if (shapeTransform) shape.transform = shapeTransform;
+	const wrap = { type: attrs.wrapType || "inline" };
+	if (attrs.distTop !== void 0) wrap.distT = pixelsToEmu(attrs.distTop);
+	if (attrs.distBottom !== void 0) wrap.distB = pixelsToEmu(attrs.distBottom);
+	if (attrs.distLeft !== void 0) wrap.distL = pixelsToEmu(attrs.distLeft);
+	if (attrs.distRight !== void 0) wrap.distR = pixelsToEmu(attrs.distRight);
+	if (attrs.wrapText) wrap.wrapText = attrs.wrapText;
+	shape.wrap = wrap;
+	const shapePosition = imagePositionFromAttrs(attrs.position);
+	if (shapePosition) shape.position = shapePosition;
+	if (attrs.fillType === "gradient" && attrs.gradientStops) try {
+		const parsed = JSON.parse(attrs.gradientStops);
+		const gradient = {
+			type: attrs.gradientType || "linear",
+			stops: parsed.map((s) => ({
+				position: s.position,
+				color: { rgb: s.color.replace("#", "") }
+			}))
+		};
+		if (attrs.gradientAngle) gradient.angle = attrs.gradientAngle;
+		shape.fill = {
+			type: "gradient",
+			gradient
+		};
+	} catch {
+		shape.fill = {
+			type: "solid",
+			color: { rgb: (attrs.fillColor || "000000").replace("#", "") }
+		};
+	}
+	else if (attrs.fillColor) shape.fill = {
+		type: attrs.fillType ?? "solid",
+		color: { rgb: attrs.fillColor.replace("#", "") }
+	};
+	else if (attrs.fillType === "none") shape.fill = { type: "none" };
+	if (attrs.outlineStyle !== "none" && (attrs.outlineWidth !== void 0 && attrs.outlineWidth > 0 || attrs.outlineColor || attrs.outlineStyle || attrs.outlineCap || attrs.outlineHeadEnd || attrs.outlineTailEnd)) {
+		const shapeOutline = {};
+		if (attrs.outlineWidth !== void 0 && attrs.outlineWidth > 0) shapeOutline.width = pixelsToEmu(attrs.outlineWidth);
+		if (attrs.outlineStyle) shapeOutline.style = normalizeShapeOutlineStyle(attrs.outlineStyle) ?? "solid";
+		if (attrs.outlineCap) shapeOutline.cap = attrs.outlineCap;
+		if (attrs.outlineHeadEnd) shapeOutline.headEnd = attrs.outlineHeadEnd;
+		if (attrs.outlineTailEnd) shapeOutline.tailEnd = attrs.outlineTailEnd;
+		if (attrs.outlineColor) shapeOutline.color = { rgb: attrs.outlineColor.replace("#", "") };
+		shape.outline = shapeOutline;
+	}
+	return {
+		type: "run",
+		content: [{
+			type: "shape",
+			shape
+		}]
+	};
+}
+/**
+* Convert ProseMirror marks to TextFormatting
+*/
+function marksToTextFormatting(marks) {
+	const formatting = {};
+	let characterStyleRPr;
+	for (const mark of marks) switch (mark.type.name) {
+		case "bold":
+			formatting.bold = true;
+			formatting.boldCs = true;
+			break;
+		case "italic":
+			formatting.italic = true;
+			formatting.italicCs = true;
+			break;
+		case "underline": {
+			const attrs = expectUnderlineMarkAttrs(mark);
+			const uline = { style: attrs.style || "single" };
+			if (attrs.color) uline.color = attrs.color;
+			formatting.underline = uline;
+			break;
+		}
+		case "strike":
+			if (expectStrikeMarkAttrs(mark).double) formatting.doubleStrike = true;
+			else formatting.strike = true;
+			break;
+		case "textColor": {
+			const attrs = expectTextColorMarkAttrs(mark);
+			const colorVal = {};
+			if (attrs.rgb) colorVal.rgb = attrs.rgb;
+			if (attrs.themeColor) colorVal.themeColor = attrs.themeColor;
+			if (attrs.themeTint) colorVal.themeTint = attrs.themeTint;
+			if (attrs.themeShade) colorVal.themeShade = attrs.themeShade;
+			formatting.color = colorVal;
+			break;
+		}
+		case "highlight":
+			formatting.highlight = expectHighlightMarkAttrs(mark).color;
+			break;
+		case "runShading":
+			formatting.shading = runShadingAttrsToShading(expectRunShadingMarkAttrs(mark));
+			break;
+		case "fontSize": {
+			const attrs = expectFontSizeMarkAttrs(mark);
+			formatting.fontSize = attrs.size;
+			formatting.fontSizeCs = attrs.size;
+			break;
+		}
+		case "fontFamily": {
+			const attrs = expectFontFamilyMarkAttrs(mark);
+			const ff = {};
+			if (attrs.ascii) ff.ascii = attrs.ascii;
+			if (attrs.hAnsi) ff.hAnsi = attrs.hAnsi;
+			if (attrs.eastAsia) ff.eastAsia = attrs.eastAsia;
+			const csVal = attrs.cs || attrs.ascii;
+			if (csVal) ff.cs = csVal;
+			if (attrs.asciiTheme) ff.asciiTheme = attrs.asciiTheme;
+			if (attrs.hAnsiTheme) ff.hAnsiTheme = attrs.hAnsiTheme;
+			if (attrs.eastAsiaTheme) ff.eastAsiaTheme = attrs.eastAsiaTheme;
+			if (attrs.csTheme) ff.csTheme = attrs.csTheme;
+			formatting.fontFamily = ff;
+			break;
+		}
+		case "superscript":
+			formatting.vertAlign = "superscript";
+			break;
+		case "subscript":
+			formatting.vertAlign = "subscript";
+			break;
+		case "allCaps":
+			formatting.allCaps = true;
+			break;
+		case "smallCaps":
+			formatting.smallCaps = true;
+			break;
+		case "characterSpacing": {
+			const attrs = expectCharacterSpacingMarkAttrs(mark);
+			if (attrs.spacing !== void 0) formatting.spacing = attrs.spacing;
+			if (attrs.position !== void 0) formatting.position = attrs.position;
+			if (attrs.scale !== void 0) formatting.scale = attrs.scale;
+			if (attrs.kerning !== void 0) formatting.kerning = attrs.kerning;
+			break;
+		}
+		case "emboss":
+			formatting.emboss = true;
+			break;
+		case "imprint":
+			formatting.imprint = true;
+			break;
+		case "hidden":
+			formatting.hidden = true;
+			break;
+		case "textShadow":
+			formatting.shadow = true;
+			break;
+		case "emphasisMark":
+			formatting.emphasisMark = expectEmphasisMarkAttrs(mark).type || "dot";
+			break;
+		case "textOutline":
+			formatting.outline = true;
+			break;
+		case "rtl":
+			formatting.rtl = true;
+			break;
+		case "textEffect":
+			formatting.effect = expectTextEffectMarkAttrs(mark).effect;
+			break;
+		case "runFormattingOverride":
+			applyRunFormattingOverrideAttrs(formatting, expectRunFormattingOverrideMarkAttrs(mark));
+			break;
+		case "characterStyle": {
+			const attrs = expectCharacterStyleMarkAttrs(mark);
+			formatting.styleId = attrs.styleId;
+			characterStyleRPr = attrs._styleRPr;
+			break;
+		}
+		default: break;
+	}
+	if (characterStyleRPr) return subtractCharacterStyleFormatting(formatting, characterStyleRPr);
+	return formatting;
+}
+/**
+* Negatable boolean run-property keys whose serializer emits an explicit
+* `w:val="0"` override when the value is `false` (see `serializeTextFormatting`
+* in `runSerializer.ts`). Each entry pairs a base key with the complex-script
+* mirror that `marksToTextFormatting` sets alongside it (the bold/italic marks
+* set `*Cs` too), so a negative override disables both. Keys without a complex
+* mirror use `null`.
+*/
+const NEGATABLE_STYLE_KEYS = [
+	["bold", "boldCs"],
+	["italic", "italicCs"],
+	["strike", null],
+	["doubleStrike", null],
+	["allCaps", null],
+	["smallCaps", null],
+	["hidden", null],
+	["emboss", null],
+	["imprint", null],
+	["shadow", null],
+	["outline", null],
+	["rtl", null]
+];
+/**
+* Drop run formatting values that the run's character style already provides
+* (the `w:rStyle` reference re-imposes them on load), so a styled run
+* serializes back to a style reference instead of baked direct formatting.
+*
+* `styleRPr` is the load-time snapshot from the characterStyle mark, captured
+* in the same normal form this module produces from marks, so value equality
+* is a faithful "came from the style and is unchanged" check. Values that
+* differ (user edits, direct overrides from the source document) stay as
+* direct formatting, which wins over the style per the OOXML cascade.
+*
+* When the user *removes* a boolean property the style supplied (e.g. toggling
+* off bold on text whose `w:rStyle` is bold), that key is no longer present in
+* `formatting`, so the subtraction loop above never sees it. Without a counter,
+* the run keeps the style reference and Word re-applies the removed formatting
+* on load. The second pass emits an explicit negative override (`false`) for
+* each negatable boolean the style set to `true` but the run no longer carries.
+*/
+function subtractCharacterStyleFormatting(formatting, styleRPr) {
+	const result = {};
+	for (const key of Object.keys(formatting)) {
+		const value = formatting[key];
+		if (value === void 0) continue;
+		const styleValue = key === "styleId" ? void 0 : styleRPr[key];
+		if (styleValue !== void 0 && JSON.stringify(value) === JSON.stringify(styleValue)) continue;
+		result[key] = value;
+	}
+	for (const [key, csKey] of NEGATABLE_STYLE_KEYS) {
+		if (styleRPr[key] !== true || formatting[key] !== void 0) continue;
+		result[key] = false;
+		if (csKey !== null) result[csKey] = false;
+	}
+	return result;
+}
+function applyRunFormattingOverrideAttrs(formatting, attrs) {
+	if (attrs.bold === false) formatting.bold = false;
+	if (attrs.italic === false) formatting.italic = false;
+	if (attrs.underline === "none") formatting.underline = { style: "none" };
+	if (attrs.strike === false) formatting.strike = false;
+	if (attrs.doubleStrike === false) formatting.doubleStrike = false;
+	if (attrs.allCaps === false) formatting.allCaps = false;
+	if (attrs.smallCaps === false) formatting.smallCaps = false;
+	if (attrs.hidden === false) formatting.hidden = false;
+	if (attrs.emboss === false) formatting.emboss = false;
+	if (attrs.imprint === false) formatting.imprint = false;
+	if (attrs.shadow === false) formatting.shadow = false;
+	if (attrs.outline === false) formatting.outline = false;
+	if (attrs.rtl === false) formatting.rtl = false;
+}
+/**
+* Convert a ProseMirror table node to our Table type
+*/
+function inferTableBorders(rows) {
+	for (const row of rows) for (const cell of row.cells) {
+		const borders = cell.formatting?.borders;
+		if (borders) {
+			const base = borders.top || borders.left || borders.right || borders.bottom || borders.insideH || borders.insideV;
+			if (!base) return;
+			return {
+				top: borders.top ?? base,
+				bottom: borders.bottom ?? base,
+				left: borders.left ?? base,
+				right: borders.right ?? base,
+				insideH: borders.insideH ?? borders.bottom ?? base,
+				insideV: borders.insideV ?? borders.right ?? base
+			};
+		}
+	}
+}
+function convertPMTable(node, documentCounts) {
+	const attrs = expectTableAttrs(node);
+	const rows = convertPMTableRows(node, documentCounts);
+	const formatting = tableAttrsToFormatting(attrs) || void 0;
+	if (!formatting?.borders) {
+		const inferredBorders = inferTableBorders(rows);
+		if (inferredBorders) if (formatting) formatting.borders = inferredBorders;
+		else {
+			const minTable = {
+				type: "table",
+				formatting: { borders: inferredBorders },
+				rows
+			};
+			if (attrs.columnWidths) minTable.columnWidths = attrs.columnWidths;
+			return minTable;
+		}
+	}
+	const table = {
+		type: "table",
+		rows
+	};
+	if (attrs.columnWidths) table.columnWidths = attrs.columnWidths;
+	if (formatting) table.formatting = formatting;
+	return table;
+}
+function convertPMTableRows(node, documentCounts) {
+	const rows = [];
+	const activeVerticalMerges = /* @__PURE__ */ new Map();
+	node.forEach((rowNode) => {
+		if (rowNode.type.name === "tableRow") rows.push(convertPMTableRow(rowNode, documentCounts, activeVerticalMerges));
+	});
+	return rows;
+}
+/**
+* Build CellMargins from PM margin attrs (top/bottom/left/right as number|null|undefined)
+*/
+function buildCellMarginsFromAttrs(m) {
+	const margins = {};
+	if (m.top !== null && m.top !== void 0) margins.top = {
+		value: m.top,
+		type: "dxa"
+	};
+	if (m.bottom !== null && m.bottom !== void 0) margins.bottom = {
+		value: m.bottom,
+		type: "dxa"
+	};
+	if (m.left !== null && m.left !== void 0) margins.left = {
+		value: m.left,
+		type: "dxa"
+	};
+	if (m.right !== null && m.right !== void 0) margins.right = {
+		value: m.right,
+		type: "dxa"
+	};
+	return margins;
+}
+/**
+* Convert ProseMirror table attrs to TableFormatting
+*/
+function tableAttrsToFormatting(attrs) {
+	if (attrs._originalFormatting) {
+		const orig = attrs._originalFormatting;
+		const result = { ...orig };
+		if (attrs.styleId !== (orig.styleId ?? void 0)) if (attrs.styleId) result.styleId = attrs.styleId;
+		else delete result.styleId;
+		if (attrs.justification !== (orig.justification ?? void 0)) if (attrs.justification) result.justification = attrs.justification;
+		else delete result.justification;
+		if (attrs.floating !== (orig.floating ?? void 0)) if (attrs.floating) result.floating = attrs.floating;
+		else delete result.floating;
+		if (attrs.look !== (orig.look ?? void 0)) if (attrs.look) result.look = attrs.look;
+		else delete result.look;
+		if (attrs.borders !== (orig.borders ?? void 0)) if (attrs.borders) result.borders = attrs.borders;
+		else delete result.borders;
+		const tableWidth = attrs.width;
+		const tableWidthType = attrs.widthType;
+		const origWidthVal = orig.width?.value;
+		const origWidthType = orig.width?.type;
+		if (tableWidth !== origWidthVal || tableWidthType !== origWidthType) if (tableWidth !== void 0 || tableWidthType !== void 0) result.width = {
+			value: tableWidth ?? 0,
+			type: tableWidthType ?? "dxa"
+		};
+		else delete result.width;
+		if (attrs.cellMargins) result.cellMargins = buildCellMarginsFromAttrs(attrs.cellMargins);
+		return result;
+	}
+	const tableWidth = attrs.width;
+	const tableWidthType = attrs.widthType;
+	if (!(attrs.styleId || tableWidth !== void 0 || tableWidthType !== void 0 || attrs.justification || attrs.floating || attrs.cellMargins || attrs.look || attrs.borders)) return;
+	const cellMargins = attrs.cellMargins ? buildCellMarginsFromAttrs(attrs.cellMargins) : void 0;
+	let width;
+	if (tableWidth !== void 0 || tableWidthType !== void 0) width = {
+		value: tableWidth ?? 0,
+		type: tableWidthType ?? "dxa"
+	};
+	const f = {};
+	if (attrs.styleId) f.styleId = attrs.styleId;
+	if (width) f.width = width;
+	if (attrs.justification) f.justification = attrs.justification;
+	if (attrs.floating) f.floating = attrs.floating;
+	if (cellMargins) f.cellMargins = cellMargins;
+	if (attrs.look) f.look = attrs.look;
+	if (attrs.borders) f.borders = attrs.borders;
+	return f;
+}
+/**
+* Convert a ProseMirror table row node to our TableRow type
+*/
+function convertPMTableRow(node, documentCounts, activeVerticalMerges) {
+	const attrs = expectTableRowAttrs(node);
+	const cells = [];
+	let gridColumn = 0;
+	const appendActiveVerticalMerges = () => {
+		if (!activeVerticalMerges) return;
+		let activeMerge = activeVerticalMerges.get(gridColumn);
+		while (activeMerge) {
+			const preservedCell = activeMerge.continuationCells?.shift();
+			cells.push(preservedCell ?? createVerticalMergeContinuationCell(activeMerge.colspan));
+			activeMerge.remainingRows -= 1;
+			if (activeMerge.remainingRows <= 0) activeVerticalMerges.delete(gridColumn);
+			gridColumn += activeMerge.colspan;
+			activeMerge = activeVerticalMerges.get(gridColumn);
+		}
+	};
+	node.forEach((cellNode) => {
+		appendActiveVerticalMerges();
+		if (cellNode.type.name === "tableCell" || cellNode.type.name === "tableHeader") {
+			const cellAttrs = expectTableCellAttrs(cellNode);
+			const colspan = Math.max(cellAttrs.colspan, 1);
+			cells.push(convertPMTableCell(cellNode, documentCounts));
+			if (cellAttrs.rowspan > 1) {
+				const continuationCells = cellAttrs._docxVMergeContinuationCells;
+				activeVerticalMerges?.set(gridColumn, {
+					remainingRows: cellAttrs.rowspan - 1,
+					colspan,
+					...continuationCells ? { continuationCells: [...continuationCells] } : {}
+				});
+			}
+			gridColumn += colspan;
+		}
+	});
+	appendActiveVerticalMerges();
+	const row = {
+		type: "tableRow",
+		cells
+	};
+	const rowFormatting = tableRowAttrsToFormatting(attrs);
+	if (rowFormatting) row.formatting = rowFormatting;
+	return row;
+}
+function createVerticalMergeContinuationCell(colspan) {
+	const formatting = { vMerge: "continue" };
+	if (colspan > 1) formatting.gridSpan = colspan;
+	return {
+		type: "tableCell",
+		content: [{
+			type: "paragraph",
+			content: []
+		}],
+		formatting
+	};
+}
+/**
+* Convert ProseMirror table row attrs to TableRowFormatting
+*/
+function tableRowAttrsToFormatting(attrs) {
+	if (attrs._originalFormatting) {
+		const orig = attrs._originalFormatting;
+		const result = { ...orig };
+		if (attrs.height !== (orig.height?.value ?? void 0)) if (attrs.height) result.height = {
+			value: attrs.height,
+			type: "dxa"
+		};
+		else delete result.height;
+		if (attrs.heightRule !== (orig.heightRule ?? void 0)) if (attrs.heightRule) result.heightRule = attrs.heightRule;
+		else delete result.heightRule;
+		if (attrs.isHeader !== (orig.header ?? void 0)) if (attrs.isHeader) result.header = attrs.isHeader;
+		else delete result.header;
+		return result;
+	}
+	if (!(attrs.height || attrs.isHeader)) return;
+	const f = {};
+	if (attrs.height) f.height = {
+		value: attrs.height,
+		type: "dxa"
+	};
+	if (attrs.heightRule) f.heightRule = attrs.heightRule;
+	if (attrs.isHeader) f.header = attrs.isHeader;
+	return f;
+}
+/**
+* Convert a ProseMirror table cell node to our TableCell type
+*/
+function convertPMTableCell(node, documentCounts) {
+	const attrs = expectTableCellAttrs(node);
+	const content = [];
+	node.forEach((contentNode) => {
+		if (contentNode.type.name === "paragraph") content.push(convertPMParagraph(contentNode, documentCounts));
+		else if (contentNode.type.name === "table") content.push(convertPMTable(contentNode, documentCounts));
+	});
+	const cell = {
+		type: "tableCell",
+		content
+	};
+	const cellFormatting = tableCellAttrsToFormatting(attrs);
+	if (cellFormatting) cell.formatting = cellFormatting;
+	return cell;
+}
+/**
+* Convert ProseMirror table cell attrs to TableCellFormatting
+* Borders are stored as full BorderSpec objects — no conversion needed.
+*/
+function tableCellAttrsToFormatting(attrs) {
+	if (attrs._originalFormatting) {
+		const orig = attrs._originalFormatting;
+		const result = { ...orig };
+		if (attrs.colspan > 1) result.gridSpan = attrs.colspan;
+		if (attrs.rowspan > 1) result.vMerge = "restart";
+		else if (result.vMerge === "restart" && !attrs._preserveVMergeRestart) delete result.vMerge;
+		const cellWidth = attrs.width;
+		if (cellWidth !== void 0) result.width = {
+			value: cellWidth,
+			type: attrs.widthType ?? "dxa"
+		};
+		if (attrs.verticalAlign !== (orig.verticalAlign ?? void 0)) if (attrs.verticalAlign) result.verticalAlign = attrs.verticalAlign;
+		else delete result.verticalAlign;
+		if (attrs.backgroundColor) result.shading = { fill: { rgb: attrs.backgroundColor } };
+		else if (!attrs.backgroundColor && orig.shading) delete result.shading;
+		if (attrs.borders) result.borders = attrs.borders;
+		if (attrs.margins) result.margins = buildCellMarginsFromAttrs(attrs.margins);
+		if (attrs.textDirection !== (orig.textDirection ?? void 0)) if (attrs.textDirection) result.textDirection = attrs.textDirection;
+		else delete result.textDirection;
+		return result;
+	}
+	const cellWidth = attrs.width;
+	if (!(attrs.colspan > 1 || attrs.rowspan > 1 || cellWidth !== void 0 || attrs.verticalAlign || attrs.backgroundColor || attrs.borders || attrs.margins || attrs.textDirection)) return;
+	const f = {};
+	if (attrs.colspan > 1) f.gridSpan = attrs.colspan;
+	if (attrs.rowspan > 1) f.vMerge = "restart";
+	if (cellWidth !== void 0) f.width = {
+		value: cellWidth,
+		type: attrs.widthType ?? "dxa"
+	};
+	if (attrs.verticalAlign) f.verticalAlign = attrs.verticalAlign;
+	if (attrs.textDirection) f.textDirection = attrs.textDirection;
+	if (attrs.backgroundColor) f.shading = { fill: { rgb: attrs.backgroundColor } };
+	if (attrs.borders) f.borders = attrs.borders;
+	if (attrs.margins) f.margins = buildCellMarginsFromAttrs(attrs.margins);
+	return f;
+}
+/**
+* Convert a ProseMirror textBox node back to a Paragraph wrapping a ShapeContent run.
+* The text box content becomes a Shape with textBody.
+*/
+function convertPMTextBox(node) {
+	const attrs = expectTextBoxAttrs(node);
+	const childParagraphs = [];
+	node.forEach((child) => {
+		if (child.type.name === "paragraph") childParagraphs.push(convertPMParagraph(child));
+	});
+	const shape = {
+		type: "shape",
+		shapeType: "textBox",
+		size: {
+			width: attrs.width ? pixelsToEmu(attrs.width) : 0,
+			height: attrs.height ? pixelsToEmu(attrs.height) : 0
+		},
+		textBody: {
+			content: childParagraphs.length > 0 ? childParagraphs : [{
+				type: "paragraph",
+				content: []
+			}],
+			margins: (() => {
+				const m = {};
+				if (typeof attrs.marginTop === "number") m.top = pixelsToEmu(attrs.marginTop);
+				if (typeof attrs.marginBottom === "number") m.bottom = pixelsToEmu(attrs.marginBottom);
+				if (typeof attrs.marginLeft === "number") m.left = pixelsToEmu(attrs.marginLeft);
+				if (typeof attrs.marginRight === "number") m.right = pixelsToEmu(attrs.marginRight);
+				return m;
+			})()
+		}
+	};
+	if (attrs.textBoxId) shape.id = attrs.textBoxId;
+	if (attrs.fillColor) shape.fill = {
+		type: "solid",
+		color: { rgb: attrs.fillColor.replace("#", "") }
+	};
+	if (attrs.outlineStyle !== "none" && attrs.outlineWidth && attrs.outlineWidth > 0) {
+		const tbOutline = {
+			width: pixelsToEmu(attrs.outlineWidth),
+			style: normalizeShapeOutlineStyle(attrs.outlineStyle) ?? "solid"
+		};
+		if (attrs.outlineColor) tbOutline.color = { rgb: attrs.outlineColor.replace("#", "") };
+		shape.outline = tbOutline;
+	}
+	const wrap = textBoxWrapFromAttrs(attrs);
+	if (wrap) shape.wrap = wrap;
+	const position = imagePositionFromAttrs(attrs.position);
+	if (position) shape.position = position;
+	return {
+		type: "paragraph",
+		content: [{
+			type: "run",
+			content: [{
+				type: "shape",
+				shape
+			}]
+		}]
+	};
+}
+/**
+* Update a Document with content from a ProseMirror document
+* Preserves all non-content parts of the original document
+*/
+function updateDocumentContent(originalDocument, pmDoc) {
+	return fromProseDoc(pmDoc, originalDocument);
+}
+/**
+* Convert a ProseMirror document back to an array of `BlockContent` blocks
+* (paragraphs, tables, and block-level content controls).
+*
+* Used for converting edited header/footer PM content back to the document
+* model.
+*/
+function proseDocToBlocks(pmDoc) {
+	return extractBlocks(pmDoc);
+}
+//#endregion
+export { fromProseDoc, marksToTextFormatting, proseDocToBlocks, updateDocumentContent };