@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/runPayload.d.ts

@@ -0,0 +1,5 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/runPayload.d.ts
+declare const runHoldsPayload: (run: document_d_exports.Run) => boolean;
+//#endregion
+export { runHoldsPayload };

package/dist/docx/runPayload.js

@@ -0,0 +1,4 @@
+//#region src/docx/runPayload.ts
+const runHoldsPayload = (run) => run.content.length > 0;
+//#endregion
+export { runHoldsPayload };

package/dist/docx/sdtProperties.d.ts

@@ -1,14 +1,48 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
 //#region src/docx/sdtProperties.d.ts
+/**
+ * One preserved `w:sdtPr` child by local name, as the source wrote it.
+ *
+ * The name is resolved, never a spelling: a producer may bind the w14 URI to
+ * any prefix, and the local name is what tells `w14:checkbox` from a run's
+ * `w:color`, because `CT_SdtPr` declares neither name twice.
+ */
+declare const preservedSdtChild: (preserved: document_d_exports.PreservedMarkup | undefined, localName: string) => string | undefined;
+/** The same set without that child, or `undefined` when nothing is left. */
+declare const withoutPreservedSdtChild: (preserved: document_d_exports.PreservedMarkup | undefined, localName: string) => document_d_exports.PreservedMarkup | undefined;
+/**
+ * Whether one preserved child is the element that states the control kind.
+ *
+ * The writer synthesises a kind marker only when the sink holds none, so a
+ * control folio parsed keeps the one its author wrote and a control built in
+ * code still gets one; and it is this child, not the whole set, that the
+ * modelled interactive state is written back into.
+ */
+declare const statesControlKind: (xml: string) => boolean;
+/**
+ * Direct children of `w:sdt` that sit outside `w:sdtContent`, split by side.
+ *
+ * Word writes range markers there. A same-named element from another
+ * namespace is not one of the structural WordprocessingML children, so it is
+ * captured rather than mistaken for `w:sdtPr`, `w:sdtEndPr`, or
+ * `w:sdtContent`.
+ */
+declare const captureSdtSiblingMarkers: (sdt: XmlElement) => {
+  before: string;
+  after: string;
+};
 /**
  * Parse `<w:sdtPr>` (and optional `<w:sdtEndPr>`) into {@link SdtProperties}.
  *
- * Modeled fields drive addressing / template tooling; `rawPropertiesXml`
- * and `rawEndPropertiesXml` carry the original bytes for the serializer to
- * replay unchanged, so the projection only needs to handle what we
- * actually consume — unmodeled markers are not silently dropped.
+ * Modelled fields drive addressing and template tooling. Everything else —
+ * the control-kind element, `w:dataBinding`, `w:label`, `w:tabIndex`,
+ * `w:temporary`, `w:rPr`, and every extension-namespace child — lands in
+ * {@link SdtProperties.preserved} at its schema ordinal. A modelled child
+ * whose value the reader refuses lands there too: `keptUnless` decides by the
+ * outcome, because a map keyed by name cannot list the values a reader will
+ * not admit.
  */
 declare function parseSdtProperties(sdtPr: XmlElement | null | undefined, sdtEndPr?: XmlElement | null | undefined): document_d_exports.SdtProperties;
 //#endregion
-export { parseSdtProperties };
+export { captureSdtSiblingMarkers, parseSdtProperties, preservedSdtChild, statesControlKind, withoutPreservedSdtChild };

package/dist/docx/sdtProperties.js

@@ -1,6 +1,8 @@
+import { CAPTURE, dispatchChildren, keptUnless, sequencePositions } from "./containerChildren.js";
 import { SdtLockSchema, narrowEnum } from "./parserEnums.js";
