fumadocs-openapi 10.8.4 → 10.8.5

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

@@ -0,0 +1,130 @@
+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/code.js
+var require_code = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = void 0;
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	const names_1 = require_names();
+	const util_2 = require_util();
+	function checkReportMissingProp(cxt, prop) {
+		const { gen, data, it } = cxt;
+		gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
+			cxt.setParams({ missingProperty: (0, codegen_1._)`${prop}` }, true);
+			cxt.error();
+		});
+	}
+	exports.checkReportMissingProp = checkReportMissingProp;
+	function checkMissingProp({ gen, data, it: { opts } }, properties, missing) {
+		return (0, codegen_1.or)(...properties.map((prop) => (0, codegen_1.and)(noPropertyInData(gen, data, prop, opts.ownProperties), (0, codegen_1._)`${missing} = ${prop}`)));
+	}
+	exports.checkMissingProp = checkMissingProp;
+	function reportMissingProp(cxt, missing) {
+		cxt.setParams({ missingProperty: missing }, true);
+		cxt.error();
+	}
+	exports.reportMissingProp = reportMissingProp;
+	function hasPropFunc(gen) {
+		return gen.scopeValue("func", {
+			ref: Object.prototype.hasOwnProperty,
+			code: (0, codegen_1._)`Object.prototype.hasOwnProperty`
+		});
+	}
+	exports.hasPropFunc = hasPropFunc;
+	function isOwnProperty(gen, data, property) {
+		return (0, codegen_1._)`${hasPropFunc(gen)}.call(${data}, ${property})`;
+	}
+	exports.isOwnProperty = isOwnProperty;
+	function propertyInData(gen, data, property, ownProperties) {
+		const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} !== undefined`;
+		return ownProperties ? (0, codegen_1._)`${cond} && ${isOwnProperty(gen, data, property)}` : cond;
+	}
+	exports.propertyInData = propertyInData;
+	function noPropertyInData(gen, data, property, ownProperties) {
+		const cond = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(property)} === undefined`;
+		return ownProperties ? (0, codegen_1.or)(cond, (0, codegen_1.not)(isOwnProperty(gen, data, property))) : cond;
+	}
+	exports.noPropertyInData = noPropertyInData;
+	function allSchemaProperties(schemaMap) {
+		return schemaMap ? Object.keys(schemaMap).filter((p) => p !== "__proto__") : [];
+	}
+	exports.allSchemaProperties = allSchemaProperties;
+	function schemaProperties(it, schemaMap) {
+		return allSchemaProperties(schemaMap).filter((p) => !(0, util_1.alwaysValidSchema)(it, schemaMap[p]));
+	}
+	exports.schemaProperties = schemaProperties;
+	function callValidateCode({ schemaCode, data, it: { gen, topSchemaRef, schemaPath, errorPath }, it }, func, context, passSchema) {
+		const dataAndSchema = passSchema ? (0, codegen_1._)`${schemaCode}, ${data}, ${topSchemaRef}${schemaPath}` : data;
+		const valCxt = [
+			[names_1.default.instancePath, (0, codegen_1.strConcat)(names_1.default.instancePath, errorPath)],
+			[names_1.default.parentData, it.parentData],
+			[names_1.default.parentDataProperty, it.parentDataProperty],
+			[names_1.default.rootData, names_1.default.rootData]
+		];
+		if (it.opts.dynamicRef) valCxt.push([names_1.default.dynamicAnchors, names_1.default.dynamicAnchors]);
+		const args = (0, codegen_1._)`${dataAndSchema}, ${gen.object(...valCxt)}`;
+		return context !== codegen_1.nil ? (0, codegen_1._)`${func}.call(${context}, ${args})` : (0, codegen_1._)`${func}(${args})`;
+	}
+	exports.callValidateCode = callValidateCode;
+	const newRegExp = (0, codegen_1._)`new RegExp`;
+	function usePattern({ gen, it: { opts } }, pattern) {
+		const u = opts.unicodeRegExp ? "u" : "";
+		const { regExp } = opts.code;
+		const rx = regExp(pattern, u);
+		return gen.scopeValue("pattern", {
+			key: rx.toString(),
+			ref: rx,
+			code: (0, codegen_1._)`${regExp.code === "new RegExp" ? newRegExp : (0, util_2.useFunc)(gen, regExp)}(${pattern}, ${u})`
+		});
+	}
+	exports.usePattern = usePattern;
+	function validateArray(cxt) {
+		const { gen, data, keyword, it } = cxt;
+		const valid = gen.name("valid");
+		if (it.allErrors) {
+			const validArr = gen.let("valid", true);
+			validateItems(() => gen.assign(validArr, false));
+			return validArr;
+		}
+		gen.var(valid, true);
+		validateItems(() => gen.break());
+		return valid;
+		function validateItems(notValid) {
+			const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+			gen.forRange("i", 0, len, (i) => {
+				cxt.subschema({
+					keyword,
+					dataProp: i,
+					dataPropType: util_1.Type.Num
+				}, valid);
+				gen.if((0, codegen_1.not)(valid), notValid);
+			});
+		}
+	}
+	exports.validateArray = validateArray;
+	function validateUnion(cxt) {
+		const { gen, schema, keyword, it } = cxt;
+		/* istanbul ignore if */
+		if (!Array.isArray(schema)) throw new Error("ajv implementation error");
+		if (schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch)) && !it.opts.unevaluated) return;
+		const valid = gen.let("valid", false);
+		const schValid = gen.name("_valid");
+		gen.block(() => schema.forEach((_sch, i) => {
+			const schCxt = cxt.subschema({
+				keyword,
+				schemaProp: i,
+				compositeRule: true
+			}, schValid);
+			gen.assign(valid, (0, codegen_1._)`${valid} || ${schValid}`);
+			if (!cxt.mergeValidEvaluated(schCxt, schValid)) gen.if((0, codegen_1.not)(valid));
+		}));
+		cxt.result(valid, () => cxt.reset(), () => cxt.error(true));
+	}
+	exports.validateUnion = validateUnion;
+}));
+//#endregion
+export default require_code();
+export { require_code };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/id.js

