@office-open/docx 0.6.4 → 0.6.5

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { i as __toCommonJS, n as __exportAll, r as __reExport, t as __esmMin } from "./chunk-090QGkrx.mjs";
-import { AppProperties, BaseXmlComponent, BuilderElement, BuilderElement as BuilderElement$1, EMPTY_OBJECT, EmptyElement, Formatter, IgnoreIfEmptyXmlComponent, ImportedRootElementAttributes, ImportedXmlComponent, InitializableXmlComponent, NextAttributeComponent, OoxmlMimeType, PrettifyType, RawPassthrough, Relationships, TargetModeType, XmlAttributeComponent, XmlAttributeComponent as XmlAttributeComponent$1, XmlComponent, ZIP_STORED_LEVEL, addSmartArtRelationships, attrObj, chartAttr, convertEmuToPixels, convertInchesToTwip, convertMillimetersToTwip, convertPixelsToEmu, convertToXmlComponent, createDefault, createOverride, createPacker, getReferencedMedia, hasPlaceholders, hashedId, hpsMeasureObj, hpsMeasureObj as hpsMeasureObj$1, numberValObj, numberValObj as numberValObj$1, onOffObj, onOffObj as onOffObj$1, parseArchive, parseCorePropsElement, replaceChartPlaceholders, replaceImagePlaceholders, replaceSmartArtPlaceholders, strFromU8, stringContainerObj, stringEnumValObj, stringEnumValObj as stringEnumValObj$1, stringValObj, stringValObj as stringValObj$1, uniqueId, uniqueNumericIdCreator, uniqueNumericIdCreator as uniqueNumericIdCreator$1, uniqueUuid, unzipSync, wrapEl, xsdVerticalMergeRev, zipAndConvert } from "@office-open/core";
+import { AppProperties, BaseXmlComponent, BuilderElement, BuilderElement as BuilderElement$1, DOCX_NS, EMPTY_OBJECT, EmptyElement, Formatter, Formatter as Formatter$1, IgnoreIfEmptyXmlComponent, ImportedRootElementAttributes, ImportedXmlComponent, InitializableXmlComponent, NextAttributeComponent, OoxmlMimeType, PrettifyType, RawPassthrough, Relationships, TargetModeType, XmlAttributeComponent, XmlAttributeComponent as XmlAttributeComponent$1, XmlComponent, ZIP_STORED_LEVEL, addSmartArtRelationships, appendContentType, appendRelationship, attrObj, chartAttr, convertEmuToPixels, convertInchesToTwip, convertMillimetersToTwip, convertPixelsToEmu, convertToXmlComponent, createDefault, createOverride, createPacker, createReplacer, createTraverser, getNextRelationshipIndex, getReferencedMedia, hasPlaceholders, hashedId, hpsMeasureObj, hpsMeasureObj as hpsMeasureObj$1, numberValObj, numberValObj as numberValObj$1, onOffObj, onOffObj as onOffObj$1, parseArchive, parseCorePropsElement, replaceChartPlaceholders, replaceImagePlaceholders, replaceSmartArtPlaceholders, strFromU8, stringContainerObj, stringEnumValObj, stringEnumValObj as stringEnumValObj$1, stringValObj, stringValObj as stringValObj$1, toJson, uniqueId, uniqueNumericIdCreator, uniqueNumericIdCreator as uniqueNumericIdCreator$1, uniqueUuid, unzipSync, wrapEl, xsdVerticalMergeRev, zipAndConvert } from "@office-open/core";
 import { textToUint8Array, toUint8Array } from "undio";
 import { PresetGeometry, buildFill, createBlipFill, createCustomGeometry, createEffectDag, createEffectList, createOutline, createScene3D, createShape3D, createTransform2D, extractBlipFillMedia } from "@office-open/core/drawingml";
 import { ChartCollection, ChartSpace } from "@office-open/core/chart";
