react-luminus-components 1.0.0

package/dist/hasClass-3JW9Qluf.mjs

@@ -0,0 +1,1482 @@
+import * as ue from "react";
+import K, { useContext as ne, useMemo as ot, useRef as Y, useCallback as $, useEffect as H, useState as Ae, useLayoutEffect as it, createContext as at, cloneElement as De } from "react";
+import { h as st, j as Q, e as ut } from "./useAxios-BU-BqYrK.mjs";
+import ee from "react-dom";
+function ct(e, n) {
+  if (e == null)
+    return {};
+  var i = {}, r = Object.keys(e), o, t;
+  for (t = 0; t < r.length; t++)
+    o = r[t], !(n.indexOf(o) >= 0) && (i[o] = e[o]);
+  return i;
+}
+function _e(e, n) {
+  return _e = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, o) {
+    return r.__proto__ = o, r;
+  }, _e(e, n);
+}
+function ft(e, n) {
+  e.prototype = Object.create(n.prototype), e.prototype.constructor = e, _e(e, n);
+}
+const lt = ["xxl", "xl", "lg", "md", "sm", "xs"], dt = "xs", ce = /* @__PURE__ */ ue.createContext({
+  prefixes: {},
+  breakpoints: lt,
+  minBreakpoint: dt
+});
+function fn(e, n) {
+  const {
+    prefixes: i
+  } = ne(ce);
+  return e || i[n] || n;
+}
+function ln() {
+  const {
+    breakpoints: e
+  } = ne(ce);
+  return e;
+}
+function dn() {
+  const {
+    minBreakpoint: e
+  } = ne(ce);
+  return e;
+}
+function pn() {
+  const {
+    dir: e
+  } = ne(ce);
+  return e === "rtl";
+}
+function Ke(e) {
+  return e && e.ownerDocument || document;
+}
+function pt(e) {
+  var n = Ke(e);
+  return n && n.defaultView || window;
+}
+function vt(e, n) {
+  return pt(e).getComputedStyle(e, n);
+}
+var yt = /([A-Z])/g;
+function Et(e) {
+  return e.replace(yt, "-$1").toLowerCase();
+}
+var mt = /^ms-/;
+function ae(e) {
+  return Et(e).replace(mt, "-ms-");
+}
+var ht = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i;
+function bt(e) {
+  return !!(e && ht.test(e));
+}
+function He(e, n) {
+  var i = "", r = "";
+  if (typeof n == "string")
+    return e.style.getPropertyValue(ae(n)) || vt(e).getPropertyValue(ae(n));
+  Object.keys(n).forEach(function(o) {
+    var t = n[o];
+    !t && t !== 0 ? e.style.removeProperty(ae(o)) : bt(o) ? r += o + "(" + t + ") " : i += ae(o) + ": " + t + ";";
+  }), r && (i += "transform: " + r + ";"), e.style.cssText += ";" + i;
+}
+var Ce = { exports: {} }, se = { exports: {} }, _ = {};
+/** @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 $e;
+function xt() {
+  if ($e)
+    return _;
+  $e = 1;
+  var e = typeof Symbol == "function" && Symbol.for, n = e ? Symbol.for("react.element") : 60103, i = e ? Symbol.for("react.portal") : 60106, r = e ? Symbol.for("react.fragment") : 60107, o = e ? Symbol.for("react.strict_mode") : 60108, t = e ? Symbol.for("react.profiler") : 60114, s = e ? Symbol.for("react.provider") : 60109, u = e ? Symbol.for("react.context") : 60110, d = e ? Symbol.for("react.async_mode") : 60111, p = e ? Symbol.for("react.concurrent_mode") : 60111, v = e ? Symbol.for("react.forward_ref") : 60112, y = e ? Symbol.for("react.suspense") : 60113, S = e ? Symbol.for("react.suspense_list") : 60120, A = e ? Symbol.for("react.memo") : 60115, D = e ? Symbol.for("react.lazy") : 60116, w = e ? Symbol.for("react.block") : 60121, I = e ? Symbol.for("react.fundamental") : 60117, L = e ? Symbol.for("react.responder") : 60118, F = e ? Symbol.for("react.scope") : 60119;
+  function M(c) {
+    if (typeof c == "object" && c !== null) {
+      var k = c.$$typeof;
+      switch (k) {
+        case n:
+          switch (c = c.type, c) {
+            case d:
+            case p:
+            case r:
+            case t:
+            case o:
+            case y:
+              return c;
+            default:
+              switch (c = c && c.$$typeof, c) {
+                case u:
+                case v:
+                case D:
+                case A:
+                case s:
+                  return c;
+                default:
+                  return k;
+              }
+          }
+        case i:
+          return k;
+      }
+    }
+  }
+  function j(c) {
+    return M(c) === p;
+  }
+  return _.AsyncMode = d, _.ConcurrentMode = p, _.ContextConsumer = u, _.ContextProvider = s, _.Element = n, _.ForwardRef = v, _.Fragment = r, _.Lazy = D, _.Memo = A, _.Portal = i, _.Profiler = t, _.StrictMode = o, _.Suspense = y, _.isAsyncMode = function(c) {
+    return j(c) || M(c) === d;
+  }, _.isConcurrentMode = j, _.isContextConsumer = function(c) {
+    return M(c) === u;
+  }, _.isContextProvider = function(c) {
+    return M(c) === s;
+  }, _.isElement = function(c) {
+    return typeof c == "object" && c !== null && c.$$typeof === n;
+  }, _.isForwardRef = function(c) {
+    return M(c) === v;
+  }, _.isFragment = function(c) {
+    return M(c) === r;
+  }, _.isLazy = function(c) {
+    return M(c) === D;
+  }, _.isMemo = function(c) {
+    return M(c) === A;
+  }, _.isPortal = function(c) {
+    return M(c) === i;
+  }, _.isProfiler = function(c) {
+    return M(c) === t;
+  }, _.isStrictMode = function(c) {
+    return M(c) === o;
+  }, _.isSuspense = function(c) {
+    return M(c) === y;
+  }, _.isValidElementType = function(c) {
+    return typeof c == "string" || typeof c == "function" || c === r || c === p || c === t || c === o || c === y || c === S || typeof c == "object" && c !== null && (c.$$typeof === D || c.$$typeof === A || c.$$typeof === s || c.$$typeof === u || c.$$typeof === v || c.$$typeof === I || c.$$typeof === L || c.$$typeof === F || c.$$typeof === w);
+  }, _.typeOf = M, _;
+}
+var C = {};
+/** @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 ke;
+function Tt() {
+  return ke || (ke = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = typeof Symbol == "function" && Symbol.for, n = e ? Symbol.for("react.element") : 60103, i = e ? Symbol.for("react.portal") : 60106, r = e ? Symbol.for("react.fragment") : 60107, o = e ? Symbol.for("react.strict_mode") : 60108, t = e ? Symbol.for("react.profiler") : 60114, s = e ? Symbol.for("react.provider") : 60109, u = e ? Symbol.for("react.context") : 60110, d = e ? Symbol.for("react.async_mode") : 60111, p = e ? Symbol.for("react.concurrent_mode") : 60111, v = e ? Symbol.for("react.forward_ref") : 60112, y = e ? Symbol.for("react.suspense") : 60113, S = e ? Symbol.for("react.suspense_list") : 60120, A = e ? Symbol.for("react.memo") : 60115, D = e ? Symbol.for("react.lazy") : 60116, w = e ? Symbol.for("react.block") : 60121, I = e ? Symbol.for("react.fundamental") : 60117, L = e ? Symbol.for("react.responder") : 60118, F = e ? Symbol.for("react.scope") : 60119;
+    function M(f) {
+      return typeof f == "string" || typeof f == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      f === r || f === p || f === t || f === o || f === y || f === S || typeof f == "object" && f !== null && (f.$$typeof === D || f.$$typeof === A || f.$$typeof === s || f.$$typeof === u || f.$$typeof === v || f.$$typeof === I || f.$$typeof === L || f.$$typeof === F || f.$$typeof === w);
+    }
+    function j(f) {
+      if (typeof f == "object" && f !== null) {
+        var W = f.$$typeof;
+        switch (W) {
+          case n:
+            var ie = f.type;
+            switch (ie) {
+              case d:
+              case p:
+              case r:
+              case t:
+              case o:
+              case y:
+                return ie;
+              default:
+                var Le = ie && ie.$$typeof;
+                switch (Le) {
+                  case u:
+                  case v:
+                  case D:
+                  case A:
+                  case s:
+                    return Le;
+                  default:
+                    return W;
+                }
+            }
+          case i:
+            return W;
+        }
+      }
+    }
+    var c = d, k = p, z = u, le = s, de = n, pe = v, re = r, ve = D, ye = A, J = i, Ee = t, q = o, V = y, oe = !1;
+    function me(f) {
+      return oe || (oe = !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.")), a(f) || j(f) === d;
+    }
+    function a(f) {
+      return j(f) === p;
+    }
+    function l(f) {
+      return j(f) === u;
+    }
+    function T(f) {
+      return j(f) === s;
+    }
+    function b(f) {
+      return typeof f == "object" && f !== null && f.$$typeof === n;
+    }
+    function E(f) {
+      return j(f) === v;
+    }
+    function g(f) {
+      return j(f) === r;
+    }
+    function h(f) {
+      return j(f) === D;
+    }
+    function x(f) {
+      return j(f) === A;
+    }
+    function R(f) {
+      return j(f) === i;
+    }
+    function P(f) {
+      return j(f) === t;
+    }
+    function O(f) {
+      return j(f) === o;
+    }
+    function N(f) {
+      return j(f) === y;
+    }
+    C.AsyncMode = c, C.ConcurrentMode = k, C.ContextConsumer = z, C.ContextProvider = le, C.Element = de, C.ForwardRef = pe, C.Fragment = re, C.Lazy = ve, C.Memo = ye, C.Portal = J, C.Profiler = Ee, C.StrictMode = q, C.Suspense = V, C.isAsyncMode = me, C.isConcurrentMode = a, C.isContextConsumer = l, C.isContextProvider = T, C.isElement = b, C.isForwardRef = E, C.isFragment = g, C.isLazy = h, C.isMemo = x, C.isPortal = R, C.isProfiler = P, C.isStrictMode = O, C.isSuspense = N, C.isValidElementType = M, C.typeOf = j;
+  }()), C;
+}
+var Ne;
+function Je() {
+  return Ne || (Ne = 1, process.env.NODE_ENV === "production" ? se.exports = xt() : se.exports = Tt()), se.exports;
+}
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var he, qe;
+function gt() {
+  if (qe)
+    return he;
+  qe = 1;
+  var e = Object.getOwnPropertySymbols, n = Object.prototype.hasOwnProperty, i = Object.prototype.propertyIsEnumerable;
+  function r(t) {
+    if (t == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(t);
+  }
+  function o() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var t = new String("abc");
+      if (t[5] = "de", Object.getOwnPropertyNames(t)[0] === "5")
+        return !1;
+      for (var s = {}, u = 0; u < 10; u++)
+        s["_" + String.fromCharCode(u)] = u;
+      var d = Object.getOwnPropertyNames(s).map(function(v) {
+        return s[v];
+      });
+      if (d.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 he = o() ? Object.assign : function(t, s) {
+    for (var u, d = r(t), p, v = 1; v < arguments.length; v++) {
+      u = Object(arguments[v]);
+      for (var y in u)
+        n.call(u, y) && (d[y] = u[y]);
+      if (e) {
+        p = e(u);
+        for (var S = 0; S < p.length; S++)
+          i.call(u, p[S]) && (d[p[S]] = u[p[S]]);
+      }
+    }
+    return d;
+  }, he;
+}
+var be, We;
+function Me() {
+  if (We)
+    return be;
+  We = 1;
+  var e = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return be = e, be;
+}
+var xe, Ye;
+function Ze() {
+  return Ye || (Ye = 1, xe = Function.call.bind(Object.prototype.hasOwnProperty)), xe;
+}
+var Te, Fe;
+function Rt() {
+  if (Fe)
+    return Te;
+  Fe = 1;
+  var e = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var n = Me(), i = {}, r = Ze();
+    e = function(t) {
+      var s = "Warning: " + t;
+      typeof console < "u" && console.error(s);
+      try {
+        throw new Error(s);
+      } catch {
+      }
+    };
+  }
+  function o(t, s, u, d, p) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var v in t)
+        if (r(t, v)) {
+          var y;
+          try {
+            if (typeof t[v] != "function") {
+              var S = Error(
+                (d || "React class") + ": " + u + " 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 S.name = "Invariant Violation", S;
+            }
+            y = t[v](s, v, d, u, null, n);
+          } catch (D) {
+            y = D;
+          }
+          if (y && !(y instanceof Error) && e(
+            (d || "React class") + ": type specification of " + u + " `" + v + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof y + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), y instanceof Error && !(y.message in i)) {
+            i[y.message] = !0;
+            var A = p ? p() : "";
+            e(
+              "Failed " + u + " type: " + y.message + (A ?? "")
+            );
+          }
+        }
+    }
+  }
+  return o.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (i = {});
+  }, Te = o, Te;
+}
+var ge, Ue;
+function Ot() {
+  if (Ue)
+    return ge;
+  Ue = 1;
+  var e = Je(), n = gt(), i = Me(), r = Ze(), o = Rt(), t = function() {
+  };
+  process.env.NODE_ENV !== "production" && (t = function(u) {
+    var d = "Warning: " + u;
+    typeof console < "u" && console.error(d);
+    try {
+      throw new Error(d);
+    } catch {
+    }
+  });
+  function s() {
+    return null;
+  }
+  return ge = function(u, d) {
+    var p = typeof Symbol == "function" && Symbol.iterator, v = "@@iterator";
+    function y(a) {
+      var l = a && (p && a[p] || a[v]);
+      if (typeof l == "function")
+        return l;
+    }
+    var S = "<<anonymous>>", A = {
+      array: L("array"),
+      bigint: L("bigint"),
+      bool: L("boolean"),
+      func: L("function"),
+      number: L("number"),
+      object: L("object"),
+      string: L("string"),
+      symbol: L("symbol"),
+      any: F(),
+      arrayOf: M,
+      element: j(),
+      elementType: c(),
+      instanceOf: k,
+      node: pe(),
+      objectOf: le,
+      oneOf: z,
+      oneOfType: de,
+      shape: ve,
+      exact: ye
+    };
+    function D(a, l) {
+      return a === l ? a !== 0 || 1 / a === 1 / l : a !== a && l !== l;
+    }
+    function w(a, l) {
+      this.message = a, this.data = l && typeof l == "object" ? l : {}, this.stack = "";
+    }
+    w.prototype = Error.prototype;
+    function I(a) {
+      if (process.env.NODE_ENV !== "production")
+        var l = {}, T = 0;
+      function b(g, h, x, R, P, O, N) {
+        if (R = R || S, O = O || x, N !== i) {
+          if (d) {
+            var f = 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 f.name = "Invariant Violation", f;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var W = R + ":" + x;
+            !l[W] && // Avoid spamming the console because they are often not actionable except for lib authors
+            T < 3 && (t(
+              "You are manually calling a React.PropTypes validation function for the `" + O + "` prop on `" + R + "`. 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."
+            ), l[W] = !0, T++);
+          }
+        }
+        return h[x] == null ? g ? h[x] === null ? new w("The " + P + " `" + O + "` is marked as required " + ("in `" + R + "`, but its value is `null`.")) : new w("The " + P + " `" + O + "` is marked as required in " + ("`" + R + "`, but its value is `undefined`.")) : null : a(h, x, R, P, O);
+      }
+      var E = b.bind(null, !1);
+      return E.isRequired = b.bind(null, !0), E;
+    }
+    function L(a) {
+      function l(T, b, E, g, h, x) {
+        var R = T[b], P = q(R);
+        if (P !== a) {
+          var O = V(R);
+          return new w(
+            "Invalid " + g + " `" + h + "` of type " + ("`" + O + "` supplied to `" + E + "`, expected ") + ("`" + a + "`."),
+            { expectedType: a }
+          );
+        }
+        return null;
+      }
+      return I(l);
+    }
+    function F() {
+      return I(s);
+    }
+    function M(a) {
+      function l(T, b, E, g, h) {
+        if (typeof a != "function")
+          return new w("Property `" + h + "` of component `" + E + "` has invalid PropType notation inside arrayOf.");
+        var x = T[b];
+        if (!Array.isArray(x)) {
+          var R = q(x);
+          return new w("Invalid " + g + " `" + h + "` of type " + ("`" + R + "` supplied to `" + E + "`, expected an array."));
+        }
+        for (var P = 0; P < x.length; P++) {
+          var O = a(x, P, E, g, h + "[" + P + "]", i);
+          if (O instanceof Error)
+            return O;
+        }
+        return null;
+      }
+      return I(l);
+    }
+    function j() {
+      function a(l, T, b, E, g) {
+        var h = l[T];
+        if (!u(h)) {
+          var x = q(h);
+          return new w("Invalid " + E + " `" + g + "` of type " + ("`" + x + "` supplied to `" + b + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return I(a);
+    }
+    function c() {
+      function a(l, T, b, E, g) {
+        var h = l[T];
+        if (!e.isValidElementType(h)) {
+          var x = q(h);
+          return new w("Invalid " + E + " `" + g + "` of type " + ("`" + x + "` supplied to `" + b + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return I(a);
+    }
+    function k(a) {
+      function l(T, b, E, g, h) {
+        if (!(T[b] instanceof a)) {
+          var x = a.name || S, R = me(T[b]);
+          return new w("Invalid " + g + " `" + h + "` of type " + ("`" + R + "` supplied to `" + E + "`, expected ") + ("instance of `" + x + "`."));
+        }
+        return null;
+      }
+      return I(l);
+    }
+    function z(a) {
+      if (!Array.isArray(a))
+        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.")), s;
+      function l(T, b, E, g, h) {
+        for (var x = T[b], R = 0; R < a.length; R++)
+          if (D(x, a[R]))
+            return null;
+        var P = JSON.stringify(a, function(N, f) {
+          var W = V(f);
+          return W === "symbol" ? String(f) : f;
+        });
+        return new w("Invalid " + g + " `" + h + "` of value `" + String(x) + "` " + ("supplied to `" + E + "`, expected one of " + P + "."));
+      }
+      return I(l);
+    }
+    function le(a) {
+      function l(T, b, E, g, h) {
+        if (typeof a != "function")
+          return new w("Property `" + h + "` of component `" + E + "` has invalid PropType notation inside objectOf.");
+        var x = T[b], R = q(x);
+        if (R !== "object")
+          return new w("Invalid " + g + " `" + h + "` of type " + ("`" + R + "` supplied to `" + E + "`, expected an object."));
+        for (var P in x)
+          if (r(x, P)) {
+            var O = a(x, P, E, g, h + "." + P, i);
+            if (O instanceof Error)
+              return O;
+          }
+        return null;
+      }
+      return I(l);
+    }
+    function de(a) {
+      if (!Array.isArray(a))
+        return process.env.NODE_ENV !== "production" && t("Invalid argument supplied to oneOfType, expected an instance of array."), s;
+      for (var l = 0; l < a.length; l++) {
+        var T = a[l];
+        if (typeof T != "function")
+          return t(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + oe(T) + " at index " + l + "."
+          ), s;
+      }
+      function b(E, g, h, x, R) {
+        for (var P = [], O = 0; O < a.length; O++) {
+          var N = a[O], f = N(E, g, h, x, R, i);
+          if (f == null)
+            return null;
+          f.data && r(f.data, "expectedType") && P.push(f.data.expectedType);
+        }
+        var W = P.length > 0 ? ", expected one of type [" + P.join(", ") + "]" : "";
+        return new w("Invalid " + x + " `" + R + "` supplied to " + ("`" + h + "`" + W + "."));
+      }
+      return I(b);
+    }
+    function pe() {
+      function a(l, T, b, E, g) {
+        return J(l[T]) ? null : new w("Invalid " + E + " `" + g + "` supplied to " + ("`" + b + "`, expected a ReactNode."));
+      }
+      return I(a);
+    }
+    function re(a, l, T, b, E) {
+      return new w(
+        (a || "React class") + ": " + l + " type `" + T + "." + b + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + E + "`."
+      );
+    }
+    function ve(a) {
+      function l(T, b, E, g, h) {
+        var x = T[b], R = q(x);
+        if (R !== "object")
+          return new w("Invalid " + g + " `" + h + "` of type `" + R + "` " + ("supplied to `" + E + "`, expected `object`."));
+        for (var P in a) {
+          var O = a[P];
+          if (typeof O != "function")
+            return re(E, g, h, P, V(O));
+          var N = O(x, P, E, g, h + "." + P, i);
+          if (N)
+            return N;
+        }
+        return null;
+      }
+      return I(l);
+    }
+    function ye(a) {
+      function l(T, b, E, g, h) {
+        var x = T[b], R = q(x);
+        if (R !== "object")
+          return new w("Invalid " + g + " `" + h + "` of type `" + R + "` " + ("supplied to `" + E + "`, expected `object`."));
+        var P = n({}, T[b], a);
+        for (var O in P) {
+          var N = a[O];
+          if (r(a, O) && typeof N != "function")
+            return re(E, g, h, O, V(N));
+          if (!N)
+            return new w(
+              "Invalid " + g + " `" + h + "` key `" + O + "` supplied to `" + E + "`.\nBad object: " + JSON.stringify(T[b], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(a), null, "  ")
+            );
+          var f = N(x, O, E, g, h + "." + O, i);
+          if (f)
+            return f;
+        }
+        return null;
+      }
+      return I(l);
+    }
+    function J(a) {
+      switch (typeof a) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !a;
+        case "object":
+          if (Array.isArray(a))
+            return a.every(J);
+          if (a === null || u(a))
+            return !0;
+          var l = y(a);
+          if (l) {
+            var T = l.call(a), b;
+            if (l !== a.entries) {
+              for (; !(b = T.next()).done; )
+                if (!J(b.value))
+                  return !1;
+            } else
+              for (; !(b = T.next()).done; ) {
+                var E = b.value;
+                if (E && !J(E[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function Ee(a, l) {
+      return a === "symbol" ? !0 : l ? l["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && l instanceof Symbol : !1;
+    }
+    function q(a) {
+      var l = typeof a;
+      return Array.isArray(a) ? "array" : a instanceof RegExp ? "object" : Ee(l, a) ? "symbol" : l;
+    }
+    function V(a) {
+      if (typeof a > "u" || a === null)
+        return "" + a;
+      var l = q(a);
+      if (l === "object") {
+        if (a instanceof Date)
+          return "date";
+        if (a instanceof RegExp)
+          return "regexp";
+      }
+      return l;
+    }
+    function oe(a) {
+      var l = V(a);
+      switch (l) {
+        case "array":
+        case "object":
+          return "an " + l;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + l;
+        default:
+          return l;
+      }
+    }
+    function me(a) {
+      return !a.constructor || !a.constructor.name ? S : a.constructor.name;
+    }
+    return A.checkPropTypes = o, A.resetWarningCache = o.resetWarningCache, A.PropTypes = A, A;
+  }, ge;
+}
+var Re, Be;
+function St() {
+  if (Be)
+    return Re;
+  Be = 1;
+  var e = Me();
+  function n() {
+  }
+  function i() {
+  }
+  return i.resetWarningCache = n, Re = function() {
+    function r(s, u, d, p, v, y) {
+      if (y !== e) {
+        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;
+      }
+    }
+    r.isRequired = r;
+    function o() {
+      return r;
+    }
+    var t = {
+      array: r,
+      bigint: r,
+      bool: r,
+      func: r,
+      number: r,
+      object: r,
+      string: r,
+      symbol: r,
+      any: r,
+      arrayOf: o,
+      element: r,
+      elementType: r,
+      instanceOf: o,
+      node: r,
+      objectOf: o,
+      oneOf: o,
+      oneOfType: o,
+      shape: o,
+      exact: o,
+      checkPropTypes: i,
+      resetWarningCache: n
+    };
+    return t.PropTypes = t, t;
+  }, Re;
+}
+if (process.env.NODE_ENV !== "production") {
+  var _t = Je(), Ct = !0;
+  Ce.exports = Ot()(_t.isElement, Ct);
+} else
+  Ce.exports = St()();
+var Pt = Ce.exports;
+const m = /* @__PURE__ */ st(Pt), ze = {
+  disabled: !1
+};
+var wt = process.env.NODE_ENV !== "production" ? m.oneOfType([m.number, m.shape({
+  enter: m.number,
+  exit: m.number,
+  appear: m.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && m.oneOfType([m.string, m.shape({
+  enter: m.string,
+  exit: m.string,
+  active: m.string
+}), m.shape({
+  enter: m.string,
+  enterDone: m.string,
+  enterActive: m.string,
+  exit: m.string,
+  exitDone: m.string,
+  exitActive: m.string
+})]);
+const Qe = K.createContext(null);
+var jt = function(n) {
+  return n.scrollTop;
+}, te = "unmounted", G = "exited", B = "entering", X = "entered", Pe = "exiting", U = /* @__PURE__ */ function(e) {
+  ft(n, e);
+  function n(r, o) {
+    var t;
+    t = e.call(this, r, o) || this;
+    var s = o, u = s && !s.isMounting ? r.enter : r.appear, d;
+    return t.appearStatus = null, r.in ? u ? (d = G, t.appearStatus = B) : d = X : r.unmountOnExit || r.mountOnEnter ? d = te : d = G, t.state = {
+      status: d
+    }, t.nextCallback = null, t;
+  }
+  n.getDerivedStateFromProps = function(o, t) {
+    var s = o.in;
+    return s && t.status === te ? {
+      status: G
+    } : null;
+  };
+  var i = n.prototype;
+  return i.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, i.componentDidUpdate = function(o) {
+    var t = null;
+    if (o !== this.props) {
+      var s = this.state.status;
+      this.props.in ? s !== B && s !== X && (t = B) : (s === B || s === X) && (t = Pe);
+    }
+    this.updateStatus(!1, t);
+  }, i.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, i.getTimeouts = function() {
+    var o = this.props.timeout, t, s, u;
+    return t = s = u = o, o != null && typeof o != "number" && (t = o.exit, s = o.enter, u = o.appear !== void 0 ? o.appear : s), {
+      exit: t,
+      enter: s,
+      appear: u
+    };
+  }, i.updateStatus = function(o, t) {
+    if (o === void 0 && (o = !1), t !== null)
+      if (this.cancelNextCallback(), t === B) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var s = this.props.nodeRef ? this.props.nodeRef.current : ee.findDOMNode(this);
+          s && jt(s);
+        }
+        this.performEnter(o);
+      } else
+        this.performExit();
+    else
+      this.props.unmountOnExit && this.state.status === G && this.setState({
+        status: te
+      });
+  }, i.performEnter = function(o) {
+    var t = this, s = this.props.enter, u = this.context ? this.context.isMounting : o, d = this.props.nodeRef ? [u] : [ee.findDOMNode(this), u], p = d[0], v = d[1], y = this.getTimeouts(), S = u ? y.appear : y.enter;
+    if (!o && !s || ze.disabled) {
+      this.safeSetState({
+        status: X
+      }, function() {
+        t.props.onEntered(p);
+      });
+      return;
+    }
+    this.props.onEnter(p, v), this.safeSetState({
+      status: B
+    }, function() {
+      t.props.onEntering(p, v), t.onTransitionEnd(S, function() {
+        t.safeSetState({
+          status: X
+        }, function() {
+          t.props.onEntered(p, v);
+        });
+      });
+    });
+  }, i.performExit = function() {
+    var o = this, t = this.props.exit, s = this.getTimeouts(), u = this.props.nodeRef ? void 0 : ee.findDOMNode(this);
+    if (!t || ze.disabled) {
+      this.safeSetState({
+        status: G
+      }, function() {
+        o.props.onExited(u);
+      });
+      return;
+    }
+    this.props.onExit(u), this.safeSetState({
+      status: Pe
+    }, function() {
+      o.props.onExiting(u), o.onTransitionEnd(s.exit, function() {
+        o.safeSetState({
+          status: G
+        }, function() {
+          o.props.onExited(u);
+        });
+      });
+    });
+  }, i.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, i.safeSetState = function(o, t) {
+    t = this.setNextCallback(t), this.setState(o, t);
+  }, i.setNextCallback = function(o) {
+    var t = this, s = !0;
+    return this.nextCallback = function(u) {
+      s && (s = !1, t.nextCallback = null, o(u));
+    }, this.nextCallback.cancel = function() {
+      s = !1;
+    }, this.nextCallback;
+  }, i.onTransitionEnd = function(o, t) {
+    this.setNextCallback(t);
+    var s = this.props.nodeRef ? this.props.nodeRef.current : ee.findDOMNode(this), u = o == null && !this.props.addEndListener;
+    if (!s || u) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var d = this.props.nodeRef ? [this.nextCallback] : [s, this.nextCallback], p = d[0], v = d[1];
+      this.props.addEndListener(p, v);
+    }
+    o != null && setTimeout(this.nextCallback, o);
+  }, i.render = function() {
+    var o = this.state.status;
+    if (o === te)
+      return null;
+    var t = this.props, s = 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 u = ct(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ K.createElement(Qe.Provider, {
+        value: null
+      }, typeof s == "function" ? s(o, u) : K.cloneElement(K.Children.only(s), u))
+    );
+  }, n;
+}(K.Component);
+U.contextType = Qe;
+U.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: m.shape({
+    current: typeof Element > "u" ? m.any : function(e, n, i, r, o, t) {
+      var s = e[n];
+      return m.instanceOf(s && "ownerDocument" in s ? s.ownerDocument.defaultView.Element : Element)(e, n, i, r, o, 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: m.oneOfType([m.func.isRequired, m.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: m.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: m.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: m.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: m.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: m.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: m.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(n) {
+    var i = wt;
+    n.addEndListener || (i = i.isRequired);
+    for (var r = arguments.length, o = new Array(r > 1 ? r - 1 : 0), t = 1; t < r; t++)
+      o[t - 1] = arguments[t];
+    return i.apply(void 0, [n].concat(o));
+  },
+  /**
+   * 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: m.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: m.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: m.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: m.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: m.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: m.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: m.func
+} : {};
+function Z() {
+}
+U.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: Z,
+  onEntering: Z,
+  onEntered: Z,
+  onExit: Z,
+  onExiting: Z,
+  onExited: Z
+};
+U.UNMOUNTED = te;
+U.EXITED = G;
+U.ENTERING = B;
+U.ENTERED = X;
+U.EXITING = Pe;
+const At = U, Ie = !!(typeof window < "u" && window.document && window.document.createElement);
+var we = !1, je = !1;
+try {
+  var Oe = {
+    get passive() {
+      return we = !0;
+    },
+    get once() {
+      return je = we = !0;
+    }
+  };
+  Ie && (window.addEventListener("test", Oe, Oe), window.removeEventListener("test", Oe, !0));
+} catch {
+}
+function Dt(e, n, i, r) {
+  if (r && typeof r != "boolean" && !je) {
+    var o = r.once, t = r.capture, s = i;
+    !je && o && (s = i.__once || function u(d) {
+      this.removeEventListener(n, u, t), i.call(this, d);
+    }, i.__once = s), e.addEventListener(n, s, we ? r : t);
+  }
+  e.addEventListener(n, i, r);
+}
+function Mt(e, n, i, r) {
+  var o = r && typeof r != "boolean" ? r.capture : r;
+  e.removeEventListener(n, i, o), i.__once && e.removeEventListener(n, i.__once, o);
+}
+function et(e, n, i, r) {
+  return Dt(e, n, i, r), function() {
+    Mt(e, n, i, r);
+  };
+}
+function It(e, n, i, r) {
+  if (i === void 0 && (i = !1), r === void 0 && (r = !0), e) {
+    var o = document.createEvent("HTMLEvents");
+    o.initEvent(n, i, r), e.dispatchEvent(o);
+  }
+}
+function Lt(e) {
+  var n = He(e, "transitionDuration") || "", i = n.indexOf("ms") === -1 ? 1e3 : 1;
+  return parseFloat(n) * i;
+}
+function $t(e, n, i) {
+  i === void 0 && (i = 5);
+  var r = !1, o = setTimeout(function() {
+    r || It(e, "transitionend", !0);
+  }, n + i), t = et(e, "transitionend", function() {
+    r = !0;
+  }, {
+    once: !0
+  });
+  return function() {
+    clearTimeout(o), t();
+  };
+}
+function kt(e, n, i, r) {
+  i == null && (i = Lt(e) || 0);
+  var o = $t(e, i, r), t = et(e, "transitionend", n);
+  return function() {
+    o(), t();
+  };
+}
+function Ve(e, n) {
+  const i = He(e, n) || "", r = i.indexOf("ms") === -1 ? 1e3 : 1;
+  return parseFloat(i) * r;
+}
+function Nt(e, n) {
+  const i = Ve(e, "transitionDuration"), r = Ve(e, "transitionDelay"), o = kt(e, (t) => {
+    t.target === e && (o(), n(t));
+  }, i + r);
+}
+function qt(e) {
+  e.offsetHeight;
+}
+const Ge = (e) => !e || typeof e == "function" ? e : (n) => {
+  e.current = n;
+};
+function Wt(e, n) {
+  const i = Ge(e), r = Ge(n);
+  return (o) => {
+    i && i(o), r && r(o);
+  };
+}
+function fe(e, n) {
+  return ot(() => Wt(e, n), [e, n]);
+}
+function Yt(e) {
+  return e && "setState" in e ? ee.findDOMNode(e) : e ?? null;
+}
+const Ft = /* @__PURE__ */ K.forwardRef(({
+  onEnter: e,
+  onEntering: n,
+  onEntered: i,
+  onExit: r,
+  onExiting: o,
+  onExited: t,
+  addEndListener: s,
+  children: u,
+  childRef: d,
+  ...p
+}, v) => {
+  const y = Y(null), S = fe(y, d), A = (k) => {
+    S(Yt(k));
+  }, D = (k) => (z) => {
+    k && y.current && k(y.current, z);
+  }, w = $(D(e), [e]), I = $(D(n), [n]), L = $(D(i), [i]), F = $(D(r), [r]), M = $(D(o), [o]), j = $(D(t), [t]), c = $(D(s), [s]);
+  return /* @__PURE__ */ Q.jsx(At, {
+    ref: v,
+    ...p,
+    onEnter: w,
+    onEntered: L,
+    onEntering: I,
+    onExit: F,
+    onExited: j,
+    onExiting: M,
+    addEndListener: c,
+    nodeRef: y,
+    children: typeof u == "function" ? (k, z) => (
+      // TODO: Types for RTG missing innerProps, so need to cast.
+      u(k, {
+        ...z,
+        ref: A
+      })
+    ) : /* @__PURE__ */ K.cloneElement(u, {
+      ref: A
+    })
+  });
+}), Ut = Ft;
+function Bt(e) {
+  const n = Y(e);
+  return H(() => {
+    n.current = e;
+  }, [e]), n;
+}
+function tt(e) {
+  const n = Bt(e);
+  return $(function(...i) {
+    return n.current && n.current(...i);
+  }, [n]);
+}
+function vn() {
+  return Ae(null);
+}
+function yn() {
+  const e = Y(!0), n = Y(() => e.current);
+  return H(() => (e.current = !0, () => {
+    e.current = !1;
+  }), []), n.current;
+}
+const zt = typeof global < "u" && // @ts-ignore
+global.navigator && // @ts-ignore
+global.navigator.product === "ReactNative", Vt = typeof document < "u", Xe = Vt || zt ? it : H, Gt = {
+  [B]: "show",
+  [X]: "show"
+}, nt = /* @__PURE__ */ ue.forwardRef(({
+  className: e,
+  children: n,
+  transitionClasses: i = {},
+  onEnter: r,
+  ...o
+}, t) => {
+  const s = {
+    in: !1,
+    timeout: 300,
+    mountOnEnter: !1,
+    unmountOnExit: !1,
+    appear: !1,
+    ...o
+  }, u = $((d, p) => {
+    qt(d), r == null || r(d, p);
+  }, [r]);
+  return /* @__PURE__ */ Q.jsx(Ut, {
+    ref: t,
+    addEndListener: Nt,
+    ...s,
+    onEnter: u,
+    childRef: n.ref,
+    children: (d, p) => /* @__PURE__ */ ue.cloneElement(n, {
+      ...p,
+      className: ut("fade", e, n.props.className, Gt[d], i[d])
+    })
+  });
+});
+nt.displayName = "Fade";
+const En = nt;
+function Xt(e) {
+  const n = Y(e);
+  return n.current = e, n;
+}
+function mn(e) {
+  const n = Xt(e);
+  H(() => () => n.current(), []);
+}
+function hn(e, n) {
+  if (e.contains)
+    return e.contains(n);
+  if (e.compareDocumentPosition)
+    return e === n || !!(e.compareDocumentPosition(n) & 16);
+}
+const rt = /* @__PURE__ */ at(Ie ? window : void 0);
+rt.Provider;
+function Kt() {
+  return ne(rt);
+}
+const Se = (e, n) => Ie ? e == null ? (n || Ke()).body : (typeof e == "function" && (e = e()), e && "current" in e && (e = e.current), e && ("nodeType" in e || e.getBoundingClientRect) ? e : null) : null;
+function bn(e, n) {
+  const i = Kt(), [r, o] = Ae(() => Se(e, i == null ? void 0 : i.document));
+  if (!r) {
+    const t = Se(e);
+    t && o(t);
+  }
+  return H(() => {
+    n && r && n(r);
+  }, [n, r]), H(() => {
+    const t = Se(e);
+    t !== r && o(t);
+  }, [e, r]), r;
+}
+function Ht({
+  children: e,
+  in: n,
+  onExited: i,
+  mountOnEnter: r,
+  unmountOnExit: o
+}) {
+  const t = Y(null), s = Y(n), u = tt(i);
+  H(() => {
+    n ? s.current = !0 : u(t.current);
+  }, [n, u]);
+  const d = fe(t, e.ref), p = /* @__PURE__ */ De(e, {
+    ref: d
+  });
+  return n ? p : o || !s.current && r ? null : p;
+}
+const Jt = ["onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "addEndListener", "children"];
+function Zt(e, n) {
+  if (e == null)
+    return {};
+  var i = {}, r = Object.keys(e), o, t;
+  for (t = 0; t < r.length; t++)
+    o = r[t], !(n.indexOf(o) >= 0) && (i[o] = e[o]);
+  return i;
+}
+function Qt(e) {
+  let {
+    onEnter: n,
+    onEntering: i,
+    onEntered: r,
+    onExit: o,
+    onExiting: t,
+    onExited: s,
+    addEndListener: u,
+    children: d
+  } = e, p = Zt(e, Jt);
+  const v = Y(null), y = fe(v, typeof d == "function" ? null : d.ref), S = (j) => (c) => {
+    j && v.current && j(v.current, c);
+  }, A = $(S(n), [n]), D = $(S(i), [i]), w = $(S(r), [r]), I = $(S(o), [o]), L = $(S(t), [t]), F = $(S(s), [s]), M = $(S(u), [u]);
+  return Object.assign({}, p, {
+    nodeRef: v
+  }, n && {
+    onEnter: A
+  }, i && {
+    onEntering: D
+  }, r && {
+    onEntered: w
+  }, o && {
+    onExit: I
+  }, t && {
+    onExiting: L
+  }, s && {
+    onExited: F
+  }, u && {
+    addEndListener: M
+  }, {
+    children: typeof d == "function" ? (j, c) => (
+      // TODO: Types for RTG missing innerProps, so need to cast.
+      d(j, Object.assign({}, c, {
+        ref: y
+      }))
+    ) : /* @__PURE__ */ De(d, {
+      ref: y
+    })
+  });
+}
+const en = ["component"];
+function tn(e, n) {
+  if (e == null)
+    return {};
+  var i = {}, r = Object.keys(e), o, t;
+  for (t = 0; t < r.length; t++)
+    o = r[t], !(n.indexOf(o) >= 0) && (i[o] = e[o]);
+  return i;
+}
+const nn = /* @__PURE__ */ ue.forwardRef((e, n) => {
+  let {
+    component: i
+  } = e, r = tn(e, en);
+  const o = Qt(r);
+  return /* @__PURE__ */ Q.jsx(i, Object.assign({
+    ref: n
+  }, o));
+}), rn = nn;
+function on({
+  in: e,
+  onTransition: n
+}) {
+  const i = Y(null), r = Y(!0), o = tt(n);
+  return Xe(() => {
+    if (!i.current)
+      return;
+    let t = !1;
+    return o({
+      in: e,
+      element: i.current,
+      initial: r.current,
+      isStale: () => t
+    }), () => {
+      t = !0;
+    };
+  }, [e, o]), Xe(() => (r.current = !1, () => {
+    r.current = !0;
+  }), []), i;
+}
+function an({
+  children: e,
+  in: n,
+  onExited: i,
+  onEntered: r,
+  transition: o
+}) {
+  const [t, s] = Ae(!n);
+  n && t && s(!1);
+  const u = on({
+    in: !!n,
+    onTransition: (p) => {
+      const v = () => {
+        p.isStale() || (p.in ? r == null || r(p.element, p.initial) : (s(!0), i == null || i(p.element)));
+      };
+      Promise.resolve(o(p)).then(v, (y) => {
+        throw p.in || s(!0), y;
+      });
+    }
+  }), d = fe(u, e.ref);
+  return t && !n ? null : /* @__PURE__ */ De(e, {
+    ref: d
+  });
+}
+function xn(e, n, i) {
+  return e ? /* @__PURE__ */ Q.jsx(rn, Object.assign({}, i, {
+    component: e
+  })) : n ? /* @__PURE__ */ Q.jsx(an, Object.assign({}, i, {
+    transition: n
+  })) : /* @__PURE__ */ Q.jsx(Ht, Object.assign({}, i));
+}
+function Tn(e) {
+  return e.code === "Escape" || e.keyCode === 27;
+}
+function gn(e, n) {
+  return e.classList ? !!n && e.classList.contains(n) : (" " + (e.className.baseVal || e.className) + " ").indexOf(" " + n + " ") !== -1;
+}
+export {
+  Yt as A,
+  ln as B,
+  dn as C,
+  G as E,
+  En as F,
+  m as P,
+  Ut as T,
+  ct as _,
+  Pe as a,
+  B as b,
+  X as c,
+  qt as d,
+  Ie as e,
+  bn as f,
+  yn as g,
+  tt as h,
+  hn as i,
+  mn as j,
+  Tn as k,
+  et as l,
+  gn as m,
+  fn as n,
+  Ke as o,
+  vn as p,
+  fe as q,
+  xn as r,
+  He as s,
+  Nt as t,
+  Kt as u,
+  pn as v,
+  Mt as w,
+  Dt as x,
+  kt as y,
+  Xe as z
+};