@@ -0,0 +1,14 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/id.js
+var require_id = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.default = {
+		keyword: "id",
+		code() {
+			throw new Error("NOT SUPPORTED: keyword \"id\", use \"$id\" for schema ID");
+		}
+	};
+}));
+//#endregion
+export default require_id();
+export { require_id };

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

@@ -0,0 +1,22 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_id } from "./id.js";
+import { require_ref } from "./ref.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/index.js
+var require_core = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const id_1 = require_id();
+	const ref_1 = require_ref();
+	exports.default = [
+		"$schema",
+		"$id",
+		"$defs",
+		"$vocabulary",
+		{ keyword: "$comment" },
+		"definitions",
+		id_1.default,
+		ref_1.default
+	];
+}));
+//#endregion
+export default require_core();
+export { require_core };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/ref.js

@@ -0,0 +1,112 @@
+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";
+import { require_ref_error } from "../../compile/ref_error.js";
+import { require_compile } from "../../compile/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/core/ref.js
+var require_ref = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.callRef = exports.getValidate = void 0;
+	const ref_error_1 = require_ref_error();
+	const code_1 = require_code();
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const compile_1 = require_compile();
+	const util_1 = require_util();
+	const def = {
+		keyword: "$ref",
+		schemaType: "string",
+		code(cxt) {
+			const { gen, schema: $ref, it } = cxt;
+			const { baseId, schemaEnv: env, validateName, opts, self } = it;
+			const { root } = env;
+			if (($ref === "#" || $ref === "#/") && baseId === root.baseId) return callRootRef();
+			const schOrEnv = compile_1.resolveRef.call(self, root, baseId, $ref);
+			if (schOrEnv === void 0) throw new ref_error_1.default(it.opts.uriResolver, baseId, $ref);
+			if (schOrEnv instanceof compile_1.SchemaEnv) return callValidate(schOrEnv);
+			return inlineRefSchema(schOrEnv);
+			function callRootRef() {
+				if (env === root) return callRef(cxt, validateName, env, env.$async);
+				const rootName = gen.scopeValue("root", { ref: root });
+				return callRef(cxt, (0, codegen_1._)`${rootName}.validate`, root, root.$async);
+			}
+			function callValidate(sch) {
+				callRef(cxt, getValidate(cxt, sch), sch, sch.$async);
+			}
+			function inlineRefSchema(sch) {
+				const schName = gen.scopeValue("schema", opts.code.source === true ? {
+					ref: sch,
+					code: (0, codegen_1.stringify)(sch)
+				} : { ref: sch });
+				const valid = gen.name("valid");
+				const schCxt = cxt.subschema({
+					schema: sch,
+					dataTypes: [],
+					schemaPath: codegen_1.nil,
+					topSchemaRef: schName,
+					errSchemaPath: $ref
+				}, valid);
+				cxt.mergeEvaluated(schCxt);
+				cxt.ok(valid);
+			}
+		}
+	};
+	function getValidate(cxt, sch) {
+		const { gen } = cxt;
+		return sch.validate ? gen.scopeValue("validate", { ref: sch.validate }) : (0, codegen_1._)`${gen.scopeValue("wrapper", { ref: sch })}.validate`;
+	}
+	exports.getValidate = getValidate;
+	function callRef(cxt, v, sch, $async) {
+		const { gen, it } = cxt;
+		const { allErrors, schemaEnv: env, opts } = it;
+		const passCxt = opts.passContext ? names_1.default.this : codegen_1.nil;
+		if ($async) callAsyncRef();
+		else callSyncRef();
+		function callAsyncRef() {
+			if (!env.$async) throw new Error("async schema referenced by sync schema");
+			const valid = gen.let("valid");
+			gen.try(() => {
+				gen.code((0, codegen_1._)`await ${(0, code_1.callValidateCode)(cxt, v, passCxt)}`);
+				addEvaluatedFrom(v);
+				if (!allErrors) gen.assign(valid, true);
+			}, (e) => {
+				gen.if((0, codegen_1._)`!(${e} instanceof ${it.ValidationError})`, () => gen.throw(e));
+				addErrorsFrom(e);
+				if (!allErrors) gen.assign(valid, false);
+			});
+			cxt.ok(valid);
+		}
+		function callSyncRef() {
+			cxt.result((0, code_1.callValidateCode)(cxt, v, passCxt), () => addEvaluatedFrom(v), () => addErrorsFrom(v));
+		}
+		function addErrorsFrom(source) {
+			const errs = (0, codegen_1._)`${source}.errors`;
+			gen.assign(names_1.default.vErrors, (0, codegen_1._)`${names_1.default.vErrors} === null ? ${errs} : ${names_1.default.vErrors}.concat(${errs})`);
+			gen.assign(names_1.default.errors, (0, codegen_1._)`${names_1.default.vErrors}.length`);
+		}
+		function addEvaluatedFrom(source) {
+			var _a;
+			if (!it.opts.unevaluated) return;
+			const schEvaluated = (_a = sch === null || sch === void 0 ? void 0 : sch.validate) === null || _a === void 0 ? void 0 : _a.evaluated;
+			if (it.props !== true) if (schEvaluated && !schEvaluated.dynamicProps) {
+				if (schEvaluated.props !== void 0) it.props = util_1.mergeEvaluated.props(gen, schEvaluated.props, it.props);
+			} else {
+				const props = gen.var("props", (0, codegen_1._)`${source}.evaluated.props`);
+				it.props = util_1.mergeEvaluated.props(gen, props, it.props, codegen_1.Name);
+			}
+			if (it.items !== true) if (schEvaluated && !schEvaluated.dynamicItems) {
+				if (schEvaluated.items !== void 0) it.items = util_1.mergeEvaluated.items(gen, schEvaluated.items, it.items);
+			} else {
+				const items = gen.var("items", (0, codegen_1._)`${source}.evaluated.items`);
+				it.items = util_1.mergeEvaluated.items(gen, items, it.items, codegen_1.Name);
+			}
+		}
+	}
+	exports.callRef = callRef;
+	exports.default = def;
+}));
+//#endregion
+export default require_ref();
+export { require_ref };

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

