fumadocs-openapi 10.10.1 → 10.10.3

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

@@ -0,0 +1,242 @@
+import { getHash, resolve, stripHash } from "./util/url.js";
+import { InvalidPointerError, JSONParserError, MissingPointerError, isHandledError } from "./util/errors.js";
+import { getSchemaBasePath } from "./util/schema-resources.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/pointer.js
+const nullSymbol = Symbol("null");
+const slashes = /\//g;
+const tildes = /~/g;
+const escapedSlash = /~1/g;
+const escapedTilde = /~0/g;
+/**
+* This class represents a single JSON pointer and its resolved value.
+*
+* @param $ref
+* @param path
+* @param [friendlyPath] - The original user-specified path (used for error messages)
+* @class
+*/
+var Pointer = class Pointer {
+	/**
+	* The {@link $Ref} object that contains this {@link Pointer} object.
+	*/
+	$ref;
+	/**
+	* The file path or URL, containing the JSON pointer in the hash.
+	* This path is relative to the path of the main JSON schema file.
+	*/
+	path;
+	/**
+	* The original path or URL, used for error messages.
+	*/
+	originalPath;
+	/**
+	* The current base URI used to resolve nested $ref pointers while walking this pointer.
+	*/
+	scopeBase;
+	/**
+	* The value of the JSON pointer.
+	* Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
+	*/
+	value;
+	/**
+	* Indicates whether the pointer references itself.
+	*/
+	circular;
+	/**
+	* The number of indirect references that were traversed to resolve the value.
+	* Resolving a single pointer may require resolving multiple $Refs.
+	*/
+	indirections;
+	constructor($ref, path, friendlyPath) {
+		this.$ref = $ref;
+		this.path = path;
+		this.originalPath = friendlyPath || path;
+		this.scopeBase = $ref.path || stripHash(path);
+		this.value = void 0;
+		this.circular = false;
+		this.indirections = 0;
+	}
+	/**
+	* Resolves the value of a nested property within the given object.
+	*
+	* @param obj - The object that will be crawled
+	* @param options
+	* @param pathFromRoot - the path of place that initiated resolving
+	*
+	* @returns
+	* Returns a JSON pointer whose {@link Pointer#value} is the resolved value.
+	* If resolving this value required resolving other JSON references, then
+	* the {@link Pointer#$ref} and {@link Pointer#path} will reflect the resolution path
+	* of the resolved value.
+	*/
+	resolve(obj, options, pathFromRoot) {
+		const tokens = Pointer.parse(this.path, this.originalPath);
+		const found = [];
+		this.value = unwrapOrThrow(obj);
+		if (this.$ref.dynamicIdScope && !isAliasedResource(this.$ref)) this.scopeBase = getSchemaBasePath(this.scopeBase, this.value);
+		for (let i = 0; i < tokens.length; i++) {
+			const wasCircular = this.circular;
+			const isExtendedRef = $Ref.isExtended$Ref(this.value);
+			if (resolveIf$Ref(this, options, pathFromRoot)) this.path = Pointer.join(this.path, tokens.slice(i));
+			else if (!wasCircular && this.circular && isExtendedRef) this.circular = false;
+			const token = tokens[i];
+			if (this.value[token] === void 0 || this.value[token] === null && i === tokens.length - 1) {
+				let didFindSubstringSlashMatch = false;
+				for (let j = tokens.length - 1; j > i; j--) {
+					const joinedToken = tokens.slice(i, j + 1).join("/");
+					if (this.value[joinedToken] !== void 0) {
+						this.value = this.value[joinedToken];
+						i = j;
+						didFindSubstringSlashMatch = true;
+						break;
+					}
+				}
+				if (didFindSubstringSlashMatch) continue;
+				if (token in this.value && this.value[token] === null) {
+					this.value = nullSymbol;
+					continue;
+				}
+				this.value = null;
+				const path = this.$ref.path || "";
+				const targetRef = this.path.replace(path, "");
+				const targetFound = Pointer.join("", found);
+				const parentPath = pathFromRoot?.replace(path, "");
+				throw new MissingPointerError(token, decodeURI(this.originalPath), targetRef, targetFound, parentPath);
+			} else this.value = this.value[token];
+			found.push(token);
+			if (this.$ref.dynamicIdScope) this.scopeBase = getSchemaBasePath(this.scopeBase, this.value);
+		}
+		const finalResolutionBase = this.$ref.dynamicIdScope ? this.scopeBase : this.path;
+		if (!this.value || this.value.$ref && resolve(finalResolutionBase, this.value.$ref) !== pathFromRoot) resolveIf$Ref(this, options, pathFromRoot);
+		return this;
+	}
+	/**
+	* Sets the value of a nested property within the given object.
+	*
+	* @param obj - The object that will be crawled
+	* @param value - the value to assign
+	* @param options
+	*
+	* @returns
+	* Returns the modified object, or an entirely new object if the entire object is overwritten.
+	*/
+	set(obj, value, options) {
+		const tokens = Pointer.parse(this.path);
+		let token;
+		if (tokens.length === 0) {
+			this.value = value;
+			return value;
+		}
+		this.value = unwrapOrThrow(obj);
+		if (this.$ref.dynamicIdScope && !isAliasedResource(this.$ref)) this.scopeBase = getSchemaBasePath(this.scopeBase, this.value);
+		for (let i = 0; i < tokens.length - 1; i++) {
+			resolveIf$Ref(this, options);
+			token = tokens[i];
+			if (this.value && this.value[token] !== void 0) this.value = this.value[token];
+			else this.value = setValue(this, token, {});
+			if (this.$ref.dynamicIdScope) this.scopeBase = getSchemaBasePath(this.scopeBase, this.value);
+		}
+		resolveIf$Ref(this, options);
+		token = tokens[tokens.length - 1];
+		setValue(this, token, value);
+		return obj;
+	}
+	/**
+	* Parses a JSON pointer (or a path containing a JSON pointer in the hash)
+	* and returns an array of the pointer's tokens.
+	* (e.g. "schema.json#/definitions/person/name" => ["definitions", "person", "name"])
+	*
+	* The pointer is parsed according to RFC 6901
+	* {@link https://tools.ietf.org/html/rfc6901#section-3}
+	*
+	* @param path
+	* @param [originalPath]
+	* @returns
+	*/
+	static parse(path, originalPath) {
+		const pointer = getHash(path).substring(1);
+		if (!pointer) return [];
+		const split = pointer.split("/");
+		for (let i = 0; i < split.length; i++) split[i] = split[i].replace(escapedSlash, "/").replace(escapedTilde, "~");
+		if (split[0] !== "") throw new InvalidPointerError(pointer, originalPath === void 0 ? path : originalPath);
+		return split.slice(1);
+	}
+	/**
+	* Creates a JSON pointer path, by joining one or more tokens to a base path.
+	*
+	* @param base - The base path (e.g. "schema.json#/definitions/person")
+	* @param tokens - The token(s) to append (e.g. ["name", "first"])
+	* @returns
+	*/
+	static join(base, tokens) {
+		if (base.indexOf("#") === -1) base += "#";
+		tokens = Array.isArray(tokens) ? tokens : [tokens];
+		for (let i = 0; i < tokens.length; i++) {
+			const token = tokens[i];
+			base += "/" + token.replace(tildes, "~0").replace(slashes, "~1");
+		}
+		return base;
+	}
+};
+/**
+* If the given pointer's {@link Pointer#value} is a JSON reference,
+* then the reference is resolved and {@link Pointer#value} is replaced with the resolved value.
+* In addition, {@link Pointer#path} and {@link Pointer#$ref} are updated to reflect the
+* resolution path of the new value.
+*
+* @param pointer
+* @param options
+* @param [pathFromRoot] - the path of place that initiated resolving
+* @returns - Returns `true` if the resolution path changed
+*/
+function resolveIf$Ref(pointer, options, pathFromRoot) {
+	if ($Ref.isAllowed$Ref(pointer.value, options)) {
+		const $refPath = resolve(pointer.$ref.dynamicIdScope ? pointer.scopeBase : pointer.path, pointer.value.$ref);
+		if ($refPath === pointer.path && !isRootPath(pathFromRoot)) pointer.circular = true;
+		else {
+			const resolved = pointer.$ref.$refs._resolve($refPath, pointer.path, options);
+			if (resolved === null) return false;
+			pointer.indirections += resolved.indirections + 1;
+			if ($Ref.isExtended$Ref(pointer.value)) {
+				pointer.value = $Ref.dereference(pointer.value, resolved.value, options);
+				return false;
+			} else {
+				pointer.$ref = resolved.$ref;
+				pointer.path = resolved.path;
+				pointer.value = resolved.value;
+				pointer.scopeBase = pointer.$ref.path;
+			}
+			return true;
+		}
+	}
+}
+/**
+* Sets the specified token value of the {@link Pointer#value}.
+*
+* The token is evaluated according to RFC 6901.
+* {@link https://tools.ietf.org/html/rfc6901#section-4}
+*
+* @param pointer - The JSON Pointer whose value will be modified
+* @param token - A JSON Pointer token that indicates how to modify `obj`
+* @param value - The value to assign
+* @returns - Returns the assigned value
+*/
+function setValue(pointer, token, value) {
+	if (pointer.value && typeof pointer.value === "object") if (token === "-" && Array.isArray(pointer.value)) pointer.value.push(value);
+	else pointer.value[token] = value;
+	else throw new JSONParserError(`Error assigning $ref pointer "${pointer.path}". \nCannot set "${token}" of a non-object.`);
+	return value;
+}
+function unwrapOrThrow(value) {
+	if (isHandledError(value)) throw value;
+	return value;
+}
+function isRootPath(pathFromRoot) {
+	return typeof pathFromRoot == "string" && Pointer.parse(pathFromRoot).length == 0;
+}
+function isAliasedResource($ref) {
+	return Boolean($ref.path && $ref.path in $ref.$refs._aliases);
+}
+//#endregion
+export { Pointer as default, nullSymbol };

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

