@office-open/xml 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Demo Macro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# @office-open/xml
+
+![npm version](https://img.shields.io/npm/v/@office-open/xml)
+![npm downloads](https://img.shields.io/npm/dw/@office-open/xml)
+![npm license](https://img.shields.io/npm/l/@office-open/xml)
+![zero dependencies](https://img.shields.io/badge/dependencies-0-green)
+
+> XML parsing and serialization for Office Open XML. Zero dependencies, drop-in replacement for `xml` + `xml-js`.
+
+## Features
+
+- **Zero Dependencies** - No external runtime dependencies, pure TypeScript implementation
+- **xml() Serialization** - Drop-in replacement for the `xml` package
+- **xml2js() Parsing** - Drop-in replacement for `xml-js` XML parsing
+- **js2xml() Stringifying** - Drop-in replacement for `xml-js` JS-to-XML conversion
+- **toElement() Direct Convert** - Direct conversion from xml object format to xml-js Element, 16-33x faster than the xml→xml2js bridge
+- **Complete Type Definitions** - Full type compatibility with `xml` and `xml-js`, import without changes
+- **OOXML Optimized** - Implements all options needed for Office Open XML document generation
+
+## Installation
+
+```bash
+# Install with npm
+$ npm install @office-open/xml
+
+# Install with pnpm
+$ pnpm add @office-open/xml
+```
+
+## Migration from xml + xml-js
+
+Replace your existing imports:
+
+```typescript
+// Before
+import xml from "xml";
+import { xml2js, js2xml } from "xml-js";
+import type { Element } from "xml-js";
+
+// After
+import { xml, xml2js, js2xml } from "@office-open/xml";
+import type { Element } from "@office-open/xml";
+```
+
+No other code changes needed. All options and output formats are compatible.
+
+## Quick Start
+
+```typescript
+import { xml, xml2js, js2xml, toElement } from "@office-open/xml";
+
+// Serialize JS objects to XML
+const xmlStr = xml({ "w:p": [{ _attr: { "w:val": "1" } }, { "w:r": [{ "w:t": "Hello" }] }] });
+// <w:p w:val="1"><w:r><w:t>Hello</w:t></w:r></w:p>
+
+// Parse XML to JS objects
+const parsed = xml2js("<w:t>Hello</w:t>", { compact: false });
+
+// Convert JS objects back to XML
+const output = js2xml(parsed);
+
+// Direct conversion (faster than xml → xml2js bridge)
+const element = toElement({
+    "w:p": [{ _attr: { "w:val": "1" } }, { "w:r": [{ "w:t": "Hello" }] }],
+});
+```
+
+## API
+
+### xml(input, options?)
+
+Serialize JavaScript objects to XML string. Compatible with the `xml` package.
+
+### xml2js(xmlString, options?)
+
+Parse XML string to JavaScript object. Compatible with `xml-js`.
+
+### js2xml(jsObject, options?)
+
+Convert JavaScript object (xml-js Element format) to XML string. Compatible with `xml-js`.
+
+### json2xml(jsObject, options?)
+
+Alias for `js2xml`.
+
+### xml2json(xmlString, options?)
+
+Convenience function that returns `JSON.stringify(xml2js(xmlString, options))`.
+
+### toElement(input)
+
+Direct conversion from xml object format to xml-js Element format. Much faster than the `xml() → xml2js()` bridge path.
+
+### escapeXml(str) / escapeAttributeValue(str)
+
+Low-level XML entity escaping functions.
+
+## Benchmark
+
+Performance comparison against original `xml` (1.0.1) and `xml-js` (1.6.11) packages:
+
+### Serialization (xml)
+
+| Scenario                | @office-open/xml |        xml |   Speedup |
+| ----------------------- | ---------------: | ---------: | --------: |
+| Simple element          |     4,103,029 hz | 734,685 hz | **5.58x** |
+| Nested element          |       940,333 hz | 321,791 hz | **2.92x** |
+| Nested with declaration |       800,517 hz | 262,125 hz | **3.05x** |
+
+### Parsing (xml2js)
+
+| Scenario           | @office-open/xml |    xml-js |    Speedup |
+| ------------------ | ---------------: | --------: | ---------: |
+| Simple XML         |     1,002,659 hz | 83,057 hz | **12.07x** |
+| Complex OOXML      |       357,081 hz | 48,687 hz |  **7.34x** |
+| With captureSpaces |       361,555 hz | 44,868 hz |  **8.06x** |
+
+### Stringifying (js2xml)
+
+| Scenario       | @office-open/xml |     xml-js |   Speedup |
+| -------------- | ---------------: | ---------: | --------: |
+| Simple element |       780,070 hz | 161,521 hz | **4.83x** |
+| Complex OOXML  |       276,878 hz | 106,527 hz | **2.60x** |
+
+### Direct Conversion (toElement vs bridge)
+
+| Scenario |   toElement() | xml() + xml2js() bridge |    Speedup |
+| -------- | ------------: | ----------------------: | ---------: |
+| Simple   | 14,119,071 hz |              853,290 hz | **16.55x** |
+| Nested   |  3,745,934 hz |              422,217 hz |  **8.87x** |
+
+## Bundle Size
+
+|      | @office-open/xml | xml + xml-js |
+| ---- | ---------------: | -----------: |
+| gzip |      **4.22 kB** |       ~15 kB |
+
+## License
+
+- [MIT](LICENSE) &copy; [Demo Macro](https://imst.xyz/)

package/dist/index.d.mts

@@ -0,0 +1,161 @@
+//#region src/serialize.d.ts
+declare function xml(input: Record<string, any> | Record<string, any>[], options?: boolean | string | {
+  indent?: boolean | string;
+  declaration?: boolean | {
+    encoding?: string;
+    standalone?: string;
+  };
+}): string;
+//#endregion
+//#region src/types.d.ts
+interface Attributes {
+  [key: string]: string | number | undefined;
+}
+interface DeclarationAttributes {
+  version?: string | number;
+  encoding?: string;
+  standalone?: string;
+}
+interface Element {
+  declaration?: {
+    attributes?: DeclarationAttributes;
+  };
+  instruction?: string;
+  attributes?: Attributes;
+  cdata?: string;
+  doctype?: string;
+  comment?: string;
+  text?: string | number | boolean;
+  type?: string;
+  name?: string;
+  elements?: Element[];
+  parent?: Element;
+}
+interface ElementCompact {
+  [key: string]: any;
+  _declaration?: {
+    _attributes?: DeclarationAttributes;
+  };
+  _instruction?: {
+    [key: string]: string;
+  };
+  _attributes?: Attributes;
+  _cdata?: string;
+  _doctype?: string;
+  _comment?: string;
+  _text?: string | number;
+}
+interface IgnoreOptions {
+  ignoreDeclaration?: boolean;
+  ignoreInstruction?: boolean;
+  ignoreAttributes?: boolean;
+  ignoreComment?: boolean;
+  ignoreCdata?: boolean;
+  ignoreDoctype?: boolean;
+  ignoreText?: boolean;
+}
+interface Xml2JsOptions extends IgnoreOptions {
+  compact?: boolean;
+  trim?: boolean;
+  sanitize?: boolean;
+  nativeType?: boolean;
+  nativeTypeAttributes?: boolean;
+  addParent?: boolean;
+  alwaysArray?: boolean | string[];
+  alwaysChildren?: boolean;
+  instructionHasAttributes?: boolean;
+  captureSpacesBetweenElements?: boolean;
+  doctypeFn?: (value: string, parentElement: object) => string;
+  instructionFn?: (value: string, instructionName: string, parentElement: string) => string;
+  cdataFn?: (value: string, parentElement: object) => string;
+  commentFn?: (value: string, parentElement: object) => string;
+  textFn?: (value: string, parentElement: object) => string;
+  instructionNameFn?: (instructionName: string, instructionValue: string, parentElement: string) => string;
+  elementNameFn?: (value: string, parentElement: object) => string;
+  attributeNameFn?: (attributeName: string, attributeValue: string, parentElement: string) => string;
+  attributeValueFn?: (attributeValue: string, attributeName: string, parentElement: string) => string;
+  attributesFn?: (value: Attributes, parentElement: string) => Attributes;
+}
+interface Js2XmlOptions extends IgnoreOptions {
+  spaces?: number | string;
+  compact?: boolean;
+  indentText?: boolean;
+  indentCdata?: boolean;
+  indentAttributes?: boolean;
+  indentInstruction?: boolean;
+  fullTagEmptyElement?: boolean;
+  noQuotesForNativeAttributes?: boolean;
+  doctypeFn?: (value: string, currentElementName: string, currentElementObj: object) => string;
+  instructionFn?: (instructionValue: string, instructionName: string, currentElementName: string, currentElementObj: object) => string;
+  cdataFn?: (value: string, currentElementName: string, currentElementObj: object) => string;
+  commentFn?: (value: string, currentElementName: string, currentElementObj: object) => string;
+  textFn?: (value: string, currentElementName: string, currentElementObj: object) => string;
+  instructionNameFn?: (instructionName: string, instructionValue: string, currentElementName: string, currentElementObj: object) => string;
+  elementNameFn?: (value: string, currentElementName: string, currentElementObj: object) => string;
+  attributeNameFn?: (attributeName: string, attributeValue: string, currentElementName: string, currentElementObj: object) => string;
+  attributeValueFn?: (attributeValue: string, attributeName: string, currentElementName: string, currentElementObj: object) => string;
+  attributesFn?: (value: Attributes, currentElementName: string, currentElementObj: object) => Attributes;
+  fullTagEmptyElementFn?: (currentElementName: string, currentElementObj: object) => boolean;
+}
+interface XmlOption {
+  indent?: string;
+  stream?: boolean;
+  declaration?: boolean | {
+    encoding?: string;
+    standalone?: string;
+  };
+}
+interface XmlAttrs {
+  [attr: string]: XmlAtom;
+}
+type XmlAtom = string | number | boolean | null;
+interface ElementObject {
+  push(xmlObject: XmlObject): void;
+  close(xmlObject?: XmlObject): void;
+}
+type XmlDesc = {
+  _attr: XmlAttrs;
+} | {
+  _cdata: string;
+} | {
+  _attr: XmlAttrs;
+  _cdata: string;
+} | XmlAtom | XmlAtom[] | XmlDescArray;
+interface XmlDescArray {
+  [index: number]: {
+    _attr: XmlAttrs;
+  } | XmlObject;
+}
+type XmlObject = {
+  [tag: string]: ElementObject | XmlDesc;
+} | XmlDesc;
+//#endregion
+//#region src/parse.d.ts
+declare function xml2js(xmlString: string, options?: Xml2JsOptions): Element;
+//#endregion
+//#region src/stringify.d.ts
+declare function js2xml(js: Element, options?: Js2XmlOptions): string;
+/** Alias for js2xml — xml-js compatible export */
+declare function json2xml(json: Element, options?: Js2XmlOptions): string;
+//#endregion
+//#region src/convert.d.ts
+/**
+ * Convert XmlObject (node-xml format) directly to Element (xml-js format).
+ * Eliminates the redundant xml() → xml2js() bridge path.
+ */
+declare function toElement(xmlObject: Record<string, any>): Element;
+//#endregion
+//#region src/escape.d.ts
+/** Escape text content for XML */
+declare function escapeXml(str: string): string;
+/**
+ * Escape attribute value matching xml-js's js2xml behavior.
+ * Handles already-escaped entities to prevent double-escaping.
+ */
+declare function escapeAttributeValue(str: string): string;
+//#endregion
+//#region src/json.d.ts
+/** Convert XML string to JSON string — xml-js compatible export */
+declare function xml2json(xml: string, options?: Xml2JsOptions): string;
+//#endregion
+export { Attributes, DeclarationAttributes, Element, ElementCompact, ElementObject, IgnoreOptions, Js2XmlOptions, Xml2JsOptions, XmlAtom, XmlAttrs, XmlDesc, XmlDescArray, XmlObject, XmlOption, escapeAttributeValue, escapeXml, js2xml, json2xml, toElement, xml, xml2js, xml2json };

package/dist/index.mjs

@@ -0,0 +1,502 @@
+//#region src/escape.ts
+const XML_CHAR_MAP = {
+	"&": "&",
+	"\"": """,
+	"'": "'",
+	"<": "&lt;",
+	">": "&gt;"
+};
+const XML_CHAR_PATTERN = /([&"<>'])/g;
+/** Escape text content for XML */
+function escapeXml(str) {
+	return str.replace(XML_CHAR_PATTERN, (ch) => XML_CHAR_MAP[ch]);
+}
+/**
+* Escape attribute value matching xml-js's js2xml behavior.
+* Handles already-escaped entities to prevent double-escaping.
+*/
+function escapeAttributeValue(str) {
+	return String(str).replace(/&(?!amp;|lt;|gt;|quot;|apos;)/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+//#endregion
+//#region src/serialize.ts
+const DEFAULT_INDENT = "    ";
+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;
+		let decl = "<?xml version=\"1.0\" encoding=\"" + enc + "\"";
+		if (sa) decl += " standalone=\"" + sa + "\"";
+		decl += "?>";
+		parts.push(decl);
+		if (opts.indent) parts.push("\n");
+	}
+	const items = Array.isArray(input) ? input : [input];
+	for (let i = 0; i < items.length; i++) {
+		parts.push(formatElement(resolve(items[i], 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
+	};
+}
+function resolve(data, indent, depth) {
+	const name = Object.keys(data)[0];
+	const values = data[name];
+	const attributes = [];
+	const content = [];
+	if (values == null) return {
+		name,
+		attributes,
+		content,
+		indent,
+		depth,
+		emptyArray: false
+	};
+	switch (typeof values) {
+		case "object":
+			if (values._attr) for (const key of Object.keys(values._attr)) attributes.push(`${key}="${escapeXml(String(values._attr[key]))}"`);
+			if (values._cdata) {
+				const escaped = String(values._cdata).replace(/\]\]>/g, "]]]]><![CDATA[>");
+				content.push(`<![CDATA[${escaped}]]>`);
+			}
+			if (Array.isArray(values)) {
+				if (values.length === 0) return {
+					name,
+					attributes,
+					content,
+					indent,
+					depth,
+					emptyArray: true
+				};
+				for (const value of values) if (value && typeof value === "object" && "_attr" in value) for (const key of Object.keys(value._attr)) attributes.push(`${key}="${escapeXml(String(value._attr[key]))}"`);
+				else if (value && typeof value === "object") content.push(resolve(value, indent, depth + 1));
+				else if (value != null) content.push(escapeXml(String(value)));
+			}
+			break;
+		default: content.push(escapeXml(String(values)));
+	}
+	return {
+		name,
+		attributes,
+		content,
+		indent,
+		depth,
+		emptyArray: false
+	};
+}
+function formatElement(elem) {
+	const { name, attributes, content, indent, depth } = elem;
+	const hasChildren = content.length > 0;
+	const ind = indent ? indent.repeat(depth) : "";
+	const attrStr = attributes.length ? " " + attributes.join(" ") : "";
+	if (!hasChildren) {
+		if (elem.emptyArray) return `${ind}<${name}${attrStr}></${name}>`;
+		return `${ind}<${name}${attrStr}/>`;
+	}
+	const textContent = content.length === 1 && typeof content[0] === "string" ? content[0] : null;
+	if (textContent !== null && !indent) return `<${name}${attrStr}>${textContent}</${name}>`;
+	if (textContent !== null) return `${ind}<${name}${attrStr}>${textContent}</${name}>`;
+	const parts = [];
+	parts.push(`${ind}<${name}${attrStr}>`);
+	if (indent) parts.push("\n");
+	for (const child of content) {
+		if (typeof child === "string") parts.push(`${indent.repeat(depth + 1)}${child}`);
+		else parts.push(formatElement(child));
+		if (indent) parts.push("\n");
+	}
+	parts.push(`${ind}</${name}>`);
+	return parts.join("");
+}
+//#endregion
+//#region src/parse.ts
+const ENTITY_MAP = {
+	"&amp;": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&apos;": "'"
+};
+const ENTITY_PATTERN = /&(amp|lt|gt|quot|apos);/g;
+function unescapeXml(str) {
+	return str.replace(ENTITY_PATTERN, (match) => ENTITY_MAP[match]);
+}
+function nativeTypeValue(value) {
+	const n = Number(value);
+	if (!isNaN(n)) return n;
+	const lower = value.toLowerCase();
+	if (lower === "true") return true;
+	if (lower === "false") return false;
+	return value;
+}
+function xml2js(xmlString, options) {
+	const captureSpaces = options?.captureSpacesBetweenElements ?? false;
+	const trim = options?.trim ?? false;
+	const ignoreDeclaration = options?.ignoreDeclaration ?? false;
+	const ignoreText = options?.ignoreText ?? false;
+	const ignoreComment = options?.ignoreComment ?? false;
+	const ignoreCdata = options?.ignoreCdata ?? false;
+	const ignoreDoctype = options?.ignoreDoctype ?? false;
+	const nativeTypeAttributes = options?.nativeTypeAttributes ?? false;
+	const result = {};
+	const stack = [result];
+	let i = 0;
+	const len = xmlString.length;
+	while (i < len) {
+		if (!captureSpaces && isWhitespace(xmlString.charCodeAt(i))) {
+			i++;
+			continue;
+		}
+		if (xmlString.charCodeAt(i) !== 60) {
+			const start = i;
+			while (i < len && xmlString.charCodeAt(i) !== 60) i++;
+			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) addField(stack[stack.length - 1], "text", text);
+			}
+			continue;
+		}
+		i++;
+		if (xmlString.charCodeAt(i) === 63) {
+			const end = xmlString.indexOf("?>", i + 1);
+			if (end === -1) break;
+			const body = xmlString.slice(i + 1, end);
+			i = end + 2;
+			const xmlMatch = body.match(/^xml\s+(.*)$/s);
+			if (xmlMatch) {
+				if (!ignoreDeclaration) {
+					if (!result.declaration) result.declaration = {};
+					const attrs = parseAttributes(xmlMatch[1]);
+					if (nativeTypeAttributes) for (const key of Object.keys(attrs)) attrs[key] = nativeTypeValue(attrs[key]);
+					result.declaration.attributes = attrs;
+				}
+			}
+			continue;
+		}
+		if (xmlString.charCodeAt(i) === 33 && xmlString.slice(i, i + 3) === "!--") {
+			const end = xmlString.indexOf("-->", i + 3);
+			if (end === -1) break;
+			const comment = xmlString.slice(i + 3, end);
+			i = end + 3;
+			if (!ignoreComment) if (trim) addField(stack[stack.length - 1], "comment", comment.trim());
+			else addField(stack[stack.length - 1], "comment", comment);
+			continue;
+		}
+		if (xmlString.charCodeAt(i) === 33 && xmlString.slice(i, i + 8) === "![CDATA[") {
+			const end = xmlString.indexOf("]]>", i + 8);
+			if (end === -1) break;
+			const cdata = xmlString.slice(i + 8, end);
+			i = end + 3;
+			if (!ignoreCdata) if (trim) addField(stack[stack.length - 1], "cdata", cdata.trim());
+			else addField(stack[stack.length - 1], "cdata", cdata);
+			continue;
+		}
+		if (xmlString.charCodeAt(i) === 33 && xmlString.slice(i, i + 9) === "!DOCTYPE") {
+			const end = xmlString.indexOf(">", i + 9);
+			if (end === -1) break;
+			const doctype = xmlString.slice(i + 9, end).trim();
+			i = end + 1;
+			if (!ignoreDoctype) addField(stack[stack.length - 1], "doctype", doctype);
+			continue;
+		}
+		if (xmlString.charCodeAt(i) === 47) {
+			const end = xmlString.indexOf(">", i + 1);
+			if (end === -1) break;
+			i = end + 1;
+			stack.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 of Object.keys(attributes.attrs)) attributes.attrs[key] = nativeTypeValue(attributes.attrs[key]);
+		const isSelfClosing = xmlString.charCodeAt(pos) === 47;
+		if (isSelfClosing) pos += 2;
+		else pos++;
+		const element = {
+			type: "element",
+			name: tagName
+		};
+		if (Object.keys(attributes.attrs).length > 0) element.attributes = attributes.attrs;
+		const parent = stack[stack.length - 1];
+		if (!parent.elements) parent.elements = [];
+		parent.elements.push(element);
+		if (!isSelfClosing) stack.push(element);
+		i = pos;
+	}
+	if (result.elements) {
+		const temp = result.elements;
+		delete result.elements;
+		result.elements = temp;
+		delete result.text;
+	}
+	return result;
+}
+function findTagNameEnd(str, start) {
+	let i = start;
+	const len = str.length;
+	while (i < len) {
+		const ch = str.charCodeAt(i);
+		if (ch === 32 || ch === 9 || ch === 10 || ch === 13 || ch === 47 || ch === 62) return i;
+		i++;
+	}
+	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] = str.slice(valueStart, i);
+		i++;
+	}
+	return {
+		attrs,
+		pos: i
+	};
+}
+function parseAttributes(str) {
+	const result = {};
+	let i = 0;
+	const len = str.length;
+	while (i < len) {
+		while (i < len && isWhitespace(str.charCodeAt(i))) i++;
+		if (i >= len) break;
+		const nameStart = i;
+		while (i < len && str.charCodeAt(i) !== 61) {
+			if (isWhitespace(str.charCodeAt(i))) break;
+			i++;
+		}
+		const name = str.slice(nameStart, i);
+		while (i < len && isWhitespace(str.charCodeAt(i))) i++;
+		if (i >= len || 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++;
+		result[name] = str.slice(valueStart, i);
+		i++;
+	}
+	return result;
+}
+function addField(parent, type, value) {
+	if (!parent.elements) parent.elements = [];
+	const element = { type };
+	element[type] = value;
+	parent.elements.push(element);
+}
+function isWhitespace(ch) {
+	return ch === 32 || ch === 9 || ch === 10 || ch === 13;
+}
+//#endregion
+//#region src/stringify.ts
+function js2xml(js, options) {
+	const opts = normalizeOptions(options);
+	const parts = [];
+	if (js.declaration && !opts.ignoreDeclaration) parts.push(writeDeclaration(js.declaration));
+	if (js.elements?.length) parts.push(writeElements(js.elements, opts, 0, !parts.length));
+	return parts.join("");
+}
+/** Alias for js2xml — xml-js compatible export */
+function json2xml(json, options) {
+	return js2xml(json, options);
+}
+function normalizeOptions(options) {
+	if (!options) return {
+		spaces: "",
+		ignoreDeclaration: false,
+		ignoreText: false,
+		ignoreComment: false,
+		ignoreCdata: false,
+		ignoreDoctype: false,
+		fullTagEmptyElement: false,
+		indentText: false,
+		indentCdata: false
+	};
+	let spaces = "";
+	if (options.spaces != null) spaces = typeof options.spaces === "number" ? " ".repeat(options.spaces) : options.spaces;
+	return {
+		spaces,
+		ignoreDeclaration: options.ignoreDeclaration ?? false,
+		ignoreText: options.ignoreText ?? false,
+		ignoreComment: options.ignoreComment ?? false,
+		ignoreCdata: options.ignoreCdata ?? false,
+		ignoreDoctype: options.ignoreDoctype ?? false,
+		fullTagEmptyElement: options.fullTagEmptyElement ?? false,
+		indentText: options.indentText ?? false,
+		indentCdata: options.indentCdata ?? false,
+		attributeValueFn: options.attributeValueFn
+	};
+}
+function writeIndentation(spaces, depth, firstLine) {
+	return (!firstLine && spaces ? "\n" : "") + spaces.repeat(depth);
+}
+function writeDeclaration(declaration) {
+	const attrs = declaration.attributes;
+	if (!attrs) return "<?xml version=\"1.0\"?>";
+	let result = "<?xml version=\"1.0\"";
+	if (attrs.encoding) result += ` encoding="${attrs.encoding}"`;
+	if (attrs.standalone) result += ` standalone="${attrs.standalone}"`;
+	return result + "?>";
+}
+function writeAttributes(attributes, elementName, element, attributeValueFn) {
+	const parts = [];
+	for (const key of Object.keys(attributes)) {
+		const value = attributes[key];
+		if (value === null || value === void 0) continue;
+		let attr = String(value).replace(/"/g, "&quot;");
+		if (attributeValueFn) attr = attributeValueFn(attr, key, elementName, element);
+		parts.push(` ${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("");
+}
+function writeElements(elements, opts, depth, firstLine) {
+	let result = "";
+	for (let i = 0; i < elements.length; i++) {
+		const element = elements[i];
+		const isFirst = firstLine && i === 0;
+		switch (element.type) {
+			case "element":
+				result += writeIndentation(opts.spaces, depth, isFirst);
+				result += writeElement(element, opts, depth);
+				break;
+			case "text":
+				if (opts.ignoreText) continue;
+				if (opts.indentText) result += writeIndentation(opts.spaces, depth, isFirst);
+				result += writeText(element.text);
+				break;
+			case "cdata":
+				if (opts.ignoreCdata) continue;
+				if (opts.indentCdata) result += writeIndentation(opts.spaces, depth, isFirst);
+				result += writeCdata(element.cdata);
+				break;
+			case "comment":
+				if (opts.ignoreComment) continue;
+				result += writeIndentation(opts.spaces, depth, isFirst);
+				result += writeComment(element.comment);
+				break;
+			case "doctype":
+				if (opts.ignoreDoctype) continue;
+				result += writeIndentation(opts.spaces, depth, isFirst);
+				result += writeDoctype(element.doctype);
+				break;
+			default: break;
+		}
+	}
+	return result;
+}
+function writeText(text) {
+	if (text == null) return "";
+	return String(text).replace(/&amp;/g, "&").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function writeCdata(cdata) {
+	if (cdata == null) return "";
+	return `<![CDATA[${cdata.replace(/\]\]>/g, "]]]]><![CDATA[>")}]]>`;
+}
+function writeComment(comment) {
+	if (comment == null) return "";
+	return `<!--${comment}-->`;
+}
+function writeDoctype(doctype) {
+	if (doctype == null) return "";
+	return `<!DOCTYPE ${doctype}>`;
+}
+//#endregion
+//#region src/convert.ts
+/**
+* Convert XmlObject (node-xml format) directly to Element (xml-js format).
+* Eliminates the redundant xml() → xml2js() bridge path.
+*/
+function toElement(xmlObject) {
+	const tagName = Object.keys(xmlObject)[0];
+	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;
+	}
+	if (typeof value === "object") {
+		if (value._attr) element.attributes = value._attr;
+		if (value._cdata) element.elements = [{
+			type: "cdata",
+			cdata: String(value._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(xml2js(xml, options));
+}
+//#endregion
+export { escapeAttributeValue, escapeXml, js2xml, json2xml, toElement, xml, xml2js, xml2json };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@office-open/xml",
+  "version": "0.1.0",
+  "description": "XML parsing and serialization, replacing xml + xml-js",
+  "keywords": [
+    "office-open",
+    "ooxml",
+    "parse",
+    "serialize",
+    "xml"
+  ],
+  "homepage": "https://github.com/DemoMacro/office-open#readme",
+  "bugs": {
+    "url": "https://github.com/DemoMacro/office-open/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Demo Macro",
+    "email": "abc@imst.xyz",
+    "url": "https://imst.xyz/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DemoMacro/office-open.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "devDependencies": {
+    "@types/xml": "1.0.11",
+    "xml": "1.0.1",
+    "xml-js": "1.6.11"
+  },
+  "scripts": {
+    "dev": "basis build --stub",
+    "build": "basis build"
+  }
+}