@stll/folio-core 0.46.0 → 0.47.0

package/dist/docx/selectiveXmlPatch.js

@@ -1,4 +1,5 @@
 import { patchBreaksCommentRangeBalance } from "./commentRangeIntegrity.js";
+import { resolveParagraphIdentities } from "./paraIdAttribute.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { WORDPROCESSINGML_NAMESPACE_URIS, cloneElement, findAttributeByNamespaceUri, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespacePrefix, getNamespaceUri, parseXmlDocument } from "./xmlParser.js";
 //#region src/docx/selectiveXmlPatch.ts
@@ -95,24 +96,43 @@ function extractParagraphXml(serializedXml, paraId) {
 function buildParagraphOffsetIndex(xml) {
 	const seenCount = /* @__PURE__ */ new Map();
 	const ranges = /* @__PURE__ */ new Map();
-	const stack = [];
-	let pos = 0;
-	const noteOpen = (paraId) => {
-		if (paraId) seenCount.set(paraId, (seenCount.get(paraId) ?? 0) + 1);
-	};
-	const noteRange = (paraId, start, end) => {
-		if (paraId) ranges.set(paraId, {
+	for (const { start, end, paraId } of scanParagraphs(xml)) {
+		if (paraId === void 0) continue;
+		seenCount.set(paraId, (seenCount.get(paraId) ?? 0) + 1);
+		if (end > start) ranges.set(paraId, {
 			start,
 			end
 		});
-	};
+	}
+	const index = /* @__PURE__ */ new Map();
+	for (const [id, range] of ranges) if (seenCount.get(id) === 1) index.set(id, range);
+	return index;
+}
+/**
+* Every `<w:p>` element of `xml`, in the document order of its opening tags,
+* with the `w14:paraId` that tag carries.
+*
+* Document order is what makes the array an ordinal space: the *n*th entry of
+* the source part and the *n*th entry of the model's serialization name the
+* same paragraph, which is the only way to address a paragraph the producer
+* gave no id. A `<w:p>` nested inside another (inside `mc:AlternateContent`,
+* a text box) is one entry of its own, exactly as
+* {@link countParagraphElements} counts it, so the two never disagree about
+* what an ordinal is. An unterminated paragraph keeps `end === start`: it
+* occupies its ordinal but no splice can be built from it.
+*/
+function scanParagraphs(xml) {
+	const paragraphs = [];
+	const open = [];
+	let pos = 0;
 	while (pos < xml.length) {
 		const tagStart = xml.indexOf("<", pos);
 		if (tagStart === -1) break;
 		if (xml.startsWith("</w:p>", tagStart)) {
-			const frame = stack.pop();
+			const slot = open.pop();
 			const end = tagStart + 6;
-			if (frame) noteRange(frame.paraId, frame.start, end);
+			const paragraph = slot === void 0 ? void 0 : paragraphs[slot];
+			if (paragraph) paragraph.end = end;
 			pos = end;
 			continue;
 		}
@@ -123,18 +143,23 @@ function buildParagraphOffsetIndex(xml) {
 		const tagEnd = xml.indexOf(">", tagStart);
 		if (tagEnd === -1) break;
 		const openTag = xml.slice(tagStart, tagEnd + 1);
-		const paraId = /\bw14:paraId="(?<id>[^"]*)"/u.exec(openTag)?.groups?.["id"];
-		noteOpen(paraId);
-		if (xml[tagEnd - 1] === "/") noteRange(paraId, tagStart, tagEnd + 1);
-		else stack.push({
+		const paraId = /\bw14:paraId="(?<id>[^"]+)"/u.exec(openTag)?.groups?.["id"];
+		if (xml[tagEnd - 1] === "/") paragraphs.push({
 			start: tagStart,
+			end: tagEnd + 1,
 			paraId
 		});
+		else {
+			open.push(paragraphs.length);
+			paragraphs.push({
+				start: tagStart,
+				end: tagStart,
+				paraId
+			});
+		}
 		pos = tagEnd + 1;
 	}
-	const index = /* @__PURE__ */ new Map();
-	for (const [id, range] of ranges) if (seenCount.get(id) === 1) index.set(id, range);
-	return index;
+	return paragraphs;
 }
 /**
 * Count <w:p> elements in an XML string (top-level paragraph count).
@@ -163,40 +188,140 @@ function collectParaIds(xml) {
 	}
 	return ids;
 }
+/** Paragraph ids folio writes and this module may have to remove again. */
+const MINTED_PARA_ID_ATTRIBUTE = /\sw14:(?:para|text)Id="[^"]*"/gu;
 /**
-* Validate that a selective patch can be safely applied.
+* The replacement for a paragraph whose source open tag carries no paraId.
 *
-* Checks:
-* - All changed paraIds exist in original XML (exactly once)
-* - All changed paraIds exist in serialized XML (exactly once)
-* - Paragraph count matches between original and serialized (unless disabled)
+* The model always has a key, because folio mints one for every paragraph that
+* arrives without one, and the serializer writes whatever key the model holds.
+* Writing a minted key into the package would upgrade a producer's id-less
+* document to a partly-id'd one on any edit, declare a `w14` namespace the
+* part never had, and turn an id the minter itself calls positional into an
+* authored one the next reader trusts. So the save keeps the author's
+* convention: `ensureParaIds` is the one pass that gives a package ids, and it
+* runs when a host asks for it. An id the source *does* carry (a `w14:textId`
+* beside no paraId) is the author's and stays.
 */
-function validatePatchSafety(originalXml, serializedXml, changedIds, options = {}) {
-	if (changedIds.size === 0) return { safe: true };
+const withoutMintedIds = (paragraphXml, sourceOpenTag) => {
+	const tagEnd = paragraphXml.indexOf(">");
+	if (tagEnd === -1) return paragraphXml;
+	return paragraphXml.slice(0, tagEnd + 1).replace(MINTED_PARA_ID_ATTRIBUTE, (attribute) => sourceOpenTag.includes(attribute.trim()) ? attribute : "") + paragraphXml.slice(tagEnd + 1);
+};
+/**
+* Route every changed paragraph from the model's serialization to its region
+* of the source part.
+*
+* One owner for the question the patch turns on: *which paragraph of the file
+* is this model paragraph?* {@link resolveParagraphIdentities} answers it per
+* paragraph, and the union is consumed exhaustively here, so a paragraph the
+* source names by id keeps the id lookup — robust to any reordering — and one
+* the source never named falls back to its ordinal, which is sound exactly
+* when the identity plan says the two sequences line up. A package with ids on
+* some paragraphs and not others therefore needs no special case: its authored
+* ids are the witnesses that prove the ordinals for the rest.
+*/
+const routeChangedParagraphs = (originalXml, serializedXml, changedIds) => {
+	const original = scanParagraphs(originalXml);
+	const serialized = scanParagraphs(serializedXml);
+	const { identities, ordinalsAligned } = resolveParagraphIdentities({
+		sourceParaIds: original.map(({ paraId }) => paraId),
+		serializedParaIds: serialized.map(({ paraId }) => paraId)
+	});
 	const originalParaIds = collectParaIds(originalXml);
 	const serializedParaIds = collectParaIds(serializedXml);
+	const identityByParaId = /* @__PURE__ */ new Map();
+	for (const identity of identities) if (identity.type !== "anonymous" && serializedParaIds.get(identity.paraId) === 1) identityByParaId.set(identity.paraId, identity);
+	const splices = [];
 	for (const id of changedIds) {
-		const origCount = originalParaIds.get(id) || 0;
-		if (origCount === 0) return {
-			safe: false,
-			reason: `paraId-not-found-in-original: ${id}`
-		};
-		if (origCount > 1) return {
-			safe: false,
+		const originalCount = originalParaIds.get(id) ?? 0;
+		if (originalCount > 1) return {
+			type: "refused",
 			reason: `duplicate-paraId-in-original: ${id}`
 		};
-	}
-	for (const id of changedIds) {
-		const serCount = serializedParaIds.get(id) || 0;
-		if (serCount === 0) return {
-			safe: false,
+		const serializedCount = serializedParaIds.get(id) ?? 0;
+		if (originalCount === 1 && serializedCount === 0) return {
+			type: "refused",
 			reason: `paraId-not-found-in-serialized: ${id}`
 		};
-		if (serCount > 1) return {
-			safe: false,
+		if (serializedCount === 0) return {
+			type: "refused",
+			reason: `paraId-not-found-in-original: ${id}`
+		};
+		if (serializedCount > 1) return {
+			type: "refused",
 			reason: `duplicate-paraId-in-serialized: ${id}`
 		};
+		const identity = identityByParaId.get(id);
+		if (!identity) return {
+			type: "refused",
+			reason: `paraId-not-found-in-serialized: ${id}`
+		};
+		const replacement = serialized[identity.ordinal];
+		if (!replacement || replacement.end <= replacement.start) return {
+			type: "refused",
+			reason: `unterminated-paragraph: ${id}`
+		};
+		const newXml = serializedXml.slice(replacement.start, replacement.end);
+		switch (identity.type) {
+			case "authored": {
+				const offsets = findParagraphOffsets(originalXml, identity.paraId);
+				if (!offsets) return {
+					type: "refused",
+					reason: `paraId-not-found-in-original: ${id}`
+				};
+				splices.push({
+					start: offsets.start,
+					end: offsets.end,
+					newXml
+				});
+				break;
+			}
+			case "minted": {
+				if (!ordinalsAligned) return {
+					type: "refused",
+					reason: `unaligned-paragraph-ordinals: ${id}`
+				};
+				const source = original[identity.ordinal];
+				if (!source || source.end <= source.start) return {
+					type: "refused",
+					reason: `paraId-not-found-in-original: ${id}`
+				};
+				splices.push({
+					start: source.start,
+					end: source.end,
+					newXml: withoutMintedIds(newXml, originalXml.slice(source.start, source.end))
+				});
+				break;
+			}
+			case "anonymous": return {
+				type: "refused",
+				reason: `paraId-not-found-in-serialized: ${id}`
+			};
+			default: return identity;
+		}
 	}
+	return {
+		type: "routed",
+		splices
+	};
+};
+/**
+* Validate that a selective patch can be safely applied.
+*
+* Checks:
+* - Every changed paraId routes to one region of the original XML, by its
+*   authored id or, when the producer wrote none, by its paragraph ordinal
+* - All changed paraIds exist in serialized XML (exactly once)
+* - Paragraph count matches between original and serialized (unless disabled)
+*/
+function validatePatchSafety(originalXml, serializedXml, changedIds, options = {}) {
+	if (changedIds.size === 0) return { safe: true };
+	const routing = routeChangedParagraphs(originalXml, serializedXml, changedIds);
+	if (routing.type === "refused") return {
+		safe: false,
+		reason: routing.reason
+	};
 	if (options.checkParagraphCount === false) return { safe: true };
 	const originalCount = countParagraphElements(originalXml);
 	const serializedCount = countParagraphElements(serializedXml);
@@ -261,19 +386,8 @@ const spliceXml = (xml, splices) => {
 * repack, whose parts are all re-serialized from one model.
 */
 function spliceChangedParagraphs(originalXml, serializedXml, changedIds) {
-	const replacements = [];
-	for (const paraId of changedIds) {
-		const origOffsets = findParagraphOffsets(originalXml, paraId);
-		if (!origOffsets) return null;
-		const newXml = extractParagraphXml(serializedXml, paraId);
-		if (!newXml) return null;
-		replacements.push({
-			start: origOffsets.start,
-			end: origOffsets.end,
-			newXml
-		});
-	}
-	return spliceXml(originalXml, replacements);
+	const routing = routeChangedParagraphs(originalXml, serializedXml, changedIds);
+	return routing.type === "refused" ? null : spliceXml(originalXml, routing.splices);
 }
 /**
 * Depth-count the end of the element that opens at `start` (an `<openLiteral…>`
@@ -616,7 +730,7 @@ function buildNumberingElementOffsetIndex(xml, kind) {
 	}
 	return index;
 }
-const SYNTHETIC_NUM_FMT_PATTERN = /<w:numFmt w:val="decimalZero(?<width>[345])"\/>/u;
+const CUSTOM_NUM_FMT_PATTERN = /<w:numFmt w:val="custom"(?: w:format="(?<format>[^"]*)")?\/>/u;
 /**
 * The numbering definitions whose current serialization differs from the
 * baseline (re-parsed original) serialization — the ones actually edited. An id
@@ -653,30 +767,15 @@ function extractLevelNumFmtElement(levelXml) {
 	return match ? match[0] : null;
 }
 /**
-* A valid OOXML custom number format equivalent to a `decimalZero{width}`
-* synthetic value: a zero-padded first token folio's parser reads back to the
-* same width. Used only when the original element cannot be resolved, so a
-* changed definition never emits a non-OOXML synthetic value.
+* The `@w:format` an original level's number-format element declares, or null
+* when it declares no custom format at all. Telling a preserved format from an
+* edited one is what keeps a genuine change from being reverted.
 */
-function reconstructCustomNumFmt(width) {
-	return `<w:numFmt w:val="custom" w:format="${`${"0".repeat(Number.parseInt(width, 10) - 1)}1`}"/>`;
-}
-/**
-* The synthetic `decimalZero{width}` width the parser would derive from an
-* original level's number-format element (its custom `w:format` first token),
-* as the same digit-count string the SYNTHETIC_NUM_FMT_PATTERN captures. Mirrors
-* `parseCustomNumberFormat` (first comma-separated token, `^0+1$`, clamped to 5).
-* Returns null when the element carries no zero-padded custom format, so a
-* genuine format change is never mistaken for the original.
-*/
-function originalNumFmtWidth(numFmtElement) {
+function originalCustomNumFmtFormat(numFmtElement) {
 	for (const match of numFmtElement.matchAll(/<w:numFmt\b[^>]*\/>/gu)) {
 		const tag = match[0];
 		if (!/\bw:val="custom"/u.test(tag)) continue;
-		const format = /\bw:format="(?<format>[^"]*)"/u.exec(tag)?.groups?.["format"];
-		if (format === void 0) continue;
-		const firstToken = format.split(",")[0]?.trim() ?? "";
-		return /^0+1$/u.test(firstToken) ? String(Math.min(firstToken.length, 5)) : null;
+		return /\bw:format="(?<format>[^"]*)"/u.exec(tag)?.groups?.["format"] ?? null;
 	}
 	return null;
 }
@@ -709,21 +808,19 @@ function withXmlnsDeclarations(fragmentXml, xmlnsDecls) {
 	return fragmentXml.slice(0, nameEnd) + additions.join("") + fragmentXml.slice(nameEnd);
 }
 /**
-* Swap each synthetic `decimalZero{3,4,5}` numFmt in a re-serialized definition
-* back to the original level's number-format element.
+* Swap each re-serialized custom numFmt back to the original level's
+* number-format element.
 *
-* folio's parser collapses a Word custom / mc:AlternateContent number format
-* into a synthetic `decimalZero{3,4,5}` value the model cannot re-emit as valid
-* OOXML. When an unrelated field of the definition is edited, the whole
-* definition is re-serialized, so without this pass the level's custom format
-* would be replaced by an invalid value and lost on reparse. For each level
-* whose re-emitted numFmt is synthetic, restore the original level's numFmt
-* element by ilvl ONLY when the model's synthetic value still matches the
-* original's (the format was not edited, just preserved past an unrelated
-* change). When the model deliberately changed the width (e.g. decimalZero4 ->
-* decimalZero5), or the original cannot be resolved, emit a valid OOXML custom
-* format for the CURRENT width instead — honoring the edit and never leaving a
-* synthetic value.
+* The model holds a custom format as `custom` plus its `@w:format`, which the
+* serializer re-emits as a bare `<w:numFmt w:val="custom" w:format="…"/>`. That
+* is valid OOXML and reparses to the same model, but it is not what the source
+* wrote: Word wraps a custom format in an `mc:AlternateContent` whose Fallback
+* carries a plain format for pre-w14 readers, and the model has no field for
+* the Fallback. When an unrelated field of the definition is edited the whole
+* definition is re-serialized, so without this pass that wrapper would be
+* flattened away. Restore it by ilvl only when the model's format still matches
+* the original's; a level whose format was actually edited keeps the model's
+* own element, which is the edit.
 */
 function restoreLevelNumFmts(originalDefXml, currentDefXml) {
 	const replacements = [];
@@ -732,21 +829,20 @@ function restoreLevelNumFmts(originalDefXml, currentDefXml) {
 		const curOffsets = findElementByIdAttr(currentDefXml, LEVEL_OPEN_LITERAL, LEVEL_CLOSE_TAG, LEVEL_ID_ATTR, ilvl);
 		if (!curOffsets) continue;
 		const curLevel = currentDefXml.slice(curOffsets.start, curOffsets.end);
-		const synthetic = SYNTHETIC_NUM_FMT_PATTERN.exec(curLevel);
-		if (!synthetic) continue;
+		const custom = CUSTOM_NUM_FMT_PATTERN.exec(curLevel);
+		if (!custom) continue;
 		const origLevel = extractElementByIdAttr(originalDefXml, LEVEL_OPEN_LITERAL, LEVEL_CLOSE_TAG, LEVEL_ID_ATTR, ilvl);
-		const currentWidth = synthetic.groups["width"];
+		const currentFormat = custom.groups?.["format"] ?? null;
 		const original = origLevel ? extractLevelNumFmtElement(origLevel) : null;
-		let replacement;
-		if (original && origLevel && originalNumFmtWidth(original) === currentWidth) replacement = withXmlnsDeclarations(original, {
+		if (!original || !origLevel || originalCustomNumFmtFormat(original) !== currentFormat) continue;
+		const ancestorXmlns = {
 			...collectXmlnsFromOpeningTag(originalDefXml),
 			...collectXmlnsFromOpeningTag(origLevel)
-		});
-		else replacement = reconstructCustomNumFmt(currentWidth);
+		};
 		const restoredLevel = spliceXml(curLevel, [{
-			start: synthetic.index,
-			end: synthetic.index + synthetic[0].length,
-			newXml: replacement
+			start: custom.index,
+			end: custom.index + custom[0].length,
+			newXml: withXmlnsDeclarations(original, ancestorXmlns)
 		}]);
 		if (restoredLevel === null) continue;
 		replacements.push({
@@ -898,12 +994,12 @@ function appendNumberingDefs(xml, currentXml, added) {
 	return head + abstractXmls.join("") + middle + numXmls.join("") + tail;
 }
 /**
-* For an added abstract definition that still carries a synthetic numFmt, find
+* For an added abstract definition that carries a flattened custom numFmt, find
 * the original abstract it was cloned from (same serialized body apart from the
 * id) and restore the level formats from it.
 */
 function restoreClonedLevelNumFmts(originalXml, currentXml, addedDefXml, addedId) {
-	if (!SYNTHETIC_NUM_FMT_PATTERN.test(addedDefXml)) return addedDefXml;
+	if (!CUSTOM_NUM_FMT_PATTERN.test(addedDefXml)) return addedDefXml;
 	const addedBody = stripAbstractNumId(addedDefXml, addedId);
 	const originalIds = collectElementIds(originalXml, NUMBERING_OPEN_LITERAL.abstractNum, NUMBERING_ID_ATTR.abstractNum);
 	for (const [id] of originalIds) {
@@ -919,4 +1015,4 @@ function escapeRegExp(str) {
 	return str.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
 //#endregion
-export { appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNotePartXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNoteParaIds, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, patchNumberingDefinitions, spliceXml, validatePatchSafety };
+export { appendNumberingDefs, buildParagraphOffsetIndex, buildPatchedDocumentXml, buildPatchedNotePartXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNoteParaIds, collectChangedNumberingDefs, collectParaIds, countParagraphElements, extractParagraphXml, findParagraphOffsets, isXmlNameBoundary, patchNumberingDefinitions, scanParagraphs, spliceXml, validatePatchSafety };

package/dist/docx/serializer/blockSdtSerializer.js

@@ -1,102 +1,8 @@
-import { reconcileRawSdtPr } from "../sdtPropertiesPatch.js";
-import { isSingleWellFormedElement } from "./xmlUtils.js";
-import { escapeXmlAttribute } from "@stll/docx-core";
+import { serializeSdtWrapper } from "./sdtPropertiesSerializer.js";
 //#region src/docx/serializer/blockSdtSerializer.ts
-/**
-* Block-level SDT serializer.
-*
-* Replays `<w:sdtPr>` (and `<w:sdtEndPr>` when present) verbatim from the
-* `rawPropertiesXml` / `rawEndPropertiesXml` strings captured by the parser.
-* That keeps OOXML element order intact (`CT_SdtPr` is an `xsd:sequence`,
-* ECMA-376 §17.5.2) and round-trips unmodeled features — `w:dataBinding`,
-* `w15:repeatingSection`, `@lastValue`, custom XML mappings — without us
-* having to enumerate them.
-*
-* If a `BlockSdt` was constructed programmatically (no parsed snapshot to
-* replay), fall back to a minimal projection from the modeled fields so the
-* result is still a valid `<w:sdt>`.
-*
-* Sharing the helper between the document body and the header/footer
-* serializers keeps body↔HF parity in one place.
-*/
-function serializeFallbackSdtPr(props) {
-	const parts = [];
-	if (props.id !== void 0) parts.push(`<w:id w:val="${props.id}"/>`);
-	if (props.alias) parts.push(`<w:alias w:val="${escapeXmlAttribute(props.alias)}"/>`);
-	if (props.tag) parts.push(`<w:tag w:val="${escapeXmlAttribute(props.tag)}"/>`);
-	if (props.lock) parts.push(`<w:lock w:val="${props.lock}"/>`);
-	if (props.placeholder) parts.push(`<w:placeholder><w:docPart w:val="${escapeXmlAttribute(props.placeholder)}"/></w:placeholder>`);
-	if (props.showingPlaceholder) parts.push("<w:showingPlcHdr/>");
-	switch (props.sdtType) {
-		case "plainText":
-			parts.push("<w:text/>");
-			break;
-		case "date": {
-			const fullDateAttr = props.dateValueISO ? ` w:fullDate="${escapeXmlAttribute(props.dateValueISO)}"` : "";
-			const formatChild = props.dateFormat ? `<w:dateFormat w:val="${escapeXmlAttribute(props.dateFormat)}"/>` : "";
-			if (fullDateAttr || formatChild) parts.push(`<w:date${fullDateAttr}>${formatChild}</w:date>`);
-			else parts.push("<w:date/>");
-			break;
-		}
-		case "dropdown":
-		case "comboBox": {
-			const tag = props.sdtType === "dropdown" ? "w:dropDownList" : "w:comboBox";
-			const items = (props.listItems ?? []).map((item) => `<w:listItem w:displayText="${escapeXmlAttribute(item.displayText)}" w:value="${escapeXmlAttribute(item.value)}"/>`).join("");
-			parts.push(`<${tag}>${items}</${tag}>`);
-			break;
-		}
-		case "checkbox": {
-			const val = props.checked ? "1" : "0";
-			parts.push(`<w14:checkbox><w14:checked w14:val="${val}"/></w14:checkbox>`);
-			break;
-		}
-		case "picture":
-			parts.push("<w:picture/>");
-			break;
-		case "buildingBlockGallery":
-			parts.push("<w:docPartObj/>");
-			break;
-		case "group":
-			parts.push("<w:group/>");
-			break;
-		default: break;
-	}
-	return `<w:sdtPr>${parts.join("")}</w:sdtPr>`;
-}
-/**
-* `properties.dropdownLastValue` is the only record of what was selected.
-*
-* The XSD default of `@w:lastValue` is the empty string, so "never selected",
-* "cleared" and "selected" are three distinguishable states, and the body's
-* display text is evidence for none of them: it is equally the placeholder of
-* a dropdown nobody has touched, and a displayText shared by two list items
-* picks the wrong sibling. The parser records the authored `@w:lastValue` and
-* `setContentControlValue` records a pick; what neither wrote is no selection.
-*
-* `""` is a value a producer can author (`<w:listItem w:value=""/>`), so
-* presence is the test, not truthiness.
-*/
-function extractDropdownLastValue(blockSdt) {
-	if (blockSdt.properties.sdtType !== "dropdown" && blockSdt.properties.sdtType !== "comboBox") return;
-	return blockSdt.properties.dropdownLastValue;
-}
-function extractDateFullDate(blockSdt) {
-	if (blockSdt.properties.sdtType !== "date") return;
-	const iso = blockSdt.properties.dateValueISO;
-	return iso !== void 0 && iso.length > 0 ? iso : void 0;
-}
 function serializeBlockSdt(blockSdt, serializeChild) {
 	const props = blockSdt.properties;
-	const baseSdtPr = props.rawPropertiesXml && isSingleWellFormedElement(props.rawPropertiesXml, "sdtPr") ? props.rawPropertiesXml : serializeFallbackSdtPr(props);
-	const dateFullDate = extractDateFullDate(blockSdt);
-	const dropdownLastValue = extractDropdownLastValue(blockSdt);
-	const sdtPrXml = reconcileRawSdtPr(baseSdtPr, props, {
-		...dateFullDate !== void 0 ? { dateFullDate } : {},
-		...dropdownLastValue !== void 0 ? { dropdownLastValue } : {}
-	});
-	const sdtEndPrXml = props.rawEndPropertiesXml && isSingleWellFormedElement(props.rawEndPropertiesXml, "sdtEndPr") ? props.rawEndPropertiesXml : "";
-	const contentXml = blockSdt.content.map(serializeChild).join("");
-	return `<w:sdt>${sdtPrXml}${sdtEndPrXml}${props.rawSdtChildrenBeforeContent ?? ""}<w:sdtContent>${contentXml}</w:sdtContent>${props.rawSdtChildrenAfterContent ?? ""}</w:sdt>`;
+	return serializeSdtWrapper(props, blockSdt.content.map(serializeChild).join(""));
 }
 //#endregion
 export { serializeBlockSdt };

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

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../../types/document.js";
 //#region src/docx/serializer/borderSerializer.d.ts
-type ClassifiedBorderField = "style" | "color" | "size" | "space" | "shadow" | "frame" | "artRelationshipId" | "topLeftArtRelationshipId" | "topRightArtRelationshipId" | "bottomLeftArtRelationshipId" | "bottomRightArtRelationshipId";
+type ClassifiedBorderField = "style" | "color" | "size" | "space" | "shadow" | "frame" | "artRelationshipId" | "topLeftArtRelationshipId" | "topRightArtRelationshipId" | "bottomLeftArtRelationshipId" | "bottomRightArtRelationshipId" | "preservedAttributes";
 type ExhaustiveBorder = document_d_exports.ExhaustiveFields<document_d_exports.BorderSpec, ClassifiedBorderField>;
 /**
  * Serialize a single border element (`<w:top .../>`, `<w:left .../>`, ...).
@@ -16,10 +16,10 @@ type ExhaustiveBorder = document_d_exports.ExhaustiveFields<document_d_exports.B
  * turned-off side; those are emitted when present so the value survives a
  * save→parse round-trip and is not otherwise added.
  *
- * `style` and the color values come straight from the parsed DOCX (the parser
- * casts `w:val`/`w:color` without validating the enum), so they are
- * untrusted and are `escapeXmlAttribute`'d before re-entering XML attributes; for valid
- * documents these are enum/hex values, so escaping is a no-op.
+ * An unrecognised `w:val` and the color values come straight from the parsed
+ * DOCX, so they are untrusted and are `escapeXmlAttribute`'d before re-entering
+ * XML attributes; for valid documents these are enum/hex values, so escaping is
+ * a no-op.
  */
 declare function serializeBorder(input: ExhaustiveBorder | undefined, elementName: string): string;
 //#endregion

package/dist/docx/serializer/borderSerializer.js

@@ -1,5 +1,7 @@
+import { serializePreservedAttributes } from "../attributeRemainder.js";
 import { intAttr } from "./xmlUtils.js";
 import { escapeXmlAttribute } from "@stll/docx-core";
+import { borderStyleToken, themeColorToken } from "@stll/docx-core/model";
 //#region src/docx/serializer/borderSerializer.ts
 /**
 * Serialize a single border element (`<w:top .../>`, `<w:left .../>`, ...).
@@ -15,22 +17,22 @@ import { escapeXmlAttribute } from "@stll/docx-core";
 * turned-off side; those are emitted when present so the value survives a
 * save→parse round-trip and is not otherwise added.
 *
-* `style` and the color values come straight from the parsed DOCX (the parser
-* casts `w:val`/`w:color` without validating the enum), so they are
-* untrusted and are `escapeXmlAttribute`'d before re-entering XML attributes; for valid
-* documents these are enum/hex values, so escaping is a no-op.
+* An unrecognised `w:val` and the color values come straight from the parsed
+* DOCX, so they are untrusted and are `escapeXmlAttribute`'d before re-entering
+* XML attributes; for valid documents these are enum/hex values, so escaping is
+* a no-op.
 */
 function serializeBorder(input, elementName) {
 	if (!input) return "";
-	const { style, color, size, space, shadow, frame, artRelationshipId, topLeftArtRelationshipId, topRightArtRelationshipId, bottomLeftArtRelationshipId, bottomRightArtRelationshipId } = input;
-	const attrs = [`w:val="${escapeXmlAttribute(style)}"`];
+	const { style, color, size, space, shadow, frame, artRelationshipId, topLeftArtRelationshipId, topRightArtRelationshipId, bottomLeftArtRelationshipId, bottomRightArtRelationshipId, preservedAttributes } = input;
+	const attrs = [`w:val="${escapeXmlAttribute(borderStyleToken(style))}"`];
 	if (size !== void 0) attrs.push(`w:sz="${intAttr(size)}"`);
 	if (space !== void 0) attrs.push(`w:space="${intAttr(space)}"`);
 	if (color) {
 		const { auto, rgb, themeColor, themeTint, themeShade } = color;
 		if (auto) attrs.push("w:color=\"auto\"");
 		else if (rgb) attrs.push(`w:color="${escapeXmlAttribute(rgb)}"`);
-		if (themeColor) attrs.push(`w:themeColor="${escapeXmlAttribute(themeColor)}"`);
+		if (themeColor) attrs.push(`w:themeColor="${escapeXmlAttribute(themeColorToken(themeColor))}"`);
 		if (themeTint) attrs.push(`w:themeTint="${escapeXmlAttribute(themeTint)}"`);
 		if (themeShade) attrs.push(`w:themeShade="${escapeXmlAttribute(themeShade)}"`);
 	}
@@ -41,7 +43,7 @@ function serializeBorder(input, elementName) {
 	if (topRightArtRelationshipId) attrs.push(`r:topRight="${escapeXmlAttribute(topRightArtRelationshipId)}"`);
 	if (bottomLeftArtRelationshipId) attrs.push(`r:bottomLeft="${escapeXmlAttribute(bottomLeftArtRelationshipId)}"`);
 	if (bottomRightArtRelationshipId) attrs.push(`r:bottomRight="${escapeXmlAttribute(bottomRightArtRelationshipId)}"`);
-	return `<w:${elementName} ${attrs.join(" ")}/>`;
+	return `<w:${elementName} ${serializePreservedAttributes(attrs, preservedAttributes).join(" ")}/>`;
 }
 //#endregion
 export { serializeBorder };

package/dist/docx/serializer/documentSerializer.js

@@ -1,4 +1,5 @@
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
+import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { resetAutoIdCounter } from "./runSerializer.js";
@@ -43,6 +44,8 @@ function serializeBlockContent(block) {
 		case "table": return serializeTable(block, serializeParagraph);
 		case "blockSdt": return serializeBlockSdt(block, serializeBlockContent);
 		case "preservedBlock": return block.xml;
+		case "bookmarkStart":
+		case "bookmarkEnd": return serializeBookmarkMarker(block);
 		default: return block;
 	}
 }