@stll/folio-core 0.15.0 → 0.15.2

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/runConsolidator.js

@@ -161,7 +161,6 @@ function consolidateRuns(runs) {
 	return result;
 }
 function consolidateParagraphContent(content) {
-	if (content.length <= 1) return content;
 	const result = [];
 	const pendingRuns = [];
 	function flushRuns() {

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, PositionalTabAlignmentSchema, PositionalTabLeaderSchema, PositionalTabRelativeToSchema, 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
@@ -382,6 +386,19 @@ function parseTextContent(element) {
 function parseTabContent() {
 	return { type: "tab" };
 }
+function parsePositionalTabContent(element) {
+	const positional = {};
+	const relativeTo = narrowEnum(getAttribute(element, "w", "relativeTo"), PositionalTabRelativeToSchema);
+	const alignment = narrowEnum(getAttribute(element, "w", "alignment"), PositionalTabAlignmentSchema);
+	const leader = narrowEnum(getAttribute(element, "w", "leader"), PositionalTabLeaderSchema);
+	if (relativeTo !== void 0) positional.relativeTo = relativeTo;
+	if (alignment !== void 0) positional.alignment = alignment;
+	if (leader !== void 0) positional.leader = leader;
+	return {
+		type: "tab",
+		positional
+	};
+}
 /**
 * Parse break element (w:br)
 */
@@ -500,14 +517,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 = {}) {
@@ -520,6 +529,9 @@ function parseRunContents(runElement, rels, media, rootXmlns = {}) {
 		case "tab":
 			contents.push(parseTabContent());
 			break;
+		case "ptab":
+			contents.push(parsePositionalTabContent(child));
+			break;
 		case "br":
 			contents.push(parseBreakContent(child));
 			break;
@@ -573,6 +585,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 +596,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