fumadocs-openapi 10.8.3 → 10.8.5

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/format.js

@@ -0,0 +1,92 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/format.js
+var require_format = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	exports.default = {
+		keyword: "format",
+		type: ["number", "string"],
+		schemaType: "string",
+		$data: true,
+		error: {
+			message: ({ schemaCode }) => (0, codegen_1.str)`must match format "${schemaCode}"`,
+			params: ({ schemaCode }) => (0, codegen_1._)`{format: ${schemaCode}}`
+		},
+		code(cxt, ruleType) {
+			const { gen, data, $data, schema, schemaCode, it } = cxt;
+			const { opts, errSchemaPath, schemaEnv, self } = it;
+			if (!opts.validateFormats) return;
+			if ($data) validate$DataFormat();
+			else validateFormat();
+			function validate$DataFormat() {
+				const fmts = gen.scopeValue("formats", {
+					ref: self.formats,
+					code: opts.code.formats
+				});
+				const fDef = gen.const("fDef", (0, codegen_1._)`${fmts}[${schemaCode}]`);
+				const fType = gen.let("fType");
+				const format = gen.let("format");
+				gen.if((0, codegen_1._)`typeof ${fDef} == "object" && !(${fDef} instanceof RegExp)`, () => gen.assign(fType, (0, codegen_1._)`${fDef}.type || "string"`).assign(format, (0, codegen_1._)`${fDef}.validate`), () => gen.assign(fType, (0, codegen_1._)`"string"`).assign(format, fDef));
+				cxt.fail$data((0, codegen_1.or)(unknownFmt(), invalidFmt()));
+				function unknownFmt() {
+					if (opts.strictSchema === false) return codegen_1.nil;
+					return (0, codegen_1._)`${schemaCode} && !${format}`;
+				}
+				function invalidFmt() {
+					const callFormat = schemaEnv.$async ? (0, codegen_1._)`(${fDef}.async ? await ${format}(${data}) : ${format}(${data}))` : (0, codegen_1._)`${format}(${data})`;
+					const validData = (0, codegen_1._)`(typeof ${format} == "function" ? ${callFormat} : ${format}.test(${data}))`;
+					return (0, codegen_1._)`${format} && ${format} !== true && ${fType} === ${ruleType} && !${validData}`;
+				}
+			}
+			function validateFormat() {
+				const formatDef = self.formats[schema];
+				if (!formatDef) {
+					unknownFormat();
+					return;
+				}
+				if (formatDef === true) return;
+				const [fmtType, format, fmtRef] = getFormat(formatDef);
+				if (fmtType === ruleType) cxt.pass(validCondition());
+				function unknownFormat() {
+					if (opts.strictSchema === false) {
+						self.logger.warn(unknownMsg());
+						return;
+					}
+					throw new Error(unknownMsg());
+					function unknownMsg() {
+						return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
+					}
+				}
+				function getFormat(fmtDef) {
+					const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : void 0;
+					const fmt = gen.scopeValue("formats", {
+						key: schema,
+						ref: fmtDef,
+						code
+					});
+					if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) return [
+						fmtDef.type || "string",
+						fmtDef.validate,
+						(0, codegen_1._)`${fmt}.validate`
+					];
+					return [
+						"string",
+						fmtDef,
+						fmt
+					];
+				}
+				function validCondition() {
+					if (typeof formatDef == "object" && !(formatDef instanceof RegExp) && formatDef.async) {
+						if (!schemaEnv.$async) throw new Error("async format in sync schema");
+						return (0, codegen_1._)`await ${fmtRef}(${data})`;
+					}
+					return typeof format == "function" ? (0, codegen_1._)`${fmtRef}(${data})` : (0, codegen_1._)`${fmtRef}.test(${data})`;
+				}
+			}
+		}
+	};
+}));
+//#endregion
+export default require_format();
+export { require_format };

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

@@ -0,0 +1,10 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_format as require_format$1 } from "./format.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/format/index.js
+var require_format = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = [require_format$1().default];
+}));
+//#endregion
+export default require_format();
+export { require_format };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/metadata.js

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/metadata.js
+var require_metadata = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.contentVocabulary = exports.metadataVocabulary = void 0;
+	exports.metadataVocabulary = [
+		"title",
+		"description",
+		"default",
+		"deprecated",
+		"readOnly",
+		"writeOnly",
+		"examples"
+	];
+	exports.contentVocabulary = [
+		"contentMediaType",
+		"contentEncoding",
+		"contentSchema"
+	];
+}));
+//#endregion
+export default require_metadata();
+export { require_metadata };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/next.js

