@stll/anonymize-docx 0.0.1-placeholder.0 → 2.0.2

package/dist/index.mjs

@@ -0,0 +1,868 @@
+import { strToU8, unzipSync, zipSync } from "fflate";
+import { SaxesParser } from "saxes";
+//#region src/types.ts
+const DOCX_PART_TYPES = {
+	comments: "comments",
+	endnotes: "endnotes",
+	footer: "footer",
+	footnotes: "footnotes",
+	header: "header",
+	mainDocument: "main-document"
+};
+const DOCX_COVERAGE_MODES = {
+	allowPartial: "allow-partial",
+	requireFull: "require-full"
+};
+const DOCX_ANONYMIZATION_ERROR_CODES = {
+	incompleteCoverage: "incomplete-coverage",
+	invalidCallerDetections: "invalid-caller-detections",
+	sessionMismatch: "session-mismatch"
+};
+const DOCX_RESTORATION_ERROR_CODES = {
+	invalidPlaceholder: "invalid-placeholder",
+	invalidSession: "invalid-session",
+	restorationLimitExceeded: "restoration-limit-exceeded",
+	sessionMismatch: "session-mismatch"
+};
+const DOCX_REWRITE_ERROR_CODES = {
+	invalidReplacement: "invalid-replacement",
+	rewriteLimitExceeded: "rewrite-limit-exceeded",
+	staleExtraction: "stale-extraction",
+	unsupportedReplacement: "unsupported-replacement"
+};
+const DOCX_EXTRACTION_ERROR_CODES = {
+	archiveLimitExceeded: "archive-limit-exceeded",
+	invalidArchive: "invalid-archive",
+	invalidPackage: "invalid-package",
+	invalidXml: "invalid-xml",
+	unsafeEntryPath: "unsafe-entry-path",
+	uncompressedLimitExceeded: "uncompressed-limit-exceeded"
+};
+//#endregion
+//#region src/extract.ts
+const DOCX_EXTRACTION_CONTRACT_VERSION = 1;
+const DOCX_ARCHIVE_MAX_BYTES = 64 * 1024 * 1024;
+const DOCX_ENTRY_MAX_BYTES = 16 * 1024 * 1024;
+const DOCX_UNCOMPRESSED_MAX_BYTES = 128 * 1024 * 1024;
+const DOCX_XML_MAX_DEPTH = 256;
+const DOCX_MAX_ENTRIES = 4096;
+const DOCX_MAX_TEXT_BLOCKS = 1e5;
+const DOCX_MAX_TEXT_SEGMENTS = 1e6;
+const CONTENT_TYPES_PATH = "[Content_Types].xml";
+const ROOT_RELATIONSHIPS_PATH = "_rels/.rels";
+const CONTENT_TYPES_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/content-types";
+const PACKAGE_RELATIONSHIP_NAMESPACES = /* @__PURE__ */ new Set(["http://purl.oclc.org/ooxml/package/relationships", "http://schemas.openxmlformats.org/package/2006/relationships"]);
+const WORDPROCESSING_CONTENT_TYPE_PREFIX = "application/vnd.openxmlformats-officedocument.wordprocessingml.";
+const SUPPORTED_CONTENT_TYPE_SUFFIXES = {
+	"comments+xml": DOCX_PART_TYPES.comments,
+	"document.main+xml": DOCX_PART_TYPES.mainDocument,
+	"endnotes+xml": DOCX_PART_TYPES.endnotes,
+	"footer+xml": DOCX_PART_TYPES.footer,
+	"footnotes+xml": DOCX_PART_TYPES.footnotes,
+	"header+xml": DOCX_PART_TYPES.header
+};
+const WORDPROCESSING_NAMESPACES$1 = /* @__PURE__ */ new Set(["http://purl.oclc.org/ooxml/wordprocessingml/main", "http://schemas.openxmlformats.org/wordprocessingml/2006/main"]);
+const RELATIONSHIP_NAMESPACES = /* @__PURE__ */ new Set(["http://purl.oclc.org/ooxml/officeDocument/relationships", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"]);
+const OFFICE_DOCUMENT_RELATIONSHIP_TYPES = new Set([...RELATIONSHIP_NAMESPACES].map((namespace) => `${namespace}/officeDocument`));
+const MARKUP_COMPATIBILITY_NAMESPACES = /* @__PURE__ */ new Set(["http://purl.oclc.org/ooxml/markup-compatibility/main", "http://schemas.openxmlformats.org/markup-compatibility/2006"]);
+var DocxExtractionError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "DocxExtractionError";
+		this.code = code;
+	}
+};
+const invalidPackage = (message) => new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.invalidPackage, message);
+const assertXmlDepth = (depth) => {
+	if (depth < 256) return;
+	throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.uncompressedLimitExceeded, `DOCX XML must not exceed 256 nested elements`);
+};
+const safeEntryPath = (name) => name.length > 0 && !name.startsWith("/") && !name.includes("\\") && !name.split("/").includes("..") && !name.includes("\0");
+const archiveFilter = ({ budget, file, includeAllEntries }) => {
+	budget.entryCount += 1;
+	if (budget.entryCount > DOCX_MAX_ENTRIES) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.uncompressedLimitExceeded, `DOCX archives must contain at most ${DOCX_MAX_ENTRIES} entries`);
+	if (!safeEntryPath(file.name)) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.unsafeEntryPath, "DOCX archive contains an unsafe entry path");
+	if (file.originalSize > 16777216) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.uncompressedLimitExceeded, `DOCX entries must not exceed ${DOCX_ENTRY_MAX_BYTES} bytes`);
+	budget.uncompressedBytes += file.originalSize;
+	if (budget.uncompressedBytes > 134217728) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.uncompressedLimitExceeded, `DOCX archives must not exceed ${DOCX_UNCOMPRESSED_MAX_BYTES} uncompressed bytes`);
+	return includeAllEntries || file.name === CONTENT_TYPES_PATH || file.name === ROOT_RELATIONSHIPS_PATH || file.name.startsWith("word/") && file.name.endsWith(".xml");
+};
+const unzipDocxArchive = (archive, includeAllEntries = false) => {
+	if (archive.byteLength > 67108864) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.archiveLimitExceeded, `DOCX archives must not exceed ${DOCX_ARCHIVE_MAX_BYTES} bytes`);
+	const budget = {
+		entryCount: 0,
+		uncompressedBytes: 0
+	};
+	try {
+		return unzipSync(archive, { filter: (file) => archiveFilter({
+			budget,
+			file,
+			includeAllEntries
+		}) });
+	} catch (error) {
+		if (error instanceof DocxExtractionError) throw error;
+		throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.invalidArchive, "Input is not a valid bounded DOCX ZIP archive");
+	}
+};
+const decodeXml = (bytes, path) => {
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	} catch {
+		throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.invalidXml, `DOCX XML part is not valid UTF-8: ${path}`);
+	}
+};
+const attributeByLocalName = (tag, localName, namespaces) => {
+	for (const attribute of Object.values(tag.attributes)) if (attribute.local === localName && (namespaces === void 0 || namespaces.has(attribute.uri))) return attribute.value;
+	return null;
+};
+const parseContentTypes = (xml) => {
+	const parts = [];
+	const paths = /* @__PURE__ */ new Set();
+	const parser = new SaxesParser({ xmlns: true });
+	let parseError = null;
+	let depth = 0;
+	parser.on("error", (error) => {
+		parseError = error;
+	});
+	parser.on("doctype", () => {
+		throw invalidPackage("DOCX XML must not contain a document type declaration");
+	});
+	parser.on("opentag", (tag) => {
+		assertXmlDepth(depth);
+		depth += 1;
+		if (tag.local !== "Override" || tag.uri !== CONTENT_TYPES_NAMESPACE) return;
+		const rawPath = attributeByLocalName(tag, "PartName");
+		const contentType = attributeByLocalName(tag, "ContentType");
+		if (rawPath === null || contentType === null) throw invalidPackage("DOCX content-type override is incomplete");
+		const path = rawPath.startsWith("/") ? rawPath.slice(1) : rawPath;
+		if (!safeEntryPath(path)) throw invalidPackage("DOCX content-type override has an unsafe path");
+		if (paths.has(path)) throw invalidPackage("DOCX content-type overrides must have unique paths");
+		paths.add(path);
+		parts.push({
+			path,
+			contentType
+		});
+	});
+	parser.on("closetag", () => {
+		depth -= 1;
+	});
+	try {
+		parser.write(xml).close();
+	} catch (error) {
+		if (error instanceof DocxExtractionError) throw error;
+		parseError = error instanceof Error ? error : /* @__PURE__ */ new Error("invalid XML");
+	}
+	if (parseError !== null) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.invalidXml, "DOCX content types are not valid XML");
+	return parts;
+};
+const parseMainDocumentTarget = (xml) => {
+	const targets = [];
+	const parser = new SaxesParser({ xmlns: true });
+	let parseError = null;
+	let depth = 0;
+	parser.on("error", (error) => {
+		parseError = error;
+	});
+	parser.on("doctype", () => {
+		throw invalidPackage("DOCX XML must not contain a document type declaration");
+	});
+	parser.on("opentag", (tag) => {
+		assertXmlDepth(depth);
+		depth += 1;
+		if (tag.local !== "Relationship" || !PACKAGE_RELATIONSHIP_NAMESPACES.has(tag.uri)) return;
+		const type = attributeByLocalName(tag, "Type");
+		if (type === null || !OFFICE_DOCUMENT_RELATIONSHIP_TYPES.has(type)) return;
+		const targetMode = attributeByLocalName(tag, "TargetMode");
+		const rawTarget = attributeByLocalName(tag, "Target");
+		if (targetMode === "External" || rawTarget === null) throw invalidPackage("DOCX main-document relationship must be internal");
+		const target = rawTarget.startsWith("/") ? rawTarget.slice(1) : rawTarget;
+		if (!safeEntryPath(target) || target.includes(":")) throw invalidPackage("DOCX main-document relationship has an unsafe target");
+		targets.push(target);
+	});
+	parser.on("closetag", () => {
+		depth -= 1;
+	});
+	try {
+		parser.write(xml).close();
+	} catch (error) {
+		if (error instanceof DocxExtractionError) throw error;
+		parseError = error instanceof Error ? error : /* @__PURE__ */ new Error("invalid XML");
+	}
+	if (parseError !== null) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.invalidXml, "DOCX root relationships are not valid XML");
+	if (targets.length !== 1) throw invalidPackage("DOCX archive must contain exactly one main-document relationship");
+	const target = targets.at(0);
+	if (target === void 0) throw invalidPackage("DOCX main-document relationship is unavailable");
+	return target;
+};
+const classifyPart = ({ contentType, path }) => {
+	if (!contentType.startsWith(WORDPROCESSING_CONTENT_TYPE_PREFIX)) return null;
+	const suffix = contentType.slice(63);
+	const type = SUPPORTED_CONTENT_TYPE_SUFFIXES[suffix];
+	return type === void 0 ? null : {
+		type,
+		path
+	};
+};
+const isWordTag = (tag, local) => tag.local === local && WORDPROCESSING_NAMESPACES$1.has(tag.uri);
+const frameByLocalName = (stack, local) => {
+	for (let index = stack.length - 1; index >= 0; index -= 1) {
+		const frame = stack.at(index);
+		if (frame !== void 0 && isWordTag(frame.tag, local)) return frame;
+	}
+	return null;
+};
+const blockLocation = (part, blockIndex, paragraphPath, stack) => {
+	const textBox = frameByLocalName(stack, "txbxContent");
+	if (textBox !== null) return {
+		type: "text-box-paragraph",
+		part,
+		blockIndex,
+		xmlPath: paragraphPath,
+		textBoxPath: textBox.path
+	};
+	const cell = frameByLocalName(stack, "tc");
+	const row = frameByLocalName(stack, "tr");
+	const table = frameByLocalName(stack, "tbl");
+	if (cell !== null && row !== null && table !== null) return {
+		type: "table-cell-paragraph",
+		part,
+		blockIndex,
+		xmlPath: paragraphPath,
+		tablePath: table.path,
+		rowPath: row.path,
+		cellPath: cell.path
+	};
+	return {
+		type: "paragraph",
+		part,
+		blockIndex,
+		xmlPath: paragraphPath
+	};
+};
+const revisionForTag = (tag) => {
+	if (!WORDPROCESSING_NAMESPACES$1.has(tag.uri)) return null;
+	const revision = {
+		del: "deletion",
+		ins: "insertion",
+		moveFrom: "move-from",
+		moveTo: "move-to"
+	}[tag.local];
+	return revision === void 0 ? null : {
+		type: "revision",
+		revision
+	};
+};
+const inlineContexts = (stack) => {
+	const contexts = [];
+	for (const { tag } of stack) {
+		if (isWordTag(tag, "hyperlink")) contexts.push({
+			type: "hyperlink",
+			relationshipId: attributeByLocalName(tag, "id", RELATIONSHIP_NAMESPACES),
+			anchor: attributeByLocalName(tag, "anchor", WORDPROCESSING_NAMESPACES$1)
+		});
+		const revision = revisionForTag(tag);
+		if (revision !== null) contexts.push(revision);
+	}
+	return contexts;
+};
+const appendSegment = (block, budget, value, source, path, stack) => {
+	if (value.length === 0) return;
+	if (budget.segmentCount >= DOCX_MAX_TEXT_SEGMENTS) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.uncompressedLimitExceeded, `DOCX parts must not contain more than ${DOCX_MAX_TEXT_SEGMENTS} text segments`);
+	budget.segmentCount += 1;
+	const start = block.text.length;
+	block.text += value;
+	block.segments.push({
+		start,
+		end: block.text.length,
+		source,
+		contexts: inlineContexts(stack),
+		xmlPath: path
+	});
+};
+const extractPart = (part, xml) => {
+	const blocks = [];
+	const stack = [];
+	const blockStack = [];
+	let nextBlockIndex = 0;
+	let currentText = "";
+	let currentTextPath = null;
+	let parseError = null;
+	let unsupportedSymbolCount = 0;
+	let unsupportedFieldInstructionCount = 0;
+	let unsupportedAlternateContentCount = 0;
+	const textBudget = { segmentCount: 0 };
+	const parser = new SaxesParser({ xmlns: true });
+	parser.on("error", (error) => {
+		parseError = error;
+	});
+	parser.on("doctype", () => {
+		throw invalidPackage("DOCX XML must not contain a document type declaration");
+	});
+	parser.on("opentag", (tag) => {
+		assertXmlDepth(stack.length);
+		const parent = stack.at(-1);
+		const childIndex = parent?.nextChildIndex ?? 0;
+		if (parent !== void 0) parent.nextChildIndex += 1;
+		const path = [...parent?.path ?? [], childIndex];
+		if (isWordTag(tag, "p")) {
+			if (nextBlockIndex >= DOCX_MAX_TEXT_BLOCKS) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.uncompressedLimitExceeded, `DOCX parts must not contain more than ${DOCX_MAX_TEXT_BLOCKS} text blocks`);
+			blockStack.push({
+				text: "",
+				segments: [],
+				location: blockLocation(part, nextBlockIndex, path, stack)
+			});
+			nextBlockIndex += 1;
+		}
+		stack.push({
+			tag,
+			path,
+			nextChildIndex: 0
+		});
+		if (isWordTag(tag, "t") || isWordTag(tag, "delText")) {
+			currentText = "";
+			currentTextPath = path;
+		}
+		const currentBlock = blockStack.at(-1);
+		if (currentBlock !== void 0 && isWordTag(tag, "tab")) appendSegment(currentBlock, textBudget, "	", "tab", path, stack);
+		if (currentBlock !== void 0 && (isWordTag(tag, "br") || isWordTag(tag, "cr"))) appendSegment(currentBlock, textBudget, "\n", "break", path, stack);
+		if (isWordTag(tag, "sym")) unsupportedSymbolCount += 1;
+		if (isWordTag(tag, "instrText") || isWordTag(tag, "fldSimple")) unsupportedFieldInstructionCount += 1;
+		if (tag.local === "AlternateContent" && MARKUP_COMPATIBILITY_NAMESPACES.has(tag.uri)) unsupportedAlternateContentCount += 1;
+	});
+	parser.on("text", (text) => {
+		if (currentTextPath !== null) currentText += text;
+	});
+	parser.on("cdata", (text) => {
+		if (currentTextPath !== null) currentText += text;
+	});
+	parser.on("closetag", (tag) => {
+		const frame = stack.at(-1);
+		if (frame === void 0 || frame.tag !== tag) throw invalidPackage("DOCX XML element stack is inconsistent");
+		if (currentTextPath !== null && (isWordTag(tag, "t") || isWordTag(tag, "delText"))) {
+			const currentBlock = blockStack.at(-1);
+			if (currentBlock === void 0) {
+				if (currentText.length > 0) throw invalidPackage("DOCX text is outside a paragraph");
+			} else appendSegment(currentBlock, textBudget, currentText, "text", currentTextPath, stack);
+			currentText = "";
+			currentTextPath = null;
+		}
+		if (isWordTag(tag, "p")) {
+			const completedBlock = blockStack.pop();
+			if (completedBlock === void 0) throw invalidPackage("DOCX paragraph state is unavailable");
+			blocks.push(completedBlock);
+		}
+		stack.pop();
+	});
+	try {
+		parser.write(xml).close();
+	} catch (error) {
+		if (error instanceof DocxExtractionError) throw error;
+		parseError = error instanceof Error ? error : /* @__PURE__ */ new Error("invalid XML");
+	}
+	if (parseError !== null) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.invalidXml, `DOCX part is not valid XML: ${part.path}`);
+	blocks.sort((left, right) => left.location.blockIndex - right.location.blockIndex);
+	let hyperlinkTextSegmentCount = 0;
+	let revisionTextSegmentCount = 0;
+	for (const { segments } of blocks) for (const { contexts } of segments) {
+		if (contexts.some((context) => context.type === "hyperlink")) hyperlinkTextSegmentCount += 1;
+		if (contexts.some((context) => context.type === "revision")) revisionTextSegmentCount += 1;
+	}
+	return {
+		blocks,
+		hyperlinkTextSegmentCount,
+		revisionTextSegmentCount,
+		unsupportedAlternateContentCount,
+		unsupportedSymbolCount,
+		unsupportedFieldInstructionCount
+	};
+};
+const extractDocxText = (archive) => {
+	const entries = unzipDocxArchive(archive);
+	const contentTypesBytes = entries[CONTENT_TYPES_PATH];
+	if (contentTypesBytes === void 0) throw invalidPackage("DOCX archive is missing [Content_Types].xml");
+	const contentTypes = parseContentTypes(decodeXml(contentTypesBytes, CONTENT_TYPES_PATH));
+	const rootRelationshipsBytes = entries[ROOT_RELATIONSHIPS_PATH];
+	if (rootRelationshipsBytes === void 0) throw invalidPackage("DOCX archive is missing _rels/.rels");
+	const mainDocumentTarget = parseMainDocumentTarget(decodeXml(rootRelationshipsBytes, ROOT_RELATIONSHIPS_PATH));
+	const supportedParts = contentTypes.map(classifyPart).filter((part) => part !== null);
+	if (supportedParts.filter((part) => part.type === DOCX_PART_TYPES.mainDocument).length !== 1) throw invalidPackage("DOCX archive must contain exactly one main document");
+	if (supportedParts.find((part) => part.type === DOCX_PART_TYPES.mainDocument)?.path !== mainDocumentTarget) throw invalidPackage("DOCX main-document relationship and content type do not agree");
+	const blocks = [];
+	const coverageParts = [];
+	let hyperlinkTextSegmentCount = 0;
+	let revisionTextSegmentCount = 0;
+	let unsupportedSymbolCount = 0;
+	let unsupportedFieldInstructionCount = 0;
+	let unsupportedAlternateContentCount = 0;
+	let textSegmentCount = 0;
+	for (const part of supportedParts) {
+		const bytes = entries[part.path];
+		if (bytes === void 0) throw invalidPackage(`DOCX archive is missing declared part: ${part.path}`);
+		const extracted = extractPart(part, decodeXml(bytes, part.path));
+		if (blocks.length + extracted.blocks.length > DOCX_MAX_TEXT_BLOCKS) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.uncompressedLimitExceeded, `DOCX archives must not contain more than ${DOCX_MAX_TEXT_BLOCKS} text blocks`);
+		const extractedSegmentCount = extracted.blocks.reduce((count, block) => count + block.segments.length, 0);
+		if (textSegmentCount + extractedSegmentCount > DOCX_MAX_TEXT_SEGMENTS) throw new DocxExtractionError(DOCX_EXTRACTION_ERROR_CODES.uncompressedLimitExceeded, `DOCX archives must not contain more than ${DOCX_MAX_TEXT_SEGMENTS} text segments`);
+		textSegmentCount += extractedSegmentCount;
+		blocks.push(...extracted.blocks);
+		coverageParts.push({
+			status: "extracted",
+			part,
+			blockCount: extracted.blocks.length
+		});
+		hyperlinkTextSegmentCount += extracted.hyperlinkTextSegmentCount;
+		revisionTextSegmentCount += extracted.revisionTextSegmentCount;
+		unsupportedSymbolCount += extracted.unsupportedSymbolCount;
+		unsupportedFieldInstructionCount += extracted.unsupportedFieldInstructionCount;
+		unsupportedAlternateContentCount += extracted.unsupportedAlternateContentCount;
+	}
+	for (const { contentType, path } of contentTypes) if (contentType.startsWith(WORDPROCESSING_CONTENT_TYPE_PREFIX) && classifyPart({
+		contentType,
+		path
+	}) === null) coverageParts.push({
+		status: "unsupported",
+		path,
+		contentType,
+		reason: "WordprocessingML part type is not extracted"
+	});
+	return {
+		contractVersion: 1,
+		blocks,
+		coverage: {
+			parts: coverageParts,
+			hyperlinkTextSegmentCount,
+			revisionTextSegmentCount,
+			unsupportedAlternateContentCount,
+			unsupportedSymbolCount,
+			unsupportedFieldInstructionCount
+		}
+	};
+};
+//#endregion
+//#region src/location.ts
+const arraysEqual = (left, right) => left.length === right.length && left.every((value, index) => value === right.at(index));
+const docxLocationsEqual = (left, right) => {
+	if (left.type !== right.type || left.part.type !== right.part.type || left.part.path !== right.part.path || left.blockIndex !== right.blockIndex || !arraysEqual(left.xmlPath, right.xmlPath)) return false;
+	if (left.type === "paragraph" && right.type === "paragraph") return true;
+	if (left.type === "table-cell-paragraph" && right.type === "table-cell-paragraph") return arraysEqual(left.tablePath, right.tablePath) && arraysEqual(left.rowPath, right.rowPath) && arraysEqual(left.cellPath, right.cellPath);
+	if (left.type === "text-box-paragraph" && right.type === "text-box-paragraph") return arraysEqual(left.textBoxPath, right.textBoxPath);
+	return false;
+};
+const docxLocationKey = ({ blockIndex, part }) => `${part.path}\0${blockIndex}`;
+//#endregion
+//#region src/rewrite.ts
+const WORDPROCESSING_NAMESPACES = /* @__PURE__ */ new Set(["http://purl.oclc.org/ooxml/wordprocessingml/main", "http://schemas.openxmlformats.org/wordprocessingml/2006/main"]);
+const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+const DOCX_MAX_REPLACEMENTS = 1e6;
+const SIGNATURE_PART_PREFIX = "_xmlsignatures/";
+var DocxRewriteError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "DocxRewriteError";
+		this.code = code;
+	}
+};
+const rewriteError = (code, message) => new DocxRewriteError(code, message);
+const pathKey = (path) => path.join(".");
+const isValidXmlText = (value) => {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint === void 0 || codePoint !== 9 && codePoint !== 10 && codePoint !== 13 && (codePoint < 32 || codePoint > 55295 && codePoint < 57344 || codePoint > 65533 && codePoint < 65536 || codePoint > 1114111)) return false;
+	}
+	return true;
+};
+const isUtf16Boundary = (value, offset) => {
+	if (offset === 0 || offset === value.length) return true;
+	const previous = value.charCodeAt(offset - 1);
+	const next = value.charCodeAt(offset);
+	return !(previous >= 55296 && previous <= 56319 && next >= 56320 && next <= 57343);
+};
+const validateReplacement = (replacement, blockText) => {
+	if (!Number.isSafeInteger(replacement.start) || !Number.isSafeInteger(replacement.end) || replacement.start < 0 || replacement.start >= replacement.end || replacement.end > blockText.length || !isUtf16Boundary(blockText, replacement.start) || !isUtf16Boundary(blockText, replacement.end)) throw rewriteError(DOCX_REWRITE_ERROR_CODES.invalidReplacement, "DOCX replacement spans must be nonempty bounded integer ranges at UTF-16 boundaries");
+	if (!isValidXmlText(replacement.replacement)) throw rewriteError(DOCX_REWRITE_ERROR_CODES.invalidReplacement, "DOCX replacement text must contain only valid XML characters");
+	if (strToU8(replacement.replacement).byteLength > 16777216) throw rewriteError(DOCX_REWRITE_ERROR_CODES.rewriteLimitExceeded, `DOCX replacement text must not exceed ${DOCX_ENTRY_MAX_BYTES} UTF-8 bytes`);
+};
+const coveredTextSegments = (block, replacement) => {
+	const segments = block.segments.filter(({ end, start }) => start < replacement.end && end > replacement.start);
+	let cursor = replacement.start;
+	for (const segment of segments) {
+		if (segment.source !== "text" || segment.start > cursor || segment.contexts.some((context) => context.type === "revision")) throw rewriteError(DOCX_REWRITE_ERROR_CODES.unsupportedReplacement, "DOCX replacements must stay within contiguous non-revision text segments");
+		cursor = Math.min(replacement.end, segment.end);
+	}
+	if (segments.length === 0 || cursor !== replacement.end) throw rewriteError(DOCX_REWRITE_ERROR_CODES.unsupportedReplacement, "DOCX replacements must stay within contiguous non-revision text segments");
+	return segments;
+};
+const planBlockUpdates = (block, rewrite) => {
+	const replacements = [...rewrite.replacements].sort((left, right) => left.start - right.start);
+	for (const [index, replacement] of replacements.entries()) {
+		validateReplacement(replacement, block.text);
+		const previous = index === 0 ? void 0 : replacements.at(index - 1);
+		if (previous !== void 0 && previous.end > replacement.start) throw rewriteError(DOCX_REWRITE_ERROR_CODES.invalidReplacement, "DOCX replacement spans must not overlap");
+	}
+	const values = /* @__PURE__ */ new Map();
+	const originalValues = /* @__PURE__ */ new Map();
+	for (const segment of block.segments) {
+		if (segment.source !== "text") continue;
+		values.set(pathKey(segment.xmlPath), {
+			path: segment.xmlPath,
+			value: block.text.slice(segment.start, segment.end)
+		});
+		originalValues.set(pathKey(segment.xmlPath), block.text.slice(segment.start, segment.end));
+	}
+	for (const replacement of replacements.toReversed()) {
+		const segments = coveredTextSegments(block, replacement);
+		const first = segments.at(0);
+		const last = segments.at(-1);
+		if (first === void 0 || last === void 0) throw rewriteError(DOCX_REWRITE_ERROR_CODES.unsupportedReplacement, "DOCX replacement text segments are unavailable");
+		const firstUpdate = values.get(pathKey(first.xmlPath));
+		const lastUpdate = values.get(pathKey(last.xmlPath));
+		if (firstUpdate === void 0 || lastUpdate === void 0) throw rewriteError(DOCX_REWRITE_ERROR_CODES.unsupportedReplacement, "DOCX replacement text nodes are unavailable");
+		const firstStart = replacement.start - first.start;
+		const lastEnd = replacement.end - last.start;
+		if (first === last) {
+			firstUpdate.value = firstUpdate.value.slice(0, firstStart) + replacement.replacement + firstUpdate.value.slice(lastEnd);
+			continue;
+		}
+		firstUpdate.value = firstUpdate.value.slice(0, firstStart) + replacement.replacement;
+		for (const segment of segments.slice(1, -1)) {
+			const update = values.get(pathKey(segment.xmlPath));
+			if (update !== void 0) update.value = "";
+		}
+		lastUpdate.value = lastUpdate.value.slice(lastEnd);
+	}
+	return [...values.entries()].filter(([key, update]) => update.value !== originalValues.get(key)).map(([, update]) => update);
+};
+const escapeXmlText = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const requiresPreservedSpace = (value) => /^\s|\s$/u.test(value);
+const isWordTextTag = (tag) => WORDPROCESSING_NAMESPACES.has(tag.uri) && (tag.local === "t" || tag.local === "delText");
+const hasPreservedSpace = (tag) => Object.values(tag.attributes).some((attribute) => attribute.uri === XML_NAMESPACE && attribute.local === "space" && attribute.value === "preserve");
+const findClosingTagStart = ({ xml, contentStart, parserPosition }) => {
+	for (let index = parserPosition - 1; index >= contentStart; index -= 1) if (xml[index] === "<" && xml[index + 1] === "/") return index;
+	throw rewriteError(DOCX_REWRITE_ERROR_CODES.staleExtraction, "DOCX text-node closing tag changed after extraction");
+};
+const rewritePartXml = (xml, updates) => {
+	const updatesByPath = new Map(updates.map((update) => [pathKey(update.path), update]));
+	const foundPaths = /* @__PURE__ */ new Set();
+	const patches = [];
+	const stack = [];
+	let activeText;
+	let parseError = null;
+	const parser = new SaxesParser({ xmlns: true });
+	parser.on("error", (error) => {
+		parseError = error;
+	});
+	parser.on("opentag", (tag) => {
+		if (stack.length >= 256) throw rewriteError(DOCX_REWRITE_ERROR_CODES.rewriteLimitExceeded, `DOCX XML must not exceed 256 nested elements`);
+		const parent = stack.at(-1);
+		const childIndex = parent?.nextChildIndex ?? 0;
+		if (parent !== void 0) parent.nextChildIndex += 1;
+		const path = [...parent?.path ?? [], childIndex];
+		stack.push({
+			path,
+			nextChildIndex: 0
+		});
+		const key = pathKey(path);
+		if (isWordTextTag(tag) && updatesByPath.has(key)) {
+			if (tag.isSelfClosing) throw rewriteError(DOCX_REWRITE_ERROR_CODES.unsupportedReplacement, "DOCX self-closing text nodes cannot receive replacements");
+			activeText = {
+				key,
+				contentStart: parser.position,
+				tag
+			};
+		}
+	});
+	parser.on("closetag", (tag) => {
+		if (activeText?.tag === tag) {
+			const update = updatesByPath.get(activeText.key);
+			if (update !== void 0) {
+				const contentEnd = findClosingTagStart({
+					xml,
+					contentStart: activeText.contentStart,
+					parserPosition: parser.position
+				});
+				patches.push({
+					start: activeText.contentStart,
+					end: contentEnd,
+					value: escapeXmlText(update.value)
+				});
+				if (requiresPreservedSpace(update.value) && !hasPreservedSpace(tag)) patches.push({
+					start: activeText.contentStart - 1,
+					end: activeText.contentStart - 1,
+					value: " xml:space=\"preserve\""
+				});
+				foundPaths.add(activeText.key);
+			}
+			activeText = void 0;
+		}
+		stack.pop();
+	});
+	try {
+		parser.write(xml).close();
+	} catch (error) {
+		if (error instanceof DocxRewriteError) throw error;
+		parseError = error instanceof Error ? error : /* @__PURE__ */ new Error("invalid XML");
+	}
+	if (parseError !== null) throw rewriteError(DOCX_REWRITE_ERROR_CODES.unsupportedReplacement, "DOCX source XML changed after extraction");
+	if (foundPaths.size !== updatesByPath.size) throw rewriteError(DOCX_REWRITE_ERROR_CODES.staleExtraction, "DOCX text-node locations changed after extraction");
+	let rewritten = xml;
+	for (const patch of patches.toSorted((left, right) => right.start - left.start)) rewritten = rewritten.slice(0, patch.start) + patch.value + rewritten.slice(patch.end);
+	return rewritten;
+};
+const assertArchiveBudgets = (entries) => {
+	let totalBytes = 0;
+	for (const bytes of Object.values(entries)) {
+		if (bytes.byteLength > 16777216) throw rewriteError(DOCX_REWRITE_ERROR_CODES.rewriteLimitExceeded, `Rewritten DOCX entries must not exceed ${DOCX_ENTRY_MAX_BYTES} bytes`);
+		totalBytes += bytes.byteLength;
+	}
+	if (totalBytes > 134217728) throw rewriteError(DOCX_REWRITE_ERROR_CODES.rewriteLimitExceeded, `Rewritten DOCX archives must not exceed ${DOCX_UNCOMPRESSED_MAX_BYTES} uncompressed bytes`);
+};
+const rewriteDocxText = (archive, rewrites) => {
+	const extraction = extractDocxText(archive);
+	if (rewrites.length === 0) return {
+		document: archive.slice(),
+		rewrittenBlockCount: 0,
+		appliedReplacementCount: 0
+	};
+	const blocksByLocation = new Map(extraction.blocks.map((block) => [docxLocationKey(block.location), block]));
+	const updatesByPart = /* @__PURE__ */ new Map();
+	const rewrittenLocations = /* @__PURE__ */ new Set();
+	let appliedReplacementCount = 0;
+	for (const rewrite of rewrites) {
+		const key = docxLocationKey(rewrite.location);
+		if (rewrittenLocations.has(key)) throw rewriteError(DOCX_REWRITE_ERROR_CODES.invalidReplacement, "Each DOCX block may appear in a rewrite plan only once");
+		rewrittenLocations.add(key);
+		const block = blocksByLocation.get(key);
+		if (block === void 0 || !docxLocationsEqual(block.location, rewrite.location) || block.text !== rewrite.expectedText) throw rewriteError(DOCX_REWRITE_ERROR_CODES.staleExtraction, "DOCX block location or expected text no longer matches");
+		if (rewrite.replacements.length === 0) throw rewriteError(DOCX_REWRITE_ERROR_CODES.invalidReplacement, "DOCX block rewrite plans must contain at least one replacement");
+		if (appliedReplacementCount + rewrite.replacements.length > DOCX_MAX_REPLACEMENTS) throw rewriteError(DOCX_REWRITE_ERROR_CODES.rewriteLimitExceeded, `DOCX rewrites must not contain more than ${DOCX_MAX_REPLACEMENTS} replacements`);
+		const partUpdates = updatesByPart.get(block.location.part.path) ?? /* @__PURE__ */ new Map();
+		for (const update of planBlockUpdates(block, rewrite)) partUpdates.set(pathKey(update.path), update);
+		updatesByPart.set(block.location.part.path, partUpdates);
+		appliedReplacementCount += rewrite.replacements.length;
+	}
+	const entries = unzipDocxArchive(archive, true);
+	if (Object.keys(entries).some((path) => path.toLowerCase().startsWith(SIGNATURE_PART_PREFIX))) throw rewriteError(DOCX_REWRITE_ERROR_CODES.unsupportedReplacement, "Digitally signed DOCX packages must be re-signed before rewriting");
+	for (const [partPath, updates] of updatesByPart) {
+		const partBytes = entries[partPath];
+		if (partBytes === void 0) throw rewriteError(DOCX_REWRITE_ERROR_CODES.staleExtraction, "DOCX source part changed after extraction");
+		const xml = new TextDecoder("utf-8", { fatal: true }).decode(partBytes);
+		entries[partPath] = strToU8(rewritePartXml(xml, [...updates.values()]));
+	}
+	assertArchiveBudgets(entries);
+	const document = zipSync(entries);
+	if (document.byteLength > 67108864) throw rewriteError(DOCX_REWRITE_ERROR_CODES.rewriteLimitExceeded, `Rewritten DOCX archives must not exceed ${DOCX_ARCHIVE_MAX_BYTES} bytes`);
+	return {
+		document,
+		rewrittenBlockCount: rewrites.length,
+		appliedReplacementCount
+	};
+};
+//#endregion
+//#region src/coverage.ts
+const hasPartialCoverage = (coverage) => coverage.parts.some(({ status }) => status === "unsupported") || coverage.hyperlinkTextSegmentCount > 0 || coverage.revisionTextSegmentCount > 0 || coverage.unsupportedAlternateContentCount > 0 || coverage.unsupportedSymbolCount > 0 || coverage.unsupportedFieldInstructionCount > 0;
+const docxWorkflowCoverage = (coverage) => {
+	const counts = {
+		extractedPartCount: coverage.parts.filter(({ status }) => status === "extracted").length,
+		unsupportedPartCount: coverage.parts.filter(({ status }) => status === "unsupported").length,
+		hyperlinkTextSegmentCount: coverage.hyperlinkTextSegmentCount,
+		revisionTextSegmentCount: coverage.revisionTextSegmentCount,
+		unsupportedAlternateContentCount: coverage.unsupportedAlternateContentCount,
+		unsupportedSymbolCount: coverage.unsupportedSymbolCount,
+		unsupportedFieldInstructionCount: coverage.unsupportedFieldInstructionCount
+	};
+	return hasPartialCoverage(coverage) ? {
+		status: "partial",
+		counts
+	} : {
+		status: "full",
+		counts
+	};
+};
+//#endregion
+//#region src/restore.ts
+const DOCX_RESTORE_MAX_PLACEHOLDER_UTF16 = 512;
+const DOCX_RESTORE_MAX_CANDIDATES = 1e6;
+var DocxRestorationError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "DocxRestorationError";
+		this.code = code;
+	}
+};
+const restorationError = (code, message) => new DocxRestorationError(code, message);
+const encodedSessionNamespace = (sessionId) => sessionId.replaceAll("_", "%5F");
+const isOwnedPlaceholderCandidate = (value, encodedSessionId) => {
+	const inner = value.endsWith("]") ? value.slice(0, -1) : value;
+	const countSeparator = inner.lastIndexOf("_");
+	if (countSeparator <= 0) return false;
+	const prefix = inner.slice(0, countSeparator);
+	const namespaceSeparator = prefix.lastIndexOf("_");
+	if (namespaceSeparator <= 0) return false;
+	return prefix.slice(namespaceSeparator + 1) === encodedSessionId;
+};
+const planBlockRestoration = ({ text, encodedSessionId, restoreCandidate, budget }) => {
+	const replacements = [];
+	let start;
+	for (let cursor = 0; cursor < text.length; cursor += 1) {
+		const character = text.at(cursor);
+		if (character === "[") {
+			if (start !== void 0 && isOwnedPlaceholderCandidate(text.slice(start + 1, cursor), encodedSessionId)) throw restorationError(DOCX_RESTORATION_ERROR_CODES.invalidPlaceholder, "DOCX text contains an incomplete placeholder for the expected session");
+			start = cursor;
+			continue;
+		}
+		if (character !== "]" || start === void 0) continue;
+		const candidateEnd = cursor + 1;
+		const candidate = text.slice(start, candidateEnd);
+		budget.candidateCount += 1;
+		if (budget.candidateCount > DOCX_RESTORE_MAX_CANDIDATES) throw restorationError(DOCX_RESTORATION_ERROR_CODES.restorationLimitExceeded, `DOCX restoration must not inspect more than ${DOCX_RESTORE_MAX_CANDIDATES} placeholder candidates`);
+		const isOwned = isOwnedPlaceholderCandidate(candidate.slice(1), encodedSessionId);
+		if (candidate.length > DOCX_RESTORE_MAX_PLACEHOLDER_UTF16) {
+			if (isOwned) throw restorationError(DOCX_RESTORATION_ERROR_CODES.invalidPlaceholder, "DOCX session placeholder exceeds the maximum length");
+			start = void 0;
+			continue;
+		}
+		if (!isOwned) {
+			start = void 0;
+			continue;
+		}
+		const replacement = restoreCandidate(candidate);
+		if (replacement !== candidate) replacements.push({
+			start,
+			end: candidateEnd,
+			replacement
+		});
+		else throw restorationError(DOCX_RESTORATION_ERROR_CODES.invalidPlaceholder, "DOCX text contains an unknown placeholder for the expected session");
+		start = void 0;
+	}
+	if (start !== void 0 && isOwnedPlaceholderCandidate(text.slice(start + 1), encodedSessionId)) throw restorationError(DOCX_RESTORATION_ERROR_CODES.invalidPlaceholder, "DOCX text contains an incomplete placeholder for the expected session");
+	return replacements;
+};
+const restoreDocxText = ({ document, session, expectedSessionId, observedAtEpochSeconds }) => {
+	const sessionId = session.sessionId();
+	if (sessionId !== expectedSessionId) throw restorationError(DOCX_RESTORATION_ERROR_CODES.sessionMismatch, "DOCX restoration session does not match the expected session id");
+	const assertSessionAvailable = () => {
+		if (session.restoreText("", observedAtEpochSeconds) !== "") throw restorationError(DOCX_RESTORATION_ERROR_CODES.invalidSession, "DOCX restoration session must preserve text without placeholders");
+	};
+	assertSessionAvailable();
+	const restoredCandidates = /* @__PURE__ */ new Map();
+	const restoreCandidate = (candidate) => {
+		const cached = restoredCandidates.get(candidate);
+		if (cached !== void 0) return cached;
+		const restored = session.restoreText(candidate, observedAtEpochSeconds);
+		restoredCandidates.set(candidate, restored);
+		return restored;
+	};
+	const encodedSessionId = encodedSessionNamespace(sessionId);
+	const extraction = extractDocxText(document);
+	const rewrites = [];
+	const budget = { candidateCount: 0 };
+	let restoredPlaceholderCount = 0;
+	for (const block of extraction.blocks) {
+		const replacements = planBlockRestoration({
+			text: block.text,
+			encodedSessionId,
+			restoreCandidate,
+			budget
+		});
+		if (replacements.length === 0) continue;
+		restoredPlaceholderCount += replacements.length;
+		rewrites.push({
+			location: block.location,
+			expectedText: block.text,
+			replacements
+		});
+	}
+	assertSessionAvailable();
+	const restored = rewriteDocxText(document, rewrites);
+	return {
+		document: restored.document,
+		sessionId,
+		restoredBlockCount: restored.rewrittenBlockCount,
+		restoredPlaceholderCount,
+		coverage: docxWorkflowCoverage(extraction.coverage)
+	};
+};
+//#endregion
+//#region src/anonymize.ts
+const DOCX_ANONYMIZATION_MAX_CALLER_DETECTIONS = 1e6;
+var DocxAnonymizationError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "DocxAnonymizationError";
+		this.code = code;
+	}
+};
+const anonymizationError = (code, message) => new DocxAnonymizationError(code, message);
+const planCallerDetections = (extractionBlocks, inputs) => {
+	const blocksByLocation = new Map(extractionBlocks.map((block) => [docxLocationKey(block.location), block]));
+	const detectionsByLocation = /* @__PURE__ */ new Map();
+	let callerDetectionCount = 0;
+	for (const input of inputs) {
+		const key = docxLocationKey(input.location);
+		if (detectionsByLocation.has(key)) throw anonymizationError(DOCX_ANONYMIZATION_ERROR_CODES.invalidCallerDetections, "Each DOCX block may have only one caller-detection input");
+		const block = blocksByLocation.get(key);
+		if (block === void 0 || !docxLocationsEqual(block.location, input.location) || block.text !== input.expectedText) throw anonymizationError(DOCX_ANONYMIZATION_ERROR_CODES.invalidCallerDetections, "DOCX caller-detection location or expected text no longer matches");
+		if (input.detections.length > 1e6 - callerDetectionCount) throw anonymizationError(DOCX_ANONYMIZATION_ERROR_CODES.invalidCallerDetections, `DOCX workflows must not contain more than ${DOCX_ANONYMIZATION_MAX_CALLER_DETECTIONS} caller detections`);
+		detectionsByLocation.set(key, input);
+		callerDetectionCount += input.detections.length;
+	}
+	return {
+		detectionsByLocation,
+		callerDetectionCount
+	};
+};
+const anonymizeDocx = ({ document, session, expectedSessionId, policy, callerDetections = [], observedAtEpochSeconds }) => {
+	const sessionId = session.sessionId();
+	if (sessionId !== expectedSessionId) throw anonymizationError(DOCX_ANONYMIZATION_ERROR_CODES.sessionMismatch, "DOCX anonymization session does not match the expected session");
+	const extraction = extractDocxText(document);
+	const coverage = docxWorkflowCoverage(extraction.coverage);
+	if (coverage.status === "partial" && policy.coverage.mode === DOCX_COVERAGE_MODES.requireFull) throw anonymizationError(DOCX_ANONYMIZATION_ERROR_CODES.incompleteCoverage, "DOCX contains content outside the fully supported anonymization coverage");
+	const { detectionsByLocation, callerDetectionCount } = planCallerDetections(extraction.blocks, callerDetections);
+	const plan = session.planTextBatchWithCallerDetections({
+		inputs: extraction.blocks.map((block) => ({
+			fullText: block.text,
+			detections: detectionsByLocation.get(docxLocationKey(block.location))?.detections ?? []
+		})),
+		...policy.operators === void 0 ? {} : { operators: policy.operators },
+		...observedAtEpochSeconds === void 0 ? {} : { observedAtEpochSeconds }
+	});
+	if (plan.blocks.length !== extraction.blocks.length) throw anonymizationError(DOCX_ANONYMIZATION_ERROR_CODES.invalidCallerDetections, "DOCX session redaction plan does not match the extracted block count");
+	const rewrites = [];
+	let entityCount = 0;
+	let retainedCallerDetectionCount = 0;
+	for (const [index, block] of extraction.blocks.entries()) {
+		const blockPlan = plan.blocks.at(index);
+		if (blockPlan === void 0) throw anonymizationError(DOCX_ANONYMIZATION_ERROR_CODES.invalidCallerDetections, "DOCX session redaction plan is missing an extracted block");
+		entityCount += blockPlan.entityCount;
+		retainedCallerDetectionCount += blockPlan.callerEntityCount;
+		if (blockPlan.replacements.length === 0) continue;
+		rewrites.push({
+			location: block.location,
+			expectedText: block.text,
+			replacements: blockPlan.replacements
+		});
+	}
+	const rewritten = rewriteDocxText(document, rewrites);
+	plan.commit();
+	return {
+		document: rewritten.document,
+		summary: {
+			contractVersion: 1,
+			sessionId,
+			blockCount: extraction.blocks.length,
+			rewrittenBlockCount: rewritten.rewrittenBlockCount,
+			appliedReplacementCount: rewritten.appliedReplacementCount,
+			entityCount,
+			callerDetectionCount,
+			retainedCallerDetectionCount,
+			coverage
+		}
+	};
+};
+//#endregion
+export { DOCX_ANONYMIZATION_ERROR_CODES, DOCX_ANONYMIZATION_MAX_CALLER_DETECTIONS, DOCX_ARCHIVE_MAX_BYTES, DOCX_COVERAGE_MODES, DOCX_ENTRY_MAX_BYTES, DOCX_EXTRACTION_CONTRACT_VERSION, DOCX_EXTRACTION_ERROR_CODES, DOCX_PART_TYPES, DOCX_RESTORATION_ERROR_CODES, DOCX_REWRITE_ERROR_CODES, DOCX_UNCOMPRESSED_MAX_BYTES, DOCX_XML_MAX_DEPTH, DocxAnonymizationError, DocxExtractionError, DocxRestorationError, DocxRewriteError, anonymizeDocx, extractDocxText, restoreDocxText, rewriteDocxText };
+
+//# sourceMappingURL=index.mjs.map