fumadocs-openapi 10.8.4 → 10.8.6

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/scope.js

@@ -0,0 +1,141 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_code } from "./code.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/scope.js
+var require_scope = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ValueScope = exports.ValueScopeName = exports.Scope = exports.varKinds = exports.UsedValueState = void 0;
+	const code_1 = require_code();
+	var ValueError = class extends Error {
+		constructor(name) {
+			super(`CodeGen: "code" for ${name} not defined`);
+			this.value = name.value;
+		}
+	};
+	var UsedValueState;
+	(function(UsedValueState) {
+		UsedValueState[UsedValueState["Started"] = 0] = "Started";
+		UsedValueState[UsedValueState["Completed"] = 1] = "Completed";
+	})(UsedValueState || (exports.UsedValueState = UsedValueState = {}));
+	exports.varKinds = {
+		const: new code_1.Name("const"),
+		let: new code_1.Name("let"),
+		var: new code_1.Name("var")
+	};
+	var Scope = class {
+		constructor({ prefixes, parent } = {}) {
+			this._names = {};
+			this._prefixes = prefixes;
+			this._parent = parent;
+		}
+		toName(nameOrPrefix) {
+			return nameOrPrefix instanceof code_1.Name ? nameOrPrefix : this.name(nameOrPrefix);
+		}
+		name(prefix) {
+			return new code_1.Name(this._newName(prefix));
+		}
+		_newName(prefix) {
+			const ng = this._names[prefix] || this._nameGroup(prefix);
+			return `${prefix}${ng.index++}`;
+		}
+		_nameGroup(prefix) {
+			var _a, _b;
+			if (((_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a._prefixes) === null || _b === void 0 ? void 0 : _b.has(prefix)) || this._prefixes && !this._prefixes.has(prefix)) throw new Error(`CodeGen: prefix "${prefix}" is not allowed in this scope`);
+			return this._names[prefix] = {
+				prefix,
+				index: 0
+			};
+		}
+	};
+	exports.Scope = Scope;
+	var ValueScopeName = class extends code_1.Name {
+		constructor(prefix, nameStr) {
+			super(nameStr);
+			this.prefix = prefix;
+		}
+		setValue(value, { property, itemIndex }) {
+			this.value = value;
+			this.scopePath = (0, code_1._)`.${new code_1.Name(property)}[${itemIndex}]`;
+		}
+	};
+	exports.ValueScopeName = ValueScopeName;
+	const line = (0, code_1._)`\n`;
+	var ValueScope = class extends Scope {
+		constructor(opts) {
+			super(opts);
+			this._values = {};
+			this._scope = opts.scope;
+			this.opts = {
+				...opts,
+				_n: opts.lines ? line : code_1.nil
+			};
+		}
+		get() {
+			return this._scope;
+		}
+		name(prefix) {
+			return new ValueScopeName(prefix, this._newName(prefix));
+		}
+		value(nameOrPrefix, value) {
+			var _a;
+			if (value.ref === void 0) throw new Error("CodeGen: ref must be passed in value");
+			const name = this.toName(nameOrPrefix);
+			const { prefix } = name;
+			const valueKey = (_a = value.key) !== null && _a !== void 0 ? _a : value.ref;
+			let vs = this._values[prefix];
+			if (vs) {
+				const _name = vs.get(valueKey);
+				if (_name) return _name;
+			} else vs = this._values[prefix] = /* @__PURE__ */ new Map();
+			vs.set(valueKey, name);
+			const s = this._scope[prefix] || (this._scope[prefix] = []);
+			const itemIndex = s.length;
+			s[itemIndex] = value.ref;
+			name.setValue(value, {
+				property: prefix,
+				itemIndex
+			});
+			return name;
+		}
+		getValue(prefix, keyOrRef) {
+			const vs = this._values[prefix];
+			if (!vs) return;
+			return vs.get(keyOrRef);
+		}
+		scopeRefs(scopeName, values = this._values) {
+			return this._reduceValues(values, (name) => {
+				if (name.scopePath === void 0) throw new Error(`CodeGen: name "${name}" has no value`);
+				return (0, code_1._)`${scopeName}${name.scopePath}`;
+			});
+		}
+		scopeCode(values = this._values, usedValues, getCode) {
+			return this._reduceValues(values, (name) => {
+				if (name.value === void 0) throw new Error(`CodeGen: name "${name}" has no value`);
+				return name.value.code;
+			}, usedValues, getCode);
+		}
+		_reduceValues(values, valueCode, usedValues = {}, getCode) {
+			let code = code_1.nil;
+			for (const prefix in values) {
+				const vs = values[prefix];
+				if (!vs) continue;
+				const nameSet = usedValues[prefix] = usedValues[prefix] || /* @__PURE__ */ new Map();
+				vs.forEach((name) => {
+					if (nameSet.has(name)) return;
+					nameSet.set(name, UsedValueState.Started);
+					let c = valueCode(name);
+					if (c) {
+						const def = this.opts.es5 ? exports.varKinds.var : exports.varKinds.const;
+						code = (0, code_1._)`${code}${def} ${name} = ${c};${this.opts._n}`;
+					} else if (c = getCode === null || getCode === void 0 ? void 0 : getCode(name)) code = (0, code_1._)`${code}${c}${this.opts._n}`;
+					else throw new ValueError(name);
+					nameSet.set(name, UsedValueState.Completed);
+				});
+			}
+			return code;
+		}
+	};
+	exports.ValueScope = ValueScope;
+}));
+//#endregion
+export default require_scope();
+export { require_scope };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/errors.js

