fumadocs-openapi 10.8.3 → 10.8.5

package/dist/node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js

@@ -0,0 +1,282 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** @type {(value: string) => boolean} */
+	const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
+	/** @type {(value: string) => boolean} */
+	const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+	/**
+	* @param {Array<string>} input
+	* @returns {string}
+	*/
+	function stringArrayToHexStripped(input) {
+		let acc = "";
+		let code = 0;
+		let i = 0;
+		for (i = 0; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (code === 48) continue;
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+			break;
+		}
+		for (i += 1; i < input.length; i++) {
+			code = input[i].charCodeAt(0);
+			if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) return "";
+			acc += input[i];
+		}
+		return acc;
+	}
+	/**
+	* @typedef {Object} GetIPV6Result
+	* @property {boolean} error - Indicates if there was an error parsing the IPv6 address.
+	* @property {string} address - The parsed IPv6 address.
+	* @property {string} [zone] - The zone identifier, if present.
+	*/
+	/**
+	* @param {string} value
+	* @returns {boolean}
+	*/
+	const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+	/**
+	* @param {Array<string>} buffer
+	* @returns {boolean}
+	*/
+	function consumeIsZone(buffer) {
+		buffer.length = 0;
+		return true;
+	}
+	/**
+	* @param {Array<string>} buffer
+	* @param {Array<string>} address
+	* @param {GetIPV6Result} output
+	* @returns {boolean}
+	*/
+	function consumeHextets(buffer, address, output) {
+		if (buffer.length) {
+			const hex = stringArrayToHexStripped(buffer);
+			if (hex !== "") address.push(hex);
+			else {
+				output.error = true;
+				return false;
+			}
+			buffer.length = 0;
+		}
+		return true;
+	}
+	/**
+	* @param {string} input
+	* @returns {GetIPV6Result}
+	*/
+	function getIPV6(input) {
+		let tokenCount = 0;
+		const output = {
+			error: false,
+			address: "",
+			zone: ""
+		};
+		/** @type {Array<string>} */
+		const address = [];
+		/** @type {Array<string>} */
+		const buffer = [];
+		let endipv6Encountered = false;
+		let endIpv6 = false;
+		let consume = consumeHextets;
+		for (let i = 0; i < input.length; i++) {
+			const cursor = input[i];
+			if (cursor === "[" || cursor === "]") continue;
+			if (cursor === ":") {
+				if (endipv6Encountered === true) endIpv6 = true;
+				if (!consume(buffer, address, output)) break;
+				if (++tokenCount > 7) {
+					output.error = true;
+					break;
+				}
+				if (i > 0 && input[i - 1] === ":") endipv6Encountered = true;
+				address.push(":");
+				continue;
+			} else if (cursor === "%") {
+				if (!consume(buffer, address, output)) break;
+				consume = consumeIsZone;
+			} else {
+				buffer.push(cursor);
+				continue;
+			}
+		}
+		if (buffer.length) if (consume === consumeIsZone) output.zone = buffer.join("");
+		else if (endIpv6) address.push(buffer.join(""));
+		else address.push(stringArrayToHexStripped(buffer));
+		output.address = address.join("");
+		return output;
+	}
+	/**
+	* @typedef {Object} NormalizeIPv6Result
+	* @property {string} host - The normalized host.
+	* @property {string} [escapedHost] - The escaped host.
+	* @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.
+	*/
+	/**
+	* @param {string} host
+	* @returns {NormalizeIPv6Result}
+	*/
+	function normalizeIPv6(host) {
+		if (findToken(host, ":") < 2) return {
+			host,
+			isIPV6: false
+		};
+		const ipv6 = getIPV6(host);
+		if (!ipv6.error) {
+			let newHost = ipv6.address;
+			let escapedHost = ipv6.address;
+			if (ipv6.zone) {
+				newHost += "%" + ipv6.zone;
+				escapedHost += "%25" + ipv6.zone;
+			}
+			return {
+				host: newHost,
+				isIPV6: true,
+				escapedHost
+			};
+		} else return {
+			host,
+			isIPV6: false
+		};
+	}
+	/**
+	* @param {string} str
+	* @param {string} token
+	* @returns {number}
+	*/
+	function findToken(str, token) {
+		let ind = 0;
+		for (let i = 0; i < str.length; i++) if (str[i] === token) ind++;
+		return ind;
+	}
+	/**
+	* @param {string} path
+	* @returns {string}
+	*
+	* @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+	*/
+	function removeDotSegments(path) {
+		let input = path;
+		const output = [];
+		let nextSlash = -1;
+		let len = 0;
+		while (len = input.length) {
+			if (len === 1) if (input === ".") break;
+			else if (input === "/") {
+				output.push("/");
+				break;
+			} else {
+				output.push(input);
+				break;
+			}
+			else if (len === 2) {
+				if (input[0] === ".") {
+					if (input[1] === ".") break;
+					else if (input[1] === "/") {
+						input = input.slice(2);
+						continue;
+					}
+				} else if (input[0] === "/") {
+					if (input[1] === "." || input[1] === "/") {
+						output.push("/");
+						break;
+					}
+				}
+			} else if (len === 3) {
+				if (input === "/..") {
+					if (output.length !== 0) output.pop();
+					output.push("/");
+					break;
+				}
+			}
+			if (input[0] === ".") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(3);
+						continue;
+					}
+				} else if (input[1] === "/") {
+					input = input.slice(2);
+					continue;
+				}
+			} else if (input[0] === "/") {
+				if (input[1] === ".") {
+					if (input[2] === "/") {
+						input = input.slice(2);
+						continue;
+					} else if (input[2] === ".") {
+						if (input[3] === "/") {
+							input = input.slice(3);
+							if (output.length !== 0) output.pop();
+							continue;
+						}
+					}
+				}
+			}
+			if ((nextSlash = input.indexOf("/", 1)) === -1) {
+				output.push(input);
+				break;
+			} else {
+				output.push(input.slice(0, nextSlash));
+				input = input.slice(nextSlash);
+			}
+		}
+		return output.join("");
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @param {boolean} esc
+	* @returns {import('../types/index').URIComponent}
+	*/
+	function normalizeComponentEncoding(component, esc) {
+		const func = esc !== true ? escape : unescape;
+		if (component.scheme !== void 0) component.scheme = func(component.scheme);
+		if (component.userinfo !== void 0) component.userinfo = func(component.userinfo);
+		if (component.host !== void 0) component.host = func(component.host);
+		if (component.path !== void 0) component.path = func(component.path);
+		if (component.query !== void 0) component.query = func(component.query);
+		if (component.fragment !== void 0) component.fragment = func(component.fragment);
+		return component;
+	}
+	/**
+	* @param {import('../types/index').URIComponent} component
+	* @returns {string|undefined}
+	*/
+	function recomposeAuthority(component) {
+		const uriTokens = [];
+		if (component.userinfo !== void 0) {
+			uriTokens.push(component.userinfo);
+			uriTokens.push("@");
+		}
+		if (component.host !== void 0) {
+			let host = unescape(component.host);
+			if (!isIPv4(host)) {
+				const ipV6res = normalizeIPv6(host);
+				if (ipV6res.isIPV6 === true) host = `[${ipV6res.escapedHost}]`;
+				else host = component.host;
+			}
+			uriTokens.push(host);
+		}
+		if (typeof component.port === "number" || typeof component.port === "string") {
+			uriTokens.push(":");
+			uriTokens.push(String(component.port));
+		}
+		return uriTokens.length ? uriTokens.join("") : void 0;
+	}
+	module.exports = {
+		nonSimpleDomain,
+		recomposeAuthority,
+		normalizeComponentEncoding,
+		removeDotSegments,
+		isIPv4,
+		isUUID,
+		normalizeIPv6,
+		stringArrayToHexStripped
+	};
+}));
+//#endregion
+export default require_utils();
+export { require_utils };

