@stll/folio-core 0.14.1 → 0.15.1

package/dist/docx/rezip.js

@@ -1,3 +1,4 @@
+import { findChild, getChildElements, matchesName, parseXml } from "./xmlParser.js";
 import { parseNumbering } from "./numberingParser.js";
 import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
 import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
@@ -5,6 +6,7 @@ import { assertValidFolioDocumentModel } from "./modelValidation.js";
 import { isPreservableDocxEntry } from "./unzip.js";
 import { applyReplyThreadMarkers } from "./commentReplyMarkers.js";
 import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
+import { isNewDataUrlDrawing } from "./newImage.js";
 import { buildParagraphOffsetIndex, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds } from "./selectiveXmlPatch.js";
 import { escapeXml } from "./serializer/xmlUtils.js";
 import { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
@@ -95,11 +97,15 @@ function assertDocumentPackageFidelity(originalDocumentXml, serializedDocumentXm
 }
 async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	const comments = doc.package.document.comments ?? [];
-	const hadCommentsFile = zip.file("word/comments.xml") !== null;
-	if (comments.length === 0 && !hadCommentsFile) return;
+	const sourceCommentsFile = findZipEntryCaseInsensitive(zip, "word/comments.xml");
+	if (comments.length === 0) {
+		if (!sourceCommentsFile) return;
+		const sourceCommentsXml = await sourceCommentsFile.async("text");
+		if (!hasCommentEntries(sourceCommentsXml)) return;
+	}
 	ensureThreadedCommentParaIds(comments);
 	const commentsXml = serializeComments(comments);
-	zip.file("word/comments.xml", commentsXml, {
+	zip.file(sourceCommentsFile?.name ?? "word/comments.xml", commentsXml, {
 		compression: "DEFLATE",
 		compressionOptions: { level: compressionLevel }
 	});
@@ -107,6 +113,10 @@ async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	await ensureCommentsRelationship(zip, compressionLevel);
 	await syncCommentsExtendedPart(comments, zip, compressionLevel);
 }
+const hasCommentEntries = (xml) => {
+	const root = parseXml(xml);
+	return getChildElements(findChild(root, "w", "comments") ?? root).some((element) => matchesName(element, "w", "comment"));
+};
 /**
 * Bring `word/commentsExtended.xml` and its packaging (content-type override +
 * relationship) in line with the model: write the part when there is thread /
@@ -235,18 +245,10 @@ async function registerImageExtensions(zip, extensions, compressionLevel) {
 		compressionOptions: { level: compressionLevel }
 	});
 }
-/**
-* Collect all newly inserted images with data-URL src from the document content.
-* Existing DOCX images may also have a resolved data URL for preview; those must
-* continue to reference their original media part. Editor-created images use a
-* synthetic rId until they are assigned a real DOCX relationship here.
-*/
-const SYNTHETIC_IMAGE_RID_PREFIX = "rId_img_";
-const isNewDataUrlImage = (image) => image.src?.startsWith("data:") && (!image.rId || image.rId.startsWith(SYNTHETIC_IMAGE_RID_PREFIX));
 function collectNewImages(blocks) {
 	const images = [];
 	const collectFromRun = (run) => {
-		for (const c of run.content) if (c.type === "drawing" && c.image && isNewDataUrlImage(c.image)) images.push(c.image);
+		for (const c of run.content) if (isNewDataUrlDrawing(c)) images.push(c.image);
 	};
 	for (const block of blocks) if (block.type === "paragraph") {
 		for (const item of block.content) if (item.type === "run") collectFromRun(item);
@@ -270,13 +272,18 @@ const MIME_TO_EXT = {
 * Decode a data URL to binary ArrayBuffer and file extension.
 */
 function decodeDataUrl(dataUrl) {
-	const match = /^data:(?<mime>[^;]+);base64,(?<data>.+)$/u.exec(dataUrl);
+	const match = /^data:(?<mime>[^;,]+)(?<parameters>(?:;[^,]*)?),(?<data>[\s\S]*)$/u.exec(dataUrl);
 	if (!match) panic("Invalid data URL");
-	const binary = atob(match.groups["data"]);
-	const bytes = new Uint8Array(binary.length);
-	for (let i = 0; i < binary.length; i++) bytes[i] = binary.codePointAt(i) ?? 0;
+	const payload = match.groups["data"];
+	const parameters = match.groups["parameters"];
+	let bytes;
+	if (parameters.split(";").some((parameter) => parameter.toLowerCase() === "base64")) {
+		const binary = atob(payload);
+		bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.codePointAt(i) ?? 0;
+	} else bytes = new TextEncoder().encode(decodeURIComponent(payload));
 	return {
-		data: bytes.buffer,
+		data: bytes.slice().buffer,
 		extension: MIME_TO_EXT[match.groups["mime"]] ?? "png"
 	};
 }
@@ -360,6 +367,64 @@ async function processNewHyperlinks(newHyperlinks, zip, compressionLevel) {
 		});
 	}
 }
+const generateDocxZip = (zip, compressionLevel) => zip.generateAsync({
+	type: "arraybuffer",
+	compression: "DEFLATE",
+	compressionOptions: { level: compressionLevel }
+});
+const parsedZipSources = /* @__PURE__ */ new WeakMap();
+const removeNonPreservableEntries = (zip) => {
+	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && !isPreservableDocxEntry(path)) zip.remove(path);
+};
+const loadParsedZipSource = async (document, buffer) => {
+	const cached = parsedZipSources.get(document);
+	if (cached?.buffer === buffer) return cached;
+	const zip = await JSZip.loadAsync(buffer);
+	removeNonPreservableEntries(zip);
+	const [documentXml, corePropertiesXml] = await Promise.all([zip.file("word/document.xml")?.async("text"), zip.file("docProps/core.xml")?.async("text")]);
+	const source = {
+		buffer,
+		zip,
+		documentXml,
+		corePropertiesXml
+	};
+	parsedZipSources.set(document, source);
+	return source;
+};
+const cloneDocxZip = (source) => {
+	const clone = new JSZip();
+	clone.files = { ...source.files };
+	return clone;
+};
+const finishRepack = async ({ document, originalZip, outputZip, originalDocumentXml, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy }) => {
+	await materializeNewHeaderFooterParts(document, outputZip, compressionLevel);
+	await processNewImages(collectImageParts(document), outputZip, compressionLevel);
+	await processNewHyperlinks(collectHyperlinksWithoutRId(document.package.document.content), outputZip, compressionLevel);
+	assertValidFolioDocumentModel(document, "Cannot repack invalid DOCX document model");
+	applyReplyThreadMarkers(document);
+	const documentXml = serializeDocument(document);
+	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 serializeNotesToZip(document, originalZip, outputZip, compressionLevel);
+	await serializeNumberingIntoZip(document, originalZip, outputZip, compressionLevel);
+	await serializeCommentsToZip(document, outputZip, compressionLevel);
+	if (updateModifiedDate && originalCorePropertiesXml) {
+		const updatedCoreProperties = updateCoreProperties(originalCorePropertiesXml, {
+			updateModifiedDate,
+			...modifiedBy !== void 0 ? { modifiedBy } : {}
+		});
+		outputZip.file("docProps/core.xml", updatedCoreProperties, {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		});
+	}
+	return generateDocxZip(outputZip, compressionLevel);
+};
 /**
 * Repack a Document into a valid DOCX file
 *
@@ -373,54 +438,18 @@ async function repackDocx(doc, options = {}) {
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy } = options;
 	const exportDocument = withoutOrphanCommentRanges(doc);
 	const originalZip = await JSZip.loadAsync(doc.originalBuffer);
-	const newZip = new JSZip();
-	for (const [path, file] of Object.entries(originalZip.files)) {
-		if (file.dir) {
-			newZip.folder(path.replace(/\/$/u, ""));
-			continue;
-		}
-		if (!isPreservableDocxEntry(path)) continue;
-		const content = await file.async("arraybuffer");
-		newZip.file(path, content, {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		});
-	}
-	await materializeNewHeaderFooterParts(exportDocument, newZip, compressionLevel);
-	await processNewImages(collectImageParts(exportDocument), newZip, compressionLevel);
-	await processNewHyperlinks(collectHyperlinksWithoutRId(exportDocument.package.document.content), newZip, compressionLevel);
-	assertValidFolioDocumentModel(exportDocument, "Cannot repack invalid DOCX document model");
-	applyReplyThreadMarkers(exportDocument);
-	const documentXml = serializeDocument(exportDocument);
-	const originalDocumentXml = await originalZip.file("word/document.xml")?.async("text");
-	if (originalDocumentXml) assertDocumentPackageFidelity(originalDocumentXml, documentXml, exportDocument);
-	newZip.file("word/document.xml", documentXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
-	});
-	await rebindWatermarkRelIds(exportDocument, newZip, compressionLevel);
-	serializeHeadersFootersToZip(exportDocument, newZip, compressionLevel);
-	await serializeNotesToZip(exportDocument, originalZip, newZip, compressionLevel);
-	await serializeNumberingIntoZip(exportDocument, originalZip, newZip, compressionLevel);
-	await serializeCommentsToZip(exportDocument, newZip, compressionLevel);
-	if (updateModifiedDate) {
-		const corePropsPath = "docProps/core.xml";
-		const corePropsFile = originalZip.file(corePropsPath);
-		if (corePropsFile) {
-			const updatedCoreProps = updateCoreProperties(await corePropsFile.async("text"), {
-				updateModifiedDate,
-				...modifiedBy !== void 0 ? { modifiedBy } : {}
-			});
-			newZip.file(corePropsPath, updatedCoreProps, {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
-			});
-		}
-	}
-	return await newZip.generateAsync({
-		type: "arraybuffer",
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	const [originalDocumentXml, originalCorePropertiesXml] = await Promise.all([originalZip.file("word/document.xml")?.async("text"), originalZip.file("docProps/core.xml")?.async("text")]);
+	removeNonPreservableEntries(originalZip);
+	const newZip = cloneDocxZip(originalZip);
+	return finishRepack({
+		document: exportDocument,
+		originalZip,
+		outputZip: newZip,
+		originalDocumentXml,
+		originalCorePropertiesXml,
+		compressionLevel,
+		updateModifiedDate,
+		...modifiedBy !== void 0 ? { modifiedBy } : {}
 	});
 }
 /**
@@ -953,32 +982,26 @@ async function serializeNotesToZip(doc, originalZip, newZip, compressionLevel) {
 	const endnotes = doc.package.endnotes ?? [];
 	if (endnotes.length > 0) await patchNotePartIntoZip("word/endnotes.xml", serializeEndnotes(endnotes), (xml) => serializeEndnotes(parseEndnotes(xml).getNormalEndnotes()), originalZip, newZip, compressionLevel);
 }
-/**
-* Write edited numbering definitions into word/numbering.xml.
-*
-* Like the note parts, numbering.xml is preserved verbatim by the copy loop:
-* the model does not faithfully retain it (abstractNums drop `w:nsid`/`w:tmpl`,
-* custom number formats collapse, level `w:pPr`/`w:rPr` keep only a subset), so
-* re-emitting the whole part would lose those pieces. Instead each edited
-* `w:abstractNum` / `w:num` is spliced by id into the ORIGINAL part.
-*
-* Full repack has no change-tracking signal, so "edited" is detected by
-* comparing the model's numbering serialization against a BASELINE that
-* re-parses and re-serializes the original part. Both go through the same
-* (lossy) parse+serialize, so an unedited definition matches its baseline and
-* is left byte-exact; only a genuine definition edit differs and is spliced.
-*/
+const numberingBaselines = /* @__PURE__ */ new WeakMap();
 async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLevel) {
 	const numbering = doc.package.numbering;
 	if (!numbering || numbering.abstractNums.length === 0 && numbering.nums.length === 0) return;
 	const file = findNotePartEntry(originalZip, "word/numbering.xml");
 	if (!file) return;
-	const originalXml = await file.async("text");
-	const baselineXml = serializeNumberingXml(parseNumbering(originalXml).definitions);
+	let baseline = doc.originalBuffer ? numberingBaselines.get(doc) : void 0;
+	if (!baseline || baseline.originalBuffer !== doc.originalBuffer) {
+		const originalXml = await file.async("text");
+		baseline = {
+			originalBuffer: doc.originalBuffer,
+			originalXml,
+			serializedXml: serializeNumberingXml(parseNumbering(originalXml).definitions)
+		};
+		if (doc.originalBuffer) numberingBaselines.set(doc, baseline);
+	}
 	const currentXml = serializeNumberingXml(numbering);
-	const changed = collectChangedNumberingDefs(baselineXml, currentXml);
+	const changed = collectChangedNumberingDefs(baseline.serializedXml, currentXml);
 	if (changed.abstractNums.size === 0 && changed.nums.size === 0) return;
-	const patched = buildPatchedNumberingXml(originalXml, currentXml, changed);
+	const patched = buildPatchedNumberingXml(baseline.originalXml, currentXml, changed);
 	if (patched === null) return;
 	newZip.file(file.name, patched, {
 		compression: "DEFLATE",
@@ -1119,6 +1142,9 @@ function isDocxBuffer(buffer) {
 * @returns Promise resolving to minimal DOCX as ArrayBuffer
 */
 function createEmptyDocx() {
+	return generateDocxZip(createEmptyDocxZip(), 6);
+}
+const createEmptyDocxZip = () => {
 	const zip = new JSZip();
 	zip.file("[Content_Types].xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
@@ -1184,12 +1210,8 @@ function createEmptyDocx() {
   <Application>EigenPal DOCX Editor</Application>
   <AppVersion>1.0000</AppVersion>
 </Properties>`);
-	return zip.generateAsync({
-		type: "arraybuffer",
-		compression: "DEFLATE",
-		compressionOptions: { level: 6 }
-	});
-}
+	return zip;
+};
 /**
 * Create a new DOCX from a Document (without requiring original buffer)
 *
@@ -1197,15 +1219,31 @@ function createEmptyDocx() {
 * @returns Promise resolving to DOCX as ArrayBuffer
 */
 async function createDocx(doc) {
-	const emptyBuffer = await createDocumentSeedDocx(doc);
-	return repackDocx({
-		...doc,
-		originalBuffer: emptyBuffer
+	if (doc.originalBuffer) {
+		const source = await loadParsedZipSource(doc, doc.originalBuffer);
+		return finishRepack({
+			document: withoutOrphanCommentRanges(doc),
+			originalZip: source.zip,
+			outputZip: cloneDocxZip(source.zip),
+			originalDocumentXml: source.documentXml,
+			originalCorePropertiesXml: source.corePropertiesXml,
+			compressionLevel: 6,
+			updateModifiedDate: true
+		});
+	}
+	const zip = await createDocumentSeedZip(doc);
+	return finishRepack({
+		document: withoutOrphanCommentRanges(doc),
+		originalZip: zip,
+		outputZip: zip,
+		originalDocumentXml: void 0,
+		originalCorePropertiesXml: await zip.file("docProps/core.xml")?.async("text"),
+		compressionLevel: 6,
+		updateModifiedDate: true
 	});
 }
-const createDocumentSeedDocx = async (doc) => {
-	const buffer = await createEmptyDocx();
-	const zip = await JSZip.loadAsync(buffer);
+const createDocumentSeedZip = async (doc) => {
+	const zip = createEmptyDocxZip();
 	const relationships = ["<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/>"];
 	const overrides = [];
 	let nextRelationshipId = 2;
@@ -1244,11 +1282,7 @@ const createDocumentSeedDocx = async (doc) => {
 		const contentTypes = await contentTypesFile.async("string");
 		zip.file("[Content_Types].xml", contentTypes.replace("</Types>", `${overrides.join("")}\n</Types>`));
 	}
-	return zip.generateAsync({
-		type: "arraybuffer",
-		compression: "DEFLATE",
-		compressionOptions: { level: 6 }
-	});
+	return zip;
 };
 const relationshipXml = (id, type, target) => `<Relationship Id="rId${id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/${type}" Target="${target}"/>`;
 const overrideXml = (partName, contentType) => `<Override PartName="${partName}" ContentType="${contentType}"/>`;

package/dist/docx/runConsolidator.d.ts

@@ -1,5 +1,4 @@
 import { document_d_exports } from "../types/document.js";
-
 //#region src/docx/runConsolidator.d.ts
 /**
  * Check if two TextFormatting objects are equivalent

package/dist/docx/runParser.d.ts

@@ -1,7 +1,6 @@
 import { document_d_exports } from "../types/document.js";
 import { StyleMap } from "./styleParser.js";
 import { XmlElement } from "./xmlParser.js";
-
 //#region src/docx/runParser.d.ts
 /**
  * Parse run formatting properties (w:rPr)

package/dist/docx/runParser.js

@@ -1,10 +1,12 @@
-import { EmphasisMarkSchema, FontThemeSchema, HighlightColorSchema, ShadingPatternSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
-import { cloneWithXmlnsDeclarations, elementToXml, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
+import { EmphasisMarkSchema, FontHintSchema, FontThemeSchema, HighlightColorSchema, ShadingPatternSchema, TextEffectSchema, ThemeColorSlotSchema, UnderlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { cloneWithXmlnsDeclarations, elementToXml, findAllDeep, findChild, findChildren, getAttribute, getChildElements, getLocalName, getTextContent, mergeXmlnsDeclarations, parseBooleanElement, parseNumericAttribute } from "./xmlParser.js";
+import { isTextBoxDrawing } from "./textBoxParser.js";
 import { parseImage } from "./imageParser.js";
 import { parseGroupDrawing } from "./groupDrawingParser.js";
 import { parseShapeFromDrawing, shouldPreserveRawShapeDrawing } from "./shapeParser.js";
 import { parseVmlImageContent } from "./vmlImageParser.js";
 import { resolveThemeFontRef } from "./themeParser.js";
+import { requiresXmlSpacePreserve } from "./textWhitespace.js";
 import { normalizeRevisionId } from "@stll/docx-core/model";
 //#region src/docx/runParser.ts
 /**
@@ -240,6 +242,8 @@ function parseRunProperties(rPr, theme, _styles) {
 		if (eastAsia) fontFamily.eastAsia = eastAsia;
 		const csFont = getAttribute(rFonts, "w", "cs");
 		if (csFont) fontFamily.cs = csFont;
+		const hint = narrowEnum(getAttribute(rFonts, "w", "hint"), FontHintSchema);
+		if (hint) fontFamily.hint = hint;
 		const asciiTheme = narrowEnum(getAttribute(rFonts, "w", "asciiTheme"), FontThemeSchema);
 		if (asciiTheme) {
 			fontFamily.asciiTheme = asciiTheme;
@@ -368,7 +372,7 @@ function parseRunPropertyChanges(rPr, theme, styles, currentFormatting) {
 */
 function parseTextContent(element) {
 	const text = getTextContent(element);
-	const preserveSpace = getAttribute(element, "xml", "space") === "preserve";
+	const preserveSpace = getAttribute(element, "xml", "space") === "preserve" || requiresXmlSpacePreserve(text);
 	const content = {
 		type: "text",
 		text
@@ -500,14 +504,6 @@ function parseDrawingContent(element, rels, media) {
 	return drawing;
 }
 /**
-* Get the local name of an element (without namespace prefix)
-*/
-function getLocalName(name) {
-	if (!name) return "";
-	const colonIndex = name.indexOf(":");
-	return colonIndex !== -1 ? name.slice(colonIndex + 1) : name;
-}
-/**
 * Parse all content within a run element
 */
 function parseRunContents(runElement, rels, media, rootXmlns = {}) {
@@ -573,6 +569,7 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 			const alternateChildren = getChildElements(child);
 			const choiceEl = alternateChildren.find((el) => getLocalName(el.name) === "Choice");
 			const fallbackEl = alternateChildren.find((el) => getLocalName(el.name) === "Fallback");
+			const choiceTextBoxDrawing = choiceEl ? getChildElements(choiceEl).find((element) => getLocalName(element.name) === "drawing" && isTextBoxDrawing(element)) : void 0;
 			const groupedChoiceDrawing = choiceEl ? getChildElements(choiceEl).find((element) => getLocalName(element.name) === "drawing" && findAllDeep(element, "wpg", "wgp").length > 0) : void 0;
 			if (groupedChoiceDrawing) {
 				const groupedDrawing = parseDrawingContent(groupedChoiceDrawing, rels, media);
@@ -583,7 +580,7 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 				}
 			}
 			const fallbackPict = fallbackEl ? getChildElements(fallbackEl).find((el) => getLocalName(el.name) === "pict") : void 0;
-			const fallbackVml = fallbackPict ? parseVmlImageContent(fallbackPict, rels, media, rootXmlns) : null;
+			const fallbackVml = fallbackPict && !choiceTextBoxDrawing ? parseVmlImageContent(fallbackPict, rels, media, rootXmlns) : null;
 			if (fallbackVml?.image.src) {
 				fallbackVml.rawXml = elementToXml(cloneWithXmlnsDeclarations(child, rootXmlns));
 				contents.push(fallbackVml);

package/dist/docx/sdtProperties.d.ts

@@ -1,6 +1,5 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
-
 //#region src/docx/sdtProperties.d.ts
 /**
  * Parse `<w:sdtPr>` (and optional `<w:sdtEndPr>`) into {@link SdtProperties}.

package/dist/docx/sdtPropertiesPatch.d.ts

@@ -1,5 +1,4 @@
 import { document_d_exports } from "../types/document.js";
-
 //#region src/docx/sdtPropertiesPatch.d.ts
 /**
  * Rewrite the relevant child elements of `<w:sdtPr>` so the modeled

package/dist/docx/sectionParser.d.ts

@@ -1,6 +1,5 @@
 import { document_d_exports } from "../types/document.js";
 import { XmlElement } from "./xmlParser.js";
-
 //#region src/docx/sectionParser.d.ts
 declare function getUnserializedSectionPropertyChildNames(props: document_d_exports.SectionProperties): readonly string[] | undefined;
 /**

package/dist/docx/selectiveSave.d.ts

@@ -1,9 +1,11 @@
 import { document_d_exports } from "../types/document.js";
-
 //#region src/docx/selectiveSave.d.ts
 type SelectiveSaveOptions = {
-  /** Changed paragraph IDs to selectively patch */changedParaIds: Set<string>; /** Whether structural changes occurred (paragraph add/delete) */
-  structuralChange: boolean; /** Whether any changes affected paragraphs without paraId */
+  /** Changed paragraph IDs to selectively patch */
+  changedParaIds: Set<string>;
+  /** Whether structural changes occurred (paragraph add/delete) */
+  structuralChange: boolean;
+  /** Whether any changes affected paragraphs without paraId */
   hasUntrackedChanges: boolean;
   /**
    * Maximum allowed `originalBuffer.byteLength` for the selective path. Above

package/dist/docx/selectiveSave.js

@@ -5,6 +5,7 @@ import { validateFolioDocumentModel } from "./modelValidation.js";
 import { isPreservableDocxEntry } from "./unzip.js";
 import { hasUnsynthesizedReplyRanges } from "./commentReplyMarkers.js";
 import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
+import { isNewDataUrlDrawing } from "./newImage.js";
 import { buildPatchedDocumentXml, buildPatchedNoteXml, buildPatchedNumberingXml, collectChangedNumberingDefs, collectParaIds } from "./selectiveXmlPatch.js";
 import { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
@@ -13,14 +14,13 @@ import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
 import { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_PART_LOWER, addCommentsExtendedOverride, addCommentsExtendedRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, updateCoreProperties } from "./rezip.js";
 import "./selectiveSaveFlags.js";
 //#region src/docx/selectiveSave.ts
-const SYNTHETIC_IMAGE_RID_PREFIX = "rId_img_";
 /**
 * Check if document content has new images (data: URL without rId) or
 * new hyperlinks (href without rId). Combined into a single traversal
 * to avoid walking the block tree twice.
 */
 function hasNewImagesOrHyperlinks(blocks) {
-	const runHasNewImage = (run) => run.content.some((c) => c.type === "drawing" && c.image?.src?.startsWith("data:") === true && (!c.image.rId || c.image.rId.startsWith(SYNTHETIC_IMAGE_RID_PREFIX)));
+	const runHasNewImage = (run) => run.content.some(isNewDataUrlDrawing);
 	for (const block of blocks) if (block.type === "paragraph") {
 		for (const item of block.content) if (item.type === "run") {
 			if (runHasNewImage(item)) return true;

package/dist/docx/selectiveSaveFlags.d.ts

@@ -13,13 +13,15 @@
  *   the dominant cost.
  */
 type FolioSelectiveSaveFlags = {
-  /** Enable the selective save path. Default: false (full repack only). */selectiveSave?: boolean;
+  /** Enable the selective save path. Default: false (full repack only). */
+  selectiveSave?: boolean;
   /**
    * Run selective save and full repack on every save, compare bytes, and emit
    * a `TripwireResult` via `onSelectiveSaveTripwire`. Independent of
    * `selectiveSave`: the tripwire always observes both paths.
    */
-  selectiveSaveTripwire?: boolean; /** Maximum original buffer size, in bytes, for which selective save is allowed. */
+  selectiveSaveTripwire?: boolean;
+  /** Maximum original buffer size, in bytes, for which selective save is allowed. */
   selectiveSaveMaxBytes?: number;
 };
 declare const DEFAULT_SELECTIVE_SAVE_MAX_BYTES: number;

package/dist/docx/selectiveXmlPatch.js

@@ -367,8 +367,20 @@ function findNumberingElementOffsets(xml, kind, id) {
 function extractNumberingElementXml(xml, kind, id) {
 	return extractElementByIdAttr(xml, NUMBERING_OPEN_LITERAL[kind], NUMBERING_CLOSE_TAG[kind], NUMBERING_ID_ATTR[kind], id);
 }
-function collectNumberingElementIds(xml, kind) {
-	return collectElementIds(xml, NUMBERING_OPEN_LITERAL[kind], NUMBERING_ID_ATTR[kind]);
+function buildNumberingElementOffsetIndex(xml, kind) {
+	const index = /* @__PURE__ */ new Map();
+	const openLiteral = NUMBERING_OPEN_LITERAL[kind];
+	const pattern = new RegExp(`${escapeRegExp(openLiteral)}[\\s][^>]*?${escapeRegExp(NUMBERING_ID_ATTR[kind])}="(?<id>[^"]+)"`, "gu");
+	let match;
+	while ((match = pattern.exec(xml)) !== null) {
+		const id = match.groups["id"];
+		if (index.has(id)) {
+			index.set(id, null);
+			continue;
+		}
+		index.set(id, scanElementRange(xml, match.index, openLiteral, NUMBERING_CLOSE_TAG[kind]));
+	}
+	return index;
 }
 const SYNTHETIC_NUM_FMT_PATTERN = /<w:numFmt w:val="decimalZero(?<width>[345])"\/>/u;
 /**
@@ -381,12 +393,12 @@ const SYNTHETIC_NUM_FMT_PATTERN = /<w:numFmt w:val="decimalZero(?<width>[345])"\
 function collectChangedNumberingDefs(baselineXml, currentXml) {
 	const changedForKind = (kind) => {
 		const changed = /* @__PURE__ */ new Set();
-		const baselineIds = collectNumberingElementIds(baselineXml, kind);
-		for (const [id, count] of collectNumberingElementIds(currentXml, kind)) {
-			if (count !== 1 || baselineIds.get(id) !== 1) continue;
-			const before = extractNumberingElementXml(baselineXml, kind, id);
-			const after = extractNumberingElementXml(currentXml, kind, id);
-			if (before !== null && after !== null && before !== after) changed.add(id);
+		const baselineIndex = buildNumberingElementOffsetIndex(baselineXml, kind);
+		const currentIndex = buildNumberingElementOffsetIndex(currentXml, kind);
+		for (const [id, afterRange] of currentIndex) {
+			const beforeRange = baselineIndex.get(id);
+			if (!beforeRange || !afterRange) continue;
+			if (baselineXml.slice(beforeRange.start, beforeRange.end) !== currentXml.slice(afterRange.start, afterRange.end)) changed.add(id);
 		}
 		return changed;
 	};

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

@@ -1,5 +1,4 @@
 import { document_d_exports } from "../../types/document.js";
-
 //#region src/docx/serializer/blockSdtSerializer.d.ts
 declare function serializeBlockSdt(blockSdt: document_d_exports.BlockSdt, serializeChild: (block: document_d_exports.BlockContent) => string): string;
 //#endregion

package/dist/docx/serializer/blockSdtSerializer.js

@@ -1,5 +1,5 @@
-import { isSingleWellFormedElement } from "./xmlUtils.js";
 import { reconcileRawSdtPr } from "../sdtPropertiesPatch.js";
+import { isSingleWellFormedElement } from "./xmlUtils.js";
 //#region src/docx/serializer/blockSdtSerializer.ts
 function escapeXmlAttr(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
@@ -52,6 +52,7 @@ function extractDropdownLastValue(blockSdt) {
 	if (blockSdt.properties.sdtType !== "dropdown" && blockSdt.properties.sdtType !== "comboBox") return;
 	const modeled = blockSdt.properties.dropdownLastValue;
 	if (modeled !== void 0) return modeled;
+	if (blockSdt.properties.rawPropertiesXml !== void 0) return;
 	const firstBlock = blockSdt.content[0];
 	if (!firstBlock || firstBlock.type !== "paragraph") return;
 	const parts = [];

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

@@ -1,5 +1,4 @@
 import { document_d_exports } from "../../types/document.js";
-
 //#region src/docx/serializer/borderSerializer.d.ts
 /**
  * Serialize a single border element (`<w:top .../>`, `<w:left .../>`, ...).

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

@@ -1,5 +1,4 @@
 import { Comment } from "../../types/content.js";
-
 //#region src/docx/serializer/commentSerializer.d.ts
 /**
  * Serialize comments array to comments.xml content. Returns a valid empty

package/dist/docx/serializer/commentSerializer.js

@@ -1,49 +1,23 @@
 import { deterministicHexId } from "../../utils/hexId.js";
 import { escapeXml } from "./xmlUtils.js";
+import { serializeParagraph } from "./paragraphSerializer.js";
 //#region src/docx/serializer/commentSerializer.ts
 /**
 * Comment Serializer
 *
 * Serializes Comment[] to OOXML comments.xml format.
 */
-function serializeRunContent(run) {
-	let xml = "<w:r>";
-	const rPr = [];
-	if (run.formatting?.bold) rPr.push("<w:b/>");
-	if (run.formatting?.italic) rPr.push("<w:i/>");
-	if (rPr.length > 0) xml += `<w:rPr>${rPr.join("")}</w:rPr>`;
-	for (const c of run.content) if (c.type === "text") {
-		const preserveSpace = c.text !== c.text.trim() || c.text.includes("  ");
-		xml += preserveSpace ? `<w:t xml:space="preserve">${escapeXml(c.text)}</w:t>` : `<w:t>${escapeXml(c.text)}</w:t>`;
-	} else if (c.type === "break") xml += "<w:br/>";
-	xml += "</w:r>";
-	return xml;
-}
-/**
-* `w14:paraId` / `w14:textId` open tag for a comment paragraph. Word keys
-* commentsExtended.xml (reply threading) and commentsExtensible.xml (UTC
-* dates) on the paraId of a comment's LAST paragraph, so the id must survive
-* serialization; the parser stores it on `Paragraph.paraId`.
-*/
-function commentParagraphOpenTag(p) {
-	const attrs = [];
-	if (p.paraId) attrs.push(`w14:paraId="${escapeXml(p.paraId)}"`);
-	if (p.textId) attrs.push(`w14:textId="${escapeXml(p.textId)}"`);
-	return attrs.length > 0 ? `<w:p ${attrs.join(" ")}>` : "<w:p>";
-}
-function serializeParagraph(p) {
-	let xml = commentParagraphOpenTag(p);
-	for (const item of p.content) if (item.type === "run") xml += serializeRunContent(item);
-	xml += "</w:p>";
-	return xml;
-}
+const ANNOTATION_REFERENCE_XML = "<w:r><w:rPr><w:rStyle w:val=\"CommentReference\"/></w:rPr><w:annotationRef/></w:r>";
+const PARAGRAPH_PROPERTIES_END = "</w:pPr>";
 /** Serialize a paragraph, prepending an annotationRef run (required by Word in first paragraph of a comment) */
-function serializeParagraphWithAnnotationRef(p) {
-	let xml = commentParagraphOpenTag(p);
-	xml += "<w:r><w:rPr><w:rStyle w:val=\"CommentReference\"/></w:rPr><w:annotationRef/></w:r>";
-	for (const item of p.content) if (item.type === "run") xml += serializeRunContent(item);
-	xml += "</w:p>";
-	return xml;
+function serializeParagraphWithAnnotationRef(paragraph) {
+	const xml = serializeParagraph(paragraph);
+	const propertiesEnd = xml.indexOf(PARAGRAPH_PROPERTIES_END);
+	if (propertiesEnd !== -1) {
+		const contentStart = propertiesEnd + 8;
+		return `${xml.slice(0, contentStart)}${ANNOTATION_REFERENCE_XML}${xml.slice(contentStart)}`;
+	}
+	return xml.replace(/^<w:p(?=[\s>])[^>]*>/u, (openingTag) => `${openingTag}${ANNOTATION_REFERENCE_XML}`);
 }
 function serializeComment(comment) {
 	const attrs = [`w:id="${comment.id}"`, `w:author="${escapeXml(comment.author)}"`];