@@ -0,0 +1,101 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_util } from "../../compile/util.js";
+import { require_ref_error } from "../../compile/ref_error.js";
+import { require_compile } from "../../compile/index.js";
+import { require_types } from "./types.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/index.js
+var require_discriminator = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const codegen_1 = require_codegen();
+	const types_1 = require_types();
+	const compile_1 = require_compile();
+	const ref_error_1 = require_ref_error();
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "discriminator",
+		type: "object",
+		schemaType: "object",
+		error: {
+			message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
+			params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
+		},
+		code(cxt) {
+			const { gen, data, schema, parentSchema, it } = cxt;
+			const { oneOf } = parentSchema;
+			if (!it.opts.discriminator) throw new Error("discriminator: requires discriminator option");
+			const tagName = schema.propertyName;
+			if (typeof tagName != "string") throw new Error("discriminator: requires propertyName");
+			if (schema.mapping) throw new Error("discriminator: mapping is not supported");
+			if (!oneOf) throw new Error("discriminator: requires oneOf keyword");
+			const valid = gen.let("valid", false);
+			const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
+			gen.if((0, codegen_1._)`typeof ${tag} == "string"`, () => validateMapping(), () => cxt.error(false, {
+				discrError: types_1.DiscrError.Tag,
+				tag,
+				tagName
+			}));
+			cxt.ok(valid);
+			function validateMapping() {
+				const mapping = getMapping();
+				gen.if(false);
+				for (const tagValue in mapping) {
+					gen.elseIf((0, codegen_1._)`${tag} === ${tagValue}`);
+					gen.assign(valid, applyTagSchema(mapping[tagValue]));
+				}
+				gen.else();
+				cxt.error(false, {
+					discrError: types_1.DiscrError.Mapping,
+					tag,
+					tagName
+				});
+				gen.endIf();
+			}
+			function applyTagSchema(schemaProp) {
+				const _valid = gen.name("valid");
+				const schCxt = cxt.subschema({
+					keyword: "oneOf",
+					schemaProp
+				}, _valid);
+				cxt.mergeEvaluated(schCxt, codegen_1.Name);
+				return _valid;
+			}
+			function getMapping() {
+				var _a;
+				const oneOfMapping = {};
+				const topRequired = hasRequired(parentSchema);
+				let tagRequired = true;
+				for (let i = 0; i < oneOf.length; i++) {
+					let sch = oneOf[i];
+					if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
+						const ref = sch.$ref;
+						sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
+						if (sch instanceof compile_1.SchemaEnv) sch = sch.schema;
+						if (sch === void 0) throw new ref_error_1.default(it.opts.uriResolver, it.baseId, ref);
+					}
+					const propSch = (_a = sch === null || sch === void 0 ? void 0 : sch.properties) === null || _a === void 0 ? void 0 : _a[tagName];
+					if (typeof propSch != "object") throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`);
+					tagRequired = tagRequired && (topRequired || hasRequired(sch));
+					addMappings(propSch, i);
+				}
+				if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`);
+				return oneOfMapping;
+				function hasRequired({ required }) {
+					return Array.isArray(required) && required.includes(tagName);
+				}
+				function addMappings(sch, i) {
+					if (sch.const) addMapping(sch.const, i);
+					else if (sch.enum) for (const tagValue of sch.enum) addMapping(tagValue, i);
+					else throw new Error(`discriminator: "properties/${tagName}" must have "const" or "enum"`);
+				}
+				function addMapping(tagValue, i) {
+					if (typeof tagValue != "string" || tagValue in oneOfMapping) throw new Error(`discriminator: "${tagName}" values must be unique strings`);
+					oneOfMapping[tagValue] = i;
+				}
+			}
+		}
+	};
+}));
+//#endregion
+export default require_discriminator();
+export { require_discriminator };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/types.js

