@stll/folio-core 0.43.0 → 0.45.0

package/dist/docx/revisionIdNormalization.js

@@ -31,16 +31,79 @@ const REVISION_ELEMENT_NAMES = /* @__PURE__ */ new Set([
 	"trPrChange"
 ]);
 const REVISION_ELEMENT_CANDIDATE = new RegExp(`<(?:[^\\s<>/:]+:)?(?:${[...REVISION_ELEMENT_NAMES].join("|")})(?:[\\s/>])`, "u");
-const revisionAttribute = (element) => {
-	if (!element.name || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "") || !REVISION_ELEMENT_NAMES.has(getLocalName(element.name))) return null;
+/**
+* The rest of the annotation id space.
+*
+* A comment, a bookmark, a protected range and a tracked change all draw their
+* `w:id` from one space: Word allocates from a single counter, which is why a
+* package carrying several kinds almost never repeats a value across them. So
+* an id this pass mints must avoid these as well, or a renumbered `w:ins`
+* lands on a live comment.
+*
+* They are only ever reserved, never claimed. A comment id legitimately
+* appears four times (`w:comment`, both range markers and the reference) and a
+* bookmark id twice, so feeding them to the uniqueness machinery would reject
+* a package Word wrote. Their pairing is also why they are not revision
+* elements: renumbering one end of a range would unpair it.
+*/
+const ANNOTATION_ELEMENT_NAMES = /* @__PURE__ */ new Set([
+	"bookmarkEnd",
+	"bookmarkStart",
+	"comment",
+	"commentRangeEnd",
+	"commentRangeStart",
+	"commentReference",
+	"customXmlDelRangeEnd",
+	"customXmlDelRangeStart",
+	"customXmlInsRangeEnd",
+	"customXmlInsRangeStart",
+	"customXmlMoveFromRangeEnd",
+	"customXmlMoveFromRangeStart",
+	"customXmlMoveToRangeEnd",
+	"customXmlMoveToRangeStart",
+	"moveFromRangeEnd",
+	"moveFromRangeStart",
+	"moveToRangeEnd",
+	"moveToRangeStart",
+	"permEnd",
+	"permStart"
+]);
+const ANNOTATION_ELEMENT_CANDIDATE = new RegExp(`<(?:[^\\s<>/:]+:)?(?:${[...ANNOTATION_ELEMENT_NAMES].join("|")})(?:[\\s/>])`, "u");
+const ID_KINDS = {
+	revision: "revision",
+	annotation: "annotation"
+};
+/** One lookup for both halves of the space, so an element is classified once. */
+const ID_KIND_BY_ELEMENT_NAME = new Map([...[...REVISION_ELEMENT_NAMES].map((name) => [name, ID_KINDS.revision]), ...[...ANNOTATION_ELEMENT_NAMES].map((name) => [name, ID_KINDS.annotation])]);
+/**
+* An element's `w:id` and which half of the annotation space it belongs to.
+*
+* One classifier rather than two, because it runs on every element of every
+* scanned part: resolving the namespace and the local name twice to ask two
+* questions measured 18% on a 17.6 MiB package.
+*
+* `w:permStart` types its id as a string, so a protected range named
+* `everyone` yields nothing. That is correct: a value the allocator can never
+* mint is not one it has to avoid.
+*/
+const identifiedElement = (element) => {
+	if (!element.name || !WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "")) return null;
+	const localName = getLocalName(element.name);
+	const kind = ID_KIND_BY_ELEMENT_NAME.get(localName);
+	if (kind === void 0) return null;
 	const attribute = findAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "id");
 	if (!attribute) return null;
 	const id = Number(attribute.value);
 	return Number.isSafeInteger(id) && id >= 0 ? {
+		kind,
 		name: attribute.name,
 		id
 	} : null;
 };
