kdpa-components 1.35.2 → 1.35.3

package/dist/Modal-5f23fcfd.js

@@ -0,0 +1,984 @@
+import { a as oe, _ as y } from "./extends-393586f3.js";
+import * as c from "react";
+import { P as e, g as fe } from "./identifier-9dfe30d8.js";
+import { g as be, a as me, s as te, u as he, c as ee } from "./useThemeProps-7d04a175.js";
+import { j as C } from "./jsx-runtime-944c88e2.js";
+import { F as Fe } from "./Fade-aabbd0cb.js";
+import { o as L } from "./ownerDocument-5430cd5b.js";
+import { o as ne } from "./ownerWindow-e6cc3097.js";
+import { P as Se, u as Me } from "./Portal-b4f8657f.js";
+import { u as ge } from "./useForkRef-0781dda0.js";
+import { u as ae } from "./useEventCallback-fe4fd69c.js";
+import { c as le } from "./createChainedFunction-68e2a88d.js";
+import { u as ce, r as de, i as Oe } from "./useSlotProps-f238319f.js";
+import { e as re } from "./elementAcceptingRef-803dfd80.js";
+import { e as Ie } from "./exactProp-3aaa3ecc.js";
+import { H as ye } from "./HTMLElementType-ff213f3c.js";
+function we(o) {
+  const t = o.documentElement.clientWidth;
+  return Math.abs(window.innerWidth - t);
+}
+const Ae = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])'].join(",");
+function Be(o) {
+  const t = parseInt(o.getAttribute("tabindex") || "", 10);
+  return Number.isNaN(t) ? o.contentEditable === "true" || (o.nodeName === "AUDIO" || o.nodeName === "VIDEO" || o.nodeName === "DETAILS") && o.getAttribute("tabindex") === null ? 0 : o.tabIndex : t;
+}
+function je(o) {
+  if (o.tagName !== "INPUT" || o.type !== "radio" || !o.name)
+    return !1;
+  const t = (n) => o.ownerDocument.querySelector(`input[type="radio"]${n}`);
+  let r = t(`[name="${o.name}"]:checked`);
+  return r || (r = t(`[name="${o.name}"]`)), r !== o;
+}
+function De(o) {
+  return !(o.disabled || o.tagName === "INPUT" && o.type === "hidden" || je(o));
+}
+function Le(o) {
+  const t = [], r = [];
+  return Array.from(o.querySelectorAll(Ae)).forEach((n, a) => {
+    const s = Be(n);
+    s === -1 || !De(n) || (s === 0 ? t.push(n) : r.push({
+      documentOrder: a,
+      tabIndex: s,
+      node: n
+    }));
+  }), r.sort((n, a) => n.tabIndex === a.tabIndex ? n.documentOrder - a.documentOrder : n.tabIndex - a.tabIndex).map((n) => n.node).concat(t);
+}
+function _e() {
+  return !0;
+}
+function G(o) {
+  const {
+    children: t,
+    disableAutoFocus: r = !1,
+    disableEnforceFocus: n = !1,
+    disableRestoreFocus: a = !1,
+    getTabbable: s = Le,
+    isEnabled: i = _e,
+    open: d
+  } = o, p = c.useRef(!1), T = c.useRef(null), v = c.useRef(null), m = c.useRef(null), b = c.useRef(null), k = c.useRef(!1), u = c.useRef(null), M = ge(t.ref, u), F = c.useRef(null);
+  c.useEffect(() => {
+    !d || !u.current || (k.current = !r);
+  }, [r, d]), c.useEffect(() => {
+    if (!d || !u.current)
+      return;
+    const l = L(u.current);
+    return u.current.contains(l.activeElement) || (u.current.hasAttribute("tabIndex") || (process.env.NODE_ENV !== "production" && console.error(["MUI: The modal content node does not accept focus.", 'For the benefit of assistive technologies, the tabIndex of the node is being set to "-1".'].join(`
+`)), u.current.setAttribute("tabIndex", "-1")), k.current && u.current.focus()), () => {
+      a || (m.current && m.current.focus && (p.current = !0, m.current.focus()), m.current = null);
+    };
+  }, [d]), c.useEffect(() => {
+    if (!d || !u.current)
+      return;
+    const l = L(u.current), f = (R) => {
+      const {
+        current: I
+      } = u;
+      if (I !== null) {
+        if (!l.hasFocus() || n || !i() || p.current) {
+          p.current = !1;
+          return;
+        }
+        if (!I.contains(l.activeElement)) {
+          if (R && b.current !== R.target || l.activeElement !== b.current)
+            b.current = null;
+          else if (b.current !== null)
+            return;
+          if (!k.current)
+            return;
+          let N = [];
+          if ((l.activeElement === T.current || l.activeElement === v.current) && (N = s(u.current)), N.length > 0) {
+            var $, P;
+            const H = !!(($ = F.current) != null && $.shiftKey && ((P = F.current) == null ? void 0 : P.key) === "Tab"), w = N[0], A = N[N.length - 1];
+            typeof w != "string" && typeof A != "string" && (H ? A.focus() : w.focus());
+          } else
+            I.focus();
+        }
+      }
+    }, g = (R) => {
+      F.current = R, !(n || !i() || R.key !== "Tab") && l.activeElement === u.current && R.shiftKey && (p.current = !0, v.current && v.current.focus());
+    };
+    l.addEventListener("focusin", f), l.addEventListener("keydown", g, !0);
+    const _ = setInterval(() => {
+      l.activeElement && l.activeElement.tagName === "BODY" && f(null);
+    }, 50);
+    return () => {
+      clearInterval(_), l.removeEventListener("focusin", f), l.removeEventListener("keydown", g, !0);
+    };
+  }, [r, n, a, i, d, s]);
+  const O = (l) => {
+    m.current === null && (m.current = l.relatedTarget), k.current = !0, b.current = l.target;
+    const f = t.props.onFocus;
+    f && f(l);
+  }, E = (l) => {
+    m.current === null && (m.current = l.relatedTarget), k.current = !0;
+  };
+  return /* @__PURE__ */ C.jsxs(c.Fragment, {
+    children: [/* @__PURE__ */ C.jsx("div", {
+      tabIndex: d ? 0 : -1,
+      onFocus: E,
+      ref: T,
+      "data-testid": "sentinelStart"
+    }), /* @__PURE__ */ c.cloneElement(t, {
+      ref: M,
+      onFocus: O
+    }), /* @__PURE__ */ C.jsx("div", {
+      tabIndex: d ? 0 : -1,
+      onFocus: E,
+      ref: v,
+      "data-testid": "sentinelEnd"
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (G.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * A single child content element.
+   */
+  children: re,
+  /**
+   * If `true`, the focus trap will not automatically shift focus to itself when it opens, and
+   * replace it to the last focused element when it closes.
+   * This also works correctly with any focus trap children that have the `disableAutoFocus` prop.
+   *
+   * Generally this should never be set to `true` as it makes the focus trap less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableAutoFocus: e.bool,
+  /**
+   * If `true`, the focus trap will not prevent focus from leaving the focus trap while open.
+   *
+   * Generally this should never be set to `true` as it makes the focus trap less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableEnforceFocus: e.bool,
+  /**
+   * If `true`, the focus trap will not restore focus to previously focused element once
+   * focus trap is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: e.bool,
+  /**
+   * Returns an array of ordered tabbable nodes (i.e. in tab order) within the root.
+   * For instance, you can provide the "tabbable" npm dependency.
+   * @param {HTMLElement} root
+   */
+  getTabbable: e.func,
+  /**
+   * This prop extends the `open` prop.
+   * It allows to toggle the open state without having to wait for a rerender when changing the `open` prop.
+   * This prop should be memoized.
+   * It can be used to support multiple focus trap mounted at the same time.
+   * @default function defaultIsEnabled(): boolean {
+   *   return true;
+   * }
+   */
+  isEnabled: e.func,
+  /**
+   * If `true`, focus is locked.
+   */
+  open: e.bool.isRequired
+});
+process.env.NODE_ENV !== "production" && (G["propTypes"] = Ie(G.propTypes));
+function $e(o) {
+  const t = L(o);
+  return t.body === o ? ne(o).innerWidth > t.documentElement.clientWidth : o.scrollHeight > o.clientHeight;
+}
+function z(o, t) {
+  t ? o.setAttribute("aria-hidden", "true") : o.removeAttribute("aria-hidden");
+}
+function ue(o) {
+  return parseInt(ne(o).getComputedStyle(o).paddingRight, 10) || 0;
+}
+function He(o) {
+  const r = ["TEMPLATE", "SCRIPT", "STYLE", "LINK", "MAP", "META", "NOSCRIPT", "PICTURE", "COL", "COLGROUP", "PARAM", "SLOT", "SOURCE", "TRACK"].indexOf(o.tagName) !== -1, n = o.tagName === "INPUT" && o.getAttribute("type") === "hidden";
+  return r || n;
+}
+function pe(o, t, r, n, a) {
+  const s = [t, r, ...n];
+  [].forEach.call(o.children, (i) => {
+    const d = s.indexOf(i) === -1, p = !He(i);
+    d && p && z(i, a);
+  });
+}
+function Z(o, t) {
+  let r = -1;
+  return o.some((n, a) => t(n) ? (r = a, !0) : !1), r;
+}
+function Ue(o, t) {
+  const r = [], n = o.container;
+  if (!t.disableScrollLock) {
+    if ($e(n)) {
+      const i = we(L(n));
+      r.push({
+        value: n.style.paddingRight,
+        property: "padding-right",
+        el: n
+      }), n.style.paddingRight = `${ue(n) + i}px`;
+      const d = L(n).querySelectorAll(".mui-fixed");
+      [].forEach.call(d, (p) => {
+        r.push({
+          value: p.style.paddingRight,
+          property: "padding-right",
+          el: p
+        }), p.style.paddingRight = `${ue(p) + i}px`;
+      });
+    }
+    let s;
+    if (n.parentNode instanceof DocumentFragment)
+      s = L(n).body;
+    else {
+      const i = n.parentElement, d = ne(n);
+      s = (i == null ? void 0 : i.nodeName) === "HTML" && d.getComputedStyle(i).overflowY === "scroll" ? i : n;
+    }
+    r.push({
+      value: s.style.overflow,
+      property: "overflow",
+      el: s
+    }, {
+      value: s.style.overflowX,
+      property: "overflow-x",
+      el: s
+    }, {
+      value: s.style.overflowY,
+      property: "overflow-y",
+      el: s
+    }), s.style.overflow = "hidden";
+  }
+  return () => {
+    r.forEach(({
+      value: s,
+      el: i,
+      property: d
+    }) => {
+      s ? i.style.setProperty(d, s) : i.style.removeProperty(d);
+    });
+  };
+}
+function Ke(o) {
+  const t = [];
+  return [].forEach.call(o.children, (r) => {
+    r.getAttribute("aria-hidden") === "true" && t.push(r);
+  }), t;
+}
+class qe {
+  constructor() {
+    this.containers = void 0, this.modals = void 0, this.modals = [], this.containers = [];
+  }
+  add(t, r) {
+    let n = this.modals.indexOf(t);
+    if (n !== -1)
+      return n;
+    n = this.modals.length, this.modals.push(t), t.modalRef && z(t.modalRef, !1);
+    const a = Ke(r);
+    pe(r, t.mount, t.modalRef, a, !0);
+    const s = Z(this.containers, (i) => i.container === r);
+    return s !== -1 ? (this.containers[s].modals.push(t), n) : (this.containers.push({
+      modals: [t],
+      container: r,
+      restore: null,
+      hiddenSiblings: a
+    }), n);
+  }
+  mount(t, r) {
+    const n = Z(this.containers, (s) => s.modals.indexOf(t) !== -1), a = this.containers[n];
+    a.restore || (a.restore = Ue(a, r));
+  }
+  remove(t, r = !0) {
+    const n = this.modals.indexOf(t);
+    if (n === -1)
+      return n;
+    const a = Z(this.containers, (i) => i.modals.indexOf(t) !== -1), s = this.containers[a];
+    if (s.modals.splice(s.modals.indexOf(t), 1), this.modals.splice(n, 1), s.modals.length === 0)
+      s.restore && s.restore(), t.modalRef && z(t.modalRef, r), pe(s.container, t.mount, t.modalRef, s.hiddenSiblings, !1), this.containers.splice(a, 1);
+    else {
+      const i = s.modals[s.modals.length - 1];
+      i.modalRef && z(i.modalRef, !1);
+    }
+    return n;
+  }
+  isTopModal(t) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === t;
+  }
+}
+function We(o) {
+  return fe("MuiModal", o);
+}
+be("MuiModal", ["root", "hidden", "backdrop"]);
+const Ve = ["children", "closeAfterTransition", "container", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted", "manager", "onBackdropClick", "onClose", "onKeyDown", "open", "onTransitionEnter", "onTransitionExited", "slotProps", "slots"], ze = (o) => {
+  const {
+    open: t,
+    exited: r
+  } = o;
+  return me({
+    root: ["root", !t && r && "hidden"],
+    backdrop: ["backdrop"]
+  }, Me(We));
+};
+function Ye(o) {
+  return typeof o == "function" ? o() : o;
+}
+function Ge(o) {
+  return o ? o.props.hasOwnProperty("in") : !1;
+}
+const Xe = new qe(), Te = /* @__PURE__ */ c.forwardRef(function(t, r) {
+  var n, a;
+  const {
+    children: s,
+    closeAfterTransition: i = !1,
+    container: d,
+    disableAutoFocus: p = !1,
+    disableEnforceFocus: T = !1,
+    disableEscapeKeyDown: v = !1,
+    disablePortal: m = !1,
+    disableRestoreFocus: b = !1,
+    disableScrollLock: k = !1,
+    hideBackdrop: u = !1,
+    keepMounted: M = !1,
+    // private
+    manager: F = Xe,
+    onBackdropClick: O,
+    onClose: E,
+    onKeyDown: l,
+    open: f,
+    onTransitionEnter: g,
+    onTransitionExited: _,
+    slotProps: R = {},
+    slots: I = {}
+  } = t, $ = oe(t, Ve), P = F, [N, H] = c.useState(!f), w = c.useRef({}), A = c.useRef(null), x = c.useRef(null), U = ge(x, r), K = Ge(s), W = (n = t["aria-hidden"]) != null ? n : !0, X = () => L(A.current), B = () => (w.current.modalRef = x.current, w.current.mountNode = A.current, w.current), V = () => {
+    P.mount(B(), {
+      disableScrollLock: k
+    }), x.current && (x.current.scrollTop = 0);
+  }, j = ae(() => {
+    const h = Ye(d) || X().body;
+    P.add(B(), h), x.current && V();
+  }), q = c.useCallback(() => P.isTopModal(B()), [P]), J = ae((h) => {
+    A.current = h, !(!h || !x.current) && (f && q() ? V() : z(x.current, W));
+  }), S = c.useCallback(() => {
+    P.remove(B(), W);
+  }, [P, W]);
+  c.useEffect(() => () => {
+    S();
+  }, [S]), c.useEffect(() => {
+    f ? j() : (!K || !i) && S();
+  }, [f, S, K, i, j]);
+  const D = y({}, t, {
+    closeAfterTransition: i,
+    disableAutoFocus: p,
+    disableEnforceFocus: T,
+    disableEscapeKeyDown: v,
+    disablePortal: m,
+    disableRestoreFocus: b,
+    disableScrollLock: k,
+    exited: N,
+    hideBackdrop: u,
+    keepMounted: M
+  }), se = ze(D), xe = () => {
+    H(!1), g && g();
+  }, ve = () => {
+    H(!0), _ && _(), i && S();
+  }, Re = (h) => {
+    h.target === h.currentTarget && (O && O(h), E && E(h, "backdropClick"));
+  }, Pe = (h) => {
+    l && l(h), !(h.key !== "Escape" || !q()) && (v || (h.stopPropagation(), E && E(h, "escapeKeyDown")));
+  }, Y = {};
+  s.props.tabIndex === void 0 && (Y.tabIndex = "-1"), K && (Y.onEnter = le(xe, s.props.onEnter), Y.onExited = le(ve, s.props.onExited));
+  const ie = (a = I.root) != null ? a : "div", Ne = ce({
+    elementType: ie,
+    externalSlotProps: R.root,
+    externalForwardedProps: $,
+    additionalProps: {
+      ref: U,
+      role: "presentation",
+      onKeyDown: Pe
+    },
+    className: se.root,
+    ownerState: D
+  }), Q = I.backdrop, Ce = ce({
+    elementType: Q,
+    externalSlotProps: R.backdrop,
+    additionalProps: {
+      "aria-hidden": !0,
+      onClick: Re,
+      open: f
+    },
+    className: se.backdrop,
+    ownerState: D
+  });
+  return !M && !f && (!K || N) ? null : /* @__PURE__ */ C.jsx(
+    Se,
+    {
+      ref: J,
+      container: d,
+      disablePortal: m,
+      children: /* @__PURE__ */ C.jsxs(ie, y({}, Ne, {
+        children: [!u && Q ? /* @__PURE__ */ C.jsx(Q, y({}, Ce)) : null, /* @__PURE__ */ C.jsx(G, {
+          disableEnforceFocus: T,
+          disableAutoFocus: p,
+          disableRestoreFocus: b,
+          isEnabled: q,
+          open: f,
+          children: /* @__PURE__ */ c.cloneElement(s, Y)
+        })]
+      }))
+    }
+  );
+});
+process.env.NODE_ENV !== "production" && (Te.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * A single child content element.
+   */
+  children: re.isRequired,
+  /**
+   * When set to true the Modal waits until a nested Transition is completed before closing.
+   * @default false
+   */
+  closeAfterTransition: e.bool,
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: e.oneOfType([ye, e.func]),
+  /**
+   * If `true`, the modal will not automatically shift focus to itself when it opens, and
+   * replace it to the last focused element when it closes.
+   * This also works correctly with any modal children that have the `disableAutoFocus` prop.
+   *
+   * Generally this should never be set to `true` as it makes the modal less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableAutoFocus: e.bool,
+  /**
+   * If `true`, the modal will not prevent focus from leaving the modal while open.
+   *
+   * Generally this should never be set to `true` as it makes the modal less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableEnforceFocus: e.bool,
+  /**
+   * If `true`, hitting escape will not fire the `onClose` callback.
+   * @default false
+   */
+  disableEscapeKeyDown: e.bool,
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: e.bool,
+  /**
+   * If `true`, the modal will not restore focus to previously focused element once
+   * modal is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: e.bool,
+  /**
+   * Disable the scroll lock behavior.
+   * @default false
+   */
+  disableScrollLock: e.bool,
+  /**
+   * If `true`, the backdrop is not rendered.
+   * @default false
+   */
+  hideBackdrop: e.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Modal.
+   * @default false
+   */
+  keepMounted: e.bool,
+  /**
+   * Callback fired when the backdrop is clicked.
+   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
+   */
+  onBackdropClick: e.func,
+  /**
+   * Callback fired when the component requests to be closed.
+   * The `reason` parameter can optionally be used to control the response to `onClose`.
+   *
+   * @param {object} event The event source of the callback.
+   * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`.
+   */
+  onClose: e.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool.isRequired,
+  /**
+   * The props used for each slot inside the Modal.
+   * @default {}
+   */
+  slotProps: e.shape({
+    backdrop: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside the Modal.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: e.shape({
+    backdrop: e.elementType,
+    root: e.elementType
+  })
+});
+const Je = Te;
+function Qe(o) {
+  return fe("MuiBackdrop", o);
+}
+be("MuiBackdrop", ["root", "invisible"]);
+const Ze = ["children", "className", "component", "components", "componentsProps", "invisible", "open", "slotProps", "slots", "TransitionComponent", "transitionDuration"], eo = (o) => {
+  const {
+    classes: t,
+    invisible: r
+  } = o;
+  return me({
+    root: ["root", r && "invisible"]
+  }, Qe, t);
+}, oo = te("div", {
+  name: "MuiBackdrop",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, r.invisible && t.invisible];
+  }
+})(({
+  ownerState: o
+}) => y({
+  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"
+}, o.invisible && {
+  backgroundColor: "transparent"
+})), ke = /* @__PURE__ */ c.forwardRef(function(t, r) {
+  var n, a, s;
+  const i = he({
+    props: t,
+    name: "MuiBackdrop"
+  }), {
+    children: d,
+    className: p,
+    component: T = "div",
+    components: v = {},
+    componentsProps: m = {},
+    invisible: b = !1,
+    open: k,
+    slotProps: u = {},
+    slots: M = {},
+    TransitionComponent: F = Fe,
+    transitionDuration: O
+  } = i, E = oe(i, Ze), l = y({}, i, {
+    component: T,
+    invisible: b
+  }), f = eo(l), g = (n = u.root) != null ? n : m.root;
+  return /* @__PURE__ */ C.jsx(F, y({
+    in: k,
+    timeout: O
+  }, E, {
+    children: /* @__PURE__ */ C.jsx(oo, y({
+      "aria-hidden": !0
+    }, g, {
+      as: (a = (s = M.root) != null ? s : v.Root) != null ? a : T,
+      className: ee(f.root, p, g == null ? void 0 : g.className),
+      ownerState: y({}, l, g == null ? void 0 : g.ownerState),
+      classes: f,
+      ref: r,
+      children: d
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (ke.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn 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.
+   *
+   * This prop is an alias for the `slots` prop.
+   * It's recommended to use the `slots` prop instead.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Root: e.elementType
+  }),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `slotProps` prop.
+   * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
+   *
+   * @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 extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slotProps: e.shape({
+    root: e.object
+  }),
+  /**
+   * The components used for each slot inside.
+   *
+   * This prop is an alias for the `components` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slots: e.shape({
+    root: 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](/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 to = ke, no = ["BackdropComponent", "BackdropProps", "classes", "className", "closeAfterTransition", "children", "container", "component", "components", "componentsProps", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted", "onBackdropClick", "onClose", "open", "slotProps", "slots", "theme"], ro = te("div", {
+  name: "MuiModal",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, !r.open && r.exited && t.hidden];
+  }
+})(({
+  theme: o,
+  ownerState: t
+}) => y({
+  position: "fixed",
+  zIndex: (o.vars || o).zIndex.modal,
+  right: 0,
+  bottom: 0,
+  top: 0,
+  left: 0
+}, !t.open && t.exited && {
+  visibility: "hidden"
+})), so = te(to, {
+  name: "MuiModal",
+  slot: "Backdrop",
+  overridesResolver: (o, t) => t.backdrop
+})({
+  zIndex: -1
+}), Ee = /* @__PURE__ */ c.forwardRef(function(t, r) {
+  var n, a, s, i, d, p;
+  const T = he({
+    name: "MuiModal",
+    props: t
+  }), {
+    BackdropComponent: v = so,
+    BackdropProps: m,
+    classes: b,
+    className: k,
+    closeAfterTransition: u = !1,
+    children: M,
+    container: F,
+    component: O,
+    components: E = {},
+    componentsProps: l = {},
+    disableAutoFocus: f = !1,
+    disableEnforceFocus: g = !1,
+    disableEscapeKeyDown: _ = !1,
+    disablePortal: R = !1,
+    disableRestoreFocus: I = !1,
+    disableScrollLock: $ = !1,
+    hideBackdrop: P = !1,
+    keepMounted: N = !1,
+    onBackdropClick: H,
+    onClose: w,
+    open: A,
+    slotProps: x,
+    slots: U,
+    // eslint-disable-next-line react/prop-types
+    theme: K
+  } = T, W = oe(T, no), [X, B] = c.useState(!0), V = {
+    container: F,
+    closeAfterTransition: u,
+    disableAutoFocus: f,
+    disableEnforceFocus: g,
+    disableEscapeKeyDown: _,
+    disablePortal: R,
+    disableRestoreFocus: I,
+    disableScrollLock: $,
+    hideBackdrop: P,
+    keepMounted: N,
+    onBackdropClick: H,
+    onClose: w,
+    open: A
+  }, j = y({}, T, V, {
+    exited: X
+  }), q = (n = (a = U == null ? void 0 : U.root) != null ? a : E.Root) != null ? n : ro, J = (s = (i = U == null ? void 0 : U.backdrop) != null ? i : E.Backdrop) != null ? s : v, S = (d = x == null ? void 0 : x.root) != null ? d : l.root, D = (p = x == null ? void 0 : x.backdrop) != null ? p : l.backdrop;
+  return /* @__PURE__ */ C.jsx(Je, y({
+    slots: {
+      root: q,
+      backdrop: J
+    },
+    slotProps: {
+      root: () => y({}, de(S, j), !Oe(q) && {
+        as: O,
+        theme: K
+      }, {
+        className: ee(k, S == null ? void 0 : S.className, b == null ? void 0 : b.root, !j.open && j.exited && (b == null ? void 0 : b.hidden))
+      }),
+      backdrop: () => y({}, m, de(D, j), {
+        className: ee(D == null ? void 0 : D.className, b == null ? void 0 : b.backdrop)
+      })
+    },
+    onTransitionEnter: () => B(!1),
+    onTransitionExited: () => B(!0),
+    ref: r
+  }, W, V, {
+    children: M
+  }));
+});
+process.env.NODE_ENV !== "production" && (Ee.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn proptypes"     |
+  // ----------------------------------------------------------------------
+  /**
+   * A backdrop component. This prop enables custom backdrop rendering.
+   * @deprecated Use `slots.backdrop` instead. While this prop currently works, it will be removed in the next major version.
+   * Use the `slots.backdrop` prop to make your application ready for the next version of Material UI.
+   * @default styled(Backdrop, {
+   *   name: 'MuiModal',
+   *   slot: 'Backdrop',
+   *   overridesResolver: (props, styles) => {
+   *     return styles.backdrop;
+   *   },
+   * })({
+   *   zIndex: -1,
+   * })
+   */
+  BackdropComponent: e.elementType,
+  /**
+   * Props applied to the [`Backdrop`](/material-ui/api/backdrop/) element.
+   * @deprecated Use `slotProps.backdrop` instead.
+   */
+  BackdropProps: e.object,
+  /**
+   * A single child content element.
+   */
+  children: re.isRequired,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * When set to true the Modal waits until a nested Transition is completed before closing.
+   * @default false
+   */
+  closeAfterTransition: e.bool,
+  /**
+   * 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.
+   *
+   * This prop is an alias for the `slots` prop.
+   * It's recommended to use the `slots` prop instead.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Backdrop: e.elementType,
+    Root: e.elementType
+  }),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `slotProps` prop.
+   * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    backdrop: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: e.oneOfType([ye, e.func]),
+  /**
+   * If `true`, the modal will not automatically shift focus to itself when it opens, and
+   * replace it to the last focused element when it closes.
+   * This also works correctly with any modal children that have the `disableAutoFocus` prop.
+   *
+   * Generally this should never be set to `true` as it makes the modal less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableAutoFocus: e.bool,
+  /**
+   * If `true`, the modal will not prevent focus from leaving the modal while open.
+   *
+   * Generally this should never be set to `true` as it makes the modal less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableEnforceFocus: e.bool,
+  /**
+   * If `true`, hitting escape will not fire the `onClose` callback.
+   * @default false
+   */
+  disableEscapeKeyDown: e.bool,
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: e.bool,
+  /**
+   * If `true`, the modal will not restore focus to previously focused element once
+   * modal is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: e.bool,
+  /**
+   * Disable the scroll lock behavior.
+   * @default false
+   */
+  disableScrollLock: e.bool,
+  /**
+   * If `true`, the backdrop is not rendered.
+   * @default false
+   */
+  hideBackdrop: e.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Modal.
+   * @default false
+   */
+  keepMounted: e.bool,
+  /**
+   * Callback fired when the backdrop is clicked.
+   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
+   */
+  onBackdropClick: e.func,
+  /**
+   * Callback fired when the component requests to be closed.
+   * The `reason` parameter can optionally be used to control the response to `onClose`.
+   *
+   * @param {object} event The event source of the callback.
+   * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`.
+   */
+  onClose: e.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool.isRequired,
+  /**
+   * The props used for each slot inside the Modal.
+   * @default {}
+   */
+  slotProps: e.shape({
+    backdrop: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside the Modal.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: e.shape({
+    backdrop: e.elementType,
+    root: 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])
+});
+const xo = Ee;
+export {
+  to as B,
+  G as F,
+  xo as M,
+  we as g
+};