fumadocs-openapi 10.10.1 → 10.10.3

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/resolve-external.js

@@ -0,0 +1,100 @@
+import { cwd, getHash, resolve, safePointerToPath, stripHash } from "./util/url.js";
+import { isHandledError } from "./util/errors.js";
+import { getSchemaBasePath } from "./util/schema-resources.js";
+import Pointer from "./pointer.js";
+import $Ref from "./ref.js";
+import parse from "./parse.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/resolve-external.js
+/**
+* Crawls the JSON schema, finds all external JSON references, and resolves their values.
+* This method does not mutate the JSON schema. The resolved values are added to {@link $RefParser#$refs}.
+*
+* NOTE: We only care about EXTERNAL references here. INTERNAL references are only relevant when dereferencing.
+*
+* @returns
+* The promise resolves once all JSON references in the schema have been resolved,
+* including nested references that are contained in externally-referenced files.
+*/
+function resolveExternal(parser, options) {
+	if (!options.resolve?.external) return Promise.resolve();
+	try {
+		const rootScopeBase = parser.$refs._root$Ref.dynamicIdScope ? getSchemaBasePath(parser.$refs._root$Ref.path, parser.schema) : parser.$refs._root$Ref.path;
+		const promises = crawl(parser.schema, parser.$refs._root$Ref.path + "#", rootScopeBase, parser.$refs._root$Ref.dynamicIdScope, parser.$refs, options);
+		return Promise.all(promises);
+	} catch (e) {
+		return Promise.reject(e);
+	}
+}
+/**
+* Recursively crawls the given value, and resolves any external JSON references.
+*
+* @param obj - The value to crawl. If it's not an object or array, it will be ignored.
+* @param path - The full path of `obj`, possibly with a JSON Pointer in the hash
+* @param {boolean} external - Whether `obj` was found in an external document.
+* @param $refs
+* @param options
+* @param seen - Internal.
+*
+* @returns
+* Returns an array of promises. There will be one promise for each JSON reference in `obj`.
+* If `obj` does not contain any JSON references, then the array will be empty.
+* If any of the JSON references point to files that contain additional JSON references,
+* then the corresponding promise will internally reference an array of promises.
+*/
+function crawl(obj, path, scopeBase, dynamicIdScope, $refs, options, seen, external) {
+	seen ||= /* @__PURE__ */ new Set();
+	let promises = [];
+	if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !seen.has(obj)) {
+		seen.add(obj);
+		const currentScopeBase = scopeBase;
+		if ($Ref.isExternal$Ref(obj)) promises.push(resolve$Ref(obj, path, currentScopeBase, dynamicIdScope, $refs, options));
+		const keys = Object.keys(obj);
+		for (const key of keys) {
+			const keyPath = Pointer.join(path, key);
+			const value = obj[key];
+			const childScopeBase = dynamicIdScope && value && typeof value === "object" && !ArrayBuffer.isView(value) ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
+			promises = promises.concat(crawl(value, keyPath, childScopeBase, dynamicIdScope, $refs, options, seen, external));
+		}
+	}
+	return promises;
+}
+/**
+* Resolves the given JSON Reference, and then crawls the resulting value.
+*
+* @param $ref - The JSON Reference to resolve
+* @param path - The full path of `$ref`, possibly with a JSON Pointer in the hash
+* @param $refs
+* @param options
+*
+* @returns
+* The promise resolves once all JSON references in the object have been resolved,
+* including nested references that are contained in externally-referenced files.
+*/
+async function resolve$Ref($ref, path, scopeBase, dynamicIdScope, $refs, options) {
+	const resolutionBase = options.dereference?.externalReferenceResolution === "root" ? cwd() : dynamicIdScope ? scopeBase : path;
+	const resolvedPath = resolve(resolutionBase, $ref.$ref);
+	const withoutHash = stripHash(resolvedPath);
+	const ref = $refs._get$Ref(withoutHash);
+	if (ref) return Promise.resolve(ref.value);
+	try {
+		const reference = $ref.$ref;
+		const parseTarget = {
+			url: resolvedPath,
+			baseUrl: resolutionBase
+		};
+		if (typeof reference === "string") parseTarget.reference = reference;
+		const result = await parse(parseTarget, $refs, options);
+		const parsedRef = $refs._get$Ref(withoutHash);
+		const promises = crawl(result, withoutHash + "#", withoutHash, parsedRef?.dynamicIdScope ?? false, $refs, options, /* @__PURE__ */ new Set(), true);
+		return Promise.all(promises);
+	} catch (err) {
+		if (!options?.continueOnError || !isHandledError(err)) throw err;
+		if ($refs._$refs[withoutHash]) {
+			err.source = decodeURI(stripHash(path));
+			err.path = safePointerToPath(getHash(path));
+		}
+		return [];
+	}
+}
+//#endregion
+export { resolveExternal as default };

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

