fumadocs-openapi 10.8.4 → 10.8.5

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js

@@ -0,0 +1,87 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_code } from "../code.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependencies.js
+var require_dependencies = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = void 0;
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const code_1 = require_code();
+	exports.error = {
+		message: ({ params: { property, depsCount, deps } }) => {
+			const property_ies = depsCount === 1 ? "property" : "properties";
+			return (0, codegen_1.str)`must have ${property_ies} ${deps} when property ${property} is present`;
+		},
+		params: ({ params: { property, depsCount, deps, missingProperty } }) => (0, codegen_1._)`{property: ${property},
+    missingProperty: ${missingProperty},
+    depsCount: ${depsCount},
+    deps: ${deps}}`
+	};
+	const def = {
+		keyword: "dependencies",
+		type: "object",
+		schemaType: "object",
+		error: exports.error,
+		code(cxt) {
+			const [propDeps, schDeps] = splitDependencies(cxt);
+			validatePropertyDeps(cxt, propDeps);
+			validateSchemaDeps(cxt, schDeps);
+		}
+	};
+	function splitDependencies({ schema }) {
+		const propertyDeps = {};
+		const schemaDeps = {};
+		for (const key in schema) {
+			if (key === "__proto__") continue;
+			const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
+			deps[key] = schema[key];
+		}
+		return [propertyDeps, schemaDeps];
+	}
+	function validatePropertyDeps(cxt, propertyDeps = cxt.schema) {
+		const { gen, data, it } = cxt;
+		if (Object.keys(propertyDeps).length === 0) return;
+		const missing = gen.let("missing");
+		for (const prop in propertyDeps) {
+			const deps = propertyDeps[prop];
+			if (deps.length === 0) continue;
+			const hasProperty = (0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties);
+			cxt.setParams({
+				property: prop,
+				depsCount: deps.length,
+				deps: deps.join(", ")
+			});
+			if (it.allErrors) gen.if(hasProperty, () => {
+				for (const depProp of deps) (0, code_1.checkReportMissingProp)(cxt, depProp);
+			});
+			else {
+				gen.if((0, codegen_1._)`${hasProperty} && (${(0, code_1.checkMissingProp)(cxt, deps, missing)})`);
+				(0, code_1.reportMissingProp)(cxt, missing);
+				gen.else();
+			}
+		}
+	}
+	exports.validatePropertyDeps = validatePropertyDeps;
+	function validateSchemaDeps(cxt, schemaDeps = cxt.schema) {
+		const { gen, data, keyword, it } = cxt;
+		const valid = gen.name("valid");
+		for (const prop in schemaDeps) {
+			if ((0, util_1.alwaysValidSchema)(it, schemaDeps[prop])) continue;
+			gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties), () => {
+				const schCxt = cxt.subschema({
+					keyword,
+					schemaProp: prop
+				}, valid);
+				cxt.mergeValidEvaluated(schCxt, valid);
+			}, () => gen.var(valid, true));
+			cxt.ok(valid);
+		}
+	}
+	exports.validateSchemaDeps = validateSchemaDeps;
+	exports.default = def;
+}));
+//#endregion
+export default require_dependencies();
+export { require_dependencies };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js

@@ -0,0 +1,16 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_dependencies } from "./dependencies.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
+var require_dependentSchemas = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dependencies_1 = require_dependencies();
+	exports.default = {
+		keyword: "dependentSchemas",
+		type: "object",
+		schemaType: "object",
+		code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
+	};
+}));
+//#endregion
+export default require_dependentSchemas();
+export { require_dependentSchemas };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/if.js

@@ -0,0 +1,62 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/if.js
+var require_if = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const def = {
+		keyword: "if",
+		schemaType: ["object", "boolean"],
+		trackErrors: true,
+		error: {
+			message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
+			params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
+		},
+		code(cxt) {
+			const { gen, parentSchema, it } = cxt;
+			if (parentSchema.then === void 0 && parentSchema.else === void 0) (0, util_1.checkStrictMode)(it, "\"if\" without \"then\" and \"else\" is ignored");
+			const hasThen = hasSchema(it, "then");
+			const hasElse = hasSchema(it, "else");
+			if (!hasThen && !hasElse) return;
+			const valid = gen.let("valid", true);
+			const schValid = gen.name("_valid");
+			validateIf();
+			cxt.reset();
+			if (hasThen && hasElse) {
+				const ifClause = gen.let("ifClause");
+				cxt.setParams({ ifClause });
+				gen.if(schValid, validateClause("then", ifClause), validateClause("else", ifClause));
+			} else if (hasThen) gen.if(schValid, validateClause("then"));
+			else gen.if((0, codegen_1.not)(schValid), validateClause("else"));
+			cxt.pass(valid, () => cxt.error(true));
+			function validateIf() {
+				const schCxt = cxt.subschema({
+					keyword: "if",
+					compositeRule: true,
+					createErrors: false,
+					allErrors: false
+				}, schValid);
+				cxt.mergeEvaluated(schCxt);
+			}
+			function validateClause(keyword, ifClause) {
+				return () => {
+					const schCxt = cxt.subschema({ keyword }, schValid);
+					gen.assign(valid, schValid);
+					cxt.mergeValidEvaluated(schCxt, valid);
+					if (ifClause) gen.assign(ifClause, (0, codegen_1._)`${keyword}`);
+					else cxt.setParams({ ifClause: keyword });
+				};
+			}
+		}
+	};
+	function hasSchema(it, keyword) {
+		const schema = it.schema[keyword];
+		return schema !== void 0 && !(0, util_1.alwaysValidSchema)(it, schema);
+	}
+	exports.default = def;
+}));
+//#endregion
+export default require_if();
+export { require_if };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/index.js