@@ -14559,7 +14559,7 @@ function replaceNumberingPlaceholders(xml, concreteNumberings) {
 var Compiler = class {
 	formatter;
 	constructor() {
-		this.formatter = new Formatter();
+		this.formatter = new Formatter$1();
 	}
 	/**
 	* Compiles a File object into a flat file map suitable for fflate zipSync.
@@ -15097,581 +15097,30 @@ init_convenience_functions();
 init_values();
 __reExport(util_exports, values_exports);
 //#endregion
-//#region src/patcher/util.ts
-/**
-* Utility functions for XML manipulation in document patching.
-*
-* @module
-*/
-init_text();
-/**
-* Converts XML string to JSON element structure.
-*
-* Parses XML text into a JavaScript object representation that can be
-* manipulated programmatically. Preserves spaces between elements for
-* accurate text handling.
-*
-* @param xmlData - The XML string to parse
-* @returns Parsed XML as an Element object
-*
-* @example
-* ```typescript
-* const element = toJson('<w:p><w:r><w:t>Hello</w:t></w:r></w:p>');
-* ```
-*/
-const toJson = (xmlData) => {
-	return xml2js(xmlData, {
-		captureSpacesBetweenElements: true,
-		compact: false
-	});
-};
-/**
-* Creates text element contents from a text string.
-*
-* Generates the XML element structure for a text node (w:t) by formatting
-* a Text component and extracting its element contents. Used when creating
-* new text runs during replacement operations.
-*
-* @param text - The text content to wrap in element structure
-* @returns Array of XML elements representing the text
-*
-* @example
-* ```typescript
-* const elements = createTextElementContents("Hello World");
-* // Returns XML elements for <w:t>Hello World</w:t>
-* ```
-*/
-const createTextElementContents = (text) => {
-	return toJson(xml(buildText({ text }))).elements[0].elements ?? [];
-};
-/**
-* Adds xml:space="preserve" attribute to an element.
-*
-* The xml:space attribute instructs XML processors to preserve whitespace
-* in the element's content. This is important when text contains leading
-* or trailing spaces that must be maintained.
-*
-* @param element - The element to patch
-* @returns New element with xml:space attribute added
-*
-* @example
-* ```typescript
-* const patched = patchSpaceAttribute(textElement);
-* // Adds xml:space="preserve" to maintain whitespace
-* ```
-*/
-const patchSpaceAttribute = (element) => ({
-	...element,
-	attributes: { "xml:space": "preserve" }
-});
-/**
-* Retrieves first-level child elements by parent element name.
-*
-* Finds the first element with the specified name and returns its children.
-* Used to access collections like relationship elements or content type definitions.
-*
-* @param relationships - The parent XML element to search
-* @param id - The element name to find
-* @returns Array of child elements
-*
-* @example
-* ```typescript
-* const rels = getFirstLevelElements(relationshipsXml, "Relationships");
-* // Returns array of Relationship elements
-* ```
-*/
-const getFirstLevelElements = (relationships, id) => relationships.elements?.filter((e) => e.name === id)[0].elements ?? [];
-//#endregion
-//#region src/patcher/content-types-manager.ts
-/**
-* Appends a content type definition to the [Content_Types].xml structure.
-*
-* The [Content_Types].xml file declares the MIME types for all file extensions
-* in the OOXML package. This function adds a new content type if it doesn't
-* already exist, ensuring that newly added media files are properly declared.
-*
-* @param element - The [Content_Types].xml root element
-* @param contentType - The MIME type (e.g., "image/png")
-* @param extension - The file extension (e.g., "png")
-*
-* @example
-* ```typescript
-* appendContentType(contentTypesElement, "image/png", "png");
-* appendContentType(contentTypesElement, "image/jpeg", "jpg");
-* ```
-*/
-const appendContentType = (element, contentType, extension) => {
-	const relationshipElements = getFirstLevelElements(element, "Types");
-	if (relationshipElements.some((el) => el.type === "element" && el.name === "Default" && el?.attributes?.ContentType === contentType && el?.attributes?.Extension === extension)) return;
-	relationshipElements.push({
-		attributes: {
-			ContentType: contentType,
-			Extension: extension
-		},
-		name: "Default",
-		type: "element"
-	});
-};
-//#endregion
-//#region src/patcher/relationship-manager.ts
-/**
-* Extracts the numeric ID from a relationship ID string.
-*
-* @param relationshipId - Relationship ID in format "rId123"
-* @returns The numeric portion of the ID
-*/
-const getIdFromRelationshipId = (relationshipId) => {
-	const output = parseInt(relationshipId.substring(3), 10);
-	return isNaN(output) ? 0 : output;
-};
-/**
-* Determines the next available relationship ID number.
-*
-* Scans all existing relationships and returns the next sequential ID number
-* to use when adding a new relationship.
-*
-* @param relationships - The relationships XML element
-* @returns The next available relationship ID number
-*
-* @example
-* ```typescript
-* const nextId = getNextRelationshipIndex(relationshipsElement);
-* // If highest existing ID is rId5, returns 6
-* ```
-*/
-const getNextRelationshipIndex = (relationships) => {
-	return getFirstLevelElements(relationships, "Relationships").map((e) => getIdFromRelationshipId(e.attributes?.Id?.toString() ?? "")).reduce((acc, curr) => Math.max(acc, curr), 0) + 1;
-};
-/**
-* Appends a new relationship to a .rels file structure.
-*
-* Relationships define connections between parts of an OOXML package,
-* such as linking documents to images, hyperlinks, or other resources.
-*
-* @param relationships - The relationships XML element
-* @param id - The relationship ID (number or string)
-* @param type - The relationship type URI
-* @param target - The target path or URI
-* @param targetMode - Optional target mode (Internal or External)
-* @returns The updated relationship elements array
-*
-* @example
-* ```typescript
-* appendRelationship(
-*   relationshipsElement,
-*   6,
-*   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
-*   "media/image1.png"
-* );
-* ```
-*/
-const appendRelationship = (relationships, id, type, target, targetMode) => {
-	const relationshipElements = getFirstLevelElements(relationships, "Relationships");
-	relationshipElements.push({
-		attributes: {
-			Id: `rId${id}`,
-			Target: target,
-			TargetMode: targetMode,
-			Type: type
-		},
-		name: "Relationship",
-		type: "element"
-	});
-	return relationshipElements;
-};
-//#endregion
-//#region src/patcher/paragraph-split-inject.ts
-var TokenNotFoundError = class extends Error {
-	constructor(token) {
-		super(`Token ${token} not found`);
-		this.name = "TokenNotFoundError";
-	}
-};
-/**
-* Finds the index of the run element containing a specific token.
-*
-* Searches through all run (w:r) elements in a paragraph to find which one
-* contains the specified token text. This is used to locate where new content
-* should be injected during replacement operations.
-*
-* @param paragraphElement - The paragraph element to search
-* @param token - The token text to find
-* @returns The index of the run element containing the token
-* @throws Error if the token is not found in any run
-*
-* @example
-* ```typescript
-* const index = findRunElementIndexWithToken(paragraph, "ɵ");
-* // Returns the index of the run containing the split token
-* ```
-*/
-const findRunElementIndexWithToken = (paragraphElement, token) => {
-	for (let i = 0; i < (paragraphElement.elements ?? []).length; i++) {
-		const element = paragraphElement.elements[i];
-		if (element.type === "element" && element.name === "w:r") {
-			const textElement = (element.elements ?? []).filter((e) => e.type === "element" && e.name === "w:t");
-			for (const text of textElement) {
-				if (!text.elements?.[0]) continue;
-				if (text.elements[0].text?.includes(token)) return i;
-			}
-		}
-	}
-	throw new TokenNotFoundError(token);
-};
-/**
-* Splits a run element at a token position into left and right parts.
-*
-* Divides a run element at the location of a token, creating two separate
-* runs. This allows new content to be injected between the split parts while
-* preserving the original run's formatting properties.
-*
-* @param runElement - The run element to split
-* @param token - The token text marking the split point
-* @returns Object containing the left and right run elements
-*
-* @example
-* ```typescript
-* const { left, right } = splitRunElement(run, "ɵ");
-* // If run contains "Helloɵworld", left contains "Hello" and right contains "world"
-* ```
-*/
-const splitRunElement = (runElement, token) => {
-	let splitIndex = -1;
-	const splitElements = runElement.elements?.map((e, i) => {
-		if (splitIndex !== -1) return e;
-		if (e.type === "element" && e.name === "w:t") {
-			const splitText = (e.elements?.[0]?.text ?? "").split(token);
-			const newElements = splitText.map((t) => ({
-				...e,
-				...patchSpaceAttribute(e),
-				elements: createTextElementContents(t)
-			}));
-			if (splitText.length > 1) splitIndex = i;
-			return newElements;
-		} else return e;
-	}).flat() ?? [];
-	return {
-		left: {
-			...JSON.parse(JSON.stringify(runElement)),
-			elements: splitElements.slice(0, splitIndex + 1)
-		},
-		right: {
-			...JSON.parse(JSON.stringify(runElement)),
-			elements: splitElements.slice(splitIndex + 1)
-		}
-	};
-};
-//#endregion
-//#region src/patcher/paragraph-token-replacer.ts
-/**
-* Replacement modes for multi-run text replacement.
-*/
-const ReplaceMode = {
-	/** Looking for the start of the replacement text */
-	START: 0,
-	/** Processing runs in the middle of the replacement text */
-	MIDDLE: 1,
-	/** Reached the end of the replacement text */
-	END: 2
-};
-/**
-* Replaces a token with replacement text within a paragraph's run elements.
-*
-* Handles the complex case where placeholder text may span multiple runs
-* (text fragments) within a paragraph. Processes each run to replace the
-* appropriate portion of the token, handling start, middle, and end sections.
-*
-* @param paragraphElement - The paragraph XML element to modify
-* @param renderedParagraph - Pre-rendered paragraph structure with text positions
-* @param originalText - The token text to replace (e.g., "{{name}}")
-* @param replacementText - The text to replace it with (often a split token)
-* @returns The modified paragraph element
-*
-* @example
-* ```typescript
-* replaceTokenInParagraphElement({
-*   paragraphElement,
-*   renderedParagraph,
-*   originalText: "{{placeholder}}",
-*   replacementText: "ɵ",
-* });
-* ```
-*/
-const replaceTokenInParagraphElement = ({ paragraphElement, renderedParagraph, originalText, replacementText }) => {
-	const startIndex = renderedParagraph.text.indexOf(originalText);
-	const endIndex = startIndex + originalText.length - 1;
-	let replaceMode = ReplaceMode.START;
-	for (const run of renderedParagraph.runs) for (const { text, index, start, end } of run.parts) switch (replaceMode) {
-		case ReplaceMode.START:
-			if (startIndex >= start && startIndex <= end) {
-				const offsetStartIndex = startIndex - start;
-				const offsetEndIndex = Math.min(endIndex, end) - start;
-				const partToReplace = text.substring(offsetStartIndex, offsetEndIndex + 1);
-				if (partToReplace === "") continue;
-				const firstPart = text.replace(partToReplace, replacementText);
-				patchTextElement(paragraphElement.elements[run.index].elements[index], firstPart);
-				replaceMode = ReplaceMode.MIDDLE;
-				continue;
-			}
-			break;
-		case ReplaceMode.MIDDLE:
-			if (endIndex <= end) {
-				const lastPart = text.substring(endIndex - start + 1);
-				patchTextElement(paragraphElement.elements[run.index].elements[index], lastPart);
-				const currentElement = paragraphElement.elements[run.index].elements[index];
-				paragraphElement.elements[run.index].elements[index] = patchSpaceAttribute(currentElement);
-				replaceMode = ReplaceMode.END;
-			} else patchTextElement(paragraphElement.elements[run.index].elements[index], "");
-			break;
-		default:
-	}
-	return paragraphElement;
-};
-const patchTextElement = (element, text) => {
-	element.elements = createTextElementContents(text);
-	return element;
-};
-//#endregion
-//#region src/patcher/run-renderer.ts
-/**
-* Renders a paragraph element into a structured representation with text content.
-*
-* Extracts all text content from a paragraph (w:p) element by processing its
-* run (w:r) children. Calculates character positions for each text fragment
-* to enable precise text replacement operations.
-*
-* @param node - The paragraph element wrapper to render
-* @returns Rendered paragraph with text content, runs, and position information
-* @throws Error if the node is not a paragraph element
-*
-* @example
-* ```typescript
-* const rendered = renderParagraphNode(paragraphWrapper);
-* console.log(rendered.text); // "Hello World"
-* console.log(rendered.runs.length); // 2 (if text is in separate runs)
-* ```
-*/
-const renderParagraphNode = (node) => {
-	if (node.element.name !== "w:p") throw new Error(`Invalid node type: ${node.element.name}`);
-	if (!node.element.elements) return {
-		index: -1,
-		pathToParagraph: [],
-		runs: [],
-		text: ""
-	};
-	let currentRunStringLength = 0;
-	const runs = node.element.elements.map((element, i) => ({
-		element,
-		i
-	})).filter(({ element }) => element.name === "w:r").map(({ element, i }) => {
-		const renderedRunNode = renderRunNode(element, i, currentRunStringLength);
-		currentRunStringLength += renderedRunNode.text.length;
-		return renderedRunNode;
-	}).filter((e) => Boolean(e));
-	const text = runs.reduce((acc, curr) => acc + curr.text, "");
-	return {
-		index: node.index,
-		pathToParagraph: buildNodePath(node),
-		runs,
-		text
-	};
-};
-const renderRunNode = (node, index, currentRunStringIndex) => {
-	if (!node.elements) return {
-		end: currentRunStringIndex,
-		index: -1,
-		parts: [],
-		start: currentRunStringIndex,
-		text: ""
-	};
-	let currentTextStringIndex = currentRunStringIndex;
-	const parts = node.elements.map((element, i) => element.name === "w:t" && element.elements && element.elements.length > 0 ? (() => {
-		const partStart = currentTextStringIndex;
-		currentTextStringIndex += (element.elements[0].text?.toString() ?? "").length;
-		return {
-			end: currentTextStringIndex - 1,
-			index: i,
-			start: partStart,
-			text: element.elements[0].text?.toString() ?? ""
-		};
-	})() : void 0).filter((e) => Boolean(e)).map((e) => e);
-	const text = parts.reduce((acc, curr) => acc + curr.text, "");
-	return {
-		end: currentTextStringIndex - 1,
-		index,
-		parts,
-		start: currentRunStringIndex,
-		text
-	};
-};
-const buildNodePath = (node) => node.parent ? [...buildNodePath(node.parent), node.index] : [node.index];
-//#endregion
-//#region src/patcher/traverser.ts
-const elementsToWrapper = (wrapper) => wrapper.element.elements?.map((e, i) => ({
-	element: e,
-	index: i,
-	parent: wrapper
-})) ?? [];
-/**
-* Traverses an XML document tree to find and render all paragraphs.
-*
-* Uses breadth-first search to walk through the XML structure, identifying
-* all paragraph elements (w:p) and rendering their text content along with
-* positional information.
-*
-* @param node - The root XML element to traverse
-* @returns Array of rendered paragraph nodes with text content and positions
-*
-* @example
-* ```typescript
-* const paragraphs = traverse(documentElement);
-* paragraphs.forEach(p => console.log(p.text));
-* ```
-*/
-const traverse = (node) => {
-	let renderedParagraphs = [];
-	const queue = [...elementsToWrapper({
-		element: node,
-		index: 0,
-		parent: void 0
-	})];
-	let currentNode;
-	while (queue.length > 0) {
-		currentNode = queue.shift();
-		if (currentNode.element.name === "w:p") renderedParagraphs = [...renderedParagraphs, renderParagraphNode(currentNode)];
-		queue.push(...elementsToWrapper(currentNode));
-	}
-	return renderedParagraphs;
-};
-/**
-* Finds all paragraphs containing specific text.
-*
-* Traverses the document and filters paragraphs to find those containing
-* the specified text string. Useful for locating placeholder text that
-* needs to be replaced.
-*
-* @param node - The root XML element to search
-* @param text - The text to search for
-* @returns Array of paragraph nodes containing the text
-*
-* @example
-* ```typescript
-* const matches = findLocationOfText(documentElement, "{{name}}");
-* // Returns all paragraphs containing "{{name}}"
-* ```
-*/
-const findLocationOfText = (node, text) => traverse(node).filter((p) => p.text.includes(text));
-//#endregion
-//#region src/patcher/replacer.ts
-/**
-* Replacer module for performing placeholder substitution in XML structures.
-*
-* @module
-*/
-const formatter = new Formatter();
-const SPLIT_TOKEN = "ɵ";
-/**
-* Replaces placeholder text in XML with new content from a patch.
-*
-* This function locates placeholder text within the XML structure and performs
-* the appropriate replacement based on the patch type (document or paragraph level).
-* It handles splitting runs, preserving styles, and injecting the new content.
-*
-* @param json - The XML element structure to search
-* @param patch - The patch definition containing replacement content
-* @param patchText - The placeholder text to find (e.g., "{{name}}")
-* @param context - The document context for formatting
-* @param keepOriginalStyles - Whether to preserve original text formatting
-* @returns Result containing the modified element and whether a replacement occurred
-*/
-const replacer = ({ json, patch, patchText, context, keepOriginalStyles = true }) => {
-	const renderedParagraphs = findLocationOfText(json, patchText);
-	if (renderedParagraphs.length === 0) return {
-		didFindOccurrence: false,
-		element: json
-	};
-	for (const renderedParagraph of renderedParagraphs) {
-		const textJson = patch.children.map((c) => toJson(xml(formatter.format(c, context)))).map((c) => c.elements[0]);
-		switch (patch.type) {
-			case PatchType.DOCUMENT: {
-				const parentElement = goToParentElementFromPath(json, renderedParagraph.pathToParagraph);
-				const elementIndex = getLastElementIndexFromPath(renderedParagraph.pathToParagraph);
-				parentElement.elements.splice(elementIndex, 1, ...textJson);
-				break;
-			}
-			case PatchType.PARAGRAPH:
-			default: {
-				const paragraphElement = goToElementFromPath(json, renderedParagraph.pathToParagraph);
-				replaceTokenInParagraphElement({
-					originalText: patchText,
-					paragraphElement,
-					renderedParagraph,
-					replacementText: SPLIT_TOKEN
-				});
-				const index = findRunElementIndexWithToken(paragraphElement, SPLIT_TOKEN);
-				const runElementToBeReplaced = paragraphElement.elements[index];
-				const { left, right } = splitRunElement(runElementToBeReplaced, SPLIT_TOKEN);
-				let newRunElements = textJson;
-				let patchedRightElement = right;
-				if (keepOriginalStyles) {
-					const runElementNonTextualElements = runElementToBeReplaced.elements.filter((e) => e.type === "element" && e.name === "w:rPr");
-					newRunElements = textJson.map((e) => {
-						if (e.type !== "element" || e.name !== "w:r" || e.elements?.some((c) => c.type === "element" && c.name === "w:rPr")) return e;
-						return {
-							...e,
-							elements: [...runElementNonTextualElements, ...e.elements ?? []]
-						};
-					});
-					patchedRightElement = {
-						...right,
-						elements: [...runElementNonTextualElements, ...right.elements]
-					};
-				}
-				paragraphElement.elements.splice(index, 1, left, ...newRunElements, patchedRightElement);
-				break;
-			}
-		}
-	}
-	return {
-		didFindOccurrence: true,
-		element: json
-	};
-};
-const goToElementFromPath = (json, path) => {
-	let element = json;
-	for (let i = 1; i < path.length; i++) {
-		const index = path[i];
-		element = element.elements[index];
-	}
-	return element;
-};
-const goToParentElementFromPath = (json, path) => goToElementFromPath(json, path.slice(0, -1));
-const getLastElementIndexFromPath = (path) => path[path.length - 1];
-//#endregion
 //#region src/patcher/from-docx.ts
+init_media();
+init_paragraph();
+init_relationship();
+init_convenience_functions();
 /**
 * Document patching module for modifying existing .docx files.
 *
-* This module provides functionality to patch existing Word documents by replacing
-* placeholder text with new content while preserving the original document structure.
-*
 * @module
 */
-init_media();
-init_paragraph();
-init_relationship();
-init_convenience_functions();
+const formatter = new Formatter();
+const docxReplacer = createReplacer({
+	ns: DOCX_NS,
+	formatChild: (child, context) => {
+		return [toJson(xml(formatter.format(child, context))).elements[0]];
+	}
+});
 /**
 * Patch type enumeration.
 *
-* Determines how the replacement content should be inserted into the document.
-*
 * @publicApi
 */
 const PatchType = {
-	/** Replace entire file-level elements (e.g., whole paragraphs) */
 	DOCUMENT: "file",
-	/** Replace content within paragraphs (inline replacement) */
 	PARAGRAPH: "paragraph"
 };
 const UTF16LE = new Uint8Array([255, 254]);
@@ -15684,36 +15133,6 @@ const compareByteArrays = (a, b) => {
 /**
 * Patches an existing .docx document by replacing placeholders with new content.
 *
-* This function opens an existing Word document, searches for placeholder text
-* (e.g., {{name}}), and replaces it with the provided content while preserving
-* the original document structure and optionally the original formatting.
-*
-* @param options - Configuration options for patching
-* @returns A promise resolving to the patched document in the specified output format
-*
-* @example
-* ```typescript
-* // Patch with paragraph content
-* const buffer = await patchDocument({
-*   outputType: "nodebuffer",
-*   data: templateBuffer,
-*   patches: {
-*     name: {
-*       type: PatchType.PARAGRAPH,
-*       children: [new TextRun({ text: "John Doe", bold: true })],
-*     },
-*   },
-* });
-*
-* // Patch with custom delimiters
-* const buffer = await patchDocument({
-*   outputType: "nodebuffer",
-*   data: templateBuffer,
-*   patches: { ... },
-*   placeholderDelimiters: { start: "<<", end: ">>" },
-* });
-* ```
-*
 * @publicApi
 */
 const patchDocument = async ({ outputType, data, patches, keepOriginalStyles, placeholderDelimiters = {
@@ -15722,7 +15141,7 @@ const patchDocument = async ({ outputType, data, patches, keepOriginalStyles, pl
 }, recursive = true }) => {
 	const zipContent = unzipSync(toUint8Array(data));
 	const contexts = /* @__PURE__ */ new Map();
-	const file = { Media: new Media() };
+	const file = { media: new Media() };
 	const map = /* @__PURE__ */ new Map();
 	const imageRelationshipAdditions = [];
 	const hyperlinkRelationshipAdditions = [];
@@ -15757,7 +15176,7 @@ const patchDocument = async ({ outputType, data, patches, keepOriginalStyles, pl
 				fileData: file,
 				file,
 				stack: [],
-				viewWrapper: { Relationships: { addRelationship: (linkId, _, target, __) => {
+				viewWrapper: { relationships: { addRelationship: (linkId, _, target, __) => {
 					hyperlinkRelationshipAdditions.push({
 						hyperlink: {
 							id: linkId,
@@ -15773,7 +15192,7 @@ const patchDocument = async ({ outputType, data, patches, keepOriginalStyles, pl
 			for (const [patchKey, patchValue] of Object.entries(patches)) {
 				const patchText = `${start}${patchKey}${end}`;
 				while (true) {
-					const { didFindOccurrence } = replacer({
+					const { didFindOccurrence } = docxReplacer({
 						context,
 						json,
 						keepOriginalStyles,
@@ -15838,14 +15257,11 @@ const patchDocument = async ({ outputType, data, patches, keepOriginalStyles, pl
 		appendContentType(contentTypesJson, "image/svg+xml", "svg");
 	}
 	const files = {};
-	for (const [key, value] of map) files[key] = textToUint8Array(toXml(value));
+	for (const [key, value] of map) files[key] = textToUint8Array(js2xml(value));
 	for (const [key, value] of binaryContentMap) files[key] = value;
 	for (const { data: mediaData, fileName } of file.media.array) files[`word/media/${fileName}`] = mediaData instanceof Uint8Array ? mediaData : new Uint8Array(mediaData);
 	return await zipAndConvert(files, outputType, OoxmlMimeType.DOCX);
 };
-const toXml = (jsonObj) => {
-	return js2xml(jsonObj, { attributeValueFn: (str) => String(str).replace(/&(?!amp;|lt;|gt;|quot;|apos;)/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;") });
-};
 const createRelationshipFile = () => ({
 	declaration: { attributes: {
 		encoding: "UTF-8",
@@ -15896,7 +15312,11 @@ const patchDetector = async ({ data }) => {
 	const patches = /* @__PURE__ */ new Set();
 	for (const [key, value] of Object.entries(zipContent)) {
 		if (!key.endsWith(".xml") && !key.endsWith(".rels")) continue;
-		if (key.startsWith("word/") && !key.endsWith(".xml.rels")) traverse(toJson(strFromU8(value))).forEach((p) => findPatchKeys(p.text).forEach((patch) => patches.add(patch)));
+		if (key.startsWith("word/") && !key.endsWith(".xml.rels")) {
+			const json = toJson(strFromU8(value));
+			const { traverse } = createTraverser(DOCX_NS);
+			traverse(json).forEach((p) => findPatchKeys(p.text).forEach((patch) => patches.add(patch)));
+		}
 	}
 	return [...patches];
 };