@@ -0,0 +1,14 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/discriminator/types.js
+var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.DiscrError = void 0;
+	var DiscrError;
+	(function(DiscrError) {
+		DiscrError["Tag"] = "tag";
+		DiscrError["Mapping"] = "mapping";
+	})(DiscrError || (exports.DiscrError = DiscrError = {}));
+}));
+//#endregion
+export default require_types();
+export { require_types };

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

@@ -0,0 +1,35 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_core } from "./core/index.js";
+import { require_validation } from "./validation/index.js";
+import { require_applicator } from "./applicator/index.js";
+import { require_dynamic } from "./dynamic/index.js";
+import { require_next } from "./next.js";
+import { require_unevaluated } from "./unevaluated/index.js";
+import { require_format } from "./format/index.js";
+import { require_metadata } from "./metadata.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/draft2020.js
+var require_draft2020 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const core_1 = require_core();
+	const validation_1 = require_validation();
+	const applicator_1 = require_applicator();
+	const dynamic_1 = require_dynamic();
+	const next_1 = require_next();
+	const unevaluated_1 = require_unevaluated();
+	const format_1 = require_format();
+	const metadata_1 = require_metadata();
+	exports.default = [
+		dynamic_1.default,
+		core_1.default,
+		validation_1.default,
+		(0, applicator_1.default)(true),
+		format_1.default,
+		metadata_1.metadataVocabulary,
+		metadata_1.contentVocabulary,
+		next_1.default,
+		unevaluated_1.default
+	];
+}));
+//#endregion
+export default require_draft2020();
+export { require_draft2020 };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js

