@stll/folio-core 0.59.0 → 0.61.0

package/dist/docx/runParser.js

@@ -1,4 +1,5 @@
 import { parseHorizontalScalePercent } from "../utils/horizontalScale.js";
+import { sliceText } from "../utils/sliceText.js";
 import { NO_MODELLED_ATTRIBUTES, attributeRemainder } from "./attributeRemainder.js";
 import { CAPTURE, dispatchChildrenWithContext, keptUnless, ownedElsewhere, sequencePositions } from "./containerChildren.js";
 import { parseDiagramPreview } from "./diagramPreview.js";
@@ -10,6 +11,7 @@ import { EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSche
 import { preserveRunChild } from "./preservedRunContent.js";
 import { standalonePreviewLedger } from "./previewBudget.js";
 import { parseBoundaryJoins } from "./reviewResolutionProvenance.js";
+import { isEmptyRunPropertiesAttribute, omitsPreviousRunProperties, retainsEmptyRunProperties } from "./runPropertyPresence.js";
 import { parseShading } from "./shadingParser.js";
 import { captureShapeAlternateContent } from "./shapeAlternateContent.js";
 import { parseShapeFromDrawing, shouldPreserveRawShapeDrawing } from "./shapeParser.js";
@@ -48,7 +50,11 @@ import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 * attacker-sized string per run.
 */
 const MAX_LANGUAGE_TAG_LENGTH = 35;
-const truncateLanguageTag = (value) => value === void 0 ? void 0 : value.slice(0, MAX_LANGUAGE_TAG_LENGTH);
+const truncateLanguageTag = (value) => value === void 0 ? void 0 : sliceText({
+	text: value,
+	units: "codeUnits",
+	end: MAX_LANGUAGE_TAG_LENGTH
+});
 function parseColorValue({ rgb, themeColor, themeTint, themeShade, element }) {
 	const color = {};
 	if (rgb && rgb !== "auto") color.rgb = rgb;
@@ -429,7 +435,7 @@ function parseRunProperties(rPr, theme, owner) {
 	});
 	if (preserved) formatting.preserved = preserved;
 	const children = getChildElements(rPr);
-	if (owner === RUN_PROPERTY_OWNERS.paragraphMark && Object.keys(formatting).length === 0 && children.length > 0 && children.every((child) => WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(child) ?? "") && Object.hasOwn(OWNED_BY_A_SIBLING_RECORD.paragraphMark, getLocalName(child.name)))) return;
+	if (owner !== RUN_PROPERTY_OWNERS.standalone && Object.keys(formatting).length === 0 && children.length > 0 && children.every((child) => WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(child) ?? "") && Object.hasOwn(OWNED_BY_A_SIBLING_RECORD[owner], getLocalName(child.name)))) return;
 	return formatting;
 }
 function parseRunPropertyChanges(rPr, theme, currentFormatting) {
@@ -443,7 +449,7 @@ function parseRunPropertyChanges(rPr, theme, currentFormatting) {
 		const boundaryJoins = parseBoundaryJoins(changeElement);
 		if (boundaryJoins !== void 0) change.boundaryJoins = boundaryJoins;
 		const previousFormatting = parseRunProperties(previousRPr, theme, RUN_PROPERTY_OWNERS.standalone);
-		if (previousFormatting) change.previousFormatting = previousFormatting;
+		if (previousFormatting && (!omitsPreviousRunProperties(changeElement) || Object.keys(previousFormatting).length > 0)) change.previousFormatting = previousFormatting;
 		if (currentFormatting) change.currentFormatting = currentFormatting;
 		return change;
 	});
