@unicom-cloud/ui 0.8.66 → 0.8.68

package/chunk/DzVH9IBy.js

@@ -0,0 +1,1413 @@
+import { jsx as _ } from "react/jsx-runtime";
+import Re from "react-is";
+import O, { isValidElement as G, cloneElement as J, Children as Ve, useRef as Ee, useMemo as Ye } from "react";
+import H from "react-dom";
+import { s as Be } from "./D-TPB2Do.js";
+import { f as He, c as Fe } from "./C48SmsN-.js";
+const ve = {
+  disabled: !1
+};
+function Ge(n, e) {
+  return n.classList ? !!e && n.classList.contains(e) : ` ${n.className.baseVal || n.className} `.indexOf(
+    ` ${e} `
+  ) !== -1;
+}
+function Je(n, e) {
+  n.classList ? n.classList.add(e) : Ge(n, e) || (typeof n.className == "string" ? n.className = `${n.className} ${e}` : n.setAttribute(
+    "class",
+    `${n.className && n.className.baseVal || ""} ${e}`
+  ));
+}
+function Xe(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var ee = { exports: {} };
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var ne, ye;
+function ze() {
+  if (ye) return ne;
+  ye = 1;
+  var n = Object.getOwnPropertySymbols, e = Object.prototype.hasOwnProperty, t = Object.prototype.propertyIsEnumerable;
+  function r(i) {
+    if (i == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(i);
+  }
+  function s() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var i = new String("abc");
+      if (i[5] = "de", Object.getOwnPropertyNames(i)[0] === "5")
+        return !1;
+      for (var u = {}, l = 0; l < 10; l++)
+        u["_" + String.fromCharCode(l)] = l;
+      var b = Object.getOwnPropertyNames(u).map(function(x) {
+        return u[x];
+      });
+      if (b.join("") !== "0123456789")
+        return !1;
+      var T = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(x) {
+        T[x] = x;
+      }), Object.keys(Object.assign({}, T)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return ne = s() ? Object.assign : function(i, u) {
+    for (var l, b = r(i), T, x = 1; x < arguments.length; x++) {
+      l = Object(arguments[x]);
+      for (var R in l)
+        e.call(l, R) && (b[R] = l[R]);
+      if (n) {
+        T = n(l);
+        for (var S = 0; S < T.length; S++)
+          t.call(l, T[S]) && (b[T[S]] = l[T[S]]);
+      }
+    }
+    return b;
+  }, ne;
+}
+var re, ge;
+function le() {
+  if (ge) return re;
+  ge = 1;
+  var n = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return re = n, re;
+}
+var ie, me;
+function Se() {
+  return me || (me = 1, ie = Function.call.bind(Object.prototype.hasOwnProperty)), ie;
+}
+var se, be;
+function Ke() {
+  if (be) return se;
+  be = 1;
+  var n = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var e = /* @__PURE__ */ le(), t = {}, r = /* @__PURE__ */ Se();
+    n = function(i) {
+      var u = "Warning: " + i;
+      typeof console < "u" && console.error(u);
+      try {
+        throw new Error(u);
+      } catch {
+      }
+    };
+  }
+  function s(i, u, l, b, T) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var x in i)
+        if (r(i, x)) {
+          var R;
+          try {
+            if (typeof i[x] != "function") {
+              var S = Error(
+                (b || "React class") + ": " + l + " type `" + x + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof i[x] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw S.name = "Invariant Violation", S;
+            }
+            R = i[x](u, x, b, l, null, e);
+          } catch (K) {
+            R = K;
+          }
+          if (R && !(R instanceof Error) && n(
+            (b || "React class") + ": type specification of " + l + " `" + x + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof R + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), R instanceof Error && !(R.message in t)) {
+            t[R.message] = !0;
+            var A = T ? T() : "";
+            n(
+              "Failed " + l + " type: " + R.message + (A ?? "")
+            );
+          }
+        }
+    }
+  }
+  return s.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (t = {});
+  }, se = s, se;
+}
+var oe, xe;
+function Qe() {
+  if (xe) return oe;
+  xe = 1;
+  var n = Re, e = ze(), t = /* @__PURE__ */ le(), r = /* @__PURE__ */ Se(), s = /* @__PURE__ */ Ke(), i = function() {
+  };
+  process.env.NODE_ENV !== "production" && (i = function(l) {
+    var b = "Warning: " + l;
+    typeof console < "u" && console.error(b);
+    try {
+      throw new Error(b);
+    } catch {
+    }
+  });
+  function u() {
+    return null;
+  }
+  return oe = function(l, b) {
+    var T = typeof Symbol == "function" && Symbol.iterator, x = "@@iterator";
+    function R(o) {
+      var a = o && (T && o[T] || o[x]);
+      if (typeof a == "function")
+        return a;
+    }
+    var S = "<<anonymous>>", A = {
+      array: I("array"),
+      bigint: I("bigint"),
+      bool: I("boolean"),
+      func: I("function"),
+      number: I("number"),
+      object: I("object"),
+      string: I("string"),
+      symbol: I("symbol"),
+      any: Q(),
+      arrayOf: je,
+      element: ke(),
+      elementType: $e(),
+      instanceOf: De,
+      node: qe(),
+      objectOf: Ae,
+      oneOf: Ne,
+      oneOfType: Ie,
+      shape: _e,
+      exact: Le
+    };
+    function K(o, a) {
+      return o === a ? o !== 0 || 1 / o === 1 / a : o !== o && a !== a;
+    }
+    function C(o, a) {
+      this.message = o, this.data = a && typeof a == "object" ? a : {}, this.stack = "";
+    }
+    C.prototype = Error.prototype;
+    function w(o) {
+      if (process.env.NODE_ENV !== "production")
+        var a = {}, E = 0;
+      function d(v, f, h, y, m, g, j) {
+        if (y = y || S, g = g || h, j !== t) {
+          if (b) {
+            var P = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw P.name = "Invariant Violation", P;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var U = y + ":" + h;
+            !a[U] && // Avoid spamming the console because they are often not actionable except for lib authors
+            E < 3 && (i(
+              "You are manually calling a React.PropTypes validation function for the `" + g + "` prop on `" + y + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), a[U] = !0, E++);
+          }
+        }
+        return f[h] == null ? v ? f[h] === null ? new C("The " + m + " `" + g + "` is marked as required " + ("in `" + y + "`, but its value is `null`.")) : new C("The " + m + " `" + g + "` is marked as required in " + ("`" + y + "`, but its value is `undefined`.")) : null : o(f, h, y, m, g);
+      }
+      var p = d.bind(null, !1);
+      return p.isRequired = d.bind(null, !0), p;
+    }
+    function I(o) {
+      function a(E, d, p, v, f, h) {
+        var y = E[d], m = q(y);
+        if (m !== o) {
+          var g = B(y);
+          return new C(
+            "Invalid " + v + " `" + f + "` of type " + ("`" + g + "` supplied to `" + p + "`, expected ") + ("`" + o + "`."),
+            { expectedType: o }
+          );
+        }
+        return null;
+      }
+      return w(a);
+    }
+    function Q() {
+      return w(u);
+    }
+    function je(o) {
+      function a(E, d, p, v, f) {
+        if (typeof o != "function")
+          return new C("Property `" + f + "` of component `" + p + "` has invalid PropType notation inside arrayOf.");
+        var h = E[d];
+        if (!Array.isArray(h)) {
+          var y = q(h);
+          return new C("Invalid " + v + " `" + f + "` of type " + ("`" + y + "` supplied to `" + p + "`, expected an array."));
+        }
+        for (var m = 0; m < h.length; m++) {
+          var g = o(h, m, p, v, f + "[" + m + "]", t);
+          if (g instanceof Error)
+            return g;
+        }
+        return null;
+      }
+      return w(a);
+    }
+    function ke() {
+      function o(a, E, d, p, v) {
+        var f = a[E];
+        if (!l(f)) {
+          var h = q(f);
+          return new C("Invalid " + p + " `" + v + "` of type " + ("`" + h + "` supplied to `" + d + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return w(o);
+    }
+    function $e() {
+      function o(a, E, d, p, v) {
+        var f = a[E];
+        if (!n.isValidElementType(f)) {
+          var h = q(f);
+          return new C("Invalid " + p + " `" + v + "` of type " + ("`" + h + "` supplied to `" + d + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return w(o);
+    }
+    function De(o) {
+      function a(E, d, p, v, f) {
+        if (!(E[d] instanceof o)) {
+          var h = o.name || S, y = Ue(E[d]);
+          return new C("Invalid " + v + " `" + f + "` of type " + ("`" + y + "` supplied to `" + p + "`, expected ") + ("instance of `" + h + "`."));
+        }
+        return null;
+      }
+      return w(a);
+    }
+    function Ne(o) {
+      if (!Array.isArray(o))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? i(
+          "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])."
+        ) : i("Invalid argument supplied to oneOf, expected an array.")), u;
+      function a(E, d, p, v, f) {
+        for (var h = E[d], y = 0; y < o.length; y++)
+          if (K(h, o[y]))
+            return null;
+        var m = JSON.stringify(o, function(j, P) {
+          var U = B(P);
+          return U === "symbol" ? String(P) : P;
+        });
+        return new C("Invalid " + v + " `" + f + "` of value `" + String(h) + "` " + ("supplied to `" + p + "`, expected one of " + m + "."));
+      }
+      return w(a);
+    }
+    function Ae(o) {
+      function a(E, d, p, v, f) {
+        if (typeof o != "function")
+          return new C("Property `" + f + "` of component `" + p + "` has invalid PropType notation inside objectOf.");
+        var h = E[d], y = q(h);
+        if (y !== "object")
+          return new C("Invalid " + v + " `" + f + "` of type " + ("`" + y + "` supplied to `" + p + "`, expected an object."));
+        for (var m in h)
+          if (r(h, m)) {
+            var g = o(h, m, p, v, f + "." + m, t);
+            if (g instanceof Error)
+              return g;
+          }
+        return null;
+      }
+      return w(a);
+    }
+    function Ie(o) {
+      if (!Array.isArray(o))
+        return process.env.NODE_ENV !== "production" && i("Invalid argument supplied to oneOfType, expected an instance of array."), u;
+      for (var a = 0; a < o.length; a++) {
+        var E = o[a];
+        if (typeof E != "function")
+          return i(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + We(E) + " at index " + a + "."
+          ), u;
+      }
+      function d(p, v, f, h, y) {
+        for (var m = [], g = 0; g < o.length; g++) {
+          var j = o[g], P = j(p, v, f, h, y, t);
+          if (P == null)
+            return null;
+          P.data && r(P.data, "expectedType") && m.push(P.data.expectedType);
+        }
+        var U = m.length > 0 ? ", expected one of type [" + m.join(", ") + "]" : "";
+        return new C("Invalid " + h + " `" + y + "` supplied to " + ("`" + f + "`" + U + "."));
+      }
+      return w(d);
+    }
+    function qe() {
+      function o(a, E, d, p, v) {
+        return Z(a[E]) ? null : new C("Invalid " + p + " `" + v + "` supplied to " + ("`" + d + "`, expected a ReactNode."));
+      }
+      return w(o);
+    }
+    function he(o, a, E, d, p) {
+      return new C(
+        (o || "React class") + ": " + a + " type `" + E + "." + d + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + p + "`."
+      );
+    }
+    function _e(o) {
+      function a(E, d, p, v, f) {
+        var h = E[d], y = q(h);
+        if (y !== "object")
+          return new C("Invalid " + v + " `" + f + "` of type `" + y + "` " + ("supplied to `" + p + "`, expected `object`."));
+        for (var m in o) {
+          var g = o[m];
+          if (typeof g != "function")
+            return he(p, v, f, m, B(g));
+          var j = g(h, m, p, v, f + "." + m, t);
+          if (j)
+            return j;
+        }
+        return null;
+      }
+      return w(a);
+    }
+    function Le(o) {
+      function a(E, d, p, v, f) {
+        var h = E[d], y = q(h);
+        if (y !== "object")
+          return new C("Invalid " + v + " `" + f + "` of type `" + y + "` " + ("supplied to `" + p + "`, expected `object`."));
+        var m = e({}, E[d], o);
+        for (var g in m) {
+          var j = o[g];
+          if (r(o, g) && typeof j != "function")
+            return he(p, v, f, g, B(j));
+          if (!j)
+            return new C(
+              "Invalid " + v + " `" + f + "` key `" + g + "` supplied to `" + p + "`.\nBad object: " + JSON.stringify(E[d], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(o), null, "  ")
+            );
+          var P = j(h, g, p, v, f + "." + g, t);
+          if (P)
+            return P;
+        }
+        return null;
+      }
+      return w(a);
+    }
+    function Z(o) {
+      switch (typeof o) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !o;
+        case "object":
+          if (Array.isArray(o))
+            return o.every(Z);
+          if (o === null || l(o))
+            return !0;
+          var a = R(o);
+          if (a) {
+            var E = a.call(o), d;
+            if (a !== o.entries) {
+              for (; !(d = E.next()).done; )
+                if (!Z(d.value))
+                  return !1;
+            } else
+              for (; !(d = E.next()).done; ) {
+                var p = d.value;
+                if (p && !Z(p[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function Me(o, a) {
+      return o === "symbol" ? !0 : a ? a["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && a instanceof Symbol : !1;
+    }
+    function q(o) {
+      var a = typeof o;
+      return Array.isArray(o) ? "array" : o instanceof RegExp ? "object" : Me(a, o) ? "symbol" : a;
+    }
+    function B(o) {
+      if (typeof o > "u" || o === null)
+        return "" + o;
+      var a = q(o);
+      if (a === "object") {
+        if (o instanceof Date)
+          return "date";
+        if (o instanceof RegExp)
+          return "regexp";
+      }
+      return a;
+    }
+    function We(o) {
+      var a = B(o);
+      switch (a) {
+        case "array":
+        case "object":
+          return "an " + a;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + a;
+        default:
+          return a;
+      }
+    }
+    function Ue(o) {
+      return !o.constructor || !o.constructor.name ? S : o.constructor.name;
+    }
+    return A.checkPropTypes = s, A.resetWarningCache = s.resetWarningCache, A.PropTypes = A, A;
+  }, oe;
+}
+var ae, Oe;
+function Ze() {
+  if (Oe) return ae;
+  Oe = 1;
+  var n = /* @__PURE__ */ le();
+  function e() {
+  }
+  function t() {
+  }
+  return t.resetWarningCache = e, ae = function() {
+    function r(u, l, b, T, x, R) {
+      if (R !== n) {
+        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 s() {
+      return r;
+    }
+    var i = {
+      array: r,
+      bigint: r,
+      bool: r,
+      func: r,
+      number: r,
+      object: r,
+      string: r,
+      symbol: r,
+      any: r,
+      arrayOf: s,
+      element: r,
+      elementType: r,
+      instanceOf: s,
+      node: r,
+      objectOf: s,
+      oneOf: s,
+      oneOfType: s,
+      shape: s,
+      exact: s,
+      checkPropTypes: t,
+      resetWarningCache: e
+    };
+    return i.PropTypes = i, i;
+  }, ae;
+}
+var Te;
+function et() {
+  if (Te) return ee.exports;
+  if (Te = 1, process.env.NODE_ENV !== "production") {
+    var n = Re, e = !0;
+    ee.exports = /* @__PURE__ */ Qe()(n.isElement, e);
+  } else
+    ee.exports = /* @__PURE__ */ Ze()();
+  return ee.exports;
+}
+var tt = /* @__PURE__ */ et();
+const c = /* @__PURE__ */ Xe(tt);
+function Ce(n, e) {
+  return n.replace(new RegExp(`(^|\\s)${e}(?:\\s|$)`, "g"), "$1").replace(/\s+/g, " ").replace(/^\s*|\s*$/g, "");
+}
+function nt(n, e) {
+  n.classList ? n.classList.remove(e) : typeof n.className == "string" ? n.className = Ce(
+    n.className,
+    e
+  ) : n.setAttribute(
+    "class",
+    Ce(
+      n.className && n.className.baseVal || "",
+      e
+    )
+  );
+}
+const X = O.createContext(null);
+var rt = Object.defineProperty, it = (n, e, t) => e in n ? rt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, st = (n, e, t) => it(n, e + "", t);
+const ot = process.env.NODE_ENV !== "production" ? c.oneOfType([
+  c.number,
+  c.shape({
+    enter: c.number,
+    exit: c.number,
+    appear: c.number
+  }).isRequired
+]) : null, at = process.env.NODE_ENV !== "production" ? c.oneOfType([
+  c.string,
+  c.shape({
+    enter: c.string,
+    exit: c.string,
+    active: c.string
+  }),
+  c.shape({
+    enter: c.string,
+    enterDone: c.string,
+    enterActive: c.string,
+    exit: c.string,
+    exitDone: c.string,
+    exitActive: c.string
+  })
+]) : null, Pe = (n) => n.scrollTop, F = "unmounted", M = "exited", k = "entering", D = "entered", z = "exiting";
+let N = class extends O.Component {
+  constructor(e, t) {
+    super(e, t);
+    let r = t, s = r && !r.isMounting ? e.enter : e.appear, i;
+    this.appearStatus = null, e.in ? s ? (i = M, this.appearStatus = k) : i = D : e.unmountOnExit || e.mountOnEnter ? i = F : i = M, this.state = { status: i }, this.nextCallback = null;
+  }
+  static getDerivedStateFromProps({ in: e }, t) {
+    return e && t.status === F ? { status: M } : null;
+  }
+  // getSnapshotBeforeUpdate(prevProps) {
+  //   let nextStatus = null
+  //   if (prevProps !== this.props) {
+  //     const { status } = this.state
+  //     if (this.props.in) {
+  //       if (status !== ENTERING && status !== ENTERED) {
+  //         nextStatus = ENTERING
+  //       }
+  //     } else {
+  //       if (status === ENTERING || status === ENTERED) {
+  //         nextStatus = EXITING
+  //       }
+  //     }
+  //   }
+  //   return { nextStatus }
+  // }
+  componentDidMount() {
+    this.updateStatus(!0, this.appearStatus);
+  }
+  componentDidUpdate(e) {
+    let t = null;
+    if (e !== this.props) {
+      const { status: r } = this.state;
+      this.props.in ? r !== k && r !== D && (t = k) : (r === k || r === D) && (t = z);
+    }
+    this.updateStatus(!1, t);
+  }
+  componentWillUnmount() {
+    this.cancelNextCallback();
+  }
+  getTimeouts() {
+    const { timeout: e } = this.props;
+    let t, r, s;
+    return t = r = s = e, e != null && typeof e != "number" && (t = e.exit, r = e.enter, s = e.appear !== void 0 ? e.appear : r), { exit: t, enter: r, appear: s };
+  }
+  updateStatus(e = !1, t) {
+    if (t !== null)
+      if (this.cancelNextCallback(), t === k) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          const r = this.props.nodeRef ? this.props.nodeRef.current : H.findDOMNode(this);
+          r && Pe(r);
+        }
+        this.performEnter(e);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === M && this.setState({ status: F });
+  }
+  performEnter(e) {
+    const { enter: t } = this.props, r = this.context ? this.context.isMounting : e, [s, i] = this.props.nodeRef ? [r] : [H.findDOMNode(this), r], u = this.getTimeouts(), l = r ? u.appear : u.enter;
+    if (!e && !t || ve.disabled) {
+      this.safeSetState({ status: D }, () => {
+        this.props.onEntered(s);
+      });
+      return;
+    }
+    this.props.onEnter(s, i), this.safeSetState({ status: k }, () => {
+      this.props.onEntering(s, i), this.onTransitionEnd(l, () => {
+        this.safeSetState({ status: D }, () => {
+          this.props.onEntered(s, i);
+        });
+      });
+    });
+  }
+  performExit() {
+    const { exit: e } = this.props, t = this.getTimeouts(), r = this.props.nodeRef ? void 0 : H.findDOMNode(this);
+    if (!e || ve.disabled) {
+      this.safeSetState({ status: M }, () => {
+        this.props.onExited(r);
+      });
+      return;
+    }
+    this.props.onExit(r), this.safeSetState({ status: z }, () => {
+      this.props.onExiting(r), this.onTransitionEnd(t.exit, () => {
+        this.safeSetState({ status: M }, () => {
+          this.props.onExited(r);
+        });
+      });
+    });
+  }
+  cancelNextCallback() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }
+  safeSetState(e, t) {
+    t = this.setNextCallback(t), this.setState(e, t);
+  }
+  setNextCallback(e) {
+    let t = !0;
+    return this.nextCallback = (r) => {
+      t && (t = !1, this.nextCallback = null, e(r));
+    }, this.nextCallback.cancel = () => {
+      t = !1;
+    }, this.nextCallback;
+  }
+  onTransitionEnd(e, t) {
+    this.setNextCallback(t);
+    const r = this.props.nodeRef ? this.props.nodeRef.current : H.findDOMNode(this), s = e == null && !this.props.addEndListener;
+    if (!r || s) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      const [i, u] = this.props.nodeRef ? [this.nextCallback] : [r, this.nextCallback];
+      this.props.addEndListener(i, u);
+    }
+    e != null && setTimeout(this.nextCallback, e);
+  }
+  render() {
+    const e = this.state.status;
+    if (e === F)
+      return null;
+    const {
+      children: t,
+      // filter props for `Transition`
+      in: r,
+      mountOnEnter: s,
+      unmountOnExit: i,
+      appear: u,
+      enter: l,
+      exit: b,
+      timeout: T,
+      addEndListener: x,
+      onEnter: R,
+      onEntering: S,
+      onEntered: A,
+      onExit: K,
+      onExiting: C,
+      onExited: w,
+      nodeRef: I,
+      ...Q
+    } = this.props;
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ _(X.Provider, { value: null, children: typeof t == "function" ? t(e, Q) : O.cloneElement(O.Children.only(t), Q) })
+    );
+  }
+};
+st(N, "contextType", X);
+N.propTypes = {
+  /**
+   * A React reference to the DOM element that needs to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - This prop is optional, but recommended in order to avoid defaulting to
+   *      [`ReactDOM.findDOMNode`](https://reactjs.org/docs/react-dom.html#finddomnode),
+   *      which is deprecated in `StrictMode`
+   *   - 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: c.shape({
+    current: typeof Element > "u" ? c.any : (n, e, t, r, s, i) => {
+      const u = n[e];
+      return c.instanceOf(
+        u && "ownerDocument" in u ? u.ownerDocument.defaultView.Element : Element
+      )(n, e, t, r, s, i);
+    }
+  }),
+  /**
+   * 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 nodeRef={nodeRef} in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent ref={nodeRef} className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: c.oneOfType([
+    c.func.isRequired,
+    c.element.isRequired
+  ]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: c.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: c.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: c.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: c.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: c.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: c.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: (n, ...e) => {
+    let t = ot;
+    return n.addEndListener || (t = t.isRequired), t(n, ...e);
+  },
+  /**
+   * 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, so `done` is being passed as the first argument.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: c.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, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: c.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, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: c.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, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: c.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: c.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: c.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: c.func
+};
+function V() {
+}
+N.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: V,
+  onEntering: V,
+  onEntered: V,
+  onExit: V,
+  onExiting: V,
+  onExited: V
+};
+N.UNMOUNTED = F;
+N.EXITED = M;
+N.ENTERING = k;
+N.ENTERED = D;
+N.EXITING = z;
+var ut = Object.defineProperty, ct = (n, e, t) => e in n ? ut(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, $ = (n, e, t) => ct(n, typeof e != "symbol" ? e + "" : e, t);
+const lt = (n, e) => n && e && e.split(" ").forEach((t) => Je(n, t)), ue = (n, e) => n && e && e.split(" ").forEach((t) => nt(n, t));
+let pe = class extends O.Component {
+  constructor() {
+    super(...arguments), $(this, "appliedClasses", {
+      appear: {},
+      enter: {},
+      exit: {}
+    }), $(this, "onEnter", (e, t) => {
+      const [r, s] = this.resolveArguments(e, t);
+      this.removeClasses(r, "exit"), this.addClass(r, s ? "appear" : "enter", "base"), this.props.onEnter && this.props.onEnter(e, t);
+    }), $(this, "onEntering", (e, t) => {
+      const [r, s] = this.resolveArguments(e, t), i = s ? "appear" : "enter";
+      this.addClass(r, i, "active"), this.props.onEntering && this.props.onEntering(e, t);
+    }), $(this, "onEntered", (e, t) => {
+      const [r, s] = this.resolveArguments(e, t), i = s ? "appear" : "enter";
+      this.removeClasses(r, i), this.addClass(r, i, "done"), this.props.onEntered && this.props.onEntered(e, t);
+    }), $(this, "onExit", (e) => {
+      const [t] = this.resolveArguments(e);
+      this.removeClasses(t, "appear"), this.removeClasses(t, "enter"), this.addClass(t, "exit", "base"), this.props.onExit && this.props.onExit(e);
+    }), $(this, "onExiting", (e) => {
+      const [t] = this.resolveArguments(e);
+      this.addClass(t, "exit", "active"), this.props.onExiting && this.props.onExiting(e);
+    }), $(this, "onExited", (e) => {
+      const [t] = this.resolveArguments(e);
+      this.removeClasses(t, "exit"), this.addClass(t, "exit", "done"), this.props.onExited && this.props.onExited(e);
+    }), $(this, "resolveArguments", (e, t) => this.props.nodeRef ? [this.props.nodeRef.current, e] : [e, t]), $(this, "getClassNames", (e) => {
+      const { classNames: t } = this.props, r = typeof t == "string", s = r && t ? `${t}-` : "";
+      let i = r ? `${s}${e}` : t[e], u = r ? `${i}-active` : t[`${e}Active`], l = r ? `${i}-done` : t[`${e}Done`];
+      return {
+        baseClassName: i,
+        activeClassName: u,
+        doneClassName: l
+      };
+    });
+  }
+  addClass(e, t, r) {
+    let s = this.getClassNames(t)[`${r}ClassName`];
+    const { doneClassName: i } = this.getClassNames("enter");
+    t === "appear" && r === "done" && i && (s += ` ${i}`), r === "active" && e && Pe(e), s && (this.appliedClasses[t][r] = s, lt(e, s));
+  }
+  removeClasses(e, t) {
+    const {
+      base: r,
+      active: s,
+      done: i
+    } = this.appliedClasses[t];
+    this.appliedClasses[t] = {}, r && ue(e, r), s && ue(e, s), i && ue(e, i);
+  }
+  render() {
+    const { classNames: e, ...t } = this.props;
+    return /* @__PURE__ */ _(
+      N,
+      {
+        ...t,
+        onEnter: this.onEnter,
+        onEntered: this.onEntered,
+        onEntering: this.onEntering,
+        onExit: this.onExit,
+        onExiting: this.onExiting,
+        onExited: this.onExited
+      }
+    );
+  }
+};
+$(pe, "defaultProps", {
+  classNames: ""
+});
+pe.propTypes = {
+  ...N.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: at,
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is
+   * applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEnter: c.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, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: c.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, so `isAppearing` is being passed as the first argument.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntered: c.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: c.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: c.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: c.func
+};
+function fe(n, e) {
+  let t = (s) => e && G(s) ? e(s) : s, r = /* @__PURE__ */ Object.create(null);
+  return n && Ve.map(n, (s) => s).forEach((s) => {
+    r[s.key] = t(s);
+  }), r;
+}
+function pt(n, e) {
+  n = n || {}, e = e || {};
+  function t(l) {
+    return l in e ? e[l] : n[l];
+  }
+  let r = /* @__PURE__ */ Object.create(null), s = [];
+  for (let l in n)
+    l in e ? s.length && (r[l] = s, s = []) : s.push(l);
+  let i, u = {};
+  for (let l in e) {
+    if (r[l])
+      for (i = 0; i < r[l].length; i++) {
+        let b = r[l][i];
+        u[r[l][i]] = t(b);
+      }
+    u[l] = t(l);
+  }
+  for (i = 0; i < s.length; i++)
+    u[s[i]] = t(s[i]);
+  return u;
+}
+function W(n, e, t) {
+  return t[e] != null ? t[e] : n.props[e];
+}
+function ft(n, e) {
+  return fe(n.children, (t) => J(t, {
+    onExited: e.bind(null, t),
+    in: !0,
+    appear: W(t, "appear", n),
+    enter: W(t, "enter", n),
+    exit: W(t, "exit", n)
+  }));
+}
+function dt(n, e, t) {
+  let r = fe(n.children), s = pt(e, r);
+  return Object.keys(s).forEach((i) => {
+    let u = s[i];
+    if (!G(u)) return;
+    const l = i in e, b = i in r, T = e[i], x = G(T) && !T.props.in;
+    b && (!l || x) ? s[i] = J(u, {
+      onExited: t.bind(null, u),
+      in: !0,
+      exit: W(u, "exit", n),
+      enter: W(u, "enter", n)
+    }) : !b && l && !x ? s[i] = J(u, { in: !1 }) : b && l && G(T) && (s[i] = J(u, {
+      onExited: t.bind(null, u),
+      in: T.props.in,
+      exit: W(u, "exit", n),
+      enter: W(u, "enter", n)
+    }));
+  }), s;
+}
+const ht = Object.values || ((n) => Object.keys(n).map((e) => n[e])), Et = {
+  component: "div",
+  childFactory: (n) => n
+};
+class de extends O.Component {
+  constructor(e, t) {
+    super(e, t);
+    const r = this.handleExited.bind(this);
+    this.state = {
+      contextValue: { isMounting: !0 },
+      handleExited: r,
+      firstRender: !0
+    };
+  }
+  componentDidMount() {
+    this.mounted = !0, this.setState({
+      contextValue: { isMounting: !1 }
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = !1;
+  }
+  static getDerivedStateFromProps(e, { children: t, handleExited: r, firstRender: s }) {
+    return {
+      children: s ? ft(e, r) : dt(e, t, r),
+      firstRender: !1
+    };
+  }
+  // node is `undefined` when user provided `nodeRef` prop
+  handleExited(e, t) {
+    let r = fe(this.props.children);
+    e.key in r || (e.props.onExited && e.props.onExited(t), this.mounted && this.setState((s) => {
+      let i = { ...s.children };
+      return delete i[e.key], { children: i };
+    }));
+  }
+  render() {
+    const { component: e, childFactory: t, ...r } = this.props, { contextValue: s } = this.state, i = ht(this.state.children).map(t);
+    return delete r.appear, delete r.enter, delete r.exit, e === null ? /* @__PURE__ */ _(X.Provider, { value: s, children: i }) : /* @__PURE__ */ _(X.Provider, { value: s, children: /* @__PURE__ */ _(e, { ...r, children: i }) });
+  }
+}
+de.propTypes = {
+  /**
+   * `<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: c.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: c.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: c.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: c.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: c.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: c.func
+};
+de.defaultProps = Et;
+var vt = Object.defineProperty, yt = (n, e, t) => e in n ? vt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, Y = (n, e, t) => yt(n, typeof e != "symbol" ? e + "" : e, t);
+class gt extends O.Component {
+  constructor() {
+    super(...arguments), Y(this, "handleEnter", (...e) => this.handleLifecycle("onEnter", 0, e)), Y(this, "handleEntering", (...e) => this.handleLifecycle("onEntering", 0, e)), Y(this, "handleEntered", (...e) => this.handleLifecycle("onEntered", 0, e)), Y(this, "handleExit", (...e) => this.handleLifecycle("onExit", 1, e)), Y(this, "handleExiting", (...e) => this.handleLifecycle("onExiting", 1, e)), Y(this, "handleExited", (...e) => this.handleLifecycle("onExited", 1, e));
+  }
+  handleLifecycle(e, t, r) {
+    const { children: s } = this.props, i = O.Children.toArray(s)[t];
+    if (i.props[e] && i.props[e](...r), this.props[e]) {
+      const u = i.props.nodeRef ? void 0 : H.findDOMNode(this);
+      this.props[e](u);
+    }
+  }
+  render() {
+    const { children: e, in: t, ...r } = this.props, [s, i] = O.Children.toArray(e);
+    return delete r.onEnter, delete r.onEntering, delete r.onEntered, delete r.onExit, delete r.onExiting, delete r.onExited, /* @__PURE__ */ _(de, { ...r, children: t ? O.cloneElement(s, {
+      key: "first",
+      onEnter: this.handleEnter,
+      onEntering: this.handleEntering,
+      onEntered: this.handleEntered
+    }) : O.cloneElement(i, {
+      key: "second",
+      onEnter: this.handleExit,
+      onEntering: this.handleExiting,
+      onEntered: this.handleExited
+    }) });
+  }
+}
+gt.propTypes = {
+  in: c.bool.isRequired,
+  children(n, e) {
+    return O.Children.count(n[e]) !== 2 ? new Error(
+      `"${e}" must be exactly two transition components.`
+    ) : null;
+  }
+};
+var mt = Object.defineProperty, bt = (n, e, t) => e in n ? mt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, ce = (n, e, t) => bt(n, typeof e != "symbol" ? e + "" : e, t);
+function xt(n, e) {
+  return !(n === e || O.isValidElement(n) && O.isValidElement(e) && n.key != null && n.key === e.key);
+}
+const L = {
+  out: "out-in",
+  in: "in-out"
+}, te = (n, e, t) => (...r) => {
+  n.props[e] && n.props[e](...r), t();
+}, Ot = {
+  [L.out]: ({ current: n, changeState: e }) => O.cloneElement(n, {
+    in: !1,
+    onExited: te(n, "onExited", () => {
+      e(k, null);
+    })
+  }),
+  [L.in]: ({ current: n, changeState: e, children: t }) => [
+    n,
+    O.cloneElement(t, {
+      in: !0,
+      onEntered: te(t, "onEntered", () => {
+        e(k);
+      })
+    })
+  ]
+}, Tt = {
+  [L.out]: ({ children: n, changeState: e }) => O.cloneElement(n, {
+    in: !0,
+    onEntered: te(n, "onEntered", () => {
+      e(D, O.cloneElement(n, { in: !0 }));
+    })
+  }),
+  [L.in]: ({ current: n, children: e, changeState: t }) => [
+    O.cloneElement(n, {
+      in: !1,
+      onExited: te(n, "onExited", () => {
+        t(D, O.cloneElement(e, { in: !0 }));
+      })
+    }),
+    O.cloneElement(e, {
+      in: !0
+    })
+  ]
+};
+class we extends O.Component {
+  constructor() {
+    super(...arguments), ce(this, "state", {
+      status: D,
+      current: null
+    }), ce(this, "appeared", !1), ce(this, "changeState", (e, t = this.state.current) => {
+      this.setState({
+        status: e,
+        current: t
+      });
+    });
+  }
+  componentDidMount() {
+    this.appeared = !0;
+  }
+  static getDerivedStateFromProps(e, t) {
+    return e.children == null ? {
+      current: null
+    } : t.status === k && e.mode === L.in ? {
+      status: k
+    } : t.current && xt(t.current, e.children) ? {
+      status: z
+    } : {
+      current: O.cloneElement(e.children, {
+        in: !0
+      })
+    };
+  }
+  render() {
+    const {
+      props: { children: e, mode: t },
+      state: { status: r, current: s }
+    } = this, i = { children: e, current: s, changeState: this.changeState, status: r };
+    let u;
+    switch (r) {
+      case k:
+        u = Tt[t](i);
+        break;
+      case z:
+        u = Ot[t](i);
+        break;
+      case D:
+        u = s;
+    }
+    return /* @__PURE__ */ _(X.Provider, { value: { isMounting: !this.appeared }, children: u });
+  }
+}
+we.propTypes = {
+  /**
+   * Transition modes.
+   * `out-in`: Current element transitions out first, then when complete, the new element transitions in.
+   * `in-out`: New element transitions in first, then when complete, the current element transitions out.
+   *
+   * @type {'out-in'|'in-out'}
+   */
+  mode: c.oneOf([L.in, L.out]),
+  /**
+   * Any `Transition` or `CSSTransition` component.
+   */
+  children: c.oneOfType([c.element.isRequired])
+};
+we.defaultProps = {
+  mode: L.out
+};
+function Dt(n) {
+  const { children: e, ...t } = n, r = Ee(), s = Ee(), i = Ye(() => n.nodeRef === void 0 && Be(e) && G(e) ? (s.current = !0, J(e, {
+    ref: (u) => {
+      r.current = He(u), Fe(e, u);
+    }
+  })) : (s.current = !1, e), [e, n.nodeRef]);
+  return s.current && [
+    "onEnter",
+    "onEntering",
+    "onEntered",
+    "onExit",
+    "onExiting",
+    "onExited"
+  ].forEach((u) => {
+    n[u] && (t[u] = (l, ...b) => {
+      n[u](r.current, ...b);
+    });
+  }), /* @__PURE__ */ _(pe, { ...t, nodeRef: s.current ? r : void 0, children: i });
+}
+export {
+  Dt as P,
+  de as b,
+  pe as c,
+  we as h,
+  gt as m,
+  N as u
+};