fumadocs-openapi 10.8.4 → 10.8.5

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.js

@@ -0,0 +1,20 @@
+import { __commonJSMin } from "../../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
+var require_content = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/content",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/content": true },
+		"$dynamicAnchor": "meta",
+		"title": "Content vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"contentEncoding": { "type": "string" },
+			"contentMediaType": { "type": "string" },
+			"contentSchema": { "$dynamicRef": "#meta" }
+		}
+	};
+}));
+//#endregion
+export default require_content();
+export { require_content };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.js

@@ -0,0 +1,51 @@
+import { __commonJSMin } from "../../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
+var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/core",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/core": true },
+		"$dynamicAnchor": "meta",
+		"title": "Core vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"$id": {
+				"$ref": "#/$defs/uriReferenceString",
+				"$comment": "Non-empty fragments not allowed.",
+				"pattern": "^[^#]*#?$"
+			},
+			"$schema": { "$ref": "#/$defs/uriString" },
+			"$ref": { "$ref": "#/$defs/uriReferenceString" },
+			"$anchor": { "$ref": "#/$defs/anchorString" },
+			"$dynamicRef": { "$ref": "#/$defs/uriReferenceString" },
+			"$dynamicAnchor": { "$ref": "#/$defs/anchorString" },
+			"$vocabulary": {
+				"type": "object",
+				"propertyNames": { "$ref": "#/$defs/uriString" },
+				"additionalProperties": { "type": "boolean" }
+			},
+			"$comment": { "type": "string" },
+			"$defs": {
+				"type": "object",
+				"additionalProperties": { "$dynamicRef": "#meta" }
+			}
+		},
+		"$defs": {
+			"anchorString": {
+				"type": "string",
+				"pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+			},
+			"uriString": {
+				"type": "string",
+				"format": "uri"
+			},
+			"uriReferenceString": {
+				"type": "string",
+				"format": "uri-reference"
+			}
+		}
+	};
+}));
+//#endregion
+export default require_core();
+export { require_core };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.js

@@ -0,0 +1,16 @@
+import { __commonJSMin } from "../../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
+var require_format_annotation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/format-annotation": true },
+		"$dynamicAnchor": "meta",
+		"title": "Format vocabulary meta-schema for annotation results",
+		"type": ["object", "boolean"],
+		"properties": { "format": { "type": "string" } }
+	};
+}));
+//#endregion
+export default require_format_annotation();
+export { require_format_annotation };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.js

@@ -0,0 +1,36 @@
+import { __commonJSMin } from "../../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
+var require_meta_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/meta-data": true },
+		"$dynamicAnchor": "meta",
+		"title": "Meta-data vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"title": { "type": "string" },
+			"description": { "type": "string" },
+			"default": true,
+			"deprecated": {
+				"type": "boolean",
+				"default": false
+			},
+			"readOnly": {
+				"type": "boolean",
+				"default": false
+			},
+			"writeOnly": {
+				"type": "boolean",
+				"default": false
+			},
+			"examples": {
+				"type": "array",
+				"items": true
+			}
+		}
+	};
+}));
+//#endregion
+export default require_meta_data();
+export { require_meta_data };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.js

@@ -0,0 +1,19 @@
+import { __commonJSMin } from "../../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
+var require_unevaluated = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/unevaluated": true },
+		"$dynamicAnchor": "meta",
+		"title": "Unevaluated applicator vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"unevaluatedItems": { "$dynamicRef": "#meta" },
+			"unevaluatedProperties": { "$dynamicRef": "#meta" }
+		}
+	};
+}));
+//#endregion
+export default require_unevaluated();
+export { require_unevaluated };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.js

