@stll/folio-core 0.45.0 → 0.47.0

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -1,39 +1,54 @@
+import { joinCommentRangesAcrossParagraphs } from "../../docx/commentRangeJoin.js";
+import { completeCommentReferences } from "../../docx/commentReferenceCompletion.js";
 import { EDITED_PREVIEW_FINGERPRINT, imageRawXmlFingerprint } from "../../docx/imageRawXml.js";
-import { isNumberingReference } from "../../docx/numberingReference.js";
+import { isInlineSdtContent, isSimpleFieldContent } from "../../docx/inlineWrapperContent.js";
+import { paragraphNumberingReferenceId as paragraphNumberingReferenceId$1, sameStatedParagraphNumbering as sameStatedParagraphNumbering$1 } from "../../docx/numberingReference.js";
 import { PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, ParagraphPropertySourceValidationError, copyDocumentParagraphPropertySourceContract, copyDocumentParagraphPropertySources, copyParagraphPropertyCapture, copyParagraphPropertySource, decodeTableCellParagraphSourcePayload, getDocumentParagraphPropertySourceContract, getParagraphPropertySource, getParagraphPropertySourceCandidate, getParagraphPropertySourceToken, getParagraphPropertySourceTransferId, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, isParagraphPropertySourceToken, linkParagraphPropertySourceCandidate, paragraphPropertySourceBelongsToDocument, paragraphPropertySourceTokenMatchesContract, recreateProseNodeWithParagraphPropertySource, restoreTableCellsWithParagraphPropertySources, visitDocumentStoryParagraphs, visitTableCellParagraphPropertySourceBindings } from "../../docx/paragraphPropertySource.js";
-import { visitDocxParagraphs } from "../../docx/paragraphTraversal.js";
-import { ShapeOutlineStyleSchema, narrowEnum } from "../../docx/parserEnums.js";
+import { BLOCK_TREE_DESCENT, visitBlockTreeRecords, visitDocxParagraphs } from "../../docx/paragraphTraversal.js";
 import { DATE_UTC_ATTRIBUTE } from "../../docx/trackedChangeInfo.js";
-import { isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission, sameAuthoredParagraphNumberingReference } from "../../internal/paragraphFormattingSerialization.js";
+import { copiedWrapPolygon } from "../../docx/wrapPolygon.js";
+import { isStyleSourcedParagraphNumbering, modelParagraphFormattingEmission } from "../../internal/paragraphFormattingSerialization.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
-import { OUTLINE_STYLE_CSS_ALIASES, normalizeShapeTextAnchor } from "../../types/documentEnumValues.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 { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectPageBreakRunOwnerMarkAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../attrs/index.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 { readAuthoredTransform } from "../authoredTransformAttrs.js";
 import { autospacingMatchesBase, hasAutospacingBaseSide } from "../autospacingBase.js";
-import { bookmarkBoundaryDisplacement, expectBookmarkBoundaryAttrs } from "../bookmarkBoundaryAttrs.js";
+import { bookmarkMarkerFromAttrs, expectBookmarkBoundaryAttrs } from "../bookmarkBoundaryAttrs.js";
 import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges } from "../commands/propertyChangeScope.js";
+import { expectCommentReferenceAttrs } from "../commentReferenceAttrs.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 { expectMoveRangeBoundaryAttrs } from "../moveRangeBoundaryAttrs.js";
 import { resolveNumberedRefFields } from "../numberedRefFields.js";
 import { directParagraphAlignment } from "../paragraphAlignment.js";
 import { directionToBidi } from "../paragraphDirection.js";
 import { directParagraphSpacing } from "../paragraphSpacing.js";
+import { expectRangeAnchorAttrs } from "../rangeAnchorAttrs.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 { PRESERVED_XML_LEVELS } from "../schema/nodes.js";
 import { parseShapeGeometryAdjustments } from "../shapeGeometryAdjustments.js";
 import { expectTextBoxAnchorAttrs } from "../textBoxAnchorAttrs.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";
 import { Fragment } from "prosemirror-model";
-import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 //#region src/prosemirror/conversion/fromProseDoc.ts
 /**
 * ProseMirror to Document Conversion
@@ -46,23 +61,16 @@ import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 * - Preserve paragraph attributes (paraId, textId, formatting)
 * - Handle marks -> TextFormatting conversion
 */
