@stll/folio-core 0.46.0 → 0.47.0

package/dist/docx/tableParser.js

@@ -1,17 +1,18 @@
 import { NO_MODELLED_ATTRIBUTES, attributeRemainder } from "./attributeRemainder.js";
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
-import { appendBookmarkMarkerToLastParagraphInBlocks, appendBookmarkMarkerToLastParagraphInCells, prependBookmarkMarkersToFirstParagraphInBlocks, prependBookmarkMarkersToFirstParagraphInCell } from "./bookmarkPlacement.js";
 import { parseBorderSpec } from "./borderParser.js";
-import { CAPTURE, OWNED_ELSEWHERE, dispatchChildren, withPreservedChildren } from "./containerChildren.js";
+import { CAPTURE, dispatchChildren, keptUnless, ownedElsewhere, sequencePositions, withPreservedChildren } from "./containerChildren.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { enrichParagraphTextBoxes } from "./paragraphTextBoxEnrichment.js";
-import { FloatingTableXSpecSchema, FloatingTableYSpecSchema, TableCellTextDirectionSchema, narrowEnum } from "./parserEnums.js";
+import { FloatingTableXSpecSchema, FloatingTableYSpecSchema, TableAlignmentSchema, TextDirectionSchema, narrowEnum } from "./parserEnums.js";
+import { captureSdtSiblingMarkers, parseSdtProperties } from "./sdtProperties.js";
 import { parseShading } from "./shadingParser.js";
+import { findChildAnySpelling } from "./strictNames.js";
 import { TABLE_LOOK_FLAGS } from "./tableLook.js";
 import { parsePropertyChangeInfo, parseTrackedChangeInfo } from "./trackedChangeInfo.js";
 import { percentageSpelling, transitionalSlotEncoding } from "./transitionalSpelling.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