@@ -0,0 +1,60 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_additionalItems } from "./additionalItems.js";
+import { require_items } from "./items.js";
+import { require_prefixItems } from "./prefixItems.js";
+import { require_items2020 } from "./items2020.js";
+import { require_contains } from "./contains.js";
+import { require_dependencies } from "./dependencies.js";
+import { require_propertyNames } from "./propertyNames.js";
+import { require_additionalProperties } from "./additionalProperties.js";
+import { require_properties } from "./properties.js";
+import { require_patternProperties } from "./patternProperties.js";
+import { require_not } from "./not.js";
+import { require_anyOf } from "./anyOf.js";
+import { require_oneOf } from "./oneOf.js";
+import { require_allOf } from "./allOf.js";
+import { require_if } from "./if.js";
+import { require_thenElse } from "./thenElse.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/index.js
+var require_applicator = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const additionalItems_1 = require_additionalItems();
+	const prefixItems_1 = require_prefixItems();
+	const items_1 = require_items();
+	const items2020_1 = require_items2020();
+	const contains_1 = require_contains();
+	const dependencies_1 = require_dependencies();
+	const propertyNames_1 = require_propertyNames();
+	const additionalProperties_1 = require_additionalProperties();
+	const properties_1 = require_properties();
+	const patternProperties_1 = require_patternProperties();
+	const not_1 = require_not();
+	const anyOf_1 = require_anyOf();
+	const oneOf_1 = require_oneOf();
+	const allOf_1 = require_allOf();
+	const if_1 = require_if();
+	const thenElse_1 = require_thenElse();
+	function getApplicator(draft2020 = false) {
+		const applicator = [
+			not_1.default,
+			anyOf_1.default,
+			oneOf_1.default,
+			allOf_1.default,
+			if_1.default,
+			thenElse_1.default,
+			propertyNames_1.default,
+			additionalProperties_1.default,
+			dependencies_1.default,
+			properties_1.default,
+			patternProperties_1.default
+		];
+		if (draft2020) applicator.push(prefixItems_1.default, items2020_1.default);
+		else applicator.push(additionalItems_1.default, items_1.default);
+		applicator.push(contains_1.default);
+		return applicator;
+	}
+	exports.default = getApplicator;
+}));
+//#endregion
+export default require_applicator();
+export { require_applicator };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items.js

@@ -0,0 +1,59 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_code } from "../code.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items.js
+var require_items = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.validateTuple = void 0;
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const code_1 = require_code();
+	const def = {
+		keyword: "items",
+		type: "array",
+		schemaType: [
+			"object",
+			"array",
+			"boolean"
+		],
+		before: "uniqueItems",
+		code(cxt) {
+			const { schema, it } = cxt;
+			if (Array.isArray(schema)) return validateTuple(cxt, "additionalItems", schema);
+			it.items = true;
+			if ((0, util_1.alwaysValidSchema)(it, schema)) return;
+			cxt.ok((0, code_1.validateArray)(cxt));
+		}
+	};
+	function validateTuple(cxt, extraItems, schArr = cxt.schema) {
+		const { gen, parentSchema, data, keyword, it } = cxt;
+		checkStrictTuple(parentSchema);
+		if (it.opts.unevaluated && schArr.length && it.items !== true) it.items = util_1.mergeEvaluated.items(gen, schArr.length, it.items);
+		const valid = gen.name("valid");
+		const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+		schArr.forEach((sch, i) => {
+			if ((0, util_1.alwaysValidSchema)(it, sch)) return;
+			gen.if((0, codegen_1._)`${len} > ${i}`, () => cxt.subschema({
+				keyword,
+				schemaProp: i,
+				dataProp: i
+			}, valid));
+			cxt.ok(valid);
+		});
+		function checkStrictTuple(sch) {
+			const { opts, errSchemaPath } = it;
+			const l = schArr.length;
+			const fullTuple = l === sch.minItems && (l === sch.maxItems || sch[extraItems] === false);
+			if (opts.strictTuples && !fullTuple) {
+				const msg = `"${keyword}" is ${l}-tuple, but minItems or maxItems/${extraItems} are not specified or different at path "${errSchemaPath}"`;
+				(0, util_1.checkStrictMode)(it, msg, opts.strictTuples);
+			}
+		}
+	}
+	exports.validateTuple = validateTuple;
+	exports.default = def;
+}));
+//#endregion
+export default require_items();
+export { require_items };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js

