xml-model 1.3.3 → 2.0.0-beta.2

package/dist/node_modules/xml-js/lib/array-helper.js

@@ -0,0 +1,13 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/xml-js/lib/array-helper.js
+var require_array_helper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = { isArray: function(value) {
+		if (Array.isArray) return Array.isArray(value);
+		return Object.prototype.toString.call(value) === "[object Array]";
+	} };
+}));
+//#endregion
+export default require_array_helper();
+export { require_array_helper };
+
+//# sourceMappingURL=array-helper.js.map

package/dist/node_modules/xml-js/lib/index.js

@@ -0,0 +1,19 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+import { require_xml2js } from "./xml2js.js";
+import { require_xml2json } from "./xml2json.js";
+import { require_js2xml } from "./js2xml.js";
+import { require_json2xml } from "./json2xml.js";
+//#region node_modules/xml-js/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		xml2js: require_xml2js(),
+		xml2json: require_xml2json(),
+		js2xml: require_js2xml(),
+		json2xml: require_json2xml()
+	};
+}));
+//#endregion
+export default require_lib();
+export { require_lib };
+
+//# sourceMappingURL=index.js.map

package/dist/node_modules/xml-js/lib/js2xml.js

@@ -0,0 +1,258 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+import { require_array_helper } from "./array-helper.js";
+import { require_options_helper } from "./options-helper.js";
+//#region node_modules/xml-js/lib/js2xml.js
+var require_js2xml = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var helper = require_options_helper();
+	var isArray = require_array_helper().isArray;
+	var currentElement, currentElementName;
+	function validateOptions(userOptions) {
+		var options = helper.copyOptions(userOptions);
+		helper.ensureFlagExists("ignoreDeclaration", options);
+		helper.ensureFlagExists("ignoreInstruction", options);
+		helper.ensureFlagExists("ignoreAttributes", options);
+		helper.ensureFlagExists("ignoreText", options);
+		helper.ensureFlagExists("ignoreComment", options);
+		helper.ensureFlagExists("ignoreCdata", options);
+		helper.ensureFlagExists("ignoreDoctype", options);
+		helper.ensureFlagExists("compact", options);
+		helper.ensureFlagExists("indentText", options);
+		helper.ensureFlagExists("indentCdata", options);
+		helper.ensureFlagExists("indentAttributes", options);
+		helper.ensureFlagExists("indentInstruction", options);
+		helper.ensureFlagExists("fullTagEmptyElement", options);
+		helper.ensureFlagExists("noQuotesForNativeAttributes", options);
+		helper.ensureSpacesExists(options);
+		if (typeof options.spaces === "number") options.spaces = Array(options.spaces + 1).join(" ");
+		helper.ensureKeyExists("declaration", options);
+		helper.ensureKeyExists("instruction", options);
+		helper.ensureKeyExists("attributes", options);
+		helper.ensureKeyExists("text", options);
+		helper.ensureKeyExists("comment", options);
+		helper.ensureKeyExists("cdata", options);
+		helper.ensureKeyExists("doctype", options);
+		helper.ensureKeyExists("type", options);
+		helper.ensureKeyExists("name", options);
+		helper.ensureKeyExists("elements", options);
+		helper.checkFnExists("doctype", options);
+		helper.checkFnExists("instruction", options);
+		helper.checkFnExists("cdata", options);
+		helper.checkFnExists("comment", options);
+		helper.checkFnExists("text", options);
+		helper.checkFnExists("instructionName", options);
+		helper.checkFnExists("elementName", options);
+		helper.checkFnExists("attributeName", options);
+		helper.checkFnExists("attributeValue", options);
+		helper.checkFnExists("attributes", options);
+		helper.checkFnExists("fullTagEmptyElement", options);
+		return options;
+	}
+	function writeIndentation(options, depth, firstLine) {
+		return (!firstLine && options.spaces ? "\n" : "") + Array(depth + 1).join(options.spaces);
+	}
+	function writeAttributes(attributes, options, depth) {
+		if (options.ignoreAttributes) return "";
+		if ("attributesFn" in options) attributes = options.attributesFn(attributes, currentElementName, currentElement);
+		var key, attr, attrName, quote, result = [];
+		for (key in attributes) if (attributes.hasOwnProperty(key) && attributes[key] !== null && attributes[key] !== void 0) {
+			quote = options.noQuotesForNativeAttributes && typeof attributes[key] !== "string" ? "" : "\"";
+			attr = "" + attributes[key];
+			attr = attr.replace(/"/g, """);
+			attrName = "attributeNameFn" in options ? options.attributeNameFn(key, attr, currentElementName, currentElement) : key;
+			result.push(options.spaces && options.indentAttributes ? writeIndentation(options, depth + 1, false) : " ");
+			result.push(attrName + "=" + quote + ("attributeValueFn" in options ? options.attributeValueFn(attr, key, currentElementName, currentElement) : attr) + quote);
+		}
+		if (attributes && Object.keys(attributes).length && options.spaces && options.indentAttributes) result.push(writeIndentation(options, depth, false));
+		return result.join("");
+	}
+	function writeDeclaration(declaration, options, depth) {
+		currentElement = declaration;
+		currentElementName = "xml";
+		return options.ignoreDeclaration ? "" : "<?xml" + writeAttributes(declaration[options.attributesKey], options, depth) + "?>";
+	}
+	function writeInstruction(instruction, options, depth) {
+		if (options.ignoreInstruction) return "";
+		var key;
+		for (key in instruction) if (instruction.hasOwnProperty(key)) break;
+		var instructionName = "instructionNameFn" in options ? options.instructionNameFn(key, instruction[key], currentElementName, currentElement) : key;
+		if (typeof instruction[key] === "object") {
+			currentElement = instruction;
+			currentElementName = instructionName;
+			return "<?" + instructionName + writeAttributes(instruction[key][options.attributesKey], options, depth) + "?>";
+		} else {
+			var instructionValue = instruction[key] ? instruction[key] : "";
+			if ("instructionFn" in options) instructionValue = options.instructionFn(instructionValue, key, currentElementName, currentElement);
+			return "<?" + instructionName + (instructionValue ? " " + instructionValue : "") + "?>";
+		}
+	}
+	function writeComment(comment, options) {
+		return options.ignoreComment ? "" : "<!--" + ("commentFn" in options ? options.commentFn(comment, currentElementName, currentElement) : comment) + "-->";
+	}
+	function writeCdata(cdata, options) {
+		return options.ignoreCdata ? "" : "<![CDATA[" + ("cdataFn" in options ? options.cdataFn(cdata, currentElementName, currentElement) : cdata.replace("]]>", "]]]]><![CDATA[>")) + "]]>";
+	}
+	function writeDoctype(doctype, options) {
+		return options.ignoreDoctype ? "" : "<!DOCTYPE " + ("doctypeFn" in options ? options.doctypeFn(doctype, currentElementName, currentElement) : doctype) + ">";
+	}
+	function writeText(text, options) {
+		if (options.ignoreText) return "";
+		text = "" + text;
+		text = text.replace(/&amp;/g, "&");
+		text = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+		return "textFn" in options ? options.textFn(text, currentElementName, currentElement) : text;
+	}
+	function hasContent(element, options) {
+		var i;
+		if (element.elements && element.elements.length) for (i = 0; i < element.elements.length; ++i) switch (element.elements[i][options.typeKey]) {
+			case "text":
+				if (options.indentText) return true;
+				break;
+			case "cdata":
+				if (options.indentCdata) return true;
+				break;
+			case "instruction":
+				if (options.indentInstruction) return true;
+				break;
+			case "doctype":
+			case "comment":
+			case "element": return true;
+			default: return true;
+		}
+		return false;
+	}
+	function writeElement(element, options, depth) {
+		currentElement = element;
+		currentElementName = element.name;
+		var xml = [], elementName = "elementNameFn" in options ? options.elementNameFn(element.name, element) : element.name;
+		xml.push("<" + elementName);
+		if (element[options.attributesKey]) xml.push(writeAttributes(element[options.attributesKey], options, depth));
+		var withClosingTag = element[options.elementsKey] && element[options.elementsKey].length || element[options.attributesKey] && element[options.attributesKey]["xml:space"] === "preserve";
+		if (!withClosingTag) if ("fullTagEmptyElementFn" in options) withClosingTag = options.fullTagEmptyElementFn(element.name, element);
+		else withClosingTag = options.fullTagEmptyElement;
+		if (withClosingTag) {
+			xml.push(">");
+			if (element[options.elementsKey] && element[options.elementsKey].length) {
+				xml.push(writeElements(element[options.elementsKey], options, depth + 1));
+				currentElement = element;
+				currentElementName = element.name;
+			}
+			xml.push(options.spaces && hasContent(element, options) ? "\n" + Array(depth + 1).join(options.spaces) : "");
+			xml.push("</" + elementName + ">");
+		} else xml.push("/>");
+		return xml.join("");
+	}
+	function writeElements(elements, options, depth, firstLine) {
+		return elements.reduce(function(xml, element) {
+			var indent = writeIndentation(options, depth, firstLine && !xml);
+			switch (element.type) {
+				case "element": return xml + indent + writeElement(element, options, depth);
+				case "comment": return xml + indent + writeComment(element[options.commentKey], options);
+				case "doctype": return xml + indent + writeDoctype(element[options.doctypeKey], options);
+				case "cdata": return xml + (options.indentCdata ? indent : "") + writeCdata(element[options.cdataKey], options);
+				case "text": return xml + (options.indentText ? indent : "") + writeText(element[options.textKey], options);
+				case "instruction":
+					var instruction = {};
+					instruction[element[options.nameKey]] = element[options.attributesKey] ? element : element[options.instructionKey];
+					return xml + (options.indentInstruction ? indent : "") + writeInstruction(instruction, options, depth);
+			}
+		}, "");
+	}
+	function hasContentCompact(element, options, anyContent) {
+		var key;
+		for (key in element) if (element.hasOwnProperty(key)) switch (key) {
+			case options.parentKey:
+			case options.attributesKey: break;
+			case options.textKey:
+				if (options.indentText || anyContent) return true;
+				break;
+			case options.cdataKey:
+				if (options.indentCdata || anyContent) return true;
+				break;
+			case options.instructionKey:
+				if (options.indentInstruction || anyContent) return true;
+				break;
+			case options.doctypeKey:
+			case options.commentKey: return true;
+			default: return true;
+		}
+		return false;
+	}
+	function writeElementCompact(element, name, options, depth, indent) {
+		currentElement = element;
+		currentElementName = name;
+		var elementName = "elementNameFn" in options ? options.elementNameFn(name, element) : name;
+		if (typeof element === "undefined" || element === null || element === "") return "fullTagEmptyElementFn" in options && options.fullTagEmptyElementFn(name, element) || options.fullTagEmptyElement ? "<" + elementName + "></" + elementName + ">" : "<" + elementName + "/>";
+		var xml = [];
+		if (name) {
+			xml.push("<" + elementName);
+			if (typeof element !== "object") {
+				xml.push(">" + writeText(element, options) + "</" + elementName + ">");
+				return xml.join("");
+			}
+			if (element[options.attributesKey]) xml.push(writeAttributes(element[options.attributesKey], options, depth));
+			var withClosingTag = hasContentCompact(element, options, true) || element[options.attributesKey] && element[options.attributesKey]["xml:space"] === "preserve";
+			if (!withClosingTag) if ("fullTagEmptyElementFn" in options) withClosingTag = options.fullTagEmptyElementFn(name, element);
+			else withClosingTag = options.fullTagEmptyElement;
+			if (withClosingTag) xml.push(">");
+			else {
+				xml.push("/>");
+				return xml.join("");
+			}
+		}
+		xml.push(writeElementsCompact(element, options, depth + 1, false));
+		currentElement = element;
+		currentElementName = name;
+		if (name) xml.push((indent ? writeIndentation(options, depth, false) : "") + "</" + elementName + ">");
+		return xml.join("");
+	}
+	function writeElementsCompact(element, options, depth, firstLine) {
+		var i, key, nodes, xml = [];
+		for (key in element) if (element.hasOwnProperty(key)) {
+			nodes = isArray(element[key]) ? element[key] : [element[key]];
+			for (i = 0; i < nodes.length; ++i) {
+				switch (key) {
+					case options.declarationKey:
+						xml.push(writeDeclaration(nodes[i], options, depth));
+						break;
+					case options.instructionKey:
+						xml.push((options.indentInstruction ? writeIndentation(options, depth, firstLine) : "") + writeInstruction(nodes[i], options, depth));
+						break;
+					case options.attributesKey:
+					case options.parentKey: break;
+					case options.textKey:
+						xml.push((options.indentText ? writeIndentation(options, depth, firstLine) : "") + writeText(nodes[i], options));
+						break;
+					case options.cdataKey:
+						xml.push((options.indentCdata ? writeIndentation(options, depth, firstLine) : "") + writeCdata(nodes[i], options));
+						break;
+					case options.doctypeKey:
+						xml.push(writeIndentation(options, depth, firstLine) + writeDoctype(nodes[i], options));
+						break;
+					case options.commentKey:
+						xml.push(writeIndentation(options, depth, firstLine) + writeComment(nodes[i], options));
+						break;
+					default: xml.push(writeIndentation(options, depth, firstLine) + writeElementCompact(nodes[i], key, options, depth, hasContentCompact(nodes[i], options)));
+				}
+				firstLine = firstLine && !xml.length;
+			}
+		}
+		return xml.join("");
+	}
+	module.exports = function(js, options) {
+		options = validateOptions(options);
+		var xml = [];
+		currentElement = js;
+		currentElementName = "_root_";
+		if (options.compact) xml.push(writeElementsCompact(js, options, 0, true));
+		else {
+			if (js[options.declarationKey]) xml.push(writeDeclaration(js[options.declarationKey], options, 0));
+			if (js[options.elementsKey] && js[options.elementsKey].length) xml.push(writeElements(js[options.elementsKey], options, 0, !xml.length));
+		}
+		return xml.join("");
+	};
+}));
+//#endregion
+export default require_js2xml();
+export { require_js2xml };
+
+//# sourceMappingURL=js2xml.js.map

