fumadocs-openapi 10.10.3 → 11.0.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/parsers/text.js

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

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

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

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