@stll/folio-core 0.33.0 → 0.33.2

package/dist/docx/paragraphParser.js

@@ -2,14 +2,16 @@ import { isValidHexColor } from "../utils/colorResolver.js";
 import { isValidHexId } from "../utils/hexId.js";
 import { parseBookmarkEnd as parseBookmarkEnd$1, parseBookmarkStart as parseBookmarkStart$1 } from "./bookmarkParser.js";
 import { parseFieldType } from "./fieldParser.js";
-import { parseHyperlink as parseHyperlink$1 } from "./hyperlinkParser.js";
+import { parseHyperlink as parseHyperlink$1, parseHyperlinkChild } from "./hyperlinkParser.js";
 import { markerFormattingFromLevel } from "./numberingParser.js";
+import { paraIdInRange } from "./paraIdRangeNormalization.js";
 import { BorderStyleSchema, FrameWrapSchema, FrameXAlignSchema, FrameYAlignSchema, LineSpacingRuleSchema, ParagraphAlignmentSchema, ShadingPatternSchema, TabLeaderSchema, TabStopAlignmentSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
 import { consolidateParagraphContent } from "./runConsolidator.js";
 import { parseRun, parseRunProperties } from "./runParser.js";
 import { parseSdtProperties } from "./sdtProperties.js";
 import { parseSectionProperties } from "./sectionParser.js";
-import { WORDPROCESSINGML_NAMESPACE_URIS, elementToXml, findChild, findChildByNamespaceUri, findChildren, getAttribute, getChildElements, getLocalName, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute } from "./xmlParser.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, findChildByNamespaceUri, findChildren, getAttribute, getChildElements, getLocalName, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute } from "./xmlParser.js";
 import { panic } from "better-result";
 import { PARAGRAPH_MARK_CHANGE_KINDS, normalizeRevisionId } from "@stll/docx-core/model";
 //#region src/docx/paragraphParser.ts
@@ -646,6 +648,80 @@ function pushInlineSdtSegments({ contents, properties, parsedContent }) {
 function parseHyperlink(node, rels, styles, theme, media, rootXmlns = {}) {
 	return parseHyperlink$1(node, rels, styles, theme, media, rootXmlns);
 }
+/** The revision wrapper a `w:hyperlink` child is, when it is one. */
+const hyperlinkRevisionWrapperType = (node) => {
+	switch (getLocalName(node.name)) {
+		case "ins": return "insertion";
+		case "del": return "deletion";
+		case "moveFrom": return "moveFrom";
+		case "moveTo": return "moveTo";
+		default: return;
+	}
+};
+const isHyperlinkChildContent = (content) => content.type === "run" || content.type === "bookmarkStart" || content.type === "bookmarkEnd";
+/**
+* A `w:hyperlink` as paragraph content, with any revision wrapper it holds
+* hoisted around it.
+*
+* OOXML nests `w:ins`/`w:del` INSIDE `w:hyperlink`; the model nests the
+* hyperlink inside the revision, because a revision is the unit a redline
+* reads and a link that is half deleted is two links to it. This is the exact
+* inverse of what the serializer writes, so a package survives the round trip.
+*/
+function parseHyperlinkParagraphContents(node, rels, styles, theme, media, rootXmlns) {
+	const children = getChildElements(node);
+	if (!children.some((child) => hyperlinkRevisionWrapperType(child) !== void 0)) return [parseHyperlink(node, rels, styles, theme, media, rootXmlns)];
+	const inScopeXmlns = mergeXmlnsDeclarations(rootXmlns, node);
+	const shell = parseHyperlink(node, rels, styles, theme, media, rootXmlns);
+	const linkOver = (linkChildren) => ({
+		...shell,
+		children: [...linkChildren]
+	});
+	const contents = [];
+	let plain = [];
+	const flushPlain = () => {
+		if (plain.length > 0) {
+			contents.push(linkOver(plain));
+			plain = [];
+		}
+	};
+	for (const child of children) {
+		const wrapperType = hyperlinkRevisionWrapperType(child);
+		if (wrapperType === void 0) {
+			const parsed = parseHyperlinkChild(child, styles, theme, rels, media, inScopeXmlns);
+			if (parsed) plain.push(parsed);
+			continue;
+		}
+		flushPlain();
+		const wrapped = parseParagraphContents(child, styles, theme, null, rels, media, wrapperType === "deletion" || wrapperType === "moveFrom" ? "deletion" : "default", inScopeXmlns);
+		const content = [];
+		let linked = [];
+		const flushLinked = () => {
+			if (linked.length > 0) {
+				content.push(linkOver(linked));
+				linked = [];
+			}
+		};
+		for (const item of wrapped) {
+			if (isHyperlinkChildContent(item)) {
+				linked.push(item);
+				continue;
+			}
+			flushLinked();
+			if (isTrackedChangeWrapperChild(item)) content.push(item);
+		}
+		flushLinked();
+		pushTrackedChangeWrapper({
+			contents,
+			type: wrapperType,
+			info: parseTrackedChangeInfo(child),
+			content,
+			preserveEmpty: true
+		});
+	}
+	flushPlain();
+	return contents;
+}
 /**
 * Parse bookmark start (w:bookmarkStart)
 * Delegates to bookmarkParser module.
@@ -798,7 +874,7 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 				break;
 			}
 			case "hyperlink":
-				contents.push(parseHyperlink(child, rels, styles, theme, media, inScopeXmlns));
+				contents.push(...parseHyperlinkParagraphContents(child, rels, styles, theme, media, inScopeXmlns));
 				break;
 			case "bookmarkStart":
 				contents.push(parseBookmarkStart(child));
@@ -920,7 +996,7 @@ function parseParagraphContents(paraElement, styles, theme, _numbering, rels, me
 			case "oMath":
 			case "oMathPara": {
 				const isBlock = localName === "oMathPara";
-				const ommlXml = elementToXml(child);
+				const ommlXml = captureVerbatimXml(child);
 				const plainText = extractMathText(child);
 				const mathEq = {
 					type: "mathEquation",
@@ -961,9 +1037,9 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 		content: []
 	};
 	const paraId = getAttribute(node, "w14", "paraId") ?? getAttribute(node, "w", "paraId");
-	if (paraId && isValidHexId(paraId)) paragraph.paraId = paraId;
+	if (paraId && isValidHexId(paraId)) paragraph.paraId = paraIdInRange(paraId);
 	const textId = getAttribute(node, "w14", "textId") ?? getAttribute(node, "w", "textId");
-	if (textId && isValidHexId(textId)) paragraph.textId = textId;
+	if (textId && isValidHexId(textId)) paragraph.textId = paraIdInRange(textId);
 	if (!options?.inHeaderFooter && paragraphStartsWithRenderedPageBreak(node)) paragraph.renderedPageBreakBefore = true;
 	const pPr = findChild(node, "w", "pPr");
 	if (pPr) {

package/dist/docx/revisionIdNormalization.d.ts

@@ -1,4 +1,18 @@
 //#region src/docx/revisionIdNormalization.d.ts
+declare const RevisionIdCollisionError_base: import("better-result").TaggedErrorClass<"RevisionIdCollisionError">;
+/**
+ * Two revision elements in one package claimed the same `w:id`.
+ *
+ * `w:id` on a revision element is unique across the package, so a collision is
+ * a package a consumer may reject rather than a cosmetic detail. The
+ * normalization below hands every id it emits to one choke point, which throws
+ * this rather than letting the duplicate reach the ZIP.
+ */
+declare class RevisionIdCollisionError extends RevisionIdCollisionError_base<{
+  message: string;
+  revisionId: number;
+  part: string;
+}> {}
 declare const REVISION_ELEMENT_NAMES: Set<string>;
 /**
  * Keep physical tracked-change element ids unique across a package.
@@ -10,4 +24,4 @@ declare const REVISION_ELEMENT_NAMES: Set<string>;
  */
 declare const normalizeRevisionIdsInXmlParts: (parts: ReadonlyMap<string, string>) => Map<string, string>;
 //#endregion
-export { REVISION_ELEMENT_NAMES, normalizeRevisionIdsInXmlParts };
+export { REVISION_ELEMENT_NAMES, RevisionIdCollisionError, normalizeRevisionIdsInXmlParts };

package/dist/docx/revisionIdNormalization.js

@@ -1,7 +1,17 @@
 import { rewriteStreamingXmlDecimalAttributes } from "./streamingXmlParser.js";
 import { WORDPROCESSINGML_NAMESPACE_URIS, findAttributeByNamespaceUri, getLocalName, getNamespaceUri } from "./xmlParser.js";
 import { XmlResourceLimitError, assertXmlResourceLimits } from "./xmlResourceLimits.js";
+import { TaggedError } from "better-result";
 //#region src/docx/revisionIdNormalization.ts
+/**
+* Two revision elements in one package claimed the same `w:id`.
+*
+* `w:id` on a revision element is unique across the package, so a collision is
+* a package a consumer may reject rather than a cosmetic detail. The
+* normalization below hands every id it emits to one choke point, which throws
+* this rather than letting the duplicate reach the ZIP.
+*/
+var RevisionIdCollisionError = class extends TaggedError("RevisionIdCollisionError") {};
 const REVISION_ELEMENT_NAMES = /* @__PURE__ */ new Set([
 	"cellDel",
 	"cellIns",
@@ -76,19 +86,27 @@ const normalizeRevisionIdsInXmlParts = (parts) => {
 	for (const [path, xml] of candidates) {
 		const ids = occurrencesByPath.get(path);
 		if (!ids) continue;
+		const claim = (id) => {
+			if (seen.has(id)) throw new RevisionIdCollisionError({
+				message: `Revision id ${String(id)} is claimed twice in ${path}`,
+				revisionId: id,
+				part: path
+			});
+			seen.add(id);
+		};
 		if (!repeatedPaths.has(path) && ids.every((id) => !seen.has(id))) {
-			for (const id of ids) seen.add(id);
+			for (const id of ids) claim(id);
 			continue;
 		}
 		const rewritten = rewriteStreamingXmlDecimalAttributes(xml, (element) => {
 			const attribute = revisionAttribute(element);
 			if (!attribute) return null;
 			if (!seen.has(attribute.id)) {
-				seen.add(attribute.id);
+				claim(attribute.id);
 				return null;
 			}
 			const replacement = allocate();
-			seen.add(replacement);
+			claim(replacement);
 			return /* @__PURE__ */ new Map([[attribute.name, String(replacement)]]);
 		});
 		if (rewritten.status === "unsupported") throw new XmlResourceLimitError({
@@ -100,4 +118,4 @@ const normalizeRevisionIdsInXmlParts = (parts) => {
 	return normalized;
 };
 //#endregion
-export { REVISION_ELEMENT_NAMES, normalizeRevisionIdsInXmlParts };
+export { REVISION_ELEMENT_NAMES, RevisionIdCollisionError, normalizeRevisionIdsInXmlParts };

package/dist/docx/rezip.d.ts

@@ -105,6 +105,12 @@ declare function updateMultipleFiles(originalBuffer: ArrayBuffer, updates: Map<s
 /**
  * Apply file updates to an already-loaded JSZip instance and generate the output.
  * Use this when the zip is already loaded to avoid a redundant decompression pass.
+ *
+ * This is the selective save's exit, so it owes the package the same passes
+ * {@link generateDocxZip} runs: a save that rewrites only the changed
+ * paragraphs still has to see the parts it left alone, both to know which
+ * revision ids are free and because an out-of-range paragraph id, or a
+ * malformed application version, can sit in a part it never touched.
  */
 declare function applyUpdatesToZip(zip: JSZip, updates: Map<string, string | ArrayBuffer>, options?: RepackOptions): Promise<ArrayBuffer>;
 /**
@@ -153,7 +159,13 @@ declare function hasUnmaterializedHeaderFooter(doc: document_d_exports.Document)
  * have been set without yet resolving in that header's rels).
  */
 declare function hasModelDrivenPictureWatermark(doc: document_d_exports.Document): boolean;
-declare function collectHeaderFooterUpdates(doc: document_d_exports.Document): Map<string, string>;
+/**
+ * Re-serialize every header/footer the model still owns, keyed by part path.
+ *
+ * `sourceZip` supplies each part as it stands before the save so the rebuilt
+ * root can keep any prefix binding only the source document declared.
+ */
+declare function collectHeaderFooterUpdates(doc: document_d_exports.Document, sourceZip: JSZip): Promise<Map<string, string>>;
 /** `word/Footnotes.xml` -> `word/_rels/Footnotes.xml.rels` (casing preserved). */
 declare function notePartRelsPath(partPath: string): string;
 /** Update existing core-property values without synthesizing absent metadata. */

package/dist/docx/rezip.js

@@ -1,4 +1,5 @@
 import { isAllowedExternalWatermarkImageUrl } from "../watermark/index.js";
+import { normalizeAppVersionInExtendedProperties } from "./appVersionNormalization.js";
 import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
 import { applyReplyThreadMarkers } from "./commentReplyMarkers.js";
 import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
@@ -6,6 +7,7 @@ import { assertValidFolioDocumentModel } from "./modelValidation.js";
 import { isNewDataUrlDrawing } from "./newImage.js";
 import { parseNumbering } from "./numberingParser.js";
 import { isUnsafePackagePath, reconcilePackageReferences, removeUnsafeEntries } from "./packageParts.js";
+import { normalizeParaIdRangeInXmlParts } from "./paraIdRangeNormalization.js";
 import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
 import { normalizeRevisionIdsInXmlParts } from "./revisionIdNormalization.js";
 import { appendNumberingDefs, buildPatchedNotePartXml, buildPatchedNumberingXml, collectAddedNumberingDefs, collectChangedNoteParaIds, collectChangedNumberingDefs, collectParaIds } from "./selectiveXmlPatch.js";
@@ -15,6 +17,7 @@ import { serializeFontTableXml } from "./serializer/fontTableSerializer.js";
 import { serializeHeaderFooter } from "./serializer/headerFooterSerializer.js";
 import { serializeEndnotes, serializeFootnotes, serializeNewEndnotesPart, serializeNewFootnotesPart } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
+import { readRootNamespaceBindings } from "./serializer/partNamespaces.js";
 import { serializeSettingsXml } from "./serializer/settingsSerializer.js";
 import { serializeStyle, serializeStylesXml } from "./serializer/stylesSerializer.js";
 import { serializeThemeXml } from "./serializer/themeSerializer.js";
@@ -121,13 +124,12 @@ function assertDocumentPackageFidelity(originalDocumentXml, serializedDocumentXm
 async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	const comments = doc.package.document.comments ?? [];
 	const sourceCommentsFile = findZipEntryCaseInsensitive(zip, "word/comments.xml");
+	const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("text") : void 0;
 	if (comments.length === 0) {
-		if (!sourceCommentsFile) return;
-		const sourceCommentsXml = await sourceCommentsFile.async("text");
-		if (!hasCommentEntries(sourceCommentsXml)) return;
+		if (sourceCommentsXml === void 0 || !hasCommentEntries(sourceCommentsXml)) return;
 	}
 	ensureThreadedCommentParaIds(comments);
-	const commentsXml = serializeComments(comments);
+	const commentsXml = serializeComments(comments, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
 	zip.file(sourceCommentsFile?.name ?? "word/comments.xml", commentsXml, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
@@ -407,19 +409,58 @@ async function processNewHyperlinks(parts, zip, compressionLevel) {
 	}
 }
 /**
-* The single exit for a repacked package. Reconciliation runs here rather than
-* at each caller so no save path can emit a package whose relationships or
-* content types name a part it does not hold.
+* Bring the ids a package addresses itself by inside the bounds the format
+* gives them.
+*
+* Both bounds belong to the package rather than to a part, and neither is
+* something one serializer can see on its own. A revision `w:id` is unique
+* across the package, and one logical revision serializes as several physical
+* wrappers — a word diff cut around unchanged words, a revision split around a
+* hyperlink. A paragraph id is 31-bit, and a paragraph is referenced by id
+* from parts other than the one it lives in. So the passes run at the exits,
+* over every `word/*.xml` part including the ones a save left untouched.
 */
-const generateDocxZip = async (zip, compressionLevel) => {
-	await reconcilePackageReferences(zip, compressionLevel);
+const normalizePackageIdsInZip = async (zip, compressionLevel) => {
 	const xmlParts = /* @__PURE__ */ new Map();
 	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.startsWith("word/") && path.endsWith(".xml")) xmlParts.set(path, await file.async("text"));
-	const normalizedParts = normalizeRevisionIdsInXmlParts(xmlParts);
+	const normalizedParts = normalizeParaIdRangeInXmlParts(normalizeRevisionIdsInXmlParts(xmlParts));
 	for (const [path, xml] of normalizedParts) if (xml !== xmlParts.get(path)) zip.file(path, xml, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
 	});
+};
+const EXTENDED_PROPERTIES_PATH = "docProps/app.xml";
+/**
+* Bring the application version the package states about itself into the form
+* the schema gives it. A package that holds no extended properties keeps
+* holding none.
+*/
+const normalizeAppVersionInZip = async (zip, compressionLevel) => {
+	const extendedProperties = zip.file(EXTENDED_PROPERTIES_PATH);
+	if (!extendedProperties) return;
+	const xml = await extendedProperties.async("text");
+	const normalized = normalizeAppVersionInExtendedProperties(xml);
+	if (normalized !== xml) zip.file(EXTENDED_PROPERTIES_PATH, normalized, {
+		compression: "DEFLATE",
+		compressionOptions: { level: compressionLevel }
+	});
+};
+/**
+* Every pass a save owes the package as a whole, in one function so that the
+* full repack and the selective save cannot drift into running different ones.
+*/
+const normalizePackageOnSave = async (zip, compressionLevel) => {
+	await normalizePackageIdsInZip(zip, compressionLevel);
+	await normalizeAppVersionInZip(zip, compressionLevel);
+};
+/**
+* The single exit for a repacked package. Reconciliation runs here rather than
+* at each caller so no save path can emit a package whose relationships or
+* content types name a part it does not hold.
+*/
+const generateDocxZip = async (zip, compressionLevel) => {
+	await reconcilePackageReferences(zip, compressionLevel);
+	await normalizePackageOnSave(zip, compressionLevel);
 	return zip.generateAsync({
 		type: "arraybuffer",
 		compression: "DEFLATE",
@@ -454,14 +495,14 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 	await processNewHyperlinks(parts, outputZip, compressionLevel);
 	assertValidFolioDocumentModel(document, "Cannot repack invalid DOCX document model");
 	applyReplyThreadMarkers(document);
-	const documentXml = serializeDocument(document);
+	const documentXml = serializeDocument(document, originalDocumentXml === void 0 ? void 0 : readRootNamespaceBindings(originalDocumentXml));
 	if (originalDocumentXml) assertDocumentPackageFidelity(originalDocumentXml, documentXml, document);
 	outputZip.file("word/document.xml", documentXml, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
 	});
 	await rebindWatermarkRelIds(document, outputZip, compressionLevel);
-	serializeHeadersFootersToZip(document, outputZip, compressionLevel);
+	await serializeHeadersFootersToZip(document, outputZip, compressionLevel);
 	await serializeNotesToZip({
 		doc: document,
 		originalZip,
@@ -543,14 +584,14 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	await processNewHyperlinks(parts, newZip, compressionLevel);
 	assertValidFolioDocumentModel(exportDocument, "Cannot repack invalid DOCX document model");
 	applyReplyThreadMarkers(exportDocument);
-	const documentXml = serializeDocument(exportDocument);
+	const documentXml = serializeDocument(exportDocument, rawContent.documentXml ? readRootNamespaceBindings(rawContent.documentXml) : void 0);
 	if (rawContent.documentXml) assertDocumentPackageFidelity(rawContent.documentXml, documentXml, exportDocument);
 	newZip.file("word/document.xml", documentXml, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
 	});
 	await rebindWatermarkRelIds(exportDocument, newZip, compressionLevel);
-	serializeHeadersFootersToZip(exportDocument, newZip, compressionLevel);
+	await serializeHeadersFootersToZip(exportDocument, newZip, compressionLevel);
 	await serializeNotesToZip({
 		doc: exportDocument,
 		originalZip: rawContent.originalZip,
@@ -758,14 +799,21 @@ async function updateMultipleFiles(originalBuffer, updates, options = {}) {
 /**
 * Apply file updates to an already-loaded JSZip instance and generate the output.
 * Use this when the zip is already loaded to avoid a redundant decompression pass.
+*
+* This is the selective save's exit, so it owes the package the same passes
+* {@link generateDocxZip} runs: a save that rewrites only the changed
+* paragraphs still has to see the parts it left alone, both to know which
+* revision ids are free and because an out-of-range paragraph id, or a
+* malformed application version, can sit in a part it never touched.
 */
-function applyUpdatesToZip(zip, updates, options = {}) {
+async function applyUpdatesToZip(zip, updates, options = {}) {
 	const { compressionLevel = 6 } = options;
 	for (const [path, content] of updates) zip.file(path, content, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
 	});
-	return zip.generateAsync({
+	await normalizePackageOnSave(zip, compressionLevel);
+	return await zip.generateAsync({
 		type: "arraybuffer",
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
@@ -1067,7 +1115,13 @@ async function rebindWatermarkRelIds(doc, zip, compressionLevel) {
 		});
 	}
 }
-function collectHeaderFooterUpdates(doc) {
+/**
+* Re-serialize every header/footer the model still owns, keyed by part path.
+*
+* `sourceZip` supplies each part as it stands before the save so the rebuilt
+* root can keep any prefix binding only the source document declared.
+*/
+async function collectHeaderFooterUpdates(doc, sourceZip) {
 	const updates = /* @__PURE__ */ new Map();
 	const rels = doc.package.relationships;
 	if (!rels) return updates;
@@ -1084,8 +1138,13 @@ function collectHeaderFooterUpdates(doc) {
 		for (const [rId, headerFooter] of map.entries()) {
 			const rel = rels.get(rId);
 			if (rel && rel.type === type && rel.target) {
-				const filename = resolveRelativePath(documentRelsPath, rel.target);
-				updates.set(filename, serializeHeaderFooter(headerFooter));
+				const path = resolveRelativePath(documentRelsPath, rel.target);
+				const sourceFile = findZipEntryCaseInsensitive(sourceZip, path.toLowerCase());
+				const bindings = sourceFile ? readRootNamespaceBindings(await sourceFile.async("text")) : /* @__PURE__ */ new Map();
+				updates.set(path, serializeHeaderFooter(headerFooter, {
+					path,
+					bindings
+				}));
 			}
 		}
 	}
@@ -1094,9 +1153,9 @@ function collectHeaderFooterUpdates(doc) {
 /**
 * Serialize modified headers and footers into the ZIP
 */
-function serializeHeadersFootersToZip(doc, zip, compressionLevel) {
+async function serializeHeadersFootersToZip(doc, zip, compressionLevel) {
 	const compressionOptions = { level: compressionLevel };
-	for (const [filename, xml] of collectHeaderFooterUpdates(doc)) zip.file(filename, xml, {
+	for (const [filename, xml] of await collectHeaderFooterUpdates(doc, zip)) zip.file(filename, xml, {
 		compression: "DEFLATE",
 		compressionOptions
 	});

package/dist/docx/runParser.js

@@ -7,8 +7,9 @@ import { parseShapeFromDrawing, shouldPreserveRawShapeDrawing } from "./shapePar
 import { isTextBoxDrawing } from "./textBoxParser.js";
 import { requiresXmlSpacePreserve } from "./textWhitespace.js";
 import { resolveThemeFontRef } from "./themeParser.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
 import { parseVmlImageContent } from "./vmlImageParser.js";
-import { cloneWithXmlnsDeclarations, elementToXml, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
+import { cloneWithXmlnsDeclarations, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
 import { DRAWING_RAW_XML_MODES, normalizeRevisionId } from "@stll/docx-core/model";
 //#region src/docx/runParser.ts
 /**
@@ -489,7 +490,7 @@ function parseDrawingContent(element, rels, media) {
 	if (groupImage) return {
 		type: "drawing",
 		image: groupImage,
-		rawXml: elementToXml(element)
+		rawXml: captureVerbatimXml(element)
 	};
 	if (shouldPreserveRawShapeDrawing(element)) return {
 		type: "drawing",
@@ -502,7 +503,7 @@ function parseDrawingContent(element, rels, media) {
 			},
 			wrap: { type: "inline" }
 		},
-		rawXml: elementToXml(element),
+		rawXml: captureVerbatimXml(element),
 		rawXmlMode: DRAWING_RAW_XML_MODES.PRESERVE_ONLY
 	};
 	const shape = parseShapeFromDrawing(element);
@@ -516,7 +517,7 @@ function parseDrawingContent(element, rels, media) {
 		type: "drawing",
 		image
 	};
-	if (!image.src) drawing.rawXml = elementToXml(element);
+	if (!image.src) drawing.rawXml = captureVerbatimXml(element);
 	return drawing;
 }
 /**
@@ -593,7 +594,7 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 			if (groupedChoiceDrawing) {
 				const groupedDrawing = parseDrawingContent(groupedChoiceDrawing, rels, media);
 				if (groupedDrawing?.type === "drawing" && groupedDrawing.image.src) {
-					groupedDrawing.rawXml = elementToXml(child);
+					groupedDrawing.rawXml = captureVerbatimXml(child);
 					contents.push(groupedDrawing);
 					break;
 				}
@@ -601,7 +602,7 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 			const fallbackPict = fallbackEl ? getChildElements(fallbackEl).find((el) => getLocalName(el.name) === "pict") : void 0;
 			const fallbackVml = fallbackPict && !choiceTextBoxDrawing ? parseVmlImageContent(fallbackPict, rels, media, rootXmlns) : null;
 			if (fallbackVml?.image.src) {
-				fallbackVml.rawXml = elementToXml(cloneWithXmlnsDeclarations(child, rootXmlns));
+				fallbackVml.rawXml = captureVerbatimXml(cloneWithXmlnsDeclarations(child, rootXmlns));
 				contents.push(fallbackVml);
 				break;
 			}
@@ -611,13 +612,13 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 				if (innerName === "drawing") {
 					const innerDrawing = parseDrawingContent(innerChild, rels, media);
 					if (innerDrawing) {
-						if (innerDrawing.type === "drawing" && (innerDrawing.rawXml !== void 0 || !innerDrawing.image.src)) innerDrawing.rawXml = elementToXml(child);
+						if (innerDrawing.type === "drawing" && (innerDrawing.rawXml !== void 0 || !innerDrawing.image.src)) innerDrawing.rawXml = captureVerbatimXml(child);
 						contents.push(innerDrawing);
 					}
 				} else if (innerName === "pict") {
 					const innerVml = parseVmlImageContent(innerChild, rels, media, rootXmlns);
 					if (innerVml) {
-						innerVml.rawXml = elementToXml(cloneWithXmlnsDeclarations(child, rootXmlns));
+						innerVml.rawXml = captureVerbatimXml(cloneWithXmlnsDeclarations(child, rootXmlns));
 						contents.push(innerVml);
 					}
 				}

package/dist/docx/sdtProperties.js

@@ -1,5 +1,6 @@
 import { SdtLockSchema, narrowEnum } from "./parserEnums.js";
-import { elementToXml, findChild, getAttributeAnyPrefix, getLocalName, parseBooleanElement } from "./xmlParser.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
+import { findChild, getAttributeAnyPrefix, getLocalName, parseBooleanElement } from "./xmlParser.js";
 //#region src/docx/sdtProperties.ts
 function parseListItems(el) {
 	const items = [];
@@ -201,7 +202,7 @@ function rewriteOpenTagAttrPrefixes(raw, canonical, local) {
 function parseSdtProperties(sdtPr, sdtEndPr) {
 	const props = { sdtType: "richText" };
 	if (sdtPr) {
-		props.rawPropertiesXml = normalizeWordPrefix(elementToXml(sdtPr), 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) : "";
@@ -283,7 +284,7 @@ function parseSdtProperties(sdtPr, sdtEndPr) {
 			}
 		}
 	}
-	if (sdtEndPr) props.rawEndPropertiesXml = normalizeWordPrefix(elementToXml(sdtEndPr), sdtEndPr);
+	if (sdtEndPr) props.rawEndPropertiesXml = normalizeWordPrefix(captureVerbatimXml(sdtEndPr), sdtEndPr);
 	return props;
 }
 //#endregion

package/dist/docx/selectiveSave.js

@@ -13,6 +13,7 @@ import { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExten
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeEndnotes, serializeFootnotes } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
+import { readRootNamespaceBindings } from "./serializer/partNamespaces.js";
 //#region src/docx/selectiveSave.ts
 /**
 * Check if document content has new images (data: URL without rId) or
@@ -209,7 +210,6 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 	if (!validateFolioDocumentModel(doc).valid) return null;
 	const comments = doc.package.document.comments ?? [];
 	const hasComments = comments.length > 0;
-	const headerFooterUpdates = collectHeaderFooterUpdates(doc);
 	try {
 		const zip = await (await import("jszip")).default.loadAsync(originalBuffer);
 		for (const [path, file] of Object.entries(zip.files)) if (!file.dir && isUnsafePackagePath(path)) return null;
@@ -228,15 +228,16 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 				if (unrouted === null || unrouted.size > 0) return null;
 			}
 			if (bodyChangedIds.size > 0) {
-				const patchedDocXml = buildPatchedDocumentXml(originalDocXml, serializeDocument(doc), bodyChangedIds);
+				const patchedDocXml = buildPatchedDocumentXml(originalDocXml, serializeDocument(doc, readRootNamespaceBindings(originalDocXml)), bodyChangedIds);
 				if (!patchedDocXml) return null;
 				updates.set("word/document.xml", patchedDocXml);
 			}
 		}
-		const hadCommentsFile = zip.file("word/comments.xml") !== null;
-		if (hasComments || hadCommentsFile) {
+		const sourceCommentsFile = zip.file("word/comments.xml");
+		if (hasComments || sourceCommentsFile) {
 			ensureThreadedCommentParaIds(comments);
-			updates.set("word/comments.xml", serializeComments(comments));
+			const sourceBindings = sourceCommentsFile ? readRootNamespaceBindings(await sourceCommentsFile.async("text")) : void 0;
+			updates.set("word/comments.xml", serializeComments(comments, sourceBindings));
 		}
 		if (hasComments) {
 			const ctFile = zip.file("[Content_Types].xml");
@@ -256,7 +257,7 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 		}
 		if (!await patchCommentsExtended(zip, comments, updates)) return null;
 		await patchNumberingPart(zip, doc, updates);
-		for (const [path, xml] of headerFooterUpdates) updates.set(path, xml);
+		for (const [path, xml] of await collectHeaderFooterUpdates(doc, zip)) updates.set(path, xml);
 		await queueSettingsUpdates(zip, updates);
 		const corePropsFile = zip.file("docProps/core.xml");
 		if (corePropsFile) {

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

@@ -7,7 +7,7 @@ import { Comment } from "../../types/content.js";
  * comment — leaving the previous file in place would otherwise re-emit
  * the orphaned comment threads on every save.
  */
-declare function serializeComments(comments: Comment[]): string;
+declare function serializeComments(comments: Comment[], sourceBindings?: ReadonlyMap<string, string>): string;
 /**
  * Assign a deterministic `w14:paraId` to the LAST paragraph of every comment
  * that needs a commentsExtended entry (a reply, a reply's parent, or a resolved