urfu-ui-kit-react 0.0.0 → 0.0.2

package/dist/urfu-ui-kit-react.js

@@ -0,0 +1,3049 @@
+function ln(l) {
+  return l && l.__esModule && Object.prototype.hasOwnProperty.call(l, "default") ? l.default : l;
+}
+var Kr = { exports: {} }, rr = {}, Jr = { exports: {} }, U = {};
+/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Rt;
+function fn() {
+  if (Rt)
+    return U;
+  Rt = 1;
+  var l = Symbol.for("react.element"), h = Symbol.for("react.portal"), N = Symbol.for("react.fragment"), P = Symbol.for("react.strict_mode"), $ = Symbol.for("react.profiler"), O = Symbol.for("react.provider"), D = Symbol.for("react.context"), x = Symbol.for("react.forward_ref"), j = Symbol.for("react.suspense"), I = Symbol.for("react.memo"), T = Symbol.for("react.lazy"), S = Symbol.iterator;
+  function W(r) {
+    return r === null || typeof r != "object" ? null : (r = S && r[S] || r["@@iterator"], typeof r == "function" ? r : null);
+  }
+  var q = { isMounted: function() {
+    return !1;
+  }, enqueueForceUpdate: function() {
+  }, enqueueReplaceState: function() {
+  }, enqueueSetState: function() {
+  } }, ee = Object.assign, M = {};
+  function Z(r, a, f) {
+    this.props = r, this.context = a, this.refs = M, this.updater = f || q;
+  }
+  Z.prototype.isReactComponent = {}, Z.prototype.setState = function(r, a) {
+    if (typeof r != "object" && typeof r != "function" && r != null)
+      throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+    this.updater.enqueueSetState(this, r, a, "setState");
+  }, Z.prototype.forceUpdate = function(r) {
+    this.updater.enqueueForceUpdate(this, r, "forceUpdate");
+  };
+  function te() {
+  }
+  te.prototype = Z.prototype;
+  function X(r, a, f) {
+    this.props = r, this.context = a, this.refs = M, this.updater = f || q;
+  }
+  var re = X.prototype = new te();
+  re.constructor = X, ee(re, Z.prototype), re.isPureReactComponent = !0;
+  var H = Array.isArray, s = Object.prototype.hasOwnProperty, oe = { current: null }, be = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function Ee(r, a, f) {
+    var y, d = {}, w = null, g = null;
+    if (a != null)
+      for (y in a.ref !== void 0 && (g = a.ref), a.key !== void 0 && (w = "" + a.key), a)
+        s.call(a, y) && !be.hasOwnProperty(y) && (d[y] = a[y]);
+    var m = arguments.length - 2;
+    if (m === 1)
+      d.children = f;
+    else if (1 < m) {
+      for (var b = Array(m), k = 0; k < m; k++)
+        b[k] = arguments[k + 2];
+      d.children = b;
+    }
+    if (r && r.defaultProps)
+      for (y in m = r.defaultProps, m)
+        d[y] === void 0 && (d[y] = m[y]);
+    return { $$typeof: l, type: r, key: w, ref: g, props: d, _owner: oe.current };
+  }
+  function Ce(r, a) {
+    return { $$typeof: l, type: r.type, key: a, ref: r.ref, props: r.props, _owner: r._owner };
+  }
+  function we(r) {
+    return typeof r == "object" && r !== null && r.$$typeof === l;
+  }
+  function xe(r) {
+    var a = { "=": "=0", ":": "=2" };
+    return "$" + r.replace(/[=:]/g, function(f) {
+      return a[f];
+    });
+  }
+  var Te = /\/+/g;
+  function pe(r, a) {
+    return typeof r == "object" && r !== null && r.key != null ? xe("" + r.key) : a.toString(36);
+  }
+  function le(r, a, f, y, d) {
+    var w = typeof r;
+    (w === "undefined" || w === "boolean") && (r = null);
+    var g = !1;
+    if (r === null)
+      g = !0;
+    else
+      switch (w) {
+        case "string":
+        case "number":
+          g = !0;
+          break;
+        case "object":
+          switch (r.$$typeof) {
+            case l:
+            case h:
+              g = !0;
+          }
+      }
+    if (g)
+      return g = r, d = d(g), r = y === "" ? "." + pe(g, 0) : y, H(d) ? (f = "", r != null && (f = r.replace(Te, "$&/") + "/"), le(d, a, f, "", function(k) {
+        return k;
+      })) : d != null && (we(d) && (d = Ce(d, f + (!d.key || g && g.key === d.key ? "" : ("" + d.key).replace(Te, "$&/") + "/") + r)), a.push(d)), 1;
+    if (g = 0, y = y === "" ? "." : y + ":", H(r))
+      for (var m = 0; m < r.length; m++) {
+        w = r[m];
+        var b = y + pe(w, m);
+        g += le(w, a, f, b, d);
+      }
+    else if (b = W(r), typeof b == "function")
+      for (r = b.call(r), m = 0; !(w = r.next()).done; )
+        w = w.value, b = y + pe(w, m++), g += le(w, a, f, b, d);
+    else if (w === "object")
+      throw a = String(r), Error("Objects are not valid as a React child (found: " + (a === "[object Object]" ? "object with keys {" + Object.keys(r).join(", ") + "}" : a) + "). If you meant to render a collection of children, use an array instead.");
+    return g;
+  }
+  function fe(r, a, f) {
+    if (r == null)
+      return r;
+    var y = [], d = 0;
+    return le(r, y, "", "", function(w) {
+      return a.call(f, w, d++);
+    }), y;
+  }
+  function se(r) {
+    if (r._status === -1) {
+      var a = r._result;
+      a = a(), a.then(function(f) {
+        (r._status === 0 || r._status === -1) && (r._status = 1, r._result = f);
+      }, function(f) {
+        (r._status === 0 || r._status === -1) && (r._status = 2, r._result = f);
+      }), r._status === -1 && (r._status = 0, r._result = a);
+    }
+    if (r._status === 1)
+      return r._result.default;
+    throw r._result;
+  }
+  var C = { current: null }, ge = { transition: null }, Se = { ReactCurrentDispatcher: C, ReactCurrentBatchConfig: ge, ReactCurrentOwner: oe };
+  return U.Children = { map: fe, forEach: function(r, a, f) {
+    fe(r, function() {
+      a.apply(this, arguments);
+    }, f);
+  }, count: function(r) {
+    var a = 0;
+    return fe(r, function() {
+      a++;
+    }), a;
+  }, toArray: function(r) {
+    return fe(r, function(a) {
+      return a;
+    }) || [];
+  }, only: function(r) {
+    if (!we(r))
+      throw Error("React.Children.only expected to receive a single React element child.");
+    return r;
+  } }, U.Component = Z, U.Fragment = N, U.Profiler = $, U.PureComponent = X, U.StrictMode = P, U.Suspense = j, U.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Se, U.cloneElement = function(r, a, f) {
+    if (r == null)
+      throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + r + ".");
+    var y = ee({}, r.props), d = r.key, w = r.ref, g = r._owner;
+    if (a != null) {
+      if (a.ref !== void 0 && (w = a.ref, g = oe.current), a.key !== void 0 && (d = "" + a.key), r.type && r.type.defaultProps)
+        var m = r.type.defaultProps;
+      for (b in a)
+        s.call(a, b) && !be.hasOwnProperty(b) && (y[b] = a[b] === void 0 && m !== void 0 ? m[b] : a[b]);
+    }
+    var b = arguments.length - 2;
+    if (b === 1)
+      y.children = f;
+    else if (1 < b) {
+      m = Array(b);
+      for (var k = 0; k < b; k++)
+        m[k] = arguments[k + 2];
+      y.children = m;
+    }
+    return { $$typeof: l, type: r.type, key: d, ref: w, props: y, _owner: g };
+  }, U.createContext = function(r) {
+    return r = { $$typeof: D, _currentValue: r, _currentValue2: r, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null }, r.Provider = { $$typeof: O, _context: r }, r.Consumer = r;
+  }, U.createElement = Ee, U.createFactory = function(r) {
+    var a = Ee.bind(null, r);
+    return a.type = r, a;
+  }, U.createRef = function() {
+    return { current: null };
+  }, U.forwardRef = function(r) {
+    return { $$typeof: x, render: r };
+  }, U.isValidElement = we, U.lazy = function(r) {
+    return { $$typeof: T, _payload: { _status: -1, _result: r }, _init: se };
+  }, U.memo = function(r, a) {
+    return { $$typeof: I, type: r, compare: a === void 0 ? null : a };
+  }, U.startTransition = function(r) {
+    var a = ge.transition;
+    ge.transition = {};
+    try {
+      r();
+    } finally {
+      ge.transition = a;
+    }
+  }, U.unstable_act = function() {
+    throw Error("act(...) is not supported in production builds of React.");
+  }, U.useCallback = function(r, a) {
+    return C.current.useCallback(r, a);
+  }, U.useContext = function(r) {
+    return C.current.useContext(r);
+  }, U.useDebugValue = function() {
+  }, U.useDeferredValue = function(r) {
+    return C.current.useDeferredValue(r);
+  }, U.useEffect = function(r, a) {
+    return C.current.useEffect(r, a);
+  }, U.useId = function() {
+    return C.current.useId();
+  }, U.useImperativeHandle = function(r, a, f) {
+    return C.current.useImperativeHandle(r, a, f);
+  }, U.useInsertionEffect = function(r, a) {
+    return C.current.useInsertionEffect(r, a);
+  }, U.useLayoutEffect = function(r, a) {
+    return C.current.useLayoutEffect(r, a);
+  }, U.useMemo = function(r, a) {
+    return C.current.useMemo(r, a);
+  }, U.useReducer = function(r, a, f) {
+    return C.current.useReducer(r, a, f);
+  }, U.useRef = function(r) {
+    return C.current.useRef(r);
+  }, U.useState = function(r) {
+    return C.current.useState(r);
+  }, U.useSyncExternalStore = function(r, a, f) {
+    return C.current.useSyncExternalStore(r, a, f);
+  }, U.useTransition = function() {
+    return C.current.useTransition();
+  }, U.version = "18.2.0", U;
+}
+var nr = { exports: {} };
+/**
+ * @license React
+ * react.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+nr.exports;
+var Ct;
+function dn() {
+  return Ct || (Ct = 1, function(l, h) {
+    process.env.NODE_ENV !== "production" && function() {
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      var N = "18.2.0", P = Symbol.for("react.element"), $ = Symbol.for("react.portal"), O = Symbol.for("react.fragment"), D = Symbol.for("react.strict_mode"), x = Symbol.for("react.profiler"), j = Symbol.for("react.provider"), I = Symbol.for("react.context"), T = Symbol.for("react.forward_ref"), S = Symbol.for("react.suspense"), W = Symbol.for("react.suspense_list"), q = Symbol.for("react.memo"), ee = Symbol.for("react.lazy"), M = Symbol.for("react.offscreen"), Z = Symbol.iterator, te = "@@iterator";
+      function X(e) {
+        if (e === null || typeof e != "object")
+          return null;
+        var t = Z && e[Z] || e[te];
+        return typeof t == "function" ? t : null;
+      }
+      var re = {
+        /**
+         * @internal
+         * @type {ReactComponent}
+         */
+        current: null
+      }, H = {
+        transition: null
+      }, s = {
+        current: null,
+        // Used to reproduce behavior of `batchedUpdates` in legacy mode.
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1
+      }, oe = {
+        /**
+         * @internal
+         * @type {ReactComponent}
+         */
+        current: null
+      }, be = {}, Ee = null;
+      function Ce(e) {
+        Ee = e;
+      }
+      be.setExtraStackFrame = function(e) {
+        Ee = e;
+      }, be.getCurrentStack = null, be.getStackAddendum = function() {
+        var e = "";
+        Ee && (e += Ee);
+        var t = be.getCurrentStack;
+        return t && (e += t() || ""), e;
+      };
+      var we = !1, xe = !1, Te = !1, pe = !1, le = !1, fe = {
+        ReactCurrentDispatcher: re,
+        ReactCurrentBatchConfig: H,
+        ReactCurrentOwner: oe
+      };
+      fe.ReactDebugCurrentFrame = be, fe.ReactCurrentActQueue = s;
+      function se(e) {
+        {
+          for (var t = arguments.length, o = new Array(t > 1 ? t - 1 : 0), i = 1; i < t; i++)
+            o[i - 1] = arguments[i];
+          ge("warn", e, o);
+        }
+      }
+      function C(e) {
+        {
+          for (var t = arguments.length, o = new Array(t > 1 ? t - 1 : 0), i = 1; i < t; i++)
+            o[i - 1] = arguments[i];
+          ge("error", e, o);
+        }
+      }
+      function ge(e, t, o) {
+        {
+          var i = fe.ReactDebugCurrentFrame, c = i.getStackAddendum();
+          c !== "" && (t += "%s", o = o.concat([c]));
+          var A = o.map(function(E) {
+            return String(E);
+          });
+          A.unshift("Warning: " + t), Function.prototype.apply.call(console[e], console, A);
+        }
+      }
+      var Se = {};
+      function r(e, t) {
+        {
+          var o = e.constructor, i = o && (o.displayName || o.name) || "ReactClass", c = i + "." + t;
+          if (Se[c])
+            return;
+          C("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", t, i), Se[c] = !0;
+        }
+      }
+      var a = {
+        /**
+         * Checks whether or not this composite component is mounted.
+         * @param {ReactClass} publicInstance The instance we want to test.
+         * @return {boolean} True if mounted, false otherwise.
+         * @protected
+         * @final
+         */
+        isMounted: function(e) {
+          return !1;
+        },
+        /**
+         * Forces an update. This should only be invoked when it is known with
+         * certainty that we are **not** in a DOM transaction.
+         *
+         * You may want to call this when you know that some deeper aspect of the
+         * component's state has changed but `setState` was not called.
+         *
+         * This will not invoke `shouldComponentUpdate`, but it will invoke
+         * `componentWillUpdate` and `componentDidUpdate`.
+         *
+         * @param {ReactClass} publicInstance The instance that should rerender.
+         * @param {?function} callback Called after component is updated.
+         * @param {?string} callerName name of the calling function in the public API.
+         * @internal
+         */
+        enqueueForceUpdate: function(e, t, o) {
+          r(e, "forceUpdate");
+        },
+        /**
+         * Replaces all of the state. Always use this or `setState` to mutate state.
+         * You should treat `this.state` as immutable.
+         *
+         * There is no guarantee that `this.state` will be immediately updated, so
+         * accessing `this.state` after calling this method may return the old value.
+         *
+         * @param {ReactClass} publicInstance The instance that should rerender.
+         * @param {object} completeState Next state.
+         * @param {?function} callback Called after component is updated.
+         * @param {?string} callerName name of the calling function in the public API.
+         * @internal
+         */
+        enqueueReplaceState: function(e, t, o, i) {
+          r(e, "replaceState");
+        },
+        /**
+         * Sets a subset of the state. This only exists because _pendingState is
+         * internal. This provides a merging strategy that is not available to deep
+         * properties which is confusing. TODO: Expose pendingState or don't use it
+         * during the merge.
+         *
+         * @param {ReactClass} publicInstance The instance that should rerender.
+         * @param {object} partialState Next partial state to be merged with state.
+         * @param {?function} callback Called after component is updated.
+         * @param {?string} Name of the calling function in the public API.
+         * @internal
+         */
+        enqueueSetState: function(e, t, o, i) {
+          r(e, "setState");
+        }
+      }, f = Object.assign, y = {};
+      Object.freeze(y);
+      function d(e, t, o) {
+        this.props = e, this.context = t, this.refs = y, this.updater = o || a;
+      }
+      d.prototype.isReactComponent = {}, d.prototype.setState = function(e, t) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw new Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+        this.updater.enqueueSetState(this, e, t, "setState");
+      }, d.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      {
+        var w = {
+          isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
+          replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
+        }, g = function(e, t) {
+          Object.defineProperty(d.prototype, e, {
+            get: function() {
+              se("%s(...) is deprecated in plain JavaScript React classes. %s", t[0], t[1]);
+            }
+          });
+        };
+        for (var m in w)
+          w.hasOwnProperty(m) && g(m, w[m]);
+      }
+      function b() {
+      }
+      b.prototype = d.prototype;
+      function k(e, t, o) {
+        this.props = e, this.context = t, this.refs = y, this.updater = o || a;
+      }
+      var L = k.prototype = new b();
+      L.constructor = k, f(L, d.prototype), L.isPureReactComponent = !0;
+      function ve() {
+        var e = {
+          current: null
+        };
+        return Object.seal(e), e;
+      }
+      var v = Array.isArray;
+      function ye(e) {
+        return v(e);
+      }
+      function Ae(e) {
+        {
+          var t = typeof Symbol == "function" && Symbol.toStringTag, o = t && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return o;
+        }
+      }
+      function je(e) {
+        try {
+          return Me(e), !1;
+        } catch {
+          return !0;
+        }
+      }
+      function Me(e) {
+        return "" + e;
+      }
+      function Le(e) {
+        if (je(e))
+          return C("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Ae(e)), Me(e);
+      }
+      function ar(e, t, o) {
+        var i = e.displayName;
+        if (i)
+          return i;
+        var c = t.displayName || t.name || "";
+        return c !== "" ? o + "(" + c + ")" : o;
+      }
+      function Ne(e) {
+        return e.displayName || "Context";
+      }
+      function Pe(e) {
+        if (e == null)
+          return null;
+        if (typeof e.tag == "number" && C("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+          return e.displayName || e.name || null;
+        if (typeof e == "string")
+          return e;
+        switch (e) {
+          case O:
+            return "Fragment";
+          case $:
+            return "Portal";
+          case x:
+            return "Profiler";
+          case D:
+            return "StrictMode";
+          case S:
+            return "Suspense";
+          case W:
+            return "SuspenseList";
+        }
+        if (typeof e == "object")
+          switch (e.$$typeof) {
+            case I:
+              var t = e;
+              return Ne(t) + ".Consumer";
+            case j:
+              var o = e;
+              return Ne(o._context) + ".Provider";
+            case T:
+              return ar(e, e.render, "ForwardRef");
+            case q:
+              var i = e.displayName || null;
+              return i !== null ? i : Pe(e.type) || "Memo";
+            case ee: {
+              var c = e, A = c._payload, E = c._init;
+              try {
+                return Pe(E(A));
+              } catch {
+                return null;
+              }
+            }
+          }
+        return null;
+      }
+      var Ye = Object.prototype.hasOwnProperty, Be = {
+        key: !0,
+        ref: !0,
+        __self: !0,
+        __source: !0
+      }, or, ir, ze;
+      ze = {};
+      function Ze(e) {
+        if (Ye.call(e, "ref")) {
+          var t = Object.getOwnPropertyDescriptor(e, "ref").get;
+          if (t && t.isReactWarning)
+            return !1;
+        }
+        return e.ref !== void 0;
+      }
+      function Ie(e) {
+        if (Ye.call(e, "key")) {
+          var t = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (t && t.isReactWarning)
+            return !1;
+        }
+        return e.key !== void 0;
+      }
+      function Cr(e, t) {
+        var o = function() {
+          or || (or = !0, C("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", t));
+        };
+        o.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: o,
+          configurable: !0
+        });
+      }
+      function ur(e, t) {
+        var o = function() {
+          ir || (ir = !0, C("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", t));
+        };
+        o.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: o,
+          configurable: !0
+        });
+      }
+      function sr(e) {
+        if (typeof e.ref == "string" && oe.current && e.__self && oe.current.stateNode !== e.__self) {
+          var t = Pe(oe.current.type);
+          ze[t] || (C('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', t, e.ref), ze[t] = !0);
+        }
+      }
+      var We = function(e, t, o, i, c, A, E) {
+        var F = {
+          // This tag allows us to uniquely identify this as a React Element
+          $$typeof: P,
+          // Built-in properties that belong on the element
+          type: e,
+          key: t,
+          ref: o,
+          props: E,
+          // Record the component responsible for creating this element.
+          _owner: A
+        };
+        return F._store = {}, Object.defineProperty(F._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: !1
+        }), Object.defineProperty(F, "_self", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !1,
+          value: i
+        }), Object.defineProperty(F, "_source", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !1,
+          value: c
+        }), Object.freeze && (Object.freeze(F.props), Object.freeze(F)), F;
+      };
+      function wr(e, t, o) {
+        var i, c = {}, A = null, E = null, F = null, B = null;
+        if (t != null) {
+          Ze(t) && (E = t.ref, sr(t)), Ie(t) && (Le(t.key), A = "" + t.key), F = t.__self === void 0 ? null : t.__self, B = t.__source === void 0 ? null : t.__source;
+          for (i in t)
+            Ye.call(t, i) && !Be.hasOwnProperty(i) && (c[i] = t[i]);
+        }
+        var Q = arguments.length - 2;
+        if (Q === 1)
+          c.children = o;
+        else if (Q > 1) {
+          for (var ne = Array(Q), ae = 0; ae < Q; ae++)
+            ne[ae] = arguments[ae + 2];
+          Object.freeze && Object.freeze(ne), c.children = ne;
+        }
+        if (e && e.defaultProps) {
+          var ue = e.defaultProps;
+          for (i in ue)
+            c[i] === void 0 && (c[i] = ue[i]);
+        }
+        if (A || E) {
+          var de = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          A && Cr(c, de), E && ur(c, de);
+        }
+        return We(e, A, E, F, B, oe.current, c);
+      }
+      function Tr(e, t) {
+        var o = We(e.type, t, e.ref, e._self, e._source, e._owner, e.props);
+        return o;
+      }
+      function Sr(e, t, o) {
+        if (e == null)
+          throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + e + ".");
+        var i, c = f({}, e.props), A = e.key, E = e.ref, F = e._self, B = e._source, Q = e._owner;
+        if (t != null) {
+          Ze(t) && (E = t.ref, Q = oe.current), Ie(t) && (Le(t.key), A = "" + t.key);
+          var ne;
+          e.type && e.type.defaultProps && (ne = e.type.defaultProps);
+          for (i in t)
+            Ye.call(t, i) && !Be.hasOwnProperty(i) && (t[i] === void 0 && ne !== void 0 ? c[i] = ne[i] : c[i] = t[i]);
+        }
+        var ae = arguments.length - 2;
+        if (ae === 1)
+          c.children = o;
+        else if (ae > 1) {
+          for (var ue = Array(ae), de = 0; de < ae; de++)
+            ue[de] = arguments[de + 2];
+          c.children = ue;
+        }
+        return We(e.type, A, E, F, B, Q, c);
+      }
+      function Fe(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === P;
+      }
+      var cr = ".", Or = ":";
+      function xr(e) {
+        var t = /[=:]/g, o = {
+          "=": "=0",
+          ":": "=2"
+        }, i = e.replace(t, function(c) {
+          return o[c];
+        });
+        return "$" + i;
+      }
+      var He = !1, lr = /\/+/g;
+      function ke(e) {
+        return e.replace(lr, "$&/");
+      }
+      function Ue(e, t) {
+        return typeof e == "object" && e !== null && e.key != null ? (Le(e.key), xr("" + e.key)) : t.toString(36);
+      }
+      function $e(e, t, o, i, c) {
+        var A = typeof e;
+        (A === "undefined" || A === "boolean") && (e = null);
+        var E = !1;
+        if (e === null)
+          E = !0;
+        else
+          switch (A) {
+            case "string":
+            case "number":
+              E = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case P:
+                case $:
+                  E = !0;
+              }
+          }
+        if (E) {
+          var F = e, B = c(F), Q = i === "" ? cr + Ue(F, 0) : i;
+          if (ye(B)) {
+            var ne = "";
+            Q != null && (ne = ke(Q) + "/"), $e(B, t, ne, "", function(cn) {
+              return cn;
+            });
+          } else
+            B != null && (Fe(B) && (B.key && (!F || F.key !== B.key) && Le(B.key), B = Tr(
+              B,
+              // Keep both the (mapped) and old keys if they differ, just as
+              // traverseAllChildren used to do for objects as children
+              o + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
+              (B.key && (!F || F.key !== B.key) ? (
+                // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
+                // eslint-disable-next-line react-internal/safe-string-coercion
+                ke("" + B.key) + "/"
+              ) : "") + Q
+            )), t.push(B));
+          return 1;
+        }
+        var ae, ue, de = 0, me = i === "" ? cr : i + Or;
+        if (ye(e))
+          for (var Er = 0; Er < e.length; Er++)
+            ae = e[Er], ue = me + Ue(ae, Er), de += $e(ae, t, o, ue, c);
+        else {
+          var Ur = X(e);
+          if (typeof Ur == "function") {
+            var bt = e;
+            Ur === bt.entries && (He || se("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), He = !0);
+            for (var un = Ur.call(bt), _t, sn = 0; !(_t = un.next()).done; )
+              ae = _t.value, ue = me + Ue(ae, sn++), de += $e(ae, t, o, ue, c);
+          } else if (A === "object") {
+            var Et = String(e);
+            throw new Error("Objects are not valid as a React child (found: " + (Et === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : Et) + "). If you meant to render a collection of children, use an array instead.");
+          }
+        }
+        return de;
+      }
+      function Ve(e, t, o) {
+        if (e == null)
+          return e;
+        var i = [], c = 0;
+        return $e(e, i, "", "", function(A) {
+          return t.call(o, A, c++);
+        }), i;
+      }
+      function Pr(e) {
+        var t = 0;
+        return Ve(e, function() {
+          t++;
+        }), t;
+      }
+      function fr(e, t, o) {
+        Ve(e, function() {
+          t.apply(this, arguments);
+        }, o);
+      }
+      function jr(e) {
+        return Ve(e, function(t) {
+          return t;
+        }) || [];
+      }
+      function dr(e) {
+        if (!Fe(e))
+          throw new Error("React.Children.only expected to receive a single React element child.");
+        return e;
+      }
+      function pr(e) {
+        var t = {
+          $$typeof: I,
+          // As a workaround to support multiple concurrent renderers, we categorize
+          // some renderers as primary and others as secondary. We only expect
+          // there to be two concurrent renderers at most: React Native (primary) and
+          // Fabric (secondary); React DOM (primary) and React ART (secondary).
+          // Secondary renderers store their context values on separate fields.
+          _currentValue: e,
+          _currentValue2: e,
+          // Used to track how many concurrent renderers this context currently
+          // supports within in a single renderer. Such as parallel server rendering.
+          _threadCount: 0,
+          // These are circular
+          Provider: null,
+          Consumer: null,
+          // Add these to use same hidden class in VM as ServerContext
+          _defaultValue: null,
+          _globalName: null
+        };
+        t.Provider = {
+          $$typeof: j,
+          _context: t
+        };
+        var o = !1, i = !1, c = !1;
+        {
+          var A = {
+            $$typeof: I,
+            _context: t
+          };
+          Object.defineProperties(A, {
+            Provider: {
+              get: function() {
+                return i || (i = !0, C("Rendering <Context.Consumer.Provider> is not supported and will be removed in a future major release. Did you mean to render <Context.Provider> instead?")), t.Provider;
+              },
+              set: function(E) {
+                t.Provider = E;
+              }
+            },
+            _currentValue: {
+              get: function() {
+                return t._currentValue;
+              },
+              set: function(E) {
+                t._currentValue = E;
+              }
+            },
+            _currentValue2: {
+              get: function() {
+                return t._currentValue2;
+              },
+              set: function(E) {
+                t._currentValue2 = E;
+              }
+            },
+            _threadCount: {
+              get: function() {
+                return t._threadCount;
+              },
+              set: function(E) {
+                t._threadCount = E;
+              }
+            },
+            Consumer: {
+              get: function() {
+                return o || (o = !0, C("Rendering <Context.Consumer.Consumer> is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?")), t.Consumer;
+              }
+            },
+            displayName: {
+              get: function() {
+                return t.displayName;
+              },
+              set: function(E) {
+                c || (se("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", E), c = !0);
+              }
+            }
+          }), t.Consumer = A;
+        }
+        return t._currentRenderer = null, t._currentRenderer2 = null, t;
+      }
+      var qe = -1, Xe = 0, Qe = 1, kr = 2;
+      function Ar(e) {
+        if (e._status === qe) {
+          var t = e._result, o = t();
+          if (o.then(function(A) {
+            if (e._status === Xe || e._status === qe) {
+              var E = e;
+              E._status = Qe, E._result = A;
+            }
+          }, function(A) {
+            if (e._status === Xe || e._status === qe) {
+              var E = e;
+              E._status = kr, E._result = A;
+            }
+          }), e._status === qe) {
+            var i = e;
+            i._status = Xe, i._result = o;
+          }
+        }
+        if (e._status === Qe) {
+          var c = e._result;
+          return c === void 0 && C(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`, c), "default" in c || C(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`, c), c.default;
+        } else
+          throw e._result;
+      }
+      function Ir(e) {
+        var t = {
+          // We use these fields to store the result.
+          _status: qe,
+          _result: e
+        }, o = {
+          $$typeof: ee,
+          _payload: t,
+          _init: Ar
+        };
+        {
+          var i, c;
+          Object.defineProperties(o, {
+            defaultProps: {
+              configurable: !0,
+              get: function() {
+                return i;
+              },
+              set: function(A) {
+                C("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), i = A, Object.defineProperty(o, "defaultProps", {
+                  enumerable: !0
+                });
+              }
+            },
+            propTypes: {
+              configurable: !0,
+              get: function() {
+                return c;
+              },
+              set: function(A) {
+                C("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), c = A, Object.defineProperty(o, "propTypes", {
+                  enumerable: !0
+                });
+              }
+            }
+          });
+        }
+        return o;
+      }
+      function Fr(e) {
+        e != null && e.$$typeof === q ? C("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof e != "function" ? C("forwardRef requires a render function but was given %s.", e === null ? "null" : typeof e) : e.length !== 0 && e.length !== 2 && C("forwardRef render functions accept exactly two parameters: props and ref. %s", e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."), e != null && (e.defaultProps != null || e.propTypes != null) && C("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?");
+        var t = {
+          $$typeof: T,
+          render: e
+        };
+        {
+          var o;
+          Object.defineProperty(t, "displayName", {
+            enumerable: !1,
+            configurable: !0,
+            get: function() {
+              return o;
+            },
+            set: function(i) {
+              o = i, !e.name && !e.displayName && (e.displayName = i);
+            }
+          });
+        }
+        return t;
+      }
+      var n;
+      n = Symbol.for("react.module.reference");
+      function u(e) {
+        return !!(typeof e == "string" || typeof e == "function" || e === O || e === x || le || e === D || e === S || e === W || pe || e === M || we || xe || Te || typeof e == "object" && e !== null && (e.$$typeof === ee || e.$$typeof === q || e.$$typeof === j || e.$$typeof === I || e.$$typeof === T || // This needs to include all possible module reference object
+        // types supported by any Flight configuration anywhere since
+        // we don't know which Flight build this will end up being used
+        // with.
+        e.$$typeof === n || e.getModuleId !== void 0));
+      }
+      function p(e, t) {
+        u(e) || C("memo: The first argument must be a component. Instead received: %s", e === null ? "null" : typeof e);
+        var o = {
+          $$typeof: q,
+          type: e,
+          compare: t === void 0 ? null : t
+        };
+        {
+          var i;
+          Object.defineProperty(o, "displayName", {
+            enumerable: !1,
+            configurable: !0,
+            get: function() {
+              return i;
+            },
+            set: function(c) {
+              i = c, !e.name && !e.displayName && (e.displayName = c);
+            }
+          });
+        }
+        return o;
+      }
+      function _() {
+        var e = re.current;
+        return e === null && C(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.`), e;
+      }
+      function z(e) {
+        var t = _();
+        if (e._context !== void 0) {
+          var o = e._context;
+          o.Consumer === e ? C("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?") : o.Provider === e && C("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?");
+        }
+        return t.useContext(e);
+      }
+      function J(e) {
+        var t = _();
+        return t.useState(e);
+      }
+      function V(e, t, o) {
+        var i = _();
+        return i.useReducer(e, t, o);
+      }
+      function Y(e) {
+        var t = _();
+        return t.useRef(e);
+      }
+      function he(e, t) {
+        var o = _();
+        return o.useEffect(e, t);
+      }
+      function ie(e, t) {
+        var o = _();
+        return o.useInsertionEffect(e, t);
+      }
+      function ce(e, t) {
+        var o = _();
+        return o.useLayoutEffect(e, t);
+      }
+      function _e(e, t) {
+        var o = _();
+        return o.useCallback(e, t);
+      }
+      function De(e, t) {
+        var o = _();
+        return o.useMemo(e, t);
+      }
+      function vr(e, t, o) {
+        var i = _();
+        return i.useImperativeHandle(e, t, o);
+      }
+      function Oe(e, t) {
+        {
+          var o = _();
+          return o.useDebugValue(e, t);
+        }
+      }
+      function Mt() {
+        var e = _();
+        return e.useTransition();
+      }
+      function Lt(e) {
+        var t = _();
+        return t.useDeferredValue(e);
+      }
+      function Nt() {
+        var e = _();
+        return e.useId();
+      }
+      function Yt(e, t, o) {
+        var i = _();
+        return i.useSyncExternalStore(e, t, o);
+      }
+      var er = 0, Qr, et, rt, tt, nt, at, ot;
+      function it() {
+      }
+      it.__reactDisabledLog = !0;
+      function Wt() {
+        {
+          if (er === 0) {
+            Qr = console.log, et = console.info, rt = console.warn, tt = console.error, nt = console.group, at = console.groupCollapsed, ot = console.groupEnd;
+            var e = {
+              configurable: !0,
+              enumerable: !0,
+              value: it,
+              writable: !0
+            };
+            Object.defineProperties(console, {
+              info: e,
+              log: e,
+              warn: e,
+              error: e,
+              group: e,
+              groupCollapsed: e,
+              groupEnd: e
+            });
+          }
+          er++;
+        }
+      }
+      function Ut() {
+        {
+          if (er--, er === 0) {
+            var e = {
+              configurable: !0,
+              enumerable: !0,
+              writable: !0
+            };
+            Object.defineProperties(console, {
+              log: f({}, e, {
+                value: Qr
+              }),
+              info: f({}, e, {
+                value: et
+              }),
+              warn: f({}, e, {
+                value: rt
+              }),
+              error: f({}, e, {
+                value: tt
+              }),
+              group: f({}, e, {
+                value: nt
+              }),
+              groupCollapsed: f({}, e, {
+                value: at
+              }),
+              groupEnd: f({}, e, {
+                value: ot
+              })
+            });
+          }
+          er < 0 && C("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+        }
+      }
+      var $r = fe.ReactCurrentDispatcher, Dr;
+      function yr(e, t, o) {
+        {
+          if (Dr === void 0)
+            try {
+              throw Error();
+            } catch (c) {
+              var i = c.stack.trim().match(/\n( *(at )?)/);
+              Dr = i && i[1] || "";
+            }
+          return `
+` + Dr + e;
+        }
+      }
+      var Mr = !1, hr;
+      {
+        var Vt = typeof WeakMap == "function" ? WeakMap : Map;
+        hr = new Vt();
+      }
+      function ut(e, t) {
+        if (!e || Mr)
+          return "";
+        {
+          var o = hr.get(e);
+          if (o !== void 0)
+            return o;
+        }
+        var i;
+        Mr = !0;
+        var c = Error.prepareStackTrace;
+        Error.prepareStackTrace = void 0;
+        var A;
+        A = $r.current, $r.current = null, Wt();
+        try {
+          if (t) {
+            var E = function() {
+              throw Error();
+            };
+            if (Object.defineProperty(E.prototype, "props", {
+              set: function() {
+                throw Error();
+              }
+            }), typeof Reflect == "object" && Reflect.construct) {
+              try {
+                Reflect.construct(E, []);
+              } catch (me) {
+                i = me;
+              }
+              Reflect.construct(e, [], E);
+            } else {
+              try {
+                E.call();
+              } catch (me) {
+                i = me;
+              }
+              e.call(E.prototype);
+            }
+          } else {
+            try {
+              throw Error();
+            } catch (me) {
+              i = me;
+            }
+            e();
+          }
+        } catch (me) {
+          if (me && i && typeof me.stack == "string") {
+            for (var F = me.stack.split(`
+`), B = i.stack.split(`
+`), Q = F.length - 1, ne = B.length - 1; Q >= 1 && ne >= 0 && F[Q] !== B[ne]; )
+              ne--;
+            for (; Q >= 1 && ne >= 0; Q--, ne--)
+              if (F[Q] !== B[ne]) {
+                if (Q !== 1 || ne !== 1)
+                  do
+                    if (Q--, ne--, ne < 0 || F[Q] !== B[ne]) {
+                      var ae = `
+` + F[Q].replace(" at new ", " at ");
+                      return e.displayName && ae.includes("<anonymous>") && (ae = ae.replace("<anonymous>", e.displayName)), typeof e == "function" && hr.set(e, ae), ae;
+                    }
+                  while (Q >= 1 && ne >= 0);
+                break;
+              }
+          }
+        } finally {
+          Mr = !1, $r.current = A, Ut(), Error.prepareStackTrace = c;
+        }
+        var ue = e ? e.displayName || e.name : "", de = ue ? yr(ue) : "";
+        return typeof e == "function" && hr.set(e, de), de;
+      }
+      function qt(e, t, o) {
+        return ut(e, !1);
+      }
+      function Bt(e) {
+        var t = e.prototype;
+        return !!(t && t.isReactComponent);
+      }
+      function mr(e, t, o) {
+        if (e == null)
+          return "";
+        if (typeof e == "function")
+          return ut(e, Bt(e));
+        if (typeof e == "string")
+          return yr(e);
+        switch (e) {
+          case S:
+            return yr("Suspense");
+          case W:
+            return yr("SuspenseList");
+        }
+        if (typeof e == "object")
+          switch (e.$$typeof) {
+            case T:
+              return qt(e.render);
+            case q:
+              return mr(e.type, t, o);
+            case ee: {
+              var i = e, c = i._payload, A = i._init;
+              try {
+                return mr(A(c), t, o);
+              } catch {
+              }
+            }
+          }
+        return "";
+      }
+      var st = {}, ct = fe.ReactDebugCurrentFrame;
+      function gr(e) {
+        if (e) {
+          var t = e._owner, o = mr(e.type, e._source, t ? t.type : null);
+          ct.setExtraStackFrame(o);
+        } else
+          ct.setExtraStackFrame(null);
+      }
+      function zt(e, t, o, i, c) {
+        {
+          var A = Function.call.bind(Ye);
+          for (var E in e)
+            if (A(e, E)) {
+              var F = void 0;
+              try {
+                if (typeof e[E] != "function") {
+                  var B = Error((i || "React class") + ": " + o + " type `" + E + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[E] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                  throw B.name = "Invariant Violation", B;
+                }
+                F = e[E](t, E, i, o, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+              } catch (Q) {
+                F = Q;
+              }
+              F && !(F instanceof Error) && (gr(c), C("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", i || "React class", o, E, typeof F), gr(null)), F instanceof Error && !(F.message in st) && (st[F.message] = !0, gr(c), C("Failed %s type: %s", o, F.message), gr(null));
+            }
+        }
+      }
+      function Ge(e) {
+        if (e) {
+          var t = e._owner, o = mr(e.type, e._source, t ? t.type : null);
+          Ce(o);
+        } else
+          Ce(null);
+      }
+      var Lr;
+      Lr = !1;
+      function lt() {
+        if (oe.current) {
+          var e = Pe(oe.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+      function Ht(e) {
+        if (e !== void 0) {
+          var t = e.fileName.replace(/^.*[\\\/]/, ""), o = e.lineNumber;
+          return `
+
+Check your code at ` + t + ":" + o + ".";
+        }
+        return "";
+      }
+      function Gt(e) {
+        return e != null ? Ht(e.__source) : "";
+      }
+      var ft = {};
+      function Kt(e) {
+        var t = lt();
+        if (!t) {
+          var o = typeof e == "string" ? e : e.displayName || e.name;
+          o && (t = `
+
+Check the top-level render call using <` + o + ">.");
+        }
+        return t;
+      }
+      function dt(e, t) {
+        if (!(!e._store || e._store.validated || e.key != null)) {
+          e._store.validated = !0;
+          var o = Kt(t);
+          if (!ft[o]) {
+            ft[o] = !0;
+            var i = "";
+            e && e._owner && e._owner !== oe.current && (i = " It was passed a child from " + Pe(e._owner.type) + "."), Ge(e), C('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', o, i), Ge(null);
+          }
+        }
+      }
+      function pt(e, t) {
+        if (typeof e == "object") {
+          if (ye(e))
+            for (var o = 0; o < e.length; o++) {
+              var i = e[o];
+              Fe(i) && dt(i, t);
+            }
+          else if (Fe(e))
+            e._store && (e._store.validated = !0);
+          else if (e) {
+            var c = X(e);
+            if (typeof c == "function" && c !== e.entries)
+              for (var A = c.call(e), E; !(E = A.next()).done; )
+                Fe(E.value) && dt(E.value, t);
+          }
+        }
+      }
+      function vt(e) {
+        {
+          var t = e.type;
+          if (t == null || typeof t == "string")
+            return;
+          var o;
+          if (typeof t == "function")
+            o = t.propTypes;
+          else if (typeof t == "object" && (t.$$typeof === T || // Note: Memo only checks outer props here.
+          // Inner props are checked in the reconciler.
+          t.$$typeof === q))
+            o = t.propTypes;
+          else
+            return;
+          if (o) {
+            var i = Pe(t);
+            zt(o, e.props, "prop", i, e);
+          } else if (t.PropTypes !== void 0 && !Lr) {
+            Lr = !0;
+            var c = Pe(t);
+            C("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", c || "Unknown");
+          }
+          typeof t.getDefaultProps == "function" && !t.getDefaultProps.isReactClassApproved && C("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+        }
+      }
+      function Jt(e) {
+        {
+          for (var t = Object.keys(e.props), o = 0; o < t.length; o++) {
+            var i = t[o];
+            if (i !== "children" && i !== "key") {
+              Ge(e), C("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", i), Ge(null);
+              break;
+            }
+          }
+          e.ref !== null && (Ge(e), C("Invalid attribute `ref` supplied to `React.Fragment`."), Ge(null));
+        }
+      }
+      function yt(e, t, o) {
+        var i = u(e);
+        if (!i) {
+          var c = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (c += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var A = Gt(t);
+          A ? c += A : c += lt();
+          var E;
+          e === null ? E = "null" : ye(e) ? E = "array" : e !== void 0 && e.$$typeof === P ? (E = "<" + (Pe(e.type) || "Unknown") + " />", c = " Did you accidentally export a JSX literal instead of a component?") : E = typeof e, C("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", E, c);
+        }
+        var F = wr.apply(this, arguments);
+        if (F == null)
+          return F;
+        if (i)
+          for (var B = 2; B < arguments.length; B++)
+            pt(arguments[B], e);
+        return e === O ? Jt(F) : vt(F), F;
+      }
+      var ht = !1;
+      function Zt(e) {
+        var t = yt.bind(null, e);
+        return t.type = e, ht || (ht = !0, se("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.")), Object.defineProperty(t, "type", {
+          enumerable: !1,
+          get: function() {
+            return se("Factory.type is deprecated. Access the class directly before passing it to createFactory."), Object.defineProperty(this, "type", {
+              value: e
+            }), e;
+          }
+        }), t;
+      }
+      function Xt(e, t, o) {
+        for (var i = Sr.apply(this, arguments), c = 2; c < arguments.length; c++)
+          pt(arguments[c], i.type);
+        return vt(i), i;
+      }
+      function Qt(e, t) {
+        var o = H.transition;
+        H.transition = {};
+        var i = H.transition;
+        H.transition._updatedFibers = /* @__PURE__ */ new Set();
+        try {
+          e();
+        } finally {
+          if (H.transition = o, o === null && i._updatedFibers) {
+            var c = i._updatedFibers.size;
+            c > 10 && se("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."), i._updatedFibers.clear();
+          }
+        }
+      }
+      var mt = !1, br = null;
+      function en(e) {
+        if (br === null)
+          try {
+            var t = ("require" + Math.random()).slice(0, 7), o = l && l[t];
+            br = o.call(l, "timers").setImmediate;
+          } catch {
+            br = function(c) {
+              mt === !1 && (mt = !0, typeof MessageChannel > "u" && C("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
+              var A = new MessageChannel();
+              A.port1.onmessage = c, A.port2.postMessage(void 0);
+            };
+          }
+        return br(e);
+      }
+      var Ke = 0, gt = !1;
+      function rn(e) {
+        {
+          var t = Ke;
+          Ke++, s.current === null && (s.current = []);
+          var o = s.isBatchingLegacy, i;
+          try {
+            if (s.isBatchingLegacy = !0, i = e(), !o && s.didScheduleLegacyUpdate) {
+              var c = s.current;
+              c !== null && (s.didScheduleLegacyUpdate = !1, Wr(c));
+            }
+          } catch (ue) {
+            throw _r(t), ue;
+          } finally {
+            s.isBatchingLegacy = o;
+          }
+          if (i !== null && typeof i == "object" && typeof i.then == "function") {
+            var A = i, E = !1, F = {
+              then: function(ue, de) {
+                E = !0, A.then(function(me) {
+                  _r(t), Ke === 0 ? Nr(me, ue, de) : ue(me);
+                }, function(me) {
+                  _r(t), de(me);
+                });
+              }
+            };
+            return !gt && typeof Promise < "u" && Promise.resolve().then(function() {
+            }).then(function() {
+              E || (gt = !0, C("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
+            }), F;
+          } else {
+            var B = i;
+            if (_r(t), Ke === 0) {
+              var Q = s.current;
+              Q !== null && (Wr(Q), s.current = null);
+              var ne = {
+                then: function(ue, de) {
+                  s.current === null ? (s.current = [], Nr(B, ue, de)) : ue(B);
+                }
+              };
+              return ne;
+            } else {
+              var ae = {
+                then: function(ue, de) {
+                  ue(B);
+                }
+              };
+              return ae;
+            }
+          }
+        }
+      }
+      function _r(e) {
+        e !== Ke - 1 && C("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "), Ke = e;
+      }
+      function Nr(e, t, o) {
+        {
+          var i = s.current;
+          if (i !== null)
+            try {
+              Wr(i), en(function() {
+                i.length === 0 ? (s.current = null, t(e)) : Nr(e, t, o);
+              });
+            } catch (c) {
+              o(c);
+            }
+          else
+            t(e);
+        }
+      }
+      var Yr = !1;
+      function Wr(e) {
+        if (!Yr) {
+          Yr = !0;
+          var t = 0;
+          try {
+            for (; t < e.length; t++) {
+              var o = e[t];
+              do
+                o = o(!0);
+              while (o !== null);
+            }
+            e.length = 0;
+          } catch (i) {
+            throw e = e.slice(t + 1), i;
+          } finally {
+            Yr = !1;
+          }
+        }
+      }
+      var tn = yt, nn = Xt, an = Zt, on = {
+        map: Ve,
+        forEach: fr,
+        count: Pr,
+        toArray: jr,
+        only: dr
+      };
+      h.Children = on, h.Component = d, h.Fragment = O, h.Profiler = x, h.PureComponent = k, h.StrictMode = D, h.Suspense = S, h.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = fe, h.cloneElement = nn, h.createContext = pr, h.createElement = tn, h.createFactory = an, h.createRef = ve, h.forwardRef = Fr, h.isValidElement = Fe, h.lazy = Ir, h.memo = p, h.startTransition = Qt, h.unstable_act = rn, h.useCallback = _e, h.useContext = z, h.useDebugValue = Oe, h.useDeferredValue = Lt, h.useEffect = he, h.useId = Nt, h.useImperativeHandle = vr, h.useInsertionEffect = ie, h.useLayoutEffect = ce, h.useMemo = De, h.useReducer = V, h.useRef = Y, h.useState = J, h.useSyncExternalStore = Yt, h.useTransition = Mt, h.version = N, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+    }();
+  }(nr, nr.exports)), nr.exports;
+}
+process.env.NODE_ENV === "production" ? Jr.exports = fn() : Jr.exports = dn();
+var Je = Jr.exports;
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var wt;
+function pn() {
+  if (wt)
+    return rr;
+  wt = 1;
+  var l = Je, h = Symbol.for("react.element"), N = Symbol.for("react.fragment"), P = Object.prototype.hasOwnProperty, $ = l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, O = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function D(x, j, I) {
+    var T, S = {}, W = null, q = null;
+    I !== void 0 && (W = "" + I), j.key !== void 0 && (W = "" + j.key), j.ref !== void 0 && (q = j.ref);
+    for (T in j)
+      P.call(j, T) && !O.hasOwnProperty(T) && (S[T] = j[T]);
+    if (x && x.defaultProps)
+      for (T in j = x.defaultProps, j)
+        S[T] === void 0 && (S[T] = j[T]);
+    return { $$typeof: h, type: x, key: W, ref: q, props: S, _owner: $.current };
+  }
+  return rr.Fragment = N, rr.jsx = D, rr.jsxs = D, rr;
+}
+var tr = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Tt;
+function vn() {
+  return Tt || (Tt = 1, process.env.NODE_ENV !== "production" && function() {
+    var l = Je, h = Symbol.for("react.element"), N = Symbol.for("react.portal"), P = Symbol.for("react.fragment"), $ = Symbol.for("react.strict_mode"), O = Symbol.for("react.profiler"), D = Symbol.for("react.provider"), x = Symbol.for("react.context"), j = Symbol.for("react.forward_ref"), I = Symbol.for("react.suspense"), T = Symbol.for("react.suspense_list"), S = Symbol.for("react.memo"), W = Symbol.for("react.lazy"), q = Symbol.for("react.offscreen"), ee = Symbol.iterator, M = "@@iterator";
+    function Z(n) {
+      if (n === null || typeof n != "object")
+        return null;
+      var u = ee && n[ee] || n[M];
+      return typeof u == "function" ? u : null;
+    }
+    var te = l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function X(n) {
+      {
+        for (var u = arguments.length, p = new Array(u > 1 ? u - 1 : 0), _ = 1; _ < u; _++)
+          p[_ - 1] = arguments[_];
+        re("error", n, p);
+      }
+    }
+    function re(n, u, p) {
+      {
+        var _ = te.ReactDebugCurrentFrame, z = _.getStackAddendum();
+        z !== "" && (u += "%s", p = p.concat([z]));
+        var J = p.map(function(V) {
+          return String(V);
+        });
+        J.unshift("Warning: " + u), Function.prototype.apply.call(console[n], console, J);
+      }
+    }
+    var H = !1, s = !1, oe = !1, be = !1, Ee = !1, Ce;
+    Ce = Symbol.for("react.module.reference");
+    function we(n) {
+      return !!(typeof n == "string" || typeof n == "function" || n === P || n === O || Ee || n === $ || n === I || n === T || be || n === q || H || s || oe || typeof n == "object" && n !== null && (n.$$typeof === W || n.$$typeof === S || n.$$typeof === D || n.$$typeof === x || n.$$typeof === j || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      n.$$typeof === Ce || n.getModuleId !== void 0));
+    }
+    function xe(n, u, p) {
+      var _ = n.displayName;
+      if (_)
+        return _;
+      var z = u.displayName || u.name || "";
+      return z !== "" ? p + "(" + z + ")" : p;
+    }
+    function Te(n) {
+      return n.displayName || "Context";
+    }
+    function pe(n) {
+      if (n == null)
+        return null;
+      if (typeof n.tag == "number" && X("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof n == "function")
+        return n.displayName || n.name || null;
+      if (typeof n == "string")
+        return n;
+      switch (n) {
+        case P:
+          return "Fragment";
+        case N:
+          return "Portal";
+        case O:
+          return "Profiler";
+        case $:
+          return "StrictMode";
+        case I:
+          return "Suspense";
+        case T:
+          return "SuspenseList";
+      }
+      if (typeof n == "object")
+        switch (n.$$typeof) {
+          case x:
+            var u = n;
+            return Te(u) + ".Consumer";
+          case D:
+            var p = n;
+            return Te(p._context) + ".Provider";
+          case j:
+            return xe(n, n.render, "ForwardRef");
+          case S:
+            var _ = n.displayName || null;
+            return _ !== null ? _ : pe(n.type) || "Memo";
+          case W: {
+            var z = n, J = z._payload, V = z._init;
+            try {
+              return pe(V(J));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var le = Object.assign, fe = 0, se, C, ge, Se, r, a, f;
+    function y() {
+    }
+    y.__reactDisabledLog = !0;
+    function d() {
+      {
+        if (fe === 0) {
+          se = console.log, C = console.info, ge = console.warn, Se = console.error, r = console.group, a = console.groupCollapsed, f = console.groupEnd;
+          var n = {
+            configurable: !0,
+            enumerable: !0,
+            value: y,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: n,
+            log: n,
+            warn: n,
+            error: n,
+            group: n,
+            groupCollapsed: n,
+            groupEnd: n
+          });
+        }
+        fe++;
+      }
+    }
+    function w() {
+      {
+        if (fe--, fe === 0) {
+          var n = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: le({}, n, {
+              value: se
+            }),
+            info: le({}, n, {
+              value: C
+            }),
+            warn: le({}, n, {
+              value: ge
+            }),
+            error: le({}, n, {
+              value: Se
+            }),
+            group: le({}, n, {
+              value: r
+            }),
+            groupCollapsed: le({}, n, {
+              value: a
+            }),
+            groupEnd: le({}, n, {
+              value: f
+            })
+          });
+        }
+        fe < 0 && X("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var g = te.ReactCurrentDispatcher, m;
+    function b(n, u, p) {
+      {
+        if (m === void 0)
+          try {
+            throw Error();
+          } catch (z) {
+            var _ = z.stack.trim().match(/\n( *(at )?)/);
+            m = _ && _[1] || "";
+          }
+        return `
+` + m + n;
+      }
+    }
+    var k = !1, L;
+    {
+      var ve = typeof WeakMap == "function" ? WeakMap : Map;
+      L = new ve();
+    }
+    function v(n, u) {
+      if (!n || k)
+        return "";
+      {
+        var p = L.get(n);
+        if (p !== void 0)
+          return p;
+      }
+      var _;
+      k = !0;
+      var z = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var J;
+      J = g.current, g.current = null, d();
+      try {
+        if (u) {
+          var V = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(V.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(V, []);
+            } catch (Oe) {
+              _ = Oe;
+            }
+            Reflect.construct(n, [], V);
+          } else {
+            try {
+              V.call();
+            } catch (Oe) {
+              _ = Oe;
+            }
+            n.call(V.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (Oe) {
+            _ = Oe;
+          }
+          n();
+        }
+      } catch (Oe) {
+        if (Oe && _ && typeof Oe.stack == "string") {
+          for (var Y = Oe.stack.split(`
+`), he = _.stack.split(`
+`), ie = Y.length - 1, ce = he.length - 1; ie >= 1 && ce >= 0 && Y[ie] !== he[ce]; )
+            ce--;
+          for (; ie >= 1 && ce >= 0; ie--, ce--)
+            if (Y[ie] !== he[ce]) {
+              if (ie !== 1 || ce !== 1)
+                do
+                  if (ie--, ce--, ce < 0 || Y[ie] !== he[ce]) {
+                    var _e = `
+` + Y[ie].replace(" at new ", " at ");
+                    return n.displayName && _e.includes("<anonymous>") && (_e = _e.replace("<anonymous>", n.displayName)), typeof n == "function" && L.set(n, _e), _e;
+                  }
+                while (ie >= 1 && ce >= 0);
+              break;
+            }
+        }
+      } finally {
+        k = !1, g.current = J, w(), Error.prepareStackTrace = z;
+      }
+      var De = n ? n.displayName || n.name : "", vr = De ? b(De) : "";
+      return typeof n == "function" && L.set(n, vr), vr;
+    }
+    function ye(n, u, p) {
+      return v(n, !1);
+    }
+    function Ae(n) {
+      var u = n.prototype;
+      return !!(u && u.isReactComponent);
+    }
+    function je(n, u, p) {
+      if (n == null)
+        return "";
+      if (typeof n == "function")
+        return v(n, Ae(n));
+      if (typeof n == "string")
+        return b(n);
+      switch (n) {
+        case I:
+          return b("Suspense");
+        case T:
+          return b("SuspenseList");
+      }
+      if (typeof n == "object")
+        switch (n.$$typeof) {
+          case j:
+            return ye(n.render);
+          case S:
+            return je(n.type, u, p);
+          case W: {
+            var _ = n, z = _._payload, J = _._init;
+            try {
+              return je(J(z), u, p);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var Me = Object.prototype.hasOwnProperty, Le = {}, ar = te.ReactDebugCurrentFrame;
+    function Ne(n) {
+      if (n) {
+        var u = n._owner, p = je(n.type, n._source, u ? u.type : null);
+        ar.setExtraStackFrame(p);
+      } else
+        ar.setExtraStackFrame(null);
+    }
+    function Pe(n, u, p, _, z) {
+      {
+        var J = Function.call.bind(Me);
+        for (var V in n)
+          if (J(n, V)) {
+            var Y = void 0;
+            try {
+              if (typeof n[V] != "function") {
+                var he = Error((_ || "React class") + ": " + p + " type `" + V + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof n[V] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw he.name = "Invariant Violation", he;
+              }
+              Y = n[V](u, V, _, p, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (ie) {
+              Y = ie;
+            }
+            Y && !(Y instanceof Error) && (Ne(z), X("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", _ || "React class", p, V, typeof Y), Ne(null)), Y instanceof Error && !(Y.message in Le) && (Le[Y.message] = !0, Ne(z), X("Failed %s type: %s", p, Y.message), Ne(null));
+          }
+      }
+    }
+    var Ye = Array.isArray;
+    function Be(n) {
+      return Ye(n);
+    }
+    function or(n) {
+      {
+        var u = typeof Symbol == "function" && Symbol.toStringTag, p = u && n[Symbol.toStringTag] || n.constructor.name || "Object";
+        return p;
+      }
+    }
+    function ir(n) {
+      try {
+        return ze(n), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function ze(n) {
+      return "" + n;
+    }
+    function Ze(n) {
+      if (ir(n))
+        return X("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", or(n)), ze(n);
+    }
+    var Ie = te.ReactCurrentOwner, Cr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, ur, sr, We;
+    We = {};
+    function wr(n) {
+      if (Me.call(n, "ref")) {
+        var u = Object.getOwnPropertyDescriptor(n, "ref").get;
+        if (u && u.isReactWarning)
+          return !1;
+      }
+      return n.ref !== void 0;
+    }
+    function Tr(n) {
+      if (Me.call(n, "key")) {
+        var u = Object.getOwnPropertyDescriptor(n, "key").get;
+        if (u && u.isReactWarning)
+          return !1;
+      }
+      return n.key !== void 0;
+    }
+    function Sr(n, u) {
+      if (typeof n.ref == "string" && Ie.current && u && Ie.current.stateNode !== u) {
+        var p = pe(Ie.current.type);
+        We[p] || (X('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', pe(Ie.current.type), n.ref), We[p] = !0);
+      }
+    }
+    function Fe(n, u) {
+      {
+        var p = function() {
+          ur || (ur = !0, X("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", u));
+        };
+        p.isReactWarning = !0, Object.defineProperty(n, "key", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    function cr(n, u) {
+      {
+        var p = function() {
+          sr || (sr = !0, X("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", u));
+        };
+        p.isReactWarning = !0, Object.defineProperty(n, "ref", {
+          get: p,
+          configurable: !0
+        });
+      }
+    }
+    var Or = function(n, u, p, _, z, J, V) {
+      var Y = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: h,
+        // Built-in properties that belong on the element
+        type: n,
+        key: u,
+        ref: p,
+        props: V,
+        // Record the component responsible for creating this element.
+        _owner: J
+      };
+      return Y._store = {}, Object.defineProperty(Y._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(Y, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: _
+      }), Object.defineProperty(Y, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: z
+      }), Object.freeze && (Object.freeze(Y.props), Object.freeze(Y)), Y;
+    };
+    function xr(n, u, p, _, z) {
+      {
+        var J, V = {}, Y = null, he = null;
+        p !== void 0 && (Ze(p), Y = "" + p), Tr(u) && (Ze(u.key), Y = "" + u.key), wr(u) && (he = u.ref, Sr(u, z));
+        for (J in u)
+          Me.call(u, J) && !Cr.hasOwnProperty(J) && (V[J] = u[J]);
+        if (n && n.defaultProps) {
+          var ie = n.defaultProps;
+          for (J in ie)
+            V[J] === void 0 && (V[J] = ie[J]);
+        }
+        if (Y || he) {
+          var ce = typeof n == "function" ? n.displayName || n.name || "Unknown" : n;
+          Y && Fe(V, ce), he && cr(V, ce);
+        }
+        return Or(n, Y, he, z, _, Ie.current, V);
+      }
+    }
+    var He = te.ReactCurrentOwner, lr = te.ReactDebugCurrentFrame;
+    function ke(n) {
+      if (n) {
+        var u = n._owner, p = je(n.type, n._source, u ? u.type : null);
+        lr.setExtraStackFrame(p);
+      } else
+        lr.setExtraStackFrame(null);
+    }
+    var Ue;
+    Ue = !1;
+    function $e(n) {
+      return typeof n == "object" && n !== null && n.$$typeof === h;
+    }
+    function Ve() {
+      {
+        if (He.current) {
+          var n = pe(He.current.type);
+          if (n)
+            return `
+
+Check the render method of \`` + n + "`.";
+        }
+        return "";
+      }
+    }
+    function Pr(n) {
+      {
+        if (n !== void 0) {
+          var u = n.fileName.replace(/^.*[\\\/]/, ""), p = n.lineNumber;
+          return `
+
+Check your code at ` + u + ":" + p + ".";
+        }
+        return "";
+      }
+    }
+    var fr = {};
+    function jr(n) {
+      {
+        var u = Ve();
+        if (!u) {
+          var p = typeof n == "string" ? n : n.displayName || n.name;
+          p && (u = `
+
+Check the top-level render call using <` + p + ">.");
+        }
+        return u;
+      }
+    }
+    function dr(n, u) {
+      {
+        if (!n._store || n._store.validated || n.key != null)
+          return;
+        n._store.validated = !0;
+        var p = jr(u);
+        if (fr[p])
+          return;
+        fr[p] = !0;
+        var _ = "";
+        n && n._owner && n._owner !== He.current && (_ = " It was passed a child from " + pe(n._owner.type) + "."), ke(n), X('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', p, _), ke(null);
+      }
+    }
+    function pr(n, u) {
+      {
+        if (typeof n != "object")
+          return;
+        if (Be(n))
+          for (var p = 0; p < n.length; p++) {
+            var _ = n[p];
+            $e(_) && dr(_, u);
+          }
+        else if ($e(n))
+          n._store && (n._store.validated = !0);
+        else if (n) {
+          var z = Z(n);
+          if (typeof z == "function" && z !== n.entries)
+            for (var J = z.call(n), V; !(V = J.next()).done; )
+              $e(V.value) && dr(V.value, u);
+        }
+      }
+    }
+    function qe(n) {
+      {
+        var u = n.type;
+        if (u == null || typeof u == "string")
+          return;
+        var p;
+        if (typeof u == "function")
+          p = u.propTypes;
+        else if (typeof u == "object" && (u.$$typeof === j || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        u.$$typeof === S))
+          p = u.propTypes;
+        else
+          return;
+        if (p) {
+          var _ = pe(u);
+          Pe(p, n.props, "prop", _, n);
+        } else if (u.PropTypes !== void 0 && !Ue) {
+          Ue = !0;
+          var z = pe(u);
+          X("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", z || "Unknown");
+        }
+        typeof u.getDefaultProps == "function" && !u.getDefaultProps.isReactClassApproved && X("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Xe(n) {
+      {
+        for (var u = Object.keys(n.props), p = 0; p < u.length; p++) {
+          var _ = u[p];
+          if (_ !== "children" && _ !== "key") {
+            ke(n), X("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", _), ke(null);
+            break;
+          }
+        }
+        n.ref !== null && (ke(n), X("Invalid attribute `ref` supplied to `React.Fragment`."), ke(null));
+      }
+    }
+    function Qe(n, u, p, _, z, J) {
+      {
+        var V = we(n);
+        if (!V) {
+          var Y = "";
+          (n === void 0 || typeof n == "object" && n !== null && Object.keys(n).length === 0) && (Y += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var he = Pr(z);
+          he ? Y += he : Y += Ve();
+          var ie;
+          n === null ? ie = "null" : Be(n) ? ie = "array" : n !== void 0 && n.$$typeof === h ? (ie = "<" + (pe(n.type) || "Unknown") + " />", Y = " Did you accidentally export a JSX literal instead of a component?") : ie = typeof n, X("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", ie, Y);
+        }
+        var ce = xr(n, u, p, z, J);
+        if (ce == null)
+          return ce;
+        if (V) {
+          var _e = u.children;
+          if (_e !== void 0)
+            if (_)
+              if (Be(_e)) {
+                for (var De = 0; De < _e.length; De++)
+                  pr(_e[De], n);
+                Object.freeze && Object.freeze(_e);
+              } else
+                X("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              pr(_e, n);
+        }
+        return n === P ? Xe(ce) : qe(ce), ce;
+      }
+    }
+    function kr(n, u, p) {
+      return Qe(n, u, p, !0);
+    }
+    function Ar(n, u, p) {
+      return Qe(n, u, p, !1);
+    }
+    var Ir = Ar, Fr = kr;
+    tr.Fragment = P, tr.jsx = Ir, tr.jsxs = Fr;
+  }()), tr;
+}
+process.env.NODE_ENV === "production" ? Kr.exports = pn() : Kr.exports = vn();
+var R = Kr.exports, Zr = { exports: {} }, Rr = { exports: {} }, G = {};
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var St;
+function yn() {
+  if (St)
+    return G;
+  St = 1;
+  var l = typeof Symbol == "function" && Symbol.for, h = l ? Symbol.for("react.element") : 60103, N = l ? Symbol.for("react.portal") : 60106, P = l ? Symbol.for("react.fragment") : 60107, $ = l ? Symbol.for("react.strict_mode") : 60108, O = l ? Symbol.for("react.profiler") : 60114, D = l ? Symbol.for("react.provider") : 60109, x = l ? Symbol.for("react.context") : 60110, j = l ? Symbol.for("react.async_mode") : 60111, I = l ? Symbol.for("react.concurrent_mode") : 60111, T = l ? Symbol.for("react.forward_ref") : 60112, S = l ? Symbol.for("react.suspense") : 60113, W = l ? Symbol.for("react.suspense_list") : 60120, q = l ? Symbol.for("react.memo") : 60115, ee = l ? Symbol.for("react.lazy") : 60116, M = l ? Symbol.for("react.block") : 60121, Z = l ? Symbol.for("react.fundamental") : 60117, te = l ? Symbol.for("react.responder") : 60118, X = l ? Symbol.for("react.scope") : 60119;
+  function re(s) {
+    if (typeof s == "object" && s !== null) {
+      var oe = s.$$typeof;
+      switch (oe) {
+        case h:
+          switch (s = s.type, s) {
+            case j:
+            case I:
+            case P:
+            case O:
+            case $:
+            case S:
+              return s;
+            default:
+              switch (s = s && s.$$typeof, s) {
+                case x:
+                case T:
+                case ee:
+                case q:
+                case D:
+                  return s;
+                default:
+                  return oe;
+              }
+          }
+        case N:
+          return oe;
+      }
+    }
+  }
+  function H(s) {
+    return re(s) === I;
+  }
+  return G.AsyncMode = j, G.ConcurrentMode = I, G.ContextConsumer = x, G.ContextProvider = D, G.Element = h, G.ForwardRef = T, G.Fragment = P, G.Lazy = ee, G.Memo = q, G.Portal = N, G.Profiler = O, G.StrictMode = $, G.Suspense = S, G.isAsyncMode = function(s) {
+    return H(s) || re(s) === j;
+  }, G.isConcurrentMode = H, G.isContextConsumer = function(s) {
+    return re(s) === x;
+  }, G.isContextProvider = function(s) {
+    return re(s) === D;
+  }, G.isElement = function(s) {
+    return typeof s == "object" && s !== null && s.$$typeof === h;
+  }, G.isForwardRef = function(s) {
+    return re(s) === T;
+  }, G.isFragment = function(s) {
+    return re(s) === P;
+  }, G.isLazy = function(s) {
+    return re(s) === ee;
+  }, G.isMemo = function(s) {
+    return re(s) === q;
+  }, G.isPortal = function(s) {
+    return re(s) === N;
+  }, G.isProfiler = function(s) {
+    return re(s) === O;
+  }, G.isStrictMode = function(s) {
+    return re(s) === $;
+  }, G.isSuspense = function(s) {
+    return re(s) === S;
+  }, G.isValidElementType = function(s) {
+    return typeof s == "string" || typeof s == "function" || s === P || s === I || s === O || s === $ || s === S || s === W || typeof s == "object" && s !== null && (s.$$typeof === ee || s.$$typeof === q || s.$$typeof === D || s.$$typeof === x || s.$$typeof === T || s.$$typeof === Z || s.$$typeof === te || s.$$typeof === X || s.$$typeof === M);
+  }, G.typeOf = re, G;
+}
+var K = {};
+/** @license React v16.13.1
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ot;
+function hn() {
+  return Ot || (Ot = 1, process.env.NODE_ENV !== "production" && function() {
+    var l = typeof Symbol == "function" && Symbol.for, h = l ? Symbol.for("react.element") : 60103, N = l ? Symbol.for("react.portal") : 60106, P = l ? Symbol.for("react.fragment") : 60107, $ = l ? Symbol.for("react.strict_mode") : 60108, O = l ? Symbol.for("react.profiler") : 60114, D = l ? Symbol.for("react.provider") : 60109, x = l ? Symbol.for("react.context") : 60110, j = l ? Symbol.for("react.async_mode") : 60111, I = l ? Symbol.for("react.concurrent_mode") : 60111, T = l ? Symbol.for("react.forward_ref") : 60112, S = l ? Symbol.for("react.suspense") : 60113, W = l ? Symbol.for("react.suspense_list") : 60120, q = l ? Symbol.for("react.memo") : 60115, ee = l ? Symbol.for("react.lazy") : 60116, M = l ? Symbol.for("react.block") : 60121, Z = l ? Symbol.for("react.fundamental") : 60117, te = l ? Symbol.for("react.responder") : 60118, X = l ? Symbol.for("react.scope") : 60119;
+    function re(v) {
+      return typeof v == "string" || typeof v == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      v === P || v === I || v === O || v === $ || v === S || v === W || typeof v == "object" && v !== null && (v.$$typeof === ee || v.$$typeof === q || v.$$typeof === D || v.$$typeof === x || v.$$typeof === T || v.$$typeof === Z || v.$$typeof === te || v.$$typeof === X || v.$$typeof === M);
+    }
+    function H(v) {
+      if (typeof v == "object" && v !== null) {
+        var ye = v.$$typeof;
+        switch (ye) {
+          case h:
+            var Ae = v.type;
+            switch (Ae) {
+              case j:
+              case I:
+              case P:
+              case O:
+              case $:
+              case S:
+                return Ae;
+              default:
+                var je = Ae && Ae.$$typeof;
+                switch (je) {
+                  case x:
+                  case T:
+                  case ee:
+                  case q:
+                  case D:
+                    return je;
+                  default:
+                    return ye;
+                }
+            }
+          case N:
+            return ye;
+        }
+      }
+    }
+    var s = j, oe = I, be = x, Ee = D, Ce = h, we = T, xe = P, Te = ee, pe = q, le = N, fe = O, se = $, C = S, ge = !1;
+    function Se(v) {
+      return ge || (ge = !0, console.warn("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.")), r(v) || H(v) === j;
+    }
+    function r(v) {
+      return H(v) === I;
+    }
+    function a(v) {
+      return H(v) === x;
+    }
+    function f(v) {
+      return H(v) === D;
+    }
+    function y(v) {
+      return typeof v == "object" && v !== null && v.$$typeof === h;
+    }
+    function d(v) {
+      return H(v) === T;
+    }
+    function w(v) {
+      return H(v) === P;
+    }
+    function g(v) {
+      return H(v) === ee;
+    }
+    function m(v) {
+      return H(v) === q;
+    }
+    function b(v) {
+      return H(v) === N;
+    }
+    function k(v) {
+      return H(v) === O;
+    }
+    function L(v) {
+      return H(v) === $;
+    }
+    function ve(v) {
+      return H(v) === S;
+    }
+    K.AsyncMode = s, K.ConcurrentMode = oe, K.ContextConsumer = be, K.ContextProvider = Ee, K.Element = Ce, K.ForwardRef = we, K.Fragment = xe, K.Lazy = Te, K.Memo = pe, K.Portal = le, K.Profiler = fe, K.StrictMode = se, K.Suspense = C, K.isAsyncMode = Se, K.isConcurrentMode = r, K.isContextConsumer = a, K.isContextProvider = f, K.isElement = y, K.isForwardRef = d, K.isFragment = w, K.isLazy = g, K.isMemo = m, K.isPortal = b, K.isProfiler = k, K.isStrictMode = L, K.isSuspense = ve, K.isValidElementType = re, K.typeOf = H;
+  }()), K;
+}
+var xt;
+function $t() {
+  return xt || (xt = 1, process.env.NODE_ENV === "production" ? Rr.exports = yn() : Rr.exports = hn()), Rr.exports;
+}
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var Vr, Pt;
+function mn() {
+  if (Pt)
+    return Vr;
+  Pt = 1;
+  var l = Object.getOwnPropertySymbols, h = Object.prototype.hasOwnProperty, N = Object.prototype.propertyIsEnumerable;
+  function P(O) {
+    if (O == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(O);
+  }
+  function $() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var O = new String("abc");
+      if (O[5] = "de", Object.getOwnPropertyNames(O)[0] === "5")
+        return !1;
+      for (var D = {}, x = 0; x < 10; x++)
+        D["_" + String.fromCharCode(x)] = x;
+      var j = Object.getOwnPropertyNames(D).map(function(T) {
+        return D[T];
+      });
+      if (j.join("") !== "0123456789")
+        return !1;
+      var I = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(T) {
+        I[T] = T;
+      }), Object.keys(Object.assign({}, I)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return Vr = $() ? Object.assign : function(O, D) {
+    for (var x, j = P(O), I, T = 1; T < arguments.length; T++) {
+      x = Object(arguments[T]);
+      for (var S in x)
+        h.call(x, S) && (j[S] = x[S]);
+      if (l) {
+        I = l(x);
+        for (var W = 0; W < I.length; W++)
+          N.call(x, I[W]) && (j[I[W]] = x[I[W]]);
+      }
+    }
+    return j;
+  }, Vr;
+}
+var qr, jt;
+function Xr() {
+  if (jt)
+    return qr;
+  jt = 1;
+  var l = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return qr = l, qr;
+}
+var Br, kt;
+function Dt() {
+  return kt || (kt = 1, Br = Function.call.bind(Object.prototype.hasOwnProperty)), Br;
+}
+var zr, At;
+function gn() {
+  if (At)
+    return zr;
+  At = 1;
+  var l = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var h = Xr(), N = {}, P = Dt();
+    l = function(O) {
+      var D = "Warning: " + O;
+      typeof console < "u" && console.error(D);
+      try {
+        throw new Error(D);
+      } catch {
+      }
+    };
+  }
+  function $(O, D, x, j, I) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var T in O)
+        if (P(O, T)) {
+          var S;
+          try {
+            if (typeof O[T] != "function") {
+              var W = Error(
+                (j || "React class") + ": " + x + " type `" + T + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof O[T] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw W.name = "Invariant Violation", W;
+            }
+            S = O[T](D, T, j, x, null, h);
+          } catch (ee) {
+            S = ee;
+          }
+          if (S && !(S instanceof Error) && l(
+            (j || "React class") + ": type specification of " + x + " `" + T + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof S + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), S instanceof Error && !(S.message in N)) {
+            N[S.message] = !0;
+            var q = I ? I() : "";
+            l(
+              "Failed " + x + " type: " + S.message + (q ?? "")
+            );
+          }
+        }
+    }
+  }
+  return $.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (N = {});
+  }, zr = $, zr;
+}
+var Hr, It;
+function bn() {
+  if (It)
+    return Hr;
+  It = 1;
+  var l = $t(), h = mn(), N = Xr(), P = Dt(), $ = gn(), O = function() {
+  };
+  process.env.NODE_ENV !== "production" && (O = function(x) {
+    var j = "Warning: " + x;
+    typeof console < "u" && console.error(j);
+    try {
+      throw new Error(j);
+    } catch {
+    }
+  });
+  function D() {
+    return null;
+  }
+  return Hr = function(x, j) {
+    var I = typeof Symbol == "function" && Symbol.iterator, T = "@@iterator";
+    function S(r) {
+      var a = r && (I && r[I] || r[T]);
+      if (typeof a == "function")
+        return a;
+    }
+    var W = "<<anonymous>>", q = {
+      array: te("array"),
+      bigint: te("bigint"),
+      bool: te("boolean"),
+      func: te("function"),
+      number: te("number"),
+      object: te("object"),
+      string: te("string"),
+      symbol: te("symbol"),
+      any: X(),
+      arrayOf: re,
+      element: H(),
+      elementType: s(),
+      instanceOf: oe,
+      node: we(),
+      objectOf: Ee,
+      oneOf: be,
+      oneOfType: Ce,
+      shape: Te,
+      exact: pe
+    };
+    function ee(r, a) {
+      return r === a ? r !== 0 || 1 / r === 1 / a : r !== r && a !== a;
+    }
+    function M(r, a) {
+      this.message = r, this.data = a && typeof a == "object" ? a : {}, this.stack = "";
+    }
+    M.prototype = Error.prototype;
+    function Z(r) {
+      if (process.env.NODE_ENV !== "production")
+        var a = {}, f = 0;
+      function y(w, g, m, b, k, L, ve) {
+        if (b = b || W, L = L || m, ve !== N) {
+          if (j) {
+            var v = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw v.name = "Invariant Violation", v;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var ye = b + ":" + m;
+            !a[ye] && // Avoid spamming the console because they are often not actionable except for lib authors
+            f < 3 && (O(
+              "You are manually calling a React.PropTypes validation function for the `" + L + "` prop on `" + b + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), a[ye] = !0, f++);
+          }
+        }
+        return g[m] == null ? w ? g[m] === null ? new M("The " + k + " `" + L + "` is marked as required " + ("in `" + b + "`, but its value is `null`.")) : new M("The " + k + " `" + L + "` is marked as required in " + ("`" + b + "`, but its value is `undefined`.")) : null : r(g, m, b, k, L);
+      }
+      var d = y.bind(null, !1);
+      return d.isRequired = y.bind(null, !0), d;
+    }
+    function te(r) {
+      function a(f, y, d, w, g, m) {
+        var b = f[y], k = se(b);
+        if (k !== r) {
+          var L = C(b);
+          return new M(
+            "Invalid " + w + " `" + g + "` of type " + ("`" + L + "` supplied to `" + d + "`, expected ") + ("`" + r + "`."),
+            { expectedType: r }
+          );
+        }
+        return null;
+      }
+      return Z(a);
+    }
+    function X() {
+      return Z(D);
+    }
+    function re(r) {
+      function a(f, y, d, w, g) {
+        if (typeof r != "function")
+          return new M("Property `" + g + "` of component `" + d + "` has invalid PropType notation inside arrayOf.");
+        var m = f[y];
+        if (!Array.isArray(m)) {
+          var b = se(m);
+          return new M("Invalid " + w + " `" + g + "` of type " + ("`" + b + "` supplied to `" + d + "`, expected an array."));
+        }
+        for (var k = 0; k < m.length; k++) {
+          var L = r(m, k, d, w, g + "[" + k + "]", N);
+          if (L instanceof Error)
+            return L;
+        }
+        return null;
+      }
+      return Z(a);
+    }
+    function H() {
+      function r(a, f, y, d, w) {
+        var g = a[f];
+        if (!x(g)) {
+          var m = se(g);
+          return new M("Invalid " + d + " `" + w + "` of type " + ("`" + m + "` supplied to `" + y + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return Z(r);
+    }
+    function s() {
+      function r(a, f, y, d, w) {
+        var g = a[f];
+        if (!l.isValidElementType(g)) {
+          var m = se(g);
+          return new M("Invalid " + d + " `" + w + "` of type " + ("`" + m + "` supplied to `" + y + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return Z(r);
+    }
+    function oe(r) {
+      function a(f, y, d, w, g) {
+        if (!(f[y] instanceof r)) {
+          var m = r.name || W, b = Se(f[y]);
+          return new M("Invalid " + w + " `" + g + "` of type " + ("`" + b + "` supplied to `" + d + "`, expected ") + ("instance of `" + m + "`."));
+        }
+        return null;
+      }
+      return Z(a);
+    }
+    function be(r) {
+      if (!Array.isArray(r))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? O(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : O("Invalid argument supplied to oneOf, expected an array.")), D;
+      function a(f, y, d, w, g) {
+        for (var m = f[y], b = 0; b < r.length; b++)
+          if (ee(m, r[b]))
+            return null;
+        var k = JSON.stringify(r, function(ve, v) {
+          var ye = C(v);
+          return ye === "symbol" ? String(v) : v;
+        });
+        return new M("Invalid " + w + " `" + g + "` of value `" + String(m) + "` " + ("supplied to `" + d + "`, expected one of " + k + "."));
+      }
+      return Z(a);
+    }
+    function Ee(r) {
+      function a(f, y, d, w, g) {
+        if (typeof r != "function")
+          return new M("Property `" + g + "` of component `" + d + "` has invalid PropType notation inside objectOf.");
+        var m = f[y], b = se(m);
+        if (b !== "object")
+          return new M("Invalid " + w + " `" + g + "` of type " + ("`" + b + "` supplied to `" + d + "`, expected an object."));
+        for (var k in m)
+          if (P(m, k)) {
+            var L = r(m, k, d, w, g + "." + k, N);
+            if (L instanceof Error)
+              return L;
+          }
+        return null;
+      }
+      return Z(a);
+    }
+    function Ce(r) {
+      if (!Array.isArray(r))
+        return process.env.NODE_ENV !== "production" && O("Invalid argument supplied to oneOfType, expected an instance of array."), D;
+      for (var a = 0; a < r.length; a++) {
+        var f = r[a];
+        if (typeof f != "function")
+          return O(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + ge(f) + " at index " + a + "."
+          ), D;
+      }
+      function y(d, w, g, m, b) {
+        for (var k = [], L = 0; L < r.length; L++) {
+          var ve = r[L], v = ve(d, w, g, m, b, N);
+          if (v == null)
+            return null;
+          v.data && P(v.data, "expectedType") && k.push(v.data.expectedType);
+        }
+        var ye = k.length > 0 ? ", expected one of type [" + k.join(", ") + "]" : "";
+        return new M("Invalid " + m + " `" + b + "` supplied to " + ("`" + g + "`" + ye + "."));
+      }
+      return Z(y);
+    }
+    function we() {
+      function r(a, f, y, d, w) {
+        return le(a[f]) ? null : new M("Invalid " + d + " `" + w + "` supplied to " + ("`" + y + "`, expected a ReactNode."));
+      }
+      return Z(r);
+    }
+    function xe(r, a, f, y, d) {
+      return new M(
+        (r || "React class") + ": " + a + " type `" + f + "." + y + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + d + "`."
+      );
+    }
+    function Te(r) {
+      function a(f, y, d, w, g) {
+        var m = f[y], b = se(m);
+        if (b !== "object")
+          return new M("Invalid " + w + " `" + g + "` of type `" + b + "` " + ("supplied to `" + d + "`, expected `object`."));
+        for (var k in r) {
+          var L = r[k];
+          if (typeof L != "function")
+            return xe(d, w, g, k, C(L));
+          var ve = L(m, k, d, w, g + "." + k, N);
+          if (ve)
+            return ve;
+        }
+        return null;
+      }
+      return Z(a);
+    }
+    function pe(r) {
+      function a(f, y, d, w, g) {
+        var m = f[y], b = se(m);
+        if (b !== "object")
+          return new M("Invalid " + w + " `" + g + "` of type `" + b + "` " + ("supplied to `" + d + "`, expected `object`."));
+        var k = h({}, f[y], r);
+        for (var L in k) {
+          var ve = r[L];
+          if (P(r, L) && typeof ve != "function")
+            return xe(d, w, g, L, C(ve));
+          if (!ve)
+            return new M(
+              "Invalid " + w + " `" + g + "` key `" + L + "` supplied to `" + d + "`.\nBad object: " + JSON.stringify(f[y], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(r), null, "  ")
+            );
+          var v = ve(m, L, d, w, g + "." + L, N);
+          if (v)
+            return v;
+        }
+        return null;
+      }
+      return Z(a);
+    }
+    function le(r) {
+      switch (typeof r) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !r;
+        case "object":
+          if (Array.isArray(r))
+            return r.every(le);
+          if (r === null || x(r))
+            return !0;
+          var a = S(r);
+          if (a) {
+            var f = a.call(r), y;
+            if (a !== r.entries) {
+              for (; !(y = f.next()).done; )
+                if (!le(y.value))
+                  return !1;
+            } else
+              for (; !(y = f.next()).done; ) {
+                var d = y.value;
+                if (d && !le(d[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function fe(r, a) {
+      return r === "symbol" ? !0 : a ? a["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && a instanceof Symbol : !1;
+    }
+    function se(r) {
+      var a = typeof r;
+      return Array.isArray(r) ? "array" : r instanceof RegExp ? "object" : fe(a, r) ? "symbol" : a;
+    }
+    function C(r) {
+      if (typeof r > "u" || r === null)
+        return "" + r;
+      var a = se(r);
+      if (a === "object") {
+        if (r instanceof Date)
+          return "date";
+        if (r instanceof RegExp)
+          return "regexp";
+      }
+      return a;
+    }
+    function ge(r) {
+      var a = C(r);
+      switch (a) {
+        case "array":
+        case "object":
+          return "an " + a;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + a;
+        default:
+          return a;
+      }
+    }
+    function Se(r) {
+      return !r.constructor || !r.constructor.name ? W : r.constructor.name;
+    }
+    return q.checkPropTypes = $, q.resetWarningCache = $.resetWarningCache, q.PropTypes = q, q;
+  }, Hr;
+}
+var Gr, Ft;
+function _n() {
+  if (Ft)
+    return Gr;
+  Ft = 1;
+  var l = Xr();
+  function h() {
+  }
+  function N() {
+  }
+  return N.resetWarningCache = h, Gr = function() {
+    function P(D, x, j, I, T, S) {
+      if (S !== l) {
+        var W = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw W.name = "Invariant Violation", W;
+      }
+    }
+    P.isRequired = P;
+    function $() {
+      return P;
+    }
+    var O = {
+      array: P,
+      bigint: P,
+      bool: P,
+      func: P,
+      number: P,
+      object: P,
+      string: P,
+      symbol: P,
+      any: P,
+      arrayOf: $,
+      element: P,
+      elementType: P,
+      instanceOf: $,
+      node: P,
+      objectOf: $,
+      oneOf: $,
+      oneOfType: $,
+      shape: $,
+      exact: $,
+      checkPropTypes: N,
+      resetWarningCache: h
+    };
+    return O.PropTypes = O, O;
+  }, Gr;
+}
+if (process.env.NODE_ENV !== "production") {
+  var En = $t(), Rn = !0;
+  Zr.exports = bn()(En.isElement, Rn);
+} else
+  Zr.exports = _n()();
+var Cn = Zr.exports;
+const Re = /* @__PURE__ */ ln(Cn), wn = ({ title: l = "", id: h = "", children: N = /* @__PURE__ */ R.jsx("div", {}) }) => /* @__PURE__ */ R.jsxs("div", { className: "u-accordion", children: [
+  /* @__PURE__ */ R.jsx("div", { className: "u-accordion-title", children: l }),
+  /* @__PURE__ */ R.jsx("input", { className: "u-accordion-input", type: "checkbox", id: `u-accordion${h}` }),
+  /* @__PURE__ */ R.jsx("label", { className: "u-accordion-toggle", htmlFor: `u-accordion${h}` }),
+  /* @__PURE__ */ R.jsx("div", { className: "u-accordion-content", children: N })
+] });
+wn.propTypes = {
+  title: Re.string,
+  id: Re.string,
+  children: Re.node
+};
+const Tn = ({ onClick: l, variant: h = "primary", size: N = "medium", type: P = "button", icon: $ = "", iconLeft: O = !1, iconOnly: D = !1, iconSize: x, disabled: j = !1, children: I = /* @__PURE__ */ R.jsx("span", { children: "ОК" }) }) => {
+  const T = (M) => {
+    switch (M) {
+      case "primary":
+        return "u-button";
+      case "danger":
+        return "u-button u-button-danger";
+      case "outline":
+        return "u-button u-button-outline";
+      case "danger-outline":
+        return "u-button u-button-danger-outline";
+      case "simple":
+        return "u-button u-button-simple";
+      case "text":
+        return "u-button-text";
+      case "text-danger":
+        return "u-button-text u-button-text-danger";
+      default:
+        return "u-button";
+    }
+  }, S = (M) => {
+    switch (M) {
+      case "medium":
+        return "";
+      case "small":
+        return " u-button-small";
+      default:
+        return "";
+    }
+  }, W = (M) => M ? " u-button-text-icon-left" : "", q = (M) => M ? " icon-only" : "", ee = (M) => typeof M == "number" ? `${M}px` : String(M);
+  return /* @__PURE__ */ R.jsxs(
+    "button",
+    {
+      className: `${T(h)}${S(N)}${W(O)}`,
+      type: P,
+      onClick: l,
+      disabled: j,
+      children: [
+        I,
+        " ",
+        $ && /* @__PURE__ */ R.jsx("i", { style: x && { fontSize: ee(x) }, className: `u-icon${q(D)} icon-${$}` })
+      ]
+    }
+  );
+};
+Tn.propTypes = {
+  variant: Re.oneOf(["primary", "danger", "outline", "danger-outline", "simple", "text", "text-danger"]),
+  type: Re.string,
+  size: Re.string,
+  children: Re.node,
+  onClick: Re.func,
+  icon: Re.oneOf([
+    "active",
+    "application",
+    "attention",
+    "basket",
+    "block",
+    "briefcase",
+    "calculator",
+    "calendar",
+    "catalog",
+    "chat",
+    "check",
+    "clock",
+    "cloud",
+    "copy",
+    "correct",
+    "cross",
+    "cup",
+    "directory",
+    "doc",
+    "document",
+    "documents",
+    "down",
+    "down-arrow",
+    "download",
+    "download-line",
+    "dropdown",
+    "dropdown-horisontal",
+    "entrance",
+    "extracurricular-activities",
+    "filter",
+    "filter-mobile",
+    "folder",
+    "folders",
+    "full-screen",
+    "hidden",
+    "home",
+    "img",
+    "information",
+    "jpg",
+    "left",
+    "left-arrow",
+    "letter",
+    "like",
+    "link",
+    "list-view",
+    "lk-role",
+    "minus",
+    "moderation",
+    "news",
+    "notify",
+    "ok",
+    "pdf",
+    "pencil",
+    "people",
+    "plus",
+    "png",
+    "ppt",
+    "question",
+    "rating",
+    "right",
+    "right-arrow",
+    "role",
+    "save",
+    "search",
+    "setting",
+    "settlement",
+    "sorting",
+    "star",
+    "star-top20",
+    "star-top50",
+    "submenu",
+    "svg",
+    "table-view",
+    "telephone",
+    "test-tube",
+    "top100",
+    "top20",
+    "top50",
+    "union",
+    "university",
+    "unlink",
+    "up",
+    "up-arrow",
+    "upload",
+    "user",
+    "warning",
+    "xls",
+    "zip"
+  ])
+};
+const Sn = ({ variant: l = "small-primary" }) => /* @__PURE__ */ R.jsxs(R.Fragment, { children: [
+  l === "small-primary" && /* @__PURE__ */ R.jsx("div", { className: "u-preloader-mini", children: /* @__PURE__ */ R.jsxs("svg", { className: "u-preloader-mini-container", width: "48", height: "48", viewBox: "0 0 48 48", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+    /* @__PURE__ */ R.jsx("circle", { cx: "24", cy: "24", r: "23", stroke: "#1E4391", "stroke-width": "2" }),
+    /* @__PURE__ */ R.jsx("circle", { className: "u-preloader-mini-dot", cx: "6.5", cy: "6.5", r: "6.5", fill: "#1E4391" })
+  ] }) }),
+  l === "small-special" && /* @__PURE__ */ R.jsx("div", { className: "u-preloader-mini-gradient", children: /* @__PURE__ */ R.jsxs("svg", { className: "u-preloader-mini-gradient-container", width: "48", height: "48", viewBox: "0 0 48 48", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+    /* @__PURE__ */ R.jsx("circle", { cx: "24", cy: "24", r: "23", stroke: "url(#paint0_linear_8025_35626)", "stroke-width": "2" }),
+    /* @__PURE__ */ R.jsx("circle", { className: "u-preloader-mini-dot", cx: "6.5", cy: "6.5", r: "6.5", fill: "url(#paint0_linear_8025_35627)" }),
+    /* @__PURE__ */ R.jsxs("defs", { children: [
+      /* @__PURE__ */ R.jsxs("linearGradient", { id: "paint0_linear_8025_35626", x1: "54.3387", y1: "23.9985", x2: "6", y2: "23.9985", gradientUnits: "userSpaceOnUse", children: [
+        /* @__PURE__ */ R.jsx("stop", { "stop-color": "#FF2D7F" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "0.48", "stop-color": "#FB3727" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "1", "stop-color": "#FEEA0F" })
+      ] }),
+      /* @__PURE__ */ R.jsxs("linearGradient", { id: "paint0_linear_8025_35627", x1: "0.50109", y1: "13", x2: "8.00065", y2: "0.000589107", gradientUnits: "userSpaceOnUse", children: [
+        /* @__PURE__ */ R.jsx("stop", { "stop-color": "#FF2D7F" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "0.192259", "stop-color": "#FB3727" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "1", "stop-color": "#FEEA0F" })
+      ] })
+    ] })
+  ] }) }),
+  l === "large-primary" && /* @__PURE__ */ R.jsx("div", { className: "u-preloader", children: /* @__PURE__ */ R.jsxs("svg", { className: "u-preloader-container", width: "76", height: "76", viewBox: "0 0 76 76", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+    /* @__PURE__ */ R.jsx("path", { "fill-rule": "evenodd", "clip-rule": "evenodd", d: "M38 74C57.8823 74 74 57.8823 74 38C74 18.1177 57.8823 2 38 2C18.1177 2 2 18.1177 2 38C2 57.8823 18.1177 74 38 74ZM38 76C58.9868 76 76 58.9868 76 38C76 17.0132 58.9868 0 38 0C17.0132 0 0 17.0132 0 38C0 58.9868 17.0132 76 38 76Z", fill: "#1E4391" }),
+    /* @__PURE__ */ R.jsx("path", { className: "u-preloader-dot", d: "M12.2573 17.5283C12.2573 20.0136 10.2426 22.0283 7.75732 22.0283C5.27204 22.0283 3.25732 20.0136 3.25732 17.5283C3.25732 15.043 5.27204 13.0283 7.75732 13.0283C10.2426 13.0283 12.2573 15.043 12.2573 17.5283Z", fill: "#1E4391" }),
+    /* @__PURE__ */ R.jsx("path", { className: "u-preloader-logo", d: "M52.5974 25.4219C52.9649 24.721 53.5215 24.137 54.2039 23.7362C54.8864 23.3354 55.6675 23.1338 56.4587 23.1542L56.8417 21.7254H45.4303L45.0472 23.1542C46.9626 23.1542 49.575 23.9203 49.7512 25.4219H52.5897H52.5974ZM19.543 23.1542C22.4274 23.1542 23.6456 25.1653 24.9441 27.3219L35.5588 45.525C36.0606 46.4329 36.5509 47.5322 36.5356 48.5589C36.4973 51.2403 33.0229 52.2171 30.9429 52.3167C29.4339 52.3686 27.9339 52.0642 26.5645 51.428L25.7179 52.5159C26.2121 54.6151 28.1542 57.1663 30.8242 57.1471C35.463 57.1126 37.8993 52.8721 39.7648 49.4169L43.2124 43.016L33.1838 25.8203C32.2568 24.288 33.7776 23.1618 35.3941 23.1389L35.7771 21.7139H19.9145L19.543 23.1542Z", fill: "#1E4391" })
+  ] }) }),
+  l === "large-special" && /* @__PURE__ */ R.jsx("div", { className: "u-preloader-gradient", children: /* @__PURE__ */ R.jsxs("svg", { className: "u-preloader-gradient-container", width: "76", height: "76", viewBox: "0 0 76 76", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+    /* @__PURE__ */ R.jsx("path", { "fill-rule": "evenodd", "clip-rule": "evenodd", d: "M38 74C57.8823 74 74 57.8823 74 38C74 18.1177 57.8823 2 38 2C18.1177 2 2 18.1177 2 38C2 57.8823 18.1177 74 38 74ZM38 76C58.9868 76 76 58.9868 76 38C76 17.0132 58.9868 0 38 0C17.0132 0 0 17.0132 0 38C0 58.9868 17.0132 76 38 76Z", fill: "url(#paint0_linear_1804_4939)" }),
+    /* @__PURE__ */ R.jsx("path", { className: "u-preloader-gradient-dot", d: "M12.2573 17.5283C12.2573 20.0136 10.2426 22.0283 7.75732 22.0283C5.27204 22.0283 3.25732 20.0136 3.25732 17.5283C3.25732 15.043 5.27204 13.0283 7.75732 13.0283C10.2426 13.0283 12.2573 15.043 12.2573 17.5283Z", fill: "url(#paint1_linear_1804_4939)" }),
+    /* @__PURE__ */ R.jsx("path", { className: "u-preloader-gradient-logo", d: "M52.5974 25.4219C52.9649 24.721 53.5215 24.137 54.2039 23.7362C54.8864 23.3354 55.6675 23.1338 56.4587 23.1542L56.8417 21.7254H45.4303L45.0472 23.1542C46.9626 23.1542 49.575 23.9203 49.7512 25.4219H52.5897H52.5974ZM19.543 23.1542C22.4274 23.1542 23.6456 25.1653 24.9441 27.3219L35.5588 45.525C36.0606 46.4329 36.5509 47.5322 36.5356 48.5589C36.4973 51.2403 33.0229 52.2171 30.9429 52.3167C29.4339 52.3686 27.9339 52.0642 26.5645 51.428L25.7179 52.5159C26.2121 54.6151 28.1542 57.1663 30.8242 57.1471C35.463 57.1126 37.8993 52.8721 39.7648 49.4169L43.2124 43.016L33.1838 25.8203C32.2568 24.288 33.7776 23.1618 35.3941 23.1389L35.7771 21.7139H19.9145L19.543 23.1542Z", fill: "url(#paint2_linear_1804_4939)" }),
+    /* @__PURE__ */ R.jsxs("defs", { children: [
+      /* @__PURE__ */ R.jsxs("linearGradient", { id: "paint0_linear_1804_4939", x1: "76.5363", y1: "37.9977", x2: "1.9146e-07", y2: "37.9977", gradientUnits: "userSpaceOnUse", children: [
+        /* @__PURE__ */ R.jsx("stop", { "stop-color": "#FF2D7F" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "0.48", "stop-color": "#FB3727" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "1", "stop-color": "#FEEA0F" })
+      ] }),
+      /* @__PURE__ */ R.jsxs("linearGradient", { id: "paint1_linear_1804_4939", x1: "5.06202", y1: "20.769", x2: "11.2799", y2: "12.9983", gradientUnits: "userSpaceOnUse", children: [
+        /* @__PURE__ */ R.jsx("stop", { "stop-color": "#FF2D7F" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "0.48", "stop-color": "#FB3727" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "1", "stop-color": "#FEEA0F" })
+      ] }),
+      /* @__PURE__ */ R.jsxs("linearGradient", { id: "paint2_linear_1804_4939", x1: "35.9984", y1: "21.9995", x2: "36.4978", y2: "56.9995", gradientUnits: "userSpaceOnUse", children: [
+        /* @__PURE__ */ R.jsx("stop", { "stop-color": "#FF2D7F" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "0.48", "stop-color": "#FB3727" }),
+        /* @__PURE__ */ R.jsx("stop", { offset: "1", "stop-color": "#FEEA0F" })
+      ] })
+    ] })
+  ] }) })
+] });
+Sn.propTypes = {
+  variant: Re.string
+};
+const On = ({ options: l, placeholder: h = "Не выбрано", defaultValue: N }) => {
+  const [P, $] = Je.useState(!1), [O, D] = Je.useState(N || { label: h, value: null }), [x, j] = Je.useState(!!N), I = l.map((S, W) => /* @__PURE__ */ R.jsx("div", { className: "u-selectbox-option", onClick: () => {
+    D(S), j(!0);
+  }, children: S.label }, W));
+  Je.useEffect(() => (document.addEventListener("click", T), () => document.removeEventListener("click", T)), []);
+  const T = (S) => {
+    S.target.closest(".u-selectbox") || $(!1);
+  };
+  return /* @__PURE__ */ R.jsxs("div", { className: "u-selectbox", children: [
+    /* @__PURE__ */ R.jsxs(
+      "div",
+      {
+        className: P ? "u-selectbox-select u-selectbox-select-open" : "u-selectbox-select",
+        onClick: () => {
+          $(!P);
+        },
+        children: [
+          /* @__PURE__ */ R.jsx("span", { className: "u-selectbox-select-title", children: O.label }),
+          x ? /* @__PURE__ */ R.jsx(
+            "i",
+            {
+              className: "u-selectbox-select-icon-cross",
+              onClick: (S) => {
+                D({ label: h, value: null }), j(!1), S.stopPropagation();
+              }
+            }
+          ) : /* @__PURE__ */ R.jsx(R.Fragment, {}),
+          /* @__PURE__ */ R.jsx("i", { className: "u-selectbox-select-icon-arrow" })
+        ]
+      }
+    ),
+    /* @__PURE__ */ R.jsx(
+      "div",
+      {
+        className: "u-selectbox-options",
+        onClick: () => {
+          $(!1);
+        },
+        children: I
+      }
+    )
+  ] });
+};
+On.propTypes = {
+  options: Re.array,
+  placeholder: Re.string
+};
+export {
+  wn as Accordion,
+  Tn as Button,
+  Sn as Preloader,
+  On as Select
+};