@@ -0,0 +1,102 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "./codegen/index.js";
+import { require_util } from "./util.js";
+import { require_names } from "./names.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/errors.js
+var require_errors = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = void 0;
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const names_1 = require_names();
+	exports.keywordError = { message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation` };
+	exports.keyword$DataError = { message: ({ keyword, schemaType }) => schemaType ? (0, codegen_1.str)`"${keyword}" keyword must be ${schemaType} ($data)` : (0, codegen_1.str)`"${keyword}" keyword is invalid ($data)` };
+	function reportError(cxt, error = exports.keywordError, errorPaths, overrideAllErrors) {
+		const { it } = cxt;
+		const { gen, compositeRule, allErrors } = it;
+		const errObj = errorObjectCode(cxt, error, errorPaths);
+		if (overrideAllErrors !== null && overrideAllErrors !== void 0 ? overrideAllErrors : compositeRule || allErrors) addError(gen, errObj);
+		else returnErrors(it, (0, codegen_1._)`[${errObj}]`);
+	}
+	exports.reportError = reportError;
+	function reportExtraError(cxt, error = exports.keywordError, errorPaths) {
+		const { it } = cxt;
+		const { gen, compositeRule, allErrors } = it;
+		addError(gen, errorObjectCode(cxt, error, errorPaths));
+		if (!(compositeRule || allErrors)) returnErrors(it, names_1.default.vErrors);
+	}
+	exports.reportExtraError = reportExtraError;
+	function resetErrorsCount(gen, errsCount) {
+		gen.assign(names_1.default.errors, errsCount);
+		gen.if((0, codegen_1._)`${names_1.default.vErrors} !== null`, () => gen.if(errsCount, () => gen.assign((0, codegen_1._)`${names_1.default.vErrors}.length`, errsCount), () => gen.assign(names_1.default.vErrors, null)));
+	}
+	exports.resetErrorsCount = resetErrorsCount;
+	function extendErrors({ gen, keyword, schemaValue, data, errsCount, it }) {
+		/* istanbul ignore if */
+		if (errsCount === void 0) throw new Error("ajv implementation error");
+		const err = gen.name("err");
+		gen.forRange("i", errsCount, names_1.default.errors, (i) => {
+			gen.const(err, (0, codegen_1._)`${names_1.default.vErrors}[${i}]`);
+			gen.if((0, codegen_1._)`${err}.instancePath === undefined`, () => gen.assign((0, codegen_1._)`${err}.instancePath`, (0, codegen_1.strConcat)(names_1.default.instancePath, it.errorPath)));
+			gen.assign((0, codegen_1._)`${err}.schemaPath`, (0, codegen_1.str)`${it.errSchemaPath}/${keyword}`);
+			if (it.opts.verbose) {
+				gen.assign((0, codegen_1._)`${err}.schema`, schemaValue);
+				gen.assign((0, codegen_1._)`${err}.data`, data);
+			}
+		});
+	}
+	exports.extendErrors = extendErrors;
+	function addError(gen, errObj) {
+		const err = gen.const("err", errObj);
+		gen.if((0, codegen_1._)`${names_1.default.vErrors} === null`, () => gen.assign(names_1.default.vErrors, (0, codegen_1._)`[${err}]`), (0, codegen_1._)`${names_1.default.vErrors}.push(${err})`);
+		gen.code((0, codegen_1._)`${names_1.default.errors}++`);
+	}
+	function returnErrors(it, errs) {
+		const { gen, validateName, schemaEnv } = it;
+		if (schemaEnv.$async) gen.throw((0, codegen_1._)`new ${it.ValidationError}(${errs})`);
+		else {
+			gen.assign((0, codegen_1._)`${validateName}.errors`, errs);
+			gen.return(false);
+		}
+	}
+	const E = {
+		keyword: new codegen_1.Name("keyword"),
+		schemaPath: new codegen_1.Name("schemaPath"),
+		params: new codegen_1.Name("params"),
+		propertyName: new codegen_1.Name("propertyName"),
+		message: new codegen_1.Name("message"),
+		schema: new codegen_1.Name("schema"),
+		parentSchema: new codegen_1.Name("parentSchema")
+	};
+	function errorObjectCode(cxt, error, errorPaths) {
+		const { createErrors } = cxt.it;
+		if (createErrors === false) return (0, codegen_1._)`{}`;
+		return errorObject(cxt, error, errorPaths);
+	}
+	function errorObject(cxt, error, errorPaths = {}) {
+		const { gen, it } = cxt;
+		const keyValues = [errorInstancePath(it, errorPaths), errorSchemaPath(cxt, errorPaths)];
+		extraErrorProps(cxt, error, keyValues);
+		return gen.object(...keyValues);
+	}
+	function errorInstancePath({ errorPath }, { instancePath }) {
+		const instPath = instancePath ? (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(instancePath, util_1.Type.Str)}` : errorPath;
+		return [names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, instPath)];
+	}
+	function errorSchemaPath({ keyword, it: { errSchemaPath } }, { schemaPath, parentSchema }) {
+		let schPath = parentSchema ? errSchemaPath : (0, codegen_1.str)`${errSchemaPath}/${keyword}`;
+		if (schemaPath) schPath = (0, codegen_1.str)`${schPath}${(0, util_1.getErrorPath)(schemaPath, util_1.Type.Str)}`;
+		return [E.schemaPath, schPath];
+	}
+	function extraErrorProps(cxt, { params, message }, keyValues) {
+		const { keyword, data, schemaValue, it } = cxt;
+		const { opts, propertyName, topSchemaRef, schemaPath } = it;
+		keyValues.push([E.keyword, keyword], [E.params, typeof params == "function" ? params(cxt) : params || (0, codegen_1._)`{}`]);
+		if (opts.messages) keyValues.push([E.message, typeof message == "function" ? message(cxt) : message]);
+		if (opts.verbose) keyValues.push([E.schema, schemaValue], [E.parentSchema, (0, codegen_1._)`${topSchemaRef}${schemaPath}`], [names_1.default.data, data]);
+		if (propertyName) keyValues.push([E.propertyName, propertyName]);
+	}
+}));
+//#endregion
+export default require_errors();
+export { require_errors };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/index.js

