@stll/folio-core 0.44.0 → 0.46.0

package/dist/prosemirror/conversion/toProseDoc.js

@@ -1,4 +1,6 @@
+import { rangedCommentIds } from "../../docx/commentAnchorIndex.js";
 import { resolveColorValueToHex } from "../../docx/drawingUtils.js";
+import { isInlineSdtContent, isTrackedChangeWrapperChild } from "../../docx/inlineWrapperContent.js";
 import { isNumberingReference } from "../../docx/numberingReference.js";
 import { PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, createProseParagraphWithPropertySource, getDocumentParagraphPropertySourceContract, recreateProseNodeWithParagraphPropertySource, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
 import { isBaselineVertAlign } from "../../docx/runParser.js";
@@ -10,9 +12,12 @@ import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js"
 import { mergeParagraphFormatting, mergeParagraphTabStops } from "../../utils/paragraphFormattingMerge.js";
 import { tableOfContentsStyleLevel } from "../../utils/tableOfContentsStyle.js";
 import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
-import { emuToPixels } from "../../utils/units.js";
+import { emuToPixels, emuToStrokePixels } from "../../utils/units.js";
+import { expectInlineWrapperMarkAttrs } from "../attrs/index.js";
+import { authoredTransformAttrs } from "../authoredTransformAttrs.js";
 import { setAutospacingBaseValue } from "../autospacingBase.js";
 import { textFormattingToMarks } from "../extensions/marks/markUtils.js";
+import { inlineWrapperLayer } from "../inlineWrapperStack.js";
 import { listRenderingAttrPatch } from "../listRenderingAttrs.js";
 import { stampNumberedRefFieldBaselines } from "../numberedRefFields.js";
 import { pageBreakRunParagraphProjectionDispositionForFeatures } from "../pageBreakRunProjection.js";
@@ -21,17 +26,23 @@ import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenan
 import { lineSpacingProvenanceFromSpacing } from "../paragraphSpacing.js";
 import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, resolveParagraphBodyRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting } from "../runStyleFormatting.js";
 import { schema } from "../schema/index.js";
+import { PRESERVED_XML_LEVELS } from "../schema/nodes.js";
 import { cascadeStyleTextFormatting } from "../styles/styleToggleCascade.js";
 import { canCarryTrackedRunMark, trackedRunInlineAtomDisposition } from "../trackedRunInlineAtoms.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { resolveEffectiveTableCellFormatting } from "./effectiveTableCellFormatting.js";
 import { sdtAttrsFromProperties } from "./sdtAttrs.js";
-import { TaggedError, panic } from "better-result";
-import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
+import { panic } from "better-result";
+import { DRAWING_RAW_XML_MODES, PARSE_WARNING_CODES } from "@stll/docx-core/model";
 //#region src/prosemirror/conversion/toProseDoc.ts
-/** DOCX content that cannot be preserved by the editable ProseMirror model. */
-var UnsupportedDocxToProseMirrorConversionError = class extends TaggedError("UnsupportedDocxToProseMirrorConversionError") {};
 const DETACHED_WATERMARK_HOST = Symbol.for("stll.detachedWatermarkHost");
