@fumadocs/api-docs 0.0.3 → 0.1.0

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.6_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/refs.d.ts

@@ -1,134 +0,0 @@
-import { JSONSchema } from "./types/index.js";
-import { ParserOptions } from "./options.js";
-import { $Ref } from "./ref.js";
-import { Pointer } from "./pointer.js";
-import { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from "json-schema";
-
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/refs.d.ts
-interface $RefsMap<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
-  [url: string]: $Ref<S, O>;
-}
-/**
- * When you call the resolve method, the value that gets passed to the callback function (or Promise) is a $Refs object. This same object is accessible via the parser.$refs property of $RefParser objects.
- *
- * This object is a map of JSON References and their resolved values. It also has several convenient helper methods that make it easy for you to navigate and manipulate the JSON References.
- *
- * See https://apidevtools.com/json-schema-ref-parser/docs/refs.html
- */
-declare class $Refs<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
-  /**
-   * This property is true if the schema contains any circular references. You may want to check this property before serializing the dereferenced schema as JSON, since JSON.stringify() does not support circular references by default.
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/refs.html#circular
-   */
-  circular: boolean;
-  /**
-   * Returns the paths/URLs of all the files in your schema (including the main schema file).
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/refs.html#pathstypes
-   *
-   * @param types (optional) Optionally only return certain types of paths ("file", "http", etc.)
-   */
-  paths(...types: (string | string[])[]): string[];
-  /**
-   * Returns a map of paths/URLs and their correspond values.
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/refs.html#valuestypes
-   *
-   * @param types (optional) Optionally only return values from certain locations ("file", "http", etc.)
-   */
-  values(...types: (string | string[])[]): S;
-  /**
-   * Returns `true` if the given path exists in the schema; otherwise, returns `false`
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/refs.html#existsref
-   *
-   * @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
-   */
-  /**
-   * Determines whether the given JSON reference exists.
-   *
-   * @param path - The path being resolved, optionally with a JSON pointer in the hash
-   * @param [options]
-   * @returns
-   */
-  exists(path: string, options: any): boolean;
-  /**
-   * Resolves the given JSON reference and returns the resolved value.
-   *
-   * @param path - The path being resolved, with a JSON pointer in the hash
-   * @param [options]
-   * @returns - Returns the resolved value
-   */
-  get(path: string, options?: O): JSONSchema4Type | JSONSchema6Type | JSONSchema7Type;
-  /**
-   * Sets the value at the given path in the schema. If the property, or any of its parents, don't exist, they will be created.
-   *
-   * @param path The JSON Reference path, optionally with a JSON Pointer in the hash
-   * @param value The value to assign. Can be anything (object, string, number, etc.)
-   */
-  set(path: string, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type): void;
-  /**
-   * Returns the specified {@link $Ref} object, or undefined.
-   *
-   * @param path - The path being resolved, optionally with a JSON pointer in the hash
-   * @returns
-   * @protected
-   */
-  _get$Ref(path: string): $Ref<S, O>;
-  /**
-   * Creates a new {@link $Ref} object and adds it to this {@link $Refs} object.
-   *
-   * @param path  - The file path or URL of the referenced file
-   */
-  _add(path: string): $Ref<S, O>;
-  _addAlias(path: string, value: S, pathType?: string | unknown, dynamicIdScope?: boolean): $Ref<S, O>;
-  /**
-   * Resolves the given JSON reference.
-   *
-   * @param path - The path being resolved, optionally with a JSON pointer in the hash
-   * @param pathFromRoot - The path of `obj` from the schema root
-   * @param [options]
-   * @returns
-   * @protected
-   */
-  _resolve(path: string, pathFromRoot: string, options?: O): Pointer<S, O> | null;
-  /**
-   * A map of paths/urls to {@link $Ref} objects
-   *
-   * @type {object}
-   * @protected
-   */
-  _$refs: $RefsMap<S, O>;
-  _aliases: $RefsMap<S, O>;
-  /**
-   * The {@link $Ref} object that is the root of the JSON schema.
-   *
-   * @type {$Ref}
-   * @protected
-   */
-  _root$Ref: $Ref<S, O>;
-  constructor();
-  /**
-   * Returns the paths of all the files/URLs that are referenced by the JSON schema,
-   * including the schema itself.
-   *
-   * @param [types] - Only return paths of the given types ("file", "http", etc.)
-   * @returns
-   */
-  /**
-   * Returns the map of JSON references and their resolved values.
-   *
-   * @param [types] - Only return references of the given types ("file", "http", etc.)
-   * @returns
-   */
-  /**
-   * Returns a POJO (plain old JavaScript object) for serialization as JSON.
-   *
-   * @returns {object}
-   */
-  toJSON: (...types: (string | string[])[]) => S;
-  private _getRef;
-}
-//#endregion
-export { $Refs };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.6_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/resolvers/http.js