@@ -789,7 +795,7 @@ function parseRun(node, _styles, theme, rels = null, media = null, rootXmlns = {
 	};
 	const rPr = findChild(node, "w", "rPr");
 	if (rPr) {
-		const formattingResult = parseRunProperties(rPr, theme, RUN_PROPERTY_OWNERS.run);
+		const formattingResult = parseRunProperties(rPr, theme, RUN_PROPERTY_OWNERS.run) ?? (retainsEmptyRunProperties(node) ? {} : void 0);
 		if (formattingResult) run.formatting = formattingResult;
 		const propertyChangesResult = parseRunPropertyChanges(rPr, theme, run.formatting);
 		if (propertyChangesResult) run.propertyChanges = propertyChangesResult;
@@ -798,8 +804,8 @@ function parseRun(node, _styles, theme, rels = null, media = null, rootXmlns = {
 	const remainder = attributeRemainder({
 		element: node,
 		modelled: NO_MODELLED_ATTRIBUTES
-	});
-	if (remainder) run.preservedAttributes = remainder;
+	})?.filter((attribute) => !isEmptyRunPropertiesAttribute(attribute));
+	if (remainder?.length) run.preservedAttributes = remainder;
 	return run;
 }
 /**

package/dist/docx/runPropertyPresence.d.ts

@@ -0,0 +1,11 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/runPropertyPresence.d.ts
+declare const EMPTY_RUN_PROPERTIES_ATTRIBUTE = "emptyRunProperties";
+declare const retainsEmptyRunProperties: (element: XmlElement) => boolean;
+declare const omitsPreviousRunProperties: (element: XmlElement) => boolean;
+declare const serializePreviousRunProperties: (properties: document_d_exports.TextFormatting | undefined) => string;
+declare const serializeEmptyRunProperties: (run: document_d_exports.Run) => string[];
+declare const isEmptyRunPropertiesAttribute: ({ namespace, name }: Pick<document_d_exports.PreservedAttribute, "namespace" | "name">) => boolean;
+//#endregion
+export { EMPTY_RUN_PROPERTIES_ATTRIBUTE, isEmptyRunPropertiesAttribute, omitsPreviousRunProperties, retainsEmptyRunProperties, serializeEmptyRunProperties, serializePreviousRunProperties };

package/dist/docx/runPropertyPresence.js

@@ -0,0 +1,14 @@
+import { OOXML_NAMESPACES } from "./serializer/partNamespaces.js";
+import { getAttributeByNamespaceUri } from "./xmlParser.js";
+import { EMPTY_PROPERTY_SETS } from "@stll/docx-core/ops";
+//#region src/docx/runPropertyPresence.ts
+const EMPTY_RUN_PROPERTIES_ATTRIBUTE = "emptyRunProperties";
+const PREVIOUS_PROPERTIES_ATTRIBUTE = "previousProperties";
+const HISTORY_NAMESPACES = /* @__PURE__ */ new Set([OOXML_NAMESPACES.folio.uri]);
+const retainsEmptyRunProperties = (element) => getAttributeByNamespaceUri(element, HISTORY_NAMESPACES, EMPTY_RUN_PROPERTIES_ATTRIBUTE) === EMPTY_PROPERTY_SETS.KEEP;
+const omitsPreviousRunProperties = (element) => getAttributeByNamespaceUri(element, HISTORY_NAMESPACES, PREVIOUS_PROPERTIES_ATTRIBUTE) === EMPTY_PROPERTY_SETS.OMIT;
+const serializePreviousRunProperties = (properties) => properties === void 0 ? ` folio:${PREVIOUS_PROPERTIES_ATTRIBUTE}="${EMPTY_PROPERTY_SETS.OMIT}"` : "";
+const serializeEmptyRunProperties = (run) => run.propertyChanges?.length && run.formatting !== void 0 && Object.keys(run.formatting).length === 0 ? [`folio:${EMPTY_RUN_PROPERTIES_ATTRIBUTE}="${EMPTY_PROPERTY_SETS.KEEP}"`] : [];
+const isEmptyRunPropertiesAttribute = ({ namespace, name }) => namespace === OOXML_NAMESPACES.folio.uri && name === "emptyRunProperties";
+//#endregion
+export { EMPTY_RUN_PROPERTIES_ATTRIBUTE, isEmptyRunPropertiesAttribute, omitsPreviousRunProperties, retainsEmptyRunProperties, serializeEmptyRunProperties, serializePreviousRunProperties };

package/dist/docx/selectedXmlIdentityScan.d.ts

@@ -0,0 +1,10 @@
+import { scanStreamingXmlElements } from "./streamingXmlParser.js";
+//#region src/docx/selectedXmlIdentityScan.d.ts
+/** Identity census follows the parser's first-Choice, otherwise-Fallback policy. */
+declare const scanSelectedStreamingXmlElements: (xml: string, visitor: Parameters<typeof scanStreamingXmlElements>[1]) => {
+  status: "unsupported";
+} | {
+  status: "scanned";
+};
+//#endregion
+export { scanSelectedStreamingXmlElements };

package/dist/docx/selectedXmlIdentityScan.js

@@ -0,0 +1,36 @@
+import { scanStreamingXmlElements } from "./streamingXmlParser.js";
+import { NAMESPACES, getLocalName, getNamespaceUri, selectAlternateContentBranch } from "./xmlParser.js";
+//#region src/docx/selectedXmlIdentityScan.ts
+const isCompatibilityElement = (element, name) => getNamespaceUri(element) === NAMESPACES.mc && getLocalName(element.name) === name;
+/** Identity census follows the parser's first-Choice, otherwise-Fallback policy. */
+const scanSelectedStreamingXmlElements = (xml, visitor) => {
+	if (!xml.includes("AlternateContent")) return scanStreamingXmlElements(xml, visitor);
+	const alternatives = /* @__PURE__ */ new Map();
+	const positions = /* @__PURE__ */ new WeakMap();
+	const scanned = scanStreamingXmlElements(xml, ({ element, parent, nameEnd }) => {
+		positions.set(element, nameEnd);
+		if (isCompatibilityElement(element, "AlternateContent")) {
+			element.elements = [];
+			alternatives.set(nameEnd, element);
+		}
+		if (!parent || !isCompatibilityElement(parent, "AlternateContent")) return;
+		parent.elements?.push(element);
+	});
+	if (scanned.status === "unsupported") return scanned;
+	const selectedPositions = /* @__PURE__ */ new Map();
+	for (const [position, alternative] of alternatives) {
+		const selected = selectAlternateContentBranch(alternative);
+		selectedPositions.set(position, selected === void 0 ? void 0 : positions.get(selected));
+	}
+	const active = /* @__PURE__ */ new WeakMap();
+	return scanStreamingXmlElements(xml, (entry) => {
+		const { element, parent, nameEnd } = entry;
+		positions.set(element, nameEnd);
+		let included = parent === void 0 || active.get(parent) === true;
+		if (parent && isCompatibilityElement(parent, "AlternateContent")) included &&= nameEnd === selectedPositions.get(positions.get(parent) ?? -1);
+		active.set(element, included);
+		if (included) visitor(entry);
+	});
+};
+//#endregion
+export { scanSelectedStreamingXmlElements };

package/dist/docx/selectiveSave.js

@@ -1,3 +1,4 @@
+import { decodeText, encodeUtf8 } from "../utils/textEncoding.js";
 import { parseCommentsExtended } from "./commentParser.js";
 import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
 import { hasUnsynthesizedReplyRanges } from "./commentReplyMarkers.js";
@@ -10,7 +11,7 @@ import { RELATIONSHIP_TYPES } from "./relsParser.js";
 import { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_PART_LOWER, addCommentsExtendedOverride, addCommentsExtendedRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, hasUnmaterializedHyperlinkBindings, hasUnmaterializedInlineResources, planAddedStyles, publishCanonicalImageResources, updateCoreProperties, withoutAttachedTemplate } from "./rezip.js";
 import "./selectiveSaveFlags.js";
 import { buildPatchedDocumentXml, buildPatchedNoteXml, collectAddedNumberingDefs, collectParaIds, patchNumberingDefinitions } from "./selectiveXmlPatch.js";
-import { hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
+import { canReplayCommentsPart, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeEndnotes, serializeFootnotes } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
@@ -46,7 +47,7 @@ async function patchNoteParts(zip, doc, candidateIds, updates) {
 	const patchPart = async (conventionalLowerPath, serialize) => {
 		const file = findPart(conventionalLowerPath);
 		if (!file) return true;
-		const originalXml = await file.async("text");
+		const originalXml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 		const originalIds = collectParaIds(originalXml);
 		const partIds = /* @__PURE__ */ new Set();
 		for (const id of remainingIds) if (originalIds.has(id)) partIds.add(id);
@@ -93,7 +94,7 @@ async function patchCommentsExtended(zip, plan, updates) {
 	const desiredXml = serializeCommentsExtended(plan);
 	const existing = findZipEntryCaseInsensitive(zip, COMMENTS_EXTENDED_PART_LOWER);
 	if (!desiredXml) return existing === null;
-	const baselineInfo = existing ? parseCommentsExtended(await existing.async("text")) : /* @__PURE__ */ new Map();
+	const baselineInfo = existing ? parseCommentsExtended(await existing.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))) : /* @__PURE__ */ new Map();
 	if (commentsExtendedInfoEqual(parseCommentsExtended(desiredXml), baselineInfo)) return true;
 	updates.set(existing?.name ?? "word/commentsExtended.xml", desiredXml);
 	return ensureCommentsExtendedPackaging(zip, updates);
@@ -106,12 +107,12 @@ async function patchCommentsExtended(zip, plan, updates) {
 */
 async function ensureCommentsExtendedPackaging(zip, updates) {
 	const ctPath = "[Content_Types].xml";
-	const ctXml = updates.get(ctPath) ?? await zip.file(ctPath)?.async("text");
+	const ctXml = updates.get(ctPath) ?? await zip.file(ctPath)?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	if (ctXml === void 0) return false;
 	const nextCt = addCommentsExtendedOverride(ctXml);
 	if (nextCt !== ctXml) updates.set(ctPath, nextCt);
 	const relsPath = "word/_rels/document.xml.rels";
-	const relsXml = updates.get(relsPath) ?? await zip.file(relsPath)?.async("text");
+	const relsXml = updates.get(relsPath) ?? await zip.file(relsPath)?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	if (relsXml === void 0) return false;
 	const nextRels = addCommentsExtendedRelationship(relsXml);
 	if (nextRels !== relsXml) updates.set(relsPath, nextRels);
@@ -146,7 +147,7 @@ async function patchNumberingPart(zip, doc, updates) {
 		}
 	}
 	if (!file) return false;
-	const originalXml = await file.async("text");
+	const originalXml = await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 	const baselineXml = serializeNumberingXml(parseNumbering(originalXml).definitions);
 	const currentXml = serializeNumberingXml(numbering);
 	if (currentXml === baselineXml) return true;
@@ -177,7 +178,7 @@ const queueSettingsUpdates = async (zip, updates) => {
 	const settingsFile = zip.file("word/settings.xml");
 	if (!settingsFile) return;
 	const relsFile = zip.file("word/_rels/settings.xml.rels");
-	const filtered = withoutAttachedTemplate(await settingsFile.async("text"), await relsFile?.async("text"));
+	const filtered = withoutAttachedTemplate(await settingsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })), await relsFile?.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })));
 	if (filtered.settingsXml !== void 0) updates.set("word/settings.xml", filtered.settingsXml);
 	if (filtered.relsXml !== void 0) updates.set("word/_rels/settings.xml.rels", filtered.relsXml);
 };