package/dist/node_modules/xml-js/lib/json2xml.js

@@ -0,0 +1,22 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+import { require_js2xml } from "./js2xml.js";
+//#region node_modules/xml-js/lib/json2xml.js
+var require_json2xml = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var js2xml = require_js2xml();
+	module.exports = function(json, options) {
+		if (json instanceof Buffer) json = json.toString();
+		var js = null;
+		if (typeof json === "string") try {
+			js = JSON.parse(json);
+		} catch (e) {
+			throw new Error("The JSON structure is invalid");
+		}
+		else js = json;
+		return js2xml(js, options);
+	};
+}));
+//#endregion
+export default require_json2xml();
+export { require_json2xml };
+
+//# sourceMappingURL=json2xml.js.map

package/dist/node_modules/xml-js/lib/options-helper.js

@@ -0,0 +1,33 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+import { require_array_helper } from "./array-helper.js";
+//#region node_modules/xml-js/lib/options-helper.js
+var require_options_helper = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArray = require_array_helper().isArray;
+	module.exports = {
+		copyOptions: function(options) {
+			var key, copy = {};
+			for (key in options) if (options.hasOwnProperty(key)) copy[key] = options[key];
+			return copy;
+		},
+		ensureFlagExists: function(item, options) {
+			if (!(item in options) || typeof options[item] !== "boolean") options[item] = false;
+		},
+		ensureSpacesExists: function(options) {
+			if (!("spaces" in options) || typeof options.spaces !== "number" && typeof options.spaces !== "string") options.spaces = 0;
+		},
+		ensureAlwaysArrayExists: function(options) {
+			if (!("alwaysArray" in options) || typeof options.alwaysArray !== "boolean" && !isArray(options.alwaysArray)) options.alwaysArray = false;
+		},
+		ensureKeyExists: function(key, options) {
+			if (!(key + "Key" in options) || typeof options[key + "Key"] !== "string") options[key + "Key"] = options.compact ? "_" + key : key;
+		},
+		checkFnExists: function(key, options) {
+			return key + "Fn" in options;
+		}
+	};
+}));
+//#endregion
+export default require_options_helper();
+export { require_options_helper };
+
+//# sourceMappingURL=options-helper.js.map

