@cartanova/qgrid-cli 2.7.0 → 2.7.2

package/bundle/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/pattern.js

@@ -0,0 +1,40 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_code } from "../code.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/pattern.js
+var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const code_1 = require_code();
+	const util_1 = require_util();
+	const codegen_1 = require_codegen();
+	exports.default = {
+		keyword: "pattern",
+		type: "string",
+		schemaType: "string",
+		$data: true,
+		error: {
+			message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
+			params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { gen, data, $data, schema, schemaCode, it } = cxt;
+			const u = it.opts.unicodeRegExp ? "u" : "";
+			if ($data) {
+				const { regExp } = it.opts.code;
+				const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+				const valid = gen.let("valid");
+				gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+				cxt.fail$data((0, codegen_1._)`!${valid}`);
+			} else {
+				const regExp = (0, code_1.usePattern)(cxt, schema);
+				cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+			}
+		}
+	};
+}));
+//#endregion
+export default require_pattern();
+export { require_pattern };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/required.js

@@ -0,0 +1,74 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_code } from "../code.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/required.js
+var require_required = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const code_1 = require_code();
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "required",
+		type: "object",
+		schemaType: "array",
+		$data: true,
+		error: {
+			message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
+			params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
+		},
+		code(cxt) {
+			const { gen, schema, schemaCode, data, $data, it } = cxt;
+			const { opts } = it;
+			if (!$data && schema.length === 0) return;
+			const useLoop = schema.length >= opts.loopRequired;
+			if (it.allErrors) allErrorsMode();
+			else exitOnErrorMode();
+			if (opts.strictRequired) {
+				const props = cxt.parentSchema.properties;
+				const { definedProperties } = cxt.it;
+				for (const requiredKey of schema) if ((props === null || props === void 0 ? void 0 : props[requiredKey]) === void 0 && !definedProperties.has(requiredKey)) {
+					const msg = `required property "${requiredKey}" is not defined at "${it.schemaEnv.baseId + it.errSchemaPath}" (strictRequired)`;
+					(0, util_1.checkStrictMode)(it, msg, it.opts.strictRequired);
+				}
+			}
+			function allErrorsMode() {
+				if (useLoop || $data) cxt.block$data(codegen_1.nil, loopAllRequired);
+				else for (const prop of schema) (0, code_1.checkReportMissingProp)(cxt, prop);
+			}
+			function exitOnErrorMode() {
+				const missing = gen.let("missing");
+				if (useLoop || $data) {
+					const valid = gen.let("valid", true);
+					cxt.block$data(valid, () => loopUntilMissing(missing, valid));
+					cxt.ok(valid);
+				} else {
+					gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
+					(0, code_1.reportMissingProp)(cxt, missing);
+					gen.else();
+				}
+			}
+			function loopAllRequired() {
+				gen.forOf("prop", schemaCode, (prop) => {
+					cxt.setParams({ missingProperty: prop });
+					gen.if((0, code_1.noPropertyInData)(gen, data, prop, opts.ownProperties), () => cxt.error());
+				});
+			}
+			function loopUntilMissing(missing, valid) {
+				cxt.setParams({ missingProperty: missing });
+				gen.forOf(missing, schemaCode, () => {
+					gen.assign(valid, (0, code_1.propertyInData)(gen, data, missing, opts.ownProperties));
+					gen.if((0, codegen_1.not)(valid), () => {
+						cxt.error();
+						gen.break();
+					});
+				}, codegen_1.nil);
+			}
+		}
+	};
+}));
+//#endregion
+export default require_required();
+export { require_required };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js

