@cccsaurora/clue-ui 1.2.8-dev.326 → 1.2.8

package/ActionForm-1iQtvort.js

@@ -0,0 +1,4470 @@
+import { jsx as M, jsxs as W } from "react/jsx-runtime";
+import { materialRenderers as Eo, materialCells as So } from "@jsonforms/material-renderers";
+import { JsonForms as Po } from "@jsonforms/react";
+import { Modal as bs, Paper as Es, Stack as se, Typography as ke, Divider as Dt, LinearProgress as ko, Button as ot, IconButton as No, Box as et, CircularProgress as Co, Collapse as jo } from "@mui/material";
+import Ss from "./components/display/icons/Iconified.js";
+import { J as Ro } from "./index-BK-zfYhR.js";
+import { ClueComponentContext as ft } from "./hooks/ClueComponentContext.js";
+import { g as Oo } from "./_commonjsHelpers-DaMA6jEr.js";
+import { x as To, y as Ps, z as Io } from "./index-BHAe_V9n.js";
+import { a as Ht } from "./useClueTypeConfig-Ct9Ygter.js";
+import { d as ks } from "./_baseGet-DSZygzyq.js";
+import { b as Mo } from "./_baseSlice-M5RKzt1A.js";
+import { i as Vo } from "./utils-DmwSUrum.js";
+import { useState as de, useRef as Fo, useMemo as Ne, useEffect as Wt, memo as Ns, useCallback as Oe } from "react";
+import { u as je, c as Ko, a as qo } from "./index-Dj5C04IX.js";
+import dt from "./components/ErrorBoundary.js";
+import { adaptSchema as Uo } from "./components/actions/form/schemaAdapter.js";
+import { I as zo } from "./iconify-BBckr5AQ.js";
+import { C as Ao } from "./ClueEnrichContext-B8X0Nw9n.js";
+import { ClueFetcherContext as Lo } from "./hooks/ClueFetcherContext.js";
+import Go from "./components/ClassificationChip.js";
+import Jo from "./components/actions/formats/index.js";
+import { SNACKBAR_EVENT_ID as yt } from "./data/event.js";
+import { dayjs as Ho } from "./utils/time.js";
+import { safeDispatchEvent as _t } from "./utils/window.js";
+import Bo from "./hooks/useClue.js";
+import { i as Qo } from "./isNil-CjWwlQS3.js";
+function Xo(e, t, r) {
+  var s = e.length;
+  return r = r === void 0 ? s : r, !t && r >= s ? e : Mo(e, t, r);
+}
+var Yo = "\\ud800-\\udfff", Zo = "\\u0300-\\u036f", Do = "\\ufe20-\\ufe2f", Wo = "\\u20d0-\\u20ff", xo = Zo + Do + Wo, en = "\\ufe0e\\ufe0f", tn = "\\u200d", rn = RegExp("[" + tn + Yo + xo + en + "]");
+function Cs(e) {
+  return rn.test(e);
+}
+function sn(e) {
+  return e.split("");
+}
+var js = "\\ud800-\\udfff", on = "\\u0300-\\u036f", nn = "\\ufe20-\\ufe2f", an = "\\u20d0-\\u20ff", cn = on + nn + an, ln = "\\ufe0e\\ufe0f", dn = "[" + js + "]", xt = "[" + cn + "]", er = "\\ud83c[\\udffb-\\udfff]", un = "(?:" + xt + "|" + er + ")", Rs = "[^" + js + "]", Os = "(?:\\ud83c[\\udde6-\\uddff]){2}", Ts = "[\\ud800-\\udbff][\\udc00-\\udfff]", fn = "\\u200d", Is = un + "?", Ms = "[" + ln + "]?", mn = "(?:" + fn + "(?:" + [Rs, Os, Ts].join("|") + ")" + Ms + Is + ")*", hn = Ms + Is + mn, pn = "(?:" + [Rs + xt + "?", xt, Os, Ts, dn].join("|") + ")", yn = RegExp(er + "(?=" + er + ")|" + pn + hn, "g");
+function _n(e) {
+  return e.match(yn) || [];
+}
+function vn(e) {
+  return Cs(e) ? _n(e) : sn(e);
+}
+function $n(e) {
+  return function(t) {
+    t = ks(t);
+    var r = Cs(t) ? vn(t) : void 0, s = r ? r[0] : t.charAt(0), o = r ? Xo(r, 1).join("") : t.slice(1);
+    return s[e]() + o;
+  };
+}
+var gn = $n("toUpperCase");
+function wn(e) {
+  return gn(ks(e).toLowerCase());
+}
+var tr = { exports: {} }, Vs = {}, fe = {}, Qe = {}, mt = {}, q = {}, ut = {};
+(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($) {
+      if (super(), !e.IDENTIFIER.test($))
+        throw new Error("CodeGen: name must be a valid identifier");
+      this.str = $;
+    }
+    toString() {
+      return this.str;
+    }
+    emptyStr() {
+      return !1;
+    }
+    get names() {
+      return { [this.str]: 1 };
+    }
+  }
+  e.Name = r;
+  class s extends t {
+    constructor($) {
+      super(), this._items = typeof $ == "string" ? [$] : $;
+    }
+    toString() {
+      return this.str;
+    }
+    emptyStr() {
+      if (this._items.length > 1)
+        return !1;
+      const $ = this._items[0];
+      return $ === "" || $ === '""';
+    }
+    get str() {
+      var $;
+      return ($ = this._str) !== null && $ !== void 0 ? $ : this._str = this._items.reduce((P, R) => `${P}${R}`, "");
+    }
+    get names() {
+      var $;
+      return ($ = this._names) !== null && $ !== void 0 ? $ : this._names = this._items.reduce((P, R) => (R instanceof r && (P[R.str] = (P[R.str] || 0) + 1), P), {});
+    }
+  }
+  e._Code = s, e.nil = new s("");
+  function o(f, ...$) {
+    const P = [f[0]];
+    let R = 0;
+    for (; R < $.length; )
+      d(P, $[R]), P.push(f[++R]);
+    return new s(P);
+  }
+  e._ = o;
+  const a = new s("+");
+  function i(f, ...$) {
+    const P = [E(f[0])];
+    let R = 0;
+    for (; R < $.length; )
+      P.push(a), d(P, $[R]), P.push(a, E(f[++R]));
+    return u(P), new s(P);
+  }
+  e.str = i;
+  function d(f, $) {
+    $ instanceof s ? f.push(...$._items) : $ instanceof r ? f.push($) : f.push(y($));
+  }
+  e.addCodeArg = d;
+  function u(f) {
+    let $ = 1;
+    for (; $ < f.length - 1; ) {
+      if (f[$] === a) {
+        const P = l(f[$ - 1], f[$ + 1]);
+        if (P !== void 0) {
+          f.splice($ - 1, 3, P);
+          continue;
+        }
+        f[$++] = "+";
+      }
+      $++;
+    }
+  }
+  function l(f, $) {
+    if ($ === '""')
+      return f;
+    if (f === '""')
+      return $;
+    if (typeof f == "string")
+      return $ instanceof r || f[f.length - 1] !== '"' ? void 0 : typeof $ != "string" ? `${f.slice(0, -1)}${$}"` : $[0] === '"' ? f.slice(0, -1) + $.slice(1) : void 0;
+    if (typeof $ == "string" && $[0] === '"' && !(f instanceof r))
+      return `"${f}${$.slice(1)}`;
+  }
+  function m(f, $) {
+    return $.emptyStr() ? f : f.emptyStr() ? $ : i`${f}${$}`;
+  }
+  e.strConcat = m;
+  function y(f) {
+    return typeof f == "number" || typeof f == "boolean" || f === null ? f : E(Array.isArray(f) ? f.join(",") : f);
+  }
+  function b(f) {
+    return new s(E(f));
+  }
+  e.stringify = b;
+  function E(f) {
+    return JSON.stringify(f).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+  }
+  e.safeStringify = E;
+  function g(f) {
+    return typeof f == "string" && e.IDENTIFIER.test(f) ? new s(`.${f}`) : o`[${f}]`;
+  }
+  e.getProperty = g;
+  function v(f) {
+    if (typeof f == "string" && e.IDENTIFIER.test(f))
+      return new s(`${f}`);
+    throw new Error(`CodeGen: invalid export name: ${f}, use explicit $id name mapping`);
+  }
+  e.getEsmExportName = v;
+  function h(f) {
+    return new s(f.toString());
+  }
+  e.regexpCode = h;
+})(ut);
+var rr = {};
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.ValueScope = e.ValueScopeName = e.Scope = e.varKinds = e.UsedValueState = void 0;
+  const t = ut;
+  class r extends Error {
+    constructor(l) {
+      super(`CodeGen: "code" for ${l} not defined`), this.value = l.value;
+    }
+  }
+  var s;
+  (function(u) {
+    u[u.Started = 0] = "Started", u[u.Completed = 1] = "Completed";
+  })(s || (e.UsedValueState = s = {})), e.varKinds = {
+    const: new t.Name("const"),
+    let: new t.Name("let"),
+    var: new t.Name("var")
+  };
+  class o {
+    constructor({ prefixes: l, parent: m } = {}) {
+      this._names = {}, this._prefixes = l, this._parent = m;
+    }
+    toName(l) {
+      return l instanceof t.Name ? l : this.name(l);
+    }
+    name(l) {
+      return new t.Name(this._newName(l));
+    }
+    _newName(l) {
+      const m = this._names[l] || this._nameGroup(l);
+      return `${l}${m.index++}`;
+    }
+    _nameGroup(l) {
+      var m, y;
+      if (!((y = (m = this._parent) === null || m === void 0 ? void 0 : m._prefixes) === null || y === void 0) && y.has(l) || this._prefixes && !this._prefixes.has(l))
+        throw new Error(`CodeGen: prefix "${l}" is not allowed in this scope`);
+      return this._names[l] = { prefix: l, index: 0 };
+    }
+  }
+  e.Scope = o;
+  class a extends t.Name {
+    constructor(l, m) {
+      super(m), this.prefix = l;
+    }
+    setValue(l, { property: m, itemIndex: y }) {
+      this.value = l, this.scopePath = (0, t._)`.${new t.Name(m)}[${y}]`;
+    }
+  }
+  e.ValueScopeName = a;
+  const i = (0, t._)`\n`;
+  class d extends o {
+    constructor(l) {
+      super(l), this._values = {}, this._scope = l.scope, this.opts = { ...l, _n: l.lines ? i : t.nil };
+    }
+    get() {
+      return this._scope;
+    }
+    name(l) {
+      return new a(l, this._newName(l));
+    }
+    value(l, m) {
+      var y;
+      if (m.ref === void 0)
+        throw new Error("CodeGen: ref must be passed in value");
+      const b = this.toName(l), { prefix: E } = b, g = (y = m.key) !== null && y !== void 0 ? y : m.ref;
+      let v = this._values[E];
+      if (v) {
+        const $ = v.get(g);
+        if ($)
+          return $;
+      } else
+        v = this._values[E] = /* @__PURE__ */ new Map();
+      v.set(g, b);
+      const h = this._scope[E] || (this._scope[E] = []), f = h.length;
+      return h[f] = m.ref, b.setValue(m, { property: E, itemIndex: f }), b;
+    }
+    getValue(l, m) {
+      const y = this._values[l];
+      if (y)
+        return y.get(m);
+    }
+    scopeRefs(l, m = this._values) {
+      return this._reduceValues(m, (y) => {
+        if (y.scopePath === void 0)
+          throw new Error(`CodeGen: name "${y}" has no value`);
+        return (0, t._)`${l}${y.scopePath}`;
+      });
+    }
+    scopeCode(l = this._values, m, y) {
+      return this._reduceValues(l, (b) => {
+        if (b.value === void 0)
+          throw new Error(`CodeGen: name "${b}" has no value`);
+        return b.value.code;
+      }, m, y);
+    }
+    _reduceValues(l, m, y = {}, b) {
+      let E = t.nil;
+      for (const g in l) {
+        const v = l[g];
+        if (!v)
+          continue;
+        const h = y[g] = y[g] || /* @__PURE__ */ new Map();
+        v.forEach((f) => {
+          if (h.has(f))
+            return;
+          h.set(f, s.Started);
+          let $ = m(f);
+          if ($) {
+            const P = this.opts.es5 ? e.varKinds.var : e.varKinds.const;
+            E = (0, t._)`${E}${P} ${f} = ${$};${this.opts._n}`;
+          } else if ($ = b == null ? void 0 : b(f))
+            E = (0, t._)`${E}${$}${this.opts._n}`;
+          else
+            throw new r(f);
+          h.set(f, s.Completed);
+        });
+      }
+      return E;
+    }
+  }
+  e.ValueScope = d;
+})(rr);
+(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 = ut, r = rr;
+  var s = ut;
+  Object.defineProperty(e, "_", { enumerable: !0, get: function() {
+    return s._;
+  } }), Object.defineProperty(e, "str", { enumerable: !0, get: function() {
+    return s.str;
+  } }), Object.defineProperty(e, "strConcat", { enumerable: !0, get: function() {
+    return s.strConcat;
+  } }), Object.defineProperty(e, "nil", { enumerable: !0, get: function() {
+    return s.nil;
+  } }), Object.defineProperty(e, "getProperty", { enumerable: !0, get: function() {
+    return s.getProperty;
+  } }), Object.defineProperty(e, "stringify", { enumerable: !0, get: function() {
+    return s.stringify;
+  } }), Object.defineProperty(e, "regexpCode", { enumerable: !0, get: function() {
+    return s.regexpCode;
+  } }), Object.defineProperty(e, "Name", { enumerable: !0, get: function() {
+    return s.Name;
+  } });
+  var o = rr;
+  Object.defineProperty(e, "Scope", { enumerable: !0, get: function() {
+    return o.Scope;
+  } }), Object.defineProperty(e, "ValueScope", { enumerable: !0, get: function() {
+    return o.ValueScope;
+  } }), Object.defineProperty(e, "ValueScopeName", { enumerable: !0, get: function() {
+    return o.ValueScopeName;
+  } }), Object.defineProperty(e, "varKinds", { enumerable: !0, get: function() {
+    return o.varKinds;
+  } }), e.operators = {
+    GT: new t._Code(">"),
+    GTE: new t._Code(">="),
+    LT: new t._Code("<"),
+    LTE: new t._Code("<="),
+    EQ: new t._Code("==="),
+    NEQ: new t._Code("!=="),
+    NOT: new t._Code("!"),
+    OR: new t._Code("||"),
+    AND: new t._Code("&&"),
+    ADD: new t._Code("+")
+  };
+  class a {
+    optimizeNodes() {
+      return this;
+    }
+    optimizeNames(n, c) {
+      return this;
+    }
+  }
+  class i extends a {
+    constructor(n, c, w) {
+      super(), this.varKind = n, this.name = c, this.rhs = w;
+    }
+    render({ es5: n, _n: c }) {
+      const w = n ? r.varKinds.var : this.varKind, j = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
+      return `${w} ${this.name}${j};` + c;
+    }
+    optimizeNames(n, c) {
+      if (n[this.name.str])
+        return this.rhs && (this.rhs = B(this.rhs, n, c)), this;
+    }
+    get names() {
+      return this.rhs instanceof t._CodeOrName ? this.rhs.names : {};
+    }
+  }
+  class d extends a {
+    constructor(n, c, w) {
+      super(), this.lhs = n, this.rhs = c, this.sideEffects = w;
+    }
+    render({ _n: n }) {
+      return `${this.lhs} = ${this.rhs};` + n;
+    }
+    optimizeNames(n, c) {
+      if (!(this.lhs instanceof t.Name && !n[this.lhs.str] && !this.sideEffects))
+        return this.rhs = B(this.rhs, n, c), this;
+    }
+    get names() {
+      const n = this.lhs instanceof t.Name ? {} : { ...this.lhs.names };
+      return z(n, this.rhs);
+    }
+  }
+  class u extends d {
+    constructor(n, c, w, j) {
+      super(n, w, j), this.op = c;
+    }
+    render({ _n: n }) {
+      return `${this.lhs} ${this.op}= ${this.rhs};` + n;
+    }
+  }
+  class l extends a {
+    constructor(n) {
+      super(), this.label = n, this.names = {};
+    }
+    render({ _n: n }) {
+      return `${this.label}:` + n;
+    }
+  }
+  class m extends a {
+    constructor(n) {
+      super(), this.label = n, this.names = {};
+    }
+    render({ _n: n }) {
+      return `break${this.label ? ` ${this.label}` : ""};` + n;
+    }
+  }
+  class y extends a {
+    constructor(n) {
+      super(), this.error = n;
+    }
+    render({ _n: n }) {
+      return `throw ${this.error};` + n;
+    }
+    get names() {
+      return this.error.names;
+    }
+  }
+  class b extends a {
+    constructor(n) {
+      super(), this.code = n;
+    }
+    render({ _n: n }) {
+      return `${this.code};` + n;
+    }
+    optimizeNodes() {
+      return `${this.code}` ? this : void 0;
+    }
+    optimizeNames(n, c) {
+      return this.code = B(this.code, n, c), this;
+    }
+    get names() {
+      return this.code instanceof t._CodeOrName ? this.code.names : {};
+    }
+  }
+  class E extends a {
+    constructor(n = []) {
+      super(), this.nodes = n;
+    }
+    render(n) {
+      return this.nodes.reduce((c, w) => c + w.render(n), "");
+    }
+    optimizeNodes() {
+      const { nodes: n } = this;
+      let c = n.length;
+      for (; c--; ) {
+        const w = n[c].optimizeNodes();
+        Array.isArray(w) ? n.splice(c, 1, ...w) : w ? n[c] = w : n.splice(c, 1);
+      }
+      return n.length > 0 ? this : void 0;
+    }
+    optimizeNames(n, c) {
+      const { nodes: w } = this;
+      let j = w.length;
+      for (; j--; ) {
+        const O = w[j];
+        O.optimizeNames(n, c) || (ee(n, O.names), w.splice(j, 1));
+      }
+      return w.length > 0 ? this : void 0;
+    }
+    get names() {
+      return this.nodes.reduce((n, c) => ie(n, c.names), {});
+    }
+  }
+  class g extends E {
+    render(n) {
+      return "{" + n._n + super.render(n) + "}" + n._n;
+    }
+  }
+  class v extends E {
+  }
+  class h extends g {
+  }
+  h.kind = "else";
+  class f extends g {
+    constructor(n, c) {
+      super(c), this.condition = n;
+    }
+    render(n) {
+      let c = `if(${this.condition})` + super.render(n);
+      return this.else && (c += "else " + this.else.render(n)), c;
+    }
+    optimizeNodes() {
+      super.optimizeNodes();
+      const n = this.condition;
+      if (n === !0)
+        return this.nodes;
+      let c = this.else;
+      if (c) {
+        const w = c.optimizeNodes();
+        c = this.else = Array.isArray(w) ? new h(w) : w;
+      }
+      if (c)
+        return n === !1 ? c instanceof f ? c : c.nodes : this.nodes.length ? this : new f(Ke(n), c instanceof f ? [c] : c.nodes);
+      if (!(n === !1 || !this.nodes.length))
+        return this;
+    }
+    optimizeNames(n, c) {
+      var w;
+      if (this.else = (w = this.else) === null || w === void 0 ? void 0 : w.optimizeNames(n, c), !!(super.optimizeNames(n, c) || this.else))
+        return this.condition = B(this.condition, n, c), this;
+    }
+    get names() {
+      const n = super.names;
+      return z(n, this.condition), this.else && ie(n, this.else.names), n;
+    }
+  }
+  f.kind = "if";
+  class $ extends g {
+  }
+  $.kind = "for";
+  class P extends $ {
+    constructor(n) {
+      super(), this.iteration = n;
+    }
+    render(n) {
+      return `for(${this.iteration})` + super.render(n);
+    }
+    optimizeNames(n, c) {
+      if (super.optimizeNames(n, c))
+        return this.iteration = B(this.iteration, n, c), this;
+    }
+    get names() {
+      return ie(super.names, this.iteration.names);
+    }
+  }
+  class R extends $ {
+    constructor(n, c, w, j) {
+      super(), this.varKind = n, this.name = c, this.from = w, this.to = j;
+    }
+    render(n) {
+      const c = n.es5 ? r.varKinds.var : this.varKind, { name: w, from: j, to: O } = this;
+      return `for(${c} ${w}=${j}; ${w}<${O}; ${w}++)` + super.render(n);
+    }
+    get names() {
+      const n = z(super.names, this.from);
+      return z(n, this.to);
+    }
+  }
+  class C extends $ {
+    constructor(n, c, w, j) {
+      super(), this.loop = n, this.varKind = c, this.name = w, this.iterable = j;
+    }
+    render(n) {
+      return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(n);
+    }
+    optimizeNames(n, c) {
+      if (super.optimizeNames(n, c))
+        return this.iterable = B(this.iterable, n, c), this;
+    }
+    get names() {
+      return ie(super.names, this.iterable.names);
+    }
+  }
+  class L extends g {
+    constructor(n, c, w) {
+      super(), this.name = n, this.args = c, this.async = w;
+    }
+    render(n) {
+      return `${this.async ? "async " : ""}function ${this.name}(${this.args})` + super.render(n);
+    }
+  }
+  L.kind = "func";
+  class H extends E {
+    render(n) {
+      return "return " + super.render(n);
+    }
+  }
+  H.kind = "return";
+  class oe extends g {
+    render(n) {
+      let c = "try" + super.render(n);
+      return this.catch && (c += this.catch.render(n)), this.finally && (c += this.finally.render(n)), c;
+    }
+    optimizeNodes() {
+      var n, c;
+      return super.optimizeNodes(), (n = this.catch) === null || n === void 0 || n.optimizeNodes(), (c = this.finally) === null || c === void 0 || c.optimizeNodes(), this;
+    }
+    optimizeNames(n, c) {
+      var w, j;
+      return super.optimizeNames(n, c), (w = this.catch) === null || w === void 0 || w.optimizeNames(n, c), (j = this.finally) === null || j === void 0 || j.optimizeNames(n, c), this;
+    }
+    get names() {
+      const n = super.names;
+      return this.catch && ie(n, this.catch.names), this.finally && ie(n, this.finally.names), n;
+    }
+  }
+  class ae extends g {
+    constructor(n) {
+      super(), this.error = n;
+    }
+    render(n) {
+      return `catch(${this.error})` + super.render(n);
+    }
+  }
+  ae.kind = "catch";
+  class me extends g {
+    render(n) {
+      return "finally" + super.render(n);
+    }
+  }
+  me.kind = "finally";
+  class Ee {
+    constructor(n, c = {}) {
+      this._values = {}, this._blockStarts = [], this._constants = {}, this.opts = { ...c, _n: c.lines ? `
+` : "" }, this._extScope = n, this._scope = new r.Scope({ parent: n }), this._nodes = [new v()];
+    }
+    toString() {
+      return this._root.render(this.opts);
+    }
+    // returns unique name in the internal scope
+    name(n) {
+      return this._scope.name(n);
+    }
+    // reserves unique name in the external scope
+    scopeName(n) {
+      return this._extScope.name(n);
+    }
+    // reserves unique name in the external scope and assigns value to it
+    scopeValue(n, c) {
+      const w = this._extScope.value(n, c);
+      return (this._values[w.prefix] || (this._values[w.prefix] = /* @__PURE__ */ new Set())).add(w), w;
+    }
+    getScopeValue(n, c) {
+      return this._extScope.getValue(n, c);
+    }
+    // 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(n) {
+      return this._extScope.scopeRefs(n, this._values);
+    }
+    scopeCode() {
+      return this._extScope.scopeCode(this._values);
+    }
+    _def(n, c, w, j) {
+      const O = this._scope.toName(c);
+      return w !== void 0 && j && (this._constants[O.str] = w), this._leafNode(new i(n, O, w)), O;
+    }
+    // `const` declaration (`var` in es5 mode)
+    const(n, c, w) {
+      return this._def(r.varKinds.const, n, c, w);
+    }
+    // `let` declaration with optional assignment (`var` in es5 mode)
+    let(n, c, w) {
+      return this._def(r.varKinds.let, n, c, w);
+    }
+    // `var` declaration with optional assignment
+    var(n, c, w) {
+      return this._def(r.varKinds.var, n, c, w);
+    }
+    // assignment code
+    assign(n, c, w) {
+      return this._leafNode(new d(n, c, w));
+    }
+    // `+=` code
+    add(n, c) {
+      return this._leafNode(new u(n, e.operators.ADD, c));
+    }
+    // appends passed SafeExpr to code or executes Block
+    code(n) {
+      return typeof n == "function" ? n() : n !== t.nil && this._leafNode(new b(n)), this;
+    }
+    // returns code for object literal for the passed argument list of key-value pairs
+    object(...n) {
+      const c = ["{"];
+      for (const [w, j] of n)
+        c.length > 1 && c.push(","), c.push(w), (w !== j || this.opts.es5) && (c.push(":"), (0, t.addCodeArg)(c, j));
+      return c.push("}"), new t._Code(c);
+    }
+    // `if` clause (or statement if `thenBody` and, optionally, `elseBody` are passed)
+    if(n, c, w) {
+      if (this._blockNode(new f(n)), c && w)
+        this.code(c).else().code(w).endIf();
+      else if (c)
+        this.code(c).endIf();
+      else if (w)
+        throw new Error('CodeGen: "else" body without "then" body');
+      return this;
+    }
+    // `else if` clause - invalid without `if` or after `else` clauses
+    elseIf(n) {
+      return this._elseNode(new f(n));
+    }
+    // `else` clause - only valid after `if` or `else if` clauses
+    else() {
+      return this._elseNode(new h());
+    }
+    // end `if` statement (needed if gen.if was used only with condition)
+    endIf() {
+      return this._endBlockNode(f, h);
+    }
+    _for(n, c) {
+      return this._blockNode(n), c && this.code(c).endFor(), this;
+    }
+    // a generic `for` clause (or statement if `forBody` is passed)
+    for(n, c) {
+      return this._for(new P(n), c);
+    }
+    // `for` statement for a range of values
+    forRange(n, c, w, j, O = this.opts.es5 ? r.varKinds.var : r.varKinds.let) {
+      const A = this._scope.toName(n);
+      return this._for(new R(O, A, c, w), () => j(A));
+    }
+    // `for-of` statement (in es5 mode replace with a normal for loop)
+    forOf(n, c, w, j = r.varKinds.const) {
+      const O = this._scope.toName(n);
+      if (this.opts.es5) {
+        const A = c instanceof t.Name ? c : this.var("_arr", c);
+        return this.forRange("_i", 0, (0, t._)`${A}.length`, (U) => {
+          this.var(O, (0, t._)`${A}[${U}]`), w(O);
+        });
+      }
+      return this._for(new C("of", j, O, c), () => w(O));
+    }
+    // `for-in` statement.
+    // With option `ownProperties` replaced with a `for-of` loop for object keys
+    forIn(n, c, w, j = this.opts.es5 ? r.varKinds.var : r.varKinds.const) {
+      if (this.opts.ownProperties)
+        return this.forOf(n, (0, t._)`Object.keys(${c})`, w);
+      const O = this._scope.toName(n);
+      return this._for(new C("in", j, O, c), () => w(O));
+    }
+    // end `for` loop
+    endFor() {
+      return this._endBlockNode($);
+    }
+    // `label` statement
+    label(n) {
+      return this._leafNode(new l(n));
+    }
+    // `break` statement
+    break(n) {
+      return this._leafNode(new m(n));
+    }
+    // `return` statement
+    return(n) {
+      const c = new H();
+      if (this._blockNode(c), this.code(n), c.nodes.length !== 1)
+        throw new Error('CodeGen: "return" should have one node');
+      return this._endBlockNode(H);
+    }
+    // `try` statement
+    try(n, c, w) {
+      if (!c && !w)
+        throw new Error('CodeGen: "try" without "catch" and "finally"');
+      const j = new oe();
+      if (this._blockNode(j), this.code(n), c) {
+        const O = this.name("e");
+        this._currNode = j.catch = new ae(O), c(O);
+      }
+      return w && (this._currNode = j.finally = new me(), this.code(w)), this._endBlockNode(ae, me);
+    }
+    // `throw` statement
+    throw(n) {
+      return this._leafNode(new y(n));
+    }
+    // start self-balancing block
+    block(n, c) {
+      return this._blockStarts.push(this._nodes.length), n && this.code(n).endBlock(c), this;
+    }
+    // end the current self-balancing block
+    endBlock(n) {
+      const c = this._blockStarts.pop();
+      if (c === void 0)
+        throw new Error("CodeGen: not in self-balancing block");
+      const w = this._nodes.length - c;
+      if (w < 0 || n !== void 0 && w !== n)
+        throw new Error(`CodeGen: wrong number of nodes: ${w} vs ${n} expected`);
+      return this._nodes.length = c, this;
+    }
+    // `function` heading (or definition if funcBody is passed)
+    func(n, c = t.nil, w, j) {
+      return this._blockNode(new L(n, c, w)), j && this.code(j).endFunc(), this;
+    }
+    // end function definition
+    endFunc() {
+      return this._endBlockNode(L);
+    }
+    optimize(n = 1) {
+      for (; n-- > 0; )
+        this._root.optimizeNodes(), this._root.optimizeNames(this._root.names, this._constants);
+    }
+    _leafNode(n) {
+      return this._currNode.nodes.push(n), this;
+    }
+    _blockNode(n) {
+      this._currNode.nodes.push(n), this._nodes.push(n);
+    }
+    _endBlockNode(n, c) {
+      const w = this._currNode;
+      if (w instanceof n || c && w instanceof c)
+        return this._nodes.pop(), this;
+      throw new Error(`CodeGen: not in block "${c ? `${n.kind}/${c.kind}` : n.kind}"`);
+    }
+    _elseNode(n) {
+      const c = this._currNode;
+      if (!(c instanceof f))
+        throw new Error('CodeGen: "else" without "if"');
+      return this._currNode = c.else = n, this;
+    }
+    get _root() {
+      return this._nodes[0];
+    }
+    get _currNode() {
+      const n = this._nodes;
+      return n[n.length - 1];
+    }
+    set _currNode(n) {
+      const c = this._nodes;
+      c[c.length - 1] = n;
+    }
+  }
+  e.CodeGen = Ee;
+  function ie(_, n) {
+    for (const c in n)
+      _[c] = (_[c] || 0) + (n[c] || 0);
+    return _;
+  }
+  function z(_, n) {
+    return n instanceof t._CodeOrName ? ie(_, n.names) : _;
+  }
+  function B(_, n, c) {
+    if (_ instanceof t.Name)
+      return w(_);
+    if (!j(_))
+      return _;
+    return new t._Code(_._items.reduce((O, A) => (A instanceof t.Name && (A = w(A)), A instanceof t._Code ? O.push(...A._items) : O.push(A), O), []));
+    function w(O) {
+      const A = c[O.str];
+      return A === void 0 || n[O.str] !== 1 ? O : (delete n[O.str], A);
+    }
+    function j(O) {
+      return O instanceof t._Code && O._items.some((A) => A instanceof t.Name && n[A.str] === 1 && c[A.str] !== void 0);
+    }
+  }
+  function ee(_, n) {
+    for (const c in n)
+      _[c] = (_[c] || 0) - (n[c] || 0);
+  }
+  function Ke(_) {
+    return typeof _ == "boolean" || typeof _ == "number" || _ === null ? !_ : (0, t._)`!${S(_)}`;
+  }
+  e.not = Ke;
+  const qe = p(e.operators.AND);
+  function $e(..._) {
+    return _.reduce(qe);
+  }
+  e.and = $e;
+  const he = p(e.operators.OR);
+  function k(..._) {
+    return _.reduce(he);
+  }
+  e.or = k;
+  function p(_) {
+    return (n, c) => n === t.nil ? c : c === t.nil ? n : (0, t._)`${S(n)} ${_} ${S(c)}`;
+  }
+  function S(_) {
+    return _ instanceof t.Name ? _ : (0, t._)`(${_})`;
+  }
+})(q);
+var N = {};
+Object.defineProperty(N, "__esModule", { value: !0 });
+N.checkStrictMode = N.getErrorPath = N.Type = N.useFunc = N.setEvaluated = N.evaluatedPropsToName = N.mergeEvaluated = N.eachItem = N.unescapeJsonPointer = N.escapeJsonPointer = N.escapeFragment = N.unescapeFragment = N.schemaRefOrVal = N.schemaHasRulesButRef = N.schemaHasRules = N.checkUnknownRules = N.alwaysValidSchema = N.toHash = void 0;
+const G = q, bn = ut;
+function En(e) {
+  const t = {};
+  for (const r of e)
+    t[r] = !0;
+  return t;
+}
+N.toHash = En;
+function Sn(e, t) {
+  return typeof t == "boolean" ? t : Object.keys(t).length === 0 ? !0 : (Fs(e, t), !Ks(t, e.self.RULES.all));
+}
+N.alwaysValidSchema = Sn;
+function Fs(e, t = e.schema) {
+  const { opts: r, self: s } = e;
+  if (!r.strictSchema || typeof t == "boolean")
+    return;
+  const o = s.RULES.keywords;
+  for (const a in t)
+    o[a] || zs(e, `unknown keyword: "${a}"`);
+}
+N.checkUnknownRules = Fs;
+function Ks(e, t) {
+  if (typeof e == "boolean")
+    return !e;
+  for (const r in e)
+    if (t[r])
+      return !0;
+  return !1;
+}
+N.schemaHasRules = Ks;
+function Pn(e, t) {
+  if (typeof e == "boolean")
+    return !e;
+  for (const r in e)
+    if (r !== "$ref" && t.all[r])
+      return !0;
+  return !1;
+}
+N.schemaHasRulesButRef = Pn;
+function kn({ topSchemaRef: e, schemaPath: t }, r, s, o) {
+  if (!o) {
+    if (typeof r == "number" || typeof r == "boolean")
+      return r;
+    if (typeof r == "string")
+      return (0, G._)`${r}`;
+  }
+  return (0, G._)`${e}${t}${(0, G.getProperty)(s)}`;
+}
+N.schemaRefOrVal = kn;
+function Nn(e) {
+  return qs(decodeURIComponent(e));
+}
+N.unescapeFragment = Nn;
+function Cn(e) {
+  return encodeURIComponent(lr(e));
+}
+N.escapeFragment = Cn;
+function lr(e) {
+  return typeof e == "number" ? `${e}` : e.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+N.escapeJsonPointer = lr;
+function qs(e) {
+  return e.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+N.unescapeJsonPointer = qs;
+function jn(e, t) {
+  if (Array.isArray(e))
+    for (const r of e)
+      t(r);
+  else
+    t(e);
+}
+N.eachItem = jn;
+function es({ mergeNames: e, mergeToName: t, mergeValues: r, resultToName: s }) {
+  return (o, a, i, d) => {
+    const u = i === void 0 ? a : i instanceof G.Name ? (a instanceof G.Name ? e(o, a, i) : t(o, a, i), i) : a instanceof G.Name ? (t(o, i, a), a) : r(a, i);
+    return d === G.Name && !(u instanceof G.Name) ? s(o, u) : u;
+  };
+}
+N.mergeEvaluated = {
+  props: es({
+    mergeNames: (e, t, r) => e.if((0, G._)`${r} !== true && ${t} !== undefined`, () => {
+      e.if((0, G._)`${t} === true`, () => e.assign(r, !0), () => e.assign(r, (0, G._)`${r} || {}`).code((0, G._)`Object.assign(${r}, ${t})`));
+    }),
+    mergeToName: (e, t, r) => e.if((0, G._)`${r} !== true`, () => {
+      t === !0 ? e.assign(r, !0) : (e.assign(r, (0, G._)`${r} || {}`), dr(e, r, t));
+    }),
+    mergeValues: (e, t) => e === !0 ? !0 : { ...e, ...t },
+    resultToName: Us
+  }),
+  items: es({
+    mergeNames: (e, t, r) => e.if((0, G._)`${r} !== true && ${t} !== undefined`, () => e.assign(r, (0, G._)`${t} === true ? true : ${r} > ${t} ? ${r} : ${t}`)),
+    mergeToName: (e, t, r) => e.if((0, G._)`${r} !== true`, () => e.assign(r, t === !0 ? !0 : (0, G._)`${r} > ${t} ? ${r} : ${t}`)),
+    mergeValues: (e, t) => e === !0 ? !0 : Math.max(e, t),
+    resultToName: (e, t) => e.var("items", t)
+  })
+};
+function Us(e, t) {
+  if (t === !0)
+    return e.var("props", !0);
+  const r = e.var("props", (0, G._)`{}`);
+  return t !== void 0 && dr(e, r, t), r;
+}
+N.evaluatedPropsToName = Us;
+function dr(e, t, r) {
+  Object.keys(r).forEach((s) => e.assign((0, G._)`${t}${(0, G.getProperty)(s)}`, !0));
+}
+N.setEvaluated = dr;
+const ts = {};
+function Rn(e, t) {
+  return e.scopeValue("func", {
+    ref: t,
+    code: ts[t.code] || (ts[t.code] = new bn._Code(t.code))
+  });
+}
+N.useFunc = Rn;
+var sr;
+(function(e) {
+  e[e.Num = 0] = "Num", e[e.Str = 1] = "Str";
+})(sr || (N.Type = sr = {}));
+function On(e, t, r) {
+  if (e instanceof G.Name) {
+    const s = t === sr.Num;
+    return r ? s ? (0, G._)`"[" + ${e} + "]"` : (0, G._)`"['" + ${e} + "']"` : s ? (0, G._)`"/" + ${e}` : (0, G._)`"/" + ${e}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+  }
+  return r ? (0, G.getProperty)(e).toString() : "/" + lr(e);
+}
+N.getErrorPath = On;
+function zs(e, t, r = e.opts.strictSchema) {
+  if (r) {
+    if (t = `strict mode: ${t}`, r === !0)
+      throw new Error(t);
+    e.self.logger.warn(t);
+  }
+}
+N.checkStrictMode = zs;
+var ve = {};
+Object.defineProperty(ve, "__esModule", { value: !0 });
+const D = q, Tn = {
+  // validation function arguments
+  data: new D.Name("data"),
+  // data passed to validation function
+  // args passed from referencing schema
+  valCxt: new D.Name("valCxt"),
+  // validation/data context - should not be used directly, it is destructured to the names below
+  instancePath: new D.Name("instancePath"),
+  parentData: new D.Name("parentData"),
+  parentDataProperty: new D.Name("parentDataProperty"),
+  rootData: new D.Name("rootData"),
+  // root data - same as the data passed to the first/top validation function
+  dynamicAnchors: new D.Name("dynamicAnchors"),
+  // used to support recursiveRef and dynamicRef
+  // function scoped variables
+  vErrors: new D.Name("vErrors"),
+  // null or array of validation errors
+  errors: new D.Name("errors"),
+  // counter of validation errors
+  this: new D.Name("this"),
+  // "globals"
+  self: new D.Name("self"),
+  scope: new D.Name("scope"),
+  // JTD serialize/parse name for JSON string and position
+  json: new D.Name("json"),
+  jsonPos: new D.Name("jsonPos"),
+  jsonLen: new D.Name("jsonLen"),
+  jsonPart: new D.Name("jsonPart")
+};
+ve.default = Tn;
+(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 = q, r = N, s = ve;
+  e.keywordError = {
+    message: ({ keyword: h }) => (0, t.str)`must pass "${h}" keyword validation`
+  }, e.keyword$DataError = {
+    message: ({ keyword: h, schemaType: f }) => f ? (0, t.str)`"${h}" keyword must be ${f} ($data)` : (0, t.str)`"${h}" keyword is invalid ($data)`
+  };
+  function o(h, f = e.keywordError, $, P) {
+    const { it: R } = h, { gen: C, compositeRule: L, allErrors: H } = R, oe = y(h, f, $);
+    P ?? (L || H) ? u(C, oe) : l(R, (0, t._)`[${oe}]`);
+  }
+  e.reportError = o;
+  function a(h, f = e.keywordError, $) {
+    const { it: P } = h, { gen: R, compositeRule: C, allErrors: L } = P, H = y(h, f, $);
+    u(R, H), C || L || l(P, s.default.vErrors);
+  }
+  e.reportExtraError = a;
+  function i(h, f) {
+    h.assign(s.default.errors, f), h.if((0, t._)`${s.default.vErrors} !== null`, () => h.if(f, () => h.assign((0, t._)`${s.default.vErrors}.length`, f), () => h.assign(s.default.vErrors, null)));
+  }
+  e.resetErrorsCount = i;
+  function d({ gen: h, keyword: f, schemaValue: $, data: P, errsCount: R, it: C }) {
+    if (R === void 0)
+      throw new Error("ajv implementation error");
+    const L = h.name("err");
+    h.forRange("i", R, s.default.errors, (H) => {
+      h.const(L, (0, t._)`${s.default.vErrors}[${H}]`), h.if((0, t._)`${L}.instancePath === undefined`, () => h.assign((0, t._)`${L}.instancePath`, (0, t.strConcat)(s.default.instancePath, C.errorPath))), h.assign((0, t._)`${L}.schemaPath`, (0, t.str)`${C.errSchemaPath}/${f}`), C.opts.verbose && (h.assign((0, t._)`${L}.schema`, $), h.assign((0, t._)`${L}.data`, P));
+    });
+  }
+  e.extendErrors = d;
+  function u(h, f) {
+    const $ = h.const("err", f);
+    h.if((0, t._)`${s.default.vErrors} === null`, () => h.assign(s.default.vErrors, (0, t._)`[${$}]`), (0, t._)`${s.default.vErrors}.push(${$})`), h.code((0, t._)`${s.default.errors}++`);
+  }
+  function l(h, f) {
+    const { gen: $, validateName: P, schemaEnv: R } = h;
+    R.$async ? $.throw((0, t._)`new ${h.ValidationError}(${f})`) : ($.assign((0, t._)`${P}.errors`, f), $.return(!1));
+  }
+  const m = {
+    keyword: new t.Name("keyword"),
+    schemaPath: new t.Name("schemaPath"),
+    // also used in JTD errors
+    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 y(h, f, $) {
+    const { createErrors: P } = h.it;
+    return P === !1 ? (0, t._)`{}` : b(h, f, $);
+  }
+  function b(h, f, $ = {}) {
+    const { gen: P, it: R } = h, C = [
+      E(R, $),
+      g(h, $)
+    ];
+    return v(h, f, C), P.object(...C);
+  }
+  function E({ errorPath: h }, { instancePath: f }) {
+    const $ = f ? (0, t.str)`${h}${(0, r.getErrorPath)(f, r.Type.Str)}` : h;
+    return [s.default.instancePath, (0, t.strConcat)(s.default.instancePath, $)];
+  }
+  function g({ keyword: h, it: { errSchemaPath: f } }, { schemaPath: $, parentSchema: P }) {
+    let R = P ? f : (0, t.str)`${f}/${h}`;
+    return $ && (R = (0, t.str)`${R}${(0, r.getErrorPath)($, r.Type.Str)}`), [m.schemaPath, R];
+  }
+  function v(h, { params: f, message: $ }, P) {
+    const { keyword: R, data: C, schemaValue: L, it: H } = h, { opts: oe, propertyName: ae, topSchemaRef: me, schemaPath: Ee } = H;
+    P.push([m.keyword, R], [m.params, typeof f == "function" ? f(h) : f || (0, t._)`{}`]), oe.messages && P.push([m.message, typeof $ == "function" ? $(h) : $]), oe.verbose && P.push([m.schema, L], [m.parentSchema, (0, t._)`${me}${Ee}`], [s.default.data, C]), ae && P.push([m.propertyName, ae]);
+  }
+})(mt);
+Object.defineProperty(Qe, "__esModule", { value: !0 });
+Qe.boolOrEmptySchema = Qe.topBoolOrEmptySchema = void 0;
+const In = mt, Mn = q, Vn = ve, Fn = {
+  message: "boolean schema is false"
+};
+function Kn(e) {
+  const { gen: t, schema: r, validateName: s } = e;
+  r === !1 ? As(e, !1) : typeof r == "object" && r.$async === !0 ? t.return(Vn.default.data) : (t.assign((0, Mn._)`${s}.errors`, null), t.return(!0));
+}
+Qe.topBoolOrEmptySchema = Kn;
+function qn(e, t) {
+  const { gen: r, schema: s } = e;
+  s === !1 ? (r.var(t, !1), As(e)) : r.var(t, !0);
+}
+Qe.boolOrEmptySchema = qn;
+function As(e, t) {
+  const { gen: r, data: s } = e, o = {
+    gen: r,
+    keyword: "false schema",
+    data: s,
+    schema: !1,
+    schemaCode: !1,
+    schemaValue: !1,
+    params: {},
+    it: e
+  };
+  (0, In.reportError)(o, Fn, void 0, t);
+}
+var X = {}, Ve = {};
+Object.defineProperty(Ve, "__esModule", { value: !0 });
+Ve.getRules = Ve.isJSONType = void 0;
+const Un = ["string", "number", "integer", "boolean", "null", "object", "array"], zn = new Set(Un);
+function An(e) {
+  return typeof e == "string" && zn.has(e);
+}
+Ve.isJSONType = An;
+function Ln() {
+  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: {}
+  };
+}
+Ve.getRules = Ln;
+var we = {};
+Object.defineProperty(we, "__esModule", { value: !0 });
+we.shouldUseRule = we.shouldUseGroup = we.schemaHasRulesForType = void 0;
+function Gn({ schema: e, self: t }, r) {
+  const s = t.RULES.types[r];
+  return s && s !== !0 && Ls(e, s);
+}
+we.schemaHasRulesForType = Gn;
+function Ls(e, t) {
+  return t.rules.some((r) => Gs(e, r));
+}
+we.shouldUseGroup = Ls;
+function Gs(e, t) {
+  var r;
+  return e[t.keyword] !== void 0 || ((r = t.definition.implements) === null || r === void 0 ? void 0 : r.some((s) => e[s] !== void 0));
+}
+we.shouldUseRule = Gs;
+Object.defineProperty(X, "__esModule", { value: !0 });
+X.reportTypeError = X.checkDataTypes = X.checkDataType = X.coerceAndCheckDataType = X.getJSONTypes = X.getSchemaTypes = X.DataType = void 0;
+const Jn = Ve, Hn = we, Bn = mt, F = q, Js = N;
+var He;
+(function(e) {
+  e[e.Correct = 0] = "Correct", e[e.Wrong = 1] = "Wrong";
+})(He || (X.DataType = He = {}));
+function Qn(e) {
+  const t = Hs(e.type);
+  if (t.includes("null")) {
+    if (e.nullable === !1)
+      throw new Error("type: null contradicts nullable: false");
+  } else {
+    if (!t.length && e.nullable !== void 0)
+      throw new Error('"nullable" cannot be used without "type"');
+    e.nullable === !0 && t.push("null");
+  }
+  return t;
+}
+X.getSchemaTypes = Qn;
+function Hs(e) {
+  const t = Array.isArray(e) ? e : e ? [e] : [];
+  if (t.every(Jn.isJSONType))
+    return t;
+  throw new Error("type must be JSONType or JSONType[]: " + t.join(","));
+}
+X.getJSONTypes = Hs;
+function Xn(e, t) {
+  const { gen: r, data: s, opts: o } = e, a = Yn(t, o.coerceTypes), i = t.length > 0 && !(a.length === 0 && t.length === 1 && (0, Hn.schemaHasRulesForType)(e, t[0]));
+  if (i) {
+    const d = ur(t, s, o.strictNumbers, He.Wrong);
+    r.if(d, () => {
+      a.length ? Zn(e, t, a) : fr(e);
+    });
+  }
+  return i;
+}
+X.coerceAndCheckDataType = Xn;
+const Bs = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
+function Yn(e, t) {
+  return t ? e.filter((r) => Bs.has(r) || t === "array" && r === "array") : [];
+}
+function Zn(e, t, r) {
+  const { gen: s, data: o, opts: a } = e, i = s.let("dataType", (0, F._)`typeof ${o}`), d = s.let("coerced", (0, F._)`undefined`);
+  a.coerceTypes === "array" && s.if((0, F._)`${i} == 'object' && Array.isArray(${o}) && ${o}.length == 1`, () => s.assign(o, (0, F._)`${o}[0]`).assign(i, (0, F._)`typeof ${o}`).if(ur(t, o, a.strictNumbers), () => s.assign(d, o))), s.if((0, F._)`${d} !== undefined`);
+  for (const l of r)
+    (Bs.has(l) || l === "array" && a.coerceTypes === "array") && u(l);
+  s.else(), fr(e), s.endIf(), s.if((0, F._)`${d} !== undefined`, () => {
+    s.assign(o, d), Dn(e, d);
+  });
+  function u(l) {
+    switch (l) {
+      case "string":
+        s.elseIf((0, F._)`${i} == "number" || ${i} == "boolean"`).assign(d, (0, F._)`"" + ${o}`).elseIf((0, F._)`${o} === null`).assign(d, (0, F._)`""`);
+        return;
+      case "number":
+        s.elseIf((0, F._)`${i} == "boolean" || ${o} === null
+              || (${i} == "string" && ${o} && ${o} == +${o})`).assign(d, (0, F._)`+${o}`);
+        return;
+      case "integer":
+        s.elseIf((0, F._)`${i} === "boolean" || ${o} === null
+              || (${i} === "string" && ${o} && ${o} == +${o} && !(${o} % 1))`).assign(d, (0, F._)`+${o}`);
+        return;
+      case "boolean":
+        s.elseIf((0, F._)`${o} === "false" || ${o} === 0 || ${o} === null`).assign(d, !1).elseIf((0, F._)`${o} === "true" || ${o} === 1`).assign(d, !0);
+        return;
+      case "null":
+        s.elseIf((0, F._)`${o} === "" || ${o} === 0 || ${o} === false`), s.assign(d, null);
+        return;
+      case "array":
+        s.elseIf((0, F._)`${i} === "string" || ${i} === "number"
+              || ${i} === "boolean" || ${o} === null`).assign(d, (0, F._)`[${o}]`);
+    }
+  }
+}
+function Dn({ gen: e, parentData: t, parentDataProperty: r }, s) {
+  e.if((0, F._)`${t} !== undefined`, () => e.assign((0, F._)`${t}[${r}]`, s));
+}
+function or(e, t, r, s = He.Correct) {
+  const o = s === He.Correct ? F.operators.EQ : F.operators.NEQ;
+  let a;
+  switch (e) {
+    case "null":
+      return (0, F._)`${t} ${o} null`;
+    case "array":
+      a = (0, F._)`Array.isArray(${t})`;
+      break;
+    case "object":
+      a = (0, F._)`${t} && typeof ${t} == "object" && !Array.isArray(${t})`;
+      break;
+    case "integer":
+      a = i((0, F._)`!(${t} % 1) && !isNaN(${t})`);
+      break;
+    case "number":
+      a = i();
+      break;
+    default:
+      return (0, F._)`typeof ${t} ${o} ${e}`;
+  }
+  return s === He.Correct ? a : (0, F.not)(a);
+  function i(d = F.nil) {
+    return (0, F.and)((0, F._)`typeof ${t} == "number"`, d, r ? (0, F._)`isFinite(${t})` : F.nil);
+  }
+}
+X.checkDataType = or;
+function ur(e, t, r, s) {
+  if (e.length === 1)
+    return or(e[0], t, r, s);
+  let o;
+  const a = (0, Js.toHash)(e);
+  if (a.array && a.object) {
+    const i = (0, F._)`typeof ${t} != "object"`;
+    o = a.null ? i : (0, F._)`!${t} || ${i}`, delete a.null, delete a.array, delete a.object;
+  } else
+    o = F.nil;
+  a.number && delete a.integer;
+  for (const i in a)
+    o = (0, F.and)(o, or(i, t, r, s));
+  return o;
+}
+X.checkDataTypes = ur;
+const Wn = {
+  message: ({ schema: e }) => `must be ${e}`,
+  params: ({ schema: e, schemaValue: t }) => typeof e == "string" ? (0, F._)`{type: ${e}}` : (0, F._)`{type: ${t}}`
+};
+function fr(e) {
+  const t = xn(e);
+  (0, Bn.reportError)(t, Wn);
+}
+X.reportTypeError = fr;
+function xn(e) {
+  const { gen: t, data: r, schema: s } = e, o = (0, Js.schemaRefOrVal)(e, s, "type");
+  return {
+    gen: t,
+    keyword: "type",
+    data: r,
+    schema: s.type,
+    schemaCode: o,
+    schemaValue: o,
+    parentSchema: s,
+    params: {},
+    it: e
+  };
+}
+var Rt = {};
+Object.defineProperty(Rt, "__esModule", { value: !0 });
+Rt.assignDefaults = void 0;
+const Ae = q, ea = N;
+function ta(e, t) {
+  const { properties: r, items: s } = e.schema;
+  if (t === "object" && r)
+    for (const o in r)
+      rs(e, o, r[o].default);
+  else t === "array" && Array.isArray(s) && s.forEach((o, a) => rs(e, a, o.default));
+}
+Rt.assignDefaults = ta;
+function rs(e, t, r) {
+  const { gen: s, compositeRule: o, data: a, opts: i } = e;
+  if (r === void 0)
+    return;
+  const d = (0, Ae._)`${a}${(0, Ae.getProperty)(t)}`;
+  if (o) {
+    (0, ea.checkStrictMode)(e, `default is ignored for: ${d}`);
+    return;
+  }
+  let u = (0, Ae._)`${d} === undefined`;
+  i.useDefaults === "empty" && (u = (0, Ae._)`${u} || ${d} === null || ${d} === ""`), s.if(u, (0, Ae._)`${d} = ${(0, Ae.stringify)(r)}`);
+}
+var _e = {}, K = {};
+Object.defineProperty(K, "__esModule", { value: !0 });
+K.validateUnion = K.validateArray = K.usePattern = K.callValidateCode = K.schemaProperties = K.allSchemaProperties = K.noPropertyInData = K.propertyInData = K.isOwnProperty = K.hasPropFunc = K.reportMissingProp = K.checkMissingProp = K.checkReportMissingProp = void 0;
+const J = q, mr = N, Se = ve, ra = N;
+function sa(e, t) {
+  const { gen: r, data: s, it: o } = e;
+  r.if(pr(r, s, t, o.opts.ownProperties), () => {
+    e.setParams({ missingProperty: (0, J._)`${t}` }, !0), e.error();
+  });
+}
+K.checkReportMissingProp = sa;
+function oa({ gen: e, data: t, it: { opts: r } }, s, o) {
+  return (0, J.or)(...s.map((a) => (0, J.and)(pr(e, t, a, r.ownProperties), (0, J._)`${o} = ${a}`)));
+}
+K.checkMissingProp = oa;
+function na(e, t) {
+  e.setParams({ missingProperty: t }, !0), e.error();
+}
+K.reportMissingProp = na;
+function Qs(e) {
+  return e.scopeValue("func", {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    ref: Object.prototype.hasOwnProperty,
+    code: (0, J._)`Object.prototype.hasOwnProperty`
+  });
+}
+K.hasPropFunc = Qs;
+function hr(e, t, r) {
+  return (0, J._)`${Qs(e)}.call(${t}, ${r})`;
+}
+K.isOwnProperty = hr;
+function aa(e, t, r, s) {
+  const o = (0, J._)`${t}${(0, J.getProperty)(r)} !== undefined`;
+  return s ? (0, J._)`${o} && ${hr(e, t, r)}` : o;
+}
+K.propertyInData = aa;
+function pr(e, t, r, s) {
+  const o = (0, J._)`${t}${(0, J.getProperty)(r)} === undefined`;
+  return s ? (0, J.or)(o, (0, J.not)(hr(e, t, r))) : o;
+}
+K.noPropertyInData = pr;
+function Xs(e) {
+  return e ? Object.keys(e).filter((t) => t !== "__proto__") : [];
+}
+K.allSchemaProperties = Xs;
+function ia(e, t) {
+  return Xs(t).filter((r) => !(0, mr.alwaysValidSchema)(e, t[r]));
+}
+K.schemaProperties = ia;
+function ca({ schemaCode: e, data: t, it: { gen: r, topSchemaRef: s, schemaPath: o, errorPath: a }, it: i }, d, u, l) {
+  const m = l ? (0, J._)`${e}, ${t}, ${s}${o}` : t, y = [
+    [Se.default.instancePath, (0, J.strConcat)(Se.default.instancePath, a)],
+    [Se.default.parentData, i.parentData],
+    [Se.default.parentDataProperty, i.parentDataProperty],
+    [Se.default.rootData, Se.default.rootData]
+  ];
+  i.opts.dynamicRef && y.push([Se.default.dynamicAnchors, Se.default.dynamicAnchors]);
+  const b = (0, J._)`${m}, ${r.object(...y)}`;
+  return u !== J.nil ? (0, J._)`${d}.call(${u}, ${b})` : (0, J._)`${d}(${b})`;
+}
+K.callValidateCode = ca;
+const la = (0, J._)`new RegExp`;
+function da({ gen: e, it: { opts: t } }, r) {
+  const s = t.unicodeRegExp ? "u" : "", { regExp: o } = t.code, a = o(r, s);
+  return e.scopeValue("pattern", {
+    key: a.toString(),
+    ref: a,
+    code: (0, J._)`${o.code === "new RegExp" ? la : (0, ra.useFunc)(e, o)}(${r}, ${s})`
+  });
+}
+K.usePattern = da;
+function ua(e) {
+  const { gen: t, data: r, keyword: s, it: o } = e, a = t.name("valid");
+  if (o.allErrors) {
+    const d = t.let("valid", !0);
+    return i(() => t.assign(d, !1)), d;
+  }
+  return t.var(a, !0), i(() => t.break()), a;
+  function i(d) {
+    const u = t.const("len", (0, J._)`${r}.length`);
+    t.forRange("i", 0, u, (l) => {
+      e.subschema({
+        keyword: s,
+        dataProp: l,
+        dataPropType: mr.Type.Num
+      }, a), t.if((0, J.not)(a), d);
+    });
+  }
+}
+K.validateArray = ua;
+function fa(e) {
+  const { gen: t, schema: r, keyword: s, it: o } = e;
+  if (!Array.isArray(r))
+    throw new Error("ajv implementation error");
+  if (r.some((u) => (0, mr.alwaysValidSchema)(o, u)) && !o.opts.unevaluated)
+    return;
+  const i = t.let("valid", !1), d = t.name("_valid");
+  t.block(() => r.forEach((u, l) => {
+    const m = e.subschema({
+      keyword: s,
+      schemaProp: l,
+      compositeRule: !0
+    }, d);
+    t.assign(i, (0, J._)`${i} || ${d}`), e.mergeValidEvaluated(m, d) || t.if((0, J.not)(i));
+  })), e.result(i, () => e.reset(), () => e.error(!0));
+}
+K.validateUnion = fa;
+Object.defineProperty(_e, "__esModule", { value: !0 });
+_e.validateKeywordUsage = _e.validSchemaType = _e.funcKeywordCode = _e.macroKeywordCode = void 0;
+const x = q, Te = ve, ma = K, ha = mt;
+function pa(e, t) {
+  const { gen: r, keyword: s, schema: o, parentSchema: a, it: i } = e, d = t.macro.call(i.self, o, a, i), u = Ys(r, s, d);
+  i.opts.validateSchema !== !1 && i.self.validateSchema(d, !0);
+  const l = r.name("valid");
+  e.subschema({
+    schema: d,
+    schemaPath: x.nil,
+    errSchemaPath: `${i.errSchemaPath}/${s}`,
+    topSchemaRef: u,
+    compositeRule: !0
+  }, l), e.pass(l, () => e.error(!0));
+}
+_e.macroKeywordCode = pa;
+function ya(e, t) {
+  var r;
+  const { gen: s, keyword: o, schema: a, parentSchema: i, $data: d, it: u } = e;
+  va(u, t);
+  const l = !d && t.compile ? t.compile.call(u.self, a, i, u) : t.validate, m = Ys(s, o, l), y = s.let("valid");
+  e.block$data(y, b), e.ok((r = t.valid) !== null && r !== void 0 ? r : y);
+  function b() {
+    if (t.errors === !1)
+      v(), t.modifying && ss(e), h(() => e.error());
+    else {
+      const f = t.async ? E() : g();
+      t.modifying && ss(e), h(() => _a(e, f));
+    }
+  }
+  function E() {
+    const f = s.let("ruleErrs", null);
+    return s.try(() => v((0, x._)`await `), ($) => s.assign(y, !1).if((0, x._)`${$} instanceof ${u.ValidationError}`, () => s.assign(f, (0, x._)`${$}.errors`), () => s.throw($))), f;
+  }
+  function g() {
+    const f = (0, x._)`${m}.errors`;
+    return s.assign(f, null), v(x.nil), f;
+  }
+  function v(f = t.async ? (0, x._)`await ` : x.nil) {
+    const $ = u.opts.passContext ? Te.default.this : Te.default.self, P = !("compile" in t && !d || t.schema === !1);
+    s.assign(y, (0, x._)`${f}${(0, ma.callValidateCode)(e, m, $, P)}`, t.modifying);
+  }
+  function h(f) {
+    var $;
+    s.if((0, x.not)(($ = t.valid) !== null && $ !== void 0 ? $ : y), f);
+  }
+}
+_e.funcKeywordCode = ya;
+function ss(e) {
+  const { gen: t, data: r, it: s } = e;
+  t.if(s.parentData, () => t.assign(r, (0, x._)`${s.parentData}[${s.parentDataProperty}]`));
+}
+function _a(e, t) {
+  const { gen: r } = e;
+  r.if((0, x._)`Array.isArray(${t})`, () => {
+    r.assign(Te.default.vErrors, (0, x._)`${Te.default.vErrors} === null ? ${t} : ${Te.default.vErrors}.concat(${t})`).assign(Te.default.errors, (0, x._)`${Te.default.vErrors}.length`), (0, ha.extendErrors)(e);
+  }, () => e.error());
+}
+function va({ schemaEnv: e }, t) {
+  if (t.async && !e.$async)
+    throw new Error("async keyword in sync schema");
+}
+function Ys(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, x.stringify)(r) });
+}
+function $a(e, t, r = !1) {
+  return !t.length || t.some((s) => s === "array" ? Array.isArray(e) : s === "object" ? e && typeof e == "object" && !Array.isArray(e) : typeof e == s || r && typeof e > "u");
+}
+_e.validSchemaType = $a;
+function ga({ schema: e, opts: t, self: r, errSchemaPath: s }, o, a) {
+  if (Array.isArray(o.keyword) ? !o.keyword.includes(a) : o.keyword !== a)
+    throw new Error("ajv implementation error");
+  const i = o.dependencies;
+  if (i != null && i.some((d) => !Object.prototype.hasOwnProperty.call(e, d)))
+    throw new Error(`parent schema must have dependencies of ${a}: ${i.join(",")}`);
+  if (o.validateSchema && !o.validateSchema(e[a])) {
+    const u = `keyword "${a}" value is invalid at path "${s}": ` + r.errorsText(o.validateSchema.errors);
+    if (t.validateSchema === "log")
+      r.logger.error(u);
+    else
+      throw new Error(u);
+  }
+}
+_e.validateKeywordUsage = ga;
+var Ce = {};
+Object.defineProperty(Ce, "__esModule", { value: !0 });
+Ce.extendSubschemaMode = Ce.extendSubschemaData = Ce.getSubschema = void 0;
+const ye = q, Zs = N;
+function wa(e, { keyword: t, schemaProp: r, schema: s, schemaPath: o, errSchemaPath: a, topSchemaRef: i }) {
+  if (t !== void 0 && s !== void 0)
+    throw new Error('both "keyword" and "schema" passed, only one allowed');
+  if (t !== void 0) {
+    const d = e.schema[t];
+    return r === void 0 ? {
+      schema: d,
+      schemaPath: (0, ye._)`${e.schemaPath}${(0, ye.getProperty)(t)}`,
+      errSchemaPath: `${e.errSchemaPath}/${t}`
+    } : {
+      schema: d[r],
+      schemaPath: (0, ye._)`${e.schemaPath}${(0, ye.getProperty)(t)}${(0, ye.getProperty)(r)}`,
+      errSchemaPath: `${e.errSchemaPath}/${t}/${(0, Zs.escapeFragment)(r)}`
+    };
+  }
+  if (s !== void 0) {
+    if (o === void 0 || a === void 0 || i === void 0)
+      throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
+    return {
+      schema: s,
+      schemaPath: o,
+      topSchemaRef: i,
+      errSchemaPath: a
+    };
+  }
+  throw new Error('either "keyword" or "schema" must be passed');
+}
+Ce.getSubschema = wa;
+function ba(e, t, { dataProp: r, dataPropType: s, data: o, dataTypes: a, propertyName: i }) {
+  if (o !== void 0 && r !== void 0)
+    throw new Error('both "data" and "dataProp" passed, only one allowed');
+  const { gen: d } = t;
+  if (r !== void 0) {
+    const { errorPath: l, dataPathArr: m, opts: y } = t, b = d.let("data", (0, ye._)`${t.data}${(0, ye.getProperty)(r)}`, !0);
+    u(b), e.errorPath = (0, ye.str)`${l}${(0, Zs.getErrorPath)(r, s, y.jsPropertySyntax)}`, e.parentDataProperty = (0, ye._)`${r}`, e.dataPathArr = [...m, e.parentDataProperty];
+  }
+  if (o !== void 0) {
+    const l = o instanceof ye.Name ? o : d.let("data", o, !0);
+    u(l), i !== void 0 && (e.propertyName = i);
+  }
+  a && (e.dataTypes = a);
+  function u(l) {
+    e.data = l, e.dataLevel = t.dataLevel + 1, e.dataTypes = [], t.definedProperties = /* @__PURE__ */ new Set(), e.parentData = t.data, e.dataNames = [...t.dataNames, l];
+  }
+}
+Ce.extendSubschemaData = ba;
+function Ea(e, { jtdDiscriminator: t, jtdMetadata: r, compositeRule: s, createErrors: o, allErrors: a }) {
+  s !== void 0 && (e.compositeRule = s), o !== void 0 && (e.createErrors = o), a !== void 0 && (e.allErrors = a), e.jtdDiscriminator = t, e.jtdMetadata = r;
+}
+Ce.extendSubschemaMode = Ea;
+var Z = {};
+Object.defineProperty(Z, "__esModule", { value: !0 });
+Z.getSchemaRefs = Z.resolveUrl = Z.normalizeId = Z._getFullPath = Z.getFullPath = Z.inlineRef = void 0;
+const Sa = N, Pa = Ps, ka = To, Na = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "pattern",
+  "maxLength",
+  "minLength",
+  "maxProperties",
+  "minProperties",
+  "maxItems",
+  "minItems",
+  "maximum",
+  "minimum",
+  "uniqueItems",
+  "multipleOf",
+  "required",
+  "enum",
+  "const"
+]);
+function Ca(e, t = !0) {
+  return typeof e == "boolean" ? !0 : t === !0 ? !nr(e) : t ? Ds(e) <= t : !1;
+}
+Z.inlineRef = Ca;
+const ja = /* @__PURE__ */ new Set([
+  "$ref",
+  "$recursiveRef",
+  "$recursiveAnchor",
+  "$dynamicRef",
+  "$dynamicAnchor"
+]);
+function nr(e) {
+  for (const t in e) {
+    if (ja.has(t))
+      return !0;
+    const r = e[t];
+    if (Array.isArray(r) && r.some(nr) || typeof r == "object" && nr(r))
+      return !0;
+  }
+  return !1;
+}
+function Ds(e) {
+  let t = 0;
+  for (const r in e) {
+    if (r === "$ref")
+      return 1 / 0;
+    if (t++, !Na.has(r) && (typeof e[r] == "object" && (0, Sa.eachItem)(e[r], (s) => t += Ds(s)), t === 1 / 0))
+      return 1 / 0;
+  }
+  return t;
+}
+function Ws(e, t = "", r) {
+  r !== !1 && (t = Be(t));
+  const s = e.parse(t);
+  return xs(e, s);
+}
+Z.getFullPath = Ws;
+function xs(e, t) {
+  return e.serialize(t).split("#")[0] + "#";
+}
+Z._getFullPath = xs;
+const Ra = /#\/?$/;
+function Be(e) {
+  return e ? e.replace(Ra, "") : "";
+}
+Z.normalizeId = Be;
+function Oa(e, t, r) {
+  return r = Be(r), e.resolve(t, r);
+}
+Z.resolveUrl = Oa;
+const Ta = /^[a-z_][-a-z0-9._]*$/i;
+function Ia(e, t) {
+  if (typeof e == "boolean")
+    return {};
+  const { schemaId: r, uriResolver: s } = this.opts, o = Be(e[r] || t), a = { "": o }, i = Ws(s, o, !1), d = {}, u = /* @__PURE__ */ new Set();
+  return ka(e, { allKeys: !0 }, (y, b, E, g) => {
+    if (g === void 0)
+      return;
+    const v = i + b;
+    let h = a[g];
+    typeof y[r] == "string" && (h = f.call(this, y[r])), $.call(this, y.$anchor), $.call(this, y.$dynamicAnchor), a[b] = h;
+    function f(P) {
+      const R = this.opts.uriResolver.resolve;
+      if (P = Be(h ? R(h, P) : P), u.has(P))
+        throw m(P);
+      u.add(P);
+      let C = this.refs[P];
+      return typeof C == "string" && (C = this.refs[C]), typeof C == "object" ? l(y, C.schema, P) : P !== Be(v) && (P[0] === "#" ? (l(y, d[P], P), d[P] = y) : this.refs[P] = v), P;
+    }
+    function $(P) {
+      if (typeof P == "string") {
+        if (!Ta.test(P))
+          throw new Error(`invalid anchor "${P}"`);
+        f.call(this, `#${P}`);
+      }
+    }
+  }), d;
+  function l(y, b, E) {
+    if (b !== void 0 && !Pa(y, b))
+      throw m(E);
+  }
+  function m(y) {
+    return new Error(`reference "${y}" resolves to more than one schema`);
+  }
+}
+Z.getSchemaRefs = Ia;
+Object.defineProperty(fe, "__esModule", { value: !0 });
+fe.getData = fe.KeywordCxt = fe.validateFunctionCode = void 0;
+const eo = Qe, os = X, yr = we, kt = X, Ma = Rt, nt = _e, Bt = Ce, T = q, I = ve, Va = Z, be = N, tt = mt;
+function Fa(e) {
+  if (so(e) && (oo(e), ro(e))) {
+    Ua(e);
+    return;
+  }
+  to(e, () => (0, eo.topBoolOrEmptySchema)(e));
+}
+fe.validateFunctionCode = Fa;
+function to({ gen: e, validateName: t, schema: r, schemaEnv: s, opts: o }, a) {
+  o.code.es5 ? e.func(t, (0, T._)`${I.default.data}, ${I.default.valCxt}`, s.$async, () => {
+    e.code((0, T._)`"use strict"; ${ns(r, o)}`), qa(e, o), e.code(a);
+  }) : e.func(t, (0, T._)`${I.default.data}, ${Ka(o)}`, s.$async, () => e.code(ns(r, o)).code(a));
+}
+function Ka(e) {
+  return (0, T._)`{${I.default.instancePath}="", ${I.default.parentData}, ${I.default.parentDataProperty}, ${I.default.rootData}=${I.default.data}${e.dynamicRef ? (0, T._)`, ${I.default.dynamicAnchors}={}` : T.nil}}={}`;
+}
+function qa(e, t) {
+  e.if(I.default.valCxt, () => {
+    e.var(I.default.instancePath, (0, T._)`${I.default.valCxt}.${I.default.instancePath}`), e.var(I.default.parentData, (0, T._)`${I.default.valCxt}.${I.default.parentData}`), e.var(I.default.parentDataProperty, (0, T._)`${I.default.valCxt}.${I.default.parentDataProperty}`), e.var(I.default.rootData, (0, T._)`${I.default.valCxt}.${I.default.rootData}`), t.dynamicRef && e.var(I.default.dynamicAnchors, (0, T._)`${I.default.valCxt}.${I.default.dynamicAnchors}`);
+  }, () => {
+    e.var(I.default.instancePath, (0, T._)`""`), e.var(I.default.parentData, (0, T._)`undefined`), e.var(I.default.parentDataProperty, (0, T._)`undefined`), e.var(I.default.rootData, I.default.data), t.dynamicRef && e.var(I.default.dynamicAnchors, (0, T._)`{}`);
+  });
+}
+function Ua(e) {
+  const { schema: t, opts: r, gen: s } = e;
+  to(e, () => {
+    r.$comment && t.$comment && ao(e), Ja(e), s.let(I.default.vErrors, null), s.let(I.default.errors, 0), r.unevaluated && za(e), no(e), Qa(e);
+  });
+}
+function za(e) {
+  const { gen: t, validateName: r } = e;
+  e.evaluated = t.const("evaluated", (0, T._)`${r}.evaluated`), t.if((0, T._)`${e.evaluated}.dynamicProps`, () => t.assign((0, T._)`${e.evaluated}.props`, (0, T._)`undefined`)), t.if((0, T._)`${e.evaluated}.dynamicItems`, () => t.assign((0, T._)`${e.evaluated}.items`, (0, T._)`undefined`));
+}
+function ns(e, t) {
+  const r = typeof e == "object" && e[t.schemaId];
+  return r && (t.code.source || t.code.process) ? (0, T._)`/*# sourceURL=${r} */` : T.nil;
+}
+function Aa(e, t) {
+  if (so(e) && (oo(e), ro(e))) {
+    La(e, t);
+    return;
+  }
+  (0, eo.boolOrEmptySchema)(e, t);
+}
+function ro({ 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 so(e) {
+  return typeof e.schema != "boolean";
+}
+function La(e, t) {
+  const { schema: r, gen: s, opts: o } = e;
+  o.$comment && r.$comment && ao(e), Ha(e), Ba(e);
+  const a = s.const("_errs", I.default.errors);
+  no(e, a), s.var(t, (0, T._)`${a} === ${I.default.errors}`);
+}
+function oo(e) {
+  (0, be.checkUnknownRules)(e), Ga(e);
+}
+function no(e, t) {
+  if (e.opts.jtd)
+    return as(e, [], !1, t);
+  const r = (0, os.getSchemaTypes)(e.schema), s = (0, os.coerceAndCheckDataType)(e, r);
+  as(e, r, !s, t);
+}
+function Ga(e) {
+  const { schema: t, errSchemaPath: r, opts: s, self: o } = e;
+  t.$ref && s.ignoreKeywordsWithRef && (0, be.schemaHasRulesButRef)(t, o.RULES) && o.logger.warn(`$ref: keywords ignored in schema at path "${r}"`);
+}
+function Ja(e) {
+  const { schema: t, opts: r } = e;
+  t.default !== void 0 && r.useDefaults && r.strictSchema && (0, be.checkStrictMode)(e, "default is ignored in the schema root");
+}
+function Ha(e) {
+  const t = e.schema[e.opts.schemaId];
+  t && (e.baseId = (0, Va.resolveUrl)(e.opts.uriResolver, e.baseId, t));
+}
+function Ba(e) {
+  if (e.schema.$async && !e.schemaEnv.$async)
+    throw new Error("async schema in sync schema");
+}
+function ao({ gen: e, schemaEnv: t, schema: r, errSchemaPath: s, opts: o }) {
+  const a = r.$comment;
+  if (o.$comment === !0)
+    e.code((0, T._)`${I.default.self}.logger.log(${a})`);
+  else if (typeof o.$comment == "function") {
+    const i = (0, T.str)`${s}/$comment`, d = e.scopeValue("root", { ref: t.root });
+    e.code((0, T._)`${I.default.self}.opts.$comment(${a}, ${i}, ${d}.schema)`);
+  }
+}
+function Qa(e) {
+  const { gen: t, schemaEnv: r, validateName: s, ValidationError: o, opts: a } = e;
+  r.$async ? t.if((0, T._)`${I.default.errors} === 0`, () => t.return(I.default.data), () => t.throw((0, T._)`new ${o}(${I.default.vErrors})`)) : (t.assign((0, T._)`${s}.errors`, I.default.vErrors), a.unevaluated && Xa(e), t.return((0, T._)`${I.default.errors} === 0`));
+}
+function Xa({ gen: e, evaluated: t, props: r, items: s }) {
+  r instanceof T.Name && e.assign((0, T._)`${t}.props`, r), s instanceof T.Name && e.assign((0, T._)`${t}.items`, s);
+}
+function as(e, t, r, s) {
+  const { gen: o, schema: a, data: i, allErrors: d, opts: u, self: l } = e, { RULES: m } = l;
+  if (a.$ref && (u.ignoreKeywordsWithRef || !(0, be.schemaHasRulesButRef)(a, m))) {
+    o.block(() => lo(e, "$ref", m.all.$ref.definition));
+    return;
+  }
+  u.jtd || Ya(e, t), o.block(() => {
+    for (const b of m.rules)
+      y(b);
+    y(m.post);
+  });
+  function y(b) {
+    (0, yr.shouldUseGroup)(a, b) && (b.type ? (o.if((0, kt.checkDataType)(b.type, i, u.strictNumbers)), is(e, b), t.length === 1 && t[0] === b.type && r && (o.else(), (0, kt.reportTypeError)(e)), o.endIf()) : is(e, b), d || o.if((0, T._)`${I.default.errors} === ${s || 0}`));
+  }
+}
+function is(e, t) {
+  const { gen: r, schema: s, opts: { useDefaults: o } } = e;
+  o && (0, Ma.assignDefaults)(e, t.type), r.block(() => {
+    for (const a of t.rules)
+      (0, yr.shouldUseRule)(s, a) && lo(e, a.keyword, a.definition, t.type);
+  });
+}
+function Ya(e, t) {
+  e.schemaEnv.meta || !e.opts.strictTypes || (Za(e, t), e.opts.allowUnionTypes || Da(e, t), Wa(e, e.dataTypes));
+}
+function Za(e, t) {
+  if (t.length) {
+    if (!e.dataTypes.length) {
+      e.dataTypes = t;
+      return;
+    }
+    t.forEach((r) => {
+      io(e.dataTypes, r) || _r(e, `type "${r}" not allowed by context "${e.dataTypes.join(",")}"`);
+    }), ei(e, t);
+  }
+}
+function Da(e, t) {
+  t.length > 1 && !(t.length === 2 && t.includes("null")) && _r(e, "use allowUnionTypes to allow union type keyword");
+}
+function Wa(e, t) {
+  const r = e.self.RULES.all;
+  for (const s in r) {
+    const o = r[s];
+    if (typeof o == "object" && (0, yr.shouldUseRule)(e.schema, o)) {
+      const { type: a } = o.definition;
+      a.length && !a.some((i) => xa(t, i)) && _r(e, `missing type "${a.join(",")}" for keyword "${s}"`);
+    }
+  }
+}
+function xa(e, t) {
+  return e.includes(t) || t === "number" && e.includes("integer");
+}
+function io(e, t) {
+  return e.includes(t) || t === "integer" && e.includes("number");
+}
+function ei(e, t) {
+  const r = [];
+  for (const s of e.dataTypes)
+    io(t, s) ? r.push(s) : t.includes("integer") && s === "number" && r.push("integer");
+  e.dataTypes = r;
+}
+function _r(e, t) {
+  const r = e.schemaEnv.baseId + e.errSchemaPath;
+  t += ` at "${r}" (strictTypes)`, (0, be.checkStrictMode)(e, t, e.opts.strictTypes);
+}
+class co {
+  constructor(t, r, s) {
+    if ((0, nt.validateKeywordUsage)(t, r, s), this.gen = t.gen, this.allErrors = t.allErrors, this.keyword = s, this.data = t.data, this.schema = t.schema[s], this.$data = r.$data && t.opts.$data && this.schema && this.schema.$data, this.schemaValue = (0, be.schemaRefOrVal)(t, this.schema, s, 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", uo(this.$data, t));
+    else if (this.schemaCode = this.schemaValue, !(0, nt.validSchemaType)(this.schema, r.schemaType, r.allowUndefined))
+      throw new Error(`${s} value must be ${JSON.stringify(r.schemaType)}`);
+    ("code" in r ? r.trackErrors : r.errors !== !1) && (this.errsCount = t.gen.const("_errs", I.default.errors));
+  }
+  result(t, r, s) {
+    this.failResult((0, T.not)(t), r, s);
+  }
+  failResult(t, r, s) {
+    this.gen.if(t), s ? s() : 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, T.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, T._)`${r} !== undefined && (${(0, T.or)(this.invalid$data(), t)})`);
+  }
+  error(t, r, s) {
+    if (r) {
+      this.setParams(r), this._error(t, s), this.setParams({});
+      return;
+    }
+    this._error(t, s);
+  }
+  _error(t, r) {
+    (t ? tt.reportExtraError : tt.reportError)(this, this.def.error, r);
+  }
+  $dataError() {
+    (0, tt.reportError)(this, this.def.$dataError || tt.keyword$DataError);
+  }
+  reset() {
+    if (this.errsCount === void 0)
+      throw new Error('add "trackErrors" to keyword definition');
+    (0, tt.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, s = T.nil) {
+    this.gen.block(() => {
+      this.check$data(t, s), r();
+    });
+  }
+  check$data(t = T.nil, r = T.nil) {
+    if (!this.$data)
+      return;
+    const { gen: s, schemaCode: o, schemaType: a, def: i } = this;
+    s.if((0, T.or)((0, T._)`${o} === undefined`, r)), t !== T.nil && s.assign(t, !0), (a.length || i.validateSchema) && (s.elseIf(this.invalid$data()), this.$dataError(), t !== T.nil && s.assign(t, !1)), s.else();
+  }
+  invalid$data() {
+    const { gen: t, schemaCode: r, schemaType: s, def: o, it: a } = this;
+    return (0, T.or)(i(), d());
+    function i() {
+      if (s.length) {
+        if (!(r instanceof T.Name))
+          throw new Error("ajv implementation error");
+        const u = Array.isArray(s) ? s : [s];
+        return (0, T._)`${(0, kt.checkDataTypes)(u, r, a.opts.strictNumbers, kt.DataType.Wrong)}`;
+      }
+      return T.nil;
+    }
+    function d() {
+      if (o.validateSchema) {
+        const u = t.scopeValue("validate$data", { ref: o.validateSchema });
+        return (0, T._)`!${u}(${r})`;
+      }
+      return T.nil;
+    }
+  }
+  subschema(t, r) {
+    const s = (0, Bt.getSubschema)(this.it, t);
+    (0, Bt.extendSubschemaData)(s, this.it, t), (0, Bt.extendSubschemaMode)(s, t);
+    const o = { ...this.it, ...s, items: void 0, props: void 0 };
+    return Aa(o, r), o;
+  }
+  mergeEvaluated(t, r) {
+    const { it: s, gen: o } = this;
+    s.opts.unevaluated && (s.props !== !0 && t.props !== void 0 && (s.props = be.mergeEvaluated.props(o, t.props, s.props, r)), s.items !== !0 && t.items !== void 0 && (s.items = be.mergeEvaluated.items(o, t.items, s.items, r)));
+  }
+  mergeValidEvaluated(t, r) {
+    const { it: s, gen: o } = this;
+    if (s.opts.unevaluated && (s.props !== !0 || s.items !== !0))
+      return o.if(r, () => this.mergeEvaluated(t, T.Name)), !0;
+  }
+}
+fe.KeywordCxt = co;
+function lo(e, t, r, s) {
+  const o = new co(e, r, t);
+  "code" in r ? r.code(o, s) : o.$data && r.validate ? (0, nt.funcKeywordCode)(o, r) : "macro" in r ? (0, nt.macroKeywordCode)(o, r) : (r.compile || r.validate) && (0, nt.funcKeywordCode)(o, r);
+}
+const ti = /^\/(?:[^~]|~0|~1)*$/, ri = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
+function uo(e, { dataLevel: t, dataNames: r, dataPathArr: s }) {
+  let o, a;
+  if (e === "")
+    return I.default.rootData;
+  if (e[0] === "/") {
+    if (!ti.test(e))
+      throw new Error(`Invalid JSON-pointer: ${e}`);
+    o = e, a = I.default.rootData;
+  } else {
+    const l = ri.exec(e);
+    if (!l)
+      throw new Error(`Invalid JSON-pointer: ${e}`);
+    const m = +l[1];
+    if (o = l[2], o === "#") {
+      if (m >= t)
+        throw new Error(u("property/index", m));
+      return s[t - m];
+    }
+    if (m > t)
+      throw new Error(u("data", m));
+    if (a = r[t - m], !o)
+      return a;
+  }
+  let i = a;
+  const d = o.split("/");
+  for (const l of d)
+    l && (a = (0, T._)`${a}${(0, T.getProperty)((0, be.unescapeJsonPointer)(l))}`, i = (0, T._)`${i} && ${a}`);
+  return i;
+  function u(l, m) {
+    return `Cannot access ${l} ${m} levels up, current level is ${t}`;
+  }
+}
+fe.getData = uo;
+var ht = {};
+Object.defineProperty(ht, "__esModule", { value: !0 });
+class si extends Error {
+  constructor(t) {
+    super("validation failed"), this.errors = t, this.ajv = this.validation = !0;
+  }
+}
+ht.default = si;
+var Ye = {};
+Object.defineProperty(Ye, "__esModule", { value: !0 });
+const Qt = Z;
+class oi extends Error {
+  constructor(t, r, s, o) {
+    super(o || `can't resolve reference ${s} from id ${r}`), this.missingRef = (0, Qt.resolveUrl)(t, r, s), this.missingSchema = (0, Qt.normalizeId)((0, Qt.getFullPath)(t, this.missingRef));
+  }
+}
+Ye.default = oi;
+var re = {};
+Object.defineProperty(re, "__esModule", { value: !0 });
+re.resolveSchema = re.getCompilingSchema = re.resolveRef = re.compileSchema = re.SchemaEnv = void 0;
+const ce = q, ni = ht, Re = ve, ue = Z, cs = N, ai = fe;
+class Ot {
+  constructor(t) {
+    var r;
+    this.refs = {}, this.dynamicAnchors = {};
+    let s;
+    typeof t.schema == "object" && (s = 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, ue.normalizeId)(s == null ? void 0 : s[t.schemaId || "$id"]), this.schemaPath = t.schemaPath, this.localRefs = t.localRefs, this.meta = t.meta, this.$async = s == null ? void 0 : s.$async, this.refs = {};
+  }
+}
+re.SchemaEnv = Ot;
+function vr(e) {
+  const t = fo.call(this, e);
+  if (t)
+    return t;
+  const r = (0, ue.getFullPath)(this.opts.uriResolver, e.root.baseId), { es5: s, lines: o } = this.opts.code, { ownProperties: a } = this.opts, i = new ce.CodeGen(this.scope, { es5: s, lines: o, ownProperties: a });
+  let d;
+  e.$async && (d = i.scopeValue("Error", {
+    ref: ni.default,
+    code: (0, ce._)`require("ajv/dist/runtime/validation_error").default`
+  }));
+  const u = i.scopeName("validate");
+  e.validateName = u;
+  const l = {
+    gen: i,
+    allErrors: this.opts.allErrors,
+    data: Re.default.data,
+    parentData: Re.default.parentData,
+    parentDataProperty: Re.default.parentDataProperty,
+    dataNames: [Re.default.data],
+    dataPathArr: [ce.nil],
+    // TODO can its length be used as dataLevel if nil is removed?
+    dataLevel: 0,
+    dataTypes: [],
+    definedProperties: /* @__PURE__ */ new Set(),
+    topSchemaRef: i.scopeValue("schema", this.opts.code.source === !0 ? { ref: e.schema, code: (0, ce.stringify)(e.schema) } : { ref: e.schema }),
+    validateName: u,
+    ValidationError: d,
+    schema: e.schema,
+    schemaEnv: e,
+    rootId: r,
+    baseId: e.baseId || r,
+    schemaPath: ce.nil,
+    errSchemaPath: e.schemaPath || (this.opts.jtd ? "" : "#"),
+    errorPath: (0, ce._)`""`,
+    opts: this.opts,
+    self: this
+  };
+  let m;
+  try {
+    this._compilations.add(e), (0, ai.validateFunctionCode)(l), i.optimize(this.opts.code.optimize);
+    const y = i.toString();
+    m = `${i.scopeRefs(Re.default.scope)}return ${y}`, this.opts.code.process && (m = this.opts.code.process(m, e));
+    const E = new Function(`${Re.default.self}`, `${Re.default.scope}`, m)(this, this.scope.get());
+    if (this.scope.value(u, { ref: E }), E.errors = null, E.schema = e.schema, E.schemaEnv = e, e.$async && (E.$async = !0), this.opts.code.source === !0 && (E.source = { validateName: u, validateCode: y, scopeValues: i._values }), this.opts.unevaluated) {
+      const { props: g, items: v } = l;
+      E.evaluated = {
+        props: g instanceof ce.Name ? void 0 : g,
+        items: v instanceof ce.Name ? void 0 : v,
+        dynamicProps: g instanceof ce.Name,
+        dynamicItems: v instanceof ce.Name
+      }, E.source && (E.source.evaluated = (0, ce.stringify)(E.evaluated));
+    }
+    return e.validate = E, e;
+  } catch (y) {
+    throw delete e.validate, delete e.validateName, m && this.logger.error("Error compiling schema, function code:", m), y;
+  } finally {
+    this._compilations.delete(e);
+  }
+}
+re.compileSchema = vr;
+function ii(e, t, r) {
+  var s;
+  r = (0, ue.resolveUrl)(this.opts.uriResolver, t, r);
+  const o = e.refs[r];
+  if (o)
+    return o;
+  let a = di.call(this, e, r);
+  if (a === void 0) {
+    const i = (s = e.localRefs) === null || s === void 0 ? void 0 : s[r], { schemaId: d } = this.opts;
+    i && (a = new Ot({ schema: i, schemaId: d, root: e, baseId: t }));
+  }
+  if (a !== void 0)
+    return e.refs[r] = ci.call(this, a);
+}
+re.resolveRef = ii;
+function ci(e) {
+  return (0, ue.inlineRef)(e.schema, this.opts.inlineRefs) ? e.schema : e.validate ? e : vr.call(this, e);
+}
+function fo(e) {
+  for (const t of this._compilations)
+    if (li(t, e))
+      return t;
+}
+re.getCompilingSchema = fo;
+function li(e, t) {
+  return e.schema === t.schema && e.root === t.root && e.baseId === t.baseId;
+}
+function di(e, t) {
+  let r;
+  for (; typeof (r = this.refs[t]) == "string"; )
+    t = r;
+  return r || this.schemas[t] || Tt.call(this, e, t);
+}
+function Tt(e, t) {
+  const r = this.opts.uriResolver.parse(t), s = (0, ue._getFullPath)(this.opts.uriResolver, r);
+  let o = (0, ue.getFullPath)(this.opts.uriResolver, e.baseId, void 0);
+  if (Object.keys(e.schema).length > 0 && s === o)
+    return Xt.call(this, r, e);
+  const a = (0, ue.normalizeId)(s), i = this.refs[a] || this.schemas[a];
+  if (typeof i == "string") {
+    const d = Tt.call(this, e, i);
+    return typeof (d == null ? void 0 : d.schema) != "object" ? void 0 : Xt.call(this, r, d);
+  }
+  if (typeof (i == null ? void 0 : i.schema) == "object") {
+    if (i.validate || vr.call(this, i), a === (0, ue.normalizeId)(t)) {
+      const { schema: d } = i, { schemaId: u } = this.opts, l = d[u];
+      return l && (o = (0, ue.resolveUrl)(this.opts.uriResolver, o, l)), new Ot({ schema: d, schemaId: u, root: e, baseId: o });
+    }
+    return Xt.call(this, r, i);
+  }
+}
+re.resolveSchema = Tt;
+const ui = /* @__PURE__ */ new Set([
+  "properties",
+  "patternProperties",
+  "enum",
+  "dependencies",
+  "definitions"
+]);
+function Xt(e, { baseId: t, schema: r, root: s }) {
+  var o;
+  if (((o = e.fragment) === null || o === void 0 ? void 0 : o[0]) !== "/")
+    return;
+  for (const d of e.fragment.slice(1).split("/")) {
+    if (typeof r == "boolean")
+      return;
+    const u = r[(0, cs.unescapeFragment)(d)];
+    if (u === void 0)
+      return;
+    r = u;
+    const l = typeof r == "object" && r[this.opts.schemaId];
+    !ui.has(d) && l && (t = (0, ue.resolveUrl)(this.opts.uriResolver, t, l));
+  }
+  let a;
+  if (typeof r != "boolean" && r.$ref && !(0, cs.schemaHasRulesButRef)(r, this.RULES)) {
+    const d = (0, ue.resolveUrl)(this.opts.uriResolver, t, r.$ref);
+    a = Tt.call(this, s, d);
+  }
+  const { schemaId: i } = this.opts;
+  if (a = a || new Ot({ schema: r, schemaId: i, root: s, baseId: t }), a.schema !== a.root.schema)
+    return a;
+}
+const fi = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#", mi = "Meta-schema for $data reference (JSON AnySchema extension proposal)", hi = "object", pi = [
+  "$data"
+], yi = {
+  $data: {
+    type: "string",
+    anyOf: [
+      {
+        format: "relative-json-pointer"
+      },
+      {
+        format: "json-pointer"
+      }
+    ]
+  }
+}, _i = !1, vi = {
+  $id: fi,
+  description: mi,
+  type: hi,
+  required: pi,
+  properties: yi,
+  additionalProperties: _i
+};
+var $r = {};
+Object.defineProperty($r, "__esModule", { value: !0 });
+const mo = Io;
+mo.code = 'require("ajv/dist/runtime/uri").default';
+$r.default = mo;
+(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 = fe;
+  Object.defineProperty(e, "KeywordCxt", { enumerable: !0, get: function() {
+    return t.KeywordCxt;
+  } });
+  var r = q;
+  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 s = ht, o = Ye, a = Ve, i = re, d = q, u = Z, l = X, m = N, y = vi, b = $r, E = (k, p) => new RegExp(k, p);
+  E.code = "new RegExp";
+  const g = ["removeAdditional", "useDefaults", "coerceTypes"], v = /* @__PURE__ */ new Set([
+    "validate",
+    "serialize",
+    "parse",
+    "wrapper",
+    "root",
+    "schema",
+    "keyword",
+    "pattern",
+    "formats",
+    "validate$data",
+    "func",
+    "obj",
+    "Error"
+  ]), h = {
+    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."
+  }, f = {
+    ignoreKeywordsWithRef: "",
+    jsPropertySyntax: "",
+    unicode: '"minLength"/"maxLength" account for unicode characters by default.'
+  }, $ = 200;
+  function P(k) {
+    var p, S, _, n, c, w, j, O, A, U, V, pe, Ue, We, ge, ze, Vt, Ft, Kt, qt, Ut, zt, At, Lt, Gt;
+    const xe = k.strict, Jt = (p = k.code) === null || p === void 0 ? void 0 : p.optimize, Wr = Jt === !0 || Jt === void 0 ? 1 : Jt || 0, xr = (_ = (S = k.code) === null || S === void 0 ? void 0 : S.regExp) !== null && _ !== void 0 ? _ : E, bo = (n = k.uriResolver) !== null && n !== void 0 ? n : b.default;
+    return {
+      strictSchema: (w = (c = k.strictSchema) !== null && c !== void 0 ? c : xe) !== null && w !== void 0 ? w : !0,
+      strictNumbers: (O = (j = k.strictNumbers) !== null && j !== void 0 ? j : xe) !== null && O !== void 0 ? O : !0,
+      strictTypes: (U = (A = k.strictTypes) !== null && A !== void 0 ? A : xe) !== null && U !== void 0 ? U : "log",
+      strictTuples: (pe = (V = k.strictTuples) !== null && V !== void 0 ? V : xe) !== null && pe !== void 0 ? pe : "log",
+      strictRequired: (We = (Ue = k.strictRequired) !== null && Ue !== void 0 ? Ue : xe) !== null && We !== void 0 ? We : !1,
+      code: k.code ? { ...k.code, optimize: Wr, regExp: xr } : { optimize: Wr, regExp: xr },
+      loopRequired: (ge = k.loopRequired) !== null && ge !== void 0 ? ge : $,
+      loopEnum: (ze = k.loopEnum) !== null && ze !== void 0 ? ze : $,
+      meta: (Vt = k.meta) !== null && Vt !== void 0 ? Vt : !0,
+      messages: (Ft = k.messages) !== null && Ft !== void 0 ? Ft : !0,
+      inlineRefs: (Kt = k.inlineRefs) !== null && Kt !== void 0 ? Kt : !0,
+      schemaId: (qt = k.schemaId) !== null && qt !== void 0 ? qt : "$id",
+      addUsedSchema: (Ut = k.addUsedSchema) !== null && Ut !== void 0 ? Ut : !0,
+      validateSchema: (zt = k.validateSchema) !== null && zt !== void 0 ? zt : !0,
+      validateFormats: (At = k.validateFormats) !== null && At !== void 0 ? At : !0,
+      unicodeRegExp: (Lt = k.unicodeRegExp) !== null && Lt !== void 0 ? Lt : !0,
+      int32range: (Gt = k.int32range) !== null && Gt !== void 0 ? Gt : !0,
+      uriResolver: bo
+    };
+  }
+  class R {
+    constructor(p = {}) {
+      this.schemas = {}, this.refs = {}, this.formats = {}, this._compilations = /* @__PURE__ */ new Set(), this._loading = {}, this._cache = /* @__PURE__ */ new Map(), p = this.opts = { ...p, ...P(p) };
+      const { es5: S, lines: _ } = this.opts.code;
+      this.scope = new d.ValueScope({ scope: {}, prefixes: v, es5: S, lines: _ }), this.logger = ie(p.logger);
+      const n = p.validateFormats;
+      p.validateFormats = !1, this.RULES = (0, a.getRules)(), C.call(this, h, p, "NOT SUPPORTED"), C.call(this, f, p, "DEPRECATED", "warn"), this._metaOpts = me.call(this), p.formats && oe.call(this), this._addVocabularies(), this._addDefaultMetaSchema(), p.keywords && ae.call(this, p.keywords), typeof p.meta == "object" && this.addMetaSchema(p.meta), H.call(this), p.validateFormats = n;
+    }
+    _addVocabularies() {
+      this.addKeyword("$async");
+    }
+    _addDefaultMetaSchema() {
+      const { $data: p, meta: S, schemaId: _ } = this.opts;
+      let n = y;
+      _ === "id" && (n = { ...y }, n.id = n.$id, delete n.$id), S && p && this.addMetaSchema(n, n[_], !1);
+    }
+    defaultMeta() {
+      const { meta: p, schemaId: S } = this.opts;
+      return this.opts.defaultMeta = typeof p == "object" ? p[S] || p : void 0;
+    }
+    validate(p, S) {
+      let _;
+      if (typeof p == "string") {
+        if (_ = this.getSchema(p), !_)
+          throw new Error(`no schema with key or ref "${p}"`);
+      } else
+        _ = this.compile(p);
+      const n = _(S);
+      return "$async" in _ || (this.errors = _.errors), n;
+    }
+    compile(p, S) {
+      const _ = this._addSchema(p, S);
+      return _.validate || this._compileSchemaEnv(_);
+    }
+    compileAsync(p, S) {
+      if (typeof this.opts.loadSchema != "function")
+        throw new Error("options.loadSchema should be a function");
+      const { loadSchema: _ } = this.opts;
+      return n.call(this, p, S);
+      async function n(U, V) {
+        await c.call(this, U.$schema);
+        const pe = this._addSchema(U, V);
+        return pe.validate || w.call(this, pe);
+      }
+      async function c(U) {
+        U && !this.getSchema(U) && await n.call(this, { $ref: U }, !0);
+      }
+      async function w(U) {
+        try {
+          return this._compileSchemaEnv(U);
+        } catch (V) {
+          if (!(V instanceof o.default))
+            throw V;
+          return j.call(this, V), await O.call(this, V.missingSchema), w.call(this, U);
+        }
+      }
+      function j({ missingSchema: U, missingRef: V }) {
+        if (this.refs[U])
+          throw new Error(`AnySchema ${U} is loaded but ${V} cannot be resolved`);
+      }
+      async function O(U) {
+        const V = await A.call(this, U);
+        this.refs[U] || await c.call(this, V.$schema), this.refs[U] || this.addSchema(V, U, S);
+      }
+      async function A(U) {
+        const V = this._loading[U];
+        if (V)
+          return V;
+        try {
+          return await (this._loading[U] = _(U));
+        } finally {
+          delete this._loading[U];
+        }
+      }
+    }
+    // Adds schema to the instance
+    addSchema(p, S, _, n = this.opts.validateSchema) {
+      if (Array.isArray(p)) {
+        for (const w of p)
+          this.addSchema(w, void 0, _, n);
+        return this;
+      }
+      let c;
+      if (typeof p == "object") {
+        const { schemaId: w } = this.opts;
+        if (c = p[w], c !== void 0 && typeof c != "string")
+          throw new Error(`schema ${w} must be string`);
+      }
+      return S = (0, u.normalizeId)(S || c), this._checkUnique(S), this.schemas[S] = this._addSchema(p, _, S, n, !0), this;
+    }
+    // Add schema that will be used to validate other schemas
+    // options in META_IGNORE_OPTIONS are alway set to false
+    addMetaSchema(p, S, _ = this.opts.validateSchema) {
+      return this.addSchema(p, S, !0, _), this;
+    }
+    //  Validate schema against its meta-schema
+    validateSchema(p, S) {
+      if (typeof p == "boolean")
+        return !0;
+      let _;
+      if (_ = p.$schema, _ !== void 0 && typeof _ != "string")
+        throw new Error("$schema must be a string");
+      if (_ = _ || this.opts.defaultMeta || this.defaultMeta(), !_)
+        return this.logger.warn("meta-schema not available"), this.errors = null, !0;
+      const n = this.validate(_, p);
+      if (!n && S) {
+        const c = "schema is invalid: " + this.errorsText();
+        if (this.opts.validateSchema === "log")
+          this.logger.error(c);
+        else
+          throw new Error(c);
+      }
+      return n;
+    }
+    // Get compiled schema by `key` or `ref`.
+    // (`key` that was passed to `addSchema` or full schema reference - `schema.$id` or resolved id)
+    getSchema(p) {
+      let S;
+      for (; typeof (S = L.call(this, p)) == "string"; )
+        p = S;
+      if (S === void 0) {
+        const { schemaId: _ } = this.opts, n = new i.SchemaEnv({ schema: {}, schemaId: _ });
+        if (S = i.resolveSchema.call(this, n, p), !S)
+          return;
+        this.refs[p] = S;
+      }
+      return S.validate || this._compileSchemaEnv(S);
+    }
+    // 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(p) {
+      if (p instanceof RegExp)
+        return this._removeAllSchemas(this.schemas, p), this._removeAllSchemas(this.refs, p), this;
+      switch (typeof p) {
+        case "undefined":
+          return this._removeAllSchemas(this.schemas), this._removeAllSchemas(this.refs), this._cache.clear(), this;
+        case "string": {
+          const S = L.call(this, p);
+          return typeof S == "object" && this._cache.delete(S.schema), delete this.schemas[p], delete this.refs[p], this;
+        }
+        case "object": {
+          const S = p;
+          this._cache.delete(S);
+          let _ = p[this.opts.schemaId];
+          return _ && (_ = (0, u.normalizeId)(_), delete this.schemas[_], delete this.refs[_]), this;
+        }
+        default:
+          throw new Error("ajv.removeSchema: invalid parameter");
+      }
+    }
+    // add "vocabulary" - a collection of keywords
+    addVocabulary(p) {
+      for (const S of p)
+        this.addKeyword(S);
+      return this;
+    }
+    addKeyword(p, S) {
+      let _;
+      if (typeof p == "string")
+        _ = p, typeof S == "object" && (this.logger.warn("these parameters are deprecated, see docs for addKeyword"), S.keyword = _);
+      else if (typeof p == "object" && S === void 0) {
+        if (S = p, _ = S.keyword, Array.isArray(_) && !_.length)
+          throw new Error("addKeywords: keyword must be string or non-empty array");
+      } else
+        throw new Error("invalid addKeywords parameters");
+      if (B.call(this, _, S), !S)
+        return (0, m.eachItem)(_, (c) => ee.call(this, c)), this;
+      qe.call(this, S);
+      const n = {
+        ...S,
+        type: (0, l.getJSONTypes)(S.type),
+        schemaType: (0, l.getJSONTypes)(S.schemaType)
+      };
+      return (0, m.eachItem)(_, n.type.length === 0 ? (c) => ee.call(this, c, n) : (c) => n.type.forEach((w) => ee.call(this, c, n, w))), this;
+    }
+    getKeyword(p) {
+      const S = this.RULES.all[p];
+      return typeof S == "object" ? S.definition : !!S;
+    }
+    // Remove keyword
+    removeKeyword(p) {
+      const { RULES: S } = this;
+      delete S.keywords[p], delete S.all[p];
+      for (const _ of S.rules) {
+        const n = _.rules.findIndex((c) => c.keyword === p);
+        n >= 0 && _.rules.splice(n, 1);
+      }
+      return this;
+    }
+    // Add format
+    addFormat(p, S) {
+      return typeof S == "string" && (S = new RegExp(S)), this.formats[p] = S, this;
+    }
+    errorsText(p = this.errors, { separator: S = ", ", dataVar: _ = "data" } = {}) {
+      return !p || p.length === 0 ? "No errors" : p.map((n) => `${_}${n.instancePath} ${n.message}`).reduce((n, c) => n + S + c);
+    }
+    $dataMetaSchema(p, S) {
+      const _ = this.RULES.all;
+      p = JSON.parse(JSON.stringify(p));
+      for (const n of S) {
+        const c = n.split("/").slice(1);
+        let w = p;
+        for (const j of c)
+          w = w[j];
+        for (const j in _) {
+          const O = _[j];
+          if (typeof O != "object")
+            continue;
+          const { $data: A } = O.definition, U = w[j];
+          A && U && (w[j] = he(U));
+        }
+      }
+      return p;
+    }
+    _removeAllSchemas(p, S) {
+      for (const _ in p) {
+        const n = p[_];
+        (!S || S.test(_)) && (typeof n == "string" ? delete p[_] : n && !n.meta && (this._cache.delete(n.schema), delete p[_]));
+      }
+    }
+    _addSchema(p, S, _, n = this.opts.validateSchema, c = this.opts.addUsedSchema) {
+      let w;
+      const { schemaId: j } = this.opts;
+      if (typeof p == "object")
+        w = p[j];
+      else {
+        if (this.opts.jtd)
+          throw new Error("schema must be object");
+        if (typeof p != "boolean")
+          throw new Error("schema must be object or boolean");
+      }
+      let O = this._cache.get(p);
+      if (O !== void 0)
+        return O;
+      _ = (0, u.normalizeId)(w || _);
+      const A = u.getSchemaRefs.call(this, p, _);
+      return O = new i.SchemaEnv({ schema: p, schemaId: j, meta: S, baseId: _, localRefs: A }), this._cache.set(O.schema, O), c && !_.startsWith("#") && (_ && this._checkUnique(_), this.refs[_] = O), n && this.validateSchema(p, !0), O;
+    }
+    _checkUnique(p) {
+      if (this.schemas[p] || this.refs[p])
+        throw new Error(`schema with key or id "${p}" already exists`);
+    }
+    _compileSchemaEnv(p) {
+      if (p.meta ? this._compileMetaSchema(p) : i.compileSchema.call(this, p), !p.validate)
+        throw new Error("ajv implementation error");
+      return p.validate;
+    }
+    _compileMetaSchema(p) {
+      const S = this.opts;
+      this.opts = this._metaOpts;
+      try {
+        i.compileSchema.call(this, p);
+      } finally {
+        this.opts = S;
+      }
+    }
+  }
+  R.ValidationError = s.default, R.MissingRefError = o.default, e.default = R;
+  function C(k, p, S, _ = "error") {
+    for (const n in k) {
+      const c = n;
+      c in p && this.logger[_](`${S}: option ${n}. ${k[c]}`);
+    }
+  }
+  function L(k) {
+    return k = (0, u.normalizeId)(k), this.schemas[k] || this.refs[k];
+  }
+  function H() {
+    const k = this.opts.schemas;
+    if (k)
+      if (Array.isArray(k))
+        this.addSchema(k);
+      else
+        for (const p in k)
+          this.addSchema(k[p], p);
+  }
+  function oe() {
+    for (const k in this.opts.formats) {
+      const p = this.opts.formats[k];
+      p && this.addFormat(k, p);
+    }
+  }
+  function ae(k) {
+    if (Array.isArray(k)) {
+      this.addVocabulary(k);
+      return;
+    }
+    this.logger.warn("keywords option as map is deprecated, pass array");
+    for (const p in k) {
+      const S = k[p];
+      S.keyword || (S.keyword = p), this.addKeyword(S);
+    }
+  }
+  function me() {
+    const k = { ...this.opts };
+    for (const p of g)
+      delete k[p];
+    return k;
+  }
+  const Ee = { log() {
+  }, warn() {
+  }, error() {
+  } };
+  function ie(k) {
+    if (k === !1)
+      return Ee;
+    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 z = /^[a-z_$][a-z0-9_$:-]*$/i;
+  function B(k, p) {
+    const { RULES: S } = this;
+    if ((0, m.eachItem)(k, (_) => {
+      if (S.keywords[_])
+        throw new Error(`Keyword ${_} is already defined`);
+      if (!z.test(_))
+        throw new Error(`Keyword ${_} has invalid name`);
+    }), !!p && p.$data && !("code" in p || "validate" in p))
+      throw new Error('$data keyword must have "code" or "validate" function');
+  }
+  function ee(k, p, S) {
+    var _;
+    const n = p == null ? void 0 : p.post;
+    if (S && n)
+      throw new Error('keyword with "post" flag cannot have "type"');
+    const { RULES: c } = this;
+    let w = n ? c.post : c.rules.find(({ type: O }) => O === S);
+    if (w || (w = { type: S, rules: [] }, c.rules.push(w)), c.keywords[k] = !0, !p)
+      return;
+    const j = {
+      keyword: k,
+      definition: {
+        ...p,
+        type: (0, l.getJSONTypes)(p.type),
+        schemaType: (0, l.getJSONTypes)(p.schemaType)
+      }
+    };
+    p.before ? Ke.call(this, w, j, p.before) : w.rules.push(j), c.all[k] = j, (_ = p.implements) === null || _ === void 0 || _.forEach((O) => this.addKeyword(O));
+  }
+  function Ke(k, p, S) {
+    const _ = k.rules.findIndex((n) => n.keyword === S);
+    _ >= 0 ? k.rules.splice(_, 0, p) : (k.rules.push(p), this.logger.warn(`rule ${S} is not defined`));
+  }
+  function qe(k) {
+    let { metaSchema: p } = k;
+    p !== void 0 && (k.$data && this.opts.$data && (p = he(p)), k.validateSchema = this.compile(p, !0));
+  }
+  const $e = {
+    $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
+  };
+  function he(k) {
+    return { anyOf: [k, $e] };
+  }
+})(Vs);
+var gr = {}, wr = {}, br = {};
+Object.defineProperty(br, "__esModule", { value: !0 });
+const $i = {
+  keyword: "id",
+  code() {
+    throw new Error('NOT SUPPORTED: keyword "id", use "$id" for schema ID');
+  }
+};
+br.default = $i;
+var Fe = {};
+Object.defineProperty(Fe, "__esModule", { value: !0 });
+Fe.callRef = Fe.getValidate = void 0;
+const gi = Ye, ls = K, te = q, Le = ve, ds = re, vt = N, wi = {
+  keyword: "$ref",
+  schemaType: "string",
+  code(e) {
+    const { gen: t, schema: r, it: s } = e, { baseId: o, schemaEnv: a, validateName: i, opts: d, self: u } = s, { root: l } = a;
+    if ((r === "#" || r === "#/") && o === l.baseId)
+      return y();
+    const m = ds.resolveRef.call(u, l, o, r);
+    if (m === void 0)
+      throw new gi.default(s.opts.uriResolver, o, r);
+    if (m instanceof ds.SchemaEnv)
+      return b(m);
+    return E(m);
+    function y() {
+      if (a === l)
+        return Et(e, i, a, a.$async);
+      const g = t.scopeValue("root", { ref: l });
+      return Et(e, (0, te._)`${g}.validate`, l, l.$async);
+    }
+    function b(g) {
+      const v = ho(e, g);
+      Et(e, v, g, g.$async);
+    }
+    function E(g) {
+      const v = t.scopeValue("schema", d.code.source === !0 ? { ref: g, code: (0, te.stringify)(g) } : { ref: g }), h = t.name("valid"), f = e.subschema({
+        schema: g,
+        dataTypes: [],
+        schemaPath: te.nil,
+        topSchemaRef: v,
+        errSchemaPath: r
+      }, h);
+      e.mergeEvaluated(f), e.ok(h);
+    }
+  }
+};
+function ho(e, t) {
+  const { gen: r } = e;
+  return t.validate ? r.scopeValue("validate", { ref: t.validate }) : (0, te._)`${r.scopeValue("wrapper", { ref: t })}.validate`;
+}
+Fe.getValidate = ho;
+function Et(e, t, r, s) {
+  const { gen: o, it: a } = e, { allErrors: i, schemaEnv: d, opts: u } = a, l = u.passContext ? Le.default.this : te.nil;
+  s ? m() : y();
+  function m() {
+    if (!d.$async)
+      throw new Error("async schema referenced by sync schema");
+    const g = o.let("valid");
+    o.try(() => {
+      o.code((0, te._)`await ${(0, ls.callValidateCode)(e, t, l)}`), E(t), i || o.assign(g, !0);
+    }, (v) => {
+      o.if((0, te._)`!(${v} instanceof ${a.ValidationError})`, () => o.throw(v)), b(v), i || o.assign(g, !1);
+    }), e.ok(g);
+  }
+  function y() {
+    e.result((0, ls.callValidateCode)(e, t, l), () => E(t), () => b(t));
+  }
+  function b(g) {
+    const v = (0, te._)`${g}.errors`;
+    o.assign(Le.default.vErrors, (0, te._)`${Le.default.vErrors} === null ? ${v} : ${Le.default.vErrors}.concat(${v})`), o.assign(Le.default.errors, (0, te._)`${Le.default.vErrors}.length`);
+  }
+  function E(g) {
+    var v;
+    if (!a.opts.unevaluated)
+      return;
+    const h = (v = r == null ? void 0 : r.validate) === null || v === void 0 ? void 0 : v.evaluated;
+    if (a.props !== !0)
+      if (h && !h.dynamicProps)
+        h.props !== void 0 && (a.props = vt.mergeEvaluated.props(o, h.props, a.props));
+      else {
+        const f = o.var("props", (0, te._)`${g}.evaluated.props`);
+        a.props = vt.mergeEvaluated.props(o, f, a.props, te.Name);
+      }
+    if (a.items !== !0)
+      if (h && !h.dynamicItems)
+        h.items !== void 0 && (a.items = vt.mergeEvaluated.items(o, h.items, a.items));
+      else {
+        const f = o.var("items", (0, te._)`${g}.evaluated.items`);
+        a.items = vt.mergeEvaluated.items(o, f, a.items, te.Name);
+      }
+  }
+}
+Fe.callRef = Et;
+Fe.default = wi;
+Object.defineProperty(wr, "__esModule", { value: !0 });
+const bi = br, Ei = Fe, Si = [
+  "$schema",
+  "$id",
+  "$defs",
+  "$vocabulary",
+  { keyword: "$comment" },
+  "definitions",
+  bi.default,
+  Ei.default
+];
+wr.default = Si;
+var Er = {}, Sr = {};
+Object.defineProperty(Sr, "__esModule", { value: !0 });
+const Nt = q, Pe = Nt.operators, Ct = {
+  maximum: { okStr: "<=", ok: Pe.LTE, fail: Pe.GT },
+  minimum: { okStr: ">=", ok: Pe.GTE, fail: Pe.LT },
+  exclusiveMaximum: { okStr: "<", ok: Pe.LT, fail: Pe.GTE },
+  exclusiveMinimum: { okStr: ">", ok: Pe.GT, fail: Pe.LTE }
+}, Pi = {
+  message: ({ keyword: e, schemaCode: t }) => (0, Nt.str)`must be ${Ct[e].okStr} ${t}`,
+  params: ({ keyword: e, schemaCode: t }) => (0, Nt._)`{comparison: ${Ct[e].okStr}, limit: ${t}}`
+}, ki = {
+  keyword: Object.keys(Ct),
+  type: "number",
+  schemaType: "number",
+  $data: !0,
+  error: Pi,
+  code(e) {
+    const { keyword: t, data: r, schemaCode: s } = e;
+    e.fail$data((0, Nt._)`${r} ${Ct[t].fail} ${s} || isNaN(${r})`);
+  }
+};
+Sr.default = ki;
+var Pr = {};
+Object.defineProperty(Pr, "__esModule", { value: !0 });
+const at = q, Ni = {
+  message: ({ schemaCode: e }) => (0, at.str)`must be multiple of ${e}`,
+  params: ({ schemaCode: e }) => (0, at._)`{multipleOf: ${e}}`
+}, Ci = {
+  keyword: "multipleOf",
+  type: "number",
+  schemaType: "number",
+  $data: !0,
+  error: Ni,
+  code(e) {
+    const { gen: t, data: r, schemaCode: s, it: o } = e, a = o.opts.multipleOfPrecision, i = t.let("res"), d = a ? (0, at._)`Math.abs(Math.round(${i}) - ${i}) > 1e-${a}` : (0, at._)`${i} !== parseInt(${i})`;
+    e.fail$data((0, at._)`(${s} === 0 || (${i} = ${r}/${s}, ${d}))`);
+  }
+};
+Pr.default = Ci;
+var kr = {}, Nr = {};
+Object.defineProperty(Nr, "__esModule", { value: !0 });
+function po(e) {
+  const t = e.length;
+  let r = 0, s = 0, o;
+  for (; s < t; )
+    r++, o = e.charCodeAt(s++), o >= 55296 && o <= 56319 && s < t && (o = e.charCodeAt(s), (o & 64512) === 56320 && s++);
+  return r;
+}
+Nr.default = po;
+po.code = 'require("ajv/dist/runtime/ucs2length").default';
+Object.defineProperty(kr, "__esModule", { value: !0 });
+const Ie = q, ji = N, Ri = Nr, Oi = {
+  message({ keyword: e, schemaCode: t }) {
+    const r = e === "maxLength" ? "more" : "fewer";
+    return (0, Ie.str)`must NOT have ${r} than ${t} characters`;
+  },
+  params: ({ schemaCode: e }) => (0, Ie._)`{limit: ${e}}`
+}, Ti = {
+  keyword: ["maxLength", "minLength"],
+  type: "string",
+  schemaType: "number",
+  $data: !0,
+  error: Oi,
+  code(e) {
+    const { keyword: t, data: r, schemaCode: s, it: o } = e, a = t === "maxLength" ? Ie.operators.GT : Ie.operators.LT, i = o.opts.unicode === !1 ? (0, Ie._)`${r}.length` : (0, Ie._)`${(0, ji.useFunc)(e.gen, Ri.default)}(${r})`;
+    e.fail$data((0, Ie._)`${i} ${a} ${s}`);
+  }
+};
+kr.default = Ti;
+var Cr = {};
+Object.defineProperty(Cr, "__esModule", { value: !0 });
+const Ii = K, Mi = N, Je = q, Vi = {
+  message: ({ schemaCode: e }) => (0, Je.str)`must match pattern "${e}"`,
+  params: ({ schemaCode: e }) => (0, Je._)`{pattern: ${e}}`
+}, Fi = {
+  keyword: "pattern",
+  type: "string",
+  schemaType: "string",
+  $data: !0,
+  error: Vi,
+  code(e) {
+    const { gen: t, data: r, $data: s, schema: o, schemaCode: a, it: i } = e, d = i.opts.unicodeRegExp ? "u" : "";
+    if (s) {
+      const { regExp: u } = i.opts.code, l = u.code === "new RegExp" ? (0, Je._)`new RegExp` : (0, Mi.useFunc)(t, u), m = t.let("valid");
+      t.try(() => t.assign(m, (0, Je._)`${l}(${a}, ${d}).test(${r})`), () => t.assign(m, !1)), e.fail$data((0, Je._)`!${m}`);
+    } else {
+      const u = (0, Ii.usePattern)(e, o);
+      e.fail$data((0, Je._)`!${u}.test(${r})`);
+    }
+  }
+};
+Cr.default = Fi;
+var jr = {};
+Object.defineProperty(jr, "__esModule", { value: !0 });
+const it = q, Ki = {
+  message({ keyword: e, schemaCode: t }) {
+    const r = e === "maxProperties" ? "more" : "fewer";
+    return (0, it.str)`must NOT have ${r} than ${t} properties`;
+  },
+  params: ({ schemaCode: e }) => (0, it._)`{limit: ${e}}`
+}, qi = {
+  keyword: ["maxProperties", "minProperties"],
+  type: "object",
+  schemaType: "number",
+  $data: !0,
+  error: Ki,
+  code(e) {
+    const { keyword: t, data: r, schemaCode: s } = e, o = t === "maxProperties" ? it.operators.GT : it.operators.LT;
+    e.fail$data((0, it._)`Object.keys(${r}).length ${o} ${s}`);
+  }
+};
+jr.default = qi;
+var Rr = {};
+Object.defineProperty(Rr, "__esModule", { value: !0 });
+const rt = K, ct = q, Ui = N, zi = {
+  message: ({ params: { missingProperty: e } }) => (0, ct.str)`must have required property '${e}'`,
+  params: ({ params: { missingProperty: e } }) => (0, ct._)`{missingProperty: ${e}}`
+}, Ai = {
+  keyword: "required",
+  type: "object",
+  schemaType: "array",
+  $data: !0,
+  error: zi,
+  code(e) {
+    const { gen: t, schema: r, schemaCode: s, data: o, $data: a, it: i } = e, { opts: d } = i;
+    if (!a && r.length === 0)
+      return;
+    const u = r.length >= d.loopRequired;
+    if (i.allErrors ? l() : m(), d.strictRequired) {
+      const E = e.parentSchema.properties, { definedProperties: g } = e.it;
+      for (const v of r)
+        if ((E == null ? void 0 : E[v]) === void 0 && !g.has(v)) {
+          const h = i.schemaEnv.baseId + i.errSchemaPath, f = `required property "${v}" is not defined at "${h}" (strictRequired)`;
+          (0, Ui.checkStrictMode)(i, f, i.opts.strictRequired);
+        }
+    }
+    function l() {
+      if (u || a)
+        e.block$data(ct.nil, y);
+      else
+        for (const E of r)
+          (0, rt.checkReportMissingProp)(e, E);
+    }
+    function m() {
+      const E = t.let("missing");
+      if (u || a) {
+        const g = t.let("valid", !0);
+        e.block$data(g, () => b(E, g)), e.ok(g);
+      } else
+        t.if((0, rt.checkMissingProp)(e, r, E)), (0, rt.reportMissingProp)(e, E), t.else();
+    }
+    function y() {
+      t.forOf("prop", s, (E) => {
+        e.setParams({ missingProperty: E }), t.if((0, rt.noPropertyInData)(t, o, E, d.ownProperties), () => e.error());
+      });
+    }
+    function b(E, g) {
+      e.setParams({ missingProperty: E }), t.forOf(E, s, () => {
+        t.assign(g, (0, rt.propertyInData)(t, o, E, d.ownProperties)), t.if((0, ct.not)(g), () => {
+          e.error(), t.break();
+        });
+      }, ct.nil);
+    }
+  }
+};
+Rr.default = Ai;
+var Or = {};
+Object.defineProperty(Or, "__esModule", { value: !0 });
+const lt = q, Li = {
+  message({ keyword: e, schemaCode: t }) {
+    const r = e === "maxItems" ? "more" : "fewer";
+    return (0, lt.str)`must NOT have ${r} than ${t} items`;
+  },
+  params: ({ schemaCode: e }) => (0, lt._)`{limit: ${e}}`
+}, Gi = {
+  keyword: ["maxItems", "minItems"],
+  type: "array",
+  schemaType: "number",
+  $data: !0,
+  error: Li,
+  code(e) {
+    const { keyword: t, data: r, schemaCode: s } = e, o = t === "maxItems" ? lt.operators.GT : lt.operators.LT;
+    e.fail$data((0, lt._)`${r}.length ${o} ${s}`);
+  }
+};
+Or.default = Gi;
+var Tr = {}, pt = {};
+Object.defineProperty(pt, "__esModule", { value: !0 });
+const yo = Ps;
+yo.code = 'require("ajv/dist/runtime/equal").default';
+pt.default = yo;
+Object.defineProperty(Tr, "__esModule", { value: !0 });
+const Yt = X, Y = q, Ji = N, Hi = pt, Bi = {
+  message: ({ params: { i: e, j: t } }) => (0, Y.str)`must NOT have duplicate items (items ## ${t} and ${e} are identical)`,
+  params: ({ params: { i: e, j: t } }) => (0, Y._)`{i: ${e}, j: ${t}}`
+}, Qi = {
+  keyword: "uniqueItems",
+  type: "array",
+  schemaType: "boolean",
+  $data: !0,
+  error: Bi,
+  code(e) {
+    const { gen: t, data: r, $data: s, schema: o, parentSchema: a, schemaCode: i, it: d } = e;
+    if (!s && !o)
+      return;
+    const u = t.let("valid"), l = a.items ? (0, Yt.getSchemaTypes)(a.items) : [];
+    e.block$data(u, m, (0, Y._)`${i} === false`), e.ok(u);
+    function m() {
+      const g = t.let("i", (0, Y._)`${r}.length`), v = t.let("j");
+      e.setParams({ i: g, j: v }), t.assign(u, !0), t.if((0, Y._)`${g} > 1`, () => (y() ? b : E)(g, v));
+    }
+    function y() {
+      return l.length > 0 && !l.some((g) => g === "object" || g === "array");
+    }
+    function b(g, v) {
+      const h = t.name("item"), f = (0, Yt.checkDataTypes)(l, h, d.opts.strictNumbers, Yt.DataType.Wrong), $ = t.const("indices", (0, Y._)`{}`);
+      t.for((0, Y._)`;${g}--;`, () => {
+        t.let(h, (0, Y._)`${r}[${g}]`), t.if(f, (0, Y._)`continue`), l.length > 1 && t.if((0, Y._)`typeof ${h} == "string"`, (0, Y._)`${h} += "_"`), t.if((0, Y._)`typeof ${$}[${h}] == "number"`, () => {
+          t.assign(v, (0, Y._)`${$}[${h}]`), e.error(), t.assign(u, !1).break();
+        }).code((0, Y._)`${$}[${h}] = ${g}`);
+      });
+    }
+    function E(g, v) {
+      const h = (0, Ji.useFunc)(t, Hi.default), f = t.name("outer");
+      t.label(f).for((0, Y._)`;${g}--;`, () => t.for((0, Y._)`${v} = ${g}; ${v}--;`, () => t.if((0, Y._)`${h}(${r}[${g}], ${r}[${v}])`, () => {
+        e.error(), t.assign(u, !1).break(f);
+      })));
+    }
+  }
+};
+Tr.default = Qi;
+var Ir = {};
+Object.defineProperty(Ir, "__esModule", { value: !0 });
+const ar = q, Xi = N, Yi = pt, Zi = {
+  message: "must be equal to constant",
+  params: ({ schemaCode: e }) => (0, ar._)`{allowedValue: ${e}}`
+}, Di = {
+  keyword: "const",
+  $data: !0,
+  error: Zi,
+  code(e) {
+    const { gen: t, data: r, $data: s, schemaCode: o, schema: a } = e;
+    s || a && typeof a == "object" ? e.fail$data((0, ar._)`!${(0, Xi.useFunc)(t, Yi.default)}(${r}, ${o})`) : e.fail((0, ar._)`${a} !== ${r}`);
+  }
+};
+Ir.default = Di;
+var Mr = {};
+Object.defineProperty(Mr, "__esModule", { value: !0 });
+const st = q, Wi = N, xi = pt, ec = {
+  message: "must be equal to one of the allowed values",
+  params: ({ schemaCode: e }) => (0, st._)`{allowedValues: ${e}}`
+}, tc = {
+  keyword: "enum",
+  schemaType: "array",
+  $data: !0,
+  error: ec,
+  code(e) {
+    const { gen: t, data: r, $data: s, schema: o, schemaCode: a, it: i } = e;
+    if (!s && o.length === 0)
+      throw new Error("enum must have non-empty array");
+    const d = o.length >= i.opts.loopEnum;
+    let u;
+    const l = () => u ?? (u = (0, Wi.useFunc)(t, xi.default));
+    let m;
+    if (d || s)
+      m = t.let("valid"), e.block$data(m, y);
+    else {
+      if (!Array.isArray(o))
+        throw new Error("ajv implementation error");
+      const E = t.const("vSchema", a);
+      m = (0, st.or)(...o.map((g, v) => b(E, v)));
+    }
+    e.pass(m);
+    function y() {
+      t.assign(m, !1), t.forOf("v", a, (E) => t.if((0, st._)`${l()}(${r}, ${E})`, () => t.assign(m, !0).break()));
+    }
+    function b(E, g) {
+      const v = o[g];
+      return typeof v == "object" && v !== null ? (0, st._)`${l()}(${r}, ${E}[${g}])` : (0, st._)`${r} === ${v}`;
+    }
+  }
+};
+Mr.default = tc;
+Object.defineProperty(Er, "__esModule", { value: !0 });
+const rc = Sr, sc = Pr, oc = kr, nc = Cr, ac = jr, ic = Rr, cc = Or, lc = Tr, dc = Ir, uc = Mr, fc = [
+  // number
+  rc.default,
+  sc.default,
+  // string
+  oc.default,
+  nc.default,
+  // object
+  ac.default,
+  ic.default,
+  // array
+  cc.default,
+  lc.default,
+  // any
+  { keyword: "type", schemaType: ["string", "array"] },
+  { keyword: "nullable", schemaType: "boolean" },
+  dc.default,
+  uc.default
+];
+Er.default = fc;
+var Vr = {}, Ze = {};
+Object.defineProperty(Ze, "__esModule", { value: !0 });
+Ze.validateAdditionalItems = void 0;
+const Me = q, ir = N, mc = {
+  message: ({ params: { len: e } }) => (0, Me.str)`must NOT have more than ${e} items`,
+  params: ({ params: { len: e } }) => (0, Me._)`{limit: ${e}}`
+}, hc = {
+  keyword: "additionalItems",
+  type: "array",
+  schemaType: ["boolean", "object"],
+  before: "uniqueItems",
+  error: mc,
+  code(e) {
+    const { parentSchema: t, it: r } = e, { items: s } = t;
+    if (!Array.isArray(s)) {
+      (0, ir.checkStrictMode)(r, '"additionalItems" is ignored when "items" is not an array of schemas');
+      return;
+    }
+    _o(e, s);
+  }
+};
+function _o(e, t) {
+  const { gen: r, schema: s, data: o, keyword: a, it: i } = e;
+  i.items = !0;
+  const d = r.const("len", (0, Me._)`${o}.length`);
+  if (s === !1)
+    e.setParams({ len: t.length }), e.pass((0, Me._)`${d} <= ${t.length}`);
+  else if (typeof s == "object" && !(0, ir.alwaysValidSchema)(i, s)) {
+    const l = r.var("valid", (0, Me._)`${d} <= ${t.length}`);
+    r.if((0, Me.not)(l), () => u(l)), e.ok(l);
+  }
+  function u(l) {
+    r.forRange("i", t.length, d, (m) => {
+      e.subschema({ keyword: a, dataProp: m, dataPropType: ir.Type.Num }, l), i.allErrors || r.if((0, Me.not)(l), () => r.break());
+    });
+  }
+}
+Ze.validateAdditionalItems = _o;
+Ze.default = hc;
+var Fr = {}, De = {};
+Object.defineProperty(De, "__esModule", { value: !0 });
+De.validateTuple = void 0;
+const us = q, St = N, pc = K, yc = {
+  keyword: "items",
+  type: "array",
+  schemaType: ["object", "array", "boolean"],
+  before: "uniqueItems",
+  code(e) {
+    const { schema: t, it: r } = e;
+    if (Array.isArray(t))
+      return vo(e, "additionalItems", t);
+    r.items = !0, !(0, St.alwaysValidSchema)(r, t) && e.ok((0, pc.validateArray)(e));
+  }
+};
+function vo(e, t, r = e.schema) {
+  const { gen: s, parentSchema: o, data: a, keyword: i, it: d } = e;
+  m(o), d.opts.unevaluated && r.length && d.items !== !0 && (d.items = St.mergeEvaluated.items(s, r.length, d.items));
+  const u = s.name("valid"), l = s.const("len", (0, us._)`${a}.length`);
+  r.forEach((y, b) => {
+    (0, St.alwaysValidSchema)(d, y) || (s.if((0, us._)`${l} > ${b}`, () => e.subschema({
+      keyword: i,
+      schemaProp: b,
+      dataProp: b
+    }, u)), e.ok(u));
+  });
+  function m(y) {
+    const { opts: b, errSchemaPath: E } = d, g = r.length, v = g === y.minItems && (g === y.maxItems || y[t] === !1);
+    if (b.strictTuples && !v) {
+      const h = `"${i}" is ${g}-tuple, but minItems or maxItems/${t} are not specified or different at path "${E}"`;
+      (0, St.checkStrictMode)(d, h, b.strictTuples);
+    }
+  }
+}
+De.validateTuple = vo;
+De.default = yc;
+Object.defineProperty(Fr, "__esModule", { value: !0 });
+const _c = De, vc = {
+  keyword: "prefixItems",
+  type: "array",
+  schemaType: ["array"],
+  before: "uniqueItems",
+  code: (e) => (0, _c.validateTuple)(e, "items")
+};
+Fr.default = vc;
+var Kr = {};
+Object.defineProperty(Kr, "__esModule", { value: !0 });
+const fs = q, $c = N, gc = K, wc = Ze, bc = {
+  message: ({ params: { len: e } }) => (0, fs.str)`must NOT have more than ${e} items`,
+  params: ({ params: { len: e } }) => (0, fs._)`{limit: ${e}}`
+}, Ec = {
+  keyword: "items",
+  type: "array",
+  schemaType: ["object", "boolean"],
+  before: "uniqueItems",
+  error: bc,
+  code(e) {
+    const { schema: t, parentSchema: r, it: s } = e, { prefixItems: o } = r;
+    s.items = !0, !(0, $c.alwaysValidSchema)(s, t) && (o ? (0, wc.validateAdditionalItems)(e, o) : e.ok((0, gc.validateArray)(e)));
+  }
+};
+Kr.default = Ec;
+var qr = {};
+Object.defineProperty(qr, "__esModule", { value: !0 });
+const ne = q, $t = N, Sc = {
+  message: ({ params: { min: e, max: t } }) => t === void 0 ? (0, ne.str)`must contain at least ${e} valid item(s)` : (0, ne.str)`must contain at least ${e} and no more than ${t} valid item(s)`,
+  params: ({ params: { min: e, max: t } }) => t === void 0 ? (0, ne._)`{minContains: ${e}}` : (0, ne._)`{minContains: ${e}, maxContains: ${t}}`
+}, Pc = {
+  keyword: "contains",
+  type: "array",
+  schemaType: ["object", "boolean"],
+  before: "uniqueItems",
+  trackErrors: !0,
+  error: Sc,
+  code(e) {
+    const { gen: t, schema: r, parentSchema: s, data: o, it: a } = e;
+    let i, d;
+    const { minContains: u, maxContains: l } = s;
+    a.opts.next ? (i = u === void 0 ? 1 : u, d = l) : i = 1;
+    const m = t.const("len", (0, ne._)`${o}.length`);
+    if (e.setParams({ min: i, max: d }), d === void 0 && i === 0) {
+      (0, $t.checkStrictMode)(a, '"minContains" == 0 without "maxContains": "contains" keyword ignored');
+      return;
+    }
+    if (d !== void 0 && i > d) {
+      (0, $t.checkStrictMode)(a, '"minContains" > "maxContains" is always invalid'), e.fail();
+      return;
+    }
+    if ((0, $t.alwaysValidSchema)(a, r)) {
+      let v = (0, ne._)`${m} >= ${i}`;
+      d !== void 0 && (v = (0, ne._)`${v} && ${m} <= ${d}`), e.pass(v);
+      return;
+    }
+    a.items = !0;
+    const y = t.name("valid");
+    d === void 0 && i === 1 ? E(y, () => t.if(y, () => t.break())) : i === 0 ? (t.let(y, !0), d !== void 0 && t.if((0, ne._)`${o}.length > 0`, b)) : (t.let(y, !1), b()), e.result(y, () => e.reset());
+    function b() {
+      const v = t.name("_valid"), h = t.let("count", 0);
+      E(v, () => t.if(v, () => g(h)));
+    }
+    function E(v, h) {
+      t.forRange("i", 0, m, (f) => {
+        e.subschema({
+          keyword: "contains",
+          dataProp: f,
+          dataPropType: $t.Type.Num,
+          compositeRule: !0
+        }, v), h();
+      });
+    }
+    function g(v) {
+      t.code((0, ne._)`${v}++`), d === void 0 ? t.if((0, ne._)`${v} >= ${i}`, () => t.assign(y, !0).break()) : (t.if((0, ne._)`${v} > ${d}`, () => t.assign(y, !1).break()), i === 1 ? t.assign(y, !0) : t.if((0, ne._)`${v} >= ${i}`, () => t.assign(y, !0)));
+    }
+  }
+};
+qr.default = Pc;
+var $o = {};
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.validateSchemaDeps = e.validatePropertyDeps = e.error = void 0;
+  const t = q, r = N, s = K;
+  e.error = {
+    message: ({ params: { property: u, depsCount: l, deps: m } }) => {
+      const y = l === 1 ? "property" : "properties";
+      return (0, t.str)`must have ${y} ${m} when property ${u} is present`;
+    },
+    params: ({ params: { property: u, depsCount: l, deps: m, missingProperty: y } }) => (0, t._)`{property: ${u},
+    missingProperty: ${y},
+    depsCount: ${l},
+    deps: ${m}}`
+    // TODO change to reference
+  };
+  const o = {
+    keyword: "dependencies",
+    type: "object",
+    schemaType: "object",
+    error: e.error,
+    code(u) {
+      const [l, m] = a(u);
+      i(u, l), d(u, m);
+    }
+  };
+  function a({ schema: u }) {
+    const l = {}, m = {};
+    for (const y in u) {
+      if (y === "__proto__")
+        continue;
+      const b = Array.isArray(u[y]) ? l : m;
+      b[y] = u[y];
+    }
+    return [l, m];
+  }
+  function i(u, l = u.schema) {
+    const { gen: m, data: y, it: b } = u;
+    if (Object.keys(l).length === 0)
+      return;
+    const E = m.let("missing");
+    for (const g in l) {
+      const v = l[g];
+      if (v.length === 0)
+        continue;
+      const h = (0, s.propertyInData)(m, y, g, b.opts.ownProperties);
+      u.setParams({
+        property: g,
+        depsCount: v.length,
+        deps: v.join(", ")
+      }), b.allErrors ? m.if(h, () => {
+        for (const f of v)
+          (0, s.checkReportMissingProp)(u, f);
+      }) : (m.if((0, t._)`${h} && (${(0, s.checkMissingProp)(u, v, E)})`), (0, s.reportMissingProp)(u, E), m.else());
+    }
+  }
+  e.validatePropertyDeps = i;
+  function d(u, l = u.schema) {
+    const { gen: m, data: y, keyword: b, it: E } = u, g = m.name("valid");
+    for (const v in l)
+      (0, r.alwaysValidSchema)(E, l[v]) || (m.if(
+        (0, s.propertyInData)(m, y, v, E.opts.ownProperties),
+        () => {
+          const h = u.subschema({ keyword: b, schemaProp: v }, g);
+          u.mergeValidEvaluated(h, g);
+        },
+        () => m.var(g, !0)
+        // TODO var
+      ), u.ok(g));
+  }
+  e.validateSchemaDeps = d, e.default = o;
+})($o);
+var Ur = {};
+Object.defineProperty(Ur, "__esModule", { value: !0 });
+const go = q, kc = N, Nc = {
+  message: "property name must be valid",
+  params: ({ params: e }) => (0, go._)`{propertyName: ${e.propertyName}}`
+}, Cc = {
+  keyword: "propertyNames",
+  type: "object",
+  schemaType: ["object", "boolean"],
+  error: Nc,
+  code(e) {
+    const { gen: t, schema: r, data: s, it: o } = e;
+    if ((0, kc.alwaysValidSchema)(o, r))
+      return;
+    const a = t.name("valid");
+    t.forIn("key", s, (i) => {
+      e.setParams({ propertyName: i }), e.subschema({
+        keyword: "propertyNames",
+        data: i,
+        dataTypes: ["string"],
+        propertyName: i,
+        compositeRule: !0
+      }, a), t.if((0, go.not)(a), () => {
+        e.error(!0), o.allErrors || t.break();
+      });
+    }), e.ok(a);
+  }
+};
+Ur.default = Cc;
+var It = {};
+Object.defineProperty(It, "__esModule", { value: !0 });
+const gt = K, le = q, jc = ve, wt = N, Rc = {
+  message: "must NOT have additional properties",
+  params: ({ params: e }) => (0, le._)`{additionalProperty: ${e.additionalProperty}}`
+}, Oc = {
+  keyword: "additionalProperties",
+  type: ["object"],
+  schemaType: ["boolean", "object"],
+  allowUndefined: !0,
+  trackErrors: !0,
+  error: Rc,
+  code(e) {
+    const { gen: t, schema: r, parentSchema: s, data: o, errsCount: a, it: i } = e;
+    if (!a)
+      throw new Error("ajv implementation error");
+    const { allErrors: d, opts: u } = i;
+    if (i.props = !0, u.removeAdditional !== "all" && (0, wt.alwaysValidSchema)(i, r))
+      return;
+    const l = (0, gt.allSchemaProperties)(s.properties), m = (0, gt.allSchemaProperties)(s.patternProperties);
+    y(), e.ok((0, le._)`${a} === ${jc.default.errors}`);
+    function y() {
+      t.forIn("key", o, (h) => {
+        !l.length && !m.length ? g(h) : t.if(b(h), () => g(h));
+      });
+    }
+    function b(h) {
+      let f;
+      if (l.length > 8) {
+        const $ = (0, wt.schemaRefOrVal)(i, s.properties, "properties");
+        f = (0, gt.isOwnProperty)(t, $, h);
+      } else l.length ? f = (0, le.or)(...l.map(($) => (0, le._)`${h} === ${$}`)) : f = le.nil;
+      return m.length && (f = (0, le.or)(f, ...m.map(($) => (0, le._)`${(0, gt.usePattern)(e, $)}.test(${h})`))), (0, le.not)(f);
+    }
+    function E(h) {
+      t.code((0, le._)`delete ${o}[${h}]`);
+    }
+    function g(h) {
+      if (u.removeAdditional === "all" || u.removeAdditional && r === !1) {
+        E(h);
+        return;
+      }
+      if (r === !1) {
+        e.setParams({ additionalProperty: h }), e.error(), d || t.break();
+        return;
+      }
+      if (typeof r == "object" && !(0, wt.alwaysValidSchema)(i, r)) {
+        const f = t.name("valid");
+        u.removeAdditional === "failing" ? (v(h, f, !1), t.if((0, le.not)(f), () => {
+          e.reset(), E(h);
+        })) : (v(h, f), d || t.if((0, le.not)(f), () => t.break()));
+      }
+    }
+    function v(h, f, $) {
+      const P = {
+        keyword: "additionalProperties",
+        dataProp: h,
+        dataPropType: wt.Type.Str
+      };
+      $ === !1 && Object.assign(P, {
+        compositeRule: !0,
+        createErrors: !1,
+        allErrors: !1
+      }), e.subschema(P, f);
+    }
+  }
+};
+It.default = Oc;
+var zr = {};
+Object.defineProperty(zr, "__esModule", { value: !0 });
+const Tc = fe, ms = K, Zt = N, hs = It, Ic = {
+  keyword: "properties",
+  type: "object",
+  schemaType: "object",
+  code(e) {
+    const { gen: t, schema: r, parentSchema: s, data: o, it: a } = e;
+    a.opts.removeAdditional === "all" && s.additionalProperties === void 0 && hs.default.code(new Tc.KeywordCxt(a, hs.default, "additionalProperties"));
+    const i = (0, ms.allSchemaProperties)(r);
+    for (const y of i)
+      a.definedProperties.add(y);
+    a.opts.unevaluated && i.length && a.props !== !0 && (a.props = Zt.mergeEvaluated.props(t, (0, Zt.toHash)(i), a.props));
+    const d = i.filter((y) => !(0, Zt.alwaysValidSchema)(a, r[y]));
+    if (d.length === 0)
+      return;
+    const u = t.name("valid");
+    for (const y of d)
+      l(y) ? m(y) : (t.if((0, ms.propertyInData)(t, o, y, a.opts.ownProperties)), m(y), a.allErrors || t.else().var(u, !0), t.endIf()), e.it.definedProperties.add(y), e.ok(u);
+    function l(y) {
+      return a.opts.useDefaults && !a.compositeRule && r[y].default !== void 0;
+    }
+    function m(y) {
+      e.subschema({
+        keyword: "properties",
+        schemaProp: y,
+        dataProp: y
+      }, u);
+    }
+  }
+};
+zr.default = Ic;
+var Ar = {};
+Object.defineProperty(Ar, "__esModule", { value: !0 });
+const ps = K, bt = q, ys = N, _s = N, Mc = {
+  keyword: "patternProperties",
+  type: "object",
+  schemaType: "object",
+  code(e) {
+    const { gen: t, schema: r, data: s, parentSchema: o, it: a } = e, { opts: i } = a, d = (0, ps.allSchemaProperties)(r), u = d.filter((v) => (0, ys.alwaysValidSchema)(a, r[v]));
+    if (d.length === 0 || u.length === d.length && (!a.opts.unevaluated || a.props === !0))
+      return;
+    const l = i.strictSchema && !i.allowMatchingProperties && o.properties, m = t.name("valid");
+    a.props !== !0 && !(a.props instanceof bt.Name) && (a.props = (0, _s.evaluatedPropsToName)(t, a.props));
+    const { props: y } = a;
+    b();
+    function b() {
+      for (const v of d)
+        l && E(v), a.allErrors ? g(v) : (t.var(m, !0), g(v), t.if(m));
+    }
+    function E(v) {
+      for (const h in l)
+        new RegExp(v).test(h) && (0, ys.checkStrictMode)(a, `property ${h} matches pattern ${v} (use allowMatchingProperties)`);
+    }
+    function g(v) {
+      t.forIn("key", s, (h) => {
+        t.if((0, bt._)`${(0, ps.usePattern)(e, v)}.test(${h})`, () => {
+          const f = u.includes(v);
+          f || e.subschema({
+            keyword: "patternProperties",
+            schemaProp: v,
+            dataProp: h,
+            dataPropType: _s.Type.Str
+          }, m), a.opts.unevaluated && y !== !0 ? t.assign((0, bt._)`${y}[${h}]`, !0) : !f && !a.allErrors && t.if((0, bt.not)(m), () => t.break());
+        });
+      });
+    }
+  }
+};
+Ar.default = Mc;
+var Lr = {};
+Object.defineProperty(Lr, "__esModule", { value: !0 });
+const Vc = N, Fc = {
+  keyword: "not",
+  schemaType: ["object", "boolean"],
+  trackErrors: !0,
+  code(e) {
+    const { gen: t, schema: r, it: s } = e;
+    if ((0, Vc.alwaysValidSchema)(s, r)) {
+      e.fail();
+      return;
+    }
+    const o = t.name("valid");
+    e.subschema({
+      keyword: "not",
+      compositeRule: !0,
+      createErrors: !1,
+      allErrors: !1
+    }, o), e.failResult(o, () => e.reset(), () => e.error());
+  },
+  error: { message: "must NOT be valid" }
+};
+Lr.default = Fc;
+var Gr = {};
+Object.defineProperty(Gr, "__esModule", { value: !0 });
+const Kc = K, qc = {
+  keyword: "anyOf",
+  schemaType: "array",
+  trackErrors: !0,
+  code: Kc.validateUnion,
+  error: { message: "must match a schema in anyOf" }
+};
+Gr.default = qc;
+var Jr = {};
+Object.defineProperty(Jr, "__esModule", { value: !0 });
+const Pt = q, Uc = N, zc = {
+  message: "must match exactly one schema in oneOf",
+  params: ({ params: e }) => (0, Pt._)`{passingSchemas: ${e.passing}}`
+}, Ac = {
+  keyword: "oneOf",
+  schemaType: "array",
+  trackErrors: !0,
+  error: zc,
+  code(e) {
+    const { gen: t, schema: r, parentSchema: s, it: o } = e;
+    if (!Array.isArray(r))
+      throw new Error("ajv implementation error");
+    if (o.opts.discriminator && s.discriminator)
+      return;
+    const a = r, i = t.let("valid", !1), d = t.let("passing", null), u = t.name("_valid");
+    e.setParams({ passing: d }), t.block(l), e.result(i, () => e.reset(), () => e.error(!0));
+    function l() {
+      a.forEach((m, y) => {
+        let b;
+        (0, Uc.alwaysValidSchema)(o, m) ? t.var(u, !0) : b = e.subschema({
+          keyword: "oneOf",
+          schemaProp: y,
+          compositeRule: !0
+        }, u), y > 0 && t.if((0, Pt._)`${u} && ${i}`).assign(i, !1).assign(d, (0, Pt._)`[${d}, ${y}]`).else(), t.if(u, () => {
+          t.assign(i, !0), t.assign(d, y), b && e.mergeEvaluated(b, Pt.Name);
+        });
+      });
+    }
+  }
+};
+Jr.default = Ac;
+var Hr = {};
+Object.defineProperty(Hr, "__esModule", { value: !0 });
+const Lc = N, Gc = {
+  keyword: "allOf",
+  schemaType: "array",
+  code(e) {
+    const { gen: t, schema: r, it: s } = e;
+    if (!Array.isArray(r))
+      throw new Error("ajv implementation error");
+    const o = t.name("valid");
+    r.forEach((a, i) => {
+      if ((0, Lc.alwaysValidSchema)(s, a))
+        return;
+      const d = e.subschema({ keyword: "allOf", schemaProp: i }, o);
+      e.ok(o), e.mergeEvaluated(d);
+    });
+  }
+};
+Hr.default = Gc;
+var Br = {};
+Object.defineProperty(Br, "__esModule", { value: !0 });
+const jt = q, wo = N, Jc = {
+  message: ({ params: e }) => (0, jt.str)`must match "${e.ifClause}" schema`,
+  params: ({ params: e }) => (0, jt._)`{failingKeyword: ${e.ifClause}}`
+}, Hc = {
+  keyword: "if",
+  schemaType: ["object", "boolean"],
+  trackErrors: !0,
+  error: Jc,
+  code(e) {
+    const { gen: t, parentSchema: r, it: s } = e;
+    r.then === void 0 && r.else === void 0 && (0, wo.checkStrictMode)(s, '"if" without "then" and "else" is ignored');
+    const o = vs(s, "then"), a = vs(s, "else");
+    if (!o && !a)
+      return;
+    const i = t.let("valid", !0), d = t.name("_valid");
+    if (u(), e.reset(), o && a) {
+      const m = t.let("ifClause");
+      e.setParams({ ifClause: m }), t.if(d, l("then", m), l("else", m));
+    } else o ? t.if(d, l("then")) : t.if((0, jt.not)(d), l("else"));
+    e.pass(i, () => e.error(!0));
+    function u() {
+      const m = e.subschema({
+        keyword: "if",
+        compositeRule: !0,
+        createErrors: !1,
+        allErrors: !1
+      }, d);
+      e.mergeEvaluated(m);
+    }
+    function l(m, y) {
+      return () => {
+        const b = e.subschema({ keyword: m }, d);
+        t.assign(i, d), e.mergeValidEvaluated(b, i), y ? t.assign(y, (0, jt._)`${m}`) : e.setParams({ ifClause: m });
+      };
+    }
+  }
+};
+function vs(e, t) {
+  const r = e.schema[t];
+  return r !== void 0 && !(0, wo.alwaysValidSchema)(e, r);
+}
+Br.default = Hc;
+var Qr = {};
+Object.defineProperty(Qr, "__esModule", { value: !0 });
+const Bc = N, Qc = {
+  keyword: ["then", "else"],
+  schemaType: ["object", "boolean"],
+  code({ keyword: e, parentSchema: t, it: r }) {
+    t.if === void 0 && (0, Bc.checkStrictMode)(r, `"${e}" without "if" is ignored`);
+  }
+};
+Qr.default = Qc;
+Object.defineProperty(Vr, "__esModule", { value: !0 });
+const Xc = Ze, Yc = Fr, Zc = De, Dc = Kr, Wc = qr, xc = $o, el = Ur, tl = It, rl = zr, sl = Ar, ol = Lr, nl = Gr, al = Jr, il = Hr, cl = Br, ll = Qr;
+function dl(e = !1) {
+  const t = [
+    // any
+    ol.default,
+    nl.default,
+    al.default,
+    il.default,
+    cl.default,
+    ll.default,
+    // object
+    el.default,
+    tl.default,
+    xc.default,
+    rl.default,
+    sl.default
+  ];
+  return e ? t.push(Yc.default, Dc.default) : t.push(Xc.default, Zc.default), t.push(Wc.default), t;
+}
+Vr.default = dl;
+var Xr = {}, Yr = {};
+Object.defineProperty(Yr, "__esModule", { value: !0 });
+const Q = q, ul = {
+  message: ({ schemaCode: e }) => (0, Q.str)`must match format "${e}"`,
+  params: ({ schemaCode: e }) => (0, Q._)`{format: ${e}}`
+}, fl = {
+  keyword: "format",
+  type: ["number", "string"],
+  schemaType: "string",
+  $data: !0,
+  error: ul,
+  code(e, t) {
+    const { gen: r, data: s, $data: o, schema: a, schemaCode: i, it: d } = e, { opts: u, errSchemaPath: l, schemaEnv: m, self: y } = d;
+    if (!u.validateFormats)
+      return;
+    o ? b() : E();
+    function b() {
+      const g = r.scopeValue("formats", {
+        ref: y.formats,
+        code: u.code.formats
+      }), v = r.const("fDef", (0, Q._)`${g}[${i}]`), h = r.let("fType"), f = r.let("format");
+      r.if((0, Q._)`typeof ${v} == "object" && !(${v} instanceof RegExp)`, () => r.assign(h, (0, Q._)`${v}.type || "string"`).assign(f, (0, Q._)`${v}.validate`), () => r.assign(h, (0, Q._)`"string"`).assign(f, v)), e.fail$data((0, Q.or)($(), P()));
+      function $() {
+        return u.strictSchema === !1 ? Q.nil : (0, Q._)`${i} && !${f}`;
+      }
+      function P() {
+        const R = m.$async ? (0, Q._)`(${v}.async ? await ${f}(${s}) : ${f}(${s}))` : (0, Q._)`${f}(${s})`, C = (0, Q._)`(typeof ${f} == "function" ? ${R} : ${f}.test(${s}))`;
+        return (0, Q._)`${f} && ${f} !== true && ${h} === ${t} && !${C}`;
+      }
+    }
+    function E() {
+      const g = y.formats[a];
+      if (!g) {
+        $();
+        return;
+      }
+      if (g === !0)
+        return;
+      const [v, h, f] = P(g);
+      v === t && e.pass(R());
+      function $() {
+        if (u.strictSchema === !1) {
+          y.logger.warn(C());
+          return;
+        }
+        throw new Error(C());
+        function C() {
+          return `unknown format "${a}" ignored in schema at path "${l}"`;
+        }
+      }
+      function P(C) {
+        const L = C instanceof RegExp ? (0, Q.regexpCode)(C) : u.code.formats ? (0, Q._)`${u.code.formats}${(0, Q.getProperty)(a)}` : void 0, H = r.scopeValue("formats", { key: a, ref: C, code: L });
+        return typeof C == "object" && !(C instanceof RegExp) ? [C.type || "string", C.validate, (0, Q._)`${H}.validate`] : ["string", C, H];
+      }
+      function R() {
+        if (typeof g == "object" && !(g instanceof RegExp) && g.async) {
+          if (!m.$async)
+            throw new Error("async format in sync schema");
+          return (0, Q._)`await ${f}(${s})`;
+        }
+        return typeof h == "function" ? (0, Q._)`${f}(${s})` : (0, Q._)`${f}.test(${s})`;
+      }
+    }
+  }
+};
+Yr.default = fl;
+Object.defineProperty(Xr, "__esModule", { value: !0 });
+const ml = Yr, hl = [ml.default];
+Xr.default = hl;
+var Xe = {};
+Object.defineProperty(Xe, "__esModule", { value: !0 });
+Xe.contentVocabulary = Xe.metadataVocabulary = void 0;
+Xe.metadataVocabulary = [
+  "title",
+  "description",
+  "default",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+  "examples"
+];
+Xe.contentVocabulary = [
+  "contentMediaType",
+  "contentEncoding",
+  "contentSchema"
+];
+Object.defineProperty(gr, "__esModule", { value: !0 });
+const pl = wr, yl = Er, _l = Vr, vl = Xr, $s = Xe, $l = [
+  pl.default,
+  yl.default,
+  (0, _l.default)(),
+  vl.default,
+  $s.metadataVocabulary,
+  $s.contentVocabulary
+];
+gr.default = $l;
+var Zr = {}, Mt = {};
+Object.defineProperty(Mt, "__esModule", { value: !0 });
+Mt.DiscrError = void 0;
+var gs;
+(function(e) {
+  e.Tag = "tag", e.Mapping = "mapping";
+})(gs || (Mt.DiscrError = gs = {}));
+Object.defineProperty(Zr, "__esModule", { value: !0 });
+const Ge = q, cr = Mt, ws = re, gl = Ye, wl = N, bl = {
+  message: ({ params: { discrError: e, tagName: t } }) => e === cr.DiscrError.Tag ? `tag "${t}" must be string` : `value of tag "${t}" must be in oneOf`,
+  params: ({ params: { discrError: e, tag: t, tagName: r } }) => (0, Ge._)`{error: ${e}, tag: ${r}, tagValue: ${t}}`
+}, El = {
+  keyword: "discriminator",
+  type: "object",
+  schemaType: "object",
+  error: bl,
+  code(e) {
+    const { gen: t, data: r, schema: s, parentSchema: o, it: a } = e, { oneOf: i } = o;
+    if (!a.opts.discriminator)
+      throw new Error("discriminator: requires discriminator option");
+    const d = s.propertyName;
+    if (typeof d != "string")
+      throw new Error("discriminator: requires propertyName");
+    if (s.mapping)
+      throw new Error("discriminator: mapping is not supported");
+    if (!i)
+      throw new Error("discriminator: requires oneOf keyword");
+    const u = t.let("valid", !1), l = t.const("tag", (0, Ge._)`${r}${(0, Ge.getProperty)(d)}`);
+    t.if((0, Ge._)`typeof ${l} == "string"`, () => m(), () => e.error(!1, { discrError: cr.DiscrError.Tag, tag: l, tagName: d })), e.ok(u);
+    function m() {
+      const E = b();
+      t.if(!1);
+      for (const g in E)
+        t.elseIf((0, Ge._)`${l} === ${g}`), t.assign(u, y(E[g]));
+      t.else(), e.error(!1, { discrError: cr.DiscrError.Mapping, tag: l, tagName: d }), t.endIf();
+    }
+    function y(E) {
+      const g = t.name("valid"), v = e.subschema({ keyword: "oneOf", schemaProp: E }, g);
+      return e.mergeEvaluated(v, Ge.Name), g;
+    }
+    function b() {
+      var E;
+      const g = {}, v = f(o);
+      let h = !0;
+      for (let R = 0; R < i.length; R++) {
+        let C = i[R];
+        if (C != null && C.$ref && !(0, wl.schemaHasRulesButRef)(C, a.self.RULES)) {
+          const H = C.$ref;
+          if (C = ws.resolveRef.call(a.self, a.schemaEnv.root, a.baseId, H), C instanceof ws.SchemaEnv && (C = C.schema), C === void 0)
+            throw new gl.default(a.opts.uriResolver, a.baseId, H);
+        }
+        const L = (E = C == null ? void 0 : C.properties) === null || E === void 0 ? void 0 : E[d];
+        if (typeof L != "object")
+          throw new Error(`discriminator: oneOf subschemas (or referenced schemas) must have "properties/${d}"`);
+        h = h && (v || f(C)), $(L, R);
+      }
+      if (!h)
+        throw new Error(`discriminator: "${d}" must be required`);
+      return g;
+      function f({ required: R }) {
+        return Array.isArray(R) && R.includes(d);
+      }
+      function $(R, C) {
+        if (R.const)
+          P(R.const, C);
+        else if (R.enum)
+          for (const L of R.enum)
+            P(L, C);
+        else
+          throw new Error(`discriminator: "properties/${d}" must have "const" or "enum"`);
+      }
+      function P(R, C) {
+        if (typeof R != "string" || R in g)
+          throw new Error(`discriminator: "${d}" values must be unique strings`);
+        g[R] = C;
+      }
+    }
+  }
+};
+Zr.default = El;
+const Sl = "http://json-schema.org/draft-07/schema#", Pl = "http://json-schema.org/draft-07/schema#", kl = "Core schema meta-schema", Nl = {
+  schemaArray: {
+    type: "array",
+    minItems: 1,
+    items: {
+      $ref: "#"
+    }
+  },
+  nonNegativeInteger: {
+    type: "integer",
+    minimum: 0
+  },
+  nonNegativeIntegerDefault0: {
+    allOf: [
+      {
+        $ref: "#/definitions/nonNegativeInteger"
+      },
+      {
+        default: 0
+      }
+    ]
+  },
+  simpleTypes: {
+    enum: [
+      "array",
+      "boolean",
+      "integer",
+      "null",
+      "number",
+      "object",
+      "string"
+    ]
+  },
+  stringArray: {
+    type: "array",
+    items: {
+      type: "string"
+    },
+    uniqueItems: !0,
+    default: []
+  }
+}, Cl = [
+  "object",
+  "boolean"
+], jl = {
+  $id: {
+    type: "string",
+    format: "uri-reference"
+  },
+  $schema: {
+    type: "string",
+    format: "uri"
+  },
+  $ref: {
+    type: "string",
+    format: "uri-reference"
+  },
+  $comment: {
+    type: "string"
+  },
+  title: {
+    type: "string"
+  },
+  description: {
+    type: "string"
+  },
+  default: !0,
+  readOnly: {
+    type: "boolean",
+    default: !1
+  },
+  examples: {
+    type: "array",
+    items: !0
+  },
+  multipleOf: {
+    type: "number",
+    exclusiveMinimum: 0
+  },
+  maximum: {
+    type: "number"
+  },
+  exclusiveMaximum: {
+    type: "number"
+  },
+  minimum: {
+    type: "number"
+  },
+  exclusiveMinimum: {
+    type: "number"
+  },
+  maxLength: {
+    $ref: "#/definitions/nonNegativeInteger"
+  },
+  minLength: {
+    $ref: "#/definitions/nonNegativeIntegerDefault0"
+  },
+  pattern: {
+    type: "string",
+    format: "regex"
+  },
+  additionalItems: {
+    $ref: "#"
+  },
+  items: {
+    anyOf: [
+      {
+        $ref: "#"
+      },
+      {
+        $ref: "#/definitions/schemaArray"
+      }
+    ],
+    default: !0
+  },
+  maxItems: {
+    $ref: "#/definitions/nonNegativeInteger"
+  },
+  minItems: {
+    $ref: "#/definitions/nonNegativeIntegerDefault0"
+  },
+  uniqueItems: {
+    type: "boolean",
+    default: !1
+  },
+  contains: {
+    $ref: "#"
+  },
+  maxProperties: {
+    $ref: "#/definitions/nonNegativeInteger"
+  },
+  minProperties: {
+    $ref: "#/definitions/nonNegativeIntegerDefault0"
+  },
+  required: {
+    $ref: "#/definitions/stringArray"
+  },
+  additionalProperties: {
+    $ref: "#"
+  },
+  definitions: {
+    type: "object",
+    additionalProperties: {
+      $ref: "#"
+    },
+    default: {}
+  },
+  properties: {
+    type: "object",
+    additionalProperties: {
+      $ref: "#"
+    },
+    default: {}
+  },
+  patternProperties: {
+    type: "object",
+    additionalProperties: {
+      $ref: "#"
+    },
+    propertyNames: {
+      format: "regex"
+    },
+    default: {}
+  },
+  dependencies: {
+    type: "object",
+    additionalProperties: {
+      anyOf: [
+        {
+          $ref: "#"
+        },
+        {
+          $ref: "#/definitions/stringArray"
+        }
+      ]
+    }
+  },
+  propertyNames: {
+    $ref: "#"
+  },
+  const: !0,
+  enum: {
+    type: "array",
+    items: !0,
+    minItems: 1,
+    uniqueItems: !0
+  },
+  type: {
+    anyOf: [
+      {
+        $ref: "#/definitions/simpleTypes"
+      },
+      {
+        type: "array",
+        items: {
+          $ref: "#/definitions/simpleTypes"
+        },
+        minItems: 1,
+        uniqueItems: !0
+      }
+    ]
+  },
+  format: {
+    type: "string"
+  },
+  contentMediaType: {
+    type: "string"
+  },
+  contentEncoding: {
+    type: "string"
+  },
+  if: {
+    $ref: "#"
+  },
+  then: {
+    $ref: "#"
+  },
+  else: {
+    $ref: "#"
+  },
+  allOf: {
+    $ref: "#/definitions/schemaArray"
+  },
+  anyOf: {
+    $ref: "#/definitions/schemaArray"
+  },
+  oneOf: {
+    $ref: "#/definitions/schemaArray"
+  },
+  not: {
+    $ref: "#"
+  }
+}, Rl = {
+  $schema: Sl,
+  $id: Pl,
+  title: kl,
+  definitions: Nl,
+  type: Cl,
+  properties: jl,
+  default: !0
+};
+(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 = t.Ajv = void 0;
+  const r = Vs, s = gr, o = Zr, a = Rl, i = ["/properties"], d = "http://json-schema.org/draft-07/schema";
+  class u extends r.default {
+    _addVocabularies() {
+      super._addVocabularies(), s.default.forEach((g) => this.addVocabulary(g)), this.opts.discriminator && this.addKeyword(o.default);
+    }
+    _addDefaultMetaSchema() {
+      if (super._addDefaultMetaSchema(), !this.opts.meta)
+        return;
+      const g = this.opts.$data ? this.$dataMetaSchema(a, i) : a;
+      this.addMetaSchema(g, d, !1), this.refs["http://json-schema.org/schema"] = d;
+    }
+    defaultMeta() {
+      return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(d) ? d : void 0);
+    }
+  }
+  t.Ajv = u, e.exports = t = u, e.exports.Ajv = u, Object.defineProperty(t, "__esModule", { value: !0 }), t.default = u;
+  var l = fe;
+  Object.defineProperty(t, "KeywordCxt", { enumerable: !0, get: function() {
+    return l.KeywordCxt;
+  } });
+  var m = q;
+  Object.defineProperty(t, "_", { enumerable: !0, get: function() {
+    return m._;
+  } }), Object.defineProperty(t, "str", { enumerable: !0, get: function() {
+    return m.str;
+  } }), Object.defineProperty(t, "stringify", { enumerable: !0, get: function() {
+    return m.stringify;
+  } }), Object.defineProperty(t, "nil", { enumerable: !0, get: function() {
+    return m.nil;
+  } }), Object.defineProperty(t, "Name", { enumerable: !0, get: function() {
+    return m.Name;
+  } }), Object.defineProperty(t, "CodeGen", { enumerable: !0, get: function() {
+    return m.CodeGen;
+  } });
+  var y = ht;
+  Object.defineProperty(t, "ValidationError", { enumerable: !0, get: function() {
+    return y.default;
+  } });
+  var b = Ye;
+  Object.defineProperty(t, "MissingRefError", { enumerable: !0, get: function() {
+    return b.default;
+  } });
+})(tr, tr.exports);
+var Ol = tr.exports;
+const Tl = /* @__PURE__ */ Oo(Ol), pd = (e) => je(Lo, e), Il = (e) => je(Dr, e), yd = (e) => je(Ao, e), _d = (e) => je(ft, e), Ml = (e, t = 2e3) => {
+  const [r, s] = de(e), o = Fo(null), { t: a } = je(ft, (l) => l.i18next), i = Il((l) => l.getActionStatus), d = Ne(() => e == null ? void 0 : e.task_id, [e == null ? void 0 : e.task_id]), u = Ne(() => e == null ? void 0 : e.actionId, [e == null ? void 0 : e.actionId]);
+  return Wt(() => {
+    if ((e == null ? void 0 : e.outcome) !== "pending" || !d)
+      return;
+    let l = !1;
+    const m = async () => {
+      var E, g;
+      const y = await i(u, d);
+      if (l)
+        return;
+      let b;
+      y ? y.outcome === "success" || y.outcome === "failure" ? b = { ...y, done: !0 } : b = y : b = { outcome: "failure", summary: a("error.unexpected"), done: !0 }, s(b), (E = e == null ? void 0 : e.onUpdate) == null || E.call(e, { ...e, ...b }), b.done ? (g = e == null ? void 0 : e.onComplete) == null || g.call(e, { ...e, ...b }) : o.current = setTimeout(m, t);
+    };
+    return m(), () => {
+      l = !0, o.current && clearTimeout(o.current);
+    };
+  }, [u, i, t, e, e == null ? void 0 : e.outcome, a, d]), Wt(() => {
+    s(e);
+  }, [e]), Ne(
+    () => e || r ? { ...e, ...r } : void 0,
+    [e, r]
+  );
+}, Vl = ({ result: e, onClose: t, show: r = !1 }) => {
+  var i, d;
+  const { t: s } = je(ft, (u) => u.i18next), o = Ml(e), a = Ne(
+    () => (o == null ? void 0 : o.outcome) === "success" || (o == null ? void 0 : o.outcome) === "failure" || (o == null ? void 0 : o.done),
+    [o == null ? void 0 : o.done, o == null ? void 0 : o.outcome]
+  );
+  return o ? /* @__PURE__ */ M(bs, { open: r, sx: { display: "flex", alignItems: "center", justifyContent: "center" }, onClose: t, children: /* @__PURE__ */ M(Es, { sx: { maxHeight: "80%", maxWidth: "80%", height: "100%", p: 2, minWidth: "750px" }, children: /* @__PURE__ */ M(dt, { children: /* @__PURE__ */ W(se, { spacing: 1, height: "100%", children: [
+    /* @__PURE__ */ W(se, { direction: "row", spacing: 1, alignItems: "center", children: [
+      o.action.action_icon && /* @__PURE__ */ M(zo, { height: "1.5rem", icon: o.action.action_icon }),
+      /* @__PURE__ */ M(ke, { variant: "h5", children: o.action.name }),
+      o.action.supported_types && /* @__PURE__ */ M(ke, { variant: "caption", color: "text.secondary", children: o.action.supported_types.map((u) => u.toUpperCase()).join(", ") }),
+      /* @__PURE__ */ M("div", { style: { flex: 1 } }),
+      /* @__PURE__ */ M(Go, { size: "small", classification: o.action.classification })
+    ] }),
+    /* @__PURE__ */ M(ke, { variant: "body1", children: o.action.summary }),
+    /* @__PURE__ */ M(Dt, { flexItem: !0 }),
+    a ? /* @__PURE__ */ M(dt, { children: /* @__PURE__ */ M(Jo, { result: o }) }) : /* @__PURE__ */ W(se, { flex: 1, sx: { pt: 2, alignItems: "center" }, spacing: 1, children: [
+      o.summary && /* @__PURE__ */ M(ke, { variant: "caption", children: o.summary }),
+      /* @__PURE__ */ M(
+        ko,
+        {
+          variant: (i = o.output) != null && i.progress ? "determinate" : "indeterminate",
+          value: ((d = o.output) == null ? void 0 : d.progress) * 100,
+          sx: { maxWidth: 500, width: "100%", borderRadius: (u) => u.shape.borderRadius }
+        }
+      )
+    ] }),
+    /* @__PURE__ */ M("div", { style: { flex: 1 } }),
+    /* @__PURE__ */ W(se, { direction: "row", spacing: 1, children: [
+      /* @__PURE__ */ M("div", { style: { flex: 1 } }),
+      o.link && /* @__PURE__ */ M(ot, { variant: "outlined", component: "a", target: "_blank", href: o.link, children: s("details.open") }),
+      /* @__PURE__ */ M(ot, { variant: "outlined", color: "error", onClick: t, children: s("close") })
+    ] })
+  ] }) }) }) }) : null;
+}, Fl = Ns(Vl), Kl = new Tl({ removeAdditional: !0, coerceTypes: !0, strict: !1 }), Dr = Ko(null), vd = ({
+  baseURL: e,
+  children: t,
+  classification: r,
+  includeContext: s,
+  getToken: o,
+  onNetworkCall: a
+}) => {
+  const { t: i, i18n: d } = je(ft, (z) => z.i18next), { ready: u } = Bo(), [l, m] = de(null), [y, b] = de({}), [E, g] = de(!1), [v, h] = de(null), [f, $] = de(!1), [P, R] = de({}), C = Ne(() => {
+    const z = {}, B = o == null ? void 0 : o();
+    return B && (z.Authorization = `Bearer ${B}`), a ? a({ baseURL: e, headers: z }) : { baseURL: e, headers: z };
+  }, [e, o, a]), L = Oe(async () => {
+    if (!u)
+      return;
+    const z = await Ht.actions.get(C);
+    return z && R(z), z;
+  }, [u, C]);
+  Wt(() => {
+    L();
+  }, [e, u]);
+  const H = Oe(
+    (z, B, ee) => JSON.stringify({ type: z, value: B, classification: ee ?? r }),
+    [r]
+  ), oe = Oe(
+    async (z, B, ee, Ke) => {
+      const {
+        forceMenu: qe,
+        onComplete: $e,
+        onUpdate: he,
+        onCancel: k,
+        skipMenu: p,
+        skipResultModal: S,
+        timeout: _,
+        includeContext: n,
+        extraContext: c
+      } = {
+        forceMenu: !1,
+        skipResultModal: !1,
+        skipMenu: !1,
+        onComplete: null,
+        onUpdate: null,
+        onCancel: null,
+        timeout: null,
+        includeContext: s ?? !1,
+        extraContext: null,
+        ...Ke
+      };
+      if (!Object.keys(P).includes(z))
+        throw new Error("Invalid action id");
+      const w = B.map(
+        (V) => V.type === "telemetry" ? { ...V, value: JSON.stringify(V.value) } : V
+      ), j = P[z], O = Kl.compile(j.params), A = { selectors: w, ...ee };
+      let U = null;
+      if (n && (U = {
+        timestamp: Ho().toISOString(),
+        url: window.location,
+        language: (d == null ? void 0 : d.language) ?? "en"
+      }), Qo(c) || (U = {
+        ...U ?? {},
+        ...c
+      }), $(!0), !O(A) || qe) {
+        if (p && !qe)
+          throw console.error(`Form is not valid (${O.errors.length} errors)`), new Error("Form is not completed");
+        (l == null ? void 0 : l.id) === z && (console.error(`Form is not valid (${O.errors.length} errors)`), _t(
+          new CustomEvent(yt, {
+            detail: {
+              message: i("action.error.validation"),
+              level: "error"
+            }
+          })
+        )), m({
+          id: z,
+          action: j,
+          selectors: B,
+          params: A ?? {},
+          skipResultModal: S,
+          context: U,
+          onComplete: $e,
+          onUpdate: he,
+          onCancel: k,
+          timeout: _
+        });
+        return;
+      }
+      try {
+        const V = await Ht.actions.post(
+          z,
+          w,
+          A ?? {},
+          U,
+          { timeout: _ },
+          C
+        ), pe = { ...V, actionId: z, action: j, params: A };
+        he == null || he(pe), V.outcome !== "pending" && ($e == null || $e(pe)), b((Ue) => {
+          const We = B.map((ge) => H(ge.type, ge.value, ge.classification));
+          return {
+            ...Ue,
+            ...We.reduce(
+              (ge, ze) => ({
+                ...ge,
+                [ze]: [...Ue[ze] ?? [], pe]
+              }),
+              {}
+            )
+          };
+        }), _t(
+          new CustomEvent(yt, {
+            detail: {
+              message: /* @__PURE__ */ W(se, { direction: "row", alignItems: "center", spacing: 0.5, width: "100%", children: [
+                /* @__PURE__ */ M(ke, { children: V.summary }),
+                V.link && /* @__PURE__ */ M(No, { component: "a", href: V.link, size: "small", target: "_blank", children: /* @__PURE__ */ M(Ss, { icon: "ic:baseline-open-in-new", fontSize: "small" }) })
+              ] }),
+              timeout: V.link ? null : 5e3,
+              level: V.outcome === "success" ? "success" : V.outcome === "pending" ? "info" : "error",
+              options: {
+                style: {
+                  minWidth: 0
+                },
+                SnackbarProps: {
+                  style: {
+                    minWidth: 0
+                  }
+                }
+              }
+            }
+          })
+        ), V.outcome === "success" && m(null), V.outcome === "pending" && (h({ ...V, actionId: z, action: j, onComplete: $e, onUpdate: he }), S || g(!0), m(null)), V.format && (h({ ...V, actionId: z, action: j }), V.format !== "pivot" && !S ? g(!0) : window.open(V.output, "_blank", "noreferrer"));
+      } catch (V) {
+        _t(
+          new CustomEvent(yt, {
+            detail: {
+              message: V.toString(),
+              level: "error"
+            }
+          })
+        );
+      } finally {
+        $(!1);
+      }
+    },
+    [P, s, H, d == null ? void 0 : d.language, C, l == null ? void 0 : l.id, i]
+  ), ae = Oe(
+    async (z, B) => {
+      try {
+        return await Ht.actions.status.get(z, B, {}, C);
+      } catch (ee) {
+        _t(
+          new CustomEvent(yt, {
+            detail: {
+              message: ee.toString(),
+              level: "error"
+            }
+          })
+        );
+      }
+    },
+    [C]
+  ), me = Oe(() => {
+    var z;
+    (z = l == null ? void 0 : l.onCancel) == null || z.call(l), m(null), $(!1);
+  }, [l]), Ee = Oe(
+    (z, B, ee) => y[H(z, B, ee)] ?? [],
+    [y, H]
+  ), ie = Ne(
+    () => ({
+      availableActions: P,
+      executeAction: oe,
+      cancelAction: me,
+      getActionStatus: ae,
+      getActionResults: Ee,
+      loading: f,
+      refreshActions: L
+    }),
+    [P, me, oe, Ee, ae, f, L]
+  );
+  return /* @__PURE__ */ W(Dr.Provider, { value: ie, children: [
+    t,
+    /* @__PURE__ */ W(dt, { children: [
+      l && /* @__PURE__ */ M(Al, { runningActionData: l }),
+      /* @__PURE__ */ M(
+        Fl,
+        {
+          show: E && !!v,
+          result: v,
+          onClose: () => g(!1)
+        }
+      )
+    ] })
+  ] });
+}, ql = () => qo(Dr), Ul = Eo.map((e) => ({
+  ...e,
+  renderer: ({ ...t }) => /* @__PURE__ */ M(dt, { children: /* @__PURE__ */ M(e.renderer, { ...t }) })
+})), zl = ({ runningActionData: e }) => {
+  const { executeAction: t, cancelAction: r } = ql(), { t: s } = je(ft, (v) => v.i18next), [o, a] = de(!1), [i, d] = de(null), [u, l] = de(e == null ? void 0 : e.params), [m, y] = de(!1), b = Ne(
+    () => e != null && e.action ? { ...Uo(e.action.params), ...e.action.extra_schema ?? {} } : null,
+    [e == null ? void 0 : e.action]
+  ), E = Ne(
+    () => ({
+      type: "VerticalLayout",
+      elements: Object.entries((b == null ? void 0 : b.properties) ?? {}).sort(([v, h], [f, $]) => h.order || $.order ? h.order - $.order : +(b == null ? void 0 : b.required.includes(v)) - +(b == null ? void 0 : b.required.includes(f))).map(([v, h]) => {
+        var f;
+        return {
+          type: "Control",
+          scope: `#/properties/${v}`,
+          options: {
+            autocomplete: !!h.enum || ((f = h.options) == null ? void 0 : f.autocomplete),
+            showUnfocusedDescription: !0,
+            ...h.options
+          },
+          rule: h.rule
+        };
+      })
+    }),
+    [b == null ? void 0 : b.properties, b == null ? void 0 : b.required]
+  ), g = Oe(async () => {
+    try {
+      a(!0);
+      const v = {};
+      e != null && e.onComplete && (v.onComplete = e == null ? void 0 : e.onComplete), e != null && e.onUpdate && (v.onUpdate = e == null ? void 0 : e.onUpdate), e != null && e.timeout && (v.timeout = e == null ? void 0 : e.timeout), e != null && e.skipResultModal && (v.skipResultModal = e == null ? void 0 : e.skipResultModal), await t(e == null ? void 0 : e.id, e == null ? void 0 : e.selectors, u, v);
+    } catch (v) {
+      console.error(v);
+    } finally {
+      a(!1);
+    }
+  }, [
+    t,
+    e == null ? void 0 : e.id,
+    e == null ? void 0 : e.selectors,
+    e == null ? void 0 : e.onComplete,
+    e == null ? void 0 : e.timeout,
+    e == null ? void 0 : e.skipResultModal,
+    u
+  ]);
+  if (e != null && e.action)
+    try {
+      return /* @__PURE__ */ M(bs, { open: !0, sx: { display: "flex", alignItems: "center", justifyContent: "center" }, onClose: r, children: /* @__PURE__ */ M(
+        Es,
+        {
+          sx: { maxHeight: "80%", maxWidth: "80%", height: "100%", px: 2, pt: 2, minWidth: "750px", overflow: "auto" },
+          children: /* @__PURE__ */ W(
+            se,
+            {
+              spacing: 1,
+              height: "100%",
+              sx: {
+                ".MuiFormHelperText-root": {
+                  marginLeft: "0 !important",
+                  "&:last-of-type": { mb: 3 }
+                }
+              },
+              children: [
+                /* @__PURE__ */ W(se, { direction: "row", spacing: 1, children: [
+                  /* @__PURE__ */ W(se, { direction: "column", spacing: 1, children: [
+                    /* @__PURE__ */ W(ke, { variant: "h5", children: [
+                      s("actions.executing"),
+                      " ",
+                      e == null ? void 0 : e.action.id.replace(/_/g, " ").split(" ").map(wn).join(" ")
+                    ] }),
+                    (e == null ? void 0 : e.action.summary) && /* @__PURE__ */ M(ke, { variant: "body1", color: "text.secondary", sx: { pb: 1.5 }, children: e == null ? void 0 : e.action.summary })
+                  ] }),
+                  /* @__PURE__ */ M(et, { flex: 1 }),
+                  /* @__PURE__ */ M(et, { alignContent: "end", children: /* @__PURE__ */ M(
+                    ot,
+                    {
+                      variant: "outlined",
+                      onClick: () => y((v) => !v),
+                      startIcon: /* @__PURE__ */ M(
+                        et,
+                        {
+                          component: "span",
+                          sx: (v) => ({
+                            transition: v.transitions.create("transform"),
+                            transform: m ? "rotate(180deg)" : "rotate(0deg)"
+                          }),
+                          children: /* @__PURE__ */ M(Ss, { icon: "ic:baseline-keyboard-double-arrow-right" })
+                        }
+                      ),
+                      children: s(m ? "actions.json.hide" : "actions.json.show")
+                    }
+                  ) })
+                ] }),
+                /* @__PURE__ */ M(Dt, { orientation: "horizontal", variant: "middle" }),
+                /* @__PURE__ */ M(et, { pt: 1.5 }),
+                /* @__PURE__ */ W(se, { flexGrow: 1, direction: "row", spacing: 1, children: [
+                  /* @__PURE__ */ W(se, { direction: "column", flexGrow: 1, children: [
+                    /* @__PURE__ */ M(dt, { children: /* @__PURE__ */ M(
+                      Po,
+                      {
+                        schema: b,
+                        uischema: E,
+                        renderers: Ul,
+                        cells: So,
+                        data: u,
+                        onChange: ({ data: v, errors: h }) => {
+                          Vo(v, u) || l(v), d(h);
+                        },
+                        config: {}
+                      }
+                    ) }),
+                    /* @__PURE__ */ W(se, { direction: "row", spacing: 1, pb: 1, children: [
+                      /* @__PURE__ */ M("div", { style: { flex: 1 } }),
+                      /* @__PURE__ */ M(ot, { color: "error", variant: "outlined", onClick: r, children: s("cancel") }),
+                      /* @__PURE__ */ M(
+                        ot,
+                        {
+                          color: "success",
+                          variant: "outlined",
+                          disabled: o || (i == null ? void 0 : i.length) > 0,
+                          onClick: g,
+                          endIcon: o && /* @__PURE__ */ M(Co, { color: "inherit", size: 18 }),
+                          children: s("actions.execute")
+                        }
+                      )
+                    ] })
+                  ] }),
+                  /* @__PURE__ */ M(jo, { orientation: "horizontal", in: m, unmountOnExit: !0, mountOnEnter: !0, children: /* @__PURE__ */ W(se, { direction: "row", height: "100%", spacing: 1, children: [
+                    /* @__PURE__ */ M(Dt, { orientation: "vertical" }),
+                    /* @__PURE__ */ W(se, { children: [
+                      /* @__PURE__ */ M(ke, { variant: "h5", children: s("action.data") }),
+                      /* @__PURE__ */ M(et, { width: 600, height: "100%", children: /* @__PURE__ */ M(Ro, { data: u, slotProps: { stack: { height: "100%" }, json: { name: !1 } } }) })
+                    ] })
+                  ] }) })
+                ] })
+              ]
+            }
+          )
+        }
+      ) });
+    } catch (v) {
+      return console.warn(v), null;
+    }
+}, Al = Ns(zl);
+export {
+  Al as A,
+  vd as C,
+  Fl as R,
+  Il as a,
+  yd as b,
+  pd as c,
+  _d as d,
+  wn as e,
+  Ml as f,
+  Dr as g,
+  ql as u
+};