package/dist/node_modules/xml-js/lib/xml2js.js

@@ -0,0 +1,246 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+import { require_sax } from "../../sax/lib/sax.js";
+import { require_array_helper } from "./array-helper.js";
+import { require_options_helper } from "./options-helper.js";
+//#region node_modules/xml-js/lib/xml2js.js
+var require_xml2js = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var sax = require_sax();
+	var expat = {
+		on: function() {},
+		parse: function() {}
+	};
+	var helper = require_options_helper();
+	var isArray = require_array_helper().isArray;
+	var options;
+	var pureJsParser = true;
+	var currentElement;
+	function validateOptions(userOptions) {
+		options = helper.copyOptions(userOptions);
+		helper.ensureFlagExists("ignoreDeclaration", options);
+		helper.ensureFlagExists("ignoreInstruction", options);
+		helper.ensureFlagExists("ignoreAttributes", options);
+		helper.ensureFlagExists("ignoreText", options);
+		helper.ensureFlagExists("ignoreComment", options);
+		helper.ensureFlagExists("ignoreCdata", options);
+		helper.ensureFlagExists("ignoreDoctype", options);
+		helper.ensureFlagExists("compact", options);
+		helper.ensureFlagExists("alwaysChildren", options);
+		helper.ensureFlagExists("addParent", options);
+		helper.ensureFlagExists("trim", options);
+		helper.ensureFlagExists("nativeType", options);
+		helper.ensureFlagExists("nativeTypeAttributes", options);
+		helper.ensureFlagExists("sanitize", options);
+		helper.ensureFlagExists("instructionHasAttributes", options);
+		helper.ensureFlagExists("captureSpacesBetweenElements", options);
+		helper.ensureAlwaysArrayExists(options);
+		helper.ensureKeyExists("declaration", options);
+		helper.ensureKeyExists("instruction", options);
+		helper.ensureKeyExists("attributes", options);
+		helper.ensureKeyExists("text", options);
+		helper.ensureKeyExists("comment", options);
+		helper.ensureKeyExists("cdata", options);
+		helper.ensureKeyExists("doctype", options);
+		helper.ensureKeyExists("type", options);
+		helper.ensureKeyExists("name", options);
+		helper.ensureKeyExists("elements", options);
+		helper.ensureKeyExists("parent", options);
+		helper.checkFnExists("doctype", options);
+		helper.checkFnExists("instruction", options);
+		helper.checkFnExists("cdata", options);
+		helper.checkFnExists("comment", options);
+		helper.checkFnExists("text", options);
+		helper.checkFnExists("instructionName", options);
+		helper.checkFnExists("elementName", options);
+		helper.checkFnExists("attributeName", options);
+		helper.checkFnExists("attributeValue", options);
+		helper.checkFnExists("attributes", options);
+		return options;
+	}
+	function nativeType(value) {
+		var nValue = Number(value);
+		if (!isNaN(nValue)) return nValue;
+		var bValue = value.toLowerCase();
+		if (bValue === "true") return true;
+		else if (bValue === "false") return false;
+		return value;
+	}
+	function addField(type, value) {
+		var key;
+		if (options.compact) {
+			if (!currentElement[options[type + "Key"]] && (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(options[type + "Key"]) !== -1 : options.alwaysArray)) currentElement[options[type + "Key"]] = [];
+			if (currentElement[options[type + "Key"]] && !isArray(currentElement[options[type + "Key"]])) currentElement[options[type + "Key"]] = [currentElement[options[type + "Key"]]];
+			if (type + "Fn" in options && typeof value === "string") value = options[type + "Fn"](value, currentElement);
+			if (type === "instruction" && ("instructionFn" in options || "instructionNameFn" in options)) {
+				for (key in value) if (value.hasOwnProperty(key)) if ("instructionFn" in options) value[key] = options.instructionFn(value[key], key, currentElement);
+				else {
+					var temp = value[key];
+					delete value[key];
+					value[options.instructionNameFn(key, temp, currentElement)] = temp;
+				}
+			}
+			if (isArray(currentElement[options[type + "Key"]])) currentElement[options[type + "Key"]].push(value);
+			else currentElement[options[type + "Key"]] = value;
+		} else {
+			if (!currentElement[options.elementsKey]) currentElement[options.elementsKey] = [];
+			var element = {};
+			element[options.typeKey] = type;
+			if (type === "instruction") {
+				for (key in value) if (value.hasOwnProperty(key)) break;
+				element[options.nameKey] = "instructionNameFn" in options ? options.instructionNameFn(key, value, currentElement) : key;
+				if (options.instructionHasAttributes) {
+					element[options.attributesKey] = value[key][options.attributesKey];
+					if ("instructionFn" in options) element[options.attributesKey] = options.instructionFn(element[options.attributesKey], key, currentElement);
+				} else {
+					if ("instructionFn" in options) value[key] = options.instructionFn(value[key], key, currentElement);
+					element[options.instructionKey] = value[key];
+				}
+			} else {
+				if (type + "Fn" in options) value = options[type + "Fn"](value, currentElement);
+				element[options[type + "Key"]] = value;
+			}
+			if (options.addParent) element[options.parentKey] = currentElement;
+			currentElement[options.elementsKey].push(element);
+		}
+	}
+	function manipulateAttributes(attributes) {
+		if ("attributesFn" in options && attributes) attributes = options.attributesFn(attributes, currentElement);
+		if ((options.trim || "attributeValueFn" in options || "attributeNameFn" in options || options.nativeTypeAttributes) && attributes) {
+			var key;
+			for (key in attributes) if (attributes.hasOwnProperty(key)) {
+				if (options.trim) attributes[key] = attributes[key].trim();
+				if (options.nativeTypeAttributes) attributes[key] = nativeType(attributes[key]);
+				if ("attributeValueFn" in options) attributes[key] = options.attributeValueFn(attributes[key], key, currentElement);
+				if ("attributeNameFn" in options) {
+					var temp = attributes[key];
+					delete attributes[key];
+					attributes[options.attributeNameFn(key, attributes[key], currentElement)] = temp;
+				}
+			}
+		}
+		return attributes;
+	}
+	function onInstruction(instruction) {
+		var attributes = {};
+		if (instruction.body && (instruction.name.toLowerCase() === "xml" || options.instructionHasAttributes)) {
+			var attrsRegExp = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;
+			var match;
+			while ((match = attrsRegExp.exec(instruction.body)) !== null) attributes[match[1]] = match[2] || match[3] || match[4];
+			attributes = manipulateAttributes(attributes);
+		}
+		if (instruction.name.toLowerCase() === "xml") {
+			if (options.ignoreDeclaration) return;
+			currentElement[options.declarationKey] = {};
+			if (Object.keys(attributes).length) currentElement[options.declarationKey][options.attributesKey] = attributes;
+			if (options.addParent) currentElement[options.declarationKey][options.parentKey] = currentElement;
+		} else {
+			if (options.ignoreInstruction) return;
+			if (options.trim) instruction.body = instruction.body.trim();
+			var value = {};
+			if (options.instructionHasAttributes && Object.keys(attributes).length) {
+				value[instruction.name] = {};
+				value[instruction.name][options.attributesKey] = attributes;
+			} else value[instruction.name] = instruction.body;
+			addField("instruction", value);
+		}
+	}
+	function onStartElement(name, attributes) {
+		var element;
+		if (typeof name === "object") {
+			attributes = name.attributes;
+			name = name.name;
+		}
+		attributes = manipulateAttributes(attributes);
+		if ("elementNameFn" in options) name = options.elementNameFn(name, currentElement);
+		if (options.compact) {
+			element = {};
+			if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
+				element[options.attributesKey] = {};
+				var key;
+				for (key in attributes) if (attributes.hasOwnProperty(key)) element[options.attributesKey][key] = attributes[key];
+			}
+			if (!(name in currentElement) && (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(name) !== -1 : options.alwaysArray)) currentElement[name] = [];
+			if (currentElement[name] && !isArray(currentElement[name])) currentElement[name] = [currentElement[name]];
+			if (isArray(currentElement[name])) currentElement[name].push(element);
+			else currentElement[name] = element;
+		} else {
+			if (!currentElement[options.elementsKey]) currentElement[options.elementsKey] = [];
+			element = {};
+			element[options.typeKey] = "element";
+			element[options.nameKey] = name;
+			if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) element[options.attributesKey] = attributes;
+			if (options.alwaysChildren) element[options.elementsKey] = [];
+			currentElement[options.elementsKey].push(element);
+		}
+		element[options.parentKey] = currentElement;
+		currentElement = element;
+	}
+	function onText(text) {
+		if (options.ignoreText) return;
+		if (!text.trim() && !options.captureSpacesBetweenElements) return;
+		if (options.trim) text = text.trim();
+		if (options.nativeType) text = nativeType(text);
+		if (options.sanitize) text = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+		addField("text", text);
+	}
+	function onComment(comment) {
+		if (options.ignoreComment) return;
+		if (options.trim) comment = comment.trim();
+		addField("comment", comment);
+	}
+	function onEndElement(name) {
+		var parentElement = currentElement[options.parentKey];
+		if (!options.addParent) delete currentElement[options.parentKey];
+		currentElement = parentElement;
+	}
+	function onCdata(cdata) {
+		if (options.ignoreCdata) return;
+		if (options.trim) cdata = cdata.trim();
+		addField("cdata", cdata);
+	}
+	function onDoctype(doctype) {
+		if (options.ignoreDoctype) return;
+		doctype = doctype.replace(/^ /, "");
+		if (options.trim) doctype = doctype.trim();
+		addField("doctype", doctype);
+	}
+	function onError(error) {
+		error.note = error;
+	}
+	module.exports = function(xml, userOptions) {
+		var parser = pureJsParser ? sax.parser(true, {}) : parser = new expat.Parser("UTF-8");
+		var result = {};
+		currentElement = result;
+		options = validateOptions(userOptions);
+		if (pureJsParser) {
+			parser.opt = { strictEntities: true };
+			parser.onopentag = onStartElement;
+			parser.ontext = onText;
+			parser.oncomment = onComment;
+			parser.onclosetag = onEndElement;
+			parser.onerror = onError;
+			parser.oncdata = onCdata;
+			parser.ondoctype = onDoctype;
+			parser.onprocessinginstruction = onInstruction;
+		} else {
+			parser.on("startElement", onStartElement);
+			parser.on("text", onText);
+			parser.on("comment", onComment);
+			parser.on("endElement", onEndElement);
+			parser.on("error", onError);
+		}
+		if (pureJsParser) parser.write(xml).close();
+		else if (!parser.parse(xml)) throw new Error("XML parsing error: " + parser.getError());
+		if (result[options.elementsKey]) {
+			var temp = result[options.elementsKey];
+			delete result[options.elementsKey];
+			result[options.elementsKey] = temp;
+			delete result.text;
+		}
+		return result;
+	};
+}));
+//#endregion
+export default require_xml2js();
+export { require_xml2js };
+
+//# sourceMappingURL=xml2js.js.map

