fumadocs-openapi 10.10.1 → 10.10.3

package/css/generated/shared.css

@@ -4,9 +4,10 @@
 @source inline("---");
 @source inline("--fd-docs-row-1");
 @source inline("--min-height");
+@source inline("--radix-popover-content-available-width");
 @source inline("-mode");
 @source inline("-ms-2");
-@source inline("-mx-2");
+@source inline("-mx-3");
 @source inline("-translate-x-1/2");
 @source inline("-translate-y-1/2");
 @source inline("@4xl:flex-row");
@@ -29,6 +30,7 @@
 @source inline("@scalar/api-client-react");
 @source inline("@see");
 @source inline("@typescript-eslint/no-explicit-any");
+@source inline("[&_svg]:size-3.5");
 @source inline("a");
 @source inline("absolute");
 @source inline("access_token");
@@ -111,6 +113,7 @@
 @source inline("bg-fd-secondary");
 @source inline("binary");
 @source inline("blob");
+@source inline("block");
 @source inline("blue");
 @source inline("body");
 @source inline("bodyMediaType");
@@ -173,6 +176,7 @@
 @source inline("codegens");
 @source inline("col-span-full");
 @source inline("collapsible");
+@source inline("collisionPadding");
 @source inline("color");
 @source inline("com");
 @source inline("compile");
@@ -282,6 +286,7 @@
 @source inline("encodeInternalRef");
 @source inline("encodeRequestData");
 @source inline("encoded");
+@source inline("end");
 @source inline("end-2");
 @source inline("endpoint");
 @source inline("enforce");
@@ -308,6 +313,7 @@
 @source inline("false");
 @source inline("fast-content-type-parse");
 @source inline("fd-page-tree-item-name");
+@source inline("fd-scroll-container");
 @source inline("fetch");
 @source inline("fetchOptions");
 @source inline("fetcher");
@@ -408,7 +414,6 @@
 @source inline("group-data-[state=open]:rotate-180");
 @source inline("group-focus-visible/accordion:text-fd-primary");
 @source inline("group/accordion");
-@source inline("group/property");
 @source inline("groupId");
 @source inline("h-10");
 @source inline("h-9");
@@ -425,7 +430,6 @@
 @source inline("headerParameters");
 @source inline("headers");
 @source inline("headingLevel");
-@source inline("height");
 @source inline("hidden");
 @source inline("hiddenProperties");
 @source inline("highlighted");
@@ -451,6 +455,7 @@
 @source inline("import");
 @source inline("imports");
 @source inline("in");
+@source inline("in-popover");
 @source inline("include");
 @source inline("index");
 @source inline("indexItemMatch");
@@ -461,7 +466,6 @@
 @source inline("initial");
 @source inline("inline-flex");
 @source inline("input");
-@source inline("inputContainer");
 @source inline("inputs");
 @source inline("inset-0");
 @source inline("instanceof");
@@ -527,10 +531,12 @@
 @source inline("max");
 @source inline("max-age");
 @source inline("max-h-[460px]");
+@source inline("max-w-(--radix-popover-content-available-width)");
 @source inline("max-w-[600px]");
 @source inline("max-w-full");
 @source inline("max-w-lg");
 @source inline("may");
+@source inline("mb-0!");
 @source inline("mb-1");
 @source inline("mb-2");
 @source inline("mb-auto");
@@ -550,16 +556,16 @@
 @source inline("migrated");
 @source inline("mime");
 @source inline("min");
-@source inline("min-h-(--min-height,0)");
+@source inline("min-h-(--min-height,200px)");
 @source inline("min-w-0");
 @source inline("missing");
 @source inline("modify");
 @source inline("mounted");
-@source inline("ms-2");
 @source inline("ms-auto");
 @source inline("mt-0!");
 @source inline("mt-10");
 @source inline("mt-2");
+@source inline("mt-2!");
 @source inline("mt-3");
 @source inline("multipart/form-data");
 @source inline("multiple");
@@ -606,6 +612,7 @@
 @source inline("onKeyDown");
 @source inline("onOpenAutoFocus");
 @source inline("onOpenChange");
+@source inline("onScrollEnd");
 @source inline("onSubmit");
 @source inline("onValueChange");
 @source inline("once");
@@ -653,6 +660,8 @@
 @source inline("parameters");
 @source inline("params");
 @source inline("parent");
+@source inline("parentItem");
+@source inline("parentPathIndex");
 @source inline("parseSecurities");
 @source inline("parsed");
 @source inline("parsedState");
@@ -673,7 +682,6 @@
 @source inline("pb-2");
 @source inline("pe-2");
 @source inline("pe-3");
-@source inline("peer");
 @source inline("peer-disabled:cursor-not-allowed");
 @source inline("peer-disabled:opacity-70");
 @source inline("perhaps");
@@ -696,7 +704,6 @@
 @source inline("pre");
 @source inline("prefix");
 @source inline("prev");
-@source inline("prevProperties");
 @source inline("prevent");
 @source inline("preventScroll");
 @source inline("primary");
@@ -713,6 +720,7 @@
 @source inline("proxyForwardCookie");
 @source inline("proxyUrl");
 @source inline("ps-2");
+@source inline("ps-3");
 @source inline("ps-4.5");
 @source inline("ps-6");
 @source inline("pt-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/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 };