@nsshunt/stsutils 1.15.30 → 1.15.32

package/dist/stsutils.mjs

@@ -1,90 +1,4596 @@
-var t = Object.defineProperty;
-var N = (E, e, o) => e in E ? t(E, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : E[e] = o;
-var n = (E, e, o) => (N(E, typeof e != "symbol" ? e + "" : e, o), o);
-import f from "ajv/dist/jtd";
-function I(E, e = null) {
+var za = Object.defineProperty;
+var Ua = (e, t, r) => t in e ? za(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var Nt = (e, t, r) => (Ua(e, typeof t != "symbol" ? t + "" : t, r), r);
+function $c(e, t = null) {
   return {
-    error: E.code,
-    error_description: E.description,
+    error: e.code,
+    error_description: e.description,
     timestamp: Date.now(),
     //trace_id: "255d1aef-8c98-452f-ac51-23d051240864", //@@
     //correlation_id: "fb3d2015-bc17-4bb9-bb85-30c5cf1aaaa7", //@@
-    details: e
+    details: t
   };
 }
-const i = new f(), T = (E, e) => E(e) ? null : E.errors;
-function g(E, e) {
-  i.addSchema(e, E);
+var Ka = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function La(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
 }
-function S(E, e) {
-  const o = i.getSchema(E);
-  if (o)
-    return T(o, e);
+var ir = {}, Ja = {
+  get exports() {
+    return ir;
+  },
+  set exports(e) {
+    ir = e;
+  }
+}, Mn = {}, Le = {}, Dt = {}, Bt = {}, ne = {}, qt = {};
+(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 t {
+  }
+  e._CodeOrName = t, e.IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
+  class r extends t {
+    constructor(P) {
+      if (super(), !e.IDENTIFIER.test(P))
+        throw new Error("CodeGen: name must be a valid identifier");
+      this.str = P;
+    }
+    toString() {
+      return this.str;
+    }
+    emptyStr() {
+      return !1;
+    }
+    get names() {
+      return { [this.str]: 1 };
+    }
+  }
+  e.Name = r;
+  class n extends t {
+    constructor(P) {
+      super(), this._items = typeof P == "string" ? [P] : P;
+    }
+    toString() {
+      return this.str;
+    }
+    emptyStr() {
+      if (this._items.length > 1)
+        return !1;
+      const P = this._items[0];
+      return P === "" || P === '""';
+    }
+    get str() {
+      var P;
+      return (P = this._str) !== null && P !== void 0 ? P : this._str = this._items.reduce((b, C) => `${b}${C}`, "");
+    }
+    get names() {
+      var P;
+      return (P = this._names) !== null && P !== void 0 ? P : this._names = this._items.reduce((b, C) => (C instanceof r && (b[C.str] = (b[C.str] || 0) + 1), b), {});
+    }
+  }
+  e._Code = n, e.nil = new n("");
+  function a(h, ...P) {
+    const b = [h[0]];
+    let C = 0;
+    for (; C < P.length; )
+      v(b, P[C]), b.push(h[++C]);
+    return new n(b);
+  }
+  e._ = a;
+  const i = new n("+");
+  function d(h, ...P) {
+    const b = [A(h[0])];
+    let C = 0;
+    for (; C < P.length; )
+      b.push(i), v(b, P[C]), b.push(i, A(h[++C]));
+    return g(b), new n(b);
+  }
+  e.str = d;
+  function v(h, P) {
+    P instanceof n ? h.push(...P._items) : P instanceof r ? h.push(P) : h.push(_(P));
+  }
+  e.addCodeArg = v;
+  function g(h) {
+    let P = 1;
+    for (; P < h.length - 1; ) {
+      if (h[P] === i) {
+        const b = p(h[P - 1], h[P + 1]);
+        if (b !== void 0) {
+          h.splice(P - 1, 3, b);
+          continue;
+        }
+        h[P++] = "+";
+      }
+      P++;
+    }
+  }
+  function p(h, P) {
+    if (P === '""')
+      return h;
+    if (h === '""')
+      return P;
+    if (typeof h == "string")
+      return P instanceof r || h[h.length - 1] !== '"' ? void 0 : typeof P != "string" ? `${h.slice(0, -1)}${P}"` : P[0] === '"' ? h.slice(0, -1) + P.slice(1) : void 0;
+    if (typeof P == "string" && P[0] === '"' && !(h instanceof r))
+      return `"${h}${P.slice(1)}`;
+  }
+  function f(h, P) {
+    return P.emptyStr() ? h : h.emptyStr() ? P : d`${h}${P}`;
+  }
+  e.strConcat = f;
+  function _(h) {
+    return typeof h == "number" || typeof h == "boolean" || h === null ? h : A(Array.isArray(h) ? h.join(",") : h);
+  }
+  function D(h) {
+    return new n(A(h));
+  }
+  e.stringify = D;
+  function A(h) {
+    return JSON.stringify(h).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  }
+  e.safeStringify = A;
+  function R(h) {
+    return typeof h == "string" && e.IDENTIFIER.test(h) ? new n(`.${h}`) : a`[${h}]`;
+  }
+  e.getProperty = R;
+  function I(h) {
+    if (typeof h == "string" && e.IDENTIFIER.test(h))
+      return new n(`${h}`);
+    throw new Error(`CodeGen: invalid export name: ${h}, use explicit $id name mapping`);
+  }
+  e.getEsmExportName = I;
+  function j(h) {
+    return new n(h.toString());
+  }
+  e.regexpCode = j;
+})(qt);
+var Sr = {};
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.ValueScope = e.ValueScopeName = e.Scope = e.varKinds = e.UsedValueState = void 0;
+  const t = qt;
+  class r extends Error {
+    constructor(p) {
+      super(`CodeGen: "code" for ${p} not defined`), this.value = p.value;
+    }
+  }
+  var n;
+  (function(g) {
+    g[g.Started = 0] = "Started", g[g.Completed = 1] = "Completed";
+  })(n = e.UsedValueState || (e.UsedValueState = {})), e.varKinds = {
+    const: new t.Name("const"),
+    let: new t.Name("let"),
+    var: new t.Name("var")
+  };
+  class a {
+    constructor({ prefixes: p, parent: f } = {}) {
+      this._names = {}, this._prefixes = p, this._parent = f;
+    }
+    toName(p) {
+      return p instanceof t.Name ? p : this.name(p);
+    }
+    name(p) {
+      return new t.Name(this._newName(p));
+    }
+    _newName(p) {
+      const f = this._names[p] || this._nameGroup(p);
+      return `${p}${f.index++}`;
+    }
+    _nameGroup(p) {
+      var f, _;
+      if (!((_ = (f = this._parent) === null || f === void 0 ? void 0 : f._prefixes) === null || _ === void 0) && _.has(p) || this._prefixes && !this._prefixes.has(p))
+        throw new Error(`CodeGen: prefix "${p}" is not allowed in this scope`);
+      return this._names[p] = { prefix: p, index: 0 };
+    }
+  }
+  e.Scope = a;
+  class i extends t.Name {
+    constructor(p, f) {
+      super(f), this.prefix = p;
+    }
+    setValue(p, { property: f, itemIndex: _ }) {
+      this.value = p, this.scopePath = (0, t._)`.${new t.Name(f)}[${_}]`;
+    }
+  }
+  e.ValueScopeName = i;
+  const d = (0, t._)`\n`;
+  class v extends a {
+    constructor(p) {
+      super(p), this._values = {}, this._scope = p.scope, this.opts = { ...p, _n: p.lines ? d : t.nil };
+    }
+    get() {
+      return this._scope;
+    }
+    name(p) {
+      return new i(p, this._newName(p));
+    }
+    value(p, f) {
+      var _;
+      if (f.ref === void 0)
+        throw new Error("CodeGen: ref must be passed in value");
+      const D = this.toName(p), { prefix: A } = D, R = (_ = f.key) !== null && _ !== void 0 ? _ : f.ref;
+      let I = this._values[A];
+      if (I) {
+        const P = I.get(R);
+        if (P)
+          return P;
+      } else
+        I = this._values[A] = /* @__PURE__ */ new Map();
+      I.set(R, D);
+      const j = this._scope[A] || (this._scope[A] = []), h = j.length;
+      return j[h] = f.ref, D.setValue(f, { property: A, itemIndex: h }), D;
+    }
+    getValue(p, f) {
+      const _ = this._values[p];
+      if (_)
+        return _.get(f);
+    }
+    scopeRefs(p, f = this._values) {
+      return this._reduceValues(f, (_) => {
+        if (_.scopePath === void 0)
+          throw new Error(`CodeGen: name "${_}" has no value`);
+        return (0, t._)`${p}${_.scopePath}`;
+      });
+    }
+    scopeCode(p = this._values, f, _) {
+      return this._reduceValues(p, (D) => {
+        if (D.value === void 0)
+          throw new Error(`CodeGen: name "${D}" has no value`);
+        return D.value.code;
+      }, f, _);
+    }
+    _reduceValues(p, f, _ = {}, D) {
+      let A = t.nil;
+      for (const R in p) {
+        const I = p[R];
+        if (!I)
+          continue;
+        const j = _[R] = _[R] || /* @__PURE__ */ new Map();
+        I.forEach((h) => {
+          if (j.has(h))
+            return;
+          j.set(h, n.Started);
+          let P = f(h);
+          if (P) {
+            const b = this.opts.es5 ? e.varKinds.var : e.varKinds.const;
+            A = (0, t._)`${A}${b} ${h} = ${P};${this.opts._n}`;
+          } else if (P = D == null ? void 0 : D(h))
+            A = (0, t._)`${A}${P}${this.opts._n}`;
+          else
+            throw new r(h);
+          j.set(h, n.Completed);
+        });
+      }
+      return A;
+    }
+  }
+  e.ValueScope = v;
+})(Sr);
+(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 t = qt, r = Sr;
+  var n = qt;
+  Object.defineProperty(e, "_", { enumerable: !0, get: function() {
+    return n._;
+  } }), Object.defineProperty(e, "str", { enumerable: !0, get: function() {
+    return n.str;
+  } }), Object.defineProperty(e, "strConcat", { enumerable: !0, get: function() {
+    return n.strConcat;
+  } }), Object.defineProperty(e, "nil", { enumerable: !0, get: function() {
+    return n.nil;
+  } }), Object.defineProperty(e, "getProperty", { enumerable: !0, get: function() {
+    return n.getProperty;
+  } }), Object.defineProperty(e, "stringify", { enumerable: !0, get: function() {
+    return n.stringify;
+  } }), Object.defineProperty(e, "regexpCode", { enumerable: !0, get: function() {
+    return n.regexpCode;
+  } }), Object.defineProperty(e, "Name", { enumerable: !0, get: function() {
+    return n.Name;
+  } });
+  var a = Sr;
+  Object.defineProperty(e, "Scope", { enumerable: !0, get: function() {
+    return a.Scope;
+  } }), Object.defineProperty(e, "ValueScope", { enumerable: !0, get: function() {
+    return a.ValueScope;
+  } }), Object.defineProperty(e, "ValueScopeName", { enumerable: !0, get: function() {
+    return a.ValueScopeName;
+  } }), Object.defineProperty(e, "varKinds", { enumerable: !0, get: function() {
+    return a.varKinds;
+  } }), e.operators = {
+    GT: new t._Code(">"),
+    GTE: new t._Code(">="),
+    LT: new t._Code("<"),
+    LTE: new t._Code("<="),
+    EQ: new t._Code("==="),
+    NEQ: new t._Code("!=="),
+    NOT: new t._Code("!"),
+    OR: new t._Code("||"),
+    AND: new t._Code("&&"),
+    ADD: new t._Code("+")
+  };
+  class i {
+    optimizeNodes() {
+      return this;
+    }
+    optimizeNames(s, u) {
+      return this;
+    }
+  }
+  class d extends i {
+    constructor(s, u, N) {
+      super(), this.varKind = s, this.name = u, this.rhs = N;
+    }
+    render({ es5: s, _n: u }) {
+      const N = s ? r.varKinds.var : this.varKind, M = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
+      return `${N} ${this.name}${M};` + u;
+    }
+    optimizeNames(s, u) {
+      if (s[this.name.str])
+        return this.rhs && (this.rhs = G(this.rhs, s, u)), this;
+    }
+    get names() {
+      return this.rhs instanceof t._CodeOrName ? this.rhs.names : {};
+    }
+  }
+  class v extends i {
+    constructor(s, u, N) {
+      super(), this.lhs = s, this.rhs = u, this.sideEffects = N;
+    }
+    render({ _n: s }) {
+      return `${this.lhs} = ${this.rhs};` + s;
+    }
+    optimizeNames(s, u) {
+      if (!(this.lhs instanceof t.Name && !s[this.lhs.str] && !this.sideEffects))
+        return this.rhs = G(this.rhs, s, u), this;
+    }
+    get names() {
+      const s = this.lhs instanceof t.Name ? {} : { ...this.lhs.names };
+      return re(s, this.rhs);
+    }
+  }
+  class g extends v {
+    constructor(s, u, N, M) {
+      super(s, N, M), this.op = u;
+    }
+    render({ _n: s }) {
+      return `${this.lhs} ${this.op}= ${this.rhs};` + s;
+    }
+  }
+  class p extends i {
+    constructor(s) {
+      super(), this.label = s, this.names = {};
+    }
+    render({ _n: s }) {
+      return `${this.label}:` + s;
+    }
+  }
+  class f extends i {
+    constructor(s) {
+      super(), this.label = s, this.names = {};
+    }
+    render({ _n: s }) {
+      return `break${this.label ? ` ${this.label}` : ""};` + s;
+    }
+  }
+  class _ extends i {
+    constructor(s) {
+      super(), this.error = s;
+    }
+    render({ _n: s }) {
+      return `throw ${this.error};` + s;
+    }
+    get names() {
+      return this.error.names;
+    }
+  }
+  class D extends i {
+    constructor(s) {
+      super(), this.code = s;
+    }
+    render({ _n: s }) {
+      return `${this.code};` + s;
+    }
+    optimizeNodes() {
+      return `${this.code}` ? this : void 0;
+    }
+    optimizeNames(s, u) {
+      return this.code = G(this.code, s, u), this;
+    }
+    get names() {
+      return this.code instanceof t._CodeOrName ? this.code.names : {};
+    }
+  }
+  class A extends i {
+    constructor(s = []) {
+      super(), this.nodes = s;
+    }
+    render(s) {
+      return this.nodes.reduce((u, N) => u + N.render(s), "");
+    }
+    optimizeNodes() {
+      const { nodes: s } = this;
+      let u = s.length;
+      for (; u--; ) {
+        const N = s[u].optimizeNodes();
+        Array.isArray(N) ? s.splice(u, 1, ...N) : N ? s[u] = N : s.splice(u, 1);
+      }
+      return s.length > 0 ? this : void 0;
+    }
+    optimizeNames(s, u) {
+      const { nodes: N } = this;
+      let M = N.length;
+      for (; M--; ) {
+        const V = N[M];
+        V.optimizeNames(s, u) || (ue(s, V.names), N.splice(M, 1));
+      }
+      return N.length > 0 ? this : void 0;
+    }
+    get names() {
+      return this.nodes.reduce((s, u) => W(s, u.names), {});
+    }
+  }
+  class R extends A {
+    render(s) {
+      return "{" + s._n + super.render(s) + "}" + s._n;
+    }
+  }
+  class I extends A {
+  }
+  class j extends R {
+  }
+  j.kind = "else";
+  class h extends R {
+    constructor(s, u) {
+      super(u), this.condition = s;
+    }
+    render(s) {
+      let u = `if(${this.condition})` + super.render(s);
+      return this.else && (u += "else " + this.else.render(s)), u;
+    }
+    optimizeNodes() {
+      super.optimizeNodes();
+      const s = this.condition;
+      if (s === !0)
+        return this.nodes;
+      let u = this.else;
+      if (u) {
+        const N = u.optimizeNodes();
+        u = this.else = Array.isArray(N) ? new j(N) : N;
+      }
+      if (u)
+        return s === !1 ? u instanceof h ? u : u.nodes : this.nodes.length ? this : new h(fe(s), u instanceof h ? [u] : u.nodes);
+      if (!(s === !1 || !this.nodes.length))
+        return this;
+    }
+    optimizeNames(s, u) {
+      var N;
+      if (this.else = (N = this.else) === null || N === void 0 ? void 0 : N.optimizeNames(s, u), !!(super.optimizeNames(s, u) || this.else))
+        return this.condition = G(this.condition, s, u), this;
+    }
+    get names() {
+      const s = super.names;
+      return re(s, this.condition), this.else && W(s, this.else.names), s;
+    }
+  }
+  h.kind = "if";
+  class P extends R {
+  }
+  P.kind = "for";
+  class b extends P {
+    constructor(s) {
+      super(), this.iteration = s;
+    }
+    render(s) {
+      return `for(${this.iteration})` + super.render(s);
+    }
+    optimizeNames(s, u) {
+      if (super.optimizeNames(s, u))
+        return this.iteration = G(this.iteration, s, u), this;
+    }
+    get names() {
+      return W(super.names, this.iteration.names);
+    }
+  }
+  class C extends P {
+    constructor(s, u, N, M) {
+      super(), this.varKind = s, this.name = u, this.from = N, this.to = M;
+    }
+    render(s) {
+      const u = s.es5 ? r.varKinds.var : this.varKind, { name: N, from: M, to: V } = this;
+      return `for(${u} ${N}=${M}; ${N}<${V}; ${N}++)` + super.render(s);
+    }
+    get names() {
+      const s = re(super.names, this.from);
+      return re(s, this.to);
+    }
+  }
+  class L extends P {
+    constructor(s, u, N, M) {
+      super(), this.loop = s, this.varKind = u, this.name = N, this.iterable = M;
+    }
+    render(s) {
+      return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(s);
+    }
+    optimizeNames(s, u) {
+      if (super.optimizeNames(s, u))
+        return this.iterable = G(this.iterable, s, u), this;
+    }
+    get names() {
+      return W(super.names, this.iterable.names);
+    }
+  }
+  class w extends R {
+    constructor(s, u, N) {
+      super(), this.name = s, this.args = u, this.async = N;
+    }
+    render(s) {
+      return `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render(s);
+    }
+  }
+  w.kind = "func";
+  class S extends A {
+    render(s) {
+      return "return " + super.render(s);
+    }
+  }
+  S.kind = "return";
+  class T extends R {
+    render(s) {
+      let u = "try" + super.render(s);
+      return this.catch && (u += this.catch.render(s)), this.finally && (u += this.finally.render(s)), u;
+    }
+    optimizeNodes() {
+      var s, u;
+      return super.optimizeNodes(), (s = this.catch) === null || s === void 0 || s.optimizeNodes(), (u = this.finally) === null || u === void 0 || u.optimizeNodes(), this;
+    }
+    optimizeNames(s, u) {
+      var N, M;
+      return super.optimizeNames(s, u), (N = this.catch) === null || N === void 0 || N.optimizeNames(s, u), (M = this.finally) === null || M === void 0 || M.optimizeNames(s, u), this;
+    }
+    get names() {
+      const s = super.names;
+      return this.catch && W(s, this.catch.names), this.finally && W(s, this.finally.names), s;
+    }
+  }
+  class J extends R {
+    constructor(s) {
+      super(), this.error = s;
+    }
+    render(s) {
+      return `catch(${this.error})` + super.render(s);
+    }
+  }
+  J.kind = "catch";
+  class B extends R {
+    render(s) {
+      return "finally" + super.render(s);
+    }
+  }
+  B.kind = "finally";
+  class oe {
+    constructor(s, u = {}) {
+      this._values = {}, this._blockStarts = [], this._constants = {}, this.opts = { ...u, _n: u.lines ? `
+` : "" }, this._extScope = s, this._scope = new r.Scope({ parent: s }), this._nodes = [new I()];
+    }
+    toString() {
+      return this._root.render(this.opts);
+    }
+    // returns unique name in the internal scope
+    name(s) {
+      return this._scope.name(s);
+    }
+    // reserves unique name in the external scope
+    scopeName(s) {
+      return this._extScope.name(s);
+    }
+    // reserves unique name in the external scope and assigns value to it
+    scopeValue(s, u) {
+      const N = this._extScope.value(s, u);
+      return (this._values[N.prefix] || (this._values[N.prefix] = /* @__PURE__ */ new Set())).add(N), N;
+    }
+    getScopeValue(s, u) {
+      return this._extScope.getValue(s, u);
+    }
+    // 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(s) {
+      return this._extScope.scopeRefs(s, this._values);
+    }
+    scopeCode() {
+      return this._extScope.scopeCode(this._values);
+    }
+    _def(s, u, N, M) {
+      const V = this._scope.toName(u);
+      return N !== void 0 && M && (this._constants[V.str] = N), this._leafNode(new d(s, V, N)), V;
+    }
+    // `const` declaration (`var` in es5 mode)
+    const(s, u, N) {
+      return this._def(r.varKinds.const, s, u, N);
+    }
+    // `let` declaration with optional assignment (`var` in es5 mode)
+    let(s, u, N) {
+      return this._def(r.varKinds.let, s, u, N);
+    }
+    // `var` declaration with optional assignment
+    var(s, u, N) {
+      return this._def(r.varKinds.var, s, u, N);
+    }
+    // assignment code
+    assign(s, u, N) {
+      return this._leafNode(new v(s, u, N));
+    }
+    // `+=` code
+    add(s, u) {
+      return this._leafNode(new g(s, e.operators.ADD, u));
+    }
+    // appends passed SafeExpr to code or executes Block
+    code(s) {
+      return typeof s == "function" ? s() : s !== t.nil && this._leafNode(new D(s)), this;
+    }
+    // returns code for object literal for the passed argument list of key-value pairs
+    object(...s) {
+      const u = ["{"];
+      for (const [N, M] of s)
+        u.length > 1 && u.push(","), u.push(N), (N !== M || this.opts.es5) && (u.push(":"), (0, t.addCodeArg)(u, M));
+      return u.push("}"), new t._Code(u);
+    }
+    // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
+    if(s, u, N) {
+      if (this._blockNode(new h(s)), u && N)
+        this.code(u).else().code(N).endIf();
+      else if (u)
+        this.code(u).endIf();
+      else if (N)
+        throw new Error('CodeGen: "else" body without "then" body');
+      return this;
+    }
+    // `else if` clause - invalid without `if` or after `else` clauses
+    elseIf(s) {
+      return this._elseNode(new h(s));
+    }
+    // `else` clause - only valid after `if` or `else if` clauses
+    else() {
+      return this._elseNode(new j());
+    }
+    // end `if` statement (needed if gen.if was used only with condition)
+    endIf() {
+      return this._endBlockNode(h, j);
+    }
+    _for(s, u) {
+      return this._blockNode(s), u && this.code(u).endFor(), this;
+    }
+    // a generic `for` clause (or statement if `forBody` is passed)
+    for(s, u) {
+      return this._for(new b(s), u);
+    }
+    // `for` statement for a range of values
+    forRange(s, u, N, M, V = this.opts.es5 ? r.varKinds.var : r.varKinds.let) {
+      const Y = this._scope.toName(s);
+      return this._for(new C(V, Y, u, N), () => M(Y));
+    }
+    // `for-of` statement (in es5 mode replace with a normal for loop)
+    forOf(s, u, N, M = r.varKinds.const) {
+      const V = this._scope.toName(s);
+      if (this.opts.es5) {
+        const Y = u instanceof t.Name ? u : this.var("_arr", u);
+        return this.forRange("_i", 0, (0, t._)`${Y}.length`, (x) => {
+          this.var(V, (0, t._)`${Y}[${x}]`), N(V);
+        });
+      }
+      return this._for(new L("of", M, V, u), () => N(V));
+    }
+    // `for-in` statement.
+    // With option `ownProperties` replaced with a `for-of` loop for object keys
+    forIn(s, u, N, M = this.opts.es5 ? r.varKinds.var : r.varKinds.const) {
+      if (this.opts.ownProperties)
+        return this.forOf(s, (0, t._)`Object.keys(${u})`, N);
+      const V = this._scope.toName(s);
+      return this._for(new L("in", M, V, u), () => N(V));
+    }
+    // end `for` loop
+    endFor() {
+      return this._endBlockNode(P);
+    }
+    // `label` statement
+    label(s) {
+      return this._leafNode(new p(s));
+    }
+    // `break` statement
+    break(s) {
+      return this._leafNode(new f(s));
+    }
+    // `return` statement
+    return(s) {
+      const u = new S();
+      if (this._blockNode(u), this.code(s), u.nodes.length !== 1)
+        throw new Error('CodeGen: "return" should have one node');
+      return this._endBlockNode(S);
+    }
+    // `try` statement
+    try(s, u, N) {
+      if (!u && !N)
+        throw new Error('CodeGen: "try" without "catch" and "finally"');
+      const M = new T();
+      if (this._blockNode(M), this.code(s), u) {
+        const V = this.name("e");
+        this._currNode = M.catch = new J(V), u(V);
+      }
+      return N && (this._currNode = M.finally = new B(), this.code(N)), this._endBlockNode(J, B);
+    }
+    // `throw` statement
+    throw(s) {
+      return this._leafNode(new _(s));
+    }
+    // start self-balancing block
+    block(s, u) {
+      return this._blockStarts.push(this._nodes.length), s && this.code(s).endBlock(u), this;
+    }
+    // end the current self-balancing block
+    endBlock(s) {
+      const u = this._blockStarts.pop();
+      if (u === void 0)
+        throw new Error("CodeGen: not in self-balancing block");
+      const N = this._nodes.length - u;
+      if (N < 0 || s !== void 0 && N !== s)
+        throw new Error(`CodeGen: wrong number of nodes: ${N} vs ${s} expected`);
+      return this._nodes.length = u, this;
+    }
+    // `function` heading (or definition if funcBody is passed)
+    func(s, u = t.nil, N, M) {
+      return this._blockNode(new w(s, u, N)), M && this.code(M).endFunc(), this;
+    }
+    // end function definition
+    endFunc() {
+      return this._endBlockNode(w);
+    }
+    optimize(s = 1) {
+      for (; s-- > 0; )
+        this._root.optimizeNodes(), this._root.optimizeNames(this._root.names, this._constants);
+    }
+    _leafNode(s) {
+      return this._currNode.nodes.push(s), this;
+    }
+    _blockNode(s) {
+      this._currNode.nodes.push(s), this._nodes.push(s);
+    }
+    _endBlockNode(s, u) {
+      const N = this._currNode;
+      if (N instanceof s || u && N instanceof u)
+        return this._nodes.pop(), this;
+      throw new Error(`CodeGen: not in block "${u ? `${s.kind}/${u.kind}` : s.kind}"`);
+    }
+    _elseNode(s) {
+      const u = this._currNode;
+      if (!(u instanceof h))
+        throw new Error('CodeGen: "else" without "if"');
+      return this._currNode = u.else = s, this;
+    }
+    get _root() {
+      return this._nodes[0];
+    }
+    get _currNode() {
+      const s = this._nodes;
+      return s[s.length - 1];
+    }
+    set _currNode(s) {
+      const u = this._nodes;
+      u[u.length - 1] = s;
+    }
+  }
+  e.CodeGen = oe;
+  function W(y, s) {
+    for (const u in s)
+      y[u] = (y[u] || 0) + (s[u] || 0);
+    return y;
+  }
+  function re(y, s) {
+    return s instanceof t._CodeOrName ? W(y, s.names) : y;
+  }
+  function G(y, s, u) {
+    if (y instanceof t.Name)
+      return N(y);
+    if (!M(y))
+      return y;
+    return new t._Code(y._items.reduce((V, Y) => (Y instanceof t.Name && (Y = N(Y)), Y instanceof t._Code ? V.push(...Y._items) : V.push(Y), V), []));
+    function N(V) {
+      const Y = u[V.str];
+      return Y === void 0 || s[V.str] !== 1 ? V : (delete s[V.str], Y);
+    }
+    function M(V) {
+      return V instanceof t._Code && V._items.some((Y) => Y instanceof t.Name && s[Y.str] === 1 && u[Y.str] !== void 0);
+    }
+  }
+  function ue(y, s) {
+    for (const u in s)
+      y[u] = (y[u] || 0) - (s[u] || 0);
+  }
+  function fe(y) {
+    return typeof y == "boolean" || typeof y == "number" || y === null ? !y : (0, t._)`!${O(y)}`;
+  }
+  e.not = fe;
+  const _e = m(e.operators.AND);
+  function $e(...y) {
+    return y.reduce(_e);
+  }
+  e.and = $e;
+  const Ze = m(e.operators.OR);
+  function k(...y) {
+    return y.reduce(Ze);
+  }
+  e.or = k;
+  function m(y) {
+    return (s, u) => s === t.nil ? u : u === t.nil ? s : (0, t._)`${O(s)} ${y} ${O(u)}`;
+  }
+  function O(y) {
+    return y instanceof t.Name ? y : (0, t._)`(${y})`;
+  }
+})(ne);
+var ye = {};
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.checkStrictMode = e.getErrorPath = e.Type = e.useFunc = e.setEvaluated = e.evaluatedPropsToName = e.mergeEvaluated = e.eachItem = e.unescapeJsonPointer = e.escapeJsonPointer = e.escapeFragment = e.unescapeFragment = e.schemaRefOrVal = e.schemaHasRulesButRef = e.schemaHasRules = e.checkUnknownRules = e.alwaysValidSchema = e.toHash = void 0;
+  const t = ne, r = qt;
+  function n(w) {
+    const S = {};
+    for (const T of w)
+      S[T] = !0;
+    return S;
+  }
+  e.toHash = n;
+  function a(w, S) {
+    return typeof S == "boolean" ? S : Object.keys(S).length === 0 ? !0 : (i(w, S), !d(S, w.self.RULES.all));
+  }
+  e.alwaysValidSchema = a;
+  function i(w, S = w.schema) {
+    const { opts: T, self: J } = w;
+    if (!T.strictSchema || typeof S == "boolean")
+      return;
+    const B = J.RULES.keywords;
+    for (const oe in S)
+      B[oe] || L(w, `unknown keyword: "${oe}"`);
+  }
+  e.checkUnknownRules = i;
+  function d(w, S) {
+    if (typeof w == "boolean")
+      return !w;
+    for (const T in w)
+      if (S[T])
+        return !0;
+    return !1;
+  }
+  e.schemaHasRules = d;
+  function v(w, S) {
+    if (typeof w == "boolean")
+      return !w;
+    for (const T in w)
+      if (T !== "$ref" && S.all[T])
+        return !0;
+    return !1;
+  }
+  e.schemaHasRulesButRef = v;
+  function g({ topSchemaRef: w, schemaPath: S }, T, J, B) {
+    if (!B) {
+      if (typeof T == "number" || typeof T == "boolean")
+        return T;
+      if (typeof T == "string")
+        return (0, t._)`${T}`;
+    }
+    return (0, t._)`${w}${S}${(0, t.getProperty)(J)}`;
+  }
+  e.schemaRefOrVal = g;
+  function p(w) {
+    return D(decodeURIComponent(w));
+  }
+  e.unescapeFragment = p;
+  function f(w) {
+    return encodeURIComponent(_(w));
+  }
+  e.escapeFragment = f;
+  function _(w) {
+    return typeof w == "number" ? `${w}` : w.replace(/~/g, "~0").replace(/\//g, "~1");
+  }
+  e.escapeJsonPointer = _;
+  function D(w) {
+    return w.replace(/~1/g, "/").replace(/~0/g, "~");
+  }
+  e.unescapeJsonPointer = D;
+  function A(w, S) {
+    if (Array.isArray(w))
+      for (const T of w)
+        S(T);
+    else
+      S(w);
+  }
+  e.eachItem = A;
+  function R({ mergeNames: w, mergeToName: S, mergeValues: T, resultToName: J }) {
+    return (B, oe, W, re) => {
+      const G = W === void 0 ? oe : W instanceof t.Name ? (oe instanceof t.Name ? w(B, oe, W) : S(B, oe, W), W) : oe instanceof t.Name ? (S(B, W, oe), oe) : T(oe, W);
+      return re === t.Name && !(G instanceof t.Name) ? J(B, G) : G;
+    };
+  }
+  e.mergeEvaluated = {
+    props: R({
+      mergeNames: (w, S, T) => w.if((0, t._)`${T} !== true && ${S} !== undefined`, () => {
+        w.if((0, t._)`${S} === true`, () => w.assign(T, !0), () => w.assign(T, (0, t._)`${T} || {}`).code((0, t._)`Object.assign(${T}, ${S})`));
+      }),
+      mergeToName: (w, S, T) => w.if((0, t._)`${T} !== true`, () => {
+        S === !0 ? w.assign(T, !0) : (w.assign(T, (0, t._)`${T} || {}`), j(w, T, S));
+      }),
+      mergeValues: (w, S) => w === !0 ? !0 : { ...w, ...S },
+      resultToName: I
+    }),
+    items: R({
+      mergeNames: (w, S, T) => w.if((0, t._)`${T} !== true && ${S} !== undefined`, () => w.assign(T, (0, t._)`${S} === true ? true : ${T} > ${S} ? ${T} : ${S}`)),
+      mergeToName: (w, S, T) => w.if((0, t._)`${T} !== true`, () => w.assign(T, S === !0 ? !0 : (0, t._)`${T} > ${S} ? ${T} : ${S}`)),
+      mergeValues: (w, S) => w === !0 ? !0 : Math.max(w, S),
+      resultToName: (w, S) => w.var("items", S)
+    })
+  };
+  function I(w, S) {
+    if (S === !0)
+      return w.var("props", !0);
+    const T = w.var("props", (0, t._)`{}`);
+    return S !== void 0 && j(w, T, S), T;
+  }
+  e.evaluatedPropsToName = I;
+  function j(w, S, T) {
+    Object.keys(T).forEach((J) => w.assign((0, t._)`${S}${(0, t.getProperty)(J)}`, !0));
+  }
+  e.setEvaluated = j;
+  const h = {};
+  function P(w, S) {
+    return w.scopeValue("func", {
+      ref: S,
+      code: h[S.code] || (h[S.code] = new r._Code(S.code))
+    });
+  }
+  e.useFunc = P;
+  var b;
+  (function(w) {
+    w[w.Num = 0] = "Num", w[w.Str = 1] = "Str";
+  })(b = e.Type || (e.Type = {}));
+  function C(w, S, T) {
+    if (w instanceof t.Name) {
+      const J = S === b.Num;
+      return T ? J ? (0, t._)`"[" + ${w} + "]"` : (0, t._)`"['" + ${w} + "']"` : J ? (0, t._)`"/" + ${w}` : (0, t._)`"/" + ${w}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+    }
+    return T ? (0, t.getProperty)(w).toString() : "/" + _(w);
+  }
+  e.getErrorPath = C;
+  function L(w, S, T = w.opts.strictSchema) {
+    if (T) {
+      if (S = `strict mode: ${S}`, T === !0)
+        throw new Error(S);
+      w.self.logger.warn(S);
+    }
+  }
+  e.checkStrictMode = L;
+})(ye);
+var De = {};
+Object.defineProperty(De, "__esModule", { value: !0 });
+const Ee = ne, qa = {
+  // validation function arguments
+  data: new Ee.Name("data"),
+  // args passed from referencing schema
+  valCxt: new Ee.Name("valCxt"),
+  instancePath: new Ee.Name("instancePath"),
+  parentData: new Ee.Name("parentData"),
+  parentDataProperty: new Ee.Name("parentDataProperty"),
+  rootData: new Ee.Name("rootData"),
+  dynamicAnchors: new Ee.Name("dynamicAnchors"),
+  // function scoped variables
+  vErrors: new Ee.Name("vErrors"),
+  errors: new Ee.Name("errors"),
+  this: new Ee.Name("this"),
+  // "globals"
+  self: new Ee.Name("self"),
+  scope: new Ee.Name("scope"),
+  // JTD serialize/parse name for JSON string and position
+  json: new Ee.Name("json"),
+  jsonPos: new Ee.Name("jsonPos"),
+  jsonLen: new Ee.Name("jsonLen"),
+  jsonPart: new Ee.Name("jsonPart")
+};
+De.default = qa;
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.extendErrors = e.resetErrorsCount = e.reportExtraError = e.reportError = e.keyword$DataError = e.keywordError = void 0;
+  const t = ne, r = ye, n = De;
+  e.keywordError = {
+    message: ({ keyword: j }) => (0, t.str)`must pass "${j}" keyword validation`
+  }, e.keyword$DataError = {
+    message: ({ keyword: j, schemaType: h }) => h ? (0, t.str)`"${j}" keyword must be ${h} ($data)` : (0, t.str)`"${j}" keyword is invalid ($data)`
+  };
+  function a(j, h = e.keywordError, P, b) {
+    const { it: C } = j, { gen: L, compositeRule: w, allErrors: S } = C, T = _(j, h, P);
+    b ?? (w || S) ? g(L, T) : p(C, (0, t._)`[${T}]`);
+  }
+  e.reportError = a;
+  function i(j, h = e.keywordError, P) {
+    const { it: b } = j, { gen: C, compositeRule: L, allErrors: w } = b, S = _(j, h, P);
+    g(C, S), L || w || p(b, n.default.vErrors);
+  }
+  e.reportExtraError = i;
+  function d(j, h) {
+    j.assign(n.default.errors, h), j.if((0, t._)`${n.default.vErrors} !== null`, () => j.if(h, () => j.assign((0, t._)`${n.default.vErrors}.length`, h), () => j.assign(n.default.vErrors, null)));
+  }
+  e.resetErrorsCount = d;
+  function v({ gen: j, keyword: h, schemaValue: P, data: b, errsCount: C, it: L }) {
+    if (C === void 0)
+      throw new Error("ajv implementation error");
+    const w = j.name("err");
+    j.forRange("i", C, n.default.errors, (S) => {
+      j.const(w, (0, t._)`${n.default.vErrors}[${S}]`), j.if((0, t._)`${w}.instancePath === undefined`, () => j.assign((0, t._)`${w}.instancePath`, (0, t.strConcat)(n.default.instancePath, L.errorPath))), j.assign((0, t._)`${w}.schemaPath`, (0, t.str)`${L.errSchemaPath}/${h}`), L.opts.verbose && (j.assign((0, t._)`${w}.schema`, P), j.assign((0, t._)`${w}.data`, b));
+    });
+  }
+  e.extendErrors = v;
+  function g(j, h) {
+    const P = j.const("err", h);
+    j.if((0, t._)`${n.default.vErrors} === null`, () => j.assign(n.default.vErrors, (0, t._)`[${P}]`), (0, t._)`${n.default.vErrors}.push(${P})`), j.code((0, t._)`${n.default.errors}++`);
+  }
+  function p(j, h) {
+    const { gen: P, validateName: b, schemaEnv: C } = j;
+    C.$async ? P.throw((0, t._)`new ${j.ValidationError}(${h})`) : (P.assign((0, t._)`${b}.errors`, h), P.return(!1));
+  }
+  const f = {
+    keyword: new t.Name("keyword"),
+    schemaPath: new t.Name("schemaPath"),
+    params: new t.Name("params"),
+    propertyName: new t.Name("propertyName"),
+    message: new t.Name("message"),
+    schema: new t.Name("schema"),
+    parentSchema: new t.Name("parentSchema")
+  };
+  function _(j, h, P) {
+    const { createErrors: b } = j.it;
+    return b === !1 ? (0, t._)`{}` : D(j, h, P);
+  }
+  function D(j, h, P = {}) {
+    const { gen: b, it: C } = j, L = [
+      A(C, P),
+      R(j, P)
+    ];
+    return I(j, h, L), b.object(...L);
+  }
+  function A({ errorPath: j }, { instancePath: h }) {
+    const P = h ? (0, t.str)`${j}${(0, r.getErrorPath)(h, r.Type.Str)}` : j;
+    return [n.default.instancePath, (0, t.strConcat)(n.default.instancePath, P)];
+  }
+  function R({ keyword: j, it: { errSchemaPath: h } }, { schemaPath: P, parentSchema: b }) {
+    let C = b ? h : (0, t.str)`${h}/${j}`;
+    return P && (C = (0, t.str)`${C}${(0, r.getErrorPath)(P, r.Type.Str)}`), [f.schemaPath, C];
+  }
+  function I(j, { params: h, message: P }, b) {
+    const { keyword: C, data: L, schemaValue: w, it: S } = j, { opts: T, propertyName: J, topSchemaRef: B, schemaPath: oe } = S;
+    b.push([f.keyword, C], [f.params, typeof h == "function" ? h(j) : h || (0, t._)`{}`]), T.messages && b.push([f.message, typeof P == "function" ? P(j) : P]), T.verbose && b.push([f.schema, w], [f.parentSchema, (0, t._)`${B}${oe}`], [n.default.data, L]), J && b.push([f.propertyName, J]);
+  }
+})(Bt);
+Object.defineProperty(Dt, "__esModule", { value: !0 });
+Dt.boolOrEmptySchema = Dt.topBoolOrEmptySchema = void 0;
+const Ha = Bt, Ga = ne, Ba = De, Wa = {
+  message: "boolean schema is false"
+};
+function Qa(e) {
+  const { gen: t, schema: r, validateName: n } = e;
+  r === !1 ? Vn(e, !1) : typeof r == "object" && r.$async === !0 ? t.return(Ba.default.data) : (t.assign((0, Ga._)`${n}.errors`, null), t.return(!0));
+}
+Dt.topBoolOrEmptySchema = Qa;
+function Ya(e, t) {
+  const { gen: r, schema: n } = e;
+  n === !1 ? (r.var(t, !1), Vn(e)) : r.var(t, !0);
+}
+Dt.boolOrEmptySchema = Ya;
+function Vn(e, t) {
+  const { gen: r, data: n } = e, a = {
+    gen: r,
+    keyword: "false schema",
+    data: n,
+    schema: !1,
+    schemaCode: !1,
+    schemaValue: !1,
+    params: {},
+    it: e
+  };
+  (0, Ha.reportError)(a, Wa, void 0, t);
+}
+var lr = {}, mt = {};
+Object.defineProperty(mt, "__esModule", { value: !0 });
+mt.getRules = mt.isJSONType = void 0;
+const Xa = ["string", "number", "integer", "boolean", "null", "object", "array"], Za = new Set(Xa);
+function xa(e) {
+  return typeof e == "string" && Za.has(e);
+}
+mt.isJSONType = xa;
+function es() {
+  const e = {
+    number: { type: "number", rules: [] },
+    string: { type: "string", rules: [] },
+    array: { type: "array", rules: [] },
+    object: { type: "object", rules: [] }
+  };
+  return {
+    types: { ...e, integer: !0, boolean: !0, null: !0 },
+    rules: [{ rules: [] }, e.number, e.string, e.array, e.object],
+    post: { rules: [] },
+    all: {},
+    keywords: {}
+  };
+}
+mt.getRules = es;
+var We = {};
+Object.defineProperty(We, "__esModule", { value: !0 });
+We.shouldUseRule = We.shouldUseGroup = We.schemaHasRulesForType = void 0;
+function ts({ schema: e, self: t }, r) {
+  const n = t.RULES.types[r];
+  return n && n !== !0 && Fn(e, n);
+}
+We.schemaHasRulesForType = ts;
+function Fn(e, t) {
+  return t.rules.some((r) => zn(e, r));
+}
+We.shouldUseGroup = Fn;
+function zn(e, t) {
+  var r;
+  return e[t.keyword] !== void 0 || ((r = t.definition.implements) === null || r === void 0 ? void 0 : r.some((n) => e[n] !== void 0));
+}
+We.shouldUseRule = zn;
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.reportTypeError = e.checkDataTypes = e.checkDataType = e.coerceAndCheckDataType = e.getJSONTypes = e.getSchemaTypes = e.DataType = void 0;
+  const t = mt, r = We, n = Bt, a = ne, i = ye;
+  var d;
+  (function(b) {
+    b[b.Correct = 0] = "Correct", b[b.Wrong = 1] = "Wrong";
+  })(d = e.DataType || (e.DataType = {}));
+  function v(b) {
+    const C = g(b.type);
+    if (C.includes("null")) {
+      if (b.nullable === !1)
+        throw new Error("type: null contradicts nullable: false");
+    } else {
+      if (!C.length && b.nullable !== void 0)
+        throw new Error('"nullable" cannot be used without "type"');
+      b.nullable === !0 && C.push("null");
+    }
+    return C;
+  }
+  e.getSchemaTypes = v;
+  function g(b) {
+    const C = Array.isArray(b) ? b : b ? [b] : [];
+    if (C.every(t.isJSONType))
+      return C;
+    throw new Error("type must be JSONType or JSONType[]: " + C.join(","));
+  }
+  e.getJSONTypes = g;
+  function p(b, C) {
+    const { gen: L, data: w, opts: S } = b, T = _(C, S.coerceTypes), J = C.length > 0 && !(T.length === 0 && C.length === 1 && (0, r.schemaHasRulesForType)(b, C[0]));
+    if (J) {
+      const B = I(C, w, S.strictNumbers, d.Wrong);
+      L.if(B, () => {
+        T.length ? D(b, C, T) : h(b);
+      });
+    }
+    return J;
+  }
+  e.coerceAndCheckDataType = p;
+  const f = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
+  function _(b, C) {
+    return C ? b.filter((L) => f.has(L) || C === "array" && L === "array") : [];
+  }
+  function D(b, C, L) {
+    const { gen: w, data: S, opts: T } = b, J = w.let("dataType", (0, a._)`typeof ${S}`), B = w.let("coerced", (0, a._)`undefined`);
+    T.coerceTypes === "array" && w.if((0, a._)`${J} == 'object' && Array.isArray(${S}) && ${S}.length == 1`, () => w.assign(S, (0, a._)`${S}[0]`).assign(J, (0, a._)`typeof ${S}`).if(I(C, S, T.strictNumbers), () => w.assign(B, S))), w.if((0, a._)`${B} !== undefined`);
+    for (const W of L)
+      (f.has(W) || W === "array" && T.coerceTypes === "array") && oe(W);
+    w.else(), h(b), w.endIf(), w.if((0, a._)`${B} !== undefined`, () => {
+      w.assign(S, B), A(b, B);
+    });
+    function oe(W) {
+      switch (W) {
+        case "string":
+          w.elseIf((0, a._)`${J} == "number" || ${J} == "boolean"`).assign(B, (0, a._)`"" + ${S}`).elseIf((0, a._)`${S} === null`).assign(B, (0, a._)`""`);
+          return;
+        case "number":
+          w.elseIf((0, a._)`${J} == "boolean" || ${S} === null
+              || (${J} == "string" && ${S} && ${S} == +${S})`).assign(B, (0, a._)`+${S}`);
+          return;
+        case "integer":
+          w.elseIf((0, a._)`${J} === "boolean" || ${S} === null
+              || (${J} === "string" && ${S} && ${S} == +${S} && !(${S} % 1))`).assign(B, (0, a._)`+${S}`);
+          return;
+        case "boolean":
+          w.elseIf((0, a._)`${S} === "false" || ${S} === 0 || ${S} === null`).assign(B, !1).elseIf((0, a._)`${S} === "true" || ${S} === 1`).assign(B, !0);
+          return;
+        case "null":
+          w.elseIf((0, a._)`${S} === "" || ${S} === 0 || ${S} === false`), w.assign(B, null);
+          return;
+        case "array":
+          w.elseIf((0, a._)`${J} === "string" || ${J} === "number"
+              || ${J} === "boolean" || ${S} === null`).assign(B, (0, a._)`[${S}]`);
+      }
+    }
+  }
+  function A({ gen: b, parentData: C, parentDataProperty: L }, w) {
+    b.if((0, a._)`${C} !== undefined`, () => b.assign((0, a._)`${C}[${L}]`, w));
+  }
+  function R(b, C, L, w = d.Correct) {
+    const S = w === d.Correct ? a.operators.EQ : a.operators.NEQ;
+    let T;
+    switch (b) {
+      case "null":
+        return (0, a._)`${C} ${S} null`;
+      case "array":
+        T = (0, a._)`Array.isArray(${C})`;
+        break;
+      case "object":
+        T = (0, a._)`${C} && typeof ${C} == "object" && !Array.isArray(${C})`;
+        break;
+      case "integer":
+        T = J((0, a._)`!(${C} % 1) && !isNaN(${C})`);
+        break;
+      case "number":
+        T = J();
+        break;
+      default:
+        return (0, a._)`typeof ${C} ${S} ${b}`;
+    }
+    return w === d.Correct ? T : (0, a.not)(T);
+    function J(B = a.nil) {
+      return (0, a.and)((0, a._)`typeof ${C} == "number"`, B, L ? (0, a._)`isFinite(${C})` : a.nil);
+    }
+  }
+  e.checkDataType = R;
+  function I(b, C, L, w) {
+    if (b.length === 1)
+      return R(b[0], C, L, w);
+    let S;
+    const T = (0, i.toHash)(b);
+    if (T.array && T.object) {
+      const J = (0, a._)`typeof ${C} != "object"`;
+      S = T.null ? J : (0, a._)`!${C} || ${J}`, delete T.null, delete T.array, delete T.object;
+    } else
+      S = a.nil;
+    T.number && delete T.integer;
+    for (const J in T)
+      S = (0, a.and)(S, R(J, C, L, w));
+    return S;
+  }
+  e.checkDataTypes = I;
+  const j = {
+    message: ({ schema: b }) => `must be ${b}`,
+    params: ({ schema: b, schemaValue: C }) => typeof b == "string" ? (0, a._)`{type: ${b}}` : (0, a._)`{type: ${C}}`
+  };
+  function h(b) {
+    const C = P(b);
+    (0, n.reportError)(C, j);
+  }
+  e.reportTypeError = h;
+  function P(b) {
+    const { gen: C, data: L, schema: w } = b, S = (0, i.schemaRefOrVal)(b, w, "type");
+    return {
+      gen: C,
+      keyword: "type",
+      data: L,
+      schema: w.type,
+      schemaCode: S,
+      schemaValue: S,
+      parentSchema: w,
+      params: {},
+      it: b
+    };
+  }
+})(lr);
+var dr = {};
+Object.defineProperty(dr, "__esModule", { value: !0 });
+dr.assignDefaults = void 0;
+const Rt = ne, rs = ye;
+function ns(e, t) {
+  const { properties: r, items: n } = e.schema;
+  if (t === "object" && r)
+    for (const a in r)
+      hn(e, a, r[a].default);
+  else
+    t === "array" && Array.isArray(n) && n.forEach((a, i) => hn(e, i, a.default));
+}
+dr.assignDefaults = ns;
+function hn(e, t, r) {
+  const { gen: n, compositeRule: a, data: i, opts: d } = e;
+  if (r === void 0)
+    return;
+  const v = (0, Rt._)`${i}${(0, Rt.getProperty)(t)}`;
+  if (a) {
+    (0, rs.checkStrictMode)(e, `default is ignored for: ${v}`);
+    return;
+  }
+  let g = (0, Rt._)`${v} === undefined`;
+  d.useDefaults === "empty" && (g = (0, Rt._)`${g} || ${v} === null || ${v} === ""`), n.if(g, (0, Rt._)`${v} = ${(0, Rt.stringify)(r)}`);
+}
+var Ke = {}, te = {};
+Object.defineProperty(te, "__esModule", { value: !0 });
+te.validateUnion = te.validateArray = te.usePattern = te.callValidateCode = te.schemaProperties = te.allSchemaProperties = te.noPropertyInData = te.propertyInData = te.isOwnProperty = te.hasPropFunc = te.reportMissingProp = te.checkMissingProp = te.checkReportMissingProp = void 0;
+const ce = ne, Rr = ye, et = De, as = ye;
+function ss(e, t) {
+  const { gen: r, data: n, it: a } = e;
+  r.if(Or(r, n, t, a.opts.ownProperties), () => {
+    e.setParams({ missingProperty: (0, ce._)`${t}` }, !0), e.error();
+  });
+}
+te.checkReportMissingProp = ss;
+function os({ gen: e, data: t, it: { opts: r } }, n, a) {
+  return (0, ce.or)(...n.map((i) => (0, ce.and)(Or(e, t, i, r.ownProperties), (0, ce._)`${a} = ${i}`)));
+}
+te.checkMissingProp = os;
+function is(e, t) {
+  e.setParams({ missingProperty: t }, !0), e.error();
+}
+te.reportMissingProp = is;
+function Un(e) {
+  return e.scopeValue("func", {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    ref: Object.prototype.hasOwnProperty,
+    code: (0, ce._)`Object.prototype.hasOwnProperty`
+  });
+}
+te.hasPropFunc = Un;
+function jr(e, t, r) {
+  return (0, ce._)`${Un(e)}.call(${t}, ${r})`;
+}
+te.isOwnProperty = jr;
+function cs(e, t, r, n) {
+  const a = (0, ce._)`${t}${(0, ce.getProperty)(r)} !== undefined`;
+  return n ? (0, ce._)`${a} && ${jr(e, t, r)}` : a;
+}
+te.propertyInData = cs;
+function Or(e, t, r, n) {
+  const a = (0, ce._)`${t}${(0, ce.getProperty)(r)} === undefined`;
+  return n ? (0, ce.or)(a, (0, ce.not)(jr(e, t, r))) : a;
+}
+te.noPropertyInData = Or;
+function Kn(e) {
+  return e ? Object.keys(e).filter((t) => t !== "__proto__") : [];
+}
+te.allSchemaProperties = Kn;
+function us(e, t) {
+  return Kn(t).filter((r) => !(0, Rr.alwaysValidSchema)(e, t[r]));
+}
+te.schemaProperties = us;
+function ls({ schemaCode: e, data: t, it: { gen: r, topSchemaRef: n, schemaPath: a, errorPath: i }, it: d }, v, g, p) {
+  const f = p ? (0, ce._)`${e}, ${t}, ${n}${a}` : t, _ = [
+    [et.default.instancePath, (0, ce.strConcat)(et.default.instancePath, i)],
+    [et.default.parentData, d.parentData],
+    [et.default.parentDataProperty, d.parentDataProperty],
+    [et.default.rootData, et.default.rootData]
+  ];
+  d.opts.dynamicRef && _.push([et.default.dynamicAnchors, et.default.dynamicAnchors]);
+  const D = (0, ce._)`${f}, ${r.object(..._)}`;
+  return g !== ce.nil ? (0, ce._)`${v}.call(${g}, ${D})` : (0, ce._)`${v}(${D})`;
+}
+te.callValidateCode = ls;
+const ds = (0, ce._)`new RegExp`;
+function fs({ gen: e, it: { opts: t } }, r) {
+  const n = t.unicodeRegExp ? "u" : "", { regExp: a } = t.code, i = a(r, n);
+  return e.scopeValue("pattern", {
+    key: i.toString(),
+    ref: i,
+    code: (0, ce._)`${a.code === "new RegExp" ? ds : (0, as.useFunc)(e, a)}(${r}, ${n})`
+  });
+}
+te.usePattern = fs;
+function hs(e) {
+  const { gen: t, data: r, keyword: n, it: a } = e, i = t.name("valid");
+  if (a.allErrors) {
+    const v = t.let("valid", !0);
+    return d(() => t.assign(v, !1)), v;
+  }
+  return t.var(i, !0), d(() => t.break()), i;
+  function d(v) {
+    const g = t.const("len", (0, ce._)`${r}.length`);
+    t.forRange("i", 0, g, (p) => {
+      e.subschema({
+        keyword: n,
+        dataProp: p,
+        dataPropType: Rr.Type.Num
+      }, i), t.if((0, ce.not)(i), v);
+    });
+  }
+}
+te.validateArray = hs;
+function ps(e) {
+  const { gen: t, schema: r, keyword: n, it: a } = e;
+  if (!Array.isArray(r))
+    throw new Error("ajv implementation error");
+  if (r.some((g) => (0, Rr.alwaysValidSchema)(a, g)) && !a.opts.unevaluated)
+    return;
+  const d = t.let("valid", !1), v = t.name("_valid");
+  t.block(() => r.forEach((g, p) => {
+    const f = e.subschema({
+      keyword: n,
+      schemaProp: p,
+      compositeRule: !0
+    }, v);
+    t.assign(d, (0, ce._)`${d} || ${v}`), e.mergeValidEvaluated(f, v) || t.if((0, ce.not)(d));
+  })), e.result(d, () => e.reset(), () => e.error(!0));
+}
+te.validateUnion = ps;
+Object.defineProperty(Ke, "__esModule", { value: !0 });
+Ke.validateKeywordUsage = Ke.validSchemaType = Ke.funcKeywordCode = Ke.macroKeywordCode = void 0;
+const Se = ne, ht = De, ms = te, vs = Bt;
+function _s(e, t) {
+  const { gen: r, keyword: n, schema: a, parentSchema: i, it: d } = e, v = t.macro.call(d.self, a, i, d), g = Ln(r, n, v);
+  d.opts.validateSchema !== !1 && d.self.validateSchema(v, !0);
+  const p = r.name("valid");
+  e.subschema({
+    schema: v,
+    schemaPath: Se.nil,
+    errSchemaPath: `${d.errSchemaPath}/${n}`,
+    topSchemaRef: g,
+    compositeRule: !0
+  }, p), e.pass(p, () => e.error(!0));
+}
+Ke.macroKeywordCode = _s;
+function ys(e, t) {
+  var r;
+  const { gen: n, keyword: a, schema: i, parentSchema: d, $data: v, it: g } = e;
+  $s(g, t);
+  const p = !v && t.compile ? t.compile.call(g.self, i, d, g) : t.validate, f = Ln(n, a, p), _ = n.let("valid");
+  e.block$data(_, D), e.ok((r = t.valid) !== null && r !== void 0 ? r : _);
+  function D() {
+    if (t.errors === !1)
+      I(), t.modifying && pn(e), j(() => e.error());
+    else {
+      const h = t.async ? A() : R();
+      t.modifying && pn(e), j(() => gs(e, h));
+    }
+  }
+  function A() {
+    const h = n.let("ruleErrs", null);
+    return n.try(() => I((0, Se._)`await `), (P) => n.assign(_, !1).if((0, Se._)`${P} instanceof ${g.ValidationError}`, () => n.assign(h, (0, Se._)`${P}.errors`), () => n.throw(P))), h;
+  }
+  function R() {
+    const h = (0, Se._)`${f}.errors`;
+    return n.assign(h, null), I(Se.nil), h;
+  }
+  function I(h = t.async ? (0, Se._)`await ` : Se.nil) {
+    const P = g.opts.passContext ? ht.default.this : ht.default.self, b = !("compile" in t && !v || t.schema === !1);
+    n.assign(_, (0, Se._)`${h}${(0, ms.callValidateCode)(e, f, P, b)}`, t.modifying);
+  }
+  function j(h) {
+    var P;
+    n.if((0, Se.not)((P = t.valid) !== null && P !== void 0 ? P : _), h);
+  }
+}
+Ke.funcKeywordCode = ys;
+function pn(e) {
+  const { gen: t, data: r, it: n } = e;
+  t.if(n.parentData, () => t.assign(r, (0, Se._)`${n.parentData}[${n.parentDataProperty}]`));
+}
+function gs(e, t) {
+  const { gen: r } = e;
+  r.if((0, Se._)`Array.isArray(${t})`, () => {
+    r.assign(ht.default.vErrors, (0, Se._)`${ht.default.vErrors} === null ? ${t} : ${ht.default.vErrors}.concat(${t})`).assign(ht.default.errors, (0, Se._)`${ht.default.vErrors}.length`), (0, vs.extendErrors)(e);
+  }, () => e.error());
+}
+function $s({ schemaEnv: e }, t) {
+  if (t.async && !e.$async)
+    throw new Error("async keyword in sync schema");
+}
+function Ln(e, t, r) {
+  if (r === void 0)
+    throw new Error(`keyword "${t}" failed to compile`);
+  return e.scopeValue("keyword", typeof r == "function" ? { ref: r } : { ref: r, code: (0, Se.stringify)(r) });
+}
+function Es(e, t, r = !1) {
+  return !t.length || t.some((n) => n === "array" ? Array.isArray(e) : n === "object" ? e && typeof e == "object" && !Array.isArray(e) : typeof e == n || r && typeof e > "u");
+}
+Ke.validSchemaType = Es;
+function ws({ schema: e, opts: t, self: r, errSchemaPath: n }, a, i) {
+  if (Array.isArray(a.keyword) ? !a.keyword.includes(i) : a.keyword !== i)
+    throw new Error("ajv implementation error");
+  const d = a.dependencies;
+  if (d != null && d.some((v) => !Object.prototype.hasOwnProperty.call(e, v)))
+    throw new Error(`parent schema must have dependencies of ${i}: ${d.join(",")}`);
+  if (a.validateSchema && !a.validateSchema(e[i])) {
+    const g = `keyword "${i}" value is invalid at path "${n}": ` + r.errorsText(a.validateSchema.errors);
+    if (t.validateSchema === "log")
+      r.logger.error(g);
+    else
+      throw new Error(g);
+  }
+}
+Ke.validateKeywordUsage = ws;
+var at = {};
+Object.defineProperty(at, "__esModule", { value: !0 });
+at.extendSubschemaMode = at.extendSubschemaData = at.getSubschema = void 0;
+const Ue = ne, Jn = ye;
+function Ss(e, { keyword: t, schemaProp: r, schema: n, schemaPath: a, errSchemaPath: i, topSchemaRef: d }) {
+  if (t !== void 0 && n !== void 0)
+    throw new Error('both "keyword" and "schema" passed, only one allowed');
+  if (t !== void 0) {
+    const v = e.schema[t];
+    return r === void 0 ? {
+      schema: v,
+      schemaPath: (0, Ue._)`${e.schemaPath}${(0, Ue.getProperty)(t)}`,
+      errSchemaPath: `${e.errSchemaPath}/${t}`
+    } : {
+      schema: v[r],
+      schemaPath: (0, Ue._)`${e.schemaPath}${(0, Ue.getProperty)(t)}${(0, Ue.getProperty)(r)}`,
+      errSchemaPath: `${e.errSchemaPath}/${t}/${(0, Jn.escapeFragment)(r)}`
+    };
+  }
+  if (n !== void 0) {
+    if (a === void 0 || i === void 0 || d === void 0)
+      throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
+    return {
+      schema: n,
+      schemaPath: a,
+      topSchemaRef: d,
+      errSchemaPath: i
+    };
+  }
+  throw new Error('either "keyword" or "schema" must be passed');
+}
+at.getSubschema = Ss;
+function bs(e, t, { dataProp: r, dataPropType: n, data: a, dataTypes: i, propertyName: d }) {
+  if (a !== void 0 && r !== void 0)
+    throw new Error('both "data" and "dataProp" passed, only one allowed');
+  const { gen: v } = t;
+  if (r !== void 0) {
+    const { errorPath: p, dataPathArr: f, opts: _ } = t, D = v.let("data", (0, Ue._)`${t.data}${(0, Ue.getProperty)(r)}`, !0);
+    g(D), e.errorPath = (0, Ue.str)`${p}${(0, Jn.getErrorPath)(r, n, _.jsPropertySyntax)}`, e.parentDataProperty = (0, Ue._)`${r}`, e.dataPathArr = [...f, e.parentDataProperty];
+  }
+  if (a !== void 0) {
+    const p = a instanceof Ue.Name ? a : v.let("data", a, !0);
+    g(p), d !== void 0 && (e.propertyName = d);
+  }
+  i && (e.dataTypes = i);
+  function g(p) {
+    e.data = p, e.dataLevel = t.dataLevel + 1, e.dataTypes = [], t.definedProperties = /* @__PURE__ */ new Set(), e.parentData = t.data, e.dataNames = [...t.dataNames, p];
+  }
+}
+at.extendSubschemaData = bs;
+function Ps(e, { jtdDiscriminator: t, jtdMetadata: r, compositeRule: n, createErrors: a, allErrors: i }) {
+  n !== void 0 && (e.compositeRule = n), a !== void 0 && (e.createErrors = a), i !== void 0 && (e.allErrors = i), e.jtdDiscriminator = t, e.jtdMetadata = r;
+}
+at.extendSubschemaMode = Ps;
+var ge = {}, Ns = function e(t, r) {
+  if (t === r)
+    return !0;
+  if (t && r && typeof t == "object" && typeof r == "object") {
+    if (t.constructor !== r.constructor)
+      return !1;
+    var n, a, i;
+    if (Array.isArray(t)) {
+      if (n = t.length, n != r.length)
+        return !1;
+      for (a = n; a-- !== 0; )
+        if (!e(t[a], r[a]))
+          return !1;
+      return !0;
+    }
+    if (t.constructor === RegExp)
+      return t.source === r.source && t.flags === r.flags;
+    if (t.valueOf !== Object.prototype.valueOf)
+      return t.valueOf() === r.valueOf();
+    if (t.toString !== Object.prototype.toString)
+      return t.toString() === r.toString();
+    if (i = Object.keys(t), n = i.length, n !== Object.keys(r).length)
+      return !1;
+    for (a = n; a-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(r, i[a]))
+        return !1;
+    for (a = n; a-- !== 0; ) {
+      var d = i[a];
+      if (!e(t[d], r[d]))
+        return !1;
+    }
+    return !0;
+  }
+  return t !== t && r !== r;
+}, br = {}, Rs = {
+  get exports() {
+    return br;
+  },
+  set exports(e) {
+    br = e;
+  }
+}, rt = Rs.exports = function(e, t, r) {
+  typeof t == "function" && (r = t, t = {}), r = t.cb || r;
+  var n = typeof r == "function" ? r : r.pre || function() {
+  }, a = r.post || function() {
+  };
+  nr(t, n, a, e, "", e);
+};
+rt.keywords = {
+  additionalItems: !0,
+  items: !0,
+  contains: !0,
+  additionalProperties: !0,
+  propertyNames: !0,
+  not: !0,
+  if: !0,
+  then: !0,
+  else: !0
+};
+rt.arrayKeywords = {
+  items: !0,
+  allOf: !0,
+  anyOf: !0,
+  oneOf: !0
+};
+rt.propsKeywords = {
+  $defs: !0,
+  definitions: !0,
+  properties: !0,
+  patternProperties: !0,
+  dependencies: !0
+};
+rt.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 nr(e, t, r, n, a, i, d, v, g, p) {
+  if (n && typeof n == "object" && !Array.isArray(n)) {
+    t(n, a, i, d, v, g, p);
+    for (var f in n) {
+      var _ = n[f];
+      if (Array.isArray(_)) {
+        if (f in rt.arrayKeywords)
+          for (var D = 0; D < _.length; D++)
+            nr(e, t, r, _[D], a + "/" + f + "/" + D, i, a, f, n, D);
+      } else if (f in rt.propsKeywords) {
+        if (_ && typeof _ == "object")
+          for (var A in _)
+            nr(e, t, r, _[A], a + "/" + f + "/" + js(A), i, a, f, n, A);
+      } else
+        (f in rt.keywords || e.allKeys && !(f in rt.skipKeywords)) && nr(e, t, r, _, a + "/" + f, i, a, f, n);
+    }
+    r(n, a, i, d, v, g, p);
+  }
+}
+function js(e) {
+  return e.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+Object.defineProperty(ge, "__esModule", { value: !0 });
+ge.getSchemaRefs = ge.resolveUrl = ge.normalizeId = ge._getFullPath = ge.getFullPath = ge.inlineRef = void 0;
+const Os = ye, Ds = Ns, Cs = br, Ts = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "pattern",
+  "maxLength",
+  "minLength",
+  "maxProperties",
+  "minProperties",
+  "maxItems",
+  "minItems",
+  "maximum",
+  "minimum",
+  "uniqueItems",
+  "multipleOf",
+  "required",
+  "enum",
+  "const"
+]);
+function Is(e, t = !0) {
+  return typeof e == "boolean" ? !0 : t === !0 ? !Pr(e) : t ? qn(e) <= t : !1;
+}
+ge.inlineRef = Is;
+const ks = /* @__PURE__ */ new Set([
+  "$ref",
+  "$recursiveRef",
+  "$recursiveAnchor",
+  "$dynamicRef",
+  "$dynamicAnchor"
+]);
+function Pr(e) {
+  for (const t in e) {
+    if (ks.has(t))
+      return !0;
+    const r = e[t];
+    if (Array.isArray(r) && r.some(Pr) || typeof r == "object" && Pr(r))
+      return !0;
+  }
+  return !1;
+}
+function qn(e) {
+  let t = 0;
+  for (const r in e) {
+    if (r === "$ref")
+      return 1 / 0;
+    if (t++, !Ts.has(r) && (typeof e[r] == "object" && (0, Os.eachItem)(e[r], (n) => t += qn(n)), t === 1 / 0))
+      return 1 / 0;
+  }
+  return t;
+}
+function Hn(e, t = "", r) {
+  r !== !1 && (t = Ot(t));
+  const n = e.parse(t);
+  return Gn(e, n);
+}
+ge.getFullPath = Hn;
+function Gn(e, t) {
+  return e.serialize(t).split("#")[0] + "#";
+}
+ge._getFullPath = Gn;
+const As = /#\/?$/;
+function Ot(e) {
+  return e ? e.replace(As, "") : "";
+}
+ge.normalizeId = Ot;
+function Ms(e, t, r) {
+  return r = Ot(r), e.resolve(t, r);
+}
+ge.resolveUrl = Ms;
+const Vs = /^[a-z_][-a-z0-9._]*$/i;
+function Fs(e, t) {
+  if (typeof e == "boolean")
+    return {};
+  const { schemaId: r, uriResolver: n } = this.opts, a = Ot(e[r] || t), i = { "": a }, d = Hn(n, a, !1), v = {}, g = /* @__PURE__ */ new Set();
+  return Cs(e, { allKeys: !0 }, (_, D, A, R) => {
+    if (R === void 0)
+      return;
+    const I = d + D;
+    let j = i[R];
+    typeof _[r] == "string" && (j = h.call(this, _[r])), P.call(this, _.$anchor), P.call(this, _.$dynamicAnchor), i[D] = j;
+    function h(b) {
+      const C = this.opts.uriResolver.resolve;
+      if (b = Ot(j ? C(j, b) : b), g.has(b))
+        throw f(b);
+      g.add(b);
+      let L = this.refs[b];
+      return typeof L == "string" && (L = this.refs[L]), typeof L == "object" ? p(_, L.schema, b) : b !== Ot(I) && (b[0] === "#" ? (p(_, v[b], b), v[b] = _) : this.refs[b] = I), b;
+    }
+    function P(b) {
+      if (typeof b == "string") {
+        if (!Vs.test(b))
+          throw new Error(`invalid anchor "${b}"`);
+        h.call(this, `#${b}`);
+      }
+    }
+  }), v;
+  function p(_, D, A) {
+    if (D !== void 0 && !Ds(_, D))
+      throw f(A);
+  }
+  function f(_) {
+    return new Error(`reference "${_}" resolves to more than one schema`);
+  }
+}
+ge.getSchemaRefs = Fs;
+Object.defineProperty(Le, "__esModule", { value: !0 });
+Le.getData = Le.KeywordCxt = Le.validateFunctionCode = void 0;
+const Bn = Dt, mn = lr, Dr = We, cr = lr, zs = dr, Jt = Ke, yr = at, F = ne, q = De, Us = ge, Qe = ye, Kt = Bt;
+function Ks(e) {
+  if (Yn(e) && (Xn(e), Qn(e))) {
+    qs(e);
+    return;
+  }
+  Wn(e, () => (0, Bn.topBoolOrEmptySchema)(e));
+}
+Le.validateFunctionCode = Ks;
+function Wn({ gen: e, validateName: t, schema: r, schemaEnv: n, opts: a }, i) {
+  a.code.es5 ? e.func(t, (0, F._)`${q.default.data}, ${q.default.valCxt}`, n.$async, () => {
+    e.code((0, F._)`"use strict"; ${vn(r, a)}`), Js(e, a), e.code(i);
+  }) : e.func(t, (0, F._)`${q.default.data}, ${Ls(a)}`, n.$async, () => e.code(vn(r, a)).code(i));
+}
+function Ls(e) {
+  return (0, F._)`{${q.default.instancePath}="", ${q.default.parentData}, ${q.default.parentDataProperty}, ${q.default.rootData}=${q.default.data}${e.dynamicRef ? (0, F._)`, ${q.default.dynamicAnchors}={}` : F.nil}}={}`;
+}
+function Js(e, t) {
+  e.if(q.default.valCxt, () => {
+    e.var(q.default.instancePath, (0, F._)`${q.default.valCxt}.${q.default.instancePath}`), e.var(q.default.parentData, (0, F._)`${q.default.valCxt}.${q.default.parentData}`), e.var(q.default.parentDataProperty, (0, F._)`${q.default.valCxt}.${q.default.parentDataProperty}`), e.var(q.default.rootData, (0, F._)`${q.default.valCxt}.${q.default.rootData}`), t.dynamicRef && e.var(q.default.dynamicAnchors, (0, F._)`${q.default.valCxt}.${q.default.dynamicAnchors}`);
+  }, () => {
+    e.var(q.default.instancePath, (0, F._)`""`), e.var(q.default.parentData, (0, F._)`undefined`), e.var(q.default.parentDataProperty, (0, F._)`undefined`), e.var(q.default.rootData, q.default.data), t.dynamicRef && e.var(q.default.dynamicAnchors, (0, F._)`{}`);
+  });
+}
+function qs(e) {
+  const { schema: t, opts: r, gen: n } = e;
+  Wn(e, () => {
+    r.$comment && t.$comment && xn(e), Qs(e), n.let(q.default.vErrors, null), n.let(q.default.errors, 0), r.unevaluated && Hs(e), Zn(e), Zs(e);
+  });
+}
+function Hs(e) {
+  const { gen: t, validateName: r } = e;
+  e.evaluated = t.const("evaluated", (0, F._)`${r}.evaluated`), t.if((0, F._)`${e.evaluated}.dynamicProps`, () => t.assign((0, F._)`${e.evaluated}.props`, (0, F._)`undefined`)), t.if((0, F._)`${e.evaluated}.dynamicItems`, () => t.assign((0, F._)`${e.evaluated}.items`, (0, F._)`undefined`));
+}
+function vn(e, t) {
+  const r = typeof e == "object" && e[t.schemaId];
+  return r && (t.code.source || t.code.process) ? (0, F._)`/*# sourceURL=${r} */` : F.nil;
+}
+function Gs(e, t) {
+  if (Yn(e) && (Xn(e), Qn(e))) {
+    Bs(e, t);
+    return;
+  }
+  (0, Bn.boolOrEmptySchema)(e, t);
+}
+function Qn({ schema: e, self: t }) {
+  if (typeof e == "boolean")
+    return !e;
+  for (const r in e)
+    if (t.RULES.all[r])
+      return !0;
+  return !1;
+}
+function Yn(e) {
+  return typeof e.schema != "boolean";
+}
+function Bs(e, t) {
+  const { schema: r, gen: n, opts: a } = e;
+  a.$comment && r.$comment && xn(e), Ys(e), Xs(e);
+  const i = n.const("_errs", q.default.errors);
+  Zn(e, i), n.var(t, (0, F._)`${i} === ${q.default.errors}`);
+}
+function Xn(e) {
+  (0, Qe.checkUnknownRules)(e), Ws(e);
+}
+function Zn(e, t) {
+  if (e.opts.jtd)
+    return _n(e, [], !1, t);
+  const r = (0, mn.getSchemaTypes)(e.schema), n = (0, mn.coerceAndCheckDataType)(e, r);
+  _n(e, r, !n, t);
+}
+function Ws(e) {
+  const { schema: t, errSchemaPath: r, opts: n, self: a } = e;
+  t.$ref && n.ignoreKeywordsWithRef && (0, Qe.schemaHasRulesButRef)(t, a.RULES) && a.logger.warn(`$ref: keywords ignored in schema at path "${r}"`);
+}
+function Qs(e) {
+  const { schema: t, opts: r } = e;
+  t.default !== void 0 && r.useDefaults && r.strictSchema && (0, Qe.checkStrictMode)(e, "default is ignored in the schema root");
+}
+function Ys(e) {
+  const t = e.schema[e.opts.schemaId];
+  t && (e.baseId = (0, Us.resolveUrl)(e.opts.uriResolver, e.baseId, t));
+}
+function Xs(e) {
+  if (e.schema.$async && !e.schemaEnv.$async)
+    throw new Error("async schema in sync schema");
+}
+function xn({ gen: e, schemaEnv: t, schema: r, errSchemaPath: n, opts: a }) {
+  const i = r.$comment;
+  if (a.$comment === !0)
+    e.code((0, F._)`${q.default.self}.logger.log(${i})`);
+  else if (typeof a.$comment == "function") {
+    const d = (0, F.str)`${n}/$comment`, v = e.scopeValue("root", { ref: t.root });
+    e.code((0, F._)`${q.default.self}.opts.$comment(${i}, ${d}, ${v}.schema)`);
+  }
+}
+function Zs(e) {
+  const { gen: t, schemaEnv: r, validateName: n, ValidationError: a, opts: i } = e;
+  r.$async ? t.if((0, F._)`${q.default.errors} === 0`, () => t.return(q.default.data), () => t.throw((0, F._)`new ${a}(${q.default.vErrors})`)) : (t.assign((0, F._)`${n}.errors`, q.default.vErrors), i.unevaluated && xs(e), t.return((0, F._)`${q.default.errors} === 0`));
+}
+function xs({ gen: e, evaluated: t, props: r, items: n }) {
+  r instanceof F.Name && e.assign((0, F._)`${t}.props`, r), n instanceof F.Name && e.assign((0, F._)`${t}.items`, n);
+}
+function _n(e, t, r, n) {
+  const { gen: a, schema: i, data: d, allErrors: v, opts: g, self: p } = e, { RULES: f } = p;
+  if (i.$ref && (g.ignoreKeywordsWithRef || !(0, Qe.schemaHasRulesButRef)(i, f))) {
+    a.block(() => ra(e, "$ref", f.all.$ref.definition));
+    return;
+  }
+  g.jtd || eo(e, t), a.block(() => {
+    for (const D of f.rules)
+      _(D);
+    _(f.post);
+  });
+  function _(D) {
+    (0, Dr.shouldUseGroup)(i, D) && (D.type ? (a.if((0, cr.checkDataType)(D.type, d, g.strictNumbers)), yn(e, D), t.length === 1 && t[0] === D.type && r && (a.else(), (0, cr.reportTypeError)(e)), a.endIf()) : yn(e, D), v || a.if((0, F._)`${q.default.errors} === ${n || 0}`));
+  }
+}
+function yn(e, t) {
+  const { gen: r, schema: n, opts: { useDefaults: a } } = e;
+  a && (0, zs.assignDefaults)(e, t.type), r.block(() => {
+    for (const i of t.rules)
+      (0, Dr.shouldUseRule)(n, i) && ra(e, i.keyword, i.definition, t.type);
+  });
+}
+function eo(e, t) {
+  e.schemaEnv.meta || !e.opts.strictTypes || (to(e, t), e.opts.allowUnionTypes || ro(e, t), no(e, e.dataTypes));
+}
+function to(e, t) {
+  if (t.length) {
+    if (!e.dataTypes.length) {
+      e.dataTypes = t;
+      return;
+    }
+    t.forEach((r) => {
+      ea(e.dataTypes, r) || Cr(e, `type "${r}" not allowed by context "${e.dataTypes.join(",")}"`);
+    }), so(e, t);
+  }
+}
+function ro(e, t) {
+  t.length > 1 && !(t.length === 2 && t.includes("null")) && Cr(e, "use allowUnionTypes to allow union type keyword");
+}
+function no(e, t) {
+  const r = e.self.RULES.all;
+  for (const n in r) {
+    const a = r[n];
+    if (typeof a == "object" && (0, Dr.shouldUseRule)(e.schema, a)) {
+      const { type: i } = a.definition;
+      i.length && !i.some((d) => ao(t, d)) && Cr(e, `missing type "${i.join(",")}" for keyword "${n}"`);
+    }
+  }
+}
+function ao(e, t) {
+  return e.includes(t) || t === "number" && e.includes("integer");
+}
+function ea(e, t) {
+  return e.includes(t) || t === "integer" && e.includes("number");
+}
+function so(e, t) {
+  const r = [];
+  for (const n of e.dataTypes)
+    ea(t, n) ? r.push(n) : t.includes("integer") && n === "number" && r.push("integer");
+  e.dataTypes = r;
+}
+function Cr(e, t) {
+  const r = e.schemaEnv.baseId + e.errSchemaPath;
+  t += ` at "${r}" (strictTypes)`, (0, Qe.checkStrictMode)(e, t, e.opts.strictTypes);
+}
+class ta {
+  constructor(t, r, n) {
+    if ((0, Jt.validateKeywordUsage)(t, r, n), this.gen = t.gen, this.allErrors = t.allErrors, this.keyword = n, this.data = t.data, this.schema = t.schema[n], this.$data = r.$data && t.opts.$data && this.schema && this.schema.$data, this.schemaValue = (0, Qe.schemaRefOrVal)(t, this.schema, n, this.$data), this.schemaType = r.schemaType, this.parentSchema = t.schema, this.params = {}, this.it = t, this.def = r, this.$data)
+      this.schemaCode = t.gen.const("vSchema", na(this.$data, t));
+    else if (this.schemaCode = this.schemaValue, !(0, Jt.validSchemaType)(this.schema, r.schemaType, r.allowUndefined))
+      throw new Error(`${n} value must be ${JSON.stringify(r.schemaType)}`);
+    ("code" in r ? r.trackErrors : r.errors !== !1) && (this.errsCount = t.gen.const("_errs", q.default.errors));
+  }
+  result(t, r, n) {
+    this.failResult((0, F.not)(t), r, n);
+  }
+  failResult(t, r, n) {
+    this.gen.if(t), n ? n() : this.error(), r ? (this.gen.else(), r(), this.allErrors && this.gen.endIf()) : this.allErrors ? this.gen.endIf() : this.gen.else();
+  }
+  pass(t, r) {
+    this.failResult((0, F.not)(t), void 0, r);
+  }
+  fail(t) {
+    if (t === void 0) {
+      this.error(), this.allErrors || this.gen.if(!1);
+      return;
+    }
+    this.gen.if(t), this.error(), this.allErrors ? this.gen.endIf() : this.gen.else();
+  }
+  fail$data(t) {
+    if (!this.$data)
+      return this.fail(t);
+    const { schemaCode: r } = this;
+    this.fail((0, F._)`${r} !== undefined && (${(0, F.or)(this.invalid$data(), t)})`);
+  }
+  error(t, r, n) {
+    if (r) {
+      this.setParams(r), this._error(t, n), this.setParams({});
+      return;
+    }
+    this._error(t, n);
+  }
+  _error(t, r) {
+    (t ? Kt.reportExtraError : Kt.reportError)(this, this.def.error, r);
+  }
+  $dataError() {
+    (0, Kt.reportError)(this, this.def.$dataError || Kt.keyword$DataError);
+  }
+  reset() {
+    if (this.errsCount === void 0)
+      throw new Error('add "trackErrors" to keyword definition');
+    (0, Kt.resetErrorsCount)(this.gen, this.errsCount);
+  }
+  ok(t) {
+    this.allErrors || this.gen.if(t);
+  }
+  setParams(t, r) {
+    r ? Object.assign(this.params, t) : this.params = t;
+  }
+  block$data(t, r, n = F.nil) {
+    this.gen.block(() => {
+      this.check$data(t, n), r();
+    });
+  }
+  check$data(t = F.nil, r = F.nil) {
+    if (!this.$data)
+      return;
+    const { gen: n, schemaCode: a, schemaType: i, def: d } = this;
+    n.if((0, F.or)((0, F._)`${a} === undefined`, r)), t !== F.nil && n.assign(t, !0), (i.length || d.validateSchema) && (n.elseIf(this.invalid$data()), this.$dataError(), t !== F.nil && n.assign(t, !1)), n.else();
+  }
+  invalid$data() {
+    const { gen: t, schemaCode: r, schemaType: n, def: a, it: i } = this;
+    return (0, F.or)(d(), v());
+    function d() {
+      if (n.length) {
+        if (!(r instanceof F.Name))
+          throw new Error("ajv implementation error");
+        const g = Array.isArray(n) ? n : [n];
+        return (0, F._)`${(0, cr.checkDataTypes)(g, r, i.opts.strictNumbers, cr.DataType.Wrong)}`;
+      }
+      return F.nil;
+    }
+    function v() {
+      if (a.validateSchema) {
+        const g = t.scopeValue("validate$data", { ref: a.validateSchema });
+        return (0, F._)`!${g}(${r})`;
+      }
+      return F.nil;
+    }
+  }
+  subschema(t, r) {
+    const n = (0, yr.getSubschema)(this.it, t);
+    (0, yr.extendSubschemaData)(n, this.it, t), (0, yr.extendSubschemaMode)(n, t);
+    const a = { ...this.it, ...n, items: void 0, props: void 0 };
+    return Gs(a, r), a;
+  }
+  mergeEvaluated(t, r) {
+    const { it: n, gen: a } = this;
+    n.opts.unevaluated && (n.props !== !0 && t.props !== void 0 && (n.props = Qe.mergeEvaluated.props(a, t.props, n.props, r)), n.items !== !0 && t.items !== void 0 && (n.items = Qe.mergeEvaluated.items(a, t.items, n.items, r)));
+  }
+  mergeValidEvaluated(t, r) {
+    const { it: n, gen: a } = this;
+    if (n.opts.unevaluated && (n.props !== !0 || n.items !== !0))
+      return a.if(r, () => this.mergeEvaluated(t, F.Name)), !0;
+  }
+}
+Le.KeywordCxt = ta;
+function ra(e, t, r, n) {
+  const a = new ta(e, r, t);
+  "code" in r ? r.code(a, n) : a.$data && r.validate ? (0, Jt.funcKeywordCode)(a, r) : "macro" in r ? (0, Jt.macroKeywordCode)(a, r) : (r.compile || r.validate) && (0, Jt.funcKeywordCode)(a, r);
+}
+const oo = /^\/(?:[^~]|~0|~1)*$/, io = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
+function na(e, { dataLevel: t, dataNames: r, dataPathArr: n }) {
+  let a, i;
+  if (e === "")
+    return q.default.rootData;
+  if (e[0] === "/") {
+    if (!oo.test(e))
+      throw new Error(`Invalid JSON-pointer: ${e}`);
+    a = e, i = q.default.rootData;
+  } else {
+    const p = io.exec(e);
+    if (!p)
+      throw new Error(`Invalid JSON-pointer: ${e}`);
+    const f = +p[1];
+    if (a = p[2], a === "#") {
+      if (f >= t)
+        throw new Error(g("property/index", f));
+      return n[t - f];
+    }
+    if (f > t)
+      throw new Error(g("data", f));
+    if (i = r[t - f], !a)
+      return i;
+  }
+  let d = i;
+  const v = a.split("/");
+  for (const p of v)
+    p && (i = (0, F._)`${i}${(0, F.getProperty)((0, Qe.unescapeJsonPointer)(p))}`, d = (0, F._)`${d} && ${i}`);
+  return d;
+  function g(p, f) {
+    return `Cannot access ${p} ${f} levels up, current level is ${t}`;
+  }
+}
+Le.getData = na;
+var Wt = {};
+Object.defineProperty(Wt, "__esModule", { value: !0 });
+class co extends Error {
+  constructor(t) {
+    super("validation failed"), this.errors = t, this.ajv = this.validation = !0;
+  }
+}
+Wt.default = co;
+var ot = {};
+Object.defineProperty(ot, "__esModule", { value: !0 });
+const gr = ge;
+class uo extends Error {
+  constructor(t, r, n, a) {
+    super(a || `can't resolve reference ${n} from id ${r}`), this.missingRef = (0, gr.resolveUrl)(t, r, n), this.missingSchema = (0, gr.normalizeId)((0, gr.getFullPath)(t, this.missingRef));
+  }
+}
+ot.default = uo;
+var we = {};
+Object.defineProperty(we, "__esModule", { value: !0 });
+we.resolveSchema = we.getCompilingSchema = we.resolveRef = we.compileSchema = we.SchemaEnv = void 0;
+const Te = ne, lo = Wt, dt = De, Ie = ge, gn = ye, fo = Le;
+class fr {
+  constructor(t) {
+    var r;
+    this.refs = {}, this.dynamicAnchors = {};
+    let n;
+    typeof t.schema == "object" && (n = t.schema), this.schema = t.schema, this.schemaId = t.schemaId, this.root = t.root || this, this.baseId = (r = t.baseId) !== null && r !== void 0 ? r : (0, Ie.normalizeId)(n == null ? void 0 : n[t.schemaId || "$id"]), this.schemaPath = t.schemaPath, this.localRefs = t.localRefs, this.meta = t.meta, this.$async = n == null ? void 0 : n.$async, this.refs = {};
+  }
+}
+we.SchemaEnv = fr;
+function Tr(e) {
+  const t = aa.call(this, e);
+  if (t)
+    return t;
+  const r = (0, Ie.getFullPath)(this.opts.uriResolver, e.root.baseId), { es5: n, lines: a } = this.opts.code, { ownProperties: i } = this.opts, d = new Te.CodeGen(this.scope, { es5: n, lines: a, ownProperties: i });
+  let v;
+  e.$async && (v = d.scopeValue("Error", {
+    ref: lo.default,
+    code: (0, Te._)`require("ajv/dist/runtime/validation_error").default`
+  }));
+  const g = d.scopeName("validate");
+  e.validateName = g;
+  const p = {
+    gen: d,
+    allErrors: this.opts.allErrors,
+    data: dt.default.data,
+    parentData: dt.default.parentData,
+    parentDataProperty: dt.default.parentDataProperty,
+    dataNames: [dt.default.data],
+    dataPathArr: [Te.nil],
+    dataLevel: 0,
+    dataTypes: [],
+    definedProperties: /* @__PURE__ */ new Set(),
+    topSchemaRef: d.scopeValue("schema", this.opts.code.source === !0 ? { ref: e.schema, code: (0, Te.stringify)(e.schema) } : { ref: e.schema }),
+    validateName: g,
+    ValidationError: v,
+    schema: e.schema,
+    schemaEnv: e,
+    rootId: r,
+    baseId: e.baseId || r,
+    schemaPath: Te.nil,
+    errSchemaPath: e.schemaPath || (this.opts.jtd ? "" : "#"),
+    errorPath: (0, Te._)`""`,
+    opts: this.opts,
+    self: this
+  };
+  let f;
+  try {
+    this._compilations.add(e), (0, fo.validateFunctionCode)(p), d.optimize(this.opts.code.optimize);
+    const _ = d.toString();
+    f = `${d.scopeRefs(dt.default.scope)}return ${_}`, this.opts.code.process && (f = this.opts.code.process(f, e));
+    const A = new Function(`${dt.default.self}`, `${dt.default.scope}`, f)(this, this.scope.get());
+    if (this.scope.value(g, { ref: A }), A.errors = null, A.schema = e.schema, A.schemaEnv = e, e.$async && (A.$async = !0), this.opts.code.source === !0 && (A.source = { validateName: g, validateCode: _, scopeValues: d._values }), this.opts.unevaluated) {
+      const { props: R, items: I } = p;
+      A.evaluated = {
+        props: R instanceof Te.Name ? void 0 : R,
+        items: I instanceof Te.Name ? void 0 : I,
+        dynamicProps: R instanceof Te.Name,
+        dynamicItems: I instanceof Te.Name
+      }, A.source && (A.source.evaluated = (0, Te.stringify)(A.evaluated));
+    }
+    return e.validate = A, e;
+  } catch (_) {
+    throw delete e.validate, delete e.validateName, f && this.logger.error("Error compiling schema, function code:", f), _;
+  } finally {
+    this._compilations.delete(e);
+  }
+}
+we.compileSchema = Tr;
+function ho(e, t, r) {
+  var n;
+  r = (0, Ie.resolveUrl)(this.opts.uriResolver, t, r);
+  const a = e.refs[r];
+  if (a)
+    return a;
+  let i = vo.call(this, e, r);
+  if (i === void 0) {
+    const d = (n = e.localRefs) === null || n === void 0 ? void 0 : n[r], { schemaId: v } = this.opts;
+    d && (i = new fr({ schema: d, schemaId: v, root: e, baseId: t }));
+  }
+  if (i !== void 0)
+    return e.refs[r] = po.call(this, i);
+}
+we.resolveRef = ho;
+function po(e) {
+  return (0, Ie.inlineRef)(e.schema, this.opts.inlineRefs) ? e.schema : e.validate ? e : Tr.call(this, e);
+}
+function aa(e) {
+  for (const t of this._compilations)
+    if (mo(t, e))
+      return t;
+}
+we.getCompilingSchema = aa;
+function mo(e, t) {
+  return e.schema === t.schema && e.root === t.root && e.baseId === t.baseId;
+}
+function vo(e, t) {
+  let r;
+  for (; typeof (r = this.refs[t]) == "string"; )
+    t = r;
+  return r || this.schemas[t] || hr.call(this, e, t);
+}
+function hr(e, t) {
+  const r = this.opts.uriResolver.parse(t), n = (0, Ie._getFullPath)(this.opts.uriResolver, r);
+  let a = (0, Ie.getFullPath)(this.opts.uriResolver, e.baseId, void 0);
+  if (Object.keys(e.schema).length > 0 && n === a)
+    return $r.call(this, r, e);
+  const i = (0, Ie.normalizeId)(n), d = this.refs[i] || this.schemas[i];
+  if (typeof d == "string") {
+    const v = hr.call(this, e, d);
+    return typeof (v == null ? void 0 : v.schema) != "object" ? void 0 : $r.call(this, r, v);
+  }
+  if (typeof (d == null ? void 0 : d.schema) == "object") {
+    if (d.validate || Tr.call(this, d), i === (0, Ie.normalizeId)(t)) {
+      const { schema: v } = d, { schemaId: g } = this.opts, p = v[g];
+      return p && (a = (0, Ie.resolveUrl)(this.opts.uriResolver, a, p)), new fr({ schema: v, schemaId: g, root: e, baseId: a });
+    }
+    return $r.call(this, r, d);
+  }
+}
+we.resolveSchema = hr;
+const _o = /* @__PURE__ */ new Set([
+  "properties",
+  "patternProperties",
+  "enum",
+  "dependencies",
+  "definitions"
+]);
+function $r(e, { baseId: t, schema: r, root: n }) {
+  var a;
+  if (((a = e.fragment) === null || a === void 0 ? void 0 : a[0]) !== "/")
+    return;
+  for (const v of e.fragment.slice(1).split("/")) {
+    if (typeof r == "boolean")
+      return;
+    const g = r[(0, gn.unescapeFragment)(v)];
+    if (g === void 0)
+      return;
+    r = g;
+    const p = typeof r == "object" && r[this.opts.schemaId];
+    !_o.has(v) && p && (t = (0, Ie.resolveUrl)(this.opts.uriResolver, t, p));
+  }
+  let i;
+  if (typeof r != "boolean" && r.$ref && !(0, gn.schemaHasRulesButRef)(r, this.RULES)) {
+    const v = (0, Ie.resolveUrl)(this.opts.uriResolver, t, r.$ref);
+    i = hr.call(this, n, v);
+  }
+  const { schemaId: d } = this.opts;
+  if (i = i || new fr({ schema: r, schemaId: d, root: n, baseId: t }), i.schema !== i.root.schema)
+    return i;
+}
+const yo = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", go = "Meta-schema for $data reference (JSON AnySchema extension proposal)", $o = "object", Eo = [
+  "$data"
+], wo = {
+  $data: {
+    type: "string",
+    anyOf: [
+      {
+        format: "relative-json-pointer"
+      },
+      {
+        format: "json-pointer"
+      }
+    ]
+  }
+}, So = !1, bo = {
+  $id: yo,
+  description: go,
+  type: $o,
+  required: Eo,
+  properties: wo,
+  additionalProperties: So
+};
+var Ir = {}, ur = {}, Po = {
+  get exports() {
+    return ur;
+  },
+  set exports(e) {
+    ur = e;
+  }
+};
+/** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */
+(function(e, t) {
+  (function(r, n) {
+    n(t);
+  })(Ka, function(r) {
+    function n() {
+      for (var c = arguments.length, o = Array(c), l = 0; l < c; l++)
+        o[l] = arguments[l];
+      if (o.length > 1) {
+        o[0] = o[0].slice(0, -1);
+        for (var E = o.length - 1, $ = 1; $ < E; ++$)
+          o[$] = o[$].slice(1, -1);
+        return o[E] = o[E].slice(1), o.join("");
+      } else
+        return o[0];
+    }
+    function a(c) {
+      return "(?:" + c + ")";
+    }
+    function i(c) {
+      return c === void 0 ? "undefined" : c === null ? "null" : Object.prototype.toString.call(c).split(" ").pop().split("]").shift().toLowerCase();
+    }
+    function d(c) {
+      return c.toUpperCase();
+    }
+    function v(c) {
+      return c != null ? c instanceof Array ? c : typeof c.length != "number" || c.split || c.setInterval || c.call ? [c] : Array.prototype.slice.call(c) : [];
+    }
+    function g(c, o) {
+      var l = c;
+      if (o)
+        for (var E in o)
+          l[E] = o[E];
+      return l;
+    }
+    function p(c) {
+      var o = "[A-Za-z]", l = "[0-9]", E = n(l, "[A-Fa-f]"), $ = a(a("%[EFef]" + E + "%" + E + E + "%" + E + E) + "|" + a("%[89A-Fa-f]" + E + "%" + E + E) + "|" + a("%" + E + E)), U = "[\\:\\/\\?\\#\\[\\]\\@]", K = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]", ee = n(U, K), ie = c ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]", pe = c ? "[\\uE000-\\uF8FF]" : "[]", X = n(o, l, "[\\-\\.\\_\\~]", ie);
+      a(o + n(o, l, "[\\+\\-\\.]") + "*"), a(a($ + "|" + n(X, K, "[\\:]")) + "*");
+      var ae = a(a("25[0-5]") + "|" + a("2[0-4]" + l) + "|" + a("1" + l + l) + "|" + a("0?[1-9]" + l) + "|0?0?" + l), me = a(ae + "\\." + ae + "\\." + ae + "\\." + ae), H = a(E + "{1,4}"), le = a(a(H + "\\:" + H) + "|" + me), ve = a(a(H + "\\:") + "{6}" + le), de = a("\\:\\:" + a(H + "\\:") + "{5}" + le), xe = a(a(H) + "?\\:\\:" + a(H + "\\:") + "{4}" + le), Ve = a(a(a(H + "\\:") + "{0,1}" + H) + "?\\:\\:" + a(H + "\\:") + "{3}" + le), Fe = a(a(a(H + "\\:") + "{0,2}" + H) + "?\\:\\:" + a(H + "\\:") + "{2}" + le), Pt = a(a(a(H + "\\:") + "{0,3}" + H) + "?\\:\\:" + H + "\\:" + le), ut = a(a(a(H + "\\:") + "{0,4}" + H) + "?\\:\\:" + le), je = a(a(a(H + "\\:") + "{0,5}" + H) + "?\\:\\:" + H), ze = a(a(a(H + "\\:") + "{0,6}" + H) + "?\\:\\:"), lt = a([ve, de, xe, Ve, Fe, Pt, ut, je, ze].join("|")), He = a(a(X + "|" + $) + "+");
+      a("[vV]" + E + "+\\." + n(X, K, "[\\:]") + "+"), a(a($ + "|" + n(X, K)) + "*");
+      var zt = a($ + "|" + n(X, K, "[\\:\\@]"));
+      return a(a($ + "|" + n(X, K, "[\\@]")) + "+"), a(a(zt + "|" + n("[\\/\\?]", pe)) + "*"), {
+        NOT_SCHEME: new RegExp(n("[^]", o, l, "[\\+\\-\\.]"), "g"),
+        NOT_USERINFO: new RegExp(n("[^\\%\\:]", X, K), "g"),
+        NOT_HOST: new RegExp(n("[^\\%\\[\\]\\:]", X, K), "g"),
+        NOT_PATH: new RegExp(n("[^\\%\\/\\:\\@]", X, K), "g"),
+        NOT_PATH_NOSCHEME: new RegExp(n("[^\\%\\/\\@]", X, K), "g"),
+        NOT_QUERY: new RegExp(n("[^\\%]", X, K, "[\\:\\@\\/\\?]", pe), "g"),
+        NOT_FRAGMENT: new RegExp(n("[^\\%]", X, K, "[\\:\\@\\/\\?]"), "g"),
+        ESCAPE: new RegExp(n("[^]", X, K), "g"),
+        UNRESERVED: new RegExp(X, "g"),
+        OTHER_CHARS: new RegExp(n("[^\\%]", X, ee), "g"),
+        PCT_ENCODED: new RegExp($, "g"),
+        IPV4ADDRESS: new RegExp("^(" + me + ")$"),
+        IPV6ADDRESS: new RegExp("^\\[?(" + lt + ")" + a(a("\\%25|\\%(?!" + E + "{2})") + "(" + He + ")") + "?\\]?$")
+        //RFC 6874, with relaxed parsing rules
+      };
+    }
+    var f = p(!1), _ = p(!0), D = function() {
+      function c(o, l) {
+        var E = [], $ = !0, U = !1, K = void 0;
+        try {
+          for (var ee = o[Symbol.iterator](), ie; !($ = (ie = ee.next()).done) && (E.push(ie.value), !(l && E.length === l)); $ = !0)
+            ;
+        } catch (pe) {
+          U = !0, K = pe;
+        } finally {
+          try {
+            !$ && ee.return && ee.return();
+          } finally {
+            if (U)
+              throw K;
+          }
+        }
+        return E;
+      }
+      return function(o, l) {
+        if (Array.isArray(o))
+          return o;
+        if (Symbol.iterator in Object(o))
+          return c(o, l);
+        throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      };
+    }(), A = function(c) {
+      if (Array.isArray(c)) {
+        for (var o = 0, l = Array(c.length); o < c.length; o++)
+          l[o] = c[o];
+        return l;
+      } else
+        return Array.from(c);
+    }, R = 2147483647, I = 36, j = 1, h = 26, P = 38, b = 700, C = 72, L = 128, w = "-", S = /^xn--/, T = /[^\0-\x7E]/, J = /[\x2E\u3002\uFF0E\uFF61]/g, B = {
+      overflow: "Overflow: input needs wider integers to process",
+      "not-basic": "Illegal input >= 0x80 (not a basic code point)",
+      "invalid-input": "Invalid input"
+    }, oe = I - j, W = Math.floor, re = String.fromCharCode;
+    function G(c) {
+      throw new RangeError(B[c]);
+    }
+    function ue(c, o) {
+      for (var l = [], E = c.length; E--; )
+        l[E] = o(c[E]);
+      return l;
+    }
+    function fe(c, o) {
+      var l = c.split("@"), E = "";
+      l.length > 1 && (E = l[0] + "@", c = l[1]), c = c.replace(J, ".");
+      var $ = c.split("."), U = ue($, o).join(".");
+      return E + U;
+    }
+    function _e(c) {
+      for (var o = [], l = 0, E = c.length; l < E; ) {
+        var $ = c.charCodeAt(l++);
+        if ($ >= 55296 && $ <= 56319 && l < E) {
+          var U = c.charCodeAt(l++);
+          (U & 64512) == 56320 ? o.push((($ & 1023) << 10) + (U & 1023) + 65536) : (o.push($), l--);
+        } else
+          o.push($);
+      }
+      return o;
+    }
+    var $e = function(o) {
+      return String.fromCodePoint.apply(String, A(o));
+    }, Ze = function(o) {
+      return o - 48 < 10 ? o - 22 : o - 65 < 26 ? o - 65 : o - 97 < 26 ? o - 97 : I;
+    }, k = function(o, l) {
+      return o + 22 + 75 * (o < 26) - ((l != 0) << 5);
+    }, m = function(o, l, E) {
+      var $ = 0;
+      for (
+        o = E ? W(o / b) : o >> 1, o += W(o / l);
+        /* no initialization */
+        o > oe * h >> 1;
+        $ += I
+      )
+        o = W(o / oe);
+      return W($ + (oe + 1) * o / (o + P));
+    }, O = function(o) {
+      var l = [], E = o.length, $ = 0, U = L, K = C, ee = o.lastIndexOf(w);
+      ee < 0 && (ee = 0);
+      for (var ie = 0; ie < ee; ++ie)
+        o.charCodeAt(ie) >= 128 && G("not-basic"), l.push(o.charCodeAt(ie));
+      for (var pe = ee > 0 ? ee + 1 : 0; pe < E; ) {
+        for (
+          var X = $, ae = 1, me = I;
+          ;
+          /* no condition */
+          me += I
+        ) {
+          pe >= E && G("invalid-input");
+          var H = Ze(o.charCodeAt(pe++));
+          (H >= I || H > W((R - $) / ae)) && G("overflow"), $ += H * ae;
+          var le = me <= K ? j : me >= K + h ? h : me - K;
+          if (H < le)
+            break;
+          var ve = I - le;
+          ae > W(R / ve) && G("overflow"), ae *= ve;
+        }
+        var de = l.length + 1;
+        K = m($ - X, de, X == 0), W($ / de) > R - U && G("overflow"), U += W($ / de), $ %= de, l.splice($++, 0, U);
+      }
+      return String.fromCodePoint.apply(String, l);
+    }, y = function(o) {
+      var l = [];
+      o = _e(o);
+      var E = o.length, $ = L, U = 0, K = C, ee = !0, ie = !1, pe = void 0;
+      try {
+        for (var X = o[Symbol.iterator](), ae; !(ee = (ae = X.next()).done); ee = !0) {
+          var me = ae.value;
+          me < 128 && l.push(re(me));
+        }
+      } catch (Ut) {
+        ie = !0, pe = Ut;
+      } finally {
+        try {
+          !ee && X.return && X.return();
+        } finally {
+          if (ie)
+            throw pe;
+        }
+      }
+      var H = l.length, le = H;
+      for (H && l.push(w); le < E; ) {
+        var ve = R, de = !0, xe = !1, Ve = void 0;
+        try {
+          for (var Fe = o[Symbol.iterator](), Pt; !(de = (Pt = Fe.next()).done); de = !0) {
+            var ut = Pt.value;
+            ut >= $ && ut < ve && (ve = ut);
+          }
+        } catch (Ut) {
+          xe = !0, Ve = Ut;
+        } finally {
+          try {
+            !de && Fe.return && Fe.return();
+          } finally {
+            if (xe)
+              throw Ve;
+          }
+        }
+        var je = le + 1;
+        ve - $ > W((R - U) / je) && G("overflow"), U += (ve - $) * je, $ = ve;
+        var ze = !0, lt = !1, He = void 0;
+        try {
+          for (var zt = o[Symbol.iterator](), un; !(ze = (un = zt.next()).done); ze = !0) {
+            var ln = un.value;
+            if (ln < $ && ++U > R && G("overflow"), ln == $) {
+              for (
+                var Zt = U, xt = I;
+                ;
+                /* no condition */
+                xt += I
+              ) {
+                var er = xt <= K ? j : xt >= K + h ? h : xt - K;
+                if (Zt < er)
+                  break;
+                var dn = Zt - er, fn = I - er;
+                l.push(re(k(er + dn % fn, 0))), Zt = W(dn / fn);
+              }
+              l.push(re(k(Zt, 0))), K = m(U, je, le == H), U = 0, ++le;
+            }
+          }
+        } catch (Ut) {
+          lt = !0, He = Ut;
+        } finally {
+          try {
+            !ze && zt.return && zt.return();
+          } finally {
+            if (lt)
+              throw He;
+          }
+        }
+        ++U, ++$;
+      }
+      return l.join("");
+    }, s = function(o) {
+      return fe(o, function(l) {
+        return S.test(l) ? O(l.slice(4).toLowerCase()) : l;
+      });
+    }, u = function(o) {
+      return fe(o, function(l) {
+        return T.test(l) ? "xn--" + y(l) : l;
+      });
+    }, N = {
+      /**
+       * A string representing the current Punycode.js version number.
+       * @memberOf punycode
+       * @type String
+       */
+      version: "2.1.0",
+      /**
+       * An object of methods to convert from JavaScript's internal character
+       * representation (UCS-2) to Unicode code points, and back.
+       * @see <https://mathiasbynens.be/notes/javascript-encoding>
+       * @memberOf punycode
+       * @type Object
+       */
+      ucs2: {
+        decode: _e,
+        encode: $e
+      },
+      decode: O,
+      encode: y,
+      toASCII: u,
+      toUnicode: s
+    }, M = {};
+    function V(c) {
+      var o = c.charCodeAt(0), l = void 0;
+      return o < 16 ? l = "%0" + o.toString(16).toUpperCase() : o < 128 ? l = "%" + o.toString(16).toUpperCase() : o < 2048 ? l = "%" + (o >> 6 | 192).toString(16).toUpperCase() + "%" + (o & 63 | 128).toString(16).toUpperCase() : l = "%" + (o >> 12 | 224).toString(16).toUpperCase() + "%" + (o >> 6 & 63 | 128).toString(16).toUpperCase() + "%" + (o & 63 | 128).toString(16).toUpperCase(), l;
+    }
+    function Y(c) {
+      for (var o = "", l = 0, E = c.length; l < E; ) {
+        var $ = parseInt(c.substr(l + 1, 2), 16);
+        if ($ < 128)
+          o += String.fromCharCode($), l += 3;
+        else if ($ >= 194 && $ < 224) {
+          if (E - l >= 6) {
+            var U = parseInt(c.substr(l + 4, 2), 16);
+            o += String.fromCharCode(($ & 31) << 6 | U & 63);
+          } else
+            o += c.substr(l, 6);
+          l += 6;
+        } else if ($ >= 224) {
+          if (E - l >= 9) {
+            var K = parseInt(c.substr(l + 4, 2), 16), ee = parseInt(c.substr(l + 7, 2), 16);
+            o += String.fromCharCode(($ & 15) << 12 | (K & 63) << 6 | ee & 63);
+          } else
+            o += c.substr(l, 9);
+          l += 9;
+        } else
+          o += c.substr(l, 3), l += 3;
+      }
+      return o;
+    }
+    function x(c, o) {
+      function l(E) {
+        var $ = Y(E);
+        return $.match(o.UNRESERVED) ? $ : E;
+      }
+      return c.scheme && (c.scheme = String(c.scheme).replace(o.PCT_ENCODED, l).toLowerCase().replace(o.NOT_SCHEME, "")), c.userinfo !== void 0 && (c.userinfo = String(c.userinfo).replace(o.PCT_ENCODED, l).replace(o.NOT_USERINFO, V).replace(o.PCT_ENCODED, d)), c.host !== void 0 && (c.host = String(c.host).replace(o.PCT_ENCODED, l).toLowerCase().replace(o.NOT_HOST, V).replace(o.PCT_ENCODED, d)), c.path !== void 0 && (c.path = String(c.path).replace(o.PCT_ENCODED, l).replace(c.scheme ? o.NOT_PATH : o.NOT_PATH_NOSCHEME, V).replace(o.PCT_ENCODED, d)), c.query !== void 0 && (c.query = String(c.query).replace(o.PCT_ENCODED, l).replace(o.NOT_QUERY, V).replace(o.PCT_ENCODED, d)), c.fragment !== void 0 && (c.fragment = String(c.fragment).replace(o.PCT_ENCODED, l).replace(o.NOT_FRAGMENT, V).replace(o.PCT_ENCODED, d)), c;
+    }
+    function he(c) {
+      return c.replace(/^0*(.*)/, "$1") || "0";
+    }
+    function ke(c, o) {
+      var l = c.match(o.IPV4ADDRESS) || [], E = D(l, 2), $ = E[1];
+      return $ ? $.split(".").map(he).join(".") : c;
+    }
+    function gt(c, o) {
+      var l = c.match(o.IPV6ADDRESS) || [], E = D(l, 3), $ = E[1], U = E[2];
+      if ($) {
+        for (var K = $.toLowerCase().split("::").reverse(), ee = D(K, 2), ie = ee[0], pe = ee[1], X = pe ? pe.split(":").map(he) : [], ae = ie.split(":").map(he), me = o.IPV4ADDRESS.test(ae[ae.length - 1]), H = me ? 7 : 8, le = ae.length - H, ve = Array(H), de = 0; de < H; ++de)
+          ve[de] = X[de] || ae[le + de] || "";
+        me && (ve[H - 1] = ke(ve[H - 1], o));
+        var xe = ve.reduce(function(je, ze, lt) {
+          if (!ze || ze === "0") {
+            var He = je[je.length - 1];
+            He && He.index + He.length === lt ? He.length++ : je.push({ index: lt, length: 1 });
+          }
+          return je;
+        }, []), Ve = xe.sort(function(je, ze) {
+          return ze.length - je.length;
+        })[0], Fe = void 0;
+        if (Ve && Ve.length > 1) {
+          var Pt = ve.slice(0, Ve.index), ut = ve.slice(Ve.index + Ve.length);
+          Fe = Pt.join(":") + "::" + ut.join(":");
+        } else
+          Fe = ve.join(":");
+        return U && (Fe += "%" + U), Fe;
+      } else
+        return c;
+    }
+    var Tt = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i, It = "".match(/(){0}/)[1] === void 0;
+    function Ne(c) {
+      var o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, l = {}, E = o.iri !== !1 ? _ : f;
+      o.reference === "suffix" && (c = (o.scheme ? o.scheme + ":" : "") + "//" + c);
+      var $ = c.match(Tt);
+      if ($) {
+        It ? (l.scheme = $[1], l.userinfo = $[3], l.host = $[4], l.port = parseInt($[5], 10), l.path = $[6] || "", l.query = $[7], l.fragment = $[8], isNaN(l.port) && (l.port = $[5])) : (l.scheme = $[1] || void 0, l.userinfo = c.indexOf("@") !== -1 ? $[3] : void 0, l.host = c.indexOf("//") !== -1 ? $[4] : void 0, l.port = parseInt($[5], 10), l.path = $[6] || "", l.query = c.indexOf("?") !== -1 ? $[7] : void 0, l.fragment = c.indexOf("#") !== -1 ? $[8] : void 0, isNaN(l.port) && (l.port = c.match(/\/\/(?:.|\n)*\:(?:\/|\?|\#|$)/) ? $[4] : void 0)), l.host && (l.host = gt(ke(l.host, E), E)), l.scheme === void 0 && l.userinfo === void 0 && l.host === void 0 && l.port === void 0 && !l.path && l.query === void 0 ? l.reference = "same-document" : l.scheme === void 0 ? l.reference = "relative" : l.fragment === void 0 ? l.reference = "absolute" : l.reference = "uri", o.reference && o.reference !== "suffix" && o.reference !== l.reference && (l.error = l.error || "URI is not a " + o.reference + " reference.");
+        var U = M[(o.scheme || l.scheme || "").toLowerCase()];
+        if (!o.unicodeSupport && (!U || !U.unicodeSupport)) {
+          if (l.host && (o.domainHost || U && U.domainHost))
+            try {
+              l.host = N.toASCII(l.host.replace(E.PCT_ENCODED, Y).toLowerCase());
+            } catch (K) {
+              l.error = l.error || "Host's domain name can not be converted to ASCII via punycode: " + K;
+            }
+          x(l, f);
+        } else
+          x(l, E);
+        U && U.parse && U.parse(l, o);
+      } else
+        l.error = l.error || "URI can not be parsed.";
+      return l;
+    }
+    function kt(c, o) {
+      var l = o.iri !== !1 ? _ : f, E = [];
+      return c.userinfo !== void 0 && (E.push(c.userinfo), E.push("@")), c.host !== void 0 && E.push(gt(ke(String(c.host), l), l).replace(l.IPV6ADDRESS, function($, U, K) {
+        return "[" + U + (K ? "%25" + K : "") + "]";
+      })), (typeof c.port == "number" || typeof c.port == "string") && (E.push(":"), E.push(String(c.port))), E.length ? E.join("") : void 0;
+    }
+    var $t = /^\.\.?\//, Et = /^\/\.(\/|$)/, wt = /^\/\.\.(\/|$)/, At = /^\/?(?:.|\n)*?(?=\/|$)/;
+    function Ae(c) {
+      for (var o = []; c.length; )
+        if (c.match($t))
+          c = c.replace($t, "");
+        else if (c.match(Et))
+          c = c.replace(Et, "/");
+        else if (c.match(wt))
+          c = c.replace(wt, "/"), o.pop();
+        else if (c === "." || c === "..")
+          c = "";
+        else {
+          var l = c.match(At);
+          if (l) {
+            var E = l[0];
+            c = c.slice(E.length), o.push(E);
+          } else
+            throw new Error("Unexpected dot segment condition");
+        }
+      return o.join("");
+    }
+    function be(c) {
+      var o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, l = o.iri ? _ : f, E = [], $ = M[(o.scheme || c.scheme || "").toLowerCase()];
+      if ($ && $.serialize && $.serialize(c, o), c.host && !l.IPV6ADDRESS.test(c.host)) {
+        if (o.domainHost || $ && $.domainHost)
+          try {
+            c.host = o.iri ? N.toUnicode(c.host) : N.toASCII(c.host.replace(l.PCT_ENCODED, Y).toLowerCase());
+          } catch (ee) {
+            c.error = c.error || "Host's domain name can not be converted to " + (o.iri ? "Unicode" : "ASCII") + " via punycode: " + ee;
+          }
+      }
+      x(c, l), o.reference !== "suffix" && c.scheme && (E.push(c.scheme), E.push(":"));
+      var U = kt(c, o);
+      if (U !== void 0 && (o.reference !== "suffix" && E.push("//"), E.push(U), c.path && c.path.charAt(0) !== "/" && E.push("/")), c.path !== void 0) {
+        var K = c.path;
+        !o.absolutePath && (!$ || !$.absolutePath) && (K = Ae(K)), U === void 0 && (K = K.replace(/^\/\//, "/%2F")), E.push(K);
+      }
+      return c.query !== void 0 && (E.push("?"), E.push(c.query)), c.fragment !== void 0 && (E.push("#"), E.push(c.fragment)), E.join("");
+    }
+    function St(c, o) {
+      var l = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, E = arguments[3], $ = {};
+      return E || (c = Ne(be(c, l), l), o = Ne(be(o, l), l)), l = l || {}, !l.tolerant && o.scheme ? ($.scheme = o.scheme, $.userinfo = o.userinfo, $.host = o.host, $.port = o.port, $.path = Ae(o.path || ""), $.query = o.query) : (o.userinfo !== void 0 || o.host !== void 0 || o.port !== void 0 ? ($.userinfo = o.userinfo, $.host = o.host, $.port = o.port, $.path = Ae(o.path || ""), $.query = o.query) : (o.path ? (o.path.charAt(0) === "/" ? $.path = Ae(o.path) : ((c.userinfo !== void 0 || c.host !== void 0 || c.port !== void 0) && !c.path ? $.path = "/" + o.path : c.path ? $.path = c.path.slice(0, c.path.lastIndexOf("/") + 1) + o.path : $.path = o.path, $.path = Ae($.path)), $.query = o.query) : ($.path = c.path, o.query !== void 0 ? $.query = o.query : $.query = c.query), $.userinfo = c.userinfo, $.host = c.host, $.port = c.port), $.scheme = c.scheme), $.fragment = o.fragment, $;
+    }
+    function Mt(c, o, l) {
+      var E = g({ scheme: "null" }, l);
+      return be(St(Ne(c, E), Ne(o, E), E, !0), E);
+    }
+    function it(c, o) {
+      return typeof c == "string" ? c = be(Ne(c, o), o) : i(c) === "object" && (c = Ne(be(c, o), o)), c;
+    }
+    function Vt(c, o, l) {
+      return typeof c == "string" ? c = be(Ne(c, l), l) : i(c) === "object" && (c = be(c, l)), typeof o == "string" ? o = be(Ne(o, l), l) : i(o) === "object" && (o = be(o, l)), c === o;
+    }
+    function Xt(c, o) {
+      return c && c.toString().replace(!o || !o.iri ? f.ESCAPE : _.ESCAPE, V);
+    }
+    function Re(c, o) {
+      return c && c.toString().replace(!o || !o.iri ? f.PCT_ENCODED : _.PCT_ENCODED, Y);
+    }
+    var ct = {
+      scheme: "http",
+      domainHost: !0,
+      parse: function(o, l) {
+        return o.host || (o.error = o.error || "HTTP URIs must have a host."), o;
+      },
+      serialize: function(o, l) {
+        var E = String(o.scheme).toLowerCase() === "https";
+        return (o.port === (E ? 443 : 80) || o.port === "") && (o.port = void 0), o.path || (o.path = "/"), o;
+      }
+    }, en = {
+      scheme: "https",
+      domainHost: ct.domainHost,
+      parse: ct.parse,
+      serialize: ct.serialize
+    };
+    function tn(c) {
+      return typeof c.secure == "boolean" ? c.secure : String(c.scheme).toLowerCase() === "wss";
+    }
+    var Ft = {
+      scheme: "ws",
+      domainHost: !0,
+      parse: function(o, l) {
+        var E = o;
+        return E.secure = tn(E), E.resourceName = (E.path || "/") + (E.query ? "?" + E.query : ""), E.path = void 0, E.query = void 0, E;
+      },
+      serialize: function(o, l) {
+        if ((o.port === (tn(o) ? 443 : 80) || o.port === "") && (o.port = void 0), typeof o.secure == "boolean" && (o.scheme = o.secure ? "wss" : "ws", o.secure = void 0), o.resourceName) {
+          var E = o.resourceName.split("?"), $ = D(E, 2), U = $[0], K = $[1];
+          o.path = U && U !== "/" ? U : void 0, o.query = K, o.resourceName = void 0;
+        }
+        return o.fragment = void 0, o;
+      }
+    }, rn = {
+      scheme: "wss",
+      domainHost: Ft.domainHost,
+      parse: Ft.parse,
+      serialize: Ft.serialize
+    }, ja = {}, nn = "[A-Za-z0-9\\-\\.\\_\\~\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]", Me = "[0-9A-Fa-f]", Oa = a(a("%[EFef]" + Me + "%" + Me + Me + "%" + Me + Me) + "|" + a("%[89A-Fa-f]" + Me + "%" + Me + Me) + "|" + a("%" + Me + Me)), Da = "[A-Za-z0-9\\!\\$\\%\\'\\*\\+\\-\\^\\_\\`\\{\\|\\}\\~]", Ca = "[\\!\\$\\%\\'\\(\\)\\*\\+\\,\\-\\.0-9\\<\\>A-Z\\x5E-\\x7E]", Ta = n(Ca, '[\\"\\\\]'), Ia = "[\\!\\$\\'\\(\\)\\*\\+\\,\\;\\:\\@]", ka = new RegExp(nn, "g"), bt = new RegExp(Oa, "g"), Aa = new RegExp(n("[^]", Da, "[\\.]", '[\\"]', Ta), "g"), an = new RegExp(n("[^]", nn, Ia), "g"), Ma = an;
+    function _r(c) {
+      var o = Y(c);
+      return o.match(ka) ? o : c;
+    }
+    var sn = {
+      scheme: "mailto",
+      parse: function(o, l) {
+        var E = o, $ = E.to = E.path ? E.path.split(",") : [];
+        if (E.path = void 0, E.query) {
+          for (var U = !1, K = {}, ee = E.query.split("&"), ie = 0, pe = ee.length; ie < pe; ++ie) {
+            var X = ee[ie].split("=");
+            switch (X[0]) {
+              case "to":
+                for (var ae = X[1].split(","), me = 0, H = ae.length; me < H; ++me)
+                  $.push(ae[me]);
+                break;
+              case "subject":
+                E.subject = Re(X[1], l);
+                break;
+              case "body":
+                E.body = Re(X[1], l);
+                break;
+              default:
+                U = !0, K[Re(X[0], l)] = Re(X[1], l);
+                break;
+            }
+          }
+          U && (E.headers = K);
+        }
+        E.query = void 0;
+        for (var le = 0, ve = $.length; le < ve; ++le) {
+          var de = $[le].split("@");
+          if (de[0] = Re(de[0]), l.unicodeSupport)
+            de[1] = Re(de[1], l).toLowerCase();
+          else
+            try {
+              de[1] = N.toASCII(Re(de[1], l).toLowerCase());
+            } catch (xe) {
+              E.error = E.error || "Email address's domain name can not be converted to ASCII via punycode: " + xe;
+            }
+          $[le] = de.join("@");
+        }
+        return E;
+      },
+      serialize: function(o, l) {
+        var E = o, $ = v(o.to);
+        if ($) {
+          for (var U = 0, K = $.length; U < K; ++U) {
+            var ee = String($[U]), ie = ee.lastIndexOf("@"), pe = ee.slice(0, ie).replace(bt, _r).replace(bt, d).replace(Aa, V), X = ee.slice(ie + 1);
+            try {
+              X = l.iri ? N.toUnicode(X) : N.toASCII(Re(X, l).toLowerCase());
+            } catch (le) {
+              E.error = E.error || "Email address's domain name can not be converted to " + (l.iri ? "Unicode" : "ASCII") + " via punycode: " + le;
+            }
+            $[U] = pe + "@" + X;
+          }
+          E.path = $.join(",");
+        }
+        var ae = o.headers = o.headers || {};
+        o.subject && (ae.subject = o.subject), o.body && (ae.body = o.body);
+        var me = [];
+        for (var H in ae)
+          ae[H] !== ja[H] && me.push(H.replace(bt, _r).replace(bt, d).replace(an, V) + "=" + ae[H].replace(bt, _r).replace(bt, d).replace(Ma, V));
+        return me.length && (E.query = me.join("&")), E;
+      }
+    }, Va = /^([^\:]+)\:(.*)/, on = {
+      scheme: "urn",
+      parse: function(o, l) {
+        var E = o.path && o.path.match(Va), $ = o;
+        if (E) {
+          var U = l.scheme || $.scheme || "urn", K = E[1].toLowerCase(), ee = E[2], ie = U + ":" + (l.nid || K), pe = M[ie];
+          $.nid = K, $.nss = ee, $.path = void 0, pe && ($ = pe.parse($, l));
+        } else
+          $.error = $.error || "URN can not be parsed.";
+        return $;
+      },
+      serialize: function(o, l) {
+        var E = l.scheme || o.scheme || "urn", $ = o.nid, U = E + ":" + (l.nid || $), K = M[U];
+        K && (o = K.serialize(o, l));
+        var ee = o, ie = o.nss;
+        return ee.path = ($ || l.nid) + ":" + ie, ee;
+      }
+    }, Fa = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/, cn = {
+      scheme: "urn:uuid",
+      parse: function(o, l) {
+        var E = o;
+        return E.uuid = E.nss, E.nss = void 0, !l.tolerant && (!E.uuid || !E.uuid.match(Fa)) && (E.error = E.error || "UUID is not valid."), E;
+      },
+      serialize: function(o, l) {
+        var E = o;
+        return E.nss = (o.uuid || "").toLowerCase(), E;
+      }
+    };
+    M[ct.scheme] = ct, M[en.scheme] = en, M[Ft.scheme] = Ft, M[rn.scheme] = rn, M[sn.scheme] = sn, M[on.scheme] = on, M[cn.scheme] = cn, r.SCHEMES = M, r.pctEncChar = V, r.pctDecChars = Y, r.parse = Ne, r.removeDotSegments = Ae, r.serialize = be, r.resolveComponents = St, r.resolve = Mt, r.normalize = it, r.equal = Vt, r.escapeComponent = Xt, r.unescapeComponent = Re, Object.defineProperty(r, "__esModule", { value: !0 });
+  });
+})(Po, ur);
+Object.defineProperty(Ir, "__esModule", { value: !0 });
+const sa = ur;
+sa.code = 'require("ajv/dist/runtime/uri").default';
+Ir.default = sa;
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.CodeGen = e.Name = e.nil = e.stringify = e.str = e._ = e.KeywordCxt = void 0;
+  var t = Le;
+  Object.defineProperty(e, "KeywordCxt", { enumerable: !0, get: function() {
+    return t.KeywordCxt;
+  } });
+  var r = ne;
+  Object.defineProperty(e, "_", { enumerable: !0, get: function() {
+    return r._;
+  } }), Object.defineProperty(e, "str", { enumerable: !0, get: function() {
+    return r.str;
+  } }), Object.defineProperty(e, "stringify", { enumerable: !0, get: function() {
+    return r.stringify;
+  } }), Object.defineProperty(e, "nil", { enumerable: !0, get: function() {
+    return r.nil;
+  } }), Object.defineProperty(e, "Name", { enumerable: !0, get: function() {
+    return r.Name;
+  } }), Object.defineProperty(e, "CodeGen", { enumerable: !0, get: function() {
+    return r.CodeGen;
+  } });
+  const n = Wt, a = ot, i = mt, d = we, v = ne, g = ge, p = lr, f = ye, _ = bo, D = Ir, A = (k, m) => new RegExp(k, m);
+  A.code = "new RegExp";
+  const R = ["removeAdditional", "useDefaults", "coerceTypes"], I = /* @__PURE__ */ new Set([
+    "validate",
+    "serialize",
+    "parse",
+    "wrapper",
+    "root",
+    "schema",
+    "keyword",
+    "pattern",
+    "formats",
+    "validate$data",
+    "func",
+    "obj",
+    "Error"
+  ]), j = {
+    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."
+  }, h = {
+    ignoreKeywordsWithRef: "",
+    jsPropertySyntax: "",
+    unicode: '"minLength"/"maxLength" account for unicode characters by default.'
+  }, P = 200;
+  function b(k) {
+    var m, O, y, s, u, N, M, V, Y, x, he, ke, gt, Tt, It, Ne, kt, $t, Et, wt, At, Ae, be, St, Mt;
+    const it = k.strict, Vt = (m = k.code) === null || m === void 0 ? void 0 : m.optimize, Xt = Vt === !0 || Vt === void 0 ? 1 : Vt || 0, Re = (y = (O = k.code) === null || O === void 0 ? void 0 : O.regExp) !== null && y !== void 0 ? y : A, ct = (s = k.uriResolver) !== null && s !== void 0 ? s : D.default;
+    return {
+      strictSchema: (N = (u = k.strictSchema) !== null && u !== void 0 ? u : it) !== null && N !== void 0 ? N : !0,
+      strictNumbers: (V = (M = k.strictNumbers) !== null && M !== void 0 ? M : it) !== null && V !== void 0 ? V : !0,
+      strictTypes: (x = (Y = k.strictTypes) !== null && Y !== void 0 ? Y : it) !== null && x !== void 0 ? x : "log",
+      strictTuples: (ke = (he = k.strictTuples) !== null && he !== void 0 ? he : it) !== null && ke !== void 0 ? ke : "log",
+      strictRequired: (Tt = (gt = k.strictRequired) !== null && gt !== void 0 ? gt : it) !== null && Tt !== void 0 ? Tt : !1,
+      code: k.code ? { ...k.code, optimize: Xt, regExp: Re } : { optimize: Xt, regExp: Re },
+      loopRequired: (It = k.loopRequired) !== null && It !== void 0 ? It : P,
+      loopEnum: (Ne = k.loopEnum) !== null && Ne !== void 0 ? Ne : P,
+      meta: (kt = k.meta) !== null && kt !== void 0 ? kt : !0,
+      messages: ($t = k.messages) !== null && $t !== void 0 ? $t : !0,
+      inlineRefs: (Et = k.inlineRefs) !== null && Et !== void 0 ? Et : !0,
+      schemaId: (wt = k.schemaId) !== null && wt !== void 0 ? wt : "$id",
+      addUsedSchema: (At = k.addUsedSchema) !== null && At !== void 0 ? At : !0,
+      validateSchema: (Ae = k.validateSchema) !== null && Ae !== void 0 ? Ae : !0,
+      validateFormats: (be = k.validateFormats) !== null && be !== void 0 ? be : !0,
+      unicodeRegExp: (St = k.unicodeRegExp) !== null && St !== void 0 ? St : !0,
+      int32range: (Mt = k.int32range) !== null && Mt !== void 0 ? Mt : !0,
+      uriResolver: ct
+    };
+  }
+  class C {
+    constructor(m = {}) {
+      this.schemas = {}, this.refs = {}, this.formats = {}, this._compilations = /* @__PURE__ */ new Set(), this._loading = {}, this._cache = /* @__PURE__ */ new Map(), m = this.opts = { ...m, ...b(m) };
+      const { es5: O, lines: y } = this.opts.code;
+      this.scope = new v.ValueScope({ scope: {}, prefixes: I, es5: O, lines: y }), this.logger = W(m.logger);
+      const s = m.validateFormats;
+      m.validateFormats = !1, this.RULES = (0, i.getRules)(), L.call(this, j, m, "NOT SUPPORTED"), L.call(this, h, m, "DEPRECATED", "warn"), this._metaOpts = B.call(this), m.formats && T.call(this), this._addVocabularies(), this._addDefaultMetaSchema(), m.keywords && J.call(this, m.keywords), typeof m.meta == "object" && this.addMetaSchema(m.meta), S.call(this), m.validateFormats = s;
+    }
+    _addVocabularies() {
+      this.addKeyword("$async");
+    }
+    _addDefaultMetaSchema() {
+      const { $data: m, meta: O, schemaId: y } = this.opts;
+      let s = _;
+      y === "id" && (s = { ..._ }, s.id = s.$id, delete s.$id), O && m && this.addMetaSchema(s, s[y], !1);
+    }
+    defaultMeta() {
+      const { meta: m, schemaId: O } = this.opts;
+      return this.opts.defaultMeta = typeof m == "object" ? m[O] || m : void 0;
+    }
+    validate(m, O) {
+      let y;
+      if (typeof m == "string") {
+        if (y = this.getSchema(m), !y)
+          throw new Error(`no schema with key or ref "${m}"`);
+      } else
+        y = this.compile(m);
+      const s = y(O);
+      return "$async" in y || (this.errors = y.errors), s;
+    }
+    compile(m, O) {
+      const y = this._addSchema(m, O);
+      return y.validate || this._compileSchemaEnv(y);
+    }
+    compileAsync(m, O) {
+      if (typeof this.opts.loadSchema != "function")
+        throw new Error("options.loadSchema should be a function");
+      const { loadSchema: y } = this.opts;
+      return s.call(this, m, O);
+      async function s(x, he) {
+        await u.call(this, x.$schema);
+        const ke = this._addSchema(x, he);
+        return ke.validate || N.call(this, ke);
+      }
+      async function u(x) {
+        x && !this.getSchema(x) && await s.call(this, { $ref: x }, !0);
+      }
+      async function N(x) {
+        try {
+          return this._compileSchemaEnv(x);
+        } catch (he) {
+          if (!(he instanceof a.default))
+            throw he;
+          return M.call(this, he), await V.call(this, he.missingSchema), N.call(this, x);
+        }
+      }
+      function M({ missingSchema: x, missingRef: he }) {
+        if (this.refs[x])
+          throw new Error(`AnySchema ${x} is loaded but ${he} cannot be resolved`);
+      }
+      async function V(x) {
+        const he = await Y.call(this, x);
+        this.refs[x] || await u.call(this, he.$schema), this.refs[x] || this.addSchema(he, x, O);
+      }
+      async function Y(x) {
+        const he = this._loading[x];
+        if (he)
+          return he;
+        try {
+          return await (this._loading[x] = y(x));
+        } finally {
+          delete this._loading[x];
+        }
+      }
+    }
+    // Adds schema to the instance
+    addSchema(m, O, y, s = this.opts.validateSchema) {
+      if (Array.isArray(m)) {
+        for (const N of m)
+          this.addSchema(N, void 0, y, s);
+        return this;
+      }
+      let u;
+      if (typeof m == "object") {
+        const { schemaId: N } = this.opts;
+        if (u = m[N], u !== void 0 && typeof u != "string")
+          throw new Error(`schema ${N} must be string`);
+      }
+      return O = (0, g.normalizeId)(O || u), this._checkUnique(O), this.schemas[O] = this._addSchema(m, y, O, s, !0), this;
+    }
+    // Add schema that will be used to validate other schemas
+    // options in META_IGNORE_OPTIONS are alway set to false
+    addMetaSchema(m, O, y = this.opts.validateSchema) {
+      return this.addSchema(m, O, !0, y), this;
+    }
+    //  Validate schema against its meta-schema
+    validateSchema(m, O) {
+      if (typeof m == "boolean")
+        return !0;
+      let y;
+      if (y = m.$schema, y !== void 0 && typeof y != "string")
+        throw new Error("$schema must be a string");
+      if (y = y || this.opts.defaultMeta || this.defaultMeta(), !y)
+        return this.logger.warn("meta-schema not available"), this.errors = null, !0;
+      const s = this.validate(y, m);
+      if (!s && O) {
+        const u = "schema is invalid: " + this.errorsText();
+        if (this.opts.validateSchema === "log")
+          this.logger.error(u);
+        else
+          throw new Error(u);
+      }
+      return s;
+    }
+    // Get compiled schema by `key` or `ref`.
+    // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)
+    getSchema(m) {
+      let O;
+      for (; typeof (O = w.call(this, m)) == "string"; )
+        m = O;
+      if (O === void 0) {
+        const { schemaId: y } = this.opts, s = new d.SchemaEnv({ schema: {}, schemaId: y });
+        if (O = d.resolveSchema.call(this, s, m), !O)
+          return;
+        this.refs[m] = O;
+      }
+      return O.validate || this._compileSchemaEnv(O);
+    }
+    // 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(m) {
+      if (m instanceof RegExp)
+        return this._removeAllSchemas(this.schemas, m), this._removeAllSchemas(this.refs, m), this;
+      switch (typeof m) {
+        case "undefined":
+          return this._removeAllSchemas(this.schemas), this._removeAllSchemas(this.refs), this._cache.clear(), this;
+        case "string": {
+          const O = w.call(this, m);
+          return typeof O == "object" && this._cache.delete(O.schema), delete this.schemas[m], delete this.refs[m], this;
+        }
+        case "object": {
+          const O = m;
+          this._cache.delete(O);
+          let y = m[this.opts.schemaId];
+          return y && (y = (0, g.normalizeId)(y), delete this.schemas[y], delete this.refs[y]), this;
+        }
+        default:
+          throw new Error("ajv.removeSchema: invalid parameter");
+      }
+    }
+    // add "vocabulary" - a collection of keywords
+    addVocabulary(m) {
+      for (const O of m)
+        this.addKeyword(O);
+      return this;
+    }
+    addKeyword(m, O) {
+      let y;
+      if (typeof m == "string")
+        y = m, typeof O == "object" && (this.logger.warn("these parameters are deprecated, see docs for addKeyword"), O.keyword = y);
+      else if (typeof m == "object" && O === void 0) {
+        if (O = m, y = O.keyword, Array.isArray(y) && !y.length)
+          throw new Error("addKeywords: keyword must be string or non-empty array");
+      } else
+        throw new Error("invalid addKeywords parameters");
+      if (G.call(this, y, O), !O)
+        return (0, f.eachItem)(y, (u) => ue.call(this, u)), this;
+      _e.call(this, O);
+      const s = {
+        ...O,
+        type: (0, p.getJSONTypes)(O.type),
+        schemaType: (0, p.getJSONTypes)(O.schemaType)
+      };
+      return (0, f.eachItem)(y, s.type.length === 0 ? (u) => ue.call(this, u, s) : (u) => s.type.forEach((N) => ue.call(this, u, s, N))), this;
+    }
+    getKeyword(m) {
+      const O = this.RULES.all[m];
+      return typeof O == "object" ? O.definition : !!O;
+    }
+    // Remove keyword
+    removeKeyword(m) {
+      const { RULES: O } = this;
+      delete O.keywords[m], delete O.all[m];
+      for (const y of O.rules) {
+        const s = y.rules.findIndex((u) => u.keyword === m);
+        s >= 0 && y.rules.splice(s, 1);
+      }
+      return this;
+    }
+    // Add format
+    addFormat(m, O) {
+      return typeof O == "string" && (O = new RegExp(O)), this.formats[m] = O, this;
+    }
+    errorsText(m = this.errors, { separator: O = ", ", dataVar: y = "data" } = {}) {
+      return !m || m.length === 0 ? "No errors" : m.map((s) => `${y}${s.instancePath} ${s.message}`).reduce((s, u) => s + O + u);
+    }
+    $dataMetaSchema(m, O) {
+      const y = this.RULES.all;
+      m = JSON.parse(JSON.stringify(m));
+      for (const s of O) {
+        const u = s.split("/").slice(1);
+        let N = m;
+        for (const M of u)
+          N = N[M];
+        for (const M in y) {
+          const V = y[M];
+          if (typeof V != "object")
+            continue;
+          const { $data: Y } = V.definition, x = N[M];
+          Y && x && (N[M] = Ze(x));
+        }
+      }
+      return m;
+    }
+    _removeAllSchemas(m, O) {
+      for (const y in m) {
+        const s = m[y];
+        (!O || O.test(y)) && (typeof s == "string" ? delete m[y] : s && !s.meta && (this._cache.delete(s.schema), delete m[y]));
+      }
+    }
+    _addSchema(m, O, y, s = this.opts.validateSchema, u = this.opts.addUsedSchema) {
+      let N;
+      const { schemaId: M } = this.opts;
+      if (typeof m == "object")
+        N = m[M];
+      else {
+        if (this.opts.jtd)
+          throw new Error("schema must be object");
+        if (typeof m != "boolean")
+          throw new Error("schema must be object or boolean");
+      }
+      let V = this._cache.get(m);
+      if (V !== void 0)
+        return V;
+      y = (0, g.normalizeId)(N || y);
+      const Y = g.getSchemaRefs.call(this, m, y);
+      return V = new d.SchemaEnv({ schema: m, schemaId: M, meta: O, baseId: y, localRefs: Y }), this._cache.set(V.schema, V), u && !y.startsWith("#") && (y && this._checkUnique(y), this.refs[y] = V), s && this.validateSchema(m, !0), V;
+    }
+    _checkUnique(m) {
+      if (this.schemas[m] || this.refs[m])
+        throw new Error(`schema with key or id "${m}" already exists`);
+    }
+    _compileSchemaEnv(m) {
+      if (m.meta ? this._compileMetaSchema(m) : d.compileSchema.call(this, m), !m.validate)
+        throw new Error("ajv implementation error");
+      return m.validate;
+    }
+    _compileMetaSchema(m) {
+      const O = this.opts;
+      this.opts = this._metaOpts;
+      try {
+        d.compileSchema.call(this, m);
+      } finally {
+        this.opts = O;
+      }
+    }
+  }
+  e.default = C, C.ValidationError = n.default, C.MissingRefError = a.default;
+  function L(k, m, O, y = "error") {
+    for (const s in k) {
+      const u = s;
+      u in m && this.logger[y](`${O}: option ${s}. ${k[u]}`);
+    }
+  }
+  function w(k) {
+    return k = (0, g.normalizeId)(k), this.schemas[k] || this.refs[k];
+  }
+  function S() {
+    const k = this.opts.schemas;
+    if (k)
+      if (Array.isArray(k))
+        this.addSchema(k);
+      else
+        for (const m in k)
+          this.addSchema(k[m], m);
+  }
+  function T() {
+    for (const k in this.opts.formats) {
+      const m = this.opts.formats[k];
+      m && this.addFormat(k, m);
+    }
+  }
+  function J(k) {
+    if (Array.isArray(k)) {
+      this.addVocabulary(k);
+      return;
+    }
+    this.logger.warn("keywords option as map is deprecated, pass array");
+    for (const m in k) {
+      const O = k[m];
+      O.keyword || (O.keyword = m), this.addKeyword(O);
+    }
+  }
+  function B() {
+    const k = { ...this.opts };
+    for (const m of R)
+      delete k[m];
+    return k;
+  }
+  const oe = { log() {
+  }, warn() {
+  }, error() {
+  } };
+  function W(k) {
+    if (k === !1)
+      return oe;
+    if (k === void 0)
+      return console;
+    if (k.log && k.warn && k.error)
+      return k;
+    throw new Error("logger must implement log, warn and error methods");
+  }
+  const re = /^[a-z_$][a-z0-9_$:-]*$/i;
+  function G(k, m) {
+    const { RULES: O } = this;
+    if ((0, f.eachItem)(k, (y) => {
+      if (O.keywords[y])
+        throw new Error(`Keyword ${y} is already defined`);
+      if (!re.test(y))
+        throw new Error(`Keyword ${y} has invalid name`);
+    }), !!m && m.$data && !("code" in m || "validate" in m))
+      throw new Error('$data keyword must have "code" or "validate" function');
+  }
+  function ue(k, m, O) {
+    var y;
+    const s = m == null ? void 0 : m.post;
+    if (O && s)
+      throw new Error('keyword with "post" flag cannot have "type"');
+    const { RULES: u } = this;
+    let N = s ? u.post : u.rules.find(({ type: V }) => V === O);
+    if (N || (N = { type: O, rules: [] }, u.rules.push(N)), u.keywords[k] = !0, !m)
+      return;
+    const M = {
+      keyword: k,
+      definition: {
+        ...m,
+        type: (0, p.getJSONTypes)(m.type),
+        schemaType: (0, p.getJSONTypes)(m.schemaType)
+      }
+    };
+    m.before ? fe.call(this, N, M, m.before) : N.rules.push(M), u.all[k] = M, (y = m.implements) === null || y === void 0 || y.forEach((V) => this.addKeyword(V));
+  }
+  function fe(k, m, O) {
+    const y = k.rules.findIndex((s) => s.keyword === O);
+    y >= 0 ? k.rules.splice(y, 0, m) : (k.rules.push(m), this.logger.warn(`rule ${O} is not defined`));
+  }
+  function _e(k) {
+    let { metaSchema: m } = k;
+    m !== void 0 && (k.$data && this.opts.$data && (m = Ze(m)), k.validateSchema = this.compile(m, !0));
+  }
+  const $e = {
+    $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
+  };
+  function Ze(k) {
+    return { anyOf: [k, $e] };
+  }
+})(Mn);
+var kr = {}, yt = {}, vt = {};
+Object.defineProperty(vt, "__esModule", { value: !0 });
+vt.callRef = vt.getValidate = void 0;
+const No = ot, $n = te, Pe = ne, jt = De, En = we, tr = ye, Ro = {
+  keyword: "$ref",
+  schemaType: "string",
+  code(e) {
+    const { gen: t, schema: r, it: n } = e, { baseId: a, schemaEnv: i, validateName: d, opts: v, self: g } = n, { root: p } = i;
+    if ((r === "#" || r === "#/") && a === p.baseId)
+      return _();
+    const f = En.resolveRef.call(g, p, a, r);
+    if (f === void 0)
+      throw new No.default(n.opts.uriResolver, a, r);
+    if (f instanceof En.SchemaEnv)
+      return D(f);
+    return A(f);
+    function _() {
+      if (i === p)
+        return ar(e, d, i, i.$async);
+      const R = t.scopeValue("root", { ref: p });
+      return ar(e, (0, Pe._)`${R}.validate`, p, p.$async);
+    }
+    function D(R) {
+      const I = oa(e, R);
+      ar(e, I, R, R.$async);
+    }
+    function A(R) {
+      const I = t.scopeValue("schema", v.code.source === !0 ? { ref: R, code: (0, Pe.stringify)(R) } : { ref: R }), j = t.name("valid"), h = e.subschema({
+        schema: R,
+        dataTypes: [],
+        schemaPath: Pe.nil,
+        topSchemaRef: I,
+        errSchemaPath: r
+      }, j);
+      e.mergeEvaluated(h), e.ok(j);
+    }
+  }
+};
+function oa(e, t) {
+  const { gen: r } = e;
+  return t.validate ? r.scopeValue("validate", { ref: t.validate }) : (0, Pe._)`${r.scopeValue("wrapper", { ref: t })}.validate`;
+}
+vt.getValidate = oa;
+function ar(e, t, r, n) {
+  const { gen: a, it: i } = e, { allErrors: d, schemaEnv: v, opts: g } = i, p = g.passContext ? jt.default.this : Pe.nil;
+  n ? f() : _();
+  function f() {
+    if (!v.$async)
+      throw new Error("async schema referenced by sync schema");
+    const R = a.let("valid");
+    a.try(() => {
+      a.code((0, Pe._)`await ${(0, $n.callValidateCode)(e, t, p)}`), A(t), d || a.assign(R, !0);
+    }, (I) => {
+      a.if((0, Pe._)`!(${I} instanceof ${i.ValidationError})`, () => a.throw(I)), D(I), d || a.assign(R, !1);
+    }), e.ok(R);
+  }
+  function _() {
+    e.result((0, $n.callValidateCode)(e, t, p), () => A(t), () => D(t));
+  }
+  function D(R) {
+    const I = (0, Pe._)`${R}.errors`;
+    a.assign(jt.default.vErrors, (0, Pe._)`${jt.default.vErrors} === null ? ${I} : ${jt.default.vErrors}.concat(${I})`), a.assign(jt.default.errors, (0, Pe._)`${jt.default.vErrors}.length`);
+  }
+  function A(R) {
+    var I;
+    if (!i.opts.unevaluated)
+      return;
+    const j = (I = r == null ? void 0 : r.validate) === null || I === void 0 ? void 0 : I.evaluated;
+    if (i.props !== !0)
+      if (j && !j.dynamicProps)
+        j.props !== void 0 && (i.props = tr.mergeEvaluated.props(a, j.props, i.props));
+      else {
+        const h = a.var("props", (0, Pe._)`${R}.evaluated.props`);
+        i.props = tr.mergeEvaluated.props(a, h, i.props, Pe.Name);
+      }
+    if (i.items !== !0)
+      if (j && !j.dynamicItems)
+        j.items !== void 0 && (i.items = tr.mergeEvaluated.items(a, j.items, i.items));
+      else {
+        const h = a.var("items", (0, Pe._)`${R}.evaluated.items`);
+        i.items = tr.mergeEvaluated.items(a, h, i.items, Pe.Name);
+      }
+  }
+}
+vt.callRef = ar;
+vt.default = Ro;
+var Ce = {};
+Object.defineProperty(Ce, "__esModule", { value: !0 });
+Ce.checkMetadata = void 0;
+const jo = ye, Oo = {
+  keyword: "metadata",
+  schemaType: "object",
+  code(e) {
+    ia(e);
+    const { gen: t, schema: r, it: n } = e;
+    if ((0, jo.alwaysValidSchema)(n, r))
+      return;
+    const a = t.name("valid");
+    e.subschema({ keyword: "metadata", jtdMetadata: !0 }, a), e.ok(a);
+  }
+};
+function ia({ it: e, keyword: t }, r) {
+  if (e.jtdMetadata !== r)
+    throw new Error(`JTD: "${t}" cannot be used in this schema location`);
+}
+Ce.checkMetadata = ia;
+Ce.default = Oo;
+Object.defineProperty(yt, "__esModule", { value: !0 });
+yt.hasRef = void 0;
+const wn = we, Lt = ne, Do = ot, Sn = De, bn = vt, Co = Ce, To = {
+  keyword: "ref",
+  schemaType: "string",
+  code(e) {
+    (0, Co.checkMetadata)(e);
+    const { gen: t, data: r, schema: n, parentSchema: a, it: i } = e, { schemaEnv: { root: d } } = i, v = t.name("valid");
+    a.nullable ? (t.var(v, (0, Lt._)`${r} === null`), t.if((0, Lt.not)(v), g)) : (t.var(v, !1), g()), e.ok(v);
+    function g() {
+      var _;
+      const D = (_ = d.schema.definitions) === null || _ === void 0 ? void 0 : _[n];
+      if (!D)
+        throw new Do.default(i.opts.uriResolver, "", n, `No definition ${n}`);
+      Ar(D) || !i.opts.inlineRefs ? p(D) : f(D);
+    }
+    function p(_) {
+      const D = wn.compileSchema.call(i.self, new wn.SchemaEnv({ schema: _, root: d, schemaPath: `/definitions/${n}` })), A = (0, bn.getValidate)(e, D), R = t.const("_errs", Sn.default.errors);
+      (0, bn.callRef)(e, A, D, D.$async), t.assign(v, (0, Lt._)`${R} === ${Sn.default.errors}`);
+    }
+    function f(_) {
+      const D = t.scopeValue("schema", i.opts.code.source === !0 ? { ref: _, code: (0, Lt.stringify)(_) } : { ref: _ });
+      e.subschema({
+        schema: _,
+        dataTypes: [],
+        schemaPath: Lt.nil,
+        topSchemaRef: D,
+        errSchemaPath: `/definitions/${n}`
+      }, v);
+    }
+  }
+};
+function Ar(e) {
+  for (const t in e) {
+    let r;
+    if (t === "ref" || typeof (r = e[t]) == "object" && Ar(r))
+      return !0;
+  }
+  return !1;
+}
+yt.hasRef = Ar;
+yt.default = To;
+var Mr = {}, pr = {};
+Object.defineProperty(pr, "__esModule", { value: !0 });
+const Io = /t|\s/i, ko = /^(\d\d\d\d)-(\d\d)-(\d\d)$/, Ao = /^(\d\d):(\d\d):(\d\d)(?:\.\d+)?(?:z|([+-]\d\d)(?::?(\d\d))?)$/i, Mo = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function ca(e, t) {
+  const r = e.split(Io);
+  return r.length === 2 && Pn(r[0]) && Vo(r[1]) || t && r.length === 1 && Pn(r[0]);
+}
+pr.default = ca;
+function Pn(e) {
+  const t = ko.exec(e);
+  if (!t)
+    return !1;
+  const r = +t[1], n = +t[2], a = +t[3];
+  return n >= 1 && n <= 12 && a >= 1 && (a <= Mo[n] || // leap year: https://tools.ietf.org/html/rfc3339#appendix-C
+  n === 2 && a === 29 && (r % 100 === 0 ? r % 400 === 0 : r % 4 === 0));
+}
+function Vo(e) {
+  const t = Ao.exec(e);
+  if (!t)
+    return !1;
+  const r = +t[1], n = +t[2], a = +t[3], i = +(t[4] || 0), d = +(t[5] || 0);
+  return r <= 23 && n <= 59 && a <= 59 || // leap second
+  r - i === 23 && n - d === 59 && a === 60;
+}
+ca.code = 'require("ajv/dist/runtime/timestamp").default';
+var Oe = {};
+Object.defineProperty(Oe, "__esModule", { value: !0 });
+Oe.typeErrorParams = Oe.typeErrorMessage = Oe.typeError = void 0;
+const Fo = ne;
+function zo(e) {
+  return {
+    message: (t) => ua(t, e),
+    params: (t) => la(t, e)
+  };
+}
+Oe.typeError = zo;
+function ua({ parentSchema: e }, t) {
+  return e != null && e.nullable ? `must be ${t} or null` : `must be ${t}`;
+}
+Oe.typeErrorMessage = ua;
+function la({ parentSchema: e }, t) {
+  return (0, Fo._)`{type: ${t}, nullable: ${!!(e != null && e.nullable)}}`;
+}
+Oe.typeErrorParams = la;
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.intRange = void 0;
+  const t = ne, r = pr, n = ye, a = Ce, i = Oe;
+  e.intRange = {
+    int8: [-128, 127, 3],
+    uint8: [0, 255, 3],
+    int16: [-32768, 32767, 5],
+    uint16: [0, 65535, 5],
+    int32: [-2147483648, 2147483647, 10],
+    uint32: [0, 4294967295, 10]
+  };
+  const d = {
+    message: (p) => (0, i.typeErrorMessage)(p, p.schema),
+    params: (p) => (0, i.typeErrorParams)(p, p.schema)
+  };
+  function v(p) {
+    const { gen: f, data: _, it: D } = p, { timestamp: A, allowDate: R } = D.opts;
+    if (A === "date")
+      return (0, t._)`${_} instanceof Date `;
+    const I = (0, n.useFunc)(f, r.default), j = R ? (0, t._)`, true` : t.nil, h = (0, t._)`typeof ${_} == "string" && ${I}(${_}${j})`;
+    return A === "string" ? h : (0, t.or)((0, t._)`${_} instanceof Date`, h);
+  }
+  const g = {
+    keyword: "type",
+    schemaType: "string",
+    error: d,
+    code(p) {
+      (0, a.checkMetadata)(p);
+      const { data: f, schema: _, parentSchema: D, it: A } = p;
+      let R;
+      switch (_) {
+        case "boolean":
+        case "string":
+          R = (0, t._)`typeof ${f} == ${_}`;
+          break;
+        case "timestamp": {
+          R = v(p);
+          break;
+        }
+        case "float32":
+        case "float64":
+          R = (0, t._)`typeof ${f} == "number"`;
+          break;
+        default: {
+          const I = _;
+          if (R = (0, t._)`typeof ${f} == "number" && isFinite(${f}) && !(${f} % 1)`, !A.opts.int32range && (I === "int32" || I === "uint32"))
+            I === "uint32" && (R = (0, t._)`${R} && ${f} >= 0`);
+          else {
+            const [j, h] = e.intRange[I];
+            R = (0, t._)`${R} && ${f} >= ${j} && ${f} <= ${h}`;
+          }
+        }
+      }
+      p.pass(D.nullable ? (0, t.or)((0, t._)`${f} === null`, R) : R);
+    }
+  };
+  e.default = g;
+})(Mr);
+var Vr = {}, Je = {};
+Object.defineProperty(Je, "__esModule", { value: !0 });
+Je.checkNullableObject = Je.checkNullable = void 0;
+const sr = ne;
+function da({ gen: e, data: t, parentSchema: r }, n = sr.nil) {
+  const a = e.name("valid");
+  return r.nullable ? (e.let(a, (0, sr._)`${t} === null`), n = (0, sr.not)(a)) : e.let(a, !1), [a, n];
+}
+Je.checkNullable = da;
+function Uo(e, t) {
+  const [r, n] = da(e, t);
+  return [r, (0, sr._)`${n} && typeof ${e.data} == "object" && !Array.isArray(${e.data})`];
+}
+Je.checkNullableObject = Uo;
+Object.defineProperty(Vr, "__esModule", { value: !0 });
+const tt = ne, Ko = Ce, Lo = Je, Jo = {
+  message: "must be equal to one of the allowed values",
+  params: ({ schemaCode: e }) => (0, tt._)`{allowedValues: ${e}}`
+}, qo = {
+  keyword: "enum",
+  schemaType: "array",
+  error: Jo,
+  code(e) {
+    (0, Ko.checkMetadata)(e);
+    const { gen: t, data: r, schema: n, schemaValue: a, parentSchema: i, it: d } = e;
+    if (n.length === 0)
+      throw new Error("enum must have non-empty array");
+    if (n.length !== new Set(n).size)
+      throw new Error("enum items must be unique");
+    let v;
+    const g = (0, tt._)`typeof ${r} == "string"`;
+    if (n.length >= d.opts.loopEnum) {
+      let f;
+      [v, f] = (0, Lo.checkNullable)(e, g), t.if(f, p);
+    } else {
+      if (!Array.isArray(n))
+        throw new Error("ajv implementation error");
+      v = (0, tt.and)(g, (0, tt.or)(...n.map((f) => (0, tt._)`${r} === ${f}`))), i.nullable && (v = (0, tt.or)((0, tt._)`${r} === null`, v));
+    }
+    e.pass(v);
+    function p() {
+      t.forOf("v", a, (f) => t.if((0, tt._)`${v} = ${r} === ${f}`, () => t.break()));
+    }
+  }
+};
+Vr.default = qo;
+var Fr = {};
+Object.defineProperty(Fr, "__esModule", { value: !0 });
+const Ho = ye, Go = te, Nn = ne, Bo = Ce, Wo = Je, Qo = Oe, Yo = {
+  keyword: "elements",
+  schemaType: "object",
+  error: (0, Qo.typeError)("array"),
+  code(e) {
+    (0, Bo.checkMetadata)(e);
+    const { gen: t, data: r, schema: n, it: a } = e;
+    if ((0, Ho.alwaysValidSchema)(a, n))
+      return;
+    const [i] = (0, Wo.checkNullable)(e);
+    t.if((0, Nn.not)(i), () => t.if((0, Nn._)`Array.isArray(${r})`, () => t.assign(i, (0, Go.validateArray)(e)), () => e.error())), e.ok(i);
+  }
+};
+Fr.default = Yo;
+var zr = {};
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.validateProperties = e.error = void 0;
+  const t = te, r = ye, n = ne, a = Ce, i = Je, d = Oe;
+  var v;
+  (function(f) {
+    f.Additional = "additional", f.Missing = "missing";
+  })(v || (v = {})), e.error = {
+    message: (f) => {
+      const { params: _ } = f;
+      return _.propError ? _.propError === v.Additional ? "must NOT have additional properties" : `must have property '${_.missingProperty}'` : (0, d.typeErrorMessage)(f, "object");
+    },
+    params: (f) => {
+      const { params: _ } = f;
+      return _.propError ? _.propError === v.Additional ? (0, n._)`{error: ${_.propError}, additionalProperty: ${_.additionalProperty}}` : (0, n._)`{error: ${_.propError}, missingProperty: ${_.missingProperty}}` : (0, d.typeErrorParams)(f, "object");
+    }
+  };
+  const g = {
+    keyword: "properties",
+    schemaType: "object",
+    error: e.error,
+    code: p
+  };
+  function p(f) {
+    (0, a.checkMetadata)(f);
+    const { gen: _, data: D, parentSchema: A, it: R } = f, { additionalProperties: I, nullable: j } = A;
+    if (R.jtdDiscriminator && j)
+      throw new Error("JTD: nullable inside discriminator mapping");
+    if (S())
+      throw new Error("JTD: properties and optionalProperties have common members");
+    const [h, P] = T("properties"), [b, C] = T("optionalProperties");
+    if (P.length === 0 && C.length === 0 && I)
+      return;
+    const [L, w] = R.jtdDiscriminator === void 0 ? (0, i.checkNullableObject)(f, D) : [_.let("valid", !1), !0];
+    _.if(w, () => _.assign(L, !0).block(() => {
+      J(P, "properties", !0), J(C, "optionalProperties"), I || oe();
+    })), f.pass(L);
+    function S() {
+      const re = A.properties, G = A.optionalProperties;
+      if (!(re && G))
+        return !1;
+      for (const ue in re)
+        if (Object.prototype.hasOwnProperty.call(G, ue))
+          return !0;
+      return !1;
+    }
+    function T(re) {
+      const G = A[re], ue = G ? (0, t.allSchemaProperties)(G) : [];
+      if (R.jtdDiscriminator && ue.some((_e) => _e === R.jtdDiscriminator))
+        throw new Error(`JTD: discriminator tag used in ${re}`);
+      const fe = ue.filter((_e) => !(0, r.alwaysValidSchema)(R, G[_e]));
+      return [ue, fe];
+    }
+    function J(re, G, ue) {
+      const fe = _.var("valid");
+      for (const $e of re)
+        _.if((0, t.propertyInData)(_, D, $e, R.opts.ownProperties), () => B($e, G, fe), () => _e($e)), f.ok(fe);
+      function _e($e) {
+        ue ? (_.assign(fe, !1), f.error(!1, { propError: v.Missing, missingProperty: $e }, { schemaPath: $e })) : _.assign(fe, !0);
+      }
+    }
+    function B(re, G, ue) {
+      f.subschema({
+        keyword: G,
+        schemaProp: re,
+        dataProp: re
+      }, ue);
+    }
+    function oe() {
+      _.forIn("key", D, (re) => {
+        const G = W(re, h, "properties", R.jtdDiscriminator), ue = W(re, b, "optionalProperties"), fe = G === !0 ? ue : ue === !0 ? G : (0, n.and)(G, ue);
+        _.if(fe, () => {
+          R.opts.removeAdditional ? _.code((0, n._)`delete ${D}[${re}]`) : (f.error(!1, { propError: v.Additional, additionalProperty: re }, { instancePath: re, parentSchema: !0 }), R.opts.allErrors || _.break());
+        });
+      });
+    }
+    function W(re, G, ue, fe) {
+      let _e;
+      if (G.length > 8) {
+        const $e = (0, r.schemaRefOrVal)(R, A[ue], ue);
+        _e = (0, n.not)((0, t.isOwnProperty)(_, $e, re)), fe !== void 0 && (_e = (0, n.and)(_e, (0, n._)`${re} !== ${fe}`));
+      } else if (G.length || fe !== void 0) {
+        const $e = fe === void 0 ? G : [fe].concat(G);
+        _e = (0, n.and)(...$e.map((Ze) => (0, n._)`${re} !== ${Ze}`));
+      } else
+        _e = !0;
+      return _e;
+    }
+  }
+  e.validateProperties = p, e.default = g;
+})(zr);
+var Ur = {};
+Object.defineProperty(Ur, "__esModule", { value: !0 });
+const Rn = zr, Xo = {
+  keyword: "optionalProperties",
+  schemaType: "object",
+  error: Rn.error,
+  code(e) {
+    e.parentSchema.properties || (0, Rn.validateProperties)(e);
+  }
+};
+Ur.default = Xo;
+var Kr = {}, fa = {};
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.DiscrError = void 0, function(t) {
+    t.Tag = "tag", t.Mapping = "mapping";
+  }(e.DiscrError || (e.DiscrError = {}));
+})(fa);
+Object.defineProperty(Kr, "__esModule", { value: !0 });
+const ft = ne, Zo = Ce, xo = Je, jn = Oe, or = fa, ei = {
+  message: (e) => {
+    const { schema: t, params: r } = e;
+    return r.discrError ? r.discrError === or.DiscrError.Tag ? `tag "${t}" must be string` : `value of tag "${t}" must be in mapping` : (0, jn.typeErrorMessage)(e, "object");
+  },
+  params: (e) => {
+    const { schema: t, params: r } = e;
+    return r.discrError ? (0, ft._)`{error: ${r.discrError}, tag: ${t}, tagValue: ${r.tag}}` : (0, jn.typeErrorParams)(e, "object");
+  }
+}, ti = {
+  keyword: "discriminator",
+  schemaType: "string",
+  implements: ["mapping"],
+  error: ei,
+  code(e) {
+    (0, Zo.checkMetadata)(e);
+    const { gen: t, data: r, schema: n, parentSchema: a } = e, [i, d] = (0, xo.checkNullableObject)(e, r);
+    t.if(d), v(), t.elseIf((0, ft.not)(i)), e.error(), t.endIf(), e.ok(i);
+    function v() {
+      const f = t.const("tag", (0, ft._)`${r}${(0, ft.getProperty)(n)}`);
+      t.if((0, ft._)`${f} === undefined`), e.error(!1, { discrError: or.DiscrError.Tag, tag: f }), t.elseIf((0, ft._)`typeof ${f} == "string"`), g(f), t.else(), e.error(!1, { discrError: or.DiscrError.Tag, tag: f }, { instancePath: n }), t.endIf();
+    }
+    function g(f) {
+      t.if(!1);
+      for (const _ in a.mapping)
+        t.elseIf((0, ft._)`${f} === ${_}`), t.assign(i, p(_));
+      t.else(), e.error(!1, { discrError: or.DiscrError.Mapping, tag: f }, { instancePath: n, schemaPath: "mapping", parentSchema: !0 }), t.endIf();
+    }
+    function p(f) {
+      const _ = t.name("valid");
+      return e.subschema({
+        keyword: "mapping",
+        schemaProp: f,
+        jtdDiscriminator: n
+      }, _), _;
+    }
+  }
+};
+Kr.default = ti;
+var Lr = {};
+Object.defineProperty(Lr, "__esModule", { value: !0 });
+const On = ye, rr = ne, ri = Ce, ni = Je, ai = Oe, si = {
+  keyword: "values",
+  schemaType: "object",
+  error: (0, ai.typeError)("object"),
+  code(e) {
+    (0, ri.checkMetadata)(e);
+    const { gen: t, data: r, schema: n, it: a } = e, [i, d] = (0, ni.checkNullableObject)(e, r);
+    (0, On.alwaysValidSchema)(a, n) ? t.if((0, rr.not)((0, rr.or)(d, i)), () => e.error()) : (t.if(d), t.assign(i, v()), t.elseIf((0, rr.not)(i)), e.error(), t.endIf()), e.ok(i);
+    function v() {
+      const g = t.name("valid");
+      if (a.allErrors) {
+        const f = t.let("valid", !0);
+        return p(() => t.assign(f, !1)), f;
+      }
+      return t.var(g, !0), p(() => t.break()), g;
+      function p(f) {
+        t.forIn("key", r, (_) => {
+          e.subschema({
+            keyword: "values",
+            dataProp: _,
+            dataPropType: On.Type.Str
+          }, g), t.if((0, rr.not)(g), f);
+        });
+      }
+    }
+  }
+};
+Lr.default = si;
+var Jr = {};
+Object.defineProperty(Jr, "__esModule", { value: !0 });
+const oi = te, ii = {
+  keyword: "union",
+  schemaType: "array",
+  trackErrors: !0,
+  code: oi.validateUnion,
+  error: { message: "must match a schema in union" }
+};
+Jr.default = ii;
+Object.defineProperty(kr, "__esModule", { value: !0 });
+const ci = yt, ui = Mr, li = Vr, di = Fr, fi = zr, hi = Ur, pi = Kr, mi = Lr, vi = Jr, _i = Ce, yi = [
+  "definitions",
+  ci.default,
+  ui.default,
+  li.default,
+  di.default,
+  fi.default,
+  hi.default,
+  pi.default,
+  mi.default,
+  vi.default,
+  _i.default,
+  { keyword: "additionalProperties", schemaType: "boolean" },
+  { keyword: "nullable", schemaType: "boolean" }
+];
+kr.default = yi;
+var qr = {};
+Object.defineProperty(qr, "__esModule", { value: !0 });
+const Xe = (e) => {
+  const t = {
+    nullable: { type: "boolean" },
+    metadata: {
+      optionalProperties: {
+        union: { elements: { ref: "schema" } }
+      },
+      additionalProperties: !0
+    }
+  };
+  return e && (t.definitions = { values: { ref: "schema" } }), t;
+}, gi = (e) => ({
+  optionalProperties: Xe(e)
+}), $i = (e) => ({
+  properties: {
+    ref: { type: "string" }
+  },
+  optionalProperties: Xe(e)
+}), Ei = (e) => ({
+  properties: {
+    type: {
+      enum: [
+        "boolean",
+        "timestamp",
+        "string",
+        "float32",
+        "float64",
+        "int8",
+        "uint8",
+        "int16",
+        "uint16",
+        "int32",
+        "uint32"
+      ]
+    }
+  },
+  optionalProperties: Xe(e)
+}), wi = (e) => ({
+  properties: {
+    enum: { elements: { type: "string" } }
+  },
+  optionalProperties: Xe(e)
+}), Si = (e) => ({
+  properties: {
+    elements: { ref: "schema" }
+  },
+  optionalProperties: Xe(e)
+}), ha = (e) => ({
+  properties: {
+    properties: { values: { ref: "schema" } }
+  },
+  optionalProperties: {
+    optionalProperties: { values: { ref: "schema" } },
+    additionalProperties: { type: "boolean" },
+    ...Xe(e)
+  }
+}), pa = (e) => ({
+  properties: {
+    optionalProperties: { values: { ref: "schema" } }
+  },
+  optionalProperties: {
+    additionalProperties: { type: "boolean" },
+    ...Xe(e)
+  }
+}), bi = (e) => ({
+  properties: {
+    discriminator: { type: "string" },
+    mapping: {
+      values: {
+        metadata: {
+          union: [ha(!1), pa(!1)]
+        }
+      }
+    }
+  },
+  optionalProperties: Xe(e)
+}), Pi = (e) => ({
+  properties: {
+    values: { ref: "schema" }
+  },
+  optionalProperties: Xe(e)
+}), Dn = (e) => ({
+  metadata: {
+    union: [
+      gi,
+      $i,
+      Ei,
+      wi,
+      Si,
+      ha,
+      pa,
+      bi,
+      Pi
+    ].map((t) => t(e))
+  }
+}), Ni = {
+  definitions: {
+    schema: Dn(!1)
+  },
+  ...Dn(!0)
+};
+qr.default = Ni;
+var Hr = {}, Qt = {};
+Object.defineProperty(Qt, "__esModule", { value: !0 });
+Qt.jtdForms = void 0;
+Qt.jtdForms = [
+  "elements",
+  "values",
+  "discriminator",
+  "properties",
+  "optionalProperties",
+  "enum",
+  "type",
+  "ref"
+];
+var Gr = {};
+Object.defineProperty(Gr, "__esModule", { value: !0 });
+const Er = (
+  // eslint-disable-next-line no-control-regex, no-misleading-character-class
+  /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g
+), Ri = {
+  "\b": "\\b",
+  "	": "\\t",
+  "\n": "\\n",
+  "\f": "\\f",
+  "\r": "\\r",
+  '"': '\\"',
+  "\\": "\\\\"
+};
+function ma(e) {
+  return Er.lastIndex = 0, '"' + (Er.test(e) ? e.replace(Er, (t) => {
+    const r = Ri[t];
+    return typeof r == "string" ? r : "\\u" + ("0000" + t.charCodeAt(0).toString(16)).slice(-4);
+  }) : e) + '"';
+}
+Gr.default = ma;
+ma.code = 'require("ajv/dist/runtime/quote").default';
+Object.defineProperty(Hr, "__esModule", { value: !0 });
+const ji = Qt, va = we, Z = ne, Oi = ot, se = De, Di = te, Ci = yt, Ti = ye, Ii = Gr, ki = {
+  elements: Mi,
+  values: Vi,
+  discriminator: Fi,
+  properties: Cn,
+  optionalProperties: Cn,
+  enum: Ht,
+  type: zi,
+  ref: Ki
+};
+function _a(e, t) {
+  const r = va.getCompilingSchema.call(this, e);
+  if (r)
+    return r;
+  const { es5: n, lines: a } = this.opts.code, { ownProperties: i } = this.opts, d = new Z.CodeGen(this.scope, { es5: n, lines: a, ownProperties: i }), v = d.scopeName("serialize"), g = {
+    self: this,
+    gen: d,
+    schema: e.schema,
+    schemaEnv: e,
+    definitions: t,
+    data: se.default.data
+  };
+  let p;
+  try {
+    this._compilations.add(e), e.serializeName = v, d.func(v, se.default.data, !1, () => {
+      d.let(se.default.json, (0, Z.str)``), Yt(g), d.return(se.default.json);
+    }), d.optimize(this.opts.code.optimize);
+    const f = d.toString();
+    p = `${d.scopeRefs(se.default.scope)}return ${f}`;
+    const D = new Function(`${se.default.scope}`, p)(this.scope.get());
+    this.scope.value(v, { ref: D }), e.serialize = D;
+  } catch (f) {
+    throw p && this.logger.error("Error compiling serializer, function code:", p), delete e.serialize, delete e.serializeName, f;
+  } finally {
+    this._compilations.delete(e);
+  }
+  return e;
+}
+Hr.default = _a;
+function Yt(e) {
+  let t;
+  for (const r of ji.jtdForms)
+    if (r in e.schema) {
+      t = r;
+      break;
+    }
+  Ai(e, t ? ki[t] : Ji);
+}
+function Ai(e, t) {
+  const { gen: r, schema: n, data: a } = e;
+  if (!n.nullable)
+    return t(e);
+  r.if((0, Z._)`${a} === undefined || ${a} === null`, () => r.add(se.default.json, (0, Z._)`"null"`), () => t(e));
+}
+function Mi(e) {
+  const { gen: t, schema: r, data: n } = e;
+  t.add(se.default.json, (0, Z.str)`[`);
+  const a = t.let("first", !0);
+  t.forOf("el", n, (i) => {
+    Br(e, a), Yt({ ...e, schema: r.elements, data: i });
+  }), t.add(se.default.json, (0, Z.str)`]`);
+}
+function Vi(e) {
+  const { gen: t, schema: r, data: n } = e;
+  t.add(se.default.json, (0, Z.str)`{`);
+  const a = t.let("first", !0);
+  t.forIn("key", n, (i) => ya(e, i, r.values, a)), t.add(se.default.json, (0, Z.str)`}`);
+}
+function ya(e, t, r, n) {
+  const { gen: a, data: i } = e;
+  Br(e, n), Ht({ ...e, data: t }), a.add(se.default.json, (0, Z.str)`:`);
+  const d = a.const("value", (0, Z._)`${i}${(0, Z.getProperty)(t)}`);
+  Yt({ ...e, schema: r, data: d });
+}
+function Fi(e) {
+  const { gen: t, schema: r, data: n } = e, { discriminator: a } = r;
+  t.add(se.default.json, (0, Z.str)`{${JSON.stringify(a)}:`);
+  const i = t.const("tag", (0, Z._)`${n}${(0, Z.getProperty)(a)}`);
+  Ht({ ...e, data: i }), t.if(!1);
+  for (const d in r.mapping) {
+    t.elseIf((0, Z._)`${i} === ${d}`);
+    const v = r.mapping[d];
+    ga({ ...e, schema: v }, a);
+  }
+  t.endIf(), t.add(se.default.json, (0, Z.str)`}`);
+}
+function Cn(e) {
+  const { gen: t } = e;
+  t.add(se.default.json, (0, Z.str)`{`), ga(e), t.add(se.default.json, (0, Z.str)`}`);
+}
+function ga(e, t) {
+  const { gen: r, schema: n, data: a } = e, { properties: i, optionalProperties: d } = n, v = D(i), g = D(d), p = A(v.concat(g));
+  let f = !t, _;
+  for (const h of v)
+    f ? f = !1 : r.add(se.default.json, (0, Z.str)`,`), I(h, i[h], R(h));
+  f && (_ = r.let("first", !0));
+  for (const h of g) {
+    const P = R(h);
+    r.if((0, Z.and)((0, Z._)`${P} !== undefined`, (0, Di.isOwnProperty)(r, a, h)), () => {
+      Br(e, _), I(h, d[h], P);
+    });
+  }
+  n.additionalProperties && r.forIn("key", a, (h) => r.if(j(h, p), () => ya(e, h, {}, _)));
+  function D(h) {
+    return h ? Object.keys(h) : [];
+  }
+  function A(h) {
+    if (t && h.push(t), new Set(h).size !== h.length)
+      throw new Error("JTD: properties/optionalProperties/disciminator overlap");
+    return h;
+  }
+  function R(h) {
+    return r.const("value", (0, Z._)`${a}${(0, Z.getProperty)(h)}`);
+  }
+  function I(h, P, b) {
+    r.add(se.default.json, (0, Z.str)`${JSON.stringify(h)}:`), Yt({ ...e, schema: P, data: b });
+  }
+  function j(h, P) {
+    return P.length ? (0, Z.and)(...P.map((b) => (0, Z._)`${h} !== ${b}`)) : !0;
+  }
+}
+function zi(e) {
+  const { gen: t, schema: r, data: n } = e;
+  switch (r.type) {
+    case "boolean":
+      t.add(se.default.json, (0, Z._)`${n} ? "true" : "false"`);
+      break;
+    case "string":
+      Ht(e);
+      break;
+    case "timestamp":
+      t.if((0, Z._)`${n} instanceof Date`, () => t.add(se.default.json, (0, Z._)`'"' + ${n}.toISOString() + '"'`), () => Ht(e));
+      break;
+    default:
+      Ui(e);
+  }
+}
+function Ht({ gen: e, data: t }) {
+  e.add(se.default.json, (0, Z._)`${(0, Ti.useFunc)(e, Ii.default)}(${t})`);
+}
+function Ui({ gen: e, data: t }) {
+  e.add(se.default.json, (0, Z._)`"" + ${t}`);
+}
+function Ki(e) {
+  const { gen: t, self: r, data: n, definitions: a, schema: i, schemaEnv: d } = e, { ref: v } = i, g = a[v];
+  if (!g)
+    throw new Oi.default(r.opts.uriResolver, "", v, `No definition ${v}`);
+  if (!(0, Ci.hasRef)(g))
+    return Yt({ ...e, schema: g });
+  const { root: p } = d, f = _a.call(r, new va.SchemaEnv({ schema: g, root: p }), a);
+  t.add(se.default.json, (0, Z._)`${Li(t, f)}(${n})`);
+}
+function Li(e, t) {
+  return t.serialize ? e.scopeValue("serialize", { ref: t.serialize }) : (0, Z._)`${e.scopeValue("wrapper", { ref: t })}.serialize`;
+}
+function Ji({ gen: e, data: t }) {
+  e.add(se.default.json, (0, Z._)`JSON.stringify(${t})`);
+}
+function Br({ gen: e }, t) {
+  t ? e.if(t, () => e.assign(t, !1), () => e.add(se.default.json, (0, Z.str)`,`)) : e.add(se.default.json, (0, Z.str)`,`);
+}
+var Wr = {}, st = {};
+Object.defineProperty(st, "__esModule", { value: !0 });
+st.parseJsonString = st.parseJsonNumber = st.parseJson = void 0;
+const qi = /position\s(\d+)$/;
+function Ge(e, t) {
+  let r;
+  Ge.message = void 0;
+  let n;
+  t && (e = e.slice(t));
+  try {
+    return Ge.position = t + e.length, JSON.parse(e);
+  } catch (a) {
+    if (n = qi.exec(a.message), !n) {
+      Ge.message = "unexpected end";
+      return;
+    }
+    r = +n[1];
+    const i = e[r];
+    e = e.slice(0, r), Ge.position = t + r;
+    try {
+      return JSON.parse(e);
+    } catch {
+      Ge.message = `unexpected token ${i}`;
+      return;
+    }
+  }
+}
+st.parseJson = Ge;
+Ge.message = void 0;
+Ge.position = 0;
+Ge.code = 'require("ajv/dist/runtime/parseJson").parseJson';
+function Be(e, t, r) {
+  let n = "", a;
+  if (Be.message = void 0, e[t] === "-" && (n += "-", t++), e[t] === "0")
+    n += "0", t++;
+  else if (!i(r)) {
+    d();
+    return;
+  }
+  if (r)
+    return Be.position = t, +n;
+  if (e[t] === "." && (n += ".", t++, !i())) {
+    d();
+    return;
+  }
+  if (a = e[t], (a === "e" || a === "E") && (n += "e", t++, a = e[t], (a === "+" || a === "-") && (n += a, t++), !i())) {
+    d();
+    return;
+  }
+  return Be.position = t, +n;
+  function i(v) {
+    let g = !1;
+    for (; a = e[t], a >= "0" && a <= "9" && (v === void 0 || v-- > 0); )
+      g = !0, n += a, t++;
+    return g;
+  }
+  function d() {
+    Be.position = t, Be.message = t < e.length ? `unexpected token ${e[t]}` : "unexpected end";
+  }
+}
+st.parseJsonNumber = Be;
+Be.message = void 0;
+Be.position = 0;
+Be.code = 'require("ajv/dist/runtime/parseJson").parseJsonNumber';
+const Tn = {
+  b: "\b",
+  f: "\f",
+  n: `
+`,
+  r: "\r",
+  t: "	",
+  '"': '"',
+  "/": "/",
+  "\\": "\\"
+}, Hi = "a".charCodeAt(0), Gi = "0".charCodeAt(0);
+function nt(e, t) {
+  let r = "", n;
+  for (nt.message = void 0; n = e[t++], n !== '"'; )
+    if (n === "\\")
+      if (n = e[t], n in Tn)
+        r += Tn[n], t++;
+      else if (n === "u") {
+        t++;
+        let i = 4, d = 0;
+        for (; i--; ) {
+          if (d <<= 4, n = e[t], n === void 0) {
+            a("unexpected end");
+            return;
+          }
+          if (n = n.toLowerCase(), n >= "a" && n <= "f")
+            d += n.charCodeAt(0) - Hi + 10;
+          else if (n >= "0" && n <= "9")
+            d += n.charCodeAt(0) - Gi;
+          else {
+            a(`unexpected token ${n}`);
+            return;
+          }
+          t++;
+        }
+        r += String.fromCharCode(d);
+      } else {
+        a(`unexpected token ${n}`);
+        return;
+      }
+    else if (n === void 0) {
+      a("unexpected end");
+      return;
+    } else if (n.charCodeAt(0) >= 32)
+      r += n;
+    else {
+      a(`unexpected token ${n}`);
+      return;
+    }
+  return nt.position = t, r;
+  function a(i) {
+    nt.position = t, nt.message = i;
+  }
+}
+st.parseJsonString = nt;
+nt.message = void 0;
+nt.position = 0;
+nt.code = 'require("ajv/dist/runtime/parseJson").parseJsonString';
+Object.defineProperty(Wr, "__esModule", { value: !0 });
+const Bi = Qt, $a = we, z = ne, Wi = ot, Q = De, Qi = te, Yi = yt, Xi = Mr, Qr = st, Ea = ye, Zi = pr, xi = {
+  elements: nc,
+  values: ac,
+  discriminator: oc,
+  properties: In,
+  optionalProperties: In,
+  enum: cc,
+  type: ic,
+  ref: uc
+};
+function wa(e, t) {
+  const r = $a.getCompilingSchema.call(this, e);
+  if (r)
+    return r;
+  const { es5: n, lines: a } = this.opts.code, { ownProperties: i } = this.opts, d = new z.CodeGen(this.scope, { es5: n, lines: a, ownProperties: i }), v = d.scopeName("parse"), g = {
+    self: this,
+    gen: d,
+    schema: e.schema,
+    schemaEnv: e,
+    definitions: t,
+    data: Q.default.data,
+    parseName: v,
+    char: d.name("c")
+  };
+  let p;
+  try {
+    this._compilations.add(e), e.parseName = v, ec(g), d.optimize(this.opts.code.optimize);
+    const f = d.toString();
+    p = `${d.scopeRefs(Q.default.scope)}return ${f}`;
+    const D = new Function(`${Q.default.scope}`, p)(this.scope.get());
+    this.scope.value(v, { ref: D }), e.parse = D;
+  } catch (f) {
+    throw p && this.logger.error("Error compiling parser, function code:", p), delete e.parse, delete e.parseName, f;
+  } finally {
+    this._compilations.delete(e);
+  }
+  return e;
+}
+Wr.default = wa;
+const Nr = (0, z._)`undefined`;
+function ec(e) {
+  const { gen: t, parseName: r, char: n } = e;
+  t.func(r, (0, z._)`${Q.default.json}, ${Q.default.jsonPos}, ${Q.default.jsonPart}`, !1, () => {
+    t.let(Q.default.data), t.let(n), t.assign((0, z._)`${r}.message`, Nr), t.assign((0, z._)`${r}.position`, Nr), t.assign(Q.default.jsonPos, (0, z._)`${Q.default.jsonPos} || 0`), t.const(Q.default.jsonLen, (0, z._)`${Q.default.json}.length`), mr(e), xr(e), t.if(Q.default.jsonPart, () => {
+      t.assign((0, z._)`${r}.position`, Q.default.jsonPos), t.return(Q.default.data);
+    }), t.if((0, z._)`${Q.default.jsonPos} === ${Q.default.jsonLen}`, () => t.return(Q.default.data)), Ct(e);
+  });
+}
+function mr(e) {
+  let t;
+  for (const r of Bi.jtdForms)
+    if (r in e.schema) {
+      t = r;
+      break;
+    }
+  t ? rc(e, xi[t]) : Xr(e);
+}
+const tc = An(!0, An(!1, Ct));
+function rc(e, t) {
+  const { gen: r, schema: n, data: a } = e;
+  if (!n.nullable)
+    return t(e);
+  Gt(e, "null", t, () => r.assign(a, null));
+}
+function nc(e) {
+  const { gen: t, schema: r, data: n } = e;
+  qe(e, "[");
+  const a = t.let("i", 0);
+  t.assign(n, (0, z._)`[]`), Yr(e, "]", () => {
+    const i = t.let("el");
+    mr({ ...e, schema: r.elements, data: i }), t.assign((0, z._)`${n}[${a}++]`, i);
+  });
+}
+function ac(e) {
+  const { gen: t, schema: r, data: n } = e;
+  qe(e, "{"), t.assign(n, (0, z._)`{}`), Yr(e, "}", () => sc(e, r.values));
+}
+function Yr(e, t, r) {
+  Sa(e, t, r), qe(e, t);
+}
+function Sa(e, t, r) {
+  const { gen: n } = e;
+  n.for((0, z._)`;${Q.default.jsonPos}<${Q.default.jsonLen} && ${vr(1)}!==${t};`, () => {
+    r(), Gt(e, ",", () => n.break(), a);
+  });
+  function a() {
+    Gt(e, t, () => {
+    }, Ct);
+  }
+}
+function sc(e, t) {
+  const { gen: r } = e, n = r.let("key");
+  _t({ ...e, data: n }), qe(e, ":"), Pa(e, n, t);
+}
+function oc(e) {
+  const { gen: t, data: r, schema: n } = e, { discriminator: a, mapping: i } = n;
+  qe(e, "{"), t.assign(r, (0, z._)`{}`);
+  const d = t.const("pos", Q.default.jsonPos), v = t.let("value"), g = t.let("tag");
+  Sa(e, "}", () => {
+    const p = t.let("key");
+    _t({ ...e, data: p }), qe(e, ":"), t.if(
+      (0, z._)`${p} === ${a}`,
+      () => {
+        _t({ ...e, data: g }), t.assign((0, z._)`${r}[${p}]`, g), t.break();
+      },
+      () => Xr({ ...e, data: v })
+      // can be discarded/skipped
+    );
+  }), t.assign(Q.default.jsonPos, d), t.if((0, z._)`${g} === undefined`), Ye(e, (0, z.str)`discriminator tag not found`);
+  for (const p in i)
+    t.elseIf((0, z._)`${g} === ${p}`), ba({ ...e, schema: i[p] }, a);
+  t.else(), Ye(e, (0, z.str)`discriminator value not in schema`), t.endIf();
+}
+function In(e) {
+  const { gen: t, data: r } = e;
+  qe(e, "{"), t.assign(r, (0, z._)`{}`), ba(e);
+}
+function ba(e, t) {
+  const { gen: r, schema: n, data: a } = e, { properties: i, optionalProperties: d, additionalProperties: v } = n;
+  if (Yr(e, "}", () => {
+    const g = r.let("key");
+    if (_t({ ...e, data: g }), qe(e, ":"), r.if(!1), kn(e, g, i), kn(e, g, d), t) {
+      r.elseIf((0, z._)`${g} === ${t}`);
+      const p = r.let("tag");
+      _t({ ...e, data: p });
+    }
+    r.else(), v ? Xr({ ...e, data: (0, z._)`${a}[${g}]` }) : Ye(e, (0, z.str)`property ${g} not allowed`), r.endIf();
+  }), i) {
+    const g = (0, Qi.hasPropFunc)(r), p = (0, z.and)(...Object.keys(i).map((f) => (0, z._)`${g}.call(${a}, ${f})`));
+    r.if((0, z.not)(p), () => Ye(e, (0, z.str)`missing required properties`));
+  }
+}
+function kn(e, t, r = {}) {
+  const { gen: n } = e;
+  for (const a in r)
+    n.elseIf((0, z._)`${t} === ${a}`), Pa(e, t, r[a]);
+}
+function Pa(e, t, r) {
+  mr({ ...e, schema: r, data: (0, z._)`${e.data}[${t}]` });
+}
+function ic(e) {
+  const { gen: t, schema: r, data: n, self: a } = e;
+  switch (r.type) {
+    case "boolean":
+      tc(e);
+      break;
+    case "string":
+      _t(e);
+      break;
+    case "timestamp": {
+      _t(e);
+      const i = (0, Ea.useFunc)(t, Zi.default), { allowDate: d, parseDate: v } = a.opts, g = d ? (0, z._)`!${i}(${n}, true)` : (0, z._)`!${i}(${n})`, p = v ? (0, z.or)(g, (0, z._)`(${n} = new Date(${n}), false)`, (0, z._)`isNaN(${n}.valueOf())`) : g;
+      t.if(p, () => Ye(e, (0, z.str)`invalid timestamp`));
+      break;
+    }
+    case "float32":
+    case "float64":
+      wr(e);
+      break;
+    default: {
+      const i = r.type;
+      if (!a.opts.int32range && (i === "int32" || i === "uint32"))
+        wr(e, 16), i === "uint32" && t.if((0, z._)`${n} < 0`, () => Ye(e, (0, z.str)`integer out of range`));
+      else {
+        const [d, v, g] = Xi.intRange[i];
+        wr(e, g), t.if((0, z._)`${n} < ${d} || ${n} > ${v}`, () => Ye(e, (0, z.str)`integer out of range`));
+      }
+    }
+  }
+}
+function _t(e) {
+  qe(e, '"'), Zr(e, Qr.parseJsonString);
+}
+function cc(e) {
+  const { gen: t, data: r, schema: n } = e, a = n.enum;
+  qe(e, '"'), t.if(!1);
+  for (const i of a) {
+    const d = JSON.stringify(i).slice(1);
+    t.elseIf((0, z._)`${vr(d.length)} === ${d}`), t.assign(r, (0, z.str)`${i}`), t.add(Q.default.jsonPos, d.length);
+  }
+  t.else(), Ct(e), t.endIf();
+}
+function wr(e, t) {
+  const { gen: r } = e;
+  xr(e), r.if((0, z._)`"-0123456789".indexOf(${vr(1)}) < 0`, () => Ct(e), () => Zr(e, Qr.parseJsonNumber, t));
+}
+function An(e, t) {
+  return (r) => {
+    const { gen: n, data: a } = r;
+    Gt(r, `${e}`, () => t(r), () => n.assign(a, e));
+  };
+}
+function uc(e) {
+  const { gen: t, self: r, definitions: n, schema: a, schemaEnv: i } = e, { ref: d } = a, v = n[d];
+  if (!v)
+    throw new Wi.default(r.opts.uriResolver, "", d, `No definition ${d}`);
+  if (!(0, Yi.hasRef)(v))
+    return mr({ ...e, schema: v });
+  const { root: g } = i, p = wa.call(r, new $a.SchemaEnv({ schema: v, root: g }), n);
+  Na(e, lc(t, p), !0);
+}
+function lc(e, t) {
+  return t.parse ? e.scopeValue("parse", { ref: t.parse }) : (0, z._)`${e.scopeValue("wrapper", { ref: t })}.parse`;
+}
+function Xr(e) {
+  Zr(e, Qr.parseJson);
+}
+function Zr(e, t, r) {
+  Na(e, (0, Ea.useFunc)(e.gen, t), r);
+}
+function Na(e, t, r) {
+  const { gen: n, data: a } = e;
+  n.assign(a, (0, z._)`${t}(${Q.default.json}, ${Q.default.jsonPos}${r ? (0, z._)`, ${r}` : z.nil})`), n.assign(Q.default.jsonPos, (0, z._)`${t}.position`), n.if((0, z._)`${a} === undefined`, () => Ye(e, (0, z._)`${t}.message`));
+}
+function qe(e, t) {
+  Gt(e, t, Ct);
+}
+function Gt(e, t, r, n) {
+  const { gen: a } = e, i = t.length;
+  xr(e), a.if((0, z._)`${vr(i)} === ${t}`, () => {
+    a.add(Q.default.jsonPos, i), n == null || n(e);
+  }, () => r(e));
+}
+function xr({ gen: e, char: t }) {
+  e.code((0, z._)`while((${t}=${Q.default.json}[${Q.default.jsonPos}],${t}===" "||${t}==="\\n"||${t}==="\\r"||${t}==="\\t"))${Q.default.jsonPos}++;`);
+}
+function vr(e) {
+  return e === 1 ? (0, z._)`${Q.default.json}[${Q.default.jsonPos}]` : (0, z._)`${Q.default.json}.slice(${Q.default.jsonPos}, ${Q.default.jsonPos}+${e})`;
+}
+function Ct(e) {
+  Ye(e, (0, z._)`"unexpected token " + ${Q.default.json}[${Q.default.jsonPos}]`);
+}
+function Ye({ gen: e, parseName: t }, r) {
+  e.assign((0, z._)`${t}.message`, r), e.assign((0, z._)`${t}.position`, Q.default.jsonPos), e.return(Nr);
+}
+(function(e, t) {
+  Object.defineProperty(t, "__esModule", { value: !0 }), t.MissingRefError = t.ValidationError = t.CodeGen = t.Name = t.nil = t.stringify = t.str = t._ = t.KeywordCxt = void 0;
+  const r = Mn, n = kr, a = qr, i = Hr, d = Wr, v = "JTD-meta-schema";
+  class g extends r.default {
+    constructor(R = {}) {
+      super({
+        ...R,
+        jtd: !0
+      });
+    }
+    _addVocabularies() {
+      super._addVocabularies(), this.addVocabulary(n.default);
+    }
+    _addDefaultMetaSchema() {
+      super._addDefaultMetaSchema(), this.opts.meta && this.addMetaSchema(a.default, v, !1);
+    }
+    defaultMeta() {
+      return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(v) ? v : void 0);
+    }
+    compileSerializer(R) {
+      const I = this._addSchema(R);
+      return I.serialize || this._compileSerializer(I);
+    }
+    compileParser(R) {
+      const I = this._addSchema(R);
+      return I.parse || this._compileParser(I);
+    }
+    _compileSerializer(R) {
+      if (i.default.call(this, R, R.schema.definitions || {}), !R.serialize)
+        throw new Error("ajv implementation error");
+      return R.serialize;
+    }
+    _compileParser(R) {
+      if (d.default.call(this, R, R.schema.definitions || {}), !R.parse)
+        throw new Error("ajv implementation error");
+      return R.parse;
+    }
+  }
+  e.exports = t = g, Object.defineProperty(t, "__esModule", { value: !0 }), t.default = g;
+  var p = Le;
+  Object.defineProperty(t, "KeywordCxt", { enumerable: !0, get: function() {
+    return p.KeywordCxt;
+  } });
+  var f = ne;
+  Object.defineProperty(t, "_", { enumerable: !0, get: function() {
+    return f._;
+  } }), Object.defineProperty(t, "str", { enumerable: !0, get: function() {
+    return f.str;
+  } }), Object.defineProperty(t, "stringify", { enumerable: !0, get: function() {
+    return f.stringify;
+  } }), Object.defineProperty(t, "nil", { enumerable: !0, get: function() {
+    return f.nil;
+  } }), Object.defineProperty(t, "Name", { enumerable: !0, get: function() {
+    return f.Name;
+  } }), Object.defineProperty(t, "CodeGen", { enumerable: !0, get: function() {
+    return f.CodeGen;
+  } });
+  var _ = Wt;
+  Object.defineProperty(t, "ValidationError", { enumerable: !0, get: function() {
+    return _.default;
+  } });
+  var D = ot;
+  Object.defineProperty(t, "MissingRefError", { enumerable: !0, get: function() {
+    return D.default;
+  } });
+})(Ja, ir);
+const dc = /* @__PURE__ */ La(ir), Ra = new dc(), fc = (e, t) => e(t) ? null : e.errors;
+function Ec(e, t) {
+  Ra.addSchema(t, e);
+}
+function hc(e, t) {
+  const r = Ra.getSchema(e);
+  if (r)
+    return fc(r, t);
 }