package/dist/node_modules/xml-js/lib/xml2json.js

@@ -0,0 +1,26 @@
+import { __commonJSMin } from "../../../_virtual/_rolldown/runtime.js";
+import { require_options_helper } from "./options-helper.js";
+import { require_xml2js } from "./xml2js.js";
+//#region node_modules/xml-js/lib/xml2json.js
+var require_xml2json = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var helper = require_options_helper();
+	var xml2js = require_xml2js();
+	function validateOptions(userOptions) {
+		var options = helper.copyOptions(userOptions);
+		helper.ensureSpacesExists(options);
+		return options;
+	}
+	module.exports = function(xml, userOptions) {
+		var options = validateOptions(userOptions), js = xml2js(xml, options), json, parentKey = "compact" in options && options.compact ? "_parent" : "parent";
+		if ("addParent" in options && options.addParent) json = JSON.stringify(js, function(k, v) {
+			return k === parentKey ? "_" : v;
+		}, options.spaces);
+		else json = JSON.stringify(js, null, options.spaces);
+		return json.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+	};
+}));
+//#endregion
+export default require_xml2json();
+export { require_xml2json };
+
+//# sourceMappingURL=xml2json.js.map

package/dist/util/kebab-case.js

@@ -1,15 +1,26 @@
-const KEBAB_REGEX = new RegExp("\\p{Lu}", "gu");
+//#region src/util/kebab-case.ts
+var KEBAB_REGEX = /\p{Lu}/gu;
+/**
+* Transforms a string into kebab-case.
+*
+* stolen from https://github.com/joakimbeng/kebab-case/blob/master/index.js
+*
+* @example
+* kebabCase("helloWorld"); // "hello-world"
+* kebabCase("HelloWorld"); // "-hello-world"
+* kebabCase("HelloWorld", false); // "hello-world"
+*
+* @param str The string to transform
+* @param keepLeadingDash Whether to keep the leading dash in case the string starts with an uppercase letter (default: true)
+* @returns The kebab-cased string
+*/
 function kebabCase(str, keepLeadingDash = false) {
-  const result = str.replace(KEBAB_REGEX, (match) => `-${match.toLowerCase()}`);
-  if (keepLeadingDash) {
-    return result;
-  }
-  if (result.startsWith("-")) {
-    return result.slice(1);
-  }
-  return result;
+	const result = str.replace(KEBAB_REGEX, (match) => `-${match.toLowerCase()}`);
+	if (keepLeadingDash) return result;
+	if (result.startsWith("-")) return result.slice(1);
+	return result;
 }
-export {
-  kebabCase
-};
-//# sourceMappingURL=kebab-case.js.map
+//#endregion
+export { kebabCase };
+
+//# sourceMappingURL=kebab-case.js.map

package/dist/util/zod.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare function isZodType(object: any): object is z.ZodType;
+export declare function getParentSchema(schema: z.ZodType): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+//# sourceMappingURL=zod.d.ts.map