@unicom-cloud/ui 0.8.52 → 0.8.53

package/chunk/DQ3uFRJD.js

@@ -0,0 +1,892 @@
+import { jsx as m } from "react/jsx-runtime";
+import U from "@unicom-cloud/utils/dom-helpers/addClass";
+import o from "prop-types";
+import I from "@unicom-cloud/utils/dom-helpers/removeClass";
+import d, { Children as _, isValidElement as O, cloneElement as N, useRef as w, useMemo as G } from "react";
+import y from "react-dom";
+import { supportRef as W } from "../utils/is.js";
+import { findDOMNode as X, callbackOriginRef as H } from "../utils/reactDOM.js";
+const q = {
+  disabled: !1
+}, R = d.createContext(null);
+var K = Object.defineProperty, z = (i, e, t) => e in i ? K(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, B = (i, e, t) => z(i, e + "", t);
+const J = process.env.NODE_ENV !== "production" ? o.oneOfType([
+  o.number,
+  o.shape({
+    enter: o.number,
+    exit: o.number,
+    appear: o.number
+  }).isRequired
+]) : null, Q = process.env.NODE_ENV !== "production" ? o.oneOfType([
+  o.string,
+  o.shape({
+    enter: o.string,
+    exit: o.string,
+    active: o.string
+  }),
+  o.shape({
+    enter: o.string,
+    enterDone: o.string,
+    enterActive: o.string,
+    exit: o.string,
+    exitDone: o.string,
+    exitActive: o.string
+  })
+]) : null, V = (i) => i.scrollTop, S = "unmounted", x = "exited", c = "entering", h = "entered", k = "exiting";
+class u extends d.Component {
+  constructor(e, t) {
+    super(e, t);
+    let n = t, s = n && !n.isMounting ? e.enter : e.appear, r;
+    this.appearStatus = null, e.in ? s ? (r = x, this.appearStatus = c) : r = h : e.unmountOnExit || e.mountOnEnter ? r = S : r = x, this.state = { status: r }, this.nextCallback = null;
+  }
+  static getDerivedStateFromProps({ in: e }, t) {
+    return e && t.status === S ? { status: x } : 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: n } = this.state;
+      this.props.in ? n !== c && n !== h && (t = c) : (n === c || n === h) && (t = k);
+    }
+    this.updateStatus(!1, t);
+  }
+  componentWillUnmount() {
+    this.cancelNextCallback();
+  }
+  getTimeouts() {
+    const { timeout: e } = this.props;
+    let t, n, s;
+    return t = n = s = e, e != null && typeof e != "number" && (t = e.exit, n = e.enter, s = e.appear !== void 0 ? e.appear : n), { exit: t, enter: n, appear: s };
+  }
+  updateStatus(e = !1, t) {
+    if (t !== null)
+      if (this.cancelNextCallback(), t === c) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          const n = this.props.nodeRef ? this.props.nodeRef.current : y.findDOMNode(this);
+          n && V(n);
+        }
+        this.performEnter(e);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === x && this.setState({ status: S });
+  }
+  performEnter(e) {
+    const { enter: t } = this.props, n = this.context ? this.context.isMounting : e, [s, r] = this.props.nodeRef ? [n] : [y.findDOMNode(this), n], a = this.getTimeouts(), l = n ? a.appear : a.enter;
+    if (!e && !t || q.disabled) {
+      this.safeSetState({ status: h }, () => {
+        this.props.onEntered(s);
+      });
+      return;
+    }
+    this.props.onEnter(s, r), this.safeSetState({ status: c }, () => {
+      this.props.onEntering(s, r), this.onTransitionEnd(l, () => {
+        this.safeSetState({ status: h }, () => {
+          this.props.onEntered(s, r);
+        });
+      });
+    });
+  }
+  performExit() {
+    const { exit: e } = this.props, t = this.getTimeouts(), n = this.props.nodeRef ? void 0 : y.findDOMNode(this);
+    if (!e || q.disabled) {
+      this.safeSetState({ status: x }, () => {
+        this.props.onExited(n);
+      });
+      return;
+    }
+    this.props.onExit(n), this.safeSetState({ status: k }, () => {
+      this.props.onExiting(n), this.onTransitionEnd(t.exit, () => {
+        this.safeSetState({ status: x }, () => {
+          this.props.onExited(n);
+        });
+      });
+    });
+  }
+  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 = (n) => {
+      t && (t = !1, this.nextCallback = null, e(n));
+    }, this.nextCallback.cancel = () => {
+      t = !1;
+    }, this.nextCallback;
+  }
+  onTransitionEnd(e, t) {
+    this.setNextCallback(t);
+    const n = this.props.nodeRef ? this.props.nodeRef.current : y.findDOMNode(this), s = e == null && !this.props.addEndListener;
+    if (!n || s) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      const [r, a] = this.props.nodeRef ? [this.nextCallback] : [n, this.nextCallback];
+      this.props.addEndListener(r, a);
+    }
+    e != null && setTimeout(this.nextCallback, e);
+  }
+  render() {
+    const e = this.state.status;
+    if (e === S)
+      return null;
+    const {
+      children: t,
+      // filter props for `Transition`
+      in: n,
+      mountOnEnter: s,
+      unmountOnExit: r,
+      appear: a,
+      enter: l,
+      exit: E,
+      timeout: C,
+      addEndListener: T,
+      onEnter: Ee,
+      onEntering: me,
+      onEntered: fe,
+      onExit: xe,
+      onExiting: ge,
+      onExited: be,
+      nodeRef: ve,
+      ...j
+    } = this.props;
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ m(R.Provider, { value: null, children: typeof t == "function" ? t(e, j) : d.cloneElement(d.Children.only(t), j) })
+    );
+  }
+}
+B(u, "contextType", R);
+u.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: o.shape({
+    current: typeof Element > "u" ? o.any : (i, e, t, n, s, r) => {
+      const a = i[e];
+      return o.instanceOf(
+        a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element
+      )(i, e, t, n, s, r);
+    }
+  }),
+  /**
+   * 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: o.oneOfType([
+    o.func.isRequired,
+    o.element.isRequired
+  ]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: o.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: o.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: o.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: o.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: o.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: o.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: (i, ...e) => {
+    let t = J;
+    return i.addEndListener || (t = t.isRequired), t(i, ...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: o.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: o.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: o.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: o.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: o.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: o.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: o.func
+};
+function b() {
+}
+u.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
+};
+u.UNMOUNTED = S;
+u.EXITED = x;
+u.ENTERING = c;
+u.ENTERED = h;
+u.EXITING = k;
+var Y = Object.defineProperty, Z = (i, e, t) => e in i ? Y(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, p = (i, e, t) => Z(i, typeof e != "symbol" ? e + "" : e, t);
+const ee = (i, e) => i && e && e.split(" ").forEach((t) => U(i, t)), D = (i, e) => i && e && e.split(" ").forEach((t) => I(i, t));
+let P = class extends d.Component {
+  constructor() {
+    super(...arguments), p(this, "appliedClasses", {
+      appear: {},
+      enter: {},
+      exit: {}
+    }), p(this, "onEnter", (e, t) => {
+      const [n, s] = this.resolveArguments(e, t);
+      this.removeClasses(n, "exit"), this.addClass(n, s ? "appear" : "enter", "base"), this.props.onEnter && this.props.onEnter(e, t);
+    }), p(this, "onEntering", (e, t) => {
+      const [n, s] = this.resolveArguments(e, t), r = s ? "appear" : "enter";
+      this.addClass(n, r, "active"), this.props.onEntering && this.props.onEntering(e, t);
+    }), p(this, "onEntered", (e, t) => {
+      const [n, s] = this.resolveArguments(e, t), r = s ? "appear" : "enter";
+      this.removeClasses(n, r), this.addClass(n, r, "done"), this.props.onEntered && this.props.onEntered(e, t);
+    }), p(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);
+    }), p(this, "onExiting", (e) => {
+      const [t] = this.resolveArguments(e);
+      this.addClass(t, "exit", "active"), this.props.onExiting && this.props.onExiting(e);
+    }), p(this, "onExited", (e) => {
+      const [t] = this.resolveArguments(e);
+      this.removeClasses(t, "exit"), this.addClass(t, "exit", "done"), this.props.onExited && this.props.onExited(e);
+    }), p(this, "resolveArguments", (e, t) => this.props.nodeRef ? [this.props.nodeRef.current, e] : [e, t]), p(this, "getClassNames", (e) => {
+      const { classNames: t } = this.props, n = typeof t == "string", s = n && t ? `${t}-` : "";
+      let r = n ? `${s}${e}` : t[e], a = n ? `${r}-active` : t[`${e}Active`], l = n ? `${r}-done` : t[`${e}Done`];
+      return {
+        baseClassName: r,
+        activeClassName: a,
+        doneClassName: l
+      };
+    });
+  }
+  addClass(e, t, n) {
+    let s = this.getClassNames(t)[`${n}ClassName`];
+    const { doneClassName: r } = this.getClassNames("enter");
+    t === "appear" && n === "done" && r && (s += ` ${r}`), n === "active" && e && V(e), s && (this.appliedClasses[t][n] = s, ee(e, s));
+  }
+  removeClasses(e, t) {
+    const {
+      base: n,
+      active: s,
+      done: r
+    } = this.appliedClasses[t];
+    this.appliedClasses[t] = {}, n && D(e, n), s && D(e, s), r && D(e, r);
+  }
+  render() {
+    const { classNames: e, ...t } = this.props;
+    return /* @__PURE__ */ m(
+      u,
+      {
+        ...t,
+        onEnter: this.onEnter,
+        onEntered: this.onEntered,
+        onEntering: this.onEntering,
+        onExit: this.onExit,
+        onExiting: this.onExiting,
+        onExited: this.onExited
+      }
+    );
+  }
+};
+p(P, "defaultProps", {
+  classNames: ""
+});
+P.propTypes = {
+  ...u.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: Q,
+  /**
+   * 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: o.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: o.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: o.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: o.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: o.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: o.func
+};
+function L(i, e) {
+  let t = (s) => e && O(s) ? e(s) : s, n = /* @__PURE__ */ Object.create(null);
+  return i && _.map(i, (s) => s).forEach((s) => {
+    n[s.key] = t(s);
+  }), n;
+}
+function te(i, e) {
+  i = i || {}, e = e || {};
+  function t(l) {
+    return l in e ? e[l] : i[l];
+  }
+  let n = /* @__PURE__ */ Object.create(null), s = [];
+  for (let l in i)
+    l in e ? s.length && (n[l] = s, s = []) : s.push(l);
+  let r, a = {};
+  for (let l in e) {
+    if (n[l])
+      for (r = 0; r < n[l].length; r++) {
+        let E = n[l][r];
+        a[n[l][r]] = t(E);
+      }
+    a[l] = t(l);
+  }
+  for (r = 0; r < s.length; r++)
+    a[s[r]] = t(s[r]);
+  return a;
+}
+function g(i, e, t) {
+  return t[e] != null ? t[e] : i.props[e];
+}
+function ne(i, e) {
+  return L(i.children, (t) => N(t, {
+    onExited: e.bind(null, t),
+    in: !0,
+    appear: g(t, "appear", i),
+    enter: g(t, "enter", i),
+    exit: g(t, "exit", i)
+  }));
+}
+function ie(i, e, t) {
+  let n = L(i.children), s = te(e, n);
+  return Object.keys(s).forEach((r) => {
+    let a = s[r];
+    if (!O(a)) return;
+    const l = r in e, E = r in n, C = e[r], T = O(C) && !C.props.in;
+    E && (!l || T) ? s[r] = N(a, {
+      onExited: t.bind(null, a),
+      in: !0,
+      exit: g(a, "exit", i),
+      enter: g(a, "enter", i)
+    }) : !E && l && !T ? s[r] = N(a, { in: !1 }) : E && l && O(C) && (s[r] = N(a, {
+      onExited: t.bind(null, a),
+      in: C.props.in,
+      exit: g(a, "exit", i),
+      enter: g(a, "enter", i)
+    }));
+  }), s;
+}
+const se = Object.values || ((i) => Object.keys(i).map((e) => i[e])), re = {
+  component: "div",
+  childFactory: (i) => i
+};
+class A extends d.Component {
+  constructor(e, t) {
+    super(e, t);
+    const n = this.handleExited.bind(this);
+    this.state = {
+      contextValue: { isMounting: !0 },
+      handleExited: n,
+      firstRender: !0
+    };
+  }
+  componentDidMount() {
+    this.mounted = !0, this.setState({
+      contextValue: { isMounting: !1 }
+    });
+  }
+  componentWillUnmount() {
+    this.mounted = !1;
+  }
+  static getDerivedStateFromProps(e, { children: t, handleExited: n, firstRender: s }) {
+    return {
+      children: s ? ne(e, n) : ie(e, t, n),
+      firstRender: !1
+    };
+  }
+  // node is `undefined` when user provided `nodeRef` prop
+  handleExited(e, t) {
+    let n = L(this.props.children);
+    e.key in n || (e.props.onExited && e.props.onExited(t), this.mounted && this.setState((s) => {
+      let r = { ...s.children };
+      return delete r[e.key], { children: r };
+    }));
+  }
+  render() {
+    const { component: e, childFactory: t, ...n } = this.props, { contextValue: s } = this.state, r = se(this.state.children).map(t);
+    return delete n.appear, delete n.enter, delete n.exit, e === null ? /* @__PURE__ */ m(R.Provider, { value: s, children: r }) : /* @__PURE__ */ m(R.Provider, { value: s, children: /* @__PURE__ */ m(e, { ...n, children: r }) });
+  }
+}
+A.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: o.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: o.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: o.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: o.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: o.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: o.func
+};
+A.defaultProps = re;
+var oe = Object.defineProperty, ae = (i, e, t) => e in i ? oe(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, v = (i, e, t) => ae(i, typeof e != "symbol" ? e + "" : e, t);
+class le extends d.Component {
+  constructor() {
+    super(...arguments), v(this, "handleEnter", (...e) => this.handleLifecycle("onEnter", 0, e)), v(this, "handleEntering", (...e) => this.handleLifecycle("onEntering", 0, e)), v(this, "handleEntered", (...e) => this.handleLifecycle("onEntered", 0, e)), v(this, "handleExit", (...e) => this.handleLifecycle("onExit", 1, e)), v(this, "handleExiting", (...e) => this.handleLifecycle("onExiting", 1, e)), v(this, "handleExited", (...e) => this.handleLifecycle("onExited", 1, e));
+  }
+  handleLifecycle(e, t, n) {
+    const { children: s } = this.props, r = d.Children.toArray(s)[t];
+    if (r.props[e] && r.props[e](...n), this.props[e]) {
+      const a = r.props.nodeRef ? void 0 : y.findDOMNode(this);
+      this.props[e](a);
+    }
+  }
+  render() {
+    const { children: e, in: t, ...n } = this.props, [s, r] = d.Children.toArray(e);
+    return delete n.onEnter, delete n.onEntering, delete n.onEntered, delete n.onExit, delete n.onExiting, delete n.onExited, /* @__PURE__ */ m(A, { ...n, children: t ? d.cloneElement(s, {
+      key: "first",
+      onEnter: this.handleEnter,
+      onEntering: this.handleEntering,
+      onEntered: this.handleEntered
+    }) : d.cloneElement(r, {
+      key: "second",
+      onEnter: this.handleExit,
+      onEntering: this.handleExiting,
+      onEntered: this.handleExited
+    }) });
+  }
+}
+le.propTypes = {
+  in: o.bool.isRequired,
+  children(i, e) {
+    return d.Children.count(i[e]) !== 2 ? new Error(
+      `"${e}" must be exactly two transition components.`
+    ) : null;
+  }
+};
+var de = Object.defineProperty, ce = (i, e, t) => e in i ? de(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t, M = (i, e, t) => ce(i, typeof e != "symbol" ? e + "" : e, t);
+function pe(i, e) {
+  return !(i === e || d.isValidElement(i) && d.isValidElement(e) && i.key != null && i.key === e.key);
+}
+const f = {
+  out: "out-in",
+  in: "in-out"
+}, $ = (i, e, t) => (...n) => {
+  var s, r;
+  (r = (s = i.props)[e]) == null || r.call(s, ...n), t();
+}, he = {
+  [f.out]: ({ current: i, changeState: e }) => d.cloneElement(i, {
+    in: !1,
+    onExited: $(i, "onExited", () => {
+      e(c, null);
+    })
+  }),
+  [f.in]: ({ current: i, changeState: e, children: t }) => [
+    i,
+    d.cloneElement(t, {
+      in: !0,
+      onEntered: $(t, "onEntered", () => {
+        e(c);
+      })
+    })
+  ]
+}, ue = {
+  [f.out]: ({ children: i, changeState: e }) => d.cloneElement(i, {
+    in: !0,
+    onEntered: $(i, "onEntered", () => {
+      e(h, d.cloneElement(i, { in: !0 }));
+    })
+  }),
+  [f.in]: ({ current: i, children: e, changeState: t }) => [
+    d.cloneElement(i, {
+      in: !1,
+      onExited: $(i, "onExited", () => {
+        t(h, d.cloneElement(e, { in: !0 }));
+      })
+    }),
+    d.cloneElement(e, {
+      in: !0
+    })
+  ]
+};
+class F extends d.Component {
+  constructor() {
+    super(...arguments), M(this, "state", {
+      status: h,
+      current: null
+    }), M(this, "appeared", !1), M(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 === c && e.mode === f.in ? {
+      status: c
+    } : t.current && pe(t.current, e.children) ? {
+      status: k
+    } : {
+      current: d.cloneElement(e.children, {
+        in: !0
+      })
+    };
+  }
+  render() {
+    const {
+      props: { children: e, mode: t },
+      state: { status: n, current: s }
+    } = this, r = { children: e, current: s, changeState: this.changeState, status: n };
+    let a;
+    switch (n) {
+      case c:
+        a = ue[t](r);
+        break;
+      case k:
+        a = he[t](r);
+        break;
+      case h:
+        a = s;
+    }
+    return /* @__PURE__ */ m(R.Provider, { value: { isMounting: !this.appeared }, children: a });
+  }
+}
+F.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: o.oneOf([f.in, f.out]),
+  /**
+   * Any `Transition` or `CSSTransition` component.
+   */
+  children: o.oneOfType([o.element.isRequired])
+};
+F.defaultProps = {
+  mode: f.out
+};
+function De(i) {
+  const { children: e, ...t } = i, n = w(), s = w(), r = G(() => i.nodeRef === void 0 && W(e) && O(e) ? (s.current = !0, N(e, {
+    ref: (a) => {
+      n.current = X(a), H(e, a);
+    }
+  })) : (s.current = !1, e), [e, i.nodeRef]);
+  return s.current && [
+    "onEnter",
+    "onEntering",
+    "onEntered",
+    "onExit",
+    "onExiting",
+    "onExited"
+  ].forEach((a) => {
+    i[a] && (t[a] = (l, ...E) => {
+      i[a](n.current, ...E);
+    });
+  }), /* @__PURE__ */ m(P, { ...t, nodeRef: s.current ? n : void 0, children: r });
+}
+export {
+  De as P,
+  A as b,
+  P as c,
+  F as h,
+  u
+};