fumadocs-openapi 10.8.4 → 10.8.6

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/required.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_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 };

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

@@ -0,0 +1,70 @@
+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 };

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

@@ -0,0 +1,33 @@
+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 };

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

@@ -0,0 +1,236 @@
+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 };

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

@@ -0,0 +1,187 @@
+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 };