@uoguelph/react-components 1.9.1 → 1.10.0-rc.0

package/dist/toaster.js

@@ -0,0 +1,1506 @@
+"use client";
+import { jsxs as Ge, jsx as F } from "react/jsx-runtime";
+import { e as Qe, d as Ke, o as et, g as tt } from "./solid-CpJcQLq3.js";
+import { FontAwesomeIcon as re } from "@fortawesome/react-fontawesome";
+import k, { isValidElement as ae, cloneElement as se, Children as rt, useState as Xe, useCallback as Ie, useContext as nt, useRef as ot, useEffect as it } from "react";
+import { twJoin as at } from "tailwind-merge";
+import { tv as st } from "tailwind-variants";
+import { ToastContext as Be } from "./toaster-context.js";
+import { g as ut } from "./_commonjsHelpers-C6fGbg64.js";
+import ne from "react-dom";
+function Q() {
+  return Q = Object.assign ? Object.assign.bind() : function(e) {
+    for (var a = 1; a < arguments.length; a++) {
+      var s = arguments[a];
+      for (var r in s) ({}).hasOwnProperty.call(s, r) && (e[r] = s[r]);
+    }
+    return e;
+  }, Q.apply(null, arguments);
+}
+function Re(e, a) {
+  if (e == null) return {};
+  var s = {};
+  for (var r in e) if ({}.hasOwnProperty.call(e, r)) {
+    if (a.indexOf(r) !== -1) continue;
+    s[r] = e[r];
+  }
+  return s;
+}
+function Oe(e, a) {
+  return Oe = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(s, r) {
+    return s.__proto__ = r, s;
+  }, Oe(e, a);
+}
+function Pe(e, a) {
+  e.prototype = Object.create(a.prototype), e.prototype.constructor = e, Oe(e, a);
+}
+var oe = { exports: {} }, ie = { exports: {} }, S = {};
+var je;
+function ct() {
+  if (je) return S;
+  je = 1;
+  var e = typeof Symbol == "function" && Symbol.for, a = e ? /* @__PURE__ */ Symbol.for("react.element") : 60103, s = e ? /* @__PURE__ */ Symbol.for("react.portal") : 60106, r = e ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107, n = e ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108, t = e ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114, i = e ? /* @__PURE__ */ Symbol.for("react.provider") : 60109, o = e ? /* @__PURE__ */ Symbol.for("react.context") : 60110, u = e ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111, f = e ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111, v = e ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112, m = e ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113, _ = e ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120, A = e ? /* @__PURE__ */ Symbol.for("react.memo") : 60115, $ = e ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116, w = e ? /* @__PURE__ */ Symbol.for("react.block") : 60121, I = e ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117, D = e ? /* @__PURE__ */ Symbol.for("react.responder") : 60118, J = e ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
+  function M(p) {
+    if (typeof p == "object" && p !== null) {
+      var W = p.$$typeof;
+      switch (W) {
+        case a:
+          switch (p = p.type, p) {
+            case u:
+            case f:
+            case r:
+            case t:
+            case n:
+            case m:
+              return p;
+            default:
+              switch (p = p && p.$$typeof, p) {
+                case o:
+                case v:
+                case $:
+                case A:
+                case i:
+                  return p;
+                default:
+                  return W;
+              }
+          }
+        case s:
+          return W;
+      }
+    }
+  }
+  function N(p) {
+    return M(p) === f;
+  }
+  return S.AsyncMode = u, S.ConcurrentMode = f, S.ContextConsumer = o, S.ContextProvider = i, S.Element = a, S.ForwardRef = v, S.Fragment = r, S.Lazy = $, S.Memo = A, S.Portal = s, S.Profiler = t, S.StrictMode = n, S.Suspense = m, S.isAsyncMode = function(p) {
+    return N(p) || M(p) === u;
+  }, S.isConcurrentMode = N, S.isContextConsumer = function(p) {
+    return M(p) === o;
+  }, S.isContextProvider = function(p) {
+    return M(p) === i;
+  }, S.isElement = function(p) {
+    return typeof p == "object" && p !== null && p.$$typeof === a;
+  }, S.isForwardRef = function(p) {
+    return M(p) === v;
+  }, S.isFragment = function(p) {
+    return M(p) === r;
+  }, S.isLazy = function(p) {
+    return M(p) === $;
+  }, S.isMemo = function(p) {
+    return M(p) === A;
+  }, S.isPortal = function(p) {
+    return M(p) === s;
+  }, S.isProfiler = function(p) {
+    return M(p) === t;
+  }, S.isStrictMode = function(p) {
+    return M(p) === n;
+  }, S.isSuspense = function(p) {
+    return M(p) === m;
+  }, S.isValidElementType = function(p) {
+    return typeof p == "string" || typeof p == "function" || p === r || p === f || p === t || p === n || p === m || p === _ || typeof p == "object" && p !== null && (p.$$typeof === $ || p.$$typeof === A || p.$$typeof === i || p.$$typeof === o || p.$$typeof === v || p.$$typeof === I || p.$$typeof === D || p.$$typeof === J || p.$$typeof === w);
+  }, S.typeOf = M, S;
+}
+var R = {};
+var $e;
+function ft() {
+  return $e || ($e = 1, process.env.NODE_ENV !== "production" && (function() {
+    var e = typeof Symbol == "function" && Symbol.for, a = e ? /* @__PURE__ */ Symbol.for("react.element") : 60103, s = e ? /* @__PURE__ */ Symbol.for("react.portal") : 60106, r = e ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107, n = e ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108, t = e ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114, i = e ? /* @__PURE__ */ Symbol.for("react.provider") : 60109, o = e ? /* @__PURE__ */ Symbol.for("react.context") : 60110, u = e ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111, f = e ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111, v = e ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112, m = e ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113, _ = e ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120, A = e ? /* @__PURE__ */ Symbol.for("react.memo") : 60115, $ = e ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116, w = e ? /* @__PURE__ */ Symbol.for("react.block") : 60121, I = e ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117, D = e ? /* @__PURE__ */ Symbol.for("react.responder") : 60118, J = e ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
+    function M(l) {
+      return typeof l == "string" || typeof l == "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+      l === r || l === f || l === t || l === n || l === m || l === _ || typeof l == "object" && l !== null && (l.$$typeof === $ || l.$$typeof === A || l.$$typeof === i || l.$$typeof === o || l.$$typeof === v || l.$$typeof === I || l.$$typeof === D || l.$$typeof === J || l.$$typeof === w);
+    }
+    function N(l) {
+      if (typeof l == "object" && l !== null) {
+        var L = l.$$typeof;
+        switch (L) {
+          case a:
+            var te = l.type;
+            switch (te) {
+              case u:
+              case f:
+              case r:
+              case t:
+              case n:
+              case m:
+                return te;
+              default:
+                var Me = te && te.$$typeof;
+                switch (Me) {
+                  case o:
+                  case v:
+                  case $:
+                  case A:
+                  case i:
+                    return Me;
+                  default:
+                    return L;
+                }
+            }
+          case s:
+            return L;
+        }
+      }
+    }
+    var p = u, W = f, ce = o, fe = i, le = a, pe = v, K = r, de = $, ve = A, X = s, he = t, q = n, U = m, ee = !1;
+    function me(l) {
+      return ee || (ee = !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.")), c(l) || N(l) === u;
+    }
+    function c(l) {
+      return N(l) === f;
+    }
+    function d(l) {
+      return N(l) === o;
+    }
+    function x(l) {
+      return N(l) === i;
+    }
+    function g(l) {
+      return typeof l == "object" && l !== null && l.$$typeof === a;
+    }
+    function E(l) {
+      return N(l) === v;
+    }
+    function T(l) {
+      return N(l) === r;
+    }
+    function y(l) {
+      return N(l) === $;
+    }
+    function b(l) {
+      return N(l) === A;
+    }
+    function C(l) {
+      return N(l) === s;
+    }
+    function P(l) {
+      return N(l) === t;
+    }
+    function O(l) {
+      return N(l) === n;
+    }
+    function j(l) {
+      return N(l) === m;
+    }
+    R.AsyncMode = p, R.ConcurrentMode = W, R.ContextConsumer = ce, R.ContextProvider = fe, R.Element = le, R.ForwardRef = pe, R.Fragment = K, R.Lazy = de, R.Memo = ve, R.Portal = X, R.Profiler = he, R.StrictMode = q, R.Suspense = U, R.isAsyncMode = me, R.isConcurrentMode = c, R.isContextConsumer = d, R.isContextProvider = x, R.isElement = g, R.isForwardRef = E, R.isFragment = T, R.isLazy = y, R.isMemo = b, R.isPortal = C, R.isProfiler = P, R.isStrictMode = O, R.isSuspense = j, R.isValidElementType = M, R.typeOf = N;
+  })()), R;
+}
+var De;
+function He() {
+  return De || (De = 1, process.env.NODE_ENV === "production" ? ie.exports = ct() : ie.exports = ft()), ie.exports;
+}
+var Ee, ke;
+function lt() {
+  if (ke) return Ee;
+  ke = 1;
+  var e = Object.getOwnPropertySymbols, a = Object.prototype.hasOwnProperty, s = 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 n() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var t = new String("abc");
+      if (t[5] = "de", Object.getOwnPropertyNames(t)[0] === "5")
+        return !1;
+      for (var i = {}, o = 0; o < 10; o++)
+        i["_" + String.fromCharCode(o)] = o;
+      var u = Object.getOwnPropertyNames(i).map(function(v) {
+        return i[v];
+      });
+      if (u.join("") !== "0123456789")
+        return !1;
+      var f = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(v) {
+        f[v] = v;
+      }), Object.keys(Object.assign({}, f)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return Ee = n() ? Object.assign : function(t, i) {
+    for (var o, u = r(t), f, v = 1; v < arguments.length; v++) {
+      o = Object(arguments[v]);
+      for (var m in o)
+        a.call(o, m) && (u[m] = o[m]);
+      if (e) {
+        f = e(o);
+        for (var _ = 0; _ < f.length; _++)
+          s.call(o, f[_]) && (u[f[_]] = o[f[_]]);
+      }
+    }
+    return u;
+  }, Ee;
+}
+var ye, qe;
+function _e() {
+  if (qe) return ye;
+  qe = 1;
+  var e = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return ye = e, ye;
+}
+var ge, Le;
+function Je() {
+  return Le || (Le = 1, ge = Function.call.bind(Object.prototype.hasOwnProperty)), ge;
+}
+var be, Fe;
+function pt() {
+  if (Fe) return be;
+  Fe = 1;
+  var e = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var a = /* @__PURE__ */ _e(), s = {}, r = /* @__PURE__ */ Je();
+    e = function(t) {
+      var i = "Warning: " + t;
+      typeof console < "u" && console.error(i);
+      try {
+        throw new Error(i);
+      } catch {
+      }
+    };
+  }
+  function n(t, i, o, u, f) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var v in t)
+        if (r(t, v)) {
+          var m;
+          try {
+            if (typeof t[v] != "function") {
+              var _ = Error(
+                (u || "React class") + ": " + o + " 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 _.name = "Invariant Violation", _;
+            }
+            m = t[v](i, v, u, o, null, a);
+          } catch ($) {
+            m = $;
+          }
+          if (m && !(m instanceof Error) && e(
+            (u || "React class") + ": type specification of " + o + " `" + v + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof m + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), m instanceof Error && !(m.message in s)) {
+            s[m.message] = !0;
+            var A = f ? f() : "";
+            e(
+              "Failed " + o + " type: " + m.message + (A ?? "")
+            );
+          }
+        }
+    }
+  }
+  return n.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (s = {});
+  }, be = n, be;
+}
+var xe, Ye;
+function dt() {
+  if (Ye) return xe;
+  Ye = 1;
+  var e = He(), a = lt(), s = /* @__PURE__ */ _e(), r = /* @__PURE__ */ Je(), n = /* @__PURE__ */ pt(), t = function() {
+  };
+  process.env.NODE_ENV !== "production" && (t = function(o) {
+    var u = "Warning: " + o;
+    typeof console < "u" && console.error(u);
+    try {
+      throw new Error(u);
+    } catch {
+    }
+  });
+  function i() {
+    return null;
+  }
+  return xe = function(o, u) {
+    var f = typeof Symbol == "function" && Symbol.iterator, v = "@@iterator";
+    function m(c) {
+      var d = c && (f && c[f] || c[v]);
+      if (typeof d == "function")
+        return d;
+    }
+    var _ = "<<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: J(),
+      arrayOf: M,
+      element: N(),
+      elementType: p(),
+      instanceOf: W,
+      node: pe(),
+      objectOf: fe,
+      oneOf: ce,
+      oneOfType: le,
+      shape: de,
+      exact: ve
+    };
+    function $(c, d) {
+      return c === d ? c !== 0 || 1 / c === 1 / d : c !== c && d !== d;
+    }
+    function w(c, d) {
+      this.message = c, this.data = d && typeof d == "object" ? d : {}, this.stack = "";
+    }
+    w.prototype = Error.prototype;
+    function I(c) {
+      if (process.env.NODE_ENV !== "production")
+        var d = {}, x = 0;
+      function g(T, y, b, C, P, O, j) {
+        if (C = C || _, O = O || b, j !== s) {
+          if (u) {
+            var l = 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 l.name = "Invariant Violation", l;
+          } 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 y[b] == null ? T ? y[b] === null ? new w("The " + P + " `" + O + "` is marked as required " + ("in `" + C + "`, but its value is `null`.")) : new w("The " + P + " `" + O + "` is marked as required in " + ("`" + C + "`, but its value is `undefined`.")) : null : c(y, b, C, P, O);
+      }
+      var E = g.bind(null, !1);
+      return E.isRequired = g.bind(null, !0), E;
+    }
+    function D(c) {
+      function d(x, g, E, T, y, b) {
+        var C = x[g], P = q(C);
+        if (P !== c) {
+          var O = U(C);
+          return new w(
+            "Invalid " + T + " `" + y + "` of type " + ("`" + O + "` supplied to `" + E + "`, expected ") + ("`" + c + "`."),
+            { expectedType: c }
+          );
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function J() {
+      return I(i);
+    }
+    function M(c) {
+      function d(x, g, E, T, y) {
+        if (typeof c != "function")
+          return new w("Property `" + y + "` of component `" + E + "` has invalid PropType notation inside arrayOf.");
+        var b = x[g];
+        if (!Array.isArray(b)) {
+          var C = q(b);
+          return new w("Invalid " + T + " `" + y + "` of type " + ("`" + C + "` supplied to `" + E + "`, expected an array."));
+        }
+        for (var P = 0; P < b.length; P++) {
+          var O = c(b, P, E, T, y + "[" + P + "]", s);
+          if (O instanceof Error)
+            return O;
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function N() {
+      function c(d, x, g, E, T) {
+        var y = d[x];
+        if (!o(y)) {
+          var b = q(y);
+          return new w("Invalid " + E + " `" + T + "` of type " + ("`" + b + "` supplied to `" + g + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return I(c);
+    }
+    function p() {
+      function c(d, x, g, E, T) {
+        var y = d[x];
+        if (!e.isValidElementType(y)) {
+          var b = q(y);
+          return new w("Invalid " + E + " `" + T + "` of type " + ("`" + b + "` supplied to `" + g + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return I(c);
+    }
+    function W(c) {
+      function d(x, g, E, T, y) {
+        if (!(x[g] instanceof c)) {
+          var b = c.name || _, C = me(x[g]);
+          return new w("Invalid " + T + " `" + y + "` of type " + ("`" + C + "` supplied to `" + E + "`, expected ") + ("instance of `" + b + "`."));
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function ce(c) {
+      if (!Array.isArray(c))
+        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.")), i;
+      function d(x, g, E, T, y) {
+        for (var b = x[g], C = 0; C < c.length; C++)
+          if ($(b, c[C]))
+            return null;
+        var P = JSON.stringify(c, function(j, l) {
+          var L = U(l);
+          return L === "symbol" ? String(l) : l;
+        });
+        return new w("Invalid " + T + " `" + y + "` of value `" + String(b) + "` " + ("supplied to `" + E + "`, expected one of " + P + "."));
+      }
+      return I(d);
+    }
+    function fe(c) {
+      function d(x, g, E, T, y) {
+        if (typeof c != "function")
+          return new w("Property `" + y + "` of component `" + E + "` has invalid PropType notation inside objectOf.");
+        var b = x[g], C = q(b);
+        if (C !== "object")
+          return new w("Invalid " + T + " `" + y + "` of type " + ("`" + C + "` supplied to `" + E + "`, expected an object."));
+        for (var P in b)
+          if (r(b, P)) {
+            var O = c(b, P, E, T, y + "." + P, s);
+            if (O instanceof Error)
+              return O;
+          }
+        return null;
+      }
+      return I(d);
+    }
+    function le(c) {
+      if (!Array.isArray(c))
+        return process.env.NODE_ENV !== "production" && t("Invalid argument supplied to oneOfType, expected an instance of array."), i;
+      for (var d = 0; d < c.length; d++) {
+        var x = c[d];
+        if (typeof x != "function")
+          return t(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + ee(x) + " at index " + d + "."
+          ), i;
+      }
+      function g(E, T, y, b, C) {
+        for (var P = [], O = 0; O < c.length; O++) {
+          var j = c[O], l = j(E, T, y, b, C, s);
+          if (l == null)
+            return null;
+          l.data && r(l.data, "expectedType") && P.push(l.data.expectedType);
+        }
+        var L = P.length > 0 ? ", expected one of type [" + P.join(", ") + "]" : "";
+        return new w("Invalid " + b + " `" + C + "` supplied to " + ("`" + y + "`" + L + "."));
+      }
+      return I(g);
+    }
+    function pe() {
+      function c(d, x, g, E, T) {
+        return X(d[x]) ? null : new w("Invalid " + E + " `" + T + "` supplied to " + ("`" + g + "`, expected a ReactNode."));
+      }
+      return I(c);
+    }
+    function K(c, d, x, g, E) {
+      return new w(
+        (c || "React class") + ": " + d + " type `" + x + "." + g + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + E + "`."
+      );
+    }
+    function de(c) {
+      function d(x, g, E, T, y) {
+        var b = x[g], C = q(b);
+        if (C !== "object")
+          return new w("Invalid " + T + " `" + y + "` of type `" + C + "` " + ("supplied to `" + E + "`, expected `object`."));
+        for (var P in c) {
+          var O = c[P];
+          if (typeof O != "function")
+            return K(E, T, y, P, U(O));
+          var j = O(b, P, E, T, y + "." + P, s);
+          if (j)
+            return j;
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function ve(c) {
+      function d(x, g, E, T, y) {
+        var b = x[g], C = q(b);
+        if (C !== "object")
+          return new w("Invalid " + T + " `" + y + "` of type `" + C + "` " + ("supplied to `" + E + "`, expected `object`."));
+        var P = a({}, x[g], c);
+        for (var O in P) {
+          var j = c[O];
+          if (r(c, O) && typeof j != "function")
+            return K(E, T, y, O, U(j));
+          if (!j)
+            return new w(
+              "Invalid " + T + " `" + y + "` key `" + O + "` supplied to `" + E + "`.\nBad object: " + JSON.stringify(x[g], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(c), null, "  ")
+            );
+          var l = j(b, O, E, T, y + "." + O, s);
+          if (l)
+            return l;
+        }
+        return null;
+      }
+      return I(d);
+    }
+    function X(c) {
+      switch (typeof c) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !c;
+        case "object":
+          if (Array.isArray(c))
+            return c.every(X);
+          if (c === null || o(c))
+            return !0;
+          var d = m(c);
+          if (d) {
+            var x = d.call(c), g;
+            if (d !== c.entries) {
+              for (; !(g = x.next()).done; )
+                if (!X(g.value))
+                  return !1;
+            } else
+              for (; !(g = x.next()).done; ) {
+                var E = g.value;
+                if (E && !X(E[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function he(c, d) {
+      return c === "symbol" ? !0 : d ? d["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && d instanceof Symbol : !1;
+    }
+    function q(c) {
+      var d = typeof c;
+      return Array.isArray(c) ? "array" : c instanceof RegExp ? "object" : he(d, c) ? "symbol" : d;
+    }
+    function U(c) {
+      if (typeof c > "u" || c === null)
+        return "" + c;
+      var d = q(c);
+      if (d === "object") {
+        if (c instanceof Date)
+          return "date";
+        if (c instanceof RegExp)
+          return "regexp";
+      }
+      return d;
+    }
+    function ee(c) {
+      var d = U(c);
+      switch (d) {
+        case "array":
+        case "object":
+          return "an " + d;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + d;
+        default:
+          return d;
+      }
+    }
+    function me(c) {
+      return !c.constructor || !c.constructor.name ? _ : c.constructor.name;
+    }
+    return A.checkPropTypes = n, A.resetWarningCache = n.resetWarningCache, A.PropTypes = A, A;
+  }, xe;
+}
+var Te, We;
+function vt() {
+  if (We) return Te;
+  We = 1;
+  var e = /* @__PURE__ */ _e();
+  function a() {
+  }
+  function s() {
+  }
+  return s.resetWarningCache = a, Te = function() {
+    function r(i, o, u, f, v, m) {
+      if (m !== e) {
+        var _ = 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 _.name = "Invariant Violation", _;
+      }
+    }
+    r.isRequired = r;
+    function n() {
+      return r;
+    }
+    var t = {
+      array: r,
+      bigint: r,
+      bool: r,
+      func: r,
+      number: r,
+      object: r,
+      string: r,
+      symbol: r,
+      any: r,
+      arrayOf: n,
+      element: r,
+      elementType: r,
+      instanceOf: n,
+      node: r,
+      objectOf: n,
+      oneOf: n,
+      oneOfType: n,
+      shape: n,
+      exact: n,
+      checkPropTypes: s,
+      resetWarningCache: a
+    };
+    return t.PropTypes = t, t;
+  }, Te;
+}
+var Ue;
+function ht() {
+  if (Ue) return oe.exports;
+  if (Ue = 1, process.env.NODE_ENV !== "production") {
+    var e = He(), a = !0;
+    oe.exports = /* @__PURE__ */ dt()(e.isElement, a);
+  } else
+    oe.exports = /* @__PURE__ */ vt()();
+  return oe.exports;
+}
+var mt = /* @__PURE__ */ ht();
+const h = /* @__PURE__ */ ut(mt);
+function Et(e, a) {
+  return e.classList ? !!a && e.classList.contains(a) : (" " + (e.className.baseVal || e.className) + " ").indexOf(" " + a + " ") !== -1;
+}
+function yt(e, a) {
+  e.classList ? e.classList.add(a) : Et(e, a) || (typeof e.className == "string" ? e.className = e.className + " " + a : e.setAttribute("class", (e.className && e.className.baseVal || "") + " " + a));
+}
+function Ve(e, a) {
+  return e.replace(new RegExp("(^|\\s)" + a + "(?:\\s|$)", "g"), "$1").replace(/\s+/g, " ").replace(/^\s*|\s*$/g, "");
+}
+function gt(e, a) {
+  e.classList ? e.classList.remove(a) : typeof e.className == "string" ? e.className = Ve(e.className, a) : e.setAttribute("class", Ve(e.className && e.className.baseVal || "", a));
+}
+const ze = {
+  disabled: !1
+};
+var bt = process.env.NODE_ENV !== "production" ? h.oneOfType([h.number, h.shape({
+  enter: h.number,
+  exit: h.number,
+  appear: h.number
+}).isRequired]) : null, xt = process.env.NODE_ENV !== "production" ? h.oneOfType([h.string, h.shape({
+  enter: h.string,
+  exit: h.string,
+  active: h.string
+}), h.shape({
+  enter: h.string,
+  enterDone: h.string,
+  enterActive: h.string,
+  exit: h.string,
+  exitDone: h.string,
+  exitActive: h.string
+})]) : null;
+const ue = k.createContext(null);
+var Ze = function(a) {
+  return a.scrollTop;
+}, Z = "unmounted", V = "exited", z = "entering", H = "entered", Se = "exiting", Y = /* @__PURE__ */ (function(e) {
+  Pe(a, e);
+  function a(r, n) {
+    var t;
+    t = e.call(this, r, n) || this;
+    var i = n, o = i && !i.isMounting ? r.enter : r.appear, u;
+    return t.appearStatus = null, r.in ? o ? (u = V, t.appearStatus = z) : u = H : r.unmountOnExit || r.mountOnEnter ? u = Z : u = V, t.state = {
+      status: u
+    }, t.nextCallback = null, t;
+  }
+  a.getDerivedStateFromProps = function(n, t) {
+    var i = n.in;
+    return i && t.status === Z ? {
+      status: V
+    } : null;
+  };
+  var s = a.prototype;
+  return s.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, s.componentDidUpdate = function(n) {
+    var t = null;
+    if (n !== this.props) {
+      var i = this.state.status;
+      this.props.in ? i !== z && i !== H && (t = z) : (i === z || i === H) && (t = Se);
+    }
+    this.updateStatus(!1, t);
+  }, s.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, s.getTimeouts = function() {
+    var n = this.props.timeout, t, i, o;
+    return t = i = o = n, n != null && typeof n != "number" && (t = n.exit, i = n.enter, o = n.appear !== void 0 ? n.appear : i), {
+      exit: t,
+      enter: i,
+      appear: o
+    };
+  }, s.updateStatus = function(n, t) {
+    if (n === void 0 && (n = !1), t !== null)
+      if (this.cancelNextCallback(), t === z) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var i = this.props.nodeRef ? this.props.nodeRef.current : ne.findDOMNode(this);
+          i && Ze(i);
+        }
+        this.performEnter(n);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === V && this.setState({
+      status: Z
+    });
+  }, s.performEnter = function(n) {
+    var t = this, i = this.props.enter, o = this.context ? this.context.isMounting : n, u = this.props.nodeRef ? [o] : [ne.findDOMNode(this), o], f = u[0], v = u[1], m = this.getTimeouts(), _ = o ? m.appear : m.enter;
+    if (!n && !i || ze.disabled) {
+      this.safeSetState({
+        status: H
+      }, function() {
+        t.props.onEntered(f);
+      });
+      return;
+    }
+    this.props.onEnter(f, v), this.safeSetState({
+      status: z
+    }, function() {
+      t.props.onEntering(f, v), t.onTransitionEnd(_, function() {
+        t.safeSetState({
+          status: H
+        }, function() {
+          t.props.onEntered(f, v);
+        });
+      });
+    });
+  }, s.performExit = function() {
+    var n = this, t = this.props.exit, i = this.getTimeouts(), o = this.props.nodeRef ? void 0 : ne.findDOMNode(this);
+    if (!t || ze.disabled) {
+      this.safeSetState({
+        status: V
+      }, function() {
+        n.props.onExited(o);
+      });
+      return;
+    }
+    this.props.onExit(o), this.safeSetState({
+      status: Se
+    }, function() {
+      n.props.onExiting(o), n.onTransitionEnd(i.exit, function() {
+        n.safeSetState({
+          status: V
+        }, function() {
+          n.props.onExited(o);
+        });
+      });
+    });
+  }, s.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, s.safeSetState = function(n, t) {
+    t = this.setNextCallback(t), this.setState(n, t);
+  }, s.setNextCallback = function(n) {
+    var t = this, i = !0;
+    return this.nextCallback = function(o) {
+      i && (i = !1, t.nextCallback = null, n(o));
+    }, this.nextCallback.cancel = function() {
+      i = !1;
+    }, this.nextCallback;
+  }, s.onTransitionEnd = function(n, t) {
+    this.setNextCallback(t);
+    var i = this.props.nodeRef ? this.props.nodeRef.current : ne.findDOMNode(this), o = n == null && !this.props.addEndListener;
+    if (!i || o) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var u = this.props.nodeRef ? [this.nextCallback] : [i, this.nextCallback], f = u[0], v = u[1];
+      this.props.addEndListener(f, v);
+    }
+    n != null && setTimeout(this.nextCallback, n);
+  }, s.render = function() {
+    var n = this.state.status;
+    if (n === Z)
+      return null;
+    var t = this.props, i = 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 o = Re(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(ue.Provider, {
+        value: null
+      }, typeof i == "function" ? i(n, o) : k.cloneElement(k.Children.only(i), o))
+    );
+  }, a;
+})(k.Component);
+Y.contextType = ue;
+Y.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: h.shape({
+    current: typeof Element > "u" ? h.any : function(e, a, s, r, n, t) {
+      var i = e[a];
+      return h.instanceOf(i && "ownerDocument" in i ? i.ownerDocument.defaultView.Element : Element)(e, a, s, r, n, 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: h.oneOfType([h.func.isRequired, h.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: h.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: h.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: h.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: h.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: h.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: h.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(a) {
+    var s = bt;
+    a.addEndListener || (s = s.isRequired);
+    for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), t = 1; t < r; t++)
+      n[t - 1] = arguments[t];
+    return s.apply(void 0, [a].concat(n));
+  },
+  /**
+   * 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: h.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: h.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: h.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: h.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: h.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: h.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: h.func
+} : {};
+function B() {
+}
+Y.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: B,
+  onEntering: B,
+  onEntered: B,
+  onExit: B,
+  onExiting: B,
+  onExited: B
+};
+Y.UNMOUNTED = Z;
+Y.EXITED = V;
+Y.ENTERING = z;
+Y.ENTERED = H;
+Y.EXITING = Se;
+var Tt = function(a, s) {
+  return a && s && s.split(" ").forEach(function(r) {
+    return yt(a, r);
+  });
+}, Ce = function(a, s) {
+  return a && s && s.split(" ").forEach(function(r) {
+    return gt(a, r);
+  });
+}, we = /* @__PURE__ */ (function(e) {
+  Pe(a, e);
+  function a() {
+    for (var r, n = arguments.length, t = new Array(n), i = 0; i < n; i++)
+      t[i] = arguments[i];
+    return r = e.call.apply(e, [this].concat(t)) || this, r.appliedClasses = {
+      appear: {},
+      enter: {},
+      exit: {}
+    }, r.onEnter = function(o, u) {
+      var f = r.resolveArguments(o, u), v = f[0], m = f[1];
+      r.removeClasses(v, "exit"), r.addClass(v, m ? "appear" : "enter", "base"), r.props.onEnter && r.props.onEnter(o, u);
+    }, r.onEntering = function(o, u) {
+      var f = r.resolveArguments(o, u), v = f[0], m = f[1], _ = m ? "appear" : "enter";
+      r.addClass(v, _, "active"), r.props.onEntering && r.props.onEntering(o, u);
+    }, r.onEntered = function(o, u) {
+      var f = r.resolveArguments(o, u), v = f[0], m = f[1], _ = m ? "appear" : "enter";
+      r.removeClasses(v, _), r.addClass(v, _, "done"), r.props.onEntered && r.props.onEntered(o, u);
+    }, r.onExit = function(o) {
+      var u = r.resolveArguments(o), f = u[0];
+      r.removeClasses(f, "appear"), r.removeClasses(f, "enter"), r.addClass(f, "exit", "base"), r.props.onExit && r.props.onExit(o);
+    }, r.onExiting = function(o) {
+      var u = r.resolveArguments(o), f = u[0];
+      r.addClass(f, "exit", "active"), r.props.onExiting && r.props.onExiting(o);
+    }, r.onExited = function(o) {
+      var u = r.resolveArguments(o), f = u[0];
+      r.removeClasses(f, "exit"), r.addClass(f, "exit", "done"), r.props.onExited && r.props.onExited(o);
+    }, r.resolveArguments = function(o, u) {
+      return r.props.nodeRef ? [r.props.nodeRef.current, o] : [o, u];
+    }, r.getClassNames = function(o) {
+      var u = r.props.classNames, f = typeof u == "string", v = f && u ? u + "-" : "", m = f ? "" + v + o : u[o], _ = f ? m + "-active" : u[o + "Active"], A = f ? m + "-done" : u[o + "Done"];
+      return {
+        baseClassName: m,
+        activeClassName: _,
+        doneClassName: A
+      };
+    }, r;
+  }
+  var s = a.prototype;
+  return s.addClass = function(n, t, i) {
+    var o = this.getClassNames(t)[i + "ClassName"], u = this.getClassNames("enter"), f = u.doneClassName;
+    t === "appear" && i === "done" && f && (o += " " + f), i === "active" && n && Ze(n), o && (this.appliedClasses[t][i] = o, Tt(n, o));
+  }, s.removeClasses = function(n, t) {
+    var i = this.appliedClasses[t], o = i.base, u = i.active, f = i.done;
+    this.appliedClasses[t] = {}, o && Ce(n, o), u && Ce(n, u), f && Ce(n, f);
+  }, s.render = function() {
+    var n = this.props;
+    n.classNames;
+    var t = Re(n, ["classNames"]);
+    return /* @__PURE__ */ k.createElement(Y, Q({}, t, {
+      onEnter: this.onEnter,
+      onEntered: this.onEntered,
+      onEntering: this.onEntering,
+      onExit: this.onExit,
+      onExiting: this.onExiting,
+      onExited: this.onExited
+    }));
+  }, a;
+})(k.Component);
+we.defaultProps = {
+  classNames: ""
+};
+we.propTypes = process.env.NODE_ENV !== "production" ? Q({}, Y.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: xt,
+  /**
+   * 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: h.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: h.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: h.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: h.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: h.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: h.func
+}) : {};
+function Ct(e) {
+  if (e === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function Ae(e, a) {
+  var s = function(t) {
+    return a && ae(t) ? a(t) : t;
+  }, r = /* @__PURE__ */ Object.create(null);
+  return e && rt.map(e, function(n) {
+    return n;
+  }).forEach(function(n) {
+    r[n.key] = s(n);
+  }), r;
+}
+function Ot(e, a) {
+  e = e || {}, a = a || {};
+  function s(v) {
+    return v in a ? a[v] : e[v];
+  }
+  var r = /* @__PURE__ */ Object.create(null), n = [];
+  for (var t in e)
+    t in a ? n.length && (r[t] = n, n = []) : n.push(t);
+  var i, o = {};
+  for (var u in a) {
+    if (r[u])
+      for (i = 0; i < r[u].length; i++) {
+        var f = r[u][i];
+        o[r[u][i]] = s(f);
+      }
+    o[u] = s(u);
+  }
+  for (i = 0; i < n.length; i++)
+    o[n[i]] = s(n[i]);
+  return o;
+}
+function G(e, a, s) {
+  return s[a] != null ? s[a] : e.props[a];
+}
+function St(e, a) {
+  return Ae(e.children, function(s) {
+    return se(s, {
+      onExited: a.bind(null, s),
+      in: !0,
+      appear: G(s, "appear", e),
+      enter: G(s, "enter", e),
+      exit: G(s, "exit", e)
+    });
+  });
+}
+function Rt(e, a, s) {
+  var r = Ae(e.children), n = Ot(a, r);
+  return Object.keys(n).forEach(function(t) {
+    var i = n[t];
+    if (ae(i)) {
+      var o = t in a, u = t in r, f = a[t], v = ae(f) && !f.props.in;
+      u && (!o || v) ? n[t] = se(i, {
+        onExited: s.bind(null, i),
+        in: !0,
+        exit: G(i, "exit", e),
+        enter: G(i, "enter", e)
+      }) : !u && o && !v ? n[t] = se(i, {
+        in: !1
+      }) : u && o && ae(f) && (n[t] = se(i, {
+        onExited: s.bind(null, i),
+        in: f.props.in,
+        exit: G(i, "exit", e),
+        enter: G(i, "enter", e)
+      }));
+    }
+  }), n;
+}
+var Pt = Object.values || function(e) {
+  return Object.keys(e).map(function(a) {
+    return e[a];
+  });
+}, _t = {
+  component: "div",
+  childFactory: function(a) {
+    return a;
+  }
+}, Ne = /* @__PURE__ */ (function(e) {
+  Pe(a, e);
+  function a(r, n) {
+    var t;
+    t = e.call(this, r, n) || this;
+    var i = t.handleExited.bind(Ct(t));
+    return t.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: i,
+      firstRender: !0
+    }, t;
+  }
+  var s = a.prototype;
+  return s.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, s.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, a.getDerivedStateFromProps = function(n, t) {
+    var i = t.children, o = t.handleExited, u = t.firstRender;
+    return {
+      children: u ? St(n, o) : Rt(n, i, o),
+      firstRender: !1
+    };
+  }, s.handleExited = function(n, t) {
+    var i = Ae(this.props.children);
+    n.key in i || (n.props.onExited && n.props.onExited(t), this.mounted && this.setState(function(o) {
+      var u = Q({}, o.children);
+      return delete u[n.key], {
+        children: u
+      };
+    }));
+  }, s.render = function() {
+    var n = this.props, t = n.component, i = n.childFactory, o = Re(n, ["component", "childFactory"]), u = this.state.contextValue, f = Pt(this.state.children).map(i);
+    return delete o.appear, delete o.enter, delete o.exit, t === null ? /* @__PURE__ */ k.createElement(ue.Provider, {
+      value: u
+    }, f) : /* @__PURE__ */ k.createElement(ue.Provider, {
+      value: u
+    }, /* @__PURE__ */ k.createElement(t, o, f));
+  }, a;
+})(k.Component);
+Ne.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: h.any,
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: h.node,
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: h.bool,
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: h.bool,
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: h.bool,
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: h.func
+} : {};
+Ne.defaultProps = _t;
+const Ft = () => {
+  const e = nt(Be);
+  if (!e)
+    throw new Error("useToast must be used within a ToasterProvider component");
+  return e;
+};
+function wt({ toast: e, onRemove: a, ...s }) {
+  const r = ot(null);
+  return /* @__PURE__ */ F(we, { ...s, nodeRef: r, timeout: 300, classNames: "uofg-toast-transition", children: /* @__PURE__ */ F(At, { toast: e, onRemove: a, nodeRef: r }) });
+}
+function At({
+  toast: e,
+  onRemove: a,
+  nodeRef: s
+}) {
+  const [r, n] = Xe(100);
+  it(() => {
+    const i = performance.now();
+    let o;
+    const u = (f) => {
+      const v = f - i, m = Math.max(0, 100 - v / e.timeout * 100);
+      n(m), m > 0 && (o = requestAnimationFrame(u));
+    };
+    return o = requestAnimationFrame(u), () => {
+      cancelAnimationFrame(o);
+    };
+  }, [e.timeout]);
+  const t = st({
+    slots: {
+      toast: "uofg-toast relative flex max-w-[50ch] gap-2 overflow-hidden p-6 text-left text-lg",
+      progress: "uofg-toast-progress absolute right-0 bottom-0 left-0 h-1 origin-left bg-current opacity-70",
+      icon: "uofg-toast-icon text-2xl",
+      message: "uofg-toast-message",
+      close: "uofg-toast-close-button text-md absolute -top-3 -left-3 h-6 w-6 cursor-pointer rounded-full bg-black text-white"
+    },
+    variants: {
+      type: {
+        info: {
+          toast: "bg-blue text-blue-contrast"
+        },
+        success: {
+          toast: "bg-green text-green-contrast"
+        },
+        warning: {
+          toast: "bg-yellow text-yellow-contrast"
+        },
+        error: {
+          toast: "bg-red text-red-contrast"
+        }
+      }
+    }
+  })({ type: e.type });
+  return /* @__PURE__ */ Ge("button", { onClick: () => a(e.id), ref: s, className: t.toast(), children: [
+    e.type === "info" && /* @__PURE__ */ F(re, { className: t.icon(), icon: Qe }),
+    e.type === "success" && /* @__PURE__ */ F(re, { className: t.icon(), icon: Ke }),
+    e.type === "warning" && /* @__PURE__ */ F(re, { className: t.icon(), icon: et }),
+    e.type === "error" && /* @__PURE__ */ F(re, { className: t.icon(), icon: tt }),
+    /* @__PURE__ */ F("span", { className: t.message(), children: e.message }),
+    /* @__PURE__ */ F("span", { className: t.progress(), style: { width: `${r}%` }, "aria-hidden": "true" })
+  ] });
+}
+function Yt({ children: e }) {
+  const [a, s] = Xe([]), r = Ie((i) => {
+    s((o) => o.filter((u) => u.id !== i));
+  }, []), n = Ie(
+    (i, o = "info", u = 3e3) => {
+      const f = Date.now().toString();
+      console.log("Adding toast:", f, i, o, u), s((v) => [
+        ...v,
+        {
+          id: f,
+          message: i,
+          type: o,
+          timeout: u
+        }
+      ]), setTimeout(() => {
+        r(f);
+      }, u);
+    },
+    [r]
+  ), t = at(
+    "uofg-toaster",
+    "fixed",
+    "right-4",
+    "bottom-4",
+    "z-1000",
+    "flex",
+    "w-fit",
+    "flex-col",
+    "items-end",
+    "gap-3"
+  );
+  return /* @__PURE__ */ Ge(Be.Provider, { value: { addToast: n }, children: [
+    e,
+    /* @__PURE__ */ F(Ne, { component: "div", className: t, children: a.map((i) => /* @__PURE__ */ F(wt, { toast: i, onRemove: r }, i.id)) })
+  ] });
+}
+export {
+  Yt as ToasterProvider,
+  Ft as useToaster
+};