@reformer/renderer-json 5.0.2 → 6.0.0

package/dist/validate.js

@@ -0,0 +1,4467 @@
+import { g as an, d as on, f as un, p as cn } from "./index-CI7YxPq2.js";
+function ln(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var Oe = { exports: {} }, bt = {}, he = {}, ge = {}, Et = {}, St = {}, Pt = {}, Vt;
+function ht() {
+  return Vt || (Vt = 1, (function(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;
+    class r {
+    }
+    e._CodeOrName = r, e.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+    class S extends r {
+      constructor(t) {
+        if (super(), !e.IDENTIFIER.test(t))
+          throw new 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 = S;
+    class d extends r {
+      constructor(t) {
+        super(), this._items = typeof t == "string" ? [t] : t;
+      }
+      toString() {
+        return this.str;
+      }
+      emptyStr() {
+        if (this._items.length > 1)
+          return !1;
+        const t = this._items[0];
+        return t === "" || t === '""';
+      }
+      get str() {
+        var t;
+        return (t = this._str) !== null && t !== void 0 ? t : this._str = this._items.reduce((o, h) => `${o}${h}`, "");
+      }
+      get names() {
+        var t;
+        return (t = this._names) !== null && t !== void 0 ? t : this._names = this._items.reduce((o, h) => (h instanceof S && (o[h.str] = (o[h.str] || 0) + 1), o), {});
+      }
+    }
+    e._Code = d, e.nil = new d("");
+    function g(i, ...t) {
+      const o = [i[0]];
+      let h = 0;
+      for (; h < t.length; )
+        c(o, t[h]), o.push(i[++h]);
+      return new d(o);
+    }
+    e._ = g;
+    const s = new d("+");
+    function f(i, ...t) {
+      const o = [y(i[0])];
+      let h = 0;
+      for (; h < t.length; )
+        o.push(s), c(o, t[h]), o.push(s, y(i[++h]));
+      return m(o), new d(o);
+    }
+    e.str = f;
+    function c(i, t) {
+      t instanceof d ? i.push(...t._items) : t instanceof S ? i.push(t) : i.push(P(t));
+    }
+    e.addCodeArg = c;
+    function m(i) {
+      let t = 1;
+      for (; t < i.length - 1; ) {
+        if (i[t] === s) {
+          const o = w(i[t - 1], i[t + 1]);
+          if (o !== void 0) {
+            i.splice(t - 1, 3, o);
+            continue;
+          }
+          i[t++] = "+";
+        }
+        t++;
+      }
+    }
+    function w(i, t) {
+      if (t === '""')
+        return i;
+      if (i === '""')
+        return t;
+      if (typeof i == "string")
+        return t instanceof S || i[i.length - 1] !== '"' ? void 0 : typeof t != "string" ? `${i.slice(0, -1)}${t}"` : t[0] === '"' ? i.slice(0, -1) + t.slice(1) : void 0;
+      if (typeof t == "string" && t[0] === '"' && !(i instanceof S))
+        return `"${i}${t.slice(1)}`;
+    }
+    function v(i, t) {
+      return t.emptyStr() ? i : i.emptyStr() ? t : f`${i}${t}`;
+    }
+    e.strConcat = v;
+    function P(i) {
+      return typeof i == "number" || typeof i == "boolean" || i === null ? i : y(Array.isArray(i) ? i.join(",") : i);
+    }
+    function _(i) {
+      return new d(y(i));
+    }
+    e.stringify = _;
+    function y(i) {
+      return JSON.stringify(i).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+    }
+    e.safeStringify = y;
+    function p(i) {
+      return typeof i == "string" && e.IDENTIFIER.test(i) ? new d(`.${i}`) : g`[${i}]`;
+    }
+    e.getProperty = p;
+    function b(i) {
+      if (typeof i == "string" && e.IDENTIFIER.test(i))
+        return new d(`${i}`);
+      throw new Error(`CodeGen: invalid export name: ${i}, use explicit $id name mapping`);
+    }
+    e.getEsmExportName = b;
+    function a(i) {
+      return new d(i.toString());
+    }
+    e.regexpCode = a;
+  })(Pt)), Pt;
+}
+var Nt = {}, Ut;
+function zt() {
+  return Ut || (Ut = 1, (function(e) {
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.ValueScope = e.ValueScopeName = e.Scope = e.varKinds = e.UsedValueState = void 0;
+    const r = ht();
+    class S extends Error {
+      constructor(w) {
+        super(`CodeGen: "code" for ${w} not defined`), this.value = w.value;
+      }
+    }
+    var d;
+    (function(m) {
+      m[m.Started = 0] = "Started", m[m.Completed = 1] = "Completed";
+    })(d || (e.UsedValueState = d = {})), e.varKinds = {
+      const: new r.Name("const"),
+      let: new r.Name("let"),
+      var: new r.Name("var")
+    };
+    class g {
+      constructor({ prefixes: w, parent: v } = {}) {
+        this._names = {}, this._prefixes = w, this._parent = v;
+      }
+      toName(w) {
+        return w instanceof r.Name ? w : this.name(w);
+      }
+      name(w) {
+        return new r.Name(this._newName(w));
+      }
+      _newName(w) {
+        const v = this._names[w] || this._nameGroup(w);
+        return `${w}${v.index++}`;
+      }
+      _nameGroup(w) {
+        var v, P;
+        if (!((P = (v = this._parent) === null || v === void 0 ? void 0 : v._prefixes) === null || P === void 0) && P.has(w) || this._prefixes && !this._prefixes.has(w))
+          throw new Error(`CodeGen: prefix "${w}" is not allowed in this scope`);
+        return this._names[w] = { prefix: w, index: 0 };
+      }
+    }
+    e.Scope = g;
+    class s extends r.Name {
+      constructor(w, v) {
+        super(v), this.prefix = w;
+      }
+      setValue(w, { property: v, itemIndex: P }) {
+        this.value = w, this.scopePath = (0, r._)`.${new r.Name(v)}[${P}]`;
+      }
+    }
+    e.ValueScopeName = s;
+    const f = (0, r._)`\n`;
+    class c extends g {
+      constructor(w) {
+        super(w), this._values = {}, this._scope = w.scope, this.opts = { ...w, _n: w.lines ? f : r.nil };
+      }
+      get() {
+        return this._scope;
+      }
+      name(w) {
+        return new s(w, this._newName(w));
+      }
+      value(w, v) {
+        var P;
+        if (v.ref === void 0)
+          throw new Error("CodeGen: ref must be passed in value");
+        const _ = this.toName(w), { prefix: y } = _, p = (P = v.key) !== null && P !== void 0 ? P : v.ref;
+        let b = this._values[y];
+        if (b) {
+          const t = b.get(p);
+          if (t)
+            return t;
+        } else
+          b = this._values[y] = /* @__PURE__ */ new Map();
+        b.set(p, _);
+        const a = this._scope[y] || (this._scope[y] = []), i = a.length;
+        return a[i] = v.ref, _.setValue(v, { property: y, itemIndex: i }), _;
+      }
+      getValue(w, v) {
+        const P = this._values[w];
+        if (P)
+          return P.get(v);
+      }
+      scopeRefs(w, v = this._values) {
+        return this._reduceValues(v, (P) => {
+          if (P.scopePath === void 0)
+            throw new Error(`CodeGen: name "${P}" has no value`);
+          return (0, r._)`${w}${P.scopePath}`;
+        });
+      }
+      scopeCode(w = this._values, v, P) {
+        return this._reduceValues(w, (_) => {
+          if (_.value === void 0)
+            throw new Error(`CodeGen: name "${_}" has no value`);
+          return _.value.code;
+        }, v, P);
+      }
+      _reduceValues(w, v, P = {}, _) {
+        let y = r.nil;
+        for (const p in w) {
+          const b = w[p];
+          if (!b)
+            continue;
+          const a = P[p] = P[p] || /* @__PURE__ */ new Map();
+          b.forEach((i) => {
+            if (a.has(i))
+              return;
+            a.set(i, d.Started);
+            let t = v(i);
+            if (t) {
+              const o = this.opts.es5 ? e.varKinds.var : e.varKinds.const;
+              y = (0, r._)`${y}${o} ${i} = ${t};${this.opts._n}`;
+            } else if (t = _?.(i))
+              y = (0, r._)`${y}${t}${this.opts._n}`;
+            else
+              throw new S(i);
+            a.set(i, d.Completed);
+          });
+        }
+        return y;
+      }
+    }
+    e.ValueScope = c;
+  })(Nt)), Nt;
+}
+var Ft;
+function J() {
+  return Ft || (Ft = 1, (function(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;
+    const r = ht(), S = zt();
+    var d = ht();
+    Object.defineProperty(e, "_", { enumerable: !0, get: function() {
+      return d._;
+    } }), Object.defineProperty(e, "str", { enumerable: !0, get: function() {
+      return d.str;
+    } }), Object.defineProperty(e, "strConcat", { enumerable: !0, get: function() {
+      return d.strConcat;
+    } }), Object.defineProperty(e, "nil", { enumerable: !0, get: function() {
+      return d.nil;
+    } }), Object.defineProperty(e, "getProperty", { enumerable: !0, get: function() {
+      return d.getProperty;
+    } }), Object.defineProperty(e, "stringify", { enumerable: !0, get: function() {
+      return d.stringify;
+    } }), Object.defineProperty(e, "regexpCode", { enumerable: !0, get: function() {
+      return d.regexpCode;
+    } }), Object.defineProperty(e, "Name", { enumerable: !0, get: function() {
+      return d.Name;
+    } });
+    var g = zt();
+    Object.defineProperty(e, "Scope", { enumerable: !0, get: function() {
+      return g.Scope;
+    } }), Object.defineProperty(e, "ValueScope", { enumerable: !0, get: function() {
+      return g.ValueScope;
+    } }), Object.defineProperty(e, "ValueScopeName", { enumerable: !0, get: function() {
+      return g.ValueScopeName;
+    } }), Object.defineProperty(e, "varKinds", { enumerable: !0, get: function() {
+      return g.varKinds;
+    } }), e.operators = {
+      GT: new r._Code(">"),
+      GTE: new r._Code(">="),
+      LT: new r._Code("<"),
+      LTE: new r._Code("<="),
+      EQ: new r._Code("==="),
+      NEQ: new r._Code("!=="),
+      NOT: new r._Code("!"),
+      OR: new r._Code("||"),
+      AND: new r._Code("&&"),
+      ADD: new r._Code("+")
+    };
+    class s {
+      optimizeNodes() {
+        return this;
+      }
+      optimizeNames(u, E) {
+        return this;
+      }
+    }
+    class f extends s {
+      constructor(u, E, I) {
+        super(), this.varKind = u, this.name = E, this.rhs = I;
+      }
+      render({ es5: u, _n: E }) {
+        const I = u ? S.varKinds.var : this.varKind, U = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
+        return `${I} ${this.name}${U};` + E;
+      }
+      optimizeNames(u, E) {
+        if (u[this.name.str])
+          return this.rhs && (this.rhs = B(this.rhs, u, E)), this;
+      }
+      get names() {
+        return this.rhs instanceof r._CodeOrName ? this.rhs.names : {};
+      }
+    }
+    class c extends s {
+      constructor(u, E, I) {
+        super(), this.lhs = u, this.rhs = E, this.sideEffects = I;
+      }
+      render({ _n: u }) {
+        return `${this.lhs} = ${this.rhs};` + u;
+      }
+      optimizeNames(u, E) {
+        if (!(this.lhs instanceof r.Name && !u[this.lhs.str] && !this.sideEffects))
+          return this.rhs = B(this.rhs, u, E), this;
+      }
+      get names() {
+        const u = this.lhs instanceof r.Name ? {} : { ...this.lhs.names };
+        return K(u, this.rhs);
+      }
+    }
+    class m extends c {
+      constructor(u, E, I, U) {
+        super(u, I, U), this.op = E;
+      }
+      render({ _n: u }) {
+        return `${this.lhs} ${this.op}= ${this.rhs};` + u;
+      }
+    }
+    class w extends s {
+      constructor(u) {
+        super(), this.label = u, this.names = {};
+      }
+      render({ _n: u }) {
+        return `${this.label}:` + u;
+      }
+    }
+    class v extends s {
+      constructor(u) {
+        super(), this.label = u, this.names = {};
+      }
+      render({ _n: u }) {
+        return `break${this.label ? ` ${this.label}` : ""};` + u;
+      }
+    }
+    class P extends s {
+      constructor(u) {
+        super(), this.error = u;
+      }
+      render({ _n: u }) {
+        return `throw ${this.error};` + u;
+      }
+      get names() {
+        return this.error.names;
+      }
+    }
+    class _ extends s {
+      constructor(u) {
+        super(), this.code = u;
+      }
+      render({ _n: u }) {
+        return `${this.code};` + u;
+      }
+      optimizeNodes() {
+        return `${this.code}` ? this : void 0;
+      }
+      optimizeNames(u, E) {
+        return this.code = B(this.code, u, E), this;
+      }
+      get names() {
+        return this.code instanceof r._CodeOrName ? this.code.names : {};
+      }
+    }
+    class y extends s {
+      constructor(u = []) {
+        super(), this.nodes = u;
+      }
+      render(u) {
+        return this.nodes.reduce((E, I) => E + I.render(u), "");
+      }
+      optimizeNodes() {
+        const { nodes: u } = this;
+        let E = u.length;
+        for (; E--; ) {
+          const I = u[E].optimizeNodes();
+          Array.isArray(I) ? u.splice(E, 1, ...I) : I ? u[E] = I : u.splice(E, 1);
+        }
+        return u.length > 0 ? this : void 0;
+      }
+      optimizeNames(u, E) {
+        const { nodes: I } = this;
+        let U = I.length;
+        for (; U--; ) {
+          const F = I[U];
+          F.optimizeNames(u, E) || (x(u, F.names), I.splice(U, 1));
+        }
+        return I.length > 0 ? this : void 0;
+      }
+      get names() {
+        return this.nodes.reduce((u, E) => L(u, E.names), {});
+      }
+    }
+    class p extends y {
+      render(u) {
+        return "{" + u._n + super.render(u) + "}" + u._n;
+      }
+    }
+    class b extends y {
+    }
+    class a extends p {
+    }
+    a.kind = "else";
+    class i extends p {
+      constructor(u, E) {
+        super(E), this.condition = u;
+      }
+      render(u) {
+        let E = `if(${this.condition})` + super.render(u);
+        return this.else && (E += "else " + this.else.render(u)), E;
+      }
+      optimizeNodes() {
+        super.optimizeNodes();
+        const u = this.condition;
+        if (u === !0)
+          return this.nodes;
+        let E = this.else;
+        if (E) {
+          const I = E.optimizeNodes();
+          E = this.else = Array.isArray(I) ? new a(I) : I;
+        }
+        if (E)
+          return u === !1 ? E instanceof i ? E : E.nodes : this.nodes.length ? this : new i(de(u), E instanceof i ? [E] : E.nodes);
+        if (!(u === !1 || !this.nodes.length))
+          return this;
+      }
+      optimizeNames(u, E) {
+        var I;
+        if (this.else = (I = this.else) === null || I === void 0 ? void 0 : I.optimizeNames(u, E), !!(super.optimizeNames(u, E) || this.else))
+          return this.condition = B(this.condition, u, E), this;
+      }
+      get names() {
+        const u = super.names;
+        return K(u, this.condition), this.else && L(u, this.else.names), u;
+      }
+    }
+    i.kind = "if";
+    class t extends p {
+    }
+    t.kind = "for";
+    class o extends t {
+      constructor(u) {
+        super(), this.iteration = u;
+      }
+      render(u) {
+        return `for(${this.iteration})` + super.render(u);
+      }
+      optimizeNames(u, E) {
+        if (super.optimizeNames(u, E))
+          return this.iteration = B(this.iteration, u, E), this;
+      }
+      get names() {
+        return L(super.names, this.iteration.names);
+      }
+    }
+    class h extends t {
+      constructor(u, E, I, U) {
+        super(), this.varKind = u, this.name = E, this.from = I, this.to = U;
+      }
+      render(u) {
+        const E = u.es5 ? S.varKinds.var : this.varKind, { name: I, from: U, to: F } = this;
+        return `for(${E} ${I}=${U}; ${I}<${F}; ${I}++)` + super.render(u);
+      }
+      get names() {
+        const u = K(super.names, this.from);
+        return K(u, this.to);
+      }
+    }
+    class n extends t {
+      constructor(u, E, I, U) {
+        super(), this.loop = u, this.varKind = E, this.name = I, this.iterable = U;
+      }
+      render(u) {
+        return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(u);
+      }
+      optimizeNames(u, E) {
+        if (super.optimizeNames(u, E))
+          return this.iterable = B(this.iterable, u, E), this;
+      }
+      get names() {
+        return L(super.names, this.iterable.names);
+      }
+    }
+    class l extends p {
+      constructor(u, E, I) {
+        super(), this.name = u, this.args = E, this.async = I;
+      }
+      render(u) {
+        return `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render(u);
+      }
+    }
+    l.kind = "func";
+    class $ extends y {
+      render(u) {
+        return "return " + super.render(u);
+      }
+    }
+    $.kind = "return";
+    class j extends p {
+      render(u) {
+        let E = "try" + super.render(u);
+        return this.catch && (E += this.catch.render(u)), this.finally && (E += this.finally.render(u)), E;
+      }
+      optimizeNodes() {
+        var u, E;
+        return super.optimizeNodes(), (u = this.catch) === null || u === void 0 || u.optimizeNodes(), (E = this.finally) === null || E === void 0 || E.optimizeNodes(), this;
+      }
+      optimizeNames(u, E) {
+        var I, U;
+        return super.optimizeNames(u, E), (I = this.catch) === null || I === void 0 || I.optimizeNames(u, E), (U = this.finally) === null || U === void 0 || U.optimizeNames(u, E), this;
+      }
+      get names() {
+        const u = super.names;
+        return this.catch && L(u, this.catch.names), this.finally && L(u, this.finally.names), u;
+      }
+    }
+    class C extends p {
+      constructor(u) {
+        super(), this.error = u;
+      }
+      render(u) {
+        return `catch(${this.error})` + super.render(u);
+      }
+    }
+    C.kind = "catch";
+    class D extends p {
+      render(u) {
+        return "finally" + super.render(u);
+      }
+    }
+    D.kind = "finally";
+    class V {
+      constructor(u, E = {}) {
+        this._values = {}, this._blockStarts = [], this._constants = {}, this.opts = { ...E, _n: E.lines ? `
+` : "" }, this._extScope = u, this._scope = new S.Scope({ parent: u }), this._nodes = [new b()];
+      }
+      toString() {
+        return this._root.render(this.opts);
+      }
+      // returns unique name in the internal scope
+      name(u) {
+        return this._scope.name(u);
+      }
+      // reserves unique name in the external scope
+      scopeName(u) {
+        return this._extScope.name(u);
+      }
+      // reserves unique name in the external scope and assigns value to it
+      scopeValue(u, E) {
+        const I = this._extScope.value(u, E);
+        return (this._values[I.prefix] || (this._values[I.prefix] = /* @__PURE__ */ new Set())).add(I), I;
+      }
+      getScopeValue(u, E) {
+        return this._extScope.getValue(u, E);
+      }
+      // return code that assigns values in the external scope to the names that are used internally
+      // (same names that were returned by gen.scopeName or gen.scopeValue)
+      scopeRefs(u) {
+        return this._extScope.scopeRefs(u, this._values);
+      }
+      scopeCode() {
+        return this._extScope.scopeCode(this._values);
+      }
+      _def(u, E, I, U) {
+        const F = this._scope.toName(E);
+        return I !== void 0 && U && (this._constants[F.str] = I), this._leafNode(new f(u, F, I)), F;
+      }
+      // `const` declaration (`var` in es5 mode)
+      const(u, E, I) {
+        return this._def(S.varKinds.const, u, E, I);
+      }
+      // `let` declaration with optional assignment (`var` in es5 mode)
+      let(u, E, I) {
+        return this._def(S.varKinds.let, u, E, I);
+      }
+      // `var` declaration with optional assignment
+      var(u, E, I) {
+        return this._def(S.varKinds.var, u, E, I);
+      }
+      // assignment code
+      assign(u, E, I) {
+        return this._leafNode(new c(u, E, I));
+      }
+      // `+=` code
+      add(u, E) {
+        return this._leafNode(new m(u, e.operators.ADD, E));
+      }
+      // appends passed SafeExpr to code or executes Block
+      code(u) {
+        return typeof u == "function" ? u() : u !== r.nil && this._leafNode(new _(u)), this;
+      }
+      // returns code for object literal for the passed argument list of key-value pairs
+      object(...u) {
+        const E = ["{"];
+        for (const [I, U] of u)
+          E.length > 1 && E.push(","), E.push(I), (I !== U || this.opts.es5) && (E.push(":"), (0, r.addCodeArg)(E, U));
+        return E.push("}"), new r._Code(E);
+      }
+      // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
+      if(u, E, I) {
+        if (this._blockNode(new i(u)), E && I)
+          this.code(E).else().code(I).endIf();
+        else if (E)
+          this.code(E).endIf();
+        else if (I)
+          throw new Error('CodeGen: "else" body without "then" body');
+        return this;
+      }
+      // `else if` clause - invalid without `if` or after `else` clauses
+      elseIf(u) {
+        return this._elseNode(new i(u));
+      }
+      // `else` clause - only valid after `if` or `else if` clauses
+      else() {
+        return this._elseNode(new a());
+      }
+      // end `if` statement (needed if gen.if was used only with condition)
+      endIf() {
+        return this._endBlockNode(i, a);
+      }
+      _for(u, E) {
+        return this._blockNode(u), E && this.code(E).endFor(), this;
+      }
+      // a generic `for` clause (or statement if `forBody` is passed)
+      for(u, E) {
+        return this._for(new o(u), E);
+      }
+      // `for` statement for a range of values
+      forRange(u, E, I, U, F = this.opts.es5 ? S.varKinds.var : S.varKinds.let) {
+        const X = this._scope.toName(u);
+        return this._for(new h(F, X, E, I), () => U(X));
+      }
+      // `for-of` statement (in es5 mode replace with a normal for loop)
+      forOf(u, E, I, U = S.varKinds.const) {
+        const F = this._scope.toName(u);
+        if (this.opts.es5) {
+          const X = E instanceof r.Name ? E : this.var("_arr", E);
+          return this.forRange("_i", 0, (0, r._)`${X}.length`, (W) => {
+            this.var(F, (0, r._)`${X}[${W}]`), I(F);
+          });
+        }
+        return this._for(new n("of", U, F, E), () => I(F));
+      }
+      // `for-in` statement.
+      // With option `ownProperties` replaced with a `for-of` loop for object keys
+      forIn(u, E, I, U = this.opts.es5 ? S.varKinds.var : S.varKinds.const) {
+        if (this.opts.ownProperties)
+          return this.forOf(u, (0, r._)`Object.keys(${E})`, I);
+        const F = this._scope.toName(u);
+        return this._for(new n("in", U, F, E), () => I(F));
+      }
+      // end `for` loop
+      endFor() {
+        return this._endBlockNode(t);
+      }
+      // `label` statement
+      label(u) {
+        return this._leafNode(new w(u));
+      }
+      // `break` statement
+      break(u) {
+        return this._leafNode(new v(u));
+      }
+      // `return` statement
+      return(u) {
+        const E = new $();
+        if (this._blockNode(E), this.code(u), E.nodes.length !== 1)
+          throw new Error('CodeGen: "return" should have one node');
+        return this._endBlockNode($);
+      }
+      // `try` statement
+      try(u, E, I) {
+        if (!E && !I)
+          throw new Error('CodeGen: "try" without "catch" and "finally"');
+        const U = new j();
+        if (this._blockNode(U), this.code(u), E) {
+          const F = this.name("e");
+          this._currNode = U.catch = new C(F), E(F);
+        }
+        return I && (this._currNode = U.finally = new D(), this.code(I)), this._endBlockNode(C, D);
+      }
+      // `throw` statement
+      throw(u) {
+        return this._leafNode(new P(u));
+      }
+      // start self-balancing block
+      block(u, E) {
+        return this._blockStarts.push(this._nodes.length), u && this.code(u).endBlock(E), this;
+      }
+      // end the current self-balancing block
+      endBlock(u) {
+        const E = this._blockStarts.pop();
+        if (E === void 0)
+          throw new Error("CodeGen: not in self-balancing block");
+        const I = this._nodes.length - E;
+        if (I < 0 || u !== void 0 && I !== u)
+          throw new Error(`CodeGen: wrong number of nodes: ${I} vs ${u} expected`);
+        return this._nodes.length = E, this;
+      }
+      // `function` heading (or definition if funcBody is passed)
+      func(u, E = r.nil, I, U) {
+        return this._blockNode(new l(u, E, I)), U && this.code(U).endFunc(), this;
+      }
+      // end function definition
+      endFunc() {
+        return this._endBlockNode(l);
+      }
+      optimize(u = 1) {
+        for (; u-- > 0; )
+          this._root.optimizeNodes(), this._root.optimizeNames(this._root.names, this._constants);
+      }
+      _leafNode(u) {
+        return this._currNode.nodes.push(u), this;
+      }
+      _blockNode(u) {
+        this._currNode.nodes.push(u), this._nodes.push(u);
+      }
+      _endBlockNode(u, E) {
+        const I = this._currNode;
+        if (I instanceof u || E && I instanceof E)
+          return this._nodes.pop(), this;
+        throw new Error(`CodeGen: not in block "${E ? `${u.kind}/${E.kind}` : u.kind}"`);
+      }
+      _elseNode(u) {
+        const E = this._currNode;
+        if (!(E instanceof i))
+          throw new Error('CodeGen: "else" without "if"');
+        return this._currNode = E.else = u, this;
+      }
+      get _root() {
+        return this._nodes[0];
+      }
+      get _currNode() {
+        const u = this._nodes;
+        return u[u.length - 1];
+      }
+      set _currNode(u) {
+        const E = this._nodes;
+        E[E.length - 1] = u;
+      }
+    }
+    e.CodeGen = V;
+    function L(O, u) {
+      for (const E in u)
+        O[E] = (O[E] || 0) + (u[E] || 0);
+      return O;
+    }
+    function K(O, u) {
+      return u instanceof r._CodeOrName ? L(O, u.names) : O;
+    }
+    function B(O, u, E) {
+      if (O instanceof r.Name)
+        return I(O);
+      if (!U(O))
+        return O;
+      return new r._Code(O._items.reduce((F, X) => (X instanceof r.Name && (X = I(X)), X instanceof r._Code ? F.push(...X._items) : F.push(X), F), []));
+      function I(F) {
+        const X = E[F.str];
+        return X === void 0 || u[F.str] !== 1 ? F : (delete u[F.str], X);
+      }
+      function U(F) {
+        return F instanceof r._Code && F._items.some((X) => X instanceof r.Name && u[X.str] === 1 && E[X.str] !== void 0);
+      }
+    }
+    function x(O, u) {
+      for (const E in u)
+        O[E] = (O[E] || 0) - (u[E] || 0);
+    }
+    function de(O) {
+      return typeof O == "boolean" || typeof O == "number" || O === null ? !O : (0, r._)`!${T(O)}`;
+    }
+    e.not = de;
+    const fe = R(e.operators.AND);
+    function Z(...O) {
+      return O.reduce(fe);
+    }
+    e.and = Z;
+    const ye = R(e.operators.OR);
+    function A(...O) {
+      return O.reduce(ye);
+    }
+    e.or = A;
+    function R(O) {
+      return (u, E) => u === r.nil ? E : E === r.nil ? u : (0, r._)`${T(u)} ${O} ${T(E)}`;
+    }
+    function T(O) {
+      return O instanceof r.Name ? O : (0, r._)`(${O})`;
+    }
+  })(St)), St;
+}
+var H = {}, Kt;
+function Q() {
+  if (Kt) return H;
+  Kt = 1, Object.defineProperty(H, "__esModule", { value: !0 }), H.checkStrictMode = H.getErrorPath = H.Type = H.useFunc = H.setEvaluated = H.evaluatedPropsToName = H.mergeEvaluated = H.eachItem = H.unescapeJsonPointer = H.escapeJsonPointer = H.escapeFragment = H.unescapeFragment = H.schemaRefOrVal = H.schemaHasRulesButRef = H.schemaHasRules = H.checkUnknownRules = H.alwaysValidSchema = H.toHash = void 0;
+  const e = J(), r = ht();
+  function S(n) {
+    const l = {};
+    for (const $ of n)
+      l[$] = !0;
+    return l;
+  }
+  H.toHash = S;
+  function d(n, l) {
+    return typeof l == "boolean" ? l : Object.keys(l).length === 0 ? !0 : (g(n, l), !s(l, n.self.RULES.all));
+  }
+  H.alwaysValidSchema = d;
+  function g(n, l = n.schema) {
+    const { opts: $, self: j } = n;
+    if (!$.strictSchema || typeof l == "boolean")
+      return;
+    const C = j.RULES.keywords;
+    for (const D in l)
+      C[D] || h(n, `unknown keyword: "${D}"`);
+  }
+  H.checkUnknownRules = g;
+  function s(n, l) {
+    if (typeof n == "boolean")
+      return !n;
+    for (const $ in n)
+      if (l[$])
+        return !0;
+    return !1;
+  }
+  H.schemaHasRules = s;
+  function f(n, l) {
+    if (typeof n == "boolean")
+      return !n;
+    for (const $ in n)
+      if ($ !== "$ref" && l.all[$])
+        return !0;
+    return !1;
+  }
+  H.schemaHasRulesButRef = f;
+  function c({ topSchemaRef: n, schemaPath: l }, $, j, C) {
+    if (!C) {
+      if (typeof $ == "number" || typeof $ == "boolean")
+        return $;
+      if (typeof $ == "string")
+        return (0, e._)`${$}`;
+    }
+    return (0, e._)`${n}${l}${(0, e.getProperty)(j)}`;
+  }
+  H.schemaRefOrVal = c;
+  function m(n) {
+    return P(decodeURIComponent(n));
+  }
+  H.unescapeFragment = m;
+  function w(n) {
+    return encodeURIComponent(v(n));
+  }
+  H.escapeFragment = w;
+  function v(n) {
+    return typeof n == "number" ? `${n}` : n.replace(/~/g, "~0").replace(/\//g, "~1");
+  }
+  H.escapeJsonPointer = v;
+  function P(n) {
+    return n.replace(/~1/g, "/").replace(/~0/g, "~");
+  }
+  H.unescapeJsonPointer = P;
+  function _(n, l) {
+    if (Array.isArray(n))
+      for (const $ of n)
+        l($);
+    else
+      l(n);
+  }
+  H.eachItem = _;
+  function y({ mergeNames: n, mergeToName: l, mergeValues: $, resultToName: j }) {
+    return (C, D, V, L) => {
+      const K = V === void 0 ? D : V instanceof e.Name ? (D instanceof e.Name ? n(C, D, V) : l(C, D, V), V) : D instanceof e.Name ? (l(C, V, D), D) : $(D, V);
+      return L === e.Name && !(K instanceof e.Name) ? j(C, K) : K;
+    };
+  }
+  H.mergeEvaluated = {
+    props: y({
+      mergeNames: (n, l, $) => n.if((0, e._)`${$} !== true && ${l} !== undefined`, () => {
+        n.if((0, e._)`${l} === true`, () => n.assign($, !0), () => n.assign($, (0, e._)`${$} || {}`).code((0, e._)`Object.assign(${$}, ${l})`));
+      }),
+      mergeToName: (n, l, $) => n.if((0, e._)`${$} !== true`, () => {
+        l === !0 ? n.assign($, !0) : (n.assign($, (0, e._)`${$} || {}`), b(n, $, l));
+      }),
+      mergeValues: (n, l) => n === !0 ? !0 : { ...n, ...l },
+      resultToName: p
+    }),
+    items: y({
+      mergeNames: (n, l, $) => n.if((0, e._)`${$} !== true && ${l} !== undefined`, () => n.assign($, (0, e._)`${l} === true ? true : ${$} > ${l} ? ${$} : ${l}`)),
+      mergeToName: (n, l, $) => n.if((0, e._)`${$} !== true`, () => n.assign($, l === !0 ? !0 : (0, e._)`${$} > ${l} ? ${$} : ${l}`)),
+      mergeValues: (n, l) => n === !0 ? !0 : Math.max(n, l),
+      resultToName: (n, l) => n.var("items", l)
+    })
+  };
+  function p(n, l) {
+    if (l === !0)
+      return n.var("props", !0);
+    const $ = n.var("props", (0, e._)`{}`);
+    return l !== void 0 && b(n, $, l), $;
+  }
+  H.evaluatedPropsToName = p;
+  function b(n, l, $) {
+    Object.keys($).forEach((j) => n.assign((0, e._)`${l}${(0, e.getProperty)(j)}`, !0));
+  }
+  H.setEvaluated = b;
+  const a = {};
+  function i(n, l) {
+    return n.scopeValue("func", {
+      ref: l,
+      code: a[l.code] || (a[l.code] = new r._Code(l.code))
+    });
+  }
+  H.useFunc = i;
+  var t;
+  (function(n) {
+    n[n.Num = 0] = "Num", n[n.Str = 1] = "Str";
+  })(t || (H.Type = t = {}));
+  function o(n, l, $) {
+    if (n instanceof e.Name) {
+      const j = l === t.Num;
+      return $ ? j ? (0, e._)`"[" + ${n} + "]"` : (0, e._)`"['" + ${n} + "']"` : j ? (0, e._)`"/" + ${n}` : (0, e._)`"/" + ${n}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+    }
+    return $ ? (0, e.getProperty)(n).toString() : "/" + v(n);
+  }
+  H.getErrorPath = o;
+  function h(n, l, $ = n.opts.strictSchema) {
+    if ($) {
+      if (l = `strict mode: ${l}`, $ === !0)
+        throw new Error(l);
+      n.self.logger.warn(l);
+    }
+  }
+  return H.checkStrictMode = h, H;
+}
+var je = {}, Lt;
+function _e() {
+  if (Lt) return je;
+  Lt = 1, Object.defineProperty(je, "__esModule", { value: !0 });
+  const e = J(), r = {
+    // validation function arguments
+    data: new e.Name("data"),
+    // data passed to validation function
+    // args passed from referencing schema
+    valCxt: new e.Name("valCxt"),
+    // validation/data context - should not be used directly, it is destructured to the names below
+    instancePath: new e.Name("instancePath"),
+    parentData: new e.Name("parentData"),
+    parentDataProperty: new e.Name("parentDataProperty"),
+    rootData: new e.Name("rootData"),
+    // root data - same as the data passed to the first/top validation function
+    dynamicAnchors: new e.Name("dynamicAnchors"),
+    // used to support recursiveRef and dynamicRef
+    // function scoped variables
+    vErrors: new e.Name("vErrors"),
+    // null or array of validation errors
+    errors: new e.Name("errors"),
+    // counter of validation errors
+    this: new e.Name("this"),
+    // "globals"
+    self: new e.Name("self"),
+    scope: new e.Name("scope"),
+    // JTD serialize/parse name for JSON string and position
+    json: new e.Name("json"),
+    jsonPos: new e.Name("jsonPos"),
+    jsonLen: new e.Name("jsonLen"),
+    jsonPart: new e.Name("jsonPart")
+  };
+  return je.default = r, je;
+}
+var Ht;
+function pt() {
+  return Ht || (Ht = 1, (function(e) {
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.extendErrors = e.resetErrorsCount = e.reportExtraError = e.reportError = e.keyword$DataError = e.keywordError = void 0;
+    const r = J(), S = Q(), d = _e();
+    e.keywordError = {
+      message: ({ keyword: a }) => (0, r.str)`must pass "${a}" keyword validation`
+    }, e.keyword$DataError = {
+      message: ({ keyword: a, schemaType: i }) => i ? (0, r.str)`"${a}" keyword must be ${i} ($data)` : (0, r.str)`"${a}" keyword is invalid ($data)`
+    };
+    function g(a, i = e.keywordError, t, o) {
+      const { it: h } = a, { gen: n, compositeRule: l, allErrors: $ } = h, j = P(a, i, t);
+      o ?? (l || $) ? m(n, j) : w(h, (0, r._)`[${j}]`);
+    }
+    e.reportError = g;
+    function s(a, i = e.keywordError, t) {
+      const { it: o } = a, { gen: h, compositeRule: n, allErrors: l } = o, $ = P(a, i, t);
+      m(h, $), n || l || w(o, d.default.vErrors);
+    }
+    e.reportExtraError = s;
+    function f(a, i) {
+      a.assign(d.default.errors, i), a.if((0, r._)`${d.default.vErrors} !== null`, () => a.if(i, () => a.assign((0, r._)`${d.default.vErrors}.length`, i), () => a.assign(d.default.vErrors, null)));
+    }
+    e.resetErrorsCount = f;
+    function c({ gen: a, keyword: i, schemaValue: t, data: o, errsCount: h, it: n }) {
+      if (h === void 0)
+        throw new Error("ajv implementation error");
+      const l = a.name("err");
+      a.forRange("i", h, d.default.errors, ($) => {
+        a.const(l, (0, r._)`${d.default.vErrors}[${$}]`), a.if((0, r._)`${l}.instancePath === undefined`, () => a.assign((0, r._)`${l}.instancePath`, (0, r.strConcat)(d.default.instancePath, n.errorPath))), a.assign((0, r._)`${l}.schemaPath`, (0, r.str)`${n.errSchemaPath}/${i}`), n.opts.verbose && (a.assign((0, r._)`${l}.schema`, t), a.assign((0, r._)`${l}.data`, o));
+      });
+    }
+    e.extendErrors = c;
+    function m(a, i) {
+      const t = a.const("err", i);
+      a.if((0, r._)`${d.default.vErrors} === null`, () => a.assign(d.default.vErrors, (0, r._)`[${t}]`), (0, r._)`${d.default.vErrors}.push(${t})`), a.code((0, r._)`${d.default.errors}++`);
+    }
+    function w(a, i) {
+      const { gen: t, validateName: o, schemaEnv: h } = a;
+      h.$async ? t.throw((0, r._)`new ${a.ValidationError}(${i})`) : (t.assign((0, r._)`${o}.errors`, i), t.return(!1));
+    }
+    const v = {
+      keyword: new r.Name("keyword"),
+      schemaPath: new r.Name("schemaPath"),
+      // also used in JTD errors
+      params: new r.Name("params"),
+      propertyName: new r.Name("propertyName"),
+      message: new r.Name("message"),
+      schema: new r.Name("schema"),
+      parentSchema: new r.Name("parentSchema")
+    };
+    function P(a, i, t) {
+      const { createErrors: o } = a.it;
+      return o === !1 ? (0, r._)`{}` : _(a, i, t);
+    }
+    function _(a, i, t = {}) {
+      const { gen: o, it: h } = a, n = [
+        y(h, t),
+        p(a, t)
+      ];
+      return b(a, i, n), o.object(...n);
+    }
+    function y({ errorPath: a }, { instancePath: i }) {
+      const t = i ? (0, r.str)`${a}${(0, S.getErrorPath)(i, S.Type.Str)}` : a;
+      return [d.default.instancePath, (0, r.strConcat)(d.default.instancePath, t)];
+    }
+    function p({ keyword: a, it: { errSchemaPath: i } }, { schemaPath: t, parentSchema: o }) {
+      let h = o ? i : (0, r.str)`${i}/${a}`;
+      return t && (h = (0, r.str)`${h}${(0, S.getErrorPath)(t, S.Type.Str)}`), [v.schemaPath, h];
+    }
+    function b(a, { params: i, message: t }, o) {
+      const { keyword: h, data: n, schemaValue: l, it: $ } = a, { opts: j, propertyName: C, topSchemaRef: D, schemaPath: V } = $;
+      o.push([v.keyword, h], [v.params, typeof i == "function" ? i(a) : i || (0, r._)`{}`]), j.messages && o.push([v.message, typeof t == "function" ? t(a) : t]), j.verbose && o.push([v.schema, l], [v.parentSchema, (0, r._)`${D}${V}`], [d.default.data, n]), C && o.push([v.propertyName, C]);
+    }
+  })(Et)), Et;
+}
+var Gt;
+function dn() {
+  if (Gt) return ge;
+  Gt = 1, Object.defineProperty(ge, "__esModule", { value: !0 }), ge.boolOrEmptySchema = ge.topBoolOrEmptySchema = void 0;
+  const e = pt(), r = J(), S = _e(), d = {
+    message: "boolean schema is false"
+  };
+  function g(c) {
+    const { gen: m, schema: w, validateName: v } = c;
+    w === !1 ? f(c, !1) : typeof w == "object" && w.$async === !0 ? m.return(S.default.data) : (m.assign((0, r._)`${v}.errors`, null), m.return(!0));
+  }
+  ge.topBoolOrEmptySchema = g;
+  function s(c, m) {
+    const { gen: w, schema: v } = c;
+    v === !1 ? (w.var(m, !1), f(c)) : w.var(m, !0);
+  }
+  ge.boolOrEmptySchema = s;
+  function f(c, m) {
+    const { gen: w, data: v } = c, P = {
+      gen: w,
+      keyword: "false schema",
+      data: v,
+      schema: !1,
+      schemaCode: !1,
+      schemaValue: !1,
+      params: {},
+      it: c
+    };
+    (0, e.reportError)(P, d, void 0, m);
+  }
+  return ge;
+}
+var re = {}, $e = {}, Jt;
+function Yr() {
+  if (Jt) return $e;
+  Jt = 1, Object.defineProperty($e, "__esModule", { value: !0 }), $e.getRules = $e.isJSONType = void 0;
+  const e = ["string", "number", "integer", "boolean", "null", "object", "array"], r = new Set(e);
+  function S(g) {
+    return typeof g == "string" && r.has(g);
+  }
+  $e.isJSONType = S;
+  function d() {
+    const g = {
+      number: { type: "number", rules: [] },
+      string: { type: "string", rules: [] },
+      array: { type: "array", rules: [] },
+      object: { type: "object", rules: [] }
+    };
+    return {
+      types: { ...g, integer: !0, boolean: !0, null: !0 },
+      rules: [{ rules: [] }, g.number, g.string, g.array, g.object],
+      post: { rules: [] },
+      all: {},
+      keywords: {}
+    };
+  }
+  return $e.getRules = d, $e;
+}
+var me = {}, Wt;
+function Zr() {
+  if (Wt) return me;
+  Wt = 1, Object.defineProperty(me, "__esModule", { value: !0 }), me.shouldUseRule = me.shouldUseGroup = me.schemaHasRulesForType = void 0;
+  function e({ schema: d, self: g }, s) {
+    const f = g.RULES.types[s];
+    return f && f !== !0 && r(d, f);
+  }
+  me.schemaHasRulesForType = e;
+  function r(d, g) {
+    return g.rules.some((s) => S(d, s));
+  }
+  me.shouldUseGroup = r;
+  function S(d, g) {
+    var s;
+    return d[g.keyword] !== void 0 || ((s = g.definition.implements) === null || s === void 0 ? void 0 : s.some((f) => d[f] !== void 0));
+  }
+  return me.shouldUseRule = S, me;
+}
+var Bt;
+function mt() {
+  if (Bt) return re;
+  Bt = 1, Object.defineProperty(re, "__esModule", { value: !0 }), re.reportTypeError = re.checkDataTypes = re.checkDataType = re.coerceAndCheckDataType = re.getJSONTypes = re.getSchemaTypes = re.DataType = void 0;
+  const e = Yr(), r = Zr(), S = pt(), d = J(), g = Q();
+  var s;
+  (function(t) {
+    t[t.Correct = 0] = "Correct", t[t.Wrong = 1] = "Wrong";
+  })(s || (re.DataType = s = {}));
+  function f(t) {
+    const o = c(t.type);
+    if (o.includes("null")) {
+      if (t.nullable === !1)
+        throw new Error("type: null contradicts nullable: false");
+    } else {
+      if (!o.length && t.nullable !== void 0)
+        throw new Error('"nullable" cannot be used without "type"');
+      t.nullable === !0 && o.push("null");
+    }
+    return o;
+  }
+  re.getSchemaTypes = f;
+  function c(t) {
+    const o = Array.isArray(t) ? t : t ? [t] : [];
+    if (o.every(e.isJSONType))
+      return o;
+    throw new Error("type must be JSONType or JSONType[]: " + o.join(","));
+  }
+  re.getJSONTypes = c;
+  function m(t, o) {
+    const { gen: h, data: n, opts: l } = t, $ = v(o, l.coerceTypes), j = o.length > 0 && !($.length === 0 && o.length === 1 && (0, r.schemaHasRulesForType)(t, o[0]));
+    if (j) {
+      const C = p(o, n, l.strictNumbers, s.Wrong);
+      h.if(C, () => {
+        $.length ? P(t, o, $) : a(t);
+      });
+    }
+    return j;
+  }
+  re.coerceAndCheckDataType = m;
+  const w = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
+  function v(t, o) {
+    return o ? t.filter((h) => w.has(h) || o === "array" && h === "array") : [];
+  }
+  function P(t, o, h) {
+    const { gen: n, data: l, opts: $ } = t, j = n.let("dataType", (0, d._)`typeof ${l}`), C = n.let("coerced", (0, d._)`undefined`);
+    $.coerceTypes === "array" && n.if((0, d._)`${j} == 'object' && Array.isArray(${l}) && ${l}.length == 1`, () => n.assign(l, (0, d._)`${l}[0]`).assign(j, (0, d._)`typeof ${l}`).if(p(o, l, $.strictNumbers), () => n.assign(C, l))), n.if((0, d._)`${C} !== undefined`);
+    for (const V of h)
+      (w.has(V) || V === "array" && $.coerceTypes === "array") && D(V);
+    n.else(), a(t), n.endIf(), n.if((0, d._)`${C} !== undefined`, () => {
+      n.assign(l, C), _(t, C);
+    });
+    function D(V) {
+      switch (V) {
+        case "string":
+          n.elseIf((0, d._)`${j} == "number" || ${j} == "boolean"`).assign(C, (0, d._)`"" + ${l}`).elseIf((0, d._)`${l} === null`).assign(C, (0, d._)`""`);
+          return;
+        case "number":
+          n.elseIf((0, d._)`${j} == "boolean" || ${l} === null
+              || (${j} == "string" && ${l} && ${l} == +${l})`).assign(C, (0, d._)`+${l}`);
+          return;
+        case "integer":
+          n.elseIf((0, d._)`${j} === "boolean" || ${l} === null
+              || (${j} === "string" && ${l} && ${l} == +${l} && !(${l} % 1))`).assign(C, (0, d._)`+${l}`);
+          return;
+        case "boolean":
+          n.elseIf((0, d._)`${l} === "false" || ${l} === 0 || ${l} === null`).assign(C, !1).elseIf((0, d._)`${l} === "true" || ${l} === 1`).assign(C, !0);
+          return;
+        case "null":
+          n.elseIf((0, d._)`${l} === "" || ${l} === 0 || ${l} === false`), n.assign(C, null);
+          return;
+        case "array":
+          n.elseIf((0, d._)`${j} === "string" || ${j} === "number"
+              || ${j} === "boolean" || ${l} === null`).assign(C, (0, d._)`[${l}]`);
+      }
+    }
+  }
+  function _({ gen: t, parentData: o, parentDataProperty: h }, n) {
+    t.if((0, d._)`${o} !== undefined`, () => t.assign((0, d._)`${o}[${h}]`, n));
+  }
+  function y(t, o, h, n = s.Correct) {
+    const l = n === s.Correct ? d.operators.EQ : d.operators.NEQ;
+    let $;
+    switch (t) {
+      case "null":
+        return (0, d._)`${o} ${l} null`;
+      case "array":
+        $ = (0, d._)`Array.isArray(${o})`;
+        break;
+      case "object":
+        $ = (0, d._)`${o} && typeof ${o} == "object" && !Array.isArray(${o})`;
+        break;
+      case "integer":
+        $ = j((0, d._)`!(${o} % 1) && !isNaN(${o})`);
+        break;
+      case "number":
+        $ = j();
+        break;
+      default:
+        return (0, d._)`typeof ${o} ${l} ${t}`;
+    }
+    return n === s.Correct ? $ : (0, d.not)($);
+    function j(C = d.nil) {
+      return (0, d.and)((0, d._)`typeof ${o} == "number"`, C, h ? (0, d._)`isFinite(${o})` : d.nil);
+    }
+  }
+  re.checkDataType = y;
+  function p(t, o, h, n) {
+    if (t.length === 1)
+      return y(t[0], o, h, n);
+    let l;
+    const $ = (0, g.toHash)(t);
+    if ($.array && $.object) {
+      const j = (0, d._)`typeof ${o} != "object"`;
+      l = $.null ? j : (0, d._)`!${o} || ${j}`, delete $.null, delete $.array, delete $.object;
+    } else
+      l = d.nil;
+    $.number && delete $.integer;
+    for (const j in $)
+      l = (0, d.and)(l, y(j, o, h, n));
+    return l;
+  }
+  re.checkDataTypes = p;
+  const b = {
+    message: ({ schema: t }) => `must be ${t}`,
+    params: ({ schema: t, schemaValue: o }) => typeof t == "string" ? (0, d._)`{type: ${t}}` : (0, d._)`{type: ${o}}`
+  };
+  function a(t) {
+    const o = i(t);
+    (0, S.reportError)(o, b);
+  }
+  re.reportTypeError = a;
+  function i(t) {
+    const { gen: o, data: h, schema: n } = t, l = (0, g.schemaRefOrVal)(t, n, "type");
+    return {
+      gen: o,
+      keyword: "type",
+      data: h,
+      schema: n.type,
+      schemaCode: l,
+      schemaValue: l,
+      parentSchema: n,
+      params: {},
+      it: t
+    };
+  }
+  return re;
+}
+var Ne = {}, Qt;
+function fn() {
+  if (Qt) return Ne;
+  Qt = 1, Object.defineProperty(Ne, "__esModule", { value: !0 }), Ne.assignDefaults = void 0;
+  const e = J(), r = Q();
+  function S(g, s) {
+    const { properties: f, items: c } = g.schema;
+    if (s === "object" && f)
+      for (const m in f)
+        d(g, m, f[m].default);
+    else s === "array" && Array.isArray(c) && c.forEach((m, w) => d(g, w, m.default));
+  }
+  Ne.assignDefaults = S;
+  function d(g, s, f) {
+    const { gen: c, compositeRule: m, data: w, opts: v } = g;
+    if (f === void 0)
+      return;
+    const P = (0, e._)`${w}${(0, e.getProperty)(s)}`;
+    if (m) {
+      (0, r.checkStrictMode)(g, `default is ignored for: ${P}`);
+      return;
+    }
+    let _ = (0, e._)`${P} === undefined`;
+    v.useDefaults === "empty" && (_ = (0, e._)`${_} || ${P} === null || ${P} === ""`), c.if(_, (0, e._)`${P} = ${(0, e.stringify)(f)}`);
+  }
+  return Ne;
+}
+var ce = {}, Y = {}, Xt;
+function le() {
+  if (Xt) return Y;
+  Xt = 1, Object.defineProperty(Y, "__esModule", { value: !0 }), Y.validateUnion = Y.validateArray = Y.usePattern = Y.callValidateCode = Y.schemaProperties = Y.allSchemaProperties = Y.noPropertyInData = Y.propertyInData = Y.isOwnProperty = Y.hasPropFunc = Y.reportMissingProp = Y.checkMissingProp = Y.checkReportMissingProp = void 0;
+  const e = J(), r = Q(), S = _e(), d = Q();
+  function g(t, o) {
+    const { gen: h, data: n, it: l } = t;
+    h.if(v(h, n, o, l.opts.ownProperties), () => {
+      t.setParams({ missingProperty: (0, e._)`${o}` }, !0), t.error();
+    });
+  }
+  Y.checkReportMissingProp = g;
+  function s({ gen: t, data: o, it: { opts: h } }, n, l) {
+    return (0, e.or)(...n.map(($) => (0, e.and)(v(t, o, $, h.ownProperties), (0, e._)`${l} = ${$}`)));
+  }
+  Y.checkMissingProp = s;
+  function f(t, o) {
+    t.setParams({ missingProperty: o }, !0), t.error();
+  }
+  Y.reportMissingProp = f;
+  function c(t) {
+    return t.scopeValue("func", {
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      ref: Object.prototype.hasOwnProperty,
+      code: (0, e._)`Object.prototype.hasOwnProperty`
+    });
+  }
+  Y.hasPropFunc = c;
+  function m(t, o, h) {
+    return (0, e._)`${c(t)}.call(${o}, ${h})`;
+  }
+  Y.isOwnProperty = m;
+  function w(t, o, h, n) {
+    const l = (0, e._)`${o}${(0, e.getProperty)(h)} !== undefined`;
+    return n ? (0, e._)`${l} && ${m(t, o, h)}` : l;
+  }
+  Y.propertyInData = w;
+  function v(t, o, h, n) {
+    const l = (0, e._)`${o}${(0, e.getProperty)(h)} === undefined`;
+    return n ? (0, e.or)(l, (0, e.not)(m(t, o, h))) : l;
+  }
+  Y.noPropertyInData = v;
+  function P(t) {
+    return t ? Object.keys(t).filter((o) => o !== "__proto__") : [];
+  }
+  Y.allSchemaProperties = P;
+  function _(t, o) {
+    return P(o).filter((h) => !(0, r.alwaysValidSchema)(t, o[h]));
+  }
+  Y.schemaProperties = _;
+  function y({ schemaCode: t, data: o, it: { gen: h, topSchemaRef: n, schemaPath: l, errorPath: $ }, it: j }, C, D, V) {
+    const L = V ? (0, e._)`${t}, ${o}, ${n}${l}` : o, K = [
+      [S.default.instancePath, (0, e.strConcat)(S.default.instancePath, $)],
+      [S.default.parentData, j.parentData],
+      [S.default.parentDataProperty, j.parentDataProperty],
+      [S.default.rootData, S.default.rootData]
+    ];
+    j.opts.dynamicRef && K.push([S.default.dynamicAnchors, S.default.dynamicAnchors]);
+    const B = (0, e._)`${L}, ${h.object(...K)}`;
+    return D !== e.nil ? (0, e._)`${C}.call(${D}, ${B})` : (0, e._)`${C}(${B})`;
+  }
+  Y.callValidateCode = y;
+  const p = (0, e._)`new RegExp`;
+  function b({ gen: t, it: { opts: o } }, h) {
+    const n = o.unicodeRegExp ? "u" : "", { regExp: l } = o.code, $ = l(h, n);
+    return t.scopeValue("pattern", {
+      key: $.toString(),
+      ref: $,
+      code: (0, e._)`${l.code === "new RegExp" ? p : (0, d.useFunc)(t, l)}(${h}, ${n})`
+    });
+  }
+  Y.usePattern = b;
+  function a(t) {
+    const { gen: o, data: h, keyword: n, it: l } = t, $ = o.name("valid");
+    if (l.allErrors) {
+      const C = o.let("valid", !0);
+      return j(() => o.assign(C, !1)), C;
+    }
+    return o.var($, !0), j(() => o.break()), $;
+    function j(C) {
+      const D = o.const("len", (0, e._)`${h}.length`);
+      o.forRange("i", 0, D, (V) => {
+        t.subschema({
+          keyword: n,
+          dataProp: V,
+          dataPropType: r.Type.Num
+        }, $), o.if((0, e.not)($), C);
+      });
+    }
+  }
+  Y.validateArray = a;
+  function i(t) {
+    const { gen: o, schema: h, keyword: n, it: l } = t;
+    if (!Array.isArray(h))
+      throw new Error("ajv implementation error");
+    if (h.some((D) => (0, r.alwaysValidSchema)(l, D)) && !l.opts.unevaluated)
+      return;
+    const j = o.let("valid", !1), C = o.name("_valid");
+    o.block(() => h.forEach((D, V) => {
+      const L = t.subschema({
+        keyword: n,
+        schemaProp: V,
+        compositeRule: !0
+      }, C);
+      o.assign(j, (0, e._)`${j} || ${C}`), t.mergeValidEvaluated(L, C) || o.if((0, e.not)(j));
+    })), t.result(j, () => t.reset(), () => t.error(!0));
+  }
+  return Y.validateUnion = i, Y;
+}
+var Yt;
+function hn() {
+  if (Yt) return ce;
+  Yt = 1, Object.defineProperty(ce, "__esModule", { value: !0 }), ce.validateKeywordUsage = ce.validSchemaType = ce.funcKeywordCode = ce.macroKeywordCode = void 0;
+  const e = J(), r = _e(), S = le(), d = pt();
+  function g(_, y) {
+    const { gen: p, keyword: b, schema: a, parentSchema: i, it: t } = _, o = y.macro.call(t.self, a, i, t), h = w(p, b, o);
+    t.opts.validateSchema !== !1 && t.self.validateSchema(o, !0);
+    const n = p.name("valid");
+    _.subschema({
+      schema: o,
+      schemaPath: e.nil,
+      errSchemaPath: `${t.errSchemaPath}/${b}`,
+      topSchemaRef: h,
+      compositeRule: !0
+    }, n), _.pass(n, () => _.error(!0));
+  }
+  ce.macroKeywordCode = g;
+  function s(_, y) {
+    var p;
+    const { gen: b, keyword: a, schema: i, parentSchema: t, $data: o, it: h } = _;
+    m(h, y);
+    const n = !o && y.compile ? y.compile.call(h.self, i, t, h) : y.validate, l = w(b, a, n), $ = b.let("valid");
+    _.block$data($, j), _.ok((p = y.valid) !== null && p !== void 0 ? p : $);
+    function j() {
+      if (y.errors === !1)
+        V(), y.modifying && f(_), L(() => _.error());
+      else {
+        const K = y.async ? C() : D();
+        y.modifying && f(_), L(() => c(_, K));
+      }
+    }
+    function C() {
+      const K = b.let("ruleErrs", null);
+      return b.try(() => V((0, e._)`await `), (B) => b.assign($, !1).if((0, e._)`${B} instanceof ${h.ValidationError}`, () => b.assign(K, (0, e._)`${B}.errors`), () => b.throw(B))), K;
+    }
+    function D() {
+      const K = (0, e._)`${l}.errors`;
+      return b.assign(K, null), V(e.nil), K;
+    }
+    function V(K = y.async ? (0, e._)`await ` : e.nil) {
+      const B = h.opts.passContext ? r.default.this : r.default.self, x = !("compile" in y && !o || y.schema === !1);
+      b.assign($, (0, e._)`${K}${(0, S.callValidateCode)(_, l, B, x)}`, y.modifying);
+    }
+    function L(K) {
+      var B;
+      b.if((0, e.not)((B = y.valid) !== null && B !== void 0 ? B : $), K);
+    }
+  }
+  ce.funcKeywordCode = s;
+  function f(_) {
+    const { gen: y, data: p, it: b } = _;
+    y.if(b.parentData, () => y.assign(p, (0, e._)`${b.parentData}[${b.parentDataProperty}]`));
+  }
+  function c(_, y) {
+    const { gen: p } = _;
+    p.if((0, e._)`Array.isArray(${y})`, () => {
+      p.assign(r.default.vErrors, (0, e._)`${r.default.vErrors} === null ? ${y} : ${r.default.vErrors}.concat(${y})`).assign(r.default.errors, (0, e._)`${r.default.vErrors}.length`), (0, d.extendErrors)(_);
+    }, () => _.error());
+  }
+  function m({ schemaEnv: _ }, y) {
+    if (y.async && !_.$async)
+      throw new Error("async keyword in sync schema");
+  }
+  function w(_, y, p) {
+    if (p === void 0)
+      throw new Error(`keyword "${y}" failed to compile`);
+    return _.scopeValue("keyword", typeof p == "function" ? { ref: p } : { ref: p, code: (0, e.stringify)(p) });
+  }
+  function v(_, y, p = !1) {
+    return !y.length || y.some((b) => b === "array" ? Array.isArray(_) : b === "object" ? _ && typeof _ == "object" && !Array.isArray(_) : typeof _ == b || p && typeof _ > "u");
+  }
+  ce.validSchemaType = v;
+  function P({ schema: _, opts: y, self: p, errSchemaPath: b }, a, i) {
+    if (Array.isArray(a.keyword) ? !a.keyword.includes(i) : a.keyword !== i)
+      throw new Error("ajv implementation error");
+    const t = a.dependencies;
+    if (t?.some((o) => !Object.prototype.hasOwnProperty.call(_, o)))
+      throw new Error(`parent schema must have dependencies of ${i}: ${t.join(",")}`);
+    if (a.validateSchema && !a.validateSchema(_[i])) {
+      const h = `keyword "${i}" value is invalid at path "${b}": ` + p.errorsText(a.validateSchema.errors);
+      if (y.validateSchema === "log")
+        p.logger.error(h);
+      else
+        throw new Error(h);
+    }
+  }
+  return ce.validateKeywordUsage = P, ce;
+}
+var pe = {}, Zt;
+function mn() {
+  if (Zt) return pe;
+  Zt = 1, Object.defineProperty(pe, "__esModule", { value: !0 }), pe.extendSubschemaMode = pe.extendSubschemaData = pe.getSubschema = void 0;
+  const e = J(), r = Q();
+  function S(s, { keyword: f, schemaProp: c, schema: m, schemaPath: w, errSchemaPath: v, topSchemaRef: P }) {
+    if (f !== void 0 && m !== void 0)
+      throw new Error('both "keyword" and "schema" passed, only one allowed');
+    if (f !== void 0) {
+      const _ = s.schema[f];
+      return c === void 0 ? {
+        schema: _,
+        schemaPath: (0, e._)`${s.schemaPath}${(0, e.getProperty)(f)}`,
+        errSchemaPath: `${s.errSchemaPath}/${f}`
+      } : {
+        schema: _[c],
+        schemaPath: (0, e._)`${s.schemaPath}${(0, e.getProperty)(f)}${(0, e.getProperty)(c)}`,
+        errSchemaPath: `${s.errSchemaPath}/${f}/${(0, r.escapeFragment)(c)}`
+      };
+    }
+    if (m !== void 0) {
+      if (w === void 0 || v === void 0 || P === void 0)
+        throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
+      return {
+        schema: m,
+        schemaPath: w,
+        topSchemaRef: P,
+        errSchemaPath: v
+      };
+    }
+    throw new Error('either "keyword" or "schema" must be passed');
+  }
+  pe.getSubschema = S;
+  function d(s, f, { dataProp: c, dataPropType: m, data: w, dataTypes: v, propertyName: P }) {
+    if (w !== void 0 && c !== void 0)
+      throw new Error('both "data" and "dataProp" passed, only one allowed');
+    const { gen: _ } = f;
+    if (c !== void 0) {
+      const { errorPath: p, dataPathArr: b, opts: a } = f, i = _.let("data", (0, e._)`${f.data}${(0, e.getProperty)(c)}`, !0);
+      y(i), s.errorPath = (0, e.str)`${p}${(0, r.getErrorPath)(c, m, a.jsPropertySyntax)}`, s.parentDataProperty = (0, e._)`${c}`, s.dataPathArr = [...b, s.parentDataProperty];
+    }
+    if (w !== void 0) {
+      const p = w instanceof e.Name ? w : _.let("data", w, !0);
+      y(p), P !== void 0 && (s.propertyName = P);
+    }
+    v && (s.dataTypes = v);
+    function y(p) {
+      s.data = p, s.dataLevel = f.dataLevel + 1, s.dataTypes = [], f.definedProperties = /* @__PURE__ */ new Set(), s.parentData = f.data, s.dataNames = [...f.dataNames, p];
+    }
+  }
+  pe.extendSubschemaData = d;
+  function g(s, { jtdDiscriminator: f, jtdMetadata: c, compositeRule: m, createErrors: w, allErrors: v }) {
+    m !== void 0 && (s.compositeRule = m), w !== void 0 && (s.createErrors = w), v !== void 0 && (s.allErrors = v), s.jtdDiscriminator = f, s.jtdMetadata = c;
+  }
+  return pe.extendSubschemaMode = g, pe;
+}
+var ne = {}, Rt, xt;
+function xr() {
+  return xt || (xt = 1, Rt = function e(r, S) {
+    if (r === S) return !0;
+    if (r && S && typeof r == "object" && typeof S == "object") {
+      if (r.constructor !== S.constructor) return !1;
+      var d, g, s;
+      if (Array.isArray(r)) {
+        if (d = r.length, d != S.length) return !1;
+        for (g = d; g-- !== 0; )
+          if (!e(r[g], S[g])) return !1;
+        return !0;
+      }
+      if (r.constructor === RegExp) return r.source === S.source && r.flags === S.flags;
+      if (r.valueOf !== Object.prototype.valueOf) return r.valueOf() === S.valueOf();
+      if (r.toString !== Object.prototype.toString) return r.toString() === S.toString();
+      if (s = Object.keys(r), d = s.length, d !== Object.keys(S).length) return !1;
+      for (g = d; g-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(S, s[g])) return !1;
+      for (g = d; g-- !== 0; ) {
+        var f = s[g];
+        if (!e(r[f], S[f])) return !1;
+      }
+      return !0;
+    }
+    return r !== r && S !== S;
+  }), Rt;
+}
+var kt = { exports: {} }, er;
+function pn() {
+  if (er) return kt.exports;
+  er = 1;
+  var e = kt.exports = function(d, g, s) {
+    typeof g == "function" && (s = g, g = {}), s = g.cb || s;
+    var f = typeof s == "function" ? s : s.pre || function() {
+    }, c = s.post || function() {
+    };
+    r(g, f, c, d, "", d);
+  };
+  e.keywords = {
+    additionalItems: !0,
+    items: !0,
+    contains: !0,
+    additionalProperties: !0,
+    propertyNames: !0,
+    not: !0,
+    if: !0,
+    then: !0,
+    else: !0
+  }, e.arrayKeywords = {
+    items: !0,
+    allOf: !0,
+    anyOf: !0,
+    oneOf: !0
+  }, e.propsKeywords = {
+    $defs: !0,
+    definitions: !0,
+    properties: !0,
+    patternProperties: !0,
+    dependencies: !0
+  }, e.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(d, g, s, f, c, m, w, v, P, _) {
+    if (f && typeof f == "object" && !Array.isArray(f)) {
+      g(f, c, m, w, v, P, _);
+      for (var y in f) {
+        var p = f[y];
+        if (Array.isArray(p)) {
+          if (y in e.arrayKeywords)
+            for (var b = 0; b < p.length; b++)
+              r(d, g, s, p[b], c + "/" + y + "/" + b, m, c, y, f, b);
+        } else if (y in e.propsKeywords) {
+          if (p && typeof p == "object")
+            for (var a in p)
+              r(d, g, s, p[a], c + "/" + y + "/" + S(a), m, c, y, f, a);
+        } else (y in e.keywords || d.allKeys && !(y in e.skipKeywords)) && r(d, g, s, p, c + "/" + y, m, c, y, f);
+      }
+      s(f, c, m, w, v, P, _);
+    }
+  }
+  function S(d) {
+    return d.replace(/~/g, "~0").replace(/\//g, "~1");
+  }
+  return kt.exports;
+}
+var tr;
+function yt() {
+  if (tr) return ne;
+  tr = 1, Object.defineProperty(ne, "__esModule", { value: !0 }), ne.getSchemaRefs = ne.resolveUrl = ne.normalizeId = ne._getFullPath = ne.getFullPath = ne.inlineRef = void 0;
+  const e = Q(), r = xr(), S = pn(), d = /* @__PURE__ */ new Set([
+    "type",
+    "format",
+    "pattern",
+    "maxLength",
+    "minLength",
+    "maxProperties",
+    "minProperties",
+    "maxItems",
+    "minItems",
+    "maximum",
+    "minimum",
+    "uniqueItems",
+    "multipleOf",
+    "required",
+    "enum",
+    "const"
+  ]);
+  function g(b, a = !0) {
+    return typeof b == "boolean" ? !0 : a === !0 ? !f(b) : a ? c(b) <= a : !1;
+  }
+  ne.inlineRef = g;
+  const s = /* @__PURE__ */ new Set([
+    "$ref",
+    "$recursiveRef",
+    "$recursiveAnchor",
+    "$dynamicRef",
+    "$dynamicAnchor"
+  ]);
+  function f(b) {
+    for (const a in b) {
+      if (s.has(a))
+        return !0;
+      const i = b[a];
+      if (Array.isArray(i) && i.some(f) || typeof i == "object" && f(i))
+        return !0;
+    }
+    return !1;
+  }
+  function c(b) {
+    let a = 0;
+    for (const i in b) {
+      if (i === "$ref")
+        return 1 / 0;
+      if (a++, !d.has(i) && (typeof b[i] == "object" && (0, e.eachItem)(b[i], (t) => a += c(t)), a === 1 / 0))
+        return 1 / 0;
+    }
+    return a;
+  }
+  function m(b, a = "", i) {
+    i !== !1 && (a = P(a));
+    const t = b.parse(a);
+    return w(b, t);
+  }
+  ne.getFullPath = m;
+  function w(b, a) {
+    return b.serialize(a).split("#")[0] + "#";
+  }
+  ne._getFullPath = w;
+  const v = /#\/?$/;
+  function P(b) {
+    return b ? b.replace(v, "") : "";
+  }
+  ne.normalizeId = P;
+  function _(b, a, i) {
+    return i = P(i), b.resolve(a, i);
+  }
+  ne.resolveUrl = _;
+  const y = /^[a-z_][-a-z0-9._]*$/i;
+  function p(b, a) {
+    if (typeof b == "boolean")
+      return {};
+    const { schemaId: i, uriResolver: t } = this.opts, o = P(b[i] || a), h = { "": o }, n = m(t, o, !1), l = {}, $ = /* @__PURE__ */ new Set();
+    return S(b, { allKeys: !0 }, (D, V, L, K) => {
+      if (K === void 0)
+        return;
+      const B = n + V;
+      let x = h[K];
+      typeof D[i] == "string" && (x = de.call(this, D[i])), fe.call(this, D.$anchor), fe.call(this, D.$dynamicAnchor), h[V] = x;
+      function de(Z) {
+        const ye = this.opts.uriResolver.resolve;
+        if (Z = P(x ? ye(x, Z) : Z), $.has(Z))
+          throw C(Z);
+        $.add(Z);
+        let A = this.refs[Z];
+        return typeof A == "string" && (A = this.refs[A]), typeof A == "object" ? j(D, A.schema, Z) : Z !== P(B) && (Z[0] === "#" ? (j(D, l[Z], Z), l[Z] = D) : this.refs[Z] = B), Z;
+      }
+      function fe(Z) {
+        if (typeof Z == "string") {
+          if (!y.test(Z))
+            throw new Error(`invalid anchor "${Z}"`);
+          de.call(this, `#${Z}`);
+        }
+      }
+    }), l;
+    function j(D, V, L) {
+      if (V !== void 0 && !r(D, V))
+        throw C(L);
+    }
+    function C(D) {
+      return new Error(`reference "${D}" resolves to more than one schema`);
+    }
+  }
+  return ne.getSchemaRefs = p, ne;
+}
+var rr;
+function vt() {
+  if (rr) return he;
+  rr = 1, Object.defineProperty(he, "__esModule", { value: !0 }), he.getData = he.KeywordCxt = he.validateFunctionCode = void 0;
+  const e = dn(), r = mt(), S = Zr(), d = mt(), g = fn(), s = hn(), f = mn(), c = J(), m = _e(), w = yt(), v = Q(), P = pt();
+  function _(N) {
+    if (n(N) && ($(N), h(N))) {
+      a(N);
+      return;
+    }
+    y(N, () => (0, e.topBoolOrEmptySchema)(N));
+  }
+  he.validateFunctionCode = _;
+  function y({ gen: N, validateName: k, schema: q, schemaEnv: M, opts: z }, G) {
+    z.code.es5 ? N.func(k, (0, c._)`${m.default.data}, ${m.default.valCxt}`, M.$async, () => {
+      N.code((0, c._)`"use strict"; ${t(q, z)}`), b(N, z), N.code(G);
+    }) : N.func(k, (0, c._)`${m.default.data}, ${p(z)}`, M.$async, () => N.code(t(q, z)).code(G));
+  }
+  function p(N) {
+    return (0, c._)`{${m.default.instancePath}="", ${m.default.parentData}, ${m.default.parentDataProperty}, ${m.default.rootData}=${m.default.data}${N.dynamicRef ? (0, c._)`, ${m.default.dynamicAnchors}={}` : c.nil}}={}`;
+  }
+  function b(N, k) {
+    N.if(m.default.valCxt, () => {
+      N.var(m.default.instancePath, (0, c._)`${m.default.valCxt}.${m.default.instancePath}`), N.var(m.default.parentData, (0, c._)`${m.default.valCxt}.${m.default.parentData}`), N.var(m.default.parentDataProperty, (0, c._)`${m.default.valCxt}.${m.default.parentDataProperty}`), N.var(m.default.rootData, (0, c._)`${m.default.valCxt}.${m.default.rootData}`), k.dynamicRef && N.var(m.default.dynamicAnchors, (0, c._)`${m.default.valCxt}.${m.default.dynamicAnchors}`);
+    }, () => {
+      N.var(m.default.instancePath, (0, c._)`""`), N.var(m.default.parentData, (0, c._)`undefined`), N.var(m.default.parentDataProperty, (0, c._)`undefined`), N.var(m.default.rootData, m.default.data), k.dynamicRef && N.var(m.default.dynamicAnchors, (0, c._)`{}`);
+    });
+  }
+  function a(N) {
+    const { schema: k, opts: q, gen: M } = N;
+    y(N, () => {
+      q.$comment && k.$comment && K(N), D(N), M.let(m.default.vErrors, null), M.let(m.default.errors, 0), q.unevaluated && i(N), j(N), B(N);
+    });
+  }
+  function i(N) {
+    const { gen: k, validateName: q } = N;
+    N.evaluated = k.const("evaluated", (0, c._)`${q}.evaluated`), k.if((0, c._)`${N.evaluated}.dynamicProps`, () => k.assign((0, c._)`${N.evaluated}.props`, (0, c._)`undefined`)), k.if((0, c._)`${N.evaluated}.dynamicItems`, () => k.assign((0, c._)`${N.evaluated}.items`, (0, c._)`undefined`));
+  }
+  function t(N, k) {
+    const q = typeof N == "object" && N[k.schemaId];
+    return q && (k.code.source || k.code.process) ? (0, c._)`/*# sourceURL=${q} */` : c.nil;
+  }
+  function o(N, k) {
+    if (n(N) && ($(N), h(N))) {
+      l(N, k);
+      return;
+    }
+    (0, e.boolOrEmptySchema)(N, k);
+  }
+  function h({ schema: N, self: k }) {
+    if (typeof N == "boolean")
+      return !N;
+    for (const q in N)
+      if (k.RULES.all[q])
+        return !0;
+    return !1;
+  }
+  function n(N) {
+    return typeof N.schema != "boolean";
+  }
+  function l(N, k) {
+    const { schema: q, gen: M, opts: z } = N;
+    z.$comment && q.$comment && K(N), V(N), L(N);
+    const G = M.const("_errs", m.default.errors);
+    j(N, G), M.var(k, (0, c._)`${G} === ${m.default.errors}`);
+  }
+  function $(N) {
+    (0, v.checkUnknownRules)(N), C(N);
+  }
+  function j(N, k) {
+    if (N.opts.jtd)
+      return de(N, [], !1, k);
+    const q = (0, r.getSchemaTypes)(N.schema), M = (0, r.coerceAndCheckDataType)(N, q);
+    de(N, q, !M, k);
+  }
+  function C(N) {
+    const { schema: k, errSchemaPath: q, opts: M, self: z } = N;
+    k.$ref && M.ignoreKeywordsWithRef && (0, v.schemaHasRulesButRef)(k, z.RULES) && z.logger.warn(`$ref: keywords ignored in schema at path "${q}"`);
+  }
+  function D(N) {
+    const { schema: k, opts: q } = N;
+    k.default !== void 0 && q.useDefaults && q.strictSchema && (0, v.checkStrictMode)(N, "default is ignored in the schema root");
+  }
+  function V(N) {
+    const k = N.schema[N.opts.schemaId];
+    k && (N.baseId = (0, w.resolveUrl)(N.opts.uriResolver, N.baseId, k));
+  }
+  function L(N) {
+    if (N.schema.$async && !N.schemaEnv.$async)
+      throw new Error("async schema in sync schema");
+  }
+  function K({ gen: N, schemaEnv: k, schema: q, errSchemaPath: M, opts: z }) {
+    const G = q.$comment;
+    if (z.$comment === !0)
+      N.code((0, c._)`${m.default.self}.logger.log(${G})`);
+    else if (typeof z.$comment == "function") {
+      const ee = (0, c.str)`${M}/$comment`, ue = N.scopeValue("root", { ref: k.root });
+      N.code((0, c._)`${m.default.self}.opts.$comment(${G}, ${ee}, ${ue}.schema)`);
+    }
+  }
+  function B(N) {
+    const { gen: k, schemaEnv: q, validateName: M, ValidationError: z, opts: G } = N;
+    q.$async ? k.if((0, c._)`${m.default.errors} === 0`, () => k.return(m.default.data), () => k.throw((0, c._)`new ${z}(${m.default.vErrors})`)) : (k.assign((0, c._)`${M}.errors`, m.default.vErrors), G.unevaluated && x(N), k.return((0, c._)`${m.default.errors} === 0`));
+  }
+  function x({ gen: N, evaluated: k, props: q, items: M }) {
+    q instanceof c.Name && N.assign((0, c._)`${k}.props`, q), M instanceof c.Name && N.assign((0, c._)`${k}.items`, M);
+  }
+  function de(N, k, q, M) {
+    const { gen: z, schema: G, data: ee, allErrors: ue, opts: se, self: ae } = N, { RULES: te } = ae;
+    if (G.$ref && (se.ignoreKeywordsWithRef || !(0, v.schemaHasRulesButRef)(G, te))) {
+      z.block(() => U(N, "$ref", te.all.$ref.definition));
+      return;
+    }
+    se.jtd || Z(N, k), z.block(() => {
+      for (const ie of te.rules)
+        be(ie);
+      be(te.post);
+    });
+    function be(ie) {
+      (0, S.shouldUseGroup)(G, ie) && (ie.type ? (z.if((0, d.checkDataType)(ie.type, ee, se.strictNumbers)), fe(N, ie), k.length === 1 && k[0] === ie.type && q && (z.else(), (0, d.reportTypeError)(N)), z.endIf()) : fe(N, ie), ue || z.if((0, c._)`${m.default.errors} === ${M || 0}`));
+    }
+  }
+  function fe(N, k) {
+    const { gen: q, schema: M, opts: { useDefaults: z } } = N;
+    z && (0, g.assignDefaults)(N, k.type), q.block(() => {
+      for (const G of k.rules)
+        (0, S.shouldUseRule)(M, G) && U(N, G.keyword, G.definition, k.type);
+    });
+  }
+  function Z(N, k) {
+    N.schemaEnv.meta || !N.opts.strictTypes || (ye(N, k), N.opts.allowUnionTypes || A(N, k), R(N, N.dataTypes));
+  }
+  function ye(N, k) {
+    if (k.length) {
+      if (!N.dataTypes.length) {
+        N.dataTypes = k;
+        return;
+      }
+      k.forEach((q) => {
+        O(N.dataTypes, q) || E(N, `type "${q}" not allowed by context "${N.dataTypes.join(",")}"`);
+      }), u(N, k);
+    }
+  }
+  function A(N, k) {
+    k.length > 1 && !(k.length === 2 && k.includes("null")) && E(N, "use allowUnionTypes to allow union type keyword");
+  }
+  function R(N, k) {
+    const q = N.self.RULES.all;
+    for (const M in q) {
+      const z = q[M];
+      if (typeof z == "object" && (0, S.shouldUseRule)(N.schema, z)) {
+        const { type: G } = z.definition;
+        G.length && !G.some((ee) => T(k, ee)) && E(N, `missing type "${G.join(",")}" for keyword "${M}"`);
+      }
+    }
+  }
+  function T(N, k) {
+    return N.includes(k) || k === "number" && N.includes("integer");
+  }
+  function O(N, k) {
+    return N.includes(k) || k === "integer" && N.includes("number");
+  }
+  function u(N, k) {
+    const q = [];
+    for (const M of N.dataTypes)
+      O(k, M) ? q.push(M) : k.includes("integer") && M === "number" && q.push("integer");
+    N.dataTypes = q;
+  }
+  function E(N, k) {
+    const q = N.schemaEnv.baseId + N.errSchemaPath;
+    k += ` at "${q}" (strictTypes)`, (0, v.checkStrictMode)(N, k, N.opts.strictTypes);
+  }
+  class I {
+    constructor(k, q, M) {
+      if ((0, s.validateKeywordUsage)(k, q, M), this.gen = k.gen, this.allErrors = k.allErrors, this.keyword = M, this.data = k.data, this.schema = k.schema[M], this.$data = q.$data && k.opts.$data && this.schema && this.schema.$data, this.schemaValue = (0, v.schemaRefOrVal)(k, this.schema, M, this.$data), this.schemaType = q.schemaType, this.parentSchema = k.schema, this.params = {}, this.it = k, this.def = q, this.$data)
+        this.schemaCode = k.gen.const("vSchema", W(this.$data, k));
+      else if (this.schemaCode = this.schemaValue, !(0, s.validSchemaType)(this.schema, q.schemaType, q.allowUndefined))
+        throw new Error(`${M} value must be ${JSON.stringify(q.schemaType)}`);
+      ("code" in q ? q.trackErrors : q.errors !== !1) && (this.errsCount = k.gen.const("_errs", m.default.errors));
+    }
+    result(k, q, M) {
+      this.failResult((0, c.not)(k), q, M);
+    }
+    failResult(k, q, M) {
+      this.gen.if(k), M ? M() : this.error(), q ? (this.gen.else(), q(), this.allErrors && this.gen.endIf()) : this.allErrors ? this.gen.endIf() : this.gen.else();
+    }
+    pass(k, q) {
+      this.failResult((0, c.not)(k), void 0, q);
+    }
+    fail(k) {
+      if (k === void 0) {
+        this.error(), this.allErrors || this.gen.if(!1);
+        return;
+      }
+      this.gen.if(k), this.error(), this.allErrors ? this.gen.endIf() : this.gen.else();
+    }
+    fail$data(k) {
+      if (!this.$data)
+        return this.fail(k);
+      const { schemaCode: q } = this;
+      this.fail((0, c._)`${q} !== undefined && (${(0, c.or)(this.invalid$data(), k)})`);
+    }
+    error(k, q, M) {
+      if (q) {
+        this.setParams(q), this._error(k, M), this.setParams({});
+        return;
+      }
+      this._error(k, M);
+    }
+    _error(k, q) {
+      (k ? P.reportExtraError : P.reportError)(this, this.def.error, q);
+    }
+    $dataError() {
+      (0, P.reportError)(this, this.def.$dataError || P.keyword$DataError);
+    }
+    reset() {
+      if (this.errsCount === void 0)
+        throw new Error('add "trackErrors" to keyword definition');
+      (0, P.resetErrorsCount)(this.gen, this.errsCount);
+    }
+    ok(k) {
+      this.allErrors || this.gen.if(k);
+    }
+    setParams(k, q) {
+      q ? Object.assign(this.params, k) : this.params = k;
+    }
+    block$data(k, q, M = c.nil) {
+      this.gen.block(() => {
+        this.check$data(k, M), q();
+      });
+    }
+    check$data(k = c.nil, q = c.nil) {
+      if (!this.$data)
+        return;
+      const { gen: M, schemaCode: z, schemaType: G, def: ee } = this;
+      M.if((0, c.or)((0, c._)`${z} === undefined`, q)), k !== c.nil && M.assign(k, !0), (G.length || ee.validateSchema) && (M.elseIf(this.invalid$data()), this.$dataError(), k !== c.nil && M.assign(k, !1)), M.else();
+    }
+    invalid$data() {
+      const { gen: k, schemaCode: q, schemaType: M, def: z, it: G } = this;
+      return (0, c.or)(ee(), ue());
+      function ee() {
+        if (M.length) {
+          if (!(q instanceof c.Name))
+            throw new Error("ajv implementation error");
+          const se = Array.isArray(M) ? M : [M];
+          return (0, c._)`${(0, d.checkDataTypes)(se, q, G.opts.strictNumbers, d.DataType.Wrong)}`;
+        }
+        return c.nil;
+      }
+      function ue() {
+        if (z.validateSchema) {
+          const se = k.scopeValue("validate$data", { ref: z.validateSchema });
+          return (0, c._)`!${se}(${q})`;
+        }
+        return c.nil;
+      }
+    }
+    subschema(k, q) {
+      const M = (0, f.getSubschema)(this.it, k);
+      (0, f.extendSubschemaData)(M, this.it, k), (0, f.extendSubschemaMode)(M, k);
+      const z = { ...this.it, ...M, items: void 0, props: void 0 };
+      return o(z, q), z;
+    }
+    mergeEvaluated(k, q) {
+      const { it: M, gen: z } = this;
+      M.opts.unevaluated && (M.props !== !0 && k.props !== void 0 && (M.props = v.mergeEvaluated.props(z, k.props, M.props, q)), M.items !== !0 && k.items !== void 0 && (M.items = v.mergeEvaluated.items(z, k.items, M.items, q)));
+    }
+    mergeValidEvaluated(k, q) {
+      const { it: M, gen: z } = this;
+      if (M.opts.unevaluated && (M.props !== !0 || M.items !== !0))
+        return z.if(q, () => this.mergeEvaluated(k, c.Name)), !0;
+    }
+  }
+  he.KeywordCxt = I;
+  function U(N, k, q, M) {
+    const z = new I(N, q, k);
+    "code" in q ? q.code(z, M) : z.$data && q.validate ? (0, s.funcKeywordCode)(z, q) : "macro" in q ? (0, s.macroKeywordCode)(z, q) : (q.compile || q.validate) && (0, s.funcKeywordCode)(z, q);
+  }
+  const F = /^\/(?:[^~]|~0|~1)*$/, X = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
+  function W(N, { dataLevel: k, dataNames: q, dataPathArr: M }) {
+    let z, G;
+    if (N === "")
+      return m.default.rootData;
+    if (N[0] === "/") {
+      if (!F.test(N))
+        throw new Error(`Invalid JSON-pointer: ${N}`);
+      z = N, G = m.default.rootData;
+    } else {
+      const ae = X.exec(N);
+      if (!ae)
+        throw new Error(`Invalid JSON-pointer: ${N}`);
+      const te = +ae[1];
+      if (z = ae[2], z === "#") {
+        if (te >= k)
+          throw new Error(se("property/index", te));
+        return M[k - te];
+      }
+      if (te > k)
+        throw new Error(se("data", te));
+      if (G = q[k - te], !z)
+        return G;
+    }
+    let ee = G;
+    const ue = z.split("/");
+    for (const ae of ue)
+      ae && (G = (0, c._)`${G}${(0, c.getProperty)((0, v.unescapeJsonPointer)(ae))}`, ee = (0, c._)`${ee} && ${G}`);
+    return ee;
+    function se(ae, te) {
+      return `Cannot access ${ae} ${te} levels up, current level is ${k}`;
+    }
+  }
+  return he.getData = W, he;
+}
+var Ie = {}, nr;
+function Tt() {
+  if (nr) return Ie;
+  nr = 1, Object.defineProperty(Ie, "__esModule", { value: !0 });
+  class e extends Error {
+    constructor(S) {
+      super("validation failed"), this.errors = S, this.ajv = this.validation = !0;
+    }
+  }
+  return Ie.default = e, Ie;
+}
+var qe = {}, sr;
+function _t() {
+  if (sr) return qe;
+  sr = 1, Object.defineProperty(qe, "__esModule", { value: !0 });
+  const e = yt();
+  class r extends Error {
+    constructor(d, g, s, f) {
+      super(f || `can't resolve reference ${s} from id ${g}`), this.missingRef = (0, e.resolveUrl)(d, g, s), this.missingSchema = (0, e.normalizeId)((0, e.getFullPath)(d, this.missingRef));
+    }
+  }
+  return qe.default = r, qe;
+}
+var oe = {}, ar;
+function Ct() {
+  if (ar) return oe;
+  ar = 1, Object.defineProperty(oe, "__esModule", { value: !0 }), oe.resolveSchema = oe.getCompilingSchema = oe.resolveRef = oe.compileSchema = oe.SchemaEnv = void 0;
+  const e = J(), r = Tt(), S = _e(), d = yt(), g = Q(), s = vt();
+  class f {
+    constructor(i) {
+      var t;
+      this.refs = {}, this.dynamicAnchors = {};
+      let o;
+      typeof i.schema == "object" && (o = i.schema), this.schema = i.schema, this.schemaId = i.schemaId, this.root = i.root || this, this.baseId = (t = i.baseId) !== null && t !== void 0 ? t : (0, d.normalizeId)(o?.[i.schemaId || "$id"]), this.schemaPath = i.schemaPath, this.localRefs = i.localRefs, this.meta = i.meta, this.$async = o?.$async, this.refs = {};
+    }
+  }
+  oe.SchemaEnv = f;
+  function c(a) {
+    const i = v.call(this, a);
+    if (i)
+      return i;
+    const t = (0, d.getFullPath)(this.opts.uriResolver, a.root.baseId), { es5: o, lines: h } = this.opts.code, { ownProperties: n } = this.opts, l = new e.CodeGen(this.scope, { es5: o, lines: h, ownProperties: n });
+    let $;
+    a.$async && ($ = l.scopeValue("Error", {
+      ref: r.default,
+      code: (0, e._)`require("ajv/dist/runtime/validation_error").default`
+    }));
+    const j = l.scopeName("validate");
+    a.validateName = j;
+    const C = {
+      gen: l,
+      allErrors: this.opts.allErrors,
+      data: S.default.data,
+      parentData: S.default.parentData,
+      parentDataProperty: S.default.parentDataProperty,
+      dataNames: [S.default.data],
+      dataPathArr: [e.nil],
+      // TODO can its length be used as dataLevel if nil is removed?
+      dataLevel: 0,
+      dataTypes: [],
+      definedProperties: /* @__PURE__ */ new Set(),
+      topSchemaRef: l.scopeValue("schema", this.opts.code.source === !0 ? { ref: a.schema, code: (0, e.stringify)(a.schema) } : { ref: a.schema }),
+      validateName: j,
+      ValidationError: $,
+      schema: a.schema,
+      schemaEnv: a,
+      rootId: t,
+      baseId: a.baseId || t,
+      schemaPath: e.nil,
+      errSchemaPath: a.schemaPath || (this.opts.jtd ? "" : "#"),
+      errorPath: (0, e._)`""`,
+      opts: this.opts,
+      self: this
+    };
+    let D;
+    try {
+      this._compilations.add(a), (0, s.validateFunctionCode)(C), l.optimize(this.opts.code.optimize);
+      const V = l.toString();
+      D = `${l.scopeRefs(S.default.scope)}return ${V}`, this.opts.code.process && (D = this.opts.code.process(D, a));
+      const K = new Function(`${S.default.self}`, `${S.default.scope}`, D)(this, this.scope.get());
+      if (this.scope.value(j, { ref: K }), K.errors = null, K.schema = a.schema, K.schemaEnv = a, a.$async && (K.$async = !0), this.opts.code.source === !0 && (K.source = { validateName: j, validateCode: V, scopeValues: l._values }), this.opts.unevaluated) {
+        const { props: B, items: x } = C;
+        K.evaluated = {
+          props: B instanceof e.Name ? void 0 : B,
+          items: x instanceof e.Name ? void 0 : x,
+          dynamicProps: B instanceof e.Name,
+          dynamicItems: x instanceof e.Name
+        }, K.source && (K.source.evaluated = (0, e.stringify)(K.evaluated));
+      }
+      return a.validate = K, a;
+    } catch (V) {
+      throw delete a.validate, delete a.validateName, D && this.logger.error("Error compiling schema, function code:", D), V;
+    } finally {
+      this._compilations.delete(a);
+    }
+  }
+  oe.compileSchema = c;
+  function m(a, i, t) {
+    var o;
+    t = (0, d.resolveUrl)(this.opts.uriResolver, i, t);
+    const h = a.refs[t];
+    if (h)
+      return h;
+    let n = _.call(this, a, t);
+    if (n === void 0) {
+      const l = (o = a.localRefs) === null || o === void 0 ? void 0 : o[t], { schemaId: $ } = this.opts;
+      l && (n = new f({ schema: l, schemaId: $, root: a, baseId: i }));
+    }
+    if (n !== void 0)
+      return a.refs[t] = w.call(this, n);
+  }
+  oe.resolveRef = m;
+  function w(a) {
+    return (0, d.inlineRef)(a.schema, this.opts.inlineRefs) ? a.schema : a.validate ? a : c.call(this, a);
+  }
+  function v(a) {
+    for (const i of this._compilations)
+      if (P(i, a))
+        return i;
+  }
+  oe.getCompilingSchema = v;
+  function P(a, i) {
+    return a.schema === i.schema && a.root === i.root && a.baseId === i.baseId;
+  }
+  function _(a, i) {
+    let t;
+    for (; typeof (t = this.refs[i]) == "string"; )
+      i = t;
+    return t || this.schemas[i] || y.call(this, a, i);
+  }
+  function y(a, i) {
+    const t = this.opts.uriResolver.parse(i), o = (0, d._getFullPath)(this.opts.uriResolver, t);
+    let h = (0, d.getFullPath)(this.opts.uriResolver, a.baseId, void 0);
+    if (Object.keys(a.schema).length > 0 && o === h)
+      return b.call(this, t, a);
+    const n = (0, d.normalizeId)(o), l = this.refs[n] || this.schemas[n];
+    if (typeof l == "string") {
+      const $ = y.call(this, a, l);
+      return typeof $?.schema != "object" ? void 0 : b.call(this, t, $);
+    }
+    if (typeof l?.schema == "object") {
+      if (l.validate || c.call(this, l), n === (0, d.normalizeId)(i)) {
+        const { schema: $ } = l, { schemaId: j } = this.opts, C = $[j];
+        return C && (h = (0, d.resolveUrl)(this.opts.uriResolver, h, C)), new f({ schema: $, schemaId: j, root: a, baseId: h });
+      }
+      return b.call(this, t, l);
+    }
+  }
+  oe.resolveSchema = y;
+  const p = /* @__PURE__ */ new Set([
+    "properties",
+    "patternProperties",
+    "enum",
+    "dependencies",
+    "definitions"
+  ]);
+  function b(a, { baseId: i, schema: t, root: o }) {
+    var h;
+    if (((h = a.fragment) === null || h === void 0 ? void 0 : h[0]) !== "/")
+      return;
+    for (const $ of a.fragment.slice(1).split("/")) {
+      if (typeof t == "boolean")
+        return;
+      const j = t[(0, g.unescapeFragment)($)];
+      if (j === void 0)
+        return;
+      t = j;
+      const C = typeof t == "object" && t[this.opts.schemaId];
+      !p.has($) && C && (i = (0, d.resolveUrl)(this.opts.uriResolver, i, C));
+    }
+    let n;
+    if (typeof t != "boolean" && t.$ref && !(0, g.schemaHasRulesButRef)(t, this.RULES)) {
+      const $ = (0, d.resolveUrl)(this.opts.uriResolver, i, t.$ref);
+      n = y.call(this, o, $);
+    }
+    const { schemaId: l } = this.opts;
+    if (n = n || new f({ schema: t, schemaId: l, root: o, baseId: i }), n.schema !== n.root.schema)
+      return n;
+  }
+  return oe;
+}
+const yn = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", vn = "Meta-schema for $data reference (JSON AnySchema extension proposal)", _n = "object", gn = ["$data"], $n = { $data: { type: "string", anyOf: [{ format: "relative-json-pointer" }, { format: "json-pointer" }] } }, wn = !1, bn = {
+  $id: yn,
+  description: vn,
+  type: _n,
+  required: gn,
+  properties: $n,
+  additionalProperties: wn
+};
+var Te = {}, Re = { exports: {} }, Ot, or;
+function en() {
+  if (or) return Ot;
+  or = 1;
+  const e = 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);
+  function S(_) {
+    let y = "", p = 0, b = 0;
+    for (b = 0; b < _.length; b++)
+      if (p = _[b].charCodeAt(0), p !== 48) {
+        if (!(p >= 48 && p <= 57 || p >= 65 && p <= 70 || p >= 97 && p <= 102))
+          return "";
+        y += _[b];
+        break;
+      }
+    for (b += 1; b < _.length; b++) {
+      if (p = _[b].charCodeAt(0), !(p >= 48 && p <= 57 || p >= 65 && p <= 70 || p >= 97 && p <= 102))
+        return "";
+      y += _[b];
+    }
+    return y;
+  }
+  const d = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+  function g(_) {
+    return _.length = 0, !0;
+  }
+  function s(_, y, p) {
+    if (_.length) {
+      const b = S(_);
+      if (b !== "")
+        y.push(b);
+      else
+        return p.error = !0, !1;
+      _.length = 0;
+    }
+    return !0;
+  }
+  function f(_) {
+    let y = 0;
+    const p = { error: !1, address: "", zone: "" }, b = [], a = [];
+    let i = !1, t = !1, o = s;
+    for (let h = 0; h < _.length; h++) {
+      const n = _[h];
+      if (!(n === "[" || n === "]"))
+        if (n === ":") {
+          if (i === !0 && (t = !0), !o(a, b, p))
+            break;
+          if (++y > 7) {
+            p.error = !0;
+            break;
+          }
+          h > 0 && _[h - 1] === ":" && (i = !0), b.push(":");
+          continue;
+        } else if (n === "%") {
+          if (!o(a, b, p))
+            break;
+          o = g;
+        } else {
+          a.push(n);
+          continue;
+        }
+    }
+    return a.length && (o === g ? p.zone = a.join("") : t ? b.push(a.join("")) : b.push(S(a))), p.address = b.join(""), p;
+  }
+  function c(_) {
+    if (m(_, ":") < 2)
+      return { host: _, isIPV6: !1 };
+    const y = f(_);
+    if (y.error)
+      return { host: _, isIPV6: !1 };
+    {
+      let p = y.address, b = y.address;
+      return y.zone && (p += "%" + y.zone, b += "%25" + y.zone), { host: p, isIPV6: !0, escapedHost: b };
+    }
+  }
+  function m(_, y) {
+    let p = 0;
+    for (let b = 0; b < _.length; b++)
+      _[b] === y && p++;
+    return p;
+  }
+  function w(_) {
+    let y = _;
+    const p = [];
+    let b = -1, a = 0;
+    for (; a = y.length; ) {
+      if (a === 1) {
+        if (y === ".")
+          break;
+        if (y === "/") {
+          p.push("/");
+          break;
+        } else {
+          p.push(y);
+          break;
+        }
+      } else if (a === 2) {
+        if (y[0] === ".") {
+          if (y[1] === ".")
+            break;
+          if (y[1] === "/") {
+            y = y.slice(2);
+            continue;
+          }
+        } else if (y[0] === "/" && (y[1] === "." || y[1] === "/")) {
+          p.push("/");
+          break;
+        }
+      } else if (a === 3 && y === "/..") {
+        p.length !== 0 && p.pop(), p.push("/");
+        break;
+      }
+      if (y[0] === ".") {
+        if (y[1] === ".") {
+          if (y[2] === "/") {
+            y = y.slice(3);
+            continue;
+          }
+        } else if (y[1] === "/") {
+          y = y.slice(2);
+          continue;
+        }
+      } else if (y[0] === "/" && y[1] === ".") {
+        if (y[2] === "/") {
+          y = y.slice(2);
+          continue;
+        } else if (y[2] === "." && y[3] === "/") {
+          y = y.slice(3), p.length !== 0 && p.pop();
+          continue;
+        }
+      }
+      if ((b = y.indexOf("/", 1)) === -1) {
+        p.push(y);
+        break;
+      } else
+        p.push(y.slice(0, b)), y = y.slice(b);
+    }
+    return p.join("");
+  }
+  function v(_, y) {
+    const p = y !== !0 ? escape : unescape;
+    return _.scheme !== void 0 && (_.scheme = p(_.scheme)), _.userinfo !== void 0 && (_.userinfo = p(_.userinfo)), _.host !== void 0 && (_.host = p(_.host)), _.path !== void 0 && (_.path = p(_.path)), _.query !== void 0 && (_.query = p(_.query)), _.fragment !== void 0 && (_.fragment = p(_.fragment)), _;
+  }
+  function P(_) {
+    const y = [];
+    if (_.userinfo !== void 0 && (y.push(_.userinfo), y.push("@")), _.host !== void 0) {
+      let p = unescape(_.host);
+      if (!r(p)) {
+        const b = c(p);
+        b.isIPV6 === !0 ? p = `[${b.escapedHost}]` : p = _.host;
+      }
+      y.push(p);
+    }
+    return (typeof _.port == "number" || typeof _.port == "string") && (y.push(":"), y.push(String(_.port))), y.length ? y.join("") : void 0;
+  }
+  return Ot = {
+    nonSimpleDomain: d,
+    recomposeAuthority: P,
+    normalizeComponentEncoding: v,
+    removeDotSegments: w,
+    isIPv4: r,
+    isUUID: e,
+    normalizeIPv6: c,
+    stringArrayToHexStripped: S
+  }, Ot;
+}
+var jt, ir;
+function En() {
+  if (ir) return jt;
+  ir = 1;
+  const { isUUID: e } = en(), r = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu, S = (
+    /** @type {const} */
+    [
+      "http",
+      "https",
+      "ws",
+      "wss",
+      "urn",
+      "urn:uuid"
+    ]
+  );
+  function d(n) {
+    return S.indexOf(
+      /** @type {*} */
+      n
+    ) !== -1;
+  }
+  function g(n) {
+    return n.secure === !0 ? !0 : n.secure === !1 ? !1 : n.scheme ? n.scheme.length === 3 && (n.scheme[0] === "w" || n.scheme[0] === "W") && (n.scheme[1] === "s" || n.scheme[1] === "S") && (n.scheme[2] === "s" || n.scheme[2] === "S") : !1;
+  }
+  function s(n) {
+    return n.host || (n.error = n.error || "HTTP URIs must have a host."), n;
+  }
+  function f(n) {
+    const l = String(n.scheme).toLowerCase() === "https";
+    return (n.port === (l ? 443 : 80) || n.port === "") && (n.port = void 0), n.path || (n.path = "/"), n;
+  }
+  function c(n) {
+    return n.secure = g(n), n.resourceName = (n.path || "/") + (n.query ? "?" + n.query : ""), n.path = void 0, n.query = void 0, n;
+  }
+  function m(n) {
+    if ((n.port === (g(n) ? 443 : 80) || n.port === "") && (n.port = void 0), typeof n.secure == "boolean" && (n.scheme = n.secure ? "wss" : "ws", n.secure = void 0), n.resourceName) {
+      const [l, $] = n.resourceName.split("?");
+      n.path = l && l !== "/" ? l : void 0, n.query = $, n.resourceName = void 0;
+    }
+    return n.fragment = void 0, n;
+  }
+  function w(n, l) {
+    if (!n.path)
+      return n.error = "URN can not be parsed", n;
+    const $ = n.path.match(r);
+    if ($) {
+      const j = l.scheme || n.scheme || "urn";
+      n.nid = $[1].toLowerCase(), n.nss = $[2];
+      const C = `${j}:${l.nid || n.nid}`, D = h(C);
+      n.path = void 0, D && (n = D.parse(n, l));
+    } else
+      n.error = n.error || "URN can not be parsed.";
+    return n;
+  }
+  function v(n, l) {
+    if (n.nid === void 0)
+      throw new Error("URN without nid cannot be serialized");
+    const $ = l.scheme || n.scheme || "urn", j = n.nid.toLowerCase(), C = `${$}:${l.nid || j}`, D = h(C);
+    D && (n = D.serialize(n, l));
+    const V = n, L = n.nss;
+    return V.path = `${j || l.nid}:${L}`, l.skipEscape = !0, V;
+  }
+  function P(n, l) {
+    const $ = n;
+    return $.uuid = $.nss, $.nss = void 0, !l.tolerant && (!$.uuid || !e($.uuid)) && ($.error = $.error || "UUID is not valid."), $;
+  }
+  function _(n) {
+    const l = n;
+    return l.nss = (n.uuid || "").toLowerCase(), l;
+  }
+  const y = (
+    /** @type {SchemeHandler} */
+    {
+      scheme: "http",
+      domainHost: !0,
+      parse: s,
+      serialize: f
+    }
+  ), p = (
+    /** @type {SchemeHandler} */
+    {
+      scheme: "https",
+      domainHost: y.domainHost,
+      parse: s,
+      serialize: f
+    }
+  ), b = (
+    /** @type {SchemeHandler} */
+    {
+      scheme: "ws",
+      domainHost: !0,
+      parse: c,
+      serialize: m
+    }
+  ), a = (
+    /** @type {SchemeHandler} */
+    {
+      scheme: "wss",
+      domainHost: b.domainHost,
+      parse: b.parse,
+      serialize: b.serialize
+    }
+  ), o = (
+    /** @type {Record<SchemeName, SchemeHandler>} */
+    {
+      http: y,
+      https: p,
+      ws: b,
+      wss: a,
+      urn: (
+        /** @type {SchemeHandler} */
+        {
+          scheme: "urn",
+          parse: w,
+          serialize: v,
+          skipNormalize: !0
+        }
+      ),
+      "urn:uuid": (
+        /** @type {SchemeHandler} */
+        {
+          scheme: "urn:uuid",
+          parse: P,
+          serialize: _,
+          skipNormalize: !0
+        }
+      )
+    }
+  );
+  Object.setPrototypeOf(o, null);
+  function h(n) {
+    return n && (o[
+      /** @type {SchemeName} */
+      n
+    ] || o[
+      /** @type {SchemeName} */
+      n.toLowerCase()
+    ]) || void 0;
+  }
+  return jt = {
+    wsIsSecure: g,
+    SCHEMES: o,
+    isValidSchemeName: d,
+    getSchemeHandler: h
+  }, jt;
+}
+var ur;
+function Sn() {
+  if (ur) return Re.exports;
+  ur = 1;
+  const { normalizeIPv6: e, removeDotSegments: r, recomposeAuthority: S, normalizeComponentEncoding: d, isIPv4: g, nonSimpleDomain: s } = en(), { SCHEMES: f, getSchemeHandler: c } = En();
+  function m(a, i) {
+    return typeof a == "string" ? a = /** @type {T} */
+    _(p(a, i), i) : typeof a == "object" && (a = /** @type {T} */
+    p(_(a, i), i)), a;
+  }
+  function w(a, i, t) {
+    const o = t ? Object.assign({ scheme: "null" }, t) : { scheme: "null" }, h = v(p(a, o), p(i, o), o, !0);
+    return o.skipEscape = !0, _(h, o);
+  }
+  function v(a, i, t, o) {
+    const h = {};
+    return o || (a = p(_(a, t), t), i = p(_(i, t), t)), t = t || {}, !t.tolerant && i.scheme ? (h.scheme = i.scheme, h.userinfo = i.userinfo, h.host = i.host, h.port = i.port, h.path = r(i.path || ""), h.query = i.query) : (i.userinfo !== void 0 || i.host !== void 0 || i.port !== void 0 ? (h.userinfo = i.userinfo, h.host = i.host, h.port = i.port, h.path = r(i.path || ""), h.query = i.query) : (i.path ? (i.path[0] === "/" ? h.path = r(i.path) : ((a.userinfo !== void 0 || a.host !== void 0 || a.port !== void 0) && !a.path ? h.path = "/" + i.path : a.path ? h.path = a.path.slice(0, a.path.lastIndexOf("/") + 1) + i.path : h.path = i.path, h.path = r(h.path)), h.query = i.query) : (h.path = a.path, i.query !== void 0 ? h.query = i.query : h.query = a.query), h.userinfo = a.userinfo, h.host = a.host, h.port = a.port), h.scheme = a.scheme), h.fragment = i.fragment, h;
+  }
+  function P(a, i, t) {
+    return typeof a == "string" ? (a = unescape(a), a = _(d(p(a, t), !0), { ...t, skipEscape: !0 })) : typeof a == "object" && (a = _(d(a, !0), { ...t, skipEscape: !0 })), typeof i == "string" ? (i = unescape(i), i = _(d(p(i, t), !0), { ...t, skipEscape: !0 })) : typeof i == "object" && (i = _(d(i, !0), { ...t, skipEscape: !0 })), a.toLowerCase() === i.toLowerCase();
+  }
+  function _(a, i) {
+    const t = {
+      host: a.host,
+      scheme: a.scheme,
+      userinfo: a.userinfo,
+      port: a.port,
+      path: a.path,
+      query: a.query,
+      nid: a.nid,
+      nss: a.nss,
+      uuid: a.uuid,
+      fragment: a.fragment,
+      reference: a.reference,
+      resourceName: a.resourceName,
+      secure: a.secure,
+      error: ""
+    }, o = Object.assign({}, i), h = [], n = c(o.scheme || t.scheme);
+    n && n.serialize && n.serialize(t, o), t.path !== void 0 && (o.skipEscape ? t.path = unescape(t.path) : (t.path = escape(t.path), t.scheme !== void 0 && (t.path = t.path.split("%3A").join(":")))), o.reference !== "suffix" && t.scheme && h.push(t.scheme, ":");
+    const l = S(t);
+    if (l !== void 0 && (o.reference !== "suffix" && h.push("//"), h.push(l), t.path && t.path[0] !== "/" && h.push("/")), t.path !== void 0) {
+      let $ = t.path;
+      !o.absolutePath && (!n || !n.absolutePath) && ($ = r($)), l === void 0 && $[0] === "/" && $[1] === "/" && ($ = "/%2F" + $.slice(2)), h.push($);
+    }
+    return t.query !== void 0 && h.push("?", t.query), t.fragment !== void 0 && h.push("#", t.fragment), h.join("");
+  }
+  const y = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+  function p(a, i) {
+    const t = Object.assign({}, i), o = {
+      scheme: void 0,
+      userinfo: void 0,
+      host: "",
+      port: void 0,
+      path: "",
+      query: void 0,
+      fragment: void 0
+    };
+    let h = !1;
+    t.reference === "suffix" && (t.scheme ? a = t.scheme + ":" + a : a = "//" + a);
+    const n = a.match(y);
+    if (n) {
+      if (o.scheme = n[1], o.userinfo = n[3], o.host = n[4], o.port = parseInt(n[5], 10), o.path = n[6] || "", o.query = n[7], o.fragment = n[8], isNaN(o.port) && (o.port = n[5]), o.host)
+        if (g(o.host) === !1) {
+          const j = e(o.host);
+          o.host = j.host.toLowerCase(), h = j.isIPV6;
+        } else
+          h = !0;
+      o.scheme === void 0 && o.userinfo === void 0 && o.host === void 0 && o.port === void 0 && o.query === void 0 && !o.path ? o.reference = "same-document" : o.scheme === void 0 ? o.reference = "relative" : o.fragment === void 0 ? o.reference = "absolute" : o.reference = "uri", t.reference && t.reference !== "suffix" && t.reference !== o.reference && (o.error = o.error || "URI is not a " + t.reference + " reference.");
+      const l = c(t.scheme || o.scheme);
+      if (!t.unicodeSupport && (!l || !l.unicodeSupport) && o.host && (t.domainHost || l && l.domainHost) && h === !1 && s(o.host))
+        try {
+          o.host = URL.domainToASCII(o.host.toLowerCase());
+        } catch ($) {
+          o.error = o.error || "Host's domain name can not be converted to ASCII: " + $;
+        }
+      (!l || l && !l.skipNormalize) && (a.indexOf("%") !== -1 && (o.scheme !== void 0 && (o.scheme = unescape(o.scheme)), o.host !== void 0 && (o.host = unescape(o.host))), o.path && (o.path = escape(unescape(o.path))), o.fragment && (o.fragment = encodeURI(decodeURIComponent(o.fragment)))), l && l.parse && l.parse(o, t);
+    } else
+      o.error = o.error || "URI can not be parsed.";
+    return o;
+  }
+  const b = {
+    SCHEMES: f,
+    normalize: m,
+    resolve: w,
+    resolveComponent: v,
+    equal: P,
+    serialize: _,
+    parse: p
+  };
+  return Re.exports = b, Re.exports.default = b, Re.exports.fastUri = b, Re.exports;
+}
+var cr;
+function Pn() {
+  if (cr) return Te;
+  cr = 1, Object.defineProperty(Te, "__esModule", { value: !0 });
+  const e = Sn();
+  return e.code = 'require("ajv/dist/runtime/uri").default', Te.default = e, Te;
+}
+var lr;
+function Nn() {
+  return lr || (lr = 1, (function(e) {
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.CodeGen = e.Name = e.nil = e.stringify = e.str = e._ = e.KeywordCxt = void 0;
+    var r = vt();
+    Object.defineProperty(e, "KeywordCxt", { enumerable: !0, get: function() {
+      return r.KeywordCxt;
+    } });
+    var S = J();
+    Object.defineProperty(e, "_", { enumerable: !0, get: function() {
+      return S._;
+    } }), Object.defineProperty(e, "str", { enumerable: !0, get: function() {
+      return S.str;
+    } }), Object.defineProperty(e, "stringify", { enumerable: !0, get: function() {
+      return S.stringify;
+    } }), Object.defineProperty(e, "nil", { enumerable: !0, get: function() {
+      return S.nil;
+    } }), Object.defineProperty(e, "Name", { enumerable: !0, get: function() {
+      return S.Name;
+    } }), Object.defineProperty(e, "CodeGen", { enumerable: !0, get: function() {
+      return S.CodeGen;
+    } });
+    const d = Tt(), g = _t(), s = Yr(), f = Ct(), c = J(), m = yt(), w = mt(), v = Q(), P = bn, _ = Pn(), y = (A, R) => new RegExp(A, R);
+    y.code = "new RegExp";
+    const p = ["removeAdditional", "useDefaults", "coerceTypes"], b = /* @__PURE__ */ new Set([
+      "validate",
+      "serialize",
+      "parse",
+      "wrapper",
+      "root",
+      "schema",
+      "keyword",
+      "pattern",
+      "formats",
+      "validate$data",
+      "func",
+      "obj",
+      "Error"
+    ]), a = {
+      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."
+    }, i = {
+      ignoreKeywordsWithRef: "",
+      jsPropertySyntax: "",
+      unicode: '"minLength"/"maxLength" account for unicode characters by default.'
+    }, t = 200;
+    function o(A) {
+      var R, T, O, u, E, I, U, F, X, W, N, k, q, M, z, G, ee, ue, se, ae, te, be, ie, gt, $t;
+      const Pe = A.strict, wt = (R = A.code) === null || R === void 0 ? void 0 : R.optimize, Mt = wt === !0 || wt === void 0 ? 1 : wt || 0, Dt = (O = (T = A.code) === null || T === void 0 ? void 0 : T.regExp) !== null && O !== void 0 ? O : y, sn = (u = A.uriResolver) !== null && u !== void 0 ? u : _.default;
+      return {
+        strictSchema: (I = (E = A.strictSchema) !== null && E !== void 0 ? E : Pe) !== null && I !== void 0 ? I : !0,
+        strictNumbers: (F = (U = A.strictNumbers) !== null && U !== void 0 ? U : Pe) !== null && F !== void 0 ? F : !0,
+        strictTypes: (W = (X = A.strictTypes) !== null && X !== void 0 ? X : Pe) !== null && W !== void 0 ? W : "log",
+        strictTuples: (k = (N = A.strictTuples) !== null && N !== void 0 ? N : Pe) !== null && k !== void 0 ? k : "log",
+        strictRequired: (M = (q = A.strictRequired) !== null && q !== void 0 ? q : Pe) !== null && M !== void 0 ? M : !1,
+        code: A.code ? { ...A.code, optimize: Mt, regExp: Dt } : { optimize: Mt, regExp: Dt },
+        loopRequired: (z = A.loopRequired) !== null && z !== void 0 ? z : t,
+        loopEnum: (G = A.loopEnum) !== null && G !== void 0 ? G : t,
+        meta: (ee = A.meta) !== null && ee !== void 0 ? ee : !0,
+        messages: (ue = A.messages) !== null && ue !== void 0 ? ue : !0,
+        inlineRefs: (se = A.inlineRefs) !== null && se !== void 0 ? se : !0,
+        schemaId: (ae = A.schemaId) !== null && ae !== void 0 ? ae : "$id",
+        addUsedSchema: (te = A.addUsedSchema) !== null && te !== void 0 ? te : !0,
+        validateSchema: (be = A.validateSchema) !== null && be !== void 0 ? be : !0,
+        validateFormats: (ie = A.validateFormats) !== null && ie !== void 0 ? ie : !0,
+        unicodeRegExp: (gt = A.unicodeRegExp) !== null && gt !== void 0 ? gt : !0,
+        int32range: ($t = A.int32range) !== null && $t !== void 0 ? $t : !0,
+        uriResolver: sn
+      };
+    }
+    class h {
+      constructor(R = {}) {
+        this.schemas = {}, this.refs = {}, this.formats = {}, this._compilations = /* @__PURE__ */ new Set(), this._loading = {}, this._cache = /* @__PURE__ */ new Map(), R = this.opts = { ...R, ...o(R) };
+        const { es5: T, lines: O } = this.opts.code;
+        this.scope = new c.ValueScope({ scope: {}, prefixes: b, es5: T, lines: O }), this.logger = L(R.logger);
+        const u = R.validateFormats;
+        R.validateFormats = !1, this.RULES = (0, s.getRules)(), n.call(this, a, R, "NOT SUPPORTED"), n.call(this, i, R, "DEPRECATED", "warn"), this._metaOpts = D.call(this), R.formats && j.call(this), this._addVocabularies(), this._addDefaultMetaSchema(), R.keywords && C.call(this, R.keywords), typeof R.meta == "object" && this.addMetaSchema(R.meta), $.call(this), R.validateFormats = u;
+      }
+      _addVocabularies() {
+        this.addKeyword("$async");
+      }
+      _addDefaultMetaSchema() {
+        const { $data: R, meta: T, schemaId: O } = this.opts;
+        let u = P;
+        O === "id" && (u = { ...P }, u.id = u.$id, delete u.$id), T && R && this.addMetaSchema(u, u[O], !1);
+      }
+      defaultMeta() {
+        const { meta: R, schemaId: T } = this.opts;
+        return this.opts.defaultMeta = typeof R == "object" ? R[T] || R : void 0;
+      }
+      validate(R, T) {
+        let O;
+        if (typeof R == "string") {
+          if (O = this.getSchema(R), !O)
+            throw new Error(`no schema with key or ref "${R}"`);
+        } else
+          O = this.compile(R);
+        const u = O(T);
+        return "$async" in O || (this.errors = O.errors), u;
+      }
+      compile(R, T) {
+        const O = this._addSchema(R, T);
+        return O.validate || this._compileSchemaEnv(O);
+      }
+      compileAsync(R, T) {
+        if (typeof this.opts.loadSchema != "function")
+          throw new Error("options.loadSchema should be a function");
+        const { loadSchema: O } = this.opts;
+        return u.call(this, R, T);
+        async function u(W, N) {
+          await E.call(this, W.$schema);
+          const k = this._addSchema(W, N);
+          return k.validate || I.call(this, k);
+        }
+        async function E(W) {
+          W && !this.getSchema(W) && await u.call(this, { $ref: W }, !0);
+        }
+        async function I(W) {
+          try {
+            return this._compileSchemaEnv(W);
+          } catch (N) {
+            if (!(N instanceof g.default))
+              throw N;
+            return U.call(this, N), await F.call(this, N.missingSchema), I.call(this, W);
+          }
+        }
+        function U({ missingSchema: W, missingRef: N }) {
+          if (this.refs[W])
+            throw new Error(`AnySchema ${W} is loaded but ${N} cannot be resolved`);
+        }
+        async function F(W) {
+          const N = await X.call(this, W);
+          this.refs[W] || await E.call(this, N.$schema), this.refs[W] || this.addSchema(N, W, T);
+        }
+        async function X(W) {
+          const N = this._loading[W];
+          if (N)
+            return N;
+          try {
+            return await (this._loading[W] = O(W));
+          } finally {
+            delete this._loading[W];
+          }
+        }
+      }
+      // Adds schema to the instance
+      addSchema(R, T, O, u = this.opts.validateSchema) {
+        if (Array.isArray(R)) {
+          for (const I of R)
+            this.addSchema(I, void 0, O, u);
+          return this;
+        }
+        let E;
+        if (typeof R == "object") {
+          const { schemaId: I } = this.opts;
+          if (E = R[I], E !== void 0 && typeof E != "string")
+            throw new Error(`schema ${I} must be string`);
+        }
+        return T = (0, m.normalizeId)(T || E), this._checkUnique(T), this.schemas[T] = this._addSchema(R, O, T, u, !0), this;
+      }
+      // Add schema that will be used to validate other schemas
+      // options in META_IGNORE_OPTIONS are alway set to false
+      addMetaSchema(R, T, O = this.opts.validateSchema) {
+        return this.addSchema(R, T, !0, O), this;
+      }
+      //  Validate schema against its meta-schema
+      validateSchema(R, T) {
+        if (typeof R == "boolean")
+          return !0;
+        let O;
+        if (O = R.$schema, O !== void 0 && typeof O != "string")
+          throw new Error("$schema must be a string");
+        if (O = O || this.opts.defaultMeta || this.defaultMeta(), !O)
+          return this.logger.warn("meta-schema not available"), this.errors = null, !0;
+        const u = this.validate(O, R);
+        if (!u && T) {
+          const E = "schema is invalid: " + this.errorsText();
+          if (this.opts.validateSchema === "log")
+            this.logger.error(E);
+          else
+            throw new Error(E);
+        }
+        return u;
+      }
+      // Get compiled schema by `key` or `ref`.
+      // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)
+      getSchema(R) {
+        let T;
+        for (; typeof (T = l.call(this, R)) == "string"; )
+          R = T;
+        if (T === void 0) {
+          const { schemaId: O } = this.opts, u = new f.SchemaEnv({ schema: {}, schemaId: O });
+          if (T = f.resolveSchema.call(this, u, R), !T)
+            return;
+          this.refs[R] = T;
+        }
+        return T.validate || this._compileSchemaEnv(T);
+      }
+      // Remove cached schema(s).
+      // If no parameter is passed all schemas but meta-schemas are removed.
+      // If RegExp is passed all schemas with key/id matching pattern but meta-schemas are removed.
+      // Even if schema is referenced by other schemas it still can be removed as other schemas have local references.
+      removeSchema(R) {
+        if (R instanceof RegExp)
+          return this._removeAllSchemas(this.schemas, R), this._removeAllSchemas(this.refs, R), this;
+        switch (typeof R) {
+          case "undefined":
+            return this._removeAllSchemas(this.schemas), this._removeAllSchemas(this.refs), this._cache.clear(), this;
+          case "string": {
+            const T = l.call(this, R);
+            return typeof T == "object" && this._cache.delete(T.schema), delete this.schemas[R], delete this.refs[R], this;
+          }
+          case "object": {
+            const T = R;
+            this._cache.delete(T);
+            let O = R[this.opts.schemaId];
+            return O && (O = (0, m.normalizeId)(O), delete this.schemas[O], delete this.refs[O]), this;
+          }
+          default:
+            throw new Error("ajv.removeSchema: invalid parameter");
+        }
+      }
+      // add "vocabulary" - a collection of keywords
+      addVocabulary(R) {
+        for (const T of R)
+          this.addKeyword(T);
+        return this;
+      }
+      addKeyword(R, T) {
+        let O;
+        if (typeof R == "string")
+          O = R, typeof T == "object" && (this.logger.warn("these parameters are deprecated, see docs for addKeyword"), T.keyword = O);
+        else if (typeof R == "object" && T === void 0) {
+          if (T = R, O = T.keyword, Array.isArray(O) && !O.length)
+            throw new Error("addKeywords: keyword must be string or non-empty array");
+        } else
+          throw new Error("invalid addKeywords parameters");
+        if (B.call(this, O, T), !T)
+          return (0, v.eachItem)(O, (E) => x.call(this, E)), this;
+        fe.call(this, T);
+        const u = {
+          ...T,
+          type: (0, w.getJSONTypes)(T.type),
+          schemaType: (0, w.getJSONTypes)(T.schemaType)
+        };
+        return (0, v.eachItem)(O, u.type.length === 0 ? (E) => x.call(this, E, u) : (E) => u.type.forEach((I) => x.call(this, E, u, I))), this;
+      }
+      getKeyword(R) {
+        const T = this.RULES.all[R];
+        return typeof T == "object" ? T.definition : !!T;
+      }
+      // Remove keyword
+      removeKeyword(R) {
+        const { RULES: T } = this;
+        delete T.keywords[R], delete T.all[R];
+        for (const O of T.rules) {
+          const u = O.rules.findIndex((E) => E.keyword === R);
+          u >= 0 && O.rules.splice(u, 1);
+        }
+        return this;
+      }
+      // Add format
+      addFormat(R, T) {
+        return typeof T == "string" && (T = new RegExp(T)), this.formats[R] = T, this;
+      }
+      errorsText(R = this.errors, { separator: T = ", ", dataVar: O = "data" } = {}) {
+        return !R || R.length === 0 ? "No errors" : R.map((u) => `${O}${u.instancePath} ${u.message}`).reduce((u, E) => u + T + E);
+      }
+      $dataMetaSchema(R, T) {
+        const O = this.RULES.all;
+        R = JSON.parse(JSON.stringify(R));
+        for (const u of T) {
+          const E = u.split("/").slice(1);
+          let I = R;
+          for (const U of E)
+            I = I[U];
+          for (const U in O) {
+            const F = O[U];
+            if (typeof F != "object")
+              continue;
+            const { $data: X } = F.definition, W = I[U];
+            X && W && (I[U] = ye(W));
+          }
+        }
+        return R;
+      }
+      _removeAllSchemas(R, T) {
+        for (const O in R) {
+          const u = R[O];
+          (!T || T.test(O)) && (typeof u == "string" ? delete R[O] : u && !u.meta && (this._cache.delete(u.schema), delete R[O]));
+        }
+      }
+      _addSchema(R, T, O, u = this.opts.validateSchema, E = this.opts.addUsedSchema) {
+        let I;
+        const { schemaId: U } = this.opts;
+        if (typeof R == "object")
+          I = R[U];
+        else {
+          if (this.opts.jtd)
+            throw new Error("schema must be object");
+          if (typeof R != "boolean")
+            throw new Error("schema must be object or boolean");
+        }
+        let F = this._cache.get(R);
+        if (F !== void 0)
+          return F;
+        O = (0, m.normalizeId)(I || O);
+        const X = m.getSchemaRefs.call(this, R, O);
+        return F = new f.SchemaEnv({ schema: R, schemaId: U, meta: T, baseId: O, localRefs: X }), this._cache.set(F.schema, F), E && !O.startsWith("#") && (O && this._checkUnique(O), this.refs[O] = F), u && this.validateSchema(R, !0), F;
+      }
+      _checkUnique(R) {
+        if (this.schemas[R] || this.refs[R])
+          throw new Error(`schema with key or id "${R}" already exists`);
+      }
+      _compileSchemaEnv(R) {
+        if (R.meta ? this._compileMetaSchema(R) : f.compileSchema.call(this, R), !R.validate)
+          throw new Error("ajv implementation error");
+        return R.validate;
+      }
+      _compileMetaSchema(R) {
+        const T = this.opts;
+        this.opts = this._metaOpts;
+        try {
+          f.compileSchema.call(this, R);
+        } finally {
+          this.opts = T;
+        }
+      }
+    }
+    h.ValidationError = d.default, h.MissingRefError = g.default, e.default = h;
+    function n(A, R, T, O = "error") {
+      for (const u in A) {
+        const E = u;
+        E in R && this.logger[O](`${T}: option ${u}. ${A[E]}`);
+      }
+    }
+    function l(A) {
+      return A = (0, m.normalizeId)(A), this.schemas[A] || this.refs[A];
+    }
+    function $() {
+      const A = this.opts.schemas;
+      if (A)
+        if (Array.isArray(A))
+          this.addSchema(A);
+        else
+          for (const R in A)
+            this.addSchema(A[R], R);
+    }
+    function j() {
+      for (const A in this.opts.formats) {
+        const R = this.opts.formats[A];
+        R && this.addFormat(A, R);
+      }
+    }
+    function C(A) {
+      if (Array.isArray(A)) {
+        this.addVocabulary(A);
+        return;
+      }
+      this.logger.warn("keywords option as map is deprecated, pass array");
+      for (const R in A) {
+        const T = A[R];
+        T.keyword || (T.keyword = R), this.addKeyword(T);
+      }
+    }
+    function D() {
+      const A = { ...this.opts };
+      for (const R of p)
+        delete A[R];
+      return A;
+    }
+    const V = { log() {
+    }, warn() {
+    }, error() {
+    } };
+    function L(A) {
+      if (A === !1)
+        return V;
+      if (A === void 0)
+        return console;
+      if (A.log && A.warn && A.error)
+        return A;
+      throw new Error("logger must implement log, warn and error methods");
+    }
+    const K = /^[a-z_$][a-z0-9_$:-]*$/i;
+    function B(A, R) {
+      const { RULES: T } = this;
+      if ((0, v.eachItem)(A, (O) => {
+        if (T.keywords[O])
+          throw new Error(`Keyword ${O} is already defined`);
+        if (!K.test(O))
+          throw new Error(`Keyword ${O} has invalid name`);
+      }), !!R && R.$data && !("code" in R || "validate" in R))
+        throw new Error('$data keyword must have "code" or "validate" function');
+    }
+    function x(A, R, T) {
+      var O;
+      const u = R?.post;
+      if (T && u)
+        throw new Error('keyword with "post" flag cannot have "type"');
+      const { RULES: E } = this;
+      let I = u ? E.post : E.rules.find(({ type: F }) => F === T);
+      if (I || (I = { type: T, rules: [] }, E.rules.push(I)), E.keywords[A] = !0, !R)
+        return;
+      const U = {
+        keyword: A,
+        definition: {
+          ...R,
+          type: (0, w.getJSONTypes)(R.type),
+          schemaType: (0, w.getJSONTypes)(R.schemaType)
+        }
+      };
+      R.before ? de.call(this, I, U, R.before) : I.rules.push(U), E.all[A] = U, (O = R.implements) === null || O === void 0 || O.forEach((F) => this.addKeyword(F));
+    }
+    function de(A, R, T) {
+      const O = A.rules.findIndex((u) => u.keyword === T);
+      O >= 0 ? A.rules.splice(O, 0, R) : (A.rules.push(R), this.logger.warn(`rule ${T} is not defined`));
+    }
+    function fe(A) {
+      let { metaSchema: R } = A;
+      R !== void 0 && (A.$data && this.opts.$data && (R = ye(R)), A.validateSchema = this.compile(R, !0));
+    }
+    const Z = {
+      $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
+    };
+    function ye(A) {
+      return { anyOf: [A, Z] };
+    }
+  })(bt)), bt;
+}
+var Ce = {}, Ae = {}, Me = {}, dr;
+function Rn() {
+  if (dr) return Me;
+  dr = 1, Object.defineProperty(Me, "__esModule", { value: !0 });
+  const e = {
+    keyword: "id",
+    code() {
+      throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
+    }
+  };
+  return Me.default = e, Me;
+}
+var ve = {}, fr;
+function kn() {
+  if (fr) return ve;
+  fr = 1, Object.defineProperty(ve, "__esModule", { value: !0 }), ve.callRef = ve.getValidate = void 0;
+  const e = _t(), r = le(), S = J(), d = _e(), g = Ct(), s = Q(), f = {
+    keyword: "$ref",
+    schemaType: "string",
+    code(w) {
+      const { gen: v, schema: P, it: _ } = w, { baseId: y, schemaEnv: p, validateName: b, opts: a, self: i } = _, { root: t } = p;
+      if ((P === "#" || P === "#/") && y === t.baseId)
+        return h();
+      const o = g.resolveRef.call(i, t, y, P);
+      if (o === void 0)
+        throw new e.default(_.opts.uriResolver, y, P);
+      if (o instanceof g.SchemaEnv)
+        return n(o);
+      return l(o);
+      function h() {
+        if (p === t)
+          return m(w, b, p, p.$async);
+        const $ = v.scopeValue("root", { ref: t });
+        return m(w, (0, S._)`${$}.validate`, t, t.$async);
+      }
+      function n($) {
+        const j = c(w, $);
+        m(w, j, $, $.$async);
+      }
+      function l($) {
+        const j = v.scopeValue("schema", a.code.source === !0 ? { ref: $, code: (0, S.stringify)($) } : { ref: $ }), C = v.name("valid"), D = w.subschema({
+          schema: $,
+          dataTypes: [],
+          schemaPath: S.nil,
+          topSchemaRef: j,
+          errSchemaPath: P
+        }, C);
+        w.mergeEvaluated(D), w.ok(C);
+      }
+    }
+  };
+  function c(w, v) {
+    const { gen: P } = w;
+    return v.validate ? P.scopeValue("validate", { ref: v.validate }) : (0, S._)`${P.scopeValue("wrapper", { ref: v })}.validate`;
+  }
+  ve.getValidate = c;
+  function m(w, v, P, _) {
+    const { gen: y, it: p } = w, { allErrors: b, schemaEnv: a, opts: i } = p, t = i.passContext ? d.default.this : S.nil;
+    _ ? o() : h();
+    function o() {
+      if (!a.$async)
+        throw new Error("async schema referenced by sync schema");
+      const $ = y.let("valid");
+      y.try(() => {
+        y.code((0, S._)`await ${(0, r.callValidateCode)(w, v, t)}`), l(v), b || y.assign($, !0);
+      }, (j) => {
+        y.if((0, S._)`!(${j} instanceof ${p.ValidationError})`, () => y.throw(j)), n(j), b || y.assign($, !1);
+      }), w.ok($);
+    }
+    function h() {
+      w.result((0, r.callValidateCode)(w, v, t), () => l(v), () => n(v));
+    }
+    function n($) {
+      const j = (0, S._)`${$}.errors`;
+      y.assign(d.default.vErrors, (0, S._)`${d.default.vErrors} === null ? ${j} : ${d.default.vErrors}.concat(${j})`), y.assign(d.default.errors, (0, S._)`${d.default.vErrors}.length`);
+    }
+    function l($) {
+      var j;
+      if (!p.opts.unevaluated)
+        return;
+      const C = (j = P?.validate) === null || j === void 0 ? void 0 : j.evaluated;
+      if (p.props !== !0)
+        if (C && !C.dynamicProps)
+          C.props !== void 0 && (p.props = s.mergeEvaluated.props(y, C.props, p.props));
+        else {
+          const D = y.var("props", (0, S._)`${$}.evaluated.props`);
+          p.props = s.mergeEvaluated.props(y, D, p.props, S.Name);
+        }
+      if (p.items !== !0)
+        if (C && !C.dynamicItems)
+          C.items !== void 0 && (p.items = s.mergeEvaluated.items(y, C.items, p.items));
+        else {
+          const D = y.var("items", (0, S._)`${$}.evaluated.items`);
+          p.items = s.mergeEvaluated.items(y, D, p.items, S.Name);
+        }
+    }
+  }
+  return ve.callRef = m, ve.default = f, ve;
+}
+var hr;
+function On() {
+  if (hr) return Ae;
+  hr = 1, Object.defineProperty(Ae, "__esModule", { value: !0 });
+  const e = Rn(), r = kn(), S = [
+    "$schema",
+    "$id",
+    "$defs",
+    "$vocabulary",
+    { keyword: "$comment" },
+    "definitions",
+    e.default,
+    r.default
+  ];
+  return Ae.default = S, Ae;
+}
+var De = {}, Ve = {}, mr;
+function jn() {
+  if (mr) return Ve;
+  mr = 1, Object.defineProperty(Ve, "__esModule", { value: !0 });
+  const e = J(), r = e.operators, S = {
+    maximum: { okStr: "<=", ok: r.LTE, fail: r.GT },
+    minimum: { okStr: ">=", ok: r.GTE, fail: r.LT },
+    exclusiveMaximum: { okStr: "<", ok: r.LT, fail: r.GTE },
+    exclusiveMinimum: { okStr: ">", ok: r.GT, fail: r.LTE }
+  }, d = {
+    message: ({ keyword: s, schemaCode: f }) => (0, e.str)`must be ${S[s].okStr} ${f}`,
+    params: ({ keyword: s, schemaCode: f }) => (0, e._)`{comparison: ${S[s].okStr}, limit: ${f}}`
+  }, g = {
+    keyword: Object.keys(S),
+    type: "number",
+    schemaType: "number",
+    $data: !0,
+    error: d,
+    code(s) {
+      const { keyword: f, data: c, schemaCode: m } = s;
+      s.fail$data((0, e._)`${c} ${S[f].fail} ${m} || isNaN(${c})`);
+    }
+  };
+  return Ve.default = g, Ve;
+}
+var Ue = {}, pr;
+function In() {
+  if (pr) return Ue;
+  pr = 1, Object.defineProperty(Ue, "__esModule", { value: !0 });
+  const e = J(), S = {
+    keyword: "multipleOf",
+    type: "number",
+    schemaType: "number",
+    $data: !0,
+    error: {
+      message: ({ schemaCode: d }) => (0, e.str)`must be multiple of ${d}`,
+      params: ({ schemaCode: d }) => (0, e._)`{multipleOf: ${d}}`
+    },
+    code(d) {
+      const { gen: g, data: s, schemaCode: f, it: c } = d, m = c.opts.multipleOfPrecision, w = g.let("res"), v = m ? (0, e._)`Math.abs(Math.round(${w}) - ${w}) > 1e-${m}` : (0, e._)`${w} !== parseInt(${w})`;
+      d.fail$data((0, e._)`(${f} === 0 || (${w} = ${s}/${f}, ${v}))`);
+    }
+  };
+  return Ue.default = S, Ue;
+}
+var ze = {}, Fe = {}, yr;
+function qn() {
+  if (yr) return Fe;
+  yr = 1, Object.defineProperty(Fe, "__esModule", { value: !0 });
+  function e(r) {
+    const S = r.length;
+    let d = 0, g = 0, s;
+    for (; g < S; )
+      d++, s = r.charCodeAt(g++), s >= 55296 && s <= 56319 && g < S && (s = r.charCodeAt(g), (s & 64512) === 56320 && g++);
+    return d;
+  }
+  return Fe.default = e, e.code = 'require("ajv/dist/runtime/ucs2length").default', Fe;
+}
+var vr;
+function Tn() {
+  if (vr) return ze;
+  vr = 1, Object.defineProperty(ze, "__esModule", { value: !0 });
+  const e = J(), r = Q(), S = qn(), g = {
+    keyword: ["maxLength", "minLength"],
+    type: "string",
+    schemaType: "number",
+    $data: !0,
+    error: {
+      message({ keyword: s, schemaCode: f }) {
+        const c = s === "maxLength" ? "more" : "fewer";
+        return (0, e.str)`must NOT have ${c} than ${f} characters`;
+      },
+      params: ({ schemaCode: s }) => (0, e._)`{limit: ${s}}`
+    },
+    code(s) {
+      const { keyword: f, data: c, schemaCode: m, it: w } = s, v = f === "maxLength" ? e.operators.GT : e.operators.LT, P = w.opts.unicode === !1 ? (0, e._)`${c}.length` : (0, e._)`${(0, r.useFunc)(s.gen, S.default)}(${c})`;
+      s.fail$data((0, e._)`${P} ${v} ${m}`);
+    }
+  };
+  return ze.default = g, ze;
+}
+var Ke = {}, _r;
+function Cn() {
+  if (_r) return Ke;
+  _r = 1, Object.defineProperty(Ke, "__esModule", { value: !0 });
+  const e = le(), r = J(), d = {
+    keyword: "pattern",
+    type: "string",
+    schemaType: "string",
+    $data: !0,
+    error: {
+      message: ({ schemaCode: g }) => (0, r.str)`must match pattern "${g}"`,
+      params: ({ schemaCode: g }) => (0, r._)`{pattern: ${g}}`
+    },
+    code(g) {
+      const { data: s, $data: f, schema: c, schemaCode: m, it: w } = g, v = w.opts.unicodeRegExp ? "u" : "", P = f ? (0, r._)`(new RegExp(${m}, ${v}))` : (0, e.usePattern)(g, c);
+      g.fail$data((0, r._)`!${P}.test(${s})`);
+    }
+  };
+  return Ke.default = d, Ke;
+}
+var Le = {}, gr;
+function An() {
+  if (gr) return Le;
+  gr = 1, Object.defineProperty(Le, "__esModule", { value: !0 });
+  const e = J(), S = {
+    keyword: ["maxProperties", "minProperties"],
+    type: "object",
+    schemaType: "number",
+    $data: !0,
+    error: {
+      message({ keyword: d, schemaCode: g }) {
+        const s = d === "maxProperties" ? "more" : "fewer";
+        return (0, e.str)`must NOT have ${s} than ${g} properties`;
+      },
+      params: ({ schemaCode: d }) => (0, e._)`{limit: ${d}}`
+    },
+    code(d) {
+      const { keyword: g, data: s, schemaCode: f } = d, c = g === "maxProperties" ? e.operators.GT : e.operators.LT;
+      d.fail$data((0, e._)`Object.keys(${s}).length ${c} ${f}`);
+    }
+  };
+  return Le.default = S, Le;
+}
+var He = {}, $r;
+function Mn() {
+  if ($r) return He;
+  $r = 1, Object.defineProperty(He, "__esModule", { value: !0 });
+  const e = le(), r = J(), S = Q(), g = {
+    keyword: "required",
+    type: "object",
+    schemaType: "array",
+    $data: !0,
+    error: {
+      message: ({ params: { missingProperty: s } }) => (0, r.str)`must have required property '${s}'`,
+      params: ({ params: { missingProperty: s } }) => (0, r._)`{missingProperty: ${s}}`
+    },
+    code(s) {
+      const { gen: f, schema: c, schemaCode: m, data: w, $data: v, it: P } = s, { opts: _ } = P;
+      if (!v && c.length === 0)
+        return;
+      const y = c.length >= _.loopRequired;
+      if (P.allErrors ? p() : b(), _.strictRequired) {
+        const t = s.parentSchema.properties, { definedProperties: o } = s.it;
+        for (const h of c)
+          if (t?.[h] === void 0 && !o.has(h)) {
+            const n = P.schemaEnv.baseId + P.errSchemaPath, l = `required property "${h}" is not defined at "${n}" (strictRequired)`;
+            (0, S.checkStrictMode)(P, l, P.opts.strictRequired);
+          }
+      }
+      function p() {
+        if (y || v)
+          s.block$data(r.nil, a);
+        else
+          for (const t of c)
+            (0, e.checkReportMissingProp)(s, t);
+      }
+      function b() {
+        const t = f.let("missing");
+        if (y || v) {
+          const o = f.let("valid", !0);
+          s.block$data(o, () => i(t, o)), s.ok(o);
+        } else
+          f.if((0, e.checkMissingProp)(s, c, t)), (0, e.reportMissingProp)(s, t), f.else();
+      }
+      function a() {
+        f.forOf("prop", m, (t) => {
+          s.setParams({ missingProperty: t }), f.if((0, e.noPropertyInData)(f, w, t, _.ownProperties), () => s.error());
+        });
+      }
+      function i(t, o) {
+        s.setParams({ missingProperty: t }), f.forOf(t, m, () => {
+          f.assign(o, (0, e.propertyInData)(f, w, t, _.ownProperties)), f.if((0, r.not)(o), () => {
+            s.error(), f.break();
+          });
+        }, r.nil);
+      }
+    }
+  };
+  return He.default = g, He;
+}
+var Ge = {}, wr;
+function Dn() {
+  if (wr) return Ge;
+  wr = 1, Object.defineProperty(Ge, "__esModule", { value: !0 });
+  const e = J(), S = {
+    keyword: ["maxItems", "minItems"],
+    type: "array",
+    schemaType: "number",
+    $data: !0,
+    error: {
+      message({ keyword: d, schemaCode: g }) {
+        const s = d === "maxItems" ? "more" : "fewer";
+        return (0, e.str)`must NOT have ${s} than ${g} items`;
+      },
+      params: ({ schemaCode: d }) => (0, e._)`{limit: ${d}}`
+    },
+    code(d) {
+      const { keyword: g, data: s, schemaCode: f } = d, c = g === "maxItems" ? e.operators.GT : e.operators.LT;
+      d.fail$data((0, e._)`${s}.length ${c} ${f}`);
+    }
+  };
+  return Ge.default = S, Ge;
+}
+var Je = {}, We = {}, br;
+function At() {
+  if (br) return We;
+  br = 1, Object.defineProperty(We, "__esModule", { value: !0 });
+  const e = xr();
+  return e.code = 'require("ajv/dist/runtime/equal").default', We.default = e, We;
+}
+var Er;
+function Vn() {
+  if (Er) return Je;
+  Er = 1, Object.defineProperty(Je, "__esModule", { value: !0 });
+  const e = mt(), r = J(), S = Q(), d = At(), s = {
+    keyword: "uniqueItems",
+    type: "array",
+    schemaType: "boolean",
+    $data: !0,
+    error: {
+      message: ({ params: { i: f, j: c } }) => (0, r.str)`must NOT have duplicate items (items ## ${c} and ${f} are identical)`,
+      params: ({ params: { i: f, j: c } }) => (0, r._)`{i: ${f}, j: ${c}}`
+    },
+    code(f) {
+      const { gen: c, data: m, $data: w, schema: v, parentSchema: P, schemaCode: _, it: y } = f;
+      if (!w && !v)
+        return;
+      const p = c.let("valid"), b = P.items ? (0, e.getSchemaTypes)(P.items) : [];
+      f.block$data(p, a, (0, r._)`${_} === false`), f.ok(p);
+      function a() {
+        const h = c.let("i", (0, r._)`${m}.length`), n = c.let("j");
+        f.setParams({ i: h, j: n }), c.assign(p, !0), c.if((0, r._)`${h} > 1`, () => (i() ? t : o)(h, n));
+      }
+      function i() {
+        return b.length > 0 && !b.some((h) => h === "object" || h === "array");
+      }
+      function t(h, n) {
+        const l = c.name("item"), $ = (0, e.checkDataTypes)(b, l, y.opts.strictNumbers, e.DataType.Wrong), j = c.const("indices", (0, r._)`{}`);
+        c.for((0, r._)`;${h}--;`, () => {
+          c.let(l, (0, r._)`${m}[${h}]`), c.if($, (0, r._)`continue`), b.length > 1 && c.if((0, r._)`typeof ${l} == "string"`, (0, r._)`${l} += "_"`), c.if((0, r._)`typeof ${j}[${l}] == "number"`, () => {
+            c.assign(n, (0, r._)`${j}[${l}]`), f.error(), c.assign(p, !1).break();
+          }).code((0, r._)`${j}[${l}] = ${h}`);
+        });
+      }
+      function o(h, n) {
+        const l = (0, S.useFunc)(c, d.default), $ = c.name("outer");
+        c.label($).for((0, r._)`;${h}--;`, () => c.for((0, r._)`${n} = ${h}; ${n}--;`, () => c.if((0, r._)`${l}(${m}[${h}], ${m}[${n}])`, () => {
+          f.error(), c.assign(p, !1).break($);
+        })));
+      }
+    }
+  };
+  return Je.default = s, Je;
+}
+var Be = {}, Sr;
+function Un() {
+  if (Sr) return Be;
+  Sr = 1, Object.defineProperty(Be, "__esModule", { value: !0 });
+  const e = J(), r = Q(), S = At(), g = {
+    keyword: "const",
+    $data: !0,
+    error: {
+      message: "must be equal to constant",
+      params: ({ schemaCode: s }) => (0, e._)`{allowedValue: ${s}}`
+    },
+    code(s) {
+      const { gen: f, data: c, $data: m, schemaCode: w, schema: v } = s;
+      m || v && typeof v == "object" ? s.fail$data((0, e._)`!${(0, r.useFunc)(f, S.default)}(${c}, ${w})`) : s.fail((0, e._)`${v} !== ${c}`);
+    }
+  };
+  return Be.default = g, Be;
+}
+var Qe = {}, Pr;
+function zn() {
+  if (Pr) return Qe;
+  Pr = 1, Object.defineProperty(Qe, "__esModule", { value: !0 });
+  const e = J(), r = Q(), S = At(), g = {
+    keyword: "enum",
+    schemaType: "array",
+    $data: !0,
+    error: {
+      message: "must be equal to one of the allowed values",
+      params: ({ schemaCode: s }) => (0, e._)`{allowedValues: ${s}}`
+    },
+    code(s) {
+      const { gen: f, data: c, $data: m, schema: w, schemaCode: v, it: P } = s;
+      if (!m && w.length === 0)
+        throw new Error("enum must have non-empty array");
+      const _ = w.length >= P.opts.loopEnum;
+      let y;
+      const p = () => y ?? (y = (0, r.useFunc)(f, S.default));
+      let b;
+      if (_ || m)
+        b = f.let("valid"), s.block$data(b, a);
+      else {
+        if (!Array.isArray(w))
+          throw new Error("ajv implementation error");
+        const t = f.const("vSchema", v);
+        b = (0, e.or)(...w.map((o, h) => i(t, h)));
+      }
+      s.pass(b);
+      function a() {
+        f.assign(b, !1), f.forOf("v", v, (t) => f.if((0, e._)`${p()}(${c}, ${t})`, () => f.assign(b, !0).break()));
+      }
+      function i(t, o) {
+        const h = w[o];
+        return typeof h == "object" && h !== null ? (0, e._)`${p()}(${c}, ${t}[${o}])` : (0, e._)`${c} === ${h}`;
+      }
+    }
+  };
+  return Qe.default = g, Qe;
+}
+var Nr;
+function Fn() {
+  if (Nr) return De;
+  Nr = 1, Object.defineProperty(De, "__esModule", { value: !0 });
+  const e = jn(), r = In(), S = Tn(), d = Cn(), g = An(), s = Mn(), f = Dn(), c = Vn(), m = Un(), w = zn(), v = [
+    // number
+    e.default,
+    r.default,
+    // string
+    S.default,
+    d.default,
+    // object
+    g.default,
+    s.default,
+    // array
+    f.default,
+    c.default,
+    // any
+    { keyword: "type", schemaType: ["string", "array"] },
+    { keyword: "nullable", schemaType: "boolean" },
+    m.default,
+    w.default
+  ];
+  return De.default = v, De;
+}
+var Xe = {}, Ee = {}, Rr;
+function tn() {
+  if (Rr) return Ee;
+  Rr = 1, Object.defineProperty(Ee, "__esModule", { value: !0 }), Ee.validateAdditionalItems = void 0;
+  const e = J(), r = Q(), d = {
+    keyword: "additionalItems",
+    type: "array",
+    schemaType: ["boolean", "object"],
+    before: "uniqueItems",
+    error: {
+      message: ({ params: { len: s } }) => (0, e.str)`must NOT have more than ${s} items`,
+      params: ({ params: { len: s } }) => (0, e._)`{limit: ${s}}`
+    },
+    code(s) {
+      const { parentSchema: f, it: c } = s, { items: m } = f;
+      if (!Array.isArray(m)) {
+        (0, r.checkStrictMode)(c, '"additionalItems" is ignored when "items" is not an array of schemas');
+        return;
+      }
+      g(s, m);
+    }
+  };
+  function g(s, f) {
+    const { gen: c, schema: m, data: w, keyword: v, it: P } = s;
+    P.items = !0;
+    const _ = c.const("len", (0, e._)`${w}.length`);
+    if (m === !1)
+      s.setParams({ len: f.length }), s.pass((0, e._)`${_} <= ${f.length}`);
+    else if (typeof m == "object" && !(0, r.alwaysValidSchema)(P, m)) {
+      const p = c.var("valid", (0, e._)`${_} <= ${f.length}`);
+      c.if((0, e.not)(p), () => y(p)), s.ok(p);
+    }
+    function y(p) {
+      c.forRange("i", f.length, _, (b) => {
+        s.subschema({ keyword: v, dataProp: b, dataPropType: r.Type.Num }, p), P.allErrors || c.if((0, e.not)(p), () => c.break());
+      });
+    }
+  }
+  return Ee.validateAdditionalItems = g, Ee.default = d, Ee;
+}
+var Ye = {}, Se = {}, kr;
+function rn() {
+  if (kr) return Se;
+  kr = 1, Object.defineProperty(Se, "__esModule", { value: !0 }), Se.validateTuple = void 0;
+  const e = J(), r = Q(), S = le(), d = {
+    keyword: "items",
+    type: "array",
+    schemaType: ["object", "array", "boolean"],
+    before: "uniqueItems",
+    code(s) {
+      const { schema: f, it: c } = s;
+      if (Array.isArray(f))
+        return g(s, "additionalItems", f);
+      c.items = !0, !(0, r.alwaysValidSchema)(c, f) && s.ok((0, S.validateArray)(s));
+    }
+  };
+  function g(s, f, c = s.schema) {
+    const { gen: m, parentSchema: w, data: v, keyword: P, it: _ } = s;
+    b(w), _.opts.unevaluated && c.length && _.items !== !0 && (_.items = r.mergeEvaluated.items(m, c.length, _.items));
+    const y = m.name("valid"), p = m.const("len", (0, e._)`${v}.length`);
+    c.forEach((a, i) => {
+      (0, r.alwaysValidSchema)(_, a) || (m.if((0, e._)`${p} > ${i}`, () => s.subschema({
+        keyword: P,
+        schemaProp: i,
+        dataProp: i
+      }, y)), s.ok(y));
+    });
+    function b(a) {
+      const { opts: i, errSchemaPath: t } = _, o = c.length, h = o === a.minItems && (o === a.maxItems || a[f] === !1);
+      if (i.strictTuples && !h) {
+        const n = `"${P}" is ${o}-tuple, but minItems or maxItems/${f} are not specified or different at path "${t}"`;
+        (0, r.checkStrictMode)(_, n, i.strictTuples);
+      }
+    }
+  }
+  return Se.validateTuple = g, Se.default = d, Se;
+}
+var Or;
+function Kn() {
+  if (Or) return Ye;
+  Or = 1, Object.defineProperty(Ye, "__esModule", { value: !0 });
+  const e = rn(), r = {
+    keyword: "prefixItems",
+    type: "array",
+    schemaType: ["array"],
+    before: "uniqueItems",
+    code: (S) => (0, e.validateTuple)(S, "items")
+  };
+  return Ye.default = r, Ye;
+}
+var Ze = {}, jr;
+function Ln() {
+  if (jr) return Ze;
+  jr = 1, Object.defineProperty(Ze, "__esModule", { value: !0 });
+  const e = J(), r = Q(), S = le(), d = tn(), s = {
+    keyword: "items",
+    type: "array",
+    schemaType: ["object", "boolean"],
+    before: "uniqueItems",
+    error: {
+      message: ({ params: { len: f } }) => (0, e.str)`must NOT have more than ${f} items`,
+      params: ({ params: { len: f } }) => (0, e._)`{limit: ${f}}`
+    },
+    code(f) {
+      const { schema: c, parentSchema: m, it: w } = f, { prefixItems: v } = m;
+      w.items = !0, !(0, r.alwaysValidSchema)(w, c) && (v ? (0, d.validateAdditionalItems)(f, v) : f.ok((0, S.validateArray)(f)));
+    }
+  };
+  return Ze.default = s, Ze;
+}
+var xe = {}, Ir;
+function Hn() {
+  if (Ir) return xe;
+  Ir = 1, Object.defineProperty(xe, "__esModule", { value: !0 });
+  const e = J(), r = Q(), d = {
+    keyword: "contains",
+    type: "array",
+    schemaType: ["object", "boolean"],
+    before: "uniqueItems",
+    trackErrors: !0,
+    error: {
+      message: ({ params: { min: g, max: s } }) => s === void 0 ? (0, e.str)`must contain at least ${g} valid item(s)` : (0, e.str)`must contain at least ${g} and no more than ${s} valid item(s)`,
+      params: ({ params: { min: g, max: s } }) => s === void 0 ? (0, e._)`{minContains: ${g}}` : (0, e._)`{minContains: ${g}, maxContains: ${s}}`
+    },
+    code(g) {
+      const { gen: s, schema: f, parentSchema: c, data: m, it: w } = g;
+      let v, P;
+      const { minContains: _, maxContains: y } = c;
+      w.opts.next ? (v = _ === void 0 ? 1 : _, P = y) : v = 1;
+      const p = s.const("len", (0, e._)`${m}.length`);
+      if (g.setParams({ min: v, max: P }), P === void 0 && v === 0) {
+        (0, r.checkStrictMode)(w, '"minContains" == 0 without "maxContains": "contains" keyword ignored');
+        return;
+      }
+      if (P !== void 0 && v > P) {
+        (0, r.checkStrictMode)(w, '"minContains" > "maxContains" is always invalid'), g.fail();
+        return;
+      }
+      if ((0, r.alwaysValidSchema)(w, f)) {
+        let o = (0, e._)`${p} >= ${v}`;
+        P !== void 0 && (o = (0, e._)`${o} && ${p} <= ${P}`), g.pass(o);
+        return;
+      }
+      w.items = !0;
+      const b = s.name("valid");
+      P === void 0 && v === 1 ? i(b, () => s.if(b, () => s.break())) : v === 0 ? (s.let(b, !0), P !== void 0 && s.if((0, e._)`${m}.length > 0`, a)) : (s.let(b, !1), a()), g.result(b, () => g.reset());
+      function a() {
+        const o = s.name("_valid"), h = s.let("count", 0);
+        i(o, () => s.if(o, () => t(h)));
+      }
+      function i(o, h) {
+        s.forRange("i", 0, p, (n) => {
+          g.subschema({
+            keyword: "contains",
+            dataProp: n,
+            dataPropType: r.Type.Num,
+            compositeRule: !0
+          }, o), h();
+        });
+      }
+      function t(o) {
+        s.code((0, e._)`${o}++`), P === void 0 ? s.if((0, e._)`${o} >= ${v}`, () => s.assign(b, !0).break()) : (s.if((0, e._)`${o} > ${P}`, () => s.assign(b, !1).break()), v === 1 ? s.assign(b, !0) : s.if((0, e._)`${o} >= ${v}`, () => s.assign(b, !0)));
+      }
+    }
+  };
+  return xe.default = d, xe;
+}
+var It = {}, qr;
+function Gn() {
+  return qr || (qr = 1, (function(e) {
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.validateSchemaDeps = e.validatePropertyDeps = e.error = void 0;
+    const r = J(), S = Q(), d = le();
+    e.error = {
+      message: ({ params: { property: m, depsCount: w, deps: v } }) => {
+        const P = w === 1 ? "property" : "properties";
+        return (0, r.str)`must have ${P} ${v} when property ${m} is present`;
+      },
+      params: ({ params: { property: m, depsCount: w, deps: v, missingProperty: P } }) => (0, r._)`{property: ${m},
+    missingProperty: ${P},
+    depsCount: ${w},
+    deps: ${v}}`
+      // TODO change to reference
+    };
+    const g = {
+      keyword: "dependencies",
+      type: "object",
+      schemaType: "object",
+      error: e.error,
+      code(m) {
+        const [w, v] = s(m);
+        f(m, w), c(m, v);
+      }
+    };
+    function s({ schema: m }) {
+      const w = {}, v = {};
+      for (const P in m) {
+        if (P === "__proto__")
+          continue;
+        const _ = Array.isArray(m[P]) ? w : v;
+        _[P] = m[P];
+      }
+      return [w, v];
+    }
+    function f(m, w = m.schema) {
+      const { gen: v, data: P, it: _ } = m;
+      if (Object.keys(w).length === 0)
+        return;
+      const y = v.let("missing");
+      for (const p in w) {
+        const b = w[p];
+        if (b.length === 0)
+          continue;
+        const a = (0, d.propertyInData)(v, P, p, _.opts.ownProperties);
+        m.setParams({
+          property: p,
+          depsCount: b.length,
+          deps: b.join(", ")
+        }), _.allErrors ? v.if(a, () => {
+          for (const i of b)
+            (0, d.checkReportMissingProp)(m, i);
+        }) : (v.if((0, r._)`${a} && (${(0, d.checkMissingProp)(m, b, y)})`), (0, d.reportMissingProp)(m, y), v.else());
+      }
+    }
+    e.validatePropertyDeps = f;
+    function c(m, w = m.schema) {
+      const { gen: v, data: P, keyword: _, it: y } = m, p = v.name("valid");
+      for (const b in w)
+        (0, S.alwaysValidSchema)(y, w[b]) || (v.if(
+          (0, d.propertyInData)(v, P, b, y.opts.ownProperties),
+          () => {
+            const a = m.subschema({ keyword: _, schemaProp: b }, p);
+            m.mergeValidEvaluated(a, p);
+          },
+          () => v.var(p, !0)
+          // TODO var
+        ), m.ok(p));
+    }
+    e.validateSchemaDeps = c, e.default = g;
+  })(It)), It;
+}
+var et = {}, Tr;
+function Jn() {
+  if (Tr) return et;
+  Tr = 1, Object.defineProperty(et, "__esModule", { value: !0 });
+  const e = J(), r = Q(), d = {
+    keyword: "propertyNames",
+    type: "object",
+    schemaType: ["object", "boolean"],
+    error: {
+      message: "property name must be valid",
+      params: ({ params: g }) => (0, e._)`{propertyName: ${g.propertyName}}`
+    },
+    code(g) {
+      const { gen: s, schema: f, data: c, it: m } = g;
+      if ((0, r.alwaysValidSchema)(m, f))
+        return;
+      const w = s.name("valid");
+      s.forIn("key", c, (v) => {
+        g.setParams({ propertyName: v }), g.subschema({
+          keyword: "propertyNames",
+          data: v,
+          dataTypes: ["string"],
+          propertyName: v,
+          compositeRule: !0
+        }, w), s.if((0, e.not)(w), () => {
+          g.error(!0), m.allErrors || s.break();
+        });
+      }), g.ok(w);
+    }
+  };
+  return et.default = d, et;
+}
+var tt = {}, Cr;
+function nn() {
+  if (Cr) return tt;
+  Cr = 1, Object.defineProperty(tt, "__esModule", { value: !0 });
+  const e = le(), r = J(), S = _e(), d = Q(), s = {
+    keyword: "additionalProperties",
+    type: ["object"],
+    schemaType: ["boolean", "object"],
+    allowUndefined: !0,
+    trackErrors: !0,
+    error: {
+      message: "must NOT have additional properties",
+      params: ({ params: f }) => (0, r._)`{additionalProperty: ${f.additionalProperty}}`
+    },
+    code(f) {
+      const { gen: c, schema: m, parentSchema: w, data: v, errsCount: P, it: _ } = f;
+      if (!P)
+        throw new Error("ajv implementation error");
+      const { allErrors: y, opts: p } = _;
+      if (_.props = !0, p.removeAdditional !== "all" && (0, d.alwaysValidSchema)(_, m))
+        return;
+      const b = (0, e.allSchemaProperties)(w.properties), a = (0, e.allSchemaProperties)(w.patternProperties);
+      i(), f.ok((0, r._)`${P} === ${S.default.errors}`);
+      function i() {
+        c.forIn("key", v, (l) => {
+          !b.length && !a.length ? h(l) : c.if(t(l), () => h(l));
+        });
+      }
+      function t(l) {
+        let $;
+        if (b.length > 8) {
+          const j = (0, d.schemaRefOrVal)(_, w.properties, "properties");
+          $ = (0, e.isOwnProperty)(c, j, l);
+        } else b.length ? $ = (0, r.or)(...b.map((j) => (0, r._)`${l} === ${j}`)) : $ = r.nil;
+        return a.length && ($ = (0, r.or)($, ...a.map((j) => (0, r._)`${(0, e.usePattern)(f, j)}.test(${l})`))), (0, r.not)($);
+      }
+      function o(l) {
+        c.code((0, r._)`delete ${v}[${l}]`);
+      }
+      function h(l) {
+        if (p.removeAdditional === "all" || p.removeAdditional && m === !1) {
+          o(l);
+          return;
+        }
+        if (m === !1) {
+          f.setParams({ additionalProperty: l }), f.error(), y || c.break();
+          return;
+        }
+        if (typeof m == "object" && !(0, d.alwaysValidSchema)(_, m)) {
+          const $ = c.name("valid");
+          p.removeAdditional === "failing" ? (n(l, $, !1), c.if((0, r.not)($), () => {
+            f.reset(), o(l);
+          })) : (n(l, $), y || c.if((0, r.not)($), () => c.break()));
+        }
+      }
+      function n(l, $, j) {
+        const C = {
+          keyword: "additionalProperties",
+          dataProp: l,
+          dataPropType: d.Type.Str
+        };
+        j === !1 && Object.assign(C, {
+          compositeRule: !0,
+          createErrors: !1,
+          allErrors: !1
+        }), f.subschema(C, $);
+      }
+    }
+  };
+  return tt.default = s, tt;
+}
+var rt = {}, Ar;
+function Wn() {
+  if (Ar) return rt;
+  Ar = 1, Object.defineProperty(rt, "__esModule", { value: !0 });
+  const e = vt(), r = le(), S = Q(), d = nn(), g = {
+    keyword: "properties",
+    type: "object",
+    schemaType: "object",
+    code(s) {
+      const { gen: f, schema: c, parentSchema: m, data: w, it: v } = s;
+      v.opts.removeAdditional === "all" && m.additionalProperties === void 0 && d.default.code(new e.KeywordCxt(v, d.default, "additionalProperties"));
+      const P = (0, r.allSchemaProperties)(c);
+      for (const a of P)
+        v.definedProperties.add(a);
+      v.opts.unevaluated && P.length && v.props !== !0 && (v.props = S.mergeEvaluated.props(f, (0, S.toHash)(P), v.props));
+      const _ = P.filter((a) => !(0, S.alwaysValidSchema)(v, c[a]));
+      if (_.length === 0)
+        return;
+      const y = f.name("valid");
+      for (const a of _)
+        p(a) ? b(a) : (f.if((0, r.propertyInData)(f, w, a, v.opts.ownProperties)), b(a), v.allErrors || f.else().var(y, !0), f.endIf()), s.it.definedProperties.add(a), s.ok(y);
+      function p(a) {
+        return v.opts.useDefaults && !v.compositeRule && c[a].default !== void 0;
+      }
+      function b(a) {
+        s.subschema({
+          keyword: "properties",
+          schemaProp: a,
+          dataProp: a
+        }, y);
+      }
+    }
+  };
+  return rt.default = g, rt;
+}
+var nt = {}, Mr;
+function Bn() {
+  if (Mr) return nt;
+  Mr = 1, Object.defineProperty(nt, "__esModule", { value: !0 });
+  const e = le(), r = J(), S = Q(), d = Q(), g = {
+    keyword: "patternProperties",
+    type: "object",
+    schemaType: "object",
+    code(s) {
+      const { gen: f, schema: c, data: m, parentSchema: w, it: v } = s, { opts: P } = v, _ = (0, e.allSchemaProperties)(c), y = _.filter((h) => (0, S.alwaysValidSchema)(v, c[h]));
+      if (_.length === 0 || y.length === _.length && (!v.opts.unevaluated || v.props === !0))
+        return;
+      const p = P.strictSchema && !P.allowMatchingProperties && w.properties, b = f.name("valid");
+      v.props !== !0 && !(v.props instanceof r.Name) && (v.props = (0, d.evaluatedPropsToName)(f, v.props));
+      const { props: a } = v;
+      i();
+      function i() {
+        for (const h of _)
+          p && t(h), v.allErrors ? o(h) : (f.var(b, !0), o(h), f.if(b));
+      }
+      function t(h) {
+        for (const n in p)
+          new RegExp(h).test(n) && (0, S.checkStrictMode)(v, `property ${n} matches pattern ${h} (use allowMatchingProperties)`);
+      }
+      function o(h) {
+        f.forIn("key", m, (n) => {
+          f.if((0, r._)`${(0, e.usePattern)(s, h)}.test(${n})`, () => {
+            const l = y.includes(h);
+            l || s.subschema({
+              keyword: "patternProperties",
+              schemaProp: h,
+              dataProp: n,
+              dataPropType: d.Type.Str
+            }, b), v.opts.unevaluated && a !== !0 ? f.assign((0, r._)`${a}[${n}]`, !0) : !l && !v.allErrors && f.if((0, r.not)(b), () => f.break());
+          });
+        });
+      }
+    }
+  };
+  return nt.default = g, nt;
+}
+var st = {}, Dr;
+function Qn() {
+  if (Dr) return st;
+  Dr = 1, Object.defineProperty(st, "__esModule", { value: !0 });
+  const e = Q(), r = {
+    keyword: "not",
+    schemaType: ["object", "boolean"],
+    trackErrors: !0,
+    code(S) {
+      const { gen: d, schema: g, it: s } = S;
+      if ((0, e.alwaysValidSchema)(s, g)) {
+        S.fail();
+        return;
+      }
+      const f = d.name("valid");
+      S.subschema({
+        keyword: "not",
+        compositeRule: !0,
+        createErrors: !1,
+        allErrors: !1
+      }, f), S.failResult(f, () => S.reset(), () => S.error());
+    },
+    error: { message: "must NOT be valid" }
+  };
+  return st.default = r, st;
+}
+var at = {}, Vr;
+function Xn() {
+  if (Vr) return at;
+  Vr = 1, Object.defineProperty(at, "__esModule", { value: !0 });
+  const r = {
+    keyword: "anyOf",
+    schemaType: "array",
+    trackErrors: !0,
+    code: le().validateUnion,
+    error: { message: "must match a schema in anyOf" }
+  };
+  return at.default = r, at;
+}
+var ot = {}, Ur;
+function Yn() {
+  if (Ur) return ot;
+  Ur = 1, Object.defineProperty(ot, "__esModule", { value: !0 });
+  const e = J(), r = Q(), d = {
+    keyword: "oneOf",
+    schemaType: "array",
+    trackErrors: !0,
+    error: {
+      message: "must match exactly one schema in oneOf",
+      params: ({ params: g }) => (0, e._)`{passingSchemas: ${g.passing}}`
+    },
+    code(g) {
+      const { gen: s, schema: f, parentSchema: c, it: m } = g;
+      if (!Array.isArray(f))
+        throw new Error("ajv implementation error");
+      if (m.opts.discriminator && c.discriminator)
+        return;
+      const w = f, v = s.let("valid", !1), P = s.let("passing", null), _ = s.name("_valid");
+      g.setParams({ passing: P }), s.block(y), g.result(v, () => g.reset(), () => g.error(!0));
+      function y() {
+        w.forEach((p, b) => {
+          let a;
+          (0, r.alwaysValidSchema)(m, p) ? s.var(_, !0) : a = g.subschema({
+            keyword: "oneOf",
+            schemaProp: b,
+            compositeRule: !0
+          }, _), b > 0 && s.if((0, e._)`${_} && ${v}`).assign(v, !1).assign(P, (0, e._)`[${P}, ${b}]`).else(), s.if(_, () => {
+            s.assign(v, !0), s.assign(P, b), a && g.mergeEvaluated(a, e.Name);
+          });
+        });
+      }
+    }
+  };
+  return ot.default = d, ot;
+}
+var it = {}, zr;
+function Zn() {
+  if (zr) return it;
+  zr = 1, Object.defineProperty(it, "__esModule", { value: !0 });
+  const e = Q(), r = {
+    keyword: "allOf",
+    schemaType: "array",
+    code(S) {
+      const { gen: d, schema: g, it: s } = S;
+      if (!Array.isArray(g))
+        throw new Error("ajv implementation error");
+      const f = d.name("valid");
+      g.forEach((c, m) => {
+        if ((0, e.alwaysValidSchema)(s, c))
+          return;
+        const w = S.subschema({ keyword: "allOf", schemaProp: m }, f);
+        S.ok(f), S.mergeEvaluated(w);
+      });
+    }
+  };
+  return it.default = r, it;
+}
+var ut = {}, Fr;
+function xn() {
+  if (Fr) return ut;
+  Fr = 1, Object.defineProperty(ut, "__esModule", { value: !0 });
+  const e = J(), r = Q(), d = {
+    keyword: "if",
+    schemaType: ["object", "boolean"],
+    trackErrors: !0,
+    error: {
+      message: ({ params: s }) => (0, e.str)`must match "${s.ifClause}" schema`,
+      params: ({ params: s }) => (0, e._)`{failingKeyword: ${s.ifClause}}`
+    },
+    code(s) {
+      const { gen: f, parentSchema: c, it: m } = s;
+      c.then === void 0 && c.else === void 0 && (0, r.checkStrictMode)(m, '"if" without "then" and "else" is ignored');
+      const w = g(m, "then"), v = g(m, "else");
+      if (!w && !v)
+        return;
+      const P = f.let("valid", !0), _ = f.name("_valid");
+      if (y(), s.reset(), w && v) {
+        const b = f.let("ifClause");
+        s.setParams({ ifClause: b }), f.if(_, p("then", b), p("else", b));
+      } else w ? f.if(_, p("then")) : f.if((0, e.not)(_), p("else"));
+      s.pass(P, () => s.error(!0));
+      function y() {
+        const b = s.subschema({
+          keyword: "if",
+          compositeRule: !0,
+          createErrors: !1,
+          allErrors: !1
+        }, _);
+        s.mergeEvaluated(b);
+      }
+      function p(b, a) {
+        return () => {
+          const i = s.subschema({ keyword: b }, _);
+          f.assign(P, _), s.mergeValidEvaluated(i, P), a ? f.assign(a, (0, e._)`${b}`) : s.setParams({ ifClause: b });
+        };
+      }
+    }
+  };
+  function g(s, f) {
+    const c = s.schema[f];
+    return c !== void 0 && !(0, r.alwaysValidSchema)(s, c);
+  }
+  return ut.default = d, ut;
+}
+var ct = {}, Kr;
+function es() {
+  if (Kr) return ct;
+  Kr = 1, Object.defineProperty(ct, "__esModule", { value: !0 });
+  const e = Q(), r = {
+    keyword: ["then", "else"],
+    schemaType: ["object", "boolean"],
+    code({ keyword: S, parentSchema: d, it: g }) {
+      d.if === void 0 && (0, e.checkStrictMode)(g, `"${S}" without "if" is ignored`);
+    }
+  };
+  return ct.default = r, ct;
+}
+var Lr;
+function ts() {
+  if (Lr) return Xe;
+  Lr = 1, Object.defineProperty(Xe, "__esModule", { value: !0 });
+  const e = tn(), r = Kn(), S = rn(), d = Ln(), g = Hn(), s = Gn(), f = Jn(), c = nn(), m = Wn(), w = Bn(), v = Qn(), P = Xn(), _ = Yn(), y = Zn(), p = xn(), b = es();
+  function a(i = !1) {
+    const t = [
+      // any
+      v.default,
+      P.default,
+      _.default,
+      y.default,
+      p.default,
+      b.default,
+      // object
+      f.default,
+      c.default,
+      s.default,
+      m.default,
+      w.default
+    ];
+    return i ? t.push(r.default, d.default) : t.push(e.default, S.default), t.push(g.default), t;
+  }
+  return Xe.default = a, Xe;
+}
+var lt = {}, dt = {}, Hr;
+function rs() {
+  if (Hr) return dt;
+  Hr = 1, Object.defineProperty(dt, "__esModule", { value: !0 });
+  const e = J(), S = {
+    keyword: "format",
+    type: ["number", "string"],
+    schemaType: "string",
+    $data: !0,
+    error: {
+      message: ({ schemaCode: d }) => (0, e.str)`must match format "${d}"`,
+      params: ({ schemaCode: d }) => (0, e._)`{format: ${d}}`
+    },
+    code(d, g) {
+      const { gen: s, data: f, $data: c, schema: m, schemaCode: w, it: v } = d, { opts: P, errSchemaPath: _, schemaEnv: y, self: p } = v;
+      if (!P.validateFormats)
+        return;
+      c ? b() : a();
+      function b() {
+        const i = s.scopeValue("formats", {
+          ref: p.formats,
+          code: P.code.formats
+        }), t = s.const("fDef", (0, e._)`${i}[${w}]`), o = s.let("fType"), h = s.let("format");
+        s.if((0, e._)`typeof ${t} == "object" && !(${t} instanceof RegExp)`, () => s.assign(o, (0, e._)`${t}.type || "string"`).assign(h, (0, e._)`${t}.validate`), () => s.assign(o, (0, e._)`"string"`).assign(h, t)), d.fail$data((0, e.or)(n(), l()));
+        function n() {
+          return P.strictSchema === !1 ? e.nil : (0, e._)`${w} && !${h}`;
+        }
+        function l() {
+          const $ = y.$async ? (0, e._)`(${t}.async ? await ${h}(${f}) : ${h}(${f}))` : (0, e._)`${h}(${f})`, j = (0, e._)`(typeof ${h} == "function" ? ${$} : ${h}.test(${f}))`;
+          return (0, e._)`${h} && ${h} !== true && ${o} === ${g} && !${j}`;
+        }
+      }
+      function a() {
+        const i = p.formats[m];
+        if (!i) {
+          n();
+          return;
+        }
+        if (i === !0)
+          return;
+        const [t, o, h] = l(i);
+        t === g && d.pass($());
+        function n() {
+          if (P.strictSchema === !1) {
+            p.logger.warn(j());
+            return;
+          }
+          throw new Error(j());
+          function j() {
+            return `unknown format "${m}" ignored in schema at path "${_}"`;
+          }
+        }
+        function l(j) {
+          const C = j instanceof RegExp ? (0, e.regexpCode)(j) : P.code.formats ? (0, e._)`${P.code.formats}${(0, e.getProperty)(m)}` : void 0, D = s.scopeValue("formats", { key: m, ref: j, code: C });
+          return typeof j == "object" && !(j instanceof RegExp) ? [j.type || "string", j.validate, (0, e._)`${D}.validate`] : ["string", j, D];
+        }
+        function $() {
+          if (typeof i == "object" && !(i instanceof RegExp) && i.async) {
+            if (!y.$async)
+              throw new Error("async format in sync schema");
+            return (0, e._)`await ${h}(${f})`;
+          }
+          return typeof o == "function" ? (0, e._)`${h}(${f})` : (0, e._)`${h}.test(${f})`;
+        }
+      }
+    }
+  };
+  return dt.default = S, dt;
+}
+var Gr;
+function ns() {
+  if (Gr) return lt;
+  Gr = 1, Object.defineProperty(lt, "__esModule", { value: !0 });
+  const r = [rs().default];
+  return lt.default = r, lt;
+}
+var we = {}, Jr;
+function ss() {
+  return Jr || (Jr = 1, Object.defineProperty(we, "__esModule", { value: !0 }), we.contentVocabulary = we.metadataVocabulary = void 0, we.metadataVocabulary = [
+    "title",
+    "description",
+    "default",
+    "deprecated",
+    "readOnly",
+    "writeOnly",
+    "examples"
+  ], we.contentVocabulary = [
+    "contentMediaType",
+    "contentEncoding",
+    "contentSchema"
+  ]), we;
+}
+var Wr;
+function as() {
+  if (Wr) return Ce;
+  Wr = 1, Object.defineProperty(Ce, "__esModule", { value: !0 });
+  const e = On(), r = Fn(), S = ts(), d = ns(), g = ss(), s = [
+    e.default,
+    r.default,
+    (0, S.default)(),
+    d.default,
+    g.metadataVocabulary,
+    g.contentVocabulary
+  ];
+  return Ce.default = s, Ce;
+}
+var ft = {}, ke = {}, Br;
+function os() {
+  if (Br) return ke;
+  Br = 1, Object.defineProperty(ke, "__esModule", { value: !0 }), ke.DiscrError = void 0;
+  var e;
+  return (function(r) {
+    r.Tag = "tag", r.Mapping = "mapping";
+  })(e || (ke.DiscrError = e = {})), ke;
+}
+var Qr;
+function is() {
+  if (Qr) return ft;
+  Qr = 1, Object.defineProperty(ft, "__esModule", { value: !0 });
+  const e = J(), r = os(), S = Ct(), d = _t(), g = Q(), f = {
+    keyword: "discriminator",
+    type: "object",
+    schemaType: "object",
+    error: {
+      message: ({ params: { discrError: c, tagName: m } }) => c === r.DiscrError.Tag ? `tag "${m}" must be string` : `value of tag "${m}" must be in oneOf`,
+      params: ({ params: { discrError: c, tag: m, tagName: w } }) => (0, e._)`{error: ${c}, tag: ${w}, tagValue: ${m}}`
+    },
+    code(c) {
+      const { gen: m, data: w, schema: v, parentSchema: P, it: _ } = c, { oneOf: y } = P;
+      if (!_.opts.discriminator)
+        throw new Error("discriminator: requires discriminator option");
+      const p = v.propertyName;
+      if (typeof p != "string")
+        throw new Error("discriminator: requires propertyName");
+      if (v.mapping)
+        throw new Error("discriminator: mapping is not supported");
+      if (!y)
+        throw new Error("discriminator: requires oneOf keyword");
+      const b = m.let("valid", !1), a = m.const("tag", (0, e._)`${w}${(0, e.getProperty)(p)}`);
+      m.if((0, e._)`typeof ${a} == "string"`, () => i(), () => c.error(!1, { discrError: r.DiscrError.Tag, tag: a, tagName: p })), c.ok(b);
+      function i() {
+        const h = o();
+        m.if(!1);
+        for (const n in h)
+          m.elseIf((0, e._)`${a} === ${n}`), m.assign(b, t(h[n]));
+        m.else(), c.error(!1, { discrError: r.DiscrError.Mapping, tag: a, tagName: p }), m.endIf();
+      }
+      function t(h) {
+        const n = m.name("valid"), l = c.subschema({ keyword: "oneOf", schemaProp: h }, n);
+        return c.mergeEvaluated(l, e.Name), n;
+      }
+      function o() {
+        var h;
+        const n = {}, l = j(P);
+        let $ = !0;
+        for (let V = 0; V < y.length; V++) {
+          let L = y[V];
+          if (L?.$ref && !(0, g.schemaHasRulesButRef)(L, _.self.RULES)) {
+            const B = L.$ref;
+            if (L = S.resolveRef.call(_.self, _.schemaEnv.root, _.baseId, B), L instanceof S.SchemaEnv && (L = L.schema), L === void 0)
+              throw new d.default(_.opts.uriResolver, _.baseId, B);
+          }
+          const K = (h = L?.properties) === null || h === void 0 ? void 0 : h[p];
+          if (typeof K != "object")
+            throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${p}"`);
+          $ = $ && (l || j(L)), C(K, V);
+        }
+        if (!$)
+          throw new Error(`discriminator: "${p}" must be required`);
+        return n;
+        function j({ required: V }) {
+          return Array.isArray(V) && V.includes(p);
+        }
+        function C(V, L) {
+          if (V.const)
+            D(V.const, L);
+          else if (V.enum)
+            for (const K of V.enum)
+              D(K, L);
+          else
+            throw new Error(`discriminator: "properties/${p}" must have "const" or "enum"`);
+        }
+        function D(V, L) {
+          if (typeof V != "string" || V in n)
+            throw new Error(`discriminator: "${p}" values must be unique strings`);
+          n[V] = L;
+        }
+      }
+    }
+  };
+  return ft.default = f, ft;
+}
+const us = "http://json-schema.org/draft-07/schema#", cs = "http://json-schema.org/draft-07/schema#", ls = "Core schema meta-schema", ds = { 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: [] } }, fs = ["object", "boolean"], hs = { $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: "#" } }, ms = {
+  $schema: us,
+  $id: cs,
+  title: ls,
+  definitions: ds,
+  type: fs,
+  properties: hs,
+  default: !0
+};
+var Xr;
+function ps() {
+  return Xr || (Xr = 1, (function(e, r) {
+    Object.defineProperty(r, "__esModule", { value: !0 }), r.MissingRefError = r.ValidationError = r.CodeGen = r.Name = r.nil = r.stringify = r.str = r._ = r.KeywordCxt = r.Ajv = void 0;
+    const S = Nn(), d = as(), g = is(), s = ms, f = ["/properties"], c = "http://json-schema.org/draft-07/schema";
+    class m extends S.default {
+      _addVocabularies() {
+        super._addVocabularies(), d.default.forEach((p) => this.addVocabulary(p)), this.opts.discriminator && this.addKeyword(g.default);
+      }
+      _addDefaultMetaSchema() {
+        if (super._addDefaultMetaSchema(), !this.opts.meta)
+          return;
+        const p = this.opts.$data ? this.$dataMetaSchema(s, f) : s;
+        this.addMetaSchema(p, c, !1), this.refs["http://json-schema.org/schema"] = c;
+      }
+      defaultMeta() {
+        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(c) ? c : void 0);
+      }
+    }
+    r.Ajv = m, e.exports = r = m, e.exports.Ajv = m, Object.defineProperty(r, "__esModule", { value: !0 }), r.default = m;
+    var w = vt();
+    Object.defineProperty(r, "KeywordCxt", { enumerable: !0, get: function() {
+      return w.KeywordCxt;
+    } });
+    var v = J();
+    Object.defineProperty(r, "_", { enumerable: !0, get: function() {
+      return v._;
+    } }), Object.defineProperty(r, "str", { enumerable: !0, get: function() {
+      return v.str;
+    } }), Object.defineProperty(r, "stringify", { enumerable: !0, get: function() {
+      return v.stringify;
+    } }), Object.defineProperty(r, "nil", { enumerable: !0, get: function() {
+      return v.nil;
+    } }), Object.defineProperty(r, "Name", { enumerable: !0, get: function() {
+      return v.Name;
+    } }), Object.defineProperty(r, "CodeGen", { enumerable: !0, get: function() {
+      return v.CodeGen;
+    } });
+    var P = Tt();
+    Object.defineProperty(r, "ValidationError", { enumerable: !0, get: function() {
+      return P.default;
+    } });
+    var _ = _t();
+    Object.defineProperty(r, "MissingRefError", { enumerable: !0, get: function() {
+      return _.default;
+    } });
+  })(Oe, Oe.exports)), Oe.exports;
+}
+var ys = ps();
+const vs = /* @__PURE__ */ ln(ys);
+function qt(e, r, S, d, g) {
+  if (typeof e == "string") {
+    const s = cn(e);
+    s?.op === "component" && S && !S.includes(s.arg) ? g.push(`${r || "/"}: unknown component "${s.arg}"`) : s?.op === "dataSource" && d && !d.includes(s.arg) && g.push(`${r || "/"}: unknown dataSource "${s.arg}"`);
+    return;
+  }
+  if (Array.isArray(e)) {
+    e.forEach(
+      (s, f) => qt(s, `${r}[${f}]`, S, d, g)
+    );
+    return;
+  }
+  if (e !== null && typeof e == "object")
+    for (const [s, f] of Object.entries(e))
+      qt(f, r ? `${r}.${s}` : s, S, d, g);
+}
+function gs(e, r = {}) {
+  const S = r.componentNames ?? (r.registry ? an(r.registry) : void 0), d = r.sourceNames ?? (r.registry ? on(r.registry) : void 0), g = [], f = new vs({ allErrors: !0 }).compile(un);
+  if (!f(e))
+    for (const c of f.errors ?? [])
+      g.push(`${c.instancePath || "/"} ${c.message ?? "invalid"}`.trim());
+  return qt(e, "", S, d, g), { valid: g.length === 0, errors: g };
+}
+export {
+  gs as validateFormSchema
+};