+const revisionAttribute = (element) => {
+	const identified = identifiedElement(element);
+	return identified?.kind === ID_KINDS.revision ? identified : null;
+};
 /**
 * Keep physical tracked-change element ids unique across a package.
 *
@@ -54,18 +117,22 @@ const normalizeRevisionIdsInXmlParts = (parts) => {
 	const occurrencesByPath = /* @__PURE__ */ new Map();
 	const reserved = /* @__PURE__ */ new Set();
 	for (const [path, xml] of candidates) {
-		assertXmlResourceLimits(xml);
+		assertXmlResourceLimits({
+			xml,
+			partPath: path
+		});
 		const ids = [];
 		if (rewriteStreamingXmlDecimalAttributes(xml, (element) => {
-			const attribute = revisionAttribute(element);
-			if (attribute) {
-				ids.push(attribute.id);
-				reserved.add(attribute.id);
-			}
+			const identified = identifiedElement(element);
+			if (identified === null) return null;
+			if (identified.kind === ID_KINDS.revision) ids.push(identified.id);
+			reserved.add(identified.id);
 			return null;
 		}).status === "unsupported") throw new XmlResourceLimitError({
 			message: `Revision-id normalization could not safely scan ${path}`,
-			limit: "syntax"
+			limit: "syntax",
+			observed: 0,
+			allowed: 0
 		});
 		occurrencesByPath.set(path, ids);
 	}
@@ -73,6 +140,23 @@ const normalizeRevisionIdsInXmlParts = (parts) => {
 	const firstSeen = /* @__PURE__ */ new Set();
 	for (const [path, ids] of occurrencesByPath) for (const id of ids) if (firstSeen.has(id)) repeatedPaths.add(path);
 	else firstSeen.add(id);
+	if (repeatedPaths.size > 0) for (const [path, xml] of parts) {
+		if (occurrencesByPath.has(path) || !ANNOTATION_ELEMENT_CANDIDATE.test(xml)) continue;
+		assertXmlResourceLimits({
+			xml,
+			partPath: path
+		});
+		if (rewriteStreamingXmlDecimalAttributes(xml, (element) => {
+			const identified = identifiedElement(element);
+			if (identified !== null) reserved.add(identified.id);
+			return null;
+		}).status === "unsupported") throw new XmlResourceLimitError({
+			message: `Revision-id normalization could not safely scan ${path}`,
+			limit: "syntax",
+			observed: 0,
+			allowed: 0
+		});
+	}
 	let nextId = 0;
 	const allocate = () => {
 		while (reserved.has(nextId)) nextId += 1;
@@ -111,7 +195,9 @@ const normalizeRevisionIdsInXmlParts = (parts) => {
 		});
 		if (rewritten.status === "unsupported") throw new XmlResourceLimitError({
 			message: `Revision-id normalization could not safely rewrite ${path}`,
-			limit: "syntax"
+			limit: "syntax",
+			observed: 0,
+			allowed: 0
 		});
 		normalized.set(path, rewritten.value);
 	}

package/dist/docx/rezip.js

@@ -10,6 +10,7 @@ import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
 import { parseHeaderFooterType } from "./headerFooterRefParser.js";
 import { assertValidFolioDocumentModel } from "./modelValidation.js";
 import { isNewDataUrlDrawing } from "./newImage.js";
+import { missingNoteReferenceStyles, noteReferenceNeeds } from "./noteReferenceStyles.js";
 import { parseNumbering } from "./numberingParser.js";
 import { isNumberingReference } from "./numberingReference.js";
 import { isUnsafePackagePath, reconcilePackageReferences, removeUnsafeEntries } from "./packageParts.js";
@@ -18,7 +19,7 @@ import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./r
 import { removeResolvedHeaderFooterParts } from "./removeHeaderFooterParts.js";
 import { normalizeRevisionIdsInXmlParts } from "./revisionIdNormalization.js";
 import { buildPatchedNotePartXml, collectChangedNoteParaIds, collectParaIds, patchNumberingDefinitions } from "./selectiveXmlPatch.js";
