@stll/folio-core 0.46.0 → 0.47.1

package/dist/docx/serializer/stylesSerializer.js

@@ -2,7 +2,7 @@ import { serializeParagraphFormatting } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTableCellFormatting, serializeTableFormatting, serializeTableRowFormatting } from "./tableSerializer.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
-import { escapeXmlAttribute } from "@stll/docx-core";
+import { escapeXmlAttribute, pushOnOffElement } from "@stll/docx-core";
 //#region src/docx/serializer/stylesSerializer.ts
 const serializeStylesXml = (definitions) => {
 	return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
@@ -14,7 +14,8 @@ const serializeStylesXml = (definitions) => {
 	});
 };
 const serializeDocumentDefaults = (definitions) => {
-	return `<w:docDefaults><w:rPrDefault>${serializeTextFormatting(definitions.docDefaults?.rPr) || "<w:rPr/>"}</w:rPrDefault><w:pPrDefault>${serializeParagraphFormatting(definitions.docDefaults?.pPr) || "<w:pPr/>"}</w:pPrDefault></w:docDefaults>`;
+	const rPr = serializeTextFormatting(definitions.docDefaults?.rPr);
+	return `<w:docDefaults>${rPr === "" ? "<w:rPrDefault/>" : `<w:rPrDefault>${rPr}</w:rPrDefault>`}<w:pPrDefault>${serializeParagraphFormatting(definitions.docDefaults?.pPr) || "<w:pPr/>"}</w:pPrDefault></w:docDefaults>`;
 };
 const serializeLatentStyles = (definitions) => {
 	const latent = definitions.latentStyles;
@@ -35,11 +36,11 @@ const serializeStyle = (style) => {
 	if (style.next) parts.push(`<w:next w:val="${escapeXmlAttribute(style.next)}"/>`);
 	if (style.link) parts.push(`<w:link w:val="${escapeXmlAttribute(style.link)}"/>`);
 	if (style.uiPriority !== void 0) parts.push(`<w:uiPriority w:val="${style.uiPriority}"/>`);
-	pushBooleanElement(parts, "hidden", style.hidden);
-	pushBooleanElement(parts, "semiHidden", style.semiHidden);
-	pushBooleanElement(parts, "unhideWhenUsed", style.unhideWhenUsed);
-	pushBooleanElement(parts, "qFormat", style.qFormat);
-	pushBooleanElement(parts, "personal", style.personal);
+	pushOnOffElement(parts, style.hidden, "hidden");
+	pushOnOffElement(parts, style.semiHidden, "semiHidden");
+	pushOnOffElement(parts, style.unhideWhenUsed, "unhideWhenUsed");
+	pushOnOffElement(parts, style.qFormat, "qFormat");
+	pushOnOffElement(parts, style.personal, "personal");
 	parts.push(serializeParagraphFormatting(style.pPr));
 	parts.push(serializeTextFormatting(style.rPr));
 	parts.push(serializeTableFormatting(style.tblPr));
@@ -48,10 +49,6 @@ const serializeStyle = (style) => {
 	for (const conditional of style.tblStylePr ?? []) parts.push(`<w:tblStylePr w:type="${conditional.type}">${serializeParagraphFormatting(conditional.pPr)}${serializeTextFormatting(conditional.rPr)}${serializeTableFormatting(conditional.tblPr)}${serializeTableRowFormatting(conditional.trPr)}${serializeTableCellFormatting(conditional.tcPr)}</w:tblStylePr>`);
 	return `<w:style ${attrs.join(" ")}>${parts.join("")}</w:style>`;
 };
-const pushBooleanElement = (parts, name, value) => {
-	if (value === true) parts.push(`<w:${name}/>`);
-	else if (value === false) parts.push(`<w:${name} w:val="0"/>`);
-};
 const pushBooleanAttr = (attrs, name, value) => {
 	if (value !== void 0) attrs.push(`${name}="${value ? 1 : 0}"`);
 };

package/dist/docx/serializer/tableSerializer.js

@@ -1,15 +1,19 @@
 import { canonicalJson } from "../../utils/canonicalJson.js";
 import { isValidHexColor } from "../../utils/colorResolver.js";
 import { serializePreservedAttributes } from "../attributeRemainder.js";
-import { serializeWithPreservedChildren } from "../containerChildren.js";
+import { withPreservedChildren } from "../containerChildren.js";
+import { TRANSITIONAL_NAME_BY_STRICT_NAME } from "../strictNames.gen.js";
 import { TABLE_LOOK_FLAGS } from "../tableLook.js";
-import { parseTableCellProperties, parseTableGrid, parseTableProperties, parseTableRowProperties } from "../tableParser.js";
-import { sanitizeCapturedXmlElement } from "../verbatimCapture.js";
-import { NAMESPACES, OOXML_NAMESPACE_SCOPE, parseXml } from "../xmlParser.js";
+import { parseTableCellProperties, parseTableGrid, parseTableProperties, parseTablePropertyExceptions, parseTableRowProperties } from "../tableParser.js";
+import { OOXML_NAMESPACE_SCOPE, parseXml } from "../xmlParser.js";
 import { serializeBorder } from "./borderSerializer.js";
+import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
+import { serializeSdtWrapper } from "./sdtPropertiesSerializer.js";
 import { serializeTrackedChangeAttributes } from "./trackedChangeAttributes.js";
 import { intAttr } from "./xmlUtils.js";
-import { escapeXmlAttribute } from "@stll/docx-core";
+import { escapeXmlAttribute, serializeOnOffElement } from "@stll/docx-core";
+import { themeColorToken } from "@stll/docx-core/model";
+import { serializeSequenceChildren } from "@stll/docx-core/schema";
 //#region src/docx/serializer/tableSerializer.ts
 /**
 * The captured element with the revision children written back into it.
@@ -30,20 +34,36 @@ const withRevisionChildren = (sourceXml, revisions) => {
 };
 /** `w:trPr/w:ins` | `w:trPr/w:del`, the row's own structural revision. */
 const rowStructuralChangeXml = (change) => {
-	if (change?.type === "tableRowInsertion") return [`<w:ins ${serializeTrackedChangeAttributes(change.info)}/>`];
-	if (change?.type === "tableRowDeletion") return [`<w:del ${serializeTrackedChangeAttributes(change.info)}/>`];
-	return [];
+	if (change?.type === "tableRowInsertion") return {
+		name: "ins",
+		xml: `<w:ins ${serializeTrackedChangeAttributes(change.info)}/>`
+	};
+	if (change?.type === "tableRowDeletion") return {
+		name: "del",
+		xml: `<w:del ${serializeTrackedChangeAttributes(change.info)}/>`
+	};
 };
 /** `w:tcPr/w:cellIns` | `w:cellDel` | `w:cellMerge`, the cell's own. */
 const cellStructuralChangeXml = (change) => {
-	if (change?.type === "tableCellInsertion") return [`<w:cellIns ${serializeTrackedChangeAttributes(change.info)}/>`];
-	if (change?.type === "tableCellDeletion") return [`<w:cellDel ${serializeTrackedChangeAttributes(change.info)}/>`];
-	if (change?.type !== "tableCellMerge") return [];
+	if (change?.type === "tableCellInsertion") return {
+		name: "cellIns",
+		xml: `<w:cellIns ${serializeTrackedChangeAttributes(change.info)}/>`
+	};
+	if (change?.type === "tableCellDeletion") return {
+		name: "cellDel",
+		xml: `<w:cellDel ${serializeTrackedChangeAttributes(change.info)}/>`
+	};
+	if (change?.type !== "tableCellMerge") return;
 	const attrs = [serializeTrackedChangeAttributes(change.info)];
 	if (change.verticalMerge) attrs.push(`w:vMerge="${change.verticalMerge === "continue" ? "cont" : "rest"}"`);
 	if (change.verticalMergeOriginal) attrs.push(`w:vMergeOrig="${change.verticalMergeOriginal === "continue" ? "cont" : "rest"}"`);
-	return [`<w:cellMerge ${attrs.join(" ")}/>`];
+	return {
+		name: "cellMerge",
+		xml: `<w:cellMerge ${attrs.join(" ")}/>`
+	};
 };
+/** The one structural revision a property set carries, as a modelled entry. */
+const structuralChangeEntry = (name, change) => [name, change?.name === name ? change.xml : ""];
 /**
 * A property set without the elements kept beside it. Only the typed values
 * decide whether a capture still describes the node; the captures themselves
@@ -82,6 +102,16 @@ function serializeMeasurement(measurement, elementName) {
 	return `<w:${elementName} ${[`w:w="${intAttr(measurement.value)}"`, `w:type="${measurement.type}"`].join(" ")}/>`;
 }
 /**
+* The side names folio writes, from the table the census reads.
+*
+* A Strict producer spells these `w:start` and `w:end`; folio rebuilds every
+* package as Transitional and writes one spelling, and taking it from the
+* generated table is what keeps the writer and the survival law's equivalence
+* from drifting apart.
+*/
+const BORDER_LEFT = TRANSITIONAL_NAME_BY_STRICT_NAME["CT_Border start"];
+const BORDER_RIGHT = TRANSITIONAL_NAME_BY_STRICT_NAME["CT_Border end"];
+/**
 * Serialize table borders (w:tblBorders or w:tcBorders)
 */
 function serializeTableBorderParts(borders) {
@@ -91,9 +121,9 @@ function serializeTableBorderParts(borders) {
 		if (xml) parts.push(xml);
 	};
 	appendBorder(borders.top, "top");
-	appendBorder(borders.left, "left");
+	appendBorder(borders.left, BORDER_LEFT);
 	appendBorder(borders.bottom, "bottom");
-	appendBorder(borders.right, "right");
+	appendBorder(borders.right, BORDER_RIGHT);
 	appendBorder(borders.insideH, "insideH");
 	appendBorder(borders.insideV, "insideV");
 	return parts;
@@ -113,6 +143,9 @@ function serializeTableCellBorders(borders) {
 	if (topRightToBottomLeft) parts.push(topRightToBottomLeft);
 	return parts.length > 0 ? `<w:tcBorders>${parts.join("")}</w:tcBorders>` : "";
 }
+/** The same rename one type over: a cell margin is a `CT_TblWidth`. */
+const MARGIN_LEFT = TRANSITIONAL_NAME_BY_STRICT_NAME["CT_TblWidth start"];
+const MARGIN_RIGHT = TRANSITIONAL_NAME_BY_STRICT_NAME["CT_TblWidth end"];
 /**
 * Serialize cell margins (w:tblCellMar or w:tcMar)
 */
@@ -120,9 +153,9 @@ function serializeCellMargins(margins, elementName) {
 	if (!margins) return "";
 	const parts = [];
 	if (margins.top) parts.push(serializeMeasurement(margins.top, "top"));
-	if (margins.left) parts.push(serializeMeasurement(margins.left, "left"));
+	if (margins.left) parts.push(serializeMeasurement(margins.left, MARGIN_LEFT));
 	if (margins.bottom) parts.push(serializeMeasurement(margins.bottom, "bottom"));
-	if (margins.right) parts.push(serializeMeasurement(margins.right, "right"));
+	if (margins.right) parts.push(serializeMeasurement(margins.right, MARGIN_RIGHT));
 	if (parts.length === 0) return "";
 	return `<w:${elementName}>${parts.join("")}</w:${elementName}>`;
 }
@@ -136,9 +169,12 @@ function serializeShading(shading) {
 	else attrs.push("w:val=\"clear\"");
 	if (shading.color?.rgb && isValidHexColor(shading.color.rgb)) attrs.push(`w:color="${escapeXmlAttribute(shading.color.rgb)}"`);
 	else if (shading.color?.auto) attrs.push("w:color=\"auto\"");
+	if (shading.color?.themeColor) attrs.push(`w:themeColor="${escapeXmlAttribute(themeColorToken(shading.color.themeColor))}"`);
+	if (shading.color?.themeTint) attrs.push(`w:themeTint="${escapeXmlAttribute(shading.color.themeTint)}"`);
+	if (shading.color?.themeShade) attrs.push(`w:themeShade="${escapeXmlAttribute(shading.color.themeShade)}"`);
 	if (shading.fill?.rgb && isValidHexColor(shading.fill.rgb)) attrs.push(`w:fill="${escapeXmlAttribute(shading.fill.rgb)}"`);
 	else if (shading.fill?.auto) attrs.push("w:fill=\"auto\"");
-	if (shading.fill?.themeColor) attrs.push(`w:themeFill="${escapeXmlAttribute(shading.fill.themeColor)}"`);
+	if (shading.fill?.themeColor) attrs.push(`w:themeFill="${escapeXmlAttribute(themeColorToken(shading.fill.themeColor))}"`);
 	if (shading.fill?.themeTint) attrs.push(`w:themeFillTint="${escapeXmlAttribute(shading.fill.themeTint)}"`);
 	if (shading.fill?.themeShade) attrs.push(`w:themeFillShade="${escapeXmlAttribute(shading.fill.themeShade)}"`);
 	if (attrs.length === 0) return "";
@@ -183,37 +219,39 @@ function serializeFloatingTableProperties(floating) {
 	if (attrs.length === 0) return "";
 	return `<w:tblpPr ${attrs.join(" ")}/>`;
 }
+/** `<w:name w:val="…"/>`, or nothing when the model holds no value. */
+const tagWithVal = (name, value) => value === void 0 ? "" : `<w:${name} w:val="${escapeXmlAttribute(value)}"/>`;
+const numberTag = (name, value) => value === void 0 ? "" : `<w:${name} w:val="${intAttr(value)}"/>`;
 /**
 * Serialize table formatting properties (w:tblPr)
 */
 function serializeTableFormatting(formatting, propertyChanges) {
 	const tableSource = verifiedSourceXml(formatting, parseTableProperties);
 	if (tableSource !== null) return withRevisionChildren(tableSource, (propertyChanges ?? []).map((change) => serializeTablePropertyChange(change)));
-	const parts = [];
-	if (formatting) {
-		if (formatting.styleId) parts.push(`<w:tblStyle w:val="${escapeXmlAttribute(formatting.styleId)}"/>`);
-		const floatingXml = serializeFloatingTableProperties(formatting.floating);
-		if (floatingXml) parts.push(floatingXml);
-		if (formatting.overlap) parts.push(`<w:tblOverlap w:val="${formatting.overlap}"/>`);
-		if (formatting.bidi !== void 0) parts.push(formatting.bidi ? "<w:bidiVisual/>" : "<w:bidiVisual w:val=\"0\"/>");
-		const widthXml = serializeMeasurement(formatting.width, "tblW");
-		if (widthXml) parts.push(widthXml);
-		if (formatting.justification) parts.push(`<w:jc w:val="${formatting.justification}"/>`);
-		const cellSpacingXml = serializeMeasurement(formatting.cellSpacing, "tblCellSpacing");
-		if (cellSpacingXml) parts.push(cellSpacingXml);
-		const indentXml = serializeMeasurement(formatting.indent, "tblInd");
-		if (indentXml) parts.push(indentXml);
-		const bordersXml = serializeTableBorders(formatting.borders, "tblBorders");
-		if (bordersXml) parts.push(bordersXml);
-		const shadingXml = serializeShading(formatting.shading);
-		if (shadingXml) parts.push(shadingXml);
-		if (formatting.layout) parts.push(`<w:tblLayout w:type="${formatting.layout}"/>`);
-		const marginsXml = serializeCellMargins(formatting.cellMargins, "tblCellMar");
-		if (marginsXml) parts.push(marginsXml);
-		const lookXml = serializeTableLook(formatting.look);
-		if (lookXml) parts.push(lookXml);
-	}
-	if (propertyChanges && propertyChanges.length > 0) parts.push(...propertyChanges.map((change) => serializeTablePropertyChange(change)));
+	const parts = serializeSequenceChildren({
+		container: "table-properties",
+		modelled: [
+			["tblStyle", formatting?.styleId ? tagWithVal("tblStyle", formatting.styleId) : ""],
+			["tblpPr", serializeFloatingTableProperties(formatting?.floating)],
+			["tblOverlap", formatting?.overlap ? `<w:tblOverlap w:val="${formatting.overlap}"/>` : ""],
+			["bidiVisual", serializeOnOffElement(formatting?.bidi, "bidiVisual")],
+			["tblStyleRowBandSize", numberTag("tblStyleRowBandSize", formatting?.rowBandSize)],
+			["tblStyleColBandSize", numberTag("tblStyleColBandSize", formatting?.columnBandSize)],
+			["tblW", serializeMeasurement(formatting?.width, "tblW")],
+			["jc", formatting?.justification ? `<w:jc w:val="${formatting.justification}"/>` : ""],
+			["tblCellSpacing", serializeMeasurement(formatting?.cellSpacing, "tblCellSpacing")],
+			["tblInd", serializeMeasurement(formatting?.indent, "tblInd")],
+			["tblBorders", serializeTableBorders(formatting?.borders, "tblBorders")],
+			["shd", serializeShading(formatting?.shading)],
+			["tblLayout", formatting?.layout ? `<w:tblLayout w:type="${formatting.layout}"/>` : ""],
+			["tblCellMar", serializeCellMargins(formatting?.cellMargins, "tblCellMar")],
+			["tblLook", serializeTableLook(formatting?.look)],
+			["tblCaption", tagWithVal("tblCaption", formatting?.caption)],
+			["tblDescription", tagWithVal("tblDescription", formatting?.description)],
+			["tblPrChange", (propertyChanges ?? []).map((change) => serializeTablePropertyChange(change)).join("")]
+		],
+		preserved: formatting?.preserved
+	});
 	if (parts.length === 0) return "";
 	return `<w:tblPr>${parts.join("")}</w:tblPr>`;
 }
@@ -227,32 +265,73 @@ function serializeTablePropertyChange(change) {
 	return `<w:tblPrChange ${attrs}>${previousTblPrInner.length > 0 ? `<w:tblPr>${previousTblPrInner}</w:tblPr>` : "<w:tblPr/>"}</w:tblPrChange>`;
 }
 /**
+* Serialize a row's table property exceptions (w:tblPrEx).
+*
+* `CT_TblPrEx` is a sequence like `CT_TblPr`, and the nine children it shares
+* with it are written by the same statements: the modelled half is keyed by
+* element name and `serializeSequenceChildren` puts it in the generated order,
+* so the exception and the property it overrides cannot come out spelled two
+* different ways.
+*/
+function serializeTablePropertyExceptions(exceptions, propertyChanges) {
+	if (exceptions === void 0 && (propertyChanges ?? []).length === 0) return "";
+	const exceptionSource = verifiedSourceXml(exceptions, parseTablePropertyExceptions);
+	if (exceptionSource !== null) return withRevisionChildren(exceptionSource, (propertyChanges ?? []).map((change) => serializeTablePropertyExceptionChange(change)));
+	const parts = serializeSequenceChildren({
+		container: "table-property-exceptions",
+		modelled: [
+			["tblW", serializeMeasurement(exceptions?.width, "tblW")],
+			["jc", exceptions?.justification ? `<w:jc w:val="${exceptions.justification}"/>` : ""],
+			["tblCellSpacing", serializeMeasurement(exceptions?.cellSpacing, "tblCellSpacing")],
+			["tblInd", serializeMeasurement(exceptions?.indent, "tblInd")],
+			["tblBorders", serializeTableBorders(exceptions?.borders, "tblBorders")],
+			["shd", serializeShading(exceptions?.shading)],
+			["tblLayout", exceptions?.layout ? `<w:tblLayout w:type="${exceptions.layout}"/>` : ""],
+			["tblCellMar", serializeCellMargins(exceptions?.cellMargins, "tblCellMar")],
+			["tblLook", serializeTableLook(exceptions?.look)],
+			["tblPrExChange", (propertyChanges ?? []).map((change) => serializeTablePropertyExceptionChange(change)).join("")]
+		],
+		preserved: exceptions?.preserved
+	});
+	return parts.length === 0 ? "<w:tblPrEx/>" : `<w:tblPrEx>${parts.join("")}</w:tblPrEx>`;
+}
+function serializeTablePropertyExceptionChange(change) {
+	return `<w:tblPrExChange ${serializeTrackedChangeAttributes(change.info)}>${serializeTablePropertyExceptions(change.previousFormatting) || "<w:tblPrEx/>"}</w:tblPrExChange>`;
+}
+/** `w:trHeight`, whose value rides `w:val` rather than `w:w`. */
+const serializeRowHeight = (formatting) => {
+	if (!formatting?.height) return "";
+	const attrs = [`w:val="${intAttr(formatting.height.value)}"`];
+	if (formatting.heightRule) attrs.push(`w:hRule="${formatting.heightRule}"`);
+	return `<w:trHeight ${attrs.join(" ")}/>`;
+};
+/**
 * Serialize table row formatting properties (w:trPr)
 */
 function serializeTableRowFormatting(formatting, propertyChanges, structuralChange) {
+	const rowStructuralChange = rowStructuralChangeXml(structuralChange);
 	const rowSource = verifiedSourceXml(formatting, parseTableRowProperties);
-	if (rowSource !== null) return withRevisionChildren(rowSource, [...rowStructuralChangeXml(structuralChange), ...(propertyChanges ?? []).map((change) => serializeTableRowPropertyChange(change))]);
-	const parts = [];
-	if (formatting) {
-		const cnfStyleXml = serializeConditionalFormatStyle(formatting.conditionalFormat);
-		if (cnfStyleXml) parts.push(cnfStyleXml);
-		if (formatting.gridBefore) parts.push(`<w:gridBefore w:val="${intAttr(formatting.gridBefore)}"/>`);
-		if (formatting.widthBefore) parts.push(`<w:wBefore w:w="${intAttr(formatting.widthBefore.value)}" w:type="${formatting.widthBefore.type}"/>`);
-		if (formatting.gridAfter) parts.push(`<w:gridAfter w:val="${intAttr(formatting.gridAfter)}"/>`);
-		if (formatting.widthAfter) parts.push(`<w:wAfter w:w="${intAttr(formatting.widthAfter.value)}" w:type="${formatting.widthAfter.type}"/>`);
-		if (formatting.cantSplit) parts.push("<w:cantSplit/>");
-		if (formatting.header) parts.push("<w:tblHeader/>");
-		if (formatting.height) {
-			const attrs = [`w:val="${intAttr(formatting.height.value)}"`];
-			if (formatting.heightRule) attrs.push(`w:hRule="${formatting.heightRule}"`);
-			parts.push(`<w:trHeight ${attrs.join(" ")}/>`);
-		}
-		if (formatting.justification) parts.push(`<w:jc w:val="${formatting.justification}"/>`);
-		if (formatting.hidden) parts.push("<w:hidden/>");
-	}
-	parts.push(...rowStructuralChangeXml(structuralChange));
-	if (propertyChanges && propertyChanges.length > 0) parts.push(...propertyChanges.map((change) => serializeTableRowPropertyChange(change)));
-	if (parts.length === 0) return "";
+	if (rowSource !== null) return withRevisionChildren(rowSource, [...rowStructuralChange ? [rowStructuralChange.xml] : [], ...(propertyChanges ?? []).map((change) => serializeTableRowPropertyChange(change))]);
+	const parts = serializeSequenceChildren({
+		container: "row-properties",
+		modelled: [
+			["cnfStyle", serializeConditionalFormatStyle(formatting?.conditionalFormat)],
+			["gridBefore", formatting?.gridBefore ? `<w:gridBefore w:val="${intAttr(formatting.gridBefore)}"/>` : ""],
+			["gridAfter", formatting?.gridAfter ? `<w:gridAfter w:val="${intAttr(formatting.gridAfter)}"/>` : ""],
+			["wBefore", serializeMeasurement(formatting?.widthBefore, "wBefore")],
+			["wAfter", serializeMeasurement(formatting?.widthAfter, "wAfter")],
+			["cantSplit", serializeOnOffElement(formatting?.cantSplit, "cantSplit")],
+			["trHeight", serializeRowHeight(formatting)],
+			["tblHeader", serializeOnOffElement(formatting?.header, "tblHeader")],
+			["jc", formatting?.justification ? `<w:jc w:val="${formatting.justification}"/>` : ""],
+			["hidden", serializeOnOffElement(formatting?.hidden, "hidden")],
+			structuralChangeEntry("ins", rowStructuralChange),
+			structuralChangeEntry("del", rowStructuralChange),
+			["trPrChange", (propertyChanges ?? []).map((change) => serializeTableRowPropertyChange(change)).join("")]
+		],
+		preserved: formatting?.preserved
+	});
+	if (parts.length === 0) return formatting === void 0 ? "" : "<w:trPr/>";
 	return `<w:trPr>${parts.join("")}</w:trPr>`;
 }
 function extractTrPrInner(trPrXml) {
@@ -286,37 +365,41 @@ function serializeConditionalFormatStyle(style) {
 	if (val === "000000000000") return "";
 	return `<w:cnfStyle w:val="${val}"/>`;
 }
+/** `w:vMerge`: no `w:val` is the continuation, so only a restart states one. */
+const serializeVerticalMerge = (vMerge) => {
+	if (vMerge === void 0) return "";
+	return vMerge === "restart" ? "<w:vMerge w:val=\"restart\"/>" : "<w:vMerge/>";
+};
 /**
 * Serialize table cell formatting properties (w:tcPr)
 */
 function serializeTableCellFormatting(formatting, propertyChanges, structuralChange) {
+	const cellStructuralChange = cellStructuralChangeXml(structuralChange);
 	const cellSource = verifiedSourceXml(formatting, parseTableCellProperties);
-	if (cellSource !== null) return withRevisionChildren(cellSource, [...cellStructuralChangeXml(structuralChange), ...(propertyChanges ?? []).map((change) => serializeTableCellPropertyChange(change))]);
-	const parts = [];
-	if (formatting) {
-		const cnfStyleXml = serializeConditionalFormatStyle(formatting.conditionalFormat);
-		if (cnfStyleXml) parts.push(cnfStyleXml);
-		const widthXml = serializeMeasurement(formatting.width, "tcW");
-		if (widthXml) parts.push(widthXml);
-		if (formatting.gridSpan && formatting.gridSpan > 1) parts.push(`<w:gridSpan w:val="${intAttr(formatting.gridSpan)}"/>`);
-		if (formatting.vMerge) if (formatting.vMerge === "restart") parts.push("<w:vMerge w:val=\"restart\"/>");
-		else parts.push("<w:vMerge/>");
-		const bordersXml = serializeTableCellBorders(formatting.borders);
-		if (bordersXml) parts.push(bordersXml);
-		const shadingXml = serializeShading(formatting.shading);
-		if (shadingXml) parts.push(shadingXml);
-		if (formatting.noWrap) parts.push("<w:noWrap/>");
-		const marginsXml = serializeCellMargins(formatting.margins, "tcMar");
-		if (marginsXml) parts.push(marginsXml);
-		if (formatting.textDirection) parts.push(`<w:textDirection w:val="${formatting.textDirection}"/>`);
-		if (formatting.fitText) parts.push("<w:tcFitText/>");
-		if (formatting.verticalAlign) parts.push(`<w:vAlign w:val="${formatting.verticalAlign}"/>`);
-		if (formatting.hideMark === true) parts.push("<w:hideMark/>");
-		else if (formatting.hideMark === false) parts.push("<w:hideMark w:val=\"off\"/>");
-	}
-	parts.push(...cellStructuralChangeXml(structuralChange));
-	if (propertyChanges && propertyChanges.length > 0) parts.push(...propertyChanges.map((change) => serializeTableCellPropertyChange(change)));
-	if (parts.length === 0) return "";
+	if (cellSource !== null) return withRevisionChildren(cellSource, [...cellStructuralChange ? [cellStructuralChange.xml] : [], ...(propertyChanges ?? []).map((change) => serializeTableCellPropertyChange(change))]);
+	const parts = serializeSequenceChildren({
+		container: "cell-properties",
+		modelled: [
+			["cnfStyle", serializeConditionalFormatStyle(formatting?.conditionalFormat)],
+			["tcW", serializeMeasurement(formatting?.width, "tcW")],
+			["gridSpan", formatting?.gridSpan && formatting.gridSpan > 1 ? `<w:gridSpan w:val="${intAttr(formatting.gridSpan)}"/>` : ""],
+			["vMerge", serializeVerticalMerge(formatting?.vMerge)],
+			["tcBorders", serializeTableCellBorders(formatting?.borders)],
+			["shd", serializeShading(formatting?.shading)],
+			["noWrap", serializeOnOffElement(formatting?.noWrap, "noWrap")],
+			["tcMar", serializeCellMargins(formatting?.margins, "tcMar")],
+			["textDirection", formatting?.textDirection ? `<w:textDirection w:val="${formatting.textDirection}"/>` : ""],
+			["tcFitText", serializeOnOffElement(formatting?.fitText, "tcFitText")],
+			["vAlign", formatting?.verticalAlign ? `<w:vAlign w:val="${formatting.verticalAlign}"/>` : ""],
+			["hideMark", serializeOnOffElement(formatting?.hideMark, "hideMark")],
+			structuralChangeEntry("cellIns", cellStructuralChange),
+			structuralChangeEntry("cellDel", cellStructuralChange),
+			structuralChangeEntry("cellMerge", cellStructuralChange),
+			["tcPrChange", (propertyChanges ?? []).map((change) => serializeTableCellPropertyChange(change)).join("")]
+		],
+		preserved: formatting?.preserved
+	});
+	if (parts.length === 0) return formatting === void 0 ? "" : "<w:tcPr/>";
 	return `<w:tcPr>${parts.join("")}</w:tcPr>`;
 }
 function extractTcPrInner(tcPrXml) {
@@ -325,7 +408,7 @@ function extractTcPrInner(tcPrXml) {
 }
 function serializeTableCellPropertyChange(change) {
 	const attrs = serializeTrackedChangeAttributes(change.info);
-	const previousTcPrInner = extractTcPrInner(serializeTableCellFormatting(change.previousFormatting) || "<w:tcPr/>");
+	const previousTcPrInner = extractTcPrInner(serializeTableCellFormatting(change.previousFormatting, void 0, change.previousStructuralChange) || "<w:tcPr/>");
 	return `<w:tcPrChange ${attrs}>${previousTcPrInner.length > 0 ? `<w:tcPr>${previousTcPrInner}</w:tcPr>` : "<w:tcPr/>"}</w:tcPrChange>`;
 }
 /**
@@ -354,17 +437,75 @@ function serializeTableGrid(table) {
 	if (gridSourceXml !== void 0) {
 		if (canonicalJson(parseTableGrid(parseXml(gridSourceXml, OOXML_NAMESPACE_SCOPE).elements?.[0] ?? null)) === canonicalJson(columnWidths)) return gridSourceXml;
 	}
-	const gridChange = replayableGridChangeXml(table.formatting?.gridChangeXml) ?? "";
+	const change = table.formatting?.gridChange;
+	const gridChange = change === void 0 ? "" : serializeTableGridChange(change);
 	if (columnWidths && columnWidths.length > 0) return `<w:tblGrid>${columnWidths.map((w) => `<w:gridCol w:w="${intAttr(w)}"/>`).join("")}${gridChange}</w:tblGrid>`;
 	const columns = gridColumnCount(table);
 	return columns === 0 && gridChange === "" ? "<w:tblGrid/>" : `<w:tblGrid>${"<w:gridCol/>".repeat(columns)}${gridChange}</w:tblGrid>`;
 }
-const GRID_CHANGE_ROOT_NAME = /* @__PURE__ */ new Set(["tblGridChange"]);
-const WORDPROCESSINGML_NAMESPACE = /* @__PURE__ */ new Set([NAMESPACES.w]);
-const replayableGridChangeXml = (gridChangeXml) => sanitizeCapturedXmlElement(gridChangeXml, {
-	allowedLocalNames: GRID_CHANGE_ROOT_NAME,
-	allowedNamespaceUris: WORDPROCESSINGML_NAMESPACE,
-	inheritedNamespaceScope: OOXML_NAMESPACE_SCOPE
+/**
+* Serialize `w:tblGridChange`: the grid a reviewer replaced, from the change's
+* own record rather than from the bytes it arrived as.
+*
+* `w:w` is optional on a `w:gridCol`, so a column the snapshot recorded no
+* measure for is written back without one; spelling it as a zero would claim a
+* width the source never stated.
+*/
+const serializeTableGridChange = ({ id, columnWidths }) => {
+	const columns = columnWidths.map((width) => width === void 0 ? "<w:gridCol/>" : `<w:gridCol w:w="${intAttr(width)}"/>`).join("");
+	return `<w:tblGridChange w:id="${intAttr(id)}"><w:tblGrid>${columns}</w:tblGrid></w:tblGridChange>`;
+};
+/**
+* What makes two rows members of the same control.
+*
+* The control's record is on every child it held, so the wrapper is rebuilt
+* by grouping consecutive children that name the same control. Equality is
+* the record's canonical spelling rather than object identity, because the
+* editor carries these records through JSON — a Yjs sync, a snapshot, a
+* structured clone — and hands back an equal record rather than the same one.
+* A wrapper that split in two there would mint a second `w:id` for one
+* control, which is the defect, not the fix.
+*
+* The cost is the other direction: two adjacent rows the author put in two
+* separate but identically spelled controls come back as one. Word mints a
+* distinct `w:id` per control, so that needs a producer that writes none; the
+* inline wrapper stack makes the same trade for the same reason.
+*/
+const contentControlKey = (properties) => canonicalJson(properties);
+/**
+* Re-open each control around the run of children that named it, outermost
+* first.
+*
+* @param depth which layer of the stack this call is opening
+*/
+const serializeControlledChildren = (children, depth) => {
+	const parts = [];
+	let index = 0;
+	while (index < children.length) {
+		const child = children[index];
+		const control = child.controls[depth];
+		if (control === void 0) {
+			parts.push(child.xml);
+			index += 1;
+			continue;
+		}
+		const key = contentControlKey(control);
+		let end = index + 1;
+		while (end < children.length) {
+			const next = children[end]?.controls[depth];
+			if (next === void 0 || contentControlKey(next) !== key) break;
+			end += 1;
+		}
+		const inner = serializeControlledChildren(children.slice(index, end), depth + 1);
+		parts.push(serializeSdtWrapper(control, inner));
+		index = end;
+	}
+	return parts.join("");
+};
+/** A capture from the sink, with the controls it sat inside when parsed. */
+const preservedChild = (xml, child) => ({
+	controls: child.contentControls ?? [],
+	xml
 });
 /**
 * Serialize cell content (paragraphs, nested tables)
@@ -375,6 +516,8 @@ function serializeCellContent(content, serializeParagraph) {
 			case "paragraph": return serializeParagraph(block);
 			case "table": return serializeTable(block, serializeParagraph);
 			case "preservedBlock": return block.xml;
+			case "bookmarkStart":
+			case "bookmarkEnd": return serializeBookmarkMarker(block);
 			default: return block;
 		}
 	});
@@ -392,13 +535,35 @@ function serializeTableCell(cell, serializeParagraph) {
 	return `<w:tc>${parts.join("")}</w:tc>`;
 }
 /**
+* A container's verbatim sink and its bookmark markers, as one positioned list.
+*
+* Both stand between the same two modelled children and both record where by
+* counting the ones before them, so one writer puts both back. Two entries
+* recorded at the same index keep their group's order, with the sink's first;
+* the source order between a capture and a bookmark sharing a slot is the one
+* thing an index cannot say, and it changes nothing a reader can see.
+*/
+const positionedChildren = (preserved, bookmarks) => {
+	if (bookmarks === void 0 || bookmarks.length === 0) return preserved;
+	return { children: [...preserved?.children ?? [], ...bookmarks.map(({ index, marker, contentControls }) => ({
+		index,
+		xml: serializeBookmarkMarker(marker),
+		...contentControls === void 0 ? {} : { contentControls }
+	}))] };
+};
+/**
 * Serialize a table row (w:tr)
 */
 function serializeTableRow(row, serializeParagraph) {
 	const parts = [];
+	const tblPrExXml = serializeTablePropertyExceptions(row.tablePropertyExceptions, row.tablePropertyExceptionChanges);
+	if (tblPrExXml) parts.push(tblPrExXml);
 	const trPrXml = serializeTableRowFormatting(row.formatting, row.propertyChanges, row.structuralChange);
 	if (trPrXml) parts.push(trPrXml);
-	parts.push(serializeWithPreservedChildren(row.cells.map((cell) => serializeTableCell(cell, serializeParagraph)), row.preserved));
+	parts.push(serializeControlledChildren(withPreservedChildren(row.cells.map((cell) => ({
+		controls: cell.contentControls ?? [],
+		xml: serializeTableCell(cell, serializeParagraph)
+	})), positionedChildren(row.preserved, row.bookmarks), preservedChild), 0));
 	const attrs = serializePreservedAttributes([], row.preservedAttributes);
 	return `<w:tr${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>${parts.join("")}</w:tr>`;
 }
@@ -412,7 +577,10 @@ function serializeTable(table, serializeParagraph) {
 	return `<w:tbl>${[
 		serializeTableFormatting(table.formatting, table.propertyChanges) || "<w:tblPr/>",
 		serializeTableGrid(table),
-		serializeWithPreservedChildren(table.rows.map((row) => serializeTableRow(row, serializeParagraph)), table.preserved)
+		serializeControlledChildren(withPreservedChildren(table.rows.map((row) => ({
+			controls: row.contentControls ?? [],
+			xml: serializeTableRow(row, serializeParagraph)
+		})), positionedChildren(table.preserved, table.bookmarks), preservedChild), 0)
 	].join("")}</w:tbl>`;
 }
 /**

package/dist/docx/serializer/textFormattingSerializer.d.ts

@@ -1,16 +1,40 @@
 import { document_d_exports } from "../../types/document.js";
+import { DeclaredChild } from "../containerChildren.gen.js";
 //#region src/docx/serializer/textFormattingSerializer.d.ts
-type ClassifiedShadingField = "color" | "fill" | "pattern";
+type ClassifiedShadingField = "color" | "fill" | "pattern" | "preservedAttributes";
 type ExhaustiveShadingProperties = document_d_exports.ExhaustiveFields<document_d_exports.ShadingProperties, ClassifiedShadingField>;
-type ClassifiedTextFormattingField = "bold" | "boldCs" | "italic" | "italicCs" | "underline" | "strike" | "doubleStrike" | "vertAlign" | "smallCaps" | "allCaps" | "hidden" | "noProof" | "color" | "highlight" | "shading" | "fontSize" | "fontSizeCs" | "fontFamily" | "language" | "spacing" | "position" | "scale" | "kerning" | "effect" | "emphasisMark" | "emboss" | "imprint" | "outline" | "shadow" | "rtl" | "cs" | "styleId";
+type ClassifiedTextFormattingField = "bold" | "boldCs" | "italic" | "italicCs" | "underline" | "strike" | "doubleStrike" | "vertAlign" | "smallCaps" | "allCaps" | "hidden" | "noProof" | "color" | "highlight" | "shading" | "fontSize" | "fontSizeCs" | "fontFamily" | "language" | "spacing" | "position" | "scale" | "kerning" | "effect" | "emphasisMark" | "emboss" | "imprint" | "outline" | "shadow" | "rtl" | "cs" | "styleId" | "preserved";
 type ExhaustiveTextFormatting = document_d_exports.ExhaustiveFields<document_d_exports.TextFormatting, ClassifiedTextFormattingField>;
+/**
+ * A child of this `w:rPr` that another record owns, named by its declared
+ * child so the sequence places it.
+ *
+ * A run's `w:rPrChange` and the paragraph mark's revision and `w:specVanish`
+ * are read by the run's and the paragraph's own records, so they arrive here
+ * as markup rather than as a field. Naming each one means the schema decides
+ * where it goes, exactly as it does for the modelled children.
+ */
+type OwnedRunPropertyChild = readonly [name: DeclaredChild<"run-properties">, xml: string];
 /**
  * Serialize shading properties (w:shd)
  */
 declare function serializeShading(shading: ExhaustiveShadingProperties | undefined): string;
 /**
- * Serialize text formatting properties to w:rPr XML
+ * The single `w:rPr` writer.
+ *
+ * A run, the paragraph mark, a style, a numbering level and the snapshot
+ * inside either kind of `w:rPrChange` all write their run properties through
+ * here, so none of them can grow its own order or its own idea of which
+ * children exist. `EG_RPrBase` is an `xsd:choice` referenced
+ * `maxOccurs="unbounded"`, so a `w:rPr` in any order is valid and the order
+ * below is a canonical form rather than a validity rule: it is the one Word
+ * writes, and writing it from the generated declared-child list is what stops
+ * two of folio's serializers from disagreeing. The restatement is what
+ * drifted, and it is why folio wrote `w:vanish` before `w:noProof` while the
+ * schema declares the reverse.
+ *
+ * @param owned children a sibling record holds; see {@link OwnedRunPropertyChild}
  */
-declare function serializeTextFormatting(input: ExhaustiveTextFormatting | undefined): string;
+declare function serializeTextFormatting(input: ExhaustiveTextFormatting | undefined, owned?: readonly OwnedRunPropertyChild[]): string;
 //#endregion
 export { serializeShading, serializeTextFormatting };