@@ -0,0 +1,34 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_code } from "../code.js";
+import { require_additionalItems } from "./additionalItems.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/items2020.js
+var require_items2020 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const code_1 = require_code();
+	const additionalItems_1 = require_additionalItems();
+	exports.default = {
+		keyword: "items",
+		type: "array",
+		schemaType: ["object", "boolean"],
+		before: "uniqueItems",
+		error: {
+			message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
+			params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
+		},
+		code(cxt) {
+			const { schema, parentSchema, it } = cxt;
+			const { prefixItems } = parentSchema;
+			it.items = true;
+			if ((0, util_1.alwaysValidSchema)(it, schema)) return;
+			if (prefixItems) (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
+			else cxt.ok((0, code_1.validateArray)(cxt));
+		}
+	};
+}));
+//#endregion
+export default require_items2020();
+export { require_items2020 };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/not.js

@@ -0,0 +1,31 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_util } from "../../compile/util.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/not.js
+var require_not = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "not",
+		schemaType: ["object", "boolean"],
+		trackErrors: true,
+		code(cxt) {
+			const { gen, schema, it } = cxt;
+			if ((0, util_1.alwaysValidSchema)(it, schema)) {
+				cxt.fail();
+				return;
+			}
+			const valid = gen.name("valid");
+			cxt.subschema({
+				keyword: "not",
+				compositeRule: true,
+				createErrors: false,
+				allErrors: false
+			}, valid);
+			cxt.failResult(valid, () => cxt.reset(), () => cxt.error());
+		},
+		error: { message: "must NOT be valid" }
+	};
+}));
+//#endregion
+export default require_not();
+export { require_not };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js

@@ -0,0 +1,51 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/oneOf.js
+var require_oneOf = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "oneOf",
+		schemaType: "array",
+		trackErrors: true,
+		error: {
+			message: "must match exactly one schema in oneOf",
+			params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
+		},
+		code(cxt) {
+			const { gen, schema, parentSchema, it } = cxt;
+			/* istanbul ignore if */
+			if (!Array.isArray(schema)) throw new Error("ajv implementation error");
+			if (it.opts.discriminator && parentSchema.discriminator) return;
+			const schArr = schema;
+			const valid = gen.let("valid", false);
+			const passing = gen.let("passing", null);
+			const schValid = gen.name("_valid");
+			cxt.setParams({ passing });
+			gen.block(validateOneOf);
+			cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
+			function validateOneOf() {
+				schArr.forEach((sch, i) => {
+					let schCxt;
+					if ((0, util_1.alwaysValidSchema)(it, sch)) gen.var(schValid, true);
+					else schCxt = cxt.subschema({
+						keyword: "oneOf",
+						schemaProp: i,
+						compositeRule: true
+					}, schValid);
+					if (i > 0) gen.if((0, codegen_1._)`${schValid} && ${valid}`).assign(valid, false).assign(passing, (0, codegen_1._)`[${passing}, ${i}]`).else();
+					gen.if(schValid, () => {
+						gen.assign(valid, true);
+						gen.assign(passing, i);
+						if (schCxt) cxt.mergeEvaluated(schCxt, codegen_1.Name);
+					});
+				});
+			}
+		}
+	};
+}));
+//#endregion
+export default require_oneOf();
+export { require_oneOf };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js

