@stll/folio-core 0.45.0 → 0.47.0

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,33 +17,33 @@ 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)}"`);
 	}
-	if (shadow) attrs.push("w:shadow=\"true\"");
-	if (frame) attrs.push("w:frame=\"true\"");
+	if (shadow !== void 0) attrs.push(`w:shadow="${shadow ? "1" : "0"}"`);
+	if (frame !== void 0) attrs.push(`w:frame="${frame ? "1" : "0"}"`);
 	if (artRelationshipId) attrs.push(`r:id="${escapeXmlAttribute(artRelationshipId)}"`);
 	if (topLeftArtRelationshipId) attrs.push(`r:topLeft="${escapeXmlAttribute(topLeftArtRelationshipId)}"`);
 	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/commentSerializer.js

@@ -1,5 +1,6 @@
 import { deterministicHexId } from "../../utils/hexId.js";
 import { commentThreadParaId } from "../commentThreadKey.js";
+import { serializeWithPreservedChildren } from "../containerChildren.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
@@ -30,13 +31,10 @@ function serializeComment(comment) {
 	const attrs = [`w:id="${comment.id}"`, `w:author="${escapeXmlAttribute(comment.author)}"`];
 	if (comment.initials !== void 0) attrs.push(`w:initials="${escapeXmlAttribute(comment.initials)}"`);
 	if (comment.date) attrs.push(`w:date="${escapeXmlAttribute(comment.date)}"`);
-	let xml = `<w:comment ${attrs.join(" ")}>`;
-	if (comment.content.length > 0) {
-		xml += serializeParagraphWithAnnotationRef(comment.content[0], comment.annotationReferenceFormatting);
-		for (let i = 1; i < comment.content.length; i++) xml += serializeParagraph(comment.content[i]);
-	} else xml += `<w:p>${serializeAnnotationReference(comment.annotationReferenceFormatting)}</w:p>`;
-	xml += "</w:comment>";
-	return xml;
+	const paragraphs = comment.content.map((paragraph, index) => index === 0 ? serializeParagraphWithAnnotationRef(paragraph, comment.annotationReferenceFormatting) : serializeParagraph(paragraph));
+	if (paragraphs.length === 0 && comment.preserved === void 0) paragraphs.push(`<w:p>${serializeAnnotationReference(comment.annotationReferenceFormatting)}</w:p>`);
+	const body = serializeWithPreservedChildren(paragraphs, comment.preserved);
+	return `<w:comment ${attrs.join(" ")}>${body}</w:comment>`;
 }
 const COMMENTS_BASELINE_PREFIXES = [
 	"wpc",

package/dist/docx/serializer/documentSerializer.js

@@ -1,5 +1,5 @@
-import { withBlockRangeMarkers } from "../blockRangeMarkers.js";
 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";
@@ -37,17 +37,17 @@ const DOCUMENT_BASELINE_PREFIXES = [
 	"wpg",
 	"wps"
 ];
-/**
-* Serialize a single block content item (paragraph, table, or block-level SDT).
-*/
+/** Serialize a single block, whether or not folio models what is in it. */
 function serializeBlockContent(block) {
-	return withBlockRangeMarkers(block, serializeBlockBody(block));
-}
-/** The block itself, without the range markers that stood around it. */
-function serializeBlockBody(block) {
-	if (block.type === "paragraph") return serializeParagraph(block);
-	if (block.type === "table") return serializeTable(block, serializeParagraph);
-	return serializeBlockSdt(block, serializeBlockContent);
+	switch (block.type) {
+		case "paragraph": return serializeParagraph(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;
+	}
 }
 /**
 * Serialize document body content

package/dist/docx/serializer/fontTableSerializer.js

@@ -1,18 +1,33 @@
+import { serializePreservedAttributes } from "../attributeRemainder.js";
+import { serializeWithPreservedChildren } from "../containerChildren.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { escapeXmlAttribute } from "@stll/docx-core";
 //#region src/docx/serializer/fontTableSerializer.ts
 const serializeFontTableXml = (fontTable) => "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
 	partPath: "word/fontTable.xml",
 	rootName: "w:fonts",
+	rootAttributes: serializePreservedAttributes([], fontTable.preservedAttributes).join(" "),
 	baselinePrefixes: ["w"],
 	sourceBindings: void 0,
-	body: fontTable.fonts.map(serializeFont).join("")
+	body: serializeWithPreservedChildren(fontTable.fonts.map(serializeFont), fontTable.preserved)
 });
+/**
+* One `w:font`, with its children in the order `CT_Font` declares them.
+*
+* The order is what makes the sink's index mean something: a capture recorded
+* after the third field the reader kept goes back after the third field this
+* writes, so unmodelled markup keeps the neighbours it was authored between.
+*/
 const serializeFont = (font) => {
 	const parts = [];
 	if (font.altName) parts.push(`<w:altName w:val="${escapeXmlAttribute(font.altName)}"/>`);
 	if (font.panose1) parts.push(`<w:panose1 w:val="${escapeXmlAttribute(font.panose1)}"/>`);
-	if (font.charset) parts.push(`<w:charset w:val="${escapeXmlAttribute(font.charset)}"/>`);
+	if (font.charset) {
+		const attributes = [];
+		if (font.charset.val !== void 0) attributes.push(`w:val="${escapeXmlAttribute(font.charset.val)}"`);
+		if (font.charset.characterSet !== void 0) attributes.push(`w:characterSet="${escapeXmlAttribute(font.charset.characterSet)}"`);
+		parts.push(attributes.length === 0 ? "<w:charset/>" : `<w:charset ${attributes.join(" ")}/>`);
+	}
 	if (font.family) parts.push(`<w:family w:val="${font.family}"/>`);
 	if (font.pitch) parts.push(`<w:pitch w:val="${font.pitch}"/>`);
 	if (font.sig) {
@@ -23,7 +38,20 @@ const serializeFont = (font) => {
 		}
 		if (attrs.length > 0) parts.push(`<w:sig ${attrs.join(" ")}/>`);
 	}
-	return `<w:font w:name="${escapeXmlAttribute(font.name)}">${parts.join("")}</w:font>`;
+	pushEmbed(parts, "embedRegular", font.embedRegular);
+	pushEmbed(parts, "embedBold", font.embedBold);
+	pushEmbed(parts, "embedItalic", font.embedItalic);
+	pushEmbed(parts, "embedBoldItalic", font.embedBoldItalic);
+	const attributes = serializePreservedAttributes([`w:name="${escapeXmlAttribute(font.name)}"`], font.preservedAttributes);
+	const body = serializeWithPreservedChildren(parts, font.preserved);
+	return `<w:font ${attributes.join(" ")}>${body}</w:font>`;
+};
+const pushEmbed = (parts, element, embed) => {
+	if (embed === void 0) return;
+	const attributes = [`r:id="${escapeXmlAttribute(embed.id)}"`];
+	if (embed.fontKey !== void 0) attributes.push(`w:fontKey="${escapeXmlAttribute(embed.fontKey)}"`);
+	if (embed.subsetted !== void 0) attributes.push(`w:subsetted="${embed.subsetted ? "1" : "0"}"`);
+	parts.push(`<w:${element} ${attributes.join(" ")}/>`);
 };
 //#endregion
 export { serializeFontTableXml };

package/dist/docx/serializer/headerFooterSerializer.js

@@ -1,9 +1,9 @@
-import { withBlockRangeMarkers } from "../blockRangeMarkers.js";
 import { canReplayHeaderFooterVerbatim, getHeaderFooterVerbatimXml } from "../headerFooterVerbatim.js";
 import { isEmptyParagraph } from "../paragraphParser.js";
 import { captureVerbatimXml } from "../verbatimCapture.js";
 import { getLocalName, parseXmlDocument } from "../xmlParser.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
+import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTable } from "./tableSerializer.js";
@@ -37,13 +37,15 @@ const HEADER_FOOTER_BASELINE_PREFIXES = [
 * header/footer.
 */
 function serializeBlock(block) {
-	return withBlockRangeMarkers(block, serializeBlockBody(block));
-}
-/** The block itself, without the range markers that stood around it. */
-function serializeBlockBody(block) {
-	if (block.type === "paragraph") return serializeParagraph(block);
-	if (block.type === "table") return serializeTable(block, serializeParagraph);
-	return serializeBlockSdt(block, serializeBlock);
+	switch (block.type) {
+		case "paragraph": return serializeParagraph(block);
+		case "table": return serializeTable(block, serializeParagraph);
+		case "blockSdt": return serializeBlockSdt(block, serializeBlock);
+		case "preservedBlock": return block.xml;
+		case "bookmarkStart":
+		case "bookmarkEnd": return serializeBookmarkMarker(block);
+		default: return block;
+	}
 }
 /**
 * Serialize a HeaderFooter object to valid OOXML XML
@@ -71,7 +73,6 @@ function serializeHeaderFooter(hf, source) {
 		});
 		contentXml = blocksXml.slice(0, watermarkInsertIndex).join("") + (mergesIntoRetainedHost ? "" : watermarkXml) + blocksXml.slice(watermarkInsertIndex).join("");
 	} else contentXml = blocksXml.join("");
-	if (!contentXml) contentXml = "<w:p><w:pPr/></w:p>";
 	return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
 		partPath: source?.path ?? `word/${hf.type}.xml`,
 		rootName: rootTag,

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

@@ -2,7 +2,15 @@ import { document_d_exports } from "../../types/document.js";
 //#region src/docx/serializer/markupRangeAttributes.d.ts
 declare const markupRangeAttributes: (marker: document_d_exports.MarkupRangeMarker) => string[];
 declare const bookmarkRangeAttributes: (marker: document_d_exports.BookmarkRangeMarker) => string[];
+/**
+ * One bookmark marker, wherever it stands.
+ *
+ * The same element is a paragraph child, a block, a child of `w:tr` and a
+ * child of `w:tbl`, so the four serializers share one writer: an attribute
+ * added to `CT_Bookmark` reaches every level at once.
+ */
+declare const serializeBookmarkMarker: (marker: document_d_exports.BookmarkStart | document_d_exports.BookmarkEnd) => string;
 /** `w:author` is required, so it is always written; `w:date` only when known. */
 declare const moveBookmarkAttributes: (marker: document_d_exports.MoveBookmarkMarker) => string[];
 //#endregion
-export { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes };
+export { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes, serializeBookmarkMarker };

package/dist/docx/serializer/markupRangeAttributes.js

@@ -13,6 +13,14 @@ const bookmarkRangeAttributes = (marker) => {
 	attributes.push(attribute("w:name", marker.name));
 	return attributes;
 };
+/**
+* One bookmark marker, wherever it stands.
+*
+* The same element is a paragraph child, a block, a child of `w:tr` and a
+* child of `w:tbl`, so the four serializers share one writer: an attribute
+* added to `CT_Bookmark` reaches every level at once.
+*/
+const serializeBookmarkMarker = (marker) => marker.type === "bookmarkStart" ? `<w:bookmarkStart ${bookmarkRangeAttributes(marker).join(" ")}/>` : `<w:bookmarkEnd ${markupRangeAttributes(marker).join(" ")}/>`;
 /** `w:author` is required, so it is always written; `w:date` only when known. */
 const moveBookmarkAttributes = (marker) => {
 	const attributes = bookmarkRangeAttributes(marker);
@@ -21,4 +29,4 @@ const moveBookmarkAttributes = (marker) => {
 	return attributes;
 };
 //#endregion
-export { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes };
+export { bookmarkRangeAttributes, markupRangeAttributes, moveBookmarkAttributes, serializeBookmarkMarker };

package/dist/docx/serializer/noteSerializer.js

@@ -1,5 +1,5 @@
-import { withBlockRangeMarkers } from "../blockRangeMarkers.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
+import { serializeBookmarkMarker } from "./markupRangeAttributes.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTable } from "./tableSerializer.js";
@@ -39,13 +39,15 @@ const serializeNotePart = (elementName, body) => "<?xml version=\"1.0\" encoding
 * note body.
 */
 function serializeBlock(block) {
-	return withBlockRangeMarkers(block, serializeBlockBody(block));
-}
-/** The block itself, without the range markers that stood around it. */
-function serializeBlockBody(block) {
-	if (block.type === "paragraph") return serializeParagraph(block);
-	if (block.type === "table") return serializeTable(block, serializeParagraph);
-	return serializeBlockSdt(block, serializeBlock);
+	switch (block.type) {
+		case "paragraph": return serializeParagraph(block);
+		case "table": return serializeTable(block, serializeParagraph);
+		case "blockSdt": return serializeBlockSdt(block, serializeBlock);
+		case "preservedBlock": return block.xml;
+		case "bookmarkStart":
+		case "bookmarkEnd": return serializeBookmarkMarker(block);
+		default: return block;
+	}
 }
 /**
 * Serialize a single note element. Footnotes and endnotes share the same
@@ -63,6 +65,7 @@ function serializeRequiredNoteSeparators(elementName) {
 	return `<w:${elementName} w:type="separator" w:id="-1">${NOTE_SEPARATOR_BODY}<w:r><w:separator/></w:r></w:p></w:${elementName}><w:${elementName} w:type="continuationSeparator" w:id="0">${NOTE_SEPARATOR_BODY}<w:r><w:continuationSeparator/></w:r></w:p></w:${elementName}>`;
 }
 function insertNoteReferenceMark(xml, elementName) {
+	if (xml.includes(`<w:${elementName}Ref`)) return xml;
 	const paragraphOpen = /<w:p(?=[\s>])[^>]*>/u.exec(xml);
 	if (!paragraphOpen) return `${`<w:p><w:r><w:rPr><w:rStyle w:val="${elementName === "footnote" ? "FootnoteReference" : "EndnoteReference"}"/></w:rPr><w:${elementName}Ref/></w:r></w:p>`}${xml}`;
 	const paragraphStart = paragraphOpen.index + paragraphOpen[0].length;

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

@@ -1,11 +1,6 @@
 import { document_d_exports } from "../../types/document.js";
 //#region src/docx/serializer/numberingSerializer.d.ts
-/**
- * Serialize {@link NumberingDefinitions} to a complete `word/numbering.xml`
- * string. `w:abstractNum` elements precede `w:num` elements as ECMA-376 §17.9
- * requires. See the module note: this whole-part output is used only for
- * change detection and per-definition splicing, never to overwrite the part.
- */
+/** Serialize a complete `word/numbering.xml` part. */
 declare function serializeNumberingXml(numbering: document_d_exports.NumberingDefinitions): string;
 //#endregion
 export { serializeNumberingXml };

package/dist/docx/serializer/numberingSerializer.js

@@ -1,99 +1,101 @@
+import { serializeParagraphPropertySet } from "../../internal/paragraphFormattingSerialization.js";
+import { serializePreservedAttributes } from "../attributeRemainder.js";
+import { customNumberFormatOf } from "../numberingParser.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
 import { intAttr } from "./xmlUtils.js";
-import { escapeXmlAttribute } from "@stll/docx-core";
+import { escapeXmlAttribute, serializeOnOffElement } from "@stll/docx-core";
+import { serializeSequenceChildren } from "@stll/docx-core/schema";
 //#region src/docx/serializer/numberingSerializer.ts
-/**
-* Serialize a level's paragraph properties — the modeled subset is indentation
-* plus tab stops (see `parseLevelParagraphProps`). Returns "" when neither is
-* present so an empty `<w:pPr/>` is not emitted.
-*/
-function serializeLevelParagraphProps(pPr) {
-	const indAttrs = [];
-	if (pPr.indentLeft !== void 0) indAttrs.push(`w:left="${intAttr(pPr.indentLeft)}"`);
-	if (pPr.indentRight !== void 0) indAttrs.push(`w:right="${intAttr(pPr.indentRight)}"`);
-	if (pPr.indentFirstLine !== void 0) {
-		if (pPr.hangingIndent) indAttrs.push(`w:hanging="${intAttr(Math.abs(pPr.indentFirstLine))}"`);
-		else if (pPr.indentFirstLine !== 0) indAttrs.push(`w:firstLine="${intAttr(pPr.indentFirstLine)}"`);
-	}
-	const parts = [];
-	if (pPr.tabs && pPr.tabs.length > 0) {
-		const tabs = pPr.tabs.map((tab) => {
-			const attrs = [`w:val="${tab.alignment}"`, `w:pos="${intAttr(tab.position)}"`];
-			if (tab.leader) attrs.push(`w:leader="${tab.leader}"`);
-			return `<w:tab ${attrs.join(" ")}/>`;
-		}).join("");
-		parts.push(`<w:tabs>${tabs}</w:tabs>`);
-	}
-	if (indAttrs.length > 0) parts.push(`<w:ind ${indAttrs.join(" ")}/>`);
-	if (parts.length === 0) return "";
-	return `<w:pPr>${parts.join("")}</w:pPr>`;
-}
-/**
-* Serialize one `w:lvl`. Children follow the ECMA-376 §17.9.6 CT_Lvl order
-* (start, numFmt, lvlRestart, isLgl, suff, lvlText, legacy, lvlJc, pPr, rPr) so
-* a re-emitted level parses back into an equivalent model.
-*/
+/** Serialize one `w:lvl`. */
 function serializeLevel(level) {
-	const parts = [];
-	if (level.start !== void 0) parts.push(`<w:start w:val="${intAttr(level.start)}"/>`);
-	parts.push(`<w:numFmt w:val="${escapeXmlAttribute(level.numFmt)}"/>`);
-	if (level.lvlRestart !== void 0) parts.push(`<w:lvlRestart w:val="${intAttr(level.lvlRestart)}"/>`);
-	if (level.isLgl) parts.push("<w:isLgl/>");
-	if (level.suffix) parts.push(`<w:suff w:val="${level.suffix}"/>`);
-	parts.push(`<w:lvlText w:val="${escapeXmlAttribute(level.lvlText)}"/>`);
-	if (level.legacy) {
-		const legacyAttrs = [`w:legacy="${level.legacy.legacy ? 1 : 0}"`];
-		if (level.legacy.legacySpace !== void 0) legacyAttrs.push(`w:legacySpace="${intAttr(level.legacy.legacySpace)}"`);
-		if (level.legacy.legacyIndent !== void 0) legacyAttrs.push(`w:legacyIndent="${intAttr(level.legacy.legacyIndent)}"`);
-		parts.push(`<w:legacy ${legacyAttrs.join(" ")}/>`);
+	const customFormat = customNumberFormatOf(level);
+	const numFmtFormat = customFormat === void 0 ? "" : ` w:format="${escapeXmlAttribute(customFormat)}"`;
+	const pPr = level.pPr === void 0 ? "" : serializeParagraphPropertySet({ formatting: level.pPr }) || "<w:pPr/>";
+	const rPr = level.rPr === void 0 ? "" : serializeTextFormatting(level.rPr) || "<w:rPr/>";
+	const lvlTextAttrs = [`w:val="${escapeXmlAttribute(level.lvlText)}"`];
+	if (level.lvlTextNull !== void 0) lvlTextAttrs.push(`w:null="${level.lvlTextNull ? 1 : 0}"`);
+	let legacy = "";
+	if (level.legacy !== void 0) {
+		const attributes = [];
+		if (level.legacy.legacy !== void 0) attributes.push(`w:legacy="${level.legacy.legacy ? 1 : 0}"`);
+		if (level.legacy.legacySpace !== void 0) attributes.push(`w:legacySpace="${intAttr(level.legacy.legacySpace)}"`);
+		if (level.legacy.legacyIndent !== void 0) attributes.push(`w:legacyIndent="${intAttr(level.legacy.legacyIndent)}"`);
+		legacy = attributes.length === 0 ? "<w:legacy/>" : `<w:legacy ${attributes.join(" ")}/>`;
 	}
-	if (level.lvlJc) parts.push(`<w:lvlJc w:val="${level.lvlJc}"/>`);
-	if (level.pPr) parts.push(serializeLevelParagraphProps(level.pPr));
-	parts.push(serializeTextFormatting(level.rPr));
-	return `<w:lvl w:ilvl="${intAttr(level.ilvl)}">${parts.join("")}</w:lvl>`;
+	const children = serializeSequenceChildren({
+		container: "w:lvl",
+		modelled: [
+			["start", level.start === void 0 ? "" : `<w:start w:val="${intAttr(level.start)}"/>`],
+			["numFmt", `<w:numFmt w:val="${escapeXmlAttribute(level.numFmt)}"${numFmtFormat}/>`],
+			["lvlRestart", level.lvlRestart === void 0 ? "" : `<w:lvlRestart w:val="${intAttr(level.lvlRestart)}"/>`],
+			["pStyle", level.pStyle === void 0 ? "" : `<w:pStyle w:val="${escapeXmlAttribute(level.pStyle)}"/>`],
+			["isLgl", serializeOnOffElement(level.isLgl, "isLgl")],
+			["suff", level.suffix === void 0 ? "" : `<w:suff w:val="${escapeXmlAttribute(level.suffix)}"/>`],
+			["lvlText", `<w:lvlText ${lvlTextAttrs.join(" ")}/>`],
+			["lvlPicBulletId", level.lvlPicBulletId === void 0 ? "" : `<w:lvlPicBulletId w:val="${intAttr(level.lvlPicBulletId)}"/>`],
+			["legacy", legacy],
+			["lvlJc", level.lvlJc === void 0 ? "" : `<w:lvlJc w:val="${escapeXmlAttribute(level.lvlJc)}"/>`],
+			["pPr", pPr],
+			["rPr", rPr]
+		],
+		preserved: level.preserved
+	});
+	const attributes = [`w:ilvl="${intAttr(level.ilvl)}"`];
+	if (level.tplc !== void 0) attributes.push(`w:tplc="${escapeXmlAttribute(level.tplc)}"`);
+	if (level.tentative !== void 0) attributes.push(`w:tentative="${level.tentative ? 1 : 0}"`);
+	return `<w:lvl ${serializePreservedAttributes(attributes, level.preservedAttributes).join(" ")}>${children.join("")}</w:lvl>`;
 }
-/**
-* Serialize one `w:abstractNum` (the reusable list template). Children follow
-* ECMA-376 §17.9.1 CT_AbstractNum order for the modeled subset (multiLevelType,
-* name, styleLink, numStyleLink, lvl+); `w:nsid` / `w:tmpl` are not modeled.
-*/
+/** Serialize one reusable `w:abstractNum` list template. */
 function serializeAbstractNum(abstractNum) {
-	const parts = [];
-	if (abstractNum.multiLevelType) parts.push(`<w:multiLevelType w:val="${abstractNum.multiLevelType}"/>`);
-	if (abstractNum.name !== void 0) parts.push(`<w:name w:val="${escapeXmlAttribute(abstractNum.name)}"/>`);
-	if (abstractNum.styleLink !== void 0) parts.push(`<w:styleLink w:val="${escapeXmlAttribute(abstractNum.styleLink)}"/>`);
-	if (abstractNum.numStyleLink !== void 0) parts.push(`<w:numStyleLink w:val="${escapeXmlAttribute(abstractNum.numStyleLink)}"/>`);
-	const levels = [...abstractNum.levels].sort((a, b) => a.ilvl - b.ilvl);
-	for (const level of levels) parts.push(serializeLevel(level));
-	return `<w:abstractNum w:abstractNumId="${intAttr(abstractNum.abstractNumId)}">${parts.join("")}</w:abstractNum>`;
+	const levels = [...abstractNum.levels].sort((left, right) => left.ilvl - right.ilvl);
+	const children = serializeSequenceChildren({
+		container: "w:abstractNum",
+		modelled: [
+			["nsid", abstractNum.nsid === void 0 ? "" : `<w:nsid w:val="${escapeXmlAttribute(abstractNum.nsid)}"/>`],
+			["multiLevelType", abstractNum.multiLevelType === void 0 ? "" : `<w:multiLevelType w:val="${escapeXmlAttribute(abstractNum.multiLevelType)}"/>`],
+			["tmpl", abstractNum.tmpl === void 0 ? "" : `<w:tmpl w:val="${escapeXmlAttribute(abstractNum.tmpl)}"/>`],
+			["name", abstractNum.name === void 0 ? "" : `<w:name w:val="${escapeXmlAttribute(abstractNum.name)}"/>`],
+			["styleLink", abstractNum.styleLink === void 0 ? "" : `<w:styleLink w:val="${escapeXmlAttribute(abstractNum.styleLink)}"/>`],
+			["numStyleLink", abstractNum.numStyleLink === void 0 ? "" : `<w:numStyleLink w:val="${escapeXmlAttribute(abstractNum.numStyleLink)}"/>`],
+			["lvl", levels.map(serializeLevel).join("")]
+		],
+		preserved: abstractNum.preserved
+	});
+	return `<w:abstractNum ${serializePreservedAttributes([`w:abstractNumId="${intAttr(abstractNum.abstractNumId)}"`], abstractNum.preservedAttributes).join(" ")}>${children.join("")}</w:abstractNum>`;
 }
-/**
-* Serialize one `w:num` (a concrete numbering instance referenced by `numId`).
-*/
+/** Serialize one concrete instance's per-level override. */
+function serializeLevelOverride(override) {
+	const children = serializeSequenceChildren({
+		container: "w:lvlOverride",
+		modelled: [["startOverride", override.startOverride === void 0 ? "" : `<w:startOverride w:val="${intAttr(override.startOverride)}"/>`], ["lvl", override.lvl === void 0 ? "" : serializeLevel(override.lvl)]],
+		preserved: override.preserved
+	});
+	return `<w:lvlOverride ${serializePreservedAttributes([`w:ilvl="${intAttr(override.ilvl)}"`], override.preservedAttributes).join(" ")}>${children.join("")}</w:lvlOverride>`;
+}
+/** Serialize one concrete `w:num` numbering instance. */
 function serializeNum(instance) {
-	const parts = [`<w:abstractNumId w:val="${intAttr(instance.abstractNumId)}"/>`];
-	for (const override of instance.levelOverrides ?? []) {
-		const overrideParts = [];
-		if (override.startOverride !== void 0) overrideParts.push(`<w:startOverride w:val="${intAttr(override.startOverride)}"/>`);
-		if (override.lvl) overrideParts.push(serializeLevel(override.lvl));
-		parts.push(`<w:lvlOverride w:ilvl="${intAttr(override.ilvl)}">${overrideParts.join("")}</w:lvlOverride>`);
-	}
-	return `<w:num w:numId="${intAttr(instance.numId)}">${parts.join("")}</w:num>`;
+	const children = serializeSequenceChildren({
+		container: "w:num",
+		modelled: [["abstractNumId", `<w:abstractNumId w:val="${intAttr(instance.abstractNumId)}"/>`], ["lvlOverride", (instance.levelOverrides ?? []).map(serializeLevelOverride).join("")]],
+		preserved: instance.preserved
+	});
+	return `<w:num ${serializePreservedAttributes([`w:numId="${intAttr(instance.numId)}"`], instance.preservedAttributes).join(" ")}>${children.join("")}</w:num>`;
 }
-/**
-* Serialize {@link NumberingDefinitions} to a complete `word/numbering.xml`
-* string. `w:abstractNum` elements precede `w:num` elements as ECMA-376 §17.9
-* requires. See the module note: this whole-part output is used only for
-* change detection and per-definition splicing, never to overwrite the part.
-*/
+/** Serialize a complete `word/numbering.xml` part. */
 function serializeNumberingXml(numbering) {
+	const children = serializeSequenceChildren({
+		container: "w:numbering",
+		modelled: [["abstractNum", numbering.abstractNums.map(serializeAbstractNum).join("")], ["num", numbering.nums.map(serializeNum).join("")]],
+		preserved: numbering.preserved
+	});
 	return "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + serializePartElement({
 		partPath: "word/numbering.xml",
 		rootName: "w:numbering",
+		rootAttributes: serializePreservedAttributes([], numbering.preservedAttributes).join(" "),
 		baselinePrefixes: ["w"],
 		sourceBindings: void 0,
-		body: `${numbering.abstractNums.map(serializeAbstractNum).join("")}${numbering.nums.map(serializeNum).join("")}`
+		body: children.join("")
 	});
 }
 //#endregion