+import { RUN_PROPERTY_OWNERS, parseRunProperties } from "./runParser.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
-import { findChild, getAttributeAnyPrefix, getLocalName, parseBooleanElement } from "./xmlParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, findChildByLocalName, getAttributeAnyPrefix, getLocalName, parseBooleanElement } from "./xmlParser.js";
 //#region src/docx/sdtProperties.ts
 function parseListItems(el) {
 	const items = [];
@@ -192,100 +194,219 @@ function rewriteOpenTagAttrPrefixes(raw, canonical, local) {
 	return pieces.join("");
 }
 /**
+* The `w:sdtPr` children that state which kind of control this is.
+*
+* They are the choice that closes `CT_SdtPr`, so at most one may appear, and
+* every one of them is kept as bytes rather than rebuilt: `w:date` carries a
+* calendar and a locale, `w:docPartObj` a gallery and a category, `w:text` a
+* `@w:multiLine`, and `w14:checkbox` its two glyph elements — none of which
+* {@link SdtProperties} has a field for. The handler reads the projection
+* folio does model off the element and hands the element itself back, so the
+* kind survives an edit whole.
+*
+* `checkbox` is `w14:` and the Transitional graph does not declare it, so it
+* is listed separately: the dispatcher reaches it through `undeclared` and it
+* cannot be bound to the generated child set.
+*/
+const CONTROL_KIND_CHILDREN = [
+	"equation",
+	"comboBox",
+	"date",
+	"docPartObj",
+	"docPartList",
+	"dropDownList",
+	"picture",
+	"richText",
+	"text",
+	"citation",
+	"group",
+	"bibliography"
+];
+const CHECKBOX_CHILD = "checkbox";
+/**
+* The local name of a captured fragment's root element.
+*
+* The fragments in the sink are folio's own output — `captureVerbatimXml`
+* serialises one element and materialises its namespace bindings — so the
+* start tag is the first thing in the string and reading its name off the
+* front is exact rather than a guess about arbitrary markup.
+*/
+const capturedRootName = (xml) => /^<(?:[\w.-]+:)?(?<local>[\w.-]+)/u.exec(xml)?.groups?.["local"];
+/**
+* One preserved `w:sdtPr` child by local name, as the source wrote it.
+*
+* The name is resolved, never a spelling: a producer may bind the w14 URI to
+* any prefix, and the local name is what tells `w14:checkbox` from a run's
+* `w:color`, because `CT_SdtPr` declares neither name twice.
+*/
+const preservedSdtChild = (preserved, localName) => preserved?.children?.find(({ xml }) => capturedRootName(xml) === localName)?.xml;
+/** The same set without that child, or `undefined` when nothing is left. */
+const withoutPreservedSdtChild = (preserved, localName) => {
+	const children = (preserved?.children ?? []).filter(({ xml }) => capturedRootName(xml) !== localName);
+	return children.length === 0 ? void 0 : { children };
+};
+/**
+* Whether one preserved child is the element that states the control kind.
+*
+* The writer synthesises a kind marker only when the sink holds none, so a
+* control folio parsed keeps the one its author wrote and a control built in
+* code still gets one; and it is this child, not the whole set, that the
+* modelled interactive state is written back into.
+*/
+const statesControlKind = (xml) => {
+	const root = capturedRootName(xml);
+	return root !== void 0 && (root === CHECKBOX_CHILD || CONTROL_KIND_CHILDREN.some((name) => name === root));
+};
+/**
+* Direct children of `w:sdt` that sit outside `w:sdtContent`, split by side.
+*
+* Word writes range markers there. A same-named element from another
+* namespace is not one of the structural WordprocessingML children, so it is
+* captured rather than mistaken for `w:sdtPr`, `w:sdtEndPr`, or
+* `w:sdtContent`.
+*/
+const captureSdtSiblingMarkers = (sdt) => {
+	const beforeParts = [];
+	const afterParts = [];
+	let sawContent = false;
+	for (const child of sdt.elements ?? []) {
+		if (child.type !== "element" || !child.name) continue;
+		const local = getLocalName(child.name);
+		const isWordprocessingChild = WORDPROCESSINGML_NAMESPACE_URIS.has(child.namespaceUri ?? "");
+		if (isWordprocessingChild && (local === "sdtPr" || local === "sdtEndPr")) continue;
+		if (isWordprocessingChild && local === "sdtContent") {
+			sawContent = true;
+			continue;
+		}
+		const xml = captureVerbatimXml(child);
+		if (sawContent) afterParts.push(xml);
+		else beforeParts.push(xml);
+	}
+	return {
+		before: beforeParts.join(""),
+		after: afterParts.join("")
+	};
+};
+/**
 * Parse `<w:sdtPr>` (and optional `<w:sdtEndPr>`) into {@link SdtProperties}.
 *
-* Modeled fields drive addressing / template tooling; `rawPropertiesXml`
-* and `rawEndPropertiesXml` carry the original bytes for the serializer to
-* replay unchanged, so the projection only needs to handle what we
-* actually consume — unmodeled markers are not silently dropped.
+* Modelled fields drive addressing and template tooling. Everything else —
+* the control-kind element, `w:dataBinding`, `w:label`, `w:tabIndex`,
+* `w:temporary`, `w:rPr`, and every extension-namespace child — lands in
+* {@link SdtProperties.preserved} at its schema ordinal. A modelled child
+* whose value the reader refuses lands there too: `keptUnless` decides by the
+* outcome, because a map keyed by name cannot list the values a reader will
+* not admit.
 */
 function parseSdtProperties(sdtPr, sdtEndPr) {
 	const props = { sdtType: "richText" };
 	if (sdtPr) {
-		props.rawPropertiesXml = normalizeWordPrefix(captureVerbatimXml(sdtPr), sdtPr);
-		for (const el of sdtPr.elements ?? []) {
-			if (el.type !== "element") continue;
-			const name = el.name ? getLocalName(el.name) : "";
-			switch (name) {
-				case "id": {
-					const raw = getAttributeAnyPrefix(el, "val");
-					if (raw !== null) {
-						const n = Number.parseInt(raw, 10);
-						if (!Number.isNaN(n)) props.id = n;
-					}
-					break;
-				}
-				case "alias": {
-					const aliasVal = getAttributeAnyPrefix(el, "val");
-					if (aliasVal !== null) props.alias = aliasVal;
-					break;
-				}
-				case "tag": {
-					const tagVal = getAttributeAnyPrefix(el, "val");
-					if (tagVal !== null) props.tag = tagVal;
-					break;
-				}
-				case "lock":
-					props.lock = narrowEnum(getAttributeAnyPrefix(el, "val"), SdtLockSchema) ?? "unlocked";
-					break;
-				case "placeholder": {
-					const docPart = findChild(el, "w", "docPart");
-					if (docPart) {
-						const phVal = getAttributeAnyPrefix(docPart, "val");
-						if (phVal !== null) props.placeholder = phVal;
-					}
-					break;
-				}
-				case "showingPlcHdr":
-					props.showingPlaceholder = parseBooleanElement(el, "w");
-					break;
-				case "text":
-					props.sdtType = "plainText";
-					break;
-				case "date": {
+		/** Read a projection off a control-kind element, and keep the element. */
+		const kind = (read) => (element) => {
+			read(element);
+			return CAPTURE;
+		};
+		const preserved = dispatchChildren({
+			element: sdtPr,
+			container: "content-control-properties",
+			handlers: {
+				rPr: CAPTURE,
+				alias: (element) => {
+					const value = getAttributeAnyPrefix(element, "val");
+					if (value !== null) props.alias = value;
+					return keptUnless(value !== null);
+				},
+				tag: (element) => {
+					const value = getAttributeAnyPrefix(element, "val");
+					if (value !== null) props.tag = value;
+					return keptUnless(value !== null);
+				},
+				id: (element) => {
+					const raw = getAttributeAnyPrefix(element, "val");
+					const value = raw === null ? NaN : Number.parseInt(raw, 10);
+					if (!Number.isNaN(value)) props.id = value;
+					return keptUnless(!Number.isNaN(value));
+				},
+				lock: (element) => {
+					const value = narrowEnum(getAttributeAnyPrefix(element, "val"), SdtLockSchema);
+					if (value !== void 0) props.lock = value;
+					return keptUnless(value !== void 0);
+				},
+				placeholder: (element) => {
+					const value = getAttributeAnyPrefix(findChild(element, "w", "docPart"), "val");
+					if (value !== null) props.placeholder = value;
+					return keptUnless(value !== null);
+				},
+				temporary: CAPTURE,
+				showingPlcHdr: (element) => {
+					props.showingPlaceholder = parseBooleanElement(element, "w");
+				},
+				dataBinding: CAPTURE,
+				label: CAPTURE,
+				tabIndex: CAPTURE,
+				equation: kind(() => {}),
+				comboBox: kind((element) => {
+					props.sdtType = "comboBox";
+					props.listItems = parseListItems(element);
+					readLastValue(element, props);
+				}),
+				date: kind((element) => {
 					props.sdtType = "date";
-					const dateFormatEl = findChild(el, "w", "dateFormat");
-					if (dateFormatEl) {
-						const fmt = getAttributeAnyPrefix(dateFormatEl, "val");
-						if (fmt !== null) props.dateFormat = fmt;
-					}
-					const fullDate = getAttributeAnyPrefix(el, "fullDate");
+					const format = getAttributeAnyPrefix(findChild(element, "w", "dateFormat"), "val");
+					if (format !== null) props.dateFormat = format;
+					const fullDate = getAttributeAnyPrefix(element, "fullDate");
 					if (fullDate !== null) props.dateValueISO = fullDate;
-					break;
-				}
-				case "dropDownList":
-				case "comboBox": {
-					props.sdtType = name === "dropDownList" ? "dropdown" : "comboBox";
-					props.listItems = parseListItems(el);
-					const lastValue = getAttributeAnyPrefix(el, "lastValue");
-					if (lastValue !== null) props.dropdownLastValue = lastValue;
-					break;
-				}
-				case "checkbox": {
-					props.sdtType = "checkbox";
-					const checked14 = findChild(el, "w14", "checked");
-					const checkedW = findChild(el, "w", "checked");
-					if (checked14) props.checked = parseBooleanElement(checked14, "w14");
-					else if (checkedW) props.checked = parseBooleanElement(checkedW, "w");
-					else props.checked = false;
-					break;
-				}
-				case "picture":
-					props.sdtType = "picture";
-					break;
-				case "docPartObj":
-				case "docPartList":
+				}),
+				docPartObj: kind(() => {
+					props.sdtType = "buildingBlockGallery";
+				}),
+				docPartList: kind(() => {
 					props.sdtType = "buildingBlockGallery";
-					break;
-				case "group":
+				}),
+				dropDownList: kind((element) => {
+					props.sdtType = "dropdown";
+					props.listItems = parseListItems(element);
+					readLastValue(element, props);
+				}),
+				picture: kind(() => {
+					props.sdtType = "picture";
+				}),
+				richText: kind(() => {}),
+				text: kind(() => {
+					props.sdtType = "plainText";
+				}),
+				citation: kind(() => {}),
+				group: kind(() => {
 					props.sdtType = "group";
-					break;
-				default: break;
-			}
-		}
+				}),
+				bibliography: kind(() => {})
+			},
+			capturePosition: sequencePositions("content-control-properties", sdtPr),
+			undeclared: { [CHECKBOX_CHILD]: kind((element) => {
+				props.sdtType = "checkbox";
+				const state = findChild(element, "w14", "checked") ?? findChild(element, "w", "checked");
+				props.checked = state === null ? false : parseBooleanElement(state, "w14");
+			}) }
+		});
+		if (preserved !== void 0) props.preserved = preserved;
+	}
+	if (sdtEndPr) {
+		props.rawEndPropertiesXml = normalizeWordPrefix(captureVerbatimXml(sdtEndPr), sdtEndPr);
+		const runProperties = parseRunProperties(findChildByLocalName(sdtEndPr, "rPr"), null, RUN_PROPERTY_OWNERS.standalone);
+		props.endProperties = runProperties === void 0 ? {} : { runProperties };
 	}
-	if (sdtEndPr) props.rawEndPropertiesXml = normalizeWordPrefix(captureVerbatimXml(sdtEndPr), sdtEndPr);
 	return props;
 }
+/**
+* The value a producer last chose, from the list element's `@w:lastValue`.
+*
+* `""` is a value a producer can author, so presence is the test rather than
+* truthiness: "never selected", "cleared" and "selected" are three states and
+* the body's display text is evidence for none of them.
+*/
+function readLastValue(element, props) {
+	const lastValue = getAttributeAnyPrefix(element, "lastValue");
+	if (lastValue !== null) props.dropdownLastValue = lastValue;
+}
 //#endregion
-export { parseSdtProperties };
+export { captureSdtSiblingMarkers, parseSdtProperties, preservedSdtChild, statesControlKind, withoutPreservedSdtChild };

package/dist/docx/sdtPropertiesPatch.d.ts

@@ -1,15 +1,11 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/sdtPropertiesPatch.d.ts
 /**
- * Rewrite the relevant child elements of `<w:sdtPr>` so the modeled
- * properties (checked / dateFormat / fullDate / lastValue / showingPlcHdr)
- * agree with the raw XML before it is replayed by the serializer.
+ * The control-kind element with the modelled interactive state written in.
  *
- * Pure: returns a new string; the input is not modified.
+ * Pure: returns a new string; the input is not modified. A kind the model
+ * states nothing interactive about comes back unchanged.
  */
-declare function reconcileRawSdtPr(raw: string, props: document_d_exports.SdtProperties, options?: {
-  dateFullDate?: string;
-  dropdownLastValue?: string;
-}): string;
+declare const withModelledControlState: (xml: string, props: document_d_exports.SdtProperties) => string;
 //#endregion
-export { reconcileRawSdtPr };
+export { withModelledControlState };

package/dist/docx/sdtPropertiesPatch.js

@@ -1,39 +1,32 @@
 import { escapeXmlAttribute } from "@stll/docx-core";
 //#region src/docx/sdtPropertiesPatch.ts
 /**
-* Surgical patches for the captured `<w:sdtPr>` XML string.
+* The modelled interactive state, written into the control-kind element.
 *
-* Background. The block-SDT serializer (commit 3) replays
-* `properties.rawPropertiesXml` verbatim so unmodeled OOXML markers
-* (`w:dataBinding`, `w15:repeatingSection`, custom XML mappings) survive
-* a round trip. That replay is correct for unchanged controls but goes
-* stale the moment the editor mutates a modeled property: a user
-* toggling a checkbox, picking a date, or choosing a dropdown value
-* updates `properties.checked` / `dateFormat` / etc., but the raw
-* `w14:checked w14:val="0"` already encoded by the source DOCX stays
-* in `rawPropertiesXml` and gets written back on save — Word reopens
-* the document with the user's interactive change discarded.
+* `w:date`, `w:dropDownList`, `w:comboBox` and `w14:checkbox` are kept as
+* bytes: each carries children and attributes {@link SdtProperties} has no
+* field for — a calendar and a locale, a gallery, the two checkbox glyphs —
+* and rebuilding one from the model would drop them. But four of their values
+* *are* modelled, because a user changes them: the checkbox state, the bound
+* date, the display format and the chosen list value. The model wins for
+* those four; the element keeps everything else.
 *
-* `reconcileRawSdtPr` walks every modeled field that has an OOXML
-* representation inside `<w:sdtPr>` and, if the field is set on the
-* model, rewrites the matching element in the raw string. Unmodeled
-* markers are untouched, so dataBinding / repeatingSection round-trip
-* stays lossless even after the user has mutated the control.
-*
-* Picked up from upstream eigenpal/docx-editor#661.
+* This is the one place the two halves meet, and it runs inside the one
+* `w:sdtPr` writer rather than beside it.
 */
 /**
-* Drop any `*:lastValue="…"` attribute (any namespace prefix, or
-* unprefixed) from an attribute-list string. We avoid a single greedy
-* regex with `\s+` (which lint flags as backtracking-risky) and instead
-* scan character-by-character against `lastValue=` while accepting any
-* preceding `prefix:`. Without prefix tolerance, a source DOCX that
-* binds the Word namespace under a non-`w` prefix
-* (`<ns0:dropDownList ns0:lastValue="old">`) would keep the stale
-* attribute alongside our freshly-emitted `w:lastValue` on save.
+* Drop one attribute by local name (any namespace prefix, or unprefixed) from
+* an attribute-list string, leaving every other attribute alone.
+*
+* A scan rather than one greedy regex, which lint flags as backtracking-risky.
+* Two things make the rest of the list worth keeping rather than rebuilding:
+* a source that binds the Word namespace under `ns0` writes `ns0:lastValue`,
+* and keeping it beside a freshly emitted one would leave the element with
+* two; and a captured element carries the `xmlns:*` declarations that make it
+* replayable on its own, which a rebuilt attribute list would throw away.
 */
-function stripLastValueAttr(attrs) {
-	const SUFFIX = "lastValue=";
+function withoutAttr(attrs, localName) {
+	const SUFFIX = `${localName}=`;
 	let out = attrs;
 	let searchFrom = 0;
 	while (searchFrom < out.length) {
@@ -46,13 +39,13 @@ function stripLastValueAttr(attrs) {
 			while (nameStart > 0 && /[A-Za-z0-9_-]/u.test(out[nameStart - 1] ?? "")) nameStart -= 1;
 		}
 		if (nameStart === 0 || !/\s/u.test(out[nameStart - 1] ?? "")) {
-			searchFrom = hitIdx + 10;
+			searchFrom = hitIdx + SUFFIX.length;
 			continue;
 		}
-		const quoteIdx = hitIdx + 10;
+		const quoteIdx = hitIdx + SUFFIX.length;
 		const quote = out[quoteIdx];
 		if (quote !== "\"" && quote !== "'") {
-			searchFrom = hitIdx + 10;
+			searchFrom = hitIdx + SUFFIX.length;
 			continue;
 		}
 		const closeIdx = out.indexOf(quote, quoteIdx + 1);
@@ -62,89 +55,52 @@ function stripLastValueAttr(attrs) {
 	}
 	return out;
 }
+const withCheckedState = (xml, checked) => {
+	const val = checked ? "1" : "0";
+	const opened = /<(?<prefix>\w+):checked\b[^>]*>[\s\S]*?<\/\w+:checked>/giu;
+	if (/<\w+:checked\b[^>]*>[\s\S]*?<\/\w+:checked>/iu.test(xml)) return xml.replaceAll(opened, (_match, prefix) => `<${prefix}:checked ${prefix}:val="${val}"/>`);
+	if (/<\w+:checked\b[^>]*\/>/iu.test(xml)) return xml.replaceAll(/<(?<prefix>\w+):checked\b[^>]*\/>/giu, (_match, prefix) => `<${prefix}:checked ${prefix}:val="${val}"/>`);
+	return xml.replace(/<(?<prefix>\w+):checkbox\b[^>]*>/iu, (match, prefix) => `${match}<${prefix}:checked ${prefix}:val="${val}"/>`);
+};
+const withDateState = (xml, props) => {
+	const fullDate = props.dateValueISO;
+	const format = props.dateFormat;
+	if (fullDate === void 0 && format === void 0) return xml;
+	const attributes = (prefix, matched) => fullDate === void 0 ? matched : `${withoutAttr(matched, "fullDate")} ${prefix}:fullDate="${escapeXmlAttribute(fullDate)}"`;
+	const formatChild = (prefix) => format === void 0 ? "" : `<${prefix}:dateFormat ${prefix}:val="${escapeXmlAttribute(format)}"/>`;
+	const opened = /<(?<prefix>\w+):date\b(?<attrs>[^>]*)>(?<inner>[\s\S]*?)<\/\w+:date>/iu;
+	if (opened.test(xml)) return xml.replace(opened, (_match, prefix, matchedAttrs, inner) => {
+		const body = inner.replaceAll(/<\w+:dateFormat\b[^>]*(?:\/>|>[\s\S]*?<\/\w+:dateFormat>)/giu, "");
+		return `<${prefix}:date${attributes(prefix, matchedAttrs)}>${formatChild(prefix)}${body}</${prefix}:date>`;
+	});
+	return xml.replace(/<(?<prefix>\w+):date\b(?<attrs>[^/>]*)\/>/iu, (_match, prefix, matchedAttrs) => `<${prefix}:date${attributes(prefix, matchedAttrs)}>${formatChild(prefix)}</${prefix}:date>`);
+};
+const withLastValue = (xml, lastValue) => {
+	const escaped = escapeXmlAttribute(lastValue);
+	const opened = /<(?<prefix>\w+):(?<name>dropDownList|comboBox)\b(?<attrs>[^>]*)>(?<inner>[\s\S]*?)<\/\w+:(?:dropDownList|comboBox)>/iu;
+	if (opened.test(xml)) return xml.replace(opened, (_match, prefix, name, attrs, inner) => `<${prefix}:${name}${withoutAttr(attrs, "lastValue")} ${prefix}:lastValue="${escaped}">${inner}</${prefix}:${name}>`);
+	return xml.replace(/<(?<prefix>\w+):(?<name>dropDownList|comboBox)\b(?<attrs>[^/>]*)\/>/iu, (_match, prefix, name, attrs) => `<${prefix}:${name}${withoutAttr(attrs, "lastValue")} ${prefix}:lastValue="${escaped}"/>`);
+};
 /**
-* Replace or insert a child element inside `<w:sdtPr>...</w:sdtPr>`.
+* The control-kind element with the modelled interactive state written in.
 *
-* - If a matching child already exists (by local name), the whole element
-*   is replaced verbatim by `replacement` (so attributes / payload come
-*   from the caller).
-* - Otherwise `replacement` is injected just before `</w:sdtPr>` so the
-*   element ends up as a child of sdtPr, not after it.
+* Pure: returns a new string; the input is not modified. A kind the model
+* states nothing interactive about comes back unchanged.
 */
-function upsertSdtPrChild(raw, localName, replacement) {
-	const escaped = localName.replaceAll(/[$()*+./?[\\\]^{|}]/gu, "\\$&");
-	const selfClosing = new RegExp(`<\\w+:${escaped}\\b[^>]*\\/>`, "iu");
-	const opened = new RegExp(`<\\w+:${escaped}\\b[^>]*>[\\s\\S]*?<\\/\\w+:${escaped}>`, "iu");
-	if (selfClosing.test(raw)) return raw.replace(selfClosing, replacement);
-	if (opened.test(raw)) return raw.replace(opened, replacement);
-	const closing = /<\/(?<prefix>\w+):sdtPr>/iu;
-	const closingMatch = closing.exec(raw);
-	if (closingMatch) {
-		const closingPrefix = closingMatch.groups?.["prefix"];
-		return raw.replace(closing, `${replacement}</${closingPrefix}:sdtPr>`);
-	}
-	const selfClosingPr = /<(?<prefix>\w+):sdtPr(?<attrs>[^/>]*)\/>/iu;
-	if (selfClosingPr.test(raw)) return raw.replace(selfClosingPr, (_match, prefix, attrs) => `<${prefix}:sdtPr${attrs}>${replacement}</${prefix}:sdtPr>`);
-	return raw;
-}
-function setOrRemove(raw, localName, replacementWhenSet) {
-	if (replacementWhenSet === null) {
-		const escaped = localName.replaceAll(/[$()*+./?[\\\]^{|}]/gu, "\\$&");
-		const selfClosing = new RegExp(`<\\w+:${escaped}\\b[^>]*\\/>`, "igu");
-		const opened = new RegExp(`<\\w+:${escaped}\\b[^>]*>[\\s\\S]*?<\\/\\w+:${escaped}>`, "igu");
-		return raw.replaceAll(selfClosing, "").replaceAll(opened, "");
+const withModelledControlState = (xml, props) => {
+	switch (props.sdtType) {
+		case "checkbox": return typeof props.checked === "boolean" ? withCheckedState(xml, props.checked) : xml;
+		case "date": return withDateState(xml, props);
+		case "dropdown":
+		case "comboBox": return props.dropdownLastValue === void 0 ? xml : withLastValue(xml, props.dropdownLastValue);
+		case "richText":
+		case "plainText":
+		case "picture":
+		case "buildingBlockGallery":
+		case "group":
+		case "unknown": return xml;
+		default: return props.sdtType;
 	}
-	return upsertSdtPrChild(raw, localName, replacementWhenSet);
-}
-/**
-* Rewrite the relevant child elements of `<w:sdtPr>` so the modeled
-* properties (checked / dateFormat / fullDate / lastValue / showingPlcHdr)
-* agree with the raw XML before it is replayed by the serializer.
-*
-* Pure: returns a new string; the input is not modified.
-*/
-function reconcileRawSdtPr(raw, props, options = {}) {
-	let next = raw;
-	if (props.showingPlaceholder === true) next = setOrRemove(next, "showingPlcHdr", "<w:showingPlcHdr/>");
-	else if (props.showingPlaceholder === false) next = setOrRemove(next, "showingPlcHdr", null);
-	if (props.sdtType === "checkbox" && typeof props.checked === "boolean") {
-		const val = props.checked ? "1" : "0";
-		const checkedOpened = /<(?:\w+):checked\b[^>]*>[\s\S]*?<\/\w+:checked>/iu;
-		const checkedSelfClosing = /<(?:\w+):checked\b[^>]*\/>/iu;
-		if (checkedOpened.test(next)) next = next.replaceAll(/<(?<prefix>\w+):checked\b[^>]*>[\s\S]*?<\/\w+:checked>/giu, (_match, prefix) => `<${prefix}:checked ${prefix}:val="${val}"/>`);
-		else if (checkedSelfClosing.test(next)) next = next.replaceAll(/<(?<prefix>\w+):checked\b[^>]*\/>/giu, (_match, prefix) => `<${prefix}:checked ${prefix}:val="${val}"/>`);
-		else if (/<\w+:checkbox\b[^>]*>/iu.test(next)) next = next.replace(/<(?<prefix>\w+):checkbox\b[^>]*>/iu, (match, prefix) => `${match}<${prefix}:checked ${prefix}:val="${val}"/>`);
-		else next = upsertSdtPrChild(next, "checkbox", `<w14:checkbox><w14:checked w14:val="${val}"/></w14:checkbox>`);
-	}
-	if (props.sdtType === "date") {
-		const fullDate = options.dateFullDate;
-		const dateFormat = props.dateFormat;
-		if (fullDate !== void 0 || dateFormat !== void 0) {
-			const wDate = /<(?<prefix>\w+):date\b(?<attrs>[^>]*)>(?<inner>[\s\S]*?)<\/\w+:date>/iu;
-			const wDateSelf = /<(?<prefix>\w+):date\b(?<attrs>[^/>]*)\/>/iu;
-			const fullDateAttr = fullDate !== void 0 ? ` w:fullDate="${escapeXmlAttribute(fullDate)}"` : "";
-			const formatChild = dateFormat !== void 0 ? `<w:dateFormat w:val="${escapeXmlAttribute(dateFormat)}"/>` : "";
-			if (wDate.test(next)) next = next.replace(wDate, (_match, prefix, matchedAttrs, inner) => {
-				let body = inner.replaceAll(/<\w+:dateFormat\b[^>]*(?:\/>|>[\s\S]*?<\/\w+:dateFormat>)/giu, "");
-				if (formatChild) body = `${formatChild}${body}`;
-				return `<${prefix}:date${fullDate !== void 0 ? fullDateAttr : matchedAttrs}>${body}</${prefix}:date>`;
-			});
-			else if (wDateSelf.test(next)) next = next.replace(wDateSelf, (_match, prefix) => `<${prefix}:date${fullDateAttr}>${formatChild}</${prefix}:date>`);
-			else next = upsertSdtPrChild(next, "date", `<w:date${fullDateAttr}>${formatChild}</w:date>`);
-		}
-	}
-	if ((props.sdtType === "dropdown" || props.sdtType === "comboBox") && options.dropdownLastValue !== void 0) {
-		const escapedValue = escapeXmlAttribute(options.dropdownLastValue);
-		const opened = /<(?<prefix>\w+):(?<name>dropDownList|comboBox)\b(?<attrs>[^>]*)>(?<inner>[\s\S]*?)<\/\w+:(?:dropDownList|comboBox)>/iu;
-		const selfClosing = /<(?<prefix>\w+):(?<name>dropDownList|comboBox)\b(?<attrs>[^/>]*)\/>/iu;
-		if (opened.test(next)) next = next.replace(opened, (_match, prefix, name, attrs, inner) => {
-			return `<${prefix}:${name}${stripLastValueAttr(attrs)} ${prefix}:lastValue="${escapedValue}">${inner}</${prefix}:${name}>`;
-		});
-		else if (selfClosing.test(next)) next = next.replace(selfClosing, (_match, prefix, name, attrs) => {
-			return `<${prefix}:${name}${stripLastValueAttr(attrs)} ${prefix}:lastValue="${escapedValue}"/>`;
-		});
-	}
-	return next;
-}
+};
 //#endregion
-export { reconcileRawSdtPr };
+export { withModelledControlState };

package/dist/docx/sectionParser.d.ts

@@ -2,7 +2,6 @@ import { document_d_exports } from "../types/document.js";
 import { ParseContext } from "./parseContext.js";
 import { XmlElement } from "./xmlParser.js";
 //#region src/docx/sectionParser.d.ts
-declare function getUnserializedSectionPropertyChildNames(props: document_d_exports.SectionProperties): readonly string[] | undefined;
 /**
  * Parse section properties (w:sectPr)
  *
@@ -92,4 +91,4 @@ declare function getDefaultSectionProperties(): document_d_exports.SectionProper
  */
 declare function mergeSectionProperties(base: document_d_exports.SectionProperties, override: document_d_exports.SectionProperties): document_d_exports.SectionProperties;
 //#endregion
-export { getColumnCount, getContentHeightPixels, getContentWidthPixels, getDefaultSectionProperties, getMarginsPixels, getPageHeightPixels, getPageWidthPixels, getUnserializedSectionPropertyChildNames, hasDifferentFirstPage, hasDifferentOddEven, hasLineNumbers, hasPageBorders, isLandscape, mergeSectionProperties, parseSectionProperties };
+export { getColumnCount, getContentHeightPixels, getContentWidthPixels, getDefaultSectionProperties, getMarginsPixels, getPageHeightPixels, getPageWidthPixels, hasDifferentFirstPage, hasDifferentOddEven, hasLineNumbers, hasPageBorders, isLandscape, mergeSectionProperties, parseSectionProperties };