@cartanova/qgrid-cli 2.7.0 → 2.7.1

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

@@ -0,0 +1,189 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_utils } from "./utils.js";
+//#region ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js
+var require_schemes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { isUUID } = require_utils();
+	const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+	const supportedSchemeNames = [
+		"http",
+		"https",
+		"ws",
+		"wss",
+		"urn",
+		"urn:uuid"
+	];
+	/** @typedef {supportedSchemeNames[number]} SchemeName */
+	/**
+	* @param {string} name
+	* @returns {name is SchemeName}
+	*/
+	function isValidSchemeName(name) {
+		return supportedSchemeNames.indexOf(name) !== -1;
+	}
+	/**
+	* @callback SchemeFn
+	* @param {import('../types/index').URIComponent} component
+	* @param {import('../types/index').Options} options
+	* @returns {import('../types/index').URIComponent}
+	*/
+	/**
+	* @typedef {Object} SchemeHandler
+	* @property {SchemeName} scheme - The scheme name.
+	* @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.
+	* @property {SchemeFn} parse - Function to parse the URI component for this scheme.
+	* @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.
+	* @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.
+	* @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.
+	* @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.
+	*/
+	/**
+	* @param {import('../types/index').URIComponent} wsComponent
+	* @returns {boolean}
+	*/
+	function wsIsSecure(wsComponent) {
+		if (wsComponent.secure === true) return true;
+		else if (wsComponent.secure === false) return false;
+		else if (wsComponent.scheme) return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S");
+		else return false;
+	}
+	/** @type {SchemeFn} */
+	function httpParse(component) {
+		if (!component.host) component.error = component.error || "HTTP URIs must have a host.";
+		return component;
+	}
+	/** @type {SchemeFn} */
+	function httpSerialize(component) {
+		const secure = String(component.scheme).toLowerCase() === "https";
+		if (component.port === (secure ? 443 : 80) || component.port === "") component.port = void 0;
+		if (!component.path) component.path = "/";
+		return component;
+	}
+	/** @type {SchemeFn} */
+	function wsParse(wsComponent) {
+		wsComponent.secure = wsIsSecure(wsComponent);
+		wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
+		wsComponent.path = void 0;
+		wsComponent.query = void 0;
+		return wsComponent;
+	}
+	/** @type {SchemeFn} */
+	function wsSerialize(wsComponent) {
+		if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") wsComponent.port = void 0;
+		if (typeof wsComponent.secure === "boolean") {
+			wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
+			wsComponent.secure = void 0;
+		}
+		if (wsComponent.resourceName) {
+			const [path, query] = wsComponent.resourceName.split("?");
+			wsComponent.path = path && path !== "/" ? path : void 0;
+			wsComponent.query = query;
+			wsComponent.resourceName = void 0;
+		}
+		wsComponent.fragment = void 0;
+		return wsComponent;
+	}
+	/** @type {SchemeFn} */
+	function urnParse(urnComponent, options) {
+		if (!urnComponent.path) {
+			urnComponent.error = "URN can not be parsed";
+			return urnComponent;
+		}
+		const matches = urnComponent.path.match(URN_REG);
+		if (matches) {
+			const scheme = options.scheme || urnComponent.scheme || "urn";
+			urnComponent.nid = matches[1].toLowerCase();
+			urnComponent.nss = matches[2];
+			const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || urnComponent.nid}`);
+			urnComponent.path = void 0;
+			if (schemeHandler) urnComponent = schemeHandler.parse(urnComponent, options);
+		} else urnComponent.error = urnComponent.error || "URN can not be parsed.";
+		return urnComponent;
+	}
+	/** @type {SchemeFn} */
+	function urnSerialize(urnComponent, options) {
+		if (urnComponent.nid === void 0) throw new Error("URN without nid cannot be serialized");
+		const scheme = options.scheme || urnComponent.scheme || "urn";
+		const nid = urnComponent.nid.toLowerCase();
+		const schemeHandler = getSchemeHandler(`${scheme}:${options.nid || nid}`);
+		if (schemeHandler) urnComponent = schemeHandler.serialize(urnComponent, options);
+		const uriComponent = urnComponent;
+		const nss = urnComponent.nss;
+		uriComponent.path = `${nid || options.nid}:${nss}`;
+		options.skipEscape = true;
+		return uriComponent;
+	}
+	/** @type {SchemeFn} */
+	function urnuuidParse(urnComponent, options) {
+		const uuidComponent = urnComponent;
+		uuidComponent.uuid = uuidComponent.nss;
+		uuidComponent.nss = void 0;
+		if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) uuidComponent.error = uuidComponent.error || "UUID is not valid.";
+		return uuidComponent;
+	}
+	/** @type {SchemeFn} */
+	function urnuuidSerialize(uuidComponent) {
+		const urnComponent = uuidComponent;
+		urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
+		return urnComponent;
+	}
+	const http = {
+		scheme: "http",
+		domainHost: true,
+		parse: httpParse,
+		serialize: httpSerialize
+	};
+	const https = {
+		scheme: "https",
+		domainHost: http.domainHost,
+		parse: httpParse,
+		serialize: httpSerialize
+	};
+	const ws = {
+		scheme: "ws",
+		domainHost: true,
+		parse: wsParse,
+		serialize: wsSerialize
+	};
+	const SCHEMES = {
+		http,
+		https,
+		ws,
+		wss: {
+			scheme: "wss",
+			domainHost: ws.domainHost,
+			parse: ws.parse,
+			serialize: ws.serialize
+		},
+		urn: {
+			scheme: "urn",
+			parse: urnParse,
+			serialize: urnSerialize,
+			skipNormalize: true
+		},
+		"urn:uuid": {
+			scheme: "urn:uuid",
+			parse: urnuuidParse,
+			serialize: urnuuidSerialize,
+			skipNormalize: true
+		}
+	};
+	Object.setPrototypeOf(SCHEMES, null);
+	/**
+	* @param {string|undefined} scheme
+	* @returns {SchemeHandler|undefined}
+	*/
+	function getSchemeHandler(scheme) {
+		return scheme && (SCHEMES[scheme] || SCHEMES[scheme.toLowerCase()]) || void 0;
+	}
+	module.exports = {
+		wsIsSecure,
+		SCHEMES,
+		isValidSchemeName,
+		getSchemeHandler
+	};
+}));
+//#endregion
+export default require_schemes();
+export { require_schemes };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"schemes.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js"],"sourcesContent":["'use strict'\n\nconst { isUUID } = require('./utils')\nconst URN_REG = /([\\da-z][\\d\\-a-z]{0,31}):((?:[\\w!$'()*+,\\-.:;=@]|%[\\da-f]{2})+)/iu\n\nconst supportedSchemeNames = /** @type {const} */ (['http', 'https', 'ws',\n  'wss', 'urn', 'urn:uuid'])\n\n/** @typedef {supportedSchemeNames[number]} SchemeName */\n\n/**\n * @param {string} name\n * @returns {name is SchemeName}\n */\nfunction isValidSchemeName (name) {\n  return supportedSchemeNames.indexOf(/** @type {*} */ (name)) !== -1\n}\n\n/**\n * @callback SchemeFn\n * @param {import('../types/index').URIComponent} component\n * @param {import('../types/index').Options} options\n * @returns {import('../types/index').URIComponent}\n */\n\n/**\n * @typedef {Object} SchemeHandler\n * @property {SchemeName} scheme - The scheme name.\n * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts.\n * @property {SchemeFn} parse - Function to parse the URI component for this scheme.\n * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme.\n * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme.\n * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths.\n * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode.\n */\n\n/**\n * @param {import('../types/index').URIComponent} wsComponent\n * @returns {boolean}\n */\nfunction wsIsSecure (wsComponent) {\n  if (wsComponent.secure === true) {\n    return true\n  } else if (wsComponent.secure === false) {\n    return false\n  } else if (wsComponent.scheme) {\n    return (\n      wsComponent.scheme.length === 3 &&\n      (wsComponent.scheme[0] === 'w' || wsComponent.scheme[0] === 'W') &&\n      (wsComponent.scheme[1] === 's' || wsComponent.scheme[1] === 'S') &&\n      (wsComponent.scheme[2] === 's' || wsComponent.scheme[2] === 'S')\n    )\n  } else {\n    return false\n  }\n}\n\n/** @type {SchemeFn} */\nfunction httpParse (component) {\n  if (!component.host) {\n    component.error = component.error || 'HTTP URIs must have a host.'\n  }\n\n  return component\n}\n\n/** @type {SchemeFn} */\nfunction httpSerialize (component) {\n  const secure = String(component.scheme).toLowerCase() === 'https'\n\n  // normalize the default port\n  if (component.port === (secure ? 443 : 80) || component.port === '') {\n    component.port = undefined\n  }\n\n  // normalize the empty path\n  if (!component.path) {\n    component.path = '/'\n  }\n\n  // NOTE: We do not parse query strings for HTTP URIs\n  // as WWW Form Url Encoded query strings are part of the HTML4+ spec,\n  // and not the HTTP spec.\n\n  return component\n}\n\n/** @type {SchemeFn} */\nfunction wsParse (wsComponent) {\n// indicate if the secure flag is set\n  wsComponent.secure = wsIsSecure(wsComponent)\n\n  // construct resouce name\n  wsComponent.resourceName = (wsComponent.path || '/') + (wsComponent.query ? '?' + wsComponent.query : '')\n  wsComponent.path = undefined\n  wsComponent.query = undefined\n\n  return wsComponent\n}\n\n/** @type {SchemeFn} */\nfunction wsSerialize (wsComponent) {\n// normalize the default port\n  if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === '') {\n    wsComponent.port = undefined\n  }\n\n  // ensure scheme matches secure flag\n  if (typeof wsComponent.secure === 'boolean') {\n    wsComponent.scheme = (wsComponent.secure ? 'wss' : 'ws')\n    wsComponent.secure = undefined\n  }\n\n  // reconstruct path from resource name\n  if (wsComponent.resourceName) {\n    const [path, query] = wsComponent.resourceName.split('?')\n    wsComponent.path = (path && path !== '/' ? path : undefined)\n    wsComponent.query = query\n    wsComponent.resourceName = undefined\n  }\n\n  // forbid fragment component\n  wsComponent.fragment = undefined\n\n  return wsComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnParse (urnComponent, options) {\n  if (!urnComponent.path) {\n    urnComponent.error = 'URN can not be parsed'\n    return urnComponent\n  }\n  const matches = urnComponent.path.match(URN_REG)\n  if (matches) {\n    const scheme = options.scheme || urnComponent.scheme || 'urn'\n    urnComponent.nid = matches[1].toLowerCase()\n    urnComponent.nss = matches[2]\n    const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`\n    const schemeHandler = getSchemeHandler(urnScheme)\n    urnComponent.path = undefined\n\n    if (schemeHandler) {\n      urnComponent = schemeHandler.parse(urnComponent, options)\n    }\n  } else {\n    urnComponent.error = urnComponent.error || 'URN can not be parsed.'\n  }\n\n  return urnComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnSerialize (urnComponent, options) {\n  if (urnComponent.nid === undefined) {\n    throw new Error('URN without nid cannot be serialized')\n  }\n  const scheme = options.scheme || urnComponent.scheme || 'urn'\n  const nid = urnComponent.nid.toLowerCase()\n  const urnScheme = `${scheme}:${options.nid || nid}`\n  const schemeHandler = getSchemeHandler(urnScheme)\n\n  if (schemeHandler) {\n    urnComponent = schemeHandler.serialize(urnComponent, options)\n  }\n\n  const uriComponent = urnComponent\n  const nss = urnComponent.nss\n  uriComponent.path = `${nid || options.nid}:${nss}`\n\n  options.skipEscape = true\n  return uriComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnuuidParse (urnComponent, options) {\n  const uuidComponent = urnComponent\n  uuidComponent.uuid = uuidComponent.nss\n  uuidComponent.nss = undefined\n\n  if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {\n    uuidComponent.error = uuidComponent.error || 'UUID is not valid.'\n  }\n\n  return uuidComponent\n}\n\n/** @type {SchemeFn} */\nfunction urnuuidSerialize (uuidComponent) {\n  const urnComponent = uuidComponent\n  // normalize UUID\n  urnComponent.nss = (uuidComponent.uuid || '').toLowerCase()\n  return urnComponent\n}\n\nconst http = /** @type {SchemeHandler} */ ({\n  scheme: 'http',\n  domainHost: true,\n  parse: httpParse,\n  serialize: httpSerialize\n})\n\nconst https = /** @type {SchemeHandler} */ ({\n  scheme: 'https',\n  domainHost: http.domainHost,\n  parse: httpParse,\n  serialize: httpSerialize\n})\n\nconst ws = /** @type {SchemeHandler} */ ({\n  scheme: 'ws',\n  domainHost: true,\n  parse: wsParse,\n  serialize: wsSerialize\n})\n\nconst wss = /** @type {SchemeHandler} */ ({\n  scheme: 'wss',\n  domainHost: ws.domainHost,\n  parse: ws.parse,\n  serialize: ws.serialize\n})\n\nconst urn = /** @type {SchemeHandler} */ ({\n  scheme: 'urn',\n  parse: urnParse,\n  serialize: urnSerialize,\n  skipNormalize: true\n})\n\nconst urnuuid = /** @type {SchemeHandler} */ ({\n  scheme: 'urn:uuid',\n  parse: urnuuidParse,\n  serialize: urnuuidSerialize,\n  skipNormalize: true\n})\n\nconst SCHEMES = /** @type {Record<SchemeName, SchemeHandler>} */ ({\n  http,\n  https,\n  ws,\n  wss,\n  urn,\n  'urn:uuid': urnuuid\n})\n\nObject.setPrototypeOf(SCHEMES, null)\n\n/**\n * @param {string|undefined} scheme\n * @returns {SchemeHandler|undefined}\n */\nfunction getSchemeHandler (scheme) {\n  return (\n    scheme && (\n      SCHEMES[/** @type {SchemeName} */ (scheme)] ||\n      SCHEMES[/** @type {SchemeName} */(scheme.toLowerCase())])\n  ) ||\n    undefined\n}\n\nmodule.exports = {\n  wsIsSecure,\n  SCHEMES,\n  isValidSchemeName,\n  getSchemeHandler,\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -0,0 +1,284 @@
+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 };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js"],"sourcesContent":["'use strict'\n\n/** @type {(value: string) => boolean} */\nconst isUUID = RegExp.prototype.test.bind(/^[\\da-f]{8}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{12}$/iu)\n\n/** @type {(value: string) => boolean} */\nconst 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)\n\n/**\n * @param {Array<string>} input\n * @returns {string}\n */\nfunction stringArrayToHexStripped (input) {\n  let acc = ''\n  let code = 0\n  let i = 0\n\n  for (i = 0; i < input.length; i++) {\n    code = input[i].charCodeAt(0)\n    if (code === 48) {\n      continue\n    }\n    if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {\n      return ''\n    }\n    acc += input[i]\n    break\n  }\n\n  for (i += 1; i < input.length; i++) {\n    code = input[i].charCodeAt(0)\n    if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) {\n      return ''\n    }\n    acc += input[i]\n  }\n  return acc\n}\n\n/**\n * @typedef {Object} GetIPV6Result\n * @property {boolean} error - Indicates if there was an error parsing the IPv6 address.\n * @property {string} address - The parsed IPv6 address.\n * @property {string} [zone] - The zone identifier, if present.\n */\n\n/**\n * @param {string} value\n * @returns {boolean}\n */\nconst nonSimpleDomain = RegExp.prototype.test.bind(/[^!\"$&'()*+,\\-.;=_`a-z{}~]/u)\n\n/**\n * @param {Array<string>} buffer\n * @returns {boolean}\n */\nfunction consumeIsZone (buffer) {\n  buffer.length = 0\n  return true\n}\n\n/**\n * @param {Array<string>} buffer\n * @param {Array<string>} address\n * @param {GetIPV6Result} output\n * @returns {boolean}\n */\nfunction consumeHextets (buffer, address, output) {\n  if (buffer.length) {\n    const hex = stringArrayToHexStripped(buffer)\n    if (hex !== '') {\n      address.push(hex)\n    } else {\n      output.error = true\n      return false\n    }\n    buffer.length = 0\n  }\n  return true\n}\n\n/**\n * @param {string} input\n * @returns {GetIPV6Result}\n */\nfunction getIPV6 (input) {\n  let tokenCount = 0\n  const output = { error: false, address: '', zone: '' }\n  /** @type {Array<string>} */\n  const address = []\n  /** @type {Array<string>} */\n  const buffer = []\n  let endipv6Encountered = false\n  let endIpv6 = false\n\n  let consume = consumeHextets\n\n  for (let i = 0; i < input.length; i++) {\n    const cursor = input[i]\n    if (cursor === '[' || cursor === ']') { continue }\n    if (cursor === ':') {\n      if (endipv6Encountered === true) {\n        endIpv6 = true\n      }\n      if (!consume(buffer, address, output)) { break }\n      if (++tokenCount > 7) {\n        // not valid\n        output.error = true\n        break\n      }\n      if (i > 0 && input[i - 1] === ':') {\n        endipv6Encountered = true\n      }\n      address.push(':')\n      continue\n    } else if (cursor === '%') {\n      if (!consume(buffer, address, output)) { break }\n      // switch to zone detection\n      consume = consumeIsZone\n    } else {\n      buffer.push(cursor)\n      continue\n    }\n  }\n  if (buffer.length) {\n    if (consume === consumeIsZone) {\n      output.zone = buffer.join('')\n    } else if (endIpv6) {\n      address.push(buffer.join(''))\n    } else {\n      address.push(stringArrayToHexStripped(buffer))\n    }\n  }\n  output.address = address.join('')\n  return output\n}\n\n/**\n * @typedef {Object} NormalizeIPv6Result\n * @property {string} host - The normalized host.\n * @property {string} [escapedHost] - The escaped host.\n * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address.\n */\n\n/**\n * @param {string} host\n * @returns {NormalizeIPv6Result}\n */\nfunction normalizeIPv6 (host) {\n  if (findToken(host, ':') < 2) { return { host, isIPV6: false } }\n  const ipv6 = getIPV6(host)\n\n  if (!ipv6.error) {\n    let newHost = ipv6.address\n    let escapedHost = ipv6.address\n    if (ipv6.zone) {\n      newHost += '%' + ipv6.zone\n      escapedHost += '%25' + ipv6.zone\n    }\n    return { host: newHost, isIPV6: true, escapedHost }\n  } else {\n    return { host, isIPV6: false }\n  }\n}\n\n/**\n * @param {string} str\n * @param {string} token\n * @returns {number}\n */\nfunction findToken (str, token) {\n  let ind = 0\n  for (let i = 0; i < str.length; i++) {\n    if (str[i] === token) ind++\n  }\n  return ind\n}\n\n/**\n * @param {string} path\n * @returns {string}\n *\n * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4\n */\nfunction removeDotSegments (path) {\n  let input = path\n  const output = []\n  let nextSlash = -1\n  let len = 0\n\n  // eslint-disable-next-line no-cond-assign\n  while (len = input.length) {\n    if (len === 1) {\n      if (input === '.') {\n        break\n      } else if (input === '/') {\n        output.push('/')\n        break\n      } else {\n        output.push(input)\n        break\n      }\n    } else if (len === 2) {\n      if (input[0] === '.') {\n        if (input[1] === '.') {\n          break\n        } else if (input[1] === '/') {\n          input = input.slice(2)\n          continue\n        }\n      } else if (input[0] === '/') {\n        if (input[1] === '.' || input[1] === '/') {\n          output.push('/')\n          break\n        }\n      }\n    } else if (len === 3) {\n      if (input === '/..') {\n        if (output.length !== 0) {\n          output.pop()\n        }\n        output.push('/')\n        break\n      }\n    }\n    if (input[0] === '.') {\n      if (input[1] === '.') {\n        if (input[2] === '/') {\n          input = input.slice(3)\n          continue\n        }\n      } else if (input[1] === '/') {\n        input = input.slice(2)\n        continue\n      }\n    } else if (input[0] === '/') {\n      if (input[1] === '.') {\n        if (input[2] === '/') {\n          input = input.slice(2)\n          continue\n        } else if (input[2] === '.') {\n          if (input[3] === '/') {\n            input = input.slice(3)\n            if (output.length !== 0) {\n              output.pop()\n            }\n            continue\n          }\n        }\n      }\n    }\n\n    // Rule 2E: Move normal path segment to output\n    if ((nextSlash = input.indexOf('/', 1)) === -1) {\n      output.push(input)\n      break\n    } else {\n      output.push(input.slice(0, nextSlash))\n      input = input.slice(nextSlash)\n    }\n  }\n\n  return output.join('')\n}\n\n/**\n * @param {import('../types/index').URIComponent} component\n * @param {boolean} esc\n * @returns {import('../types/index').URIComponent}\n */\nfunction normalizeComponentEncoding (component, esc) {\n  const func = esc !== true ? escape : unescape\n  if (component.scheme !== undefined) {\n    component.scheme = func(component.scheme)\n  }\n  if (component.userinfo !== undefined) {\n    component.userinfo = func(component.userinfo)\n  }\n  if (component.host !== undefined) {\n    component.host = func(component.host)\n  }\n  if (component.path !== undefined) {\n    component.path = func(component.path)\n  }\n  if (component.query !== undefined) {\n    component.query = func(component.query)\n  }\n  if (component.fragment !== undefined) {\n    component.fragment = func(component.fragment)\n  }\n  return component\n}\n\n/**\n * @param {import('../types/index').URIComponent} component\n * @returns {string|undefined}\n */\nfunction recomposeAuthority (component) {\n  const uriTokens = []\n\n  if (component.userinfo !== undefined) {\n    uriTokens.push(component.userinfo)\n    uriTokens.push('@')\n  }\n\n  if (component.host !== undefined) {\n    let host = unescape(component.host)\n    if (!isIPv4(host)) {\n      const ipV6res = normalizeIPv6(host)\n      if (ipV6res.isIPV6 === true) {\n        host = `[${ipV6res.escapedHost}]`\n      } else {\n        host = component.host\n      }\n    }\n    uriTokens.push(host)\n  }\n\n  if (typeof component.port === 'number' || typeof component.port === 'string') {\n    uriTokens.push(':')\n    uriTokens.push(String(component.port))\n  }\n\n  return uriTokens.length ? uriTokens.join('') : undefined\n};\n\nmodule.exports = {\n  nonSimpleDomain,\n  recomposeAuthority,\n  normalizeComponentEncoding,\n  removeDotSegments,\n  isIPv4,\n  isUUID,\n  normalizeIPv6,\n  stringArrayToHexStripped\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}

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

@@ -0,0 +1,80 @@
+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 };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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