@@ -0,0 +1,19 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_dependentRequired } from "./validation/dependentRequired.js";
+import { require_dependentSchemas } from "./applicator/dependentSchemas.js";
+import { require_limitContains } from "./validation/limitContains.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/next.js
+var require_next = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dependentRequired_1 = require_dependentRequired();
+	const dependentSchemas_1 = require_dependentSchemas();
+	const limitContains_1 = require_limitContains();
+	exports.default = [
+		dependentRequired_1.default,
+		dependentSchemas_1.default,
+		limitContains_1.default
+	];
+}));
+//#endregion
+export default require_next();
+export { require_next };

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

@@ -0,0 +1,13 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_unevaluatedProperties } from "./unevaluatedProperties.js";
+import { require_unevaluatedItems } from "./unevaluatedItems.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/unevaluated/index.js
+var require_unevaluated = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const unevaluatedProperties_1 = require_unevaluatedProperties();
+	const unevaluatedItems_1 = require_unevaluatedItems();
+	exports.default = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
+}));
+//#endregion
+export default require_unevaluated();
+export { require_unevaluated };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js

@@ -0,0 +1,46 @@
+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/unevaluated/unevaluatedItems.js
+var require_unevaluatedItems = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "unevaluatedItems",
+		type: "array",
+		schemaType: ["boolean", "object"],
+		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 { gen, schema, data, it } = cxt;
+			const items = it.items || 0;
+			if (items === true) return;
+			const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+			if (schema === false) {
+				cxt.setParams({ len: items });
+				cxt.fail((0, codegen_1._)`${len} > ${items}`);
+			} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+				const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
+				gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
+				cxt.ok(valid);
+			}
+			it.items = true;
+			function validateItems(valid, from) {
+				gen.forRange("i", from, len, (i) => {
+					cxt.subschema({
+						keyword: "unevaluatedItems",
+						dataProp: i,
+						dataPropType: util_1.Type.Num
+					}, valid);
+					if (!it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
+				});
+			}
+		}
+	};
+}));
+//#endregion
+export default require_unevaluatedItems();
+export { require_unevaluatedItems };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.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_names } from "../../compile/names.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
+var require_unevaluatedProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const names_1 = require_names();
+	exports.default = {
+		keyword: "unevaluatedProperties",
+		type: "object",
+		schemaType: ["boolean", "object"],
+		trackErrors: true,
+		error: {
+			message: "must NOT have unevaluated properties",
+			params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
+		},
+		code(cxt) {
+			const { gen, schema, data, errsCount, it } = cxt;
+			/* istanbul ignore if */
+			if (!errsCount) throw new Error("ajv implementation error");
+			const { allErrors, props } = it;
+			if (props instanceof codegen_1.Name) gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
+			else if (props !== true) gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
+			it.props = true;
+			cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+			function unevaluatedPropCode(key) {
+				if (schema === false) {
+					cxt.setParams({ unevaluatedProperty: key });
+					cxt.error();
+					if (!allErrors) gen.break();
+					return;
+				}
+				if (!(0, util_1.alwaysValidSchema)(it, schema)) {
+					const valid = gen.name("valid");
+					cxt.subschema({
+						keyword: "unevaluatedProperties",
+						dataProp: key,
+						dataPropType: util_1.Type.Str
+					}, valid);
+					if (!allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
+				}
+			}
+			function unevaluatedDynamic(evaluatedProps, key) {
+				return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
+			}
+			function unevaluatedStatic(evaluatedProps, key) {
+				const ps = [];
+				for (const p in evaluatedProps) if (evaluatedProps[p] === true) ps.push((0, codegen_1._)`${key} !== ${p}`);
+				return (0, codegen_1.and)(...ps);
+			}
+		}
+	};
+}));
+//#endregion
+export default require_unevaluatedProperties();
+export { require_unevaluatedProperties };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/const.js

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_equal } from "../../runtime/equal.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/const.js
+var require_const = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const equal_1 = require_equal();
+	exports.default = {
+		keyword: "const",
+		$data: true,
+		error: {
+			message: "must be equal to constant",
+			params: ({ schemaCode }) => (0, codegen_1._)`{allowedValue: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { gen, data, $data, schemaCode, schema } = cxt;
+			if ($data || schema && typeof schema == "object") cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
+			else cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
+		}
+	};
+}));
+//#endregion
+export default require_const();
+export { require_const };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/dependentRequired.js

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

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/enum.js

@@ -0,0 +1,49 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_equal } from "../../runtime/equal.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/enum.js
+var require_enum = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const equal_1 = require_equal();
+	exports.default = {
+		keyword: "enum",
+		schemaType: "array",
+		$data: true,
+		error: {
+			message: "must be equal to one of the allowed values",
+			params: ({ schemaCode }) => (0, codegen_1._)`{allowedValues: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { gen, data, $data, schema, schemaCode, it } = cxt;
+			if (!$data && schema.length === 0) throw new Error("enum must have non-empty array");
+			const useLoop = schema.length >= it.opts.loopEnum;
+			let eql;
+			const getEql = () => eql !== null && eql !== void 0 ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
+			let valid;
+			if (useLoop || $data) {
+				valid = gen.let("valid");
+				cxt.block$data(valid, loopEnum);
+			} else {
+				/* istanbul ignore if */
+				if (!Array.isArray(schema)) throw new Error("ajv implementation error");
+				const vSchema = gen.const("vSchema", schemaCode);
+				valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
+			}
+			cxt.pass(valid);
+			function loopEnum() {
+				gen.assign(valid, false);
+				gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
+			}
+			function equalCode(vSchema, i) {
+				const sch = schema[i];
+				return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
+			}
+		}
+	};
+}));
+//#endregion
+export default require_enum();
+export { require_enum };

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

