import { r as ie } from "./index.CpgBNqDC.js";
var B, V;
function Te() {
  if (V) return B;
  V = 1;
  var S = function(i) {
    return _(i) && !w(i);
  };
  function _(n) {
    return !!n && typeof n == "object";
  }
  function w(n) {
    var i = Object.prototype.toString.call(n);
    return i === "[object RegExp]" || i === "[object Date]" || y(n);
  }
  var b = typeof Symbol == "function" && Symbol.for, m = b ? Symbol.for("react.element") : 60103;
  function y(n) {
    return n.$$typeof === m;
  }
  function P(n) {
    return Array.isArray(n) ? [] : {};
  }
  function f(n, i) {
    return i.clone !== !1 && i.isMergeableObject(n) ? h(P(n), n, i) : n;
  }
  function R(n, i, v) {
    return n.concat(i).map(function(x) {
      return f(x, v);
    });
  }
  function T(n, i) {
    if (!i.customMerge)
      return h;
    var v = i.customMerge(n);
    return typeof v == "function" ? v : h;
  }
  function g(n) {
    return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(n).filter(function(i) {
      return Object.propertyIsEnumerable.call(n, i);
    }) : [];
  }
  function O(n) {
    return Object.keys(n).concat(g(n));
  }
  function j(n, i) {
    try {
      return i in n;
    } catch {
      return !1;
    }
  }
  function C(n, i) {
    return j(n, i) && !(Object.hasOwnProperty.call(n, i) && Object.propertyIsEnumerable.call(n, i));
  }
  function D(n, i, v) {
    var x = {};
    return v.isMergeableObject(n) && O(n).forEach(function(E) {
      x[E] = f(n[E], v);
    }), O(i).forEach(function(E) {
      C(n, E) || (j(n, E) && v.isMergeableObject(i[E]) ? x[E] = T(E, v)(n[E], i[E], v) : x[E] = f(i[E], v));
    }), x;
  }
  function h(n, i, v) {
    v = v || {}, v.arrayMerge = v.arrayMerge || R, v.isMergeableObject = v.isMergeableObject || S, v.cloneUnlessOtherwiseSpecified = f;
    var x = Array.isArray(i), E = Array.isArray(n), L = x === E;
    return L ? x ? v.arrayMerge(n, i, v) : D(n, i, v) : f(i, v);
  }
  h.all = function(i, v) {
    if (!Array.isArray(i))
      throw new Error("first argument should be an array");
    return i.reduce(function(x, E) {
      return h(x, E, v);
    }, {});
  };
  var A = h;
  return B = A, B;
}
var Y = { exports: {} };
var H, Z;
function de() {
  if (Z) return H;
  Z = 1;
  var S = Object.getOwnPropertySymbols, _ = Object.prototype.hasOwnProperty, w = Object.prototype.propertyIsEnumerable;
  function b(y) {
    if (y == null)
      throw new TypeError("Object.assign cannot be called with null or undefined");
    return Object(y);
  }
  function m() {
    try {
      if (!Object.assign)
        return !1;
      var y = new String("abc");
      if (y[5] = "de", Object.getOwnPropertyNames(y)[0] === "5")
        return !1;
      for (var P = {}, f = 0; f < 10; f++)
        P["_" + String.fromCharCode(f)] = f;
      var R = Object.getOwnPropertyNames(P).map(function(g) {
        return P[g];
      });
      if (R.join("") !== "0123456789")
        return !1;
      var T = {};
      return "abcdefghijklmnopqrst".split("").forEach(function(g) {
        T[g] = g;
      }), Object.keys(Object.assign({}, T)).join("") === "abcdefghijklmnopqrst";
    } catch {
      return !1;
    }
  }
  return H = m() ? Object.assign : function(y, P) {
    for (var f, R = b(y), T, g = 1; g < arguments.length; g++) {
      f = Object(arguments[g]);
      for (var O in f)
        _.call(f, O) && (R[O] = f[O]);
      if (S) {
        T = S(f);
        for (var j = 0; j < T.length; j++)
          w.call(f, T[j]) && (R[T[j]] = f[T[j]]);
      }
    }
    return R;
  }, H;
}
var J, F;
function G() {
  if (F) return J;
  F = 1;
  var S = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
  return J = S, J;
}
var z, N;
function ae() {
  return N || (N = 1, z = Function.call.bind(Object.prototype.hasOwnProperty)), z;
}
var $, ee;
function be() {
  if (ee) return $;
  ee = 1;
  var S = function() {
  };
  if (process.env.NODE_ENV !== "production") {
    var _ = /* @__PURE__ */ G(), w = {}, b = /* @__PURE__ */ ae();
    S = function(y) {
      var P = "Warning: " + y;
      typeof console < "u" && console.error(P);
      try {
        throw new Error(P);
      } catch {
      }
    };
  }
  function m(y, P, f, R, T) {
    if (process.env.NODE_ENV !== "production") {
      for (var g in y)
        if (b(y, g)) {
          var O;
          try {
            if (typeof y[g] != "function") {
              var j = Error(
                (R || "React class") + ": " + f + " type `" + g + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof y[g] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
              );
              throw j.name = "Invariant Violation", j;
            }
            O = y[g](P, g, R, f, null, _);
          } catch (D) {
            O = D;
          }
          if (O && !(O instanceof Error) && S(
            (R || "React class") + ": type specification of " + f + " `" + g + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof O + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
          ), O instanceof Error && !(O.message in w)) {
            w[O.message] = !0;
            var C = T ? T() : "";
            S(
              "Failed " + f + " type: " + O.message + (C ?? "")
            );
          }
        }
    }
  }
  return m.resetWarningCache = function() {
    process.env.NODE_ENV !== "production" && (w = {});
  }, $ = m, $;
}
var K, re;
function he() {
  if (re) return K;
  re = 1;
  var S = ie(), _ = de(), w = /* @__PURE__ */ G(), b = /* @__PURE__ */ ae(), m = /* @__PURE__ */ be(), y = function() {
  };
  process.env.NODE_ENV !== "production" && (y = function(f) {
    var R = "Warning: " + f;
    typeof console < "u" && console.error(R);
    try {
      throw new Error(R);
    } catch {
    }
  });
  function P() {
    return null;
  }
  return K = function(f, R) {
    var T = typeof Symbol == "function" && Symbol.iterator, g = "@@iterator";
    function O(e) {
      var r = e && (T && e[T] || e[g]);
      if (typeof r == "function")
        return r;
    }
    var j = "<<anonymous>>", C = {
      array: n("array"),
      bigint: n("bigint"),
      bool: n("boolean"),
      func: n("function"),
      number: n("number"),
      object: n("object"),
      string: n("string"),
      symbol: n("symbol"),
      any: i(),
      arrayOf: v,
      element: x(),
      elementType: E(),
      instanceOf: L,
      node: fe(),
      objectOf: ue,
      oneOf: oe,
      oneOfType: ce,
      shape: se,
      exact: le
    };
    function D(e, r) {
      return e === r ? e !== 0 || 1 / e === 1 / r : e !== e && r !== r;
    }
    function h(e, r) {
      this.message = e, this.data = r && typeof r == "object" ? r : {}, this.stack = "";
    }
    h.prototype = Error.prototype;
    function A(e) {
      if (process.env.NODE_ENV !== "production")
        var r = {}, c = 0;
      function o(s, a, u, l, d, p, q) {
        if (l = l || j, p = p || u, q !== w) {
          if (R) {
            var I = 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 I.name = "Invariant Violation", I;
          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
            var W = l + ":" + u;
            !r[W] && // Avoid spamming the console because they are often not actionable except for lib authors
            c < 3 && (y(
              "You are manually calling a React.PropTypes validation function for the `" + p + "` prop on `" + l + "`. 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."
            ), r[W] = !0, c++);
          }
        }
        return a[u] == null ? s ? a[u] === null ? new h("The " + d + " `" + p + "` is marked as required " + ("in `" + l + "`, but its value is `null`.")) : new h("The " + d + " `" + p + "` is marked as required in " + ("`" + l + "`, but its value is `undefined`.")) : null : e(a, u, l, d, p);
      }
      var t = o.bind(null, !1);
      return t.isRequired = o.bind(null, !0), t;
    }
    function n(e) {
      function r(c, o, t, s, a, u) {
        var l = c[o], d = M(l);
        if (d !== e) {
          var p = U(l);
          return new h(
            "Invalid " + s + " `" + a + "` of type " + ("`" + p + "` supplied to `" + t + "`, expected ") + ("`" + e + "`."),
            { expectedType: e }
          );
        }
        return null;
      }
      return A(r);
    }
    function i() {
      return A(P);
    }
    function v(e) {
      function r(c, o, t, s, a) {
        if (typeof e != "function")
          return new h("Property `" + a + "` of component `" + t + "` has invalid PropType notation inside arrayOf.");
        var u = c[o];
        if (!Array.isArray(u)) {
          var l = M(u);
          return new h("Invalid " + s + " `" + a + "` of type " + ("`" + l + "` supplied to `" + t + "`, expected an array."));
        }
        for (var d = 0; d < u.length; d++) {
          var p = e(u, d, t, s, a + "[" + d + "]", w);
          if (p instanceof Error)
            return p;
        }
        return null;
      }
      return A(r);
    }
    function x() {
      function e(r, c, o, t, s) {
        var a = r[c];
        if (!f(a)) {
          var u = M(a);
          return new h("Invalid " + t + " `" + s + "` of type " + ("`" + u + "` supplied to `" + o + "`, expected a single ReactElement."));
        }
        return null;
      }
      return A(e);
    }
    function E() {
      function e(r, c, o, t, s) {
        var a = r[c];
        if (!S.isValidElementType(a)) {
          var u = M(a);
          return new h("Invalid " + t + " `" + s + "` of type " + ("`" + u + "` supplied to `" + o + "`, expected a single ReactElement type."));
        }
        return null;
      }
      return A(e);
    }
    function L(e) {
      function r(c, o, t, s, a) {
        if (!(c[o] instanceof e)) {
          var u = e.name || j, l = ve(c[o]);
          return new h("Invalid " + s + " `" + a + "` of type " + ("`" + l + "` supplied to `" + t + "`, expected ") + ("instance of `" + u + "`."));
        }
        return null;
      }
      return A(r);
    }
    function oe(e) {
      if (!Array.isArray(e))
        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? y(
          "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])."
        ) : y("Invalid argument supplied to oneOf, expected an array.")), P;
      function r(c, o, t, s, a) {
        for (var u = c[o], l = 0; l < e.length; l++)
          if (D(u, e[l]))
            return null;
        var d = JSON.stringify(e, function(q, I) {
          var W = U(I);
          return W === "symbol" ? String(I) : I;
        });
        return new h("Invalid " + s + " `" + a + "` of value `" + String(u) + "` " + ("supplied to `" + t + "`, expected one of " + d + "."));
      }
      return A(r);
    }
    function ue(e) {
      function r(c, o, t, s, a) {
        if (typeof e != "function")
          return new h("Property `" + a + "` of component `" + t + "` has invalid PropType notation inside objectOf.");
        var u = c[o], l = M(u);
        if (l !== "object")
          return new h("Invalid " + s + " `" + a + "` of type " + ("`" + l + "` supplied to `" + t + "`, expected an object."));
        for (var d in u)
          if (b(u, d)) {
            var p = e(u, d, t, s, a + "." + d, w);
            if (p instanceof Error)
              return p;
          }
        return null;
      }
      return A(r);
    }
    function ce(e) {
      if (!Array.isArray(e))
        return process.env.NODE_ENV !== "production" && y("Invalid argument supplied to oneOfType, expected an instance of array."), P;
      for (var r = 0; r < e.length; r++) {
        var c = e[r];
        if (typeof c != "function")
          return y(
            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + ye(c) + " at index " + r + "."
          ), P;
      }
      function o(t, s, a, u, l) {
        for (var d = [], p = 0; p < e.length; p++) {
          var q = e[p], I = q(t, s, a, u, l, w);
          if (I == null)
            return null;
          I.data && b(I.data, "expectedType") && d.push(I.data.expectedType);
        }
        var W = d.length > 0 ? ", expected one of type [" + d.join(", ") + "]" : "";
        return new h("Invalid " + u + " `" + l + "` supplied to " + ("`" + a + "`" + W + "."));
      }
      return A(o);
    }
    function fe() {
      function e(r, c, o, t, s) {
        return k(r[c]) ? null : new h("Invalid " + t + " `" + s + "` supplied to " + ("`" + o + "`, expected a ReactNode."));
      }
      return A(e);
    }
    function Q(e, r, c, o, t) {
      return new h(
        (e || "React class") + ": " + r + " type `" + c + "." + o + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + t + "`."
      );
    }
    function se(e) {
      function r(c, o, t, s, a) {
        var u = c[o], l = M(u);
        if (l !== "object")
          return new h("Invalid " + s + " `" + a + "` of type `" + l + "` " + ("supplied to `" + t + "`, expected `object`."));
        for (var d in e) {
          var p = e[d];
          if (typeof p != "function")
            return Q(t, s, a, d, U(p));
          var q = p(u, d, t, s, a + "." + d, w);
          if (q)
            return q;
        }
        return null;
      }
      return A(r);
    }
    function le(e) {
      function r(c, o, t, s, a) {
        var u = c[o], l = M(u);
        if (l !== "object")
          return new h("Invalid " + s + " `" + a + "` of type `" + l + "` " + ("supplied to `" + t + "`, expected `object`."));
        var d = _({}, c[o], e);
        for (var p in d) {
          var q = e[p];
          if (b(e, p) && typeof q != "function")
            return Q(t, s, a, p, U(q));
          if (!q)
            return new h(
              "Invalid " + s + " `" + a + "` key `" + p + "` supplied to `" + t + "`.\nBad object: " + JSON.stringify(c[o], null, "  ") + `
Valid keys: ` + JSON.stringify(Object.keys(e), null, "  ")
            );
          var I = q(u, p, t, s, a + "." + p, w);
          if (I)
            return I;
        }
        return null;
      }
      return A(r);
    }
    function k(e) {
      switch (typeof e) {
        case "number":
        case "string":
        case "undefined":
          return !0;
        case "boolean":
          return !e;
        case "object":
          if (Array.isArray(e))
            return e.every(k);
          if (e === null || f(e))
            return !0;
          var r = O(e);
          if (r) {
            var c = r.call(e), o;
            if (r !== e.entries) {
              for (; !(o = c.next()).done; )
                if (!k(o.value))
                  return !1;
            } else
              for (; !(o = c.next()).done; ) {
                var t = o.value;
                if (t && !k(t[1]))
                  return !1;
              }
          } else
            return !1;
          return !0;
        default:
          return !1;
      }
    }
    function pe(e, r) {
      return e === "symbol" ? !0 : r ? r["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && r instanceof Symbol : !1;
    }
    function M(e) {
      var r = typeof e;
      return Array.isArray(e) ? "array" : e instanceof RegExp ? "object" : pe(r, e) ? "symbol" : r;
    }
    function U(e) {
      if (typeof e > "u" || e === null)
        return "" + e;
      var r = M(e);
      if (r === "object") {
        if (e instanceof Date)
          return "date";
        if (e instanceof RegExp)
          return "regexp";
      }
      return r;
    }
    function ye(e) {
      var r = U(e);
      switch (r) {
        case "array":
        case "object":
          return "an " + r;
        case "boolean":
        case "date":
        case "regexp":
          return "a " + r;
        default:
          return r;
      }
    }
    function ve(e) {
      return !e.constructor || !e.constructor.name ? j : e.constructor.name;
    }
    return C.checkPropTypes = m, C.resetWarningCache = m.resetWarningCache, C.PropTypes = C, C;
  }, K;
}
var X, ne;
function ge() {
  if (ne) return X;
  ne = 1;
  var S = /* @__PURE__ */ G();
  function _() {
  }
  function w() {
  }
  return w.resetWarningCache = _, X = function() {
    function b(P, f, R, T, g, O) {
      if (O !== S) {
        var j = 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 j.name = "Invariant Violation", j;
      }
    }
    b.isRequired = b;
    function m() {
      return b;
    }
    var y = {
      array: b,
      bigint: b,
      bool: b,
      func: b,
      number: b,
      object: b,
      string: b,
      symbol: b,
      any: b,
      arrayOf: m,
      element: b,
      elementType: b,
      instanceOf: m,
      node: b,
      objectOf: m,
      oneOf: m,
      oneOfType: m,
      shape: m,
      exact: m,
      checkPropTypes: w,
      resetWarningCache: _
    };
    return y.PropTypes = y, y;
  }, X;
}
var te;
function je() {
  if (te) return Y.exports;
  if (te = 1, process.env.NODE_ENV !== "production") {
    var S = ie(), _ = !0;
    Y.exports = /* @__PURE__ */ he()(S.isElement, _);
  } else
    Y.exports = /* @__PURE__ */ ge()();
  return Y.exports;
}
export {
  je as a,
  Te as r
};