@@ -0,0 +1,223 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "./codegen/index.js";
+import { require_util } from "./util.js";
+import { require_names } from "./names.js";
+import { require_resolve } from "./resolve.js";
+import { require_validate } from "./validate/index.js";
+import { require_validation_error } from "../runtime/validation_error.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/index.js
+var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
+	const codegen_1 = require_codegen();
+	const validation_error_1 = require_validation_error();
+	const names_1 = require_names();
+	const resolve_1 = require_resolve();
+	const util_1 = require_util();
+	const validate_1 = require_validate();
+	var SchemaEnv = class {
+		constructor(env) {
+			var _a;
+			this.refs = {};
+			this.dynamicAnchors = {};
+			let schema;
+			if (typeof env.schema == "object") schema = env.schema;
+			this.schema = env.schema;
+			this.schemaId = env.schemaId;
+			this.root = env.root || this;
+			this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : (0, resolve_1.normalizeId)(schema === null || schema === void 0 ? void 0 : schema[env.schemaId || "$id"]);
+			this.schemaPath = env.schemaPath;
+			this.localRefs = env.localRefs;
+			this.meta = env.meta;
+			this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
+			this.refs = {};
+		}
+	};
+	exports.SchemaEnv = SchemaEnv;
+	function compileSchema(sch) {
+		const _sch = getCompilingSchema.call(this, sch);
+		if (_sch) return _sch;
+		const rootId = (0, resolve_1.getFullPath)(this.opts.uriResolver, sch.root.baseId);
+		const { es5, lines } = this.opts.code;
+		const { ownProperties } = this.opts;
+		const gen = new codegen_1.CodeGen(this.scope, {
+			es5,
+			lines,
+			ownProperties
+		});
+		let _ValidationError;
+		if (sch.$async) _ValidationError = gen.scopeValue("Error", {
+			ref: validation_error_1.default,
+			code: (0, codegen_1._)`require("ajv/dist/runtime/validation_error").default`
+		});
+		const validateName = gen.scopeName("validate");
+		sch.validateName = validateName;
+		const schemaCxt = {
+			gen,
+			allErrors: this.opts.allErrors,
+			data: names_1.default.data,
+			parentData: names_1.default.parentData,
+			parentDataProperty: names_1.default.parentDataProperty,
+			dataNames: [names_1.default.data],
+			dataPathArr: [codegen_1.nil],
+			dataLevel: 0,
+			dataTypes: [],
+			definedProperties: /* @__PURE__ */ new Set(),
+			topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true ? {
+				ref: sch.schema,
+				code: (0, codegen_1.stringify)(sch.schema)
+			} : { ref: sch.schema }),
+			validateName,
+			ValidationError: _ValidationError,
+			schema: sch.schema,
+			schemaEnv: sch,
+			rootId,
+			baseId: sch.baseId || rootId,
+			schemaPath: codegen_1.nil,
+			errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
+			errorPath: (0, codegen_1._)`""`,
+			opts: this.opts,
+			self: this
+		};
+		let sourceCode;
+		try {
+			this._compilations.add(sch);
+			(0, validate_1.validateFunctionCode)(schemaCxt);
+			gen.optimize(this.opts.code.optimize);
+			const validateCode = gen.toString();
+			sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
+			if (this.opts.code.process) sourceCode = this.opts.code.process(sourceCode, sch);
+			const validate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode)(this, this.scope.get());
+			this.scope.value(validateName, { ref: validate });
+			validate.errors = null;
+			validate.schema = sch.schema;
+			validate.schemaEnv = sch;
+			if (sch.$async) validate.$async = true;
+			if (this.opts.code.source === true) validate.source = {
+				validateName,
+				validateCode,
+				scopeValues: gen._values
+			};
+			if (this.opts.unevaluated) {
+				const { props, items } = schemaCxt;
+				validate.evaluated = {
+					props: props instanceof codegen_1.Name ? void 0 : props,
+					items: items instanceof codegen_1.Name ? void 0 : items,
+					dynamicProps: props instanceof codegen_1.Name,
+					dynamicItems: items instanceof codegen_1.Name
+				};
+				if (validate.source) validate.source.evaluated = (0, codegen_1.stringify)(validate.evaluated);
+			}
+			sch.validate = validate;
+			return sch;
+		} catch (e) {
+			delete sch.validate;
+			delete sch.validateName;
+			if (sourceCode) this.logger.error("Error compiling schema, function code:", sourceCode);
+			throw e;
+		} finally {
+			this._compilations.delete(sch);
+		}
+	}
+	exports.compileSchema = compileSchema;
+	function resolveRef(root, baseId, ref) {
+		var _a;
+		ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
+		const schOrFunc = root.refs[ref];
+		if (schOrFunc) return schOrFunc;
+		let _sch = resolve.call(this, root, ref);
+		if (_sch === void 0) {
+			const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
+			const { schemaId } = this.opts;
+			if (schema) _sch = new SchemaEnv({
+				schema,
+				schemaId,
+				root,
+				baseId
+			});
+		}
+		if (_sch === void 0) return;
+		return root.refs[ref] = inlineOrCompile.call(this, _sch);
+	}
+	exports.resolveRef = resolveRef;
+	function inlineOrCompile(sch) {
+		if ((0, resolve_1.inlineRef)(sch.schema, this.opts.inlineRefs)) return sch.schema;
+		return sch.validate ? sch : compileSchema.call(this, sch);
+	}
+	function getCompilingSchema(schEnv) {
+		for (const sch of this._compilations) if (sameSchemaEnv(sch, schEnv)) return sch;
+	}
+	exports.getCompilingSchema = getCompilingSchema;
+	function sameSchemaEnv(s1, s2) {
+		return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
+	}
+	function resolve(root, ref) {
+		let sch;
+		while (typeof (sch = this.refs[ref]) == "string") ref = sch;
+		return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
+	}
+	function resolveSchema(root, ref) {
+		const p = this.opts.uriResolver.parse(ref);
+		const refPath = (0, resolve_1._getFullPath)(this.opts.uriResolver, p);
+		let baseId = (0, resolve_1.getFullPath)(this.opts.uriResolver, root.baseId, void 0);
+		if (Object.keys(root.schema).length > 0 && refPath === baseId) return getJsonPointer.call(this, p, root);
+		const id = (0, resolve_1.normalizeId)(refPath);
+		const schOrRef = this.refs[id] || this.schemas[id];
+		if (typeof schOrRef == "string") {
+			const sch = resolveSchema.call(this, root, schOrRef);
+			if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object") return;
+			return getJsonPointer.call(this, p, sch);
+		}
+		if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object") return;
+		if (!schOrRef.validate) compileSchema.call(this, schOrRef);
+		if (id === (0, resolve_1.normalizeId)(ref)) {
+			const { schema } = schOrRef;
+			const { schemaId } = this.opts;
+			const schId = schema[schemaId];
+			if (schId) baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
+			return new SchemaEnv({
+				schema,
+				schemaId,
+				root,
+				baseId
+			});
+		}
+		return getJsonPointer.call(this, p, schOrRef);
+	}
+	exports.resolveSchema = resolveSchema;
+	const PREVENT_SCOPE_CHANGE = new Set([
+		"properties",
+		"patternProperties",
+		"enum",
+		"dependencies",
+		"definitions"
+	]);
+	function getJsonPointer(parsedRef, { baseId, schema, root }) {
+		var _a;
+		if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/") return;
+		for (const part of parsedRef.fragment.slice(1).split("/")) {
+			if (typeof schema === "boolean") return;
+			const partSchema = schema[(0, util_1.unescapeFragment)(part)];
+			if (partSchema === void 0) return;
+			schema = partSchema;
+			const schId = typeof schema === "object" && schema[this.opts.schemaId];
+			if (!PREVENT_SCOPE_CHANGE.has(part) && schId) baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
+		}
+		let env;
+		if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
+			const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
+			env = resolveSchema.call(this, root, $ref);
+		}
+		const { schemaId } = this.opts;
+		env = env || new SchemaEnv({
+			schema,
+			schemaId,
+			root,
+			baseId
+		});
+		if (env.schema !== env.root.schema) return env;
+	}
+}));
+//#endregion
+export default require_compile();
+export { require_compile };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/names.js