@@ -0,0 +1,72 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_dataType } from "../../compile/validate/dataType.js";
+import { require_equal } from "../../runtime/equal.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/uniqueItems.js
+var require_uniqueItems = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dataType_1 = require_dataType();
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const equal_1 = require_equal();
+	exports.default = {
+		keyword: "uniqueItems",
+		type: "array",
+		schemaType: "boolean",
+		$data: true,
+		error: {
+			message: ({ params: { i, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i} are identical)`,
+			params: ({ params: { i, j } }) => (0, codegen_1._)`{i: ${i}, j: ${j}}`
+		},
+		code(cxt) {
+			const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
+			if (!$data && !schema) return;
+			const valid = gen.let("valid");
+			const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
+			cxt.block$data(valid, validateUniqueItems, (0, codegen_1._)`${schemaCode} === false`);
+			cxt.ok(valid);
+			function validateUniqueItems() {
+				const i = gen.let("i", (0, codegen_1._)`${data}.length`);
+				const j = gen.let("j");
+				cxt.setParams({
+					i,
+					j
+				});
+				gen.assign(valid, true);
+				gen.if((0, codegen_1._)`${i} > 1`, () => (canOptimize() ? loopN : loopN2)(i, j));
+			}
+			function canOptimize() {
+				return itemTypes.length > 0 && !itemTypes.some((t) => t === "object" || t === "array");
+			}
+			function loopN(i, j) {
+				const item = gen.name("item");
+				const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
+				const indices = gen.const("indices", (0, codegen_1._)`{}`);
+				gen.for((0, codegen_1._)`;${i}--;`, () => {
+					gen.let(item, (0, codegen_1._)`${data}[${i}]`);
+					gen.if(wrongType, (0, codegen_1._)`continue`);
+					if (itemTypes.length > 1) gen.if((0, codegen_1._)`typeof ${item} == "string"`, (0, codegen_1._)`${item} += "_"`);
+					gen.if((0, codegen_1._)`typeof ${indices}[${item}] == "number"`, () => {
+						gen.assign(j, (0, codegen_1._)`${indices}[${item}]`);
+						cxt.error();
+						gen.assign(valid, false).break();
+					}).code((0, codegen_1._)`${indices}[${item}] = ${i}`);
+				});
+			}
+			function loopN2(i, j) {
+				const eql = (0, util_1.useFunc)(gen, equal_1.default);
+				const outer = gen.name("outer");
+				gen.label(outer).for((0, codegen_1._)`;${i}--;`, () => gen.for((0, codegen_1._)`${j} = ${i}; ${j}--;`, () => gen.if((0, codegen_1._)`${eql}(${data}[${i}], ${data}[${j}])`, () => {
+					cxt.error();
+					gen.assign(valid, false).break(outer);
+				})));
+			}
+		}
+	};
+}));
+//#endregion
+export default require_uniqueItems();
+export { require_uniqueItems };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/bundle/dist/node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js

@@ -0,0 +1,35 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function equal(a, b) {
+		if (a === b) return true;
+		if (a && b && typeof a == "object" && typeof b == "object") {
+			if (a.constructor !== b.constructor) return false;
+			var length, i, keys;
+			if (Array.isArray(a)) {
+				length = a.length;
+				if (length != b.length) return false;
+				for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
+				return true;
+			}
+			if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+			if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+			if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+			keys = Object.keys(a);
+			length = keys.length;
+			if (length !== Object.keys(b).length) return false;
+			for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+			for (i = length; i-- !== 0;) {
+				var key = keys[i];
+				if (!equal(a[key], b[key])) return false;
+			}
+			return true;
+		}
+		return a !== a && b !== b;
+	};
+}));
+//#endregion
+export default require_fast_deep_equal();
+export { require_fast_deep_equal };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,238 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_utils } from "./lib/utils.js";
+import { require_schemes } from "./lib/schemes.js";
+//#region ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js
+var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+	const { SCHEMES, getSchemeHandler } = require_schemes();
+	/**
+	* @template {import('./types/index').URIComponent|string} T
+	* @param {T} uri
+	* @param {import('./types/index').Options} [options]
+	* @returns {T}
+	*/
+	function normalize(uri, options) {
+		if (typeof uri === "string") uri = serialize(parse(uri, options), options);
+		else if (typeof uri === "object") uri = parse(serialize(uri, options), options);
+		return uri;
+	}
+	/**
+	* @param {string} baseURI
+	* @param {string} relativeURI
+	* @param {import('./types/index').Options} [options]
+	* @returns {string}
+	*/
+	function resolve(baseURI, relativeURI, options) {
+		const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
+		const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+		schemelessOptions.skipEscape = true;
+		return serialize(resolved, schemelessOptions);
+	}
+	/**
+	* @param {import ('./types/index').URIComponent} base
+	* @param {import ('./types/index').URIComponent} relative
+	* @param {import('./types/index').Options} [options]
+	* @param {boolean} [skipNormalization=false]
+	* @returns {import ('./types/index').URIComponent}
+	*/
+	function resolveComponent(base, relative, options, skipNormalization) {
+		/** @type {import('./types/index').URIComponent} */
+		const target = {};
+		if (!skipNormalization) {
+			base = parse(serialize(base, options), options);
+			relative = parse(serialize(relative, options), options);
+		}
+		options = options || {};
+		if (!options.tolerant && relative.scheme) {
+			target.scheme = relative.scheme;
+			target.userinfo = relative.userinfo;
+			target.host = relative.host;
+			target.port = relative.port;
+			target.path = removeDotSegments(relative.path || "");
+			target.query = relative.query;
+		} else {
+			if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
+				target.userinfo = relative.userinfo;
+				target.host = relative.host;
+				target.port = relative.port;
+				target.path = removeDotSegments(relative.path || "");
+				target.query = relative.query;
+			} else {
+				if (!relative.path) {
+					target.path = base.path;
+					if (relative.query !== void 0) target.query = relative.query;
+					else target.query = base.query;
+				} else {
+					if (relative.path[0] === "/") target.path = removeDotSegments(relative.path);
+					else {
+						if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) target.path = "/" + relative.path;
+						else if (!base.path) target.path = relative.path;
+						else target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+						target.path = removeDotSegments(target.path);
+					}
+					target.query = relative.query;
+				}
+				target.userinfo = base.userinfo;
+				target.host = base.host;
+				target.port = base.port;
+			}
+			target.scheme = base.scheme;
+		}
+		target.fragment = relative.fragment;
+		return target;
+	}
+	/**
+	* @param {import ('./types/index').URIComponent|string} uriA
+	* @param {import ('./types/index').URIComponent|string} uriB
+	* @param {import ('./types/index').Options} options
+	* @returns {boolean}
+	*/
+	function equal(uriA, uriB, options) {
+		if (typeof uriA === "string") {
+			uriA = unescape(uriA);
+			uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), {
+				...options,
+				skipEscape: true
+			});
+		} else if (typeof uriA === "object") uriA = serialize(normalizeComponentEncoding(uriA, true), {
+			...options,
+			skipEscape: true
+		});
+		if (typeof uriB === "string") {
+			uriB = unescape(uriB);
+			uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), {
+				...options,
+				skipEscape: true
+			});
+		} else if (typeof uriB === "object") uriB = serialize(normalizeComponentEncoding(uriB, true), {
+			...options,
+			skipEscape: true
+		});
+		return uriA.toLowerCase() === uriB.toLowerCase();
+	}
+	/**
+	* @param {Readonly<import('./types/index').URIComponent>} cmpts
+	* @param {import('./types/index').Options} [opts]
+	* @returns {string}
+	*/
+	function serialize(cmpts, opts) {
+		const component = {
+			host: cmpts.host,
+			scheme: cmpts.scheme,
+			userinfo: cmpts.userinfo,
+			port: cmpts.port,
+			path: cmpts.path,
+			query: cmpts.query,
+			nid: cmpts.nid,
+			nss: cmpts.nss,
+			uuid: cmpts.uuid,
+			fragment: cmpts.fragment,
+			reference: cmpts.reference,
+			resourceName: cmpts.resourceName,
+			secure: cmpts.secure,
+			error: ""
+		};
+		const options = Object.assign({}, opts);
+		const uriTokens = [];
+		const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
+		if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+		if (component.path !== void 0) if (!options.skipEscape) {
+			component.path = escape(component.path);
+			if (component.scheme !== void 0) component.path = component.path.split("%3A").join(":");
+		} else component.path = unescape(component.path);
+		if (options.reference !== "suffix" && component.scheme) uriTokens.push(component.scheme, ":");
+		const authority = recomposeAuthority(component);
+		if (authority !== void 0) {
+			if (options.reference !== "suffix") uriTokens.push("//");
+			uriTokens.push(authority);
+			if (component.path && component.path[0] !== "/") uriTokens.push("/");
+		}
+		if (component.path !== void 0) {
+			let s = component.path;
+			if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) s = removeDotSegments(s);
+			if (authority === void 0 && s[0] === "/" && s[1] === "/") s = "/%2F" + s.slice(2);
+			uriTokens.push(s);
+		}
+		if (component.query !== void 0) uriTokens.push("?", component.query);
+		if (component.fragment !== void 0) uriTokens.push("#", component.fragment);
+		return uriTokens.join("");
+	}
+	const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+	/**
+	* @param {string} uri
+	* @param {import('./types/index').Options} [opts]
+	* @returns
+	*/
+	function parse(uri, opts) {
+		const options = Object.assign({}, opts);
+		/** @type {import('./types/index').URIComponent} */
+		const parsed = {
+			scheme: void 0,
+			userinfo: void 0,
+			host: "",
+			port: void 0,
+			path: "",
+			query: void 0,
+			fragment: void 0
+		};
+		let isIP = false;
+		if (options.reference === "suffix") if (options.scheme) uri = options.scheme + ":" + uri;
+		else uri = "//" + uri;
+		const matches = uri.match(URI_PARSE);
+		if (matches) {
+			parsed.scheme = matches[1];
+			parsed.userinfo = matches[3];
+			parsed.host = matches[4];
+			parsed.port = parseInt(matches[5], 10);
+			parsed.path = matches[6] || "";
+			parsed.query = matches[7];
+			parsed.fragment = matches[8];
+			if (isNaN(parsed.port)) parsed.port = matches[5];
+			if (parsed.host) if (isIPv4(parsed.host) === false) {
+				const ipv6result = normalizeIPv6(parsed.host);
+				parsed.host = ipv6result.host.toLowerCase();
+				isIP = ipv6result.isIPV6;
+			} else isIP = true;
+			if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) parsed.reference = "same-document";
+			else if (parsed.scheme === void 0) parsed.reference = "relative";
+			else if (parsed.fragment === void 0) parsed.reference = "absolute";
+			else parsed.reference = "uri";
+			if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
+			const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
+			if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
+				if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) try {
+					parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
+				} catch (e) {
+					parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+				}
+			}
+			if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
+				if (uri.indexOf("%") !== -1) {
+					if (parsed.scheme !== void 0) parsed.scheme = unescape(parsed.scheme);
+					if (parsed.host !== void 0) parsed.host = unescape(parsed.host);
+				}
+				if (parsed.path) parsed.path = escape(unescape(parsed.path));
+				if (parsed.fragment) parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+			}
+			if (schemeHandler && schemeHandler.parse) schemeHandler.parse(parsed, options);
+		} else parsed.error = parsed.error || "URI can not be parsed.";
+		return parsed;
+	}
+	const fastUri = {
+		SCHEMES,
+		normalize,
+		resolve,
+		resolveComponent,
+		equal,
+		serialize,
+		parse
+	};
+	module.exports = fastUri;
+	module.exports.default = fastUri;
+	module.exports.fastUri = fastUri;
+}));
+//#endregion
+export default require_fast_uri();
+export { require_fast_uri };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":[],"sources":["../../../../../../../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js"],"sourcesContent":["'use strict'\n\nconst { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require('./lib/utils')\nconst { SCHEMES, getSchemeHandler } = require('./lib/schemes')\n\n/**\n * @template {import('./types/index').URIComponent|string} T\n * @param {T} uri\n * @param {import('./types/index').Options} [options]\n * @returns {T}\n */\nfunction normalize (uri, options) {\n  if (typeof uri === 'string') {\n    uri = /** @type {T} */ (serialize(parse(uri, options), options))\n  } else if (typeof uri === 'object') {\n    uri = /** @type {T} */ (parse(serialize(uri, options), options))\n  }\n  return uri\n}\n\n/**\n * @param {string} baseURI\n * @param {string} relativeURI\n * @param {import('./types/index').Options} [options]\n * @returns {string}\n */\nfunction resolve (baseURI, relativeURI, options) {\n  const schemelessOptions = options ? Object.assign({ scheme: 'null' }, options) : { scheme: 'null' }\n  const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true)\n  schemelessOptions.skipEscape = true\n  return serialize(resolved, schemelessOptions)\n}\n\n/**\n * @param {import ('./types/index').URIComponent} base\n * @param {import ('./types/index').URIComponent} relative\n * @param {import('./types/index').Options} [options]\n * @param {boolean} [skipNormalization=false]\n * @returns {import ('./types/index').URIComponent}\n */\nfunction resolveComponent (base, relative, options, skipNormalization) {\n  /** @type {import('./types/index').URIComponent} */\n  const target = {}\n  if (!skipNormalization) {\n    base = parse(serialize(base, options), options) // normalize base component\n    relative = parse(serialize(relative, options), options) // normalize relative component\n  }\n  options = options || {}\n\n  if (!options.tolerant && relative.scheme) {\n    target.scheme = relative.scheme\n    // target.authority = relative.authority;\n    target.userinfo = relative.userinfo\n    target.host = relative.host\n    target.port = relative.port\n    target.path = removeDotSegments(relative.path || '')\n    target.query = relative.query\n  } else {\n    if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {\n      // target.authority = relative.authority;\n      target.userinfo = relative.userinfo\n      target.host = relative.host\n      target.port = relative.port\n      target.path = removeDotSegments(relative.path || '')\n      target.query = relative.query\n    } else {\n      if (!relative.path) {\n        target.path = base.path\n        if (relative.query !== undefined) {\n          target.query = relative.query\n        } else {\n          target.query = base.query\n        }\n      } else {\n        if (relative.path[0] === '/') {\n          target.path = removeDotSegments(relative.path)\n        } else {\n          if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {\n            target.path = '/' + relative.path\n          } else if (!base.path) {\n            target.path = relative.path\n          } else {\n            target.path = base.path.slice(0, base.path.lastIndexOf('/') + 1) + relative.path\n          }\n          target.path = removeDotSegments(target.path)\n        }\n        target.query = relative.query\n      }\n      // target.authority = base.authority;\n      target.userinfo = base.userinfo\n      target.host = base.host\n      target.port = base.port\n    }\n    target.scheme = base.scheme\n  }\n\n  target.fragment = relative.fragment\n\n  return target\n}\n\n/**\n * @param {import ('./types/index').URIComponent|string} uriA\n * @param {import ('./types/index').URIComponent|string} uriB\n * @param {import ('./types/index').Options} options\n * @returns {boolean}\n */\nfunction equal (uriA, uriB, options) {\n  if (typeof uriA === 'string') {\n    uriA = unescape(uriA)\n    uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), { ...options, skipEscape: true })\n  } else if (typeof uriA === 'object') {\n    uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true })\n  }\n\n  if (typeof uriB === 'string') {\n    uriB = unescape(uriB)\n    uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), { ...options, skipEscape: true })\n  } else if (typeof uriB === 'object') {\n    uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true })\n  }\n\n  return uriA.toLowerCase() === uriB.toLowerCase()\n}\n\n/**\n * @param {Readonly<import('./types/index').URIComponent>} cmpts\n * @param {import('./types/index').Options} [opts]\n * @returns {string}\n */\nfunction serialize (cmpts, opts) {\n  const component = {\n    host: cmpts.host,\n    scheme: cmpts.scheme,\n    userinfo: cmpts.userinfo,\n    port: cmpts.port,\n    path: cmpts.path,\n    query: cmpts.query,\n    nid: cmpts.nid,\n    nss: cmpts.nss,\n    uuid: cmpts.uuid,\n    fragment: cmpts.fragment,\n    reference: cmpts.reference,\n    resourceName: cmpts.resourceName,\n    secure: cmpts.secure,\n    error: ''\n  }\n  const options = Object.assign({}, opts)\n  const uriTokens = []\n\n  // find scheme handler\n  const schemeHandler = getSchemeHandler(options.scheme || component.scheme)\n\n  // perform scheme specific serialization\n  if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options)\n\n  if (component.path !== undefined) {\n    if (!options.skipEscape) {\n      component.path = escape(component.path)\n\n      if (component.scheme !== undefined) {\n        component.path = component.path.split('%3A').join(':')\n      }\n    } else {\n      component.path = unescape(component.path)\n    }\n  }\n\n  if (options.reference !== 'suffix' && component.scheme) {\n    uriTokens.push(component.scheme, ':')\n  }\n\n  const authority = recomposeAuthority(component)\n  if (authority !== undefined) {\n    if (options.reference !== 'suffix') {\n      uriTokens.push('//')\n    }\n\n    uriTokens.push(authority)\n\n    if (component.path && component.path[0] !== '/') {\n      uriTokens.push('/')\n    }\n  }\n  if (component.path !== undefined) {\n    let s = component.path\n\n    if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {\n      s = removeDotSegments(s)\n    }\n\n    if (\n      authority === undefined &&\n      s[0] === '/' &&\n      s[1] === '/'\n    ) {\n      // don't allow the path to start with \"//\"\n      s = '/%2F' + s.slice(2)\n    }\n\n    uriTokens.push(s)\n  }\n\n  if (component.query !== undefined) {\n    uriTokens.push('?', component.query)\n  }\n\n  if (component.fragment !== undefined) {\n    uriTokens.push('#', component.fragment)\n  }\n  return uriTokens.join('')\n}\n\nconst URI_PARSE = /^(?:([^#/:?]+):)?(?:\\/\\/((?:([^#/?@]*)@)?(\\[[^#/?\\]]+\\]|[^#/:?]*)(?::(\\d*))?))?([^#?]*)(?:\\?([^#]*))?(?:#((?:.|[\\n\\r])*))?/u\n\n/**\n * @param {string} uri\n * @param {import('./types/index').Options} [opts]\n * @returns\n */\nfunction parse (uri, opts) {\n  const options = Object.assign({}, opts)\n  /** @type {import('./types/index').URIComponent} */\n  const parsed = {\n    scheme: undefined,\n    userinfo: undefined,\n    host: '',\n    port: undefined,\n    path: '',\n    query: undefined,\n    fragment: undefined\n  }\n\n  let isIP = false\n  if (options.reference === 'suffix') {\n    if (options.scheme) {\n      uri = options.scheme + ':' + uri\n    } else {\n      uri = '//' + uri\n    }\n  }\n\n  const matches = uri.match(URI_PARSE)\n\n  if (matches) {\n    // store each component\n    parsed.scheme = matches[1]\n    parsed.userinfo = matches[3]\n    parsed.host = matches[4]\n    parsed.port = parseInt(matches[5], 10)\n    parsed.path = matches[6] || ''\n    parsed.query = matches[7]\n    parsed.fragment = matches[8]\n\n    // fix port number\n    if (isNaN(parsed.port)) {\n      parsed.port = matches[5]\n    }\n    if (parsed.host) {\n      const ipv4result = isIPv4(parsed.host)\n      if (ipv4result === false) {\n        const ipv6result = normalizeIPv6(parsed.host)\n        parsed.host = ipv6result.host.toLowerCase()\n        isIP = ipv6result.isIPV6\n      } else {\n        isIP = true\n      }\n    }\n    if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && parsed.query === undefined && !parsed.path) {\n      parsed.reference = 'same-document'\n    } else if (parsed.scheme === undefined) {\n      parsed.reference = 'relative'\n    } else if (parsed.fragment === undefined) {\n      parsed.reference = 'absolute'\n    } else {\n      parsed.reference = 'uri'\n    }\n\n    // check for reference errors\n    if (options.reference && options.reference !== 'suffix' && options.reference !== parsed.reference) {\n      parsed.error = parsed.error || 'URI is not a ' + options.reference + ' reference.'\n    }\n\n    // find scheme handler\n    const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme)\n\n    // check if scheme can't handle IRIs\n    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {\n      // if host component is a domain name\n      if (parsed.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost)) && isIP === false && nonSimpleDomain(parsed.host)) {\n        // convert Unicode IDN -> ASCII IDN\n        try {\n          parsed.host = URL.domainToASCII(parsed.host.toLowerCase())\n        } catch (e) {\n          parsed.error = parsed.error || \"Host's domain name can not be converted to ASCII: \" + e\n        }\n      }\n      // convert IRI -> URI\n    }\n\n    if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) {\n      if (uri.indexOf('%') !== -1) {\n        if (parsed.scheme !== undefined) {\n          parsed.scheme = unescape(parsed.scheme)\n        }\n        if (parsed.host !== undefined) {\n          parsed.host = unescape(parsed.host)\n        }\n      }\n      if (parsed.path) {\n        parsed.path = escape(unescape(parsed.path))\n      }\n      if (parsed.fragment) {\n        parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment))\n      }\n    }\n\n    // perform scheme specific parsing\n    if (schemeHandler && schemeHandler.parse) {\n      schemeHandler.parse(parsed, options)\n    }\n  } else {\n    parsed.error = parsed.error || 'URI can not be parsed.'\n  }\n  return parsed\n}\n\nconst fastUri = {\n  SCHEMES,\n  normalize,\n  resolve,\n  resolveComponent,\n  equal,\n  serialize,\n  parse\n}\n\nmodule.exports = fastUri\nmodule.exports.default = fastUri\nmodule.exports.fastUri = fastUri\n"],"x_google_ignoreList":[0],"mappings":"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"}