everest-npm-features 0.0.61 → 0.0.63

package/dist/Portal-BeS9yJCZ.js

@@ -0,0 +1,968 @@
+var ge = Object.defineProperty;
+var ve = (e, o, r) => o in e ? ge(e, o, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[o] = r;
+var L = (e, o, r) => ve(e, typeof o != "symbol" ? o + "" : o, r);
+import * as c from "react";
+import k from "react";
+import { h as xe, P as s, T as Te, i as be, b as B } from "./memoTheme-DnE8lj0t.js";
+import { jsx as Ne } from "react/jsx-runtime";
+import { ThemeContext as Oe } from "@emotion/react";
+import * as Re from "react-dom";
+import P from "react-dom";
+function De(e) {
+  return Object.keys(e).length === 0;
+}
+function Ce(e = null) {
+  const o = c.useContext(Oe);
+  return !o || De(o) ? e : o;
+}
+const Se = xe();
+function Ie(e = Se) {
+  return Ce(e);
+}
+const G = typeof window < "u" ? c.useLayoutEffect : c.useEffect, we = "exact-prop: ​";
+function ke(e) {
+  return process.env.NODE_ENV === "production" ? e : {
+    ...e,
+    [we]: (o) => {
+      const r = Object.keys(o).filter((t) => !e.hasOwnProperty(t));
+      return r.length > 0 ? new Error(`The following props are not supported: ${r.map((t) => `\`${t}\``).join(", ")}. Please remove them.`) : null;
+    }
+  };
+}
+const _e = /* @__PURE__ */ c.createContext();
+process.env.NODE_ENV !== "production" && (s.node, s.bool);
+const rt = () => c.useContext(_e) ?? !1;
+let J = 0;
+function Me(e) {
+  const [o, r] = c.useState(e), t = e || o;
+  return c.useEffect(() => {
+    o == null && (J += 1, r(`mui-${J}`));
+  }, [o]), t;
+}
+const $e = {
+  ...c
+}, K = $e.useId;
+function it(e) {
+  if (K !== void 0) {
+    const o = K();
+    return e ?? o;
+  }
+  return Me(e);
+}
+function Le() {
+  const e = Ie(be);
+  return process.env.NODE_ENV !== "production" && c.useDebugValue(e), e[Te] || e;
+}
+const st = s.oneOfType([s.func, s.object]);
+function oe(e, o) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...t) {
+    return e(...t) || o(...t);
+  };
+}
+function V(...e) {
+  const o = c.useRef(void 0), r = c.useCallback((t) => {
+    const i = e.map((n) => {
+      if (n == null)
+        return null;
+      if (typeof n == "function") {
+        const u = n, a = u(t);
+        return typeof a == "function" ? a : () => {
+          u(null);
+        };
+      }
+      return n.current = t, () => {
+        n.current = null;
+      };
+    });
+    return () => {
+      i.forEach((n) => n == null ? void 0 : n());
+    };
+  }, e);
+  return c.useMemo(() => e.every((t) => t == null) ? null : (t) => {
+    o.current && (o.current(), o.current = void 0), t != null && (o.current = r(t));
+  }, e);
+}
+function ut(e) {
+  const o = c.useRef(e);
+  return G(() => {
+    o.current = e;
+  }), c.useRef((...r) => (
+    // @ts-expect-error hide `this`
+    (0, o.current)(...r)
+  )).current;
+}
+function at(e) {
+  return e && e.ownerDocument || document;
+}
+function Y(e, o) {
+  typeof e == "function" ? e(o) : e && (e.current = o);
+}
+function ct(e) {
+  const {
+    controlled: o,
+    default: r,
+    name: t,
+    state: i = "value"
+  } = e, {
+    current: n
+  } = c.useRef(o !== void 0), [u, a] = c.useState(r), l = n ? o : u;
+  if (process.env.NODE_ENV !== "production") {
+    c.useEffect(() => {
+      n !== (o !== void 0) && console.error([`MUI: A component is changing the ${n ? "" : "un"}controlled ${i} state of ${t} to be ${n ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${t} 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, t, o]);
+    const {
+      current: p
+    } = c.useRef(r);
+    c.useEffect(() => {
+      !n && !Object.is(p, r) && console.error([`MUI: A component is changing the default ${i} state of an uncontrolled ${t} after being initialized. To suppress this warning opt to use a controlled ${t}.`].join(`
+`));
+    }, [JSON.stringify(r)]);
+  }
+  const f = c.useCallback((p) => {
+    n || a(p);
+  }, []);
+  return [l, f];
+}
+function Pe(e) {
+  return typeof e == "string";
+}
+function re(e, o, r) {
+  return e === void 0 || Pe(e) ? o : {
+    ...o,
+    ownerState: {
+      ...o.ownerState,
+      ...r
+    }
+  };
+}
+function ie(e, o, r) {
+  return typeof e == "function" ? e(o, r) : e;
+}
+function Ve(e, o = []) {
+  if (e === void 0)
+    return {};
+  const r = {};
+  return Object.keys(e).filter((t) => t.match(/^on[A-Z]/) && typeof e[t] == "function" && !o.includes(t)).forEach((t) => {
+    r[t] = e[t];
+  }), r;
+}
+function Q(e) {
+  if (e === void 0)
+    return {};
+  const o = {};
+  return Object.keys(e).filter((r) => !(r.match(/^on[A-Z]/) && typeof e[r] == "function")).forEach((r) => {
+    o[r] = e[r];
+  }), o;
+}
+function se(e) {
+  const {
+    getSlotProps: o,
+    additionalProps: r,
+    externalSlotProps: t,
+    externalForwardedProps: i,
+    className: n
+  } = e;
+  if (!o) {
+    const N = B(r == null ? void 0 : r.className, n, i == null ? void 0 : i.className, t == null ? void 0 : t.className), h = {
+      ...r == null ? void 0 : r.style,
+      ...i == null ? void 0 : i.style,
+      ...t == null ? void 0 : t.style
+    }, E = {
+      ...r,
+      ...i,
+      ...t
+    };
+    return N.length > 0 && (E.className = N), Object.keys(h).length > 0 && (E.style = h), {
+      props: E,
+      internalRef: void 0
+    };
+  }
+  const u = Ve({
+    ...i,
+    ...t
+  }), a = Q(t), l = Q(i), f = o(u), p = B(f == null ? void 0 : f.className, r == null ? void 0 : r.className, n, i == null ? void 0 : i.className, t == null ? void 0 : t.className), m = {
+    ...f == null ? void 0 : f.style,
+    ...r == null ? void 0 : r.style,
+    ...i == null ? void 0 : i.style,
+    ...t == null ? void 0 : t.style
+  }, g = {
+    ...f,
+    ...r,
+    ...l,
+    ...a
+  };
+  return p.length > 0 && (g.className = p), Object.keys(m).length > 0 && (g.style = m), {
+    props: g,
+    internalRef: f.ref
+  };
+}
+function lt(e, o) {
+  const {
+    className: r,
+    elementType: t,
+    ownerState: i,
+    externalForwardedProps: n,
+    internalForwardedProps: u,
+    shouldForwardComponentProp: a = !1,
+    ...l
+  } = o, {
+    component: f,
+    slots: p = {
+      [e]: void 0
+    },
+    slotProps: m = {
+      [e]: void 0
+    },
+    ...g
+  } = n, N = p[e] || t, h = ie(m[e], i), {
+    props: {
+      component: E,
+      ...j
+    },
+    internalRef: A
+  } = se({
+    className: r,
+    ...l,
+    externalForwardedProps: e === "root" ? g : void 0,
+    externalSlotProps: h
+  }), H = V(A, h == null ? void 0 : h.ref, o.ref), T = e === "root" ? E || f : E, b = re(N, {
+    ...e === "root" && !f && !p[e] && u,
+    ...e !== "root" && !p[e] && u,
+    ...j,
+    ...T && !a && {
+      as: T
+    },
+    ...T && a && {
+      component: T
+    },
+    ref: H
+  }, i);
+  return [N, b];
+}
+function ue(e) {
+  var o;
+  return parseInt(c.version, 10) >= 19 ? ((o = e == null ? void 0 : e.props) == null ? void 0 : o.ref) || null : (e == null ? void 0 : e.ref) || null;
+}
+function je(e, o, r, t, i) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const n = e[o], u = i || o;
+  return n == null ? null : n && n.nodeType !== 1 ? new Error(`Invalid ${t} \`${u}\` supplied to \`${r}\`. Expected an HTMLElement.`) : null;
+}
+function ft(e) {
+  var m;
+  const {
+    elementType: o,
+    externalSlotProps: r,
+    ownerState: t,
+    skipResolvingSlotProps: i = !1,
+    ...n
+  } = e, u = i ? {} : ie(r, t), {
+    props: a,
+    internalRef: l
+  } = se({
+    ...n,
+    externalSlotProps: u
+  }), f = V(l, u == null ? void 0 : u.ref, (m = e.additionalProps) == null ? void 0 : m.ref);
+  return re(o, {
+    ...a,
+    ref: f
+  }, t);
+}
+const ee = {};
+function Ae(e, o) {
+  const r = c.useRef(ee);
+  return r.current === ee && (r.current = e(o)), r;
+}
+const He = [];
+function Ue(e) {
+  c.useEffect(e, He);
+}
+class Z {
+  constructor() {
+    L(this, "currentId", null);
+    L(this, "clear", () => {
+      this.currentId !== null && (clearTimeout(this.currentId), this.currentId = null);
+    });
+    L(this, "disposeEffect", () => this.clear);
+  }
+  static create() {
+    return new Z();
+  }
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  start(o, r) {
+    this.clear(), this.currentId = setTimeout(() => {
+      this.currentId = null, r();
+    }, o);
+  }
+}
+function Ge() {
+  const e = Ae(Z.create).current;
+  return Ue(e.disposeEffect), e;
+}
+function qe(e) {
+  const {
+    prototype: o = {}
+  } = e;
+  return !!o.isReactComponent;
+}
+function ae(e, o, r, t, i) {
+  const n = e[o], u = i || o;
+  if (n == 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 a;
+  const l = n.type;
+  return typeof l == "function" && !qe(l) && (a = "Did you accidentally use a plain function component for an element instead?"), a !== void 0 ? new Error(`Invalid ${t} \`${u}\` supplied to \`${r}\`. Expected an element that can hold a ref. ${a} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const ce = oe(s.element, ae);
+ce.isRequired = oe(s.element.isRequired, ae);
+function We(e, o) {
+  if (e == null) return {};
+  var r = {};
+  for (var t in e) if ({}.hasOwnProperty.call(e, t)) {
+    if (o.indexOf(t) !== -1) continue;
+    r[t] = e[t];
+  }
+  return r;
+}
+function q(e, o) {
+  return q = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, t) {
+    return r.__proto__ = t, r;
+  }, q(e, o);
+}
+function Fe(e, o) {
+  e.prototype = Object.create(o.prototype), e.prototype.constructor = e, q(e, o);
+}
+const te = {
+  disabled: !1
+};
+var Xe = process.env.NODE_ENV !== "production" ? s.oneOfType([s.number, s.shape({
+  enter: s.number,
+  exit: s.number,
+  appear: s.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && s.oneOfType([s.string, s.shape({
+  enter: s.string,
+  exit: s.string,
+  active: s.string
+}), s.shape({
+  enter: s.string,
+  enterDone: s.string,
+  enterActive: s.string,
+  exit: s.string,
+  exitDone: s.string,
+  exitActive: s.string
+})]);
+const le = k.createContext(null);
+var ze = function(o) {
+  return o.scrollTop;
+}, _ = "unmounted", R = "exited", D = "entering", w = "entered", W = "exiting", x = /* @__PURE__ */ function(e) {
+  Fe(o, e);
+  function o(t, i) {
+    var n;
+    n = e.call(this, t, i) || this;
+    var u = i, a = u && !u.isMounting ? t.enter : t.appear, l;
+    return n.appearStatus = null, t.in ? a ? (l = R, n.appearStatus = D) : l = w : t.unmountOnExit || t.mountOnEnter ? l = _ : l = R, n.state = {
+      status: l
+    }, n.nextCallback = null, n;
+  }
+  o.getDerivedStateFromProps = function(i, n) {
+    var u = i.in;
+    return u && n.status === _ ? {
+      status: R
+    } : null;
+  };
+  var r = o.prototype;
+  return r.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, r.componentDidUpdate = function(i) {
+    var n = null;
+    if (i !== this.props) {
+      var u = this.state.status;
+      this.props.in ? u !== D && u !== w && (n = D) : (u === D || u === w) && (n = W);
+    }
+    this.updateStatus(!1, n);
+  }, r.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, r.getTimeouts = function() {
+    var i = this.props.timeout, n, u, a;
+    return n = u = a = i, i != null && typeof i != "number" && (n = i.exit, u = i.enter, a = i.appear !== void 0 ? i.appear : u), {
+      exit: n,
+      enter: u,
+      appear: a
+    };
+  }, r.updateStatus = function(i, n) {
+    if (i === void 0 && (i = !1), n !== null)
+      if (this.cancelNextCallback(), n === D) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var u = this.props.nodeRef ? this.props.nodeRef.current : P.findDOMNode(this);
+          u && ze(u);
+        }
+        this.performEnter(i);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === R && this.setState({
+      status: _
+    });
+  }, r.performEnter = function(i) {
+    var n = this, u = this.props.enter, a = this.context ? this.context.isMounting : i, l = this.props.nodeRef ? [a] : [P.findDOMNode(this), a], f = l[0], p = l[1], m = this.getTimeouts(), g = a ? m.appear : m.enter;
+    if (!i && !u || te.disabled) {
+      this.safeSetState({
+        status: w
+      }, function() {
+        n.props.onEntered(f);
+      });
+      return;
+    }
+    this.props.onEnter(f, p), this.safeSetState({
+      status: D
+    }, function() {
+      n.props.onEntering(f, p), n.onTransitionEnd(g, function() {
+        n.safeSetState({
+          status: w
+        }, function() {
+          n.props.onEntered(f, p);
+        });
+      });
+    });
+  }, r.performExit = function() {
+    var i = this, n = this.props.exit, u = this.getTimeouts(), a = this.props.nodeRef ? void 0 : P.findDOMNode(this);
+    if (!n || te.disabled) {
+      this.safeSetState({
+        status: R
+      }, function() {
+        i.props.onExited(a);
+      });
+      return;
+    }
+    this.props.onExit(a), this.safeSetState({
+      status: W
+    }, function() {
+      i.props.onExiting(a), i.onTransitionEnd(u.exit, function() {
+        i.safeSetState({
+          status: R
+        }, function() {
+          i.props.onExited(a);
+        });
+      });
+    });
+  }, r.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, r.safeSetState = function(i, n) {
+    n = this.setNextCallback(n), this.setState(i, n);
+  }, r.setNextCallback = function(i) {
+    var n = this, u = !0;
+    return this.nextCallback = function(a) {
+      u && (u = !1, n.nextCallback = null, i(a));
+    }, this.nextCallback.cancel = function() {
+      u = !1;
+    }, this.nextCallback;
+  }, r.onTransitionEnd = function(i, n) {
+    this.setNextCallback(n);
+    var u = this.props.nodeRef ? this.props.nodeRef.current : P.findDOMNode(this), a = i == null && !this.props.addEndListener;
+    if (!u || a) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var l = this.props.nodeRef ? [this.nextCallback] : [u, this.nextCallback], f = l[0], p = l[1];
+      this.props.addEndListener(f, p);
+    }
+    i != null && setTimeout(this.nextCallback, i);
+  }, r.render = function() {
+    var i = this.state.status;
+    if (i === _)
+      return null;
+    var n = this.props, u = n.children;
+    n.in, n.mountOnEnter, n.unmountOnExit, n.appear, n.enter, n.exit, n.timeout, n.addEndListener, n.onEnter, n.onEntering, n.onEntered, n.onExit, n.onExiting, n.onExited, n.nodeRef;
+    var a = We(n, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ k.createElement(le.Provider, {
+        value: null
+      }, typeof u == "function" ? u(i, a) : k.cloneElement(k.Children.only(u), a))
+    );
+  }, o;
+}(k.Component);
+x.contextType = le;
+x.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: s.shape({
+    current: typeof Element > "u" ? s.any : function(e, o, r, t, i, n) {
+      var u = e[o];
+      return s.instanceOf(u && "ownerDocument" in u ? u.ownerDocument.defaultView.Element : Element)(e, o, r, t, i, n);
+    }
+  }),
+  /**
+   * 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: s.oneOfType([s.func.isRequired, s.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: s.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: s.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: s.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: s.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: s.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: s.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(o) {
+    var r = Xe;
+    o.addEndListener || (r = r.isRequired);
+    for (var t = arguments.length, i = new Array(t > 1 ? t - 1 : 0), n = 1; n < t; n++)
+      i[n - 1] = arguments[n];
+    return r.apply(void 0, [o].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: s.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: s.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: s.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: s.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: s.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: s.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: s.func
+} : {};
+function I() {
+}
+x.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: I,
+  onEntering: I,
+  onEntered: I,
+  onExit: I,
+  onExiting: I,
+  onExited: I
+};
+x.UNMOUNTED = _;
+x.EXITED = R;
+x.ENTERING = D;
+x.ENTERED = w;
+x.EXITING = W;
+const Ze = (e) => e.scrollTop;
+function ne(e, o) {
+  const {
+    timeout: r,
+    easing: t,
+    style: i = {}
+  } = e;
+  return {
+    duration: i.transitionDuration ?? (typeof r == "number" ? r : r[o.mode] || 0),
+    easing: i.transitionTimingFunction ?? (typeof t == "object" ? t[o.mode] : t),
+    delay: i.transitionDelay
+  };
+}
+function F(e) {
+  return `scale(${e}, ${e ** 2})`;
+}
+const Be = {
+  entering: {
+    opacity: 1,
+    transform: F(1)
+  },
+  entered: {
+    opacity: 1,
+    transform: "none"
+  }
+}, U = typeof navigator < "u" && /^((?!chrome|android).)*(safari|mobile)/i.test(navigator.userAgent) && /(os |version\/)15(.|_)4/i.test(navigator.userAgent), X = /* @__PURE__ */ c.forwardRef(function(o, r) {
+  const {
+    addEndListener: t,
+    appear: i = !0,
+    children: n,
+    easing: u,
+    in: a,
+    onEnter: l,
+    onEntered: f,
+    onEntering: p,
+    onExit: m,
+    onExited: g,
+    onExiting: N,
+    style: h,
+    timeout: E = "auto",
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: j = x,
+    ...A
+  } = o, H = Ge(), T = c.useRef(), b = Le(), M = c.useRef(null), fe = V(M, ue(n), r), C = (d) => (O) => {
+    if (d) {
+      const y = M.current;
+      O === void 0 ? d(y) : d(y, O);
+    }
+  }, de = C(p), pe = C((d, O) => {
+    Ze(d);
+    const {
+      duration: y,
+      delay: $,
+      easing: v
+    } = ne({
+      style: h,
+      timeout: E,
+      easing: u
+    }, {
+      mode: "enter"
+    });
+    let S;
+    E === "auto" ? (S = b.transitions.getAutoHeightDuration(d.clientHeight), T.current = S) : S = y, d.style.transition = [b.transitions.create("opacity", {
+      duration: S,
+      delay: $
+    }), b.transitions.create("transform", {
+      duration: U ? S : S * 0.666,
+      delay: $,
+      easing: v
+    })].join(","), l && l(d, O);
+  }), Ee = C(f), me = C(N), he = C((d) => {
+    const {
+      duration: O,
+      delay: y,
+      easing: $
+    } = ne({
+      style: h,
+      timeout: E,
+      easing: u
+    }, {
+      mode: "exit"
+    });
+    let v;
+    E === "auto" ? (v = b.transitions.getAutoHeightDuration(d.clientHeight), T.current = v) : v = O, d.style.transition = [b.transitions.create("opacity", {
+      duration: v,
+      delay: y
+    }), b.transitions.create("transform", {
+      duration: U ? v : v * 0.666,
+      delay: U ? y : y || v * 0.333,
+      easing: $
+    })].join(","), d.style.opacity = 0, d.style.transform = F(0.75), m && m(d);
+  }), ye = C(g);
+  return /* @__PURE__ */ Ne(j, {
+    appear: i,
+    in: a,
+    nodeRef: M,
+    onEnter: pe,
+    onEntered: Ee,
+    onEntering: de,
+    onExit: he,
+    onExited: ye,
+    onExiting: me,
+    addEndListener: (d) => {
+      E === "auto" && H.start(T.current || 0, d), t && t(M.current, d);
+    },
+    timeout: E === "auto" ? null : E,
+    ...A,
+    children: (d, {
+      ownerState: O,
+      ...y
+    }) => /* @__PURE__ */ c.cloneElement(n, {
+      style: {
+        opacity: 0,
+        transform: F(0.75),
+        visibility: d === "exited" && !a ? "hidden" : void 0,
+        ...Be[d],
+        ...h,
+        ...n.props.style
+      },
+      ref: fe,
+      ...y
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (X.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: s.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: s.bool,
+  /**
+   * A single child content element.
+   */
+  children: ce.isRequired,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: s.oneOfType([s.shape({
+    enter: s.string,
+    exit: s.string
+  }), s.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: s.bool,
+  /**
+   * @ignore
+   */
+  onEnter: s.func,
+  /**
+   * @ignore
+   */
+  onEntered: s.func,
+  /**
+   * @ignore
+   */
+  onEntering: s.func,
+  /**
+   * @ignore
+   */
+  onExit: s.func,
+  /**
+   * @ignore
+   */
+  onExited: s.func,
+  /**
+   * @ignore
+   */
+  onExiting: s.func,
+  /**
+   * @ignore
+   */
+  style: s.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: s.oneOfType([s.oneOf(["auto"]), s.number, s.shape({
+    appear: s.number,
+    enter: s.number,
+    exit: s.number
+  })])
+});
+X && (X.muiSupportAuto = !0);
+function Je(e) {
+  return typeof e == "function" ? e() : e;
+}
+const z = /* @__PURE__ */ c.forwardRef(function(o, r) {
+  const {
+    children: t,
+    container: i,
+    disablePortal: n = !1
+  } = o, [u, a] = c.useState(null), l = V(/* @__PURE__ */ c.isValidElement(t) ? ue(t) : null, r);
+  if (G(() => {
+    n || a(Je(i) || document.body);
+  }, [i, n]), G(() => {
+    if (u && !n)
+      return Y(r, u), () => {
+        Y(r, null);
+      };
+  }, [r, u, n]), n) {
+    if (/* @__PURE__ */ c.isValidElement(t)) {
+      const f = {
+        ref: l
+      };
+      return /* @__PURE__ */ c.cloneElement(t, f);
+    }
+    return t;
+  }
+  return u && /* @__PURE__ */ Re.createPortal(t, u);
+});
+process.env.NODE_ENV !== "production" && (z.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: s.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: s.oneOfType([je, s.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: s.bool
+});
+process.env.NODE_ENV !== "production" && (z.propTypes = ke(z.propTypes));
+export {
+  X as G,
+  je as H,
+  z as P,
+  le as T,
+  Fe as _,
+  We as a,
+  Ge as b,
+  V as c,
+  ut as d,
+  oe as e,
+  it as f,
+  lt as g,
+  G as h,
+  ft as i,
+  rt as j,
+  Le as k,
+  ct as l,
+  ue as m,
+  ce as n,
+  at as o,
+  Z as p,
+  Ie as q,
+  st as r,
+  ke as s,
+  x as t,
+  Ae as u,
+  Ze as v,
+  ne as w,
+  Ve as x
+};