fumadocs-openapi 10.8.4 → 10.8.6

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

@@ -0,0 +1,433 @@
+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_errors } from "../errors.js";
+import { require_boolSchema } from "./boolSchema.js";
+import { require_applicability } from "./applicability.js";
+import { require_dataType } from "./dataType.js";
+import { require_defaults } from "./defaults.js";
+import { require_keyword } from "./keyword.js";
+import { require_subschema } from "./subschema.js";
+import { require_resolve } from "../resolve.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/index.js
+var require_validate = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getData = exports.KeywordCxt = exports.validateFunctionCode = void 0;
+	const boolSchema_1 = require_boolSchema();
+	const dataType_1 = require_dataType();
+	const applicability_1 = require_applicability();
+	const dataType_2 = require_dataType();
+	const defaults_1 = require_defaults();
+	const keyword_1 = require_keyword();
+	const subschema_1 = require_subschema();
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const resolve_1 = require_resolve();
+	const util_1 = require_util();
+	const errors_1 = require_errors();
+	function validateFunctionCode(it) {
+		if (isSchemaObj(it)) {
+			checkKeywords(it);
+			if (schemaCxtHasRules(it)) {
+				topSchemaObjCode(it);
+				return;
+			}
+		}
+		validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
+	}
+	exports.validateFunctionCode = validateFunctionCode;
+	function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
+		if (opts.code.es5) gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
+			gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
+			destructureValCxtES5(gen, opts);
+			gen.code(body);
+		});
+		else gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
+	}
+	function destructureValCxt(opts) {
+		return (0, codegen_1._)`{${names_1.default.instancePath}="", ${names_1.default.parentData}, ${names_1.default.parentDataProperty}, ${names_1.default.rootData}=${names_1.default.data}${opts.dynamicRef ? (0, codegen_1._)`, ${names_1.default.dynamicAnchors}={}` : codegen_1.nil}}={}`;
+	}
+	function destructureValCxtES5(gen, opts) {
+		gen.if(names_1.default.valCxt, () => {
+			gen.var(names_1.default.instancePath, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.instancePath}`);
+			gen.var(names_1.default.parentData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentData}`);
+			gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.parentDataProperty}`);
+			gen.var(names_1.default.rootData, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.rootData}`);
+			if (opts.dynamicRef) gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`${names_1.default.valCxt}.${names_1.default.dynamicAnchors}`);
+		}, () => {
+			gen.var(names_1.default.instancePath, (0, codegen_1._)`""`);
+			gen.var(names_1.default.parentData, (0, codegen_1._)`undefined`);
+			gen.var(names_1.default.parentDataProperty, (0, codegen_1._)`undefined`);
+			gen.var(names_1.default.rootData, names_1.default.data);
+			if (opts.dynamicRef) gen.var(names_1.default.dynamicAnchors, (0, codegen_1._)`{}`);
+		});
+	}
+	function topSchemaObjCode(it) {
+		const { schema, opts, gen } = it;
+		validateFunction(it, () => {
+			if (opts.$comment && schema.$comment) commentKeyword(it);
+			checkNoDefault(it);
+			gen.let(names_1.default.vErrors, null);
+			gen.let(names_1.default.errors, 0);
+			if (opts.unevaluated) resetEvaluated(it);
+			typeAndKeywords(it);
+			returnResults(it);
+		});
+	}
+	function resetEvaluated(it) {
+		const { gen, validateName } = it;
+		it.evaluated = gen.const("evaluated", (0, codegen_1._)`${validateName}.evaluated`);
+		gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
+		gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
+	}
+	function funcSourceUrl(schema, opts) {
+		const schId = typeof schema == "object" && schema[opts.schemaId];
+		return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
+	}
+	function subschemaCode(it, valid) {
+		if (isSchemaObj(it)) {
+			checkKeywords(it);
+			if (schemaCxtHasRules(it)) {
+				subSchemaObjCode(it, valid);
+				return;
+			}
+		}
+		(0, boolSchema_1.boolOrEmptySchema)(it, valid);
+	}
+	function schemaCxtHasRules({ schema, self }) {
+		if (typeof schema == "boolean") return !schema;
+		for (const key in schema) if (self.RULES.all[key]) return true;
+		return false;
+	}
+	function isSchemaObj(it) {
+		return typeof it.schema != "boolean";
+	}
+	function subSchemaObjCode(it, valid) {
+		const { schema, gen, opts } = it;
+		if (opts.$comment && schema.$comment) commentKeyword(it);
+		updateContext(it);
+		checkAsyncSchema(it);
+		const errsCount = gen.const("_errs", names_1.default.errors);
+		typeAndKeywords(it, errsCount);
+		gen.var(valid, (0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+	}
+	function checkKeywords(it) {
+		(0, util_1.checkUnknownRules)(it);
+		checkRefsAndKeywords(it);
+	}
+	function typeAndKeywords(it, errsCount) {
+		if (it.opts.jtd) return schemaKeywords(it, [], false, errsCount);
+		const types = (0, dataType_1.getSchemaTypes)(it.schema);
+		schemaKeywords(it, types, !(0, dataType_1.coerceAndCheckDataType)(it, types), errsCount);
+	}
+	function checkRefsAndKeywords(it) {
+		const { schema, errSchemaPath, opts, self } = it;
+		if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self.RULES)) self.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
+	}
+	function checkNoDefault(it) {
+		const { schema, opts } = it;
+		if (schema.default !== void 0 && opts.useDefaults && opts.strictSchema) (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
+	}
+	function updateContext(it) {
+		const schId = it.schema[it.opts.schemaId];
+		if (schId) it.baseId = (0, resolve_1.resolveUrl)(it.opts.uriResolver, it.baseId, schId);
+	}
+	function checkAsyncSchema(it) {
+		if (it.schema.$async && !it.schemaEnv.$async) throw new Error("async schema in sync schema");
+	}
+	function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
+		const msg = schema.$comment;
+		if (opts.$comment === true) gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
+		else if (typeof opts.$comment == "function") {
+			const schemaPath = (0, codegen_1.str)`${errSchemaPath}/$comment`;
+			const rootName = gen.scopeValue("root", { ref: schemaEnv.root });
+			gen.code((0, codegen_1._)`${names_1.default.self}.opts.$comment(${msg}, ${schemaPath}, ${rootName}.schema)`);
+		}
+	}
+	function returnResults(it) {
+		const { gen, schemaEnv, validateName, ValidationError, opts } = it;
+		if (schemaEnv.$async) gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
+		else {
+			gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
+			if (opts.unevaluated) assignEvaluated(it);
+			gen.return((0, codegen_1._)`${names_1.default.errors} === 0`);
+		}
+	}
+	function assignEvaluated({ gen, evaluated, props, items }) {
+		if (props instanceof codegen_1.Name) gen.assign((0, codegen_1._)`${evaluated}.props`, props);
+		if (items instanceof codegen_1.Name) gen.assign((0, codegen_1._)`${evaluated}.items`, items);
+	}
+	function schemaKeywords(it, types, typeErrors, errsCount) {
+		const { gen, schema, data, allErrors, opts, self } = it;
+		const { RULES } = self;
+		if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
+			gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
+			return;
+		}
+		if (!opts.jtd) checkStrictTypes(it, types);
+		gen.block(() => {
+			for (const group of RULES.rules) groupKeywords(group);
+			groupKeywords(RULES.post);
+		});
+		function groupKeywords(group) {
+			if (!(0, applicability_1.shouldUseGroup)(schema, group)) return;
+			if (group.type) {
+				gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
+				iterateKeywords(it, group);
+				if (types.length === 1 && types[0] === group.type && typeErrors) {
+					gen.else();
+					(0, dataType_2.reportTypeError)(it);
+				}
+				gen.endIf();
+			} else iterateKeywords(it, group);
+			if (!allErrors) gen.if((0, codegen_1._)`${names_1.default.errors} === ${errsCount || 0}`);
+		}
+	}
+	function iterateKeywords(it, group) {
+		const { gen, schema, opts: { useDefaults } } = it;
+		if (useDefaults) (0, defaults_1.assignDefaults)(it, group.type);
+		gen.block(() => {
+			for (const rule of group.rules) if ((0, applicability_1.shouldUseRule)(schema, rule)) keywordCode(it, rule.keyword, rule.definition, group.type);
+		});
+	}
+	function checkStrictTypes(it, types) {
+		if (it.schemaEnv.meta || !it.opts.strictTypes) return;
+		checkContextTypes(it, types);
+		if (!it.opts.allowUnionTypes) checkMultipleTypes(it, types);
+		checkKeywordTypes(it, it.dataTypes);
+	}
+	function checkContextTypes(it, types) {
+		if (!types.length) return;
+		if (!it.dataTypes.length) {
+			it.dataTypes = types;
+			return;
+		}
+		types.forEach((t) => {
+			if (!includesType(it.dataTypes, t)) strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
+		});
+		narrowSchemaTypes(it, types);
+	}
+	function checkMultipleTypes(it, ts) {
+		if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) strictTypesError(it, "use allowUnionTypes to allow union type keyword");
+	}
+	function checkKeywordTypes(it, ts) {
+		const rules = it.self.RULES.all;
+		for (const keyword in rules) {
+			const rule = rules[keyword];
+			if (typeof rule == "object" && (0, applicability_1.shouldUseRule)(it.schema, rule)) {
+				const { type } = rule.definition;
+				if (type.length && !type.some((t) => hasApplicableType(ts, t))) strictTypesError(it, `missing type "${type.join(",")}" for keyword "${keyword}"`);
+			}
+		}
+	}
+	function hasApplicableType(schTs, kwdT) {
+		return schTs.includes(kwdT) || kwdT === "number" && schTs.includes("integer");
+	}
+	function includesType(ts, t) {
+		return ts.includes(t) || t === "integer" && ts.includes("number");
+	}
+	function narrowSchemaTypes(it, withTypes) {
+		const ts = [];
+		for (const t of it.dataTypes) if (includesType(withTypes, t)) ts.push(t);
+		else if (withTypes.includes("integer") && t === "number") ts.push("integer");
+		it.dataTypes = ts;
+	}
+	function strictTypesError(it, msg) {
+		const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
+		msg += ` at "${schemaPath}" (strictTypes)`;
+		(0, util_1.checkStrictMode)(it, msg, it.opts.strictTypes);
+	}
+	var KeywordCxt = class {
+		constructor(it, def, keyword) {
+			(0, keyword_1.validateKeywordUsage)(it, def, keyword);
+			this.gen = it.gen;
+			this.allErrors = it.allErrors;
+			this.keyword = keyword;
+			this.data = it.data;
+			this.schema = it.schema[keyword];
+			this.$data = def.$data && it.opts.$data && this.schema && this.schema.$data;
+			this.schemaValue = (0, util_1.schemaRefOrVal)(it, this.schema, keyword, this.$data);
+			this.schemaType = def.schemaType;
+			this.parentSchema = it.schema;
+			this.params = {};
+			this.it = it;
+			this.def = def;
+			if (this.$data) this.schemaCode = it.gen.const("vSchema", getData(this.$data, it));
+			else {
+				this.schemaCode = this.schemaValue;
+				if (!(0, keyword_1.validSchemaType)(this.schema, def.schemaType, def.allowUndefined)) throw new Error(`${keyword} value must be ${JSON.stringify(def.schemaType)}`);
+			}
+			if ("code" in def ? def.trackErrors : def.errors !== false) this.errsCount = it.gen.const("_errs", names_1.default.errors);
+		}
+		result(condition, successAction, failAction) {
+			this.failResult((0, codegen_1.not)(condition), successAction, failAction);
+		}
+		failResult(condition, successAction, failAction) {
+			this.gen.if(condition);
+			if (failAction) failAction();
+			else this.error();
+			if (successAction) {
+				this.gen.else();
+				successAction();
+				if (this.allErrors) this.gen.endIf();
+			} else if (this.allErrors) this.gen.endIf();
+			else this.gen.else();
+		}
+		pass(condition, failAction) {
+			this.failResult((0, codegen_1.not)(condition), void 0, failAction);
+		}
+		fail(condition) {
+			if (condition === void 0) {
+				this.error();
+				if (!this.allErrors) this.gen.if(false);
+				return;
+			}
+			this.gen.if(condition);
+			this.error();
+			if (this.allErrors) this.gen.endIf();
+			else this.gen.else();
+		}
+		fail$data(condition) {
+			if (!this.$data) return this.fail(condition);
+			const { schemaCode } = this;
+			this.fail((0, codegen_1._)`${schemaCode} !== undefined && (${(0, codegen_1.or)(this.invalid$data(), condition)})`);
+		}
+		error(append, errorParams, errorPaths) {
+			if (errorParams) {
+				this.setParams(errorParams);
+				this._error(append, errorPaths);
+				this.setParams({});
+				return;
+			}
+			this._error(append, errorPaths);
+		}
+		_error(append, errorPaths) {
+			(append ? errors_1.reportExtraError : errors_1.reportError)(this, this.def.error, errorPaths);
+		}
+		$dataError() {
+			(0, errors_1.reportError)(this, this.def.$dataError || errors_1.keyword$DataError);
+		}
+		reset() {
+			if (this.errsCount === void 0) throw new Error("add \"trackErrors\" to keyword definition");
+			(0, errors_1.resetErrorsCount)(this.gen, this.errsCount);
+		}
+		ok(cond) {
+			if (!this.allErrors) this.gen.if(cond);
+		}
+		setParams(obj, assign) {
+			if (assign) Object.assign(this.params, obj);
+			else this.params = obj;
+		}
+		block$data(valid, codeBlock, $dataValid = codegen_1.nil) {
+			this.gen.block(() => {
+				this.check$data(valid, $dataValid);
+				codeBlock();
+			});
+		}
+		check$data(valid = codegen_1.nil, $dataValid = codegen_1.nil) {
+			if (!this.$data) return;
+			const { gen, schemaCode, schemaType, def } = this;
+			gen.if((0, codegen_1.or)((0, codegen_1._)`${schemaCode} === undefined`, $dataValid));
+			if (valid !== codegen_1.nil) gen.assign(valid, true);
+			if (schemaType.length || def.validateSchema) {
+				gen.elseIf(this.invalid$data());
+				this.$dataError();
+				if (valid !== codegen_1.nil) gen.assign(valid, false);
+			}
+			gen.else();
+		}
+		invalid$data() {
+			const { gen, schemaCode, schemaType, def, it } = this;
+			return (0, codegen_1.or)(wrong$DataType(), invalid$DataSchema());
+			function wrong$DataType() {
+				if (schemaType.length) {
+					/* istanbul ignore if */
+					if (!(schemaCode instanceof codegen_1.Name)) throw new Error("ajv implementation error");
+					const st = Array.isArray(schemaType) ? schemaType : [schemaType];
+					return (0, codegen_1._)`${(0, dataType_2.checkDataTypes)(st, schemaCode, it.opts.strictNumbers, dataType_2.DataType.Wrong)}`;
+				}
+				return codegen_1.nil;
+			}
+			function invalid$DataSchema() {
+				if (def.validateSchema) {
+					const validateSchemaRef = gen.scopeValue("validate$data", { ref: def.validateSchema });
+					return (0, codegen_1._)`!${validateSchemaRef}(${schemaCode})`;
+				}
+				return codegen_1.nil;
+			}
+		}
+		subschema(appl, valid) {
+			const subschema = (0, subschema_1.getSubschema)(this.it, appl);
+			(0, subschema_1.extendSubschemaData)(subschema, this.it, appl);
+			(0, subschema_1.extendSubschemaMode)(subschema, appl);
+			const nextContext = {
+				...this.it,
+				...subschema,
+				items: void 0,
+				props: void 0
+			};
+			subschemaCode(nextContext, valid);
+			return nextContext;
+		}
+		mergeEvaluated(schemaCxt, toName) {
+			const { it, gen } = this;
+			if (!it.opts.unevaluated) return;
+			if (it.props !== true && schemaCxt.props !== void 0) it.props = util_1.mergeEvaluated.props(gen, schemaCxt.props, it.props, toName);
+			if (it.items !== true && schemaCxt.items !== void 0) it.items = util_1.mergeEvaluated.items(gen, schemaCxt.items, it.items, toName);
+		}
+		mergeValidEvaluated(schemaCxt, valid) {
+			const { it, gen } = this;
+			if (it.opts.unevaluated && (it.props !== true || it.items !== true)) {
+				gen.if(valid, () => this.mergeEvaluated(schemaCxt, codegen_1.Name));
+				return true;
+			}
+		}
+	};
+	exports.KeywordCxt = KeywordCxt;
+	function keywordCode(it, keyword, def, ruleType) {
+		const cxt = new KeywordCxt(it, def, keyword);
+		if ("code" in def) def.code(cxt, ruleType);
+		else if (cxt.$data && def.validate) (0, keyword_1.funcKeywordCode)(cxt, def);
+		else if ("macro" in def) (0, keyword_1.macroKeywordCode)(cxt, def);
+		else if (def.compile || def.validate) (0, keyword_1.funcKeywordCode)(cxt, def);
+	}
+	const JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
+	const RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
+	function getData($data, { dataLevel, dataNames, dataPathArr }) {
+		let jsonPointer;
+		let data;
+		if ($data === "") return names_1.default.rootData;
+		if ($data[0] === "/") {
+			if (!JSON_POINTER.test($data)) throw new Error(`Invalid JSON-pointer: ${$data}`);
+			jsonPointer = $data;
+			data = names_1.default.rootData;
+		} else {
+			const matches = RELATIVE_JSON_POINTER.exec($data);
+			if (!matches) throw new Error(`Invalid JSON-pointer: ${$data}`);
+			const up = +matches[1];
+			jsonPointer = matches[2];
+			if (jsonPointer === "#") {
+				if (up >= dataLevel) throw new Error(errorMsg("property/index", up));
+				return dataPathArr[dataLevel - up];
+			}
+			if (up > dataLevel) throw new Error(errorMsg("data", up));
+			data = dataNames[dataLevel - up];
+			if (!jsonPointer) return data;
+		}
+		let expr = data;
+		const segments = jsonPointer.split("/");
+		for (const segment of segments) if (segment) {
+			data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
+			expr = (0, codegen_1._)`${expr} && ${data}`;
+		}
+		return expr;
+		function errorMsg(pointerType, up) {
+			return `Cannot access ${pointerType} ${up} levels up, current level is ${dataLevel}`;
+		}
+	}
+	exports.getData = getData;
+}));
+//#endregion
+export default require_validate();
+export { require_validate };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/keyword.js

