ai-client-sdk 4.1.1 → 4.1.3

package/dist/es/vendor-ajv-BgE6aqKX.mjs

@@ -0,0 +1,4290 @@
+import { i as e, n as t, r as n, t as r } from "./rolldown-runtime-DC4cgjXG.mjs";
+//#region node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
+var i = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.regexpCode = e.getEsmExportName = e.getProperty = e.safeStringify = e.stringify = e.strConcat = e.addCodeArg = e.str = e._ = e.nil = e._Code = e.Name = e.IDENTIFIER = e._CodeOrName = void 0;
+	var t = class {};
+	e._CodeOrName = t, e.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+	var n = class extends t {
+		constructor(t) {
+			if (super(), !e.IDENTIFIER.test(t)) throw Error("CodeGen: name must be a valid identifier");
+			this.str = t;
+		}
+		toString() {
+			return this.str;
+		}
+		emptyStr() {
+			return !1;
+		}
+		get names() {
+			return { [this.str]: 1 };
+		}
+	};
+	e.Name = n;
+	var r = class extends t {
+		constructor(e) {
+			super(), this._items = typeof e == "string" ? [e] : e;
+		}
+		toString() {
+			return this.str;
+		}
+		emptyStr() {
+			if (this._items.length > 1) return !1;
+			let e = this._items[0];
+			return e === "" || e === "\"\"";
+		}
+		get str() {
+			return this._str ??= this._items.reduce((e, t) => `${e}${t}`, "");
+		}
+		get names() {
+			return this._names ??= this._items.reduce((e, t) => (t instanceof n && (e[t.str] = (e[t.str] || 0) + 1), e), {});
+		}
+	};
+	e._Code = r, e.nil = new r("");
+	function i(e, ...t) {
+		let n = [e[0]], i = 0;
+		for (; i < t.length;) s(n, t[i]), n.push(e[++i]);
+		return new r(n);
+	}
+	e._ = i;
+	var a = new r("+");
+	function o(e, ...t) {
+		let n = [p(e[0])], i = 0;
+		for (; i < t.length;) n.push(a), s(n, t[i]), n.push(a, p(e[++i]));
+		return c(n), new r(n);
+	}
+	e.str = o;
+	function s(e, t) {
+		t instanceof r ? e.push(...t._items) : t instanceof n ? e.push(t) : e.push(d(t));
+	}
+	e.addCodeArg = s;
+	function c(e) {
+		let t = 1;
+		for (; t < e.length - 1;) {
+			if (e[t] === a) {
+				let n = l(e[t - 1], e[t + 1]);
+				if (n !== void 0) {
+					e.splice(t - 1, 3, n);
+					continue;
+				}
+				e[t++] = "+";
+			}
+			t++;
+		}
+	}
+	function l(e, t) {
+		if (t === "\"\"") return e;
+		if (e === "\"\"") return t;
+		if (typeof e == "string") return t instanceof n || e[e.length - 1] !== "\"" ? void 0 : typeof t == "string" ? t[0] === "\"" ? e.slice(0, -1) + t.slice(1) : void 0 : `${e.slice(0, -1)}${t}"`;
+		if (typeof t == "string" && t[0] === "\"" && !(e instanceof n)) return `"${e}${t.slice(1)}`;
+	}
+	function u(e, t) {
+		return t.emptyStr() ? e : e.emptyStr() ? t : o`${e}${t}`;
+	}
+	e.strConcat = u;
+	function d(e) {
+		return typeof e == "number" || typeof e == "boolean" || e === null ? e : p(Array.isArray(e) ? e.join(",") : e);
+	}
+	function f(e) {
+		return new r(p(e));
+	}
+	e.stringify = f;
+	function p(e) {
+		return JSON.stringify(e).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+	}
+	e.safeStringify = p;
+	function m(t) {
+		return typeof t == "string" && e.IDENTIFIER.test(t) ? new r(`.${t}`) : i`[${t}]`;
+	}
+	e.getProperty = m;
+	function h(t) {
+		if (typeof t == "string" && e.IDENTIFIER.test(t)) return new r(`${t}`);
+		throw Error(`CodeGen: invalid export name: ${t}, use explicit $id name mapping`);
+	}
+	e.getEsmExportName = h;
+	function g(e) {
+		return new r(e.toString());
+	}
+	e.regexpCode = g;
+})), a = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.ValueScope = e.ValueScopeName = e.Scope = e.varKinds = e.UsedValueState = void 0;
+	var t = i(), n = class extends Error {
+		constructor(e) {
+			super(`CodeGen: "code" for ${e} not defined`), this.value = e.value;
+		}
+	}, r;
+	(function(e) {
+		e[e.Started = 0] = "Started", e[e.Completed = 1] = "Completed";
+	})(r || (e.UsedValueState = r = {})), e.varKinds = {
+		const: new t.Name("const"),
+		let: new t.Name("let"),
+		var: new t.Name("var")
+	};
+	var a = class {
+		constructor({ prefixes: e, parent: t } = {}) {
+			this._names = {}, this._prefixes = e, this._parent = t;
+		}
+		toName(e) {
+			return e instanceof t.Name ? e : this.name(e);
+		}
+		name(e) {
+			return new t.Name(this._newName(e));
+		}
+		_newName(e) {
+			let t = this._names[e] || this._nameGroup(e);
+			return `${e}${t.index++}`;
+		}
+		_nameGroup(e) {
+			if ((this._parent?._prefixes)?.has(e) || this._prefixes && !this._prefixes.has(e)) throw Error(`CodeGen: prefix "${e}" is not allowed in this scope`);
+			return this._names[e] = {
+				prefix: e,
+				index: 0
+			};
+		}
+	};
+	e.Scope = a;
+	var o = class extends t.Name {
+		constructor(e, t) {
+			super(t), this.prefix = e;
+		}
+		setValue(e, { property: n, itemIndex: r }) {
+			this.value = e, this.scopePath = (0, t._)`.${new t.Name(n)}[${r}]`;
+		}
+	};
+	e.ValueScopeName = o;
+	var s = (0, t._)`\n`;
+	e.ValueScope = class extends a {
+		constructor(e) {
+			super(e), this._values = {}, this._scope = e.scope, this.opts = {
+				...e,
+				_n: e.lines ? s : t.nil
+			};
+		}
+		get() {
+			return this._scope;
+		}
+		name(e) {
+			return new o(e, this._newName(e));
+		}
+		value(e, t) {
+			if (t.ref === void 0) throw Error("CodeGen: ref must be passed in value");
+			let n = this.toName(e), { prefix: r } = n, i = t.key ?? t.ref, a = this._values[r];
+			if (a) {
+				let e = a.get(i);
+				if (e) return e;
+			} else a = this._values[r] = /* @__PURE__ */ new Map();
+			a.set(i, n);
+			let o = this._scope[r] || (this._scope[r] = []), s = o.length;
+			return o[s] = t.ref, n.setValue(t, {
+				property: r,
+				itemIndex: s
+			}), n;
+		}
+		getValue(e, t) {
+			let n = this._values[e];
+			if (n) return n.get(t);
+		}
+		scopeRefs(e, n = this._values) {
+			return this._reduceValues(n, (n) => {
+				if (n.scopePath === void 0) throw Error(`CodeGen: name "${n}" has no value`);
+				return (0, t._)`${e}${n.scopePath}`;
+			});
+		}
+		scopeCode(e = this._values, t, n) {
+			return this._reduceValues(e, (e) => {
+				if (e.value === void 0) throw Error(`CodeGen: name "${e}" has no value`);
+				return e.value.code;
+			}, t, n);
+		}
+		_reduceValues(i, a, o = {}, s) {
+			let c = t.nil;
+			for (let l in i) {
+				let u = i[l];
+				if (!u) continue;
+				let d = o[l] = o[l] || /* @__PURE__ */ new Map();
+				u.forEach((i) => {
+					if (d.has(i)) return;
+					d.set(i, r.Started);
+					let o = a(i);
+					if (o) {
+						let n = this.opts.es5 ? e.varKinds.var : e.varKinds.const;
+						c = (0, t._)`${c}${n} ${i} = ${o};${this.opts._n}`;
+					} else if (o = s?.(i)) c = (0, t._)`${c}${o}${this.opts._n}`;
+					else throw new n(i);
+					d.set(i, r.Completed);
+				});
+			}
+			return c;
+		}
+	};
+})), o = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.or = e.and = e.not = e.CodeGen = e.operators = e.varKinds = e.ValueScopeName = e.ValueScope = e.Scope = e.Name = e.regexpCode = e.stringify = e.getProperty = e.nil = e.strConcat = e.str = e._ = void 0;
+	var t = i(), n = a(), r = i();
+	Object.defineProperty(e, "_", {
+		enumerable: !0,
+		get: function() {
+			return r._;
+		}
+	}), Object.defineProperty(e, "str", {
+		enumerable: !0,
+		get: function() {
+			return r.str;
+		}
+	}), Object.defineProperty(e, "strConcat", {
+		enumerable: !0,
+		get: function() {
+			return r.strConcat;
+		}
+	}), Object.defineProperty(e, "nil", {
+		enumerable: !0,
+		get: function() {
+			return r.nil;
+		}
+	}), Object.defineProperty(e, "getProperty", {
+		enumerable: !0,
+		get: function() {
+			return r.getProperty;
+		}
+	}), Object.defineProperty(e, "stringify", {
+		enumerable: !0,
+		get: function() {
+			return r.stringify;
+		}
+	}), Object.defineProperty(e, "regexpCode", {
+		enumerable: !0,
+		get: function() {
+			return r.regexpCode;
+		}
+	}), Object.defineProperty(e, "Name", {
+		enumerable: !0,
+		get: function() {
+			return r.Name;
+		}
+	});
+	var o = a();
+	Object.defineProperty(e, "Scope", {
+		enumerable: !0,
+		get: function() {
+			return o.Scope;
+		}
+	}), Object.defineProperty(e, "ValueScope", {
+		enumerable: !0,
+		get: function() {
+			return o.ValueScope;
+		}
+	}), Object.defineProperty(e, "ValueScopeName", {
+		enumerable: !0,
+		get: function() {
+			return o.ValueScopeName;
+		}
+	}), Object.defineProperty(e, "varKinds", {
+		enumerable: !0,
+		get: function() {
+			return o.varKinds;
+		}
+	}), e.operators = {
+		GT: new t._Code(">"),
+		GTE: new t._Code(">="),
+		LT: new t._Code("<"),
+		LTE: new t._Code("<="),
+		EQ: new t._Code("==="),
+		NEQ: new t._Code("!=="),
+		NOT: new t._Code("!"),
+		OR: new t._Code("||"),
+		AND: new t._Code("&&"),
+		ADD: new t._Code("+")
+	};
+	var s = class {
+		optimizeNodes() {
+			return this;
+		}
+		optimizeNames(e, t) {
+			return this;
+		}
+	}, c = class extends s {
+		constructor(e, t, n) {
+			super(), this.varKind = e, this.name = t, this.rhs = n;
+		}
+		render({ es5: e, _n: t }) {
+			let r = e ? n.varKinds.var : this.varKind, i = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
+			return `${r} ${this.name}${i};` + t;
+		}
+		optimizeNames(e, t) {
+			if (e[this.name.str]) return this.rhs &&= j(this.rhs, e, t), this;
+		}
+		get names() {
+			return this.rhs instanceof t._CodeOrName ? this.rhs.names : {};
+		}
+	}, l = class extends s {
+		constructor(e, t, n) {
+			super(), this.lhs = e, this.rhs = t, this.sideEffects = n;
+		}
+		render({ _n: e }) {
+			return `${this.lhs} = ${this.rhs};` + e;
+		}
+		optimizeNames(e, n) {
+			if (!(this.lhs instanceof t.Name && !e[this.lhs.str] && !this.sideEffects)) return this.rhs = j(this.rhs, e, n), this;
+		}
+		get names() {
+			return A(this.lhs instanceof t.Name ? {} : { ...this.lhs.names }, this.rhs);
+		}
+	}, u = class extends l {
+		constructor(e, t, n, r) {
+			super(e, n, r), this.op = t;
+		}
+		render({ _n: e }) {
+			return `${this.lhs} ${this.op}= ${this.rhs};` + e;
+		}
+	}, d = class extends s {
+		constructor(e) {
+			super(), this.label = e, this.names = {};
+		}
+		render({ _n: e }) {
+			return `${this.label}:` + e;
+		}
+	}, f = class extends s {
+		constructor(e) {
+			super(), this.label = e, this.names = {};
+		}
+		render({ _n: e }) {
+			return `break${this.label ? ` ${this.label}` : ""};` + e;
+		}
+	}, p = class extends s {
+		constructor(e) {
+			super(), this.error = e;
+		}
+		render({ _n: e }) {
+			return `throw ${this.error};` + e;
+		}
+		get names() {
+			return this.error.names;
+		}
+	}, m = class extends s {
+		constructor(e) {
+			super(), this.code = e;
+		}
+		render({ _n: e }) {
+			return `${this.code};` + e;
+		}
+		optimizeNodes() {
+			return `${this.code}` ? this : void 0;
+		}
+		optimizeNames(e, t) {
+			return this.code = j(this.code, e, t), this;
+		}
+		get names() {
+			return this.code instanceof t._CodeOrName ? this.code.names : {};
+		}
+	}, h = class extends s {
+		constructor(e = []) {
+			super(), this.nodes = e;
+		}
+		render(e) {
+			return this.nodes.reduce((t, n) => t + n.render(e), "");
+		}
+		optimizeNodes() {
+			let { nodes: e } = this, t = e.length;
+			for (; t--;) {
+				let n = e[t].optimizeNodes();
+				Array.isArray(n) ? e.splice(t, 1, ...n) : n ? e[t] = n : e.splice(t, 1);
+			}
+			return e.length > 0 ? this : void 0;
+		}
+		optimizeNames(e, t) {
+			let { nodes: n } = this, r = n.length;
+			for (; r--;) {
+				let i = n[r];
+				i.optimizeNames(e, t) || (M(e, i.names), n.splice(r, 1));
+			}
+			return n.length > 0 ? this : void 0;
+		}
+		get names() {
+			return this.nodes.reduce((e, t) => k(e, t.names), {});
+		}
+	}, g = class extends h {
+		render(e) {
+			return "{" + e._n + super.render(e) + "}" + e._n;
+		}
+	}, _ = class extends h {}, v = class extends g {};
+	v.kind = "else";
+	var y = class e extends g {
+		constructor(e, t) {
+			super(t), this.condition = e;
+		}
+		render(e) {
+			let t = `if(${this.condition})` + super.render(e);
+			return this.else && (t += "else " + this.else.render(e)), t;
+		}
+		optimizeNodes() {
+			super.optimizeNodes();
+			let t = this.condition;
+			if (t === !0) return this.nodes;
+			let n = this.else;
+			if (n) {
+				let e = n.optimizeNodes();
+				n = this.else = Array.isArray(e) ? new v(e) : e;
+			}
+			if (n) return t === !1 ? n instanceof e ? n : n.nodes : this.nodes.length ? this : new e(N(t), n instanceof e ? [n] : n.nodes);
+			if (!(t === !1 || !this.nodes.length)) return this;
+		}
+		optimizeNames(e, t) {
+			if (this.else = this.else?.optimizeNames(e, t), super.optimizeNames(e, t) || this.else) return this.condition = j(this.condition, e, t), this;
+		}
+		get names() {
+			let e = super.names;
+			return A(e, this.condition), this.else && k(e, this.else.names), e;
+		}
+	};
+	y.kind = "if";
+	var b = class extends g {};
+	b.kind = "for";
+	var x = class extends b {
+		constructor(e) {
+			super(), this.iteration = e;
+		}
+		render(e) {
+			return `for(${this.iteration})` + super.render(e);
+		}
+		optimizeNames(e, t) {
+			if (super.optimizeNames(e, t)) return this.iteration = j(this.iteration, e, t), this;
+		}
+		get names() {
+			return k(super.names, this.iteration.names);
+		}
+	}, S = class extends b {
+		constructor(e, t, n, r) {
+			super(), this.varKind = e, this.name = t, this.from = n, this.to = r;
+		}
+		render(e) {
+			let t = e.es5 ? n.varKinds.var : this.varKind, { name: r, from: i, to: a } = this;
+			return `for(${t} ${r}=${i}; ${r}<${a}; ${r}++)` + super.render(e);
+		}
+		get names() {
+			return A(A(super.names, this.from), this.to);
+		}
+	}, C = class extends b {
+		constructor(e, t, n, r) {
+			super(), this.loop = e, this.varKind = t, this.name = n, this.iterable = r;
+		}
+		render(e) {
+			return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(e);
+		}
+		optimizeNames(e, t) {
+			if (super.optimizeNames(e, t)) return this.iterable = j(this.iterable, e, t), this;
+		}
+		get names() {
+			return k(super.names, this.iterable.names);
+		}
+	}, w = class extends g {
+		constructor(e, t, n) {
+			super(), this.name = e, this.args = t, this.async = n;
+		}
+		render(e) {
+			return `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render(e);
+		}
+	};
+	w.kind = "func";
+	var T = class extends h {
+		render(e) {
+			return "return " + super.render(e);
+		}
+	};
+	T.kind = "return";
+	var E = class extends g {
+		render(e) {
+			let t = "try" + super.render(e);
+			return this.catch && (t += this.catch.render(e)), this.finally && (t += this.finally.render(e)), t;
+		}
+		optimizeNodes() {
+			var e, t;
+			return super.optimizeNodes(), (e = this.catch) == null || e.optimizeNodes(), (t = this.finally) == null || t.optimizeNodes(), this;
+		}
+		optimizeNames(e, t) {
+			var n, r;
+			return super.optimizeNames(e, t), (n = this.catch) == null || n.optimizeNames(e, t), (r = this.finally) == null || r.optimizeNames(e, t), this;
+		}
+		get names() {
+			let e = super.names;
+			return this.catch && k(e, this.catch.names), this.finally && k(e, this.finally.names), e;
+		}
+	}, D = class extends g {
+		constructor(e) {
+			super(), this.error = e;
+		}
+		render(e) {
+			return `catch(${this.error})` + super.render(e);
+		}
+	};
+	D.kind = "catch";
+	var O = class extends g {
+		render(e) {
+			return "finally" + super.render(e);
+		}
+	};
+	O.kind = "finally", e.CodeGen = class {
+		constructor(e, t = {}) {
+			this._values = {}, this._blockStarts = [], this._constants = {}, this.opts = {
+				...t,
+				_n: t.lines ? "\n" : ""
+			}, this._extScope = e, this._scope = new n.Scope({ parent: e }), this._nodes = [new _()];
+		}
+		toString() {
+			return this._root.render(this.opts);
+		}
+		name(e) {
+			return this._scope.name(e);
+		}
+		scopeName(e) {
+			return this._extScope.name(e);
+		}
+		scopeValue(e, t) {
+			let n = this._extScope.value(e, t);
+			return (this._values[n.prefix] || (this._values[n.prefix] = /* @__PURE__ */ new Set())).add(n), n;
+		}
+		getScopeValue(e, t) {
+			return this._extScope.getValue(e, t);
+		}
+		scopeRefs(e) {
+			return this._extScope.scopeRefs(e, this._values);
+		}
+		scopeCode() {
+			return this._extScope.scopeCode(this._values);
+		}
+		_def(e, t, n, r) {
+			let i = this._scope.toName(t);
+			return n !== void 0 && r && (this._constants[i.str] = n), this._leafNode(new c(e, i, n)), i;
+		}
+		const(e, t, r) {
+			return this._def(n.varKinds.const, e, t, r);
+		}
+		let(e, t, r) {
+			return this._def(n.varKinds.let, e, t, r);
+		}
+		var(e, t, r) {
+			return this._def(n.varKinds.var, e, t, r);
+		}
+		assign(e, t, n) {
+			return this._leafNode(new l(e, t, n));
+		}
+		add(t, n) {
+			return this._leafNode(new u(t, e.operators.ADD, n));
+		}
+		code(e) {
+			return typeof e == "function" ? e() : e !== t.nil && this._leafNode(new m(e)), this;
+		}
+		object(...e) {
+			let n = ["{"];
+			for (let [r, i] of e) n.length > 1 && n.push(","), n.push(r), (r !== i || this.opts.es5) && (n.push(":"), (0, t.addCodeArg)(n, i));
+			return n.push("}"), new t._Code(n);
+		}
+		if(e, t, n) {
+			if (this._blockNode(new y(e)), t && n) this.code(t).else().code(n).endIf();
+			else if (t) this.code(t).endIf();
+			else if (n) throw Error("CodeGen: \"else\" body without \"then\" body");
+			return this;
+		}
+		elseIf(e) {
+			return this._elseNode(new y(e));
+		}
+		else() {
+			return this._elseNode(new v());
+		}
+		endIf() {
+			return this._endBlockNode(y, v);
+		}
+		_for(e, t) {
+			return this._blockNode(e), t && this.code(t).endFor(), this;
+		}
+		for(e, t) {
+			return this._for(new x(e), t);
+		}
+		forRange(e, t, r, i, a = this.opts.es5 ? n.varKinds.var : n.varKinds.let) {
+			let o = this._scope.toName(e);
+			return this._for(new S(a, o, t, r), () => i(o));
+		}
+		forOf(e, r, i, a = n.varKinds.const) {
+			let o = this._scope.toName(e);
+			if (this.opts.es5) {
+				let e = r instanceof t.Name ? r : this.var("_arr", r);
+				return this.forRange("_i", 0, (0, t._)`${e}.length`, (n) => {
+					this.var(o, (0, t._)`${e}[${n}]`), i(o);
+				});
+			}
+			return this._for(new C("of", a, o, r), () => i(o));
+		}
+		forIn(e, r, i, a = this.opts.es5 ? n.varKinds.var : n.varKinds.const) {
+			if (this.opts.ownProperties) return this.forOf(e, (0, t._)`Object.keys(${r})`, i);
+			let o = this._scope.toName(e);
+			return this._for(new C("in", a, o, r), () => i(o));
+		}
+		endFor() {
+			return this._endBlockNode(b);
+		}
+		label(e) {
+			return this._leafNode(new d(e));
+		}
+		break(e) {
+			return this._leafNode(new f(e));
+		}
+		return(e) {
+			let t = new T();
+			if (this._blockNode(t), this.code(e), t.nodes.length !== 1) throw Error("CodeGen: \"return\" should have one node");
+			return this._endBlockNode(T);
+		}
+		try(e, t, n) {
+			if (!t && !n) throw Error("CodeGen: \"try\" without \"catch\" and \"finally\"");
+			let r = new E();
+			if (this._blockNode(r), this.code(e), t) {
+				let e = this.name("e");
+				this._currNode = r.catch = new D(e), t(e);
+			}
+			return n && (this._currNode = r.finally = new O(), this.code(n)), this._endBlockNode(D, O);
+		}
+		throw(e) {
+			return this._leafNode(new p(e));
+		}
+		block(e, t) {
+			return this._blockStarts.push(this._nodes.length), e && this.code(e).endBlock(t), this;
+		}
+		endBlock(e) {
+			let t = this._blockStarts.pop();
+			if (t === void 0) throw Error("CodeGen: not in self-balancing block");
+			let n = this._nodes.length - t;
+			if (n < 0 || e !== void 0 && n !== e) throw Error(`CodeGen: wrong number of nodes: ${n} vs ${e} expected`);
+			return this._nodes.length = t, this;
+		}
+		func(e, n = t.nil, r, i) {
+			return this._blockNode(new w(e, n, r)), i && this.code(i).endFunc(), this;
+		}
+		endFunc() {
+			return this._endBlockNode(w);
+		}
+		optimize(e = 1) {
+			for (; e-- > 0;) this._root.optimizeNodes(), this._root.optimizeNames(this._root.names, this._constants);
+		}
+		_leafNode(e) {
+			return this._currNode.nodes.push(e), this;
+		}
+		_blockNode(e) {
+			this._currNode.nodes.push(e), this._nodes.push(e);
+		}
+		_endBlockNode(e, t) {
+			let n = this._currNode;
+			if (n instanceof e || t && n instanceof t) return this._nodes.pop(), this;
+			throw Error(`CodeGen: not in block "${t ? `${e.kind}/${t.kind}` : e.kind}"`);
+		}
+		_elseNode(e) {
+			let t = this._currNode;
+			if (!(t instanceof y)) throw Error("CodeGen: \"else\" without \"if\"");
+			return this._currNode = t.else = e, this;
+		}
+		get _root() {
+			return this._nodes[0];
+		}
+		get _currNode() {
+			let e = this._nodes;
+			return e[e.length - 1];
+		}
+		set _currNode(e) {
+			let t = this._nodes;
+			t[t.length - 1] = e;
+		}
+	};
+	function k(e, t) {
+		for (let n in t) e[n] = (e[n] || 0) + (t[n] || 0);
+		return e;
+	}
+	function A(e, n) {
+		return n instanceof t._CodeOrName ? k(e, n.names) : e;
+	}
+	function j(e, n, r) {
+		if (e instanceof t.Name) return i(e);
+		if (!a(e)) return e;
+		return new t._Code(e._items.reduce((e, n) => (n instanceof t.Name && (n = i(n)), n instanceof t._Code ? e.push(...n._items) : e.push(n), e), []));
+		function i(e) {
+			let t = r[e.str];
+			return t === void 0 || n[e.str] !== 1 ? e : (delete n[e.str], t);
+		}
+		function a(e) {
+			return e instanceof t._Code && e._items.some((e) => e instanceof t.Name && n[e.str] === 1 && r[e.str] !== void 0);
+		}
+	}
+	function M(e, t) {
+		for (let n in t) e[n] = (e[n] || 0) - (t[n] || 0);
+	}
+	function N(e) {
+		return typeof e == "boolean" || typeof e == "number" || e === null ? !e : (0, t._)`!${z(e)}`;
+	}
+	e.not = N;
+	var P = R(e.operators.AND);
+	function F(...e) {
+		return e.reduce(P);
+	}
+	e.and = F;
+	var I = R(e.operators.OR);
+	function L(...e) {
+		return e.reduce(I);
+	}
+	e.or = L;
+	function R(e) {
+		return (n, r) => n === t.nil ? r : r === t.nil ? n : (0, t._)`${z(n)} ${e} ${z(r)}`;
+	}
+	function z(e) {
+		return e instanceof t.Name ? e : (0, t._)`(${e})`;
+	}
+})), s = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.checkStrictMode = e.getErrorPath = e.Type = e.useFunc = e.setEvaluated = e.evaluatedPropsToName = e.mergeEvaluated = e.eachItem = e.unescapeJsonPointer = e.escapeJsonPointer = e.escapeFragment = e.unescapeFragment = e.schemaRefOrVal = e.schemaHasRulesButRef = e.schemaHasRules = e.checkUnknownRules = e.alwaysValidSchema = e.toHash = void 0;
+	var t = o(), n = i();
+	function r(e) {
+		let t = {};
+		for (let n of e) t[n] = !0;
+		return t;
+	}
+	e.toHash = r;
+	function a(e, t) {
+		return typeof t == "boolean" ? t : Object.keys(t).length === 0 ? !0 : (s(e, t), !c(t, e.self.RULES.all));
+	}
+	e.alwaysValidSchema = a;
+	function s(e, t = e.schema) {
+		let { opts: n, self: r } = e;
+		if (!n.strictSchema || typeof t == "boolean") return;
+		let i = r.RULES.keywords;
+		for (let n in t) i[n] || C(e, `unknown keyword: "${n}"`);
+	}
+	e.checkUnknownRules = s;
+	function c(e, t) {
+		if (typeof e == "boolean") return !e;
+		for (let n in e) if (t[n]) return !0;
+		return !1;
+	}
+	e.schemaHasRules = c;
+	function l(e, t) {
+		if (typeof e == "boolean") return !e;
+		for (let n in e) if (n !== "$ref" && t.all[n]) return !0;
+		return !1;
+	}
+	e.schemaHasRulesButRef = l;
+	function u({ topSchemaRef: e, schemaPath: n }, r, i, a) {
+		if (!a) {
+			if (typeof r == "number" || typeof r == "boolean") return r;
+			if (typeof r == "string") return (0, t._)`${r}`;
+		}
+		return (0, t._)`${e}${n}${(0, t.getProperty)(i)}`;
+	}
+	e.schemaRefOrVal = u;
+	function d(e) {
+		return m(decodeURIComponent(e));
+	}
+	e.unescapeFragment = d;
+	function f(e) {
+		return encodeURIComponent(p(e));
+	}
+	e.escapeFragment = f;
+	function p(e) {
+		return typeof e == "number" ? `${e}` : e.replace(/~/g, "~0").replace(/\//g, "~1");
+	}
+	e.escapeJsonPointer = p;
+	function m(e) {
+		return e.replace(/~1/g, "/").replace(/~0/g, "~");
+	}
+	e.unescapeJsonPointer = m;
+	function h(e, t) {
+		if (Array.isArray(e)) for (let n of e) t(n);
+		else t(e);
+	}
+	e.eachItem = h;
+	function g({ mergeNames: e, mergeToName: n, mergeValues: r, resultToName: i }) {
+		return (a, o, s, c) => {
+			let l = s === void 0 ? o : s instanceof t.Name ? (o instanceof t.Name ? e(a, o, s) : n(a, o, s), s) : o instanceof t.Name ? (n(a, s, o), o) : r(o, s);
+			return c === t.Name && !(l instanceof t.Name) ? i(a, l) : l;
+		};
+	}
+	e.mergeEvaluated = {
+		props: g({
+			mergeNames: (e, n, r) => e.if((0, t._)`${r} !== true && ${n} !== undefined`, () => {
+				e.if((0, t._)`${n} === true`, () => e.assign(r, !0), () => e.assign(r, (0, t._)`${r} || {}`).code((0, t._)`Object.assign(${r}, ${n})`));
+			}),
+			mergeToName: (e, n, r) => e.if((0, t._)`${r} !== true`, () => {
+				n === !0 ? e.assign(r, !0) : (e.assign(r, (0, t._)`${r} || {}`), v(e, r, n));
+			}),
+			mergeValues: (e, t) => e === !0 ? !0 : {
+				...e,
+				...t
+			},
+			resultToName: _
+		}),
+		items: g({
+			mergeNames: (e, n, r) => e.if((0, t._)`${r} !== true && ${n} !== undefined`, () => e.assign(r, (0, t._)`${n} === true ? true : ${r} > ${n} ? ${r} : ${n}`)),
+			mergeToName: (e, n, r) => e.if((0, t._)`${r} !== true`, () => e.assign(r, n === !0 ? !0 : (0, t._)`${r} > ${n} ? ${r} : ${n}`)),
+			mergeValues: (e, t) => e === !0 ? !0 : Math.max(e, t),
+			resultToName: (e, t) => e.var("items", t)
+		})
+	};
+	function _(e, n) {
+		if (n === !0) return e.var("props", !0);
+		let r = e.var("props", (0, t._)`{}`);
+		return n !== void 0 && v(e, r, n), r;
+	}
+	e.evaluatedPropsToName = _;
+	function v(e, n, r) {
+		Object.keys(r).forEach((r) => e.assign((0, t._)`${n}${(0, t.getProperty)(r)}`, !0));
+	}
+	e.setEvaluated = v;
+	var y = {};
+	function b(e, t) {
+		return e.scopeValue("func", {
+			ref: t,
+			code: y[t.code] || (y[t.code] = new n._Code(t.code))
+		});
+	}
+	e.useFunc = b;
+	var x;
+	(function(e) {
+		e[e.Num = 0] = "Num", e[e.Str = 1] = "Str";
+	})(x || (e.Type = x = {}));
+	function S(e, n, r) {
+		if (e instanceof t.Name) {
+			let i = n === x.Num;
+			return r ? i ? (0, t._)`"[" + ${e} + "]"` : (0, t._)`"['" + ${e} + "']"` : i ? (0, t._)`"/" + ${e}` : (0, t._)`"/" + ${e}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+		}
+		return r ? (0, t.getProperty)(e).toString() : "/" + p(e);
+	}
+	e.getErrorPath = S;
+	function C(e, t, n = e.opts.strictSchema) {
+		if (n) {
+			if (t = `strict mode: ${t}`, n === !0) throw Error(t);
+			e.self.logger.warn(t);
+		}
+	}
+	e.checkStrictMode = C;
+})), c = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o();
+	e.default = {
+		data: new t.Name("data"),
+		valCxt: new t.Name("valCxt"),
+		instancePath: new t.Name("instancePath"),
+		parentData: new t.Name("parentData"),
+		parentDataProperty: new t.Name("parentDataProperty"),
+		rootData: new t.Name("rootData"),
+		dynamicAnchors: new t.Name("dynamicAnchors"),
+		vErrors: new t.Name("vErrors"),
+		errors: new t.Name("errors"),
+		this: new t.Name("this"),
+		self: new t.Name("self"),
+		scope: new t.Name("scope"),
+		json: new t.Name("json"),
+		jsonPos: new t.Name("jsonPos"),
+		jsonLen: new t.Name("jsonLen"),
+		jsonPart: new t.Name("jsonPart")
+	};
+})), l = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.extendErrors = e.resetErrorsCount = e.reportExtraError = e.reportError = e.keyword$DataError = e.keywordError = void 0;
+	var t = o(), n = s(), r = c();
+	e.keywordError = { message: ({ keyword: e }) => (0, t.str)`must pass "${e}" keyword validation` }, e.keyword$DataError = { message: ({ keyword: e, schemaType: n }) => n ? (0, t.str)`"${e}" keyword must be ${n} ($data)` : (0, t.str)`"${e}" keyword is invalid ($data)` };
+	function i(n, r = e.keywordError, i, a) {
+		let { it: o } = n, { gen: s, compositeRule: c, allErrors: l } = o, u = m(n, r, i);
+		a ?? (c || l) ? d(s, u) : f(o, (0, t._)`[${u}]`);
+	}
+	e.reportError = i;
+	function a(t, n = e.keywordError, i) {
+		let { it: a } = t, { gen: o, compositeRule: s, allErrors: c } = a;
+		d(o, m(t, n, i)), s || c || f(a, r.default.vErrors);
+	}
+	e.reportExtraError = a;
+	function l(e, n) {
+		e.assign(r.default.errors, n), e.if((0, t._)`${r.default.vErrors} !== null`, () => e.if(n, () => e.assign((0, t._)`${r.default.vErrors}.length`, n), () => e.assign(r.default.vErrors, null)));
+	}
+	e.resetErrorsCount = l;
+	function u({ gen: e, keyword: n, schemaValue: i, data: a, errsCount: o, it: s }) {
+		/* istanbul ignore if */
+		if (o === void 0) throw Error("ajv implementation error");
+		let c = e.name("err");
+		e.forRange("i", o, r.default.errors, (o) => {
+			e.const(c, (0, t._)`${r.default.vErrors}[${o}]`), e.if((0, t._)`${c}.instancePath === undefined`, () => e.assign((0, t._)`${c}.instancePath`, (0, t.strConcat)(r.default.instancePath, s.errorPath))), e.assign((0, t._)`${c}.schemaPath`, (0, t.str)`${s.errSchemaPath}/${n}`), s.opts.verbose && (e.assign((0, t._)`${c}.schema`, i), e.assign((0, t._)`${c}.data`, a));
+		});
+	}
+	e.extendErrors = u;
+	function d(e, n) {
+		let i = e.const("err", n);
+		e.if((0, t._)`${r.default.vErrors} === null`, () => e.assign(r.default.vErrors, (0, t._)`[${i}]`), (0, t._)`${r.default.vErrors}.push(${i})`), e.code((0, t._)`${r.default.errors}++`);
+	}
+	function f(e, n) {
+		let { gen: r, validateName: i, schemaEnv: a } = e;
+		a.$async ? r.throw((0, t._)`new ${e.ValidationError}(${n})`) : (r.assign((0, t._)`${i}.errors`, n), r.return(!1));
+	}
+	var p = {
+		keyword: new t.Name("keyword"),
+		schemaPath: new t.Name("schemaPath"),
+		params: new t.Name("params"),
+		propertyName: new t.Name("propertyName"),
+		message: new t.Name("message"),
+		schema: new t.Name("schema"),
+		parentSchema: new t.Name("parentSchema")
+	};
+	function m(e, n, r) {
+		let { createErrors: i } = e.it;
+		return i === !1 ? (0, t._)`{}` : h(e, n, r);
+	}
+	function h(e, t, n = {}) {
+		let { gen: r, it: i } = e, a = [g(i, n), _(e, n)];
+		return v(e, t, a), r.object(...a);
+	}
+	function g({ errorPath: e }, { instancePath: i }) {
+		let a = i ? (0, t.str)`${e}${(0, n.getErrorPath)(i, n.Type.Str)}` : e;
+		return [r.default.instancePath, (0, t.strConcat)(r.default.instancePath, a)];
+	}
+	function _({ keyword: e, it: { errSchemaPath: r } }, { schemaPath: i, parentSchema: a }) {
+		let o = a ? r : (0, t.str)`${r}/${e}`;
+		return i && (o = (0, t.str)`${o}${(0, n.getErrorPath)(i, n.Type.Str)}`), [p.schemaPath, o];
+	}
+	function v(e, { params: n, message: i }, a) {
+		let { keyword: o, data: s, schemaValue: c, it: l } = e, { opts: u, propertyName: d, topSchemaRef: f, schemaPath: m } = l;
+		a.push([p.keyword, o], [p.params, typeof n == "function" ? n(e) : n || (0, t._)`{}`]), u.messages && a.push([p.message, typeof i == "function" ? i(e) : i]), u.verbose && a.push([p.schema, c], [p.parentSchema, (0, t._)`${f}${m}`], [r.default.data, s]), d && a.push([p.propertyName, d]);
+	}
+})), u = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.boolOrEmptySchema = e.topBoolOrEmptySchema = void 0;
+	var t = l(), n = o(), r = c(), i = { message: "boolean schema is false" };
+	function a(e) {
+		let { gen: t, schema: i, validateName: a } = e;
+		i === !1 ? u(e, !1) : typeof i == "object" && i.$async === !0 ? t.return(r.default.data) : (t.assign((0, n._)`${a}.errors`, null), t.return(!0));
+	}
+	e.topBoolOrEmptySchema = a;
+	function s(e, t) {
+		let { gen: n, schema: r } = e;
+		r === !1 ? (n.var(t, !1), u(e)) : n.var(t, !0);
+	}
+	e.boolOrEmptySchema = s;
+	function u(e, n) {
+		let { gen: r, data: a } = e, o = {
+			gen: r,
+			keyword: "false schema",
+			data: a,
+			schema: !1,
+			schemaCode: !1,
+			schemaValue: !1,
+			params: {},
+			it: e
+		};
+		(0, t.reportError)(o, i, void 0, n);
+	}
+})), d = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.getRules = e.isJSONType = void 0;
+	var t = new Set([
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null",
+		"object",
+		"array"
+	]);
+	function n(e) {
+		return typeof e == "string" && t.has(e);
+	}
+	e.isJSONType = n;
+	function r() {
+		let e = {
+			number: {
+				type: "number",
+				rules: []
+			},
+			string: {
+				type: "string",
+				rules: []
+			},
+			array: {
+				type: "array",
+				rules: []
+			},
+			object: {
+				type: "object",
+				rules: []
+			}
+		};
+		return {
+			types: {
+				...e,
+				integer: !0,
+				boolean: !0,
+				null: !0
+			},
+			rules: [
+				{ rules: [] },
+				e.number,
+				e.string,
+				e.array,
+				e.object
+			],
+			post: { rules: [] },
+			all: {},
+			keywords: {}
+		};
+	}
+	e.getRules = r;
+})), f = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.shouldUseRule = e.shouldUseGroup = e.schemaHasRulesForType = void 0;
+	function t({ schema: e, self: t }, r) {
+		let i = t.RULES.types[r];
+		return i && i !== !0 && n(e, i);
+	}
+	e.schemaHasRulesForType = t;
+	function n(e, t) {
+		return t.rules.some((t) => r(e, t));
+	}
+	e.shouldUseGroup = n;
+	function r(e, t) {
+		return e[t.keyword] !== void 0 || t.definition.implements?.some((t) => e[t] !== void 0);
+	}
+	e.shouldUseRule = r;
+})), p = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.reportTypeError = e.checkDataTypes = e.checkDataType = e.coerceAndCheckDataType = e.getJSONTypes = e.getSchemaTypes = e.DataType = void 0;
+	var t = d(), n = f(), r = l(), i = o(), a = s(), c;
+	(function(e) {
+		e[e.Correct = 0] = "Correct", e[e.Wrong = 1] = "Wrong";
+	})(c || (e.DataType = c = {}));
+	function u(e) {
+		let t = p(e.type);
+		if (t.includes("null")) {
+			if (e.nullable === !1) throw Error("type: null contradicts nullable: false");
+		} else {
+			if (!t.length && e.nullable !== void 0) throw Error("\"nullable\" cannot be used without \"type\"");
+			e.nullable === !0 && t.push("null");
+		}
+		return t;
+	}
+	e.getSchemaTypes = u;
+	function p(e) {
+		let n = Array.isArray(e) ? e : e ? [e] : [];
+		if (n.every(t.isJSONType)) return n;
+		throw Error("type must be JSONType or JSONType[]: " + n.join(","));
+	}
+	e.getJSONTypes = p;
+	function m(e, t) {
+		let { gen: r, data: i, opts: a } = e, o = g(t, a.coerceTypes), s = t.length > 0 && !(o.length === 0 && t.length === 1 && (0, n.schemaHasRulesForType)(e, t[0]));
+		if (s) {
+			let n = b(t, i, a.strictNumbers, c.Wrong);
+			r.if(n, () => {
+				o.length ? _(e, t, o) : S(e);
+			});
+		}
+		return s;
+	}
+	e.coerceAndCheckDataType = m;
+	var h = new Set([
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"null"
+	]);
+	function g(e, t) {
+		return t ? e.filter((e) => h.has(e) || t === "array" && e === "array") : [];
+	}
+	function _(e, t, n) {
+		let { gen: r, data: a, opts: o } = e, s = r.let("dataType", (0, i._)`typeof ${a}`), c = r.let("coerced", (0, i._)`undefined`);
+		o.coerceTypes === "array" && r.if((0, i._)`${s} == 'object' && Array.isArray(${a}) && ${a}.length == 1`, () => r.assign(a, (0, i._)`${a}[0]`).assign(s, (0, i._)`typeof ${a}`).if(b(t, a, o.strictNumbers), () => r.assign(c, a))), r.if((0, i._)`${c} !== undefined`);
+		for (let e of n) (h.has(e) || e === "array" && o.coerceTypes === "array") && l(e);
+		r.else(), S(e), r.endIf(), r.if((0, i._)`${c} !== undefined`, () => {
+			r.assign(a, c), v(e, c);
+		});
+		function l(e) {
+			switch (e) {
+				case "string":
+					r.elseIf((0, i._)`${s} == "number" || ${s} == "boolean"`).assign(c, (0, i._)`"" + ${a}`).elseIf((0, i._)`${a} === null`).assign(c, (0, i._)`""`);
+					return;
+				case "number":
+					r.elseIf((0, i._)`${s} == "boolean" || ${a} === null
+              || (${s} == "string" && ${a} && ${a} == +${a})`).assign(c, (0, i._)`+${a}`);
+					return;
+				case "integer":
+					r.elseIf((0, i._)`${s} === "boolean" || ${a} === null
+              || (${s} === "string" && ${a} && ${a} == +${a} && !(${a} % 1))`).assign(c, (0, i._)`+${a}`);
+					return;
+				case "boolean":
+					r.elseIf((0, i._)`${a} === "false" || ${a} === 0 || ${a} === null`).assign(c, !1).elseIf((0, i._)`${a} === "true" || ${a} === 1`).assign(c, !0);
+					return;
+				case "null":
+					r.elseIf((0, i._)`${a} === "" || ${a} === 0 || ${a} === false`), r.assign(c, null);
+					return;
+				case "array": r.elseIf((0, i._)`${s} === "string" || ${s} === "number"
+              || ${s} === "boolean" || ${a} === null`).assign(c, (0, i._)`[${a}]`);
+			}
+		}
+	}
+	function v({ gen: e, parentData: t, parentDataProperty: n }, r) {
+		e.if((0, i._)`${t} !== undefined`, () => e.assign((0, i._)`${t}[${n}]`, r));
+	}
+	function y(e, t, n, r = c.Correct) {
+		let a = r === c.Correct ? i.operators.EQ : i.operators.NEQ, o;
+		switch (e) {
+			case "null": return (0, i._)`${t} ${a} null`;
+			case "array":
+				o = (0, i._)`Array.isArray(${t})`;
+				break;
+			case "object":
+				o = (0, i._)`${t} && typeof ${t} == "object" && !Array.isArray(${t})`;
+				break;
+			case "integer":
+				o = s((0, i._)`!(${t} % 1) && !isNaN(${t})`);
+				break;
+			case "number":
+				o = s();
+				break;
+			default: return (0, i._)`typeof ${t} ${a} ${e}`;
+		}
+		return r === c.Correct ? o : (0, i.not)(o);
+		function s(e = i.nil) {
+			return (0, i.and)((0, i._)`typeof ${t} == "number"`, e, n ? (0, i._)`isFinite(${t})` : i.nil);
+		}
+	}
+	e.checkDataType = y;
+	function b(e, t, n, r) {
+		if (e.length === 1) return y(e[0], t, n, r);
+		let o, s = (0, a.toHash)(e);
+		if (s.array && s.object) {
+			let e = (0, i._)`typeof ${t} != "object"`;
+			o = s.null ? e : (0, i._)`!${t} || ${e}`, delete s.null, delete s.array, delete s.object;
+		} else o = i.nil;
+		s.number && delete s.integer;
+		for (let e in s) o = (0, i.and)(o, y(e, t, n, r));
+		return o;
+	}
+	e.checkDataTypes = b;
+	var x = {
+		message: ({ schema: e }) => `must be ${e}`,
+		params: ({ schema: e, schemaValue: t }) => typeof e == "string" ? (0, i._)`{type: ${e}}` : (0, i._)`{type: ${t}}`
+	};
+	function S(e) {
+		let t = C(e);
+		(0, r.reportError)(t, x);
+	}
+	e.reportTypeError = S;
+	function C(e) {
+		let { gen: t, data: n, schema: r } = e, i = (0, a.schemaRefOrVal)(e, r, "type");
+		return {
+			gen: t,
+			keyword: "type",
+			data: n,
+			schema: r.type,
+			schemaCode: i,
+			schemaValue: i,
+			parentSchema: r,
+			params: {},
+			it: e
+		};
+	}
+})), m = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.assignDefaults = void 0;
+	var t = o(), n = s();
+	function r(e, t) {
+		let { properties: n, items: r } = e.schema;
+		if (t === "object" && n) for (let t in n) i(e, t, n[t].default);
+		else t === "array" && Array.isArray(r) && r.forEach((t, n) => i(e, n, t.default));
+	}
+	e.assignDefaults = r;
+	function i(e, r, i) {
+		let { gen: a, compositeRule: o, data: s, opts: c } = e;
+		if (i === void 0) return;
+		let l = (0, t._)`${s}${(0, t.getProperty)(r)}`;
+		if (o) {
+			(0, n.checkStrictMode)(e, `default is ignored for: ${l}`);
+			return;
+		}
+		let u = (0, t._)`${l} === undefined`;
+		c.useDefaults === "empty" && (u = (0, t._)`${u} || ${l} === null || ${l} === ""`), a.if(u, (0, t._)`${l} = ${(0, t.stringify)(i)}`);
+	}
+})), h = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.validateUnion = e.validateArray = e.usePattern = e.callValidateCode = e.schemaProperties = e.allSchemaProperties = e.noPropertyInData = e.propertyInData = e.isOwnProperty = e.hasPropFunc = e.reportMissingProp = e.checkMissingProp = e.checkReportMissingProp = void 0;
+	var t = o(), n = s(), r = c(), i = s();
+	function a(e, n) {
+		let { gen: r, data: i, it: a } = e;
+		r.if(m(r, i, n, a.opts.ownProperties), () => {
+			e.setParams({ missingProperty: (0, t._)`${n}` }, !0), e.error();
+		});
+	}
+	e.checkReportMissingProp = a;
+	function l({ gen: e, data: n, it: { opts: r } }, i, a) {
+		return (0, t.or)(...i.map((i) => (0, t.and)(m(e, n, i, r.ownProperties), (0, t._)`${a} = ${i}`)));
+	}
+	e.checkMissingProp = l;
+	function u(e, t) {
+		e.setParams({ missingProperty: t }, !0), e.error();
+	}
+	e.reportMissingProp = u;
+	function d(e) {
+		return e.scopeValue("func", {
+			ref: Object.prototype.hasOwnProperty,
+			code: (0, t._)`Object.prototype.hasOwnProperty`
+		});
+	}
+	e.hasPropFunc = d;
+	function f(e, n, r) {
+		return (0, t._)`${d(e)}.call(${n}, ${r})`;
+	}
+	e.isOwnProperty = f;
+	function p(e, n, r, i) {
+		let a = (0, t._)`${n}${(0, t.getProperty)(r)} !== undefined`;
+		return i ? (0, t._)`${a} && ${f(e, n, r)}` : a;
+	}
+	e.propertyInData = p;
+	function m(e, n, r, i) {
+		let a = (0, t._)`${n}${(0, t.getProperty)(r)} === undefined`;
+		return i ? (0, t.or)(a, (0, t.not)(f(e, n, r))) : a;
+	}
+	e.noPropertyInData = m;
+	function h(e) {
+		return e ? Object.keys(e).filter((e) => e !== "__proto__") : [];
+	}
+	e.allSchemaProperties = h;
+	function g(e, t) {
+		return h(t).filter((r) => !(0, n.alwaysValidSchema)(e, t[r]));
+	}
+	e.schemaProperties = g;
+	function _({ schemaCode: e, data: n, it: { gen: i, topSchemaRef: a, schemaPath: o, errorPath: s }, it: c }, l, u, d) {
+		let f = d ? (0, t._)`${e}, ${n}, ${a}${o}` : n, p = [
+			[r.default.instancePath, (0, t.strConcat)(r.default.instancePath, s)],
+			[r.default.parentData, c.parentData],
+			[r.default.parentDataProperty, c.parentDataProperty],
+			[r.default.rootData, r.default.rootData]
+		];
+		c.opts.dynamicRef && p.push([r.default.dynamicAnchors, r.default.dynamicAnchors]);
+		let m = (0, t._)`${f}, ${i.object(...p)}`;
+		return u === t.nil ? (0, t._)`${l}(${m})` : (0, t._)`${l}.call(${u}, ${m})`;
+	}
+	e.callValidateCode = _;
+	var v = (0, t._)`new RegExp`;
+	function y({ gen: e, it: { opts: n } }, r) {
+		let a = n.unicodeRegExp ? "u" : "", { regExp: o } = n.code, s = o(r, a);
+		return e.scopeValue("pattern", {
+			key: s.toString(),
+			ref: s,
+			code: (0, t._)`${o.code === "new RegExp" ? v : (0, i.useFunc)(e, o)}(${r}, ${a})`
+		});
+	}
+	e.usePattern = y;
+	function b(e) {
+		let { gen: r, data: i, keyword: a, it: o } = e, s = r.name("valid");
+		if (o.allErrors) {
+			let e = r.let("valid", !0);
+			return c(() => r.assign(e, !1)), e;
+		}
+		return r.var(s, !0), c(() => r.break()), s;
+		function c(o) {
+			let c = r.const("len", (0, t._)`${i}.length`);
+			r.forRange("i", 0, c, (i) => {
+				e.subschema({
+					keyword: a,
+					dataProp: i,
+					dataPropType: n.Type.Num
+				}, s), r.if((0, t.not)(s), o);
+			});
+		}
+	}
+	e.validateArray = b;
+	function x(e) {
+		let { gen: r, schema: i, keyword: a, it: o } = e;
+		/* istanbul ignore if */
+		if (!Array.isArray(i)) throw Error("ajv implementation error");
+		if (i.some((e) => (0, n.alwaysValidSchema)(o, e)) && !o.opts.unevaluated) return;
+		let s = r.let("valid", !1), c = r.name("_valid");
+		r.block(() => i.forEach((n, i) => {
+			let o = e.subschema({
+				keyword: a,
+				schemaProp: i,
+				compositeRule: !0
+			}, c);
+			r.assign(s, (0, t._)`${s} || ${c}`), e.mergeValidEvaluated(o, c) || r.if((0, t.not)(s));
+		})), e.result(s, () => e.reset(), () => e.error(!0));
+	}
+	e.validateUnion = x;
+})), g = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.validateKeywordUsage = e.validSchemaType = e.funcKeywordCode = e.macroKeywordCode = void 0;
+	var t = o(), n = c(), r = h(), i = l();
+	function a(e, n) {
+		let { gen: r, keyword: i, schema: a, parentSchema: o, it: s } = e, c = n.macro.call(s.self, a, o, s), l = p(r, i, c);
+		s.opts.validateSchema !== !1 && s.self.validateSchema(c, !0);
+		let u = r.name("valid");
+		e.subschema({
+			schema: c,
+			schemaPath: t.nil,
+			errSchemaPath: `${s.errSchemaPath}/${i}`,
+			topSchemaRef: l,
+			compositeRule: !0
+		}, u), e.pass(u, () => e.error(!0));
+	}
+	e.macroKeywordCode = a;
+	function s(e, i) {
+		let { gen: a, keyword: o, schema: s, parentSchema: c, $data: l, it: m } = e;
+		f(m, i);
+		let h = p(a, o, !l && i.compile ? i.compile.call(m.self, s, c, m) : i.validate), g = a.let("valid");
+		e.block$data(g, _), e.ok(i.valid ?? g);
+		function _() {
+			if (i.errors === !1) b(), i.modifying && u(e), x(() => e.error());
+			else {
+				let t = i.async ? v() : y();
+				i.modifying && u(e), x(() => d(e, t));
+			}
+		}
+		function v() {
+			let e = a.let("ruleErrs", null);
+			return a.try(() => b((0, t._)`await `), (n) => a.assign(g, !1).if((0, t._)`${n} instanceof ${m.ValidationError}`, () => a.assign(e, (0, t._)`${n}.errors`), () => a.throw(n))), e;
+		}
+		function y() {
+			let e = (0, t._)`${h}.errors`;
+			return a.assign(e, null), b(t.nil), e;
+		}
+		function b(o = i.async ? (0, t._)`await ` : t.nil) {
+			let s = m.opts.passContext ? n.default.this : n.default.self, c = !("compile" in i && !l || i.schema === !1);
+			a.assign(g, (0, t._)`${o}${(0, r.callValidateCode)(e, h, s, c)}`, i.modifying);
+		}
+		function x(e) {
+			a.if((0, t.not)(i.valid ?? g), e);
+		}
+	}
+	e.funcKeywordCode = s;
+	function u(e) {
+		let { gen: n, data: r, it: i } = e;
+		n.if(i.parentData, () => n.assign(r, (0, t._)`${i.parentData}[${i.parentDataProperty}]`));
+	}
+	function d(e, r) {
+		let { gen: a } = e;
+		a.if((0, t._)`Array.isArray(${r})`, () => {
+			a.assign(n.default.vErrors, (0, t._)`${n.default.vErrors} === null ? ${r} : ${n.default.vErrors}.concat(${r})`).assign(n.default.errors, (0, t._)`${n.default.vErrors}.length`), (0, i.extendErrors)(e);
+		}, () => e.error());
+	}
+	function f({ schemaEnv: e }, t) {
+		if (t.async && !e.$async) throw Error("async keyword in sync schema");
+	}
+	function p(e, n, r) {
+		if (r === void 0) throw Error(`keyword "${n}" failed to compile`);
+		return e.scopeValue("keyword", typeof r == "function" ? { ref: r } : {
+			ref: r,
+			code: (0, t.stringify)(r)
+		});
+	}
+	function m(e, t, n = !1) {
+		return !t.length || t.some((t) => t === "array" ? Array.isArray(e) : t === "object" ? e && typeof e == "object" && !Array.isArray(e) : typeof e == t || n && e === void 0);
+	}
+	e.validSchemaType = m;
+	function g({ schema: e, opts: t, self: n, errSchemaPath: r }, i, a) {
+		/* istanbul ignore if */
+		if (Array.isArray(i.keyword) ? !i.keyword.includes(a) : i.keyword !== a) throw Error("ajv implementation error");
+		let o = i.dependencies;
+		if (o?.some((t) => !Object.prototype.hasOwnProperty.call(e, t))) throw Error(`parent schema must have dependencies of ${a}: ${o.join(",")}`);
+		if (i.validateSchema && !i.validateSchema(e[a])) {
+			let e = `keyword "${a}" value is invalid at path "${r}": ` + n.errorsText(i.validateSchema.errors);
+			if (t.validateSchema === "log") n.logger.error(e);
+			else throw Error(e);
+		}
+	}
+	e.validateKeywordUsage = g;
+})), _ = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.extendSubschemaMode = e.extendSubschemaData = e.getSubschema = void 0;
+	var t = o(), n = s();
+	function r(e, { keyword: r, schemaProp: i, schema: a, schemaPath: o, errSchemaPath: s, topSchemaRef: c }) {
+		if (r !== void 0 && a !== void 0) throw Error("both \"keyword\" and \"schema\" passed, only one allowed");
+		if (r !== void 0) {
+			let a = e.schema[r];
+			return i === void 0 ? {
+				schema: a,
+				schemaPath: (0, t._)`${e.schemaPath}${(0, t.getProperty)(r)}`,
+				errSchemaPath: `${e.errSchemaPath}/${r}`
+			} : {
+				schema: a[i],
+				schemaPath: (0, t._)`${e.schemaPath}${(0, t.getProperty)(r)}${(0, t.getProperty)(i)}`,
+				errSchemaPath: `${e.errSchemaPath}/${r}/${(0, n.escapeFragment)(i)}`
+			};
+		}
+		if (a !== void 0) {
+			if (o === void 0 || s === void 0 || c === void 0) throw Error("\"schemaPath\", \"errSchemaPath\" and \"topSchemaRef\" are required with \"schema\"");
+			return {
+				schema: a,
+				schemaPath: o,
+				topSchemaRef: c,
+				errSchemaPath: s
+			};
+		}
+		throw Error("either \"keyword\" or \"schema\" must be passed");
+	}
+	e.getSubschema = r;
+	function i(e, r, { dataProp: i, dataPropType: a, data: o, dataTypes: s, propertyName: c }) {
+		if (o !== void 0 && i !== void 0) throw Error("both \"data\" and \"dataProp\" passed, only one allowed");
+		let { gen: l } = r;
+		if (i !== void 0) {
+			let { errorPath: o, dataPathArr: s, opts: c } = r;
+			u(l.let("data", (0, t._)`${r.data}${(0, t.getProperty)(i)}`, !0)), e.errorPath = (0, t.str)`${o}${(0, n.getErrorPath)(i, a, c.jsPropertySyntax)}`, e.parentDataProperty = (0, t._)`${i}`, e.dataPathArr = [...s, e.parentDataProperty];
+		}
+		o !== void 0 && (u(o instanceof t.Name ? o : l.let("data", o, !0)), c !== void 0 && (e.propertyName = c)), s && (e.dataTypes = s);
+		function u(t) {
+			e.data = t, e.dataLevel = r.dataLevel + 1, e.dataTypes = [], r.definedProperties = /* @__PURE__ */ new Set(), e.parentData = r.data, e.dataNames = [...r.dataNames, t];
+		}
+	}
+	e.extendSubschemaData = i;
+	function a(e, { jtdDiscriminator: t, jtdMetadata: n, compositeRule: r, createErrors: i, allErrors: a }) {
+		r !== void 0 && (e.compositeRule = r), i !== void 0 && (e.createErrors = i), a !== void 0 && (e.allErrors = a), e.jtdDiscriminator = t, e.jtdMetadata = n;
+	}
+	e.extendSubschemaMode = a;
+})), v = /* @__PURE__ */ r(((e, t) => {
+	t.exports = function e(t, n) {
+		if (t === n) return !0;
+		if (t && n && typeof t == "object" && typeof n == "object") {
+			if (t.constructor !== n.constructor) return !1;
+			var r, i, a;
+			if (Array.isArray(t)) {
+				if (r = t.length, r != n.length) return !1;
+				for (i = r; i-- !== 0;) if (!e(t[i], n[i])) return !1;
+				return !0;
+			}
+			if (t.constructor === RegExp) return t.source === n.source && t.flags === n.flags;
+			if (t.valueOf !== Object.prototype.valueOf) return t.valueOf() === n.valueOf();
+			if (t.toString !== Object.prototype.toString) return t.toString() === n.toString();
+			if (a = Object.keys(t), r = a.length, r !== Object.keys(n).length) return !1;
+			for (i = r; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(n, a[i])) return !1;
+			for (i = r; i-- !== 0;) {
+				var o = a[i];
+				if (!e(t[o], n[o])) return !1;
+			}
+			return !0;
+		}
+		return t !== t && n !== n;
+	};
+})), y = /* @__PURE__ */ r(((e, t) => {
+	var n = t.exports = function(e, t, n) {
+		typeof t == "function" && (n = t, t = {}), n = t.cb || n;
+		var i = typeof n == "function" ? n : n.pre || function() {}, a = n.post || function() {};
+		r(t, i, a, e, "", e);
+	};
+	n.keywords = {
+		additionalItems: !0,
+		items: !0,
+		contains: !0,
+		additionalProperties: !0,
+		propertyNames: !0,
+		not: !0,
+		if: !0,
+		then: !0,
+		else: !0
+	}, n.arrayKeywords = {
+		items: !0,
+		allOf: !0,
+		anyOf: !0,
+		oneOf: !0
+	}, n.propsKeywords = {
+		$defs: !0,
+		definitions: !0,
+		properties: !0,
+		patternProperties: !0,
+		dependencies: !0
+	}, n.skipKeywords = {
+		default: !0,
+		enum: !0,
+		const: !0,
+		required: !0,
+		maximum: !0,
+		minimum: !0,
+		exclusiveMaximum: !0,
+		exclusiveMinimum: !0,
+		multipleOf: !0,
+		maxLength: !0,
+		minLength: !0,
+		pattern: !0,
+		format: !0,
+		maxItems: !0,
+		minItems: !0,
+		uniqueItems: !0,
+		maxProperties: !0,
+		minProperties: !0
+	};
+	function r(e, t, a, o, s, c, l, u, d, f) {
+		if (o && typeof o == "object" && !Array.isArray(o)) {
+			for (var p in t(o, s, c, l, u, d, f), o) {
+				var m = o[p];
+				if (Array.isArray(m)) {
+					if (p in n.arrayKeywords) for (var h = 0; h < m.length; h++) r(e, t, a, m[h], s + "/" + p + "/" + h, c, s, p, o, h);
+				} else if (p in n.propsKeywords) {
+					if (m && typeof m == "object") for (var g in m) r(e, t, a, m[g], s + "/" + p + "/" + i(g), c, s, p, o, g);
+				} else (p in n.keywords || e.allKeys && !(p in n.skipKeywords)) && r(e, t, a, m, s + "/" + p, c, s, p, o);
+			}
+			a(o, s, c, l, u, d, f);
+		}
+	}
+	function i(e) {
+		return e.replace(/~/g, "~0").replace(/\//g, "~1");
+	}
+})), b = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.getSchemaRefs = e.resolveUrl = e.normalizeId = e._getFullPath = e.getFullPath = e.inlineRef = void 0;
+	var t = s(), n = v(), r = y(), i = new Set([
+		"type",
+		"format",
+		"pattern",
+		"maxLength",
+		"minLength",
+		"maxProperties",
+		"minProperties",
+		"maxItems",
+		"minItems",
+		"maximum",
+		"minimum",
+		"uniqueItems",
+		"multipleOf",
+		"required",
+		"enum",
+		"const"
+	]);
+	function a(e, t = !0) {
+		return typeof e == "boolean" ? !0 : t === !0 ? !c(e) : t ? l(e) <= t : !1;
+	}
+	e.inlineRef = a;
+	var o = new Set([
+		"$ref",
+		"$recursiveRef",
+		"$recursiveAnchor",
+		"$dynamicRef",
+		"$dynamicAnchor"
+	]);
+	function c(e) {
+		for (let t in e) {
+			if (o.has(t)) return !0;
+			let n = e[t];
+			if (Array.isArray(n) && n.some(c) || typeof n == "object" && c(n)) return !0;
+		}
+		return !1;
+	}
+	function l(e) {
+		let n = 0;
+		for (let r in e) if (r === "$ref" || (n++, !i.has(r) && (typeof e[r] == "object" && (0, t.eachItem)(e[r], (e) => n += l(e)), n === Infinity))) return Infinity;
+		return n;
+	}
+	function u(e, t = "", n) {
+		return n !== !1 && (t = p(t)), d(e, e.parse(t));
+	}
+	e.getFullPath = u;
+	function d(e, t) {
+		return e.serialize(t).split("#")[0] + "#";
+	}
+	e._getFullPath = d;
+	var f = /#\/?$/;
+	function p(e) {
+		return e ? e.replace(f, "") : "";
+	}
+	e.normalizeId = p;
+	function m(e, t, n) {
+		return n = p(n), e.resolve(t, n);
+	}
+	e.resolveUrl = m;
+	var h = /^[a-z_][-a-z0-9._]*$/i;
+	function g(e, t) {
+		if (typeof e == "boolean") return {};
+		let { schemaId: i, uriResolver: a } = this.opts, o = p(e[i] || t), s = { "": o }, c = u(a, o, !1), l = {}, d = /* @__PURE__ */ new Set();
+		return r(e, { allKeys: !0 }, (e, t, n, r) => {
+			if (r === void 0) return;
+			let a = c + t, o = s[r];
+			typeof e[i] == "string" && (o = u.call(this, e[i])), g.call(this, e.$anchor), g.call(this, e.$dynamicAnchor), s[t] = o;
+			function u(t) {
+				let n = this.opts.uriResolver.resolve;
+				if (t = p(o ? n(o, t) : t), d.has(t)) throw m(t);
+				d.add(t);
+				let r = this.refs[t];
+				return typeof r == "string" && (r = this.refs[r]), typeof r == "object" ? f(e, r.schema, t) : t !== p(a) && (t[0] === "#" ? (f(e, l[t], t), l[t] = e) : this.refs[t] = a), t;
+			}
+			function g(e) {
+				if (typeof e == "string") {
+					if (!h.test(e)) throw Error(`invalid anchor "${e}"`);
+					u.call(this, `#${e}`);
+				}
+			}
+		}), l;
+		function f(e, t, r) {
+			if (t !== void 0 && !n(e, t)) throw m(r);
+		}
+		function m(e) {
+			return /* @__PURE__ */ Error(`reference "${e}" resolves to more than one schema`);
+		}
+	}
+	e.getSchemaRefs = g;
+})), x = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.getData = e.KeywordCxt = e.validateFunctionCode = void 0;
+	var t = u(), n = p(), r = f(), i = p(), a = m(), d = g(), h = _(), v = o(), y = c(), x = b(), S = s(), C = l();
+	function w(e) {
+		if (N(e) && (F(e), M(e))) {
+			O(e);
+			return;
+		}
+		T(e, () => (0, t.topBoolOrEmptySchema)(e));
+	}
+	e.validateFunctionCode = w;
+	function T({ gen: e, validateName: t, schema: n, schemaEnv: r, opts: i }, a) {
+		i.code.es5 ? e.func(t, (0, v._)`${y.default.data}, ${y.default.valCxt}`, r.$async, () => {
+			e.code((0, v._)`"use strict"; ${A(n, i)}`), D(e, i), e.code(a);
+		}) : e.func(t, (0, v._)`${y.default.data}, ${E(i)}`, r.$async, () => e.code(A(n, i)).code(a));
+	}
+	function E(e) {
+		return (0, v._)`{${y.default.instancePath}="", ${y.default.parentData}, ${y.default.parentDataProperty}, ${y.default.rootData}=${y.default.data}${e.dynamicRef ? (0, v._)`, ${y.default.dynamicAnchors}={}` : v.nil}}={}`;
+	}
+	function D(e, t) {
+		e.if(y.default.valCxt, () => {
+			e.var(y.default.instancePath, (0, v._)`${y.default.valCxt}.${y.default.instancePath}`), e.var(y.default.parentData, (0, v._)`${y.default.valCxt}.${y.default.parentData}`), e.var(y.default.parentDataProperty, (0, v._)`${y.default.valCxt}.${y.default.parentDataProperty}`), e.var(y.default.rootData, (0, v._)`${y.default.valCxt}.${y.default.rootData}`), t.dynamicRef && e.var(y.default.dynamicAnchors, (0, v._)`${y.default.valCxt}.${y.default.dynamicAnchors}`);
+		}, () => {
+			e.var(y.default.instancePath, (0, v._)`""`), e.var(y.default.parentData, (0, v._)`undefined`), e.var(y.default.parentDataProperty, (0, v._)`undefined`), e.var(y.default.rootData, y.default.data), t.dynamicRef && e.var(y.default.dynamicAnchors, (0, v._)`{}`);
+		});
+	}
+	function O(e) {
+		let { schema: t, opts: n, gen: r } = e;
+		T(e, () => {
+			n.$comment && t.$comment && V(e), R(e), r.let(y.default.vErrors, null), r.let(y.default.errors, 0), n.unevaluated && k(e), I(e), ee(e);
+		});
+	}
+	function k(e) {
+		let { gen: t, validateName: n } = e;
+		e.evaluated = t.const("evaluated", (0, v._)`${n}.evaluated`), t.if((0, v._)`${e.evaluated}.dynamicProps`, () => t.assign((0, v._)`${e.evaluated}.props`, (0, v._)`undefined`)), t.if((0, v._)`${e.evaluated}.dynamicItems`, () => t.assign((0, v._)`${e.evaluated}.items`, (0, v._)`undefined`));
+	}
+	function A(e, t) {
+		let n = typeof e == "object" && e[t.schemaId];
+		return n && (t.code.source || t.code.process) ? (0, v._)`/*# sourceURL=${n} */` : v.nil;
+	}
+	function j(e, n) {
+		if (N(e) && (F(e), M(e))) {
+			P(e, n);
+			return;
+		}
+		(0, t.boolOrEmptySchema)(e, n);
+	}
+	function M({ schema: e, self: t }) {
+		if (typeof e == "boolean") return !e;
+		for (let n in e) if (t.RULES.all[n]) return !0;
+		return !1;
+	}
+	function N(e) {
+		return typeof e.schema != "boolean";
+	}
+	function P(e, t) {
+		let { schema: n, gen: r, opts: i } = e;
+		i.$comment && n.$comment && V(e), z(e), B(e);
+		let a = r.const("_errs", y.default.errors);
+		I(e, a), r.var(t, (0, v._)`${a} === ${y.default.errors}`);
+	}
+	function F(e) {
+		(0, S.checkUnknownRules)(e), L(e);
+	}
+	function I(e, t) {
+		if (e.opts.jtd) return U(e, [], !1, t);
+		let r = (0, n.getSchemaTypes)(e.schema);
+		U(e, r, !(0, n.coerceAndCheckDataType)(e, r), t);
+	}
+	function L(e) {
+		let { schema: t, errSchemaPath: n, opts: r, self: i } = e;
+		t.$ref && r.ignoreKeywordsWithRef && (0, S.schemaHasRulesButRef)(t, i.RULES) && i.logger.warn(`$ref: keywords ignored in schema at path "${n}"`);
+	}
+	function R(e) {
+		let { schema: t, opts: n } = e;
+		t.default !== void 0 && n.useDefaults && n.strictSchema && (0, S.checkStrictMode)(e, "default is ignored in the schema root");
+	}
+	function z(e) {
+		let t = e.schema[e.opts.schemaId];
+		t && (e.baseId = (0, x.resolveUrl)(e.opts.uriResolver, e.baseId, t));
+	}
+	function B(e) {
+		if (e.schema.$async && !e.schemaEnv.$async) throw Error("async schema in sync schema");
+	}
+	function V({ gen: e, schemaEnv: t, schema: n, errSchemaPath: r, opts: i }) {
+		let a = n.$comment;
+		if (i.$comment === !0) e.code((0, v._)`${y.default.self}.logger.log(${a})`);
+		else if (typeof i.$comment == "function") {
+			let n = (0, v.str)`${r}/$comment`, i = e.scopeValue("root", { ref: t.root });
+			e.code((0, v._)`${y.default.self}.opts.$comment(${a}, ${n}, ${i}.schema)`);
+		}
+	}
+	function ee(e) {
+		let { gen: t, schemaEnv: n, validateName: r, ValidationError: i, opts: a } = e;
+		n.$async ? t.if((0, v._)`${y.default.errors} === 0`, () => t.return(y.default.data), () => t.throw((0, v._)`new ${i}(${y.default.vErrors})`)) : (t.assign((0, v._)`${r}.errors`, y.default.vErrors), a.unevaluated && H(e), t.return((0, v._)`${y.default.errors} === 0`));
+	}
+	function H({ gen: e, evaluated: t, props: n, items: r }) {
+		n instanceof v.Name && e.assign((0, v._)`${t}.props`, n), r instanceof v.Name && e.assign((0, v._)`${t}.items`, r);
+	}
+	function U(e, t, n, a) {
+		let { gen: o, schema: s, data: c, allErrors: l, opts: u, self: d } = e, { RULES: f } = d;
+		if (s.$ref && (u.ignoreKeywordsWithRef || !(0, S.schemaHasRulesButRef)(s, f))) {
+			o.block(() => Q(e, "$ref", f.all.$ref.definition));
+			return;
+		}
+		u.jtd || G(e, t), o.block(() => {
+			for (let e of f.rules) p(e);
+			p(f.post);
+		});
+		function p(d) {
+			(0, r.shouldUseGroup)(s, d) && (d.type ? (o.if((0, i.checkDataType)(d.type, c, u.strictNumbers)), W(e, d), t.length === 1 && t[0] === d.type && n && (o.else(), (0, i.reportTypeError)(e)), o.endIf()) : W(e, d), l || o.if((0, v._)`${y.default.errors} === ${a || 0}`));
+		}
+	}
+	function W(e, t) {
+		let { gen: n, schema: i, opts: { useDefaults: o } } = e;
+		o && (0, a.assignDefaults)(e, t.type), n.block(() => {
+			for (let n of t.rules) (0, r.shouldUseRule)(i, n) && Q(e, n.keyword, n.definition, t.type);
+		});
+	}
+	function G(e, t) {
+		e.schemaEnv.meta || !e.opts.strictTypes || (K(e, t), e.opts.allowUnionTypes || q(e, t), J(e, e.dataTypes));
+	}
+	function K(e, t) {
+		if (t.length) {
+			if (!e.dataTypes.length) {
+				e.dataTypes = t;
+				return;
+			}
+			t.forEach((t) => {
+				Y(e.dataTypes, t) || X(e, `type "${t}" not allowed by context "${e.dataTypes.join(",")}"`);
+			}), ne(e, t);
+		}
+	}
+	function q(e, t) {
+		t.length > 1 && !(t.length === 2 && t.includes("null")) && X(e, "use allowUnionTypes to allow union type keyword");
+	}
+	function J(e, t) {
+		let n = e.self.RULES.all;
+		for (let i in n) {
+			let a = n[i];
+			if (typeof a == "object" && (0, r.shouldUseRule)(e.schema, a)) {
+				let { type: n } = a.definition;
+				n.length && !n.some((e) => te(t, e)) && X(e, `missing type "${n.join(",")}" for keyword "${i}"`);
+			}
+		}
+	}
+	function te(e, t) {
+		return e.includes(t) || t === "number" && e.includes("integer");
+	}
+	function Y(e, t) {
+		return e.includes(t) || t === "integer" && e.includes("number");
+	}
+	function ne(e, t) {
+		let n = [];
+		for (let r of e.dataTypes) Y(t, r) ? n.push(r) : t.includes("integer") && r === "number" && n.push("integer");
+		e.dataTypes = n;
+	}
+	function X(e, t) {
+		let n = e.schemaEnv.baseId + e.errSchemaPath;
+		t += ` at "${n}" (strictTypes)`, (0, S.checkStrictMode)(e, t, e.opts.strictTypes);
+	}
+	var Z = class {
+		constructor(e, t, n) {
+			if ((0, d.validateKeywordUsage)(e, t, n), this.gen = e.gen, this.allErrors = e.allErrors, this.keyword = n, this.data = e.data, this.schema = e.schema[n], this.$data = t.$data && e.opts.$data && this.schema && this.schema.$data, this.schemaValue = (0, S.schemaRefOrVal)(e, this.schema, n, this.$data), this.schemaType = t.schemaType, this.parentSchema = e.schema, this.params = {}, this.it = e, this.def = t, this.$data) this.schemaCode = e.gen.const("vSchema", $(this.$data, e));
+			else if (this.schemaCode = this.schemaValue, !(0, d.validSchemaType)(this.schema, t.schemaType, t.allowUndefined)) throw Error(`${n} value must be ${JSON.stringify(t.schemaType)}`);
+			("code" in t ? t.trackErrors : t.errors !== !1) && (this.errsCount = e.gen.const("_errs", y.default.errors));
+		}
+		result(e, t, n) {
+			this.failResult((0, v.not)(e), t, n);
+		}
+		failResult(e, t, n) {
+			this.gen.if(e), n ? n() : this.error(), t ? (this.gen.else(), t(), this.allErrors && this.gen.endIf()) : this.allErrors ? this.gen.endIf() : this.gen.else();
+		}
+		pass(e, t) {
+			this.failResult((0, v.not)(e), void 0, t);
+		}
+		fail(e) {
+			if (e === void 0) {
+				this.error(), this.allErrors || this.gen.if(!1);
+				return;
+			}
+			this.gen.if(e), this.error(), this.allErrors ? this.gen.endIf() : this.gen.else();
+		}
+		fail$data(e) {
+			if (!this.$data) return this.fail(e);
+			let { schemaCode: t } = this;
+			this.fail((0, v._)`${t} !== undefined && (${(0, v.or)(this.invalid$data(), e)})`);
+		}
+		error(e, t, n) {
+			if (t) {
+				this.setParams(t), this._error(e, n), this.setParams({});
+				return;
+			}
+			this._error(e, n);
+		}
+		_error(e, t) {
+			(e ? C.reportExtraError : C.reportError)(this, this.def.error, t);
+		}
+		$dataError() {
+			(0, C.reportError)(this, this.def.$dataError || C.keyword$DataError);
+		}
+		reset() {
+			if (this.errsCount === void 0) throw Error("add \"trackErrors\" to keyword definition");
+			(0, C.resetErrorsCount)(this.gen, this.errsCount);
+		}
+		ok(e) {
+			this.allErrors || this.gen.if(e);
+		}
+		setParams(e, t) {
+			t ? Object.assign(this.params, e) : this.params = e;
+		}
+		block$data(e, t, n = v.nil) {
+			this.gen.block(() => {
+				this.check$data(e, n), t();
+			});
+		}
+		check$data(e = v.nil, t = v.nil) {
+			if (!this.$data) return;
+			let { gen: n, schemaCode: r, schemaType: i, def: a } = this;
+			n.if((0, v.or)((0, v._)`${r} === undefined`, t)), e !== v.nil && n.assign(e, !0), (i.length || a.validateSchema) && (n.elseIf(this.invalid$data()), this.$dataError(), e !== v.nil && n.assign(e, !1)), n.else();
+		}
+		invalid$data() {
+			let { gen: e, schemaCode: t, schemaType: n, def: r, it: a } = this;
+			return (0, v.or)(o(), s());
+			function o() {
+				if (n.length) {
+					/* istanbul ignore if */
+					if (!(t instanceof v.Name)) throw Error("ajv implementation error");
+					let e = Array.isArray(n) ? n : [n];
+					return (0, v._)`${(0, i.checkDataTypes)(e, t, a.opts.strictNumbers, i.DataType.Wrong)}`;
+				}
+				return v.nil;
+			}
+			function s() {
+				if (r.validateSchema) {
+					let n = e.scopeValue("validate$data", { ref: r.validateSchema });
+					return (0, v._)`!${n}(${t})`;
+				}
+				return v.nil;
+			}
+		}
+		subschema(e, t) {
+			let n = (0, h.getSubschema)(this.it, e);
+			(0, h.extendSubschemaData)(n, this.it, e), (0, h.extendSubschemaMode)(n, e);
+			let r = {
+				...this.it,
+				...n,
+				items: void 0,
+				props: void 0
+			};
+			return j(r, t), r;
+		}
+		mergeEvaluated(e, t) {
+			let { it: n, gen: r } = this;
+			n.opts.unevaluated && (n.props !== !0 && e.props !== void 0 && (n.props = S.mergeEvaluated.props(r, e.props, n.props, t)), n.items !== !0 && e.items !== void 0 && (n.items = S.mergeEvaluated.items(r, e.items, n.items, t)));
+		}
+		mergeValidEvaluated(e, t) {
+			let { it: n, gen: r } = this;
+			if (n.opts.unevaluated && (n.props !== !0 || n.items !== !0)) return r.if(t, () => this.mergeEvaluated(e, v.Name)), !0;
+		}
+	};
+	e.KeywordCxt = Z;
+	function Q(e, t, n, r) {
+		let i = new Z(e, n, t);
+		"code" in n ? n.code(i, r) : i.$data && n.validate ? (0, d.funcKeywordCode)(i, n) : "macro" in n ? (0, d.macroKeywordCode)(i, n) : (n.compile || n.validate) && (0, d.funcKeywordCode)(i, n);
+	}
+	var re = /^\/(?:[^~]|~0|~1)*$/, ie = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
+	function $(e, { dataLevel: t, dataNames: n, dataPathArr: r }) {
+		let i, a;
+		if (e === "") return y.default.rootData;
+		if (e[0] === "/") {
+			if (!re.test(e)) throw Error(`Invalid JSON-pointer: ${e}`);
+			i = e, a = y.default.rootData;
+		} else {
+			let o = ie.exec(e);
+			if (!o) throw Error(`Invalid JSON-pointer: ${e}`);
+			let s = +o[1];
+			if (i = o[2], i === "#") {
+				if (s >= t) throw Error(c("property/index", s));
+				return r[t - s];
+			}
+			if (s > t) throw Error(c("data", s));
+			if (a = n[t - s], !i) return a;
+		}
+		let o = a, s = i.split("/");
+		for (let e of s) e && (a = (0, v._)`${a}${(0, v.getProperty)((0, S.unescapeJsonPointer)(e))}`, o = (0, v._)`${o} && ${a}`);
+		return o;
+		function c(e, n) {
+			return `Cannot access ${e} ${n} levels up, current level is ${t}`;
+		}
+	}
+	e.getData = $;
+})), S = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.default = class extends Error {
+		constructor(e) {
+			super("validation failed"), this.errors = e, this.ajv = this.validation = !0;
+		}
+	};
+})), C = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = b();
+	e.default = class extends Error {
+		constructor(e, n, r, i) {
+			super(i || `can't resolve reference ${r} from id ${n}`), this.missingRef = (0, t.resolveUrl)(e, n, r), this.missingSchema = (0, t.normalizeId)((0, t.getFullPath)(e, this.missingRef));
+		}
+	};
+})), w = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.resolveSchema = e.getCompilingSchema = e.resolveRef = e.compileSchema = e.SchemaEnv = void 0;
+	var t = o(), n = S(), r = c(), i = b(), a = s(), l = x(), u = class {
+		constructor(e) {
+			this.refs = {}, this.dynamicAnchors = {};
+			let t;
+			typeof e.schema == "object" && (t = e.schema), this.schema = e.schema, this.schemaId = e.schemaId, this.root = e.root || this, this.baseId = e.baseId ?? (0, i.normalizeId)(t?.[e.schemaId || "$id"]), this.schemaPath = e.schemaPath, this.localRefs = e.localRefs, this.meta = e.meta, this.$async = t?.$async, this.refs = {};
+		}
+	};
+	e.SchemaEnv = u;
+	function d(e) {
+		let a = m.call(this, e);
+		if (a) return a;
+		let o = (0, i.getFullPath)(this.opts.uriResolver, e.root.baseId), { es5: s, lines: c } = this.opts.code, { ownProperties: u } = this.opts, d = new t.CodeGen(this.scope, {
+			es5: s,
+			lines: c,
+			ownProperties: u
+		}), f;
+		e.$async && (f = d.scopeValue("Error", {
+			ref: n.default,
+			code: (0, t._)`require("ajv/dist/runtime/validation_error").default`
+		}));
+		let p = d.scopeName("validate");
+		e.validateName = p;
+		let h = {
+			gen: d,
+			allErrors: this.opts.allErrors,
+			data: r.default.data,
+			parentData: r.default.parentData,
+			parentDataProperty: r.default.parentDataProperty,
+			dataNames: [r.default.data],
+			dataPathArr: [t.nil],
+			dataLevel: 0,
+			dataTypes: [],
+			definedProperties: /* @__PURE__ */ new Set(),
+			topSchemaRef: d.scopeValue("schema", this.opts.code.source === !0 ? {
+				ref: e.schema,
+				code: (0, t.stringify)(e.schema)
+			} : { ref: e.schema }),
+			validateName: p,
+			ValidationError: f,
+			schema: e.schema,
+			schemaEnv: e,
+			rootId: o,
+			baseId: e.baseId || o,
+			schemaPath: t.nil,
+			errSchemaPath: e.schemaPath || (this.opts.jtd ? "" : "#"),
+			errorPath: (0, t._)`""`,
+			opts: this.opts,
+			self: this
+		}, g;
+		try {
+			this._compilations.add(e), (0, l.validateFunctionCode)(h), d.optimize(this.opts.code.optimize);
+			let n = d.toString();
+			g = `${d.scopeRefs(r.default.scope)}return ${n}`, this.opts.code.process && (g = this.opts.code.process(g, e));
+			let i = Function(`${r.default.self}`, `${r.default.scope}`, g)(this, this.scope.get());
+			if (this.scope.value(p, { ref: i }), i.errors = null, i.schema = e.schema, i.schemaEnv = e, e.$async && (i.$async = !0), this.opts.code.source === !0 && (i.source = {
+				validateName: p,
+				validateCode: n,
+				scopeValues: d._values
+			}), this.opts.unevaluated) {
+				let { props: e, items: n } = h;
+				i.evaluated = {
+					props: e instanceof t.Name ? void 0 : e,
+					items: n instanceof t.Name ? void 0 : n,
+					dynamicProps: e instanceof t.Name,
+					dynamicItems: n instanceof t.Name
+				}, i.source && (i.source.evaluated = (0, t.stringify)(i.evaluated));
+			}
+			return e.validate = i, e;
+		} catch (t) {
+			throw delete e.validate, delete e.validateName, g && this.logger.error("Error compiling schema, function code:", g), t;
+		} finally {
+			this._compilations.delete(e);
+		}
+	}
+	e.compileSchema = d;
+	function f(e, t, n) {
+		n = (0, i.resolveUrl)(this.opts.uriResolver, t, n);
+		let r = e.refs[n];
+		if (r) return r;
+		let a = g.call(this, e, n);
+		if (a === void 0) {
+			let r = e.localRefs?.[n], { schemaId: i } = this.opts;
+			r && (a = new u({
+				schema: r,
+				schemaId: i,
+				root: e,
+				baseId: t
+			}));
+		}
+		if (a !== void 0) return e.refs[n] = p.call(this, a);
+	}
+	e.resolveRef = f;
+	function p(e) {
+		return (0, i.inlineRef)(e.schema, this.opts.inlineRefs) ? e.schema : e.validate ? e : d.call(this, e);
+	}
+	function m(e) {
+		for (let t of this._compilations) if (h(t, e)) return t;
+	}
+	e.getCompilingSchema = m;
+	function h(e, t) {
+		return e.schema === t.schema && e.root === t.root && e.baseId === t.baseId;
+	}
+	function g(e, t) {
+		let n;
+		for (; typeof (n = this.refs[t]) == "string";) t = n;
+		return n || this.schemas[t] || _.call(this, e, t);
+	}
+	function _(e, t) {
+		let n = this.opts.uriResolver.parse(t), r = (0, i._getFullPath)(this.opts.uriResolver, n), a = (0, i.getFullPath)(this.opts.uriResolver, e.baseId, void 0);
+		if (Object.keys(e.schema).length > 0 && r === a) return y.call(this, n, e);
+		let o = (0, i.normalizeId)(r), s = this.refs[o] || this.schemas[o];
+		if (typeof s == "string") {
+			let t = _.call(this, e, s);
+			return typeof t?.schema == "object" ? y.call(this, n, t) : void 0;
+		}
+		if (typeof s?.schema == "object") {
+			if (s.validate || d.call(this, s), o === (0, i.normalizeId)(t)) {
+				let { schema: t } = s, { schemaId: n } = this.opts, r = t[n];
+				return r && (a = (0, i.resolveUrl)(this.opts.uriResolver, a, r)), new u({
+					schema: t,
+					schemaId: n,
+					root: e,
+					baseId: a
+				});
+			}
+			return y.call(this, n, s);
+		}
+	}
+	e.resolveSchema = _;
+	var v = new Set([
+		"properties",
+		"patternProperties",
+		"enum",
+		"dependencies",
+		"definitions"
+	]);
+	function y(e, { baseId: t, schema: n, root: r }) {
+		if (e.fragment?.[0] !== "/") return;
+		for (let r of e.fragment.slice(1).split("/")) {
+			if (typeof n == "boolean") return;
+			let e = n[(0, a.unescapeFragment)(r)];
+			if (e === void 0) return;
+			n = e;
+			let o = typeof n == "object" && n[this.opts.schemaId];
+			!v.has(r) && o && (t = (0, i.resolveUrl)(this.opts.uriResolver, t, o));
+		}
+		let o;
+		if (typeof n != "boolean" && n.$ref && !(0, a.schemaHasRulesButRef)(n, this.RULES)) {
+			let e = (0, i.resolveUrl)(this.opts.uriResolver, t, n.$ref);
+			o = _.call(this, r, e);
+		}
+		let { schemaId: s } = this.opts;
+		if (o ||= new u({
+			schema: n,
+			schemaId: s,
+			root: r,
+			baseId: t
+		}), o.schema !== o.root.schema) return o;
+	}
+})), T = /* @__PURE__ */ n({
+	$id: () => E,
+	additionalProperties: () => !1,
+	default: () => j,
+	description: () => D,
+	properties: () => A,
+	required: () => k,
+	type: () => O
+}), E, D, O, k, A, j, M = t((() => {
+	E = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", D = "Meta-schema for $data reference (JSON AnySchema extension proposal)", O = "object", k = ["$data"], A = { $data: {
+		type: "string",
+		anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }]
+	} }, j = {
+		$id: E,
+		description: D,
+		type: O,
+		required: k,
+		properties: A,
+		additionalProperties: !1
+	};
+})), N = /* @__PURE__ */ r(((e, t) => {
+	var n = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu), r = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u), i = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu), a = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu), o = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+	function s(e) {
+		let t = "", n = 0, r = 0;
+		for (r = 0; r < e.length; r++) if (n = e[r].charCodeAt(0), n !== 48) {
+			if (!(n >= 48 && n <= 57 || n >= 65 && n <= 70 || n >= 97 && n <= 102)) return "";
+			t += e[r];
+			break;
+		}
+		for (r += 1; r < e.length; r++) {
+			if (n = e[r].charCodeAt(0), !(n >= 48 && n <= 57 || n >= 65 && n <= 70 || n >= 97 && n <= 102)) return "";
+			t += e[r];
+		}
+		return t;
+	}
+	var c = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+	function l(e) {
+		return e.length = 0, !0;
+	}
+	function u(e, t, n) {
+		if (e.length) {
+			let r = s(e);
+			if (r !== "") t.push(r);
+			else return n.error = !0, !1;
+			e.length = 0;
+		}
+		return !0;
+	}
+	function d(e) {
+		let t = 0, n = {
+			error: !1,
+			address: "",
+			zone: ""
+		}, r = [], i = [], a = !1, o = !1, c = u;
+		for (let s = 0; s < e.length; s++) {
+			let u = e[s];
+			if (!(u === "[" || u === "]")) if (u === ":") {
+				if (a === !0 && (o = !0), !c(i, r, n)) break;
+				if (++t > 7) {
+					n.error = !0;
+					break;
+				}
+				s > 0 && e[s - 1] === ":" && (a = !0), r.push(":");
+				continue;
+			} else if (u === "%") {
+				if (!c(i, r, n)) break;
+				c = l;
+			} else {
+				i.push(u);
+				continue;
+			}
+		}
+		return i.length && (c === l ? n.zone = i.join("") : o ? r.push(i.join("")) : r.push(s(i))), n.address = r.join(""), n;
+	}
+	function f(e) {
+		if (p(e, ":") < 2) return {
+			host: e,
+			isIPV6: !1
+		};
+		let t = d(e);
+		if (t.error) return {
+			host: e,
+			isIPV6: !1
+		};
+		{
+			let e = t.address, n = t.address;
+			return t.zone && (e += "%" + t.zone, n += "%25" + t.zone), {
+				host: e,
+				isIPV6: !0,
+				escapedHost: n
+			};
+		}
+	}
+	function p(e, t) {
+		let n = 0;
+		for (let r = 0; r < e.length; r++) e[r] === t && n++;
+		return n;
+	}
+	function m(e) {
+		let t = e, n = [], r = -1, i = 0;
+		for (; i = t.length;) {
+			if (i === 1) {
+				if (t === ".") break;
+				if (t === "/") {
+					n.push("/");
+					break;
+				} else {
+					n.push(t);
+					break;
+				}
+			} else if (i === 2) {
+				if (t[0] === ".") {
+					if (t[1] === ".") break;
+					if (t[1] === "/") {
+						t = t.slice(2);
+						continue;
+					}
+				} else if (t[0] === "/" && (t[1] === "." || t[1] === "/")) {
+					n.push("/");
+					break;
+				}
+			} else if (i === 3 && t === "/..") {
+				n.length !== 0 && n.pop(), n.push("/");
+				break;
+			}
+			if (t[0] === ".") {
+				if (t[1] === ".") {
+					if (t[2] === "/") {
+						t = t.slice(3);
+						continue;
+					}
+				} else if (t[1] === "/") {
+					t = t.slice(2);
+					continue;
+				}
+			} else if (t[0] === "/" && t[1] === ".") {
+				if (t[2] === "/") {
+					t = t.slice(2);
+					continue;
+				} else if (t[2] === "." && t[3] === "/") {
+					t = t.slice(3), n.length !== 0 && n.pop();
+					continue;
+				}
+			}
+			if ((r = t.indexOf("/", 1)) === -1) {
+				n.push(t);
+				break;
+			} else n.push(t.slice(0, r)), t = t.slice(r);
+		}
+		return n.join("");
+	}
+	var h = {
+		"@": "%40",
+		"/": "%2F",
+		"?": "%3F",
+		"#": "%23",
+		":": "%3A"
+	}, g = /[@/?#:]/g, _ = /[@/?#]/g;
+	function v(e, t) {
+		let n = t ? _ : g;
+		return n.lastIndex = 0, e.replace(n, (e) => h[e]);
+	}
+	function y(e, t = !1) {
+		if (e.indexOf("%") === -1) return e;
+		let n = "";
+		for (let r = 0; r < e.length; r++) {
+			if (e[r] === "%" && r + 2 < e.length) {
+				let o = e.slice(r + 1, r + 3);
+				if (i(o)) {
+					let e = o.toUpperCase(), i = String.fromCharCode(parseInt(e, 16));
+					t && a(i) ? n += i : n += "%" + e, r += 2;
+					continue;
+				}
+			}
+			n += e[r];
+		}
+		return n;
+	}
+	function b(e) {
+		let t = "";
+		for (let n = 0; n < e.length; n++) {
+			if (e[n] === "%" && n + 2 < e.length) {
+				let r = e.slice(n + 1, n + 3);
+				if (i(r)) {
+					let e = r.toUpperCase(), i = String.fromCharCode(parseInt(e, 16));
+					i !== "." && a(i) ? t += i : t += "%" + e, n += 2;
+					continue;
+				}
+			}
+			o(e[n]) ? t += e[n] : t += escape(e[n]);
+		}
+		return t;
+	}
+	function x(e) {
+		let t = "";
+		for (let n = 0; n < e.length; n++) {
+			if (e[n] === "%" && n + 2 < e.length) {
+				let r = e.slice(n + 1, n + 3);
+				if (i(r)) {
+					t += "%" + r.toUpperCase(), n += 2;
+					continue;
+				}
+			}
+			t += escape(e[n]);
+		}
+		return t;
+	}
+	function S(e) {
+		let t = [];
+		if (e.userinfo !== void 0 && (t.push(e.userinfo), t.push("@")), e.host !== void 0) {
+			let n = unescape(e.host);
+			if (!r(n)) {
+				let e = f(n);
+				n = e.isIPV6 === !0 ? `[${e.escapedHost}]` : v(n, !1);
+			}
+			t.push(n);
+		}
+		return (typeof e.port == "number" || typeof e.port == "string") && (t.push(":"), t.push(String(e.port))), t.length ? t.join("") : void 0;
+	}
+	t.exports = {
+		nonSimpleDomain: c,
+		recomposeAuthority: S,
+		reescapeHostDelimiters: v,
+		normalizePercentEncoding: y,
+		normalizePathEncoding: b,
+		escapePreservingEscapes: x,
+		removeDotSegments: m,
+		isIPv4: r,
+		isUUID: n,
+		normalizeIPv6: f,
+		stringArrayToHexStripped: s
+	};
+})), P = /* @__PURE__ */ r(((e, t) => {
+	var { isUUID: n } = N(), r = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu, i = [
+		"http",
+		"https",
+		"ws",
+		"wss",
+		"urn",
+		"urn:uuid"
+	];
+	function a(e) {
+		return i.indexOf(e) !== -1;
+	}
+	function o(e) {
+		return e.secure === !0 ? !0 : e.secure === !1 ? !1 : e.scheme ? e.scheme.length === 3 && (e.scheme[0] === "w" || e.scheme[0] === "W") && (e.scheme[1] === "s" || e.scheme[1] === "S") && (e.scheme[2] === "s" || e.scheme[2] === "S") : !1;
+	}
+	function s(e) {
+		return e.host || (e.error = e.error || "HTTP URIs must have a host."), e;
+	}
+	function c(e) {
+		let t = String(e.scheme).toLowerCase() === "https";
+		return (e.port === (t ? 443 : 80) || e.port === "") && (e.port = void 0), e.path ||= "/", e;
+	}
+	function l(e) {
+		return e.secure = o(e), e.resourceName = (e.path || "/") + (e.query ? "?" + e.query : ""), e.path = void 0, e.query = void 0, e;
+	}
+	function u(e) {
+		if ((e.port === (o(e) ? 443 : 80) || e.port === "") && (e.port = void 0), typeof e.secure == "boolean" && (e.scheme = e.secure ? "wss" : "ws", e.secure = void 0), e.resourceName) {
+			let [t, n] = e.resourceName.split("?");
+			e.path = t && t !== "/" ? t : void 0, e.query = n, e.resourceName = void 0;
+		}
+		return e.fragment = void 0, e;
+	}
+	function d(e, t) {
+		if (!e.path) return e.error = "URN can not be parsed", e;
+		let n = e.path.match(r);
+		if (n) {
+			let r = t.scheme || e.scheme || "urn";
+			e.nid = n[1].toLowerCase(), e.nss = n[2];
+			let i = y(`${r}:${t.nid || e.nid}`);
+			e.path = void 0, i && (e = i.parse(e, t));
+		} else e.error = e.error || "URN can not be parsed.";
+		return e;
+	}
+	function f(e, t) {
+		if (e.nid === void 0) throw Error("URN without nid cannot be serialized");
+		let n = t.scheme || e.scheme || "urn", r = e.nid.toLowerCase(), i = y(`${n}:${t.nid || r}`);
+		i && (e = i.serialize(e, t));
+		let a = e, o = e.nss;
+		return a.path = `${r || t.nid}:${o}`, t.skipEscape = !0, a;
+	}
+	function p(e, t) {
+		let r = e;
+		return r.uuid = r.nss, r.nss = void 0, !t.tolerant && (!r.uuid || !n(r.uuid)) && (r.error = r.error || "UUID is not valid."), r;
+	}
+	function m(e) {
+		let t = e;
+		return t.nss = (e.uuid || "").toLowerCase(), t;
+	}
+	var h = {
+		scheme: "http",
+		domainHost: !0,
+		parse: s,
+		serialize: c
+	}, g = {
+		scheme: "https",
+		domainHost: h.domainHost,
+		parse: s,
+		serialize: c
+	}, _ = {
+		scheme: "ws",
+		domainHost: !0,
+		parse: l,
+		serialize: u
+	}, v = {
+		http: h,
+		https: g,
+		ws: _,
+		wss: {
+			scheme: "wss",
+			domainHost: _.domainHost,
+			parse: _.parse,
+			serialize: _.serialize
+		},
+		urn: {
+			scheme: "urn",
+			parse: d,
+			serialize: f,
+			skipNormalize: !0
+		},
+		"urn:uuid": {
+			scheme: "urn:uuid",
+			parse: p,
+			serialize: m,
+			skipNormalize: !0
+		}
+	};
+	Object.setPrototypeOf(v, null);
+	function y(e) {
+		return e && (v[e] || v[e.toLowerCase()]) || void 0;
+	}
+	t.exports = {
+		wsIsSecure: o,
+		SCHEMES: v,
+		isValidSchemeName: a,
+		getSchemeHandler: y
+	};
+})), F = /* @__PURE__ */ r(((e, t) => {
+	var { normalizeIPv6: n, removeDotSegments: r, recomposeAuthority: i, normalizePercentEncoding: a, normalizePathEncoding: o, escapePreservingEscapes: s, reescapeHostDelimiters: c, isIPv4: l, nonSimpleDomain: u } = N(), { SCHEMES: d, getSchemeHandler: f } = P();
+	function p(e, t) {
+		return typeof e == "string" ? e = S(e, t) : typeof e == "object" && (e = x(_(e, t), t)), e;
+	}
+	function m(e, t, n) {
+		let r = n ? Object.assign({ scheme: "null" }, n) : { scheme: "null" }, i = h(x(e, r), x(t, r), r, !0);
+		return r.skipEscape = !0, _(i, r);
+	}
+	function h(e, t, n, i) {
+		let a = {};
+		return i || (e = x(_(e, n), n), t = x(_(t, n), n)), n ||= {}, !n.tolerant && t.scheme ? (a.scheme = t.scheme, a.userinfo = t.userinfo, a.host = t.host, a.port = t.port, a.path = r(t.path || ""), a.query = t.query) : (t.userinfo !== void 0 || t.host !== void 0 || t.port !== void 0 ? (a.userinfo = t.userinfo, a.host = t.host, a.port = t.port, a.path = r(t.path || ""), a.query = t.query) : (t.path ? (t.path[0] === "/" ? a.path = r(t.path) : ((e.userinfo !== void 0 || e.host !== void 0 || e.port !== void 0) && !e.path ? a.path = "/" + t.path : e.path ? a.path = e.path.slice(0, e.path.lastIndexOf("/") + 1) + t.path : a.path = t.path, a.path = r(a.path)), a.query = t.query) : (a.path = e.path, t.query === void 0 ? a.query = e.query : a.query = t.query), a.userinfo = e.userinfo, a.host = e.host, a.port = e.port), a.scheme = e.scheme), a.fragment = t.fragment, a;
+	}
+	function g(e, t, n) {
+		let r = w(e, n), i = w(t, n);
+		return r !== void 0 && i !== void 0 && r.toLowerCase() === i.toLowerCase();
+	}
+	function _(e, t) {
+		let n = {
+			host: e.host,
+			scheme: e.scheme,
+			userinfo: e.userinfo,
+			port: e.port,
+			path: e.path,
+			query: e.query,
+			nid: e.nid,
+			nss: e.nss,
+			uuid: e.uuid,
+			fragment: e.fragment,
+			reference: e.reference,
+			resourceName: e.resourceName,
+			secure: e.secure,
+			error: ""
+		}, o = Object.assign({}, t), c = [], l = f(o.scheme || n.scheme);
+		l && l.serialize && l.serialize(n, o), n.path !== void 0 && (o.skipEscape ? n.path = a(n.path) : (n.path = s(n.path), n.scheme !== void 0 && (n.path = n.path.split("%3A").join(":")))), o.reference !== "suffix" && n.scheme && c.push(n.scheme, ":");
+		let u = i(n);
+		if (u !== void 0 && (o.reference !== "suffix" && c.push("//"), c.push(u), n.path && n.path[0] !== "/" && c.push("/")), n.path !== void 0) {
+			let e = n.path;
+			!o.absolutePath && (!l || !l.absolutePath) && (e = r(e)), u === void 0 && e[0] === "/" && e[1] === "/" && (e = "/%2F" + e.slice(2)), c.push(e);
+		}
+		return n.query !== void 0 && c.push("?", n.query), n.fragment !== void 0 && c.push("#", n.fragment), c.join("");
+	}
+	var v = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+	function y(e, t) {
+		if (t[2] !== void 0 && e.path && e.path[0] !== "/") return "URI path must start with \"/\" when authority is present.";
+		if (typeof e.port == "number" && (e.port < 0 || e.port > 65535)) return "URI port is malformed.";
+	}
+	function b(e, t) {
+		let r = Object.assign({}, t), i = {
+			scheme: void 0,
+			userinfo: void 0,
+			host: "",
+			port: void 0,
+			path: "",
+			query: void 0,
+			fragment: void 0
+		}, a = !1, s = !1;
+		r.reference === "suffix" && (e = r.scheme ? r.scheme + ":" + e : "//" + e);
+		let d = e.match(v);
+		if (d) {
+			i.scheme = d[1], i.userinfo = d[3], i.host = d[4], i.port = parseInt(d[5], 10), i.path = d[6] || "", i.query = d[7], i.fragment = d[8], isNaN(i.port) && (i.port = d[5]);
+			let t = y(i, d);
+			if (t !== void 0 && (i.error = i.error || t, a = !0), i.host) if (l(i.host) === !1) {
+				let e = n(i.host);
+				i.host = e.host.toLowerCase(), s = e.isIPV6;
+			} else s = !0;
+			i.scheme === void 0 && i.userinfo === void 0 && i.host === void 0 && i.port === void 0 && i.query === void 0 && !i.path ? i.reference = "same-document" : i.scheme === void 0 ? i.reference = "relative" : i.fragment === void 0 ? i.reference = "absolute" : i.reference = "uri", r.reference && r.reference !== "suffix" && r.reference !== i.reference && (i.error = i.error || "URI is not a " + r.reference + " reference.");
+			let p = f(r.scheme || i.scheme);
+			if (!r.unicodeSupport && (!p || !p.unicodeSupport) && i.host && (r.domainHost || p && p.domainHost) && s === !1 && u(i.host)) try {
+				i.host = URL.domainToASCII(i.host.toLowerCase());
+			} catch (e) {
+				i.error = i.error || "Host's domain name can not be converted to ASCII: " + e;
+			}
+			if ((!p || p && !p.skipNormalize) && (e.indexOf("%") !== -1 && (i.scheme !== void 0 && (i.scheme = unescape(i.scheme)), i.host !== void 0 && (i.host = c(unescape(i.host), s))), i.path &&= o(i.path), i.fragment)) try {
+				i.fragment = encodeURI(decodeURIComponent(i.fragment));
+			} catch {
+				i.error = i.error || "URI malformed";
+			}
+			p && p.parse && p.parse(i, r);
+		} else i.error = i.error || "URI can not be parsed.";
+		return {
+			parsed: i,
+			malformedAuthorityOrPort: a
+		};
+	}
+	function x(e, t) {
+		return b(e, t).parsed;
+	}
+	function S(e, t) {
+		return C(e, t).normalized;
+	}
+	function C(e, t) {
+		let { parsed: n, malformedAuthorityOrPort: r } = b(e, t);
+		return {
+			normalized: r ? e : _(n, t),
+			malformedAuthorityOrPort: r
+		};
+	}
+	function w(e, t) {
+		if (typeof e == "string") {
+			let { normalized: n, malformedAuthorityOrPort: r } = C(e, t);
+			return r ? void 0 : n;
+		}
+		if (typeof e == "object") return _(e, t);
+	}
+	var T = {
+		SCHEMES: d,
+		normalize: p,
+		resolve: m,
+		resolveComponent: h,
+		equal: g,
+		serialize: _,
+		parse: x
+	};
+	t.exports = T, t.exports.default = T, t.exports.fastUri = T;
+})), I = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = F();
+	t.code = "require(\"ajv/dist/runtime/uri\").default", e.default = t;
+})), L = /* @__PURE__ */ r(((t) => {
+	Object.defineProperty(t, "__esModule", { value: !0 }), t.CodeGen = t.Name = t.nil = t.stringify = t.str = t._ = t.KeywordCxt = void 0;
+	var n = x();
+	Object.defineProperty(t, "KeywordCxt", {
+		enumerable: !0,
+		get: function() {
+			return n.KeywordCxt;
+		}
+	});
+	var r = o();
+	Object.defineProperty(t, "_", {
+		enumerable: !0,
+		get: function() {
+			return r._;
+		}
+	}), Object.defineProperty(t, "str", {
+		enumerable: !0,
+		get: function() {
+			return r.str;
+		}
+	}), Object.defineProperty(t, "stringify", {
+		enumerable: !0,
+		get: function() {
+			return r.stringify;
+		}
+	}), Object.defineProperty(t, "nil", {
+		enumerable: !0,
+		get: function() {
+			return r.nil;
+		}
+	}), Object.defineProperty(t, "Name", {
+		enumerable: !0,
+		get: function() {
+			return r.Name;
+		}
+	}), Object.defineProperty(t, "CodeGen", {
+		enumerable: !0,
+		get: function() {
+			return r.CodeGen;
+		}
+	});
+	var i = S(), a = C(), c = d(), l = w(), u = o(), f = b(), m = p(), h = s(), g = (M(), e(T).default), _ = I(), v = (e, t) => new RegExp(e, t);
+	v.code = "new RegExp";
+	var y = [
+		"removeAdditional",
+		"useDefaults",
+		"coerceTypes"
+	], E = new Set([
+		"validate",
+		"serialize",
+		"parse",
+		"wrapper",
+		"root",
+		"schema",
+		"keyword",
+		"pattern",
+		"formats",
+		"validate$data",
+		"func",
+		"obj",
+		"Error"
+	]), D = {
+		errorDataPath: "",
+		format: "`validateFormats: false` can be used instead.",
+		nullable: "\"nullable\" keyword is supported by default.",
+		jsonPointers: "Deprecated jsPropertySyntax can be used instead.",
+		extendRefs: "Deprecated ignoreKeywordsWithRef can be used instead.",
+		missingRefs: "Pass empty schema with $id that should be ignored to ajv.addSchema.",
+		processCode: "Use option `code: {process: (code, schemaEnv: object) => string}`",
+		sourceCode: "Use option `code: {source: true}`",
+		strictDefaults: "It is default now, see option `strict`.",
+		strictKeywords: "It is default now, see option `strict`.",
+		uniqueItems: "\"uniqueItems\" keyword is always validated.",
+		unknownFormats: "Disable strict mode or pass `true` to `ajv.addFormat` (or `formats` option).",
+		cache: "Map is used as cache, schema object as key.",
+		serialize: "Map is used as cache, schema object as key.",
+		ajvErrors: "It is default now."
+	}, O = {
+		ignoreKeywordsWithRef: "",
+		jsPropertySyntax: "",
+		unicode: "\"minLength\"/\"maxLength\" account for unicode characters by default."
+	}, k = 200;
+	function A(e) {
+		let t = e.strict, n = e.code?.optimize, r = n === !0 || n === void 0 ? 1 : n || 0, i = e.code?.regExp ?? v, a = e.uriResolver ?? _.default;
+		return {
+			strictSchema: e.strictSchema ?? t ?? !0,
+			strictNumbers: e.strictNumbers ?? t ?? !0,
+			strictTypes: e.strictTypes ?? t ?? "log",
+			strictTuples: e.strictTuples ?? t ?? "log",
+			strictRequired: e.strictRequired ?? t ?? !1,
+			code: e.code ? {
+				...e.code,
+				optimize: r,
+				regExp: i
+			} : {
+				optimize: r,
+				regExp: i
+			},
+			loopRequired: e.loopRequired ?? k,
+			loopEnum: e.loopEnum ?? k,
+			meta: e.meta ?? !0,
+			messages: e.messages ?? !0,
+			inlineRefs: e.inlineRefs ?? !0,
+			schemaId: e.schemaId ?? "$id",
+			addUsedSchema: e.addUsedSchema ?? !0,
+			validateSchema: e.validateSchema ?? !0,
+			validateFormats: e.validateFormats ?? !0,
+			unicodeRegExp: e.unicodeRegExp ?? !0,
+			int32range: e.int32range ?? !0,
+			uriResolver: a
+		};
+	}
+	var j = class {
+		constructor(e = {}) {
+			this.schemas = {}, this.refs = {}, this.formats = Object.create(null), this._compilations = /* @__PURE__ */ new Set(), this._loading = {}, this._cache = /* @__PURE__ */ new Map(), e = this.opts = {
+				...e,
+				...A(e)
+			};
+			let { es5: t, lines: n } = this.opts.code;
+			this.scope = new u.ValueScope({
+				scope: {},
+				prefixes: E,
+				es5: t,
+				lines: n
+			}), this.logger = V(e.logger);
+			let r = e.validateFormats;
+			e.validateFormats = !1, this.RULES = (0, c.getRules)(), N.call(this, D, e, "NOT SUPPORTED"), N.call(this, O, e, "DEPRECATED", "warn"), this._metaOpts = z.call(this), e.formats && L.call(this), this._addVocabularies(), this._addDefaultMetaSchema(), e.keywords && R.call(this, e.keywords), typeof e.meta == "object" && this.addMetaSchema(e.meta), F.call(this), e.validateFormats = r;
+		}
+		_addVocabularies() {
+			this.addKeyword("$async");
+		}
+		_addDefaultMetaSchema() {
+			let { $data: e, meta: t, schemaId: n } = this.opts, r = g;
+			n === "id" && (r = { ...g }, r.id = r.$id, delete r.$id), t && e && this.addMetaSchema(r, r[n], !1);
+		}
+		defaultMeta() {
+			let { meta: e, schemaId: t } = this.opts;
+			return this.opts.defaultMeta = typeof e == "object" ? e[t] || e : void 0;
+		}
+		validate(e, t) {
+			let n;
+			if (typeof e == "string") {
+				if (n = this.getSchema(e), !n) throw Error(`no schema with key or ref "${e}"`);
+			} else n = this.compile(e);
+			let r = n(t);
+			return "$async" in n || (this.errors = n.errors), r;
+		}
+		compile(e, t) {
+			let n = this._addSchema(e, t);
+			return n.validate || this._compileSchemaEnv(n);
+		}
+		compileAsync(e, t) {
+			if (typeof this.opts.loadSchema != "function") throw Error("options.loadSchema should be a function");
+			let { loadSchema: n } = this.opts;
+			return r.call(this, e, t);
+			async function r(e, t) {
+				await i.call(this, e.$schema);
+				let n = this._addSchema(e, t);
+				return n.validate || o.call(this, n);
+			}
+			async function i(e) {
+				e && !this.getSchema(e) && await r.call(this, { $ref: e }, !0);
+			}
+			async function o(e) {
+				try {
+					return this._compileSchemaEnv(e);
+				} catch (t) {
+					if (!(t instanceof a.default)) throw t;
+					return s.call(this, t), await c.call(this, t.missingSchema), o.call(this, e);
+				}
+			}
+			function s({ missingSchema: e, missingRef: t }) {
+				if (this.refs[e]) throw Error(`AnySchema ${e} is loaded but ${t} cannot be resolved`);
+			}
+			async function c(e) {
+				let n = await l.call(this, e);
+				this.refs[e] || await i.call(this, n.$schema), this.refs[e] || this.addSchema(n, e, t);
+			}
+			async function l(e) {
+				let t = this._loading[e];
+				if (t) return t;
+				try {
+					return await (this._loading[e] = n(e));
+				} finally {
+					delete this._loading[e];
+				}
+			}
+		}
+		addSchema(e, t, n, r = this.opts.validateSchema) {
+			if (Array.isArray(e)) {
+				for (let t of e) this.addSchema(t, void 0, n, r);
+				return this;
+			}
+			let i;
+			if (typeof e == "object") {
+				let { schemaId: t } = this.opts;
+				if (i = e[t], i !== void 0 && typeof i != "string") throw Error(`schema ${t} must be string`);
+			}
+			return t = (0, f.normalizeId)(t || i), this._checkUnique(t), this.schemas[t] = this._addSchema(e, n, t, r, !0), this;
+		}
+		addMetaSchema(e, t, n = this.opts.validateSchema) {
+			return this.addSchema(e, t, !0, n), this;
+		}
+		validateSchema(e, t) {
+			if (typeof e == "boolean") return !0;
+			let n;
+			if (n = e.$schema, n !== void 0 && typeof n != "string") throw Error("$schema must be a string");
+			if (n = n || this.opts.defaultMeta || this.defaultMeta(), !n) return this.logger.warn("meta-schema not available"), this.errors = null, !0;
+			let r = this.validate(n, e);
+			if (!r && t) {
+				let e = "schema is invalid: " + this.errorsText();
+				if (this.opts.validateSchema === "log") this.logger.error(e);
+				else throw Error(e);
+			}
+			return r;
+		}
+		getSchema(e) {
+			let t;
+			for (; typeof (t = P.call(this, e)) == "string";) e = t;
+			if (t === void 0) {
+				let { schemaId: n } = this.opts, r = new l.SchemaEnv({
+					schema: {},
+					schemaId: n
+				});
+				if (t = l.resolveSchema.call(this, r, e), !t) return;
+				this.refs[e] = t;
+			}
+			return t.validate || this._compileSchemaEnv(t);
+		}
+		removeSchema(e) {
+			if (e instanceof RegExp) return this._removeAllSchemas(this.schemas, e), this._removeAllSchemas(this.refs, e), this;
+			switch (typeof e) {
+				case "undefined": return this._removeAllSchemas(this.schemas), this._removeAllSchemas(this.refs), this._cache.clear(), this;
+				case "string": {
+					let t = P.call(this, e);
+					return typeof t == "object" && this._cache.delete(t.schema), delete this.schemas[e], delete this.refs[e], this;
+				}
+				case "object": {
+					let t = e;
+					this._cache.delete(t);
+					let n = e[this.opts.schemaId];
+					return n && (n = (0, f.normalizeId)(n), delete this.schemas[n], delete this.refs[n]), this;
+				}
+				default: throw Error("ajv.removeSchema: invalid parameter");
+			}
+		}
+		addVocabulary(e) {
+			for (let t of e) this.addKeyword(t);
+			return this;
+		}
+		addKeyword(e, t) {
+			let n;
+			if (typeof e == "string") n = e, typeof t == "object" && (this.logger.warn("these parameters are deprecated, see docs for addKeyword"), t.keyword = n);
+			else if (typeof e == "object" && t === void 0) {
+				if (t = e, n = t.keyword, Array.isArray(n) && !n.length) throw Error("addKeywords: keyword must be string or non-empty array");
+			} else throw Error("invalid addKeywords parameters");
+			if (H.call(this, n, t), !t) return (0, h.eachItem)(n, (e) => U.call(this, e)), this;
+			G.call(this, t);
+			let r = {
+				...t,
+				type: (0, m.getJSONTypes)(t.type),
+				schemaType: (0, m.getJSONTypes)(t.schemaType)
+			};
+			return (0, h.eachItem)(n, r.type.length === 0 ? (e) => U.call(this, e, r) : (e) => r.type.forEach((t) => U.call(this, e, r, t))), this;
+		}
+		getKeyword(e) {
+			let t = this.RULES.all[e];
+			return typeof t == "object" ? t.definition : !!t;
+		}
+		removeKeyword(e) {
+			let { RULES: t } = this;
+			delete t.keywords[e], delete t.all[e];
+			for (let n of t.rules) {
+				let t = n.rules.findIndex((t) => t.keyword === e);
+				t >= 0 && n.rules.splice(t, 1);
+			}
+			return this;
+		}
+		addFormat(e, t) {
+			return typeof t == "string" && (t = new RegExp(t)), this.formats[e] = t, this;
+		}
+		errorsText(e = this.errors, { separator: t = ", ", dataVar: n = "data" } = {}) {
+			return !e || e.length === 0 ? "No errors" : e.map((e) => `${n}${e.instancePath} ${e.message}`).reduce((e, n) => e + t + n);
+		}
+		$dataMetaSchema(e, t) {
+			let n = this.RULES.all;
+			e = JSON.parse(JSON.stringify(e));
+			for (let r of t) {
+				let t = r.split("/").slice(1), i = e;
+				for (let e of t) i = i[e];
+				for (let e in n) {
+					let t = n[e];
+					if (typeof t != "object") continue;
+					let { $data: r } = t.definition, a = i[e];
+					r && a && (i[e] = q(a));
+				}
+			}
+			return e;
+		}
+		_removeAllSchemas(e, t) {
+			for (let n in e) {
+				let r = e[n];
+				(!t || t.test(n)) && (typeof r == "string" ? delete e[n] : r && !r.meta && (this._cache.delete(r.schema), delete e[n]));
+			}
+		}
+		_addSchema(e, t, n, r = this.opts.validateSchema, i = this.opts.addUsedSchema) {
+			let a, { schemaId: o } = this.opts;
+			if (typeof e == "object") a = e[o];
+			else if (this.opts.jtd) throw Error("schema must be object");
+			else if (typeof e != "boolean") throw Error("schema must be object or boolean");
+			let s = this._cache.get(e);
+			if (s !== void 0) return s;
+			n = (0, f.normalizeId)(a || n);
+			let c = f.getSchemaRefs.call(this, e, n);
+			return s = new l.SchemaEnv({
+				schema: e,
+				schemaId: o,
+				meta: t,
+				baseId: n,
+				localRefs: c
+			}), this._cache.set(s.schema, s), i && !n.startsWith("#") && (n && this._checkUnique(n), this.refs[n] = s), r && this.validateSchema(e, !0), s;
+		}
+		_checkUnique(e) {
+			if (this.schemas[e] || this.refs[e]) throw Error(`schema with key or id "${e}" already exists`);
+		}
+		_compileSchemaEnv(e) {
+			/* istanbul ignore if */
+			if (e.meta ? this._compileMetaSchema(e) : l.compileSchema.call(this, e), !e.validate) throw Error("ajv implementation error");
+			return e.validate;
+		}
+		_compileMetaSchema(e) {
+			let t = this.opts;
+			this.opts = this._metaOpts;
+			try {
+				l.compileSchema.call(this, e);
+			} finally {
+				this.opts = t;
+			}
+		}
+	};
+	j.ValidationError = i.default, j.MissingRefError = a.default, t.default = j;
+	function N(e, t, n, r = "error") {
+		for (let i in e) {
+			let a = i;
+			a in t && this.logger[r](`${n}: option ${i}. ${e[a]}`);
+		}
+	}
+	function P(e) {
+		return e = (0, f.normalizeId)(e), this.schemas[e] || this.refs[e];
+	}
+	function F() {
+		let e = this.opts.schemas;
+		if (e) if (Array.isArray(e)) this.addSchema(e);
+		else for (let t in e) this.addSchema(e[t], t);
+	}
+	function L() {
+		for (let e in this.opts.formats) {
+			let t = this.opts.formats[e];
+			t && this.addFormat(e, t);
+		}
+	}
+	function R(e) {
+		if (Array.isArray(e)) {
+			this.addVocabulary(e);
+			return;
+		}
+		this.logger.warn("keywords option as map is deprecated, pass array");
+		for (let t in e) {
+			let n = e[t];
+			n.keyword ||= t, this.addKeyword(n);
+		}
+	}
+	function z() {
+		let e = { ...this.opts };
+		for (let t of y) delete e[t];
+		return e;
+	}
+	var B = {
+		log() {},
+		warn() {},
+		error() {}
+	};
+	function V(e) {
+		if (e === !1) return B;
+		if (e === void 0) return console;
+		if (e.log && e.warn && e.error) return e;
+		throw Error("logger must implement log, warn and error methods");
+	}
+	var ee = /^[a-z_$][a-z0-9_$:-]*$/i;
+	function H(e, t) {
+		let { RULES: n } = this;
+		if ((0, h.eachItem)(e, (e) => {
+			if (n.keywords[e]) throw Error(`Keyword ${e} is already defined`);
+			if (!ee.test(e)) throw Error(`Keyword ${e} has invalid name`);
+		}), t && t.$data && !("code" in t || "validate" in t)) throw Error("$data keyword must have \"code\" or \"validate\" function");
+	}
+	function U(e, t, n) {
+		var r;
+		let i = t?.post;
+		if (n && i) throw Error("keyword with \"post\" flag cannot have \"type\"");
+		let { RULES: a } = this, o = i ? a.post : a.rules.find(({ type: e }) => e === n);
+		if (o || (o = {
+			type: n,
+			rules: []
+		}, a.rules.push(o)), a.keywords[e] = !0, !t) return;
+		let s = {
+			keyword: e,
+			definition: {
+				...t,
+				type: (0, m.getJSONTypes)(t.type),
+				schemaType: (0, m.getJSONTypes)(t.schemaType)
+			}
+		};
+		t.before ? W.call(this, o, s, t.before) : o.rules.push(s), a.all[e] = s, (r = t.implements) == null || r.forEach((e) => this.addKeyword(e));
+	}
+	function W(e, t, n) {
+		let r = e.rules.findIndex((e) => e.keyword === n);
+		r >= 0 ? e.rules.splice(r, 0, t) : (e.rules.push(t), this.logger.warn(`rule ${n} is not defined`));
+	}
+	function G(e) {
+		let { metaSchema: t } = e;
+		t !== void 0 && (e.$data && this.opts.$data && (t = q(t)), e.validateSchema = this.compile(t, !0));
+	}
+	var K = { $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" };
+	function q(e) {
+		return { anyOf: [e, K] };
+	}
+})), R = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.default = {
+		keyword: "id",
+		code() {
+			throw Error("NOT SUPPORTED: keyword \"id\", use \"$id\" for schema ID");
+		}
+	};
+})), z = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.callRef = e.getValidate = void 0;
+	var t = C(), n = h(), r = o(), i = c(), a = w(), l = s(), u = {
+		keyword: "$ref",
+		schemaType: "string",
+		code(e) {
+			let { gen: n, schema: i, it: o } = e, { baseId: s, schemaEnv: c, validateName: l, opts: u, self: p } = o, { root: m } = c;
+			if ((i === "#" || i === "#/") && s === m.baseId) return g();
+			let h = a.resolveRef.call(p, m, s, i);
+			if (h === void 0) throw new t.default(o.opts.uriResolver, s, i);
+			if (h instanceof a.SchemaEnv) return _(h);
+			return v(h);
+			function g() {
+				if (c === m) return f(e, l, c, c.$async);
+				let t = n.scopeValue("root", { ref: m });
+				return f(e, (0, r._)`${t}.validate`, m, m.$async);
+			}
+			function _(t) {
+				f(e, d(e, t), t, t.$async);
+			}
+			function v(t) {
+				let a = n.scopeValue("schema", u.code.source === !0 ? {
+					ref: t,
+					code: (0, r.stringify)(t)
+				} : { ref: t }), o = n.name("valid"), s = e.subschema({
+					schema: t,
+					dataTypes: [],
+					schemaPath: r.nil,
+					topSchemaRef: a,
+					errSchemaPath: i
+				}, o);
+				e.mergeEvaluated(s), e.ok(o);
+			}
+		}
+	};
+	function d(e, t) {
+		let { gen: n } = e;
+		return t.validate ? n.scopeValue("validate", { ref: t.validate }) : (0, r._)`${n.scopeValue("wrapper", { ref: t })}.validate`;
+	}
+	e.getValidate = d;
+	function f(e, t, a, o) {
+		let { gen: s, it: c } = e, { allErrors: u, schemaEnv: d, opts: f } = c, p = f.passContext ? i.default.this : r.nil;
+		o ? m() : h();
+		function m() {
+			if (!d.$async) throw Error("async schema referenced by sync schema");
+			let i = s.let("valid");
+			s.try(() => {
+				s.code((0, r._)`await ${(0, n.callValidateCode)(e, t, p)}`), _(t), u || s.assign(i, !0);
+			}, (e) => {
+				s.if((0, r._)`!(${e} instanceof ${c.ValidationError})`, () => s.throw(e)), g(e), u || s.assign(i, !1);
+			}), e.ok(i);
+		}
+		function h() {
+			e.result((0, n.callValidateCode)(e, t, p), () => _(t), () => g(t));
+		}
+		function g(e) {
+			let t = (0, r._)`${e}.errors`;
+			s.assign(i.default.vErrors, (0, r._)`${i.default.vErrors} === null ? ${t} : ${i.default.vErrors}.concat(${t})`), s.assign(i.default.errors, (0, r._)`${i.default.vErrors}.length`);
+		}
+		function _(e) {
+			if (!c.opts.unevaluated) return;
+			let t = a?.validate?.evaluated;
+			if (c.props !== !0) if (t && !t.dynamicProps) t.props !== void 0 && (c.props = l.mergeEvaluated.props(s, t.props, c.props));
+			else {
+				let t = s.var("props", (0, r._)`${e}.evaluated.props`);
+				c.props = l.mergeEvaluated.props(s, t, c.props, r.Name);
+			}
+			if (c.items !== !0) if (t && !t.dynamicItems) t.items !== void 0 && (c.items = l.mergeEvaluated.items(s, t.items, c.items));
+			else {
+				let t = s.var("items", (0, r._)`${e}.evaluated.items`);
+				c.items = l.mergeEvaluated.items(s, t, c.items, r.Name);
+			}
+		}
+	}
+	e.callRef = f, e.default = u;
+})), B = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = R(), n = z();
+	e.default = [
+		"$schema",
+		"$id",
+		"$defs",
+		"$vocabulary",
+		{ keyword: "$comment" },
+		"definitions",
+		t.default,
+		n.default
+	];
+})), V = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = t.operators, r = {
+		maximum: {
+			okStr: "<=",
+			ok: n.LTE,
+			fail: n.GT
+		},
+		minimum: {
+			okStr: ">=",
+			ok: n.GTE,
+			fail: n.LT
+		},
+		exclusiveMaximum: {
+			okStr: "<",
+			ok: n.LT,
+			fail: n.GTE
+		},
+		exclusiveMinimum: {
+			okStr: ">",
+			ok: n.GT,
+			fail: n.LTE
+		}
+	};
+	e.default = {
+		keyword: Object.keys(r),
+		type: "number",
+		schemaType: "number",
+		$data: !0,
+		error: {
+			message: ({ keyword: e, schemaCode: n }) => (0, t.str)`must be ${r[e].okStr} ${n}`,
+			params: ({ keyword: e, schemaCode: n }) => (0, t._)`{comparison: ${r[e].okStr}, limit: ${n}}`
+		},
+		code(e) {
+			let { keyword: n, data: i, schemaCode: a } = e;
+			e.fail$data((0, t._)`${i} ${r[n].fail} ${a} || isNaN(${i})`);
+		}
+	};
+})), ee = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o();
+	e.default = {
+		keyword: "multipleOf",
+		type: "number",
+		schemaType: "number",
+		$data: !0,
+		error: {
+			message: ({ schemaCode: e }) => (0, t.str)`must be multiple of ${e}`,
+			params: ({ schemaCode: e }) => (0, t._)`{multipleOf: ${e}}`
+		},
+		code(e) {
+			let { gen: n, data: r, schemaCode: i, it: a } = e, o = a.opts.multipleOfPrecision, s = n.let("res"), c = o ? (0, t._)`Math.abs(Math.round(${s}) - ${s}) > 1e-${o}` : (0, t._)`${s} !== parseInt(${s})`;
+			e.fail$data((0, t._)`(${i} === 0 || (${s} = ${r}/${i}, ${c}))`);
+		}
+	};
+})), H = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	function t(e) {
+		let t = e.length, n = 0, r = 0, i;
+		for (; r < t;) n++, i = e.charCodeAt(r++), i >= 55296 && i <= 56319 && r < t && (i = e.charCodeAt(r), (i & 64512) == 56320 && r++);
+		return n;
+	}
+	e.default = t, t.code = "require(\"ajv/dist/runtime/ucs2length\").default";
+})), U = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = s(), r = H();
+	e.default = {
+		keyword: ["maxLength", "minLength"],
+		type: "string",
+		schemaType: "number",
+		$data: !0,
+		error: {
+			message({ keyword: e, schemaCode: n }) {
+				let r = e === "maxLength" ? "more" : "fewer";
+				return (0, t.str)`must NOT have ${r} than ${n} characters`;
+			},
+			params: ({ schemaCode: e }) => (0, t._)`{limit: ${e}}`
+		},
+		code(e) {
+			let { keyword: i, data: a, schemaCode: o, it: s } = e, c = i === "maxLength" ? t.operators.GT : t.operators.LT, l = s.opts.unicode === !1 ? (0, t._)`${a}.length` : (0, t._)`${(0, n.useFunc)(e.gen, r.default)}(${a})`;
+			e.fail$data((0, t._)`${l} ${c} ${o}`);
+		}
+	};
+})), W = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = h(), n = s(), r = o();
+	e.default = {
+		keyword: "pattern",
+		type: "string",
+		schemaType: "string",
+		$data: !0,
+		error: {
+			message: ({ schemaCode: e }) => (0, r.str)`must match pattern "${e}"`,
+			params: ({ schemaCode: e }) => (0, r._)`{pattern: ${e}}`
+		},
+		code(e) {
+			let { gen: i, data: a, $data: o, schema: s, schemaCode: c, it: l } = e, u = l.opts.unicodeRegExp ? "u" : "";
+			if (o) {
+				let { regExp: t } = l.opts.code, o = t.code === "new RegExp" ? (0, r._)`new RegExp` : (0, n.useFunc)(i, t), s = i.let("valid");
+				i.try(() => i.assign(s, (0, r._)`${o}(${c}, ${u}).test(${a})`), () => i.assign(s, !1)), e.fail$data((0, r._)`!${s}`);
+			} else {
+				let n = (0, t.usePattern)(e, s);
+				e.fail$data((0, r._)`!${n}.test(${a})`);
+			}
+		}
+	};
+})), G = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o();
+	e.default = {
+		keyword: ["maxProperties", "minProperties"],
+		type: "object",
+		schemaType: "number",
+		$data: !0,
+		error: {
+			message({ keyword: e, schemaCode: n }) {
+				let r = e === "maxProperties" ? "more" : "fewer";
+				return (0, t.str)`must NOT have ${r} than ${n} properties`;
+			},
+			params: ({ schemaCode: e }) => (0, t._)`{limit: ${e}}`
+		},
+		code(e) {
+			let { keyword: n, data: r, schemaCode: i } = e, a = n === "maxProperties" ? t.operators.GT : t.operators.LT;
+			e.fail$data((0, t._)`Object.keys(${r}).length ${a} ${i}`);
+		}
+	};
+})), K = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = h(), n = o(), r = s();
+	e.default = {
+		keyword: "required",
+		type: "object",
+		schemaType: "array",
+		$data: !0,
+		error: {
+			message: ({ params: { missingProperty: e } }) => (0, n.str)`must have required property '${e}'`,
+			params: ({ params: { missingProperty: e } }) => (0, n._)`{missingProperty: ${e}}`
+		},
+		code(e) {
+			let { gen: i, schema: a, schemaCode: o, data: s, $data: c, it: l } = e, { opts: u } = l;
+			if (!c && a.length === 0) return;
+			let d = a.length >= u.loopRequired;
+			if (l.allErrors ? f() : p(), u.strictRequired) {
+				let t = e.parentSchema.properties, { definedProperties: n } = e.it;
+				for (let e of a) if (t?.[e] === void 0 && !n.has(e)) {
+					let t = `required property "${e}" is not defined at "${l.schemaEnv.baseId + l.errSchemaPath}" (strictRequired)`;
+					(0, r.checkStrictMode)(l, t, l.opts.strictRequired);
+				}
+			}
+			function f() {
+				if (d || c) e.block$data(n.nil, m);
+				else for (let n of a) (0, t.checkReportMissingProp)(e, n);
+			}
+			function p() {
+				let n = i.let("missing");
+				if (d || c) {
+					let t = i.let("valid", !0);
+					e.block$data(t, () => h(n, t)), e.ok(t);
+				} else i.if((0, t.checkMissingProp)(e, a, n)), (0, t.reportMissingProp)(e, n), i.else();
+			}
+			function m() {
+				i.forOf("prop", o, (n) => {
+					e.setParams({ missingProperty: n }), i.if((0, t.noPropertyInData)(i, s, n, u.ownProperties), () => e.error());
+				});
+			}
+			function h(r, a) {
+				e.setParams({ missingProperty: r }), i.forOf(r, o, () => {
+					i.assign(a, (0, t.propertyInData)(i, s, r, u.ownProperties)), i.if((0, n.not)(a), () => {
+						e.error(), i.break();
+					});
+				}, n.nil);
+			}
+		}
+	};
+})), q = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o();
+	e.default = {
+		keyword: ["maxItems", "minItems"],
+		type: "array",
+		schemaType: "number",
+		$data: !0,
+		error: {
+			message({ keyword: e, schemaCode: n }) {
+				let r = e === "maxItems" ? "more" : "fewer";
+				return (0, t.str)`must NOT have ${r} than ${n} items`;
+			},
+			params: ({ schemaCode: e }) => (0, t._)`{limit: ${e}}`
+		},
+		code(e) {
+			let { keyword: n, data: r, schemaCode: i } = e, a = n === "maxItems" ? t.operators.GT : t.operators.LT;
+			e.fail$data((0, t._)`${r}.length ${a} ${i}`);
+		}
+	};
+})), J = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = v();
+	t.code = "require(\"ajv/dist/runtime/equal\").default", e.default = t;
+})), te = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = p(), n = o(), r = s(), i = J();
+	e.default = {
+		keyword: "uniqueItems",
+		type: "array",
+		schemaType: "boolean",
+		$data: !0,
+		error: {
+			message: ({ params: { i: e, j: t } }) => (0, n.str)`must NOT have duplicate items (items ## ${t} and ${e} are identical)`,
+			params: ({ params: { i: e, j: t } }) => (0, n._)`{i: ${e}, j: ${t}}`
+		},
+		code(e) {
+			let { gen: a, data: o, $data: s, schema: c, parentSchema: l, schemaCode: u, it: d } = e;
+			if (!s && !c) return;
+			let f = a.let("valid"), p = l.items ? (0, t.getSchemaTypes)(l.items) : [];
+			e.block$data(f, m, (0, n._)`${u} === false`), e.ok(f);
+			function m() {
+				let t = a.let("i", (0, n._)`${o}.length`), r = a.let("j");
+				e.setParams({
+					i: t,
+					j: r
+				}), a.assign(f, !0), a.if((0, n._)`${t} > 1`, () => (h() ? g : _)(t, r));
+			}
+			function h() {
+				return p.length > 0 && !p.some((e) => e === "object" || e === "array");
+			}
+			function g(r, i) {
+				let s = a.name("item"), c = (0, t.checkDataTypes)(p, s, d.opts.strictNumbers, t.DataType.Wrong), l = a.const("indices", (0, n._)`{}`);
+				a.for((0, n._)`;${r}--;`, () => {
+					a.let(s, (0, n._)`${o}[${r}]`), a.if(c, (0, n._)`continue`), p.length > 1 && a.if((0, n._)`typeof ${s} == "string"`, (0, n._)`${s} += "_"`), a.if((0, n._)`typeof ${l}[${s}] == "number"`, () => {
+						a.assign(i, (0, n._)`${l}[${s}]`), e.error(), a.assign(f, !1).break();
+					}).code((0, n._)`${l}[${s}] = ${r}`);
+				});
+			}
+			function _(t, s) {
+				let c = (0, r.useFunc)(a, i.default), l = a.name("outer");
+				a.label(l).for((0, n._)`;${t}--;`, () => a.for((0, n._)`${s} = ${t}; ${s}--;`, () => a.if((0, n._)`${c}(${o}[${t}], ${o}[${s}])`, () => {
+					e.error(), a.assign(f, !1).break(l);
+				})));
+			}
+		}
+	};
+})), Y = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = s(), r = J();
+	e.default = {
+		keyword: "const",
+		$data: !0,
+		error: {
+			message: "must be equal to constant",
+			params: ({ schemaCode: e }) => (0, t._)`{allowedValue: ${e}}`
+		},
+		code(e) {
+			let { gen: i, data: a, $data: o, schemaCode: s, schema: c } = e;
+			o || c && typeof c == "object" ? e.fail$data((0, t._)`!${(0, n.useFunc)(i, r.default)}(${a}, ${s})`) : e.fail((0, t._)`${c} !== ${a}`);
+		}
+	};
+})), ne = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = s(), r = J();
+	e.default = {
+		keyword: "enum",
+		schemaType: "array",
+		$data: !0,
+		error: {
+			message: "must be equal to one of the allowed values",
+			params: ({ schemaCode: e }) => (0, t._)`{allowedValues: ${e}}`
+		},
+		code(e) {
+			let { gen: i, data: a, $data: o, schema: s, schemaCode: c, it: l } = e;
+			if (!o && s.length === 0) throw Error("enum must have non-empty array");
+			let u = s.length >= l.opts.loopEnum, d, f = () => d ??= (0, n.useFunc)(i, r.default), p;
+			if (u || o) p = i.let("valid"), e.block$data(p, m);
+			else {
+				/* istanbul ignore if */
+				if (!Array.isArray(s)) throw Error("ajv implementation error");
+				let e = i.const("vSchema", c);
+				p = (0, t.or)(...s.map((t, n) => h(e, n)));
+			}
+			e.pass(p);
+			function m() {
+				i.assign(p, !1), i.forOf("v", c, (e) => i.if((0, t._)`${f()}(${a}, ${e})`, () => i.assign(p, !0).break()));
+			}
+			function h(e, n) {
+				let r = s[n];
+				return typeof r == "object" && r ? (0, t._)`${f()}(${a}, ${e}[${n}])` : (0, t._)`${a} === ${r}`;
+			}
+		}
+	};
+})), X = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = V(), n = ee(), r = U(), i = W(), a = G(), o = K(), s = q(), c = te(), l = Y(), u = ne();
+	e.default = [
+		t.default,
+		n.default,
+		r.default,
+		i.default,
+		a.default,
+		o.default,
+		s.default,
+		c.default,
+		{
+			keyword: "type",
+			schemaType: ["string", "array"]
+		},
+		{
+			keyword: "nullable",
+			schemaType: "boolean"
+		},
+		l.default,
+		u.default
+	];
+})), Z = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.validateAdditionalItems = void 0;
+	var t = o(), n = s(), r = {
+		keyword: "additionalItems",
+		type: "array",
+		schemaType: ["boolean", "object"],
+		before: "uniqueItems",
+		error: {
+			message: ({ params: { len: e } }) => (0, t.str)`must NOT have more than ${e} items`,
+			params: ({ params: { len: e } }) => (0, t._)`{limit: ${e}}`
+		},
+		code(e) {
+			let { parentSchema: t, it: r } = e, { items: a } = t;
+			if (!Array.isArray(a)) {
+				(0, n.checkStrictMode)(r, "\"additionalItems\" is ignored when \"items\" is not an array of schemas");
+				return;
+			}
+			i(e, a);
+		}
+	};
+	function i(e, r) {
+		let { gen: i, schema: a, data: o, keyword: s, it: c } = e;
+		c.items = !0;
+		let l = i.const("len", (0, t._)`${o}.length`);
+		if (a === !1) e.setParams({ len: r.length }), e.pass((0, t._)`${l} <= ${r.length}`);
+		else if (typeof a == "object" && !(0, n.alwaysValidSchema)(c, a)) {
+			let n = i.var("valid", (0, t._)`${l} <= ${r.length}`);
+			i.if((0, t.not)(n), () => u(n)), e.ok(n);
+		}
+		function u(a) {
+			i.forRange("i", r.length, l, (r) => {
+				e.subschema({
+					keyword: s,
+					dataProp: r,
+					dataPropType: n.Type.Num
+				}, a), c.allErrors || i.if((0, t.not)(a), () => i.break());
+			});
+		}
+	}
+	e.validateAdditionalItems = i, e.default = r;
+})), Q = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.validateTuple = void 0;
+	var t = o(), n = s(), r = h(), i = {
+		keyword: "items",
+		type: "array",
+		schemaType: [
+			"object",
+			"array",
+			"boolean"
+		],
+		before: "uniqueItems",
+		code(e) {
+			let { schema: t, it: i } = e;
+			if (Array.isArray(t)) return a(e, "additionalItems", t);
+			i.items = !0, !(0, n.alwaysValidSchema)(i, t) && e.ok((0, r.validateArray)(e));
+		}
+	};
+	function a(e, r, i = e.schema) {
+		let { gen: a, parentSchema: o, data: s, keyword: c, it: l } = e;
+		f(o), l.opts.unevaluated && i.length && l.items !== !0 && (l.items = n.mergeEvaluated.items(a, i.length, l.items));
+		let u = a.name("valid"), d = a.const("len", (0, t._)`${s}.length`);
+		i.forEach((r, i) => {
+			(0, n.alwaysValidSchema)(l, r) || (a.if((0, t._)`${d} > ${i}`, () => e.subschema({
+				keyword: c,
+				schemaProp: i,
+				dataProp: i
+			}, u)), e.ok(u));
+		});
+		function f(e) {
+			let { opts: t, errSchemaPath: a } = l, o = i.length, s = o === e.minItems && (o === e.maxItems || e[r] === !1);
+			if (t.strictTuples && !s) {
+				let e = `"${c}" is ${o}-tuple, but minItems or maxItems/${r} are not specified or different at path "${a}"`;
+				(0, n.checkStrictMode)(l, e, t.strictTuples);
+			}
+		}
+	}
+	e.validateTuple = a, e.default = i;
+})), re = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = Q();
+	e.default = {
+		keyword: "prefixItems",
+		type: "array",
+		schemaType: ["array"],
+		before: "uniqueItems",
+		code: (e) => (0, t.validateTuple)(e, "items")
+	};
+})), ie = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = s(), r = h(), i = Z();
+	e.default = {
+		keyword: "items",
+		type: "array",
+		schemaType: ["object", "boolean"],
+		before: "uniqueItems",
+		error: {
+			message: ({ params: { len: e } }) => (0, t.str)`must NOT have more than ${e} items`,
+			params: ({ params: { len: e } }) => (0, t._)`{limit: ${e}}`
+		},
+		code(e) {
+			let { schema: t, parentSchema: a, it: o } = e, { prefixItems: s } = a;
+			o.items = !0, !(0, n.alwaysValidSchema)(o, t) && (s ? (0, i.validateAdditionalItems)(e, s) : e.ok((0, r.validateArray)(e)));
+		}
+	};
+})), $ = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = s();
+	e.default = {
+		keyword: "contains",
+		type: "array",
+		schemaType: ["object", "boolean"],
+		before: "uniqueItems",
+		trackErrors: !0,
+		error: {
+			message: ({ params: { min: e, max: n } }) => n === void 0 ? (0, t.str)`must contain at least ${e} valid item(s)` : (0, t.str)`must contain at least ${e} and no more than ${n} valid item(s)`,
+			params: ({ params: { min: e, max: n } }) => n === void 0 ? (0, t._)`{minContains: ${e}}` : (0, t._)`{minContains: ${e}, maxContains: ${n}}`
+		},
+		code(e) {
+			let { gen: r, schema: i, parentSchema: a, data: o, it: s } = e, c, l, { minContains: u, maxContains: d } = a;
+			s.opts.next ? (c = u === void 0 ? 1 : u, l = d) : c = 1;
+			let f = r.const("len", (0, t._)`${o}.length`);
+			if (e.setParams({
+				min: c,
+				max: l
+			}), l === void 0 && c === 0) {
+				(0, n.checkStrictMode)(s, "\"minContains\" == 0 without \"maxContains\": \"contains\" keyword ignored");
+				return;
+			}
+			if (l !== void 0 && c > l) {
+				(0, n.checkStrictMode)(s, "\"minContains\" > \"maxContains\" is always invalid"), e.fail();
+				return;
+			}
+			if ((0, n.alwaysValidSchema)(s, i)) {
+				let n = (0, t._)`${f} >= ${c}`;
+				l !== void 0 && (n = (0, t._)`${n} && ${f} <= ${l}`), e.pass(n);
+				return;
+			}
+			s.items = !0;
+			let p = r.name("valid");
+			l === void 0 && c === 1 ? h(p, () => r.if(p, () => r.break())) : c === 0 ? (r.let(p, !0), l !== void 0 && r.if((0, t._)`${o}.length > 0`, m)) : (r.let(p, !1), m()), e.result(p, () => e.reset());
+			function m() {
+				let e = r.name("_valid"), t = r.let("count", 0);
+				h(e, () => r.if(e, () => g(t)));
+			}
+			function h(t, i) {
+				r.forRange("i", 0, f, (r) => {
+					e.subschema({
+						keyword: "contains",
+						dataProp: r,
+						dataPropType: n.Type.Num,
+						compositeRule: !0
+					}, t), i();
+				});
+			}
+			function g(e) {
+				r.code((0, t._)`${e}++`), l === void 0 ? r.if((0, t._)`${e} >= ${c}`, () => r.assign(p, !0).break()) : (r.if((0, t._)`${e} > ${l}`, () => r.assign(p, !1).break()), c === 1 ? r.assign(p, !0) : r.if((0, t._)`${e} >= ${c}`, () => r.assign(p, !0)));
+			}
+		}
+	};
+})), ae = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.validateSchemaDeps = e.validatePropertyDeps = e.error = void 0;
+	var t = o(), n = s(), r = h();
+	e.error = {
+		message: ({ params: { property: e, depsCount: n, deps: r } }) => {
+			let i = n === 1 ? "property" : "properties";
+			return (0, t.str)`must have ${i} ${r} when property ${e} is present`;
+		},
+		params: ({ params: { property: e, depsCount: n, deps: r, missingProperty: i } }) => (0, t._)`{property: ${e},
+    missingProperty: ${i},
+    depsCount: ${n},
+    deps: ${r}}`
+	};
+	var i = {
+		keyword: "dependencies",
+		type: "object",
+		schemaType: "object",
+		error: e.error,
+		code(e) {
+			let [t, n] = a(e);
+			c(e, t), l(e, n);
+		}
+	};
+	function a({ schema: e }) {
+		let t = {}, n = {};
+		for (let r in e) {
+			if (r === "__proto__") continue;
+			let i = Array.isArray(e[r]) ? t : n;
+			i[r] = e[r];
+		}
+		return [t, n];
+	}
+	function c(e, n = e.schema) {
+		let { gen: i, data: a, it: o } = e;
+		if (Object.keys(n).length === 0) return;
+		let s = i.let("missing");
+		for (let c in n) {
+			let l = n[c];
+			if (l.length === 0) continue;
+			let u = (0, r.propertyInData)(i, a, c, o.opts.ownProperties);
+			e.setParams({
+				property: c,
+				depsCount: l.length,
+				deps: l.join(", ")
+			}), o.allErrors ? i.if(u, () => {
+				for (let t of l) (0, r.checkReportMissingProp)(e, t);
+			}) : (i.if((0, t._)`${u} && (${(0, r.checkMissingProp)(e, l, s)})`), (0, r.reportMissingProp)(e, s), i.else());
+		}
+	}
+	e.validatePropertyDeps = c;
+	function l(e, t = e.schema) {
+		let { gen: i, data: a, keyword: o, it: s } = e, c = i.name("valid");
+		for (let l in t) (0, n.alwaysValidSchema)(s, t[l]) || (i.if((0, r.propertyInData)(i, a, l, s.opts.ownProperties), () => {
+			let t = e.subschema({
+				keyword: o,
+				schemaProp: l
+			}, c);
+			e.mergeValidEvaluated(t, c);
+		}, () => i.var(c, !0)), e.ok(c));
+	}
+	e.validateSchemaDeps = l, e.default = i;
+})), oe = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = s();
+	e.default = {
+		keyword: "propertyNames",
+		type: "object",
+		schemaType: ["object", "boolean"],
+		error: {
+			message: "property name must be valid",
+			params: ({ params: e }) => (0, t._)`{propertyName: ${e.propertyName}}`
+		},
+		code(e) {
+			let { gen: r, schema: i, data: a, it: o } = e;
+			if ((0, n.alwaysValidSchema)(o, i)) return;
+			let s = r.name("valid");
+			r.forIn("key", a, (n) => {
+				e.setParams({ propertyName: n }), e.subschema({
+					keyword: "propertyNames",
+					data: n,
+					dataTypes: ["string"],
+					propertyName: n,
+					compositeRule: !0
+				}, s), r.if((0, t.not)(s), () => {
+					e.error(!0), o.allErrors || r.break();
+				});
+			}), e.ok(s);
+		}
+	};
+})), se = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = h(), n = o(), r = c(), i = s();
+	e.default = {
+		keyword: "additionalProperties",
+		type: ["object"],
+		schemaType: ["boolean", "object"],
+		allowUndefined: !0,
+		trackErrors: !0,
+		error: {
+			message: "must NOT have additional properties",
+			params: ({ params: e }) => (0, n._)`{additionalProperty: ${e.additionalProperty}}`
+		},
+		code(e) {
+			let { gen: a, schema: o, parentSchema: s, data: c, errsCount: l, it: u } = e;
+			/* istanbul ignore if */
+			if (!l) throw Error("ajv implementation error");
+			let { allErrors: d, opts: f } = u;
+			if (u.props = !0, f.removeAdditional !== "all" && (0, i.alwaysValidSchema)(u, o)) return;
+			let p = (0, t.allSchemaProperties)(s.properties), m = (0, t.allSchemaProperties)(s.patternProperties);
+			h(), e.ok((0, n._)`${l} === ${r.default.errors}`);
+			function h() {
+				a.forIn("key", c, (e) => {
+					!p.length && !m.length ? v(e) : a.if(g(e), () => v(e));
+				});
+			}
+			function g(r) {
+				let o;
+				if (p.length > 8) {
+					let e = (0, i.schemaRefOrVal)(u, s.properties, "properties");
+					o = (0, t.isOwnProperty)(a, e, r);
+				} else o = p.length ? (0, n.or)(...p.map((e) => (0, n._)`${r} === ${e}`)) : n.nil;
+				return m.length && (o = (0, n.or)(o, ...m.map((i) => (0, n._)`${(0, t.usePattern)(e, i)}.test(${r})`))), (0, n.not)(o);
+			}
+			function _(e) {
+				a.code((0, n._)`delete ${c}[${e}]`);
+			}
+			function v(t) {
+				if (f.removeAdditional === "all" || f.removeAdditional && o === !1) {
+					_(t);
+					return;
+				}
+				if (o === !1) {
+					e.setParams({ additionalProperty: t }), e.error(), d || a.break();
+					return;
+				}
+				if (typeof o == "object" && !(0, i.alwaysValidSchema)(u, o)) {
+					let r = a.name("valid");
+					f.removeAdditional === "failing" ? (y(t, r, !1), a.if((0, n.not)(r), () => {
+						e.reset(), _(t);
+					})) : (y(t, r), d || a.if((0, n.not)(r), () => a.break()));
+				}
+			}
+			function y(t, n, r) {
+				let a = {
+					keyword: "additionalProperties",
+					dataProp: t,
+					dataPropType: i.Type.Str
+				};
+				r === !1 && Object.assign(a, {
+					compositeRule: !0,
+					createErrors: !1,
+					allErrors: !1
+				}), e.subschema(a, n);
+			}
+		}
+	};
+})), ce = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = x(), n = h(), r = s(), i = se();
+	e.default = {
+		keyword: "properties",
+		type: "object",
+		schemaType: "object",
+		code(e) {
+			let { gen: a, schema: o, parentSchema: s, data: c, it: l } = e;
+			l.opts.removeAdditional === "all" && s.additionalProperties === void 0 && i.default.code(new t.KeywordCxt(l, i.default, "additionalProperties"));
+			let u = (0, n.allSchemaProperties)(o);
+			for (let e of u) l.definedProperties.add(e);
+			l.opts.unevaluated && u.length && l.props !== !0 && (l.props = r.mergeEvaluated.props(a, (0, r.toHash)(u), l.props));
+			let d = u.filter((e) => !(0, r.alwaysValidSchema)(l, o[e]));
+			if (d.length === 0) return;
+			let f = a.name("valid");
+			for (let t of d) p(t) ? m(t) : (a.if((0, n.propertyInData)(a, c, t, l.opts.ownProperties)), m(t), l.allErrors || a.else().var(f, !0), a.endIf()), e.it.definedProperties.add(t), e.ok(f);
+			function p(e) {
+				return l.opts.useDefaults && !l.compositeRule && o[e].default !== void 0;
+			}
+			function m(t) {
+				e.subschema({
+					keyword: "properties",
+					schemaProp: t,
+					dataProp: t
+				}, f);
+			}
+		}
+	};
+})), le = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = h(), n = o(), r = s(), i = s();
+	e.default = {
+		keyword: "patternProperties",
+		type: "object",
+		schemaType: "object",
+		code(e) {
+			let { gen: a, schema: o, data: s, parentSchema: c, it: l } = e, { opts: u } = l, d = (0, t.allSchemaProperties)(o), f = d.filter((e) => (0, r.alwaysValidSchema)(l, o[e]));
+			if (d.length === 0 || f.length === d.length && (!l.opts.unevaluated || l.props === !0)) return;
+			let p = u.strictSchema && !u.allowMatchingProperties && c.properties, m = a.name("valid");
+			l.props !== !0 && !(l.props instanceof n.Name) && (l.props = (0, i.evaluatedPropsToName)(a, l.props));
+			let { props: h } = l;
+			g();
+			function g() {
+				for (let e of d) p && _(e), l.allErrors ? v(e) : (a.var(m, !0), v(e), a.if(m));
+			}
+			function _(e) {
+				for (let t in p) new RegExp(e).test(t) && (0, r.checkStrictMode)(l, `property ${t} matches pattern ${e} (use allowMatchingProperties)`);
+			}
+			function v(r) {
+				a.forIn("key", s, (o) => {
+					a.if((0, n._)`${(0, t.usePattern)(e, r)}.test(${o})`, () => {
+						let t = f.includes(r);
+						t || e.subschema({
+							keyword: "patternProperties",
+							schemaProp: r,
+							dataProp: o,
+							dataPropType: i.Type.Str
+						}, m), l.opts.unevaluated && h !== !0 ? a.assign((0, n._)`${h}[${o}]`, !0) : !t && !l.allErrors && a.if((0, n.not)(m), () => a.break());
+					});
+				});
+			}
+		}
+	};
+})), ue = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = s();
+	e.default = {
+		keyword: "not",
+		schemaType: ["object", "boolean"],
+		trackErrors: !0,
+		code(e) {
+			let { gen: n, schema: r, it: i } = e;
+			if ((0, t.alwaysValidSchema)(i, r)) {
+				e.fail();
+				return;
+			}
+			let a = n.name("valid");
+			e.subschema({
+				keyword: "not",
+				compositeRule: !0,
+				createErrors: !1,
+				allErrors: !1
+			}, a), e.failResult(a, () => e.reset(), () => e.error());
+		},
+		error: { message: "must NOT be valid" }
+	};
+})), de = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.default = {
+		keyword: "anyOf",
+		schemaType: "array",
+		trackErrors: !0,
+		code: h().validateUnion,
+		error: { message: "must match a schema in anyOf" }
+	};
+})), fe = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = s();
+	e.default = {
+		keyword: "oneOf",
+		schemaType: "array",
+		trackErrors: !0,
+		error: {
+			message: "must match exactly one schema in oneOf",
+			params: ({ params: e }) => (0, t._)`{passingSchemas: ${e.passing}}`
+		},
+		code(e) {
+			let { gen: r, schema: i, parentSchema: a, it: o } = e;
+			/* istanbul ignore if */
+			if (!Array.isArray(i)) throw Error("ajv implementation error");
+			if (o.opts.discriminator && a.discriminator) return;
+			let s = i, c = r.let("valid", !1), l = r.let("passing", null), u = r.name("_valid");
+			e.setParams({ passing: l }), r.block(d), e.result(c, () => e.reset(), () => e.error(!0));
+			function d() {
+				s.forEach((i, a) => {
+					let s;
+					(0, n.alwaysValidSchema)(o, i) ? r.var(u, !0) : s = e.subschema({
+						keyword: "oneOf",
+						schemaProp: a,
+						compositeRule: !0
+					}, u), a > 0 && r.if((0, t._)`${u} && ${c}`).assign(c, !1).assign(l, (0, t._)`[${l}, ${a}]`).else(), r.if(u, () => {
+						r.assign(c, !0), r.assign(l, a), s && e.mergeEvaluated(s, t.Name);
+					});
+				});
+			}
+		}
+	};
+})), pe = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = s();
+	e.default = {
+		keyword: "allOf",
+		schemaType: "array",
+		code(e) {
+			let { gen: n, schema: r, it: i } = e;
+			/* istanbul ignore if */
+			if (!Array.isArray(r)) throw Error("ajv implementation error");
+			let a = n.name("valid");
+			r.forEach((n, r) => {
+				if ((0, t.alwaysValidSchema)(i, n)) return;
+				let o = e.subschema({
+					keyword: "allOf",
+					schemaProp: r
+				}, a);
+				e.ok(a), e.mergeEvaluated(o);
+			});
+		}
+	};
+})), me = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = s(), r = {
+		keyword: "if",
+		schemaType: ["object", "boolean"],
+		trackErrors: !0,
+		error: {
+			message: ({ params: e }) => (0, t.str)`must match "${e.ifClause}" schema`,
+			params: ({ params: e }) => (0, t._)`{failingKeyword: ${e.ifClause}}`
+		},
+		code(e) {
+			let { gen: r, parentSchema: a, it: o } = e;
+			a.then === void 0 && a.else === void 0 && (0, n.checkStrictMode)(o, "\"if\" without \"then\" and \"else\" is ignored");
+			let s = i(o, "then"), c = i(o, "else");
+			if (!s && !c) return;
+			let l = r.let("valid", !0), u = r.name("_valid");
+			if (d(), e.reset(), s && c) {
+				let t = r.let("ifClause");
+				e.setParams({ ifClause: t }), r.if(u, f("then", t), f("else", t));
+			} else s ? r.if(u, f("then")) : r.if((0, t.not)(u), f("else"));
+			e.pass(l, () => e.error(!0));
+			function d() {
+				let t = e.subschema({
+					keyword: "if",
+					compositeRule: !0,
+					createErrors: !1,
+					allErrors: !1
+				}, u);
+				e.mergeEvaluated(t);
+			}
+			function f(n, i) {
+				return () => {
+					let a = e.subschema({ keyword: n }, u);
+					r.assign(l, u), e.mergeValidEvaluated(a, l), i ? r.assign(i, (0, t._)`${n}`) : e.setParams({ ifClause: n });
+				};
+			}
+		}
+	};
+	function i(e, t) {
+		let r = e.schema[t];
+		return r !== void 0 && !(0, n.alwaysValidSchema)(e, r);
+	}
+	e.default = r;
+})), he = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = s();
+	e.default = {
+		keyword: ["then", "else"],
+		schemaType: ["object", "boolean"],
+		code({ keyword: e, parentSchema: n, it: r }) {
+			n.if === void 0 && (0, t.checkStrictMode)(r, `"${e}" without "if" is ignored`);
+		}
+	};
+})), ge = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = Z(), n = re(), r = Q(), i = ie(), a = $(), o = ae(), s = oe(), c = se(), l = ce(), u = le(), d = ue(), f = de(), p = fe(), m = pe(), h = me(), g = he();
+	function _(e = !1) {
+		let _ = [
+			d.default,
+			f.default,
+			p.default,
+			m.default,
+			h.default,
+			g.default,
+			s.default,
+			c.default,
+			o.default,
+			l.default,
+			u.default
+		];
+		return e ? _.push(n.default, i.default) : _.push(t.default, r.default), _.push(a.default), _;
+	}
+	e.default = _;
+})), _e = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o();
+	e.default = {
+		keyword: "format",
+		type: ["number", "string"],
+		schemaType: "string",
+		$data: !0,
+		error: {
+			message: ({ schemaCode: e }) => (0, t.str)`must match format "${e}"`,
+			params: ({ schemaCode: e }) => (0, t._)`{format: ${e}}`
+		},
+		code(e, n) {
+			let { gen: r, data: i, $data: a, schema: o, schemaCode: s, it: c } = e, { opts: l, errSchemaPath: u, schemaEnv: d, self: f } = c;
+			if (!l.validateFormats) return;
+			a ? p() : m();
+			function p() {
+				let a = r.scopeValue("formats", {
+					ref: f.formats,
+					code: l.code.formats
+				}), o = r.const("fDef", (0, t._)`${a}[${s}]`), c = r.let("fType"), u = r.let("format");
+				r.if((0, t._)`typeof ${o} == "object" && !(${o} instanceof RegExp)`, () => r.assign(c, (0, t._)`${o}.type || "string"`).assign(u, (0, t._)`${o}.validate`), () => r.assign(c, (0, t._)`"string"`).assign(u, o)), e.fail$data((0, t.or)(p(), m()));
+				function p() {
+					return l.strictSchema === !1 ? t.nil : (0, t._)`${s} && !${u}`;
+				}
+				function m() {
+					let e = d.$async ? (0, t._)`(${o}.async ? await ${u}(${i}) : ${u}(${i}))` : (0, t._)`${u}(${i})`, r = (0, t._)`(typeof ${u} == "function" ? ${e} : ${u}.test(${i}))`;
+					return (0, t._)`${u} && ${u} !== true && ${c} === ${n} && !${r}`;
+				}
+			}
+			function m() {
+				let a = f.formats[o];
+				if (!a) {
+					m();
+					return;
+				}
+				if (a === !0) return;
+				let [s, c, p] = h(a);
+				s === n && e.pass(g());
+				function m() {
+					if (l.strictSchema === !1) {
+						f.logger.warn(e());
+						return;
+					}
+					throw Error(e());
+					function e() {
+						return `unknown format "${o}" ignored in schema at path "${u}"`;
+					}
+				}
+				function h(e) {
+					let n = e instanceof RegExp ? (0, t.regexpCode)(e) : l.code.formats ? (0, t._)`${l.code.formats}${(0, t.getProperty)(o)}` : void 0, i = r.scopeValue("formats", {
+						key: o,
+						ref: e,
+						code: n
+					});
+					return typeof e == "object" && !(e instanceof RegExp) ? [
+						e.type || "string",
+						e.validate,
+						(0, t._)`${i}.validate`
+					] : [
+						"string",
+						e,
+						i
+					];
+				}
+				function g() {
+					if (typeof a == "object" && !(a instanceof RegExp) && a.async) {
+						if (!d.$async) throw Error("async format in sync schema");
+						return (0, t._)`await ${p}(${i})`;
+					}
+					return typeof c == "function" ? (0, t._)`${p}(${i})` : (0, t._)`${p}.test(${i})`;
+				}
+			}
+		}
+	};
+})), ve = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.default = [_e().default];
+})), ye = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.contentVocabulary = e.metadataVocabulary = void 0, e.metadataVocabulary = [
+		"title",
+		"description",
+		"default",
+		"deprecated",
+		"readOnly",
+		"writeOnly",
+		"examples"
+	], e.contentVocabulary = [
+		"contentMediaType",
+		"contentEncoding",
+		"contentSchema"
+	];
+})), be = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = B(), n = X(), r = ge(), i = ve(), a = ye();
+	e.default = [
+		t.default,
+		n.default,
+		(0, r.default)(),
+		i.default,
+		a.metadataVocabulary,
+		a.contentVocabulary
+	];
+})), xe = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 }), e.DiscrError = void 0;
+	var t;
+	(function(e) {
+		e.Tag = "tag", e.Mapping = "mapping";
+	})(t || (e.DiscrError = t = {}));
+})), Se = /* @__PURE__ */ r(((e) => {
+	Object.defineProperty(e, "__esModule", { value: !0 });
+	var t = o(), n = xe(), r = w(), i = C(), a = s();
+	e.default = {
+		keyword: "discriminator",
+		type: "object",
+		schemaType: "object",
+		error: {
+			message: ({ params: { discrError: e, tagName: t } }) => e === n.DiscrError.Tag ? `tag "${t}" must be string` : `value of tag "${t}" must be in oneOf`,
+			params: ({ params: { discrError: e, tag: n, tagName: r } }) => (0, t._)`{error: ${e}, tag: ${r}, tagValue: ${n}}`
+		},
+		code(e) {
+			let { gen: o, data: s, schema: c, parentSchema: l, it: u } = e, { oneOf: d } = l;
+			if (!u.opts.discriminator) throw Error("discriminator: requires discriminator option");
+			let f = c.propertyName;
+			if (typeof f != "string") throw Error("discriminator: requires propertyName");
+			if (c.mapping) throw Error("discriminator: mapping is not supported");
+			if (!d) throw Error("discriminator: requires oneOf keyword");
+			let p = o.let("valid", !1), m = o.const("tag", (0, t._)`${s}${(0, t.getProperty)(f)}`);
+			o.if((0, t._)`typeof ${m} == "string"`, () => h(), () => e.error(!1, {
+				discrError: n.DiscrError.Tag,
+				tag: m,
+				tagName: f
+			})), e.ok(p);
+			function h() {
+				let r = _();
+				o.if(!1);
+				for (let e in r) o.elseIf((0, t._)`${m} === ${e}`), o.assign(p, g(r[e]));
+				o.else(), e.error(!1, {
+					discrError: n.DiscrError.Mapping,
+					tag: m,
+					tagName: f
+				}), o.endIf();
+			}
+			function g(n) {
+				let r = o.name("valid"), i = e.subschema({
+					keyword: "oneOf",
+					schemaProp: n
+				}, r);
+				return e.mergeEvaluated(i, t.Name), r;
+			}
+			function _() {
+				let e = {}, t = o(l), n = !0;
+				for (let e = 0; e < d.length; e++) {
+					let c = d[e];
+					if (c?.$ref && !(0, a.schemaHasRulesButRef)(c, u.self.RULES)) {
+						let e = c.$ref;
+						if (c = r.resolveRef.call(u.self, u.schemaEnv.root, u.baseId, e), c instanceof r.SchemaEnv && (c = c.schema), c === void 0) throw new i.default(u.opts.uriResolver, u.baseId, e);
+					}
+					let l = c?.properties?.[f];
+					if (typeof l != "object") throw Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${f}"`);
+					n &&= t || o(c), s(l, e);
+				}
+				if (!n) throw Error(`discriminator: "${f}" must be required`);
+				return e;
+				function o({ required: e }) {
+					return Array.isArray(e) && e.includes(f);
+				}
+				function s(e, t) {
+					if (e.const) c(e.const, t);
+					else if (e.enum) for (let n of e.enum) c(n, t);
+					else throw Error(`discriminator: "properties/${f}" must have "const" or "enum"`);
+				}
+				function c(t, n) {
+					if (typeof t != "string" || t in e) throw Error(`discriminator: "${f}" values must be unique strings`);
+					e[t] = n;
+				}
+			}
+		}
+	};
+})), Ce = /* @__PURE__ */ n({
+	$id: () => Te,
+	$schema: () => we,
+	default: () => Ae,
+	definitions: () => De,
+	properties: () => ke,
+	title: () => Ee,
+	type: () => Oe
+}), we, Te, Ee, De, Oe, ke, Ae, je = t((() => {
+	we = "http://json-schema.org/draft-07/schema#", Te = "http://json-schema.org/draft-07/schema#", Ee = "Core schema meta-schema", De = {
+		schemaArray: {
+			type: "array",
+			minItems: 1,
+			items: { $ref: "#" }
+		},
+		nonNegativeInteger: {
+			type: "integer",
+			minimum: 0
+		},
+		nonNegativeIntegerDefault0: { allOf: [{ $ref: "#/definitions/nonNegativeInteger" }, { default: 0 }] },
+		simpleTypes: { enum: [
+			"array",
+			"boolean",
+			"integer",
+			"null",
+			"number",
+			"object",
+			"string"
+		] },
+		stringArray: {
+			type: "array",
+			items: { type: "string" },
+			uniqueItems: !0,
+			default: []
+		}
+	}, Oe = ["object", "boolean"], ke = {
+		$id: {
+			type: "string",
+			format: "uri-reference"
+		},
+		$schema: {
+			type: "string",
+			format: "uri"
+		},
+		$ref: {
+			type: "string",
+			format: "uri-reference"
+		},
+		$comment: { type: "string" },
+		title: { type: "string" },
+		description: { type: "string" },
+		default: !0,
+		readOnly: {
+			type: "boolean",
+			default: !1
+		},
+		examples: {
+			type: "array",
+			items: !0
+		},
+		multipleOf: {
+			type: "number",
+			exclusiveMinimum: 0
+		},
+		maximum: { type: "number" },
+		exclusiveMaximum: { type: "number" },
+		minimum: { type: "number" },
+		exclusiveMinimum: { type: "number" },
+		maxLength: { $ref: "#/definitions/nonNegativeInteger" },
+		minLength: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+		pattern: {
+			type: "string",
+			format: "regex"
+		},
+		additionalItems: { $ref: "#" },
+		items: {
+			anyOf: [{ $ref: "#" }, { $ref: "#/definitions/schemaArray" }],
+			default: !0
+		},
+		maxItems: { $ref: "#/definitions/nonNegativeInteger" },
+		minItems: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+		uniqueItems: {
+			type: "boolean",
+			default: !1
+		},
+		contains: { $ref: "#" },
+		maxProperties: { $ref: "#/definitions/nonNegativeInteger" },
+		minProperties: { $ref: "#/definitions/nonNegativeIntegerDefault0" },
+		required: { $ref: "#/definitions/stringArray" },
+		additionalProperties: { $ref: "#" },
+		definitions: {
+			type: "object",
+			additionalProperties: { $ref: "#" },
+			default: {}
+		},
+		properties: {
+			type: "object",
+			additionalProperties: { $ref: "#" },
+			default: {}
+		},
+		patternProperties: {
+			type: "object",
+			additionalProperties: { $ref: "#" },
+			propertyNames: { format: "regex" },
+			default: {}
+		},
+		dependencies: {
+			type: "object",
+			additionalProperties: { anyOf: [{ $ref: "#" }, { $ref: "#/definitions/stringArray" }] }
+		},
+		propertyNames: { $ref: "#" },
+		const: !0,
+		enum: {
+			type: "array",
+			items: !0,
+			minItems: 1,
+			uniqueItems: !0
+		},
+		type: { anyOf: [{ $ref: "#/definitions/simpleTypes" }, {
+			type: "array",
+			items: { $ref: "#/definitions/simpleTypes" },
+			minItems: 1,
+			uniqueItems: !0
+		}] },
+		format: { type: "string" },
+		contentMediaType: { type: "string" },
+		contentEncoding: { type: "string" },
+		if: { $ref: "#" },
+		then: { $ref: "#" },
+		else: { $ref: "#" },
+		allOf: { $ref: "#/definitions/schemaArray" },
+		anyOf: { $ref: "#/definitions/schemaArray" },
+		oneOf: { $ref: "#/definitions/schemaArray" },
+		not: { $ref: "#" }
+	}, Ae = {
+		$schema: we,
+		$id: Te,
+		title: Ee,
+		definitions: De,
+		type: Oe,
+		properties: ke,
+		default: !0
+	};
+})), Me = /* @__PURE__ */ r(((t, n) => {
+	Object.defineProperty(t, "__esModule", { value: !0 }), t.MissingRefError = t.ValidationError = t.CodeGen = t.Name = t.nil = t.stringify = t.str = t._ = t.KeywordCxt = t.Ajv = void 0;
+	var r = L(), i = be(), a = Se(), s = (je(), e(Ce).default), c = ["/properties"], l = "http://json-schema.org/draft-07/schema", u = class extends r.default {
+		_addVocabularies() {
+			super._addVocabularies(), i.default.forEach((e) => this.addVocabulary(e)), this.opts.discriminator && this.addKeyword(a.default);
+		}
+		_addDefaultMetaSchema() {
+			if (super._addDefaultMetaSchema(), !this.opts.meta) return;
+			let e = this.opts.$data ? this.$dataMetaSchema(s, c) : s;
+			this.addMetaSchema(e, l, !1), this.refs["http://json-schema.org/schema"] = l;
+		}
+		defaultMeta() {
+			return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(l) ? l : void 0);
+		}
+	};
+	t.Ajv = u, n.exports = t = u, n.exports.Ajv = u, Object.defineProperty(t, "__esModule", { value: !0 }), t.default = u;
+	var d = x();
+	Object.defineProperty(t, "KeywordCxt", {
+		enumerable: !0,
+		get: function() {
+			return d.KeywordCxt;
+		}
+	});
+	var f = o();
+	Object.defineProperty(t, "_", {
+		enumerable: !0,
+		get: function() {
+			return f._;
+		}
+	}), Object.defineProperty(t, "str", {
+		enumerable: !0,
+		get: function() {
+			return f.str;
+		}
+	}), Object.defineProperty(t, "stringify", {
+		enumerable: !0,
+		get: function() {
+			return f.stringify;
+		}
+	}), Object.defineProperty(t, "nil", {
+		enumerable: !0,
+		get: function() {
+			return f.nil;
+		}
+	}), Object.defineProperty(t, "Name", {
+		enumerable: !0,
+		get: function() {
+			return f.Name;
+		}
+	}), Object.defineProperty(t, "CodeGen", {
+		enumerable: !0,
+		get: function() {
+			return f.CodeGen;
+		}
+	});
+	var p = S();
+	Object.defineProperty(t, "ValidationError", {
+		enumerable: !0,
+		get: function() {
+			return p.default;
+		}
+	});
+	var m = C();
+	Object.defineProperty(t, "MissingRefError", {
+		enumerable: !0,
+		get: function() {
+			return m.default;
+		}
+	});
+}));
+//#endregion
+export { Me as t };