@@ -0,0 +1,85 @@
+import { __commonJSMin } from "../../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+var require_validation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/meta/validation",
+		"$vocabulary": { "https://json-schema.org/draft/2020-12/vocab/validation": true },
+		"$dynamicAnchor": "meta",
+		"title": "Validation vocabulary meta-schema",
+		"type": ["object", "boolean"],
+		"properties": {
+			"type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, {
+				"type": "array",
+				"items": { "$ref": "#/$defs/simpleTypes" },
+				"minItems": 1,
+				"uniqueItems": true
+			}] },
+			"const": true,
+			"enum": {
+				"type": "array",
+				"items": true
+			},
+			"multipleOf": {
+				"type": "number",
+				"exclusiveMinimum": 0
+			},
+			"maximum": { "type": "number" },
+			"exclusiveMaximum": { "type": "number" },
+			"minimum": { "type": "number" },
+			"exclusiveMinimum": { "type": "number" },
+			"maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+			"minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+			"pattern": {
+				"type": "string",
+				"format": "regex"
+			},
+			"maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+			"minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+			"uniqueItems": {
+				"type": "boolean",
+				"default": false
+			},
+			"maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+			"minContains": {
+				"$ref": "#/$defs/nonNegativeInteger",
+				"default": 1
+			},
+			"maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+			"minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+			"required": { "$ref": "#/$defs/stringArray" },
+			"dependentRequired": {
+				"type": "object",
+				"additionalProperties": { "$ref": "#/$defs/stringArray" }
+			}
+		},
+		"$defs": {
+			"nonNegativeInteger": {
+				"type": "integer",
+				"minimum": 0
+			},
+			"nonNegativeIntegerDefault0": {
+				"$ref": "#/$defs/nonNegativeInteger",
+				"default": 0
+			},
+			"simpleTypes": { "enum": [
+				"array",
+				"boolean",
+				"integer",
+				"null",
+				"number",
+				"object",
+				"string"
+			] },
+			"stringArray": {
+				"type": "array",
+				"items": { "type": "string" },
+				"uniqueItems": true,
+				"default": []
+			}
+		}
+	};
+}));
+//#endregion
+export default require_validation();
+export { require_validation };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/schema.js

@@ -0,0 +1,59 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/refs/json-schema-2020-12/schema.json
+var require_schema = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"$schema": "https://json-schema.org/draft/2020-12/schema",
+		"$id": "https://json-schema.org/draft/2020-12/schema",
+		"$vocabulary": {
+			"https://json-schema.org/draft/2020-12/vocab/core": true,
+			"https://json-schema.org/draft/2020-12/vocab/applicator": true,
+			"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+			"https://json-schema.org/draft/2020-12/vocab/validation": true,
+			"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+			"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+			"https://json-schema.org/draft/2020-12/vocab/content": true
+		},
+		"$dynamicAnchor": "meta",
+		"title": "Core and Validation specifications meta-schema",
+		"allOf": [
+			{ "$ref": "meta/core" },
+			{ "$ref": "meta/applicator" },
+			{ "$ref": "meta/unevaluated" },
+			{ "$ref": "meta/validation" },
+			{ "$ref": "meta/meta-data" },
+			{ "$ref": "meta/format-annotation" },
+			{ "$ref": "meta/content" }
+		],
+		"type": ["object", "boolean"],
+		"$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+		"properties": {
+			"definitions": {
+				"$comment": "\"definitions\" has been replaced by \"$defs\".",
+				"type": "object",
+				"additionalProperties": { "$dynamicRef": "#meta" },
+				"deprecated": true,
+				"default": {}
+			},
+			"dependencies": {
+				"$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+				"type": "object",
+				"additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] },
+				"deprecated": true,
+				"default": {}
+			},
+			"$recursiveAnchor": {
+				"$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+				"$ref": "meta/core#/$defs/anchorString",
+				"deprecated": true
+			},
+			"$recursiveRef": {
+				"$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+				"$ref": "meta/core#/$defs/uriReferenceString",
+				"deprecated": true
+			}
+		}
+	};
+}));
+//#endregion
+export default require_schema();
+export { require_schema };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/equal.js

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_fast_deep_equal } from "../../../../../fast-deep-equal@3.1.3/node_modules/fast-deep-equal/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/equal.js
+var require_equal = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const equal = require_fast_deep_equal();
+	equal.code = "require(\"ajv/dist/runtime/equal\").default";
+	exports.default = equal;
+}));
+//#endregion
+export default require_equal();
+export { require_equal };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js

@@ -0,0 +1,25 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js
+var require_ucs2length = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function ucs2length(str) {
+		const len = str.length;
+		let length = 0;
+		let pos = 0;
+		let value;
+		while (pos < len) {
+			length++;
+			value = str.charCodeAt(pos++);
+			if (value >= 55296 && value <= 56319 && pos < len) {
+				value = str.charCodeAt(pos);
+				if ((value & 64512) === 56320) pos++;
+			}
+		}
+		return length;
+	}
+	exports.default = ucs2length;
+	ucs2length.code = "require(\"ajv/dist/runtime/ucs2length\").default";
+}));
+//#endregion
+export default require_ucs2length();
+export { require_ucs2length };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_fast_uri } from "../../../../../fast-uri@3.1.0/node_modules/fast-uri/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/uri.js
+var require_uri = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const uri = require_fast_uri();
+	uri.code = "require(\"ajv/dist/runtime/uri\").default";
+	exports.default = uri;
+}));
+//#endregion
+export default require_uri();
+export { require_uri };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/validation_error.js

