fumadocs-openapi 10.8.4 → 10.8.5

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/rules.js

@@ -0,0 +1,61 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/rules.js
+var require_rules = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getRules = exports.isJSONType = void 0;
+	const jsonTypes = new Set([
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null",
+		"object",
+		"array"
+	]);
+	function isJSONType(x) {
+		return typeof x == "string" && jsonTypes.has(x);
+	}
+	exports.isJSONType = isJSONType;
+	function getRules() {
+		const groups = {
+			number: {
+				type: "number",
+				rules: []
+			},
+			string: {
+				type: "string",
+				rules: []
+			},
+			array: {
+				type: "array",
+				rules: []
+			},
+			object: {
+				type: "object",
+				rules: []
+			}
+		};
+		return {
+			types: {
+				...groups,
+				integer: true,
+				boolean: true,
+				null: true
+			},
+			rules: [
+				{ rules: [] },
+				groups.number,
+				groups.string,
+				groups.array,
+				groups.object
+			],
+			post: { rules: [] },
+			all: {},
+			keywords: {}
+		};
+	}
+	exports.getRules = getRules;
+}));
+//#endregion
+export default require_rules();
+export { require_rules };

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/util.js

@@ -0,0 +1,146 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_code } from "./codegen/code.js";
+import { require_codegen } from "./codegen/index.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/util.js
+var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = void 0;
+	const codegen_1 = require_codegen();
+	const code_1 = require_code();
+	function toHash(arr) {
+		const hash = {};
+		for (const item of arr) hash[item] = true;
+		return hash;
+	}
+	exports.toHash = toHash;
+	function alwaysValidSchema(it, schema) {
+		if (typeof schema == "boolean") return schema;
+		if (Object.keys(schema).length === 0) return true;
+		checkUnknownRules(it, schema);
+		return !schemaHasRules(schema, it.self.RULES.all);
+	}
+	exports.alwaysValidSchema = alwaysValidSchema;
+	function checkUnknownRules(it, schema = it.schema) {
+		const { opts, self } = it;
+		if (!opts.strictSchema) return;
+		if (typeof schema === "boolean") return;
+		const rules = self.RULES.keywords;
+		for (const key in schema) if (!rules[key]) checkStrictMode(it, `unknown keyword: "${key}"`);
+	}
+	exports.checkUnknownRules = checkUnknownRules;
+	function schemaHasRules(schema, rules) {
+		if (typeof schema == "boolean") return !schema;
+		for (const key in schema) if (rules[key]) return true;
+		return false;
+	}
+	exports.schemaHasRules = schemaHasRules;
+	function schemaHasRulesButRef(schema, RULES) {
+		if (typeof schema == "boolean") return !schema;
+		for (const key in schema) if (key !== "$ref" && RULES.all[key]) return true;
+		return false;
+	}
+	exports.schemaHasRulesButRef = schemaHasRulesButRef;
+	function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
+		if (!$data) {
+			if (typeof schema == "number" || typeof schema == "boolean") return schema;
+			if (typeof schema == "string") return (0, codegen_1._)`${schema}`;
+		}
+		return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
+	}
+	exports.schemaRefOrVal = schemaRefOrVal;
+	function unescapeFragment(str) {
+		return unescapeJsonPointer(decodeURIComponent(str));
+	}
+	exports.unescapeFragment = unescapeFragment;
+	function escapeFragment(str) {
+		return encodeURIComponent(escapeJsonPointer(str));
+	}
+	exports.escapeFragment = escapeFragment;
+	function escapeJsonPointer(str) {
+		if (typeof str == "number") return `${str}`;
+		return str.replace(/~/g, "~0").replace(/\//g, "~1");
+	}
+	exports.escapeJsonPointer = escapeJsonPointer;
+	function unescapeJsonPointer(str) {
+		return str.replace(/~1/g, "/").replace(/~0/g, "~");
+	}
+	exports.unescapeJsonPointer = unescapeJsonPointer;
+	function eachItem(xs, f) {
+		if (Array.isArray(xs)) for (const x of xs) f(x);
+		else f(xs);
+	}
+	exports.eachItem = eachItem;
+	function makeMergeEvaluated({ mergeNames, mergeToName, mergeValues, resultToName }) {
+		return (gen, from, to, toName) => {
+			const res = to === void 0 ? from : to instanceof codegen_1.Name ? (from instanceof codegen_1.Name ? mergeNames(gen, from, to) : mergeToName(gen, from, to), to) : from instanceof codegen_1.Name ? (mergeToName(gen, to, from), from) : mergeValues(from, to);
+			return toName === codegen_1.Name && !(res instanceof codegen_1.Name) ? resultToName(gen, res) : res;
+		};
+	}
+	exports.mergeEvaluated = {
+		props: makeMergeEvaluated({
+			mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => {
+				gen.if((0, codegen_1._)`${from} === true`, () => gen.assign(to, true), () => gen.assign(to, (0, codegen_1._)`${to} || {}`).code((0, codegen_1._)`Object.assign(${to}, ${from})`));
+			}),
+			mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => {
+				if (from === true) gen.assign(to, true);
+				else {
+					gen.assign(to, (0, codegen_1._)`${to} || {}`);
+					setEvaluated(gen, to, from);
+				}
+			}),
+			mergeValues: (from, to) => from === true ? true : {
+				...from,
+				...to
+			},
+			resultToName: evaluatedPropsToName
+		}),
+		items: makeMergeEvaluated({
+			mergeNames: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true && ${from} !== undefined`, () => gen.assign(to, (0, codegen_1._)`${from} === true ? true : ${to} > ${from} ? ${to} : ${from}`)),
+			mergeToName: (gen, from, to) => gen.if((0, codegen_1._)`${to} !== true`, () => gen.assign(to, from === true ? true : (0, codegen_1._)`${to} > ${from} ? ${to} : ${from}`)),
+			mergeValues: (from, to) => from === true ? true : Math.max(from, to),
+			resultToName: (gen, items) => gen.var("items", items)
+		})
+	};
+	function evaluatedPropsToName(gen, ps) {
+		if (ps === true) return gen.var("props", true);
+		const props = gen.var("props", (0, codegen_1._)`{}`);
+		if (ps !== void 0) setEvaluated(gen, props, ps);
+		return props;
+	}
+	exports.evaluatedPropsToName = evaluatedPropsToName;
+	function setEvaluated(gen, props, ps) {
+		Object.keys(ps).forEach((p) => gen.assign((0, codegen_1._)`${props}${(0, codegen_1.getProperty)(p)}`, true));
+	}
+	exports.setEvaluated = setEvaluated;
+	const snippets = {};
+	function useFunc(gen, f) {
+		return gen.scopeValue("func", {
+			ref: f,
+			code: snippets[f.code] || (snippets[f.code] = new code_1._Code(f.code))
+		});
+	}
+	exports.useFunc = useFunc;
+	var Type;
+	(function(Type) {
+		Type[Type["Num"] = 0] = "Num";
+		Type[Type["Str"] = 1] = "Str";
+	})(Type || (exports.Type = Type = {}));
+	function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
+		if (dataProp instanceof codegen_1.Name) {
+			const isNumber = dataPropType === Type.Num;
+			return jsPropertySyntax ? isNumber ? (0, codegen_1._)`"[" + ${dataProp} + "]"` : (0, codegen_1._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_1._)`"/" + ${dataProp}` : (0, codegen_1._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+		}
+		return jsPropertySyntax ? (0, codegen_1.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
+	}
+	exports.getErrorPath = getErrorPath;
+	function checkStrictMode(it, msg, mode = it.opts.strictSchema) {
+		if (!mode) return;
+		msg = `strict mode: ${msg}`;
+		if (mode === true) throw new Error(msg);
+		it.self.logger.warn(msg);
+	}
+	exports.checkStrictMode = checkStrictMode;
+}));
+//#endregion
+export default require_util();
+export { require_util };

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

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/applicability.js
+var require_applicability = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = void 0;
+	function schemaHasRulesForType({ schema, self }, type) {
+		const group = self.RULES.types[type];
+		return group && group !== true && shouldUseGroup(schema, group);
+	}
+	exports.schemaHasRulesForType = schemaHasRulesForType;
+	function shouldUseGroup(schema, group) {
+		return group.rules.some((rule) => shouldUseRule(schema, rule));
+	}
+	exports.shouldUseGroup = shouldUseGroup;
+	function shouldUseRule(schema, rule) {
+		var _a;
+		return schema[rule.keyword] !== void 0 || ((_a = rule.definition.implements) === null || _a === void 0 ? void 0 : _a.some((kwd) => schema[kwd] !== void 0));
+	}
+	exports.shouldUseRule = shouldUseRule;
+}));
+//#endregion
+export default require_applicability();
+export { require_applicability };

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

@@ -0,0 +1,48 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../codegen/index.js";
+import { require_names } from "../names.js";
+import { require_errors } from "../errors.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/boolSchema.js
+var require_boolSchema = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.boolOrEmptySchema = exports.topBoolOrEmptySchema = void 0;
+	const errors_1 = require_errors();
+	const codegen_1 = require_codegen();
+	const names_1 = require_names();
+	const boolError = { message: "boolean schema is false" };
+	function topBoolOrEmptySchema(it) {
+		const { gen, schema, validateName } = it;
+		if (schema === false) falseSchemaError(it, false);
+		else if (typeof schema == "object" && schema.$async === true) gen.return(names_1.default.data);
+		else {
+			gen.assign((0, codegen_1._)`${validateName}.errors`, null);
+			gen.return(true);
+		}
+	}
+	exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
+	function boolOrEmptySchema(it, valid) {
+		const { gen, schema } = it;
+		if (schema === false) {
+			gen.var(valid, false);
+			falseSchemaError(it);
+		} else gen.var(valid, true);
+	}
+	exports.boolOrEmptySchema = boolOrEmptySchema;
+	function falseSchemaError(it, overrideAllErrors) {
+		const { gen, data } = it;
+		const cxt = {
+			gen,
+			keyword: "false schema",
+			data,
+			schema: false,
+			schemaCode: false,
+			schemaValue: false,
+			params: {},
+			it
+		};
+		(0, errors_1.reportError)(cxt, boolError, void 0, overrideAllErrors);
+	}
+}));
+//#endregion
+export default require_boolSchema();
+export { require_boolSchema };

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

@@ -0,0 +1,172 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../codegen/index.js";
+import { require_util } from "../util.js";
+import { require_errors } from "../errors.js";
+import { require_rules } from "../rules.js";
+import { require_applicability } from "./applicability.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/dataType.js
+var require_dataType = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.reportTypeError = exports.checkDataTypes = exports.checkDataType = exports.coerceAndCheckDataType = exports.getJSONTypes = exports.getSchemaTypes = exports.DataType = void 0;
+	const rules_1 = require_rules();
+	const applicability_1 = require_applicability();
+	const errors_1 = require_errors();
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	var DataType;
+	(function(DataType) {
+		DataType[DataType["Correct"] = 0] = "Correct";
+		DataType[DataType["Wrong"] = 1] = "Wrong";
+	})(DataType || (exports.DataType = DataType = {}));
+	function getSchemaTypes(schema) {
+		const types = getJSONTypes(schema.type);
+		if (types.includes("null")) {
+			if (schema.nullable === false) throw new Error("type: null contradicts nullable: false");
+		} else {
+			if (!types.length && schema.nullable !== void 0) throw new Error("\"nullable\" cannot be used without \"type\"");
+			if (schema.nullable === true) types.push("null");
+		}
+		return types;
+	}
+	exports.getSchemaTypes = getSchemaTypes;
+	function getJSONTypes(ts) {
+		const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
+		if (types.every(rules_1.isJSONType)) return types;
+		throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
+	}
+	exports.getJSONTypes = getJSONTypes;
+	function coerceAndCheckDataType(it, types) {
+		const { gen, data, opts } = it;
+		const coerceTo = coerceToTypes(types, opts.coerceTypes);
+		const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
+		if (checkTypes) {
+			const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
+			gen.if(wrongType, () => {
+				if (coerceTo.length) coerceData(it, types, coerceTo);
+				else reportTypeError(it);
+			});
+		}
+		return checkTypes;
+	}
+	exports.coerceAndCheckDataType = coerceAndCheckDataType;
+	const COERCIBLE = new Set([
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null"
+	]);
+	function coerceToTypes(types, coerceTypes) {
+		return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+	}
+	function coerceData(it, types, coerceTo) {
+		const { gen, data, opts } = it;
+		const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
+		const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
+		if (opts.coerceTypes === "array") gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+		gen.if((0, codegen_1._)`${coerced} !== undefined`);
+		for (const t of coerceTo) if (COERCIBLE.has(t) || t === "array" && opts.coerceTypes === "array") coerceSpecificType(t);
+		gen.else();
+		reportTypeError(it);
+		gen.endIf();
+		gen.if((0, codegen_1._)`${coerced} !== undefined`, () => {
+			gen.assign(data, coerced);
+			assignParentData(it, coerced);
+		});
+		function coerceSpecificType(t) {
+			switch (t) {
+				case "string":
+					gen.elseIf((0, codegen_1._)`${dataType} == "number" || ${dataType} == "boolean"`).assign(coerced, (0, codegen_1._)`"" + ${data}`).elseIf((0, codegen_1._)`${data} === null`).assign(coerced, (0, codegen_1._)`""`);
+					return;
+				case "number":
+					gen.elseIf((0, codegen_1._)`${dataType} == "boolean" || ${data} === null
+              || (${dataType} == "string" && ${data} && ${data} == +${data})`).assign(coerced, (0, codegen_1._)`+${data}`);
+					return;
+				case "integer":
+					gen.elseIf((0, codegen_1._)`${dataType} === "boolean" || ${data} === null
+              || (${dataType} === "string" && ${data} && ${data} == +${data} && !(${data} % 1))`).assign(coerced, (0, codegen_1._)`+${data}`);
+					return;
+				case "boolean":
+					gen.elseIf((0, codegen_1._)`${data} === "false" || ${data} === 0 || ${data} === null`).assign(coerced, false).elseIf((0, codegen_1._)`${data} === "true" || ${data} === 1`).assign(coerced, true);
+					return;
+				case "null":
+					gen.elseIf((0, codegen_1._)`${data} === "" || ${data} === 0 || ${data} === false`);
+					gen.assign(coerced, null);
+					return;
+				case "array": gen.elseIf((0, codegen_1._)`${dataType} === "string" || ${dataType} === "number"
+              || ${dataType} === "boolean" || ${data} === null`).assign(coerced, (0, codegen_1._)`[${data}]`);
+			}
+		}
+	}
+	function assignParentData({ gen, parentData, parentDataProperty }, expr) {
+		gen.if((0, codegen_1._)`${parentData} !== undefined`, () => gen.assign((0, codegen_1._)`${parentData}[${parentDataProperty}]`, expr));
+	}
+	function checkDataType(dataType, data, strictNums, correct = DataType.Correct) {
+		const EQ = correct === DataType.Correct ? codegen_1.operators.EQ : codegen_1.operators.NEQ;
+		let cond;
+		switch (dataType) {
+			case "null": return (0, codegen_1._)`${data} ${EQ} null`;
+			case "array":
+				cond = (0, codegen_1._)`Array.isArray(${data})`;
+				break;
+			case "object":
+				cond = (0, codegen_1._)`${data} && typeof ${data} == "object" && !Array.isArray(${data})`;
+				break;
+			case "integer":
+				cond = numCond((0, codegen_1._)`!(${data} % 1) && !isNaN(${data})`);
+				break;
+			case "number":
+				cond = numCond();
+				break;
+			default: return (0, codegen_1._)`typeof ${data} ${EQ} ${dataType}`;
+		}
+		return correct === DataType.Correct ? cond : (0, codegen_1.not)(cond);
+		function numCond(_cond = codegen_1.nil) {
+			return (0, codegen_1.and)((0, codegen_1._)`typeof ${data} == "number"`, _cond, strictNums ? (0, codegen_1._)`isFinite(${data})` : codegen_1.nil);
+		}
+	}
+	exports.checkDataType = checkDataType;
+	function checkDataTypes(dataTypes, data, strictNums, correct) {
+		if (dataTypes.length === 1) return checkDataType(dataTypes[0], data, strictNums, correct);
+		let cond;
+		const types = (0, util_1.toHash)(dataTypes);
+		if (types.array && types.object) {
+			const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
+			cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+			delete types.null;
+			delete types.array;
+			delete types.object;
+		} else cond = codegen_1.nil;
+		if (types.number) delete types.integer;
+		for (const t in types) cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
+		return cond;
+	}
+	exports.checkDataTypes = checkDataTypes;
+	const typeError = {
+		message: ({ schema }) => `must be ${schema}`,
+		params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
+	};
+	function reportTypeError(it) {
+		const cxt = getTypeErrorContext(it);
+		(0, errors_1.reportError)(cxt, typeError);
+	}
+	exports.reportTypeError = reportTypeError;
+	function getTypeErrorContext(it) {
+		const { gen, data, schema } = it;
+		const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
+		return {
+			gen,
+			keyword: "type",
+			data,
+			schema: schema.type,
+			schemaCode,
+			schemaValue: schemaCode,
+			parentSchema: schema,
+			params: {},
+			it
+		};
+	}
+}));
+//#endregion
+export default require_dataType();
+export { require_dataType };

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

@@ -0,0 +1,31 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_codegen } from "../codegen/index.js";
+import { require_util } from "../util.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/validate/defaults.js
+var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.assignDefaults = void 0;
+	const codegen_1 = require_codegen();
+	const util_1 = require_util();
+	function assignDefaults(it, ty) {
+		const { properties, items } = it.schema;
+		if (ty === "object" && properties) for (const key in properties) assignDefault(it, key, properties[key].default);
+		else if (ty === "array" && Array.isArray(items)) items.forEach((sch, i) => assignDefault(it, i, sch.default));
+	}
+	exports.assignDefaults = assignDefaults;
+	function assignDefault(it, prop, defaultValue) {
+		const { gen, compositeRule, data, opts } = it;
+		if (defaultValue === void 0) return;
+		const childData = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(prop)}`;
+		if (compositeRule) {
+			(0, util_1.checkStrictMode)(it, `default is ignored for: ${childData}`);
+			return;
+		}
+		let condition = (0, codegen_1._)`${childData} === undefined`;
+		if (opts.useDefaults === "empty") condition = (0, codegen_1._)`${condition} || ${childData} === null || ${childData} === ""`;
+		gen.if(condition, (0, codegen_1._)`${childData} = ${(0, codegen_1.stringify)(defaultValue)}`);
+	}
+}));
+//#endregion
+export default require_defaults();
+export { require_defaults };