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

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

@@ -0,0 +1,36 @@
+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/text.js
+const TEXT_REGEXP = /\.(txt|htm|html|md|xml|js|min|map|css|scss|less|svg)$/i;
+var text_default = {
+	/**
+	* The order that this parser will run, in relation to other parsers.
+	*/
+	order: 300,
+	/**
+	* Whether to allow "empty" files (zero bytes).
+	*/
+	allowEmpty: true,
+	/**
+	* The encoding that the text is expected to be in.
+	*/
+	encoding: "utf8",
+	/**
+	* 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 (typeof file.data === "string" || Buffer.isBuffer(file.data)) && TEXT_REGEXP.test(file.url);
+	},
+	/**
+	* Parses the given file as text
+	*/
+	parse(file) {
+		if (typeof file.data === "string") return file.data;
+		else if (Buffer.isBuffer(file.data)) return file.data.toString(this.encoding);
+		else throw new ParserError("data is not text", file.url);
+	}
+};
+//#endregion
+export { text_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/yaml.js

@@ -0,0 +1,49 @@
+import { ParserError } from "../util/errors.js";
+import yaml, { JSON_SCHEMA } from "js-yaml";
+//#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/yaml.js
+var yaml_default = {
+	/**
+	* The order that this parser will run, in relation to other parsers.
+	*/
+	order: 200,
+	/**
+	* 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: [
+		".yaml",
+		".yml",
+		".json"
+	],
+	/**
+	* Parses the given file as YAML
+	*
+	* @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
+	* @returns
+	*/
+	async parse(file) {
+		let data = file.data;
+		if (Buffer.isBuffer(data)) data = data.toString();
+		if (typeof data === "string") try {
+			return yaml.load(data, { schema: JSON_SCHEMA });
+		} catch {
+			try {
+				return yaml.load(data);
+			} catch (e) {
+				throw new ParserError(e?.message || "Parser Error", file.url);
+			}
+		}
+		else return data;
+	}
+};
+//#endregion
+export { yaml_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/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 };