@fumadocs/api-docs 0.0.3 → 0.0.4

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/dereference.js

@@ -1,187 +0,0 @@
-import { cwd, resolve } from "./util/url.js";
-import { TimeoutError } from "./util/errors.js";
-import { getSchemaBasePath } from "./util/schema-resources.js";
-import Pointer from "./pointer.js";
-import $Ref from "./ref.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/dereference.js
-var dereference_default = dereference;
-/**
-* Crawls the JSON schema, finds all JSON references, and dereferences them.
-* This method mutates the JSON schema object, replacing JSON references with their resolved value.
-*
-* @param parser
-* @param options
-*/
-function dereference(parser, options) {
-	const start = Date.now();
-	const rootScopeBase = parser.$refs._root$Ref.dynamicIdScope ? getSchemaBasePath(parser.$refs._root$Ref.path, parser.schema) : parser.$refs._root$Ref.path;
-	const dereferenced = crawl(parser.schema, parser.$refs._root$Ref.path, rootScopeBase, parser.$refs._root$Ref.dynamicIdScope, "#", /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map(), parser.$refs, options, start, 0);
-	parser.$refs.circular = dereferenced.circular;
-	parser.schema = dereferenced.value;
-}
-/**
-* Recursively crawls the given value, and dereferences any 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 pathFromRoot - The path of `obj` from the schema root
-* @param parents - An array of the parent objects that have already been dereferenced
-* @param processedObjects - An array of all the objects that have already been processed
-* @param dereferencedCache - An map of all the dereferenced objects
-* @param $refs
-* @param options
-* @param startTime - The time when the dereferencing started
-* @param depth - The current recursion depth
-* @returns
-*/
-function crawl(obj, path, scopeBase, dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth) {
-	let dereferenced;
-	const result = {
-		value: obj,
-		circular: false
-	};
-	checkDereferenceTimeout(startTime, options);
-	const derefOptions = options.dereference || {};
-	const maxDepth = derefOptions.maxDepth ?? 500;
-	if (depth > maxDepth) throw new RangeError(`Maximum dereference depth (${maxDepth}) exceeded at ${pathFromRoot}. This likely indicates an extremely deep or recursive schema. You can increase this limit with the dereference.maxDepth option.`);
-	const isExcludedPath = derefOptions.excludedPathMatcher || (() => false);
-	if (derefOptions?.circular === "ignore" || !processedObjects.has(obj)) {
-		if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
-			parents.add(obj);
-			processedObjects.add(obj);
-			const currentScopeBase = scopeBase;
-			if ($Ref.isAllowed$Ref(obj, options)) {
-				dereferenced = dereference$Ref(obj, path, currentScopeBase, dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth);
-				result.circular = dereferenced.circular;
-				result.value = dereferenced.value;
-			} else for (const key of Object.keys(obj)) {
-				checkDereferenceTimeout(startTime, options);
-				const keyPath = Pointer.join(path, key);
-				const keyPathFromRoot = Pointer.join(pathFromRoot, key);
-				if (isExcludedPath(keyPathFromRoot)) continue;
-				const value = obj[key];
-				const childScopeBase = dynamicIdScope && value && typeof value === "object" && !ArrayBuffer.isView(value) ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
-				let circular;
-				if ($Ref.isAllowed$Ref(value, options)) {
-					dereferenced = dereference$Ref(value, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth);
-					circular = dereferenced.circular;
-					if (obj[key] !== dereferenced.value) {
-						const preserved = /* @__PURE__ */ new Map();
-						if (derefOptions?.preservedProperties) {
-							if (typeof obj[key] === "object" && !Array.isArray(obj[key])) derefOptions?.preservedProperties.forEach((prop) => {
-								if (prop in obj[key]) preserved.set(prop, obj[key][prop]);
-							});
-						}
-						let assignedValue = dereferenced.value;
-						if (derefOptions?.cloneReferences && !circular && assignedValue && typeof assignedValue === "object") assignedValue = structuredClone(assignedValue);
-						obj[key] = assignedValue;
-						if (derefOptions?.preservedProperties) {
-							if (preserved.size && typeof obj[key] === "object" && !Array.isArray(obj[key])) preserved.forEach((value, prop) => {
-								obj[key][prop] = value;
-							});
-						}
-						derefOptions?.onDereference?.(value.$ref, obj[key], obj, key);
-					}
-				} else if (!parents.has(value)) {
-					dereferenced = crawl(value, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth + 1);
-					circular = dereferenced.circular;
-					if (obj[key] !== dereferenced.value) obj[key] = dereferenced.value;
-				} else circular = foundCircularReference(keyPath, $refs, options);
-				result.circular = result.circular || circular;
-			}
-			parents.delete(obj);
-		}
-	}
-	return result;
-}
-/**
-* Dereferences 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 pathFromRoot - The path of `$ref` from the schema root
-* @param parents - An array of the parent objects that have already been dereferenced
-* @param processedObjects - An array of all the objects that have already been dereferenced
-* @param dereferencedCache - An map of all the dereferenced objects
-* @param $refs
-* @param options
-* @returns
-*/
-function dereference$Ref($ref, path, scopeBase, dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth) {
-	const $refPath = resolve($Ref.isExternal$Ref($ref) && options?.dereference?.externalReferenceResolution === "root" ? cwd() : dynamicIdScope ? scopeBase : path, $ref.$ref);
-	const cache = dereferencedCache.get($refPath);
-	if (cache) {
-		if (!cache.circular) {
-			const refKeys = Object.keys($ref);
-			if (refKeys.length > 1) {
-				const extraKeys = {};
-				for (const key of refKeys) if (key !== "$ref" && !(key in cache.value)) extraKeys[key] = $ref[key];
-				return {
-					circular: cache.circular,
-					value: Object.assign({}, cache.value, extraKeys)
-				};
-			}
-			return cache;
-		}
-		if (typeof cache.value === "object" && "$ref" in cache.value && "$ref" in $ref) {
-			if (cache.value.$ref === $ref.$ref) {
-				foundCircularReference(path, $refs, options);
-				return cache;
-			}
-		} else {
-			foundCircularReference(path, $refs, options);
-			return cache;
-		}
-	}
-	const pointer = $refs._resolve($refPath, path, options);
-	if (pointer === null) return {
-		circular: false,
-		value: null
-	};
-	const directCircular = pointer.circular;
-	let circular = directCircular || parents.has(pointer.value);
-	if (circular) foundCircularReference(path, $refs, options);
-	let dereferencedValue = $Ref.dereference($ref, pointer.value, options);
-	if (!circular) {
-		const dereferenced = crawl(dereferencedValue, pointer.path, pointer.$ref.path, pointer.$ref.dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth + 1);
-		circular = dereferenced.circular;
-		dereferencedValue = dereferenced.value;
-	}
-	if (circular && !directCircular && options.dereference?.circular === "ignore") dereferencedValue = $ref;
-	if (directCircular) dereferencedValue.$ref = pathFromRoot;
-	const dereferencedObject = {
-		circular,
-		value: dereferencedValue
-	};
-	if (Object.keys($ref).length === 1) dereferencedCache.set($refPath, dereferencedObject);
-	return dereferencedObject;
-}
-/**
-* Check if we've run past our allowed timeout and throw an error if we have.
-*
-* @param startTime - The time when the dereferencing started.
-* @param options
-*/
-function checkDereferenceTimeout(startTime, options) {
-	if (options && options.timeoutMs) {
-		if (Date.now() - startTime > options.timeoutMs) throw new TimeoutError(options.timeoutMs);
-	}
-}
-/**
-* Called when a circular reference is found.
-* It sets the {@link $Refs#circular} flag, executes the options.dereference.onCircular callback,
-* and throws an error if options.dereference.circular is false.
-*
-* @param keyPath - The JSON Reference path of the circular reference
-* @param $refs
-* @param options
-* @returns - always returns true, to indicate that a circular reference was found
-*/
-function foundCircularReference(keyPath, $refs, options) {
-	$refs.circular = true;
-	options?.dereference?.onCircular?.(keyPath);
-	if (!options.dereference.circular) throw /* @__PURE__ */ new ReferenceError(`Circular $ref pointer found at ${keyPath}`);
-	return true;
-}
-//#endregion
-export { dereference_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/index.d.ts

@@ -1,157 +0,0 @@
-import { $RefsCallback, FileInfo, HTTPResolverOptions, JSONSchema, Plugin, ResolverOptions, SchemaCallback } from "./types/index.js";
-import { ParserOptions } from "./options.js";
-import { JSONParserError, MissingPointerError, ParserError, ResolverError } from "./util/errors.js";
-import { $Refs } from "./refs.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/index.d.ts
-/**
- * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
- * and provides methods for traversing, manipulating, and dereferencing those references.
- *
- * @class
- */
-declare class $RefParser<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
-  /**
-   * The parsed (and possibly dereferenced) JSON schema object
-   *
-   * @type {object}
-   * @readonly
-   */
-  schema: S | null;
-  /**
-   * The resolved JSON references
-   *
-   * @type {$Refs}
-   * @readonly
-   */
-  $refs: $Refs<S, O>;
-  /**
-   * Parses the given JSON schema.
-   * This method does not resolve any JSON references.
-   * It just reads a single file in JSON or YAML format, and parse it as a JavaScript object.
-   *
-   * @param [path] - The file path or URL of the JSON schema
-   * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
-   * @param [options] - Options that determine how the schema is parsed
-   * @param [callback] - An error-first callback. The second parameter is the parsed JSON schema object.
-   * @returns - The returned promise resolves with the parsed JSON schema object.
-   */
-  parse(schema: S | string | unknown): Promise<S>;
-  parse(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
-  parse(schema: S | string | unknown, options: O): Promise<S>;
-  parse(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  parse(path: string, schema: S | string | unknown, options: O): Promise<S>;
-  parse(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  static parse<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
-  static parse<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
-  static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
-  static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
-  static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  /**
-   * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
-   *
-   * Resolves all JSON references (`$ref` pointers) in the given JSON Schema file. If it references any other files/URLs, then they will be downloaded and resolved as well. This method **does not** dereference anything. It simply gives you a `$Refs` object, which is a map of all the resolved references and their values.
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#resolveschema-options-callback
-   *
-   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
-   * @param options (optional)
-   * @param callback (optional) A callback that will receive a `$Refs` object
-   */
-  resolve(schema: S | string | unknown): Promise<$Refs<S, O>>;
-  resolve(schema: S | string | unknown, callback: $RefsCallback<S, O>): Promise<void>;
-  resolve(schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-  resolve(schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
-  resolve(path: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-  resolve(path: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
-  /**
-   * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
-   *
-   * Resolves all JSON references (`$ref` pointers) in the given JSON Schema file. If it references any other files/URLs, then they will be downloaded and resolved as well. This method **does not** dereference anything. It simply gives you a `$Refs` object, which is a map of all the resolved references and their values.
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#resolveschema-options-callback
-   *
-   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
-   * @param options (optional)
-   * @param callback (optional) A callback that will receive a `$Refs` object
-   */
-  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown): Promise<$Refs<S, O>>;
-  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, callback: $RefsCallback<S, O>): Promise<void>;
-  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
-  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
-  /**
-   * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
-   *
-   * This also eliminates the risk of circular references, so the schema can be safely serialized using `JSON.stringify()`.
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
-   *
-   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
-   * @param options (optional)
-   * @param callback (optional) A callback that will receive the bundled schema object
-   */
-  static bundle<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
-  static bundle<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
-  static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
-  static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
-  static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<S>;
-  /**
-   * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
-   *
-   * This also eliminates the risk of circular references, so the schema can be safely serialized using `JSON.stringify()`.
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
-   *
-   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
-   * @param options (optional)
-   * @param callback (optional) A callback that will receive the bundled schema object
-   */
-  bundle(schema: S | string | unknown): Promise<S>;
-  bundle(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
-  bundle(schema: S | string | unknown, options: O): Promise<S>;
-  bundle(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  bundle(path: string, schema: S | string | unknown, options: O): Promise<S>;
-  bundle(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  /**
-   * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
-   *
-   * The dereference method maintains object reference equality, meaning that all `$ref` pointers that point to the same object will be replaced with references to the same object. Again, this is great for programmatic usage, but it does introduce the risk of circular references, so be careful if you intend to serialize the schema using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
-   *
-   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
-   * @param options (optional)
-   * @param callback (optional) A callback that will receive the dereferenced schema object
-   */
-  static dereference<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
-  static dereference<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
-  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
-  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
-  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  /**
-   * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
-   *
-   * The dereference method maintains object reference equality, meaning that all `$ref` pointers that point to the same object will be replaced with references to the same object. Again, this is great for programmatic usage, but it does introduce the risk of circular references, so be careful if you intend to serialize the schema using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
-   *
-   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
-   *
-   * @param path
-   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
-   * @param options (optional)
-   * @param callback (optional) A callback that will receive the dereferenced schema object
-   */
-  dereference(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  dereference(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-  dereference(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
-  dereference(path: string, schema: S | string | unknown, options: O): Promise<S>;
-  dereference(schema: S | string | unknown, options: O): Promise<S>;
-  dereference(schema: S | string | unknown): Promise<S>;
-}
-declare const bundle: typeof $RefParser.bundle;
-//#endregion
-export { bundle };

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/index.js

@@ -1,136 +0,0 @@
-import { cwd, fromFileSystemPath, isFileSystemPath, parse as parse$1, resolve as resolve$1, stripHash } from "./util/url.js";
-import { JSONParserErrorGroup, isHandledError } from "./util/errors.js";
-import { registerSchemaResources, usesDynamicIdScope } from "./util/schema-resources.js";
-import $Refs from "./refs.js";
-import parse$2 from "./parse.js";
-import "./resolvers/file.js";
-import "./resolvers/http.js";
-import "./options.js";
-import normalizeArgs from "./normalize-args.js";
-import resolveExternal from "./resolve-external.js";
-import bundle$1 from "./bundle.js";
-import dereference_default from "./dereference.js";
-import maybe from "./util/maybe.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/index.js
-/**
-* This class parses a JSON schema, builds a map of its JSON references and their resolved values,
-* and provides methods for traversing, manipulating, and dereferencing those references.
-*
-* @class
-*/
-var $RefParser = class $RefParser {
-	/**
-	* The parsed (and possibly dereferenced) JSON schema object
-	*
-	* @type {object}
-	* @readonly
-	*/
-	schema = null;
-	/**
-	* The resolved JSON references
-	*
-	* @type {$Refs}
-	* @readonly
-	*/
-	$refs = new $Refs();
-	async parse() {
-		const args = normalizeArgs(arguments);
-		let promise;
-		if (!args.path && !args.schema) {
-			const err = /* @__PURE__ */ new Error(`Expected a file path, URL, or object. Got ${args.path || args.schema}`);
-			return maybe(args.callback, Promise.reject(err));
-		}
-		this.schema = null;
-		this.$refs = new $Refs();
-		let pathType = "http";
-		if (isFileSystemPath(args.path)) {
-			args.path = fromFileSystemPath(args.path);
-			pathType = "file";
-		} else if (!args.path && args.schema && "$id" in args.schema && args.schema.$id) {
-			const params = parse$1(args.schema.$id);
-			const port = params.port ?? (params.protocol === "https:" ? 443 : 80);
-			args.path = `${params.protocol}//${params.hostname}:${port}`;
-		}
-		args.path = resolve$1(cwd(), args.path);
-		if (args.schema && typeof args.schema === "object") {
-			const $ref = this.$refs._add(args.path);
-			$ref.value = args.schema;
-			$ref.pathType = pathType;
-			$ref.dynamicIdScope = usesDynamicIdScope($ref.value);
-			registerSchemaResources(this.$refs, $ref.path, $ref.value, $ref.pathType, $ref.dynamicIdScope);
-			promise = Promise.resolve(args.schema);
-		} else promise = parse$2(args.path, this.$refs, args.options);
-		try {
-			const result = await promise;
-			if (result !== null && typeof result === "object" && !Buffer.isBuffer(result)) {
-				this.schema = result;
-				return maybe(args.callback, Promise.resolve(this.schema));
-			} else if (args.options.continueOnError) {
-				this.schema = null;
-				return maybe(args.callback, Promise.resolve(this.schema));
-			} else throw new SyntaxError(`"${this.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
-		} catch (err) {
-			if (!args.options.continueOnError || !isHandledError(err)) return maybe(args.callback, Promise.reject(err));
-			if (this.$refs._$refs[stripHash(args.path)]) this.$refs._$refs[stripHash(args.path)].addError(err);
-			return maybe(args.callback, Promise.resolve(null));
-		}
-	}
-	static parse() {
-		const parser = new $RefParser();
-		return parser.parse.apply(parser, arguments);
-	}
-	async resolve() {
-		const args = normalizeArgs(arguments);
-		try {
-			await this.parse(args.path, args.schema, args.options);
-			await resolveExternal(this, args.options);
-			finalize(this);
-			return maybe(args.callback, Promise.resolve(this.$refs));
-		} catch (err) {
-			return maybe(args.callback, Promise.reject(err));
-		}
-	}
-	static resolve() {
-		const instance = new $RefParser();
-		return instance.resolve.apply(instance, arguments);
-	}
-	static bundle() {
-		const instance = new $RefParser();
-		return instance.bundle.apply(instance, arguments);
-	}
-	async bundle() {
-		const args = normalizeArgs(arguments);
-		try {
-			await this.resolve(args.path, args.schema, args.options);
-			bundle$1(this, args.options);
-			finalize(this);
-			return maybe(args.callback, Promise.resolve(this.schema));
-		} catch (err) {
-			return maybe(args.callback, Promise.reject(err));
-		}
-	}
-	static dereference() {
-		const instance = new $RefParser();
-		return instance.dereference.apply(instance, arguments);
-	}
-	async dereference() {
-		const args = normalizeArgs(arguments);
-		try {
-			await this.resolve(args.path, args.schema, args.options);
-			dereference_default(this, args.options);
-			finalize(this);
-			return maybe(args.callback, Promise.resolve(this.schema));
-		} catch (err) {
-			return maybe(args.callback, Promise.reject(err));
-		}
-	}
-};
-function finalize(parser) {
-	if (JSONParserErrorGroup.getParserErrors(parser).length > 0) throw new JSONParserErrorGroup(parser);
-}
-$RefParser.parse;
-$RefParser.resolve;
-const bundle = $RefParser.bundle;
-$RefParser.dereference;
-//#endregion
-export { bundle };

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

@@ -1,166 +0,0 @@
-import { HTTPResolverOptions, JSONSchema, JSONSchemaObject, Plugin, ResolverOptions } from "./types/index.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/options.d.ts
-type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
-interface BundleOptions {
-  /**
-   * A function, called for each path, which can return true to stop this path and all
-   * subpaths from being processed further. This is useful in schemas where some
-   * subpaths contain literal $ref keys that should not be changed.
-   */
-  excludedPathMatcher?(path: string): boolean;
-  /**
-   * Callback invoked during bundling.
-   *
-   * @argument {string} path - The path being processed (ie. the `$ref` string)
-   * @argument {JSONSchemaObject} value - The JSON-Schema that the `$ref` resolved to
-   * @argument {JSONSchemaObject} parent - The parent of the processed object
-   * @argument {string} parentPropName - The prop name of the parent object whose value was processed
-   */
-  onBundle?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
-  /**
-   * Whether to optimize internal `$ref` paths by following intermediate `$ref` chains and
-   * rewriting them to point directly to the final target. When `false`, intermediate `$ref`
-   * indirections are preserved as-is.
-   *
-   * Default: `true`
-   */
-  optimizeInternalRefs?: boolean;
-}
-interface DereferenceOptions {
-  /**
-   * Determines whether circular `$ref` pointers are handled.
-   *
-   * If set to `false`, then a `ReferenceError` will be thrown if the schema contains any circular references.
-   *
-   * If set to `"ignore"`, then circular references will simply be ignored. No error will be thrown, but the `$Refs.circular` property will still be set to `true`.
-   */
-  circular?: boolean | "ignore";
-  /**
-   * A function, called for each path, which can return true to stop this path and all
-   * subpaths from being dereferenced further. This is useful in schemas where some
-   * subpaths contain literal $ref keys that should not be dereferenced.
-   */
-  excludedPathMatcher?(path: string): boolean;
-  /**
-   * Callback invoked during circular reference detection.
-   *
-   * @argument {string} path - The path that is circular (ie. the `$ref` string)
-   */
-  onCircular?(path: string): void;
-  /**
-   * Callback invoked during dereferencing.
-   *
-   * @argument {string} path - The path being dereferenced (ie. the `$ref` string)
-   * @argument {JSONSchemaObject} value - The JSON-Schema that the `$ref` resolved to
-   * @argument {JSONSchemaObject} parent - The parent of the dereferenced object
-   * @argument {string} parentPropName - The prop name of the parent object whose value was dereferenced
-   */
-  onDereference?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
-  /**
-   * An array of properties to preserve when dereferencing a `$ref` schema. Useful if you want to
-   * enforce non-standard dereferencing behavior like present in the OpenAPI 3.1 specification where
-   * `description` and `summary` properties are preserved when alongside a `$ref` pointer.
-   *
-   * If none supplied then no properties will be preserved and the object will be fully replaced
-   * with the dereferenced `$ref`.
-   */
-  preservedProperties?: string[];
-  /**
-   * Whether a reference should resolve relative to its directory/path, or from the cwd
-   *
-   * Default: `relative`
-   */
-  externalReferenceResolution?: "relative" | "root";
-  /**
-   * Whether duplicate keys should be merged when dereferencing objects.
-   *
-   * Default: `true`
-   */
-  mergeKeys?: boolean;
-  /**
-   * The maximum recursion depth for dereferencing nested schemas.
-   * If the schema nesting exceeds this depth, a RangeError will be thrown
-   * with a descriptive message instead of crashing with a stack overflow.
-   *
-   * Default: 500
-   */
-  maxDepth?: number;
-  /**
-   * Whether to create independent clones of each `$ref` target value instead of
-   * reusing the same JS object reference. When `false` (the default), multiple
-   * `$ref` pointers that resolve to the same value will all share the same object
-   * in memory, so modifying one will affect all others. When `true`, each `$ref`
-   * replacement gets its own deep copy, preventing unintended side effects from
-   * post-dereference mutations.
-   *
-   * Note: circular references are never cloned — they always maintain reference
-   * equality to correctly represent the circular structure.
-   *
-   * Default: `false`
-   */
-  cloneReferences?: boolean;
-}
-/**
- * Options that determine how JSON schemas are parsed, resolved, and dereferenced.
- *
- * @param [options] - Overridden options
- * @class
- */
-interface $RefParserOptions<S extends object = JSONSchema> {
-  /**
-   * The `parse` options determine how different types of files will be parsed.
-   *
-   * JSON Schema `$Ref` Parser comes with built-in JSON, YAML, plain-text, and binary parsers, any of which you can configure or disable. You can also add your own custom parsers if you want.
-   */
-  parse: {
-    json?: Plugin | boolean;
-    yaml?: Plugin | boolean;
-    binary?: Plugin | boolean;
-    text?: Plugin | boolean;
-    [key: string]: Plugin | boolean | undefined;
-  };
-  /**
-   * The `resolve` options control how JSON Schema $Ref Parser will resolve file paths and URLs, and how those files will be read/downloaded.
-   *
-   * JSON Schema `$Ref` Parser comes with built-in support for HTTP and HTTPS, as well as support for local files (when running in Node.js). You can configure or disable either of these built-in resolvers. You can also add your own custom resolvers if you want.
-   */
-  resolve: {
-    /**
-     * Determines whether external $ref pointers will be resolved. If this option is disabled, then external `$ref` pointers will simply be ignored.
-     */
-    external?: boolean;
-    file?: Partial<ResolverOptions<S>> | boolean;
-    http?: HTTPResolverOptions<S> | boolean;
-  } & {
-    [key: string]: Partial<ResolverOptions<S>> | HTTPResolverOptions<S> | boolean | undefined;
-  };
-  /**
-   * By default, JSON Schema $Ref Parser throws the first error it encounters. Setting `continueOnError` to `true`
-   * causes it to keep processing as much as possible and then throw a single error that contains all errors
-   * that were encountered.
-   */
-  continueOnError: boolean;
-  /**
-   * The `bundle` options control how JSON Schema `$Ref` Parser will process `$ref` pointers within the JSON schema.
-   */
-  bundle: BundleOptions;
-  /**
-   * The `dereference` options control how JSON Schema `$Ref` Parser will dereference `$ref` pointers within the JSON schema.
-   */
-  dereference: DereferenceOptions;
-  /**
-   * Whether to clone the schema before dereferencing it.
-   * This is useful when you want to dereference the same schema multiple times, but you don't want to modify the original schema.
-   * Default: `true` due to mutating the input being the default behavior historically
-   */
-  mutateInputSchema?: boolean;
-  /**
-   * The maximum amount of time (in milliseconds) that JSON Schema $Ref Parser will spend dereferencing a single schema.
-   * It will throw a timeout error if the operation takes longer than this.
-   */
-  timeoutMs?: number;
-}
-type ParserOptions<S extends object = JSONSchema> = DeepPartial<$RefParserOptions<S>>;
-//#endregion
-export { ParserOptions };