@@ -0,0 +1,48 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_limitNumber } from "./limitNumber.js";
+import { require_multipleOf } from "./multipleOf.js";
+import { require_limitLength } from "./limitLength.js";
+import { require_pattern } from "./pattern.js";
+import { require_limitProperties } from "./limitProperties.js";
+import { require_required } from "./required.js";
+import { require_limitItems } from "./limitItems.js";
+import { require_uniqueItems } from "./uniqueItems.js";
+import { require_const } from "./const.js";
+import { require_enum } from "./enum.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/index.js
+var require_validation = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const limitNumber_1 = require_limitNumber();
+	const multipleOf_1 = require_multipleOf();
+	const limitLength_1 = require_limitLength();
+	const pattern_1 = require_pattern();
+	const limitProperties_1 = require_limitProperties();
+	const required_1 = require_required();
+	const limitItems_1 = require_limitItems();
+	const uniqueItems_1 = require_uniqueItems();
+	const const_1 = require_const();
+	const enum_1 = require_enum();
+	exports.default = [
+		limitNumber_1.default,
+		multipleOf_1.default,
+		limitLength_1.default,
+		pattern_1.default,
+		limitProperties_1.default,
+		required_1.default,
+		limitItems_1.default,
+		uniqueItems_1.default,
+		{
+			keyword: "type",
+			schemaType: ["string", "array"]
+		},
+		{
+			keyword: "nullable",
+			schemaType: "boolean"
+		},
+		const_1.default,
+		enum_1.default
+	];
+}));
+//#endregion
+export default require_validation();
+export { require_validation };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitContains.js

@@ -0,0 +1,18 @@
+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/validation/limitContains.js
+var require_limitContains = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const util_1 = require_util();
+	exports.default = {
+		keyword: ["maxContains", "minContains"],
+		type: "array",
+		schemaType: "number",
+		code({ keyword, parentSchema, it }) {
+			if (parentSchema.contains === void 0) (0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
+		}
+	};
+}));
+//#endregion
+export default require_limitContains();
+export { require_limitContains };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js

@@ -0,0 +1,28 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitItems.js
+var require_limitItems = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	exports.default = {
+		keyword: ["maxItems", "minItems"],
+		type: "array",
+		schemaType: "number",
+		$data: true,
+		error: {
+			message({ keyword, schemaCode }) {
+				const comp = keyword === "maxItems" ? "more" : "fewer";
+				return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} items`;
+			},
+			params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { keyword, data, schemaCode } = cxt;
+			const op = keyword === "maxItems" ? codegen_1.operators.GT : codegen_1.operators.LT;
+			cxt.fail$data((0, codegen_1._)`${data}.length ${op} ${schemaCode}`);
+		}
+	};
+}));
+//#endregion
+export default require_limitItems();
+export { require_limitItems };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js

@@ -0,0 +1,33 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_ucs2length } from "../../runtime/ucs2length.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitLength.js
+var require_limitLength = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const ucs2length_1 = require_ucs2length();
+	exports.default = {
+		keyword: ["maxLength", "minLength"],
+		type: "string",
+		schemaType: "number",
+		$data: true,
+		error: {
+			message({ keyword, schemaCode }) {
+				const comp = keyword === "maxLength" ? "more" : "fewer";
+				return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} characters`;
+			},
+			params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { keyword, data, schemaCode, it } = cxt;
+			const op = keyword === "maxLength" ? codegen_1.operators.GT : codegen_1.operators.LT;
+			const len = it.opts.unicode === false ? (0, codegen_1._)`${data}.length` : (0, codegen_1._)`${(0, util_1.useFunc)(cxt.gen, ucs2length_1.default)}(${data})`;
+			cxt.fail$data((0, codegen_1._)`${len} ${op} ${schemaCode}`);
+		}
+	};
+}));
+//#endregion
+export default require_limitLength();
+export { require_limitLength };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js