@@ -0,0 +1,16 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/validation_error.js
+var require_validation_error = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var ValidationError = class extends Error {
+		constructor(errors) {
+			super("validation failed");
+			this.errors = errors;
+			this.ajv = this.validation = true;
+		}
+	};
+	exports.default = ValidationError;
+}));
+//#endregion
+export default require_validation_error();
+export { require_validation_error };

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

@@ -0,0 +1,57 @@
+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/additionalItems.js
+var require_additionalItems = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.validateAdditionalItems = void 0;
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const def = {
+		keyword: "additionalItems",
+		type: "array",
+		schemaType: ["boolean", "object"],
+		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 { parentSchema, it } = cxt;
+			const { items } = parentSchema;
+			if (!Array.isArray(items)) {
+				(0, util_1.checkStrictMode)(it, "\"additionalItems\" is ignored when \"items\" is not an array of schemas");
+				return;
+			}
+			validateAdditionalItems(cxt, items);
+		}
+	};
+	function validateAdditionalItems(cxt, items) {
+		const { gen, schema, data, keyword, it } = cxt;
+		it.items = true;
+		const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+		if (schema === false) {
+			cxt.setParams({ len: items.length });
+			cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
+		} else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+			const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
+			gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
+			cxt.ok(valid);
+		}
+		function validateItems(valid) {
+			gen.forRange("i", items.length, len, (i) => {
+				cxt.subschema({
+					keyword,
+					dataProp: i,
+					dataPropType: util_1.Type.Num
+				}, valid);
+				if (!it.allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
+			});
+		}
+	}
+	exports.validateAdditionalItems = validateAdditionalItems;
+	exports.default = def;
+}));
+//#endregion
+export default require_additionalItems();
+export { require_additionalItems };

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

@@ -0,0 +1,96 @@
+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";
+import { require_code } from "../code.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/applicator/additionalProperties.js
+var require_additionalProperties = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const code_1 = require_code();
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "additionalProperties",
+		type: ["object"],
+		schemaType: ["boolean", "object"],
+		allowUndefined: true,
+		trackErrors: true,
+		error: {
+			message: "must NOT have additional properties",
+			params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
+		},
+		code(cxt) {
+			const { gen, schema, parentSchema, data, errsCount, it } = cxt;
+			/* istanbul ignore if */
+			if (!errsCount) throw new Error("ajv implementation error");
+			const { allErrors, opts } = it;
+			it.props = true;
+			if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema)) return;
+			const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
+			const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
+			checkAdditionalProperties();
+			cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+			function checkAdditionalProperties() {
+				gen.forIn("key", data, (key) => {
+					if (!props.length && !patProps.length) additionalPropertyCode(key);
+					else gen.if(isAdditional(key), () => additionalPropertyCode(key));
+				});
+			}
+			function isAdditional(key) {
+				let definedProp;
+				if (props.length > 8) {
+					const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
+					definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
+				} else if (props.length) definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
+				else definedProp = codegen_1.nil;
+				if (patProps.length) definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
+				return (0, codegen_1.not)(definedProp);
+			}
+			function deleteAdditional(key) {
+				gen.code((0, codegen_1._)`delete ${data}[${key}]`);
+			}
+			function additionalPropertyCode(key) {
+				if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
+					deleteAdditional(key);
+					return;
+				}
+				if (schema === false) {
+					cxt.setParams({ additionalProperty: key });
+					cxt.error();
+					if (!allErrors) gen.break();
+					return;
+				}
+				if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+					const valid = gen.name("valid");
+					if (opts.removeAdditional === "failing") {
+						applyAdditionalSchema(key, valid, false);
+						gen.if((0, codegen_1.not)(valid), () => {
+							cxt.reset();
+							deleteAdditional(key);
+						});
+					} else {
+						applyAdditionalSchema(key, valid);
+						if (!allErrors) gen.if((0, codegen_1.not)(valid), () => gen.break());
+					}
+				}
+			}
+			function applyAdditionalSchema(key, valid, errors) {
+				const subschema = {
+					keyword: "additionalProperties",
+					dataProp: key,
+					dataPropType: util_1.Type.Str
+				};
+				if (errors === false) Object.assign(subschema, {
+					compositeRule: true,
+					createErrors: false,
+					allErrors: false
+				});
+				cxt.subschema(subschema, valid);
+			}
+		}
+	};
+}));
+//#endregion
+export default require_additionalProperties();
+export { require_additionalProperties };

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

