@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -13,11 +13,10 @@ import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { normalizeShapeTextAnchor, presetDashForOutlineAttr } from "../../types/documentEnumValues.js";
 import { presetDashForCssBorderStyle } from "../../utils/borderCss.js";
 import { canonicalJson } from "../../utils/canonicalJson.js";
-import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
 import { emuToPixels, emuToStrokePixels, pixelsToEmu } from "../../utils/units.js";
 import { unchangedAlternateContentXml } from "../alternateContentAttrs.js";
-import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../attrs/index.js";
+import { expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectFieldAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
 import { readAuthoredTransform } from "../authoredTransformAttrs.js";
 import { autospacingMatchesBase, hasAutospacingBaseSide } from "../autospacingBase.js";
 import { bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs } from "../bookmarkBoundaryAttrs.js";
@@ -25,30 +24,29 @@ import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removePara
 import { expectCommentReferenceAttrs } from "../commentReferenceAttrs.js";
 import { enclosingRevisionIds } from "../contentControlRevisions.js";
 import { INLINE_WRAPPER_MARK_NAME } from "../extensions/marks/InlineWrapperExtension.js";
-import { applyRunFormattingOverrideAttrs, buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
 import { textFormattingToMarks } from "../extensions/marks/markUtils.js";
 import "../extensions/nodes/MoveRangeBoundaryExtension.js";
 import "../extensions/nodes/RangeAnchorExtension.js";
 import { inlineWrapperMember, inlineWrapperStackKey } from "../inlineWrapperStack.js";
-import { listRenderingFromAttrs as listRenderingFromAttrs$1 } from "../listRenderingAttrs.js";
+import { completeNumberingForDoc } from "../listInstanceReferences.js";
+import { hasListRendering, listRenderingFromAttrs as listRenderingFromAttrs$1 } from "../listRenderingAttrs.js";
 import { expectMoveRangeBoundaryAttrs } from "../moveRangeBoundaryAttrs.js";
 import { resolveNumberedRefFields } from "../numberedRefFields.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionToAuthoredBidi } from "../paragraphDirection.js";
 import { directParagraphSpacing } from "../paragraphSpacing.js";
 import { expectRangeAnchorAttrs } from "../rangeAnchorAttrs.js";
+import { marksToTextFormatting, sameFormattingValue } from "../runFormattingFromMarks.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
-import { authoredRunFormattingFromAttrs, hasAuthoredRunFormattingProvenance } from "../runFormattingProvenance.js";
 import { RUN_IDENTITY_MARK_NAME } from "../runIdentity.js";
-import { paragraphFormattingForRun, paragraphRunStyleContext, resolveEffectiveRunStyleFormatting, suppressParagraphMarkFormatting } from "../runStyleFormatting.js";
-import { schema } from "../schema/index.js";
+import { paragraphFormattingForRun, paragraphRunStyleContext, resolveEffectiveRunStyleFormatting } from "../runStyleFormatting.js";
 import { PRESERVED_XML_LEVELS } from "../schema/nodes.js";
 import { parseShapeGeometryAdjustments } from "../shapeGeometryAdjustments.js";
 import { expectTextBoxAnchorAttrs } from "../textBoxAnchorAttrs.js";
 import { textBoxHostParagraph } from "../textBoxHostParagraph.js";
+import { enclosingInsertionAncestors, inlineWrapperStackOf } from "../trackedRevisionPath.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { hasSinkChildren } from "./preservedSinkCarriers.js";
-import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "./runShadingMark.js";
 import { decodeSdtListItems, sdtPropertiesFromAttrs, sdtPropertiesMatchAttrs } from "./sdtAttrs.js";
 import { panic } from "better-result";
 import { DRAWING_RAW_XML_MODES, relationshipIdOf } from "@stll/docx-core/model";
@@ -280,18 +278,23 @@ function fromProseDoc(pmDoc, baseDocument, { reuse = "none" } = {}) {
 	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;
+	const numbering = completeNumberingForDoc(baseDocument?.package.numbering, pmDoc);
 	if (baseDocument) {
 		const updatedDocument = {
 			...baseDocument,
 			package: {
 				...baseDocument.package,
-				document: documentBody
+				document: documentBody,
+				...numbering ? { numbering } : {}
 			}
 		};
 		copyDocumentParagraphPropertySourceContract(updatedDocument, baseDocument);
 		return updatedDocument;
 	}
-	return { package: { document: documentBody } };
+	return { package: {
+		document: documentBody,
+		...numbering ? { numbering } : {}
+	} };
 }
 const isSuggestedMark = (mark) => mark.attrs["provenance"] === "suggested";
 const hasSuggestedInsertion = (marks) => marks.some((mark) => mark.type.name === "insertion" && isSuggestedMark(mark));
@@ -330,7 +333,7 @@ function stripSuggestedInlineMarks(marks, { baseParagraphFormatting, inheritedFo
 			styleResolver
 		}) : paragraphFormatting, previousFormatting);
 		next = next.filter((mark) => !RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
-		for (const restored of textFormattingToMarks(effectivePreviousFormatting, schema, {
+		for (const restored of textFormattingToMarks(effectivePreviousFormatting, suggestedRunPropertyChange.type.schema, {
 			overrideFormatting: previousFormatting,
 			directFormatting: previousFormatting
 		})) next = restored.addToSet(next);
@@ -341,12 +344,30 @@ function stripSuggestedInlineMarks(marks, { baseParagraphFormatting, inheritedFo
 	}
 	return next;
 }
+/** A paragraph's attrs without its suggested property changes, or `null` when it has none. */
+function stripSuggestedParagraphPropertyChanges(node) {
+	const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
+	if (!Array.isArray(propertyChanges)) return null;
+	if (!propertyChanges.some(({ info }) => info.provenance === "suggested")) return null;
+	const removal = removeParagraphPropertyChanges(propertyChanges, ({ info }) => info.provenance === "suggested");
+	if (removal.type === "unchanged") return null;
+	const nextAttrs = {
+		...node.attrs,
+		_propertyChanges: removal.remaining.length > 0 ? removal.remaining : null
+	};
+	if (removal.type === "restore-previous") {
+		Object.assign(nextAttrs, paragraphRejectAttrPatch(removal.previousFormatting));
+		nextAttrs["_originalFormatting"] = paragraphRejectOriginalFormatting(removal.previousFormatting, nextAttrs["_originalFormatting"]);
+	}
+	return nextAttrs;
+}
 /**
 * Compute the node attrs a block/structural node keeps once its suggested
 * revision markers are neutralized. Returns `null` when nothing changes.
 *
-* - a suggested `trDel` / `cellMarker` (insertion or deletion) is cleared so
-*   the row/cell serializes as though the proposed change never happened;
+* - a suggested `trDel` / `cellMarker` (insertion or deletion) or paragraph
+*   mark revision (`pPrMark`) is cleared so the node serializes as though the
+*   proposed change never happened;
 *   merge markers never carry suggestion provenance (structurally excluded);
 * - suggested INSERT markers are handled by the caller, which drops the whole
 *   node instead of clearing an attr.
@@ -356,20 +377,13 @@ function stripSuggestedInlineMarks(marks, { baseParagraphFormatting, inheritedFo
 function stripSuggestedNodeAttrs(node) {
 	const name = node.type.name;
 	if (name === "paragraph") {
-		const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
-		if (!Array.isArray(propertyChanges)) return null;
-		if (!propertyChanges.some(({ info }) => info.provenance === "suggested")) return null;
-		const removal = removeParagraphPropertyChanges(propertyChanges, ({ info }) => info.provenance === "suggested");
-		if (removal.type === "unchanged") return null;
-		const nextAttrs = {
-			...node.attrs,
-			_propertyChanges: removal.remaining.length > 0 ? removal.remaining : null
+		const stripped = stripSuggestedParagraphPropertyChanges(node);
+		const markInfo = expectParagraphAttrs(node).pPrMark?.info;
+		if (!(typeof markInfo === "object" && markInfo !== null && "provenance" in markInfo && markInfo.provenance === "suggested")) return stripped;
+		return {
+			...stripped ?? node.attrs,
+			pPrMark: null
 		};
-		if (removal.type === "restore-previous") {
-			Object.assign(nextAttrs, paragraphRejectAttrPatch(removal.previousFormatting));
-			nextAttrs["_originalFormatting"] = paragraphRejectOriginalFormatting(removal.previousFormatting, nextAttrs["_originalFormatting"]);
-		}
-		return nextAttrs;
 	}
 	if (name === "tableRow") {
 		const rowAttrs = expectTableRowAttrs(node);
@@ -536,10 +550,15 @@ function extractBlocks(inputDoc, refResolution = "resolve", styleResolver = null
 			if (pendingPageBreaks > 0 && !appendPendingPageBreaksToPreviousParagraph()) flushPendingPageBreaks();
 			blocks.push(convertPMBlockSdt(node, styleResolver));
 			previousStandaloneTextBox = null;
+		} else if (node.type.name === "blockCustomXml") {
+			blocks.push(convertPMBlockCustomXml(node, styleResolver));
+			previousStandaloneTextBox = null;
 		} else if (node.type.name === "preservedBlock") {
+			const { xml, readerText } = expectPreservedBlockAttrs(node);
 			blocks.push({
 				type: "preservedBlock",
-				xml: expectPreservedBlockAttrs(node).xml
+				xml,
+				...readerText === void 0 ? {} : { readerText }
 			});
 			previousStandaloneTextBox = null;
 		} else if (node.type.name === "blockBookmarkBoundary") {
@@ -669,6 +688,16 @@ function convertPMBlockSdt(node, styleResolver) {
 		content: attrs._originallyEmpty === true && isStillSyntheticFiller(extracted) ? [] : extracted
 	};
 }
+function convertPMBlockCustomXml(node, styleResolver) {
+	const { openingXml, closingXml, _originallyEmpty } = expectBlockCustomXmlAttrs(node);
+	const extracted = extractBlocks(node.type.schema.node("doc", null, node.content), "inherit", styleResolver);
+	return {
+		type: "blockCustomXml",
+		openingXml,
+		closingXml,
+		content: _originallyEmpty === true && isStillSyntheticFiller(extracted) ? [] : extracted
+	};
+}
 function isStillSyntheticFiller(blocks) {
 	if (blocks.length !== 1) return false;
 	const block = blocks[0];
@@ -776,7 +805,7 @@ function replaceTextBoxAnchorInBlocks(blocks, marker, textBoxRun) {
 			for (const row of block.rows) for (const cell of row.cells) if (replaceTextBoxAnchorInBlocks(cell.content, marker, textBoxRun)) return true;
 			continue;
 		}
-		if (block.type !== "blockSdt") continue;
+		if (block.type !== "blockSdt" && block.type !== "blockCustomXml") continue;
 		if (replaceTextBoxAnchorInBlocks(block.content, marker, textBoxRun)) return true;
 	}
 	return false;
@@ -845,7 +874,7 @@ function removeTextBoxAnchorFromBlocks(blocks, marker) {
 			for (const row of block.rows) for (const cell of row.cells) if (removeTextBoxAnchorFromBlocks(cell.content, marker)) return true;
 			continue;
 		}
-		if (block.type !== "blockSdt") continue;
+		if (block.type !== "blockSdt" && block.type !== "blockCustomXml") continue;
 		if (removeTextBoxAnchorFromBlocks(block.content, marker)) return true;
 	}
 	return false;
@@ -859,7 +888,7 @@ function removeTextBoxAnchorFromBlocks(blocks, marker) {
 function listRenderingFromAttrs(attrs) {
 	const numId = paragraphNumberingReferenceId$1(attrs.numPr);
 	if (numId === void 0) return;
-	if (!(attrs.listMarker != null || attrs.listIsBullet || attrs.listNumFmt != null)) return;
+	if (!hasListRendering(attrs)) return;
 	return listRenderingFromAttrs$1({
 		attrs,
 		numId
@@ -989,6 +1018,35 @@ function assignBooleanToggle(result, attrs, orig, key) {
 	if (value === void 0) Reflect.deleteProperty(result, key);
 	else result[key] = value;
 }
+const PARAGRAPH_INDENTATION_VALUE_FIELDS = [
+	"indentLeft",
+	"indentRight",
+	"indentFirstLine"
+];
+/**
+* `w:ind` as the paragraph states it now.
+*
+* An indentation command edits the attrs and leaves `_originalFormatting`
+* alone, so a paragraph that arrived with any `w:pPr` of its own saved its
+* source indentation whatever the editor showed. A field the source stated is
+* written at its current value; one it did not is written only when the style
+* cascade does not already supply that value, as for a paragraph without
+* `_originalFormatting`.
+*/
+function assignParagraphIndentation(result, attrs, orig) {
+	let changed = false;
+	for (const key of PARAGRAPH_INDENTATION_VALUE_FIELDS) {
+		const value = authoredParagraphValue(key, attrs[key] ?? void 0, orig, attrs._resolvedFormatting);
+		if (value === (orig[key] ?? void 0)) continue;
+		changed = true;
+		if (value === void 0) Reflect.deleteProperty(result, key);
+		else result[key] = value;
+	}
+	const hanging = result.indentFirstLine !== void 0 && attrs.hangingIndent === true;
+	if (!changed && hanging === (orig.hangingIndent === true)) return;
+	if (hanging) result.hangingIndent = true;
+	else Reflect.deleteProperty(result, "hangingIndent");
+}
 function paragraphAttrsToFormatting(attrs) {
 	const directAlignment = directParagraphAlignment(attrs);
 	const directSpacing = directParagraphSpacing(attrs);
@@ -1042,6 +1100,7 @@ function paragraphAttrsToFormatting(attrs) {
 		}
 		if (attrs.styleId !== (orig.styleId ?? void 0)) if (attrs.styleId) result.styleId = attrs.styleId;
 		else delete result.styleId;
+		assignParagraphIndentation(result, attrs, orig);
 		assignBooleanToggle(result, attrs, orig, "pageBreakBefore");
 		assignBooleanToggle(result, attrs, orig, "widowControl");
 		assignBooleanToggle(result, attrs, orig, "keepNext");
@@ -1063,9 +1122,11 @@ function paragraphAttrsToFormatting(attrs) {
 	const outlineLevel = authored("outlineLevel", Reflect.get(attrs, "outlineLevel"));
 	const bidi = authored("bidi", directionToAuthoredBidi(attrs.direction));
 	const snapToGrid = authored("snapToGrid", attrs.snapToGrid);
-	const indentLeft = authored("indentLeft", attrs.indentLeft);
+	const numbered = paragraphNumberingReferenceId$1(attrs.numPr ?? void 0) !== void 0;
+	const statedIndent = (value) => value === 0 && !numbered ? void 0 : value;
+	const indentLeft = statedIndent(authored("indentLeft", attrs.indentLeft));
 	const indentRight = authored("indentRight", attrs.indentRight);
-	const indentFirstLine = authored("indentFirstLine", attrs.indentFirstLine);
+	const indentFirstLine = statedIndent(authored("indentFirstLine", attrs.indentFirstLine));
 	const borders = authored("borders", attrs.borders);
 	const shading = authored("shading", attrs.shading);
 	const tabs = authored("tabs", attrs.tabs);
@@ -1078,7 +1139,7 @@ function paragraphAttrsToFormatting(attrs) {
 	const kinsoku = authored("kinsoku", attrs.kinsoku);
 	const overflowPunctuation = authored("overflowPunctuation", attrs.overflowPunctuation);
 	const suppressAutoHyphens = authored("suppressAutoHyphens", attrs.suppressAutoHyphens);
-	if (!(directAlignment !== void 0 || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || hasDirectLineSpacing || hasDirectLineSpacingRule || snapToGrid != null || indentLeft || indentRight || indentFirstLine || attrs.numPr || attrs.styleId || borders || shading || tabs || outlineLevel !== void 0 || contextualSpacing || attrs.spacingExplicit || bidi != null || pageBreakBefore != null || widowControl != null || keepNext != null || keepLines != null || runInWithNext != null || kinsoku != null || overflowPunctuation != null || suppressAutoHyphens != null)) return;
+	if (!(directAlignment !== void 0 || shouldSerializeSpaceBefore || shouldSerializeSpaceAfter || beforeAutospacingEdited || afterAutospacingEdited || hasDirectLineSpacing || hasDirectLineSpacingRule || snapToGrid != null || indentLeft !== void 0 || indentRight || indentFirstLine !== void 0 || attrs.numPr || attrs.styleId || borders || shading || tabs || outlineLevel !== void 0 || contextualSpacing || attrs.spacingExplicit || bidi != null || pageBreakBefore != null || widowControl != null || keepNext != null || keepLines != null || runInWithNext != null || kinsoku != null || overflowPunctuation != null || suppressAutoHyphens != null)) return;
 	const f = {};
 	if (directAlignment !== void 0) f.alignment = directAlignment;
 	if (shouldSerializeSpaceBefore) f.spaceBefore = spaceBefore;
@@ -1089,9 +1150,9 @@ function paragraphAttrsToFormatting(attrs) {
 	if (hasDirectLineSpacingRule && attrs.lineSpacingRule) f.lineSpacingRule = attrs.lineSpacingRule;
 	if (snapToGrid != null) f.snapToGrid = snapToGrid;
 	if (attrs.spacingExplicit) f.spacingExplicit = attrs.spacingExplicit;
-	if (indentLeft) f.indentLeft = indentLeft;
+	if (indentLeft !== void 0) f.indentLeft = indentLeft;
 	if (indentRight) f.indentRight = indentRight;
-	if (indentFirstLine) f.indentFirstLine = indentFirstLine;
+	if (indentFirstLine !== void 0) f.indentFirstLine = indentFirstLine;
 	if (attrs.hangingIndent && indentFirstLine) f.hangingIndent = attrs.hangingIndent;
 	if (attrs.numPr !== void 0 && !isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) f.numPr = attrs.numPr;
 	if (attrs.styleId) f.styleId = attrs.styleId;
@@ -1143,11 +1204,6 @@ function createTrackedRunWrapper(type, info, child) {
 * document each time the same one is saved.
 */
 const byCommentId = (ids) => [...ids].toSorted((a, b) => a - b);
-/** The wrappers `node` sits inside, outermost first; empty when it sits in none. */
-const inlineWrapperStackOf = (node) => {
-	const mark = node.marks.find((candidate) => candidate.type.name === INLINE_WRAPPER_MARK_NAME);
-	return mark ? expectInlineWrapperMarkAttrs(mark).stack : [];
-};
 /** The authored hyperlink that owns a suffix of the node's wrapper stack. */
 const inlineWrapperHyperlinkOriginOf = (node) => {
 	const mark = node.marks.find((candidate) => candidate.type.name === INLINE_WRAPPER_MARK_NAME);
@@ -1505,9 +1561,14 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 		}
 		if (insertionMark || deletionMark) {
 			flushCurrentInline();
-			const changeMark = insertionMark ?? deletionMark;
+			const changeMark = deletionMark ?? insertionMark;
 			if (!changeMark) return;
 			const changeAttrs = expectTrackedChangeMarkAttrs(changeMark);
+			const revisionAncestors = enclosingInsertionAncestors({
+				insertionMark: deletionMark ? insertionMark : void 0,
+				ancestors: changeAttrs._docxRevisionAncestors ?? [],
+				node
+			});
 			const otherMarks = node.marks.filter((m) => m.type.name !== "insertion" && m.type.name !== "deletion");
 			const info = {
 				id: changeAttrs.revisionId,
@@ -1520,17 +1581,17 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			};
 			if (changeAttrs.initials) info.initials = changeAttrs.initials;
 			let type;
-			if (insertionMark) type = changeAttrs.moveKind === "moveTo" ? "moveTo" : "insertion";
+			if (changeMark === insertionMark) type = changeAttrs.moveKind === "moveTo" ? "moveTo" : "insertion";
 			else type = changeAttrs.moveKind === "moveFrom" ? "moveFrom" : "deletion";
 			const outerWrapperCount = changeAttrs._docxOuterWrapperCount ?? inlineWrapperStackOf(node).length;
-			const trackedChangeKey = `${type}:${JSON.stringify(info)}:${outerWrapperCount}:${JSON.stringify(changeAttrs._docxRevisionAncestors ?? [])}`;
+			const trackedChangeKey = `${type}:${JSON.stringify(info)}:${outerWrapperCount}:${JSON.stringify(revisionAncestors)}`;
 			if (linkMark) {
 				const linkKey = getLinkKey(linkMark);
 				if (!currentTrackedChange || currentTrackedChange.type !== "hyperlink" || currentTrackedChange.key !== trackedChangeKey || currentTrackedChange.hyperlinkKey !== linkKey) {
 					const hyperlink = createIndexedHyperlink(linkMark);
 					const wrapper = createTrackedRunWrapper(type, info, hyperlink);
 					revisionOuterWrapperCounts.set(wrapper, outerWrapperCount);
-					revisionAncestorsByWrapper.set(wrapper, changeAttrs._docxRevisionAncestors ?? []);
+					revisionAncestorsByWrapper.set(wrapper, revisionAncestors);
 					content.push(wrapper);
 					currentTrackedChange = {
 						type: "hyperlink",
@@ -1565,7 +1626,7 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			if (!currentTrackedChange || currentTrackedChange.type !== "direct" || currentTrackedChange.key !== trackedChangeKey) {
 				const wrapper = createTrackedRunWrapper(type, info);
 				revisionOuterWrapperCounts.set(wrapper, outerWrapperCount);
-				revisionAncestorsByWrapper.set(wrapper, changeAttrs._docxRevisionAncestors ?? []);
+				revisionAncestorsByWrapper.set(wrapper, revisionAncestors);
 				content.push(wrapper);
 				currentTrackedChange = {
 					type: "direct",
@@ -2255,18 +2316,19 @@ function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormattin
 	};
 	if (marks && node.type.name === "field") restoreRunRecord(displayRun, marks);
 	const fieldContent = extractedContent.length > 0 ? synchronizeFieldDisplayText(extractedContent, displayText, displayRun) : [];
-	const fallbackFieldContent = displayText ? [displayRun] : [];
+	const fallbackFieldContent = displayText ? [displayRun] : reconcileEmptyFieldResultRuns(attrs._docxEmptyResultRuns, displayRun);
 	if (attrs.fieldKind === "complex") {
 		const complex = {
 			type: "complexField",
 			instruction: attrs.instruction,
 			fieldType: attrs.fieldType,
-			fieldCode: [],
+			fieldCode: attrs._docxFieldCode?.instruction === attrs.instruction ? attrs._docxFieldCode.runs : [],
 			fieldResult: fieldContent.length > 0 ? fieldContent.filter((content) => content.type === "run") : fallbackFieldContent
 		};
 		if (attrs.fldLock !== void 0) complex.fldLock = attrs.fldLock;
 		if (attrs.dirty !== void 0) complex.dirty = attrs.dirty;
 		if (attrs.fieldResultIsFallback !== void 0) complex.fieldResultIsFallback = attrs.fieldResultIsFallback;
+		if (attrs.formFieldDataXml !== void 0) complex.formFieldDataXml = attrs.formFieldDataXml;
 		return complex;
 	}
 	const simple = {
@@ -2279,6 +2341,48 @@ function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormattin
 	if (attrs.dirty !== void 0) simple.dirty = attrs.dirty;
 	return simple;
 }
+const reconcileEmptyFieldResultRuns = (runs, displayRun) => {
+	if (!runs?.length) return [];
+	const firstFormatting = runs.findIndex((run) => run.formatting !== void 0);
+	const formattingOwner = firstFormatting < 0 ? 0 : firstFormatting;
+	const projectedChanges = displayRun.propertyChanges ?? [];
+	const projectedById = /* @__PURE__ */ new Map();
+	projectedChanges.forEach((change, index) => {
+		const positions = projectedById.get(change.info.id) ?? [];
+		positions.push(index);
+		projectedById.set(change.info.id, positions);
+	});
+	const usedChanges = /* @__PURE__ */ new Set();
+	const reconciled = runs.map((run, index) => {
+		const propertyChanges = run.propertyChanges?.flatMap((change) => {
+			const projectedIndex = projectedById.get(change.info.id)?.shift();
+			if (projectedIndex === void 0) return [];
+			usedChanges.add(projectedIndex);
+			const projected = projectedChanges[projectedIndex];
+			return projected ? [projected] : [];
+		});
+		if (index !== formattingOwner && !run.propertyChanges && index !== 0) return run;
+		let formatting = index === formattingOwner ? displayRun.formatting : run.formatting;
+		if (index === formattingOwner && !formatting && run.formatting && Object.keys(run.formatting).length === 0) formatting = run.formatting;
+		const preservedAttributes = index === 0 ? displayRun.preservedAttributes ?? run.preservedAttributes : run.preservedAttributes;
+		return {
+			type: "run",
+			content: run.content,
+			...formatting ? { formatting } : {},
+			...propertyChanges?.length ? { propertyChanges } : {},
+			...preservedAttributes ? { preservedAttributes } : {}
+		};
+	});
+	const newChanges = projectedChanges.filter((_, index) => !usedChanges.has(index));
+	if (newChanges.length > 0) {
+		const first = reconciled[0];
+		if (first) reconciled[0] = {
+			...first,
+			propertyChanges: [...first.propertyChanges ?? [], ...newChanges]
+		};
+	}
+	return reconciled;
+};
 const synchronizeFieldDisplayText = (content, displayText, fallbackRun) => {
 	let currentText = "";
 	const visitRunsIn = (items, visit) => {
@@ -2586,563 +2690,6 @@ function createShapeRun(node) {
 	restoreRunRecord(run, node.marks);
 	return run;
 }
-const RUN_FORMATTING_VISUAL_GROUPS = {
-	bold: "bold",
-	boldCs: null,
-	italic: "italic",
-	italicCs: null,
-	underline: "underline",
-	strike: "strike",
-	doubleStrike: "strike",
-	vertAlign: "vertAlign",
-	smallCaps: "smallCaps",
-	allCaps: "allCaps",
-	hidden: "hidden",
-	noProof: null,
-	color: "color",
-	highlight: "highlight",
-	shading: "shading",
-	fontSize: "fontSize",
-	fontSizeCs: null,
-	fontFamily: "fontFamily",
-	language: "language",
-	spacing: "characterSpacing",
-	position: "characterSpacing",
-	scale: "characterSpacing",
-	kerning: "characterSpacing",
-	effect: "effect",
-	emphasisMark: "emphasisMark",
-	emboss: "emboss",
-	imprint: "imprint",
-	outline: "outline",
-	shadow: "shadow",
-	rtl: "rtl",
-	cs: null,
-	styleId: null,
-	preserved: null
-};
-const RUN_FORMATTING_FAST_PATH_DISPOSITION = {
-	bold: "visual",
-	boldCs: "structural",
-	italic: "visual",
-	italicCs: "structural",
-	underline: "visual",
-	strike: "visual",
-	doubleStrike: "visual",
-	vertAlign: "visual",
-	smallCaps: "visual",
-	allCaps: "visual",
-	hidden: "visual",
-	noProof: "structural",
-	color: "visual",
-	highlight: "visual",
-	shading: "visual",
-	fontSize: "visual",
-	fontSizeCs: "structural",
-	fontFamily: "visual",
-	language: "visual",
-	spacing: "visual",
-	position: "visual",
-	scale: "visual",
-	kerning: "visual",
-	effect: "visual",
-	emphasisMark: "visual",
-	emboss: "visual",
-	imprint: "visual",
-	outline: "visual",
-	shadow: "visual",
-	rtl: "visual",
-	cs: "structural",
-	styleId: "character-style",
-	preserved: "structural"
-};
-const hasOnlyCarrierlessVisualFormatting = (formatting) => {
-	for (const property of Object.keys(formatting)) if (RUN_FORMATTING_FAST_PATH_DISPOSITION[property] !== "visual") return false;
-	return true;
-};
-const visibleUnderline = (formatting) => {
-	const underline = formatting?.underline;
-	return underline?.style === "none" ? void 0 : underline;
-};
-const visibleStrike = (formatting) => {
-	if (formatting?.doubleStrike === true) return "double";
-	return formatting?.strike === true ? "single" : void 0;
-};
-const visibleColor = (formatting) => formatting?.color?.auto === true ? void 0 : formatting?.color;
-const visibleValue = (value) => value === "none" ? void 0 : value;
-/**
-* Compare the exact presentation encoded by PM run marks without allocating the
-* intermediate maps used by reconciliation. Non-visual authored state is
-* deliberately absent here: the carrierless fast path below excludes every
-* structural carrier before calling this predicate.
-*/
-const sameVisualFormatting = (left, right) => {
-	if (left?.bold === true !== (right?.bold === true) || left?.italic === true !== (right?.italic === true) || !sameFormattingValue(visibleUnderline(left), visibleUnderline(right)) || visibleStrike(left) !== visibleStrike(right) || !sameFormattingValue(visibleColor(left), visibleColor(right)) || visibleValue(left?.highlight) !== visibleValue(right?.highlight) || (left?.fontSize || void 0) !== (right?.fontSize || void 0) || !sameFormattingValue(left?.fontFamily, right?.fontFamily) || !sameFormattingValue(left?.language, right?.language) || (left?.vertAlign === "superscript" || left?.vertAlign === "subscript" ? left.vertAlign : void 0) !== (right?.vertAlign === "superscript" || right?.vertAlign === "subscript" ? right.vertAlign : void 0) || left?.allCaps === true !== (right?.allCaps === true) || left?.smallCaps === true !== (right?.smallCaps === true) || left?.hidden === true !== (right?.hidden === true) || left?.emboss === true !== (right?.emboss === true) || left?.imprint === true !== (right?.imprint === true) || left?.shadow === true !== (right?.shadow === true) || left?.outline === true !== (right?.outline === true) || left?.rtl === true !== (right?.rtl === true) || (typeof left?.spacing === "number" ? left.spacing : null) !== (typeof right?.spacing === "number" ? right.spacing : null) || (typeof left?.position === "number" ? left.position : null) !== (typeof right?.position === "number" ? right.position : null) || (normalizeHorizontalScalePercent(left?.scale) ?? null) !== (normalizeHorizontalScalePercent(right?.scale) ?? null) || (typeof left?.kerning === "number" ? left.kerning : null) !== (typeof right?.kerning === "number" ? right.kerning : null) || visibleValue(left?.effect) !== visibleValue(right?.effect) || visibleValue(left?.emphasisMark) !== visibleValue(right?.emphasisMark)) return false;
-	return sameFormattingValue(shadingToRunShadingAttrs(left?.shading), shadingToRunShadingAttrs(right?.shading));
-};
-const visualFormattingGroups = (formatting) => {
-	const groups = /* @__PURE__ */ new Map();
-	if (!formatting) return groups;
-	if (formatting.bold) groups.set("bold", true);
-	if (formatting.italic) groups.set("italic", true);
-	if (formatting.underline && formatting.underline.style !== "none") groups.set("underline", {
-		style: formatting.underline.style || "single",
-		...formatting.underline.color ? { color: formatting.underline.color } : {}
-	});
-	if (formatting.strike || formatting.doubleStrike) groups.set("strike", formatting.doubleStrike ? "double" : "single");
-	if (formatting.color && !formatting.color.auto) {
-		const { rgb, themeColor, themeTint, themeShade } = formatting.color;
-		groups.set("color", {
-			...rgb ? { rgb } : {},
-			...themeColor ? { themeColor } : {},
-			...themeTint ? { themeTint } : {},
-			...themeShade ? { themeShade } : {}
-		});
-	}
-	if (formatting.highlight && formatting.highlight !== "none") groups.set("highlight", formatting.highlight);
-	const shadingAttrs = shadingToRunShadingAttrs(formatting.shading);
-	if (shadingAttrs) groups.set("shading", runShadingAttrsToShading(shadingAttrs));
-	if (formatting.fontSize) groups.set("fontSize", formatting.fontSize);
-	if (formatting.fontFamily) {
-		const { ascii, hAnsi, eastAsia, cs, hint, asciiTheme, hAnsiTheme, eastAsiaTheme, csTheme } = formatting.fontFamily;
-		groups.set("fontFamily", {
-			...ascii ? { ascii } : {},
-			...hAnsi ? { hAnsi } : {},
-			...eastAsia ? { eastAsia } : {},
-			...cs ? { cs } : {},
-			...hint ? { hint } : {},
-			...asciiTheme ? { asciiTheme } : {},
-			...hAnsiTheme ? { hAnsiTheme } : {},
-			...eastAsiaTheme ? { eastAsiaTheme } : {},
-			...csTheme ? { csTheme } : {}
-		});
-	}
-	if (formatting.language) {
-		const { val, eastAsia, bidi } = formatting.language;
-		groups.set("language", {
-			...val ? { val } : {},
-			...eastAsia ? { eastAsia } : {},
-			...bidi ? { bidi } : {}
-		});
-	}
-	if (formatting.vertAlign === "superscript" || formatting.vertAlign === "subscript") groups.set("vertAlign", formatting.vertAlign);
-	for (const [property, group] of [
-		["allCaps", "allCaps"],
-		["smallCaps", "smallCaps"],
-		["hidden", "hidden"],
-		["emboss", "emboss"],
-		["imprint", "imprint"],
-		["shadow", "shadow"],
-		["outline", "outline"],
-		["rtl", "rtl"]
-	]) if (formatting[property]) groups.set(group, true);
-	const spacing = typeof formatting.spacing === "number" ? formatting.spacing : null;
-	const position = typeof formatting.position === "number" ? formatting.position : null;
-	const scale = normalizeHorizontalScalePercent(formatting.scale) ?? null;
-	const kerning = typeof formatting.kerning === "number" ? formatting.kerning : null;
-	if (spacing !== null || position !== null || scale !== null || kerning !== null) groups.set("characterSpacing", {
-		spacing,
-		position,
-		scale,
-		kerning
-	});
-	if (formatting.effect && formatting.effect !== "none") groups.set("effect", formatting.effect);
-	if (formatting.emphasisMark && formatting.emphasisMark !== "none") groups.set("emphasisMark", formatting.emphasisMark);
-	return groups;
-};
-const expectedRunFormattingOverrideAttrs = (authoredFormatting) => {
-	const attrs = buildRunFormattingOverrideAttrs(authoredFormatting, {
-		type: "authored-baseline",
-		formatting: authoredFormatting
-	});
-	const hasDirectFormatting = Object.keys(authoredFormatting).some((property) => property !== "styleId");
-	if (!attrs && !hasDirectFormatting) return;
-	const expected = { ...attrs };
-	const directFontProperties = [
-		"color",
-		"fontFamily",
-		"fontSize"
-	].filter((property) => authoredFormatting[property] !== void 0);
-	if (directFontProperties.length > 0) expected.directFontProperties = directFontProperties;
-	const complexScriptPropertyAbsences = [
-		["bold", "boldCs"],
-		["italic", "italicCs"],
-		["fontSize", "fontSizeCs"]
-	].filter(([ordinary, complex]) => authoredFormatting[ordinary] !== void 0 && authoredFormatting[complex] === void 0).map(([, complex]) => complex);
-	if (complexScriptPropertyAbsences.length > 0) expected.complexScriptPropertyAbsences = complexScriptPropertyAbsences;
-	return Object.keys(expected).length > 0 ? expected : void 0;
-};
-const changedVisualFormattingGroups = (observedFormatting, expectedFormatting) => {
-	const actual = visualFormattingGroups(observedFormatting);
-	const expected = visualFormattingGroups(expectedFormatting);
-	const changed = /* @__PURE__ */ new Set();
-	for (const group of /* @__PURE__ */ new Set([...actual.keys(), ...expected.keys()])) {
-		const actualValue = actual.get(group);
-		const expectedValue = expected.get(group);
-		if (!sameFormattingValue(actualValue, expectedValue)) changed.add(group);
-	}
-	return changed;
-};
-const VISUAL_BOOLEAN_FORMATTING_PROPERTIES = /* @__PURE__ */ new Set([
-	"allCaps",
-	"bold",
-	"doubleStrike",
-	"emboss",
-	"hidden",
-	"imprint",
-	"italic",
-	"outline",
-	"rtl",
-	"shadow",
-	"smallCaps",
-	"strike"
-]);
-const fontFamilyDifference = (actual, inherited) => {
-	const difference = {};
-	for (const property of [
-		"ascii",
-		"hAnsi",
-		"eastAsia",
-		"cs",
-		"hint",
-		"asciiTheme",
-		"hAnsiTheme",
-		"eastAsiaTheme",
-		"csTheme"
-	]) {
-		const value = actual[property];
-		if (value !== void 0 && value !== inherited?.[property]) Reflect.set(difference, property, value);
-	}
-	return Object.keys(difference).length > 0 ? difference : void 0;
-};
-const DIRECT_OVERRIDE_FORMATTING_PROPERTIES = [
-	"allCaps",
-	"bold",
-	"boldCs",
-	"cs",
-	"doubleStrike",
-	"emboss",
-	"fontSizeCs",
-	"hidden",
-	"noProof",
-	"imprint",
-	"italic",
-	"italicCs",
-	"outline",
-	"rtl",
-	"shadow",
-	"smallCaps",
-	"strike",
-	"underline"
-];
-const POSITIVE_OVERRIDE_PROPERTIES_REPRESENTED_BY_VISUAL_MARKS = /* @__PURE__ */ new Set([
-	"allCaps",
-	"emboss",
-	"hidden",
-	"imprint",
-	"outline",
-	"rtl",
-	"shadow",
-	"smallCaps",
-	"strike"
-]);
-const setFormattingFromOverrideSignal = (formatting, property, value) => {
-	Reflect.deleteProperty(formatting, property);
-	if (value === void 0) return;
-	if (property === "underline") {
-		formatting.underline = { style: "none" };
-		return;
-	}
-	Reflect.set(formatting, property, value);
-};
-const sameFormattingValue = (left, right) => {
-	if (left === right) return true;
-	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
-	if (Array.isArray(left) || Array.isArray(right)) {
-		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
-		return left.every((value, index) => sameFormattingValue(value, right[index]));
-	}
-	const leftKeys = Object.keys(left);
-	const rightKeys = Object.keys(right);
-	if (leftKeys.length !== rightKeys.length) return false;
-	return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && sameFormattingValue(Reflect.get(left, key), Reflect.get(right, key)));
-};
-const reconcileOverrideSignals = (formatting, current, expected, inheritedFormatting, observedFormatting) => {
-	for (const property of DIRECT_OVERRIDE_FORMATTING_PROPERTIES) {
-		if (sameFormattingValue(current?.[property], expected?.[property])) continue;
-		if (current?.[property] === void 0 && expected?.[property] === true && POSITIVE_OVERRIDE_PROPERTIES_REPRESENTED_BY_VISUAL_MARKS.has(property)) continue;
-		if (current && hasAuthoredRunFormattingProvenance(current) && expected?.[property] === void 0 && sameFormattingValue(current[property], inheritedFormatting?.[property])) continue;
-		setFormattingFromOverrideSignal(formatting, property, current?.[property]);
-	}
-	for (const property of [
-		"color",
-		"fontFamily",
-		"fontSize"
-	]) {
-		const currentIsDirect = current?.directFontProperties?.includes(property) === true;
-		if (currentIsDirect === (expected?.directFontProperties?.includes(property) === true)) continue;
-		if (!currentIsDirect) {
-			Reflect.deleteProperty(formatting, property);
-			continue;
-		}
-		const observed = observedFormatting[property];
-		if (observed !== void 0) Reflect.set(formatting, property, observed);
-	}
-	for (const property of [
-		"boldCs",
-		"italicCs",
-		"fontSizeCs"
-	]) {
-		const currentIsAbsent = current?.complexScriptPropertyAbsences?.includes(property) === true;
-		if (currentIsAbsent !== (expected?.complexScriptPropertyAbsences?.includes(property) === true) && currentIsAbsent) Reflect.deleteProperty(formatting, property);
-	}
-};
-/**
-* Reconcile source-authored provenance with the current visual mark set at the
-* one save boundary shared by editor commands, raw transactions and compare.
-* Unchanged groups keep exact source state (including equal direct values and
-* otherwise invisible sentinels); changed groups derive the smallest direct
-* override needed relative to the current style cascade.
-*/
-const reconcileAuthoredFormatting = ({ authoredFormatting, carrierlessContext, currentOverrideAttrs, inheritedFormatting, observedFormatting }) => {
-	const hasAuthoredFormatting = Object.keys(authoredFormatting).length > 0;
-	if (carrierlessContext === "ordinary" && currentOverrideAttrs === void 0 && !hasAuthoredFormatting && hasOnlyCarrierlessVisualFormatting(observedFormatting)) {
-		if (sameVisualFormatting(observedFormatting, inheritedFormatting)) return authoredFormatting;
-		if (observedFormatting.fontFamily === void 0 && sameVisualFormatting(inheritedFormatting, void 0)) return observedFormatting;
-	}
-	const expectedFormatting = hasAuthoredFormatting ? mergeTextFormatting(inheritedFormatting, authoredFormatting) : inheritedFormatting;
-	const changedGroups = changedVisualFormattingGroups(observedFormatting, expectedFormatting);
-	const reconciled = { ...authoredFormatting };
-	for (const property of Object.keys(RUN_FORMATTING_VISUAL_GROUPS)) {
-		const group = RUN_FORMATTING_VISUAL_GROUPS[property];
-		if (group === null || !changedGroups.has(group)) continue;
-		Reflect.deleteProperty(reconciled, property);
-		if (VISUAL_BOOLEAN_FORMATTING_PROPERTIES.has(property)) {
-			const observed = observedFormatting[property] === true;
-			if (observed !== (inheritedFormatting?.[property] === true)) Reflect.set(reconciled, property, observed);
-			continue;
-		}
-		const observed = observedFormatting[property];
-		if (observed === void 0) continue;
-		if (property === "fontFamily") {
-			const difference = fontFamilyDifference(observed, inheritedFormatting?.fontFamily);
-			if (difference) reconciled.fontFamily = difference;
-			continue;
-		}
-		if (!sameFormattingValue(observed, inheritedFormatting?.[property])) Reflect.set(reconciled, property, observed);
-	}
-	if (currentOverrideAttrs !== void 0) reconcileOverrideSignals(reconciled, currentOverrideAttrs, expectedRunFormattingOverrideAttrs(authoredFormatting), inheritedFormatting, observedFormatting);
-	return reconciled;
-};
-const formattingAuthorshipCost = (formatting) => {
-	let cost = 0;
-	const visit = (value) => {
-		if (value === void 0) return;
-		if (value === null || typeof value !== "object") {
-			cost++;
-			return;
-		}
-		const entries = Object.entries(value);
-		if (entries.length === 0) {
-			cost++;
-			return;
-		}
-		for (const [, nested] of entries) visit(nested);
-	};
-	for (const [property, value] of Object.entries(formatting)) if (property !== "styleId") visit(value);
-	return cost;
-};
-function marksToTextFormatting(marks, options) {
-	const formatting = {};
-	let directOverrideFormatting;
-	let directFontProperties;
-	let characterStyleId;
-	let runFormattingOverrideMark;
-	let currentOverrideAttrs;
-	for (const mark of marks) switch (mark.type.name) {
-		case "bold":
-			formatting.bold = true;
-			break;
-		case "italic":
-			formatting.italic = 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":
-			formatting.fontSize = expectFontSizeMarkAttrs(mark).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;
-			if (attrs.hint) ff.hint = attrs.hint;
-			if (attrs.cs) ff.cs = attrs.cs;
-			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 "language": {
-			const attrs = expectLanguageMarkAttrs(mark);
-			formatting.language = {
-				...attrs.val ? { val: attrs.val } : {},
-				...attrs.eastAsia ? { eastAsia: attrs.eastAsia } : {},
-				...attrs.bidi ? { bidi: attrs.bidi } : {}
-			};
-			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;
-			const horizontalScale = normalizeHorizontalScalePercent(attrs.scale);
-			if (horizontalScale !== void 0) formatting.scale = horizontalScale;
-			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":
-			runFormattingOverrideMark = mark;
-			break;
-		case "characterStyle": {
-			const attrs = expectCharacterStyleMarkAttrs(mark);
-			formatting.styleId = attrs.styleId;
-			characterStyleId = attrs.styleId;
-			break;
-		}
-		default: break;
-	}
-	let authoredFormatting = {};
-	if (runFormattingOverrideMark) {
-		const overrideAttrs = expectRunFormattingOverrideMarkAttrs(runFormattingOverrideMark);
-		currentOverrideAttrs = overrideAttrs;
-		directFontProperties = overrideAttrs.directFontProperties;
-		directOverrideFormatting = {};
-		applyRunFormattingOverrideAttrs(directOverrideFormatting, overrideAttrs);
-		for (const property of directFontProperties ?? []) {
-			const value = formatting[property];
-			if (value !== void 0) Reflect.set(directOverrideFormatting, property, value);
-		}
-		authoredFormatting = authoredRunFormattingFromAttrs(overrideAttrs) ?? directOverrideFormatting;
-	}
-	if (characterStyleId !== void 0 && !options?.styleResolver) {
-		const conservativeFormatting = mergeTextFormatting(formatting, directOverrideFormatting) ?? {};
-		for (const property of currentOverrideAttrs?.complexScriptPropertyAbsences ?? []) Reflect.deleteProperty(conservativeFormatting, property);
-		return {
-			...conservativeFormatting,
-			styleId: characterStyleId
-		};
-	}
-	const inheritedFormatting = resolveEffectiveRunStyleFormatting({
-		marks,
-		paragraphFormatting: paragraphFormattingForRun({
-			context: {
-				baseParagraphFormatting: options?.baseParagraphFormatting,
-				paragraphFormatting: options?.inheritedFormatting,
-				paragraphMarkFormatting: options?.paragraphMarkFormatting,
-				paragraphMarkPrecedesStyle: options?.paragraphMarkPrecedesStyle ?? false
-			},
-			directFormatting: authoredFormatting,
-			marks
-		}),
-		...options?.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
-	});
-	let reconciled = reconcileAuthoredFormatting({
-		authoredFormatting,
-		carrierlessContext: options?.paragraphMarkFormatting === void 0 ? "ordinary" : "paragraph-mark",
-		currentOverrideAttrs,
-		inheritedFormatting,
-		observedFormatting: formatting
-	});
-	if (runFormattingOverrideMark === void 0 && characterStyleId === void 0 && options?.paragraphMarkFormatting !== void 0) {
-		const suppressedInheritedFormatting = resolveEffectiveRunStyleFormatting({
-			marks,
-			paragraphFormatting: suppressParagraphMarkFormatting({
-				baseFormatting: options.baseParagraphFormatting,
-				directFormatting: authoredFormatting,
-				paragraphMarkFormatting: options.paragraphMarkFormatting,
-				paragraphMarkPrecedesStyle: options.paragraphMarkPrecedesStyle ?? false
-			}),
-			...options.styleResolver !== void 0 ? { styleResolver: options.styleResolver } : {}
-		});
-		const suppressed = reconcileAuthoredFormatting({
-			authoredFormatting,
-			carrierlessContext: "paragraph-mark",
-			currentOverrideAttrs,
-			inheritedFormatting: suppressedInheritedFormatting,
-			observedFormatting: formatting
-		});
-		if (formattingAuthorshipCost(suppressed) < formattingAuthorshipCost(reconciled)) reconciled = suppressed;
-	}
-	return {
-		...reconciled,
-		...characterStyleId !== void 0 ? { styleId: characterStyleId } : {}
-	};
-}
 /**
 * Convert a ProseMirror table node to our Table type
 */
@@ -3214,6 +2761,7 @@ function restoreCarriedTableAttrs(table, attrs) {
 	if (Array.isArray(attrs.tblPrChange) && attrs.tblPrChange.length > 0) table.propertyChanges = [...attrs.tblPrChange];
 	if (attrs._bookmarks && attrs._bookmarks.length > 0) table.bookmarks = attrs._bookmarks;
 	if (hasSinkChildren(attrs._preserved)) table.preserved = attrs._preserved;
+	if (attrs.carrierStack?.length) table.carrierStack = attrs.carrierStack;
 }
 function convertPMTableRows(node, documentCounts, styleResolver = null) {
 	const rows = [];
@@ -3316,7 +2864,7 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges, styleReso
 		let activeMerge = activeVerticalMerges.get(gridColumn);
 		while (activeMerge) {
 			const preservedCell = activeMerge.continuationCells?.shift();
-			cells.push(preservedCell ?? createVerticalMergeContinuationCell(activeMerge.colspan));
+			cells.push(preservedCell ? continuationCellSpanning(preservedCell, activeMerge.colspan) : createVerticalMergeContinuationCell(activeMerge.colspan));
 			activeMerge.remainingRows -= 1;
 			if (activeMerge.remainingRows <= 0) activeVerticalMerges.delete(gridColumn);
 			gridColumn += activeMerge.colspan;
@@ -3358,6 +2906,7 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges, styleReso
 	if (attrs._preservedAttributes && attrs._preservedAttributes.length > 0) row.preservedAttributes = attrs._preservedAttributes;
 	if (attrs._bookmarks && attrs._bookmarks.length > 0) row.bookmarks = attrs._bookmarks;
 	if (attrs.contentControls && attrs.contentControls.length > 0) row.contentControls = attrs.contentControls;
+	if (attrs.carrierStack?.length) row.carrierStack = attrs.carrierStack;
 	if (hasSinkChildren(attrs._preserved)) row.preserved = attrs._preserved;
 	if (attrs.trIns) row.structuralChange = {
 		type: "tableRowInsertion",
@@ -3387,6 +2936,25 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges, styleReso
 	};
 	return row;
 }
+/**
+* A continuation cell the package arrived with, spanning the columns its merge
+* spans NOW. The cell is carried whole for its `w:tcPr` and content, but a
+* column deleted or inserted through the merge changes the merge's width, and
+* a continuation still stating the old one leaves the row wider or narrower
+* than the grid and no longer under the cell it continues.
+*/
+function continuationCellSpanning(cell, colspan) {
+	if ((cell.formatting?.gridSpan ?? 1) === colspan) return cell;
+	const { gridSpan: _staleSpan, ...formatting } = cell.formatting ?? {};
+	return {
+		...cell,
+		formatting: {
+			...formatting,
+			vMerge: "continue",
+			...colspan > 1 && { gridSpan: colspan }
+		}
+	};
+}
 function createVerticalMergeContinuationCell(colspan) {
 	const formatting = { vMerge: "continue" };
 	if (colspan > 1) formatting.gridSpan = colspan;
@@ -3448,6 +3016,9 @@ function convertPMTableCell(node, documentCounts, styleResolver = null) {
 		} else if (contentNode.type.name === "blockSdt") {
 			content.push(convertPMBlockSdt(contentNode, styleResolver));
 			previousStandaloneTextBox = null;
+		} else if (contentNode.type.name === "blockCustomXml") {
+			content.push(convertPMBlockCustomXml(contentNode, styleResolver));
+			previousStandaloneTextBox = null;
 		} else if (contentNode.type.name === "textBox") previousStandaloneTextBox = appendTextBoxBlock(content, contentNode, {
 			pendingPageBreaks: 0,
 			previousStandaloneTextBox,
@@ -3475,6 +3046,7 @@ function convertPMTableCell(node, documentCounts, styleResolver = null) {
 	if (cellFormatting) cell.formatting = cellFormatting;
 	if (Array.isArray(attrs.tcPrChange) && attrs.tcPrChange.length > 0) cell.propertyChanges = [...attrs.tcPrChange];
 	if (attrs.contentControls && attrs.contentControls.length > 0) cell.contentControls = attrs.contentControls;
+	if (attrs.carrierStack?.length) cell.carrierStack = attrs.carrierStack;
 	if (attrs.cellMarker) {
 		const info = {
 			id: attrs.cellMarker.info.revisionId,