-import { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
+import { planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeFontTableXml } from "./serializer/fontTableSerializer.js";
 import { serializeHeaderFooter } from "./serializer/headerFooterSerializer.js";
@@ -28,11 +29,10 @@ 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";
-import { escapeXml } from "./serializer/xmlUtils.js";
 import { OFFICE_RELATIONSHIP_NAMESPACE_URIS, WORDPROCESSINGML_NAMESPACE_URIS, findChild, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, matchesName, parseXml, parseXmlDocument } from "./xmlParser.js";
 import { assertXmlResourceLimits } from "./xmlResourceLimits.js";
 import { panic } from "better-result";
-import { validateDocxPackage } from "@stll/docx-core";
+import { escapeXmlAttribute, escapeXmlText, validateDocxPackage } from "@stll/docx-core";
 import JSZip from "jszip";
 //#region src/docx/rezip.ts
 /**
@@ -84,7 +84,7 @@ function findMaxRId(relsXml) {
 }
 const isWordprocessingElement = (element, localName) => getLocalName(element.name) === localName && WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "");
 const countDocumentSections = (xml) => {
-	assertXmlResourceLimits(xml);
+	assertXmlResourceLimits({ xml });
 	let count = 0;
 	const pending = [{
 		element: parseXml(xml),
@@ -105,7 +105,7 @@ const countDocumentSections = (xml) => {
 };
 const extractHeaderFooterReferences = (xml) => {
 	const references = [];
-	assertXmlResourceLimits(xml);
+	assertXmlResourceLimits({ xml });
 	const pending = [parseXml(xml)];
 	while (pending.length > 0) {
 		const node = pending.pop();
@@ -165,15 +165,15 @@ async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	if (comments.length === 0) {
 		if (sourceCommentsXml === void 0 || !hasCommentEntries(sourceCommentsXml)) return;
 	}
-	ensureThreadedCommentParaIds(comments);
-	const commentsXml = serializeComments(comments, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
+	const plan = planCommentParts(comments);
+	const commentsXml = serializeComments(plan, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
 	zip.file(sourceCommentsFile?.name ?? "word/comments.xml", commentsXml, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
 	});
 	await ensureCommentsContentType(zip, compressionLevel);
 	await ensureCommentsRelationship(zip, compressionLevel);
-	await syncCommentsExtendedPart(comments, zip, compressionLevel);
+	await syncCommentsExtendedPart(plan, zip, compressionLevel);
 }
 const hasCommentEntries = (xml) => {
 	const root = parseXml(xml);
@@ -188,8 +188,8 @@ const hasCommentEntries = (xml) => {
 * removed part triggers Word's repair prompt). The reply-thread markers in
 * `document.xml` are synthesized separately (see {@link applyReplyThreadMarkers}).
 */
-async function syncCommentsExtendedPart(comments, zip, compressionLevel) {
-	const xml = serializeCommentsExtended(comments);
+async function syncCommentsExtendedPart(plan, zip, compressionLevel) {
+	const xml = serializeCommentsExtended(plan);
 	const existing = findZipEntryCaseInsensitive(zip, COMMENTS_EXTENDED_PART_LOWER);
 	if (!xml) {
 		if (!existing) return;
@@ -395,7 +395,7 @@ async function processNewImages(parts, zip, compressionLevel) {
 				compression: "DEFLATE",
 				compressionOptions: { level: compressionLevel }
 			});
-			relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXml(relativeTargetForPart(partPath, mediaPath))}"/>`);
+			relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXmlAttribute(relativeTargetForPart(partPath, mediaPath))}"/>`);
 			extensionsAdded.add(extension);
 			if (drawing.rawXml) drawing.rawXml = rebindDrawingImageRelationship({
 				xml: drawing.rawXml,
@@ -475,7 +475,7 @@ async function processNewHyperlinks(parts, zip, compressionLevel) {
 			if (!hyperlink.href) continue;
 			maxId++;
 			const newRId = `rId${maxId}`;
-			relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.hyperlink}" Target="${escapeXml(hyperlink.href)}" TargetMode="External"/>`);
+			relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.hyperlink}" Target="${escapeXmlAttribute(hyperlink.href)}" TargetMode="External"/>`);
 			hyperlink.rId = newRId;
 		}
 		zip.file(relsPath, relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`), {
@@ -951,7 +951,7 @@ async function addRelationship(originalBuffer, relationship) {
 	const relsXml = await relsFile.async("text");
 	const newRId = `rId${findMaxRId(relsXml) + 1}`;
 	const targetModeAttr = relationship.targetMode === "External" ? " TargetMode=\"External\"" : "";
-	const newRelElement = `<Relationship Id="${newRId}" Type="${relationship.type}" Target="${escapeXml(relationship.target)}"${targetModeAttr}/>`;
+	const newRelElement = `<Relationship Id="${newRId}" Type="${relationship.type}" Target="${escapeXmlAttribute(relationship.target)}"${targetModeAttr}/>`;
 	const updatedRelsXml = relsXml.replace("</Relationships>", `${newRelElement}</Relationships>`);
 	zip.file(relsPath, updatedRelsXml);
 	return {
@@ -1100,7 +1100,7 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 				type: relType,
 				target: filename
 			});
-			relEntries.push(`<Relationship Id="${escapeXml(effectiveRId)}" Type="${relType}" Target="${filename}"/>`);
+			relEntries.push(`<Relationship Id="${escapeXmlAttribute(effectiveRId)}" Type="${relType}" Target="${filename}"/>`);
 			overrides.push(`<Override PartName="/word/${filename}" ContentType="${contentType}"/>`);
 		}
 	};
@@ -1217,7 +1217,7 @@ async function rebindWatermarkRelIds(doc, zip, compressionLevel) {
 		}
 		if (!resolvedRId) {
 			resolvedRId = `rId${findMaxRId(relsXml) + 1}`;
-			const relXml = canonical.mode === "external" ? `<Relationship Id="${resolvedRId}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXml(canonical.url)}" TargetMode="External"/>` : `<Relationship Id="${resolvedRId}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXml(relativeTargetForPart(partPath, canonical.absolute))}"/>`;
+			const relXml = canonical.mode === "external" ? `<Relationship Id="${resolvedRId}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXmlAttribute(canonical.url)}" TargetMode="External"/>` : `<Relationship Id="${resolvedRId}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXmlAttribute(relativeTargetForPart(partPath, canonical.absolute))}"/>`;
 			relsXmlByPath.set(relsPath, relsXml.replace("</Relationships>", `${relXml}</Relationships>`));
 			changedPaths.add(relsPath);
 		}
@@ -1389,6 +1389,42 @@ async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLe
 }
 const STYLES_PART_PATH = "word/styles.xml";
 const STYLES_CLOSE_ROOT = "</w:styles>";
+/**
+* The style table a package folio creates starts from: `docDefaults` and
+* `Normal`, and nothing else. A document that carries its own style table
+* replaces this part wholesale.
+*/
+const SEED_STYLES_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:docDefaults>
+    <w:rPrDefault>
+      <w:rPr>
+        <w:rFonts w:ascii="Calibri" w:hAnsi="Calibri"/>
+        <w:sz w:val="22"/>
+      </w:rPr>
+    </w:rPrDefault>
+    <w:pPrDefault>
+      <w:pPr>
+        <w:spacing w:after="200" w:line="276" w:lineRule="auto"/>
+      </w:pPr>
+    </w:pPrDefault>
+  </w:docDefaults>
+  <w:style w:type="paragraph" w:default="1" w:styleId="Normal">
+    <w:name w:val="Normal"/>
+  </w:style>
+</w:styles>`;
+/**
+* The seed part plus the reference styles this package's comments and notes
+* need. A document with no style table of its own never reaches
+* {@link styleDefinitionsToSerialize}, so without this its reference marks
+* would carry a `w:rStyle` naming nothing — the defect
+* `noteReferenceStyles.ts` exists to remove, on the one path that skips it.
+*/
+const seedStylesXmlWith = (missing) => {
+	if (missing.length === 0) return SEED_STYLES_XML;
+	const rootClose = SEED_STYLES_XML.lastIndexOf(STYLES_CLOSE_ROOT);
+	return SEED_STYLES_XML.slice(0, rootClose) + missing.map(serializeStyle).join("") + SEED_STYLES_XML.slice(rootClose);
+};
 const STYLE_ID_PATTERN = /<w:style\b[^>]*?\bw:styleId="(?<id>[^"]+)"/gu;
 /**
 * Append styles the model defines but the original `word/styles.xml` lacks.
@@ -1397,6 +1433,27 @@ const STYLE_ID_PATTERN = /<w:style\b[^>]*?\bw:styleId="(?<id>[^"]+)"/gu;
 * per-language clones a bilingual transform adds, are emitted before the root
 * close so paragraphs referencing them resolve on reopen.
 */