@@ -0,0 +1,28 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "./codegen/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/names.js
+var require_names = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	exports.default = {
+		data: new codegen_1.Name("data"),
+		valCxt: new codegen_1.Name("valCxt"),
+		instancePath: new codegen_1.Name("instancePath"),
+		parentData: new codegen_1.Name("parentData"),
+		parentDataProperty: new codegen_1.Name("parentDataProperty"),
+		rootData: new codegen_1.Name("rootData"),
+		dynamicAnchors: new codegen_1.Name("dynamicAnchors"),
+		vErrors: new codegen_1.Name("vErrors"),
+		errors: new codegen_1.Name("errors"),
+		this: new codegen_1.Name("this"),
+		self: new codegen_1.Name("self"),
+		scope: new codegen_1.Name("scope"),
+		json: new codegen_1.Name("json"),
+		jsonPos: new codegen_1.Name("jsonPos"),
+		jsonLen: new codegen_1.Name("jsonLen"),
+		jsonPart: new codegen_1.Name("jsonPart")
+	};
+}));
+//#endregion
+export default require_names();
+export { require_names };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/ref_error.js

@@ -0,0 +1,18 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_resolve } from "./resolve.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/ref_error.js
+var require_ref_error = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const resolve_1 = require_resolve();
+	var MissingRefError = class extends Error {
+		constructor(resolver, baseId, ref, msg) {
+			super(msg || `can't resolve reference ${ref} from id ${baseId}`);
+			this.missingRef = (0, resolve_1.resolveUrl)(resolver, baseId, ref);
+			this.missingSchema = (0, resolve_1.normalizeId)((0, resolve_1.getFullPath)(resolver, this.missingRef));
+		}
+	};
+	exports.default = MissingRefError;
+}));
+//#endregion
+export default require_ref_error();
+export { require_ref_error };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/resolve.js

