@fumadocs/api-docs 0.0.1

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.d.ts

@@ -0,0 +1,96 @@
+import { JSONSchema } from "./types/index.js";
+import { ParserOptions } from "./options.js";
+import { $Ref } from "./ref.js";
+import { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from "json-schema";
+
+//#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.d.ts
+/**
+ * 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
+ */
+declare class Pointer<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
+  /**
+   * The {@link $Ref} object that contains this {@link Pointer} object.
+   */
+  $ref: $Ref<S, O>;
+  /**
+   * 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: string;
+  /**
+   * The original path or URL, used for error messages.
+   */
+  originalPath: string;
+  /**
+   * The current base URI used to resolve nested $ref pointers while walking this pointer.
+   */
+  scopeBase: string;
+  /**
+   * The value of the JSON pointer.
+   * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
+   */
+  value: any;
+  /**
+   * Indicates whether the pointer references itself.
+   */
+  circular: boolean;
+  /**
+   * The number of indirect references that were traversed to resolve the value.
+   * Resolving a single pointer may require resolving multiple $Refs.
+   */
+  indirections: number;
+  constructor($ref: $Ref<S, O>, path: string, friendlyPath?: string);
+  /**
+   * 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: S, options?: O, pathFromRoot?: string): 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: S, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type, options?: O): string | number | boolean | import("json-schema").JSONSchema4Object | import("json-schema").JSONSchema4Array | S | null;
+  /**
+   * 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: string, originalPath?: string): string[];
+  /**
+   * 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: string, tokens: string | string[]): string;
+}
+//#endregion
+export { Pointer };

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.d.ts

@@ -0,0 +1,190 @@
+import { JSONSchema } from "./types/index.js";
+import { ParserOptions } from "./options.js";
+import { JSONParserError, MissingPointerError, ParserError, ResolverError } from "./util/errors.js";
+import { Pointer } from "./pointer.js";
+import { $Refs } from "./refs.js";
+import { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from "json-schema";
+
+//#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.d.ts
+type $RefError = JSONParserError | ResolverError | ParserError | MissingPointerError;
+/**
+ * This class represents a single JSON reference and its resolved value.
+ *
+ * @class
+ */
+declare class $Ref<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
+  /**
+   * 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: undefined | string;
+  /**
+   * 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: any;
+  /**
+   * The {@link $Refs} object that contains this {@link $Ref} object.
+   *
+   * @type {$Refs}
+   */
+  $refs: $Refs<S, O>;
+  /**
+   * Indicates the type of {@link $Ref#path} (e.g. "file", "http", etc.)
+   */
+  pathType: string | unknown;
+  /**
+   * Whether this document/resource should use JSON Schema 2019-09+ nested $id scope semantics.
+   */
+  dynamicIdScope: boolean;
+  /**
+   * List of all errors. Undefined if no errors.
+   */
+  errors: Array<$RefError>;
+  constructor($refs: $Refs<S, O>);
+  /**
+   * Pushes an error to errors array.
+   *
+   * @param err - The error to be pushed
+   * @returns
+   */
+  addError(err: $RefError): void;
+  /**
+   * 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: string, options?: O): boolean;
+  /**
+   * 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: string, options?: O): any;
+  /**
+   * 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: string, options?: O, friendlyPath?: string, pathFromRoot?: string): Pointer<S, O> | 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: string, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type): void;
+  /**
+   * Determines whether the given value is a JSON reference.
+   *
+   * @param value - The value to inspect
+   * @returns
+   */
+  static is$Ref(value: unknown): value is {
+    $ref: string;
+    length?: number;
+  };
+  /**
+   * Determines whether the given value is an external JSON reference.
+   *
+   * @param value - The value to inspect
+   * @returns
+   */
+  static isExternal$Ref(value: unknown): boolean;
+  /**
+   * 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<S extends object = JSONSchema>(value: unknown, options?: ParserOptions<S>): true | undefined;
+  /**
+   * 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: unknown): boolean;
+  /**
+   * 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<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>($ref: $Ref<S, O>, resolvedValue: S, options?: O): S;
+}
+//#endregion
+export { $Ref };