-class F {
-  constructor(e = null) {
-    n(this, "_options");
-    this._options = e, e !== null && (typeof e.validator > "u" || S(e.validator, e));
+class wc {
+  constructor(t = null) {
+    Nt(this, "_options");
+    this._options = t, t !== null && (typeof t.validator > "u" || hc(t.validator, t));
   }
   get options() {
     return this._options;
   }
 }
-async function l(E = 1e3) {
-  return new Promise((e) => setTimeout(e, E));
+async function pc(e = 1e3) {
+  return new Promise((t) => setTimeout(t, e));
 }
-async function A() {
-  return l(100);
+async function Sc() {
+  return pc(100);
 }
-var U = /* @__PURE__ */ ((E) => (E.AUDIENCE = "AUDIENCE", E.CLIENT_ID = "client_id", E.CLIENT_SECRET = "client_secret", E.RESPONSE_TYPE = "response_type", E.SCOPE = "scope", E.STATE = "state", E.REDIRECT_URI = "redirect_uri", E.ERROR = "error", E.ERROR_DESCRIPTION = "error_description", E.ERROR_CODES = "error_codes", E.ERROR_URI = "error_uri", E.GRANT_TYPE = "grant_type", E.CODE = "code", E.ACCESS_TOKEN = "access_token", E.TOKEN_TYPE = "token_type", E.EXPIRES_IN = "expires_in", E.USERNAME = "username", E.PASSWORD = "password", E.REFRESH_TOKEN = "refresh_token", E.RESPONSE_MODE = "response_mode", E.TIMESTAMP = "timestamp", E.TRACE_ID = "trace_id", E.CORRELATION_ID = "correlation_id", E))(U || {}), L = /* @__PURE__ */ ((E) => (E.SUB = "sub", E.NAME = "name", E.GIVEN_NAME = "given_name", E.FAMILY_NAME = "family_name", E.MIDDLE_NAME = "middle_name", E.NICKNAME = "nickname", E.PREFERRED_USERNAME = "preferred_username", E.PROFILE = "profile", E.PICTURE = "picture", E.WEBSITE = "website", E.EMAIL = "email", E.EMAIL_VERIFIED = "email_verified", E.GENDER = "gender", E.BIRTHDATE = "birthdate", E.ZONEINFO = "zoneinfo", E.LOCALE = "locale", E.PHONE_NUMBER = "phone_number", E.PHONE_NUMBER_VERIFIED = "phone_number_verified", E.ADDRESS = "address", E.CLIENT_SECRET = "client_secret", E.NONCE = "nonce", E))(L || {}), M = /* @__PURE__ */ ((E) => (E.FORMATTED = "formatted", E.STREET_ADDRESS = "street_address", E.LOCALITY = "locality", E.REGION = "region", E.COUNTRY = "country", E))(M || {});
-class _ {
+var mc = /* @__PURE__ */ ((e) => (e.AUDIENCE = "AUDIENCE", e.CLIENT_ID = "client_id", e.CLIENT_SECRET = "client_secret", e.RESPONSE_TYPE = "response_type", e.SCOPE = "scope", e.STATE = "state", e.REDIRECT_URI = "redirect_uri", e.ERROR = "error", e.ERROR_DESCRIPTION = "error_description", e.ERROR_CODES = "error_codes", e.ERROR_URI = "error_uri", e.GRANT_TYPE = "grant_type", e.CODE = "code", e.ACCESS_TOKEN = "access_token", e.TOKEN_TYPE = "token_type", e.EXPIRES_IN = "expires_in", e.USERNAME = "username", e.PASSWORD = "password", e.REFRESH_TOKEN = "refresh_token", e.RESPONSE_MODE = "response_mode", e.TIMESTAMP = "timestamp", e.TRACE_ID = "trace_id", e.CORRELATION_ID = "correlation_id", e))(mc || {}), vc = /* @__PURE__ */ ((e) => (e.SUB = "sub", e.NAME = "name", e.GIVEN_NAME = "given_name", e.FAMILY_NAME = "family_name", e.MIDDLE_NAME = "middle_name", e.NICKNAME = "nickname", e.PREFERRED_USERNAME = "preferred_username", e.PROFILE = "profile", e.PICTURE = "picture", e.WEBSITE = "website", e.EMAIL = "email", e.EMAIL_VERIFIED = "email_verified", e.GENDER = "gender", e.BIRTHDATE = "birthdate", e.ZONEINFO = "zoneinfo", e.LOCALE = "locale", e.PHONE_NUMBER = "phone_number", e.PHONE_NUMBER_VERIFIED = "phone_number_verified", e.ADDRESS = "address", e.CLIENT_SECRET = "client_secret", e.NONCE = "nonce", e))(vc || {}), _c = /* @__PURE__ */ ((e) => (e.FORMATTED = "formatted", e.STREET_ADDRESS = "street_address", e.LOCALITY = "locality", e.REGION = "region", e.COUNTRY = "country", e))(_c || {});
+class pt {
 }
-n(_, "NOT_EQUAL", {
+Nt(pt, "NOT_EQUAL", {
   code: "STS_OAUTH2_ERR_0001",
   description: "Parameter values not equal."
-}), n(_, "NOT_PRESENT", {
+}), Nt(pt, "NOT_PRESENT", {
   code: "STS_OAUTH2_ERR_0002",
   description: "Parameter not provided."
-}), n(_, "INVALID_FORMAT", {
+}), Nt(pt, "INVALID_FORMAT", {
   code: "STS_OAUTH2_ERR_0003",
   description: "Parameter value format invalid."
-}), n(_, "EXPIRED", {
+}), Nt(pt, "EXPIRED", {
   code: "STS_OAUTH2_ERR_0004",
   description: "Parameter value expired."
 });
-function H(E, e, o) {
-  const c = [];
-  for (let s = 0; s < o.length; s++) {
-    const R = o[s];
-    if (E[s].localeCompare(e[s]) !== 0) {
-      const r = {
-        error: _.NOT_EQUAL.code,
-        error_description: _.NOT_EQUAL.description,
+function bc(e, t, r) {
+  const n = [];
+  for (let a = 0; a < r.length; a++) {
+    const i = r[a];
+    if (e[a].localeCompare(t[a]) !== 0) {
+      const d = {
+        error: pt.NOT_EQUAL.code,
+        error_description: pt.NOT_EQUAL.description,
         timestamp: Date.now(),
-        details: `${_.NOT_EQUAL.description}: Parameter: [${R}]`
+        details: `${pt.NOT_EQUAL.description}: Parameter: [${i}]`
       };
-      c.push(r);
+      n.push(d);
     }
   }
-  return c;
+  return n;
 }
-const v = {};
-function d() {
-  return v;
+const yc = {};
+function Pc() {
+  return yc;
 }
 export {
-  v as $stsgd,
-  d as $stsgdf,
-  g as AddSchema,
-  I as GetErrorPayload,
-  A as JestSleep,
-  _ as OAuth2ParameterErrorType,
-  U as OAuth2ParameterType,
-  M as OIDCAddressClaim,
-  L as OIDCStandardClaim,
-  F as STSOptionsBase,
-  l as Sleep,
-  S as Validate,
-  H as compareParameterTypes
+  yc as $stsgd,
+  Pc as $stsgdf,
+  Ec as AddSchema,
+  $c as GetErrorPayload,
+  Sc as JestSleep,
+  pt as OAuth2ParameterErrorType,
+  mc as OAuth2ParameterType,
+  _c as OIDCAddressClaim,
+  vc as OIDCStandardClaim,
+  wc as STSOptionsBase,
+  pc as Sleep,
+  hc as Validate,
+  bc as compareParameterTypes
 };
 //# sourceMappingURL=stsutils.mjs.map