+/**
+* The styles to write into a package folio is authoring: the model's, plus any
+* reference character style the serializers are about to emit for this
+* package's comments and notes but the style table does not define. See
+* `noteReferenceStyles.ts` — the reference mark would otherwise carry a
+* `w:rStyle` pointing at nothing.
+*
+* Only for a package folio writes from scratch. Repacking a document someone
+* else authored preserves `word/styles.xml` byte for byte, and adding a
+* definition there would rewrite a part the user never edited: their document,
+* their style table, missing reference style included.
+*/
+const styleDefinitionsToSerialize = (doc) => {
+	const styles = doc.package.styles;
+	if (!styles) return;
+	const missing = missingNoteReferenceStyles(styles, noteReferenceNeeds(doc.package));
+	return missing.length === 0 ? styles : {
+		...styles,
+		styles: [...styles.styles, ...missing]
+	};
+};
 async function serializeAddedStylesIntoZip(doc, originalZip, newZip, compressionLevel) {
 	const styles = doc.package.styles;
 	if (!styles || styles.styles.length === 0) return;
@@ -1473,7 +1530,7 @@ function updateCoreProperties(corePropsXml, { updateModifiedDate, modifiedBy })
 		if (result.includes("<dcterms:modified")) result = result.replace(/<dcterms:modified[^<>]*>[^<]*<\/dcterms:modified>/u, `<dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>`);
 	}
 	if (modifiedBy) {
-		if (result.includes("<cp:lastModifiedBy")) result = result.replace(/<cp:lastModifiedBy>[^<]*<\/cp:lastModifiedBy>/u, `<cp:lastModifiedBy>${escapeXml(modifiedBy)}</cp:lastModifiedBy>`);
+		if (result.includes("<cp:lastModifiedBy")) result = result.replace(/<cp:lastModifiedBy>[^<]*<\/cp:lastModifiedBy>/u, `<cp:lastModifiedBy>${escapeXmlText(modifiedBy)}</cp:lastModifiedBy>`);
 	}
 	return result;
 }