@@ -1,121 +0,0 @@
-import { isHttp, isUnsafeUrl, parse, resolve } from "../util/url.js";
-import { ResolverError } from "../util/errors.js";
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/resolvers/http.js
-var http_default = {
-	/**
-	* The order that this resolver will run, in relation to other resolvers.
-	*/
-	order: 200,
-	/**
-	* HTTP headers to send when downloading files.
-	*
-	* @example:
-	* {
-	*   "User-Agent": "JSON Schema $Ref Parser",
-	*   Accept: "application/json"
-	* }
-	*/
-	headers: null,
-	/**
-	* HTTP request timeout (in milliseconds).
-	*/
-	timeout: 6e4,
-	/**
-	* The maximum number of HTTP redirects to follow.
-	* To disable automatic following of redirects, set this to zero.
-	*/
-	redirects: 5,
-	/**
-	* The `withCredentials` option of XMLHttpRequest.
-	* Set this to `true` if you're downloading files from a CORS-enabled server that requires authentication
-	*/
-	withCredentials: false,
-	/**
-	* Set this to `false` if you want to allow unsafe URLs (e.g., `127.0.0.1`, localhost, and other internal URLs).
-	*/
-	safeUrlResolver: true,
-	/**
-	* Determines whether this resolver can read a given file reference.
-	* Resolvers that return true will be tried in order, until one successfully resolves the file.
-	* Resolvers that return false will not be given a chance to resolve the file.
-	*/
-	canRead(file) {
-		return isHttp(file.url) && (!this.safeUrlResolver || !isUnsafeUrl(file.url));
-	},
-	/**
-	* Reads the given URL and returns its raw contents as a Buffer.
-	*/
-	read(file) {
-		const u = parse(file.url);
-		if (typeof window !== "undefined" && !u.protocol) u.protocol = parse(location.href).protocol;
-		return download(u, this);
-	}
-};
-/**
-* Downloads the given file.
-* @returns
-* The promise resolves with the raw downloaded data, or rejects if there is an HTTP error.
-*/
-async function download(u, httpOptions, _redirects) {
-	u = parse(u);
-	const redirects = _redirects || [];
-	redirects.push(u.href);
-	try {
-		if (httpOptions.safeUrlResolver && isUnsafeUrl(u.href)) throw new Error(`Unsafe URL blocked by safeUrlResolver: ${u.href}`);
-		const res = await get(u, httpOptions);
-		if (res.status >= 400) {
-			const error = /* @__PURE__ */ new Error(`HTTP ERROR ${res.status}`);
-			error.status = res.status;
-			throw error;
-		} else if (res.status >= 300) if (!Number.isNaN(httpOptions.redirects) && redirects.length > httpOptions.redirects) {
-			const error = /* @__PURE__ */ new Error(`Error downloading ${redirects[0]}. \nToo many redirects: \n  ${redirects.join(" \n  ")}`);
-			error.status = res.status;
-			throw new ResolverError(error);
-		} else {
-			const location = getHeader(res, "location");
-			if (!location) {
-				const error = /* @__PURE__ */ new Error(`HTTP ${res.status} redirect with no location header`);
-				error.status = res.status;
-				throw error;
-			}
-			return download(resolve(u.href, location), httpOptions, redirects);
-		}
-		else {
-			if (res.body) {
-				const buf = await res.arrayBuffer();
-				return Buffer.from(buf);
-			}
-			return Buffer.alloc(0);
-		}
-	} catch (err) {
-		const e = err;
-		e.message = `Error downloading ${u.href}: ${e.message}`;
-		throw new ResolverError(e, u.href);
-	}
-}
-/**
-* Sends an HTTP GET request.
-* The promise resolves with the HTTP Response object.
-*/
-async function get(u, httpOptions) {
-	let controller;
-	let timeoutId;
-	if (httpOptions.timeout && typeof AbortController !== "undefined") {
-		controller = new AbortController();
-		timeoutId = setTimeout(() => controller.abort(), httpOptions.timeout);
-	}
-	const response = await fetch(u, {
-		method: "GET",
-		headers: httpOptions.headers || {},
-		credentials: httpOptions.withCredentials ? "include" : "same-origin",
-		redirect: "manual",
-		signal: controller ? controller.signal : null
-	});
-	if (timeoutId) clearTimeout(timeoutId);
-	return response;
-}
-function getHeader(response, name) {
-	return response.headers.get(name);
-}
-//#endregion
-export { http_default as default };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.6_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/errors.d.ts