@@ -0,0 +1,113 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../codegen/index.js";
+import { require_names } from "../names.js";
+import { require_errors } from "../errors.js";
+import { require_code } from "../../vocabularies/code.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/keyword.js
+var require_keyword = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.validateKeywordUsage = exports.validSchemaType = exports.funcKeywordCode = exports.macroKeywordCode = void 0;
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const code_1 = require_code();
+	const errors_1 = require_errors();
+	function macroKeywordCode(cxt, def) {
+		const { gen, keyword, schema, parentSchema, it } = cxt;
+		const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
+		const schemaRef = useKeyword(gen, keyword, macroSchema);
+		if (it.opts.validateSchema !== false) it.self.validateSchema(macroSchema, true);
+		const valid = gen.name("valid");
+		cxt.subschema({
+			schema: macroSchema,
+			schemaPath: codegen_1.nil,
+			errSchemaPath: `${it.errSchemaPath}/${keyword}`,
+			topSchemaRef: schemaRef,
+			compositeRule: true
+		}, valid);
+		cxt.pass(valid, () => cxt.error(true));
+	}
+	exports.macroKeywordCode = macroKeywordCode;
+	function funcKeywordCode(cxt, def) {
+		var _a;
+		const { gen, keyword, schema, parentSchema, $data, it } = cxt;
+		checkAsyncKeyword(it, def);
+		const validateRef = useKeyword(gen, keyword, !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate);
+		const valid = gen.let("valid");
+		cxt.block$data(valid, validateKeyword);
+		cxt.ok((_a = def.valid) !== null && _a !== void 0 ? _a : valid);
+		function validateKeyword() {
+			if (def.errors === false) {
+				assignValid();
+				if (def.modifying) modifyData(cxt);
+				reportErrs(() => cxt.error());
+			} else {
+				const ruleErrs = def.async ? validateAsync() : validateSync();
+				if (def.modifying) modifyData(cxt);
+				reportErrs(() => addErrs(cxt, ruleErrs));
+			}
+		}
+		function validateAsync() {
+			const ruleErrs = gen.let("ruleErrs", null);
+			gen.try(() => assignValid((0, codegen_1._)`await `), (e) => gen.assign(valid, false).if((0, codegen_1._)`${e} instanceof ${it.ValidationError}`, () => gen.assign(ruleErrs, (0, codegen_1._)`${e}.errors`), () => gen.throw(e)));
+			return ruleErrs;
+		}
+		function validateSync() {
+			const validateErrs = (0, codegen_1._)`${validateRef}.errors`;
+			gen.assign(validateErrs, null);
+			assignValid(codegen_1.nil);
+			return validateErrs;
+		}
+		function assignValid(_await = def.async ? (0, codegen_1._)`await ` : codegen_1.nil) {
+			const passCxt = it.opts.passContext ? names_1.default.this : names_1.default.self;
+			const passSchema = !("compile" in def && !$data || def.schema === false);
+			gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);
+		}
+		function reportErrs(errors) {
+			var _a;
+			gen.if((0, codegen_1.not)((_a = def.valid) !== null && _a !== void 0 ? _a : valid), errors);
+		}
+	}
+	exports.funcKeywordCode = funcKeywordCode;
+	function modifyData(cxt) {
+		const { gen, data, it } = cxt;
+		gen.if(it.parentData, () => gen.assign(data, (0, codegen_1._)`${it.parentData}[${it.parentDataProperty}]`));
+	}
+	function addErrs(cxt, errs) {
+		const { gen } = cxt;
+		gen.if((0, codegen_1._)`Array.isArray(${errs})`, () => {
+			gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`).assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
+			(0, errors_1.extendErrors)(cxt);
+		}, () => cxt.error());
+	}
+	function checkAsyncKeyword({ schemaEnv }, def) {
+		if (def.async && !schemaEnv.$async) throw new Error("async keyword in sync schema");
+	}
+	function useKeyword(gen, keyword, result) {
+		if (result === void 0) throw new Error(`keyword "${keyword}" failed to compile`);
+		return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : {
+			ref: result,
+			code: (0, codegen_1.stringify)(result)
+		});
+	}
+	function validSchemaType(schema, schemaType, allowUndefined = false) {
+		return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
+	}
+	exports.validSchemaType = validSchemaType;
+	function validateKeywordUsage({ schema, opts, self, errSchemaPath }, def, keyword) {
+		/* istanbul ignore if */
+		if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) throw new Error("ajv implementation error");
+		const deps = def.dependencies;
+		if (deps === null || deps === void 0 ? void 0 : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
+		if (def.validateSchema) {
+			if (!def.validateSchema(schema[keyword])) {
+				const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self.errorsText(def.validateSchema.errors);
+				if (opts.validateSchema === "log") self.logger.error(msg);
+				else throw new Error(msg);
+			}
+		}
+	}
+	exports.validateKeywordUsage = validateKeywordUsage;
+}));
+//#endregion
+export default require_keyword();
+export { require_keyword };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/subschema.js

@@ -0,0 +1,72 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../codegen/index.js";
+import { require_util } from "../util.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/subschema.js
+var require_subschema = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = void 0;
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
+		if (keyword !== void 0 && schema !== void 0) throw new Error("both \"keyword\" and \"schema\" passed, only one allowed");
+		if (keyword !== void 0) {
+			const sch = it.schema[keyword];
+			return schemaProp === void 0 ? {
+				schema: sch,
+				schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}`,
+				errSchemaPath: `${it.errSchemaPath}/${keyword}`
+			} : {
+				schema: sch[schemaProp],
+				schemaPath: (0, codegen_1._)`${it.schemaPath}${(0, codegen_1.getProperty)(keyword)}${(0, codegen_1.getProperty)(schemaProp)}`,
+				errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
+			};
+		}
+		if (schema !== void 0) {
+			if (schemaPath === void 0 || errSchemaPath === void 0 || topSchemaRef === void 0) throw new Error("\"schemaPath\", \"errSchemaPath\" and \"topSchemaRef\" are required with \"schema\"");
+			return {
+				schema,
+				schemaPath,
+				topSchemaRef,
+				errSchemaPath
+			};
+		}
+		throw new Error("either \"keyword\" or \"schema\" must be passed");
+	}
+	exports.getSubschema = getSubschema;
+	function extendSubschemaData(subschema, it, { dataProp, dataPropType: dpType, data, dataTypes, propertyName }) {
+		if (data !== void 0 && dataProp !== void 0) throw new Error("both \"data\" and \"dataProp\" passed, only one allowed");
+		const { gen } = it;
+		if (dataProp !== void 0) {
+			const { errorPath, dataPathArr, opts } = it;
+			dataContextProps(gen.let("data", (0, codegen_1._)`${it.data}${(0, codegen_1.getProperty)(dataProp)}`, true));
+			subschema.errorPath = (0, codegen_1.str)`${errorPath}${(0, util_1.getErrorPath)(dataProp, dpType, opts.jsPropertySyntax)}`;
+			subschema.parentDataProperty = (0, codegen_1._)`${dataProp}`;
+			subschema.dataPathArr = [...dataPathArr, subschema.parentDataProperty];
+		}
+		if (data !== void 0) {
+			dataContextProps(data instanceof codegen_1.Name ? data : gen.let("data", data, true));
+			if (propertyName !== void 0) subschema.propertyName = propertyName;
+		}
+		if (dataTypes) subschema.dataTypes = dataTypes;
+		function dataContextProps(_nextData) {
+			subschema.data = _nextData;
+			subschema.dataLevel = it.dataLevel + 1;
+			subschema.dataTypes = [];
+			it.definedProperties = /* @__PURE__ */ new Set();
+			subschema.parentData = it.data;
+			subschema.dataNames = [...it.dataNames, _nextData];
+		}
+	}
+	exports.extendSubschemaData = extendSubschemaData;
+	function extendSubschemaMode(subschema, { jtdDiscriminator, jtdMetadata, compositeRule, createErrors, allErrors }) {
+		if (compositeRule !== void 0) subschema.compositeRule = compositeRule;
+		if (createErrors !== void 0) subschema.createErrors = createErrors;
+		if (allErrors !== void 0) subschema.allErrors = allErrors;
+		subschema.jtdDiscriminator = jtdDiscriminator;
+		subschema.jtdMetadata = jtdMetadata;
+	}
+	exports.extendSubschemaMode = extendSubschemaMode;
+}));
+//#endregion
+export default require_subschema();
+export { require_subschema };