@@ -0,0 +1,41 @@
+import { isFileSystemPath, toFileSystemPath } from "../util/url.js";
+import { ResolverError } from "../util/errors.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/resolvers/file.js
+var file_default = {
+	/**
+	* The order that this resolver will run, in relation to other resolvers.
+	*/
+	order: 100,
+	/**
+	* 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 isFileSystemPath(file.url);
+	},
+	/**
+	* Reads the given file and returns its raw contents as a Buffer.
+	*/
+	async read(file) {
+		let path;
+		const fs = await import("fs");
+		try {
+			path = toFileSystemPath(file.url);
+		} catch (err) {
+			const e = err;
+			e.message = `Malformed URI: ${file.url}: ${e.message}`;
+			throw new ResolverError(e, file.url);
+		}
+		if (path.endsWith("/") || path.endsWith("\\")) path = path.slice(0, -1);
+		try {
+			return await fs.promises.readFile(path);
+		} catch (err) {
+			const e = err;
+			e.message = `Error opening file ${path}: ${e.message}`;
+			throw new ResolverError(e, path);
+		}
+	}
+};
+//#endregion
+export { file_default as default };

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

@@ -0,0 +1,112 @@
+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.5_@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 {
+		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 if (!("location" in res.headers) || !res.headers.location) {
+			const error = /* @__PURE__ */ new Error(`HTTP ${res.status} redirect with no location header`);
+			error.status = res.status;
+			throw error;
+		} else return download(resolve(u.href, res.headers.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",
+		signal: controller ? controller.signal : null
+	});
+	if (timeoutId) clearTimeout(timeoutId);
+	return response;
+}
+//#endregion
+export { http_default as default };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/convert-path-to-posix.js

@@ -0,0 +1,8 @@
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/convert-path-to-posix.js
+const win32Sep = "\\";
+function convertPathToPosix(filePath) {
+	if (filePath.startsWith("\\\\?\\")) return filePath;
+	return filePath.split(win32Sep).join("/");
+}
+//#endregion
+export { convertPathToPosix as default };

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