-import { cloneElement, findChild, findChildByLocalName, findChildren, getAttribute, getLocalName, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, parseTableMeasurementValue, selectAlternateContentBranch } from "./xmlParser.js";
+import { cloneElement, findChild, findChildren, findWordprocessingChild, getAttribute, getLocalName, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, parseTableMeasurementValue, selectAlternateContentBranch } from "./xmlParser.js";
 //#region src/docx/tableParser.ts
 /**
 * Sanity cap on `w:gridSpan` (and the derived table column count). Word's
@@ -78,9 +79,9 @@ function parseTableBorders(bordersElement) {
 	if (top) borders.top = top;
 	const bottom = parseBorderSpec(findChild(bordersElement, "w", "bottom"));
 	if (bottom) borders.bottom = bottom;
-	const left = parseBorderSpec(findChild(bordersElement, "w", "left") ?? findChild(bordersElement, "w", "start"));
+	const left = parseBorderSpec(findChildAnySpelling(bordersElement, "CT_Border left"));
 	if (left) borders.left = left;
-	const right = parseBorderSpec(findChild(bordersElement, "w", "right") ?? findChild(bordersElement, "w", "end"));
+	const right = parseBorderSpec(findChildAnySpelling(bordersElement, "CT_Border right"));
 	if (right) borders.right = right;
 	const insideH = parseBorderSpec(findChild(bordersElement, "w", "insideH"));
 	if (insideH) borders.insideH = insideH;
@@ -112,9 +113,9 @@ function parseCellMargins(marginsElement) {
 	if (top) margins.top = top;
 	const bottom = parseWidth(findChild(marginsElement, "w", "bottom"));
 	if (bottom) margins.bottom = bottom;
-	const left = parseWidth(findChild(marginsElement, "w", "left") ?? findChild(marginsElement, "w", "start"));
+	const left = parseWidth(findChildAnySpelling(marginsElement, "CT_TblWidth left"));
 	if (left) margins.left = left;
-	const right = parseWidth(findChild(marginsElement, "w", "right") ?? findChild(marginsElement, "w", "end"));
+	const right = parseWidth(findChildAnySpelling(marginsElement, "CT_TblWidth right"));
 	if (right) margins.right = right;
 	if (Object.keys(margins).length === 0) return;
 	return margins;
@@ -189,6 +190,7 @@ function parseFloatingTableProperties(tblpPrElement) {
 */
 const REVISION_PROPERTY_CHILDREN = /* @__PURE__ */ new Set([
 	"tblPrChange",
+	"tblPrExChange",
 	"trPrChange",
 	"tcPrChange",
 	"ins",
@@ -206,50 +208,223 @@ const withSourceXml = (formatting, element) => ({
 	...formatting,
 	sourceXml: captureVerbatimXml(cloneElement(element, { elements: (element.elements ?? []).filter((child) => !REVISION_PROPERTY_CHILDREN.has(getLocalName(child.name))) }))
 });
+/**
+* The nine children `w:tblPr` and `w:tblPrEx` both declare, read once.
+*
+* `CT_TblPrEx` is the middle of `CT_TblPrBase`: the same elements, declared in
+* the same order, without the ones that describe the table as a whole. Two
+* handler maps over the same names would be two answers to the same question,
+* and the one folio would notice is the day they stop agreeing.
+*/
+const sharedTablePropertyHandlers = (formatting) => ({
+	tblW: (child) => {
+		const width = parseWidth(child);
+		if (width) formatting.width = width;
+		return keptUnless(width !== void 0);
+	},
+	jc: (child) => {
+		const justification = narrowEnum(getAttribute(child, "w", "val"), TableAlignmentSchema);
+		if (justification !== void 0) formatting.justification = justification;
+		return keptUnless(justification !== void 0);
+	},
+	tblCellSpacing: (child) => {
+		const cellSpacing = parseWidth(child);
+		if (cellSpacing) formatting.cellSpacing = cellSpacing;
+		return keptUnless(cellSpacing !== void 0);
+	},
+	tblInd: (child) => {
+		const indent = parseWidth(child);
+		if (indent) formatting.indent = indent;
+		return keptUnless(indent !== void 0);
+	},
+	tblBorders: (child) => {
+		const borders = parseTableBorders(child);
+		if (borders) formatting.borders = borders;
+		return keptUnless(borders !== void 0);
+	},
+	shd: (child) => {
+		const shading = parseShading(child);
+		if (shading) formatting.shading = shading;
+		return keptUnless(shading !== void 0);
+	},
+	tblLayout: (child) => {
+		const layout = getAttribute(child, "w", "type");
+		if (layout === "fixed" || layout === "autofit") {
+			formatting.layout = layout;
+			return;
+		}
+		return CAPTURE;
+	},
+	tblCellMar: (child) => {
+		const cellMargins = parseCellMargins(child);
+		if (cellMargins) formatting.cellMargins = cellMargins;
+		return keptUnless(cellMargins !== void 0);
+	},
+	tblLook: (child) => {
+		const look = parseTableLook(child);
+		if (look) formatting.look = look;
+		return keptUnless(look !== void 0);
+	}
+});
+/**
+* The children the table walks skip, and the reader that takes each instead.
+*
+* Every one of them is read off its container element before the child walk
+* runs, so capturing it here as well would write it twice. The claims are at
+* module scope, not inside the parsers, so they are registered when the module
+* loads rather than the first time a table is parsed; `ownedElsewhere` is the
+* only way to make one, which is what keeps the set complete.
+*/
+const TABLE_PROPERTY_CHANGE_OWNER = ownedElsewhere({
+	container: "table-properties",
+	child: "tblPrChange",
+	reader: "tableParser#parseTable"
+});
+const TABLE_PROPERTY_EXCEPTION_CHANGE_OWNER = ownedElsewhere({
+	container: "table-property-exceptions",
+	child: "tblPrExChange",
+	reader: "tableParser#parseTableRow"
+});
+const CELL_PROPERTIES_OWNER = ownedElsewhere({
+	container: "block-content",
+	child: "tcPr",
+	reader: "tableParser#parseTableCell"
+});
+/**
+* The revisions a row's and a cell's property set carry.
+*
+* Each is read off the property element before its child walk runs, into
+* `TableRow.structuralChange` / `propertyChanges` and the cell's equivalents,
+* and written back from there. Capturing one here as well would write it twice,
+* and worse: a capture replays a resolved revision into the document after a
+* reviewer accepted it.
+*/
+const ROW_INSERTION_OWNER = ownedElsewhere({
+	container: "row-properties",
+	child: "ins",
+	reader: "tableParser#parseTableRow"
+});
+const ROW_DELETION_OWNER = ownedElsewhere({
+	container: "row-properties",
+	child: "del",
+	reader: "tableParser#parseTableRow"
+});
+const ROW_PROPERTY_CHANGE_OWNER = ownedElsewhere({
+	container: "row-properties",
+	child: "trPrChange",
+	reader: "tableParser#parseTableRow"
+});
+const CELL_INSERTION_OWNER = ownedElsewhere({
+	container: "cell-properties",
+	child: "cellIns",
+	reader: "tableParser#parseTableCell"
+});
+const CELL_DELETION_OWNER = ownedElsewhere({
+	container: "cell-properties",
+	child: "cellDel",
+	reader: "tableParser#parseTableCell"
+});
+const CELL_MERGE_OWNER = ownedElsewhere({
+	container: "cell-properties",
+	child: "cellMerge",
+	reader: "tableParser#parseTableCell"
+});
+const CELL_PROPERTY_CHANGE_OWNER = ownedElsewhere({
+	container: "cell-properties",
+	child: "tcPrChange",
+	reader: "tableParser#parseTableCell"
+});
+const ROW_CHILD_OWNERS = {
+	trPr: ownedElsewhere({
+		container: "row-content",
+		child: "trPr",
+		reader: "tableParser#parseTableRowProperties"
+	}),
+	tblPrEx: ownedElsewhere({
+		container: "row-content",
+		child: "tblPrEx",
+		reader: "tableParser#parseTablePropertyExceptions"
+	})
+};
+const TABLE_CHILD_OWNERS = {
+	tblPr: ownedElsewhere({
+		container: "table-content",
+		child: "tblPr",
+		reader: "tableParser#parseTableProperties"
+	}),
+	tblGrid: ownedElsewhere({
+		container: "table-content",
+		child: "tblGrid",
+		reader: "tableParser#parseTableGrid"
+	})
+};
 function parseTableProperties(tblPrElement) {
 	if (!tblPrElement) return;
 	const formatting = {};
-	const width = parseWidth(findChild(tblPrElement, "w", "tblW"));
-	if (width) formatting.width = width;
-	const jcElement = findChild(tblPrElement, "w", "jc");
-	if (jcElement) {
-		const jcVal = getAttribute(jcElement, "w", "val");
-		if (jcVal === "left" || jcVal === "center" || jcVal === "right" || jcVal === "start") formatting.justification = jcVal === "start" ? "left" : jcVal;
-	}
-	const cellSpacing = parseWidth(findChild(tblPrElement, "w", "tblCellSpacing"));
-	if (cellSpacing) formatting.cellSpacing = cellSpacing;
-	const indent = parseWidth(findChild(tblPrElement, "w", "tblInd"));
-	if (indent) formatting.indent = indent;
-	const borders = parseTableBorders(findChild(tblPrElement, "w", "tblBorders"));
-	if (borders) formatting.borders = borders;
-	const cellMargins = parseCellMargins(findChild(tblPrElement, "w", "tblCellMar"));
-	if (cellMargins) formatting.cellMargins = cellMargins;
-	const layoutElement = findChild(tblPrElement, "w", "tblLayout");
-	if (layoutElement) {
-		const layoutVal = getAttribute(layoutElement, "w", "type");
-		if (layoutVal === "fixed" || layoutVal === "autofit") formatting.layout = layoutVal;
-	}
-	const styleElement = findChild(tblPrElement, "w", "tblStyle");
-	if (styleElement) {
-		const styleId = getAttribute(styleElement, "w", "val");
-		if (styleId) formatting.styleId = styleId;
-	}
-	const look = parseTableLook(findChild(tblPrElement, "w", "tblLook"));
-	if (look) formatting.look = look;
-	const shading = parseShading(findChild(tblPrElement, "w", "shd"));
-	if (shading) formatting.shading = shading;
-	const overlapElement = findChild(tblPrElement, "w", "tblOverlap");
-	if (overlapElement) {
-		const overlapVal = getAttribute(overlapElement, "w", "val");
-		if (overlapVal === "never" || overlapVal === "overlap") formatting.overlap = overlapVal;
-	}
-	const floating = parseFloatingTableProperties(findChild(tblPrElement, "w", "tblpPr"));
-	if (floating) formatting.floating = floating;
-	const bidiVisual = findChild(tblPrElement, "w", "bidiVisual");
-	if (bidiVisual) formatting.bidi = parseBooleanElement(bidiVisual);
+	const preserved = dispatchChildren({
+		element: tblPrElement,
+		container: "table-properties",
+		handlers: {
+			...sharedTablePropertyHandlers(formatting),
+			tblStyle: (child) => {
+				const styleId = getAttribute(child, "w", "val");
+				if (styleId) formatting.styleId = styleId;
+				return keptUnless(Boolean(styleId));
+			},
+			tblpPr: (child) => {
+				const floating = parseFloatingTableProperties(child);
+				if (floating) formatting.floating = floating;
+				return keptUnless(floating !== void 0);
+			},
+			tblOverlap: (child) => {
+				const overlap = getAttribute(child, "w", "val");
+				if (overlap === "never" || overlap === "overlap") {
+					formatting.overlap = overlap;
+					return;
+				}
+				return CAPTURE;
+			},
+			bidiVisual: (child) => {
+				formatting.bidi = parseBooleanElement(child);
+			},
+			tblStyleRowBandSize: (child) => {
+				const size = parseNumericAttribute(child, "w", "val");
+				if (size !== void 0) formatting.rowBandSize = size;
+				return keptUnless(size !== void 0);
+			},
+			tblStyleColBandSize: (child) => {
+				const size = parseNumericAttribute(child, "w", "val");
+				if (size !== void 0) formatting.columnBandSize = size;
+				return keptUnless(size !== void 0);
+			},
+			tblCaption: (child) => {
+				const caption = getAttribute(child, "w", "val");
+				if (caption !== null) formatting.caption = caption;
+				return keptUnless(caption !== null);
+			},
+			tblDescription: (child) => {
+				const description = getAttribute(child, "w", "val");
+				if (description !== null) formatting.description = description;
+				return keptUnless(description !== null);
+			},
+			tblPrChange: TABLE_PROPERTY_CHANGE_OWNER
+		},
+		capturePosition: sequencePositions("table-properties", tblPrElement)
+	});
+	if (preserved) formatting.preserved = preserved;
 	if (Object.keys(formatting).length === 0) return;
 	return withSourceXml(formatting, tblPrElement);
 }
+/**
+* A revision is the author, the date and the id; the snapshot may be empty.
+*
+* `<w:tblPrChange …><w:tblPr/></w:tblPrChange>` on a table that states no
+* properties of its own records that a reviewer changed the table's
+* properties from nothing to nothing — an accepted style change, most often.
+* Dropping it because neither snapshot carried a typed value threw the
+* revision away, and with it the reviewer's ability to accept or reject.
+* `w:pPrChange` and `w:rPrChange` never did this.
+*/
 function parseTablePropertyChanges(tblPrElement, currentFormatting) {
 	if (!tblPrElement) return;
 	const changes = findChildren(tblPrElement, "w", "tblPrChange").map((changeElement) => {
@@ -262,7 +437,45 @@ function parseTablePropertyChanges(tblPrElement, currentFormatting) {
 		if (prev !== void 0) change.previousFormatting = prev;
 		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
 		return change;
-	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	});
+	return changes.length > 0 ? changes : void 0;
+}
+/**
+* Parse a row's table property exceptions (`w:tblPrEx`).
+*
+* The nine children are the table's own, read by the same handlers, so an
+* exception and the property it overrides can never be read into two different
+* shapes. `w:tblPrExChange` is a revision rather than a property and is read by
+* {@link parseTablePropertyExceptionChanges}.
+*/
+function parseTablePropertyExceptions(tblPrExElement) {
+	if (!tblPrExElement) return;
+	const formatting = {};
+	const preserved = dispatchChildren({
+		element: tblPrExElement,
+		container: "table-property-exceptions",
+		handlers: {
+			...sharedTablePropertyHandlers(formatting),
+			tblPrExChange: TABLE_PROPERTY_EXCEPTION_CHANGE_OWNER
+		},
+		capturePosition: sequencePositions("table-property-exceptions", tblPrExElement)
+	});
+	if (preserved) formatting.preserved = preserved;
+	return withSourceXml(formatting, tblPrExElement);
+}
+/** `w:tblPrExChange`, read the way `w:tblPrChange` is. */
+function parseTablePropertyExceptionChanges(tblPrExElement, currentFormatting) {
+	if (!tblPrExElement) return;
+	const changes = findChildren(tblPrExElement, "w", "tblPrExChange").map((changeElement) => {
+		const change = {
+			type: "tablePropertyExceptionChange",
+			info: parsePropertyChangeInfo(changeElement)
+		};
+		const prev = parseTablePropertyExceptions(findChild(changeElement, "w", "tblPrEx"));
+		if (prev !== void 0) change.previousFormatting = prev;
+		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
+		return change;
+	});
 	return changes.length > 0 ? changes : void 0;
 }
 function parseTableRowPropertyChanges(trPrElement, currentFormatting) {
@@ -277,7 +490,7 @@ function parseTableRowPropertyChanges(trPrElement, currentFormatting) {
 		if (prev !== void 0) change.previousFormatting = prev;
 		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
 		return change;
-	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	});
 	return changes.length > 0 ? changes : void 0;
 }
 function parseTableCellPropertyChanges(tcPrElement, currentFormatting) {
@@ -290,9 +503,11 @@ function parseTableCellPropertyChanges(tcPrElement, currentFormatting) {
 		};
 		const prev = parseTableCellProperties(previousTcPr);
 		if (prev !== void 0) change.previousFormatting = prev;
+		const previousStructuralChange = parseTableCellStructuralChange(previousTcPr);
+		if (previousStructuralChange !== void 0) change.previousStructuralChange = previousStructuralChange;
 		if (currentFormatting !== void 0) change.currentFormatting = currentFormatting;
 		return change;
-	}).filter((change) => change.previousFormatting || change.currentFormatting);
+	});
 	return changes.length > 0 ? changes : void 0;
 }
 function parseTableRowStructuralChange(trPrElement) {
@@ -345,37 +560,68 @@ function parseTableCellVerticalMergeRevisionValue(value) {
 function parseTableRowProperties(trPrElement) {
 	if (!trPrElement) return;
 	const formatting = {};
-	const gridBefore = parseNumericAttribute(findChild(trPrElement, "w", "gridBefore"), "w", "val");
-	if (gridBefore !== void 0 && gridBefore > 0) formatting.gridBefore = gridBefore;
-	const widthBefore = parseTableMeasurement(findChild(trPrElement, "w", "wBefore"));
-	if (widthBefore) formatting.widthBefore = widthBefore;
-	const gridAfter = parseNumericAttribute(findChild(trPrElement, "w", "gridAfter"), "w", "val");
-	if (gridAfter !== void 0 && gridAfter > 0) formatting.gridAfter = gridAfter;
-	const widthAfter = parseTableMeasurement(findChild(trPrElement, "w", "wAfter"));
-	if (widthAfter) formatting.widthAfter = widthAfter;
-	const heightElement = findChild(trPrElement, "w", "trHeight");
-	if (heightElement) {
-		const heightVal = parseNumericAttribute(heightElement, "w", "val");
-		if (heightVal !== void 0 && heightVal > 0) {
-			formatting.height = {
-				value: heightVal,
-				type: "dxa"
-			};
-			const hRule = getAttribute(heightElement, "w", "hRule");
-			if (hRule === "auto" || hRule === "atLeast" || hRule === "exact") formatting.heightRule = hRule;
-		}
-	}
-	if (parseBooleanElement(findChild(trPrElement, "w", "tblHeader"))) formatting.header = true;
-	if (parseBooleanElement(findChild(trPrElement, "w", "cantSplit"))) formatting.cantSplit = true;
-	const jcElement = findChild(trPrElement, "w", "jc");
-	if (jcElement) {
-		const jcVal = getAttribute(jcElement, "w", "val");
-		if (jcVal === "left" || jcVal === "center" || jcVal === "right") formatting.justification = jcVal;
-	}
-	if (parseBooleanElement(findChild(trPrElement, "w", "hidden"))) formatting.hidden = true;
-	const conditionalFormat = parseConditionalFormatStyle(findChild(trPrElement, "w", "cnfStyle"));
-	if (conditionalFormat) formatting.conditionalFormat = conditionalFormat;
-	if (Object.keys(formatting).length === 0) return;
+	const preserved = dispatchChildren({
+		element: trPrElement,
+		container: "row-properties",
+		handlers: {
+			cnfStyle: (child) => {
+				const conditionalFormat = parseConditionalFormatStyle(child);
+				if (conditionalFormat) formatting.conditionalFormat = conditionalFormat;
+				return keptUnless(conditionalFormat !== void 0);
+			},
+			divId: CAPTURE,
+			gridBefore: (child) => {
+				const gridBefore = parseNumericAttribute(child, "w", "val");
+				if (gridBefore !== void 0 && gridBefore > 0) formatting.gridBefore = gridBefore;
+				return keptUnless(gridBefore !== void 0 && gridBefore > 0);
+			},
+			gridAfter: (child) => {
+				const gridAfter = parseNumericAttribute(child, "w", "val");
+				if (gridAfter !== void 0 && gridAfter > 0) formatting.gridAfter = gridAfter;
+				return keptUnless(gridAfter !== void 0 && gridAfter > 0);
+			},
+			wBefore: (child) => {
+				const widthBefore = parseTableMeasurement(child);
+				if (widthBefore) formatting.widthBefore = widthBefore;
+				return keptUnless(widthBefore !== void 0);
+			},
+			wAfter: (child) => {
+				const widthAfter = parseTableMeasurement(child);
+				if (widthAfter) formatting.widthAfter = widthAfter;
+				return keptUnless(widthAfter !== void 0);
+			},
+			cantSplit: (child) => {
+				formatting.cantSplit = parseBooleanElement(child);
+			},
+			trHeight: (child) => {
+				const heightVal = parseNumericAttribute(child, "w", "val");
+				if (heightVal === void 0 || heightVal <= 0) return CAPTURE;
+				formatting.height = {
+					value: heightVal,
+					type: "dxa"
+				};
+				const hRule = getAttribute(child, "w", "hRule");
+				if (hRule === "auto" || hRule === "atLeast" || hRule === "exact") formatting.heightRule = hRule;
+			},
+			tblHeader: (child) => {
+				formatting.header = parseBooleanElement(child);
+			},
+			tblCellSpacing: CAPTURE,
+			jc: (child) => {
+				const justification = narrowEnum(getAttribute(child, "w", "val"), TableAlignmentSchema);
+				if (justification !== void 0) formatting.justification = justification;
+				return keptUnless(justification !== void 0);
+			},
+			hidden: (child) => {
+				formatting.hidden = parseBooleanElement(child);
+			},
+			ins: ROW_INSERTION_OWNER,
+			del: ROW_DELETION_OWNER,
+			trPrChange: ROW_PROPERTY_CHANGE_OWNER
+		},
+		capturePosition: sequencePositions("row-properties", trPrElement)
+	});
+	if (preserved) formatting.preserved = preserved;
 	return withSourceXml(formatting, trPrElement);
 }
 /**
@@ -426,41 +672,88 @@ function parseConditionalFormatStyle(cnfElement) {
 function parseTableCellProperties(tcPrElement) {
 	if (!tcPrElement) return;
 	const formatting = {};
-	const width = parseWidth(findChild(tcPrElement, "w", "tcW"));
-	if (width) formatting.width = width;
-	const borders = parseTableCellBorders(findChild(tcPrElement, "w", "tcBorders"));
-	if (borders) formatting.borders = borders;
-	const margins = parseCellMargins(findChild(tcPrElement, "w", "tcMar"));
-	if (margins) formatting.margins = margins;
-	const shading = parseShading(findChild(tcPrElement, "w", "shd"));
-	if (shading) formatting.shading = shading;
-	const vAlignElement = findChild(tcPrElement, "w", "vAlign");
-	if (vAlignElement) {
-		const vAlign = getAttribute(vAlignElement, "w", "val");
-		if (vAlign === "top" || vAlign === "center" || vAlign === "bottom") formatting.verticalAlign = vAlign;
-	}
-	const textDirElement = findChild(tcPrElement, "w", "textDirection");
-	if (textDirElement) {
-		const textDir = narrowEnum(getAttribute(textDirElement, "w", "val"), TableCellTextDirectionSchema);
-		if (textDir) formatting.textDirection = textDir;
-	}
-	const gridSpanElement = findChild(tcPrElement, "w", "gridSpan");
-	if (gridSpanElement) {
-		const gridSpan = parseNumericAttribute(gridSpanElement, "w", "val");
-		if (gridSpan !== void 0 && gridSpan > 1) formatting.gridSpan = Math.min(gridSpan, 63);
-	}
-	const vMergeElement = findChild(tcPrElement, "w", "vMerge");
-	if (vMergeElement) if (getAttribute(vMergeElement, "w", "val") === "restart") formatting.vMerge = "restart";
-	else formatting.vMerge = "continue";
-	if (parseBooleanElement(findChild(tcPrElement, "w", "tcFitText"))) formatting.fitText = true;
-	if (parseBooleanElement(findChild(tcPrElement, "w", "noWrap"))) formatting.noWrap = true;
-	const hideMarkElement = findChild(tcPrElement, "w", "hideMark");
-	if (hideMarkElement) formatting.hideMark = parseBooleanElement(hideMarkElement);
-	const conditionalFormat = parseConditionalFormatStyle(findChild(tcPrElement, "w", "cnfStyle"));
-	if (conditionalFormat) formatting.conditionalFormat = conditionalFormat;
-	if (Object.keys(formatting).length === 0) return;
+	const preserved = dispatchChildren({
+		element: tcPrElement,
+		container: "cell-properties",
+		handlers: {
+			cnfStyle: (child) => {
+				const conditionalFormat = parseConditionalFormatStyle(child);
+				if (conditionalFormat) formatting.conditionalFormat = conditionalFormat;
+				return keptUnless(conditionalFormat !== void 0);
+			},
+			tcW: (child) => {
+				const width = parseWidth(child);
+				if (width) formatting.width = width;
+				return keptUnless(width !== void 0);
+			},
+			gridSpan: (child) => {
+				const gridSpan = parseNumericAttribute(child, "w", "val");
+				if (gridSpan !== void 0 && gridSpan > 1) {
+					formatting.gridSpan = Math.min(gridSpan, 63);
+					return;
+				}
+				return CAPTURE;
+			},
+			hMerge: CAPTURE,
+			vMerge: (child) => {
+				formatting.vMerge = getAttribute(child, "w", "val") === "restart" ? "restart" : "continue";
+			},
+			tcBorders: (child) => {
+				const borders = parseTableCellBorders(child);
+				if (borders) formatting.borders = borders;
+				return keptUnless(borders !== void 0);
+			},
+			shd: (child) => {
+				const shading = parseShading(child);
+				if (shading) formatting.shading = shading;
+				return keptUnless(shading !== void 0);
+			},
+			noWrap: (child) => {
+				formatting.noWrap = parseBooleanElement(child);
+			},
+			tcMar: (child) => {
+				const margins = parseCellMargins(child);
+				if (margins) formatting.margins = margins;
+				return keptUnless(margins !== void 0);
+			},
+			textDirection: (child) => {
+				const textDir = narrowEnum(getAttribute(child, "w", "val"), TextDirectionSchema);
+				if (textDir) formatting.textDirection = textDir;
+				return keptUnless(textDir !== void 0);
+			},
+			tcFitText: (child) => {
+				formatting.fitText = parseBooleanElement(child);
+			},
+			vAlign: (child) => {
+				const vAlign = getAttribute(child, "w", "val");
+				if (vAlign === "top" || vAlign === "center" || vAlign === "bottom") {
+					formatting.verticalAlign = vAlign;
+					return;
+				}
+				return CAPTURE;
+			},
+			hideMark: (child) => {
+				formatting.hideMark = parseBooleanElement(child);
+			},
+			headers: CAPTURE,
+			cellIns: CELL_INSERTION_OWNER,
+			cellDel: CELL_DELETION_OWNER,
+			cellMerge: CELL_MERGE_OWNER,
+			tcPrChange: CELL_PROPERTY_CHANGE_OWNER
+		},
+		capturePosition: sequencePositions("cell-properties", tcPrElement)
+	});
+	if (preserved) formatting.preserved = preserved;
 	return withSourceXml(formatting, tcPrElement);
 }
+const recordContentControl = (wrapped, carriers, sdtElement) => {
+	const properties = parseSdtProperties(findWordprocessingChild(sdtElement, "sdtPr"), findWordprocessingChild(sdtElement, "sdtEndPr"));
+	const siblings = captureSdtSiblingMarkers(sdtElement);
+	if (siblings.before.length > 0) properties.rawSdtChildrenBeforeContent = siblings.before;
+	if (siblings.after.length > 0) properties.rawSdtChildrenAfterContent = siblings.after;
+	for (const item of wrapped) item.contentControls = [properties, ...item.contentControls ?? []];
+	for (const item of carriers) item.contentControls = [properties, ...item.contentControls ?? []];
+};
 /**
 * Accumulate a table container's own `xmlns:*` onto the inherited in-scope set,
 * so a `w:pict` nested inside a cell still resolves prefixes scoped on the
@@ -474,13 +767,12 @@ function withContainerXmlns(options, element) {
 }
 function parseCellContent(tcElement, styles, theme, numbering, rels, media, options) {
 	const modelled = [];
-	const pendingBookmarkMarkers = [];
 	const captured = [];
 	const dispatchCellChildren = (element, childOptions) => {
 		const preserved = dispatchChildren({
 			element,
 			container: "block-content",
-			modelledCount: () => modelled.length,
+			capturePosition: () => modelled.length,
 			undeclared: { AlternateContent: (child) => {
 				const selectedBranch = selectAlternateContentBranch(child);
 				if (!selectedBranch) return;
@@ -488,29 +780,30 @@ function parseCellContent(tcElement, styles, theme, numbering, rels, media, opti
 			} },
 			handlers: {
 				p: (child) => {
-					const para = parseParagraph(child, styles, theme, numbering, rels, media, childOptions);
+					const para = parseParagraph(child, styles, theme, numbering, rels, media, {
+						...childOptions,
+						runConsolidation: "deferred"
+					});
 					enrichParagraphTextBoxes(para, child, styles, theme, numbering, rels, media, parseTable);
-					prependPendingBookmarkMarkers(para, pendingBookmarkMarkers);
 					modelled.push(para);
 				},
 				tbl: (child) => {
 					const table = parseTable(child, styles, theme, numbering, rels, media, childOptions);
 					if (!table) return;
-					if (prependBookmarkMarkersToFirstParagraphInBlocks([table], pendingBookmarkMarkers)) pendingBookmarkMarkers.length = 0;
 					modelled.push(table);
 				},
 				sdt: (child) => {
-					const sdtContent = findChildByLocalName(child, "sdtContent");
+					const sdtContent = findWordprocessingChild(child, "sdtContent");
 					if (!sdtContent) return;
 					dispatchCellChildren(sdtContent, withContainerXmlns(withContainerXmlns(childOptions, child), sdtContent));
 				},
 				bookmarkStart: (child) => {
-					collectCellBookmarkMarker(child, "bookmarkStart", modelled, pendingBookmarkMarkers);
+					modelled.push(parseBookmarkStart(child));
 				},
 				bookmarkEnd: (child) => {
-					collectCellBookmarkMarker(child, "bookmarkEnd", modelled, pendingBookmarkMarkers);
+					modelled.push(parseBookmarkEnd(child));
 				},
-				tcPr: OWNED_ELSEWHERE,
+				tcPr: CELL_PROPERTIES_OWNER,
 				sectPr: CAPTURE,
 				altChunk: CAPTURE,
 				commentRangeEnd: CAPTURE,
@@ -540,20 +833,15 @@ function parseCellContent(tcElement, styles, theme, numbering, rels, media, opti
 		if (preserved?.children) captured.push(...preserved.children);
 	};
 	dispatchCellChildren(tcElement, options);
-	if (modelled.length === 0) modelled.push({
+	if (!modelled.some((block) => block.type === "paragraph" || block.type === "table")) modelled.push({
 		type: "paragraph",
-		content: [...pendingBookmarkMarkers]
+		content: []
 	});
-	else if (pendingBookmarkMarkers.length > 0) appendBookmarkMarkersToLastParagraphInBlocks(modelled, pendingBookmarkMarkers);
 	return withPreservedChildren(modelled, { children: captured }, (xml) => ({
 		type: "preservedBlock",
 		xml
 	}));
 }
-const collectCellBookmarkMarker = (child, localName, content, pending) => {
-	const marker = parseBookmarkMarker(child, localName);
-	if (!appendBookmarkMarkerToLastParagraphInBlocks(content, marker)) pending.push(marker);
-};
 /**
 * Parse a table cell (w:tc)
 *
@@ -596,6 +884,11 @@ function parseTableRow(trElement, styles, theme, numbering, rels, media, options
 		type: "tableRow",
 		cells: []
 	};
+	const tblPrExElement = findChild(trElement, "w", "tblPrEx");
+	const exceptions = parseTablePropertyExceptions(tblPrExElement);
+	if (exceptions) row.tablePropertyExceptions = exceptions;
+	const exceptionChanges = parseTablePropertyExceptionChanges(tblPrExElement, exceptions);
+	if (exceptionChanges !== void 0) row.tablePropertyExceptionChanges = exceptionChanges;
 	const trPrElement = findChild(trElement, "w", "trPr");
 	const formatting = parseTableRowProperties(trPrElement);
 	if (formatting) row.formatting = formatting;
@@ -604,43 +897,54 @@ function parseTableRow(trElement, styles, theme, numbering, rels, media, options
 	const rowStructChange = parseTableRowStructuralChange(trPrElement);
 	if (rowStructChange !== void 0) row.structuralChange = rowStructChange;
 	const rowOptions = withContainerXmlns(options, trElement);
-	const pendingBookmarkMarkers = [];
+	const bookmarks = [];
 	const preservedChildren = [];
 	/**
-	* One row's children, or a row-level content control's.
+	* One row's children, or a cell-level content control's.
 	*
-	* folio unwraps `w:sdt` here and splices its rows' content into the row, so
-	* the recursion walks the control's content with the same map; the sink is
-	* the row's either way, because the control keeps no wrapper to hold one.
+	* folio keeps the cells `w:sdt` holds as the row's own and records the
+	* control on each of them, so the recursion walks the control's content
+	* with the same map; the sink is the row's either way, because the control
+	* holds no capture of its own.
 	*/
 	const dispatchRowChildren = (element, childOptions) => {
 		const captured = dispatchChildren({
 			element,
 			container: "row-content",
-			modelledCount: () => row.cells.length,
+			capturePosition: () => row.cells.length,
 			handlers: {
 				tc: (child) => {
-					const cell = parseTableCell(child, styles, theme, numbering, rels, media, childOptions);
-					if (pendingBookmarkMarkers.length > 0) {
-						prependBookmarkMarkersToFirstParagraphInCell(cell, pendingBookmarkMarkers);
-						pendingBookmarkMarkers.length = 0;
-					}
-					row.cells.push(cell);
+					row.cells.push(parseTableCell(child, styles, theme, numbering, rels, media, childOptions));
 				},
 				sdt: (child) => {
-					const sdtContent = findChildByLocalName(child, "sdtContent");
-					if (!sdtContent) return;
+					const sdtContent = findWordprocessingChild(child, "sdtContent");
+					if (!sdtContent) return CAPTURE;
+					const firstWrapped = row.cells.length;
+					const firstCaptured = preservedChildren.length;
+					const firstBookmark = bookmarks.length;
 					const sdtOptions = withContainerXmlns(childOptions, child);
 					dispatchRowChildren(sdtContent, withContainerXmlns(sdtOptions, sdtContent));
+					const wrapped = row.cells.slice(firstWrapped);
+					if (wrapped.length === 0) {
+						preservedChildren.splice(firstCaptured);
+						bookmarks.splice(firstBookmark);
+						return CAPTURE;
+					}
+					recordContentControl(wrapped, [...preservedChildren.slice(firstCaptured), ...bookmarks.slice(firstBookmark)], child);
 				},
 				bookmarkStart: (child) => {
-					placeBookmarkMarker(parseBookmarkStart(child));
+					bookmarks.push({
+						index: row.cells.length,
+						marker: parseBookmarkStart(child)
+					});
 				},
 				bookmarkEnd: (child) => {
-					placeBookmarkMarker(parseBookmarkEnd(child));
+					bookmarks.push({
+						index: row.cells.length,
+						marker: parseBookmarkEnd(child)
+					});
 				},
-				trPr: OWNED_ELSEWHERE,
-				tblPrEx: OWNED_ELSEWHERE,
+				...ROW_CHILD_OWNERS,
 				commentRangeEnd: CAPTURE,
 				commentRangeStart: CAPTURE,
 				customXml: CAPTURE,
@@ -668,36 +972,16 @@ function parseTableRow(trElement, styles, theme, numbering, rels, media, options
 		});
 		if (captured?.children) preservedChildren.push(...captured.children);
 	};
-	const placeBookmarkMarker = (marker) => {
-		if (!appendBookmarkMarkerToLastParagraphInCells(row.cells, marker)) pendingBookmarkMarkers.push(marker);
-	};
 	dispatchRowChildren(trElement, rowOptions);
 	if (preservedChildren.length > 0) row.preserved = { children: preservedChildren };
+	if (bookmarks.length > 0) row.bookmarks = bookmarks;
 	const remainingAttributes = attributeRemainder({
 		element: trElement,
 		modelled: NO_MODELLED_ATTRIBUTES
 	});
 	if (remainingAttributes) row.preservedAttributes = remainingAttributes;
-	if (pendingBookmarkMarkers.length > 0) appendBookmarkMarkersToLastCell(row, pendingBookmarkMarkers);
 	return row;
 }
-function parseBookmarkMarker(child, localName) {
-	if (localName === "bookmarkStart") return parseBookmarkStart(child);
-	return parseBookmarkEnd(child);
-}
-function prependPendingBookmarkMarkers(paragraph, pendingBookmarkMarkers) {
-	if (pendingBookmarkMarkers.length === 0) return;
-	paragraph.content.unshift(...pendingBookmarkMarkers);
-	pendingBookmarkMarkers.length = 0;
-}
-function appendBookmarkMarkersToLastParagraphInBlocks(blocks, markers) {
-	for (const marker of markers) appendBookmarkMarkerToLastParagraphInBlocks(blocks, marker);
-}
-function appendBookmarkMarkersToLastCell(row, markers) {
-	const lastCell = row.cells.at(-1);
-	if (!lastCell) return;
-	for (const marker of markers) appendBookmarkMarkerToLastParagraphInBlocks(lastCell.content, marker);
-}
 /**
 * Parse table grid (w:tblGrid) for column widths
 *
@@ -715,6 +999,24 @@ function parseTableGrid(tblGridElement) {
 	if (widths.length > 0 && widths.every((width) => width <= 0)) return;
 	return widths.length > 0 ? widths : void 0;
 }
+/**
+* The grid a `w:tblGridChange` snapshots, from the change's own `w:tblGrid`.
+*
+* {@link parseTableGrid} reads the *live* grid, where a column with no `w:w`
+* is a column folio has no width for and a grid of nothing but those is no
+* grid at all. A snapshot is a record of what stood, so every `w:gridCol`
+* survives whether or not it stated a width, and `undefined` is what says the
+* column stated none.
+*/
+function parseTableGridChange(gridElement) {
+	const changeElement = findChild(gridElement, "w", "tblGridChange");
+	if (!changeElement) return;
+	const snapshot = findChild(changeElement, "w", "tblGrid");
+	return {
+		id: parseTrackedChangeInfo(changeElement).id,
+		columnWidths: (snapshot === null ? [] : findChildren(snapshot, "w", "gridCol")).map((column) => parseNumericAttribute(column, "w", "w"))
+	};
+}
 function hasRowGridOffsets(rowElement) {
 	const trPrElement = findChild(rowElement, "w", "trPr");
 	if (!trPrElement) return false;
@@ -777,28 +1079,30 @@ function parseTable(tblElement, styles, theme, numbering, rels, media, options)
 	const columnWidths = parseTableGrid(gridElement);
 	if (columnWidths) table.columnWidths = columnWidths;
 	if (gridElement) {
-		const gridChange = findChild(gridElement, "w", "tblGridChange");
+		const gridChange = parseTableGridChange(gridElement);
 		table.formatting = {
 			...table.formatting,
 			gridSourceXml: captureVerbatimXml(gridElement),
-			...gridChange ? { gridChangeXml: captureVerbatimXml(gridChange) } : {}
+			...gridChange === void 0 ? {} : { gridChange }
 		};
 	}
 	const tableOptions = withContainerXmlns(options, tblElement);
 	const rowsWithGridOffsets = /* @__PURE__ */ new Set();
 	const preservedChildren = [];
+	const bookmarks = [];
 	/**
 	* One table's children, or a row-level content control's.
 	*
-	* folio unwraps `w:sdt` here and splices its rows into the table, so the
-	* recursion walks the control's content with the same map; the sink is the
-	* table's either way, because the control keeps no wrapper to hold one.
+	* folio keeps the rows `w:sdt` holds as the table's own and records the
+	* control on each of them, so the recursion walks the control's content
+	* with the same map; the sink is the table's either way, because the
+	* control holds no capture of its own.
 	*/
 	const dispatchTableChildren = (element, childOptions) => {
 		const captured = dispatchChildren({
 			element,
 			container: "table-content",
-			modelledCount: () => table.rows.length,
+			capturePosition: () => table.rows.length,
 			handlers: {
 				tr: (child) => {
 					const rowIndex = table.rows.length;
@@ -806,15 +1110,34 @@ function parseTable(tblElement, styles, theme, numbering, rels, media, options)
 					if (hasRowGridOffsets(child)) rowsWithGridOffsets.add(rowIndex);
 				},
 				sdt: (child) => {
-					const sdtContent = findChildByLocalName(child, "sdtContent");
-					if (!sdtContent) return;
+					const sdtContent = findWordprocessingChild(child, "sdtContent");
+					if (!sdtContent) return CAPTURE;
+					const firstWrapped = table.rows.length;
+					const firstCaptured = preservedChildren.length;
+					const firstBookmark = bookmarks.length;
 					const sdtOptions = withContainerXmlns(childOptions, child);
 					dispatchTableChildren(sdtContent, withContainerXmlns(sdtOptions, sdtContent));
+					const wrapped = table.rows.slice(firstWrapped);
+					if (wrapped.length === 0) {
+						preservedChildren.splice(firstCaptured);
+						bookmarks.splice(firstBookmark);
+						return CAPTURE;
+					}
+					recordContentControl(wrapped, [...preservedChildren.slice(firstCaptured), ...bookmarks.slice(firstBookmark)], child);
+				},
+				...TABLE_CHILD_OWNERS,
+				bookmarkStart: (child) => {
+					bookmarks.push({
+						index: table.rows.length,
+						marker: parseBookmarkStart(child)
+					});
+				},
+				bookmarkEnd: (child) => {
+					bookmarks.push({
+						index: table.rows.length,
+						marker: parseBookmarkEnd(child)
+					});
 				},
-				tblPr: OWNED_ELSEWHERE,
-				tblGrid: OWNED_ELSEWHERE,
-				bookmarkEnd: CAPTURE,
-				bookmarkStart: CAPTURE,
 				commentRangeEnd: CAPTURE,
 				commentRangeStart: CAPTURE,
 				customXml: CAPTURE,
@@ -845,6 +1168,7 @@ function parseTable(tblElement, styles, theme, numbering, rels, media, options)
 	dispatchTableChildren(tblElement, tableOptions);
 	if (table.rows.length === 0) return;
 	if (preservedChildren.length > 0) table.preserved = { children: preservedChildren };
+	if (bookmarks.length > 0) table.bookmarks = bookmarks;
 	inferImplicitSingleCellRowSpans(table, rowsWithGridOffsets);
 	return table;
 }
@@ -953,4 +1277,4 @@ function isFloatingTable(table) {
 	return table.formatting?.floating !== void 0;
 }
 //#endregion
-export { MAX_TABLE_COLUMNS, getHeaderRows, getTableColumnCount, getTableRowCount, getTableText, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTableRow, parseTableRowProperties };
+export { MAX_TABLE_COLUMNS, getHeaderRows, getTableColumnCount, getTableRowCount, getTableText, hasHeaderRow, isCellHorizontallyMerged, isCellMergeContinuation, isCellMergeStart, isFloatingTable, parseCellMargins, parseConditionalFormatStyle, parseFloatingTableProperties, parseTable, parseTableBorders, parseTableCell, parseTableCellProperties, parseTableGrid, parseTableLook, parseTableMeasurement, parseTableProperties, parseTablePropertyExceptions, parseTableRow, parseTableRowProperties };