@@ -1,34 +0,0 @@
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/errors.d.ts
-type JSONParserErrorType = "EUNKNOWN" | "EPARSER" | "EUNMATCHEDPARSER" | "ETIMEOUT" | "ERESOLVER" | "EUNMATCHEDRESOLVER" | "EMISSINGPOINTER" | "EINVALIDPOINTER";
-declare class JSONParserError extends Error {
-  readonly name: string;
-  readonly message: string;
-  source: string | undefined;
-  path: Array<string | number> | null;
-  readonly code: JSONParserErrorType;
-  constructor(message: string, source?: string);
-  toJSON: () => Error;
-  get footprint(): string;
-}
-declare class ParserError extends JSONParserError {
-  code: JSONParserErrorType;
-  name: string;
-  constructor(message: any, source: any);
-}
-declare class ResolverError extends JSONParserError {
-  code: JSONParserErrorType;
-  name: string;
-  ioErrorCode?: string;
-  constructor(ex: Error | any, source?: string);
-}
-declare class MissingPointerError extends JSONParserError {
-  code: JSONParserErrorType;
-  name: string;
-  targetToken: any;
-  targetRef: string;
-  targetFound: string;
-  parentPath: string;
-  constructor(token: any, path: any, targetRef: any, targetFound: any, parentPath: any);
-}
-//#endregion
-export { JSONParserError, MissingPointerError, ParserError, ResolverError };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.6_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/is-windows.js

@@ -1,5 +0,0 @@
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/is-windows.js
-const isWindowsConst = /^win/.test(globalThis.process ? globalThis.process.platform : "");
-const isWindows = () => isWindowsConst;
-//#endregion
-export { isWindows };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.6_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/url.js