@@ -0,0 +1,29 @@
+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/allOf.js
+var require_allOf = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "allOf",
+		schemaType: "array",
+		code(cxt) {
+			const { gen, schema, it } = cxt;
+			/* istanbul ignore if */
+			if (!Array.isArray(schema)) throw new Error("ajv implementation error");
+			const valid = gen.name("valid");
+			schema.forEach((sch, i) => {
+				if ((0, util_1.alwaysValidSchema)(it, sch)) return;
+				const schCxt = cxt.subschema({
+					keyword: "allOf",
+					schemaProp: i
+				}, valid);
+				cxt.ok(valid);
+				cxt.mergeEvaluated(schCxt);
+			});
+		}
+	};
+}));
+//#endregion
+export default require_allOf();
+export { require_allOf };

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

@@ -0,0 +1,16 @@
+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/vocabularies/applicator/anyOf.js
+var require_anyOf = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = {
+		keyword: "anyOf",
+		schemaType: "array",
+		trackErrors: true,
+		code: require_code().validateUnion,
+		error: { message: "must match a schema in anyOf" }
+	};
+}));
+//#endregion
+export default require_anyOf();
+export { require_anyOf };

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

@@ -0,0 +1,89 @@
+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/contains.js
+var require_contains = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "contains",
+		type: "array",
+		schemaType: ["object", "boolean"],
+		before: "uniqueItems",
+		trackErrors: true,
+		error: {
+			message: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
+			params: ({ params: { min, max } }) => max === void 0 ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
+		},
+		code(cxt) {
+			const { gen, schema, parentSchema, data, it } = cxt;
+			let min;
+			let max;
+			const { minContains, maxContains } = parentSchema;
+			if (it.opts.next) {
+				min = minContains === void 0 ? 1 : minContains;
+				max = maxContains;
+			} else min = 1;
+			const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+			cxt.setParams({
+				min,
+				max
+			});
+			if (max === void 0 && min === 0) {
+				(0, util_1.checkStrictMode)(it, `"minContains" == 0 without "maxContains": "contains" keyword ignored`);
+				return;
+			}
+			if (max !== void 0 && min > max) {
+				(0, util_1.checkStrictMode)(it, `"minContains" > "maxContains" is always invalid`);
+				cxt.fail();
+				return;
+			}
+			if ((0, util_1.alwaysValidSchema)(it, schema)) {
+				let cond = (0, codegen_1._)`${len} >= ${min}`;
+				if (max !== void 0) cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
+				cxt.pass(cond);
+				return;
+			}
+			it.items = true;
+			const valid = gen.name("valid");
+			if (max === void 0 && min === 1) validateItems(valid, () => gen.if(valid, () => gen.break()));
+			else if (min === 0) {
+				gen.let(valid, true);
+				if (max !== void 0) gen.if((0, codegen_1._)`${data}.length > 0`, validateItemsWithCount);
+			} else {
+				gen.let(valid, false);
+				validateItemsWithCount();
+			}
+			cxt.result(valid, () => cxt.reset());
+			function validateItemsWithCount() {
+				const schValid = gen.name("_valid");
+				const count = gen.let("count", 0);
+				validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
+			}
+			function validateItems(_valid, block) {
+				gen.forRange("i", 0, len, (i) => {
+					cxt.subschema({
+						keyword: "contains",
+						dataProp: i,
+						dataPropType: util_1.Type.Num,
+						compositeRule: true
+					}, _valid);
+					block();
+				});
+			}
+			function checkLimits(count) {
+				gen.code((0, codegen_1._)`${count}++`);
+				if (max === void 0) gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
+				else {
+					gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
+					if (min === 1) gen.assign(valid, true);
+					else gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
+				}
+			}
+		}
+	};
+}));
+//#endregion
+export default require_contains();
+export { require_contains };