@cccsaurora/clue-ui 1.3.0-dev.403 → 1.3.0

package/ActionForm-CHOSKfvu.js

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