@@ -0,0 +1,61 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_code } from "../code.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/patternProperties.js
+var require_patternProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const code_1 = require_code();
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const util_2 = require_util();
+	exports.default = {
+		keyword: "patternProperties",
+		type: "object",
+		schemaType: "object",
+		code(cxt) {
+			const { gen, schema, data, parentSchema, it } = cxt;
+			const { opts } = it;
+			const patterns = (0, code_1.allSchemaProperties)(schema);
+			const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
+			if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) return;
+			const checkProperties = opts.strictSchema && !opts.allowMatchingProperties && parentSchema.properties;
+			const valid = gen.name("valid");
+			if (it.props !== true && !(it.props instanceof codegen_1.Name)) it.props = (0, util_2.evaluatedPropsToName)(gen, it.props);
+			const { props } = it;
+			validatePatternProperties();
+			function validatePatternProperties() {
+				for (const pat of patterns) {
+					if (checkProperties) checkMatchingProperties(pat);
+					if (it.allErrors) validateProperties(pat);
+					else {
+						gen.var(valid, true);
+						validateProperties(pat);
+						gen.if(valid);
+					}
+				}
+			}
+			function checkMatchingProperties(pat) {
+				for (const prop in checkProperties) if (new RegExp(pat).test(prop)) (0, util_1.checkStrictMode)(it, `property ${prop} matches pattern ${pat} (use allowMatchingProperties)`);
+			}
+			function validateProperties(pat) {
+				gen.forIn("key", data, (key) => {
+					gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
+						const alwaysValid = alwaysValidPatterns.includes(pat);
+						if (!alwaysValid) cxt.subschema({
+							keyword: "patternProperties",
+							schemaProp: pat,
+							dataProp: key,
+							dataPropType: util_2.Type.Str
+						}, valid);
+						if (it.opts.unevaluated && props !== true) gen.assign((0, codegen_1._)`${props}[${key}]`, true);
+						else if (!alwaysValid && !it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
+					});
+				});
+			}
+		}
+	};
+}));
+//#endregion
+export default require_patternProperties();
+export { require_patternProperties };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js

@@ -0,0 +1,17 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_items } from "./items.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/prefixItems.js
+var require_prefixItems = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const items_1 = require_items();
+	exports.default = {
+		keyword: "prefixItems",
+		type: "array",
+		schemaType: ["array"],
+		before: "uniqueItems",
+		code: (cxt) => (0, items_1.validateTuple)(cxt, "items")
+	};
+}));
+//#endregion
+export default require_prefixItems();
+export { require_prefixItems };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/properties.js

@@ -0,0 +1,52 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_util } from "../../compile/util.js";
+import { require_code } from "../code.js";
+import { require_validate } from "../../compile/validate/index.js";
+import { require_additionalProperties } from "./additionalProperties.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/properties.js
+var require_properties = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const validate_1 = require_validate();
+	const code_1 = require_code();
+	const util_1 = require_util();
+	const additionalProperties_1 = require_additionalProperties();
+	exports.default = {
+		keyword: "properties",
+		type: "object",
+		schemaType: "object",
+		code(cxt) {
+			const { gen, schema, parentSchema, data, it } = cxt;
+			if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === void 0) additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
+			const allProps = (0, code_1.allSchemaProperties)(schema);
+			for (const prop of allProps) it.definedProperties.add(prop);
+			if (it.opts.unevaluated && allProps.length && it.props !== true) it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
+			const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
+			if (properties.length === 0) return;
+			const valid = gen.name("valid");
+			for (const prop of properties) {
+				if (hasDefault(prop)) applyPropertySchema(prop);
+				else {
+					gen.if((0, code_1.propertyInData)(gen, data, prop, it.opts.ownProperties));
+					applyPropertySchema(prop);
+					if (!it.allErrors) gen.else().var(valid, true);
+					gen.endIf();
+				}
+				cxt.it.definedProperties.add(prop);
+				cxt.ok(valid);
+			}
+			function hasDefault(prop) {
+				return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== void 0;
+			}
+			function applyPropertySchema(prop) {
+				cxt.subschema({
+					keyword: "properties",
+					schemaProp: prop,
+					dataProp: prop
+				}, valid);
+			}
+		}
+	};
+}));
+//#endregion
+export default require_properties();
+export { require_properties };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/propertyNames.js
+var require_propertyNames = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "propertyNames",
+		type: "object",
+		schemaType: ["object", "boolean"],
+		error: {
+			message: "property name must be valid",
+			params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
+		},
+		code(cxt) {
+			const { gen, schema, data, it } = cxt;
+			if ((0, util_1.alwaysValidSchema)(it, schema)) return;
+			const valid = gen.name("valid");
+			gen.forIn("key", data, (key) => {
+				cxt.setParams({ propertyName: key });
+				cxt.subschema({
+					keyword: "propertyNames",
+					data: key,
+					dataTypes: ["string"],
+					propertyName: key,
+					compositeRule: true
+				}, valid);
+				gen.if((0, codegen_1.not)(valid), () => {
+					cxt.error(true);
+					if (!it.allErrors) gen.break();
+				});
+			});
+			cxt.ok(valid);
+		}
+	};
+}));
+//#endregion
+export default require_propertyNames();
+export { require_propertyNames };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js

@@ -0,0 +1,17 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_util } from "../../compile/util.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
+var require_thenElse = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const util_1 = require_util();
+	exports.default = {
+		keyword: ["then", "else"],
+		schemaType: ["object", "boolean"],
+		code({ keyword, parentSchema, it }) {
+			if (parentSchema.if === void 0) (0, util_1.checkStrictMode)(it, `"${keyword}" without "if" is ignored`);
+		}
+	};
+}));
+//#endregion
+export default require_thenElse();
+export { require_thenElse };