fumadocs-openapi 10.8.4 → 10.8.5

package/dist/node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/index.js

@@ -0,0 +1,674 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_code } from "./code.js";
+import { require_scope } from "./scope.js";
+//#region ../../node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/index.js
+var require_codegen = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.or = exports.and = exports.not = exports.CodeGen = exports.operators = exports.varKinds = exports.ValueScopeName = exports.ValueScope = exports.Scope = exports.Name = exports.regexpCode = exports.stringify = exports.getProperty = exports.nil = exports.strConcat = exports.str = exports._ = void 0;
+	const code_1 = require_code();
+	const scope_1 = require_scope();
+	var code_2 = require_code();
+	Object.defineProperty(exports, "_", {
+		enumerable: true,
+		get: function() {
+			return code_2._;
+		}
+	});
+	Object.defineProperty(exports, "str", {
+		enumerable: true,
+		get: function() {
+			return code_2.str;
+		}
+	});
+	Object.defineProperty(exports, "strConcat", {
+		enumerable: true,
+		get: function() {
+			return code_2.strConcat;
+		}
+	});
+	Object.defineProperty(exports, "nil", {
+		enumerable: true,
+		get: function() {
+			return code_2.nil;
+		}
+	});
+	Object.defineProperty(exports, "getProperty", {
+		enumerable: true,
+		get: function() {
+			return code_2.getProperty;
+		}
+	});
+	Object.defineProperty(exports, "stringify", {
+		enumerable: true,
+		get: function() {
+			return code_2.stringify;
+		}
+	});
+	Object.defineProperty(exports, "regexpCode", {
+		enumerable: true,
+		get: function() {
+			return code_2.regexpCode;
+		}
+	});
+	Object.defineProperty(exports, "Name", {
+		enumerable: true,
+		get: function() {
+			return code_2.Name;
+		}
+	});
+	var scope_2 = require_scope();
+	Object.defineProperty(exports, "Scope", {
+		enumerable: true,
+		get: function() {
+			return scope_2.Scope;
+		}
+	});
+	Object.defineProperty(exports, "ValueScope", {
+		enumerable: true,
+		get: function() {
+			return scope_2.ValueScope;
+		}
+	});
+	Object.defineProperty(exports, "ValueScopeName", {
+		enumerable: true,
+		get: function() {
+			return scope_2.ValueScopeName;
+		}
+	});
+	Object.defineProperty(exports, "varKinds", {
+		enumerable: true,
+		get: function() {
+			return scope_2.varKinds;
+		}
+	});
+	exports.operators = {
+		GT: new code_1._Code(">"),
+		GTE: new code_1._Code(">="),
+		LT: new code_1._Code("<"),
+		LTE: new code_1._Code("<="),
+		EQ: new code_1._Code("==="),
+		NEQ: new code_1._Code("!=="),
+		NOT: new code_1._Code("!"),
+		OR: new code_1._Code("||"),
+		AND: new code_1._Code("&&"),
+		ADD: new code_1._Code("+")
+	};
+	var Node = class {
+		optimizeNodes() {
+			return this;
+		}
+		optimizeNames(_names, _constants) {
+			return this;
+		}
+	};
+	var Def = class extends Node {
+		constructor(varKind, name, rhs) {
+			super();
+			this.varKind = varKind;
+			this.name = name;
+			this.rhs = rhs;
+		}
+		render({ es5, _n }) {
+			const varKind = es5 ? scope_1.varKinds.var : this.varKind;
+			const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
+			return `${varKind} ${this.name}${rhs};` + _n;
+		}
+		optimizeNames(names, constants) {
+			if (!names[this.name.str]) return;
+			if (this.rhs) this.rhs = optimizeExpr(this.rhs, names, constants);
+			return this;
+		}
+		get names() {
+			return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
+		}
+	};
+	var Assign = class extends Node {
+		constructor(lhs, rhs, sideEffects) {
+			super();
+			this.lhs = lhs;
+			this.rhs = rhs;
+			this.sideEffects = sideEffects;
+		}
+		render({ _n }) {
+			return `${this.lhs} = ${this.rhs};` + _n;
+		}
+		optimizeNames(names, constants) {
+			if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects) return;
+			this.rhs = optimizeExpr(this.rhs, names, constants);
+			return this;
+		}
+		get names() {
+			return addExprNames(this.lhs instanceof code_1.Name ? {} : { ...this.lhs.names }, this.rhs);
+		}
+	};
+	var AssignOp = class extends Assign {
+		constructor(lhs, op, rhs, sideEffects) {
+			super(lhs, rhs, sideEffects);
+			this.op = op;
+		}
+		render({ _n }) {
+			return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
+		}
+	};
+	var Label = class extends Node {
+		constructor(label) {
+			super();
+			this.label = label;
+			this.names = {};
+		}
+		render({ _n }) {
+			return `${this.label}:` + _n;
+		}
+	};
+	var Break = class extends Node {
+		constructor(label) {
+			super();
+			this.label = label;
+			this.names = {};
+		}
+		render({ _n }) {
+			return `break${this.label ? ` ${this.label}` : ""};` + _n;
+		}
+	};
+	var Throw = class extends Node {
+		constructor(error) {
+			super();
+			this.error = error;
+		}
+		render({ _n }) {
+			return `throw ${this.error};` + _n;
+		}
+		get names() {
+			return this.error.names;
+		}
+	};
+	var AnyCode = class extends Node {
+		constructor(code) {
+			super();
+			this.code = code;
+		}
+		render({ _n }) {
+			return `${this.code};` + _n;
+		}
+		optimizeNodes() {
+			return `${this.code}` ? this : void 0;
+		}
+		optimizeNames(names, constants) {
+			this.code = optimizeExpr(this.code, names, constants);
+			return this;
+		}
+		get names() {
+			return this.code instanceof code_1._CodeOrName ? this.code.names : {};
+		}
+	};
+	var ParentNode = class extends Node {
+		constructor(nodes = []) {
+			super();
+			this.nodes = nodes;
+		}
+		render(opts) {
+			return this.nodes.reduce((code, n) => code + n.render(opts), "");
+		}
+		optimizeNodes() {
+			const { nodes } = this;
+			let i = nodes.length;
+			while (i--) {
+				const n = nodes[i].optimizeNodes();
+				if (Array.isArray(n)) nodes.splice(i, 1, ...n);
+				else if (n) nodes[i] = n;
+				else nodes.splice(i, 1);
+			}
+			return nodes.length > 0 ? this : void 0;
+		}
+		optimizeNames(names, constants) {
+			const { nodes } = this;
+			let i = nodes.length;
+			while (i--) {
+				const n = nodes[i];
+				if (n.optimizeNames(names, constants)) continue;
+				subtractNames(names, n.names);
+				nodes.splice(i, 1);
+			}
+			return nodes.length > 0 ? this : void 0;
+		}
+		get names() {
+			return this.nodes.reduce((names, n) => addNames(names, n.names), {});
+		}
+	};
+	var BlockNode = class extends ParentNode {
+		render(opts) {
+			return "{" + opts._n + super.render(opts) + "}" + opts._n;
+		}
+	};
+	var Root = class extends ParentNode {};
+	var Else = class extends BlockNode {};
+	Else.kind = "else";
+	var If = class If extends BlockNode {
+		constructor(condition, nodes) {
+			super(nodes);
+			this.condition = condition;
+		}
+		render(opts) {
+			let code = `if(${this.condition})` + super.render(opts);
+			if (this.else) code += "else " + this.else.render(opts);
+			return code;
+		}
+		optimizeNodes() {
+			super.optimizeNodes();
+			const cond = this.condition;
+			if (cond === true) return this.nodes;
+			let e = this.else;
+			if (e) {
+				const ns = e.optimizeNodes();
+				e = this.else = Array.isArray(ns) ? new Else(ns) : ns;
+			}
+			if (e) {
+				if (cond === false) return e instanceof If ? e : e.nodes;
+				if (this.nodes.length) return this;
+				return new If(not(cond), e instanceof If ? [e] : e.nodes);
+			}
+			if (cond === false || !this.nodes.length) return void 0;
+			return this;
+		}
+		optimizeNames(names, constants) {
+			var _a;
+			this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
+			if (!(super.optimizeNames(names, constants) || this.else)) return;
+			this.condition = optimizeExpr(this.condition, names, constants);
+			return this;
+		}
+		get names() {
+			const names = super.names;
+			addExprNames(names, this.condition);
+			if (this.else) addNames(names, this.else.names);
+			return names;
+		}
+	};
+	If.kind = "if";
+	var For = class extends BlockNode {};
+	For.kind = "for";
+	var ForLoop = class extends For {
+		constructor(iteration) {
+			super();
+			this.iteration = iteration;
+		}
+		render(opts) {
+			return `for(${this.iteration})` + super.render(opts);
+		}
+		optimizeNames(names, constants) {
+			if (!super.optimizeNames(names, constants)) return;
+			this.iteration = optimizeExpr(this.iteration, names, constants);
+			return this;
+		}
+		get names() {
+			return addNames(super.names, this.iteration.names);
+		}
+	};
+	var ForRange = class extends For {
+		constructor(varKind, name, from, to) {
+			super();
+			this.varKind = varKind;
+			this.name = name;
+			this.from = from;
+			this.to = to;
+		}
+		render(opts) {
+			const varKind = opts.es5 ? scope_1.varKinds.var : this.varKind;
+			const { name, from, to } = this;
+			return `for(${varKind} ${name}=${from}; ${name}<${to}; ${name}++)` + super.render(opts);
+		}
+		get names() {
+			return addExprNames(addExprNames(super.names, this.from), this.to);
+		}
+	};
+	var ForIter = class extends For {
+		constructor(loop, varKind, name, iterable) {
+			super();
+			this.loop = loop;
+			this.varKind = varKind;
+			this.name = name;
+			this.iterable = iterable;
+		}
+		render(opts) {
+			return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
+		}
+		optimizeNames(names, constants) {
+			if (!super.optimizeNames(names, constants)) return;
+			this.iterable = optimizeExpr(this.iterable, names, constants);
+			return this;
+		}
+		get names() {
+			return addNames(super.names, this.iterable.names);
+		}
+	};
+	var Func = class extends BlockNode {
+		constructor(name, args, async) {
+			super();
+			this.name = name;
+			this.args = args;
+			this.async = async;
+		}
+		render(opts) {
+			return `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render(opts);
+		}
+	};
+	Func.kind = "func";
+	var Return = class extends ParentNode {
+		render(opts) {
+			return "return " + super.render(opts);
+		}
+	};
+	Return.kind = "return";
+	var Try = class extends BlockNode {
+		render(opts) {
+			let code = "try" + super.render(opts);
+			if (this.catch) code += this.catch.render(opts);
+			if (this.finally) code += this.finally.render(opts);
+			return code;
+		}
+		optimizeNodes() {
+			var _a, _b;
+			super.optimizeNodes();
+			(_a = this.catch) === null || _a === void 0 || _a.optimizeNodes();
+			(_b = this.finally) === null || _b === void 0 || _b.optimizeNodes();
+			return this;
+		}
+		optimizeNames(names, constants) {
+			var _a, _b;
+			super.optimizeNames(names, constants);
+			(_a = this.catch) === null || _a === void 0 || _a.optimizeNames(names, constants);
+			(_b = this.finally) === null || _b === void 0 || _b.optimizeNames(names, constants);
+			return this;
+		}
+		get names() {
+			const names = super.names;
+			if (this.catch) addNames(names, this.catch.names);
+			if (this.finally) addNames(names, this.finally.names);
+			return names;
+		}
+	};
+	var Catch = class extends BlockNode {
+		constructor(error) {
+			super();
+			this.error = error;
+		}
+		render(opts) {
+			return `catch(${this.error})` + super.render(opts);
+		}
+	};
+	Catch.kind = "catch";
+	var Finally = class extends BlockNode {
+		render(opts) {
+			return "finally" + super.render(opts);
+		}
+	};
+	Finally.kind = "finally";
+	var CodeGen = class {
+		constructor(extScope, opts = {}) {
+			this._values = {};
+			this._blockStarts = [];
+			this._constants = {};
+			this.opts = {
+				...opts,
+				_n: opts.lines ? "\n" : ""
+			};
+			this._extScope = extScope;
+			this._scope = new scope_1.Scope({ parent: extScope });
+			this._nodes = [new Root()];
+		}
+		toString() {
+			return this._root.render(this.opts);
+		}
+		name(prefix) {
+			return this._scope.name(prefix);
+		}
+		scopeName(prefix) {
+			return this._extScope.name(prefix);
+		}
+		scopeValue(prefixOrName, value) {
+			const name = this._extScope.value(prefixOrName, value);
+			(this._values[name.prefix] || (this._values[name.prefix] = /* @__PURE__ */ new Set())).add(name);
+			return name;
+		}
+		getScopeValue(prefix, keyOrRef) {
+			return this._extScope.getValue(prefix, keyOrRef);
+		}
+		scopeRefs(scopeName) {
+			return this._extScope.scopeRefs(scopeName, this._values);
+		}
+		scopeCode() {
+			return this._extScope.scopeCode(this._values);
+		}
+		_def(varKind, nameOrPrefix, rhs, constant) {
+			const name = this._scope.toName(nameOrPrefix);
+			if (rhs !== void 0 && constant) this._constants[name.str] = rhs;
+			this._leafNode(new Def(varKind, name, rhs));
+			return name;
+		}
+		const(nameOrPrefix, rhs, _constant) {
+			return this._def(scope_1.varKinds.const, nameOrPrefix, rhs, _constant);
+		}
+		let(nameOrPrefix, rhs, _constant) {
+			return this._def(scope_1.varKinds.let, nameOrPrefix, rhs, _constant);
+		}
+		var(nameOrPrefix, rhs, _constant) {
+			return this._def(scope_1.varKinds.var, nameOrPrefix, rhs, _constant);
+		}
+		assign(lhs, rhs, sideEffects) {
+			return this._leafNode(new Assign(lhs, rhs, sideEffects));
+		}
+		add(lhs, rhs) {
+			return this._leafNode(new AssignOp(lhs, exports.operators.ADD, rhs));
+		}
+		code(c) {
+			if (typeof c == "function") c();
+			else if (c !== code_1.nil) this._leafNode(new AnyCode(c));
+			return this;
+		}
+		object(...keyValues) {
+			const code = ["{"];
+			for (const [key, value] of keyValues) {
+				if (code.length > 1) code.push(",");
+				code.push(key);
+				if (key !== value || this.opts.es5) {
+					code.push(":");
+					(0, code_1.addCodeArg)(code, value);
+				}
+			}
+			code.push("}");
+			return new code_1._Code(code);
+		}
+		if(condition, thenBody, elseBody) {
+			this._blockNode(new If(condition));
+			if (thenBody && elseBody) this.code(thenBody).else().code(elseBody).endIf();
+			else if (thenBody) this.code(thenBody).endIf();
+			else if (elseBody) throw new Error("CodeGen: \"else\" body without \"then\" body");
+			return this;
+		}
+		elseIf(condition) {
+			return this._elseNode(new If(condition));
+		}
+		else() {
+			return this._elseNode(new Else());
+		}
+		endIf() {
+			return this._endBlockNode(If, Else);
+		}
+		_for(node, forBody) {
+			this._blockNode(node);
+			if (forBody) this.code(forBody).endFor();
+			return this;
+		}
+		for(iteration, forBody) {
+			return this._for(new ForLoop(iteration), forBody);
+		}
+		forRange(nameOrPrefix, from, to, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.let) {
+			const name = this._scope.toName(nameOrPrefix);
+			return this._for(new ForRange(varKind, name, from, to), () => forBody(name));
+		}
+		forOf(nameOrPrefix, iterable, forBody, varKind = scope_1.varKinds.const) {
+			const name = this._scope.toName(nameOrPrefix);
+			if (this.opts.es5) {
+				const arr = iterable instanceof code_1.Name ? iterable : this.var("_arr", iterable);
+				return this.forRange("_i", 0, (0, code_1._)`${arr}.length`, (i) => {
+					this.var(name, (0, code_1._)`${arr}[${i}]`);
+					forBody(name);
+				});
+			}
+			return this._for(new ForIter("of", varKind, name, iterable), () => forBody(name));
+		}
+		forIn(nameOrPrefix, obj, forBody, varKind = this.opts.es5 ? scope_1.varKinds.var : scope_1.varKinds.const) {
+			if (this.opts.ownProperties) return this.forOf(nameOrPrefix, (0, code_1._)`Object.keys(${obj})`, forBody);
+			const name = this._scope.toName(nameOrPrefix);
+			return this._for(new ForIter("in", varKind, name, obj), () => forBody(name));
+		}
+		endFor() {
+			return this._endBlockNode(For);
+		}
+		label(label) {
+			return this._leafNode(new Label(label));
+		}
+		break(label) {
+			return this._leafNode(new Break(label));
+		}
+		return(value) {
+			const node = new Return();
+			this._blockNode(node);
+			this.code(value);
+			if (node.nodes.length !== 1) throw new Error("CodeGen: \"return\" should have one node");
+			return this._endBlockNode(Return);
+		}
+		try(tryBody, catchCode, finallyCode) {
+			if (!catchCode && !finallyCode) throw new Error("CodeGen: \"try\" without \"catch\" and \"finally\"");
+			const node = new Try();
+			this._blockNode(node);
+			this.code(tryBody);
+			if (catchCode) {
+				const error = this.name("e");
+				this._currNode = node.catch = new Catch(error);
+				catchCode(error);
+			}
+			if (finallyCode) {
+				this._currNode = node.finally = new Finally();
+				this.code(finallyCode);
+			}
+			return this._endBlockNode(Catch, Finally);
+		}
+		throw(error) {
+			return this._leafNode(new Throw(error));
+		}
+		block(body, nodeCount) {
+			this._blockStarts.push(this._nodes.length);
+			if (body) this.code(body).endBlock(nodeCount);
+			return this;
+		}
+		endBlock(nodeCount) {
+			const len = this._blockStarts.pop();
+			if (len === void 0) throw new Error("CodeGen: not in self-balancing block");
+			const toClose = this._nodes.length - len;
+			if (toClose < 0 || nodeCount !== void 0 && toClose !== nodeCount) throw new Error(`CodeGen: wrong number of nodes: ${toClose} vs ${nodeCount} expected`);
+			this._nodes.length = len;
+			return this;
+		}
+		func(name, args = code_1.nil, async, funcBody) {
+			this._blockNode(new Func(name, args, async));
+			if (funcBody) this.code(funcBody).endFunc();
+			return this;
+		}
+		endFunc() {
+			return this._endBlockNode(Func);
+		}
+		optimize(n = 1) {
+			while (n-- > 0) {
+				this._root.optimizeNodes();
+				this._root.optimizeNames(this._root.names, this._constants);
+			}
+		}
+		_leafNode(node) {
+			this._currNode.nodes.push(node);
+			return this;
+		}
+		_blockNode(node) {
+			this._currNode.nodes.push(node);
+			this._nodes.push(node);
+		}
+		_endBlockNode(N1, N2) {
+			const n = this._currNode;
+			if (n instanceof N1 || N2 && n instanceof N2) {
+				this._nodes.pop();
+				return this;
+			}
+			throw new Error(`CodeGen: not in block "${N2 ? `${N1.kind}/${N2.kind}` : N1.kind}"`);
+		}
+		_elseNode(node) {
+			const n = this._currNode;
+			if (!(n instanceof If)) throw new Error("CodeGen: \"else\" without \"if\"");
+			this._currNode = n.else = node;
+			return this;
+		}
+		get _root() {
+			return this._nodes[0];
+		}
+		get _currNode() {
+			const ns = this._nodes;
+			return ns[ns.length - 1];
+		}
+		set _currNode(node) {
+			const ns = this._nodes;
+			ns[ns.length - 1] = node;
+		}
+	};
+	exports.CodeGen = CodeGen;
+	function addNames(names, from) {
+		for (const n in from) names[n] = (names[n] || 0) + (from[n] || 0);
+		return names;
+	}
+	function addExprNames(names, from) {
+		return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
+	}
+	function optimizeExpr(expr, names, constants) {
+		if (expr instanceof code_1.Name) return replaceName(expr);
+		if (!canOptimize(expr)) return expr;
+		return new code_1._Code(expr._items.reduce((items, c) => {
+			if (c instanceof code_1.Name) c = replaceName(c);
+			if (c instanceof code_1._Code) items.push(...c._items);
+			else items.push(c);
+			return items;
+		}, []));
+		function replaceName(n) {
+			const c = constants[n.str];
+			if (c === void 0 || names[n.str] !== 1) return n;
+			delete names[n.str];
+			return c;
+		}
+		function canOptimize(e) {
+			return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0);
+		}
+	}
+	function subtractNames(names, from) {
+		for (const n in from) names[n] = (names[n] || 0) - (from[n] || 0);
+	}
+	function not(x) {
+		return typeof x == "boolean" || typeof x == "number" || x === null ? !x : (0, code_1._)`!${par(x)}`;
+	}
+	exports.not = not;
+	const andCode = mappend(exports.operators.AND);
+	function and(...args) {
+		return args.reduce(andCode);
+	}
+	exports.and = and;
+	const orCode = mappend(exports.operators.OR);
+	function or(...args) {
+		return args.reduce(orCode);
+	}
+	exports.or = or;
+	function mappend(op) {
+		return (x, y) => x === code_1.nil ? y : y === code_1.nil ? x : (0, code_1._)`${par(x)} ${op} ${par(y)}`;
+	}
+	function par(x) {
+		return x instanceof code_1.Name ? x : (0, code_1._)`(${x})`;
+	}
+}));
+//#endregion
+export default require_codegen();
+export { require_codegen };