-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;
+/**
+* The dash an `outlineStyle` attribute names.
+*
+* `"none"` is the explicit no-outline sentinel rather than a dash, so it
+* returns undefined here: the serializer's no-outline guard drops the `<a:ln>`
+* before this is called.
+*/
+function normalizeShapeOutlineDash(style) {
+	const dash = presetDashForOutlineAttr(style);
+	return dash === void 0 || dash === "none" ? void 0 : dash;
 }
 function imagePositionFromAttrs(attrs) {
 	const horizontalPosition = attrs?.horizontal;
@@ -93,8 +101,9 @@ const emuFromPixels = (px, key, authored, project) => {
 	return emu !== void 0 && project(emu) === px ? emu : pixelsToEmu(px);
 };
 /**
-* Copy the wrap insets onto a wrap. Shared by the image, shape and text-box
-* paths so one rule decides when an inset keeps its authored EMU.
+* Copy the wrap insets, the slot each was authored on, and the wrap polygon
+* onto a wrap. Shared by the image, shape and text-box paths so one rule
+* decides when an inset keeps its authored EMU.
 */
 const assignWrapDistances = (wrap, attrs) => {
 	const authored = attrs._docxAuthoredEmu;
@@ -102,6 +111,22 @@ const assignWrapDistances = (wrap, attrs) => {
 	if (attrs.distBottom !== void 0) wrap.distB = emuFromPixels(attrs.distBottom, "distBottom", authored, emuToPixels);
 	if (attrs.distLeft !== void 0) wrap.distL = emuFromPixels(attrs.distLeft, "distLeft", authored, emuToPixels);
 	if (attrs.distRight !== void 0) wrap.distR = emuFromPixels(attrs.distRight, "distRight", authored, emuToPixels);
+	const slots = copiedWrapDistanceSlots(attrs.wrapDistanceSlots);
+	if (slots !== void 0) wrap.distanceSlots = slots;
+	const extents = copiedEffectExtentSlots(attrs.wrapEffectExtentSlots);
+	if (extents !== void 0) wrap.effectExtentSlots = extents;
+	const polygon = copiedWrapPolygon(attrs.wrapPolygon);
+	if (polygon !== void 0) wrap.polygon = polygon;
+};
+/** A copy, so the model cannot share a slot record with a ProseMirror attr. */
+const copiedWrapDistanceSlots = (slots) => slots === void 0 ? void 0 : {
+	...slots.drawing === void 0 ? {} : { drawing: { ...slots.drawing } },
+	...slots.wrapChild === void 0 ? {} : { wrapChild: { ...slots.wrapChild } }
+};
+/** The same copy, one carrier over. */
+const copiedEffectExtentSlots = (slots) => slots === void 0 ? void 0 : {
+	...slots.drawing === void 0 ? {} : { drawing: { ...slots.drawing } },
+	...slots.wrapChild === void 0 ? {} : { wrapChild: { ...slots.wrapChild } }
 };
 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;
@@ -228,7 +253,12 @@ const restoreLinkedParagraphPropertySources = (content) => {
 	};
 };
 /** Convert a ProseMirror document to the document model. */
-function fromProseDoc(pmDoc, baseDocument) {
+function fromProseDoc(pmDoc, baseDocument, { reuse = "none" } = {}) {
+	switch (reuse) {
+		case "none": break;
+		case "matched": panic("fromProseDoc: reuse \"matched\" is not implemented");
+		default: panic(`fromProseDoc: unhandled reuse ${String(reuse)}`);
+	}
 	assertValidProseMirrorDocument(pmDoc, "Cannot convert invalid ProseMirror document to DOCX model");
 	const baseContract = baseDocument ? getDocumentParagraphPropertySourceContract(baseDocument) : void 0;
 	const proseContractAttribute = pmDoc.attrs[PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR];
@@ -236,6 +266,8 @@ function fromProseDoc(pmDoc, baseDocument) {
 	if (proseContractAttribute !== null && proseContractAttribute !== void 0 && proseContract === null || (baseContract ?? null) !== proseContract) throw sourceValidationError("contract_mismatch", "The ProseMirror document does not match its paragraph-property source document.");
 	const tokenSources = baseContract && proseContract && baseDocument ? validateParagraphPropertySourceTokens(pmDoc, baseDocument, baseContract) : null;
 	const blocks = extractBlocks(pmDoc, "resolve", baseDocument?.package.styles ? createStyleEngine(baseDocument.package.styles) : null);
+	joinCommentRangesAcrossParagraphs(blocks);
+	completeCommentReferences(blocks);
 	const linkedSources = restoreLinkedParagraphPropertySources(blocks);
 	if (tokenSources) restoreParagraphPropertySourcesByToken(blocks, tokenSources);
 	else if (baseDocument) restoreParagraphPropertySources(blocks, baseDocument.package.document.content, linkedSources.targets, linkedSources.sources);
@@ -452,42 +484,9 @@ function materializeNumberedRefValues(doc) {
 	};
 	return visit(doc);
 }
-const SERIALIZER_EMPTY_PAGE_FIELD_RESULT = "1";
-const fieldResultHasExplicitPageBreak = (node) => extractParagraphContent(node, void 0, void 0, /* @__PURE__ */ new Map(), false).filter((content) => content.type === "run" || content.type === "hyperlink").some((content) => {
-	return (content.type === "run" ? [content] : content.children).some((run) => run.type === "run" && run.content.some((runContent) => runContent.type === "break" && runContent.breakType === "page"));
-});
-/**
-* PAGE and NUMPAGES have a stable visible fallback. Other empty fields may
-* intentionally have no result (for example an empty TOC); inventing a space
-* changes their authored result on every save/reopen cycle. A field whose
-* result already carries an explicit page break owns that break's run, so the
-* fallback would displace it.
-*/
-function materializeSerializerFieldFallbacks(doc) {
-	const visit = (node) => {
-		if (node.type.name === "field" || node.type.name === "structuredField") {
-			const attrs = expectFieldAttrs(node);
-			return (attrs.fieldType === "PAGE" || attrs.fieldType === "NUMPAGES") && !attrs.displayText && !fieldResultHasExplicitPageBreak(node) ? recreateProseNodeWithParagraphPropertySource(node, { attrs: {
-				...node.attrs,
-				displayText: SERIALIZER_EMPTY_PAGE_FIELD_RESULT
-			} }) : node;
-		}
-		if (node.childCount === 0) return node;
-		const children = [];
-		let changed = false;
-		node.forEach((child) => {
-			const mappedChild = visit(child);
-			children.push(mappedChild);
-			changed ||= mappedChild !== child;
-		});
-		return changed ? recreateProseNodeWithParagraphPropertySource(node, { content: Fragment.fromArray(children) }) : node;
-	};
-	return visit(doc);
-}
-function extractBlocks(inputDoc, refResolution = "resolve", styleResolver = null, emptyFieldResult = "serializerFallback") {
+function extractBlocks(inputDoc, refResolution = "resolve", styleResolver = null) {
 	const strippedDoc = stripSuggestedProvenance(inputDoc, styleResolver);
-	const refResolvedDoc = refResolution === "resolve" ? materializeNumberedRefValues(strippedDoc) : strippedDoc;
-	const pmDoc = emptyFieldResult === "serializerFallback" ? materializeSerializerFieldFallbacks(refResolvedDoc) : refResolvedDoc;
+	const pmDoc = refResolution === "resolve" ? materializeNumberedRefValues(strippedDoc) : strippedDoc;
 	const blocks = [];
 	const textBoxAnchorMarkers = /* @__PURE__ */ new Map();
 	const documentCounts = buildDocumentTrackedChangeCounts(pmDoc);
@@ -530,15 +529,116 @@ function extractBlocks(inputDoc, refResolution = "resolve", styleResolver = null
 			pendingPageBreaks = 0;
 		} else if (node.type.name === "blockSdt") {
 			if (pendingPageBreaks > 0 && !appendPendingPageBreaksToPreviousParagraph()) flushPendingPageBreaks();
-			blocks.push(convertPMBlockSdt(node, styleResolver, emptyFieldResult));
+			blocks.push(convertPMBlockSdt(node, styleResolver));
+			previousStandaloneTextBox = null;
+		} else if (node.type.name === "preservedBlock") {
+			blocks.push({
+				type: "preservedBlock",
+				xml: expectPreservedBlockAttrs(node).xml
+			});
+			previousStandaloneTextBox = null;
+		} else if (node.type.name === "blockBookmarkBoundary") {
+			blocks.push(blockBookmarkMarker(node));
 			previousStandaloneTextBox = null;
 		}
 	});
 	if (pendingPageBreaks > 0 && !appendPendingPageBreaksToPreviousParagraph()) flushPendingPageBreaks();
 	removeUnresolvedTextBoxAnchors(blocks, textBoxAnchorMarkers);
+	keepOneRecordCarriedByIdentity(blocks);
+	keepTheSectionBreakOnTheLastParagraphThatCarriesIt(blocks);
 	return blocks;
 }
-function convertPMBlockSdt(node, styleResolver, emptyFieldResult) {
+/**
+* What an authored element carried follows its record, and only it.
+*
+* Two things ride a node's attrs by reference rather than by value: the
+* attribute remainder (`w:rsidR` and its family) and the ordered verbatim sink
+* (the markup a container held beside its modelled children). ProseMirror
+* copies a node's attrs when a command splits or duplicates it, so pressing
+* Enter in the middle of a paragraph produces two nodes holding the *same*
+* remainder array, and copying a table produces two tables holding the same
+* sink. Writing either back on both is a claim the author did not make:
+* `w:rsidR` says which editing session wrote this paragraph, and a second copy
+* of a `w:bookmarkEnd` is a bookmark boundary nobody wrote. The rule is that
+* the record that comes first in document order keeps what was authored, and
+* the other is a new record with none — the same answer a record the editor
+* created from scratch gets.
+*
+* Reference identity is what tells the two cases apart, and it is exact: two
+* records that each parsed their own children and attributes hold different
+* objects however equal their contents, and only a copy made by the editor
+* shares one.
+*
+* The rule holds per block container or it does not hold: a walk that reaches
+* the body, a cell and an `w:sdt` but not a text box leaves the records inside
+* one free to claim an authored revision session each. `visitBlockTreeRecords`
+* is the one traversal, and it is exhaustive over the block union.
+*/
+const keepOneRecordCarriedByIdentity = (blocks) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	/** Whether this object is the authored one rather than a copy's reference. */
+	const isAuthored = (value) => {
+		if (value === void 0) return true;
+		if (seen.has(value)) return false;
+		seen.add(value);
+		return true;
+	};
+	const keepFirst = (record) => {
+		if (!isAuthored(record.preservedAttributes)) delete record.preservedAttributes;
+		if (!isAuthored(record.bookmarks)) delete record.bookmarks;
+		if (!isAuthored(record.preserved)) delete record.preserved;
+	};
+	visitBlockTreeRecords(blocks, (record) => {
+		keepFirst(record);
+		return BLOCK_TREE_DESCENT.descend;
+	});
+};
+/**
+* The section break belongs to the last paragraph that carries it.
+*
+* A `w:sectPr` inside a `w:pPr` says "the section ends at this paragraph's
+* mark". ProseMirror copies a node's attrs when a command splits it, so
+* pressing Enter inside a section-ending paragraph produces two nodes over the
+* *same* `_sectionProperties` object; writing it back on both ends the section
+* twice. The document gains a section nobody added, and its `w:sectPr` repeats
+* the `w:rsidSect` of the real one, so the copy also claims that section's
+* revision history. On a split the trailing half is the half that still ends
+* the section, and the leading half becomes an ordinary paragraph — Word's own
+* rule, and the exact opposite of the remainder's, which stays with the
+* authored half above.
+*
+* The rule lives on the from-leg rather than in the split commands because the
+* commands cannot be enumerated: Enter, a paste that lands several paragraphs
+* in a section-ending one, an AI edit and a tracked-change resolution each
+* split a paragraph by their own route, and a split merged in from another
+* client reaches no local command at all. Every route arrives here.
+*
+* Reference identity is what tells a copy from a second authored break, and it
+* is exact: two paragraphs that each parsed their own `w:sectPr` hold
+* different objects however equal their contents, and only a copy made by the
+* editor shares one. The projection passes the object through by reference and
+* never clones it, which is what keeps that signal alive.
+*/
+const keepTheSectionBreakOnTheLastParagraphThatCarriesIt = (blocks) => {
+	const lastCarrier = /* @__PURE__ */ new Map();
+	visitBlockTreeRecords(blocks, (record) => {
+		if (record.type !== "paragraph" || record.sectionProperties === void 0) return BLOCK_TREE_DESCENT.descend;
+		const earlier = lastCarrier.get(record.sectionProperties);
+		if (earlier) delete earlier.sectionProperties;
+		lastCarrier.set(record.sectionProperties, record);
+		return BLOCK_TREE_DESCENT.descend;
+	});
+};
+/**
+* A bookmark marker standing between two blocks, back in the model.
+*
+* The node's place in the document is the whole of its position, so nothing is
+* read off it but the marker's own attributes.
+*/
+function blockBookmarkMarker(node) {
+	return bookmarkMarkerFromAttrs(expectBookmarkBoundaryAttrs(node));
+}
+function convertPMBlockSdt(node, styleResolver) {
 	const attrs = expectBlockSdtAttrs(node);
 	const properties = { sdtType: attrs.sdtType };
 	if (attrs.alias) properties.alias = attrs.alias;
@@ -552,11 +652,12 @@ function convertPMBlockSdt(node, styleResolver, emptyFieldResult) {
 	if (attrs.listItems) properties.listItems = decodeSdtListItems(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._preserved) properties.preserved = attrs._preserved;
 	if (attrs.rawEndPropertiesXml) properties.rawEndPropertiesXml = attrs.rawEndPropertiesXml;
+	if (attrs.endProperties) properties.endProperties = attrs.endProperties;
 	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), "inherit", styleResolver, emptyFieldResult);
+	const extracted = extractBlocks(node.type.schema.node("doc", null, node.content), "inherit", styleResolver);
 	return {
 		type: "blockSdt",
 		properties,
@@ -594,6 +695,7 @@ function appendTextBoxBlock(blocks, node, options) {
 		if (!mergeTextBoxIntoTrailingInlineSdts(options.previousStandaloneTextBox.paragraph, paragraph, attrs._docxInlineSdts ?? [])) options.previousStandaloneTextBox.paragraph.content.push(...paragraph.content);
 		return options.previousStandaloneTextBox;
 	}
+	if (attrs._docxPlacement === "standalone" && attrs._preservedAttributes?.length) paragraph.preservedAttributes = attrs._preservedAttributes;
 	prependPageBreaks(paragraph, options.pendingPageBreaks);
 	blocks.push(paragraph);
 	return attrs._docxPlacement === "standalone" && attrs._docxGroupId ? {
@@ -647,7 +749,7 @@ function findTextBoxShapeRun(content) {
 			if (item.content.some((runContent) => runContent.type === "shape" && runContent.shape.shapeType === "textBox")) return item;
 			continue;
 		}
-		if (item.type === "inlineSdt" || item.type === "hyperlink" || item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") {
+		if (item.type === "inlineSdt" || item.type === "hyperlink" || item.type === "inlineWrapper" || item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") {
 			const run = findTextBoxShapeRun(item.type === "hyperlink" ? item.children : item.content);
 			if (run) return run;
 		}
@@ -663,6 +765,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 (replaceTextBoxAnchorInBlocks(block.content, marker, textBoxRun)) return true;
 	}
 	return false;
@@ -685,7 +788,7 @@ const textBoxAnchorHost = (item) => {
 		case "deletion":
 		case "moveFrom":
 		case "moveTo":
-		case "bidiWrapper": return item.content;
+		case "inlineWrapper": return item.content;
 		case "run":
 		case "complexField":
 		case "bookmarkStart":
@@ -697,7 +800,8 @@ const textBoxAnchorHost = (item) => {
 		case "moveFromRangeEnd":
 		case "moveToRangeStart":
 		case "moveToRangeEnd":
-		case "mathEquation": return;
+		case "mathEquation":
+		case "preservedInline": return;
 		default: panic(`Unsupported paragraph content: ${JSON.stringify(item)}`);
 	}
 };
@@ -730,6 +834,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 (removeTextBoxAnchorFromBlocks(block.content, marker)) return true;
 	}
 	return false;
@@ -741,8 +846,8 @@ function removeTextBoxAnchorFromBlocks(blocks, marker) {
 * list markers on the way out of the editor.
 */
 function listRenderingFromAttrs(attrs) {
-	const numId = attrs.numPr?.numId;
-	if (!isNumberingReference(numId)) return;
+	const numId = paragraphNumberingReferenceId$1(attrs.numPr);
+	if (numId === void 0) return;
 	if (!(attrs.listMarker != null || attrs.listIsBullet || attrs.listNumFmt != null)) return;
 	return listRenderingFromAttrs$1({
 		attrs,
@@ -822,9 +927,9 @@ function convertPMParagraph(node, documentCounts, textBoxAnchorMarkers, styleRes
 	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 (attrs._propertyChanges && attrs._propertyChanges.length > 0) paragraph.propertyChanges = attrs._propertyChanges.map(propertyChangeFromAttrs);
 	if (attrs.pPrMark) paragraph.pPrMark = attrs.pPrMark;
+	if (attrs._preservedAttributes && attrs._preservedAttributes.length > 0) paragraph.preservedAttributes = attrs._preservedAttributes;
 	linkParagraphPropertySourceCandidate(paragraph, node);
 	return paragraph;
 }
@@ -842,7 +947,7 @@ const propertyChangeFromAttrs = (change) => {
 		currentFormatting
 	};
 	const { numPr, ...previousWithoutNumPr } = previousFormatting;
-	const normalizedPrevious = numPr === null || numPr === void 0 ? previousWithoutNumPr : {
+	const normalizedPrevious = numPr == null ? previousWithoutNumPr : {
 		...previousWithoutNumPr,
 		numPr
 	};
@@ -915,11 +1020,12 @@ function paragraphAttrsToFormatting(attrs) {
 		else Reflect.deleteProperty(result, "lineSpacingRule");
 		if (directAlignment === void 0) Reflect.deleteProperty(result, "alignment");
 		else result.alignment = directAlignment;
-		if (isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) {
+		const statedNumbering = attrs.numPr;
+		if (isStyleSourcedParagraphNumbering(statedNumbering, attrs.numPrFromStyle)) {
 			delete result.numPr;
 			delete result.numPrFromStyle;
-		} else if (attrs.numPr !== orig.numPr && !sameAuthoredParagraphNumberingReference(attrs.numPr, orig.numPr)) {
-			if (attrs.numPr) result.numPr = attrs.numPr;
+		} else if (!sameStatedParagraphNumbering$1(statedNumbering, orig.numPr)) {
+			if (statedNumbering !== void 0) result.numPr = statedNumbering;
 			else delete result.numPr;
 			delete result.numPrFromStyle;
 		}
@@ -961,7 +1067,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 || typeof outlineLevel === "number" || 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 || 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;
 	const f = {};
 	if (directAlignment !== void 0) f.alignment = directAlignment;
 	if (shouldSerializeSpaceBefore) f.spaceBefore = spaceBefore;
@@ -976,12 +1082,12 @@ function paragraphAttrsToFormatting(attrs) {
 	if (indentRight) f.indentRight = indentRight;
 	if (indentFirstLine) f.indentFirstLine = indentFirstLine;
 	if (attrs.hangingIndent && indentFirstLine) f.hangingIndent = attrs.hangingIndent;
-	if (attrs.numPr && !isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) f.numPr = attrs.numPr;
+	if (attrs.numPr !== void 0 && !isStyleSourcedParagraphNumbering(attrs.numPr, attrs.numPrFromStyle)) f.numPr = attrs.numPr;
 	if (attrs.styleId) f.styleId = attrs.styleId;
 	if (borders) f.borders = borders;
 	if (shading) f.shading = shading;
 	if (tabs) f.tabs = tabs;
-	if (typeof outlineLevel === "number") f.outlineLevel = outlineLevel;
+	if (outlineLevel !== void 0) f.outlineLevel = outlineLevel;
 	if (contextualSpacing) f.contextualSpacing = contextualSpacing;
 	if (bidi != null) f.bidi = bidi;
 	if (pageBreakBefore != null) f.pageBreakBefore = pageBreakBefore;
@@ -1017,6 +1123,70 @@ function createTrackedRunWrapper(type, info, child) {
 		content
 	};
 }
+/**
+* Comment ids in the order their markers are written at a shared boundary.
+*
+* Two ranges that begin or end at the same position have no order in the
+* editor, where each is a mark, so every emission site orders them by id: a
+* boundary written in the order the marks happened to open is a different
+* 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 : [];
+};
+const isRevisionWrapper = (item) => item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo";
+/** `stack` closed around `content`, outermost layer first. */
+const nestInlineWrappers = (stack, content) => {
+	const innermost = stack.at(-1);
+	if (innermost === void 0) panic("An inline wrapper group carries no layer");
+	let wrapper = inlineWrapperMember(innermost, content);
+	for (const layer of stack.slice(0, -1).toReversed()) wrapper = inlineWrapperMember(layer, [wrapper]);
+	return wrapper;
+};
+/**
+* The emitted sequence with each wrapper group nested back into the wrappers
+* `toProseDoc` lifted off it.
+*
+* The revision stays outermost. folio already writes a revision outside the
+* hyperlink it spans, the parse leg is revision-owned, and accepting or
+* rejecting one is a range operation over the revision's own content; a
+* wrapper placed outside two revisions would also have to mint one revision id
+* per wrapper. So a revision in the group keeps its place and takes the nest
+* inside it, and the items around it share a nest of their own.
+*
+* A group with nothing in it writes no wrapper: an authored wrapper whose
+* content was deleted or rejected is gone, and an empty one says nothing.
+*/
+const nestInlineWrapperGroups = (items, groups) => {
+	const nested = [];
+	for (const [index, group] of groups.entries()) {
+		const slice = items.slice(group.start, groups[index + 1]?.start ?? items.length);
+		if (group.stack.length === 0) {
+			nested.push(...slice);
+			continue;
+		}
+		let pending = [];
+		const closeNest = () => {
+			if (pending.length === 0) return;
+			nested.push(nestInlineWrappers(group.stack, pending));
+			pending = [];
+		};
+		for (const item of slice) {
+			if (!isRevisionWrapper(item)) {
+				pending.push(item);
+				continue;
+			}
+			closeNest();
+			if (item.content.length > 0) item.content = [nestInlineWrappers(group.stack, item.content)];
+			nested.push(item);
+		}
+		closeNest();
+	}
+	return nested;
+};
 function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, textBoxAnchorMarkers, skipLeadingRenderedPageBreak = false, inheritedFormattingOverride) {
 	const content = [];
 	const paragraphStyleContext = paragraph.type.name === "paragraph" ? paragraphRunStyleContext(paragraph) : void 0;
@@ -1033,6 +1203,11 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 	})).toSorted((left, right) => left.attrs.offset - right.attrs.offset || left.order - right.order);
 	let nextEmptyHyperlink = 0;
 	let leadingRenderedPageBreakPending = skipLeadingRenderedPageBreak;
+	const wrapperGroups = [{
+		start: 0,
+		stack: []
+	}];
+	let wrapperGroupKey = "";
 	let currentRun = null;
 	let currentMarksKey = null;
 	let currentHyperlink = null;
@@ -1058,7 +1233,7 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 	};
 	const appendDirectRun = (node, run, coalescePlainText = false) => {
 		const marksKey = getMarksKey(node.marks);
-		const ownerId = pageBreakRunOwnerId(node);
+		const ownerId = runIdentityId(node);
 		const currentOwnerId = currentRun ? sourceRunOwners.get(currentRun) : void 0;
 		const currentRunIsPlainText = currentRun?.content.every((runContent) => runContent.type === "text");
 		const joinsOwnedSourceRun = ownerId !== void 0 && ownerId === currentOwnerId && currentRun !== null && runsShareProperties(currentRun, run);
@@ -1086,14 +1261,14 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 		if (toClose.length === 0 && toOpen.length === 0) return;
 		flushCurrentInline();
 		currentTrackedChange = void 0;
-		for (const commentId of toClose.toSorted((a, b) => a - b)) {
+		for (const commentId of byCommentId(toClose)) {
 			content.push({
 				type: "commentRangeEnd",
 				id: commentId
 			});
 			openedComments.delete(commentId);
 		}
-		for (const commentId of toOpen.toSorted((a, b) => a - b)) {
+		for (const commentId of byCommentId(toOpen)) {
 			content.push({
 				type: "commentRangeStart",
 				id: commentId
@@ -1111,13 +1286,58 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			content.push(createEmptyHyperlink(item.attrs));
 		}
 	};
+	/**
+	* Cut the emitted sequence where the wrapper the nodes sit inside changes.
+	*
+	* Nothing that spans nodes may span the cut: a run, a hyperlink and a
+	* revision each sit inside one wrapper or outside it, never half in. The
+	* comment ranges `syncCommentRanges` writes are cut with the rest, which
+	* puts a range that opens or closes inside a wrapper inside it, as Word
+	* writes it; a range marker says the same thing at either level, because the
+	* wrapper is transparent and the position is unchanged.
+	*/
+	const enterWrapperGroup = (node) => {
+		const stack = inlineWrapperStackOf(node);
+		const key = inlineWrapperStackKey(stack);
+		if (key === wrapperGroupKey) return;
+		flushCurrentInline();
+		currentTrackedChange = void 0;
+		wrapperGroupKey = key;
+		wrapperGroups.push({
+			start: content.length,
+			stack
+		});
+	};
 	const processInlineNode = (node, offset) => {
 		if (node.type.name === "renderedPageBreak" && leadingRenderedPageBreakPending) {
 			leadingRenderedPageBreakPending = false;
 			return;
 		}
 		leadingRenderedPageBreakPending = false;
+		enterWrapperGroup(node);
 		syncCommentRanges(node, offset);
+		if (node.type.name === "commentReference") {
+			flushCurrentInline();
+			currentTrackedChange = void 0;
+			content.push({
+				type: "commentReference",
+				id: expectCommentReferenceAttrs(node).commentId
+			});
+			return;
+		}
+		if (node.type.name === "rangeAnchor") {
+			flushCurrentInline();
+			currentTrackedChange = void 0;
+			const { start, end } = expectRangeAnchorAttrs(node);
+			content.push({ ...start }, { ...end });
+			return;
+		}
+		if (node.type.name === "moveRangeBoundary") {
+			flushCurrentInline();
+			currentTrackedChange = void 0;
+			content.push({ ...expectMoveRangeBoundaryAttrs(node) });
+			return;
+		}
 		const linkMark = node.marks.find((m) => m.type.name === "hyperlink");
 		const noteRefMark = node.marks.find((m) => m.type.name === "footnoteRef");
 		const insertionMark = node.marks.find((m) => m.type.name === "insertion");
@@ -1210,6 +1430,10 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 					});
 					return;
 				}
+				if (isInlineLevelPreservedXml(node)) {
+					currentTrackedChange.hyperlink.children.push(createPreservedInline(node));
+					return;
+				}
 				const run = createTrackedChangeRun({
 					...formattingContext,
 					marks: otherMarks,
@@ -1228,20 +1452,7 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				};
 			}
 			if (node.type.name === "bookmarkBoundary") {
-				const attrs = expectBookmarkBoundaryAttrs(node);
-				const boundary = attrs.type === "start" ? {
-					type: "bookmarkStart",
-					id: attrs.id,
-					name: attrs.name,
-					...attrs.colFirst !== void 0 ? { colFirst: attrs.colFirst } : {},
-					...attrs.colLast !== void 0 ? { colLast: attrs.colLast } : {},
-					...bookmarkBoundaryDisplacement(attrs)
-				} : {
-					type: "bookmarkEnd",
-					id: attrs.id,
-					...bookmarkBoundaryDisplacement(attrs)
-				};
-				currentTrackedChange.wrapper.content.push(boundary);
+				currentTrackedChange.wrapper.content.push(bookmarkMarkerFromAttrs(expectBookmarkBoundaryAttrs(node)));
 				return;
 			}
 			if (node.type.name === "field" || node.type.name === "structuredField") {
@@ -1256,6 +1467,10 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 				currentTrackedChange.wrapper.content.push(createMathFromNode(node));
 				return;
 			}
+			if (isInlineLevelPreservedXml(node)) {
+				currentTrackedChange.wrapper.content.push(createPreservedInline(node));
+				return;
+			}
 			const run = createTrackedChangeRun({
 				...formattingContext,
 				marks: otherMarks,
@@ -1264,7 +1479,7 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 			if (run) appendRunToTrackedWrapper(currentTrackedChange.wrapper, run, node, sourceRunOwners);
 			return;
 		}
-		const ownedRun = linkMark || pageBreakRunOwnerId(node) === void 0 ? null : createTrackedChangeRun({
+		const ownedRun = linkMark || runIdentityId(node) === void 0 ? null : createTrackedChangeRun({
 			...formattingContext,
 			marks: node.marks,
 			node
@@ -1296,20 +1511,7 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 		if (currentHyperlink) flushCurrentInline();
 		if (node.type.name === "bookmarkBoundary") {
 			flushCurrentInline();
-			const attrs = expectBookmarkBoundaryAttrs(node);
-			if (attrs.type === "start") content.push({
-				type: "bookmarkStart",
-				id: attrs.id,
-				name: attrs.name,
-				...attrs.colFirst !== void 0 ? { colFirst: attrs.colFirst } : {},
-				...attrs.colLast !== void 0 ? { colLast: attrs.colLast } : {},
-				...bookmarkBoundaryDisplacement(attrs)
-			});
-			else content.push({
-				type: "bookmarkEnd",
-				id: attrs.id,
-				...bookmarkBoundaryDisplacement(attrs)
-			});
+			content.push(bookmarkMarkerFromAttrs(expectBookmarkBoundaryAttrs(node)));
 		} else if (node.isText) appendDirectRun(node, createRunFromText({
 			...formattingContext,
 			marks: node.marks,
@@ -1325,6 +1527,9 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 		} else if (node.type.name === "symbol") {
 			flushCurrentInline();
 			content.push(createSymbolRun(node, node.marks, formattingContext));
+		} else if (node.type.name === "preservedXml") {
+			flushCurrentInline();
+			content.push(isInlineLevelPreservedXml(node) ? createPreservedInline(node) : createPreservedXmlRun(node, node.marks, formattingContext));
 		} else if (node.type.name === "hardBreak") {
 			flushCurrentInline();
 			content.push(createBreakRun(expectHardBreakAttrs(node), node.marks, formattingContext));
@@ -1379,11 +1584,11 @@ function extractParagraphContent(paragraph, _documentCounts, emptyHyperlinks, te
 	});
 	flushEmptyHyperlinksThroughOffset(Number.POSITIVE_INFINITY);
 	flushCurrentInline();
-	for (const commentId of openedComments) content.push({
+	for (const commentId of byCommentId(openedComments)) content.push({
 		type: "commentRangeEnd",
 		id: commentId
 	});
-	return content;
+	return nestInlineWrapperGroups(content, wrapperGroups);
 }
 function createTrackedChangeRun({ baseParagraphFormatting, inheritedFormatting, marks, node, paragraphMarkFormatting, paragraphMarkPrecedesStyle, styleResolver }) {
 	const formattingContext = {
@@ -1406,8 +1611,9 @@ function createTrackedChangeRun({ baseParagraphFormatting, inheritedFormatting,
 			}] : [],
 			...Object.keys(formatting).length > 0 ? { formatting } : {}
 		};
-		restoreRunPropertyChanges(run, marks);
+		restoreRunRecord(run, marks);
 	} else if (node.type.name === "symbol") run = createSymbolRun(node, marks, formattingContext);
+	else if (node.type.name === "preservedXml") run = createPreservedXmlRun(node, marks, formattingContext);
 	else if (node.type.name === "hardBreak") run = createBreakRun(expectHardBreakAttrs(node), marks, formattingContext);
 	else if (node.type.name === "pageBreakRun") {
 		const { clear } = expectPageBreakRunAttrs(node);
@@ -1420,11 +1626,11 @@ function createTrackedChangeRun({ baseParagraphFormatting, inheritedFormatting,
 	else if (node.type.name === "shape") run = createShapeRun(node);
 	else if (node.type.name === "tab") run = createTabRun(node, marks, formattingContext);
 	else if (node.type.name === "renderedPageBreak") run = createRenderedPageBreakRun();
-	if (!run || pageBreakRunOwnerId(node) === void 0) return run;
+	if (!run || runIdentityId(node) === void 0) return run;
 	if (node.type.name === "image" || node.type.name === "shape" || node.type.name === "renderedPageBreak") {
 		const formatting = getRunFormattingFromMarks(marks, formattingContext);
 		if (formatting) run.formatting = formatting;
-		restoreRunPropertyChanges(run, marks);
+		restoreRunRecord(run, marks);
 	}
 	return run;
 }
@@ -1515,20 +1721,7 @@ function createHyperlink(linkMark) {
 }
 function addNodeToHyperlink({ baseParagraphFormatting, hyperlink, inheritedFormatting, node, paragraphMarkFormatting, paragraphMarkPrecedesStyle, sourceRunOwners, styleResolver }) {
 	if (node.type.name === "bookmarkBoundary") {
-		const attrs = expectBookmarkBoundaryAttrs(node);
-		if (attrs.type === "start") hyperlink.children.push({
-			type: "bookmarkStart",
-			id: attrs.id,
-			name: attrs.name,
-			...attrs.colFirst !== void 0 ? { colFirst: attrs.colFirst } : {},
-			...attrs.colLast !== void 0 ? { colLast: attrs.colLast } : {},
-			...bookmarkBoundaryDisplacement(attrs)
-		});
-		else hyperlink.children.push({
-			type: "bookmarkEnd",
-			id: attrs.id,
-			...bookmarkBoundaryDisplacement(attrs)
-		});
+		hyperlink.children.push(bookmarkMarkerFromAttrs(expectBookmarkBoundaryAttrs(node)));
 		return;
 	}
 	const formattingContext = {
@@ -1539,7 +1732,7 @@ function addNodeToHyperlink({ baseParagraphFormatting, hyperlink, inheritedForma
 		styleResolver
 	};
 	const nonLinkMarks = node.marks.filter((mark) => mark.type.name !== "hyperlink");
-	const ownedRun = pageBreakRunOwnerId(node) === void 0 ? null : createTrackedChangeRun({
+	const ownedRun = runIdentityId(node) === void 0 ? null : createTrackedChangeRun({
 		...formattingContext,
 		marks: nonLinkMarks,
 		node
@@ -1582,6 +1775,16 @@ function addNodeToHyperlink({ baseParagraphFormatting, hyperlink, inheritedForma
 		}));
 		return;
 	}
+	if (node.type.name === "preservedXml") {
+		hyperlink.children.push(isInlineLevelPreservedXml(node) ? createPreservedInline(node) : createPreservedXmlRun(node, nonLinkMarks, {
+			baseParagraphFormatting,
+			inheritedFormatting,
+			paragraphMarkFormatting,
+			paragraphMarkPrecedesStyle,
+			styleResolver
+		}));
+		return;
+	}
 	if (node.type.name === "hardBreak") {
 		hyperlink.children.push(createBreakRun(expectHardBreakAttrs(node), nonLinkMarks, {
 			baseParagraphFormatting,
@@ -1642,7 +1845,7 @@ function createNoteReferenceRun(noteRefMark, marks, formattingContext) {
 		...formatting,
 		vertAlign
 	};
-	restoreRunPropertyChanges(run, marks);
+	restoreRunRecord(run, marks);
 	return run;
 }
 function createRunFromText({ baseParagraphFormatting, inheritedFormatting, marks, paragraphMarkFormatting, paragraphMarkPrecedesStyle, styleResolver, text }) {
@@ -1661,7 +1864,7 @@ function createRunFromText({ baseParagraphFormatting, inheritedFormatting, marks
 		}]
 	};
 	if (formatting) run.formatting = formatting;
-	restoreRunPropertyChanges(run, marks);
+	restoreRunRecord(run, marks);
 	return run;
 }
 function createSymbolRun(node, marks, formattingContext) {
@@ -1676,15 +1879,77 @@ function createSymbolRun(node, marks, formattingContext) {
 	};
 	const formatting = getAtomRunFormattingFromMarks(marks, formattingContext);
 	if (formatting) run.formatting = formatting;
-	restoreRunPropertyChanges(run, marks);
+	restoreRunRecord(run, marks);
 	return run;
 }
-function restoreRunPropertyChanges(run, marks) {
+/**
+* Whether the atom's markup is a paragraph child rather than a run child.
+*
+* The two are the same node in the editor and different elements in the file:
+* `w:ruby` has to go back inside a `w:r` and `w:permStart` may not, because
+* the schema admits no such child of a run and Word reports the package as
+* unreadable content.
+*/
+const isInlineLevelPreservedXml = (node) => node.type.name === "preservedXml" && expectPreservedXmlAttrs(node).level === PRESERVED_XML_LEVELS.inline;
+/** The paragraph-level capture an inline-level atom writes back. */
+const createPreservedInline = (node) => {
+	const { xml, text } = expectPreservedXmlAttrs(node);
+	return {
+		type: "preservedInline",
+		xml,
+		text
+	};
+};
+/**
+* Rebuild the run around a preserved child. The markup is opaque and comes
+* back byte for byte; only the run properties around it are rebuilt from the
+* atom's marks, exactly as for a symbol.
+*/
+function createPreservedXmlRun(node, marks, formattingContext) {
+	const { xml, text } = expectPreservedXmlAttrs(node);
+	const run = {
+		type: "run",
+		content: [{
+			type: "preservedXml",
+			xml,
+			text
+		}]
+	};
+	const formatting = getAtomRunFormattingFromMarks(marks, formattingContext);
+	if (formatting) run.formatting = formatting;
+	restoreRunRecord(run, marks);
+	return run;
+}
+/**
+* Put back everything about the authored `w:r` that the marks still carry:
+* its property revision, its attribute remainder and its `w:rPr` sink.
+*
+* One helper for the three, called at every site that builds a run, because a
+* site that restored two of them would write a `w:r` that has lost the third
+* without anything saying so. A leaf with no identity mark produces a run with
+* neither remainder nor sink, which is what typed text is.
+*/
+function restoreRunRecord(run, marks) {
 	const changeMark = marks.find((mark) => mark.type.name === "runPropertyChange");
-	if (!changeMark) return;
-	const { changes } = expectRunPropertyChangeMarkAttrs(changeMark);
-	if (changes.length === 0) return;
-	run.propertyChanges = [...changes];
+	if (changeMark) {
+		const { changes } = expectRunPropertyChangeMarkAttrs(changeMark);
+		if (changes.length > 0) run.propertyChanges = [...changes];
+	}
+	const identityMark = marks.find((mark) => mark.type.name === RUN_IDENTITY_MARK_NAME);
+	if (!identityMark) return;
+	const { preservedAttributes, preserved } = expectRunIdentityMarkAttrs(identityMark);
+	if (preservedAttributes && preservedAttributes.length > 0) run.preservedAttributes = preservedAttributes.map(({ namespace, name, value }) => namespace === void 0 ? {
+		name,
+		value
+	} : {
+		namespace,
+		name,
+		value
+	});
+	if (preserved && (preserved.children?.length ?? 0) > 0) run.formatting = {
+		...run.formatting,
+		preserved
+	};
 }
 function getRunFormattingFromMarks(marks, options) {
 	if (!marks || marks.length === 0 && !options) return;
@@ -1715,17 +1980,25 @@ function runsShareProperties(left, right) {
 		propertyChanges: right.propertyChanges
 	});
 }
-function pageBreakRunOwnerId(node) {
-	const mark = node.marks.find(({ type }) => type.name === "pageBreakRunOwner");
-	return mark ? expectPageBreakRunOwnerMarkAttrs(mark).id : void 0;
+/**
+* The authored `w:r` this leaf came from, when it names one.
+*
+* Two leaves that share an id are two pieces of one authored run — the cut a
+* page-break atom makes — and the save leg rejoins them. Two leaves with
+* different ids are two runs however alike their formatting, which is what
+* keeps both sides' `w:rsid*` alive across a paragraph the editor rebuilt.
+*/
+function runIdentityId(node) {
+	const mark = node.marks.find(({ type }) => type.name === RUN_IDENTITY_MARK_NAME);
+	return mark ? expectRunIdentityMarkAttrs(mark).id : void 0;
 }
 function canJoinOwnedRuns(previous, run, node, sourceRunOwners) {
 	if (!previous || !runsShareProperties(previous, run)) return false;
-	const ownerId = pageBreakRunOwnerId(node);
+	const ownerId = runIdentityId(node);
 	return ownerId !== void 0 && sourceRunOwners.get(previous) === ownerId;
 }
 function rememberSourceRunOwner(run, node, sourceRunOwners) {
-	const ownerId = pageBreakRunOwnerId(node);
+	const ownerId = runIdentityId(node);
 	if (ownerId !== void 0) sourceRunOwners.set(run, ownerId);
 }
 function appendRunToTrackedWrapper(wrapper, run, node, sourceRunOwners) {
@@ -1763,7 +2036,7 @@ function createPageBreakCarrierRun({ baseParagraphFormatting, clear, inheritedFo
 		styleResolver
 	});
 	if (formatting) run.formatting = formatting;
-	if (marks) restoreRunPropertyChanges(run, marks);
+	if (marks) restoreRunRecord(run, marks);
 	return run;
 }
 /**
@@ -1780,7 +2053,7 @@ function createBreakRun(attrs, marks, formattingContext) {
 	};
 	const formatting = getAtomRunFormattingFromMarks(marks, formattingContext);
 	if (formatting) run.formatting = formatting;
-	if (marks) restoreRunPropertyChanges(run, marks);
+	if (marks) restoreRunRecord(run, marks);
 	return run;
 }
 function createRenderedPageBreakRun() {
@@ -1803,7 +2076,7 @@ function createTabRun(node, marks, formattingContext) {
 	};
 	const formatting = getAtomRunFormattingFromMarks(marks, formattingContext);
 	if (formatting) run.formatting = formatting;
-	if (marks) restoreRunPropertyChanges(run, marks);
+	if (marks) restoreRunRecord(run, marks);
 	return run;
 }
 function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormatting, marks, paragraphMarkFormatting, paragraphMarkPrecedesStyle, styleResolver, textBoxAnchorMarkers }) {
@@ -1821,7 +2094,7 @@ function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormattin
 		paragraphMarkFormatting,
 		paragraphMarkPrecedesStyle: paragraphMarkPrecedesStyle ?? false,
 		styleResolver: styleResolver ?? null
-	}).filter((content) => content.type === "run" || content.type === "hyperlink");
+	}).filter(isSimpleFieldContent);
 	const displayText = attrs.displayText ?? "";
 	const displayRun = {
 		type: "run",
@@ -1831,7 +2104,7 @@ function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormattin
 		}],
 		...formatting && Object.keys(formatting).length > 0 ? { formatting } : {}
 	};
-	if (marks && node.type.name === "field") restoreRunPropertyChanges(displayRun, marks);
+	if (marks && node.type.name === "field") restoreRunRecord(displayRun, marks);
 	const fieldContent = extractedContent.length > 0 ? synchronizeFieldDisplayText(extractedContent, displayText, displayRun) : [];
 	const fallbackFieldContent = displayText ? [displayRun] : [];
 	if (attrs.fieldKind === "complex") {
@@ -1842,8 +2115,8 @@ function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormattin
 			fieldCode: [],
 			fieldResult: fieldContent.length > 0 ? fieldContent.filter((content) => content.type === "run") : fallbackFieldContent
 		};
-		if (attrs.fldLock) complex.fldLock = true;
-		if (attrs.dirty) complex.dirty = true;
+		if (attrs.fldLock !== void 0) complex.fldLock = attrs.fldLock;
+		if (attrs.dirty !== void 0) complex.dirty = attrs.dirty;
 		return complex;
 	}
 	const simple = {
@@ -1852,21 +2125,24 @@ function createFieldFromNode(node, { baseParagraphFormatting, inheritedFormattin
 		fieldType: attrs.fieldType,
 		content: fieldContent.length > 0 ? fieldContent : fallbackFieldContent
 	};
-	if (attrs.fldLock) simple.fldLock = true;
-	if (attrs.dirty) simple.dirty = true;
+	if (attrs.fldLock !== void 0) simple.fldLock = attrs.fldLock;
+	if (attrs.dirty !== void 0) simple.dirty = attrs.dirty;
 	return simple;
 }
 const synchronizeFieldDisplayText = (content, displayText, fallbackRun) => {
 	let currentText = "";
-	const visitRuns = (visit) => {
-		for (const child of content) {
+	const visitRunsIn = (items, visit) => {
+		for (const child of items) {
 			if (child.type === "run") {
 				visit(child);
 				continue;
 			}
-			for (const hyperlinkChild of child.children) if (hyperlinkChild.type === "run") visit(hyperlinkChild);
+			if (child.type === "hyperlink" || child.type === "inlineWrapper") visitRunsIn(child.type === "hyperlink" ? child.children : child.content, visit);
 		}
 	};
+	const visitRuns = (visit) => {
+		visitRunsIn(content, visit);
+	};
 	visitRuns((run) => {
 		for (const runContent of run.content) if (runContent.type === "text") currentText += runContent.text;
 	});
@@ -1903,14 +2179,42 @@ function createMathFromNode(node) {
 	return math;
 }
 /**
+* A revision covering every child of a control, written around the control.
+*
+* `w:ins > w:sdt` and `w:sdt > w:ins` reach the editor as the same revision
+* mark on the same leaves, so the save leg has to pick one and writes the
+* canonical order: the revision outermost, as it already is around a hyperlink
+* and around a transparent wrapper. Outermost is also the only form in which
+* accepting or rejecting the change is an operation over the whole control —
+* the reader who inserted a bound field inserted the field, not its text.
+*
+* A revision that covers only part of the content has no such form and stays
+* where the editor holds it, per child.
+*/
+const hoistUniformRevision = (sdt) => {
+	const only = sdt.content.length === 1 ? sdt.content.at(0) : void 0;
+	if (only === void 0 || !isRevisionWrapper(only)) return sdt;
+	const admitted = only.content.filter(isInlineSdtContent);
+	if (admitted.length !== only.content.length) return sdt;
+	return {
+		...only,
+		content: [{
+			...sdt,
+			content: admitted
+		}]
+	};
+};
+/**
 * Create an InlineSdt from a PM sdt node
 */
 function createInlineSdtFromNode(node, textBoxAnchorMarkers, formattingContext) {
-	return {
+	const properties = sdtPropertiesFromAttrs(expectSdtAttrs(node));
+	const content = extractParagraphContent(node, void 0, void 0, textBoxAnchorMarkers, false, formattingContext).filter(isInlineSdtContent);
+	return hoistUniformRevision({
 		type: "inlineSdt",
-		properties: sdtPropertiesFromAttrs(expectSdtAttrs(node)),
-		content: extractParagraphContent(node, void 0, void 0, textBoxAnchorMarkers, false, formattingContext).filter((c) => c.type === "run" || c.type === "hyperlink" || c.type === "simpleField" || c.type === "complexField" || c.type === "inlineSdt" || c.type === "insertion" || c.type === "deletion" || c.type === "moveFrom" || c.type === "moveTo" || c.type === "mathEquation")
-	};
+		properties,
+		content
+	});
 }
 /**
 * Create a Run containing an image
@@ -1923,15 +2227,24 @@ function createInlineSdtFromNode(node, textBoxAnchorMarkers, formattingContext)
 * around one has no other record of the properties it was authored with.
 */
 const carriedRunFormatting = (formatting) => formatting && Object.keys(formatting).length > 0 ? { formatting } : {};
+/**
+* The anchor record off a node's attrs, copied so the model never aliases a
+* ProseMirror attribute object.
+*/
+const restoredDrawingAnchor = (anchor) => anchor === void 0 ? void 0 : {
+	...anchor,
+	...anchor.simplePosition === void 0 ? {} : { simplePosition: { ...anchor.simplePosition } }
+};
 function createImageRun(node) {
 	const attrs = expectImageAttrs(node);
 	const wrap = { type: attrs.wrapType || "inline" };
 	assignWrapDistances(wrap, attrs);
 	if (attrs.wrapText) wrap.wrapText = attrs.wrapText;
 	const authoredEmu = attrs._docxAuthoredEmu;
+	const rId = relationshipIdOf(attrs.rId);
 	const image = {
 		type: "image",
-		rId: attrs.rId || "",
+		...rId === void 0 ? {} : { rId },
 		src: attrs.src,
 		size: {
 			width: emuFromPixels(attrs.width || 0, "width", authoredEmu, emuToPixels),
@@ -1942,12 +2255,17 @@ function createImageRun(node) {
 	if (attrs.docPrName != null) image.docPrName = attrs.docPrName;
 	if (attrs.alt != null) image.alt = attrs.alt;
 	if (attrs.title != null) image.title = attrs.title;
-	const imageTransform = parseTransformAttr(attrs.transform);
+	const imageTransform = readAuthoredTransform(attrs);
 	if (imageTransform) image.transform = imageTransform;
 	if (attrs.opacity != null) image.opacity = attrs.opacity;
+	if (attrs.brightness != null || attrs.contrast != null) image.effects = {
+		...attrs.brightness == null ? {} : { brightness: attrs.brightness },
+		...attrs.contrast == null ? {} : { contrast: attrs.contrast }
+	};
 	const imagePosition = imagePositionFromAttrs(attrs.position);
 	if (imagePosition) image.position = imagePosition;
-	if (attrs.layoutInCell !== void 0) image.layoutInCell = attrs.layoutInCell;
+	const imageAnchor = restoredDrawingAnchor(attrs.anchor);
+	if (imageAnchor) image.anchor = imageAnchor;
 	if (attrs.decorative !== void 0) image.decorative = attrs.decorative;
 	if (attrs.hidden !== void 0) image.hidden = attrs.hidden;
 	if (attrs.docPrExtensions !== void 0) image.docPrExtensions = [...attrs.docPrExtensions];
@@ -1955,21 +2273,15 @@ function createImageRun(node) {
 	if (attrs.borderWidth && attrs.borderWidth > 0) {
 		const outline = {
 			width: emuFromPixels(attrs.borderWidth, "borderWidth", authoredEmu, emuToStrokePixels),
-			style: attrs.borderStyle ? {
-				solid: "solid",
-				dotted: "dot",
-				dashed: "dash",
-				double: "solid",
-				groove: "solid",
-				ridge: "solid",
-				inset: "solid",
-				outset: "solid"
-			}[attrs.borderStyle] || "solid" : "solid"
+			dash: presetDashForCssBorderStyle(attrs.borderStyle)
 		};
 		if (attrs.borderColor) outline.color = { rgb: attrs.borderColor.replace("#", "") };
 		image.outline = outline;
 	}
 	if (attrs.hlinkHref) image.hlinkHref = attrs.hlinkHref;
+	if (attrs.docPrId !== void 0) image.id = attrs.docPrId;
+	if (attrs.hlinkClickSource !== void 0) image.hlinkClickSource = { ...attrs.hlinkClickSource };
+	if (attrs.hlinkHoverXml !== void 0) image.hlinkHoverXml = attrs.hlinkHoverXml;
 	if (attrs.hlinkRId) image.hlinkRId = attrs.hlinkRId;
 	const cropTop = attrs.cropTop != null && attrs.cropTop > 0 ? attrs.cropTop : void 0;
 	const cropRight = attrs.cropRight != null && attrs.cropRight > 0 ? attrs.cropRight : void 0;
@@ -1992,11 +2304,13 @@ function createImageRun(node) {
 		if (paddingLeft !== void 0) padding.left = paddingLeft;
 		image.padding = padding;
 	}
-	return {
+	const run = {
 		type: "run",
 		...carriedRunFormatting(attrs._docxRunFormatting),
 		content: [drawingFromImageAttrs(image, attrs)]
 	};
+	restoreRunRecord(run, node.marks);
+	return run;
 }
 /**
 * Rebuild the `DrawingContent` union member the image node came from.
@@ -2049,7 +2363,7 @@ function createShapeRun(node) {
 	if (attrs.title !== void 0) shape.title = attrs.title;
 	const geometryAdjustments = parseShapeGeometryAdjustments(attrs.geometryAdjustments);
 	if (geometryAdjustments !== void 0) shape.geometryAdjustments = geometryAdjustments;
-	const shapeTransform = parseTransformAttr(attrs.transform);
+	const shapeTransform = readAuthoredTransform(attrs);
 	if (shapeTransform) shape.transform = shapeTransform;
 	const wrap = { type: attrs.wrapType || "inline" };
 	assignWrapDistances(wrap, attrs);
@@ -2057,6 +2371,8 @@ function createShapeRun(node) {
 	shape.wrap = wrap;
 	const shapePosition = imagePositionFromAttrs(attrs.position);
 	if (shapePosition) shape.position = shapePosition;
+	const shapeAnchor = restoredDrawingAnchor(attrs.anchor);
+	if (shapeAnchor) shape.anchor = shapeAnchor;
 	if (attrs.fillType === "gradient" && attrs.gradientStops) try {
 		const parsed = JSON.parse(attrs.gradientStops);
 		const gradient = {
@@ -2086,8 +2402,8 @@ function createShapeRun(node) {
 		const shapeOutline = {};
 		if (attrs.outlineWidth !== void 0 && attrs.outlineWidth > 0) shapeOutline.width = emuFromPixels(attrs.outlineWidth, "outlineWidth", authoredEmu, emuToStrokePixels);
 		if (attrs.outlineStyle) {
-			const style = normalizeShapeOutlineStyle(attrs.outlineStyle);
-			if (style !== void 0) shapeOutline.style = style;
+			const dash = normalizeShapeOutlineDash(attrs.outlineStyle);
+			if (dash !== void 0) shapeOutline.dash = dash;
 		}
 		if (attrs.outlineCap) shapeOutline.cap = attrs.outlineCap;
 		if (attrs.outlineJoin) shapeOutline.join = attrs.outlineJoin;
@@ -2100,11 +2416,13 @@ function createShapeRun(node) {
 		type: "shape",
 		shape
 	};
-	return {
+	const run = {
 		type: "run",
 		...carriedRunFormatting(attrs._docxRunFormatting),
 		content: [shapeContent]
 	};
+	restoreRunRecord(run, node.marks);
+	return run;
 }
 const RUN_FORMATTING_VISUAL_GROUPS = {
 	bold: "bold",
@@ -2138,7 +2456,8 @@ const RUN_FORMATTING_VISUAL_GROUPS = {
 	shadow: "shadow",
 	rtl: "rtl",
 	cs: null,
-	styleId: null
+	styleId: null,
+	preserved: null
 };
 const RUN_FORMATTING_FAST_PATH_DISPOSITION = {
 	bold: "visual",
@@ -2172,7 +2491,8 @@ const RUN_FORMATTING_FAST_PATH_DISPOSITION = {
 	shadow: "visual",
 	rtl: "visual",
 	cs: "structural",
-	styleId: "character-style"
+	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;
@@ -2706,7 +3026,7 @@ function convertPMTable(node, documentCounts, styleResolver = null) {
 				rows
 			};
 			if (attrs.columnWidths) minTable.columnWidths = attrs.columnWidths;
-			restoreTablePropertyChanges(minTable, attrs);
+			restoreCarriedTableAttrs(minTable, attrs);
 			return minTable;
 		}
 	}
@@ -2716,16 +3036,22 @@ function convertPMTable(node, documentCounts, styleResolver = null) {
 	};
 	if (attrs.columnWidths) table.columnWidths = attrs.columnWidths;
 	if (formatting && Object.keys(formatting).length > 0) table.formatting = formatting;
-	restoreTablePropertyChanges(table, attrs);
+	restoreCarriedTableAttrs(table, attrs);
 	return table;
 }
 /**
-* Restore `w:tblPrChange` entries that PM carried opaquely on the table attrs
-* (same rationale as the paragraph `_propertyChanges` attr): they must survive
-* an edit so the saved DOCX keeps the tracked property-change history.
+* Restore what PM carried opaquely on the table attrs, on both paths out of
+* {@link convertPMTable}.
+*
+* `w:tblPrChange` (same rationale as the paragraph `_propertyChanges` attr)
+* must survive an edit so the saved DOCX keeps the tracked property-change
+* history, and the child sink must survive it so the markup the table held
+* beside its rows comes back between the same two.
 */
-function restoreTablePropertyChanges(table, attrs) {
+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;
 }
 function convertPMTableRows(node, documentCounts, styleResolver = null) {
 	const rows = [];
@@ -2836,10 +3162,15 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges, styleReso
 		}
 	};
 	node.forEach((cellNode) => {
-		appendActiveVerticalMerges();
 		if (cellNode.type.name === "tableCell" || cellNode.type.name === "tableHeader") {
 			const cellAttrs = expectTableCellAttrs(cellNode);
 			const colspan = Math.max(cellAttrs.colspan, 1);
+			if (cellAttrs._omittedGridSlot) {
+				if (!(cellNode.childCount === 1 && cellNode.child(0).type.name === "paragraph" && cellNode.child(0).content.size === 0)) panic("An omitted table grid slot acquired authored content");
+				gridColumn += colspan;
+				return;
+			}
+			appendActiveVerticalMerges();
 			cells.push(convertPMTableCell(cellNode, documentCounts, styleResolver));
 			if (cellAttrs.rowspan > 1) {
 				const continuationCells = cellAttrs._docxVMergeContinuationCells !== void 0 && cellAttrs._docxVMergeContinuationCells !== null ? restoreTableCellsWithParagraphPropertySources(decodeTableCellParagraphSourcePayload(cellAttrs._docxVMergeContinuationCells)) : void 0;
@@ -2859,7 +3190,13 @@ function convertPMTableRow(node, documentCounts, activeVerticalMerges, styleReso
 	};
 	const rowFormatting = tableRowAttrsToFormatting(attrs);
 	if (rowFormatting) row.formatting = rowFormatting;
+	if (attrs._tablePropertyExceptions) row.tablePropertyExceptions = attrs._tablePropertyExceptions;
+	if (Array.isArray(attrs.tblPrExChange) && attrs.tblPrExChange.length > 0) row.tablePropertyExceptionChanges = [...attrs.tblPrExChange];
 	if (Array.isArray(attrs.trPrChange) && attrs.trPrChange.length > 0) row.propertyChanges = [...attrs.trPrChange];
+	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 (hasSinkChildren(attrs._preserved)) row.preserved = attrs._preserved;
 	if (attrs.trIns) row.structuralChange = {
 		type: "tableRowInsertion",
 		info: {
@@ -2916,11 +3253,11 @@ function tableRowAttrsToFormatting(attrs) {
 		else delete result.heightRule;
 		if (attrs.isHeader !== (orig.header ?? void 0)) if (attrs.isHeader) result.header = attrs.isHeader;
 		else delete result.header;
-		if (attrs.hidden !== (orig.hidden ?? void 0)) if (attrs.hidden) result.hidden = attrs.hidden;
-		else delete result.hidden;
+		if (attrs.hidden !== orig.hidden) if (attrs.hidden === void 0) delete result.hidden;
+		else result.hidden = attrs.hidden;
 		return result;
 	}
-	if (!(attrs.height || attrs.isHeader || attrs.hidden)) return;
+	if (!(attrs.height || attrs.isHeader || attrs.hidden !== void 0)) return;
 	const f = {};
 	if (attrs.height) f.height = {
 		value: attrs.height,
@@ -2928,7 +3265,7 @@ function tableRowAttrsToFormatting(attrs) {
 	};
 	if (attrs.heightRule) f.heightRule = attrs.heightRule;
 	if (attrs.isHeader) f.header = attrs.isHeader;
-	if (attrs.hidden) f.hidden = attrs.hidden;
+	if (attrs.hidden !== void 0) f.hidden = attrs.hidden;
 	return f;
 }
 /**
@@ -2952,6 +3289,16 @@ function convertPMTableCell(node, documentCounts, styleResolver = null) {
 			textBoxAnchorMarkers,
 			styleResolver
 		});
+		else if (contentNode.type.name === "preservedBlock") {
+			content.push({
+				type: "preservedBlock",
+				xml: expectPreservedBlockAttrs(contentNode).xml
+			});
+			previousStandaloneTextBox = null;
+		} else if (contentNode.type.name === "blockBookmarkBoundary") {
+			content.push(blockBookmarkMarker(contentNode));
+			previousStandaloneTextBox = null;
+		}
 	});
 	removeUnresolvedTextBoxAnchors(content, textBoxAnchorMarkers);
 	const cell = {
@@ -2961,6 +3308,7 @@ function convertPMTableCell(node, documentCounts, styleResolver = null) {
 	const cellFormatting = tableCellAttrsToFormatting(attrs);
 	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.cellMarker) {
 		const info = {
 			id: attrs.cellMarker.info.revisionId,
@@ -2996,11 +3344,8 @@ function tableCellAttrsToFormatting(attrs) {
 		else delete result.gridSpan;
 		if (attrs.rowspan > 1) result.vMerge = "restart";
 		else if (result.vMerge === "restart" && !attrs._preserveVMergeRestart) delete result.vMerge;
-		const cellWidth = attrs.width;
-		if (typeof cellWidth === "number") result.width = {
-			value: cellWidth,
-			type: attrs.widthType ?? "dxa"
-		};
+		const authoredWidth = attrs._authoredWidth;
+		if (authoredWidth) result.width = authoredWidth;
 		else delete result.width;
 		if (attrs.verticalAlign !== (orig.verticalAlign ?? void 0)) if (attrs.verticalAlign) result.verticalAlign = attrs.verticalAlign;
 		else delete result.verticalAlign;
@@ -3011,15 +3356,12 @@ function tableCellAttrsToFormatting(attrs) {
 		else delete result.textDirection;
 		return result;
 	}
-	const cellWidth = attrs.width;
-	if (!(attrs.colspan > 1 || attrs.rowspan > 1 || typeof cellWidth === "number" || attrs.verticalAlign || backgroundChanged || attrs.borders || attrs.margins || attrs.textDirection)) return;
+	const authoredWidth = attrs._authoredWidth;
+	if (!(attrs.colspan > 1 || attrs.rowspan > 1 || authoredWidth !== void 0 || attrs.verticalAlign || backgroundChanged || 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 (typeof cellWidth === "number") f.width = {
-		value: cellWidth,
-		type: attrs.widthType ?? "dxa"
-	};
+	if (authoredWidth) f.width = authoredWidth;
 	if (attrs.verticalAlign) f.verticalAlign = attrs.verticalAlign;
 	if (attrs.textDirection) f.textDirection = attrs.textDirection;
 	if (backgroundChanged) f.shading = cellShadingFromAttrs(attrs);
@@ -3086,7 +3428,7 @@ function convertPMTextBox(node, styleResolver = null) {
 	if (attrs.textBoxName !== void 0) shape.name = attrs.textBoxName;
 	if (attrs.alt !== void 0) shape.alt = attrs.alt;
 	if (attrs.title !== void 0) shape.title = attrs.title;
-	const transform = parseTransformAttr(attrs.transform);
+	const transform = readAuthoredTransform(attrs);
 	if (transform) shape.transform = transform;
 	if (attrs.fillColor) shape.fill = {
 		type: "solid",
@@ -3095,7 +3437,7 @@ function convertPMTextBox(node, styleResolver = null) {
 	if (attrs.outlineStyle !== "none" && attrs.outlineWidth && attrs.outlineWidth > 0) {
 		const tbOutline = {
 			width: emuFromPixels(attrs.outlineWidth, "outlineWidth", authoredEmu, emuToStrokePixels),
-			style: normalizeShapeOutlineStyle(attrs.outlineStyle) ?? "solid"
+			dash: normalizeShapeOutlineDash(attrs.outlineStyle) ?? "solid"
 		};
 		if (attrs.outlineColor) tbOutline.color = { rgb: attrs.outlineColor.replace("#", "") };
 		shape.outline = tbOutline;
@@ -3104,6 +3446,8 @@ function convertPMTextBox(node, styleResolver = null) {
 	if (wrap) shape.wrap = wrap;
 	const position = imagePositionFromAttrs(attrs.position);
 	if (position) shape.position = position;
+	const anchor = restoredDrawingAnchor(attrs.anchor);
+	if (anchor) shape.anchor = anchor;
 	const run = {
 		type: "run",
 		content: [{
@@ -3156,8 +3500,10 @@ function updateDocumentContent(originalDocument, pmDoc) {
 * Used for converting edited header/footer PM content back to the document
 * model.
 */
-function proseDocToBlocks(pmDoc, baseContent, styles, options) {
-	const blocks = extractBlocks(pmDoc, "resolve", styles ? createStyleEngine(styles) : null, options?.emptyFieldResult ?? "serializerFallback");
+function proseDocToBlocks(pmDoc, baseContent, styles) {
+	const blocks = extractBlocks(pmDoc, "resolve", styles ? createStyleEngine(styles) : null);
+	joinCommentRangesAcrossParagraphs(blocks);
+	completeCommentReferences(blocks);
 	const linkedSources = restoreLinkedParagraphPropertySources(blocks);
 	if (baseContent) restoreParagraphPropertySources(blocks, baseContent, linkedSources.targets, linkedSources.sources);
 	return blocks;