@@ -0,0 +1,247 @@
+import { getHash, safePointerToPath, stripHash } from "./util/url.js";
+import { InvalidPointerError, isHandledError, normalizeError } from "./util/errors.js";
+import Pointer, { nullSymbol } from "./pointer.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/ref.js
+/**
+* This class represents a single JSON reference and its resolved value.
+*
+* @class
+*/
+var $Ref = class $Ref {
+	/**
+	* The file path or URL of the referenced file.
+	* This path is relative to the path of the main JSON schema file.
+	*
+	* This path does NOT contain document fragments (JSON pointers). It always references an ENTIRE file.
+	* Use methods such as {@link $Ref#get}, {@link $Ref#resolve}, and {@link $Ref#exists} to get
+	* specific JSON pointers within the file.
+	*
+	* @type {string}
+	*/
+	path;
+	/**
+	* The resolved value of the JSON reference.
+	* Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
+	*
+	* @type {?*}
+	*/
+	value;
+	/**
+	* The {@link $Refs} object that contains this {@link $Ref} object.
+	*
+	* @type {$Refs}
+	*/
+	$refs;
+	/**
+	* Indicates the type of {@link $Ref#path} (e.g. "file", "http", etc.)
+	*/
+	pathType;
+	/**
+	* Whether this document/resource should use JSON Schema 2019-09+ nested $id scope semantics.
+	*/
+	dynamicIdScope = false;
+	/**
+	* List of all errors. Undefined if no errors.
+	*/
+	errors = [];
+	constructor($refs) {
+		this.$refs = $refs;
+	}
+	/**
+	* Pushes an error to errors array.
+	*
+	* @param err - The error to be pushed
+	* @returns
+	*/
+	addError(err) {
+		if (this.errors === void 0) this.errors = [];
+		const existingErrors = this.errors.map(({ footprint }) => footprint);
+		if ("errors" in err && Array.isArray(err.errors)) this.errors.push(...err.errors.map(normalizeError).filter(({ footprint }) => !existingErrors.includes(footprint)));
+		else if (!("footprint" in err) || !existingErrors.includes(err.footprint)) this.errors.push(normalizeError(err));
+	}
+	/**
+	* Determines whether the given JSON reference exists within this {@link $Ref#value}.
+	*
+	* @param path - The full path being resolved, optionally with a JSON pointer in the hash
+	* @param options
+	* @returns
+	*/
+	exists(path, options) {
+		try {
+			this.resolve(path, options);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Resolves the given JSON reference within this {@link $Ref#value} and returns the resolved value.
+	*
+	* @param path - The full path being resolved, optionally with a JSON pointer in the hash
+	* @param options
+	* @returns - Returns the resolved value
+	*/
+	get(path, options) {
+		return this.resolve(path, options)?.value;
+	}
+	/**
+	* Resolves the given JSON reference within this {@link $Ref#value}.
+	*
+	* @param path - The full path being resolved, optionally with a JSON pointer in the hash
+	* @param options
+	* @param friendlyPath - The original user-specified path (used for error messages)
+	* @param pathFromRoot - The path of `obj` from the schema root
+	* @returns
+	*/
+	resolve(path, options, friendlyPath, pathFromRoot) {
+		const pointer = new Pointer(this, path, friendlyPath);
+		try {
+			const resolved = pointer.resolve(this.value, options, pathFromRoot);
+			if (resolved.value === nullSymbol) resolved.value = null;
+			return resolved;
+		} catch (err) {
+			if (!options || !options.continueOnError || !isHandledError(err)) throw err;
+			if (err.path === null) err.path = safePointerToPath(getHash(pathFromRoot));
+			if (err instanceof InvalidPointerError) err.source = decodeURI(stripHash(pathFromRoot));
+			this.addError(err);
+			return null;
+		}
+	}
+	/**
+	* Sets the value of a nested property within this {@link $Ref#value}.
+	* If the property, or any of its parents don't exist, they will be created.
+	*
+	* @param path - The full path of the property to set, optionally with a JSON pointer in the hash
+	* @param value - The value to assign
+	*/
+	set(path, value) {
+		const pointer = new Pointer(this, path);
+		this.value = pointer.set(this.value, value);
+		if (this.value === nullSymbol) this.value = null;
+	}
+	/**
+	* Determines whether the given value is a JSON reference.
+	*
+	* @param value - The value to inspect
+	* @returns
+	*/
+	static is$Ref(value) {
+		return Boolean(value) && typeof value === "object" && value !== null && "$ref" in value && typeof value.$ref === "string" && value.$ref.length > 0;
+	}
+	/**
+	* Determines whether the given value is an external JSON reference.
+	*
+	* @param value - The value to inspect
+	* @returns
+	*/
+	static isExternal$Ref(value) {
+		return $Ref.is$Ref(value) && value.$ref[0] !== "#";
+	}
+	/**
+	* Determines whether the given value is a JSON reference, and whether it is allowed by the options.
+	* For example, if it references an external file, then options.resolve.external must be true.
+	*
+	* @param value - The value to inspect
+	* @param options
+	* @returns
+	*/
+	static isAllowed$Ref(value, options) {
+		if (this.is$Ref(value)) {
+			if (value.$ref.substring(0, 2) === "#/" || value.$ref === "#") return true;
+			else if (value.$ref[0] !== "#" && (!options || options.resolve?.external)) return true;
+		}
+	}
+	/**
+	* Determines whether the given value is a JSON reference that "extends" its resolved value.
+	* That is, it has extra properties (in addition to "$ref"), so rather than simply pointing to
+	* an existing value, this $ref actually creates a NEW value that is a shallow copy of the resolved
+	* value, plus the extra properties.
+	*
+	* @example: {
+	person: {
+	properties: {
+	firstName: { type: string }
+	lastName: { type: string }
+	}
+	}
+	employee: {
+	properties: {
+	$ref: #/person/properties
+	salary: { type: number }
+	}
+	}
+	}
+	*  In this example, "employee" is an extended $ref, since it extends "person" with an additional
+	*  property (salary).  The result is a NEW value that looks like this:
+	*
+	*  {
+	*    properties: {
+	*      firstName: { type: string }
+	*      lastName: { type: string }
+	*      salary: { type: number }
+	*    }
+	*  }
+	*
+	* @param value - The value to inspect
+	* @returns
+	*/
+	static isExtended$Ref(value) {
+		return $Ref.is$Ref(value) && Object.keys(value).length > 1;
+	}
+	/**
+	* Returns the resolved value of a JSON Reference.
+	* If necessary, the resolved value is merged with the JSON Reference to create a new object
+	*
+	* @example: {
+	person: {
+	properties: {
+	firstName: { type: string }
+	lastName: { type: string }
+	}
+	}
+	employee: {
+	properties: {
+	$ref: #/person/properties
+	salary: { type: number }
+	}
+	}
+	} When "person" and "employee" are merged, you end up with the following object:
+	*
+	*  {
+	*    properties: {
+	*      firstName: { type: string }
+	*      lastName: { type: string }
+	*      salary: { type: number }
+	*    }
+	*  }
+	*
+	* @param $ref - The JSON reference object (the one with the "$ref" property)
+	* @param resolvedValue - The resolved value, which can be any type
+	* @param options - The options
+	* @returns - Returns the dereferenced value
+	*/
+	static dereference($ref, resolvedValue, options) {
+		if (resolvedValue && typeof resolvedValue === "object" && $Ref.isExtended$Ref($ref)) {
+			const merged = {};
+			for (const key of Object.keys($ref)) if (key !== "$ref") merged[key] = $ref[key];
+			const mergeKeys = options?.dereference?.mergeKeys ?? true;
+			for (const _key of Object.keys(resolvedValue)) {
+				const key = _key;
+				if (!(key in merged)) merged[key] = resolvedValue[key];
+				else if (mergeKeys && typeof merged[key] === "object" && merged[key] !== null && typeof resolvedValue[key] === "object" && resolvedValue[key] !== null) merged[key] = deepMerge(resolvedValue[key], merged[key]);
+			}
+			return merged;
+		} else return resolvedValue;
+	}
+};
+function deepMerge(target, source) {
+	if (typeof target !== "object" || target === null) return source;
+	if (typeof source !== "object" || source === null) return source;
+	const output = Array.isArray(target) ? [...target] : { ...target };
+	for (const key of Object.keys(source)) if (Array.isArray(source[key])) output[key] = [...source[key]];
+	else if (typeof source[key] === "object" && source[key] !== null) output[key] = deepMerge(target[key], source[key]);
+	else output[key] = source[key];
+	return output;
+}
+//#endregion
+export { $Ref 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/refs.js

@@ -0,0 +1,210 @@
+import convertPathToPosix from "./util/convert-path-to-posix.js";
+import { resolve, stripHash, toFileSystemPath } from "./util/url.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/refs.js
+/**
+* When you call the resolve method, the value that gets passed to the callback function (or Promise) is a $Refs object. This same object is accessible via the parser.$refs property of $RefParser objects.
+*
+* This object is a map of JSON References and their resolved values. It also has several convenient helper methods that make it easy for you to navigate and manipulate the JSON References.
+*
+* See https://apidevtools.com/json-schema-ref-parser/docs/refs.html
+*/
+var $Refs = class {
+	/**
+	* This property is true if the schema contains any circular references. You may want to check this property before serializing the dereferenced schema as JSON, since JSON.stringify() does not support circular references by default.
+	*
+	* See https://apidevtools.com/json-schema-ref-parser/docs/refs.html#circular
+	*/
+	circular;
+	/**
+	* Returns the paths/URLs of all the files in your schema (including the main schema file).
+	*
+	* See https://apidevtools.com/json-schema-ref-parser/docs/refs.html#pathstypes
+	*
+	* @param types (optional) Optionally only return certain types of paths ("file", "http", etc.)
+	*/
+	paths(...types) {
+		return getPaths(this._$refs, types.flat()).map((path) => {
+			return convertPathToPosix(path.decoded);
+		});
+	}
+	/**
+	* Returns a map of paths/URLs and their correspond values.
+	*
+	* See https://apidevtools.com/json-schema-ref-parser/docs/refs.html#valuestypes
+	*
+	* @param types (optional) Optionally only return values from certain locations ("file", "http", etc.)
+	*/
+	values(...types) {
+		const $refs = this._$refs;
+		return getPaths($refs, types.flat()).reduce((obj, path) => {
+			obj[convertPathToPosix(path.decoded)] = $refs[path.encoded].value;
+			return obj;
+		}, {});
+	}
+	/**
+	* Returns `true` if the given path exists in the schema; otherwise, returns `false`
+	*
+	* See https://apidevtools.com/json-schema-ref-parser/docs/refs.html#existsref
+	*
+	* @param $ref The JSON Reference path, optionally with a JSON Pointer in the hash
+	*/
+	/**
+	* Determines whether the given JSON reference exists.
+	*
+	* @param path - The path being resolved, optionally with a JSON pointer in the hash
+	* @param [options]
+	* @returns
+	*/
+	exists(path, options) {
+		try {
+			this._resolve(path, "", options);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Resolves the given JSON reference and returns the resolved value.
+	*
+	* @param path - The path being resolved, with a JSON pointer in the hash
+	* @param [options]
+	* @returns - Returns the resolved value
+	*/
+	get(path, options) {
+		return this._resolve(path, "", options).value;
+	}
+	/**
+	* Sets the value at the given path in the schema. If the property, or any of its parents, don't exist, they will be created.
+	*
+	* @param path The JSON Reference path, optionally with a JSON Pointer in the hash
+	* @param value The value to assign. Can be anything (object, string, number, etc.)
+	*/
+	set(path, value) {
+		const absPath = resolve(this._root$Ref.path, path);
+		const $ref = this._getRef(absPath);
+		if (!$ref) throw new Error(`Error resolving $ref pointer "${path}". \n"${stripHash(absPath)}" not found.`);
+		$ref.set(absPath, value);
+	}
+	/**
+	* Returns the specified {@link $Ref} object, or undefined.
+	*
+	* @param path - The path being resolved, optionally with a JSON pointer in the hash
+	* @returns
+	* @protected
+	*/
+	_get$Ref(path) {
+		path = resolve(this._root$Ref.path, path);
+		return this._getRef(path);
+	}
+	/**
+	* Creates a new {@link $Ref} object and adds it to this {@link $Refs} object.
+	*
+	* @param path  - The file path or URL of the referenced file
+	*/
+	_add(path) {
+		const withoutHash = stripHash(path);
+		const $ref = new $Ref(this);
+		$ref.path = withoutHash;
+		this._$refs[withoutHash] = $ref;
+		this._root$Ref = this._root$Ref || $ref;
+		return $ref;
+	}
+	_addAlias(path, value, pathType, dynamicIdScope = false) {
+		const withoutHash = stripHash(path);
+		if (!withoutHash || this._$refs[withoutHash] || this._aliases[withoutHash]) return this._$refs[withoutHash] || this._aliases[withoutHash];
+		const $ref = new $Ref(this);
+		$ref.path = withoutHash;
+		$ref.pathType = pathType;
+		$ref.value = value;
+		$ref.dynamicIdScope = dynamicIdScope;
+		this._aliases[withoutHash] = $ref;
+		return $ref;
+	}
+	/**
+	* Resolves the given JSON reference.
+	*
+	* @param path - The path being resolved, optionally with a JSON pointer in the hash
+	* @param pathFromRoot - The path of `obj` from the schema root
+	* @param [options]
+	* @returns
+	* @protected
+	*/
+	_resolve(path, pathFromRoot, options) {
+		const absPath = resolve(this._root$Ref.path, path);
+		const $ref = this._getRef(absPath);
+		if (!$ref) throw new Error(`Error resolving $ref pointer "${path}". \n"${stripHash(absPath)}" not found.`);
+		return $ref.resolve(absPath, options, path, pathFromRoot);
+	}
+	/**
+	* A map of paths/urls to {@link $Ref} objects
+	*
+	* @type {object}
+	* @protected
+	*/
+	_$refs = {};
+	_aliases = {};
+	/**
+	* The {@link $Ref} object that is the root of the JSON schema.
+	*
+	* @type {$Ref}
+	* @protected
+	*/
+	_root$Ref;
+	constructor() {
+		/**
+		* Indicates whether the schema contains any circular references.
+		*
+		* @type {boolean}
+		*/
+		this.circular = false;
+		this._$refs = {};
+		this._aliases = {};
+		this._root$Ref = null;
+	}
+	/**
+	* Returns the paths of all the files/URLs that are referenced by the JSON schema,
+	* including the schema itself.
+	*
+	* @param [types] - Only return paths of the given types ("file", "http", etc.)
+	* @returns
+	*/
+	/**
+	* Returns the map of JSON references and their resolved values.
+	*
+	* @param [types] - Only return references of the given types ("file", "http", etc.)
+	* @returns
+	*/
+	/**
+	* Returns a POJO (plain old JavaScript object) for serialization as JSON.
+	*
+	* @returns {object}
+	*/
+	toJSON = this.values;
+	_getRef(path) {
+		const withoutHash = stripHash(path);
+		return this._$refs[withoutHash] || this._aliases[withoutHash];
+	}
+};
+/**
+* Returns the encoded and decoded paths keys of the given object.
+*
+* @param $refs - The object whose keys are URL-encoded paths
+* @param [types] - Only return paths of the given types ("file", "http", etc.)
+* @returns
+*/
+function getPaths($refs, types) {
+	let paths = Object.keys($refs);
+	types = Array.isArray(types[0]) ? types[0] : Array.prototype.slice.call(types);
+	if (types.length > 0 && types[0]) paths = paths.filter((key) => {
+		return types.includes($refs[key].pathType);
+	});
+	return paths.map((path) => {
+		return {
+			encoded: path,
+			decoded: $refs[path].pathType === "file" ? toFileSystemPath(path, true) : path
+		};
+	});
+}
+//#endregion
+export { $Refs as default };