@office-open/xml 0.10.15 → 0.12.0

package/dist/index.mjs

@@ -1,200 +1,4 @@
-import { allChildren, attr, attrBool, attrMeasure, attrNum, childCount, childText, children, collectText, colorAttr, findChild, findDeep, findFirst, hasChild, isNonEmpty, textOf } from "./utils.mjs";
-//#region src/escape.ts
-/** Escape text content for XML. Fast path returns original string when no special chars. */
-function escapeXml(str) {
-	for (let i = 0; i < str.length; i++) {
-		const c = str.charCodeAt(i);
-		if (c === 38 || c === 34 || c === 39 || c === 60 || c === 62) {
-			let s = "";
-			let last = 0;
-			for (let j = i; j < str.length; j++) {
-				const cj = str.charCodeAt(j);
-				if (cj === 38) {
-					s += str.slice(last, j) + "&amp;";
-					last = j + 1;
-				} else if (cj === 34) {
-					s += str.slice(last, j) + "&quot;";
-					last = j + 1;
-				} else if (cj === 39) {
-					s += str.slice(last, j) + "&apos;";
-					last = j + 1;
-				} else if (cj === 60) {
-					s += str.slice(last, j) + "&lt;";
-					last = j + 1;
-				} else if (cj === 62) {
-					s += str.slice(last, j) + "&gt;";
-					last = j + 1;
-				}
-			}
-			return s + str.slice(last);
-		}
-	}
-	return str;
-}
-/**
-* Build an XML attribute string fragment from a record.
-* `undefined` values are automatically skipped.
-* String values are escaped via `escapeXml`.
-*
-* @example
-* attrs({ id: 1, name: "foo", hidden: undefined })
-* // => ' id="1" name="foo"'
-*/
-function attrs(record) {
-	const parts = [];
-	for (const [key, v] of Object.entries(record)) if (v !== void 0) parts.push(` ${key}="${typeof v === "string" ? escapeXml(v) : v}"`);
-	return parts.join("");
-}
-/**
-* Build an XML attribute string without escaping.
-*
-* Same as `attrs()` but skips `typeof` checks and `escapeXml` — use only when
-* all values are known-safe (numbers, booleans, or strings free of `& " ' < >`).
-* Avoids per-call array and `Object.keys()` allocation in hot loops.
-*
-* @example
-* attrsRaw({ r: "A1", s: 5 })
-* // => ' r="A1" s="5"'
-*/
-function attrsRaw(record) {
-	let s = "";
-	for (const key in record) {
-		const v = record[key];
-		if (v !== void 0) s += ` ${key}="${v}"`;
-	}
-	return s;
-}
-/**
-* Build a self-closing XML element: `<tag attrStr/>`.
-* `attrStr` is a pre-serialized attribute string (from `attrs()`) or undefined.
-*/
-function selfCloseElement(tag, attrStr) {
-	return attrStr ? `<${tag}${attrStr}/>` : `<${tag}/>`;
-}
-/**
-* Build a complete XML element string from name, optional attributes, and string children.
-*
-* Replaces `new BuilderElement({...})` + `.toXml()` / `.serialize()` with a
-* single function call returning a string — zero object allocation.
-*
-* @param name  Element tag name (e.g. `"a:srgbClr"`)
-* @param attrRecord  Optional flat attribute map; `undefined` values are skipped
-* @param children  Optional pre-serialized child XML strings
-*
-* @example
-* ```ts
-* element("a:solidFill", undefined, [element("a:srgbClr", { val: "FF0000" })])
-* // => '<a:solidFill><a:srgbClr val="FF0000"/></a:solidFill>'
-* ```
-*/
-function element(name, attrRecord, children) {
-	const attrStr = attrRecord ? attrs(attrRecord) : void 0;
-	if (!children || children.length === 0) return selfCloseElement(name, attrStr);
-	const body = children.join("");
-	return body.length === 0 ? selfCloseElement(name, attrStr) : `<${name}${attrStr ?? ""}>${body}</${name}>`;
-}
-//#endregion
-//#region src/serialize.ts
-const DEFAULT_INDENT = "    ";
-/**
-* Serialize a Record-based XML object tree to an XML string.
-* @deprecated Use `stringify` (Element → string) instead. This object-tree path
-* will be removed once the Descriptor migration is complete.
-*/
-function xml(input, options) {
-	const opts = normalizeOptions$1(options);
-	const parts = [];
-	if (opts.declaration) {
-		const declOpts = opts.declaration === true ? {} : opts.declaration;
-		const enc = declOpts.encoding || "UTF-8";
-		const sa = declOpts.standalone;
-		const declParts = [`<?xml version="1.0" encoding="${enc}"`];
-		if (sa) declParts.push(` standalone="${sa}"`);
-		declParts.push("?>");
-		parts.push(declParts.join(""));
-		if (opts.indent) parts.push("\n");
-	}
-	const items = Array.isArray(input) ? input : [input];
-	for (let i = 0; i < items.length; i++) {
-		const item = items[i];
-		if (!item) continue;
-		const key = Object.keys(item)[0];
-		if (!key) continue;
-		parts.push(formatElement(key, item[key], opts.indent, 0));
-		if (opts.indent && i < items.length - 1) parts.push("\n");
-	}
-	return parts.join("");
-}
-function normalizeOptions$1(options) {
-	const opts = typeof options === "object" && !Array.isArray(options) ? options : { indent: options };
-	let indent = "";
-	if (opts.indent) indent = opts.indent === true ? DEFAULT_INDENT : String(opts.indent);
-	return {
-		indent,
-		declaration: opts.declaration
-	};
-}
-/**
-* Single-pass XML formatter: directly converts a Record-based XML object to string,
-* eliminating the intermediate ResolvedElement tree.
-*/
-function formatElement(name, values, indent, depth) {
-	const attrParts = [];
-	const textParts = [];
-	const elemParts = [];
-	let emptyArray = false;
-	if (values == null) {
-		const attrStr = attrParts.length ? " " + attrParts.join(" ") : "";
-		return `${indent ? indent.repeat(depth) : ""}<${name}${attrStr}/>`;
-	}
-	if (typeof values === "object") {
-		const obj = values;
-		if (obj._attr) {
-			const attr = obj._attr;
-			for (const key of Object.keys(attr)) attrParts.push(`${key}="${escapeXml(String(attr[key]))}"`);
-		}
-		if (obj._attributes) {
-			const attr = obj._attributes;
-			for (const key of Object.keys(attr)) attrParts.push(`${key}="${escapeXml(String(attr[key]))}"`);
-		}
-		if (obj._cdata) {
-			const escaped = String(obj._cdata).replace(/\]\]>/g, "]]]]><![CDATA[>");
-			textParts.push(`<![CDATA[${escaped}]]>`);
-		}
-		if (Array.isArray(values)) {
-			if (values.length === 0) emptyArray = true;
-			else for (const value of values) if (value && typeof value === "object" && "_attr" in value) {
-				const attr = value._attr;
-				for (const key of Object.keys(attr)) attrParts.push(`${key}="${escapeXml(String(attr[key]))}"`);
-			} else if (value && typeof value === "object" && "_attributes" in value) {
-				const attr = value._attributes;
-				for (const key of Object.keys(attr)) attrParts.push(`${key}="${escapeXml(String(attr[key]))}"`);
-			} else if (value && typeof value === "object") {
-				const childKey = Object.keys(value)[0];
-				if (childKey) elemParts.push(formatElement(childKey, value[childKey], indent, depth + 1));
-			} else if (value != null) textParts.push(escapeXml(String(value)));
-		}
-	} else textParts.push(escapeXml(String(values)));
-	const ind = indent ? indent.repeat(depth) : "";
-	const attrStr = attrParts.length ? " " + attrParts.join(" ") : "";
-	if (textParts.length + elemParts.length === 0) return emptyArray ? `${ind}<${name}${attrStr}></${name}>` : `${ind}<${name}${attrStr}/>`;
-	if (elemParts.length === 0 && textParts.length === 1) return indent ? `${ind}<${name}${attrStr}>${textParts[0]}</${name}>` : `<${name}${attrStr}>${textParts[0]}</${name}>`;
-	const parts = [];
-	parts.push(`${ind}<${name}${attrStr}>`);
-	if (indent) parts.push("\n");
-	const childIndent = indent ? indent.repeat(depth + 1) : "";
-	for (const t of textParts) {
-		parts.push(`${childIndent}${t}`);
-		if (indent) parts.push("\n");
-	}
-	for (const e of elemParts) {
-		parts.push(e);
-		if (indent) parts.push("\n");
-	}
-	parts.push(`${ind}</${name}>`);
-	return parts.join("");
-}
-//#endregion
+import { OOXML_XML_DECLARATION, allChildren, attr, attrBool, attrMeasure, attrNum, childCount, childText, children, collectText, colorAttr, findChild, findDeep, findFirst, hasChild, isNonEmpty, textOf } from "./utils.mjs";
 //#region src/parse.ts
 const ENTITY_MAP = {
 	"&amp;": "&",
@@ -205,6 +9,7 @@ const ENTITY_MAP = {
 };
 const ENTITY_PATTERN = /&(?:amp|lt|gt|quot|apos|#x[0-9a-fA-F]+|#[0-9]+);/g;
 function unescapeXml(str) {
+	if (str.indexOf("&") === -1) return str;
 	return str.replace(ENTITY_PATTERN, (match) => {
 		if (ENTITY_MAP[match] !== void 0) return ENTITY_MAP[match];
 		const body = match.slice(2, -1);
@@ -214,11 +19,31 @@ function unescapeXml(str) {
 }
 function nativeTypeValue(value) {
 	if (value === "") return value;
+	const neg = value.charCodeAt(0) === 45;
+	const start = neg ? 1 : 0;
+	const digits = value.length - start;
+	if (digits > 0 && digits <= 15) {
+		if (value.charCodeAt(start) !== 48 || !neg && digits === 1) {
+			let n = 0;
+			let allDigits = true;
+			for (let i = start; i < value.length; i++) {
+				const c = value.charCodeAt(i);
+				if (c < 48 || c > 57) {
+					allDigits = false;
+					break;
+				}
+				n = n * 10 + (c - 48);
+			}
+			if (allDigits) return neg ? -n : n;
+		}
+	}
 	const n = Number(value);
 	if (!isNaN(n) && String(n) === value) return n;
-	const lower = value.toLowerCase();
-	if (lower === "true") return true;
-	if (lower === "false") return false;
+	if (value.length === 4 || value.length === 5) {
+		const lower = value.toLowerCase();
+		if (lower === "true") return true;
+		if (lower === "false") return false;
+	}
 	return value;
 }
 function parse(xmlString, options) {
@@ -230,6 +55,12 @@ function parse(xmlString, options) {
 	const ignoreCdata = options?.ignoreCdata ?? false;
 	const ignoreDoctype = options?.ignoreDoctype ?? false;
 	const nativeTypeAttributes = options?.nativeTypeAttributes ?? false;
+	const deferSet = options?.deferElements !== void 0 && options.deferElements.length > 0 ? new Set(options.deferElements) : void 0;
+	const nsTable = options?.normalizeNamespaces !== void 0 ? new Map(Object.entries(options.normalizeNamespaces)) : void 0;
+	const nsStack = [{
+		prefixes: void 0,
+		defaultCanonical: void 0
+	}];
 	const result = {};
 	const stack = [result];
 	let i = 0;
@@ -237,12 +68,26 @@ function parse(xmlString, options) {
 	while (i < len) {
 		if (xmlString.charCodeAt(i) !== 60) {
 			const start = i;
-			while (i < len && xmlString.charCodeAt(i) !== 60) i++;
+			const lt = xmlString.indexOf("<", i);
+			i = lt === -1 ? len : lt;
 			let text = unescapeXml(xmlString.slice(start, i));
 			if (trim) text = text.trim();
 			if (ignoreText) continue;
 			if (text.length > 0) {
-				if (captureSpaces || text.trim().length > 0 || isPreserveContext(stack)) addField(peek(stack), "text", text);
+				if (captureSpaces || text.trim().length > 0 || isPreserveContext(stack)) {
+					const parent = stack[stack.length - 1];
+					const elements = parent.elements;
+					const last = elements === void 0 ? void 0 : elements[elements.length - 1];
+					if (last !== void 0 && last.type === "text") last.text = last.text + text;
+					else {
+						const node = {
+							type: "text",
+							text
+						};
+						if (elements === void 0) parent.elements = [node];
+						else elements.push(node);
+					}
+				}
 			}
 			continue;
 		}
@@ -268,8 +113,10 @@ function parse(xmlString, options) {
 			if (end === -1) break;
 			const comment = xmlString.slice(i + 3, end);
 			i = end + 3;
-			if (!ignoreComment) if (trim) addField(peek(stack), "comment", comment.trim());
-			else addField(peek(stack), "comment", comment);
+			if (!ignoreComment) {
+				if (trim) addField(peek(stack), "comment", comment.trim());
+				else addField(peek(stack), "comment", comment);
+			}
 			continue;
 		}
 		if (xmlString.charCodeAt(i) === 33 && xmlString.slice(i, i + 8) === "![CDATA[") {
@@ -277,8 +124,10 @@ function parse(xmlString, options) {
 			if (end === -1) break;
 			const cdata = xmlString.slice(i + 8, end);
 			i = end + 3;
-			if (!ignoreCdata) if (trim) addField(peek(stack), "cdata", cdata.trim());
-			else addField(peek(stack), "cdata", cdata);
+			if (!ignoreCdata) {
+				if (trim) addField(peek(stack), "cdata", cdata.trim());
+				else addField(peek(stack), "cdata", cdata);
+			}
 			continue;
 		}
 		if (xmlString.charCodeAt(i) === 33 && xmlString.slice(i, i + 9) === "!DOCTYPE") {
@@ -294,26 +143,136 @@ function parse(xmlString, options) {
 			if (end === -1) break;
 			i = end + 1;
 			stack.pop();
+			if (nsTable !== void 0) nsStack.pop();
 			continue;
 		}
 		const tagNameEnd = findTagNameEnd(xmlString, i);
 		const tagName = xmlString.slice(i, tagNameEnd);
 		let pos = tagNameEnd;
-		const attributes = parseAttributesFromXml(xmlString, pos);
-		pos = attributes.pos;
-		if (nativeTypeAttributes) for (const key in attributes.attrs) attributes.attrs[key] = nativeTypeValue(attributes.attrs[key]);
+		const nsParent = nsTable !== void 0 ? nsStack[nsStack.length - 1] : void 0;
+		let nsPrefixes = nsParent?.prefixes;
+		let nsDefault = nsParent?.defaultCanonical;
+		let nsDeclared = false;
+		let attrs;
+		while (pos < len) {
+			while (pos < len && isWhitespace(xmlString.charCodeAt(pos))) pos++;
+			if (pos >= len || xmlString.charCodeAt(pos) === 62 || xmlString.charCodeAt(pos) === 47) break;
+			const nameStart = pos;
+			while (pos < len && xmlString.charCodeAt(pos) !== 61) {
+				if (xmlString.charCodeAt(pos) === 62 || xmlString.charCodeAt(pos) === 47) break;
+				pos++;
+			}
+			const name = xmlString.slice(nameStart, pos).trim();
+			if (xmlString.charCodeAt(pos) !== 61) break;
+			pos++;
+			while (pos < len && isWhitespace(xmlString.charCodeAt(pos))) pos++;
+			const quote = xmlString.charCodeAt(pos);
+			if (quote !== 34 && quote !== 39) break;
+			pos++;
+			const valueStart = pos;
+			while (pos < len && xmlString.charCodeAt(pos) !== quote) pos++;
+			const value = unescapeXml(xmlString.slice(valueStart, pos));
+			pos++;
+			if (nsTable !== void 0 && (name === "xmlns" || name.startsWith("xmlns:"))) {
+				if (attrs === void 0) attrs = {};
+				const canonical = nsTable.get(value);
+				if (name === "xmlns") {
+					nsDefault = canonical;
+					if (canonical !== void 0 && canonical !== "") attrs[`xmlns:${canonical}`] = value;
+					else attrs[name] = value;
+				} else {
+					const prefix = name.slice(6);
+					if (canonical !== void 0 && canonical !== "") attrs[`xmlns:${canonical}`] = value;
+					else if (canonical === "" && !("xmlns" in attrs)) attrs.xmlns = value;
+					else attrs[name] = value;
+					if (!nsDeclared) {
+						nsPrefixes = new Map(nsPrefixes ?? []);
+						nsDeclared = true;
+					}
+					nsPrefixes.set(prefix, canonical ?? prefix);
+				}
+				continue;
+			}
+			if (attrs === void 0) attrs = {};
+			attrs[name] = value;
+		}
+		if (attrs && nativeTypeAttributes) for (const key in attrs) attrs[key] = nativeTypeValue(attrs[key]);
+		let finalName = tagName;
+		if (nsTable !== void 0) {
+			const colon = tagName.indexOf(":");
+			if (colon > 0) {
+				const p = tagName.slice(0, colon);
+				if (p !== "xml") {
+					const c = nsPrefixes?.get(p);
+					if (c !== void 0 && c !== p) finalName = c === "" ? tagName.slice(colon + 1) : c + tagName.slice(colon);
+				}
+			} else if (colon < 0 && nsDefault !== void 0 && nsDefault !== "") finalName = nsDefault + ":" + tagName;
+			if (attrs !== void 0 && nsPrefixes !== void 0) for (const key of Object.keys(attrs)) {
+				if (key === "xmlns" || key.startsWith("xmlns:")) continue;
+				const kcolon = key.indexOf(":");
+				if (kcolon <= 0) continue;
+				const p = key.slice(0, kcolon);
+				if (p === "xml") continue;
+				const c = nsPrefixes.get(p);
+				if (c !== void 0 && c !== p) {
+					const renamed = c === "" ? key.slice(kcolon + 1) : c + key.slice(kcolon);
+					const attrValue = attrs[key];
+					if (attrValue !== void 0) attrs[renamed] = attrValue;
+					delete attrs[key];
+				}
+			}
+		}
 		const isSelfClosing = xmlString.charCodeAt(pos) === 47;
 		if (isSelfClosing) pos += 2;
 		else pos++;
 		const element = {
 			type: "element",
-			name: tagName
+			name: finalName,
+			attributes: attrs,
+			elements: void 0
 		};
-		if (Object.keys(attributes.attrs).length > 0) element.attributes = attributes.attrs;
 		const parent = peek(stack);
 		if (!parent.elements) parent.elements = [];
 		parent.elements.push(element);
-		if (!isSelfClosing) stack.push(element);
+		if (!isSelfClosing) {
+			if (deferSet !== void 0 && deferSet.has(tagName)) {
+				const closeTag = `</${tagName}>`;
+				let depth = 1;
+				let scan = pos;
+				let closeIdx = -1;
+				for (;;) {
+					closeIdx = xmlString.indexOf(closeTag, scan);
+					if (closeIdx === -1) break;
+					let p = scan;
+					for (;;) {
+						const openIdx = xmlString.indexOf(`<${tagName}`, p);
+						if (openIdx === -1 || openIdx >= closeIdx) break;
+						const after = xmlString.charCodeAt(openIdx + tagName.length + 1);
+						if (after === 32 || after === 9 || after === 10 || after === 13 || after === 47 || after === 62) depth++;
+						p = openIdx + tagName.length + 1;
+					}
+					scan = closeIdx + closeTag.length;
+					depth--;
+					if (depth === 0) break;
+				}
+				if (closeIdx === -1) {
+					element.raw = xmlString.slice(pos);
+					i = len;
+				} else {
+					element.raw = xmlString.slice(pos, closeIdx);
+					i = scan;
+				}
+				continue;
+			}
+			stack.push(element);
+			if (nsTable !== void 0) {
+				const layerChanged = nsDeclared || nsDefault !== nsParent.defaultCanonical;
+				nsStack.push(layerChanged ? {
+					prefixes: nsPrefixes,
+					defaultCanonical: nsDefault
+				} : nsParent);
+			}
+		}
 		i = pos;
 	}
 	if (result.elements) {
@@ -334,35 +293,6 @@ function findTagNameEnd(str, start) {
 	}
 	return i;
 }
-function parseAttributesFromXml(str, start) {
-	const attrs = {};
-	let i = start;
-	const len = str.length;
-	while (i < len) {
-		while (i < len && isWhitespace(str.charCodeAt(i))) i++;
-		if (i >= len || str.charCodeAt(i) === 62 || str.charCodeAt(i) === 47) break;
-		const nameStart = i;
-		while (i < len && str.charCodeAt(i) !== 61) {
-			if (str.charCodeAt(i) === 62 || str.charCodeAt(i) === 47) break;
-			i++;
-		}
-		const name = str.slice(nameStart, i);
-		if (str.charCodeAt(i) !== 61) break;
-		i++;
-		while (i < len && isWhitespace(str.charCodeAt(i))) i++;
-		const quote = str.charCodeAt(i);
-		if (quote !== 34 && quote !== 39) break;
-		i++;
-		const valueStart = i;
-		while (i < len && str.charCodeAt(i) !== quote) i++;
-		attrs[name] = unescapeXml(str.slice(valueStart, i));
-		i++;
-	}
-	return {
-		attrs,
-		pos: i
-	};
-}
 function parseAttributes(str) {
 	const result = {};
 	let i = 0;
@@ -429,7 +359,83 @@ function isWhitespace(ch) {
 	return ch === 32 || ch === 9 || ch === 10 || ch === 13;
 }
 //#endregion
+//#region src/escape.ts
+const XML_SPECIALS = /[&"'<>]/;
+/** Escape text content for XML. Fast path returns original string when no special chars. */
+function escapeXml(str) {
+	if (!XML_SPECIALS.test(str)) return str;
+	return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/**
+* Build an XML attribute string fragment from a record.
+* `undefined` values are automatically skipped.
+* String values are escaped via `escapeXml`. Booleans serialize as 0/1 —
+* the spelling Office itself writes for xsd:boolean attributes and
+* ST_OnOff unions alike.
+*
+* @example
+* attrs({ id: 1, name: "foo", hidden: undefined })
+* // => ' id="1" name="foo"'
+*/
+function attrs(record) {
+	const parts = [];
+	for (const [key, v] of Object.entries(record)) if (v !== void 0) {
+		const value = typeof v === "string" ? escapeXml(v) : typeof v === "boolean" ? v ? 1 : 0 : v;
+		parts.push(` ${key}="${value}"`);
+	}
+	return parts.join("");
+}
+/**
+* Build an XML attribute string without escaping.
+*
+* Same as `attrs()` but skips `typeof` checks and `escapeXml` — use only when
+* all values are known-safe (numbers, booleans, or strings free of `& " ' < >`).
+* Avoids per-call array and `Object.keys()` allocation in hot loops.
+*
+* @example
+* attrsRaw({ r: "A1", s: 5 })
+* // => ' r="A1" s="5"'
+*/
+function attrsRaw(record) {
+	let s = "";
+	for (const key in record) {
+		const v = record[key];
+		if (v !== void 0) s += ` ${key}="${v}"`;
+	}
+	return s;
+}
+/**
+* Build a self-closing XML element: `<tag attrStr/>`.
+* `attrStr` is a pre-serialized attribute string (from `attrs()`) or undefined.
+*/
+function selfCloseElement(tag, attrStr) {
+	return attrStr ? `<${tag}${attrStr}/>` : `<${tag}/>`;
+}
+/**
+* Build a complete XML element string from name, optional attributes, and string children.
+*
+* Replaces `new BuilderElement({...})` + `.toXml()` / `.serialize()` with a
+* single function call returning a string — zero object allocation.
+*
+* @param name  Element tag name (e.g. `"a:srgbClr"`)
+* @param attrRecord  Optional flat attribute map; `undefined` values are skipped
+* @param children  Optional pre-serialized child XML strings
+*
+* @example
+* ```ts
+* element("a:solidFill", undefined, [element("a:srgbClr", { val: "FF0000" })])
+* // => '<a:solidFill><a:srgbClr val="FF0000"/></a:solidFill>'
+* ```
+*/
+function element(name, attrRecord, children) {
+	const attrStr = attrRecord ? attrs(attrRecord) : void 0;
+	if (!children || children.length === 0) return selfCloseElement(name, attrStr);
+	const body = children.join("");
+	return body.length === 0 ? selfCloseElement(name, attrStr) : `<${name}${attrStr ?? ""}>${body}</${name}>`;
+}
+//#endregion
 //#region src/stringify.ts
+const TEXT_SPECIALS = /[&<>]/;
 function stringify(js, options) {
 	const opts = normalizeOptions(options);
 	const parts = [];
@@ -437,22 +443,19 @@ function stringify(js, options) {
 	if (js.elements?.length) parts.push(writeElements(js.elements, opts, 0, !parts.length));
 	return parts.join("");
 }
-/** @deprecated Use `stringify` instead. xml-js compatible alias. */
-function json2xml(json, options) {
-	return stringify(json, options);
-}
+const DEFAULT_OPTIONS = {
+	spaces: "",
+	ignoreDeclaration: false,
+	ignoreText: false,
+	ignoreComment: false,
+	ignoreCdata: false,
+	ignoreDoctype: false,
+	fullTagEmptyElement: false,
+	indentText: false,
+	indentCdata: false
+};
 function normalizeOptions(options) {
-	if (!options) return {
-		spaces: "",
-		ignoreDeclaration: false,
-		ignoreText: false,
-		ignoreComment: false,
-		ignoreCdata: false,
-		ignoreDoctype: false,
-		fullTagEmptyElement: false,
-		indentText: false,
-		indentCdata: false
-	};
+	if (!options) return DEFAULT_OPTIONS;
 	let spaces = "";
 	if (options.spaces != null) spaces = typeof options.spaces === "number" ? " ".repeat(options.spaces) : options.spaces;
 	return {
@@ -469,7 +472,8 @@ function normalizeOptions(options) {
 	};
 }
 function writeIndentation(spaces, depth, firstLine) {
-	return (!firstLine && spaces ? "\n" : "") + spaces.repeat(depth);
+	if (!spaces) return "";
+	return (!firstLine ? "\n" : "") + spaces.repeat(depth);
 }
 function writeDeclaration(declaration) {
 	const attrs = declaration.attributes;
@@ -480,90 +484,66 @@ function writeDeclaration(declaration) {
 	return parts.join("") + "?>";
 }
 function writeAttributes(attributes, elementName, element, attributeValueFn) {
-	const parts = [];
-	for (const key of Object.keys(attributes)) {
+	let s = "";
+	for (const key in attributes) {
 		const value = attributes[key];
 		if (value === null || value === void 0) continue;
 		const raw = String(value);
 		const attr = attributeValueFn ? attributeValueFn(raw, key, elementName, element) : escapeXml(raw);
-		parts.push(` ${key}="${attr}"`);
+		s += ` ${key}="${attr}"`;
 	}
-	return parts.join("");
-}
-function writeElement(element, opts, depth) {
-	if (!element.name) return "";
-	const name = element.name;
-	const attrStr = element.attributes ? writeAttributes(element.attributes, name, element, opts.attributeValueFn) : "";
-	if (!((element.elements?.length ?? 0) > 0 || element.attributes?.["xml:space"] === "preserve" || opts.fullTagEmptyElement)) return `<${name}${attrStr}/>`;
-	const parts = [];
-	parts.push(`<${name}${attrStr}>`);
-	const hasChildElements = element.elements?.some((e) => e.type === "element") ?? false;
-	if (element.elements?.length) parts.push(writeElements(element.elements, opts, depth + 1, false));
-	if (opts.spaces && hasChildElements) parts.push("\n" + opts.spaces.repeat(depth));
-	parts.push(`</${name}>`);
-	return parts.join("");
+	return s;
 }
 function writeElements(elements, opts, depth, firstLine) {
-	const parts = [];
+	let s = "";
 	for (let i = 0; i < elements.length; i++) {
 		const element = elements[i];
 		if (!element) continue;
 		const isFirst = firstLine && i === 0;
-		switch (element.type) {
-			case "element":
-				parts.push(writeIndentation(opts.spaces, depth, isFirst));
-				parts.push(writeElement(element, opts, depth));
-				break;
-			case "text":
-				if (opts.ignoreText) continue;
-				if (opts.indentText) parts.push(writeIndentation(opts.spaces, depth, isFirst));
-				parts.push(writeText(element.text));
-				break;
-			case "cdata":
-				if (opts.ignoreCdata) continue;
-				if (opts.indentCdata) parts.push(writeIndentation(opts.spaces, depth, isFirst));
-				parts.push(writeCdata(element.cdata));
-				break;
-			case "comment":
-				if (opts.ignoreComment) continue;
-				parts.push(writeIndentation(opts.spaces, depth, isFirst));
-				parts.push(writeComment(element.comment));
-				break;
-			case "doctype":
-				if (opts.ignoreDoctype) continue;
-				parts.push(writeIndentation(opts.spaces, depth, isFirst));
-				parts.push(writeDoctype(element.doctype));
-				break;
-			default: break;
-		}
-	}
-	return parts.join("");
-}
-function writeText(text) {
-	if (text == null) return "";
-	const str = String(text);
-	for (let i = 0; i < str.length; i++) {
-		const c = str.charCodeAt(i);
-		if (c === 38 || c === 60 || c === 62) {
-			let s = "";
-			let last = 0;
-			for (let j = i; j < str.length; j++) {
-				const cj = str.charCodeAt(j);
-				if (cj === 38) {
-					s += str.slice(last, j) + "&amp;";
-					last = j + 1;
-				} else if (cj === 60) {
-					s += str.slice(last, j) + "&lt;";
-					last = j + 1;
-				} else if (cj === 62) {
-					s += str.slice(last, j) + "&gt;";
-					last = j + 1;
-				}
+		const type = element.type;
+		if (type === "element") {
+			const name = element.name;
+			if (!name) continue;
+			if (opts.spaces) s += writeIndentation(opts.spaces, depth, isFirst);
+			const attributes = element.attributes;
+			const attrStr = attributes ? writeAttributes(attributes, name, element, opts.attributeValueFn) : "";
+			if (element.raw !== void 0) {
+				s += `<${name}${attrStr}>${element.raw}</${name}>`;
+				continue;
+			}
+			const children = element.elements;
+			if (!(children !== void 0 && children.length > 0 || opts.fullTagEmptyElement || attributes?.["xml:space"] === "preserve")) {
+				s += `<${name}${attrStr}/>`;
+				continue;
 			}
-			return s + str.slice(last);
+			const open = `<${name}${attrStr}>`;
+			if (children !== void 0 && children.length > 0) {
+				const inner = writeElements(children, opts, depth + 1, false);
+				if (opts.spaces && children.some((e) => e.type === "element")) s += open + inner + "\n" + opts.spaces.repeat(depth) + `</${name}>`;
+				else s += open + inner + `</${name}>`;
+			} else s += open + `</${name}>`;
+		} else if (type === "text") {
+			if (opts.ignoreText) continue;
+			if (opts.indentText && opts.spaces) s += writeIndentation(opts.spaces, depth, isFirst);
+			const text = element.text;
+			if (text == null) continue;
+			const str = String(text);
+			s += TEXT_SPECIALS.test(str) ? str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;") : str;
+		} else if (type === "cdata") {
+			if (opts.ignoreCdata) continue;
+			if (opts.indentCdata && opts.spaces) s += writeIndentation(opts.spaces, depth, isFirst);
+			s += writeCdata(element.cdata);
+		} else if (type === "comment") {
+			if (opts.ignoreComment) continue;
+			if (opts.spaces) s += writeIndentation(opts.spaces, depth, isFirst);
+			s += writeComment(element.comment);
+		} else if (type === "doctype") {
+			if (opts.ignoreDoctype) continue;
+			if (opts.spaces) s += writeIndentation(opts.spaces, depth, isFirst);
+			s += writeDoctype(element.doctype);
 		}
 	}
-	return str;
+	return s;
 }
 function writeCdata(cdata) {
 	if (cdata == null) return "";
@@ -578,62 +558,26 @@ function writeDoctype(doctype) {
 	return `<!DOCTYPE ${doctype}>`;
 }
 //#endregion
-//#region src/convert.ts
+//#region src/stringify-element.ts
 /**
-* Convert XmlObject (node-xml format) directly to Element (xml-js format).
-* Eliminates the redundant xml() → xml2js() bridge path.
+* Serialize an Element including its own opening/closing tag.
+*
+* `stringify` serializes only an element's children (it treats its input as
+* a document root). Raw-XML round-trip of whole elements needs the element's
+* own tag wrapped around its serialized children.
 */
-function toElement(xmlObject) {
-	const tagName = Object.keys(xmlObject)[0];
-	if (!tagName) return {
-		type: "element",
-		name: ""
-	};
-	const value = xmlObject[tagName];
-	const element = {
-		type: "element",
-		name: tagName
-	};
-	if (value == null) return element;
-	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-		element.elements = [{
-			type: "text",
-			text: String(value)
-		}];
-		return element;
-	}
-	if (Array.isArray(value)) {
-		const children = [];
-		for (const item of value) if (item && typeof item === "object" && "_attr" in item) element.attributes = item._attr;
-		else if (item && typeof item === "object") if (Object.keys(item)[0] === "_cdata") children.push({
-			type: "cdata",
-			cdata: String(item._cdata)
-		});
-		else children.push(toElement(item));
-		else if (item != null) children.push({
-			type: "text",
-			text: String(item)
-		});
-		if (children.length > 0) element.elements = children;
-		return element;
+function stringifyElement(el) {
+	if (!el.name) return "";
+	let attrStr = "";
+	if (el.attributes) for (const key of Object.keys(el.attributes)) {
+		const v = el.attributes[key];
+		if (v === null || v === void 0) continue;
+		attrStr += ` ${key}="${escapeXml(String(v))}"`;
 	}
-	if (typeof value === "object" && value !== null) {
-		const obj = value;
-		if (obj._attr) element.attributes = obj._attr;
-		if (obj._cdata) element.elements = [{
-			type: "cdata",
-			cdata: String(obj._cdata)
-		}];
-	}
-	return element;
-}
-//#endregion
-//#region src/json.ts
-/** Convert XML string to JSON string — xml-js compatible export */
-function xml2json(xml, options) {
-	return JSON.stringify(parse(xml, options));
+	if (!((el.elements?.length ?? 0) > 0 || el.attributes?.["xml:space"] === "preserve")) return `<${el.name}${attrStr}/>`;
+	return `<${el.name}${attrStr}>${stringify(el)}</${el.name}>`;
 }
 //#endregion
-export { allChildren, attr, attrBool, attrMeasure, attrNum, attrs, attrsRaw, childCount, childText, children, collectText, colorAttr, element, escapeXml, findChild, findDeep, findFirst, hasChild, isNonEmpty, stringify as js2xml, stringify, json2xml, nativeTypeValue, parse, parse as xml2js, parseAttributes, selfCloseElement, textOf, toElement, unescapeXml, xml, xml2json };
+export { OOXML_XML_DECLARATION, allChildren, attr, attrBool, attrMeasure, attrNum, attrs, attrsRaw, childCount, childText, children, collectText, colorAttr, element, escapeXml, findChild, findDeep, findFirst, hasChild, isNonEmpty, nativeTypeValue, parse, parseAttributes, selfCloseElement, stringify, stringifyElement, textOf, unescapeXml };
 
 //# sourceMappingURL=index.mjs.map