jcicl 0.0.56 → 0.0.58

package/.chunks/Portal.js

@@ -0,0 +1,824 @@
+import * as f from "react";
+import _ from "react";
+import { P as r, b as W, h as de, T as pe, i as me } from "./DefaultPropsProvider.js";
+import { c as q, _ as Ee, a as he, T as K, b as ge, e as P, s as X } from "./TransitionGroupContext.js";
+import { jsx as H } from "react/jsx-runtime";
+import { T as ve } from "./emotion-styled.browser.esm.js";
+import { c as Q } from "./chainPropTypes.js";
+import * as xe from "react-dom";
+import M from "react-dom";
+function ye(e) {
+  const {
+    prototype: s = {}
+  } = e;
+  return !!s.isReactComponent;
+}
+function Y(e, s, o, i, n) {
+  const t = e[s], a = n || s;
+  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" && !ye(c) && (u = "Did you accidentally use a plain function component for an element instead?"), u !== void 0 ? new Error(`Invalid ${i} \`${a}\` supplied to \`${o}\`. Expected an element that can hold a ref. ${u} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const ee = Q(r.element, Y);
+ee.isRequired = Q(r.element.isRequired, Y);
+const Te = "exact-prop: ​";
+function be(e) {
+  return process.env.NODE_ENV === "production" ? e : {
+    ...e,
+    [Te]: (s) => {
+      const o = Object.keys(s).filter((i) => !e.hasOwnProperty(i));
+      return o.length > 0 ? new Error(`The following props are not supported: ${o.map((i) => `\`${i}\``).join(", ")}. Please remove them.`) : null;
+    }
+  };
+}
+function Ne(e, s, o, i, n) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const t = e[s], a = n || s;
+  return t == null ? null : t && t.nodeType !== 1 ? new Error(`Invalid ${i} \`${a}\` supplied to \`${o}\`. Expected an HTMLElement.`) : null;
+}
+function Je(e) {
+  return e && e.ownerDocument || document;
+}
+let z = 0;
+function Oe(e) {
+  const [s, o] = f.useState(e), i = e || s;
+  return f.useEffect(() => {
+    s == null && (z += 1, o(`mui-${z}`));
+  }, [s]), i;
+}
+const Re = {
+  ...f
+}, F = Re.useId;
+function Ke(e) {
+  if (F !== void 0) {
+    const s = F();
+    return e ?? s;
+  }
+  return Oe(e);
+}
+function Qe({
+  controlled: e,
+  default: s,
+  name: o,
+  state: i = "value"
+}) {
+  const {
+    current: n
+  } = f.useRef(e !== void 0), [t, a] = f.useState(s), u = n ? e : t;
+  if (process.env.NODE_ENV !== "production") {
+    f.useEffect(() => {
+      n !== (e !== void 0) && console.error([`MUI: A component is changing the ${n ? "" : "un"}controlled ${i} state of ${o} to be ${n ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${o} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [i, o, e]);
+    const {
+      current: l
+    } = f.useRef(s);
+    f.useEffect(() => {
+      !n && !Object.is(l, s) && console.error([`MUI: A component is changing the default ${i} state of an uncontrolled ${o} after being initialized. To suppress this warning opt to use a controlled ${o}.`].join(`
+`));
+    }, [JSON.stringify(s)]);
+  }
+  const c = f.useCallback((l) => {
+    n || a(l);
+  }, []);
+  return [u, c];
+}
+function De(e) {
+  return typeof e == "string";
+}
+function Ce(e, s, o) {
+  return e === void 0 || De(e) ? s : {
+    ...s,
+    ownerState: {
+      ...s.ownerState,
+      ...o
+    }
+  };
+}
+function Se(e, s = []) {
+  if (e === void 0)
+    return {};
+  const o = {};
+  return Object.keys(e).filter((i) => i.match(/^on[A-Z]/) && typeof e[i] == "function" && !s.includes(i)).forEach((i) => {
+    o[i] = e[i];
+  }), o;
+}
+function Z(e) {
+  if (e === void 0)
+    return {};
+  const s = {};
+  return Object.keys(e).filter((o) => !(o.match(/^on[A-Z]/) && typeof e[o] == "function")).forEach((o) => {
+    s[o] = e[o];
+  }), s;
+}
+function Ie(e) {
+  const {
+    getSlotProps: s,
+    additionalProps: o,
+    externalSlotProps: i,
+    externalForwardedProps: n,
+    className: t
+  } = e;
+  if (!s) {
+    const k = W(o == null ? void 0 : o.className, t, n == null ? void 0 : n.className, i == null ? void 0 : i.className), N = {
+      ...o == null ? void 0 : o.style,
+      ...n == null ? void 0 : n.style,
+      ...i == null ? void 0 : i.style
+    }, E = {
+      ...o,
+      ...n,
+      ...i
+    };
+    return k.length > 0 && (E.className = k), Object.keys(N).length > 0 && (E.style = N), {
+      props: E,
+      internalRef: void 0
+    };
+  }
+  const a = Se({
+    ...n,
+    ...i
+  }), u = Z(i), c = Z(n), l = s(a), p = W(l == null ? void 0 : l.className, o == null ? void 0 : o.className, t, n == null ? void 0 : n.className, i == null ? void 0 : i.className), m = {
+    ...l == null ? void 0 : l.style,
+    ...o == null ? void 0 : o.style,
+    ...n == null ? void 0 : n.style,
+    ...i == null ? void 0 : i.style
+  }, y = {
+    ...l,
+    ...o,
+    ...c,
+    ...u
+  };
+  return p.length > 0 && (y.className = p), Object.keys(m).length > 0 && (y.style = m), {
+    props: y,
+    internalRef: l.ref
+  };
+}
+function ke(e, s, o) {
+  return typeof e == "function" ? e(s, o) : e;
+}
+function Ye(e) {
+  var m;
+  const {
+    elementType: s,
+    externalSlotProps: o,
+    ownerState: i,
+    skipResolvingSlotProps: n = !1,
+    ...t
+  } = e, a = n ? {} : ke(o, i), {
+    props: u,
+    internalRef: c
+  } = Ie({
+    ...t,
+    externalSlotProps: a
+  }), l = q(c, a == null ? void 0 : a.ref, (m = e.additionalProps) == null ? void 0 : m.ref);
+  return Ce(s, {
+    ...u,
+    ref: l
+  }, i);
+}
+function te(e) {
+  var s;
+  return parseInt(f.version, 10) >= 19 ? ((s = e == null ? void 0 : e.props) == null ? void 0 : s.ref) || null : (e == null ? void 0 : e.ref) || null;
+}
+function $e(e) {
+  return Object.keys(e).length === 0;
+}
+function we(e = null) {
+  const s = f.useContext(ve);
+  return !s || $e(s) ? e : s;
+}
+const _e = de();
+function Me(e = _e) {
+  return we(e);
+}
+const Ve = /* @__PURE__ */ f.createContext();
+process.env.NODE_ENV !== "production" && (r.node, r.bool);
+const et = () => f.useContext(Ve) ?? !1;
+function Le() {
+  const e = Me(me);
+  return process.env.NODE_ENV !== "production" && f.useDebugValue(e), e[pe] || e;
+}
+const B = {
+  disabled: !1
+};
+var He = process.env.NODE_ENV !== "production" ? r.oneOfType([r.number, r.shape({
+  enter: r.number,
+  exit: r.number,
+  appear: r.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && r.oneOfType([r.string, r.shape({
+  enter: r.string,
+  exit: r.string,
+  active: r.string
+}), r.shape({
+  enter: r.string,
+  enterDone: r.string,
+  enterActive: r.string,
+  exit: r.string,
+  exitDone: r.string,
+  exitActive: r.string
+})]);
+var Ae = function(s) {
+  return s.scrollTop;
+}, I = "unmounted", T = "exited", b = "entering", S = "entered", A = "exiting", g = /* @__PURE__ */ function(e) {
+  Ee(s, e);
+  function s(i, n) {
+    var t;
+    t = e.call(this, i, n) || this;
+    var a = n, u = a && !a.isMounting ? i.enter : i.appear, c;
+    return t.appearStatus = null, i.in ? u ? (c = T, t.appearStatus = b) : c = S : i.unmountOnExit || i.mountOnEnter ? c = I : c = T, t.state = {
+      status: c
+    }, t.nextCallback = null, t;
+  }
+  s.getDerivedStateFromProps = function(n, t) {
+    var a = n.in;
+    return a && t.status === I ? {
+      status: T
+    } : null;
+  };
+  var o = s.prototype;
+  return o.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, o.componentDidUpdate = function(n) {
+    var t = null;
+    if (n !== this.props) {
+      var a = this.state.status;
+      this.props.in ? a !== b && a !== S && (t = b) : (a === b || a === S) && (t = A);
+    }
+    this.updateStatus(!1, t);
+  }, o.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, o.getTimeouts = function() {
+    var n = this.props.timeout, t, a, u;
+    return t = a = u = n, n != null && typeof n != "number" && (t = n.exit, a = n.enter, u = n.appear !== void 0 ? n.appear : a), {
+      exit: t,
+      enter: a,
+      appear: u
+    };
+  }, o.updateStatus = function(n, t) {
+    if (n === void 0 && (n = !1), t !== null)
+      if (this.cancelNextCallback(), t === b) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var a = this.props.nodeRef ? this.props.nodeRef.current : M.findDOMNode(this);
+          a && Ae(a);
+        }
+        this.performEnter(n);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === T && this.setState({
+      status: I
+    });
+  }, o.performEnter = function(n) {
+    var t = this, a = this.props.enter, u = this.context ? this.context.isMounting : n, c = this.props.nodeRef ? [u] : [M.findDOMNode(this), u], l = c[0], p = c[1], m = this.getTimeouts(), y = u ? m.appear : m.enter;
+    if (!n && !a || B.disabled) {
+      this.safeSetState({
+        status: S
+      }, function() {
+        t.props.onEntered(l);
+      });
+      return;
+    }
+    this.props.onEnter(l, p), this.safeSetState({
+      status: b
+    }, function() {
+      t.props.onEntering(l, p), t.onTransitionEnd(y, function() {
+        t.safeSetState({
+          status: S
+        }, function() {
+          t.props.onEntered(l, p);
+        });
+      });
+    });
+  }, o.performExit = function() {
+    var n = this, t = this.props.exit, a = this.getTimeouts(), u = this.props.nodeRef ? void 0 : M.findDOMNode(this);
+    if (!t || B.disabled) {
+      this.safeSetState({
+        status: T
+      }, function() {
+        n.props.onExited(u);
+      });
+      return;
+    }
+    this.props.onExit(u), this.safeSetState({
+      status: A
+    }, function() {
+      n.props.onExiting(u), n.onTransitionEnd(a.exit, function() {
+        n.safeSetState({
+          status: T
+        }, function() {
+          n.props.onExited(u);
+        });
+      });
+    });
+  }, o.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, o.safeSetState = function(n, t) {
+    t = this.setNextCallback(t), this.setState(n, t);
+  }, o.setNextCallback = function(n) {
+    var t = this, a = !0;
+    return this.nextCallback = function(u) {
+      a && (a = !1, t.nextCallback = null, n(u));
+    }, this.nextCallback.cancel = function() {
+      a = !1;
+    }, this.nextCallback;
+  }, o.onTransitionEnd = function(n, t) {
+    this.setNextCallback(t);
+    var a = this.props.nodeRef ? this.props.nodeRef.current : M.findDOMNode(this), u = n == 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], l = c[0], p = c[1];
+      this.props.addEndListener(l, p);
+    }
+    n != null && setTimeout(this.nextCallback, n);
+  }, o.render = function() {
+    var n = this.state.status;
+    if (n === I)
+      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 = he(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ _.createElement(K.Provider, {
+        value: null
+      }, typeof a == "function" ? a(n, u) : _.cloneElement(_.Children.only(a), u))
+    );
+  }, s;
+}(_.Component);
+g.contextType = K;
+g.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: r.shape({
+    current: typeof Element > "u" ? r.any : function(e, s, o, i, n, t) {
+      var a = e[s];
+      return r.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(e, s, o, i, n, t);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: r.oneOfType([r.func.isRequired, r.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: r.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: r.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: r.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: r.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: r.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: r.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(s) {
+    var o = He;
+    s.addEndListener || (o = o.isRequired);
+    for (var i = arguments.length, n = new Array(i > 1 ? i - 1 : 0), t = 1; t < i; t++)
+      n[t - 1] = arguments[t];
+    return o.apply(void 0, [s].concat(n));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: r.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: r.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: r.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: r.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: r.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: r.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: r.func
+} : {};
+function C() {
+}
+g.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: C,
+  onEntering: C,
+  onEntered: C,
+  onExit: C,
+  onExiting: C,
+  onExited: C
+};
+g.UNMOUNTED = I;
+g.EXITED = T;
+g.ENTERING = b;
+g.ENTERED = S;
+g.EXITING = A;
+const je = (e) => e.scrollTop;
+function J(e, s) {
+  const {
+    timeout: o,
+    easing: i,
+    style: n = {}
+  } = e;
+  return {
+    duration: n.transitionDuration ?? (typeof o == "number" ? o : o[s.mode] || 0),
+    easing: n.transitionTimingFunction ?? (typeof i == "object" ? i[s.mode] : i),
+    delay: n.transitionDelay
+  };
+}
+function j(e) {
+  return `scale(${e}, ${e ** 2})`;
+}
+const Ue = {
+  entering: {
+    opacity: 1,
+    transform: j(1)
+  },
+  entered: {
+    opacity: 1,
+    transform: "none"
+  }
+}, L = typeof navigator < "u" && /^((?!chrome|android).)*(safari|mobile)/i.test(navigator.userAgent) && /(os |version\/)15(.|_)4/i.test(navigator.userAgent), U = /* @__PURE__ */ f.forwardRef(function(s, o) {
+  const {
+    addEndListener: i,
+    appear: n = !0,
+    children: t,
+    easing: a,
+    in: u,
+    onEnter: c,
+    onEntered: l,
+    onEntering: p,
+    onExit: m,
+    onExited: y,
+    onExiting: k,
+    style: N,
+    timeout: E = "auto",
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: ne = g,
+    ...ie
+  } = s, oe = ge(), V = f.useRef(), O = Le(), $ = f.useRef(null), re = q($, te(t), o), R = (d) => (v) => {
+    if (d) {
+      const x = $.current;
+      v === void 0 ? d(x) : d(x, v);
+    }
+  }, se = R(p), ae = R((d, v) => {
+    je(d);
+    const {
+      duration: x,
+      delay: w,
+      easing: h
+    } = J({
+      style: N,
+      timeout: E,
+      easing: a
+    }, {
+      mode: "enter"
+    });
+    let D;
+    E === "auto" ? (D = O.transitions.getAutoHeightDuration(d.clientHeight), V.current = D) : D = x, d.style.transition = [O.transitions.create("opacity", {
+      duration: D,
+      delay: w
+    }), O.transitions.create("transform", {
+      duration: L ? D : D * 0.666,
+      delay: w,
+      easing: h
+    })].join(","), c && c(d, v);
+  }), ue = R(l), ce = R(k), le = R((d) => {
+    const {
+      duration: v,
+      delay: x,
+      easing: w
+    } = J({
+      style: N,
+      timeout: E,
+      easing: a
+    }, {
+      mode: "exit"
+    });
+    let h;
+    E === "auto" ? (h = O.transitions.getAutoHeightDuration(d.clientHeight), V.current = h) : h = v, d.style.transition = [O.transitions.create("opacity", {
+      duration: h,
+      delay: x
+    }), O.transitions.create("transform", {
+      duration: L ? h : h * 0.666,
+      delay: L ? x : x || h * 0.333,
+      easing: w
+    })].join(","), d.style.opacity = 0, d.style.transform = j(0.75), m && m(d);
+  }), fe = R(y);
+  return /* @__PURE__ */ H(ne, {
+    appear: n,
+    in: u,
+    nodeRef: $,
+    onEnter: ae,
+    onEntered: ue,
+    onEntering: se,
+    onExit: le,
+    onExited: fe,
+    onExiting: ce,
+    addEndListener: (d) => {
+      E === "auto" && oe.start(V.current || 0, d), i && i($.current, d);
+    },
+    timeout: E === "auto" ? null : E,
+    ...ie,
+    children: (d, v) => /* @__PURE__ */ f.cloneElement(t, {
+      style: {
+        opacity: 0,
+        transform: j(0.75),
+        visibility: d === "exited" && !u ? "hidden" : void 0,
+        ...Ue[d],
+        ...N,
+        ...t.props.style
+      },
+      ref: re,
+      ...v
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (U.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: r.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: r.bool,
+  /**
+   * A single child content element.
+   */
+  children: ee.isRequired,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: r.oneOfType([r.shape({
+    enter: r.string,
+    exit: r.string
+  }), r.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: r.bool,
+  /**
+   * @ignore
+   */
+  onEnter: r.func,
+  /**
+   * @ignore
+   */
+  onEntered: r.func,
+  /**
+   * @ignore
+   */
+  onEntering: r.func,
+  /**
+   * @ignore
+   */
+  onExit: r.func,
+  /**
+   * @ignore
+   */
+  onExited: r.func,
+  /**
+   * @ignore
+   */
+  onExiting: r.func,
+  /**
+   * @ignore
+   */
+  style: r.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: r.oneOfType([r.oneOf(["auto"]), r.number, r.shape({
+    appear: r.number,
+    enter: r.number,
+    exit: r.number
+  })])
+});
+U && (U.muiSupportAuto = !0);
+function Ge(e) {
+  return typeof e == "function" ? e() : e;
+}
+const G = /* @__PURE__ */ f.forwardRef(function(s, o) {
+  const {
+    children: i,
+    container: n,
+    disablePortal: t = !1
+  } = s, [a, u] = f.useState(null), c = q(/* @__PURE__ */ f.isValidElement(i) ? te(i) : null, o);
+  if (P(() => {
+    t || u(Ge(n) || document.body);
+  }, [n, t]), P(() => {
+    if (a && !t)
+      return X(o, a), () => {
+        X(o, null);
+      };
+  }, [o, a, t]), t) {
+    if (/* @__PURE__ */ f.isValidElement(i)) {
+      const l = {
+        ref: c
+      };
+      return /* @__PURE__ */ f.cloneElement(i, l);
+    }
+    return /* @__PURE__ */ H(f.Fragment, {
+      children: i
+    });
+  }
+  return /* @__PURE__ */ H(f.Fragment, {
+    children: a && /* @__PURE__ */ xe.createPortal(i, a)
+  });
+});
+process.env.NODE_ENV !== "production" && (G.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: r.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: r.oneOfType([Ne, r.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: r.bool
+});
+process.env.NODE_ENV !== "production" && (G.propTypes = be(G.propTypes));
+export {
+  U as G,
+  Ne as H,
+  G as P,
+  g as T,
+  et as a,
+  Le as b,
+  Qe as c,
+  Ke as d,
+  Ce as e,
+  ee as f,
+  te as g,
+  Me as h,
+  be as i,
+  je as j,
+  J as k,
+  Se as l,
+  Ie as m,
+  Je as o,
+  ke as r,
+  Ye as u
+};