+const noPageBreakProjectionWarning = () => {};
+const pageBreakProjectionWarn = (warn) => warn === void 0 ? noPageBreakProjectionWarning : (detail) => {
+	warn({
+		code: PARSE_WARNING_CODES.pageBreakProjectionApproximated,
+		detail
+	});
+};
 /**
 * Build a `nextTextBoxGroupId()` generator salted with a random per-load
 * nonce, so minted text-box anchor ids (`<salt>:<group>:<index>`) are unique
@@ -89,6 +100,7 @@ const collectPairedBookmarkIds = (blocks) => {
 			case "run":
 				visitRun(child);
 				break;
+			case "preservedInline": break;
 			default: panic(`Unsupported hyperlink child: ${JSON.stringify(child)}`);
 		}
 	};
@@ -108,7 +120,7 @@ const collectPairedBookmarkIds = (blocks) => {
 				return;
 			case "simpleField":
 				for (const child of content.content) if (child.type === "hyperlink") visitHyperlink(child);
-				else visitRun(child);
+				else if (child.type === "run") visitRun(child);
 				return;
 			case "complexField":
 				for (const run of [...content.fieldCode ?? [], ...content.fieldResult]) visitRun(run);
@@ -118,7 +130,7 @@ const collectPairedBookmarkIds = (blocks) => {
 			case "deletion":
 			case "moveFrom":
 			case "moveTo":
-			case "bidiWrapper":
+			case "inlineWrapper":
 				for (const child of content.content) visitParagraphContent(child);
 				return;
 			case "commentRangeStart":
@@ -128,7 +140,8 @@ const collectPairedBookmarkIds = (blocks) => {
 			case "moveFromRangeEnd":
 			case "moveToRangeStart":
 			case "moveToRangeEnd":
-			case "mathEquation": return;
+			case "mathEquation":
+			case "preservedInline": return;
 			default: panic(`Unsupported paragraph content: ${JSON.stringify(content)}`);
 		}
 	};
@@ -143,6 +156,7 @@ const collectPairedBookmarkIds = (blocks) => {
 			case "blockSdt":
 				visitBlocks(block.content);
 				break;
+			case "preservedBlock": break;
 			default: panic(`Unsupported block content: ${JSON.stringify(block)}`);
 		}
 	};
@@ -166,7 +180,10 @@ function toProseDoc(document, options) {
 		nextTextBoxGroupId,
 		nextHyperlinkInstanceIndex: createHyperlinkInstanceIndexAllocator(),
 		pairedBookmarkIds: collectPairedBookmarkIds(paragraphs),
-		pageBreakRunSourceDescendants: buildPageBreakRunSourceDescendantIndex(paragraphs)
+		pageBreakRunSourceDescendants: buildPageBreakRunSourceDescendantIndex(paragraphs),
+		storyRangedCommentIds: rangedCommentIds(paragraphs),
+		openCommentIds: /* @__PURE__ */ new Set(),
+		warnPageBreakProjection: pageBreakProjectionWarn(options?.warn)
 	};
 	const convertBodyBlocks = (blocks) => {
 		const out = [];
@@ -183,6 +200,9 @@ function toProseDoc(document, options) {
 			case "blockSdt":
 				out.push(convertBlockSdt(block, convertBodyBlocks));
 				break;
+			case "preservedBlock":
+				out.push(convertPreservedBlock(block));
+				break;
 			default: panic(`Unsupported block content: ${JSON.stringify(block)}`);
 		}
 		return out;
@@ -200,6 +220,30 @@ function toProseDoc(document, options) {
 	return pmDoc;
 }
 /**
+* Carry a block folio does not model into the editor as a zero-width node.
+*
+* The node's place in the document is the whole of its position, so it needs
+* no index and nothing has to keep one honest as the blocks around it change.
+*/
+function convertPreservedBlock(block) {
+	return schema.node("preservedBlock", { xml: block.xml });
+}
+/**
+* Carry an inline child folio does not model into the editor as an opaque atom.
+*
+* The same atom the run level uses, tagged with the level it came from: the
+* markup is a paragraph child and the save path must not put it back inside a
+* `w:r`. It carries whatever marks surround it, so a capture inside a
+* `w:ins` keeps the insertion and is accepted or rejected with it.
+*/
+function preservedInlineNode(content) {
+	return schema.node("preservedXml", {
+		xml: content.xml,
+		text: content.text,
+		level: PRESERVED_XML_LEVELS.inline
+	});
+}
+/**
 * Convert a `BlockSdt` model node into a `blockSdt` PM node, recursively
 * converting its children with the caller-supplied block converter. Pass
 * `rawPropertiesXml` / `rawEndPropertiesXml` through as attrs so the
@@ -236,26 +280,27 @@ function convertBlockSdt(blockSdt, convertBlocks) {
 * Resolves style-based text formatting and passes it to runs so that
 * paragraph styles (like Heading1) apply their font size, color, etc.
 */
-function convertParagraph(paragraph, styleResolver, context, activeCommentIds, extraRunFormatting, tableParagraphOverlay, textBoxAnchors) {
-	const { nextHyperlinkInstanceIndex, pairedBookmarkIds, pageBreakRunSourceDescendants } = context;
+function convertParagraph(paragraph, styleResolver, context, extraRunFormatting, tableParagraphOverlay, textBoxAnchors) {
+	const { nextHyperlinkInstanceIndex, pairedBookmarkIds, pageBreakRunSourceDescendants, storyRangedCommentIds, openCommentIds } = context;
 	let pageBreakRunOwnerId = 0;
 	const nextPageBreakRunOwnerId = () => pageBreakRunOwnerId++;
 	const { attrs, effectiveFrame } = paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay);
-	assertParagraphPageBreakCanBeProjected({
+	reportParagraphPageBreakProjection({
 		paragraph,
 		attrs,
 		effectiveFrame,
-		sourceDescendants: pageBreakRunSourceDescendants
+		sourceDescendants: pageBreakRunSourceDescendants,
+		warn: context.warnPageBreakProjection
 	});
 	const isTocParagraph = attrs._tableOfContentsLevel !== void 0;
 	const inlineNodes = [];
 	let inlineOffset = 0;
 	let bookmarksArr;
 	let emptyHyperlinks;
-	const commentIds = activeCommentIds ?? /* @__PURE__ */ new Set();
+	let wrapperStack = [];
 	const emitInlineNodes = (nodes) => {
 		if (nodes.length === 0) return;
-		const markedNodes = applyCommentMarks(nodes, commentIds);
+		const markedNodes = applyCommentMarks(withInlineWrapperMark(nodes, wrapperStack), openCommentIds);
 		inlineNodes.push(...markedNodes);
 		for (const node of markedNodes) inlineOffset += node.nodeSize;
 	};
@@ -321,97 +366,104 @@ function convertParagraph(paragraph, styleResolver, context, activeCommentIds, e
 		};
 	};
 	const emitTrackedChange = (change, markType, moveKind) => {
-		emitInlineNodes(convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, moveKind, textBoxAnchors));
+		emitInlineNodes(convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, moveKind, textBoxAnchors, wrapperStack));
 	};
-	for (const content of withoutBidiWrappers(paragraph.content)) switch (content.type) {
-		case "commentRangeStart":
-			commentIds.add(content.id);
-			break;
-		case "commentRangeEnd":
-			commentIds.delete(content.id);
-			break;
-		case "commentReference":
-			anchorPointComment(inlineNodes, content.id);
-			break;
-		case "run":
-			emitInlineNodes(convertRun(content, getInheritedRunFormatting(content.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
-			break;
-		case "hyperlink": {
-			const linkNodes = convertHyperlink(content, {
-				getInheritedRunFormatting,
-				styleResolver,
-				hyperlinkIndex: nextHyperlinkInstanceIndex(),
-				textBoxAnchors,
-				nextPageBreakRunOwnerId
-			});
-			if (linkNodes.length === 0) {
-				emptyHyperlinks ??= [];
-				emptyHyperlinks.push({
-					offset: inlineOffset,
-					...content.href !== void 0 ? { href: content.href } : {},
-					...content.anchor !== void 0 ? { anchor: content.anchor } : {},
-					...content.tooltip !== void 0 ? { tooltip: content.tooltip } : {},
-					...content.rId !== void 0 ? { rId: content.rId } : {}
+	for (const { content, stack } of withInlineWrapperStacks(paragraph.content)) {
+		wrapperStack = stack;
+		switch (content.type) {
+			case "commentRangeStart":
+				openCommentIds.add(content.id);
+				break;
+			case "commentRangeEnd":
+				openCommentIds.delete(content.id);
+				break;
+			case "commentReference":
+				if (!storyRangedCommentIds.has(content.id)) anchorPointComment(inlineNodes, content.id);
+				emitInlineNode(schema.node("commentReference", { commentId: content.id }));
+				break;
+			case "run":
+				emitInlineNodes(convertRun(content, getInheritedRunFormatting(content.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
+				break;
+			case "hyperlink": {
+				const linkNodes = convertHyperlink(content, {
+					getInheritedRunFormatting,
+					styleResolver,
+					hyperlinkIndex: nextHyperlinkInstanceIndex(),
+					textBoxAnchors,
+					nextPageBreakRunOwnerId
 				});
+				if (linkNodes.length === 0) {
+					emptyHyperlinks ??= [];
+					emptyHyperlinks.push({
+						offset: inlineOffset,
+						...content.href !== void 0 ? { href: content.href } : {},
+						...content.anchor !== void 0 ? { anchor: content.anchor } : {},
+						...content.tooltip !== void 0 ? { tooltip: content.tooltip } : {},
+						...content.rId !== void 0 ? { rId: content.rId } : {}
+					});
+					break;
+				}
+				emitInlineNodes(linkNodes);
 				break;
 			}
-			emitInlineNodes(linkNodes);
-			break;
-		}
-		case "simpleField":
-		case "complexField":
-			emitInlineNode(convertField(content, {
-				getInheritedRunFormatting,
-				styleResolver,
-				nextHyperlinkInstanceIndex,
-				nextPageBreakRunOwnerId,
-				textBoxAnchors
-			}));
-			break;
-		case "inlineSdt":
-			emitInlineNode(convertInlineSdt(content, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors));
-			break;
-		case "insertion":
-		case "moveTo":
-			emitTrackedChange(content, "insertion", content.type === "moveTo" ? "moveTo" : null);
-			break;
-		case "deletion":
-		case "moveFrom":
-			emitTrackedChange(content, "deletion", content.type === "moveFrom" ? "moveFrom" : null);
-			break;
-		case "mathEquation":
-			emitInlineNode(convertMathEquation(content));
-			break;
-		case "bookmarkStart":
-			if (pairedBookmarkIds.has(content.id)) {
-				emitInlineNode(schema.node("bookmarkBoundary", {
-					type: "start",
+			case "simpleField":
+			case "complexField":
+				emitInlineNode(convertField(content, {
+					getInheritedRunFormatting,
+					styleResolver,
+					nextHyperlinkInstanceIndex,
+					nextPageBreakRunOwnerId,
+					textBoxAnchors
+				}));
+				break;
+			case "inlineSdt":
+				emitInlineNode(convertInlineSdt(content, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors, stack));
+				break;
+			case "insertion":
+			case "moveTo":
+				emitTrackedChange(content, "insertion", content.type === "moveTo" ? "moveTo" : null);
+				break;
+			case "deletion":
+			case "moveFrom":
+				emitTrackedChange(content, "deletion", content.type === "moveFrom" ? "moveFrom" : null);
+				break;
+			case "mathEquation":
+				emitInlineNode(convertMathEquation(content));
+				break;
+			case "bookmarkStart":
+				if (pairedBookmarkIds.has(content.id)) {
+					emitInlineNode(schema.node("bookmarkBoundary", {
+						type: "start",
+						id: content.id,
+						name: content.name,
+						colFirst: content.colFirst,
+						colLast: content.colLast,
+						displacedByCustomXml: content.displacedByCustomXml
+					}));
+					break;
+				}
+				if (!bookmarksArr) bookmarksArr = [];
+				bookmarksArr.push({
+					id: content.id,
+					name: content.name
+				});
+				break;
+			case "bookmarkEnd":
+				if (pairedBookmarkIds.has(content.id)) emitInlineNode(schema.node("bookmarkBoundary", {
+					type: "end",
 					id: content.id,
-					name: content.name,
-					colFirst: content.colFirst,
-					colLast: content.colLast,
 					displacedByCustomXml: content.displacedByCustomXml
 				}));
 				break;
-			}
-			if (!bookmarksArr) bookmarksArr = [];
-			bookmarksArr.push({
-				id: content.id,
-				name: content.name
-			});
-			break;
-		case "bookmarkEnd":
-			if (pairedBookmarkIds.has(content.id)) emitInlineNode(schema.node("bookmarkBoundary", {
-				type: "end",
-				id: content.id,
-				displacedByCustomXml: content.displacedByCustomXml
-			}));
-			break;
-		case "moveFromRangeStart":
-		case "moveFromRangeEnd":
-		case "moveToRangeStart":
-		case "moveToRangeEnd": break;
-		default: panic(`Unsupported paragraph content: ${JSON.stringify(content)}`);
+			case "moveFromRangeStart":
+			case "moveFromRangeEnd":
+			case "moveToRangeStart":
+			case "moveToRangeEnd": break;
+			case "preservedInline":
+				emitInlineNode(preservedInlineNode(content));
+				break;
+			default: panic(`Unsupported paragraph content: ${JSON.stringify(content)}`);
+		}
 	}
 	if (bookmarksArr) attrs.bookmarks = bookmarksArr;
 	if (emptyHyperlinks) attrs._emptyHyperlinks = emptyHyperlinks;
@@ -449,48 +501,57 @@ function anchorPointComment(nodes, commentId) {
 * Convert tracked change (insertion or deletion) content to PM nodes with
 * an insertion/deletion mark applied.
 */
-function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, moveKind = null, textBoxAnchors) {
+function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, moveKind = null, textBoxAnchors, wrappedBy = []) {
 	const nodes = [];
-	for (const item of change.content) if (item.type === "run") nodes.push(...convertRun(item, getInheritedRunFormatting(item.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
-	else if (item.type === "hyperlink") {
-		const currentHyperlinkIndex = nextHyperlinkInstanceIndex();
-		nodes.push(...convertHyperlink(item, {
-			getInheritedRunFormatting,
-			styleResolver,
-			hyperlinkIndex: currentHyperlinkIndex,
-			textBoxAnchors,
-			nextPageBreakRunOwnerId
+	for (const { content: item, stack } of withInlineWrapperStacks(change.content)) {
+		if (!isTrackedChangeWrapperChild(item)) continue;
+		const itemNodes = [];
+		if (item.type === "run") itemNodes.push(...convertRun(item, getInheritedRunFormatting(item.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
+		else if (item.type === "hyperlink") {
+			const currentHyperlinkIndex = nextHyperlinkInstanceIndex();
+			itemNodes.push(...convertHyperlink(item, {
+				getInheritedRunFormatting,
+				styleResolver,
+				hyperlinkIndex: currentHyperlinkIndex,
+				textBoxAnchors,
+				nextPageBreakRunOwnerId
+			}));
+		} else if (item.type === "simpleField" || item.type === "complexField") {
+			const fieldNode = convertField(item, {
+				getInheritedRunFormatting,
+				styleResolver,
+				nextHyperlinkInstanceIndex,
+				nextPageBreakRunOwnerId,
+				textBoxAnchors
+			});
+			if (fieldNode) itemNodes.push(fieldNode);
+		} else if (item.type === "mathEquation") {
+			const mathNode = convertMathEquation(item);
+			if (mathNode) itemNodes.push(mathNode);
+		} else if (item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") {
+			const nestedMarkType = item.type === "insertion" || item.type === "moveTo" ? "insertion" : "deletion";
+			const nestedMoveKind = item.type === "moveFrom" || item.type === "moveTo" ? item.type : null;
+			itemNodes.push(...convertTrackedChange(item, nestedMarkType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, nestedMoveKind, textBoxAnchors));
+		} else if (item.type === "inlineSdt") {
+			const sdtNode = convertInlineSdt(item, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors, [...wrappedBy, ...stack]);
+			if (sdtNode) itemNodes.push(sdtNode);
+		} else if (item.type === "bookmarkStart") itemNodes.push(schema.node("bookmarkBoundary", {
+			type: "start",
+			id: item.id,
+			name: item.name,
+			colFirst: item.colFirst,
+			colLast: item.colLast,
+			displacedByCustomXml: item.displacedByCustomXml
 		}));
-	} else if (item.type === "simpleField" || item.type === "complexField") {
-		const fieldNode = convertField(item, {
-			getInheritedRunFormatting,
-			styleResolver,
-			nextHyperlinkInstanceIndex,
-			nextPageBreakRunOwnerId,
-			textBoxAnchors
-		});
-		if (fieldNode) nodes.push(fieldNode);
-	} else if (item.type === "mathEquation") {
-		const mathNode = convertMathEquation(item);
-		if (mathNode) nodes.push(mathNode);
-	} else if (item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") {
-		const nestedMarkType = item.type === "insertion" || item.type === "moveTo" ? "insertion" : "deletion";
-		const nestedMoveKind = item.type === "moveFrom" || item.type === "moveTo" ? item.type : null;
-		nodes.push(...convertTrackedChange(item, nestedMarkType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, nestedMoveKind, textBoxAnchors));
-	} else if (item.type === "bookmarkStart") nodes.push(schema.node("bookmarkBoundary", {
-		type: "start",
-		id: item.id,
-		name: item.name,
-		colFirst: item.colFirst,
-		colLast: item.colLast,
-		displacedByCustomXml: item.displacedByCustomXml
-	}));
-	else if (item.type === "bookmarkEnd") nodes.push(schema.node("bookmarkBoundary", {
-		type: "end",
-		id: item.id,
-		displacedByCustomXml: item.displacedByCustomXml
-	}));
-	else panic(`Unsupported tracked-run content: ${JSON.stringify(item)}`);
+		else if (item.type === "bookmarkEnd") itemNodes.push(schema.node("bookmarkBoundary", {
+			type: "end",
+			id: item.id,
+			displacedByCustomXml: item.displacedByCustomXml
+		}));
+		else if (item.type === "preservedInline") itemNodes.push(preservedInlineNode(item));
+		else panic(`Unsupported tracked-run content: ${JSON.stringify(item)}`);
+		nodes.push(...withInlineWrapperMark(itemNodes, stack));
+	}
 	const mark = schema.marks[markType].create({
 		revisionId: change.info.id,
 		author: change.info.author,
@@ -525,6 +586,7 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 	if (paragraph.listRendering) Object.assign(attrs, listRenderingAttrPatch(paragraph.listRendering));
 	if (formatting) attrs._originalFormatting = formatting;
 	if (paragraph.propertyChanges && paragraph.propertyChanges.length > 0) attrs._propertyChanges = [...paragraph.propertyChanges];
+	if (paragraph.preservedAttributes && paragraph.preservedAttributes.length > 0) attrs._preservedAttributes = paragraph.preservedAttributes;
 	if (paragraph.pPrMark) attrs.pPrMark = paragraph.pPrMark;
 	const set = (key, val) => {
 		if (val !== void 0) attrs[key] = val;
@@ -784,6 +846,7 @@ function calculateRowSpans(table) {
 			const { colIndex: cellColIndex, vMerge, isMergeContinuation, startRow, hasMeaningfulContent } = cellInfo;
 			const key = `${rowIndex}-${cellColIndex}`;
 			if (vMerge === "restart") {
+				closeVerticalMerge(activeMerges, result, cellColIndex);
 				activeMerges.set(cellColIndex, rowIndex);
 				result.set(key, {
 					rowSpan: 1,
@@ -814,7 +877,7 @@ function calculateRowSpans(table) {
 					skip: true
 				});
 			} else {
-				activeMerges.delete(cellColIndex);
+				closeVerticalMerge(activeMerges, result, cellColIndex);
 				result.set(key, {
 					rowSpan: 1,
 					skip: false
@@ -822,19 +885,34 @@ function calculateRowSpans(table) {
 			}
 		}
 	}
+	clearActiveVerticalMerges(activeMerges, result);
 	return result;
 }
+/**
+* End the vertical merge active in one column.
+*
+* A `w:vMerge="restart"` is carried through the editor by its cell's rowspan,
+* which only exists once a continuation joins it. A merge that closes with a
+* rowspan of 1 — a restart with no continuation, one interrupted by a plain
+* cell, one whose continuation is in a row a revision removed — has nothing
+* but this flag to say the cell was a merge origin, and dropping it changes
+* the table's visible structure.
+*/
+function closeVerticalMerge(activeMerges, result, colIndex) {
+	const startRow = activeMerges.get(colIndex);
+	if (startRow === void 0) return;
+	const restartCell = result.get(`${startRow}-${colIndex}`);
+	if (restartCell && restartCell.rowSpan === 1) restartCell.preserveVMergeRestart = true;
+	activeMerges.delete(colIndex);
+}
 function clearActiveVerticalMerges(activeMerges, result) {
-	for (const [colIndex, startRow] of activeMerges) {
-		const restartCell = result.get(`${startRow}-${colIndex}`);
-		if (restartCell) restartCell.preserveVMergeRestart = true;
-	}
-	activeMerges.clear();
+	for (const colIndex of [...activeMerges.keys()]) closeVerticalMerge(activeMerges, result, colIndex);
 }
 function tableCellHasMeaningfulContent(cell) {
 	return cell.content.some(blockHasMeaningfulContent);
 }
 function blockHasMeaningfulContent(block) {
+	if (block.type === "preservedBlock") return true;
 	if (block.type === "table") return block.rows.some((row) => row.cells.some((cell) => tableCellHasMeaningfulContent(cell)));
 	return block.content.some(paragraphContentHasMeaningfulContent);
 }
@@ -846,12 +924,11 @@ function paragraphContentHasMeaningfulContent(content) {
 }
 function convertTable(table, styleResolver, context) {
 	for (const row of table.rows) for (const cell of row.cells) {
-		if (isCellMergeContinuation(cell) && context.pageBreakRunSourceDescendants.containsPageBreakRun(cell.content)) throw new UnsupportedDocxToProseMirrorConversionError({
-			message: `${PAGE_BREAK_CONTAINER_DESCRIPTIONS["table-cell"]} cannot be represented in the editor model`,
-			owner: "table-cell",
-			contentType: "break"
-		});
-		assertSourceContainerHasNoPageBreakRun(cell.content, "table-cell", context.pageBreakRunSourceDescendants);
+		if (isCellMergeContinuation(cell) && context.pageBreakRunSourceDescendants.containsPageBreakRun(cell.content)) {
+			context.warnPageBreakProjection("A page break inside a vertically merged table cell paginates with the merged row");
+			continue;
+		}
+		reportSourceContainerPageBreakRun(cell.content, "table-cell", context.pageBreakRunSourceDescendants, context.warnPageBreakProjection);
 	}
 	const rowSpanMap = calculateRowSpans(table);
 	const columnWidths = table.columnWidths;
@@ -957,6 +1034,7 @@ function convertTableRow(row, styleResolver, context, isHeaderRow, columnWidths,
 	if (resolvedJustification) attrsWithoutStructuralChange._resolvedJustification = resolvedJustification;
 	if (row.formatting) attrsWithoutStructuralChange._originalFormatting = row.formatting;
 	if (row.propertyChanges && row.propertyChanges.length > 0) attrsWithoutStructuralChange.trPrChange = [...row.propertyChanges];
+	if (row.preservedAttributes && row.preservedAttributes.length > 0) attrsWithoutStructuralChange._preservedAttributes = row.preservedAttributes;
 	let attrs = attrsWithoutStructuralChange;
 	const rowStructuralChange = row.structuralChange;
 	if (rowStructuralChange) {
@@ -1153,13 +1231,23 @@ function convertTableCell({ cell, styleResolver, context, isHeader, gridWidthPer
 	if (preserveVMergeRestart) attrs._preserveVMergeRestart = true;
 	if (vMergeContinuationCells && vMergeContinuationCells.length > 0) attrs._docxVMergeContinuationCells = transportTableCellsWithParagraphPropertySources(vMergeContinuationCells);
 	const contentNodes = [];
-	for (const content of cell.content) if (content.type === "paragraph") contentNodes.push(...convertParagraphWithTextBoxes(content, styleResolver, {
-		textBoxGroupId: context.nextTextBoxGroupId(),
-		context,
-		...conditionalStyle?.rPr !== void 0 ? { extraRunFormatting: conditionalStyle.rPr } : {},
-		...conditionalStyle?.pPr !== void 0 ? { tableParagraphOverlay: conditionalStyle.pPr } : {}
-	}));
-	else contentNodes.push(convertTable(content, styleResolver, context));
+	for (const content of cell.content) switch (content.type) {
+		case "paragraph":
+			contentNodes.push(...convertParagraphWithTextBoxes(content, styleResolver, {
+				textBoxGroupId: context.nextTextBoxGroupId(),
+				context,
+				...conditionalStyle?.rPr !== void 0 ? { extraRunFormatting: conditionalStyle.rPr } : {},
+				...conditionalStyle?.pPr !== void 0 ? { tableParagraphOverlay: conditionalStyle.pPr } : {}
+			}));
+			break;
+		case "table":
+			contentNodes.push(convertTable(content, styleResolver, context));
+			break;
+		case "preservedBlock":
+			contentNodes.push(convertPreservedBlock(content));
+			break;
+		default: panic(`Unsupported table cell content: ${JSON.stringify(content)}`);
+	}
 	if (contentNodes.length === 0) contentNodes.push(schema.node("paragraph", {}, []));
 	const nodeType = isHeader ? "tableHeader" : "tableCell";
 	return schema.node(nodeType, attrs, contentNodes);
@@ -1168,7 +1256,7 @@ function standaloneTableCellToProseMirror(cell, nodeType) {
 	const nextTextBoxGroupId = createTextBoxGroupIdFactory();
 	const nextHyperlinkInstanceIndex = createHyperlinkInstanceIndexAllocator();
 	const pageBreakRunSourceDescendants = buildPageBreakRunSourceDescendantIndex(cell.content);
-	assertSourceContainerHasNoPageBreakRun(cell.content, "table-cell", pageBreakRunSourceDescendants);
+	reportSourceContainerPageBreakRun(cell.content, "table-cell", pageBreakRunSourceDescendants, noPageBreakProjectionWarning);
 	return convertTableCell({
 		cell,
 		styleResolver: null,
@@ -1177,7 +1265,10 @@ function standaloneTableCellToProseMirror(cell, nodeType) {
 			nextTextBoxGroupId,
 			nextHyperlinkInstanceIndex,
 			pairedBookmarkIds: collectPairedBookmarkIds(cell.content),
-			pageBreakRunSourceDescendants
+			pageBreakRunSourceDescendants,
+			storyRangedCommentIds: rangedCommentIds(cell.content),
+			openCommentIds: /* @__PURE__ */ new Set(),
+			warnPageBreakProjection: noPageBreakProjectionWarning
 		},
 		isHeader: nodeType === "tableHeader",
 		gridWidthPercent: void 0,
@@ -1195,15 +1286,7 @@ function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyp
 	let fieldFormatting;
 	let fieldPropertyChanges;
 	const inlineNodes = [];
-	const runHasPageBreak = (run) => run.content.some((content) => content.type === "break" && content.breakType === "page");
-	if (field.type === "complexField" && field.fieldCode.some(runHasPageBreak)) throw new UnsupportedDocxToProseMirrorConversionError({
-		message: "A complex-field instruction containing an explicit page break cannot be represented in the editor model",
-		owner: "complex-field-instruction",
-		contentType: "break"
-	});
-	const hasPageBreakContent = field.type === "simpleField" ? field.content.some((content) => content.type === "run" ? runHasPageBreak(content) : content.children.some((child) => child.type === "run" && runHasPageBreak(child))) : field.fieldResult.some(runHasPageBreak);
-	if (hasPageBreakContent) assertPageBreakFieldResultIsRepresentable(field);
-	const hasStructuredSourceContent = hasPageBreakContent || field.type === "simpleField" && field.content.some((content) => content.type === "hyperlink");
+	const hasStructuredSourceContent = fieldResultHasPageBreakContent(field) || field.type === "simpleField" && field.content.some((content) => content.type === "hyperlink" || content.type === "preservedInline");
 	const appendRun = (run) => {
 		for (const content of run.content) if (content.type === "text") displayText += content.text;
 		fieldFormatting ??= run.formatting;
@@ -1216,6 +1299,10 @@ function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyp
 			appendRun(content);
 			continue;
 		}
+		if (content.type === "preservedInline") {
+			inlineNodes.push(preservedInlineNode(content));
+			continue;
+		}
 		for (const child of content.children) if (child.type === "run") {
 			for (const runContent of child.content) if (runContent.type === "text") displayText += runContent.text;
 			fieldFormatting ??= child.formatting;
@@ -1234,36 +1321,64 @@ function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyp
 	const inheritedFormatting = getInheritedRunFormatting(fieldFormatting, field.fieldType);
 	const { marks } = buildRunMarks(fieldFormatting, inheritedFormatting, styleResolver);
 	const hasConvertedHyperlinkContent = inlineNodes.some((node) => node.marks.some((mark) => mark.type.name === "hyperlink"));
-	const createStructuredField = inlineNodes.some((node) => node.type.name === "pageBreakRun") || hasStructuredSourceContent && hasConvertedHyperlinkContent;
+	const hasConvertedPageBreakContent = inlineNodes.some((node) => node.type.name === "pageBreakRun");
+	const hasConvertedPreservedContent = inlineNodes.some((node) => node.type.name === "preservedXml");
+	const createStructuredField = hasConvertedPageBreakContent || hasConvertedPreservedContent || hasStructuredSourceContent && hasConvertedHyperlinkContent;
 	if (!createStructuredField && fieldPropertyChanges && fieldPropertyChanges.length > 0) marks.push(schema.mark("runPropertyChange", { changes: [...fieldPropertyChanges] }));
 	return schema.node(createStructuredField ? "structuredField" : "field", {
 		fieldType: field.fieldType,
 		instruction: field.instruction,
 		displayText,
 		fieldKind: field.type === "simpleField" ? "simple" : "complex",
-		fldLock: field.fldLock ?? false,
-		dirty: field.dirty ?? false
+		fldLock: field.fldLock ?? null,
+		dirty: field.dirty ?? null
 	}, createStructuredField ? inlineNodes : void 0, marks);
 }
 /**
-* Convert a MathEquation to a ProseMirror math node.
+* Lift the transparent wrappers out of an inline content list, remembering for
+* each item which wrappers it sat inside.
+*
+* The tree becomes one sequence because every inline loop below narrows by a
+* chain of `else if` rather than by exhaustion, and a wrapper left in it would
+* reach whichever branch happens to be last. What the wrapper said is not lost
+* with the tree: it rides the `inlineWrapper` mark on the leaves it held, and
+* ProseMirror maintains that range across edits instead of an index.
+*
+* It is applied to the content of whatever holds the wrapper, never around it:
+* a wrapper inside a revision or a content control is lifted inside that
+* wrapper, so its runs keep the revision mark or the control they were
+* authored under.
 */
+const withInlineWrapperStacks = (content, stack = []) => content.flatMap((item) => item.type === "inlineWrapper" ? withInlineWrapperStacks(item.content, [...stack, inlineWrapperLayer(item)]) : [{
+	content: item,
+	stack
+}]);
 /**
-* Flatten `w:bdo`/`w:dir` out of an inline content list.
+* `nodes` with `stack` recorded outside whatever wrapper they already carry.
 *
-* The editor has no projection for a bidirectional wrapper yet, and the
-* alternative to flattening it is worse than losing the direction: every
-* inline loop below narrows by a chain of `else if` rather than by
-* exhaustion, so an unhandled member reaches whichever branch happens to be
-* last and is read as that. Flattening keeps the wrapper's content and loses
-* only its direction, which the survival census records as an
-* editor-projection loss until the mark that carries it exists.
+* A revision converts its own content first, so a node that arrives here
+* already marked sat inside the item this stack wraps: the two stacks
+* concatenate, outermost first. Concatenating is what the schema forces — the
+* mark excludes itself, so a second one replaces the first, and the inner
+* wrapper would be the one lost.
 *
-* The save path is unaffected: a document opened and saved without being
-* edited replays its markup, and one that is edited keeps the wrapper because
-* `fromProseDoc` rebuilds from the source paragraph.
+* A node that holds its own leaves, a content control, is marked here as the
+* one node it is; its leaves were marked with the whole enclosing stack when
+* it was built, because the painter reads the wrapper off the leaf.
+*/
+const withInlineWrapperMark = (nodes, stack) => {
+	const markType = schema.marks["inlineWrapper"];
+	if (stack.length === 0 || !markType) return nodes;
+	return nodes.map((node) => {
+		if (!node.isText && (!node.isInline || !node.type.allowsMarkType(markType))) return node;
+		const inner = node.marks.find((mark) => mark.type === markType);
+		const layers = inner === void 0 ? stack : [...stack, ...expectInlineWrapperMarkAttrs(inner).stack];
+		return node.mark(markType.create({ stack: layers }).addToSet(node.marks));
+	});
+};
+/**
+* Convert a MathEquation to a ProseMirror math node.
 */
-const withoutBidiWrappers = (content) => content.flatMap((item) => item.type === "bidiWrapper" ? withoutBidiWrappers(item.content) : [item]);
 function convertMathEquation(math) {
 	return schema.node("math", {
 		display: math.display,
@@ -1273,54 +1388,66 @@ function convertMathEquation(math) {
 }
 /**
 * Convert an InlineSdt to a ProseMirror sdt node with inline content.
+*
+* `wrappedBy` is the stack the control itself sits inside. The control holds
+* its own leaves, so nothing outside can mark them afterwards: the caller's
+* stack has to reach them here, under the wrappers written inside the control.
 */
-function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors) {
+function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors, wrappedBy = []) {
 	const props = sdt.properties;
 	const inlineNodes = [];
-	for (const content of sdt.content) switch (content.type) {
-		case "run":
-			inlineNodes.push(...convertRun(content, getInheritedRunFormatting(content.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
-			break;
-		case "hyperlink": {
-			const currentHyperlinkIndex = nextHyperlinkInstanceIndex();
-			inlineNodes.push(...convertHyperlink(content, {
-				getInheritedRunFormatting,
-				styleResolver,
-				hyperlinkIndex: currentHyperlinkIndex,
-				textBoxAnchors,
-				nextPageBreakRunOwnerId
-			}));
-			break;
-		}
-		case "simpleField":
-		case "complexField": {
-			const fieldNode = convertField(content, {
-				getInheritedRunFormatting,
-				styleResolver,
-				nextHyperlinkInstanceIndex,
-				nextPageBreakRunOwnerId,
-				textBoxAnchors
-			});
-			if (fieldNode) inlineNodes.push(fieldNode);
-			break;
-		}
-		case "inlineSdt": {
-			const nestedSdt = convertInlineSdt(content, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors);
-			if (nestedSdt) inlineNodes.push(nestedSdt);
-			break;
-		}
-		case "insertion":
-		case "deletion":
-		case "moveTo":
-		case "moveFrom":
-			inlineNodes.push(...convertTrackedChange(content, content.type === "insertion" || content.type === "moveTo" ? "insertion" : "deletion", nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, content.type === "moveTo" || content.type === "moveFrom" ? content.type : null, textBoxAnchors));
-			break;
-		case "mathEquation": {
-			const mathNode = convertMathEquation(content);
-			if (mathNode) inlineNodes.push(mathNode);
-			break;
+	for (const { content, stack } of withInlineWrapperStacks(sdt.content, wrappedBy)) {
+		if (!isInlineSdtContent(content)) continue;
+		const itemNodes = [];
+		switch (content.type) {
+			case "run":
+				itemNodes.push(...convertRun(content, getInheritedRunFormatting(content.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
+				break;
+			case "hyperlink": {
+				const currentHyperlinkIndex = nextHyperlinkInstanceIndex();
+				itemNodes.push(...convertHyperlink(content, {
+					getInheritedRunFormatting,
+					styleResolver,
+					hyperlinkIndex: currentHyperlinkIndex,
+					textBoxAnchors,
+					nextPageBreakRunOwnerId
+				}));
+				break;
+			}
+			case "simpleField":
+			case "complexField": {
+				const fieldNode = convertField(content, {
+					getInheritedRunFormatting,
+					styleResolver,
+					nextHyperlinkInstanceIndex,
+					nextPageBreakRunOwnerId,
+					textBoxAnchors
+				});
+				if (fieldNode) itemNodes.push(fieldNode);
+				break;
+			}
+			case "inlineSdt": {
+				const nestedSdt = convertInlineSdt(content, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors, stack);
+				if (nestedSdt) itemNodes.push(nestedSdt);
+				break;
+			}
+			case "insertion":
+			case "deletion":
+			case "moveTo":
+			case "moveFrom":
+				itemNodes.push(...convertTrackedChange(content, content.type === "insertion" || content.type === "moveTo" ? "insertion" : "deletion", nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, content.type === "moveTo" || content.type === "moveFrom" ? content.type : null, textBoxAnchors));
+				break;
+			case "mathEquation": {
+				const mathNode = convertMathEquation(content);
+				if (mathNode) itemNodes.push(mathNode);
+				break;
+			}
+			case "preservedInline":
+				itemNodes.push(preservedInlineNode(content));
+				break;
+			default: panic(`Unsupported inline SDT content: ${JSON.stringify(content)}`);
 		}
-		default: panic(`Unsupported inline SDT content: ${JSON.stringify(content)}`);
+		inlineNodes.push(...withInlineWrapperMark(itemNodes, stack));
 	}
 	return schema.node("sdt", sdtAttrsFromProperties(props), inlineNodes.length > 0 ? inlineNodes : void 0);
 }
@@ -1331,7 +1458,6 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextPageBreakRunOwner
 * @param resolvedStyleFormatting - Paragraph formatting and its explicit style-toggle state
 */
 function convertRun(run, resolvedStyleFormatting, nextPageBreakRunOwnerId, styleResolver, textBoxAnchors) {
-	assertPageBreakSourceRunIsRepresentable(run);
 	const nodes = [];
 	const { marks, mergedFormatting } = buildRunMarks(run.formatting, resolvedStyleFormatting, styleResolver);
 	if (run.propertyChanges && run.propertyChanges.length > 0) marks.push(schema.mark("runPropertyChange", { changes: [...run.propertyChanges] }));
@@ -1342,28 +1468,35 @@ function convertRun(run, resolvedStyleFormatting, nextPageBreakRunOwnerId, style
 	}
 	return nodes;
 }
-function assertPageBreakSourceRunIsRepresentable(run) {
-	if (!run.content.some((content) => content.type === "break" && content.breakType === "page")) return;
-	assertRunContentIsRepresentableBesidePageBreak(run, "page-break-bearing-run");
+const runHasPageBreakContent = (run) => run.content.some((content) => content.type === "break" && content.breakType === "page");
+/**
+* Whether a field's result holds an explicit page break.
+*
+* `convertField` re-cuts the whole result into a structured field when it
+* does, so this answers both who gets re-cut and who gets reported. One
+* predicate for the two, because a reporter that disagreed with the converter
+* would name a loss nobody suffered.
+*/
+const fieldResultHasPageBreakContent = (field) => field.type === "simpleField" ? field.content.some((content) => {
+	switch (content.type) {
+		case "run": return runHasPageBreakContent(content);
+		case "hyperlink": return content.children.some((child) => child.type === "run" && runHasPageBreakContent(child));
+		case "preservedInline": return false;
+		default: panic(`Unsupported simple-field content: ${JSON.stringify(content)}`);
+	}
+}) : field.fieldResult.some(runHasPageBreakContent);
+function reportPageBreakSourceRunContent(run, warn) {
+	if (!runHasPageBreakContent(run)) return;
+	reportRunContentBesidePageBreak(run, "page-break-bearing-run", warn);
 }
 const PAGE_BREAK_CONTAINER_DESCRIPTIONS = {
-	"table-cell": "A table cell containing an explicit page break",
-	"text-box": "A text box containing an explicit page break"
-};
-const PAGE_BREAK_PARAGRAPH_OWNERS = {
-	borders: "paragraph-borders",
-	frame: "paragraph-frame",
-	outline: "paragraph-outline",
-	textBoxAnchor: "paragraph-text-box-anchor"
+	"table-cell": "An interior page break in a table cell does not paginate the cell; its row moves as a unit",
+	"text-box": "A page break inside a text box does not paginate the text box"
 };
-function assertSourceContainerHasNoPageBreakRun(content, owner, sourceDescendants) {
+function reportSourceContainerPageBreakRun(content, owner, sourceDescendants, warn) {
 	if (!sourceDescendants.containsPageBreakRun(content)) return;
 	if (owner === "table-cell" && hasSingleLeadingTableCellPageBreak(content, sourceDescendants)) return;
-	throw new UnsupportedDocxToProseMirrorConversionError({
-		message: `${PAGE_BREAK_CONTAINER_DESCRIPTIONS[owner]} cannot be represented in the editor model`,
-		owner,
-		contentType: "break"
-	});
+	warn(PAGE_BREAK_CONTAINER_DESCRIPTIONS[owner]);
 }
 /**
 * A page break opening a cell advances the whole row during pagination.
@@ -1404,7 +1537,7 @@ const scanLeadingPageBreakContent = (content, scan) => {
 		case "moveFrom":
 		case "moveTo":
 		case "inlineSdt":
-		case "bidiWrapper":
+		case "inlineWrapper":
 			for (const child of content.content) scanLeadingPageBreakContent(child, scan);
 			return;
 		case "simpleField":
@@ -1423,6 +1556,7 @@ const scanLeadingPageBreakContent = (content, scan) => {
 		case "moveToRangeEnd": return;
 		case "commentReference":
 		case "mathEquation":
+		case "preservedInline":
 			if (scan.pageBreaks === 0) scan.contentBeforeBreak = true;
 			return;
 		default: return content;
@@ -1441,64 +1575,103 @@ const hasSingleLeadingParagraphPageBreak = (paragraph) => {
 	const scan = scanParagraphPageBreaks(paragraph);
 	return !scan.contentBeforeBreak && scan.pageBreaks === 1;
 };
-function assertParagraphPageBreakCanBeProjected({ paragraph, attrs, effectiveFrame, sourceDescendants }) {
+function reportParagraphPageBreakProjection({ paragraph, attrs, effectiveFrame, sourceDescendants, warn }) {
 	const sourceFeatures = sourceDescendants.paragraphFeatures(paragraph);
 	if (!sourceFeatures.hasPageBreakRun) return;
+	reportParagraphPageBreakRunContent(paragraph, warn);
 	const disposition = pageBreakRunParagraphProjectionDispositionForFeatures({
 		attrs,
 		effectiveFrame,
 		textBoxAnchorAfterPageBreak: sourceFeatures.hasTextBoxShape && !sourceFeatures.pageBreakSharesTextBoxShape && scanParagraphPageBreaks(paragraph).textBoxShapeAfterBreak
 	});
-	if (disposition.status === "supported") return;
+	if (disposition.status === "exact") return;
 	if (disposition.reason !== "textBoxAnchor" && hasSingleLeadingParagraphPageBreak(paragraph)) return;
-	throw new UnsupportedDocxToProseMirrorConversionError({
-		message: disposition.message,
-		owner: PAGE_BREAK_PARAGRAPH_OWNERS[disposition.reason],
-		contentType: "break"
-	});
+	warn(disposition.message);
 }
-function assertPageBreakFieldResultIsRepresentable(field) {
-	if (field.type === "complexField") {
-		for (const run of field.fieldResult) assertRunContentIsRepresentableBesidePageBreak(run, "field-result");
-		return;
-	}
-	for (const content of field.content) {
-		if (content.type === "run") {
-			assertRunContentIsRepresentableBesidePageBreak(content, "field-result");
-			continue;
+/**
+* Report every run-level loss a paragraph's page breaks bring with them.
+*
+* One walk of the paragraph rather than a check at each `convertRun` and
+* `convertField`: the reporter is a conversion-wide fact, and a per-call-site
+* check would have to be threaded through every nested converter to reach it.
+*/
+function reportParagraphPageBreakRunContent(paragraph, warn) {
+	const visitField = (field) => {
+		if (field.type === "complexField") {
+			if (field.fieldCode.some(runHasPageBreakContent)) warn("A complex-field instruction holds an explicit page break");
+			if (!fieldResultHasPageBreakContent(field)) return;
+			for (const run of field.fieldResult) reportRunContentBesidePageBreak(run, "field-result", warn);
+			return;
 		}
-		for (const child of content.children) if (child.type === "run") assertRunContentIsRepresentableBesidePageBreak(child, "field-result");
-	}
+		if (!fieldResultHasPageBreakContent(field)) return;
+		for (const content of field.content) {
+			if (content.type === "run") {
+				reportRunContentBesidePageBreak(content, "field-result", warn);
+				continue;
+			}
+			if (content.type !== "hyperlink") continue;
+			for (const child of content.children) if (child.type === "run") reportRunContentBesidePageBreak(child, "field-result", warn);
+		}
+	};
+	const visitContent = (content) => {
+		switch (content.type) {
+			case "run":
+				reportPageBreakSourceRunContent(content, warn);
+				return;
+			case "hyperlink":
+				for (const child of content.children) if (child.type === "run") reportPageBreakSourceRunContent(child, warn);
+				return;
+			case "simpleField":
+			case "complexField":
+				visitField(content);
+				return;
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo":
+			case "inlineSdt":
+			case "inlineWrapper":
+				for (const child of content.content) visitContent(child);
+				return;
+			default: return;
+		}
+	};
+	for (const content of paragraph.content) visitContent(content);
 }
 const PAGE_BREAK_OWNER_DESCRIPTIONS = {
 	"field-result": "A field result with an explicit page break",
 	"page-break-bearing-run": "A page-break-bearing run"
 };
-const unsupportedPageBreakContent = (owner, contentType) => {
-	const description = contentType === "shape" ? "a text-box shape" : contentType;
-	throw new UnsupportedDocxToProseMirrorConversionError({
-		message: `${PAGE_BREAK_OWNER_DESCRIPTIONS[owner]} containing ${description} cannot be represented in the editor model`,
-		owner,
-		contentType
-	});
-};
-function assertRunContentIsRepresentableBesidePageBreak(run, owner) {
+/**
+* Record what a page-break-bearing run loses when the editor re-cuts it.
+*
+* The run is split into one node per inline atom and rebuilt from the
+* `pageBreakRunOwner` mark, and the kinds below have no node of their own:
+* a hyphen returns as its character, a field character or instruction leaves
+* no trace, and a text-box shape is hoisted to its own block. Every one of
+* those losses is what the same run suffers with no page break in it, so
+* refusing the document here declined to open a file folio otherwise reads.
+*/
+function reportRunContentBesidePageBreak(run, owner, warn) {
 	for (const content of run.content) switch (content.type) {
 		case "break":
 		case "drawing":
 		case "endnoteRef":
 		case "footnoteRef":
+		case "preservedXml":
 		case "renderedPageBreak":
 		case "symbol":
 		case "tab":
 		case "text": continue;
 		case "shape":
-			if (content.shape.textBody) unsupportedPageBreakContent(owner, content.type);
+			if (content.shape.textBody) warn(`${PAGE_BREAK_OWNER_DESCRIPTIONS[owner]} also holds a text-box shape`);
 			continue;
 		case "fieldChar":
 		case "instrText":
 		case "noBreakHyphen":
-		case "softHyphen": return unsupportedPageBreakContent(owner, content.type);
+		case "softHyphen":
+			warn(`${PAGE_BREAK_OWNER_DESCRIPTIONS[owner]} also holds ${content.type}`);
+			continue;
 		default: panic(`Unsupported page-break-bearing run content: ${JSON.stringify(content)}`);
 	}
 }
@@ -1746,6 +1919,11 @@ function convertRunContent(content, marks, formatting, textBoxAnchors, authoredF
 		}
 		case "fieldChar":
 		case "instrText": return [];
+		case "preservedXml": return [schema.node("preservedXml", {
+			xml: content.xml,
+			text: content.text,
+			level: PRESERVED_XML_LEVELS.run
+		}).mark(marks)];
 		case "noBreakHyphen": return [schema.text("‑", marks)];
 		case "softHyphen": return [schema.text("­", marks)];
 		case "symbol": return [schema.node("symbol", {
@@ -1758,6 +1936,18 @@ function withRunBoundaryMarks(node, marks) {
 	if (!marks.some(({ type }) => type.name === "hyperlink" || type.name === "pageBreakRunOwner")) return node;
 	return node.mark(marks);
 }
+/**
+* The authored-EMU carrier for a drawing, or nothing when the source authored
+* none of these values and there is accordingly nothing to carry.
+*/
+const authoredEmuAttrs = (values) => Object.values(values).some((value) => value !== void 0) ? values : void 0;
+/** The wrap insets of a drawing, keyed by the pixel attribute each becomes. */
+const wrapDistanceEmu = (wrap) => ({
+	distTop: wrap?.distT,
+	distBottom: wrap?.distB,
+	distLeft: wrap?.distL,
+	distRight: wrap?.distR
+});
 function convertImage({ image, rawXml, rawXmlMode, rawImageFingerprint, runFormatting }) {
 	const imageSize = image.size;
 	const widthPx = imageSize?.width ? emuToPixels(imageSize.width) : void 0;
@@ -1781,14 +1971,7 @@ function convertImage({ image, rawXml, rawXmlMode, rawImageFingerprint, runForma
 	else if (wrapType === "behind" || wrapType === "inFront") displayMode = "float";
 	else if (cssFloat !== "none") displayMode = "float";
 	else displayMode = "block";
-	let transform;
-	if (image.transform) {
-		const transforms = [];
-		if (image.transform.rotation) transforms.push(`rotate(${image.transform.rotation}deg)`);
-		if (image.transform.flipH) transforms.push("scaleX(-1)");
-		if (image.transform.flipV) transforms.push("scaleY(-1)");
-		if (transforms.length > 0) transform = transforms.join(" ");
-	}
+	const transformAttrs = authoredTransformAttrs(image.transform);
 	const distTop = image.wrap.distT != null ? emuToPixels(image.wrap.distT) : void 0;
 	const distBottom = image.wrap.distB != null ? emuToPixels(image.wrap.distB) : void 0;
 	const distLeft = image.wrap.distL != null ? emuToPixels(image.wrap.distL) : void 0;
@@ -1813,7 +1996,7 @@ function convertImage({ image, rawXml, rawXmlMode, rawImageFingerprint, runForma
 	let borderColor;
 	let borderStyle;
 	if (image.outline && image.outline.width) {
-		borderWidth = Math.round(image.outline.width / 914400 * 96 * 100) / 100;
+		borderWidth = emuToStrokePixels(image.outline.width);
 		if (image.outline.color?.rgb) borderColor = `#${image.outline.color.rgb}`;
 		borderStyle = image.outline.style ? {
 			solid: "solid",
@@ -1840,8 +2023,10 @@ function convertImage({ image, rawXml, rawXmlMode, rawImageFingerprint, runForma
 		wrapType,
 		displayMode,
 		cssFloat,
-		transform,
+		...transformAttrs,
 		opacity: image.opacity,
+		brightness: image.effects?.brightness,
+		contrast: image.effects?.contrast,
 		distTop,
 		distBottom,
 		distLeft,
@@ -1856,8 +2041,17 @@ function convertImage({ image, rawXml, rawXmlMode, rawImageFingerprint, runForma
 		paddingLeft: image.padding?.left,
 		position,
 		layoutInCell: image.layoutInCell,
+		decorative: image.decorative,
+		hidden: image.hidden,
+		docPrExtensions: image.docPrExtensions ? [...image.docPrExtensions] : void 0,
 		frameLocks: image.frameLocks ? { ...image.frameLocks } : void 0,
 		borderWidth,
+		_docxAuthoredEmu: authoredEmuAttrs({
+			width: imageSize?.width,
+			height: imageSize?.height,
+			borderWidth: image.outline?.width,
+			...wrapDistanceEmu(image.wrap)
+		}),
 		borderColor,
 		borderStyle,
 		wrapText,
@@ -1899,8 +2093,11 @@ function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver,
 			}, void 0, [linkMark]));
 			continue;
 		}
+		if (child.type === "preservedInline") {
+			nodes.push(preservedInlineNode(child).mark([linkMark]));
+			continue;
+		}
 		if (child.type === "run") {
-			assertPageBreakSourceRunIsRepresentable(child);
 			const inheritedFormatting = getInheritedRunFormatting(child.formatting);
 			const { marks: runMarks, mergedFormatting } = buildRunMarks(child.formatting, inheritedFormatting, styleResolver);
 			if (child.propertyChanges && child.propertyChanges.length > 0) runMarks.push(schema.mark("runPropertyChange", { changes: [...child.propertyChanges] }));
@@ -1946,27 +2143,22 @@ function convertShape(shape, runFormatting) {
 	let outlineColorValue;
 	let outlineStyle = "none";
 	let outlineCap;
+	let outlineJoin;
 	let outlineHeadEnd;
 	let outlineTailEnd;
 	if (shape.outline) {
-		if (shape.outline.width) outlineWidth = Math.round(shape.outline.width / 914400 * 96 * 100) / 100;
+		if (shape.outline.width) outlineWidth = emuToStrokePixels(shape.outline.width);
 		if (shape.outline.color) {
 			outlineColorValue = shape.outline.color;
 			outlineColor = resolveColorValueToHex(shape.outline.color);
 		}
-		outlineStyle = shape.outline.style || "solid";
+		outlineStyle = shape.outline.style;
 		outlineCap = shape.outline.cap;
+		outlineJoin = shape.outline.join;
 		outlineHeadEnd = shape.outline.headEnd;
 		outlineTailEnd = shape.outline.tailEnd;
 	} else outlineWidth = 0;
-	let transform;
-	if (shape.transform) {
-		const transforms = [];
-		if (shape.transform.rotation) transforms.push(`rotate(${shape.transform.rotation}deg)`);
-		if (shape.transform.flipH) transforms.push("scaleX(-1)");
-		if (shape.transform.flipV) transforms.push("scaleY(-1)");
-		if (transforms.length > 0) transform = transforms.join(" ");
-	}
+	const transformAttrs = authoredTransformAttrs(shape.transform);
 	const wrapType = shape.wrap?.type ?? "inline";
 	const displayMode = wrapType === "inline" ? "inline" : "float";
 	let cssFloat = "none";
@@ -1990,8 +2182,17 @@ function convertShape(shape, runFormatting) {
 		shapeType: shapeAttrs.shapeType ?? "rect",
 		geometryAdjustments: shape.geometryAdjustments === void 0 ? void 0 : JSON.stringify(shape.geometryAdjustments),
 		shapeId: shape.id,
+		shapeName: shape.name,
+		alt: shape.alt,
+		title: shape.title,
 		width: widthPx,
 		height: heightPx,
+		_docxAuthoredEmu: authoredEmuAttrs({
+			width: shapeSize?.width,
+			height: shapeSize?.height,
+			outlineWidth: shape.outline?.width,
+			...wrapDistanceEmu(shape.wrap)
+		}),
 		fillColor,
 		fillColorValue,
 		fillType,
@@ -2003,9 +2204,10 @@ function convertShape(shape, runFormatting) {
 		outlineColorValue,
 		outlineStyle,
 		outlineCap,
+		outlineJoin,
 		outlineHeadEnd,
 		outlineTailEnd,
-		transform,
+		...transformAttrs,
 		displayMode,
 		cssFloat,
 		wrapType,
@@ -2019,18 +2221,20 @@ function convertShape(shape, runFormatting) {
 }
 function convertParagraphWithTextBoxes(block, styleResolver, { textBoxGroupId, context, extraRunFormatting, preserveEmptyWrapper, tableParagraphOverlay }) {
 	const { textBoxes, textBoxAnchors } = extractTextBoxesFromParagraph(block, textBoxGroupId);
-	const pmParagraph = convertParagraph(block, styleResolver, context, void 0, extraRunFormatting, tableParagraphOverlay, textBoxAnchors);
+	const pmParagraph = convertParagraph(block, styleResolver, context, extraRunFormatting, tableParagraphOverlay, textBoxAnchors);
 	const nodes = [];
 	const isEmptyAfterExtraction = textBoxes.length > 0 && !hasContentBesidesTextBoxAnchors(pmParagraph);
 	const keepWrapperParagraph = isEmptyAfterExtraction && (preserveEmptyWrapper === true || hasParagraphBoundaryPayload(block, pmParagraph));
 	if (!isEmptyAfterExtraction || keepWrapperParagraph) nodes.push(pmParagraph);
-	for (const { textBox, anchorId, trackedChange, inlineSdts } of textBoxes) nodes.push(convertTextBox(textBox, styleResolver, {
-		placement: isEmptyAfterExtraction && !keepWrapperParagraph ? "standalone" : "inlineWithPrevious",
+	const standalone = isEmptyAfterExtraction && !keepWrapperParagraph;
+	for (const [index, { textBox, anchorId, trackedChange, inlineSdts }] of textBoxes.entries()) nodes.push(convertTextBox(textBox, styleResolver, {
+		placement: standalone ? "standalone" : "inlineWithPrevious",
 		groupId: textBoxGroupId,
 		anchorId,
 		context,
 		trackedChange,
-		inlineSdts
+		inlineSdts,
+		...standalone && index === 0 && block.preservedAttributes ? { hostPreservedAttributes: block.preservedAttributes } : {}
 	}));
 	return nodes;
 }
@@ -2158,6 +2362,9 @@ function textBoxFromShape(shape, textBody) {
 		content: textBody.content
 	};
 	if (shape.id) textBox.id = shape.id;
+	if (shape.name !== void 0) textBox.name = shape.name;
+	if (shape.alt !== void 0) textBox.alt = shape.alt;
+	if (shape.title !== void 0) textBox.title = shape.title;
 	if (shape.position) textBox.position = shape.position;
 	if (shape.wrap) textBox.wrap = shape.wrap;
 	if (shape.fill) textBox.fill = shape.fill;
@@ -2174,7 +2381,7 @@ function textBoxFromShape(shape, textBody) {
 * Convert a TextBox to a ProseMirror textBox node
 */
 function convertTextBox(textBox, styleResolver, options) {
-	assertSourceContainerHasNoPageBreakRun(textBox.content, "text-box", options.context.pageBreakRunSourceDescendants);
+	reportSourceContainerPageBreakRun(textBox.content, "text-box", options.context.pageBreakRunSourceDescendants, options.context.warnPageBreakProjection);
 	const textBoxSize = textBox.size;
 	const widthPx = textBoxSize?.width ? emuToPixels(textBoxSize.width) : 200;
 	const heightPx = textBoxSize?.height ? emuToPixels(textBoxSize.height) : void 0;
@@ -2184,32 +2391,29 @@ function convertTextBox(textBox, styleResolver, options) {
 	let outlineColor;
 	let outlineStyle;
 	if (textBox.outline && textBox.outline.width) {
-		outlineWidth = Math.round(textBox.outline.width / 914400 * 96 * 100) / 100;
+		outlineWidth = emuToStrokePixels(textBox.outline.width);
 		if (textBox.outline.color?.rgb) outlineColor = `#${textBox.outline.color.rgb}`;
 		outlineStyle = textBox.outline.style || "solid";
 	}
-	let transform;
-	if (textBox.transform) {
-		const transforms = [];
-		if (textBox.transform.rotation) transforms.push(`rotate(${textBox.transform.rotation}deg)`);
-		if (textBox.transform.flipH) transforms.push("scaleX(-1)");
-		if (textBox.transform.flipV) transforms.push("scaleY(-1)");
-		if (transforms.length > 0) transform = transforms.join(" ");
-	}
-	const marginTop = textBox.margins?.top !== void 0 ? emuToPixels(textBox.margins.top) : 4;
-	const marginBottom = textBox.margins?.bottom !== void 0 ? emuToPixels(textBox.margins.bottom) : 4;
-	const marginLeft = textBox.margins?.left !== void 0 ? emuToPixels(textBox.margins.left) : 7;
-	const marginRight = textBox.margins?.right !== void 0 ? emuToPixels(textBox.margins.right) : 7;
+	const transformAttrs = authoredTransformAttrs(textBox.transform);
+	const marginTop = textBox.margins?.top !== void 0 ? emuToPixels(textBox.margins.top) : void 0;
+	const marginBottom = textBox.margins?.bottom !== void 0 ? emuToPixels(textBox.margins.bottom) : void 0;
+	const marginLeft = textBox.margins?.left !== void 0 ? emuToPixels(textBox.margins.left) : void 0;
+	const marginRight = textBox.margins?.right !== void 0 ? emuToPixels(textBox.margins.right) : void 0;
+	const textBoxContext = {
+		...options.context,
+		openCommentIds: /* @__PURE__ */ new Set()
+	};
 	const contentNodes = [];
 	for (const block of textBox.content) {
 		if (block.type === "paragraph") {
 			contentNodes.push(...convertParagraphWithTextBoxes(block, styleResolver, {
-				textBoxGroupId: options.context.nextTextBoxGroupId(),
-				context: options.context
+				textBoxGroupId: textBoxContext.nextTextBoxGroupId(),
+				context: textBoxContext
 			}));
 			continue;
 		}
-		contentNodes.push(convertTable(block, styleResolver, options.context));
+		contentNodes.push(convertTable(block, styleResolver, textBoxContext));
 	}
 	if (contentNodes.length === 0) contentNodes.push(schema.node("paragraph", {}, []));
 	const wrapType = textBox.wrap?.type;
@@ -2243,23 +2447,36 @@ function convertTextBox(textBox, styleResolver, options) {
 	else if (wrapType === "behind" || wrapType === "inFront") displayMode = "float";
 	else if (cssFloat !== "none") displayMode = "float";
 	else displayMode = "block";
-	const distTop = textBox.wrap?.distT ? emuToPixels(textBox.wrap.distT) : void 0;
-	const distBottom = textBox.wrap?.distB ? emuToPixels(textBox.wrap.distB) : void 0;
-	const distLeft = textBox.wrap?.distL ? emuToPixels(textBox.wrap.distL) : void 0;
-	const distRight = textBox.wrap?.distR ? emuToPixels(textBox.wrap.distR) : void 0;
+	const distTop = textBox.wrap?.distT !== void 0 ? emuToPixels(textBox.wrap.distT) : void 0;
+	const distBottom = textBox.wrap?.distB !== void 0 ? emuToPixels(textBox.wrap.distB) : void 0;
+	const distLeft = textBox.wrap?.distL !== void 0 ? emuToPixels(textBox.wrap.distL) : void 0;
+	const distRight = textBox.wrap?.distR !== void 0 ? emuToPixels(textBox.wrap.distR) : void 0;
 	return schema.node("textBox", {
 		width: widthPx,
 		height: heightPx,
+		_docxAuthoredEmu: authoredEmuAttrs({
+			width: textBoxSize?.width,
+			height: textBoxSize?.height,
+			outlineWidth: textBox.outline?.width,
+			marginTop: textBox.margins?.top,
+			marginBottom: textBox.margins?.bottom,
+			marginLeft: textBox.margins?.left,
+			marginRight: textBox.margins?.right,
+			...wrapDistanceEmu(textBox.wrap)
+		}),
 		autoFit: textBox.autoFit,
 		wordArt: textBox.wordArt,
 		textWrap: textBox.textWrap,
 		verticalAlign: textBox.verticalAlign,
 		textBoxId: textBox.id,
+		textBoxName: textBox.name,
+		alt: textBox.alt,
+		title: textBox.title,
 		fillColor,
 		outlineWidth,
 		outlineColor,
 		outlineStyle,
-		transform,
+		...transformAttrs,
 		marginTop,
 		marginBottom,
 		marginLeft,
@@ -2278,7 +2495,8 @@ function convertTextBox(textBox, styleResolver, options) {
 		_docxAnchorId: options.anchorId,
 		_docxTextBodyContentState: textBox.content.length === 0 ? { type: "source-empty" } : { type: "authored" },
 		_docxTrackedChange: options.trackedChange,
-		_docxInlineSdts: options.inlineSdts.length > 0 ? options.inlineSdts : void 0
+		_docxInlineSdts: options.inlineSdts.length > 0 ? options.inlineSdts : void 0,
+		_preservedAttributes: options.hostPreservedAttributes
 	}, contentNodes);
 }
 /**
@@ -2299,7 +2517,10 @@ function headerFooterToProseDoc(content, options) {
 		nextTextBoxGroupId,
 		nextHyperlinkInstanceIndex: createHyperlinkInstanceIndexAllocator(),
 		pairedBookmarkIds: collectPairedBookmarkIds(content),
-		pageBreakRunSourceDescendants: buildPageBreakRunSourceDescendantIndex(content)
+		pageBreakRunSourceDescendants: buildPageBreakRunSourceDescendantIndex(content),
+		storyRangedCommentIds: rangedCommentIds(content),
+		openCommentIds: /* @__PURE__ */ new Set(),
+		warnPageBreakProjection: pageBreakProjectionWarn(options?.warn)
 	};
 	const convertBlocks = (blocks) => {
 		const out = [];
@@ -2328,6 +2549,9 @@ function headerFooterToProseDoc(content, options) {
 			case "blockSdt":
 				out.push(convertBlockSdt(block, convertBlocks));
 				break;
+			case "preservedBlock":
+				out.push(convertPreservedBlock(block));
+				break;
 			default: panic(`Unsupported block content: ${JSON.stringify(block)}`);
 		}
 		return out;
@@ -2348,4 +2572,4 @@ function createEmptyDoc() {
 	return schema.node("doc", null, [schema.node("paragraph", {}, [])]);
 }
 //#endregion
-export { UnsupportedDocxToProseMirrorConversionError, createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, resolveParagraphDefaultTextFormatting, standaloneTableCellToProseMirror, toProseDoc };
+export { createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, resolveParagraphDefaultTextFormatting, standaloneTableCellToProseMirror, toProseDoc };