@cgi-learning-hub/ui 1.2.0-dev.1726218202 → 1.2.0-dev.1726476985

package/dist/Backdrop-B8-BL3jx.js

@@ -0,0 +1,789 @@
+import * as j from "react";
+import I from "react";
+import { P as e, I as ee, J as te, L as ne } from "./identifier-nbk7LEJv.js";
+import { r as oe, m as ie, a as re, u as se } from "./useTheme-DmvRg71t.js";
+import { u as V } from "./useForkRef-C_4o__cU.js";
+import { jsx as _ } from "react/jsx-runtime";
+import { s as ae, u as pe, c as le } from "./DefaultPropsProvider-CU--SVzB.js";
+import { c as $ } from "./chainPropTypes-D9lkm76m.js";
+import { _ as ce, a as ue, T as W } from "./TransitionGroupContext-DMJLhY9-.js";
+import U from "react-dom";
+function de(r) {
+  const {
+    prototype: p = {}
+  } = r;
+  return !!p.isReactComponent;
+}
+function X(r, p, s, i, n) {
+  const t = r[p], o = n || p;
+  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 a;
+  const l = t.type;
+  return typeof l == "function" && !de(l) && (a = "Did you accidentally use a plain function component for an element instead?"), a !== void 0 ? new Error(`Invalid ${i} \`${o}\` supplied to \`${s}\`. Expected an element that can hold a ref. ${a} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const H = $(e.element, X);
+H.isRequired = $(e.element.isRequired, X);
+function fe(r) {
+  return !r || !/* @__PURE__ */ j.isValidElement(r) ? null : r.props.propertyIsEnumerable("ref") ? r.props.ref : (
+    // @ts-expect-error element.ref is not included in the ReactElement type
+    // We cannot check for it, but isValidElement is true at this point
+    // https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/70189
+    r.ref
+  );
+}
+const q = {
+  disabled: !1
+};
+var me = process.env.NODE_ENV !== "production" ? e.oneOfType([e.number, e.shape({
+  enter: e.number,
+  exit: e.number,
+  appear: e.number
+}).isRequired]) : null, Le = process.env.NODE_ENV !== "production" ? e.oneOfType([e.string, e.shape({
+  enter: e.string,
+  exit: e.string,
+  active: e.string
+}), e.shape({
+  enter: e.string,
+  enterDone: e.string,
+  enterActive: e.string,
+  exit: e.string,
+  exitDone: e.string,
+  exitActive: e.string
+})]) : null, Ee = function(p) {
+  return p.scrollTop;
+}, M = "unmounted", S = "exited", C = "entering", k = "entered", B = "exiting", x = /* @__PURE__ */ function(r) {
+  ce(p, r);
+  function p(i, n) {
+    var t;
+    t = r.call(this, i, n) || this;
+    var o = n, a = o && !o.isMounting ? i.enter : i.appear, l;
+    return t.appearStatus = null, i.in ? a ? (l = S, t.appearStatus = C) : l = k : i.unmountOnExit || i.mountOnEnter ? l = M : l = S, t.state = {
+      status: l
+    }, t.nextCallback = null, t;
+  }
+  p.getDerivedStateFromProps = function(n, t) {
+    var o = n.in;
+    return o && t.status === M ? {
+      status: S
+    } : null;
+  };
+  var s = p.prototype;
+  return s.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, s.componentDidUpdate = function(n) {
+    var t = null;
+    if (n !== this.props) {
+      var o = this.state.status;
+      this.props.in ? o !== C && o !== k && (t = C) : (o === C || o === k) && (t = B);
+    }
+    this.updateStatus(!1, t);
+  }, s.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, s.getTimeouts = function() {
+    var n = this.props.timeout, t, o, a;
+    return t = o = a = n, n != null && typeof n != "number" && (t = n.exit, o = n.enter, a = n.appear !== void 0 ? n.appear : o), {
+      exit: t,
+      enter: o,
+      appear: a
+    };
+  }, s.updateStatus = function(n, t) {
+    if (n === void 0 && (n = !1), t !== null)
+      if (this.cancelNextCallback(), t === C) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var o = this.props.nodeRef ? this.props.nodeRef.current : U.findDOMNode(this);
+          o && Ee(o);
+        }
+        this.performEnter(n);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === S && this.setState({
+      status: M
+    });
+  }, s.performEnter = function(n) {
+    var t = this, o = this.props.enter, a = this.context ? this.context.isMounting : n, l = this.props.nodeRef ? [a] : [U.findDOMNode(this), a], u = l[0], d = l[1], b = this.getTimeouts(), y = a ? b.appear : b.enter;
+    if (!n && !o || q.disabled) {
+      this.safeSetState({
+        status: k
+      }, function() {
+        t.props.onEntered(u);
+      });
+      return;
+    }
+    this.props.onEnter(u, d), this.safeSetState({
+      status: C
+    }, function() {
+      t.props.onEntering(u, d), t.onTransitionEnd(y, function() {
+        t.safeSetState({
+          status: k
+        }, function() {
+          t.props.onEntered(u, d);
+        });
+      });
+    });
+  }, s.performExit = function() {
+    var n = this, t = this.props.exit, o = this.getTimeouts(), a = this.props.nodeRef ? void 0 : U.findDOMNode(this);
+    if (!t || q.disabled) {
+      this.safeSetState({
+        status: S
+      }, function() {
+        n.props.onExited(a);
+      });
+      return;
+    }
+    this.props.onExit(a), this.safeSetState({
+      status: B
+    }, function() {
+      n.props.onExiting(a), n.onTransitionEnd(o.exit, function() {
+        n.safeSetState({
+          status: S
+        }, function() {
+          n.props.onExited(a);
+        });
+      });
+    });
+  }, s.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, s.safeSetState = function(n, t) {
+    t = this.setNextCallback(t), this.setState(n, t);
+  }, s.setNextCallback = function(n) {
+    var t = this, o = !0;
+    return this.nextCallback = function(a) {
+      o && (o = !1, t.nextCallback = null, n(a));
+    }, this.nextCallback.cancel = function() {
+      o = !1;
+    }, this.nextCallback;
+  }, s.onTransitionEnd = function(n, t) {
+    this.setNextCallback(t);
+    var o = this.props.nodeRef ? this.props.nodeRef.current : U.findDOMNode(this), a = n == null && !this.props.addEndListener;
+    if (!o || a) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var l = this.props.nodeRef ? [this.nextCallback] : [o, this.nextCallback], u = l[0], d = l[1];
+      this.props.addEndListener(u, d);
+    }
+    n != null && setTimeout(this.nextCallback, n);
+  }, s.render = function() {
+    var n = this.state.status;
+    if (n === M)
+      return null;
+    var t = this.props, o = 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 a = ue(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ I.createElement(W.Provider, {
+        value: null
+      }, typeof o == "function" ? o(n, a) : I.cloneElement(I.Children.only(o), a))
+    );
+  }, p;
+}(I.Component);
+x.contextType = W;
+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: e.shape({
+    current: typeof Element > "u" ? e.any : function(r, p, s, i, n, t) {
+      var o = r[p];
+      return e.instanceOf(o && "ownerDocument" in o ? o.ownerDocument.defaultView.Element : Element)(r, p, s, 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: e.oneOfType([e.func.isRequired, e.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: e.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: e.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: e.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: e.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: e.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: e.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(p) {
+    var s = me;
+    p.addEndListener || (s = s.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 s.apply(void 0, [p].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: e.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: e.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: e.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: e.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: e.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: e.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: e.func
+} : {};
+function P() {
+}
+x.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: P,
+  onEntering: P,
+  onEntered: P,
+  onExit: P,
+  onExiting: P,
+  onExited: P
+};
+x.UNMOUNTED = M;
+x.EXITED = S;
+x.ENTERING = C;
+x.ENTERED = k;
+x.EXITING = B;
+function A(r, p) {
+  const {
+    className: s,
+    elementType: i,
+    ownerState: n,
+    externalForwardedProps: t,
+    getSlotOwnerState: o,
+    internalForwardedProps: a,
+    ...l
+  } = p, {
+    component: u,
+    slots: d = {
+      [r]: void 0
+    },
+    slotProps: b = {
+      [r]: void 0
+    },
+    ...y
+  } = t, T = d[r] || i, v = oe(b[r], n), {
+    props: {
+      component: R,
+      ...m
+    },
+    internalRef: g
+  } = ie({
+    className: s,
+    ...l,
+    externalForwardedProps: r === "root" ? y : void 0,
+    externalSlotProps: v
+  }), D = V(g, v == null ? void 0 : v.ref, p.ref), N = o ? o(m) : {}, E = {
+    ...n,
+    ...N
+  }, O = r === "root" ? R || u : R, f = re(T, {
+    ...r === "root" && !u && !d[r] && a,
+    ...r !== "root" && !d[r] && a,
+    ...m,
+    ...O && {
+      as: O
+    },
+    ref: D
+  }, E);
+  return Object.keys(N).forEach((w) => {
+    delete f[w];
+  }), [T, f];
+}
+const he = (r) => r.scrollTop;
+function G(r, p) {
+  const {
+    timeout: s,
+    easing: i,
+    style: n = {}
+  } = r;
+  return {
+    duration: n.transitionDuration ?? (typeof s == "number" ? s : s[p.mode] || 0),
+    easing: n.transitionTimingFunction ?? (typeof i == "object" ? i[p.mode] : i),
+    delay: n.transitionDelay
+  };
+}
+const xe = {
+  entering: {
+    opacity: 1
+  },
+  entered: {
+    opacity: 1
+  }
+}, z = /* @__PURE__ */ j.forwardRef(function(p, s) {
+  const i = se(), n = {
+    enter: i.transitions.duration.enteringScreen,
+    exit: i.transitions.duration.leavingScreen
+  }, {
+    addEndListener: t,
+    appear: o = !0,
+    children: a,
+    easing: l,
+    in: u,
+    onEnter: d,
+    onEntered: b,
+    onEntering: y,
+    onExit: T,
+    onExited: v,
+    onExiting: R,
+    style: m,
+    timeout: g = n,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: D = x,
+    ...N
+  } = p, E = j.useRef(null), O = V(E, fe(a), s), f = (c) => (h) => {
+    if (c) {
+      const L = E.current;
+      h === void 0 ? c(L) : c(L, h);
+    }
+  }, w = f(y), F = f((c, h) => {
+    he(c);
+    const L = G({
+      style: m,
+      timeout: g,
+      easing: l
+    }, {
+      mode: "enter"
+    });
+    c.style.webkitTransition = i.transitions.create("opacity", L), c.style.transition = i.transitions.create("opacity", L), d && d(c, h);
+  }), K = f(b), Q = f(R), Y = f((c) => {
+    const h = G({
+      style: m,
+      timeout: g,
+      easing: l
+    }, {
+      mode: "exit"
+    });
+    c.style.webkitTransition = i.transitions.create("opacity", h), c.style.transition = i.transitions.create("opacity", h), T && T(c);
+  }), Z = f(v);
+  return /* @__PURE__ */ _(D, {
+    appear: o,
+    in: u,
+    nodeRef: E,
+    onEnter: F,
+    onEntered: K,
+    onEntering: w,
+    onExit: Y,
+    onExited: Z,
+    onExiting: Q,
+    addEndListener: (c) => {
+      t && t(E.current, c);
+    },
+    timeout: g,
+    ...N,
+    children: (c, h) => /* @__PURE__ */ j.cloneElement(a, {
+      style: {
+        opacity: 0,
+        visibility: c === "exited" && !u ? "hidden" : void 0,
+        ...xe[c],
+        ...m,
+        ...a.props.style
+      },
+      ref: O,
+      ...h
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (z.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: e.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: e.bool,
+  /**
+   * A single child content element.
+   */
+  children: H.isRequired,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: e.oneOfType([e.shape({
+    enter: e.string,
+    exit: e.string
+  }), e.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: e.bool,
+  /**
+   * @ignore
+   */
+  onEnter: e.func,
+  /**
+   * @ignore
+   */
+  onEntered: e.func,
+  /**
+   * @ignore
+   */
+  onEntering: e.func,
+  /**
+   * @ignore
+   */
+  onExit: e.func,
+  /**
+   * @ignore
+   */
+  onExited: e.func,
+  /**
+   * @ignore
+   */
+  onExiting: e.func,
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   * @default {
+   *   enter: theme.transitions.duration.enteringScreen,
+   *   exit: theme.transitions.duration.leavingScreen,
+   * }
+   */
+  timeout: e.oneOfType([e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+function be(r) {
+  return ee("MuiBackdrop", r);
+}
+const ve = te("MuiBackdrop", ["root", "invisible"]), Me = ve, ge = (r) => {
+  const {
+    classes: p,
+    invisible: s
+  } = r;
+  return le({
+    root: ["root", s && "invisible"]
+  }, be, p);
+}, ye = ae("div", {
+  name: "MuiBackdrop",
+  slot: "Root",
+  overridesResolver: (r, p) => {
+    const {
+      ownerState: s
+    } = r;
+    return [p.root, s.invisible && p.invisible];
+  }
+})({
+  position: "fixed",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  right: 0,
+  bottom: 0,
+  top: 0,
+  left: 0,
+  backgroundColor: "rgba(0, 0, 0, 0.5)",
+  WebkitTapHighlightColor: "transparent",
+  variants: [{
+    props: {
+      invisible: !0
+    },
+    style: {
+      backgroundColor: "transparent"
+    }
+  }]
+}), J = /* @__PURE__ */ j.forwardRef(function(p, s) {
+  const i = pe({
+    props: p,
+    name: "MuiBackdrop"
+  }), {
+    children: n,
+    className: t,
+    component: o = "div",
+    invisible: a = !1,
+    open: l,
+    components: u = {},
+    componentsProps: d = {},
+    slotProps: b = {},
+    slots: y = {},
+    TransitionComponent: T,
+    transitionDuration: v,
+    ...R
+  } = i, m = {
+    ...i,
+    component: o,
+    invisible: a
+  }, g = ge(m), D = {
+    transition: T,
+    root: u.Root,
+    ...y
+  }, N = {
+    ...d,
+    ...b
+  }, E = {
+    slots: D,
+    slotProps: N
+  }, [O, f] = A("root", {
+    elementType: ye,
+    externalForwardedProps: E,
+    className: ne(g.root, t),
+    ownerState: m
+  }), [w, F] = A("transition", {
+    elementType: z,
+    externalForwardedProps: E,
+    ownerState: m
+  });
+  return delete F.ownerState, /* @__PURE__ */ _(w, {
+    in: l,
+    timeout: v,
+    ...R,
+    ...F,
+    children: /* @__PURE__ */ _(O, {
+      "aria-hidden": !0,
+      ...f,
+      classes: g,
+      ref: s,
+      children: n
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (J.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated Use the `slots` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Root: e.elementType
+  }),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * @deprecated Use the `slotProps` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    root: e.object
+  }),
+  /**
+   * If `true`, the backdrop is invisible.
+   * It can be used when rendering a popover or a custom select component.
+   * @default false
+   */
+  invisible: e.bool,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool.isRequired,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    root: e.oneOfType([e.func, e.object]),
+    transition: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    root: e.elementType,
+    transition: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Fade
+   */
+  TransitionComponent: e.elementType,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   */
+  transitionDuration: e.oneOfType([e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+const je = J;
+export {
+  je as B,
+  z as F,
+  x as T,
+  fe as a,
+  Me as b,
+  G as c,
+  Le as d,
+  H as e,
+  Ee as f,
+  be as g,
+  he as r,
+  A as u
+};