@unicom-cloud/ui 0.8.67 → 0.8.68

package/chunk/DC1iHEiy.js

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