@@ -0,0 +1,146 @@
+import { getHash, stripHash, toFileSystemPath } from "./url.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/errors.js
+const nonJsonTypes = [
+	"function",
+	"symbol",
+	"undefined"
+];
+const protectedProps = [
+	"constructor",
+	"prototype",
+	"__proto__"
+];
+const objectPrototype = Object.getPrototypeOf({});
+/**
+* Custom JSON serializer for Error objects.
+* Returns all built-in error properties, as well as extended properties.
+*/
+function toJSON() {
+	const pojo = {};
+	const error = this;
+	for (const key of getDeepKeys(error)) if (typeof key === "string") {
+		const value = error[key];
+		const type = typeof value;
+		if (!nonJsonTypes.includes(type)) pojo[key] = value;
+	}
+	return pojo;
+}
+/**
+* Returns own, inherited, enumerable, non-enumerable, string, and symbol keys of `obj`.
+* Does NOT return members of the base Object prototype, or the specified omitted keys.
+*/
+function getDeepKeys(obj, omit = []) {
+	let keys = [];
+	while (obj && obj !== objectPrototype) {
+		keys = keys.concat(Object.getOwnPropertyNames(obj), Object.getOwnPropertySymbols(obj));
+		obj = Object.getPrototypeOf(obj);
+	}
+	const uniqueKeys = new Set(keys);
+	for (const key of omit.concat(protectedProps)) uniqueKeys.delete(key);
+	return uniqueKeys;
+}
+var JSONParserError = class extends Error {
+	name;
+	message;
+	source;
+	path;
+	code;
+	constructor(message, source) {
+		super();
+		this.code = "EUNKNOWN";
+		this.name = "JSONParserError";
+		this.message = message;
+		this.source = source;
+		this.path = null;
+	}
+	toJSON = toJSON.bind(this);
+	get footprint() {
+		return `${this.path}+${this.source}+${this.code}+${this.message}`;
+	}
+};
+var JSONParserErrorGroup = class JSONParserErrorGroup extends Error {
+	files;
+	constructor(parser) {
+		super();
+		this.files = parser;
+		this.name = "JSONParserErrorGroup";
+		this.message = `${this.errors.length} error${this.errors.length > 1 ? "s" : ""} occurred while reading '${toFileSystemPath(parser.$refs._root$Ref.path)}'`;
+	}
+	toJSON = toJSON.bind(this);
+	static getParserErrors(parser) {
+		const errors = [];
+		for (const $ref of Object.values(parser.$refs._$refs)) if ($ref.errors) errors.push(...$ref.errors);
+		return errors;
+	}
+	get errors() {
+		return JSONParserErrorGroup.getParserErrors(this.files);
+	}
+};
+var ParserError = class extends JSONParserError {
+	code = "EPARSER";
+	name = "ParserError";
+	constructor(message, source) {
+		super(`Error parsing ${source}: ${message}`, source);
+	}
+};
+var UnmatchedParserError = class extends JSONParserError {
+	code = "EUNMATCHEDPARSER";
+	name = "UnmatchedParserError";
+	constructor(source) {
+		super(`Could not find parser for "${source}"`, source);
+	}
+};
+var ResolverError = class extends JSONParserError {
+	code = "ERESOLVER";
+	name = "ResolverError";
+	ioErrorCode;
+	constructor(ex, source) {
+		super(ex.message || `Error reading file "${source}"`, source);
+		if ("code" in ex) this.ioErrorCode = String(ex.code);
+	}
+};
+var UnmatchedResolverError = class extends JSONParserError {
+	code = "EUNMATCHEDRESOLVER";
+	name = "UnmatchedResolverError";
+	constructor(source) {
+		super(`Could not find resolver for "${source}"`, source);
+	}
+};
+var MissingPointerError = class extends JSONParserError {
+	code = "EMISSINGPOINTER";
+	name = "MissingPointerError";
+	targetToken;
+	targetRef;
+	targetFound;
+	parentPath;
+	constructor(token, path, targetRef, targetFound, parentPath) {
+		super(`Missing $ref pointer "${getHash(path)}". Token "${token}" does not exist.`, stripHash(path));
+		this.targetToken = token;
+		this.targetRef = targetRef;
+		this.targetFound = targetFound;
+		this.parentPath = parentPath;
+	}
+};
+var TimeoutError = class extends JSONParserError {
+	code = "ETIMEOUT";
+	name = "TimeoutError";
+	constructor(timeout) {
+		super(`Dereferencing timeout reached: ${timeout}ms`);
+	}
+};
+var InvalidPointerError = class extends JSONParserError {
+	code = "EUNMATCHEDRESOLVER";
+	name = "InvalidPointerError";
+	constructor(pointer, path) {
+		super(`Invalid $ref pointer "${pointer}". Pointers must begin with "#/"`, stripHash(path));
+	}
+};
+function isHandledError(err) {
+	return err instanceof JSONParserError || err instanceof JSONParserErrorGroup;
+}
+function normalizeError(err) {
+	if (err.path === null) err.path = [];
+	return err;
+}
+//#endregion
+export { InvalidPointerError, JSONParserError, JSONParserErrorGroup, MissingPointerError, ParserError, ResolverError, TimeoutError, UnmatchedParserError, UnmatchedResolverError, isHandledError, normalizeError };

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

@@ -0,0 +1,5 @@
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@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.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/maybe.js

@@ -0,0 +1,18 @@
+import next_default from "./next.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/maybe.js
+function maybe(cb, promise) {
+	if (cb) {
+		promise.then(function(result) {
+			next_default(function() {
+				cb(null, result);
+			});
+		}, function(err) {
+			next_default(function() {
+				cb(err);
+			});
+		});
+		return;
+	} else return promise;
+}
+//#endregion
+export { maybe as default };

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

@@ -0,0 +1,11 @@
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/next.js
+function makeNext() {
+	if (typeof process === "object" && typeof process.nextTick === "function") return process.nextTick;
+	else if (typeof setImmediate === "function") return setImmediate;
+	else return function next(f) {
+		setTimeout(f, 0);
+	};
+}
+var next_default = makeNext();
+//#endregion
+export { next_default as default };

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