package/dist/node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js

@@ -0,0 +1,78 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js
+var require_json_schema_traverse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var traverse = module.exports = function(schema, opts, cb) {
+		if (typeof opts == "function") {
+			cb = opts;
+			opts = {};
+		}
+		cb = opts.cb || cb;
+		var pre = typeof cb == "function" ? cb : cb.pre || function() {};
+		var post = cb.post || function() {};
+		_traverse(opts, pre, post, schema, "", schema);
+	};
+	traverse.keywords = {
+		additionalItems: true,
+		items: true,
+		contains: true,
+		additionalProperties: true,
+		propertyNames: true,
+		not: true,
+		if: true,
+		then: true,
+		else: true
+	};
+	traverse.arrayKeywords = {
+		items: true,
+		allOf: true,
+		anyOf: true,
+		oneOf: true
+	};
+	traverse.propsKeywords = {
+		$defs: true,
+		definitions: true,
+		properties: true,
+		patternProperties: true,
+		dependencies: true
+	};
+	traverse.skipKeywords = {
+		default: true,
+		enum: true,
+		const: true,
+		required: true,
+		maximum: true,
+		minimum: true,
+		exclusiveMaximum: true,
+		exclusiveMinimum: true,
+		multipleOf: true,
+		maxLength: true,
+		minLength: true,
+		pattern: true,
+		format: true,
+		maxItems: true,
+		minItems: true,
+		uniqueItems: true,
+		maxProperties: true,
+		minProperties: true
+	};
+	function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+		if (schema && typeof schema == "object" && !Array.isArray(schema)) {
+			pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+			for (var key in schema) {
+				var sch = schema[key];
+				if (Array.isArray(sch)) {
+					if (key in traverse.arrayKeywords) for (var i = 0; i < sch.length; i++) _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
+				} else if (key in traverse.propsKeywords) {
+					if (sch && typeof sch == "object") for (var prop in sch) _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+				} else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+			}
+			post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+		}
+	}
+	function escapeJsonPtr(str) {
+		return str.replace(/~/g, "~0").replace(/\//g, "~1");
+	}
+}));
+//#endregion
+export default require_json_schema_traverse();
+export { require_json_schema_traverse };

