fumadocs-openapi 10.10.1 → 10.10.2

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

@@ -0,0 +1,239 @@
+import { getHash, resolve, stripHash } from "./util/url.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/bundle.js
+/**
+* Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
+* only has *internal* references, not any *external* references.
+* This method mutates the JSON schema object, adding new references and re-mapping existing ones.
+*
+* @param parser
+* @param options
+*/
+function bundle(parser, options) {
+	const rootScopeBase = parser.$refs._root$Ref.dynamicIdScope ? getSchemaBasePath(parser.$refs._root$Ref.path, parser.schema) : parser.$refs._root$Ref.path;
+	const inventory = [];
+	crawl(parser, "schema", parser.$refs._root$Ref.path + "#", rootScopeBase, parser.$refs._root$Ref.dynamicIdScope, "#", 0, inventory, parser.$refs, options);
+	remap(inventory, options, parser.schema && typeof parser.schema === "object" && "$id" in parser.schema ? parser.schema.$id : void 0);
+	if ((options.bundle || {}).optimizeInternalRefs !== false) fixRefsThroughRefs(inventory, parser.schema);
+}
+/**
+* Recursively crawls the given value, and inventories all JSON references.
+*
+* @param parent - The object containing the value to crawl. If the value is not an object or array, it will be ignored.
+* @param key - The property key of `parent` to be crawled
+* @param path - The full path of the property being crawled, possibly with a JSON Pointer in the hash
+* @param pathFromRoot - The path of the property being crawled, from the schema root
+* @param indirections
+* @param inventory - An array of already-inventoried $ref pointers
+* @param $refs
+* @param options
+*/
+function crawl(parent, key, path, scopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options) {
+	const obj = key === null ? parent : parent[key];
+	const bundleOptions = options.bundle || {};
+	const isExcludedPath = bundleOptions.excludedPathMatcher || (() => false);
+	if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
+		const currentScopeBase = scopeBase;
+		if ($Ref.isAllowed$Ref(obj)) inventory$Ref(parent, key, path, currentScopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options);
+		else {
+			const keys = Object.keys(obj).sort((a, b) => {
+				if (a === "definitions" || a === "$defs") return -1;
+				else if (b === "definitions" || b === "$defs") return 1;
+				else return a.length - b.length;
+			});
+			for (const key of keys) {
+				const keyPath = Pointer.join(path, key);
+				const keyPathFromRoot = Pointer.join(pathFromRoot, key);
+				const value = obj[key];
+				const childScopeBase = dynamicIdScope && value && typeof value === "object" && !ArrayBuffer.isView(value) ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
+				if ($Ref.isAllowed$Ref(value)) inventory$Ref(obj, key, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, indirections, inventory, $refs, options);
+				else crawl(obj, key, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, indirections, inventory, $refs, options);
+				if (value && typeof value === "object" && !Array.isArray(value)) {
+					if ("$ref" in value) bundleOptions?.onBundle?.(value["$ref"], obj[key], obj, key);
+				}
+			}
+		}
+	}
+}
+/**
+* Inventories the given JSON Reference (i.e. records detailed information about it so we can
+* optimize all $refs in the schema), and then crawls the resolved value.
+*
+* @param $refParent - The object that contains a JSON Reference as one of its keys
+* @param $refKey - The key in `$refParent` that is a JSON Reference
+* @param path - The full path of the JSON Reference at `$refKey`, possibly with a JSON Pointer in the hash
+* @param indirections - unknown
+* @param pathFromRoot - The path of the JSON Reference at `$refKey`, from the schema root
+* @param inventory - An array of already-inventoried $ref pointers
+* @param $refs
+* @param options
+*/
+function inventory$Ref($refParent, $refKey, path, scopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options) {
+	const $ref = $refKey === null ? $refParent : $refParent[$refKey];
+	const $refPath = resolve(dynamicIdScope ? scopeBase : path, $ref.$ref);
+	const pointer = $refs._resolve($refPath, pathFromRoot, options);
+	if (pointer === null) return;
+	const depth = Pointer.parse(pathFromRoot).length;
+	const file = stripHash(pointer.path);
+	const hash = getHash(pointer.path);
+	const external = file !== $refs._root$Ref.path && !$refs._aliases[file];
+	const extended = $Ref.isExtended$Ref($ref);
+	indirections += pointer.indirections;
+	const existingEntry = findInInventory(inventory, $refParent, $refKey);
+	if (existingEntry) if (depth < existingEntry.depth || indirections < existingEntry.indirections) removeFromInventory(inventory, existingEntry);
+	else return;
+	inventory.push({
+		$ref,
+		parent: $refParent,
+		key: $refKey,
+		pathFromRoot,
+		depth,
+		file,
+		hash,
+		value: pointer.value,
+		circular: pointer.circular,
+		extended,
+		external,
+		indirections
+	});
+	if (!existingEntry || external) crawl(pointer.value, null, pointer.path, pointer.$ref.path, pointer.$ref.dynamicIdScope, pathFromRoot, indirections + 1, inventory, $refs, options);
+}
+/**
+* Re-maps every $ref pointer, so that they're all relative to the root of the JSON Schema.
+* Each referenced value is dereferenced EXACTLY ONCE.  All subsequent references to the same
+* value are re-mapped to point to the first reference.
+*
+* @example: {
+*    first: { $ref: somefile.json#/some/part },
+*    second: { $ref: somefile.json#/another/part },
+*    third: { $ref: somefile.json },
+*    fourth: { $ref: somefile.json#/some/part/sub/part }
+*  }
+*
+* In this example, there are four references to the same file, but since the third reference points
+* to the ENTIRE file, that's the only one we need to dereference.  The other three can just be
+* remapped to point inside the third one.
+*
+* On the other hand, if the third reference DIDN'T exist, then the first and second would both need
+* to be dereferenced, since they point to different parts of the file. The fourth reference does NOT
+* need to be dereferenced, because it can be remapped to point inside the first one.
+*
+* @param inventory
+*/
+function remap(inventory, options, rootId) {
+	inventory.sort((a, b) => {
+		if (a.file !== b.file) return a.file < b.file ? -1 : 1;
+		else if (a.hash !== b.hash) return a.hash < b.hash ? -1 : 1;
+		else if (a.circular !== b.circular) return a.circular ? -1 : 1;
+		else if (a.extended !== b.extended) return a.extended ? 1 : -1;
+		else if (a.indirections !== b.indirections) return a.indirections - b.indirections;
+		else if (a.depth !== b.depth) return a.depth - b.depth;
+		else {
+			const aDefinitionsIndex = Math.max(a.pathFromRoot.lastIndexOf("/definitions"), a.pathFromRoot.lastIndexOf("/$defs"));
+			const bDefinitionsIndex = Math.max(b.pathFromRoot.lastIndexOf("/definitions"), b.pathFromRoot.lastIndexOf("/$defs"));
+			if (aDefinitionsIndex !== bDefinitionsIndex) return bDefinitionsIndex - aDefinitionsIndex;
+			else return a.pathFromRoot.length - b.pathFromRoot.length;
+		}
+	});
+	let file, hash, pathFromRoot;
+	for (const entry of inventory) {
+		const bundleOpts = options.bundle || {};
+		if (!entry.external) {
+			if (bundleOpts.optimizeInternalRefs !== false) entry.$ref.$ref = entry.hash;
+		} else if (entry.file === file && entry.hash === hash) if (rootId && isInsideIdScope(inventory, entry)) entry.$ref.$ref = rootId + pathFromRoot;
+		else entry.$ref.$ref = pathFromRoot;
+		else if (entry.file === file && entry.hash.indexOf(hash + "/") === 0) {
+			const subPath = Pointer.join(pathFromRoot, Pointer.parse(entry.hash.replace(hash, "#")));
+			if (rootId && isInsideIdScope(inventory, entry)) entry.$ref.$ref = rootId + subPath;
+			else entry.$ref.$ref = subPath;
+		} else {
+			file = entry.file;
+			hash = entry.hash;
+			pathFromRoot = entry.pathFromRoot;
+			entry.$ref = entry.parent[entry.key] = $Ref.dereference(entry.$ref, entry.value, options);
+			if (entry.circular) entry.$ref.$ref = entry.pathFromRoot;
+		}
+	}
+}
+/**
+* TODO
+*/
+function findInInventory(inventory, $refParent, $refKey) {
+	for (const existingEntry of inventory) if (existingEntry && existingEntry.parent === $refParent && existingEntry.key === $refKey) return existingEntry;
+}
+function removeFromInventory(inventory, entry) {
+	const index = inventory.indexOf(entry);
+	inventory.splice(index, 1);
+}
+/**
+* After remapping, some $ref paths may traverse through other $ref nodes.
+* JSON pointer resolution does not follow $ref indirection, so these paths are invalid.
+* This function detects and fixes such paths by following any intermediate $refs
+* to compute a valid direct path.
+*/
+function fixRefsThroughRefs(inventory, schema) {
+	for (const entry of inventory) {
+		if (!entry.$ref || typeof entry.$ref !== "object" || !("$ref" in entry.$ref)) continue;
+		const refValue = entry.$ref.$ref;
+		if (typeof refValue !== "string" || !refValue.startsWith("#/")) continue;
+		const fixedPath = resolvePathThroughRefs(schema, refValue);
+		if (fixedPath !== refValue) entry.$ref.$ref = fixedPath;
+	}
+}
+/**
+* Walks a JSON pointer path through the schema. If any intermediate value
+* is a $ref, follows it and adjusts the path accordingly.
+* Returns the corrected path that doesn't traverse through any $ref.
+*/
+function resolvePathThroughRefs(schema, refPath) {
+	if (!refPath.startsWith("#/")) return refPath;
+	const segments = refPath.slice(2).split("/");
+	let current = schema;
+	const resolvedSegments = [];
+	for (const seg of segments) {
+		if (current === null || current === void 0 || typeof current !== "object") return refPath;
+		if ("$ref" in current && typeof current.$ref === "string" && current.$ref.startsWith("#/")) {
+			const targetSegments = current.$ref.slice(2).split("/");
+			resolvedSegments.length = 0;
+			resolvedSegments.push(...targetSegments);
+			current = walkPath(schema, current.$ref);
+			if (current === null || current === void 0 || typeof current !== "object") return refPath;
+		}
+		const decoded = seg.replace(/~1/g, "/").replace(/~0/g, "~");
+		current = current[Array.isArray(current) ? parseInt(decoded) : decoded];
+		resolvedSegments.push(seg);
+	}
+	return "#/" + resolvedSegments.join("/");
+}
+/**
+* Walks a JSON pointer path through a schema object, returning the value at that path.
+*/
+function walkPath(schema, path) {
+	if (!path.startsWith("#/")) return;
+	const segments = path.slice(2).split("/");
+	let current = schema;
+	for (const seg of segments) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		const decoded = seg.replace(/~1/g, "/").replace(/~0/g, "~");
+		current = current[Array.isArray(current) ? parseInt(decoded) : decoded];
+	}
+	return current;
+}
+/**
+* Checks whether the given inventory entry is located inside a sub-schema that has its own $id.
+* If so, root-relative JSON Pointer $refs placed at this location would be resolved against
+* the $id base URI rather than the document root, making them invalid.
+*/
+function isInsideIdScope(inventory, entry) {
+	for (const other of inventory) {
+		if (other.pathFromRoot === "#" || other.pathFromRoot === "#/") continue;
+		if (entry.pathFromRoot.startsWith(other.pathFromRoot + "/")) {
+			if (other.value && typeof other.value === "object" && "$id" in other.value) return true;
+		}
+	}
+	return false;
+}
+//#endregion
+export { bundle 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/dereference.js

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

@@ -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 };