@@ -0,0 +1,99 @@
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/plugins.js
+/**
+* Returns the given plugins as an array, rather than an object map.
+* All other methods in this module expect an array of plugins rather than an object map.
+*
+* @returns
+*/
+function all(plugins) {
+	return Object.keys(plugins || {}).filter((key) => {
+		return typeof plugins[key] === "object";
+	}).map((key) => {
+		plugins[key].name = key;
+		return plugins[key];
+	});
+}
+/**
+* Filters the given plugins, returning only the ones return `true` for the given method.
+*/
+function filter(plugins, method, file, callback, $refs) {
+	return plugins.filter((plugin) => {
+		return !!getResult(plugin, method, file, callback, $refs);
+	});
+}
+/**
+* Sorts the given plugins, in place, by their `order` property.
+*/
+function sort(plugins) {
+	for (const plugin of plugins) plugin.order = plugin.order || Number.MAX_SAFE_INTEGER;
+	return plugins.sort((a, b) => {
+		return a.order - b.order;
+	});
+}
+/**
+* Runs the specified method of the given plugins, in order, until one of them returns a successful result.
+* Each method can return a synchronous value, a Promise, or call an error-first callback.
+* If the promise resolves successfully, or the callback is called without an error, then the result
+* is immediately returned and no further plugins are called.
+* If the promise rejects, or the callback is called with an error, then the next plugin is called.
+* If ALL plugins fail, then the last error is thrown.
+*/
+async function run(plugins, method, file, $refs) {
+	let plugin;
+	let lastError;
+	let index = 0;
+	return new Promise((resolve, reject) => {
+		runNextPlugin();
+		function runNextPlugin() {
+			plugin = plugins[index++];
+			if (!plugin) return reject(lastError);
+			try {
+				const result = getResult(plugin, method, file, callback, $refs);
+				if (result && typeof result.then === "function") result.then(onSuccess, onError);
+				else if (result !== void 0) onSuccess(result);
+				else if (index === plugins.length) throw new Error("No promise has been returned or callback has been called.");
+			} catch (e) {
+				onError(e);
+			}
+		}
+		function callback(err, result) {
+			if (err) onError(err);
+			else onSuccess(result);
+		}
+		function onSuccess(result) {
+			resolve({
+				plugin,
+				result
+			});
+		}
+		function onError(error) {
+			lastError = {
+				plugin,
+				error
+			};
+			runNextPlugin();
+		}
+	});
+}
+/**
+* Returns the value of the given property.
+* If the property is a function, then the result of the function is returned.
+* If the value is a RegExp, then it will be tested against the file URL.
+* If the value is an array, then it will be compared against the file extension.
+*/
+function getResult(obj, prop, file, callback, $refs) {
+	const value = obj[prop];
+	if (typeof value === "function") return value.apply(obj, [
+		file,
+		callback,
+		$refs
+	]);
+	if (!callback) {
+		if (value instanceof RegExp) return value.test(file.url);
+		else if (typeof value === "string") return value === file.extension;
+		else if (Array.isArray(value)) return value.indexOf(file.extension) !== -1;
+	}
+	return value;
+}
+//#endregion
+export { all, filter, run, sort };

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

@@ -0,0 +1,30 @@
+import { resolve } from "./url.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/util/schema-resources.js
+function getSchemaBasePath(basePath, value) {
+	const schemaId = getSchemaId(value);
+	return schemaId ? resolve(basePath, schemaId) : basePath;
+}
+function usesDynamicIdScope(value) {
+	if (!value || typeof value !== "object" || ArrayBuffer.isView(value)) return false;
+	const schema = value.$schema;
+	if (typeof schema === "string" && (schema.includes("draft/2019-09/") || schema.includes("draft/2020-12/") || schema.includes("oas/3.1/"))) return true;
+	const openapi = value.openapi;
+	return typeof openapi === "string" && /^3\.1(?:\.|$)/.test(openapi);
+}
+function registerSchemaResources($refs, basePath, value, pathType, dynamicIdScope = false) {
+	if (!dynamicIdScope) return;
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (node, scopeBase) => {
+		if (!node || typeof node !== "object" || ArrayBuffer.isView(node) || seen.has(node)) return;
+		seen.add(node);
+		const nextScopeBase = getSchemaBasePath(scopeBase, node);
+		if (nextScopeBase !== scopeBase) $refs._addAlias(nextScopeBase, node, pathType, dynamicIdScope);
+		for (const key of Object.keys(node)) visit(node[key], nextScopeBase);
+	};
+	visit(value, basePath);
+}
+function getSchemaId(value) {
+	if (value && typeof value === "object" && "$id" in value && typeof value.$id === "string" && value.$id.length > 0) return value.$id;
+}
+//#endregion
+export { getSchemaBasePath, registerSchemaResources, usesDynamicIdScope };