@fumadocs/api-docs 0.0.1

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/types/index.d.ts

@@ -0,0 +1,133 @@
+import { ParserOptions } from "../options.js";
+import { $Refs } from "../refs.js";
+import { JSONSchema4, JSONSchema4Object, JSONSchema6, JSONSchema6Object, JSONSchema7, JSONSchema7Object } from "json-schema";
+
+//#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/types/index.d.ts
+type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
+type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
+type SchemaCallback<S extends object = JSONSchema> = (err: Error | null, schema?: S | object | null) => any;
+type $RefsCallback<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> = (err: Error | null, $refs?: $Refs<S, O>) => any;
+/**
+ * See https://apidevtools.com/json-schema-ref-parser/docs/options.html
+ */
+interface HTTPResolverOptions<S extends object = JSONSchema> extends Partial<ResolverOptions<S>> {
+  /**
+   * You can specify any HTTP headers that should be sent when downloading files. For example, some servers may require you to set the `Accept` or `Referrer` header.
+   */
+  headers?: RequestInit["headers"] | null;
+  /**
+   * The amount of time (in milliseconds) to wait for a response from the server when downloading files. The default is 5 seconds.
+   */
+  timeout?: number;
+  /**
+   * The maximum number of HTTP redirects to follow per file. The default is 5. To disable automatic following of redirects, set this to zero.
+   */
+  redirects?: number;
+  /**
+   * Set this to `true` if you're downloading files from a CORS-enabled server that requires authentication
+   */
+  withCredentials?: boolean;
+  /**
+   * Set this to `false` if you want to allow unsafe URLs (e.g., `127.0.0.1`, localhost, and other internal URLs).
+   */
+  safeUrlResolver?: boolean;
+}
+/**
+ * JSON Schema `$Ref` Parser comes with built-in resolvers for HTTP and HTTPS URLs, as well as local filesystem paths (when running in Node.js). You can add your own custom resolvers to support additional protocols, or even replace any of the built-in resolvers with your own custom implementation.
+ *
+ * See https://apidevtools.com/json-schema-ref-parser/docs/plugins/resolvers.html
+ */
+interface ResolverOptions<S extends object = JSONSchema> {
+  name?: string;
+  /**
+   * All resolvers have an order property, even the built-in resolvers. If you don't specify an order property, then your resolver will run last. Specifying `order: 1`, like we did in this example, will make your resolver run first. Or you can squeeze your resolver in-between some of the built-in resolvers. For example, `order: 101` would make it run after the file resolver, but before the HTTP resolver. You can see the order of all the built-in resolvers by looking at their source code.
+   *
+   * The order property and canRead property are related to each other. For each file that JSON Schema $Ref Parser needs to resolve, it first determines which resolvers can read that file by checking their canRead property. If only one resolver matches a file, then only that one resolver is called, regardless of its order. If multiple resolvers match a file, then those resolvers are tried in order until one of them successfully reads the file. Once a resolver successfully reads the file, the rest of the resolvers are skipped.
+   */
+  order?: number;
+  /**
+   * The `canRead` property tells JSON Schema `$Ref` Parser what kind of files your resolver can read. In this example, we've simply specified a regular expression that matches "mogodb://" URLs, but we could have used a simple boolean, or even a function with custom logic to determine which files to resolve. Here are examples of each approach:
+   */
+  canRead: boolean | RegExp | string | string[] | ((file: FileInfo) => boolean);
+  /**
+   * This is where the real work of a resolver happens. The `read` method accepts the same file info object as the `canRead` function, but rather than returning a boolean value, the `read` method should return the contents of the file. The file contents should be returned in as raw a form as possible, such as a string or a byte array. Any further parsing or processing should be done by parsers.
+   *
+   * Unlike the `canRead` function, the `read` method can also be asynchronous. This might be important if your resolver needs to read data from a database or some other external source. You can return your asynchronous value using either an ES6 Promise or a Node.js-style error-first callback. Of course, if your resolver has the ability to return its data synchronously, then that's fine too. Here are examples of all three approaches:
+   */
+  read: string | object | ((file: FileInfo, callback?: (error: Error | null, data: string | null) => any) => string | Buffer | S | Promise<string | Buffer | S>);
+}
+interface Plugin {
+  name?: string;
+  /**
+   * Parsers run in a specific order, relative to other parsers. For example, a parser with `order: 5` will run before a parser with `order: 10`. If a parser is unable to successfully parse a file, then the next parser is tried, until one succeeds or they all fail.
+   *
+   * You can change the order in which parsers run, which is useful if you know that most of your referenced files will be a certain type, or if you add your own custom parser that you want to run first.
+   */
+  order?: number;
+  /**
+   * All of the built-in parsers allow empty files by default. The JSON and YAML parsers will parse empty files as `undefined`. The text parser will parse empty files as an empty string. The binary parser will parse empty files as an empty byte array.
+   *
+   * You can set `allowEmpty: false` on any parser, which will cause an error to be thrown if a file empty.
+   */
+  allowEmpty?: boolean;
+  /**
+   * Specifies whether a Byte Order Mark (BOM) is allowed or not. Only applies to JSON parsing
+   *
+   * @type {boolean} @default true
+   */
+  allowBOM?: boolean;
+  /**
+   * The encoding that the text is expected to be in.
+   */
+  encoding?: BufferEncoding;
+  /**
+   * Determines which parsers will be used for which files.
+   *
+   * A regular expression can be used to match files by their full path. A string (or array of strings) can be used to match files by their file extension. Or a function can be used to perform more complex matching logic. See the custom parser docs for details.
+   */
+  canParse?: boolean | RegExp | string | string[] | ((file: FileInfo) => boolean);
+  /**
+   * This is where the real work of a parser happens. The `parse` method accepts the same file info object as the `canParse` function, but rather than returning a boolean value, the `parse` method should return a JavaScript representation of the file contents.  For our CSV parser, that is a two-dimensional array of lines and values.  For your parser, it might be an object, a string, a custom class, or anything else.
+   *
+   * Unlike the `canParse` function, the `parse` method can also be asynchronous. This might be important if your parser needs to retrieve data from a database or if it relies on an external HTTP service to return the parsed value.  You can return your asynchronous value via a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) or a Node.js-style error-first callback.  Here are examples of both approaches:
+   */
+  parse: ((file: FileInfo, callback?: (error: Error | null, data: string | null) => any) => unknown | Promise<unknown>) | number | string;
+}
+/**
+ * JSON Schema `$Ref` Parser supports plug-ins, such as resolvers and parsers. These plug-ins can have methods such as `canRead()`, `read()`, `canParse()`, and `parse()`. All of these methods accept the same object as their parameter: an object containing information about the file being read or parsed.
+ *
+ * The file info object currently only consists of a few properties, but it may grow in the future if plug-ins end up needing more information.
+ *
+ * See https://apidevtools.com/json-schema-ref-parser/docs/plugins/file-info-object.html
+ */
+interface FileInfo {
+  /**
+   * The full URL of the file. This could be any type of URL, including "http://", "https://", "file://", "ftp://", "mongodb://", or even a local filesystem path (when running in Node.js).
+   */
+  url: string;
+  /**
+   * The unresolved `$ref` value exactly as it appeared in the parent schema, without the hash.
+   * This is useful for custom resolvers that need to preserve relative reference semantics instead
+   * of relying on the already-resolved `url`.
+   */
+  reference?: string;
+  /**
+   * The URL that `reference` was resolved against to produce `url`.
+   * This may include a JSON Pointer fragment when the reference originated from a nested location.
+   */
+  baseUrl?: string;
+  /**
+   * The hash (URL fragment) of the file URL, including the # symbol. If the URL doesn't have a hash, then this will be an empty string.
+   */
+  hash: string;
+  /**
+   * The lowercase file extension, such as ".json", ".yaml", ".txt", etc.
+   */
+  extension: string;
+  /**
+   * The raw file contents, in whatever form they were returned by the resolver that read the file.
+   */
+  data: string | Buffer;
+}
+//#endregion
+export { $RefsCallback, FileInfo, HTTPResolverOptions, JSONSchema, JSONSchemaObject, Plugin, ResolverOptions, SchemaCallback };

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.d.ts

@@ -0,0 +1,34 @@
+//#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.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.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 };