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

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,41 @@
+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.d.ts

@@ -0,0 +1,166 @@
+import { HTTPResolverOptions, JSONSchema, JSONSchemaObject, Plugin, ResolverOptions } from "./types/index.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.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 };

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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,30 @@
+//#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

@@ -0,0 +1,46 @@
+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 };