@@ -212,12 +213,12 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 			for (const [path, file] of Object.entries(zip.files)) {
 				const lowerPath = path.toLowerCase();
 				if (file.dir || !lowerPath.startsWith("word/") || !lowerPath.endsWith(".xml")) continue;
-				sourceParts.set(path, await file.async("text"));
+				sourceParts.set(path, await file.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })));
 			}
 			for (const [path, xml] of normalizeImportedNumericIds(sourceParts)) if (xml !== sourceParts.get(path)) writeZipPart({
 				zip,
 				path,
-				data: xml
+				data: encodeUtf8(xml)
 			});
 		}
 		if (options.bodyAuthority === "canonical") await publishCanonicalImageResources({
@@ -229,7 +230,7 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 		if (changedParaIds.size > 0 || structuralChange) {
 			const docXmlFile = zip.file("word/document.xml");
 			if (!docXmlFile) return null;
-			const originalDocXml = await docXmlFile.async("text");
+			const originalDocXml = await docXmlFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 			const serializedDocXml = serializeDocument(doc, readRootNamespaceBindings(originalDocXml), {
 				xml: originalDocXml,
 				bodyAuthority: options.bodyAuthority,
@@ -239,7 +240,7 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 			const originalBodyParaIds = structuralChange ? collectParaIds(originalDocXml) : void 0;
 			if (structuralChange && doc.package.numbering) {
 				const numberingFile = findZipEntryCaseInsensitive(zip, "word/numbering.xml");
-				const added = collectAddedNumberingDefs(numberingFile ? serializeNumberingXml(parseNumbering(await numberingFile.async("text")).definitions) : "", serializeNumberingXml(doc.package.numbering));
+				const added = collectAddedNumberingDefs(numberingFile ? serializeNumberingXml(parseNumbering(await numberingFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }))).definitions) : "", serializeNumberingXml(doc.package.numbering));
 				if (added.abstractNums.size > 0 || added.nums.size > 0) return null;
 			}
 			const bodyChangedIds = /* @__PURE__ */ new Set();
@@ -262,28 +263,29 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 		}
 		const sourceCommentsFile = findZipEntryCaseInsensitive(zip, "word/comments.xml");
 		const commentsPartPath = sourceCommentsFile?.name ?? "word/comments.xml";
-		if (hasComments || ownsCommentsPart || sourceCommentsFile) {
-			const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("text") : void 0;
+		const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true })) : void 0;
+		const commentsUnchanged = sourceCommentsXml !== void 0 && canReplayCommentsPart(doc, sourceCommentsXml);
+		if (!commentsUnchanged && (hasComments || ownsCommentsPart || sourceCommentsFile)) {
 			const commentsXml = serializeComments(commentPlan, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
 			if (commentsXml !== sourceCommentsXml) updates.set(commentsPartPath, commentsXml);
 		}
 		if (hasComments || ownsCommentsPart) {
 			const ctFile = zip.file("[Content_Types].xml");
 			if (ctFile) {
-				const ctXml = await ctFile.async("text");
+				const ctXml = await ctFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 				if (!ctXml.toLowerCase().includes("/word/comments.xml")) updates.set("[Content_Types].xml", ctXml.replace("</Types>", `<Override PartName="/${commentsPartPath}" ContentType="${COMMENTS_CONTENT_TYPE}"/></Types>`));
 			}
 			const relsPath = "word/_rels/document.xml.rels";
 			const relsFile = zip.file(relsPath);
 			if (relsFile) {
-				const relsXml = await relsFile.async("text");
+				const relsXml = await relsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 				if (!relsXml.toLowerCase().includes("comments.xml")) {
 					const maxId = findMaxRId(relsXml);
 					updates.set(relsPath, relsXml.replace("</Relationships>", `<Relationship Id="rId${maxId + 1}" Type="${RELATIONSHIP_TYPES.comments}" Target="${commentsPartPath.slice(5)}"/></Relationships>`));
 				}
 			}
 		}
-		if (!await patchCommentsExtended(zip, commentPlan, updates)) return null;
+		if (!commentsUnchanged && !await patchCommentsExtended(zip, commentPlan, updates)) return null;
 		if (!await patchNumberingPart(zip, doc, updates)) return null;
 		const styles = await planAddedStyles(doc, zip);
 		switch (styles.type) {
@@ -306,7 +308,7 @@ async function attemptSelectiveSave(doc, originalBuffer, options) {
 		await queueSettingsUpdates(zip, updates);
 		const corePropsFile = zip.file("docProps/core.xml");
 		if (corePropsFile) {
-			const corePropsXml = await corePropsFile.async("text");
+			const corePropsXml = await corePropsFile.async("uint8array").then((bytes) => decodeText(bytes, { ignoreBOM: true }));
 			updates.set("docProps/core.xml", updateCoreProperties(corePropsXml, { updateModifiedDate: true }));
 		}
 		if ([...updates.keys()].some((path) => {

package/dist/docx/selectiveXmlPatch.js

@@ -1,6 +1,7 @@
 import { patchBreaksCommentRangeBalance } from "./commentRangeIntegrity.js";
 import { resolveParagraphIdentities } from "./paraIdAttribute.js";
 import { readRootNamespaceBindings } from "./serializer/partNamespaces.js";
+import { scanStreamingXmlElements } from "./streamingXmlParser.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { PARAGRAPH_SCAN_NAMES, hasCanonicalWordprocessingPrefixes, matchCloseTag, matchOpenTag, resolveSelectiveScanPrefixes, splicesAsCanonical } from "./wordprocessingPrefixes.js";
 import { resolveNamespaceUri } from "./xmlNamespaceContext.js";
@@ -650,36 +651,32 @@ function extractElementByIdAttr(xml, openLiteral, closeTag, idAttr, id) {
 const qualifiedName = (prefix, localName) => prefix.length === 0 ? localName : `${prefix}:${localName}`;
 const collectNoteElementSyntax = (xml, elementName) => {
 	const byId = /* @__PURE__ */ new Map();
-	const root = parseXmlDocument(xml);
-	for (const element of getChildElements(root)) {
-		if (getLocalName(element.name) !== elementName || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "")) continue;
+	let root;
+	scanStreamingXmlElements(xml, ({ element, parent, nameEnd }) => {
+		if (parent === void 0) {
+			root = element;
+			return;
+		}
+		if (parent !== root || getLocalName(element.name) !== elementName || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "")) return;
 		const idAttribute = findAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "id");
-		if (!element.name || !idAttribute) continue;
+		if (!element.name || !idAttribute) return;
+		const spelling = idAttribute.value.trim();
+		if (!/^[+-]?\d+$/u.test(spelling) || !Number.isSafeInteger(Number(spelling))) return;
+		const id = String(Number(spelling));
+		const offsets = scanElementRange(xml, nameEnd - element.name.length - 1, `<${element.name}`, `</${element.name}>`);
+		if (!offsets) return;
 		const syntax = {
-			elementName: element.name,
-			idAttributeName: idAttribute.name,
+			offsets,
 			elementPrefix: getNamespacePrefix(element.name) ?? "",
 			attributePrefix: getNamespacePrefix(idAttribute.name) ?? ""
 		};
-		const entries = byId.get(idAttribute.value);
+		const entries = byId.get(id);
 		if (entries) entries.push(syntax);
-		else byId.set(idAttribute.value, [syntax]);
-	}
+		else byId.set(id, [syntax]);
+	});
 	return byId;
 };
-const syntaxLiteral = (syntax) => ({
-	openLiteral: `<${syntax.elementName}`,
-	closeTag: `</${syntax.elementName}>`,
-	idAttr: syntax.idAttributeName
-});
-const extractNoteElement = (xml, syntax, id) => {
-	const { openLiteral, closeTag, idAttr } = syntaxLiteral(syntax);
-	return extractElementByIdAttr(xml, openLiteral, closeTag, idAttr, id);
-};
-const findNoteElement = (xml, syntax, id) => {
-	const { openLiteral, closeTag, idAttr } = syntaxLiteral(syntax);
-	return findElementByIdAttr(xml, openLiteral, closeTag, idAttr, id);
-};
+const extractNoteElement = (xml, syntax) => xml.slice(syntax.offsets.start, syntax.offsets.end);
 const rewriteWordprocessingPrefixes = (xml, { source, target, sourceXmlnsDeclarations }) => {
 	let rewritten = "";
 	let quote = null;
@@ -824,7 +821,7 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 		const replacementSyntaxEntries = replacementElements.get(id);
 		if (originalSyntaxEntries === void 0) {
 			const replacementSyntax = currentSyntaxEntries.length === 1 && replacementSyntaxEntries?.length === 1 ? replacementSyntaxEntries[0] : void 0;
-			const replacementNote = replacementSyntax ? extractNoteElement(replacementXml, replacementSyntax, id) : null;
+			const replacementNote = replacementSyntax ? extractNoteElement(replacementXml, replacementSyntax) : null;
 			if (!replacementSyntax || !replacementNote) return {
 				type: "refused",
 				reason: "unroutable-paragraph"
@@ -836,24 +833,20 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 			});
 			continue;
 		}
-		if (currentSyntaxEntries.length !== 1 || originalSyntaxEntries?.length !== 1 || replacementSyntaxEntries?.length !== 1) return {
+		if (currentSyntaxEntries.length !== 1 || !originalSyntaxEntries?.length || replacementSyntaxEntries?.length !== 1) return {
 			type: "refused",
 			reason: "unroutable-paragraph"
 		};
 		const currentSyntax = currentSyntaxEntries[0];
-		const originalSyntax = originalSyntaxEntries[0];
+		const originalSyntax = originalSyntaxEntries.at(0);
 		const replacementSyntax = replacementSyntaxEntries[0];
 		if (!currentSyntax || !originalSyntax || !replacementSyntax) return {
 			type: "refused",
 			reason: "unroutable-paragraph"
 		};
-		const currentNote = extractNoteElement(serializedXml, currentSyntax, id);
-		const originalOffsets = findNoteElement(originalXml, originalSyntax, id);
-		const replacementNote = extractNoteElement(replacementXml, replacementSyntax, id);
-		if (!currentNote || !originalOffsets || !replacementNote) return {
-			type: "refused",
-			reason: "unroutable-paragraph"
-		};
+		const currentNote = extractNoteElement(serializedXml, currentSyntax);
+		const originalOffsets = originalSyntax.offsets;
+		const replacementNote = extractNoteElement(replacementXml, replacementSyntax);
 		const originalNote = originalXml.slice(originalOffsets.start, originalOffsets.end);
 		const currentParagraphs = paragraphRanges(currentNote, currentSyntax.elementPrefix);
 		const originalParagraphs = paragraphRanges(originalNote, originalSyntax.elementPrefix);
@@ -861,7 +854,7 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 		const noteChangedParaIds = [...collectParaIds(currentNote).keys()].filter((paraId) => unroutedChangedParaIds.has(paraId));
 		const baselineSyntaxEntries = baselineElements.get(id);
 		const baselineSyntax = baselineSyntaxEntries?.length === 1 ? baselineSyntaxEntries[0] : void 0;
-		const baselineNote = baselineSyntax ? extractNoteElement(baselineXml, baselineSyntax, id) : null;
+		const baselineNote = baselineSyntax ? extractNoteElement(baselineXml, baselineSyntax) : null;
 		const reshaped = baselineSyntax !== void 0 && baselineNote !== null && baselineNote !== currentNote && noteShapeChanged({
 			note: baselineNote,
 			prefix: baselineSyntax.elementPrefix
@@ -910,26 +903,29 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 	for (const [id, baselineSyntaxEntries] of baselineElements) {
 		if (currentElements.has(id) || baselineSyntaxEntries.length !== 1) continue;
 		const originalSyntaxEntries = originalElements.get(id);
-		const originalSyntax = originalSyntaxEntries?.length === 1 ? originalSyntaxEntries[0] : void 0;
-		const originalOffsets = originalSyntax && findNoteElement(originalXml, originalSyntax, id);
-		if (!originalOffsets) return {
+		if (!originalSyntaxEntries?.length) return {
 			type: "refused",
 			reason: "unroutable-paragraph"
 		};
-		const removal = {
-			start: originalOffsets.start,
-			end: originalOffsets.end,
-			newXml: ""
-		};
-		paragraphSplices.push(removal);
-		noteSplices.push(removal);
+		for (const { offsets } of originalSyntaxEntries) {
+			const removal = {
+				...offsets,
+				newXml: ""
+			};
+			paragraphSplices.push(removal);
+			noteSplices.push(removal);
+		}
 	}
 	if (unroutedChangedParaIds.size > 0) return {
 		type: "refused",
 		reason: "unroutable-paragraph"
 	};
 	if (addedNotes.length > 0) {
-		const appended = appendNotesSplice(originalXml, originalElements, addedNotes, { sourceXmlnsDeclarations: replacementXmlnsDeclarations });
+		const appended = appendNotesSplice({
+			originalElements,
+			addedNotes,
+			sourceXmlnsDeclarations: replacementXmlnsDeclarations
+		});
 		if (!appended) return {
 			type: "refused",
 			reason: "unroutable-paragraph"
@@ -951,15 +947,11 @@ function buildPatchedNotePartXml({ originalXml, baselineXml, serializedXml, repl
 		xml: wholeNotes
 	};
 }
-/**
-* Insert new notes after the part's last note, spelled with that note's
-* prefixes. Null when the part holds no note to follow.
-*/
-const appendNotesSplice = (originalXml, originalElements, addedNotes, { sourceXmlnsDeclarations }) => {
+const appendNotesSplice = ({ originalElements, addedNotes, sourceXmlnsDeclarations }) => {
 	let last = null;
-	for (const [id, entries] of originalElements) for (const syntax of entries) {
-		const offsets = findNoteElement(originalXml, syntax, id);
-		if (offsets && (!last || offsets.end > last.end)) last = {
+	for (const entries of originalElements.values()) for (const syntax of entries) {
+		const offsets = syntax.offsets;
+		if (!last || offsets.end > last.end) last = {
 			end: offsets.end,
 			syntax
 		};

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

@@ -1,6 +1,8 @@
 import { document_d_exports } from "../../types/document.js";
 import { Comment } from "../../types/content.js";
 //#region src/docx/serializer/commentSerializer.d.ts
+/** An unrelated body edit must retain unmodelled duplicate comment definitions. */
+declare const canReplayCommentsPart: (document: document_d_exports.Document, sourceXml: string) => boolean;
 /** An owned empty part survives deletion of its final thread. */
 declare const hasOwnedCommentsPart: (document: document_d_exports.Document) => boolean;
 /**
@@ -55,4 +57,4 @@ declare function serializeComments({ order, byId }: CommentPartPlan, sourceBindi
  */
 declare function serializeCommentsExtended(plan: CommentPartPlan): string | null;
 //#endregion
-export { CommentPartPlan, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };
+export { CommentPartPlan, canReplayCommentsPart, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };

package/dist/docx/serializer/commentSerializer.js

@@ -1,10 +1,13 @@
+import { canonicalJson } from "../../utils/canonicalJson.js";
 import { deterministicHexId } from "../../utils/hexId.js";
 import { commentThreadParaId } from "../commentThreadKey.js";
 import { serializeWithPreservedChildren } from "../containerChildren.js";
+import { getDocumentSourceBaseline } from "../headerFooterVerbatim.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializePartElement } from "./partNamespaces.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
-import { escapeXmlAttribute } from "@stll/docx-core";
+import { Result } from "better-result";
+import { assertValidOoxmlNumericIds, escapeXmlAttribute } from "@stll/docx-core";
 import { COMMENT_PART_RELATIONSHIPS } from "@stll/docx-core/model";
 //#region src/docx/serializer/commentSerializer.ts
 /**
@@ -12,6 +15,12 @@ import { COMMENT_PART_RELATIONSHIPS } from "@stll/docx-core/model";
 *
 * Serializes Comment[] to OOXML comments.xml format.
 */
+/** An unrelated body edit must retain unmodelled duplicate comment definitions. */
+const canReplayCommentsPart = (document, sourceXml) => {
+	if (Result.try(() => assertValidOoxmlNumericIds(sourceXml, "word/comments.xml")).isErr()) return false;
+	const baseline = getDocumentSourceBaseline(document);
+	return baseline.type === "captured" && canonicalJson(document.package.document.comments ?? []) === canonicalJson(baseline.body.comments ?? []);
+};
 /** An owned empty part survives deletion of its final thread. */
 const hasOwnedCommentsPart = (document) => [...document.package.relationships?.values() ?? []].some(({ type }) => type === COMMENT_PART_RELATIONSHIPS.comments.type);
 const DEFAULT_ANNOTATION_REFERENCE_PROPERTIES = "<w:rPr><w:rStyle w:val=\"CommentReference\"/></w:rPr>";
@@ -200,4 +209,4 @@ function serializeCommentsExtended(plan) {
 	});
 }
 //#endregion
-export { hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };
+export { canReplayCommentsPart, hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended };

package/dist/docx/serializer/runSerializer.js

@@ -9,16 +9,17 @@ import { canReplayEditableImageRawXml } from "../imageRawXml.js";
 import { serializeNonVisualDrawingNames } from "../nonVisualDrawingProps.js";
 import { serializeBoundaryJoins } from "../reviewResolutionProvenance.js";
 import { runHoldsPayload } from "../runPayload.js";
+import { serializeEmptyRunProperties, serializePreviousRunProperties } from "../runPropertyPresence.js";
 import { replayableShapeAlternateContent } from "../shapeAlternateContent.js";
 import { requiredWrapPolygon, serializeWrapPolygon } from "../wrapPolygon.js";
 import { serializeParagraph } from "./paragraphSerializer.js";
 import { serializeTable } from "./tableSerializer.js";
 import { serializeTextFormatting } from "./textFormattingSerializer.js";
-import { getSingularRunPropertyChange, serializeTrackedChangeAttributes } from "./trackedChangeAttributes.js";
+import { serializeTrackedChangeAttributes } from "./trackedChangeAttributes.js";
 import { intAttr } from "./xmlUtils.js";
 import { panic } from "better-result";
 import { escapeXmlAttribute, escapeXmlText, isValidOoxmlNumericId, requiresXmlSpacePreserve } from "@stll/docx-core";
-import { SCHEME_COLOR_VALUE_BY_THEME_COLOR, knownThemeColor, presetLineDashToken } from "@stll/docx-core/model";
+import { SCHEME_COLOR_VALUE_BY_THEME_COLOR, getSingularRunPropertyChange, knownThemeColor, presetLineDashToken } from "@stll/docx-core/model";
 //#region src/docx/serializer/runSerializer.ts
 /**
 * Run Serializer - Serialize runs to OOXML XML
@@ -52,7 +53,7 @@ function getUniqueId(id) {
 }
 function serializeRunPropertyChange(change) {
 	const previousRPrXml = serializeTextFormatting(change.previousFormatting) || "<w:rPr/>";
-	return `<w:rPrChange ${serializeTrackedChangeAttributes(change.info)}${serializeBoundaryJoins(change.boundaryJoins)}>${previousRPrXml}</w:rPrChange>`;
+	return `<w:rPrChange ${serializeTrackedChangeAttributes(change.info)}${serializeBoundaryJoins(change.boundaryJoins)}${serializePreviousRunProperties(change.previousFormatting)}>${previousRPrXml}</w:rPrChange>`;
 }
 function serializeRunProperties(formatting, propertyChanges) {
 	const propertyChange = getSingularRunPropertyChange(propertyChanges);
@@ -567,7 +568,7 @@ function serializeRun(run) {
 		const contentXml = serializeRunContent(content);
 		if (contentXml) parts.push(contentXml);
 	}
-	const attrs = serializePreservedAttributes([], run.preservedAttributes);
+	const attrs = serializePreservedAttributes(serializeEmptyRunProperties(run), run.preservedAttributes);
 	return `<w:r${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>${parts.join("")}</w:r>`;
 }
 /**

package/dist/docx/serializer/tableSerializer.js

@@ -5,6 +5,7 @@ import { withPreservedChildren } from "../containerChildren.js";
 import { TRANSITIONAL_NAME_BY_STRICT_NAME } from "../strictNames.gen.js";
 import { TABLE_LOOK_FLAGS } from "../tableLook.js";
 import { parseTableCellProperties, parseTableGrid, parseTableProperties, parseTablePropertyExceptions, parseTableRowProperties } from "../tableParser.js";
+import { serializeEmptyRowProperties } from "../tableRowPropertyPresence.js";
 import { OOXML_NAMESPACE_SCOPE, parseXml } from "../xmlParser.js";
 import { serializeBlockCustomXml } from "./blockCustomXmlSerializer.js";
 import { serializeBlockSdt } from "./blockSdtSerializer.js";
@@ -555,7 +556,7 @@ function serializeTableRow(row, serializeParagraph) {
 		carriers: carriersFor(cell),
 		xml: serializeTableCell(cell, serializeParagraph)
 	})), positionedChildren(row.preserved, row.bookmarks), preservedChild), 0));
-	const attrs = serializePreservedAttributes([], row.preservedAttributes);
+	const attrs = serializePreservedAttributes(serializeEmptyRowProperties(row), row.preservedAttributes);
 	return `<w:tr${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>${parts.join("")}</w:tr>`;
 }
 /**

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

@@ -1,11 +1,9 @@
 import { document_d_exports } from "../../types/document.js";
 //#region src/docx/serializer/trackedChangeAttributes.d.ts
 type SerializableTrackedChangeInfo = document_d_exports.TrackedChangeInfo | document_d_exports.PropertyChangeInfo;
-/** Enforces the singular `w:rPrChange` child in a run-property container. */
-declare const getSingularRunPropertyChange: (propertyChanges: readonly document_d_exports.RunPropertyChange[] | undefined) => document_d_exports.RunPropertyChange | undefined;
 /** Normalized, unescaped attributes in schema order for an XML element or string serializer. */
 declare const trackedChangeAttributeEntries: (info: SerializableTrackedChangeInfo) => readonly (readonly [string, string])[];
 declare const trackedChangeAttributeRecord: (info: SerializableTrackedChangeInfo) => Record<string, string>;
 declare const serializeTrackedChangeAttributes: (info: SerializableTrackedChangeInfo) => string;
 //#endregion
-export { getSingularRunPropertyChange, serializeTrackedChangeAttributes, trackedChangeAttributeEntries, trackedChangeAttributeRecord };
+export { serializeTrackedChangeAttributes, trackedChangeAttributeEntries, trackedChangeAttributeRecord };

package/dist/docx/serializer/trackedChangeAttributes.js

@@ -1,17 +1,7 @@
 import { DATE_UTC_ATTRIBUTE } from "../trackedChangeInfo.js";
-import { panic } from "better-result";
 import { assertValidOoxmlNumericId, escapeXmlAttribute } from "@stll/docx-core";
 import { normalizeRevisionId } from "@stll/docx-core/model";
 //#region src/docx/serializer/trackedChangeAttributes.ts
-/** Enforces the singular `w:rPrChange` child in a run-property container. */
-const getSingularRunPropertyChange = (propertyChanges) => {
-	const propertyChangeCount = propertyChanges?.length ?? 0;
-	if (propertyChangeCount > 1) panic("A run-property container cannot serialize more than one w:rPrChange", {
-		elementName: "w:rPrChange",
-		propertyChangeCount
-	});
-	return propertyChanges?.at(0);
-};
 /** Normalized, unescaped attributes in schema order for an XML element or string serializer. */
 const trackedChangeAttributeEntries = (info) => {
 	assertValidOoxmlNumericId({
@@ -34,4 +24,4 @@ const trackedChangeAttributeEntries = (info) => {
 const trackedChangeAttributeRecord = (info) => Object.fromEntries(trackedChangeAttributeEntries(info));
 const serializeTrackedChangeAttributes = (info) => trackedChangeAttributeEntries(info).map(([name, value]) => `${name}="${escapeXmlAttribute(value)}"`).join(" ");
 //#endregion
-export { getSingularRunPropertyChange, serializeTrackedChangeAttributes, trackedChangeAttributeEntries, trackedChangeAttributeRecord };
+export { serializeTrackedChangeAttributes, trackedChangeAttributeEntries, trackedChangeAttributeRecord };

package/dist/docx/server/applyDocxXmlPatchProposal.js

@@ -1,3 +1,4 @@
+import { encodeUtf8 } from "../../utils/textEncoding.js";
 import { loadDocxArchive } from "./boundedArchive.js";
 import { FOLIO_DOCX_XML_PATCH_PROPOSAL_PROFILE, InvalidFolioDocxXmlPatchProposalError, evaluateDocxXmlPatchProposal, parseFolioDocxXmlPatchProposal } from "./evaluateDocxXmlPatchProposal.js";
 import { FOLIO_DOCX_CONFORMANCE_PROFILE, validateDocxConformance } from "./validateDocxConformance.js";
@@ -96,9 +97,8 @@ const applyReplacements = async ({ bytes, proposal }) => {
 		writeZipPart({
 			zip,
 			path: replacement.path,
-			data: new TextEncoder().encode(replacement.replacementXml),
+			data: encodeUtf8(replacement.replacementXml),
 			options: {
-				binary: true,
 				date: current.date,
 				comment: current.comment,
 				unixPermissions: current.unixPermissions,

package/dist/docx/server/boundedArchive.js

@@ -1,3 +1,4 @@
+import { decodeText } from "../../utils/textEncoding.js";
 import { compressionRatioLimitFor, countCentralDirectoryRecords, createInflationBudget, exceedsCompressionRatio, getZipEntrySizes, inflateEntryWithinLimits } from "../archiveInflation.js";
 import { FOLIO_XML_RESOURCE_LIMITS, assertXmlResourceLimits, createXmlPackageBudget } from "../xmlResourceLimits.js";
 import { TaggedError } from "better-result";
@@ -170,7 +171,7 @@ const loadDocxArchive = async (bytes, options = {}) => {
 		async readEntryString(path) {
 			const content = await readEntry(path);
 			if (content === null) return null;
-			const xml = new TextDecoder("utf-8", { ignoreBOM: true }).decode(content);
+			const xml = decodeText(content, { ignoreBOM: true });
 			const lower = path.toLowerCase();
 			if (!lower.endsWith(".xml") && !lower.endsWith(".rels")) return xml;
 			const charged = countedParts.has(path);