@tencentcloud/chat-uikit-react 2.3.1 → 3.0.1

package/dist/external_modules/react-vendors-3raCpd-g.js

@@ -0,0 +1,1238 @@
+import { g as Ye } from "./classnames-HRMVOjAa.js";
+import V from "react";
+import Q from "react-dom";
+var he = { exports: {} }, ee = { exports: {} }, S = {};
+/** @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 Te;
+function We() {
+  if (Te) return S;
+  Te = 1;
+  var r = typeof Symbol == "function" && Symbol.for, u = r ? Symbol.for("react.element") : 60103, l = r ? Symbol.for("react.portal") : 60106, e = r ? Symbol.for("react.fragment") : 60107, i = r ? Symbol.for("react.strict_mode") : 60108, t = r ? Symbol.for("react.profiler") : 60114, a = r ? Symbol.for("react.provider") : 60109, n = r ? Symbol.for("react.context") : 60110, f = r ? Symbol.for("react.async_mode") : 60111, p = r ? Symbol.for("react.concurrent_mode") : 60111, v = r ? Symbol.for("react.forward_ref") : 60112, E = r ? Symbol.for("react.suspense") : 60113, P = r ? Symbol.for("react.suspense_list") : 60120, A = r ? Symbol.for("react.memo") : 60115, M = r ? Symbol.for("react.lazy") : 60116, w = r ? Symbol.for("react.block") : 60121, I = r ? Symbol.for("react.fundamental") : 60117, D = r ? Symbol.for("react.responder") : 60118, B = r ? Symbol.for("react.scope") : 60119;
+  function $(c) {
+    if (typeof c == "object" && c !== null) {
+      var Y = c.$$typeof;
+      switch (Y) {
+        case u:
+          switch (c = c.type, c) {
+            case f:
+            case p:
+            case e:
+            case t:
+            case i:
+            case E:
+              return c;
+            default:
+              switch (c = c && c.$$typeof, c) {
+                case n:
+                case v:
+                case M:
+                case A:
+                case a:
+                  return c;
+                default:
+                  return Y;
+              }
+          }
+        case l:
+          return Y;
+      }
+    }
+  }
+  function N(c) {
+    return $(c) === p;
+  }
+  return S.AsyncMode = f, S.ConcurrentMode = p, S.ContextConsumer = n, S.ContextProvider = a, S.Element = u, S.ForwardRef = v, S.Fragment = e, S.Lazy = M, S.Memo = A, S.Portal = l, S.Profiler = t, S.StrictMode = i, S.Suspense = E, S.isAsyncMode = function(c) {
+    return N(c) || $(c) === f;
+  }, S.isConcurrentMode = N, S.isContextConsumer = function(c) {
+    return $(c) === n;
+  }, S.isContextProvider = function(c) {
+    return $(c) === a;
+  }, S.isElement = function(c) {
+    return typeof c == "object" && c !== null && c.$$typeof === u;
+  }, S.isForwardRef = function(c) {
+    return $(c) === v;
+  }, S.isFragment = function(c) {
+    return $(c) === e;
+  }, S.isLazy = function(c) {
+    return $(c) === M;
+  }, S.isMemo = function(c) {
+    return $(c) === A;
+  }, S.isPortal = function(c) {
+    return $(c) === l;
+  }, S.isProfiler = function(c) {
+    return $(c) === t;
+  }, S.isStrictMode = function(c) {
+    return $(c) === i;
+  }, S.isSuspense = function(c) {
+    return $(c) === E;
+  }, S.isValidElementType = function(c) {
+    return typeof c == "string" || typeof c == "function" || c === e || c === p || c === t || c === i || c === E || c === P || typeof c == "object" && c !== null && (c.$$typeof === M || c.$$typeof === A || c.$$typeof === a || c.$$typeof === n || c.$$typeof === v || c.$$typeof === I || c.$$typeof === D || c.$$typeof === B || c.$$typeof === w);
+  }, S.typeOf = $, S;
+}
+var _ = {};
+/** @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 Ce;
+function Ue() {
+  return Ce || (Ce = 1, process.env.NODE_ENV !== "production" && function() {
+    var r = typeof Symbol == "function" && Symbol.for, u = r ? Symbol.for("react.element") : 60103, l = r ? Symbol.for("react.portal") : 60106, e = r ? Symbol.for("react.fragment") : 60107, i = r ? Symbol.for("react.strict_mode") : 60108, t = r ? Symbol.for("react.profiler") : 60114, a = r ? Symbol.for("react.provider") : 60109, n = r ? Symbol.for("react.context") : 60110, f = r ? Symbol.for("react.async_mode") : 60111, p = r ? Symbol.for("react.concurrent_mode") : 60111, v = r ? Symbol.for("react.forward_ref") : 60112, E = r ? Symbol.for("react.suspense") : 60113, P = r ? Symbol.for("react.suspense_list") : 60120, A = r ? Symbol.for("react.memo") : 60115, M = r ? Symbol.for("react.lazy") : 60116, w = r ? Symbol.for("react.block") : 60121, I = r ? Symbol.for("react.fundamental") : 60117, D = r ? Symbol.for("react.responder") : 60118, B = r ? Symbol.for("react.scope") : 60119;
+    function $(s) {
+      return typeof s == "string" || typeof s == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      s === e || s === p || s === t || s === i || s === E || s === P || typeof s == "object" && s !== null && (s.$$typeof === M || s.$$typeof === A || s.$$typeof === a || s.$$typeof === n || s.$$typeof === v || s.$$typeof === I || s.$$typeof === D || s.$$typeof === B || s.$$typeof === w);
+    }
+    function N(s) {
+      if (typeof s == "object" && s !== null) {
+        var L = s.$$typeof;
+        switch (L) {
+          case u:
+            var Z = s.type;
+            switch (Z) {
+              case f:
+              case p:
+              case e:
+              case t:
+              case i:
+              case E:
+                return Z;
+              default:
+                var xe = Z && Z.$$typeof;
+                switch (xe) {
+                  case n:
+                  case v:
+                  case M:
+                  case A:
+                  case a:
+                    return xe;
+                  default:
+                    return L;
+                }
+            }
+          case l:
+            return L;
+        }
+      }
+    }
+    var c = f, Y = p, re = n, ne = a, oe = u, ie = v, J = e, ae = M, se = A, z = l, ue = t, k = i, W = E, K = !1;
+    function ce(s) {
+      return K || (K = !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.")), o(s) || N(s) === f;
+    }
+    function o(s) {
+      return N(s) === p;
+    }
+    function d(s) {
+      return N(s) === n;
+    }
+    function x(s) {
+      return N(s) === a;
+    }
+    function g(s) {
+      return typeof s == "object" && s !== null && s.$$typeof === u;
+    }
+    function h(s) {
+      return N(s) === v;
+    }
+    function T(s) {
+      return N(s) === e;
+    }
+    function m(s) {
+      return N(s) === M;
+    }
+    function b(s) {
+      return N(s) === A;
+    }
+    function C(s) {
+      return N(s) === l;
+    }
+    function R(s) {
+      return N(s) === t;
+    }
+    function O(s) {
+      return N(s) === i;
+    }
+    function j(s) {
+      return N(s) === E;
+    }
+    _.AsyncMode = c, _.ConcurrentMode = Y, _.ContextConsumer = re, _.ContextProvider = ne, _.Element = oe, _.ForwardRef = ie, _.Fragment = J, _.Lazy = ae, _.Memo = se, _.Portal = z, _.Profiler = ue, _.StrictMode = k, _.Suspense = W, _.isAsyncMode = ce, _.isConcurrentMode = o, _.isContextConsumer = d, _.isContextProvider = x, _.isElement = g, _.isForwardRef = h, _.isFragment = T, _.isLazy = m, _.isMemo = b, _.isPortal = C, _.isProfiler = R, _.isStrictMode = O, _.isSuspense = j, _.isValidElementType = $, _.typeOf = N;
+  }()), _;
+}
+var Oe;
+function Ie() {
+  return Oe || (Oe = 1, process.env.NODE_ENV === "production" ? ee.exports = We() : ee.exports = Ue()), ee.exports;
+}
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var fe, Se;
+function Fe() {
+  if (Se) return fe;
+  Se = 1;
+  var r = Object.getOwnPropertySymbols, u = Object.prototype.hasOwnProperty, l = Object.prototype.propertyIsEnumerable;
+  function e(t) {
+    if (t == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(t);
+  }
+  function i() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var t = new String("abc");
+      if (t[5] = "de", Object.getOwnPropertyNames(t)[0] === "5")
+        return !1;
+      for (var a = {}, n = 0; n < 10; n++)
+        a["_" + String.fromCharCode(n)] = n;
+      var f = Object.getOwnPropertyNames(a).map(function(v) {
+        return a[v];
+      });
+      if (f.join("") !== "0123456789")
+        return !1;
+      var p = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(v) {
+        p[v] = v;
+      }), Object.keys(Object.assign({}, p)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return fe = i() ? Object.assign : function(t, a) {
+    for (var n, f = e(t), p, v = 1; v < arguments.length; v++) {
+      n = Object(arguments[v]);
+      for (var E in n)
+        u.call(n, E) && (f[E] = n[E]);
+      if (r) {
+        p = r(n);
+        for (var P = 0; P < p.length; P++)
+          l.call(n, p[P]) && (f[p[P]] = n[p[P]]);
+      }
+    }
+    return f;
+  }, fe;
+}
+var le, _e;
+function be() {
+  if (_e) return le;
+  _e = 1;
+  var r = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return le = r, le;
+}
+var pe, Re;
+function je() {
+  return Re || (Re = 1, pe = Function.call.bind(Object.prototype.hasOwnProperty)), pe;
+}
+var de, Pe;
+function Ve() {
+  if (Pe) return de;
+  Pe = 1;
+  var r = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var u = be(), l = {}, e = je();
+    r = function(t) {
+      var a = "Warning: " + t;
+      typeof console < "u" && console.error(a);
+      try {
+        throw new Error(a);
+      } catch {
+      }
+    };
+  }
+  function i(t, a, n, f, p) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var v in t)
+        if (e(t, v)) {
+          var E;
+          try {
+            if (typeof t[v] != "function") {
+              var P = Error(
+                (f || "React class") + ": " + n + " type `" + v + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof t[v] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw P.name = "Invariant Violation", P;
+            }
+            E = t[v](a, v, f, n, null, u);
+          } catch (M) {
+            E = M;
+          }
+          if (E && !(E instanceof Error) && r(
+            (f || "React class") + ": type specification of " + n + " `" + v + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof E + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), E instanceof Error && !(E.message in l)) {
+            l[E.message] = !0;
+            var A = p ? p() : "";
+            r(
+              "Failed " + n + " type: " + E.message + (A ?? "")
+            );
+          }
+        }
+    }
+  }
+  return i.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (l = {});
+  }, de = i, de;
+}
+var ve, we;
+function ze() {
+  if (we) return ve;
+  we = 1;
+  var r = Ie(), u = Fe(), l = be(), e = je(), i = Ve(), t = function() {
+  };
+  process.env.NODE_ENV !== "production" && (t = function(n) {
+    var f = "Warning: " + n;
+    typeof console < "u" && console.error(f);
+    try {
+      throw new Error(f);
+    } catch {
+    }
+  });
+  function a() {
+    return null;
+  }
+  return ve = function(n, f) {
+    var p = typeof Symbol == "function" && Symbol.iterator, v = "@@iterator";
+    function E(o) {
+      var d = o && (p && o[p] || o[v]);
+      if (typeof d == "function")
+        return d;
+    }
+    var P = "<<anonymous>>", A = {
+      array: D("array"),
+      bigint: D("bigint"),
+      bool: D("boolean"),
+      func: D("function"),
+      number: D("number"),
+      object: D("object"),
+      string: D("string"),
+      symbol: D("symbol"),
+      any: B(),
+      arrayOf: $,
+      element: N(),
+      elementType: c(),
+      instanceOf: Y,
+      node: ie(),
+      objectOf: ne,
+      oneOf: re,
+      oneOfType: oe,
+      shape: ae,
+      exact: se
+    };
+    function M(o, d) {
+      return o === d ? o !== 0 || 1 / o === 1 / d : o !== o && d !== d;
+    }
+    function w(o, d) {
+      this.message = o, this.data = d && typeof d == "object" ? d : {}, this.stack = "";
+    }
+    w.prototype = Error.prototype;
+    function I(o) {
+      if (process.env.NODE_ENV !== "production")
+        var d = {}, x = 0;
+      function g(T, m, b, C, R, O, j) {
+        if (C = C || P, O = O || b, j !== l) {
+          if (f) {
+            var s = 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 s.name = "Invariant Violation", s;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var L = C + ":" + b;
+            !d[L] && // Avoid spamming the console because they are often not actionable except for lib authors
+            x < 3 && (t(
+              "You are manually calling a React.PropTypes validation function for the `" + O + "` prop on `" + C + "`. 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."
+            ), d[L] = !0, x++);
+          }
+        }
+        return m[b] == null ? T ? m[b] === null ? new w("The " + R + " `" + O + "` is marked as required " + ("in `" + C + "`, but its value is `null`.")) : new w("The " + R + " `" + O + "` is marked as required in " + ("`" + C + "`, but its value is `undefined`.")) : null : o(m, b, C, R, O);
+      }
+      var h = g.bind(null, !1);
+      return h.isRequired = g.bind(null, !0), h;
+    }
+    function D(o) {
+      function d(x, g, h, T, m, b) {
+        var C = x[g], R = k(C);
+        if (R !== o) {
+          var O = W(C);
+          return new w(
+            "Invalid " + T + " `" + m + "` of type " + ("`" + O + "` supplied to `" + h + "`, expected ") + ("`" + o + "`."),
+            { expectedType: o }
+          );
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function B() {
+      return I(a);
+    }
+    function $(o) {
+      function d(x, g, h, T, m) {
+        if (typeof o != "function")
+          return new w("Property `" + m + "` of component `" + h + "` has invalid PropType notation inside arrayOf.");
+        var b = x[g];
+        if (!Array.isArray(b)) {
+          var C = k(b);
+          return new w("Invalid " + T + " `" + m + "` of type " + ("`" + C + "` supplied to `" + h + "`, expected an array."));
+        }
+        for (var R = 0; R < b.length; R++) {
+          var O = o(b, R, h, T, m + "[" + R + "]", l);
+          if (O instanceof Error)
+            return O;
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function N() {
+      function o(d, x, g, h, T) {
+        var m = d[x];
+        if (!n(m)) {
+          var b = k(m);
+          return new w("Invalid " + h + " `" + T + "` of type " + ("`" + b + "` supplied to `" + g + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return I(o);
+    }
+    function c() {
+      function o(d, x, g, h, T) {
+        var m = d[x];
+        if (!r.isValidElementType(m)) {
+          var b = k(m);
+          return new w("Invalid " + h + " `" + T + "` of type " + ("`" + b + "` supplied to `" + g + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return I(o);
+    }
+    function Y(o) {
+      function d(x, g, h, T, m) {
+        if (!(x[g] instanceof o)) {
+          var b = o.name || P, C = ce(x[g]);
+          return new w("Invalid " + T + " `" + m + "` of type " + ("`" + C + "` supplied to `" + h + "`, expected ") + ("instance of `" + b + "`."));
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function re(o) {
+      if (!Array.isArray(o))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? t(
+          "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])."
+        ) : t("Invalid argument supplied to oneOf, expected an array.")), a;
+      function d(x, g, h, T, m) {
+        for (var b = x[g], C = 0; C < o.length; C++)
+          if (M(b, o[C]))
+            return null;
+        var R = JSON.stringify(o, function(j, s) {
+          var L = W(s);
+          return L === "symbol" ? String(s) : s;
+        });
+        return new w("Invalid " + T + " `" + m + "` of value `" + String(b) + "` " + ("supplied to `" + h + "`, expected one of " + R + "."));
+      }
+      return I(d);
+    }
+    function ne(o) {
+      function d(x, g, h, T, m) {
+        if (typeof o != "function")
+          return new w("Property `" + m + "` of component `" + h + "` has invalid PropType notation inside objectOf.");
+        var b = x[g], C = k(b);
+        if (C !== "object")
+          return new w("Invalid " + T + " `" + m + "` of type " + ("`" + C + "` supplied to `" + h + "`, expected an object."));
+        for (var R in b)
+          if (e(b, R)) {
+            var O = o(b, R, h, T, m + "." + R, l);
+            if (O instanceof Error)
+              return O;
+          }
+        return null;
+      }
+      return I(d);
+    }
+    function oe(o) {
+      if (!Array.isArray(o))
+        return process.env.NODE_ENV !== "production" && t("Invalid argument supplied to oneOfType, expected an instance of array."), a;
+      for (var d = 0; d < o.length; d++) {
+        var x = o[d];
+        if (typeof x != "function")
+          return t(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + K(x) + " at index " + d + "."
+          ), a;
+      }
+      function g(h, T, m, b, C) {
+        for (var R = [], O = 0; O < o.length; O++) {
+          var j = o[O], s = j(h, T, m, b, C, l);
+          if (s == null)
+            return null;
+          s.data && e(s.data, "expectedType") && R.push(s.data.expectedType);
+        }
+        var L = R.length > 0 ? ", expected one of type [" + R.join(", ") + "]" : "";
+        return new w("Invalid " + b + " `" + C + "` supplied to " + ("`" + m + "`" + L + "."));
+      }
+      return I(g);
+    }
+    function ie() {
+      function o(d, x, g, h, T) {
+        return z(d[x]) ? null : new w("Invalid " + h + " `" + T + "` supplied to " + ("`" + g + "`, expected a ReactNode."));
+      }
+      return I(o);
+    }
+    function J(o, d, x, g, h) {
+      return new w(
+        (o || "React class") + ": " + d + " type `" + x + "." + g + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + h + "`."
+      );
+    }
+    function ae(o) {
+      function d(x, g, h, T, m) {
+        var b = x[g], C = k(b);
+        if (C !== "object")
+          return new w("Invalid " + T + " `" + m + "` of type `" + C + "` " + ("supplied to `" + h + "`, expected `object`."));
+        for (var R in o) {
+          var O = o[R];
+          if (typeof O != "function")
+            return J(h, T, m, R, W(O));
+          var j = O(b, R, h, T, m + "." + R, l);
+          if (j)
+            return j;
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function se(o) {
+      function d(x, g, h, T, m) {
+        var b = x[g], C = k(b);
+        if (C !== "object")
+          return new w("Invalid " + T + " `" + m + "` of type `" + C + "` " + ("supplied to `" + h + "`, expected `object`."));
+        var R = u({}, x[g], o);
+        for (var O in R) {
+          var j = o[O];
+          if (e(o, O) && typeof j != "function")
+            return J(h, T, m, O, W(j));
+          if (!j)
+            return new w(
+              "Invalid " + T + " `" + m + "` key `" + O + "` supplied to `" + h + "`.\nBad object: " + JSON.stringify(x[g], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(o), null, "  ")
+            );
+          var s = j(b, O, h, T, m + "." + O, l);
+          if (s)
+            return s;
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function z(o) {
+      switch (typeof o) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !o;
+        case "object":
+          if (Array.isArray(o))
+            return o.every(z);
+          if (o === null || n(o))
+            return !0;
+          var d = E(o);
+          if (d) {
+            var x = d.call(o), g;
+            if (d !== o.entries) {
+              for (; !(g = x.next()).done; )
+                if (!z(g.value))
+                  return !1;
+            } else
+              for (; !(g = x.next()).done; ) {
+                var h = g.value;
+                if (h && !z(h[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function ue(o, d) {
+      return o === "symbol" ? !0 : d ? d["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && d instanceof Symbol : !1;
+    }
+    function k(o) {
+      var d = typeof o;
+      return Array.isArray(o) ? "array" : o instanceof RegExp ? "object" : ue(d, o) ? "symbol" : d;
+    }
+    function W(o) {
+      if (typeof o > "u" || o === null)
+        return "" + o;
+      var d = k(o);
+      if (d === "object") {
+        if (o instanceof Date)
+          return "date";
+        if (o instanceof RegExp)
+          return "regexp";
+      }
+      return d;
+    }
+    function K(o) {
+      var d = W(o);
+      switch (d) {
+        case "array":
+        case "object":
+          return "an " + d;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + d;
+        default:
+          return d;
+      }
+    }
+    function ce(o) {
+      return !o.constructor || !o.constructor.name ? P : o.constructor.name;
+    }
+    return A.checkPropTypes = i, A.resetWarningCache = i.resetWarningCache, A.PropTypes = A, A;
+  }, ve;
+}
+var ye, Ae;
+function Ge() {
+  if (Ae) return ye;
+  Ae = 1;
+  var r = be();
+  function u() {
+  }
+  function l() {
+  }
+  return l.resetWarningCache = u, ye = function() {
+    function e(a, n, f, p, v, E) {
+      if (E !== r) {
+        var P = 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 P.name = "Invariant Violation", P;
+      }
+    }
+    e.isRequired = e;
+    function i() {
+      return e;
+    }
+    var t = {
+      array: e,
+      bigint: e,
+      bool: e,
+      func: e,
+      number: e,
+      object: e,
+      string: e,
+      symbol: e,
+      any: e,
+      arrayOf: i,
+      element: e,
+      elementType: e,
+      instanceOf: i,
+      node: e,
+      objectOf: i,
+      oneOf: i,
+      oneOfType: i,
+      shape: i,
+      exact: i,
+      checkPropTypes: l,
+      resetWarningCache: u
+    };
+    return t.PropTypes = t, t;
+  }, ye;
+}
+if (process.env.NODE_ENV !== "production") {
+  var Xe = Ie(), Be = !0;
+  he.exports = ze()(Xe.isElement, Be);
+} else
+  he.exports = Ge()();
+var He = he.exports;
+const y = /* @__PURE__ */ Ye(He);
+function te() {
+  return te = Object.assign ? Object.assign.bind() : function(r) {
+    for (var u = 1; u < arguments.length; u++) {
+      var l = arguments[u];
+      for (var e in l) ({}).hasOwnProperty.call(l, e) && (r[e] = l[e]);
+    }
+    return r;
+  }, te.apply(null, arguments);
+}
+function Me(r, u) {
+  if (r == null) return {};
+  var l = {};
+  for (var e in r) if ({}.hasOwnProperty.call(r, e)) {
+    if (u.indexOf(e) !== -1) continue;
+    l[e] = r[e];
+  }
+  return l;
+}
+function me(r, u) {
+  return me = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(l, e) {
+    return l.__proto__ = e, l;
+  }, me(r, u);
+}
+function De(r, u) {
+  r.prototype = Object.create(u.prototype), r.prototype.constructor = r, me(r, u);
+}
+function Je(r, u) {
+  return r.classList ? !!u && r.classList.contains(u) : (" " + (r.className.baseVal || r.className) + " ").indexOf(" " + u + " ") !== -1;
+}
+function Ke(r, u) {
+  r.classList ? r.classList.add(u) : Je(r, u) || (typeof r.className == "string" ? r.className = r.className + " " + u : r.setAttribute("class", (r.className && r.className.baseVal || "") + " " + u));
+}
+function Ne(r, u) {
+  return r.replace(new RegExp("(^|\\s)" + u + "(?:\\s|$)", "g"), "$1").replace(/\s+/g, " ").replace(/^\s*|\s*$/g, "");
+}
+function Ze(r, u) {
+  r.classList ? r.classList.remove(u) : typeof r.className == "string" ? r.className = Ne(r.className, u) : r.setAttribute("class", Ne(r.className && r.className.baseVal || "", u));
+}
+const $e = {
+  disabled: !1
+};
+var Qe = process.env.NODE_ENV !== "production" ? y.oneOfType([y.number, y.shape({
+  enter: y.number,
+  exit: y.number,
+  appear: y.number
+}).isRequired]) : null, et = process.env.NODE_ENV !== "production" ? y.oneOfType([y.string, y.shape({
+  enter: y.string,
+  exit: y.string,
+  active: y.string
+}), y.shape({
+  enter: y.string,
+  enterDone: y.string,
+  enterActive: y.string,
+  exit: y.string,
+  exitDone: y.string,
+  exitActive: y.string
+})]) : null;
+const ke = V.createContext(null);
+var Le = function(u) {
+  return u.scrollTop;
+}, H = "unmounted", U = "exited", F = "entering", X = "entered", ge = "exiting", q = /* @__PURE__ */ function(r) {
+  De(u, r);
+  function u(e, i) {
+    var t;
+    t = r.call(this, e, i) || this;
+    var a = i, n = a && !a.isMounting ? e.enter : e.appear, f;
+    return t.appearStatus = null, e.in ? n ? (f = U, t.appearStatus = F) : f = X : e.unmountOnExit || e.mountOnEnter ? f = H : f = U, t.state = {
+      status: f
+    }, t.nextCallback = null, t;
+  }
+  u.getDerivedStateFromProps = function(i, t) {
+    var a = i.in;
+    return a && t.status === H ? {
+      status: U
+    } : null;
+  };
+  var l = u.prototype;
+  return l.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, l.componentDidUpdate = function(i) {
+    var t = null;
+    if (i !== this.props) {
+      var a = this.state.status;
+      this.props.in ? a !== F && a !== X && (t = F) : (a === F || a === X) && (t = ge);
+    }
+    this.updateStatus(!1, t);
+  }, l.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, l.getTimeouts = function() {
+    var i = this.props.timeout, t, a, n;
+    return t = a = n = i, i != null && typeof i != "number" && (t = i.exit, a = i.enter, n = i.appear !== void 0 ? i.appear : a), {
+      exit: t,
+      enter: a,
+      appear: n
+    };
+  }, l.updateStatus = function(i, t) {
+    if (i === void 0 && (i = !1), t !== null)
+      if (this.cancelNextCallback(), t === F) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var a = this.props.nodeRef ? this.props.nodeRef.current : Q.findDOMNode(this);
+          a && Le(a);
+        }
+        this.performEnter(i);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === U && this.setState({
+      status: H
+    });
+  }, l.performEnter = function(i) {
+    var t = this, a = this.props.enter, n = this.context ? this.context.isMounting : i, f = this.props.nodeRef ? [n] : [Q.findDOMNode(this), n], p = f[0], v = f[1], E = this.getTimeouts(), P = n ? E.appear : E.enter;
+    if (!i && !a || $e.disabled) {
+      this.safeSetState({
+        status: X
+      }, function() {
+        t.props.onEntered(p);
+      });
+      return;
+    }
+    this.props.onEnter(p, v), this.safeSetState({
+      status: F
+    }, function() {
+      t.props.onEntering(p, v), t.onTransitionEnd(P, function() {
+        t.safeSetState({
+          status: X
+        }, function() {
+          t.props.onEntered(p, v);
+        });
+      });
+    });
+  }, l.performExit = function() {
+    var i = this, t = this.props.exit, a = this.getTimeouts(), n = this.props.nodeRef ? void 0 : Q.findDOMNode(this);
+    if (!t || $e.disabled) {
+      this.safeSetState({
+        status: U
+      }, function() {
+        i.props.onExited(n);
+      });
+      return;
+    }
+    this.props.onExit(n), this.safeSetState({
+      status: ge
+    }, function() {
+      i.props.onExiting(n), i.onTransitionEnd(a.exit, function() {
+        i.safeSetState({
+          status: U
+        }, function() {
+          i.props.onExited(n);
+        });
+      });
+    });
+  }, l.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, l.safeSetState = function(i, t) {
+    t = this.setNextCallback(t), this.setState(i, t);
+  }, l.setNextCallback = function(i) {
+    var t = this, a = !0;
+    return this.nextCallback = function(n) {
+      a && (a = !1, t.nextCallback = null, i(n));
+    }, this.nextCallback.cancel = function() {
+      a = !1;
+    }, this.nextCallback;
+  }, l.onTransitionEnd = function(i, t) {
+    this.setNextCallback(t);
+    var a = this.props.nodeRef ? this.props.nodeRef.current : Q.findDOMNode(this), n = i == null && !this.props.addEndListener;
+    if (!a || n) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var f = this.props.nodeRef ? [this.nextCallback] : [a, this.nextCallback], p = f[0], v = f[1];
+      this.props.addEndListener(p, v);
+    }
+    i != null && setTimeout(this.nextCallback, i);
+  }, l.render = function() {
+    var i = this.state.status;
+    if (i === H)
+      return null;
+    var t = this.props, a = t.children;
+    t.in, t.mountOnEnter, t.unmountOnExit, t.appear, t.enter, t.exit, t.timeout, t.addEndListener, t.onEnter, t.onEntering, t.onEntered, t.onExit, t.onExiting, t.onExited, t.nodeRef;
+    var n = Me(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ V.createElement(ke.Provider, {
+        value: null
+      }, typeof a == "function" ? a(i, n) : V.cloneElement(V.Children.only(a), n))
+    );
+  }, u;
+}(V.Component);
+q.contextType = ke;
+q.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: y.shape({
+    current: typeof Element > "u" ? y.any : function(r, u, l, e, i, t) {
+      var a = r[u];
+      return y.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(r, u, l, e, i, t);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: y.oneOfType([y.func.isRequired, y.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: y.bool,
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: y.bool,
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: y.bool,
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: y.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: y.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: y.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function(u) {
+    var l = Qe;
+    u.addEndListener || (l = l.isRequired);
+    for (var e = arguments.length, i = new Array(e > 1 ? e - 1 : 0), t = 1; t < e; t++)
+      i[t - 1] = arguments[t];
+    return l.apply(void 0, [u].concat(i));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: y.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: y.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: y.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: y.func,
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: y.func,
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: y.func,
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: y.func
+} : {};
+function G() {
+}
+q.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: G,
+  onEntering: G,
+  onEntered: G,
+  onExit: G,
+  onExiting: G,
+  onExited: G
+};
+q.UNMOUNTED = H;
+q.EXITED = U;
+q.ENTERING = F;
+q.ENTERED = X;
+q.EXITING = ge;
+var tt = function(u, l) {
+  return u && l && l.split(" ").forEach(function(e) {
+    return Ke(u, e);
+  });
+}, Ee = function(u, l) {
+  return u && l && l.split(" ").forEach(function(e) {
+    return Ze(u, e);
+  });
+}, qe = /* @__PURE__ */ function(r) {
+  De(u, r);
+  function u() {
+    for (var e, i = arguments.length, t = new Array(i), a = 0; a < i; a++)
+      t[a] = arguments[a];
+    return e = r.call.apply(r, [this].concat(t)) || this, e.appliedClasses = {
+      appear: {},
+      enter: {},
+      exit: {}
+    }, e.onEnter = function(n, f) {
+      var p = e.resolveArguments(n, f), v = p[0], E = p[1];
+      e.removeClasses(v, "exit"), e.addClass(v, E ? "appear" : "enter", "base"), e.props.onEnter && e.props.onEnter(n, f);
+    }, e.onEntering = function(n, f) {
+      var p = e.resolveArguments(n, f), v = p[0], E = p[1], P = E ? "appear" : "enter";
+      e.addClass(v, P, "active"), e.props.onEntering && e.props.onEntering(n, f);
+    }, e.onEntered = function(n, f) {
+      var p = e.resolveArguments(n, f), v = p[0], E = p[1], P = E ? "appear" : "enter";
+      e.removeClasses(v, P), e.addClass(v, P, "done"), e.props.onEntered && e.props.onEntered(n, f);
+    }, e.onExit = function(n) {
+      var f = e.resolveArguments(n), p = f[0];
+      e.removeClasses(p, "appear"), e.removeClasses(p, "enter"), e.addClass(p, "exit", "base"), e.props.onExit && e.props.onExit(n);
+    }, e.onExiting = function(n) {
+      var f = e.resolveArguments(n), p = f[0];
+      e.addClass(p, "exit", "active"), e.props.onExiting && e.props.onExiting(n);
+    }, e.onExited = function(n) {
+      var f = e.resolveArguments(n), p = f[0];
+      e.removeClasses(p, "exit"), e.addClass(p, "exit", "done"), e.props.onExited && e.props.onExited(n);
+    }, e.resolveArguments = function(n, f) {
+      return e.props.nodeRef ? [e.props.nodeRef.current, n] : [n, f];
+    }, e.getClassNames = function(n) {
+      var f = e.props.classNames, p = typeof f == "string", v = p && f ? f + "-" : "", E = p ? "" + v + n : f[n], P = p ? E + "-active" : f[n + "Active"], A = p ? E + "-done" : f[n + "Done"];
+      return {
+        baseClassName: E,
+        activeClassName: P,
+        doneClassName: A
+      };
+    }, e;
+  }
+  var l = u.prototype;
+  return l.addClass = function(i, t, a) {
+    var n = this.getClassNames(t)[a + "ClassName"], f = this.getClassNames("enter"), p = f.doneClassName;
+    t === "appear" && a === "done" && p && (n += " " + p), a === "active" && i && Le(i), n && (this.appliedClasses[t][a] = n, tt(i, n));
+  }, l.removeClasses = function(i, t) {
+    var a = this.appliedClasses[t], n = a.base, f = a.active, p = a.done;
+    this.appliedClasses[t] = {}, n && Ee(i, n), f && Ee(i, f), p && Ee(i, p);
+  }, l.render = function() {
+    var i = this.props;
+    i.classNames;
+    var t = Me(i, ["classNames"]);
+    return /* @__PURE__ */ V.createElement(q, te({}, t, {
+      onEnter: this.onEnter,
+      onEntered: this.onEntered,
+      onEntering: this.onEntering,
+      onExit: this.onExit,
+      onExiting: this.onExiting,
+      onExited: this.onExited
+    }));
+  }, u;
+}(V.Component);
+qe.defaultProps = {
+  classNames: ""
+};
+qe.propTypes = process.env.NODE_ENV !== "production" ? te({}, q.propTypes, {
+  /**
+   * The animation classNames applied to the component as it appears, enters,
+   * exits or has finished the transition. A single name can be provided, which
+   * will be suffixed for each stage, e.g. `classNames="fade"` applies:
+   *
+   * - `fade-appear`, `fade-appear-active`, `fade-appear-done`
+   * - `fade-enter`, `fade-enter-active`, `fade-enter-done`
+   * - `fade-exit`, `fade-exit-active`, `fade-exit-done`
+   *
+   * A few details to note about how these classes are applied:
+   *
+   * 1. They are _joined_ with the ones that are already defined on the child
+   *    component, so if you want to add some base styles, you can use
+   *    `className` without worrying that it will be overridden.
+   *
+   * 2. If the transition component mounts with `in={false}`, no classes are
+   *    applied yet. You might be expecting `*-exit-done`, but if you think
+   *    about it, a component cannot finish exiting if it hasn't entered yet.
+   *
+   * 2. `fade-appear-done` and `fade-enter-done` will _both_ be applied. This
+   *    allows you to define different behavior for when appearing is done and
+   *    when regular entering is done, using selectors like
+   *    `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply
+   *    an epic entrance animation when element first appears in the DOM using
+   *    [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can
+   *    simply use `fade-enter-done` for defining both cases.
+   *
+   * Each individual classNames can also be specified independently like:
+   *
+   * ```js
+   * classNames={{
+   *  appear: 'my-appear',
+   *  appearActive: 'my-active-appear',
+   *  appearDone: 'my-done-appear',
+   *  enter: 'my-enter',
+   *  enterActive: 'my-active-enter',
+   *  enterDone: 'my-done-enter',
+   *  exit: 'my-exit',
+   *  exitActive: 'my-active-exit',
+   *  exitDone: 'my-done-exit',
+   * }}
+   * ```
+   *
+   * If you want to set these classes using CSS Modules:
+   *
+   * ```js
+   * import styles from './styles.css';
+   * ```
+   *
+   * you might want to use camelCase in your CSS file, that way could simply
+   * spread them instead of listing them one by one:
+   *
+   * ```js
+   * classNames={{ ...styles }}
+   * ```
+   *
+   * @type {string | {
+   *  appear?: string,
+   *  appearActive?: string,
+   *  appearDone?: string,
+   *  enter?: string,
+   *  enterActive?: string,
+   *  enterDone?: string,
+   *  exit?: string,
+   *  exitActive?: string,
+   *  exitDone?: string,
+   * }}
+   */
+  classNames: et,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is
+   * applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEnter: y.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter-active' or
+   * 'appear-active' class is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: y.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or
+   * 'appear' classes are **removed** and the `done` class is added to the DOM node.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntered: y.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' class is
+   * applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExit: y.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExiting: y.func,
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' classes
+   * are **removed** and the `exit-done` class is added to the DOM node.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExited: y.func
+}) : {};
+export {
+  qe as C,
+  y as P
+};