@@ -1,381 +0,0 @@
-import convertPathToPosix from "./convert-path-to-posix.js";
-import { isWindows } from "./is-windows.js";
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/url.js
-const forwardSlashPattern = /\//g;
-const protocolPattern = /^(\w{2,}):\/\//i;
-const jsonPointerSlash = /~1/g;
-const jsonPointerTilde = /~0/g;
-const isAbsoluteWin32Path = /^[a-zA-Z]:[\\/]/;
-const urlEncodePatterns = [[/\?/g, "%3F"], [/#/g, "%23"]];
-const urlDecodePatterns = [
-	/%23/g,
-	"#",
-	/%24/g,
-	"$",
-	/%26/g,
-	"&",
-	/%2C/g,
-	",",
-	/%40/g,
-	"@"
-];
-const unsafeDomainSuffixes = [
-	".localhost",
-	".local",
-	".internal",
-	".intranet",
-	".corp",
-	".home",
-	".lan"
-];
-const parse = (u) => new URL(u);
-/**
-* Returns resolved target URL relative to a base URL in a manner similar to that of a Web browser resolving an anchor tag HREF.
-*
-* @returns
-*/
-function resolve(from, to) {
-	const fromUrl = new URL(convertPathToPosix(from), "https://aaa.nonexistanturl.com");
-	const resolvedUrl = new URL(convertPathToPosix(to), fromUrl);
-	const endSpaces = to.match(/(\s*)$/)?.[1] || "";
-	if (resolvedUrl.hostname === "aaa.nonexistanturl.com") {
-		const { pathname, search, hash } = resolvedUrl;
-		return pathname + search + decodeURIComponent(hash) + endSpaces;
-	}
-	const resolved = resolvedUrl.toString() + endSpaces;
-	if (resolved.includes("#")) {
-		const [base, hash] = resolved.split("#", 2);
-		return base + "#" + decodeURIComponent(hash || "");
-	}
-	return resolved;
-}
-/**
-* Returns the current working directory (in Node) or the current page URL (in browsers).
-*
-* @returns
-*/
-function cwd() {
-	if (typeof window !== "undefined" && window.location && window.location.href) {
-		const href = window.location.href;
-		if (!href || !href.startsWith("http")) try {
-			new URL(href);
-			return href;
-		} catch {
-			return "/";
-		}
-		return href;
-	}
-	if (typeof process !== "undefined" && process.cwd) {
-		const path = process.cwd();
-		const lastChar = path.slice(-1);
-		if (lastChar === "/" || lastChar === "\\") return path;
-		else return path + "/";
-	}
-	return "/";
-}
-/**
-* Returns the protocol of the given URL, or `undefined` if it has no protocol.
-*
-* @param path
-* @returns
-*/
-function getProtocol(path) {
-	const match = protocolPattern.exec(path || "");
-	if (match) return match[1].toLowerCase();
-}
-/**
-* Returns the lowercased file extension of the given URL,
-* or an empty string if it has no extension.
-*
-* @param path
-* @returns
-*/
-function getExtension(path) {
-	const lastDot = path.lastIndexOf(".");
-	if (lastDot >= 0) return stripQuery(path.substring(lastDot).toLowerCase());
-	return "";
-}
-/**
-* Removes the query, if any, from the given path.
-*
-* @param path
-* @returns
-*/
-function stripQuery(path) {
-	const queryIndex = path.indexOf("?");
-	if (queryIndex >= 0) path = path.substring(0, queryIndex);
-	return path;
-}
-/**
-* Returns the hash (URL fragment), of the given path.
-* If there is no hash, then the root hash ("#") is returned.
-*
-* @param path
-* @returns
-*/
-function getHash(path) {
-	if (!path) return "#";
-	const hashIndex = path.indexOf("#");
-	if (hashIndex >= 0) return path.substring(hashIndex);
-	return "#";
-}
-/**
-* Removes the hash (URL fragment), if any, from the given path.
-*
-* @param path
-* @returns
-*/
-function stripHash(path) {
-	if (!path) return "";
-	const hashIndex = path.indexOf("#");
-	if (hashIndex >= 0) path = path.substring(0, hashIndex);
-	return path;
-}
-/**
-* Determines whether the given path is an HTTP(S) URL.
-*
-* @param path
-* @returns
-*/
-function isHttp(path) {
-	const protocol = getProtocol(path);
-	if (protocol === "http" || protocol === "https") return true;
-	else if (protocol === void 0) return typeof window !== "undefined";
-	else return false;
-}
-/**
-* Determines whether the given url is an unsafe or internal url.
-*
-* @param path - The URL or path to check
-* @returns true if the URL is unsafe/internal, false otherwise
-*/
-function isUnsafeUrl(path) {
-	if (!path || typeof path !== "string") return true;
-	const normalizedPath = path.trim().toLowerCase();
-	if (!normalizedPath) return true;
-	if (normalizedPath.startsWith("javascript:") || normalizedPath.startsWith("vbscript:") || normalizedPath.startsWith("data:")) return true;
-	if (normalizedPath.startsWith("file:")) return true;
-	if (typeof window !== "undefined" && window.location && window.location.href) return false;
-	try {
-		const url = new URL(normalizedPath.startsWith("//") ? "http:" + normalizedPath : normalizedPath);
-		if (isUnsafeHostname(url.hostname)) return true;
-		const port = url.port;
-		if (port && isInternalPort(parseInt(port))) return true;
-	} catch {
-		if (normalizedPath.startsWith("/") && !normalizedPath.startsWith("//")) return false;
-		if (containsUnsafeHostname(normalizedPath)) return true;
-	}
-	return false;
-}
-/**
-* Helper function to check if a hostname is local or resolves to a non-public literal address.
-*/
-function isUnsafeHostname(hostname) {
-	const normalizedHostname = normalizeHostname(hostname);
-	if (!normalizedHostname) return true;
-	if (normalizedHostname === "localhost" || unsafeDomainSuffixes.some((suffix) => normalizedHostname.endsWith(suffix))) return true;
-	const ipv4 = parseIPv4Address(normalizedHostname);
-	if (ipv4) return isUnsafeIPv4Address(ipv4);
-	const ipv6 = parseIPv6Address(normalizedHostname);
-	if (ipv6) return isUnsafeIPv6Address(ipv6);
-	return false;
-}
-function normalizeHostname(hostname) {
-	let normalizedHostname = hostname.trim().toLowerCase();
-	if (normalizedHostname.startsWith("[") && normalizedHostname.endsWith("]")) normalizedHostname = normalizedHostname.slice(1, -1);
-	while (normalizedHostname.endsWith(".")) normalizedHostname = normalizedHostname.slice(0, -1);
-	return normalizedHostname;
-}
-function parseIPv4Address(ip) {
-	const parts = ip.split(".");
-	if (parts.length !== 4) return;
-	const octets = parts.map((part) => {
-		if (!/^\d+$/.test(part)) return NaN;
-		return Number(part);
-	});
-	if (octets.some((octet) => !Number.isInteger(octet) || octet < 0 || octet > 255)) return;
-	return octets;
-}
-/**
-* Helper function to check if an IPv4 address is in a non-public range.
-*/
-function isUnsafeIPv4Address([a, b, c, d]) {
-	return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 && c === 0 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224 || a === 255 && b === 255 && c === 255 && d === 255;
-}
-function parseIPv6Address(ip) {
-	if (!ip.includes(":")) return;
-	let normalizedIP = ip;
-	const lastSeparator = normalizedIP.lastIndexOf(":");
-	const possibleIPv4 = normalizedIP.slice(lastSeparator + 1);
-	if (possibleIPv4.includes(".")) {
-		const ipv4 = parseIPv4Address(possibleIPv4);
-		if (!ipv4) return;
-		const firstGroup = ipv4[0] * 256 + ipv4[1];
-		const secondGroup = ipv4[2] * 256 + ipv4[3];
-		normalizedIP = `${normalizedIP.slice(0, lastSeparator + 1)}${firstGroup.toString(16)}:${secondGroup.toString(16)}`;
-	}
-	const halves = normalizedIP.split("::");
-	if (halves.length > 2) return;
-	const head = parseIPv6Groups(halves[0]);
-	const tail = halves.length === 2 ? parseIPv6Groups(halves[1]) : [];
-	if (!head || !tail) return;
-	if (halves.length === 1) return head.length === 8 ? head : void 0;
-	const missingGroups = 8 - head.length - tail.length;
-	if (missingGroups < 1) return;
-	return [
-		...head,
-		...Array(missingGroups).fill(0),
-		...tail
-	];
-}
-function parseIPv6Groups(groups) {
-	if (!groups) return [];
-	const parsedGroups = groups.split(":").map((group) => {
-		if (!/^[\da-f]{1,4}$/i.test(group)) return NaN;
-		return Number.parseInt(group, 16);
-	});
-	if (parsedGroups.some((group) => !Number.isInteger(group) || group < 0 || group > 65535)) return;
-	return parsedGroups;
-}
-/**
-* Helper function to check if an IPv6 address is in a non-public range.
-*/
-function isUnsafeIPv6Address(groups) {
-	if (groups.length !== 8) return false;
-	const isUnspecified = groups.every((group) => group === 0);
-	const isLoopback = groups.slice(0, 7).every((group) => group === 0) && groups[7] === 1;
-	const isUniqueLocal = (groups[0] & 65024) === 64512;
-	const isLinkLocal = (groups[0] & 65472) === 65152;
-	const isMulticast = (groups[0] & 65280) === 65280;
-	if (isUnspecified || isLoopback || isUniqueLocal || isLinkLocal || isMulticast) return true;
-	const mappedIPv4 = getMappedIPv4Address(groups);
-	return mappedIPv4 ? isUnsafeIPv4Address(mappedIPv4) : false;
-}
-function getMappedIPv4Address(groups) {
-	const firstFiveGroupsAreZero = groups.slice(0, 5).every((group) => group === 0);
-	const firstSixGroupsAreZero = firstFiveGroupsAreZero && groups[5] === 0;
-	const isIPv4Mapped = firstFiveGroupsAreZero && groups[5] === 65535;
-	if (!firstSixGroupsAreZero && !isIPv4Mapped) return;
-	return [
-		Math.floor(groups[6] / 256),
-		groups[6] % 256,
-		Math.floor(groups[7] / 256),
-		groups[7] % 256
-	];
-}
-function containsUnsafeHostname(value) {
-	return value.split(/[\s/?#]+/).map((candidate) => candidate.replace(/^[a-z][\d+.a-z-]*:\/\//i, "").replace(/:\d+$/, "")).filter(Boolean).some((candidate) => isUnsafeHostname(candidate));
-}
-/**
-* Helper function to check if a port is typically used for internal services
-*/
-function isInternalPort(port) {
-	return [
-		22,
-		23,
-		25,
-		53,
-		135,
-		139,
-		445,
-		993,
-		995,
-		1433,
-		1521,
-		3306,
-		3389,
-		5432,
-		5900,
-		6379,
-		8080,
-		8443,
-		9200,
-		27017
-	].includes(port);
-}
-/**
-* Determines whether the given path is a filesystem path.
-* This includes "file://" URLs.
-*
-* @param path
-* @returns
-*/
-function isFileSystemPath(path) {
-	if (typeof window !== "undefined" || typeof process !== "undefined" && process.browser) return false;
-	const protocol = getProtocol(path);
-	return protocol === void 0 || protocol === "file";
-}
-/**
-* Converts a filesystem path to a properly-encoded URL.
-*
-* This is intended to handle situations where JSON Schema $Ref Parser is called
-* with a filesystem path that contains characters which are not allowed in URLs.
-*
-* @example
-* The following filesystem paths would be converted to the following URLs:
-*
-*    <"!@#$%^&*+=?'>.json              ==>   %3C%22!@%23$%25%5E&*+=%3F\'%3E.json
-*    C:\\My Documents\\File (1).json   ==>   C:/My%20Documents/File%20(1).json
-*    file://Project #42/file.json      ==>   file://Project%20%2342/file.json
-*
-* @param path
-* @returns
-*/
-function fromFileSystemPath(path) {
-	if (isWindows()) {
-		const projectDir = cwd();
-		const upperPath = path.toUpperCase();
-		const posixUpper = convertPathToPosix(projectDir).toUpperCase();
-		const hasProjectDir = upperPath.includes(posixUpper);
-		const hasProjectUri = upperPath.includes(posixUpper);
-		const isAbsolutePath = isAbsoluteWin32Path.test(path) || path.startsWith("http://") || path.startsWith("https://") || path.startsWith("file://");
-		if (!(hasProjectDir || hasProjectUri || isAbsolutePath) && !projectDir.startsWith("http")) {
-			const join = (a, b) => {
-				if (a.endsWith("/") || a.endsWith("\\")) return a + b;
-				else return a + "/" + b;
-			};
-			path = join(projectDir, path);
-		}
-		path = convertPathToPosix(path);
-	}
-	path = encodeURI(path);
-	for (const pattern of urlEncodePatterns) path = path.replace(pattern[0], pattern[1]);
-	return path;
-}
-/**
-* Converts a URL to a local filesystem path.
-*/
-function toFileSystemPath(path, keepFileProtocol) {
-	path = path.replace(/%(?![0-9A-Fa-f]{2})/g, "%25");
-	path = decodeURI(path);
-	for (let i = 0; i < urlDecodePatterns.length; i += 2) path = path.replace(urlDecodePatterns[i], urlDecodePatterns[i + 1]);
-	let isFileUrl = path.toLowerCase().startsWith("file://");
-	if (isFileUrl) {
-		path = path.replace(/^file:\/\//, "").replace(/^\//, "");
-		if (isWindows() && path[1] === "/") path = `${path[0]}:${path.substring(1)}`;
-		if (keepFileProtocol) path = "file:///" + path;
-		else {
-			isFileUrl = false;
-			path = isWindows() ? path : "/" + path;
-		}
-	}
-	if (isWindows() && !isFileUrl) {
-		path = path.replace(forwardSlashPattern, "\\");
-		if (path.match(/^[a-z]:\\/i)) path = path[0].toUpperCase() + path.substring(1);
-	}
-	return path;
-}
-/**
-* Converts a $ref pointer to a valid JSON Path.
-*
-* @param pointer
-* @returns
-*/
-function safePointerToPath(pointer) {
-	if (pointer.length <= 1 || pointer[0] !== "#" || pointer[1] !== "/") return [];
-	return pointer.slice(2).split("/").map((value) => {
-		return value.replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
-	});
-}
-//#endregion
-export { cwd, fromFileSystemPath, getExtension, getHash, isFileSystemPath, isHttp, isUnsafeUrl, parse, resolve, safePointerToPath, stripHash, toFileSystemPath };