@@ -0,0 +1,133 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_util } from "./util.js";
+import { require_fast_deep_equal } from "../../../../../fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js";
+import { require_json_schema_traverse } from "../../../../../json-schema-traverse@1.0.0/node_modules/json-schema-traverse/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/resolve.js
+var require_resolve = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = void 0;
+	const util_1 = require_util();
+	const equal = require_fast_deep_equal();
+	const traverse = require_json_schema_traverse();
+	const SIMPLE_INLINED = new Set([
+		"type",
+		"format",
+		"pattern",
+		"maxLength",
+		"minLength",
+		"maxProperties",
+		"minProperties",
+		"maxItems",
+		"minItems",
+		"maximum",
+		"minimum",
+		"uniqueItems",
+		"multipleOf",
+		"required",
+		"enum",
+		"const"
+	]);
+	function inlineRef(schema, limit = true) {
+		if (typeof schema == "boolean") return true;
+		if (limit === true) return !hasRef(schema);
+		if (!limit) return false;
+		return countKeys(schema) <= limit;
+	}
+	exports.inlineRef = inlineRef;
+	const REF_KEYWORDS = new Set([
+		"$ref",
+		"$recursiveRef",
+		"$recursiveAnchor",
+		"$dynamicRef",
+		"$dynamicAnchor"
+	]);
+	function hasRef(schema) {
+		for (const key in schema) {
+			if (REF_KEYWORDS.has(key)) return true;
+			const sch = schema[key];
+			if (Array.isArray(sch) && sch.some(hasRef)) return true;
+			if (typeof sch == "object" && hasRef(sch)) return true;
+		}
+		return false;
+	}
+	function countKeys(schema) {
+		let count = 0;
+		for (const key in schema) {
+			if (key === "$ref") return Infinity;
+			count++;
+			if (SIMPLE_INLINED.has(key)) continue;
+			if (typeof schema[key] == "object") (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
+			if (count === Infinity) return Infinity;
+		}
+		return count;
+	}
+	function getFullPath(resolver, id = "", normalize) {
+		if (normalize !== false) id = normalizeId(id);
+		return _getFullPath(resolver, resolver.parse(id));
+	}
+	exports.getFullPath = getFullPath;
+	function _getFullPath(resolver, p) {
+		return resolver.serialize(p).split("#")[0] + "#";
+	}
+	exports._getFullPath = _getFullPath;
+	const TRAILING_SLASH_HASH = /#\/?$/;
+	function normalizeId(id) {
+		return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
+	}
+	exports.normalizeId = normalizeId;
+	function resolveUrl(resolver, baseId, id) {
+		id = normalizeId(id);
+		return resolver.resolve(baseId, id);
+	}
+	exports.resolveUrl = resolveUrl;
+	const ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
+	function getSchemaRefs(schema, baseId) {
+		if (typeof schema == "boolean") return {};
+		const { schemaId, uriResolver } = this.opts;
+		const schId = normalizeId(schema[schemaId] || baseId);
+		const baseIds = { "": schId };
+		const pathPrefix = getFullPath(uriResolver, schId, false);
+		const localRefs = {};
+		const schemaRefs = /* @__PURE__ */ new Set();
+		traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
+			if (parentJsonPtr === void 0) return;
+			const fullPath = pathPrefix + jsonPtr;
+			let innerBaseId = baseIds[parentJsonPtr];
+			if (typeof sch[schemaId] == "string") innerBaseId = addRef.call(this, sch[schemaId]);
+			addAnchor.call(this, sch.$anchor);
+			addAnchor.call(this, sch.$dynamicAnchor);
+			baseIds[jsonPtr] = innerBaseId;
+			function addRef(ref) {
+				const _resolve = this.opts.uriResolver.resolve;
+				ref = normalizeId(innerBaseId ? _resolve(innerBaseId, ref) : ref);
+				if (schemaRefs.has(ref)) throw ambiguos(ref);
+				schemaRefs.add(ref);
+				let schOrRef = this.refs[ref];
+				if (typeof schOrRef == "string") schOrRef = this.refs[schOrRef];
+				if (typeof schOrRef == "object") checkAmbiguosRef(sch, schOrRef.schema, ref);
+				else if (ref !== normalizeId(fullPath)) if (ref[0] === "#") {
+					checkAmbiguosRef(sch, localRefs[ref], ref);
+					localRefs[ref] = sch;
+				} else this.refs[ref] = fullPath;
+				return ref;
+			}
+			function addAnchor(anchor) {
+				if (typeof anchor == "string") {
+					if (!ANCHOR.test(anchor)) throw new Error(`invalid anchor "${anchor}"`);
+					addRef.call(this, `#${anchor}`);
+				}
+			}
+		});
+		return localRefs;
+		function checkAmbiguosRef(sch1, sch2, ref) {
+			if (sch2 !== void 0 && !equal(sch1, sch2)) throw ambiguos(ref);
+		}
+		function ambiguos(ref) {
+			return /* @__PURE__ */ new Error(`reference "${ref}" resolves to more than one schema`);
+		}
+	}
+	exports.getSchemaRefs = getSchemaRefs;
+}));
+//#endregion
+export default require_resolve();
+export { require_resolve };