@@ -0,0 +1,47 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitNumber.js
+var require_limitNumber = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const ops = codegen_1.operators;
+	const KWDs = {
+		maximum: {
+			okStr: "<=",
+			ok: ops.LTE,
+			fail: ops.GT
+		},
+		minimum: {
+			okStr: ">=",
+			ok: ops.GTE,
+			fail: ops.LT
+		},
+		exclusiveMaximum: {
+			okStr: "<",
+			ok: ops.LT,
+			fail: ops.GTE
+		},
+		exclusiveMinimum: {
+			okStr: ">",
+			ok: ops.GT,
+			fail: ops.LTE
+		}
+	};
+	exports.default = {
+		keyword: Object.keys(KWDs),
+		type: "number",
+		schemaType: "number",
+		$data: true,
+		error: {
+			message: ({ keyword, schemaCode }) => (0, codegen_1.str)`must be ${KWDs[keyword].okStr} ${schemaCode}`,
+			params: ({ keyword, schemaCode }) => (0, codegen_1._)`{comparison: ${KWDs[keyword].okStr}, limit: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { keyword, data, schemaCode } = cxt;
+			cxt.fail$data((0, codegen_1._)`${data} ${KWDs[keyword].fail} ${schemaCode} || isNaN(${data})`);
+		}
+	};
+}));
+//#endregion
+export default require_limitNumber();
+export { require_limitNumber };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js

@@ -0,0 +1,28 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/limitProperties.js
+var require_limitProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	exports.default = {
+		keyword: ["maxProperties", "minProperties"],
+		type: "object",
+		schemaType: "number",
+		$data: true,
+		error: {
+			message({ keyword, schemaCode }) {
+				const comp = keyword === "maxProperties" ? "more" : "fewer";
+				return (0, codegen_1.str)`must NOT have ${comp} than ${schemaCode} properties`;
+			},
+			params: ({ schemaCode }) => (0, codegen_1._)`{limit: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { keyword, data, schemaCode } = cxt;
+			const op = keyword === "maxProperties" ? codegen_1.operators.GT : codegen_1.operators.LT;
+			cxt.fail$data((0, codegen_1._)`Object.keys(${data}).length ${op} ${schemaCode}`);
+		}
+	};
+}));
+//#endregion
+export default require_limitProperties();
+export { require_limitProperties };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/multipleOf.js
+var require_multipleOf = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	exports.default = {
+		keyword: "multipleOf",
+		type: "number",
+		schemaType: "number",
+		$data: true,
+		error: {
+			message: ({ schemaCode }) => (0, codegen_1.str)`must be multiple of ${schemaCode}`,
+			params: ({ schemaCode }) => (0, codegen_1._)`{multipleOf: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { gen, data, schemaCode, it } = cxt;
+			const prec = it.opts.multipleOfPrecision;
+			const res = gen.let("res");
+			const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
+			cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
+		}
+	};
+}));
+//#endregion
+export default require_multipleOf();
+export { require_multipleOf };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/validation/pattern.js

@@ -0,0 +1,38 @@
+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/validation/pattern.js
+var require_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const code_1 = require_code();
+	const util_1 = require_util();
+	const codegen_1 = require_codegen();
+	exports.default = {
+		keyword: "pattern",
+		type: "string",
+		schemaType: "string",
+		$data: true,
+		error: {
+			message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
+			params: ({ schemaCode }) => (0, codegen_1._)`{pattern: ${schemaCode}}`
+		},
+		code(cxt) {
+			const { gen, data, $data, schema, schemaCode, it } = cxt;
+			const u = it.opts.unicodeRegExp ? "u" : "";
+			if ($data) {
+				const { regExp } = it.opts.code;
+				const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+				const valid = gen.let("valid");
+				gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+				cxt.fail$data((0, codegen_1._)`!${valid}`);
+			} else {
+				const regExp = (0, code_1.usePattern)(cxt, schema);
+				cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+			}
+		}
+	};
+}));
+//#endregion
+export default require_pattern();
+export { require_pattern };