@@ -1578,33 +1635,15 @@ const createEmptyDocxZip = ({ creator, application }) => {
     </w:sectPr>
   </w:body>
 </w:document>`);
-	zip.file("word/styles.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
-  <w:docDefaults>
-    <w:rPrDefault>
-      <w:rPr>
-        <w:rFonts w:ascii="Calibri" w:hAnsi="Calibri"/>
-        <w:sz w:val="22"/>
-      </w:rPr>
-    </w:rPrDefault>
-    <w:pPrDefault>
-      <w:pPr>
-        <w:spacing w:after="200" w:line="276" w:lineRule="auto"/>
-      </w:pPr>
-    </w:pPrDefault>
-  </w:docDefaults>
-  <w:style w:type="paragraph" w:default="1" w:styleId="Normal">
-    <w:name w:val="Normal"/>
-  </w:style>
-</w:styles>`);
+	zip.file(STYLES_PART_PATH, SEED_STYLES_XML);
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const creatorElement = creator === void 0 ? "" : `\n  <dc:creator>${escapeXml(creator)}</dc:creator>`;
+	const creatorElement = creator === void 0 ? "" : `\n  <dc:creator>${escapeXmlText(creator)}</dc:creator>`;
 	zip.file("docProps/core.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">${creatorElement}
   <dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>
   <dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>
 </cp:coreProperties>`);
-	const applicationElements = application === void 0 ? "" : `\n  <Application>${escapeXml(application)}</Application>\n  <AppVersion>${CREATED_APP_VERSION}</AppVersion>`;
+	const applicationElements = application === void 0 ? "" : `\n  <Application>${escapeXmlText(application)}</Application>\n  <AppVersion>${CREATED_APP_VERSION}</AppVersion>`;
 	zip.file("docProps/app.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">${applicationElements}
 </Properties>`);