package/dist/node_modules/.pnpm/xml-js@1.6.11/node_modules/xml-js/lib/array-helper.js

@@ -0,0 +1,11 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/xml-js@1.6.11/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 };

package/dist/node_modules/.pnpm/xml-js@1.6.11/node_modules/xml-js/lib/js2xml.js

@@ -0,0 +1,256 @@
+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/.pnpm/xml-js@1.6.11/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 };

package/dist/node_modules/.pnpm/xml-js@1.6.11/node_modules/xml-js/lib/options-helper.js

@@ -0,0 +1,31 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_array_helper } from "./array-helper.js";
+//#region ../../node_modules/.pnpm/xml-js@1.6.11/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 };

package/dist/node_modules/.pnpm/{yaml@2.8.4 → yaml@2.9.0}/node_modules/yaml/browser/dist/compose/compose-collection.js

@@ -5,7 +5,7 @@ import { YAMLSeq } from "../nodes/YAMLSeq.js";
 import { resolveBlockMap } from "./resolve-block-map.js";
 import { resolveBlockSeq } from "./resolve-block-seq.js";
 import { resolveFlowCollection } from "./resolve-flow-collection.js";
-//#region ../../node_modules/.pnpm/yaml@2.8.4/node_modules/yaml/browser/dist/compose/compose-collection.js
+//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/browser/dist/compose/compose-collection.js
 function resolveCollection(CN, ctx, token, onError, tagName, tag) {
 	const coll = token.type === "block-map" ? resolveBlockMap(CN, ctx, token, onError, tag) : token.type === "block-seq" ? resolveBlockSeq(CN, ctx, token, onError, tag) : resolveFlowCollection(CN, ctx, token, onError, tag);
 	const Coll = coll.constructor;

package/dist/node_modules/.pnpm/{yaml@2.8.4 → yaml@2.9.0}/node_modules/yaml/browser/dist/compose/compose-doc.js

@@ -2,7 +2,7 @@ import { Document } from "../doc/Document.js";
 import { resolveProps } from "./resolve-props.js";
 import { resolveEnd } from "./resolve-end.js";
 import { composeEmptyNode, composeNode } from "./compose-node.js";
-//#region ../../node_modules/.pnpm/yaml@2.8.4/node_modules/yaml/browser/dist/compose/compose-doc.js
+//#region ../../node_modules/.pnpm/yaml@2.9.0/node_modules/yaml/browser/dist/compose/compose-doc.js
 function composeDoc(options, directives, { offset, start, value, end }, onError) {
 	const doc = new Document(void 0, Object.assign({ _directives: directives }, options));
 	const ctx = {