fumadocs-openapi 10.10.3 → 11.0.0

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/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.5_@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.5_@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.5_@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.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/normalize-args.js

@@ -1,41 +0,0 @@
-import { getNewOptions } from "./options.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/normalize-args.js
-/**
-* Normalizes the given arguments, accounting for optional args.
-*/
-function normalizeArgs(_args) {
-	let path;
-	let schema;
-	let options;
-	let callback;
-	const args = Array.prototype.slice.call(_args);
-	if (typeof args[args.length - 1] === "function") callback = args.pop();
-	if (typeof args[0] === "string") {
-		path = args[0];
-		if (typeof args[2] === "object") {
-			schema = args[1];
-			options = args[2];
-		} else {
-			schema = void 0;
-			options = args[1];
-		}
-	} else {
-		path = "";
-		schema = args[0];
-		options = args[1];
-	}
-	try {
-		options = getNewOptions(options);
-	} catch (e) {
-		console.error(`JSON Schema Ref Parser: Error normalizing options: ${e}`);
-	}
-	if (!options.mutateInputSchema && typeof schema === "object") schema = JSON.parse(JSON.stringify(schema));
-	return {
-		path,
-		schema,
-		options,
-		callback
-	};
-}
-//#endregion
-export { normalizeArgs 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/options.js

@@ -1,124 +0,0 @@
-import json_default from "./parsers/json.js";
-import yaml_default from "./parsers/yaml.js";
-import text_default from "./parsers/text.js";
-import binary_default from "./parsers/binary.js";
-import file_default from "./resolvers/file.js";
-import http_default from "./resolvers/http.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/options.js
-const getJsonSchemaRefParserDefaultOptions = () => {
-	return {
-		/**
-		* Determines how different types of files will be parsed.
-		*
-		* You can add additional parsers of your own, replace an existing one with
-		* your own implementation, or disable any parser by setting it to false.
-		*/
-		parse: {
-			json: { ...json_default },
-			yaml: { ...yaml_default },
-			text: { ...text_default },
-			binary: { ...binary_default }
-		},
-		/**
-		* Determines how JSON References will be resolved.
-		*
-		* You can add additional resolvers of your own, replace an existing one with
-		* your own implementation, or disable any resolver by setting it to false.
-		*/
-		resolve: {
-			file: { ...file_default },
-			http: { ...http_default },
-			/**
-			* Determines whether external $ref pointers will be resolved.
-			* If this option is disabled, then none of above resolvers will be called.
-			* Instead, external $ref pointers will simply be ignored.
-			*
-			* @type {boolean}
-			*/
-			external: true
-		},
-		/**
-		* 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: false,
-		/**
-		* Determines the types of JSON references that are allowed.
-		*/
-		bundle: { 
-		/**
-		* 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.
-		*
-		* @type {function}
-		*/
-excludedPathMatcher: () => false },
-		/**
-		* Determines the types of JSON references that are allowed.
-		*/
-		dereference: {
-			/**
-			* Dereference circular (recursive) JSON references?
-			* If false, then a {@link ReferenceError} will be thrown if a circular reference is found.
-			* If "ignore", then circular references will not be dereferenced.
-			*
-			* @type {boolean|string}
-			*/
-			circular: true,
-			/**
-			* 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.
-			*
-			* @type {function}
-			*/
-			excludedPathMatcher: () => false,
-			referenceResolution: "relative",
-			mergeKeys: true
-		},
-		mutateInputSchema: true
-	};
-};
-const getNewOptions = (options) => {
-	const newOptions = getJsonSchemaRefParserDefaultOptions();
-	if (options) merge(newOptions, options);
-	return newOptions;
-};
-/**
-* Merges the properties of the source object into the target object.
-*
-* @param target - The object that we're populating
-* @param source - The options that are being merged
-* @returns
-*/
-function merge(target, source) {
-	if (isMergeable(source)) {
-		const keys = Object.keys(source).filter((key) => ![
-			"__proto__",
-			"constructor",
-			"prototype"
-		].includes(key));
-		for (let i = 0; i < keys.length; i++) {
-			const key = keys[i];
-			const sourceSetting = source[key];
-			const targetSetting = target[key];
-			if (isMergeable(sourceSetting)) target[key] = merge(targetSetting || {}, sourceSetting);
-			else if (sourceSetting !== void 0) target[key] = sourceSetting;
-		}
-	}
-	return target;
-}
-/**
-* Determines whether the given value can be merged,
-* or if it is a scalar value that should just override the target value.
-*
-* @param val
-* @returns
-*/
-function isMergeable(val) {
-	return val && typeof val === "object" && !Array.isArray(val) && !(val instanceof RegExp) && !(val instanceof Date);
-}
-//#endregion
-export { getJsonSchemaRefParserDefaultOptions, getNewOptions };

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

@@ -1,109 +0,0 @@
-import { getExtension } from "./util/url.js";
-import { ParserError, ResolverError, UnmatchedParserError, UnmatchedResolverError, isHandledError } from "./util/errors.js";
-import { registerSchemaResources, usesDynamicIdScope } from "./util/schema-resources.js";
-import { all, filter, run, sort } from "./util/plugins.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/parse.js
-/**
-* Reads and parses the specified file path or URL.
-*/
-async function parse(target, $refs, options) {
-	let path = typeof target === "string" ? target : target.url;
-	const baseUrl = typeof target === "string" ? void 0 : target.baseUrl;
-	let reference = typeof target === "string" ? void 0 : target.reference;
-	const hashIndex = path.indexOf("#");
-	let hash = "";
-	if (hashIndex >= 0) {
-		hash = path.substring(hashIndex);
-		path = path.substring(0, hashIndex);
-	}
-	if (reference) {
-		const referenceHashIndex = reference.indexOf("#");
-		if (referenceHashIndex >= 0) reference = reference.substring(0, referenceHashIndex);
-	}
-	const $ref = $refs._add(path);
-	const file = {
-		url: path,
-		hash,
-		extension: getExtension(path),
-		...reference !== void 0 ? { reference } : {},
-		...baseUrl !== void 0 ? { baseUrl } : {}
-	};
-	try {
-		const resolver = await readFile(file, options, $refs);
-		$ref.pathType = resolver.plugin.name;
-		file.data = resolver.result;
-		const parser = await parseFile(file, options, $refs);
-		$ref.value = parser.result;
-		$ref.dynamicIdScope = usesDynamicIdScope($ref.value);
-		registerSchemaResources($refs, $ref.path, $ref.value, $ref.pathType, $ref.dynamicIdScope);
-		return parser.result;
-	} catch (err) {
-		if (isHandledError(err)) $ref.value = err;
-		throw err;
-	}
-}
-/**
-* Reads the given file, using the configured resolver plugins
-*
-* @param file           - An object containing information about the referenced file
-* @param file.url       - The full URL of the referenced file
-* @param file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
-* @param options
-* @param $refs
-* @returns
-* The promise resolves with the raw file contents and the resolver that was used.
-*/
-async function readFile(file, options, $refs) {
-	let resolvers = all(options.resolve);
-	resolvers = filter(resolvers, "canRead", file, void 0, $refs);
-	sort(resolvers);
-	try {
-		return await run(resolvers, "read", file, $refs);
-	} catch (err) {
-		if (!err && options.continueOnError) throw new UnmatchedResolverError(file.url);
-		else if (!err || !("error" in err)) throw new SyntaxError(`Unable to resolve $ref pointer "${file.url}"`, { cause: err });
-		else if (err.error instanceof ResolverError) throw err.error;
-		else throw new ResolverError(err, file.url);
-	}
-}
-/**
-* Parses the given file's contents, using the configured parser plugins.
-*
-* @param file           - An object containing information about the referenced file
-* @param file.url       - The full URL of the referenced file
-* @param file.extension - The lowercased file extension (e.g. ".txt", ".html", etc.)
-* @param file.data      - The file contents. This will be whatever data type was returned by the resolver
-* @param options
-* @param $refs
-*
-* @returns
-* The promise resolves with the parsed file contents and the parser that was used.
-*/
-async function parseFile(file, options, $refs) {
-	const allParsers = all(options.parse);
-	const filteredParsers = filter(allParsers, "canParse", file);
-	const parsers = filteredParsers.length > 0 ? filteredParsers : allParsers;
-	sort(parsers);
-	try {
-		const parser = await run(parsers, "parse", file, $refs);
-		if (!parser.plugin.allowEmpty && isEmpty(parser.result)) throw new SyntaxError(`Error parsing "${file.url}" as ${parser.plugin.name}. \nParsed value is empty`);
-		else return parser;
-	} catch (err) {
-		if (!err && options.continueOnError) throw new UnmatchedParserError(file.url);
-		else if (err && err.message && err.message.startsWith("Error parsing")) throw err;
-		else if (!err || !("error" in err)) throw new SyntaxError(`Unable to parse ${file.url}`, { cause: err });
-		else if (err.error instanceof ParserError) throw err.error;
-		else throw new ParserError(err.error.message, file.url);
-	}
-}
-/**
-* Determines whether the parsed value is "empty".
-*
-* @param value
-* @returns
-*/
-function isEmpty(value) {
-	return value === void 0 || typeof value === "object" && Object.keys(value).length === 0 || typeof value === "string" && value.trim().length === 0 || Buffer.isBuffer(value) && value.length === 0;
-}
-//#endregion
-export { parse 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/parsers/binary.js

@@ -1,30 +0,0 @@
-//#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/parsers/binary.js
-const BINARY_REGEXP = /\.(jpeg|jpg|gif|png|bmp|ico)$/i;
-var binary_default = {
-	/**
-	* The order that this parser will run, in relation to other parsers.
-	*/
-	order: 400,
-	/**
-	* Whether to allow "empty" files (zero bytes).
-	*/
-	allowEmpty: true,
-	/**
-	* Determines whether this parser can parse a given file reference.
-	* Parsers that return true will be tried, in order, until one successfully parses the file.
-	* Parsers that return false will be skipped, UNLESS all parsers returned false, in which case
-	* every parser will be tried.
-	*/
-	canParse(file) {
-		return Buffer.isBuffer(file.data) && BINARY_REGEXP.test(file.url);
-	},
-	/**
-	* Parses the given data as a Buffer (byte array).
-	*/
-	parse(file) {
-		if (Buffer.isBuffer(file.data)) return file.data;
-		else return Buffer.from(file.data);
-	}
-};
-//#endregion
-export { binary_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/parsers/json.js

@@ -1,46 +0,0 @@
-import { ParserError } 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/parsers/json.js
-var json_default = {
-	/**
-	* The order that this parser will run, in relation to other parsers.
-	*/
-	order: 100,
-	/**
-	* Whether to allow "empty" files. This includes zero-byte files, as well as empty JSON objects.
-	*/
-	allowEmpty: true,
-	/**
-	* Determines whether this parser can parse a given file reference.
-	* Parsers that match will be tried, in order, until one successfully parses the file.
-	* Parsers that don't match will be skipped, UNLESS none of the parsers match, in which case
-	* every parser will be tried.
-	*/
-	canParse: ".json",
-	/**
-	* Allow JSON files with byte order marks (BOM)
-	*/
-	allowBOM: true,
-	/**
-	* Parses the given file as JSON
-	*/
-	async parse(file) {
-		let data = file.data;
-		if (Buffer.isBuffer(data)) data = data.toString();
-		if (typeof data === "string") if (data.trim().length === 0) return;
-		else try {
-			return JSON.parse(data);
-		} catch (e) {
-			if (this.allowBOM) try {
-				const firstCurlyBrace = data.indexOf("{");
-				data = data.slice(firstCurlyBrace);
-				return JSON.parse(data);
-			} catch (e) {
-				throw new ParserError(e.message, file.url);
-			}
-			throw new ParserError(e.message, file.url);
-		}
-		else return data;
-	}
-};
-//#endregion
-export { json_default as default };