@stll/folio-core 0.11.0 → 0.13.0

package/dist/docx/commentRangeIntegrity.js

@@ -0,0 +1,186 @@
+//#region src/docx/commentRangeIntegrity.ts
+const withoutOrphanCommentRanges = (doc) => {
+	const validCommentIds = new Set((doc.package.document.comments ?? []).map((comment) => comment.id));
+	const document = withoutOrphanDocumentBodyMarkers(doc.package.document, validCommentIds);
+	const headers = withoutOrphanHeaderFooterMapMarkers(doc.package.headers, validCommentIds);
+	const footers = withoutOrphanHeaderFooterMapMarkers(doc.package.footers, validCommentIds);
+	const footnotes = withoutOrphanNoteMarkers(doc.package.footnotes, validCommentIds);
+	const endnotes = withoutOrphanNoteMarkers(doc.package.endnotes, validCommentIds);
+	if (!document && !headers && !footers && !footnotes && !endnotes) return doc;
+	return {
+		...doc,
+		package: {
+			...doc.package,
+			...document ? { document } : {},
+			...headers ? { headers } : {},
+			...footers ? { footers } : {},
+			...footnotes ? { footnotes } : {},
+			...endnotes ? { endnotes } : {}
+		}
+	};
+};
+const withoutOrphanDocumentBodyMarkers = (document, validCommentIds) => {
+	const content = withoutOrphanBlockMarkers(document.content, validCommentIds);
+	const comments = withoutOrphanCommentBodyMarkers(document.comments, validCommentIds);
+	if (!content && !comments) return null;
+	return {
+		...document,
+		...content ? { content } : {},
+		...comments ? { comments } : {}
+	};
+};
+const withoutOrphanCommentBodyMarkers = (comments, validCommentIds) => {
+	if (!comments) return null;
+	let changed = false;
+	const next = [];
+	for (const comment of comments) {
+		const content = withoutOrphanParagraphListMarkers(comment.content, validCommentIds);
+		if (!content) {
+			next.push(comment);
+			continue;
+		}
+		changed = true;
+		next.push({
+			...comment,
+			content
+		});
+	}
+	return changed ? next : null;
+};
+const withoutOrphanParagraphListMarkers = (paragraphs, validCommentIds) => {
+	let changed = false;
+	const next = [];
+	for (const paragraph of paragraphs) {
+		const nextParagraph = withoutOrphanParagraphMarkers(paragraph, validCommentIds);
+		if (nextParagraph !== paragraph) changed = true;
+		next.push(nextParagraph);
+	}
+	return changed ? next : null;
+};
+const withoutOrphanHeaderFooterMapMarkers = (map, validCommentIds) => {
+	if (!map) return null;
+	let changed = false;
+	const next = /* @__PURE__ */ new Map();
+	for (const [rId, headerFooter] of map) {
+		const content = withoutOrphanBlockMarkers(headerFooter.content, validCommentIds);
+		if (!content) {
+			next.set(rId, headerFooter);
+			continue;
+		}
+		changed = true;
+		next.set(rId, {
+			...headerFooter,
+			content
+		});
+	}
+	return changed ? next : null;
+};
+const withoutOrphanNoteMarkers = (notes, validCommentIds) => {
+	if (!notes) return null;
+	let changed = false;
+	const next = [];
+	for (const note of notes) {
+		const content = withoutOrphanBlockMarkers(note.content, validCommentIds);
+		if (!content) {
+			next.push(note);
+			continue;
+		}
+		changed = true;
+		next.push({
+			...note,
+			content
+		});
+	}
+	return changed ? next : null;
+};
+const withoutOrphanBlockMarkers = (blocks, validCommentIds) => {
+	let changed = false;
+	const next = [];
+	for (const block of blocks) {
+		const nextBlock = withoutOrphanBlockMarker(block, validCommentIds);
+		if (nextBlock !== block) changed = true;
+		next.push(nextBlock);
+	}
+	return changed ? next : null;
+};
+const withoutOrphanBlockMarker = (block, validCommentIds) => {
+	if (block.type === "paragraph") return withoutOrphanParagraphMarkers(block, validCommentIds);
+	if (block.type === "table") return withoutOrphanTableMarkers(block, validCommentIds);
+	if (!("content" in block) || !block.content) return block;
+	const content = withoutOrphanBlockMarkers(block.content, validCommentIds);
+	if (!content) return block;
+	return {
+		...block,
+		content
+	};
+};
+const withoutOrphanTableMarkers = (table, validCommentIds) => {
+	let changed = false;
+	const rows = [];
+	for (const row of table.rows) {
+		const nextRow = withoutOrphanTableRowMarkers(row, validCommentIds);
+		if (nextRow !== row) changed = true;
+		rows.push(nextRow);
+	}
+	if (!changed) return table;
+	return {
+		...table,
+		rows
+	};
+};
+const withoutOrphanTableRowMarkers = (row, validCommentIds) => {
+	let changed = false;
+	const cells = [];
+	for (const cell of row.cells) {
+		const nextCell = withoutOrphanTableCellMarkers(cell, validCommentIds);
+		if (nextCell !== cell) changed = true;
+		cells.push(nextCell);
+	}
+	if (!changed) return row;
+	return {
+		...row,
+		cells
+	};
+};
+const withoutOrphanTableCellMarkers = (cell, validCommentIds) => {
+	const content = withoutOrphanTableCellBlockMarkers(cell.content, validCommentIds);
+	if (!content) return cell;
+	return {
+		...cell,
+		content
+	};
+};
+const withoutOrphanTableCellBlockMarkers = (blocks, validCommentIds) => {
+	let changed = false;
+	const next = [];
+	for (const block of blocks) {
+		const nextBlock = withoutOrphanTableCellBlockMarker(block, validCommentIds);
+		if (nextBlock !== block) changed = true;
+		next.push(nextBlock);
+	}
+	return changed ? next : null;
+};
+const withoutOrphanTableCellBlockMarker = (block, validCommentIds) => {
+	if (block.type === "paragraph") return withoutOrphanParagraphMarkers(block, validCommentIds);
+	if (block.type === "table") return withoutOrphanTableMarkers(block, validCommentIds);
+	return block;
+};
+const withoutOrphanParagraphMarkers = (paragraph, validCommentIds) => {
+	let changed = false;
+	const content = [];
+	for (const item of paragraph.content) {
+		if (isCommentMarker(item) && !validCommentIds.has(item.id)) {
+			changed = true;
+			continue;
+		}
+		content.push(item);
+	}
+	if (!changed) return paragraph;
+	return {
+		...paragraph,
+		content
+	};
+};
+const isCommentMarker = (content) => content.type === "commentRangeStart" || content.type === "commentRangeEnd" || content.type === "commentReference";
+//#endregion
+export { withoutOrphanCommentRanges };