@@ -1647,10 +1686,11 @@ const createDocumentSeedZip = async (doc, properties) => {
 	const relationships = ["<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/>"];
 	const overrides = [];
 	let nextRelationshipId = 2;
-	if (doc.package.styles) {
+	const styleDefinitions = styleDefinitionsToSerialize(doc);
+	if (styleDefinitions) {
 		assertStyleNumberingReferences(doc);
-		zip.file("word/styles.xml", serializeStylesXml(doc.package.styles));
-	}
+		zip.file(STYLES_PART_PATH, serializeStylesXml(styleDefinitions));
+	} else zip.file(STYLES_PART_PATH, seedStylesXmlWith(missingNoteReferenceStyles(void 0, noteReferenceNeeds(doc.package))));
 	const numbering = doc.package.numbering;
 	if (numbering && (numbering.abstractNums.length > 0 || numbering.nums.length > 0)) {
 		zip.file("word/numbering.xml", serializeNumberingXml(numbering));

package/dist/docx/runConsolidator.js

@@ -114,8 +114,7 @@ function mergeRunContent(content1, content2) {
 	if (lastText?.type === "text" && firstText?.type === "text") {
 		result[result.length - 1] = {
 			type: "text",
-			text: lastText.text + firstText.text,
-			...lastText.preserveSpace || firstText.preserveSpace ? { preserveSpace: true } : {}
+			text: lastText.text + firstText.text
 		};
 		for (let i = 1; i < content2.length; i++) result.push(content2[i]);
 	} else for (const c of content2) result.push(c);

package/dist/docx/runParser.d.ts

@@ -2,6 +2,13 @@ import { document_d_exports } from "../types/document.js";
 import { StyleMap } from "./styleParser.js";
 import { XmlElement } from "./xmlParser.js";
 //#region src/docx/runParser.d.ts
+/**
+ * `w:vertAlign` `baseline` is the reserved value that means "no vertical
+ * offset", not a third offset beside `superscript` and `subscript`. It is
+ * answered here because this module reads the slot, so a consumer deciding
+ * whether a run sits on the baseline cannot drift from how it was parsed.
+ */
+declare const isBaselineVertAlign: (vertAlign: document_d_exports.TextFormatting["vertAlign"]) => boolean;
 /**
  * Parse run formatting properties (w:rPr)
  *
@@ -74,4 +81,4 @@ declare function hasFieldChar(run: document_d_exports.Run): boolean;
  */
 declare function getFieldCharType(run: document_d_exports.Run): "begin" | "separate" | "end" | null;
 //#endregion
-export { getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, parseRun, parseRunProperties };
+export { getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, isBaselineVertAlign, parseRun, parseRunProperties };

package/dist/docx/runParser.js

@@ -1,18 +1,17 @@
-import { isValidHexColor } from "../utils/colorResolver.js";
 import { parseHorizontalScalePercent } from "../utils/horizontalScale.js";
 import { parseDiagramPreview } from "./diagramPreview.js";
 import { isGroupDrawing, parseGroupDrawing } from "./groupDrawingParser.js";
 import { parseImage } from "./imageParser.js";
 import { imageRawXmlFingerprint } from "./imageRawXml.js";
-import { EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSchema, PositionalTabAlignmentSchema, PositionalTabLeaderSchema, PositionalTabRelativeToSchema, ShadingPatternSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSchema, PositionalTabAlignmentSchema, PositionalTabLeaderSchema, PositionalTabRelativeToSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { parseShading } from "./shadingParser.js";
 import { parseShapeFromDrawing, shouldPreserveRawShapeDrawing } from "./shapeParser.js";
 import { isTextBoxDrawing } from "./textBoxParser.js";
-import { requiresXmlSpacePreserve } from "./textWhitespace.js";
 import { resolveThemeFontRef } from "./themeParser.js";
 import { parsePropertyChangeInfo } from "./trackedChangeInfo.js";
 import { captureVerbatimXml } from "./verbatimCapture.js";
 import { parseVmlImageContent, shouldPreserveRawVmlPict } from "./vmlImageParser.js";
-import { cloneWithXmlnsDeclarations, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, selectAlternateContentBranch } from "./xmlParser.js";
+import { cloneWithXmlnsDeclarations, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, selectAlternateContentBranch } from "./xmlParser.js";
 import { DRAWING_RAW_XML_MODES } from "@stll/docx-core/model";
 //#region src/docx/runParser.ts
 /**
@@ -36,31 +35,6 @@ function parseColorValue(rgb, themeColor, themeTint, themeShade) {
 	if (themeShade) color.themeShade = themeShade;
 	return color;
 }
-/**
-* Parse shading properties (w:shd)
-*/
-function parseShadingProperties(shd) {
-	if (!shd) return;
-	const props = {};
-	const color = getAttribute(shd, "w", "color");
-	if (color === "auto") props.color = { auto: true };
-	else if (color && isValidHexColor(color)) props.color = { rgb: color };
-	const fill = getAttribute(shd, "w", "fill");
-	if (fill === "auto") props.fill = { auto: true };
-	else if (fill && isValidHexColor(fill)) props.fill = { rgb: fill };
-	const validatedThemeFill = narrowEnum(getAttribute(shd, "w", "themeFill"), ThemeColorSlotSchema);
-	if (validatedThemeFill) {
-		if (!props.fill) props.fill = {};
-		props.fill.themeColor = validatedThemeFill;
-	}
-	const themeFillTint = getAttribute(shd, "w", "themeFillTint");
-	if (themeFillTint && props.fill) props.fill.themeTint = themeFillTint;
-	const themeFillShade = getAttribute(shd, "w", "themeFillShade");
-	if (themeFillShade && props.fill) props.fill.themeShade = themeFillShade;
-	const pattern = narrowEnum(getAttribute(shd, "w", "val"), ShadingPatternSchema);
-	if (pattern) props.pattern = pattern;
-	return Object.keys(props).length > 0 ? props : void 0;
-}
 function collectFirstRunPropertyChildren(rPr) {
 	const children = {};
 	for (const child of rPr.elements ?? []) {
@@ -167,6 +141,13 @@ function collectFirstRunPropertyChildren(rPr) {
 	return children;
 }
 /**
+* `w:vertAlign` `baseline` is the reserved value that means "no vertical
+* offset", not a third offset beside `superscript` and `subscript`. It is
+* answered here because this module reads the slot, so a consumer deciding
+* whether a run sits on the baseline cannot drift from how it was parsed.
+*/
+const isBaselineVertAlign = (vertAlign) => vertAlign === "baseline";
+/**
 * Parse run formatting properties (w:rPr)
 *
 * Handles ALL rPr properties:
@@ -231,7 +212,7 @@ function parseRunProperties(rPr, theme, _styles) {
 	}
 	const shd = propertyChildren.shd;
 	if (shd) {
-		const shadingResult = parseShadingProperties(shd);
+		const shadingResult = parseShading(shd);
 		if (shadingResult) formatting.shading = shadingResult;
 	}
 	const sz = propertyChildren.sz;
@@ -370,14 +351,10 @@ function parseRunPropertyChanges(rPr, theme, styles, currentFormatting) {
 * Parse text content (w:t)
 */
 function parseTextContent(element) {
-	const text = getTextContent(element);
-	const preserveSpace = getAttribute(element, "xml", "space") === "preserve" || requiresXmlSpacePreserve(text);
-	const content = {
+	return {
 		type: "text",
-		text
+		text: getTextContent(element)
 	};
-	if (preserveSpace) content.preserveSpace = true;
-	return content;
 }
 /**
 * Parse tab element (w:tab)
@@ -442,8 +419,8 @@ function parseEndnoteReference(element) {
 */
 function parseFieldChar(element) {
 	const fldCharType = getAttribute(element, "w", "fldCharType");
-	const fldLock = getAttribute(element, "w", "fldLock") === "true" || getAttribute(element, "w", "fldLock") === "1";
-	const dirty = getAttribute(element, "w", "dirty") === "true" || getAttribute(element, "w", "dirty") === "1";
+	const fldLock = parseOnOffAttribute(element, "w", "fldLock") === true;
+	const dirty = parseOnOffAttribute(element, "w", "dirty") === true;
 	let charType = "begin";
 	if (fldCharType === "separate") charType = "separate";
 	else if (fldCharType === "end") charType = "end";
@@ -473,15 +450,14 @@ function parseInstrText(element) {
 * Wrap raw XML the model cannot project at all.
 *
 * `DrawingContent` always carries an `Image`, so preservation-only content
-* gets a placeholder one: the empty `rId` marks it as backed by no
-* relationship, which keeps `classifyDrawingSafety` and the serializer on the
-* replay path instead of regenerating DrawingML from the placeholder.
+* gets a placeholder one. It names no relationship, which keeps
+* `classifyDrawingSafety` and the serializer on the replay path instead of
+* regenerating DrawingML from the placeholder.
 */
 const preserveOnlyDrawing = (rawXml) => ({
 	type: "drawing",
 	image: {
 		type: "image",
-		rId: "",
 		size: {
 			width: 0,
 			height: 0
@@ -530,13 +506,19 @@ function parseDrawingContent(element, rels, media) {
 	};
 	const image = parseImage(element, rels ?? void 0, media ?? void 0);
 	if (!image) return null;
-	const drawing = {
+	const rawXml = captureVerbatimXml(element);
+	if (image.rId === void 0) return {
+		type: "drawing",
+		image,
+		rawXml,
+		rawXmlMode: DRAWING_RAW_XML_MODES.PRESERVE_ONLY
+	};
+	return {
 		type: "drawing",
-		image
+		image,
+		rawXml,
+		rawImageFingerprint: imageRawXmlFingerprint(image)
 	};
-	drawing.rawXml = captureVerbatimXml(element);
-	drawing.rawImageFingerprint = imageRawXmlFingerprint(image);
-	return drawing;
 }
 /**
 * Parse all content within a run element
@@ -750,4 +732,4 @@ function getFieldCharType(run) {
 	return run.content.find((c) => c.type === "fieldChar")?.charType ?? null;
 }
 //#endregion
-export { getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, parseRun, parseRunProperties };
+export { getFieldCharType, getImages, getRunText, hasContent, hasFieldChar, hasImage, isBaselineVertAlign, parseRun, parseRunProperties };

package/dist/docx/sdtPropertiesPatch.js

@@ -1,21 +1,27 @@
+import { escapeXmlAttribute } from "@stll/docx-core";
 //#region src/docx/sdtPropertiesPatch.ts
-const XML_ATTR_ESCAPES = {
-	"&": "&",
-	"<": "&lt;",
-	">": "&gt;",
-	"\"": "&quot;",
-	"'": "&apos;"
-};
 /**
-* Escape a value for embedding in an XML attribute. Single-pass replace
-* over the five XML metacharacters (incl. apostrophe so the function
-* stays correct for `'`-delimited attributes even though this file always
-* emits double-quoted ones). Output is XML written to a DOCX zip — no
-* HTML / browser interpretation downstream.
+* Surgical patches for the captured `<w:sdtPr>` XML string.
+*
+* Background. The block-SDT serializer (commit 3) replays
+* `properties.rawPropertiesXml` verbatim so unmodeled OOXML markers
+* (`w:dataBinding`, `w15:repeatingSection`, custom XML mappings) survive
+* a round trip. That replay is correct for unchanged controls but goes
+* stale the moment the editor mutates a modeled property: a user
+* toggling a checkbox, picking a date, or choosing a dropdown value
+* updates `properties.checked` / `dateFormat` / etc., but the raw
+* `w14:checked w14:val="0"` already encoded by the source DOCX stays
+* in `rawPropertiesXml` and gets written back on save — Word reopens
+* the document with the user's interactive change discarded.
+*
+* `reconcileRawSdtPr` walks every modeled field that has an OOXML
+* representation inside `<w:sdtPr>` and, if the field is set on the
+* model, rewrites the matching element in the raw string. Unmodeled
+* markers are untouched, so dataBinding / repeatingSection round-trip
+* stays lossless even after the user has mutated the control.
+*
+* Picked up from upstream eigenpal/docx-editor#661.
 */
-function escapeXmlAttr(value) {
-	return value.replace(/[&<>"']/gu, (ch) => XML_ATTR_ESCAPES[ch] ?? ch);
-}
 /**
 * Drop any `*:lastValue="…"` attribute (any namespace prefix, or
 * unprefixed) from an attribute-list string. We avoid a single greedy
@@ -116,8 +122,8 @@ function reconcileRawSdtPr(raw, props, options = {}) {
 		if (fullDate !== void 0 || dateFormat !== void 0) {
 			const wDate = /<(?<prefix>\w+):date\b(?<attrs>[^>]*)>(?<inner>[\s\S]*?)<\/\w+:date>/iu;
 			const wDateSelf = /<(?<prefix>\w+):date\b(?<attrs>[^/>]*)\/>/iu;
-			const fullDateAttr = fullDate !== void 0 ? ` w:fullDate="${escapeXmlAttr(fullDate)}"` : "";
-			const formatChild = dateFormat !== void 0 ? `<w:dateFormat w:val="${escapeXmlAttr(dateFormat)}"/>` : "";
+			const fullDateAttr = fullDate !== void 0 ? ` w:fullDate="${escapeXmlAttribute(fullDate)}"` : "";
+			const formatChild = dateFormat !== void 0 ? `<w:dateFormat w:val="${escapeXmlAttribute(dateFormat)}"/>` : "";
 			if (wDate.test(next)) next = next.replace(wDate, (_match, prefix, matchedAttrs, inner) => {
 				let body = inner.replaceAll(/<\w+:dateFormat\b[^>]*(?:\/>|>[\s\S]*?<\/\w+:dateFormat>)/giu, "");
 				if (formatChild) body = `${formatChild}${body}`;
@@ -128,7 +134,7 @@ function reconcileRawSdtPr(raw, props, options = {}) {
 		}
 	}
 	if ((props.sdtType === "dropdown" || props.sdtType === "comboBox") && options.dropdownLastValue !== void 0) {
-		const escapedValue = escapeXmlAttr(options.dropdownLastValue);
+		const escapedValue = escapeXmlAttribute(options.dropdownLastValue);
 		const opened = /<(?<prefix>\w+):(?<name>dropDownList|comboBox)\b(?<attrs>[^>]*)>(?<inner>[\s\S]*?)<\/\w+:(?:dropDownList|comboBox)>/iu;
 		const selfClosing = /<(?<prefix>\w+):(?<name>dropDownList|comboBox)\b(?<attrs>[^/>]*)\/>/iu;
 		if (opened.test(next)) next = next.replace(opened, (_match, prefix, name, attrs, inner) => {