@ck-ui/component-library 0.2.0 → 1.0.0

package/dist/Grow-D08Iq1uH.js

@@ -0,0 +1,794 @@
+import * as f from "react";
+import P from "react";
+import { a as lt, j as ft, T as pt, n as dt, P as n, F as Et, z as mt, U as H, c as ht, Q as G, e as Q } from "./useSlot-ylt7_lTY.js";
+import * as xt from "react-dom";
+import L from "react-dom";
+import { jsx as gt } from "react/jsx-runtime";
+function yt(e) {
+  return Object.keys(e).length === 0;
+}
+function vt(e = null) {
+  const r = f.useContext(lt);
+  return !r || yt(r) ? e : r;
+}
+const Tt = ft();
+function bt(e = Tt) {
+  return vt(e);
+}
+const Ot = "exact-prop: ​";
+function Nt(e) {
+  return process.env.NODE_ENV === "production" ? e : {
+    ...e,
+    [Ot]: (r) => {
+      const s = Object.keys(r).filter((o) => !e.hasOwnProperty(o));
+      return s.length > 0 ? new Error(`The following props are not supported: ${s.map((o) => `\`${o}\``).join(", ")}. Please remove them.`) : null;
+    }
+  };
+}
+let q = 0;
+function Dt(e) {
+  const [r, s] = f.useState(e), o = e || r;
+  return f.useEffect(() => {
+    r == null && (q += 1, s(`mui-${q}`));
+  }, [r]), o;
+}
+const Rt = {
+  ...f
+}, F = Rt.useId;
+function Bt(e) {
+  if (F !== void 0) {
+    const r = F();
+    return e ?? r;
+  }
+  return Dt(e);
+}
+function St() {
+  const e = bt(dt);
+  return process.env.NODE_ENV !== "production" && f.useDebugValue(e), e[pt] || e;
+}
+function X(e, r) {
+  typeof e == "function" ? e(r) : e && (e.current = r);
+}
+function Pt(e, r) {
+  if (e == null) return {};
+  var s = {};
+  for (var o in e) if ({}.hasOwnProperty.call(e, o)) {
+    if (r.indexOf(o) !== -1) continue;
+    s[o] = e[o];
+  }
+  return s;
+}
+function j(e, r) {
+  return j = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(s, o) {
+    return s.__proto__ = o, s;
+  }, j(e, r);
+}
+function Ct(e, r) {
+  e.prototype = Object.create(r.prototype), e.prototype.constructor = e, j(e, r);
+}
+const z = {
+  disabled: !1
+};
+var It = process.env.NODE_ENV !== "production" ? n.oneOfType([n.number, n.shape({
+  enter: n.number,
+  exit: n.number,
+  appear: n.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && n.oneOfType([n.string, n.shape({
+  enter: n.string,
+  exit: n.string,
+  active: n.string
+}), n.shape({
+  enter: n.string,
+  enterDone: n.string,
+  enterActive: n.string,
+  exit: n.string,
+  exitDone: n.string,
+  exitActive: n.string
+})]);
+const Y = P.createContext(null);
+var wt = function(r) {
+  return r.scrollTop;
+}, C = "unmounted", g = "exited", y = "entering", D = "entered", V = "exiting", E = /* @__PURE__ */ (function(e) {
+  Ct(r, e);
+  function r(o, i) {
+    var t;
+    t = e.call(this, o, i) || this;
+    var a = i, u = a && !a.isMounting ? o.enter : o.appear, c;
+    return t.appearStatus = null, o.in ? u ? (c = g, t.appearStatus = y) : c = D : o.unmountOnExit || o.mountOnEnter ? c = C : c = g, t.state = {
+      status: c
+    }, t.nextCallback = null, t;
+  }
+  r.getDerivedStateFromProps = function(i, t) {
+    var a = i.in;
+    return a && t.status === C ? {
+      status: g
+    } : null;
+  };
+  var s = r.prototype;
+  return s.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, s.componentDidUpdate = function(i) {
+    var t = null;
+    if (i !== this.props) {
+      var a = this.state.status;
+      this.props.in ? a !== y && a !== D && (t = y) : (a === y || a === D) && (t = V);
+    }
+    this.updateStatus(!1, t);
+  }, s.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, s.getTimeouts = function() {
+    var i = this.props.timeout, t, a, u;
+    return t = a = u = i, i != null && typeof i != "number" && (t = i.exit, a = i.enter, u = i.appear !== void 0 ? i.appear : a), {
+      exit: t,
+      enter: a,
+      appear: u
+    };
+  }, s.updateStatus = function(i, t) {
+    if (i === void 0 && (i = !1), t !== null)
+      if (this.cancelNextCallback(), t === y) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var a = this.props.nodeRef ? this.props.nodeRef.current : L.findDOMNode(this);
+          a && wt(a);
+        }
+        this.performEnter(i);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === g && this.setState({
+      status: C
+    });
+  }, s.performEnter = function(i) {
+    var t = this, a = this.props.enter, u = this.context ? this.context.isMounting : i, c = this.props.nodeRef ? [u] : [L.findDOMNode(this), u], p = c[0], m = c[1], R = this.getTimeouts(), w = u ? R.appear : R.enter;
+    if (!i && !a || z.disabled) {
+      this.safeSetState({
+        status: D
+      }, function() {
+        t.props.onEntered(p);
+      });
+      return;
+    }
+    this.props.onEnter(p, m), this.safeSetState({
+      status: y
+    }, function() {
+      t.props.onEntering(p, m), t.onTransitionEnd(w, function() {
+        t.safeSetState({
+          status: D
+        }, function() {
+          t.props.onEntered(p, m);
+        });
+      });
+    });
+  }, s.performExit = function() {
+    var i = this, t = this.props.exit, a = this.getTimeouts(), u = this.props.nodeRef ? void 0 : L.findDOMNode(this);
+    if (!t || z.disabled) {
+      this.safeSetState({
+        status: g
+      }, function() {
+        i.props.onExited(u);
+      });
+      return;
+    }
+    this.props.onExit(u), this.safeSetState({
+      status: V
+    }, function() {
+      i.props.onExiting(u), i.onTransitionEnd(a.exit, function() {
+        i.safeSetState({
+          status: g
+        }, function() {
+          i.props.onExited(u);
+        });
+      });
+    });
+  }, s.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, s.safeSetState = function(i, t) {
+    t = this.setNextCallback(t), this.setState(i, t);
+  }, s.setNextCallback = function(i) {
+    var t = this, a = !0;
+    return this.nextCallback = function(u) {
+      a && (a = !1, t.nextCallback = null, i(u));
+    }, this.nextCallback.cancel = function() {
+      a = !1;
+    }, this.nextCallback;
+  }, s.onTransitionEnd = function(i, t) {
+    this.setNextCallback(t);
+    var a = this.props.nodeRef ? this.props.nodeRef.current : L.findDOMNode(this), u = i == null && !this.props.addEndListener;
+    if (!a || u) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var c = this.props.nodeRef ? [this.nextCallback] : [a, this.nextCallback], p = c[0], m = c[1];
+      this.props.addEndListener(p, m);
+    }
+    i != null && setTimeout(this.nextCallback, i);
+  }, s.render = function() {
+    var i = this.state.status;
+    if (i === C)
+      return null;
+    var t = this.props, a = t.children;
+    t.in, t.mountOnEnter, t.unmountOnExit, t.appear, t.enter, t.exit, t.timeout, t.addEndListener, t.onEnter, t.onEntering, t.onEntered, t.onExit, t.onExiting, t.onExited, t.nodeRef;
+    var u = Pt(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ P.createElement(Y.Provider, {
+        value: null
+      }, typeof a == "function" ? a(i, u) : P.cloneElement(P.Children.only(a), u))
+    );
+  }, r;
+})(P.Component);
+E.contextType = Y;
+E.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: n.shape({
+    current: typeof Element > "u" ? n.any : function(e, r, s, o, i, t) {
+      var a = e[r];
+      return n.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(e, r, s, o, i, t);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: n.oneOfType([n.func.isRequired, n.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: n.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: n.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: n.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: n.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: n.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: n.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function(r) {
+    var s = It;
+    r.addEndListener || (s = s.isRequired);
+    for (var o = arguments.length, i = new Array(o > 1 ? o - 1 : 0), t = 1; t < o; t++)
+      i[t - 1] = arguments[t];
+    return s.apply(void 0, [r].concat(i));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: n.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: n.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: n.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: n.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: n.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: n.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: n.func
+} : {};
+function O() {
+}
+E.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: O,
+  onEntering: O,
+  onEntered: O,
+  onExit: O,
+  onExiting: O,
+  onExited: O
+};
+E.UNMOUNTED = C;
+E.EXITED = g;
+E.ENTERING = y;
+E.ENTERED = D;
+E.EXITING = V;
+const W = {};
+function _t(e, r) {
+  const s = f.useRef(W);
+  return s.current === W && (s.current = e(r)), s;
+}
+const Lt = [];
+function Mt(e) {
+  f.useEffect(e, Lt);
+}
+class U {
+  static create() {
+    return new U();
+  }
+  currentId = null;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  start(r, s) {
+    this.clear(), this.currentId = setTimeout(() => {
+      this.currentId = null, s();
+    }, r);
+  }
+  clear = () => {
+    this.currentId !== null && (clearTimeout(this.currentId), this.currentId = null);
+  };
+  disposeEffect = () => this.clear;
+}
+function kt() {
+  const e = _t(U.create).current;
+  return Mt(e.disposeEffect), e;
+}
+const jt = (e) => e.scrollTop;
+function N(e, r) {
+  return (s) => {
+    if (r) {
+      const o = e.current;
+      s === void 0 ? r(o) : r(o, s);
+    }
+  };
+}
+function Vt(e, r, s, o, i, t) {
+  const a = e === "exited" && !r ? o : s[e] || s.exited;
+  return i || t ? {
+    ...a,
+    ...i,
+    ...t
+  } : a;
+}
+function B(e, r) {
+  const {
+    timeout: s,
+    easing: o,
+    style: i = {}
+  } = e;
+  return {
+    duration: i.transitionDuration ?? (typeof s == "number" ? s : s[r.mode] || 0),
+    easing: i.transitionTimingFunction ?? (typeof o == "object" ? o[r.mode] : o),
+    delay: i.transitionDelay
+  };
+}
+const Qt = n.oneOfType([n.func, n.object]);
+function $t(e, r, s, o, i) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const t = e[r], a = i || r;
+  return t == null ? null : t && t.nodeType !== 1 ? new Error(`Invalid ${o} \`${a}\` supplied to \`${s}\`. Expected an HTMLElement.`) : null;
+}
+function Yt(e) {
+  const {
+    elementType: r,
+    externalSlotProps: s,
+    ownerState: o,
+    skipResolvingSlotProps: i = !1,
+    ...t
+  } = e, a = i ? {} : Et(s, o), {
+    props: u,
+    internalRef: c
+  } = mt({
+    ...t,
+    externalSlotProps: a
+  }), p = H(c, a?.ref, e.additionalProps?.ref);
+  return ht(r, {
+    ...u,
+    ref: p
+  }, o);
+}
+function Zt() {
+  return !(/jsdom|HappyDOM/.test(window.navigator.userAgent) || // TODO(v9): Remove the test environment check
+  // eslint-disable-next-line mui/consistent-production-guard
+  process.env.NODE_ENV === "test");
+}
+function Z(e) {
+  return parseInt(f.version, 10) >= 19 ? e?.props?.ref || null : e?.ref || null;
+}
+function At(e) {
+  return typeof e == "function" ? e() : e;
+}
+const $ = /* @__PURE__ */ f.forwardRef(function(r, s) {
+  const {
+    children: o,
+    container: i,
+    disablePortal: t = !1
+  } = r, [a, u] = f.useState(null), c = H(/* @__PURE__ */ f.isValidElement(o) ? Z(o) : null, s);
+  if (G(() => {
+    t || u(At(i) || document.body);
+  }, [i, t]), G(() => {
+    if (a && !t)
+      return X(s, a), () => {
+        X(s, null);
+      };
+  }, [s, a, t]), t) {
+    if (/* @__PURE__ */ f.isValidElement(o)) {
+      const p = {
+        ref: c
+      };
+      return /* @__PURE__ */ f.cloneElement(o, p);
+    }
+    return o;
+  }
+  return a && /* @__PURE__ */ xt.createPortal(o, a);
+});
+process.env.NODE_ENV !== "production" && ($.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The children to render into the `container`.
+   */
+  children: n.node,
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: n.oneOfType([$t, n.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: n.bool
+});
+process.env.NODE_ENV !== "production" && ($.propTypes = Nt($.propTypes));
+function Ht(e) {
+  const {
+    prototype: r = {}
+  } = e;
+  return !!r.isReactComponent;
+}
+function J(e, r, s, o, i) {
+  const t = e[r], a = i || r;
+  if (t == null || // When server-side rendering React doesn't warn either.
+  // This is not an accurate check for SSR.
+  // This is only in place for Emotion compat.
+  // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
+  typeof window > "u")
+    return null;
+  let u;
+  const c = t.type;
+  return typeof c == "function" && !Ht(c) && (u = "Did you accidentally use a plain function component for an element instead?"), u !== void 0 ? new Error(`Invalid ${o} \`${a}\` supplied to \`${s}\`. Expected an element that can hold a ref. ${u} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const K = Q(n.element, J);
+K.isRequired = Q(n.element.isRequired, J);
+function I(e) {
+  return `scale(${e}, ${e ** 2})`;
+}
+const Ut = {
+  entering: {
+    opacity: 1,
+    transform: I(1)
+  },
+  entered: {
+    opacity: 1,
+    transform: "none"
+  },
+  exiting: {
+    opacity: 0,
+    transform: I(0.75)
+  },
+  exited: {
+    opacity: 0,
+    transform: I(0.75)
+  }
+}, Gt = {
+  opacity: 0,
+  transform: I(0.75),
+  visibility: "hidden"
+}, A = /* @__PURE__ */ f.forwardRef(function(r, s) {
+  const {
+    addEndListener: o,
+    appear: i = !0,
+    children: t,
+    easing: a,
+    in: u,
+    onEnter: c,
+    onEntered: p,
+    onEntering: m,
+    onExit: R,
+    onExited: w,
+    onExiting: tt,
+    style: M,
+    timeout: x = "auto",
+    ...et
+  } = r, nt = kt(), k = f.useRef(), v = St(), d = f.useRef(null), ot = H(d, Z(t), s), rt = N(d, m), it = N(d, (l, _) => {
+    jt(l);
+    const {
+      duration: T,
+      delay: b,
+      easing: h
+    } = B({
+      style: M,
+      timeout: x,
+      easing: a
+    }, {
+      mode: "enter"
+    });
+    let S;
+    x === "auto" ? (S = v.transitions.getAutoHeightDuration(l.clientHeight), k.current = S) : S = T, l.style.transition = [v.transitions.create("opacity", {
+      duration: S,
+      delay: b
+    }), v.transitions.create("transform", {
+      duration: S * 0.666,
+      delay: b,
+      easing: h
+    })].join(","), c && c(l, _);
+  }), st = N(d, p), at = N(d, tt), ut = N(d, (l) => {
+    const {
+      duration: _,
+      delay: T,
+      easing: b
+    } = B({
+      style: M,
+      timeout: x,
+      easing: a
+    }, {
+      mode: "exit"
+    });
+    let h;
+    x === "auto" ? (h = v.transitions.getAutoHeightDuration(l.clientHeight), k.current = h) : h = _, l.style.transition = [v.transitions.create("opacity", {
+      duration: h,
+      delay: T
+    }), v.transitions.create("transform", {
+      duration: h * 0.666,
+      delay: T || h * 0.333,
+      easing: b
+    })].join(","), l.style.opacity = 0, l.style.transform = I(0.75), R && R(l);
+  }), ct = N(d, (l) => {
+    l.style.transition = "", w && w(l);
+  });
+  return /* @__PURE__ */ gt(E, {
+    appear: i,
+    in: u,
+    nodeRef: d,
+    onEnter: it,
+    onEntered: st,
+    onEntering: rt,
+    onExit: ut,
+    onExited: ct,
+    onExiting: at,
+    addEndListener: (l) => {
+      x === "auto" && nt.start(k.current || 0, l), o && o(d.current, l);
+    },
+    timeout: x === "auto" ? null : x,
+    ...et,
+    children: (l, {
+      ownerState: _,
+      ...T
+    }) => {
+      const b = Vt(l, u, Ut, Gt, M, t.props.style);
+      return /* @__PURE__ */ f.cloneElement(t, {
+        style: b,
+        ref: ot,
+        ...T
+      });
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (A.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: n.func,
+  /**
+   * Perform the enter transition when it first mounts if `in` is also `true`.
+   * Set this to `false` to disable this behavior.
+   * @default true
+   */
+  appear: n.bool,
+  /**
+   * A single child content element.
+   */
+  children: K.isRequired,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: n.oneOfType([n.shape({
+    enter: n.string,
+    exit: n.string
+  }), n.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: n.bool,
+  /**
+   * @ignore
+   */
+  onEnter: n.func,
+  /**
+   * @ignore
+   */
+  onEntered: n.func,
+  /**
+   * @ignore
+   */
+  onEntering: n.func,
+  /**
+   * @ignore
+   */
+  onExit: n.func,
+  /**
+   * @ignore
+   */
+  onExited: n.func,
+  /**
+   * @ignore
+   */
+  onExiting: n.func,
+  /**
+   * @ignore
+   */
+  style: n.object,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   *
+   * Set to 'auto' to automatically calculate transition time based on height.
+   * @default 'auto'
+   */
+  timeout: n.oneOfType([n.oneOf(["auto"]), n.number, n.shape({
+    appear: n.number,
+    enter: n.number,
+    exit: n.number
+  })])
+});
+A && (A.muiSupportAuto = !0);
+export {
+  A as G,
+  $t as H,
+  $ as P,
+  U as T,
+  Ct as _,
+  E as a,
+  Y as b,
+  Pt as c,
+  Nt as d,
+  K as e,
+  Vt as f,
+  Z as g,
+  B as h,
+  Zt as i,
+  jt as j,
+  _t as k,
+  Yt as l,
+  St as m,
+  N as n,
+  bt as o,
+  vt as p,
+  kt as q,
+  Qt as r,
+  X as s,
+  Bt as u
+};