package/dist/docx/conformance.js

@@ -3,9 +3,70 @@ import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 //#region src/docx/conformance.ts
 const STRICT_MAIN_NAMESPACE = "http://purl.oclc.org/ooxml/wordprocessingml/main";
 const TRANSITIONAL_MAIN_NAMESPACE = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+const ROOT_START_TAG_SCAN_LIMIT = 64 * 1024;
+const XML_WHITESPACE = /\s/u;
+/**
+* Find the root start tag within a bounded prefix of `document.xml`,
+* without backtracking.
+*
+* Equivalent in captured-tag semantics to the previous
+* `/^(?:\uFEFF|\s|<\?[\s\S]*?\?>|<!--[\s\S]*?-->)*(?<tag><[^\s/>]+(?:[^>"']|"[^"]*"|'[^']*')*>)/u`
+* pattern, but as a linear hand-rolled scanner: the original alternation of
+* greedy/lazy `[\s\S]*?` spans over an attacker-controlled prefix was
+* susceptible to catastrophic backtracking on crafted input. This walks
+* `scanTarget` once, tracking in-quote state, and returns `undefined` in
+* every case the regex would have failed to match (unterminated PI/comment,
+* no tag found before the scan limit, malformed tag open).
+*/
+function scanRootStartTag(scanTarget) {
+	const length = scanTarget.length;
+	let index = 0;
+	for (;;) {
+		if (index >= length) return;
+		const character = scanTarget[index];
+		if (character === "" || XML_WHITESPACE.test(character ?? "")) {
+			index += 1;
+			continue;
+		}
+		if (scanTarget.startsWith("<?", index)) {
+			const closeIndex = scanTarget.indexOf("?>", index + 2);
+			if (closeIndex === -1) return;
+			index = closeIndex + 2;
+			continue;
+		}
+		if (scanTarget.startsWith("<!--", index)) {
+			const closeIndex = scanTarget.indexOf("-->", index + 4);
+			if (closeIndex === -1) return;
+			index = closeIndex + 3;
+			continue;
+		}
+		break;
+	}
+	if (scanTarget[index] !== "<") return;
+	const nameStart = index + 1;
+	const firstNameChar = scanTarget[nameStart];
+	if (firstNameChar === void 0 || firstNameChar === "/" || firstNameChar === ">" || XML_WHITESPACE.test(firstNameChar)) return;
+	let quote;
+	for (let cursor = nameStart; cursor < length; cursor++) {
+		const character = scanTarget[cursor];
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === ">") return scanTarget.slice(index, cursor + 1);
+	}
+}
 const detectDocxConformanceClass = (documentXml) => {
 	if (documentXml === null) return DOCX_CONFORMANCE_CLASSES.UNKNOWN;
-	const root = parseXmlDocument(documentXml);
+	const rootStartTag = scanRootStartTag(documentXml.length <= ROOT_START_TAG_SCAN_LIMIT ? documentXml : documentXml.slice(0, ROOT_START_TAG_SCAN_LIMIT));
+	const root = (rootStartTag === void 0 ? null : parseXmlDocument(rootStartTag.endsWith("/>") ? rootStartTag : `${rootStartTag.slice(0, -1)}/>`)) ?? parseXmlDocument(documentXml);
+	return detectDocxConformanceClassFromRoot(root);
+};
+const detectDocxConformanceClassFromRoot = (root) => {
 	if (root === null || getLocalName(root.name ?? "") !== "document") return DOCX_CONFORMANCE_CLASSES.UNKNOWN;
 	const prefix = getNamespacePrefix(root.name ?? "");
 	const namespaceAttribute = prefix === null ? "xmlns" : `xmlns:${prefix}`;

package/dist/docx/documentGrid.d.ts

@@ -0,0 +1,8 @@
+//#region src/docx/documentGrid.d.ts
+type DocumentGrid = {
+  type?: "default" | "lines" | "linesAndChars" | "snapToChars";
+  linePitch?: number;
+};
+declare function resolveDocumentGridLinePitch(grid: DocumentGrid | undefined): number | undefined;
+//#endregion
+export { resolveDocumentGridLinePitch };

package/dist/docx/documentGrid.js

@@ -0,0 +1,8 @@
+//#region src/docx/documentGrid.ts
+function resolveDocumentGridLinePitch(grid) {
+	if (grid?.type === void 0 || grid.type === "default") return;
+	if (grid.linePitch === void 0 || grid.linePitch <= 0) return;
+	return grid.linePitch;
+}
+//#endregion
+export { resolveDocumentGridLinePitch };

package/dist/docx/drawingUtils.js

@@ -1,5 +1,5 @@
-import { findByFullName, getAttribute, getChildElements, getTextContent, parseNumericAttribute } from "./xmlParser.js";
 import { ImageHorizontalAlignmentSchema, ImageHorizontalRelativeToSchema, ImageVerticalAlignmentSchema, ImageVerticalRelativeToSchema, ImageWrapTextSchema, ShapeOutlineStyleSchema, narrowEnum } from "./parserEnums.js";
+import { findByFullName, getAttribute, getChildElements, getTextContent, parseNumericAttribute } from "./xmlParser.js";
 //#region src/docx/drawingUtils.ts
 /**
 * Map OOXML scheme names to standard theme color slots.

package/dist/docx/encryption/agileDecryption.js

@@ -1,5 +1,6 @@
 import { DOCX_ENCRYPTION_ERROR_CODES, DocxEncryptionError } from "./errors.js";
 import { bytesEqual, joinBytes, padToBlock, passwordToUtf16Le, toArrayBuffer, writeUint32Le } from "./cryptoBytes.js";
+import { MAX_SPIN_COUNT } from "./encryptionInfo.js";
 //#region src/docx/encryption/agileDecryption.ts
 /**
 * Agile Encryption decryption (Office 2010+) using Web Crypto.
@@ -115,11 +116,20 @@ const decryptAesCbc = async (rawKey, iv, ciphertext) => {
 	}, key, toArrayBuffer(paddedCiphertext));
 	return new Uint8Array(decrypted).subarray(0, ciphertext.length);
 };
-/** [MS-OFFCRYPTO] 2.3.4.9 — iterated hash of password + salt. */
+/**
+* [MS-OFFCRYPTO] 2.3.4.9 — iterated hash of password + salt.
+*
+* `iterations` is expected to already be validated by
+* `encryptionInfo.ts`'s `spinCount` parsing, but this loop drives real
+* WebCrypto work per iteration, so it is clamped again here as well —
+* this function must stay safe to call with an untrusted iteration count
+* regardless of caller.
+*/
 const hashPassword = async (password, salt, iterations, hashName) => {
 	const algorithm = webHashName(hashName);
+	const boundedIterations = Math.min(Math.max(iterations, 0), MAX_SPIN_COUNT);
 	let state = await digest(algorithm, joinBytes([salt, passwordToUtf16Le(password)]));
-	for (let i = 0; i < iterations; i++) state = await digest(algorithm, joinBytes([writeUint32Le(i), state]));
+	for (let i = 0; i < boundedIterations; i++) state = await digest(algorithm, joinBytes([writeUint32Le(i), state]));
 	return state;
 };
 /** [MS-OFFCRYPTO] 2.3.4.9 — finalize a derived key with a block key suffix. */

package/dist/docx/encryption/compoundFile.js

@@ -83,9 +83,14 @@ const loadSector = (file, header, sectorId) => {
 };
 const loadFatSectorIds = (file, header) => {
 	const ids = [...header.headerDifat];
+	const maxDifatSectors = Math.ceil(file.length / header.sectorBytes);
+	const stepLimit = Math.min(header.difatSectorCount, maxDifatSectors);
+	const seen = /* @__PURE__ */ new Set();
 	let chain = header.difatStart;
-	for (let step = 0; step < header.difatSectorCount; step++) {
+	for (let step = 0; step < stepLimit; step++) {
 		if (chain === SECTOR_END || chain === SECTOR_FREE) break;
+		if (seen.has(chain)) throw new Error(`DIFAT chain loop at sector ${chain}`);
+		seen.add(chain);
 		const sector = loadSector(file, header, chain);
 		const view = viewOf(sector);
 		const slotsPerSector = header.sectorBytes / 4 - 1;

package/dist/docx/encryption/encryptionInfo.d.ts

@@ -27,6 +27,14 @@ type AgileEncryptionDescriptor = {
   scheme: "agile";
   material: AgileKeyMaterial;
 };
+/**
+ * Cap on `encryptedKey/@spinCount`. MS-OFFCRYPTO's documented default is
+ * 100,000; a hostile/corrupt value here would drive `hashPassword`'s
+ * per-iteration WebCrypto digest loop (agileDecryption.ts) an
+ * attacker-chosen number of times, so reject anything past a generous
+ * multiple of that default instead of trusting the file.
+ */
+declare const MAX_SPIN_COUNT = 200000;
 declare const parseAgileEncryptionInfo: (stream: Uint8Array) => AgileEncryptionDescriptor;
 //#endregion
-export { AgileEncryptionDescriptor, AgileKeyMaterial, parseAgileEncryptionInfo };
+export { AgileEncryptionDescriptor, AgileKeyMaterial, MAX_SPIN_COUNT, parseAgileEncryptionInfo };

package/dist/docx/encryption/encryptionInfo.js

@@ -68,6 +68,22 @@ const requireInt = (attrs, name, element) => {
 	return parsed;
 };
 const requireBase64 = (attrs, name, element) => decodeBase64(requireAttr(attrs, name, element));
+/**
+* Cap on `encryptedKey/@spinCount`. MS-OFFCRYPTO's documented default is
+* 100,000; a hostile/corrupt value here would drive `hashPassword`'s
+* per-iteration WebCrypto digest loop (agileDecryption.ts) an
+* attacker-chosen number of times, so reject anything past a generous
+* multiple of that default instead of trusting the file.
+*/
+const MAX_SPIN_COUNT = 2e5;
+const requireSpinCount = (attrs, element) => {
+	const spinCount = requireInt(attrs, "spinCount", element);
+	if (spinCount < 0 || spinCount > 2e5) throw new DocxEncryptionError({
+		code: DOCX_ENCRYPTION_ERROR_CODES.DECRYPTION_FAILED,
+		message: `EncryptionInfo <${element}> attribute "spinCount" out of range: ${spinCount}`
+	});
+	return spinCount;
+};
 const parseAgileXml = (xmlBytes) => {
 	const xml = new TextDecoder("utf-8").decode(xmlBytes);
 	const keyDataTag = findElement(xml, "keyData");
@@ -88,7 +104,7 @@ const parseAgileXml = (xmlBytes) => {
 		cipherBlockBytes: requireInt(keyData, "blockSize", "keyData"),
 		cipherName: requireAttr(keyData, "cipherAlgorithm", "keyData"),
 		cipherMode: requireAttr(keyData, "cipherChaining", "keyData"),
-		passwordIterations: requireInt(encryptedKey, "spinCount", "encryptedKey"),
+		passwordIterations: requireSpinCount(encryptedKey, "encryptedKey"),
 		passwordSalt: requireBase64(encryptedKey, "saltValue", "encryptedKey"),
 		passwordHash: requireAttr(encryptedKey, "hashAlgorithm", "encryptedKey"),
 		passwordKeyBits: requireInt(encryptedKey, "keyBits", "encryptedKey"),
@@ -125,4 +141,4 @@ const parseAgileEncryptionInfo = (stream) => {
 	});
 };
 //#endregion
-export { parseAgileEncryptionInfo };
+export { MAX_SPIN_COUNT, parseAgileEncryptionInfo };

package/dist/docx/encryption/openEncryptedDocx.js

@@ -1,9 +1,9 @@
 import { DOCX_ENCRYPTION_ERROR_CODES, DocxEncryptionError } from "./errors.js";
 import { toArrayBuffer } from "./cryptoBytes.js";
+import { parseAgileEncryptionInfo } from "./encryptionInfo.js";
 import { decryptAgileEncryptedPackage } from "./agileDecryption.js";
 import { readEncryptedPackageStreams } from "./compoundFile.js";
 import { DOCX_CONTAINER_TYPES, detectDocxContainerType } from "./containerFormat.js";
-import { parseAgileEncryptionInfo } from "./encryptionInfo.js";
 //#region src/docx/encryption/openEncryptedDocx.ts
 /**
 * Decrypt password-protected OOXML before ZIP extraction.

package/dist/docx/ensureParaIds.js

@@ -1,5 +1,6 @@
-import { isXmlNameBoundary } from "./selectiveXmlPatch.js";
 import { deterministicHexId } from "../utils/hexId.js";
+import { isXmlNameBoundary } from "./selectiveXmlPatch.js";
+import { loadDocxArchive } from "./server/boundedArchive.js";
 import { TaggedError } from "better-result";
 import JSZip from "jszip";
 //#region src/docx/ensureParaIds.ts
@@ -350,18 +351,17 @@ const hasDigitalSignatureParts = (zip) => Object.values(zip.files).some(({ dir,
 * the buffer is not a WordprocessingML package or a part is malformed.
 */
 const ensureParaIdsInternal = async (docx, options) => {
-	const zip = await JSZip.loadAsync(docx);
-	const xmlPartNames = [];
-	zip.forEach((relativePath, entry) => {
+	const archive = await loadDocxArchive(docx);
+	const xmlPartNames = archive.entries.filter((relativePath) => {
 		const lower = relativePath.toLowerCase();
-		if (!entry.dir && lower.startsWith("word/") && lower.endsWith(".xml")) xmlPartNames.push(relativePath);
+		return lower.startsWith("word/") && lower.endsWith(".xml");
 	});
 	const documentPartName = xmlPartNames.find((name) => name.toLowerCase() === DOCUMENT_PART);
 	if (documentPartName === void 0) throw createEnsureParaIdsError("word/document.xml not found: not a WordprocessingML package");
 	const partTexts = /* @__PURE__ */ new Map();
 	for (const name of xmlPartNames) {
-		const entry = zip.file(name);
-		if (entry) partTexts.set(name, await entry.async("text"));
+		const text = await archive.readEntryString(name);
+		if (text !== null) partTexts.set(name, text);
 	}
 	const taken = /* @__PURE__ */ new Set();
 	for (const text of partTexts.values()) collectExistingParaIds(text, taken);
@@ -390,6 +390,7 @@ const ensureParaIdsInternal = async (docx, options) => {
 		deduplicated: 0,
 		alreadyComplete: true
 	};
+	const zip = await JSZip.loadAsync(docx);
 	if (hasDigitalSignatureParts(zip) && options.allowSignedPackageMutation !== true) throw createEnsureParaIdsError("Refusing to normalize a digitally signed package because rewriting OOXML invalidates its signatures. Warn the user and pass allowSignedPackageMutation only if invalidation is acceptable.");
 	for (const [partPath, content] of updates) zip.file(partPath, content, {
 		compression: "DEFLATE",

package/dist/docx/fieldParser.js

@@ -1,5 +1,5 @@
-import { findChildren, getAttribute } from "./xmlParser.js";
 import { FieldTypeSchema, narrowEnum } from "./parserEnums.js";
+import { findChildren, getAttribute } from "./xmlParser.js";
 import { parseRun } from "./runParser.js";
 //#region src/docx/fieldParser.ts
 /**

package/dist/docx/groupDrawingParser.js

@@ -150,12 +150,17 @@ const groupViewBox = (group, width, height) => {
 	};
 };
 const createSvg = (group, width, height, rels, media) => {
-	const content = getChildElements(group).slice(0, MAX_GROUP_SHAPES).map((child, index) => {
+	const children = getChildElements(group).slice(0, MAX_GROUP_SHAPES);
+	let content = "";
+	for (const [index, child] of children.entries()) {
 		const localName = getLocalName(child.name ?? "");
-		if (localName === "pic") return renderPicture(child, index, rels, media);
-		if (localName !== "wsp") return "";
-		return findChildByLocalName(child, "txbx") ? renderTextBox(child) : renderGeometry(child);
-	}).join("");
+		let piece;
+		if (localName === "pic") piece = renderPicture(child, index, rels, media);
+		else if (localName === "wsp") piece = findChildByLocalName(child, "txbx") ? renderTextBox(child) : renderGeometry(child);
+		else continue;
+		content += piece;
+		if (content.length > MAX_SVG_CHARACTERS) return null;
+	}
 	if (!content) return null;
 	const viewBox = groupViewBox(group, width, height);
 	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox.x} ${viewBox.y} ${viewBox.width} ${viewBox.height}" width="${emuToPixels(width)}" height="${emuToPixels(height)}">${content}</svg>`;

package/dist/docx/hyperlinkParser.js

@@ -1,6 +1,6 @@
 import { getAttribute, getChildElements, mergeXmlnsDeclarations, parseNumericAttribute } from "./xmlParser.js";
-import { parseRun } from "./runParser.js";
 import { sanitizeExternalUrl, sanitizeLinkTarget } from "../utils/urlSecurity.js";
+import { parseRun } from "./runParser.js";
 //#region src/docx/hyperlinkParser.ts
 /**
 * Get the local name of an element (without namespace prefix)

package/dist/docx/imageParser.js

@@ -1,5 +1,7 @@
 import { findByFullName, findChild, getAttribute, getChildElements, parseNumericAttribute } from "./xmlParser.js";
 import { emuToPixels } from "../utils/units.js";
+import { sanitizeExternalUrl } from "../utils/urlSecurity.js";
+import { sanitizeImageSrc } from "../utils/sanitizeImageSrc.js";
 import { WRAP_ELEMENT_NAMES, parsePositionH, parsePositionV, parseWrapElement } from "./drawingUtils.js";
 import { resolveTarget } from "./relsParser.js";
 import { isTextBoxDrawing } from "./textBoxParser.js";
@@ -326,7 +328,8 @@ function parseInline(inlineEl, rels, media) {
 	if (props.alt) image.alt = props.alt;
 	if (props.title) image.title = props.title;
 	if (props.decorative) image.decorative = true;
-	if (imageData.src) image.src = imageData.src;
+	const safeSrc = sanitizeImageSrc(imageData.src);
+	if (safeSrc) image.src = safeSrc;
 	if (imageData.mimeType) image.mimeType = imageData.mimeType;
 	if (imageData.filename) image.filename = imageData.filename;
 	if (padding) image.padding = padding;
@@ -334,8 +337,8 @@ function parseInline(inlineEl, rels, media) {
 	if (crop) image.crop = crop;
 	if (opacity !== void 0) image.opacity = opacity;
 	if (props.hlinkRId && rels) {
-		const href = resolveTarget(rels, props.hlinkRId);
-		if (href) image.hlinkHref = href;
+		const safeHref = sanitizeExternalUrl(resolveTarget(rels, props.hlinkRId));
+		if (safeHref) image.hlinkHref = safeHref;
 	}
 	return image;
 }
@@ -391,7 +394,8 @@ function parseAnchor(anchorEl, rels, media) {
 	if (props.alt) image.alt = props.alt;
 	if (props.title) image.title = props.title;
 	if (props.decorative) image.decorative = true;
-	if (imageData.src) image.src = imageData.src;
+	const safeSrc = sanitizeImageSrc(imageData.src);
+	if (safeSrc) image.src = safeSrc;
 	if (imageData.mimeType) image.mimeType = imageData.mimeType;
 	if (imageData.filename) image.filename = imageData.filename;
 	if (position) image.position = position;
@@ -402,8 +406,8 @@ function parseAnchor(anchorEl, rels, media) {
 	if (layoutInCell !== void 0) image.layoutInCell = layoutInCell;
 	if (allowOverlap !== void 0) image.allowOverlap = allowOverlap;
 	if (props.hlinkRId && rels) {
-		const href = resolveTarget(rels, props.hlinkRId);
-		if (href) image.hlinkHref = href;
+		const safeHref = sanitizeExternalUrl(resolveTarget(rels, props.hlinkRId));
+		if (safeHref) image.hlinkHref = safeHref;
 	}
 	return image;
 }

package/dist/docx/metadataPrivacy.js

@@ -44,6 +44,20 @@ const XML_DECLARATION_PATTERN = /^\s*<\?xml[^?]*\?>/u;
 const MAX_INPUT_BYTES = 50 * 1024 * 1024;
 const MAX_ARCHIVE_ENTRIES = 5e3;
 const MAX_CORE_PROPERTIES_BYTES = 1024 * 1024;
+const CORE_PROPERTIES_PATH_LOWER = "docprops/core.xml";
+/**
+* Look up a package part by its conventional lowercase path, falling back to
+* a case-insensitive scan. OPC part names are case-insensitive, so a
+* producer that wrote `docProps/Core.xml` (or another casing) must still be
+* found — otherwise the privacy rewrite silently no-ops and the unscrubbed
+* buffer round-trips untouched.
+*/
+const findZipEntryCaseInsensitive = (zip, lowerPath) => {
+	const direct = zip.file(lowerPath);
+	if (direct) return direct;
+	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.toLowerCase() === lowerPath) return file;
+	return null;
+};
 const loadPrivacyArchive = async (buffer) => {
 	if (buffer.byteLength > MAX_INPUT_BYTES) throw new FolioDocumentPrivacyArchiveError({
 		message: "Document privacy input exceeded the compressed-size limit",
@@ -63,7 +77,7 @@ const loadPrivacyArchive = async (buffer) => {
 		message: "Document privacy input exceeded the package-entry limit",
 		reason: "too-many-entries"
 	});
-	const coreProperties = zip.file("docProps/core.xml");
+	const coreProperties = findZipEntryCaseInsensitive(zip, CORE_PROPERTIES_PATH_LOWER);
 	if (!coreProperties) return zip;
 	const data = "_data" in coreProperties ? coreProperties._data : void 0;
 	const declaredBytes = typeof data === "object" && data !== null && "uncompressedSize" in data ? data.uncompressedSize : void 0;
@@ -99,7 +113,7 @@ const rewriteCorePropertiesPrivacy = (xml, transforms) => {
 const rewriteDocxMetadataPrivacy = async (buffer, { transforms }) => {
 	const appliedTransforms = resolveFolioDocumentPrivacyTransforms(transforms);
 	const zip = await loadPrivacyArchive(buffer);
-	const coreProperties = zip.file("docProps/core.xml");
+	const coreProperties = findZipEntryCaseInsensitive(zip, CORE_PROPERTIES_PATH_LOWER);
 	if (!coreProperties) return {
 		buffer,
 		privacyReport: {
@@ -115,7 +129,7 @@ const rewriteDocxMetadataPrivacy = async (buffer, { transforms }) => {
 			removedMetadataProperties: []
 		}
 	};
-	zip.file("docProps/core.xml", rewritten.xml);
+	zip.file(coreProperties.name, rewritten.xml);
 	return {
 		buffer: await zip.generateAsync({
 			type: "arraybuffer",

package/dist/docx/notePropertiesParser.js

@@ -1,5 +1,5 @@
-import { findChild, getAttribute, parseNumericAttribute } from "./xmlParser.js";
 import { NumberFormatSchema, narrowEnum } from "./parserEnums.js";
+import { findChild, getAttribute, parseNumericAttribute } from "./xmlParser.js";
 //#region src/docx/notePropertiesParser.ts
 function parseNumberFormat(numFmtAttr) {
 	return narrowEnum(numFmtAttr, NumberFormatSchema);

package/dist/docx/numberingParser.js

@@ -1,5 +1,5 @@
-import { findChild, findChildren, getAttribute, parseBooleanElement, parseNumericAttribute, parseXmlDocument } from "./xmlParser.js";
 import { LevelSuffixSchema, ThemeColorSlotSchema, narrowEnum } from "./parserEnums.js";
+import { findChild, findChildren, getAttribute, parseBooleanElement, parseNumericAttribute, parseXmlDocument } from "./xmlParser.js";
 //#region src/docx/numberingParser.ts
 const NUMBER_FORMAT_MAP = {
 	decimal: "decimal",