@@ -0,0 +1,46 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_names } from "../../compile/names.js";
+import { require_compile } from "../../compile/index.js";
+import { require_ref } from "../core/ref.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js
+var require_dynamicAnchor = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.dynamicAnchor = void 0;
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const compile_1 = require_compile();
+	const ref_1 = require_ref();
+	const def = {
+		keyword: "$dynamicAnchor",
+		schemaType: "string",
+		code: (cxt) => dynamicAnchor(cxt, cxt.schema)
+	};
+	function dynamicAnchor(cxt, anchor) {
+		const { gen, it } = cxt;
+		it.schemaEnv.root.dynamicAnchors[anchor] = true;
+		const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
+		const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
+		gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
+	}
+	exports.dynamicAnchor = dynamicAnchor;
+	function _getValidate(cxt) {
+		const { schemaEnv, schema, self } = cxt.it;
+		const { root, baseId, localRefs, meta } = schemaEnv.root;
+		const { schemaId } = self.opts;
+		const sch = new compile_1.SchemaEnv({
+			schema,
+			schemaId,
+			root,
+			baseId,
+			localRefs,
+			meta
+		});
+		compile_1.compileSchema.call(self, sch);
+		return (0, ref_1.getValidate)(cxt, sch);
+	}
+	exports.default = def;
+}));
+//#endregion
+export default require_dynamicAnchor();
+export { require_dynamicAnchor };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js

@@ -0,0 +1,45 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../../compile/codegen/index.js";
+import { require_names } from "../../compile/names.js";
+import { require_ref } from "../core/ref.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
+var require_dynamicRef = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.dynamicRef = void 0;
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const ref_1 = require_ref();
+	const def = {
+		keyword: "$dynamicRef",
+		schemaType: "string",
+		code: (cxt) => dynamicRef(cxt, cxt.schema)
+	};
+	function dynamicRef(cxt, ref) {
+		const { gen, keyword, it } = cxt;
+		if (ref[0] !== "#") throw new Error(`"${keyword}" only supports hash fragment reference`);
+		const anchor = ref.slice(1);
+		if (it.allErrors) _dynamicRef();
+		else {
+			const valid = gen.let("valid", false);
+			_dynamicRef(valid);
+			cxt.ok(valid);
+		}
+		function _dynamicRef(valid) {
+			if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+				const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
+				gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
+			} else _callRef(it.validateName, valid)();
+		}
+		function _callRef(validate, valid) {
+			return valid ? () => gen.block(() => {
+				(0, ref_1.callRef)(cxt, validate);
+				gen.let(valid, true);
+			}) : () => (0, ref_1.callRef)(cxt, validate);
+		}
+	}
+	exports.dynamicRef = dynamicRef;
+	exports.default = def;
+}));
+//#endregion
+export default require_dynamicRef();
+export { require_dynamicRef };

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

@@ -0,0 +1,22 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_dynamicAnchor } from "./dynamicAnchor.js";
+import { require_dynamicRef } from "./dynamicRef.js";
+import { require_recursiveAnchor } from "./recursiveAnchor.js";
+import { require_recursiveRef } from "./recursiveRef.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/index.js
+var require_dynamic = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dynamicAnchor_1 = require_dynamicAnchor();
+	const dynamicRef_1 = require_dynamicRef();
+	const recursiveAnchor_1 = require_recursiveAnchor();
+	const recursiveRef_1 = require_recursiveRef();
+	exports.default = [
+		dynamicAnchor_1.default,
+		dynamicRef_1.default,
+		recursiveAnchor_1.default,
+		recursiveRef_1.default
+	];
+}));
+//#endregion
+export default require_dynamic();
+export { require_dynamic };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js

@@ -0,0 +1,20 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_util } from "../../compile/util.js";
+import { require_dynamicAnchor } from "./dynamicAnchor.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
+var require_recursiveAnchor = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dynamicAnchor_1 = require_dynamicAnchor();
+	const util_1 = require_util();
+	exports.default = {
+		keyword: "$recursiveAnchor",
+		schemaType: "boolean",
+		code(cxt) {
+			if (cxt.schema) (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
+			else (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
+		}
+	};
+}));
+//#endregion
+export default require_recursiveAnchor();
+export { require_recursiveAnchor };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js

@@ -0,0 +1,15 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_dynamicRef } from "./dynamicRef.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
+var require_recursiveRef = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const dynamicRef_1 = require_dynamicRef();
+	exports.default = {
+		keyword: "$recursiveRef",
+		schemaType: "string",
+		code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
+	};
+}));
+//#endregion
+export default require_recursiveRef();
+export { require_recursiveRef };