@hybridcore/ui 1.3.3 → 1.3.5

package/dist/Modal-DNGEQJ1M.js

@@ -0,0 +1,1267 @@
+import { _ as b, a as z } from "./extends-Cyw62AD_.js";
+import * as a from "react";
+import { P as e } from "./createStyled-B96gjom1.js";
+import { c as q, g as ge, a as Te, u as ve } from "./useThemeProps-DeftUmqJ.js";
+import { g as xe, s as se } from "./styled-cPJbqF0E.js";
+import { jsxs as ke, jsx as M } from "react/jsx-runtime";
+import { u as Be } from "./useTheme-C-T6Qisa.js";
+import { T as Le, r as _e, g as de } from "./utils-CCkxV0lZ.js";
+import { e as Q, a as Re } from "./exactProp-CI_rjX83.js";
+import { a as Y, u as ue, s as fe, b as pe } from "./ButtonBase-D6qhsxB0.js";
+import { o as H } from "./ownerDocument-CUrv0DIK.js";
+import { o as ie } from "./ownerWindow-niciwP7I.js";
+import { c as me } from "./useId-BHG98T5I.js";
+import { i as Pe } from "./isHostComponent-kiaBvYVo.js";
+import * as je from "react-dom";
+function He(o, n, r) {
+  return o === void 0 || Pe(o) ? n : b({}, n, {
+    ownerState: b({}, n.ownerState, r)
+  });
+}
+const $e = {
+  disableDefaultClasses: !1
+}, Ue = /* @__PURE__ */ a.createContext($e);
+function Ke(o) {
+  const {
+    disableDefaultClasses: n
+  } = a.useContext(Ue);
+  return (r) => n ? "" : o(r);
+}
+function Ve(o, n = []) {
+  if (o === void 0)
+    return {};
+  const r = {};
+  return Object.keys(o).filter((t) => t.match(/^on[A-Z]/) && typeof o[t] == "function" && !n.includes(t)).forEach((t) => {
+    r[t] = o[t];
+  }), r;
+}
+function re(o, n) {
+  return typeof o == "function" ? o(n) : o;
+}
+function le(o, n, r, t, i) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const s = o[n], l = i || n;
+  return s == null ? null : s && s.nodeType !== 1 ? new Error(`Invalid ${t} \`${l}\` supplied to \`${r}\`. Expected an HTMLElement.`) : null;
+}
+function We(o) {
+  const n = o.documentElement.clientWidth;
+  return Math.abs(window.innerWidth - n);
+}
+function be(o) {
+  if (o === void 0)
+    return {};
+  const n = {};
+  return Object.keys(o).filter((r) => !(r.match(/^on[A-Z]/) && typeof o[r] == "function")).forEach((r) => {
+    n[r] = o[r];
+  }), n;
+}
+function qe(o) {
+  const {
+    getSlotProps: n,
+    additionalProps: r,
+    externalSlotProps: t,
+    externalForwardedProps: i,
+    className: s
+  } = o;
+  if (!n) {
+    const x = q(i == null ? void 0 : i.className, t == null ? void 0 : t.className, s, r == null ? void 0 : r.className), m = b({}, r == null ? void 0 : r.style, i == null ? void 0 : i.style, t == null ? void 0 : t.style), P = b({}, r, i, t);
+    return x.length > 0 && (P.className = x), Object.keys(m).length > 0 && (P.style = m), {
+      props: P,
+      internalRef: void 0
+    };
+  }
+  const l = Ve(b({}, i, t)), c = be(t), u = be(i), f = n(l), v = q(f == null ? void 0 : f.className, r == null ? void 0 : r.className, s, i == null ? void 0 : i.className, t == null ? void 0 : t.className), E = b({}, f == null ? void 0 : f.style, r == null ? void 0 : r.style, i == null ? void 0 : i.style, t == null ? void 0 : t.style), h = b({}, f, r, u, c);
+  return v.length > 0 && (h.className = v), Object.keys(E).length > 0 && (h.style = E), {
+    props: h,
+    internalRef: f.ref
+  };
+}
+const ze = ["elementType", "externalSlotProps", "ownerState"];
+function he(o) {
+  var n;
+  const {
+    elementType: r,
+    externalSlotProps: t,
+    ownerState: i
+  } = o, s = z(o, ze), l = re(t, i), {
+    props: c,
+    internalRef: u
+  } = qe(b({}, s, {
+    externalSlotProps: l
+  })), f = Y(u, l == null ? void 0 : l.ref, (n = o.additionalProps) == null ? void 0 : n.ref);
+  return He(r, b({}, c, {
+    ref: f
+  }), i);
+}
+const Ye = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])'].join(",");
+function Ge(o) {
+  const n = parseInt(o.getAttribute("tabindex") || "", 10);
+  return Number.isNaN(n) ? o.contentEditable === "true" || (o.nodeName === "AUDIO" || o.nodeName === "VIDEO" || o.nodeName === "DETAILS") && o.getAttribute("tabindex") === null ? 0 : o.tabIndex : n;
+}
+function Ze(o) {
+  if (o.tagName !== "INPUT" || o.type !== "radio" || !o.name)
+    return !1;
+  const n = (t) => o.ownerDocument.querySelector(`input[type="radio"]${t}`);
+  let r = n(`[name="${o.name}"]:checked`);
+  return r || (r = n(`[name="${o.name}"]`)), r !== o;
+}
+function Xe(o) {
+  return !(o.disabled || o.tagName === "INPUT" && o.type === "hidden" || Ze(o));
+}
+function Je(o) {
+  const n = [], r = [];
+  return Array.from(o.querySelectorAll(Ye)).forEach((t, i) => {
+    const s = Ge(t);
+    s === -1 || !Xe(t) || (s === 0 ? n.push(t) : r.push({
+      documentOrder: i,
+      tabIndex: s,
+      node: t
+    }));
+  }), r.sort((t, i) => t.tabIndex === i.tabIndex ? t.documentOrder - i.documentOrder : t.tabIndex - i.tabIndex).map((t) => t.node).concat(n);
+}
+function Qe() {
+  return !0;
+}
+function X(o) {
+  const {
+    children: n,
+    disableAutoFocus: r = !1,
+    disableEnforceFocus: t = !1,
+    disableRestoreFocus: i = !1,
+    getTabbable: s = Je,
+    isEnabled: l = Qe,
+    open: c
+  } = o, u = a.useRef(!1), f = a.useRef(null), v = a.useRef(null), E = a.useRef(null), h = a.useRef(null), x = a.useRef(!1), m = a.useRef(null), P = Y(n.ref, m), N = a.useRef(null);
+  a.useEffect(() => {
+    !c || !m.current || (x.current = !r);
+  }, [r, c]), a.useEffect(() => {
+    if (!c || !m.current)
+      return;
+    const d = H(m.current);
+    return m.current.contains(d.activeElement) || (m.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(`
+`)), m.current.setAttribute("tabIndex", "-1")), x.current && m.current.focus()), () => {
+      i || (E.current && E.current.focus && (u.current = !0, E.current.focus()), E.current = null);
+    };
+  }, [c]), a.useEffect(() => {
+    if (!c || !m.current)
+      return;
+    const d = H(m.current), g = (O) => {
+      const {
+        current: I
+      } = m;
+      if (I !== null) {
+        if (!d.hasFocus() || t || !l() || u.current) {
+          u.current = !1;
+          return;
+        }
+        if (!I.contains(d.activeElement)) {
+          if (O && h.current !== O.target || d.activeElement !== h.current)
+            h.current = null;
+          else if (h.current !== null)
+            return;
+          if (!x.current)
+            return;
+          let R = [];
+          if ((d.activeElement === f.current || d.activeElement === v.current) && (R = s(m.current)), R.length > 0) {
+            var D, L;
+            const F = !!((D = N.current) != null && D.shiftKey && ((L = N.current) == null ? void 0 : L.key) === "Tab"), B = R[0], p = R[R.length - 1];
+            typeof B != "string" && typeof p != "string" && (F ? p.focus() : B.focus());
+          } else
+            I.focus();
+        }
+      }
+    }, y = (O) => {
+      N.current = O, !(t || !l() || O.key !== "Tab") && d.activeElement === m.current && O.shiftKey && (u.current = !0, v.current && v.current.focus());
+    };
+    d.addEventListener("focusin", g), d.addEventListener("keydown", y, !0);
+    const C = setInterval(() => {
+      d.activeElement && d.activeElement.tagName === "BODY" && g(null);
+    }, 50);
+    return () => {
+      clearInterval(C), d.removeEventListener("focusin", g), d.removeEventListener("keydown", y, !0);
+    };
+  }, [r, t, i, l, c, s]);
+  const k = (d) => {
+    E.current === null && (E.current = d.relatedTarget), x.current = !0, h.current = d.target;
+    const g = n.props.onFocus;
+    g && g(d);
+  }, w = (d) => {
+    E.current === null && (E.current = d.relatedTarget), x.current = !0;
+  };
+  return /* @__PURE__ */ ke(a.Fragment, {
+    children: [/* @__PURE__ */ M("div", {
+      tabIndex: c ? 0 : -1,
+      onFocus: w,
+      ref: f,
+      "data-testid": "sentinelStart"
+    }), /* @__PURE__ */ a.cloneElement(n, {
+      ref: P,
+      onFocus: k
+    }), /* @__PURE__ */ M("div", {
+      tabIndex: c ? 0 : -1,
+      onFocus: w,
+      ref: v,
+      "data-testid": "sentinelEnd"
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (X.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: Q,
+  /**
+   * 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" && (X.propTypes = Re(X.propTypes));
+function eo(o) {
+  return typeof o == "function" ? o() : o;
+}
+const J = /* @__PURE__ */ a.forwardRef(function(n, r) {
+  const {
+    children: t,
+    container: i,
+    disablePortal: s = !1
+  } = n, [l, c] = a.useState(null), u = Y(/* @__PURE__ */ a.isValidElement(t) ? t.ref : null, r);
+  if (ue(() => {
+    s || c(eo(i) || document.body);
+  }, [i, s]), ue(() => {
+    if (l && !s)
+      return fe(r, l), () => {
+        fe(r, null);
+      };
+  }, [r, l, s]), s) {
+    if (/* @__PURE__ */ a.isValidElement(t)) {
+      const f = {
+        ref: u
+      };
+      return /* @__PURE__ */ a.cloneElement(t, f);
+    }
+    return /* @__PURE__ */ M(a.Fragment, {
+      children: t
+    });
+  }
+  return /* @__PURE__ */ M(a.Fragment, {
+    children: l && /* @__PURE__ */ je.createPortal(t, l)
+  });
+});
+process.env.NODE_ENV !== "production" && (J.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * The children to render into the `container`.
+   */
+  children: e.node,
+  /**
+   * 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([le, e.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: e.bool
+});
+process.env.NODE_ENV !== "production" && (J.propTypes = Re(J.propTypes));
+function oo(o) {
+  const n = H(o);
+  return n.body === o ? ie(o).innerWidth > n.documentElement.clientWidth : o.scrollHeight > o.clientHeight;
+}
+function W(o, n) {
+  n ? o.setAttribute("aria-hidden", "true") : o.removeAttribute("aria-hidden");
+}
+function Ee(o) {
+  return parseInt(ie(o).getComputedStyle(o).paddingRight, 10) || 0;
+}
+function no(o) {
+  const r = ["TEMPLATE", "SCRIPT", "STYLE", "LINK", "MAP", "META", "NOSCRIPT", "PICTURE", "COL", "COLGROUP", "PARAM", "SLOT", "SOURCE", "TRACK"].indexOf(o.tagName) !== -1, t = o.tagName === "INPUT" && o.getAttribute("type") === "hidden";
+  return r || t;
+}
+function ye(o, n, r, t, i) {
+  const s = [n, r, ...t];
+  [].forEach.call(o.children, (l) => {
+    const c = s.indexOf(l) === -1, u = !no(l);
+    c && u && W(l, i);
+  });
+}
+function te(o, n) {
+  let r = -1;
+  return o.some((t, i) => n(t) ? (r = i, !0) : !1), r;
+}
+function to(o, n) {
+  const r = [], t = o.container;
+  if (!n.disableScrollLock) {
+    if (oo(t)) {
+      const l = We(H(t));
+      r.push({
+        value: t.style.paddingRight,
+        property: "padding-right",
+        el: t
+      }), t.style.paddingRight = `${Ee(t) + l}px`;
+      const c = H(t).querySelectorAll(".mui-fixed");
+      [].forEach.call(c, (u) => {
+        r.push({
+          value: u.style.paddingRight,
+          property: "padding-right",
+          el: u
+        }), u.style.paddingRight = `${Ee(u) + l}px`;
+      });
+    }
+    let s;
+    if (t.parentNode instanceof DocumentFragment)
+      s = H(t).body;
+    else {
+      const l = t.parentElement, c = ie(t);
+      s = (l == null ? void 0 : l.nodeName) === "HTML" && c.getComputedStyle(l).overflowY === "scroll" ? l : t;
+    }
+    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: l,
+      property: c
+    }) => {
+      s ? l.style.setProperty(c, s) : l.style.removeProperty(c);
+    });
+  };
+}
+function ro(o) {
+  const n = [];
+  return [].forEach.call(o.children, (r) => {
+    r.getAttribute("aria-hidden") === "true" && n.push(r);
+  }), n;
+}
+class so {
+  constructor() {
+    this.containers = void 0, this.modals = void 0, this.modals = [], this.containers = [];
+  }
+  add(n, r) {
+    let t = this.modals.indexOf(n);
+    if (t !== -1)
+      return t;
+    t = this.modals.length, this.modals.push(n), n.modalRef && W(n.modalRef, !1);
+    const i = ro(r);
+    ye(r, n.mount, n.modalRef, i, !0);
+    const s = te(this.containers, (l) => l.container === r);
+    return s !== -1 ? (this.containers[s].modals.push(n), t) : (this.containers.push({
+      modals: [n],
+      container: r,
+      restore: null,
+      hiddenSiblings: i
+    }), t);
+  }
+  mount(n, r) {
+    const t = te(this.containers, (s) => s.modals.indexOf(n) !== -1), i = this.containers[t];
+    i.restore || (i.restore = to(i, r));
+  }
+  remove(n, r = !0) {
+    const t = this.modals.indexOf(n);
+    if (t === -1)
+      return t;
+    const i = te(this.containers, (l) => l.modals.indexOf(n) !== -1), s = this.containers[i];
+    if (s.modals.splice(s.modals.indexOf(n), 1), this.modals.splice(t, 1), s.modals.length === 0)
+      s.restore && s.restore(), n.modalRef && W(n.modalRef, r), ye(s.container, n.mount, n.modalRef, s.hiddenSiblings, !1), this.containers.splice(i, 1);
+    else {
+      const l = s.modals[s.modals.length - 1];
+      l.modalRef && W(l.modalRef, !1);
+    }
+    return t;
+  }
+  isTopModal(n) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === n;
+  }
+}
+function io(o) {
+  return xe("MuiModal", o);
+}
+ge("MuiModal", ["root", "hidden", "backdrop"]);
+const lo = ["children", "closeAfterTransition", "component", "container", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted", "manager", "onBackdropClick", "onClose", "onKeyDown", "open", "onTransitionEnter", "onTransitionExited", "slotProps", "slots"], ao = (o) => {
+  const {
+    open: n,
+    exited: r
+  } = o;
+  return Te({
+    root: ["root", !n && r && "hidden"],
+    backdrop: ["backdrop"]
+  }, Ke(io));
+};
+function co(o) {
+  return typeof o == "function" ? o() : o;
+}
+function uo(o) {
+  return o ? o.props.hasOwnProperty("in") : !1;
+}
+const fo = new so(), Ne = /* @__PURE__ */ a.forwardRef(function(n, r) {
+  var t, i;
+  const {
+    children: s,
+    closeAfterTransition: l = !1,
+    component: c,
+    container: u,
+    disableAutoFocus: f = !1,
+    disableEnforceFocus: v = !1,
+    disableEscapeKeyDown: E = !1,
+    disablePortal: h = !1,
+    disableRestoreFocus: x = !1,
+    disableScrollLock: m = !1,
+    hideBackdrop: P = !1,
+    keepMounted: N = !1,
+    // private
+    manager: k = fo,
+    onBackdropClick: w,
+    onClose: d,
+    onKeyDown: g,
+    open: y,
+    onTransitionEnter: C,
+    onTransitionExited: O,
+    slotProps: I = {},
+    slots: D = {}
+  } = n, L = z(n, lo), [R, F] = a.useState(!y), B = a.useRef({}), p = a.useRef(null), T = a.useRef(null), A = Y(T, r), j = uo(s), _ = (t = n["aria-hidden"]) != null ? t : !0, G = () => H(p.current), $ = () => (B.current.modalRef = T.current, B.current.mountNode = p.current, B.current), U = () => {
+    k.mount($(), {
+      disableScrollLock: m
+    }), T.current && (T.current.scrollTop = 0);
+  }, K = pe(() => {
+    const S = co(u) || G().body;
+    k.add($(), S), T.current && U();
+  }), ee = a.useCallback(() => k.isTopModal($()), [k]), Oe = pe((S) => {
+    p.current = S, !(!S || !T.current) && (y && ee() ? U() : W(T.current, _));
+  }), V = a.useCallback(() => {
+    k.remove($(), _);
+  }, [k, _]);
+  a.useEffect(() => () => {
+    V();
+  }, [V]), a.useEffect(() => {
+    y ? K() : (!j || !l) && V();
+  }, [y, V, j, l, K]);
+  const oe = b({}, n, {
+    closeAfterTransition: l,
+    disableAutoFocus: f,
+    disableEnforceFocus: v,
+    disableEscapeKeyDown: E,
+    disablePortal: h,
+    disableRestoreFocus: x,
+    disableScrollLock: m,
+    exited: R,
+    hideBackdrop: P,
+    keepMounted: N
+  }), ae = ao(oe), we = () => {
+    F(!1), C && C();
+  }, Fe = () => {
+    F(!0), O && O(), l && V();
+  }, Me = (S) => {
+    S.target === S.currentTarget && (w && w(S), d && d(S, "backdropClick"));
+  }, Ie = (S) => {
+    g && g(S), !(S.key !== "Escape" || !ee()) && (E || (S.stopPropagation(), d && d(S, "escapeKeyDown")));
+  }, Z = {};
+  s.props.tabIndex === void 0 && (Z.tabIndex = "-1"), j && (Z.onEnter = me(we, s.props.onEnter), Z.onExited = me(Fe, s.props.onExited));
+  const ce = (i = c ?? D.root) != null ? i : "div", Ae = he({
+    elementType: ce,
+    externalSlotProps: I.root,
+    externalForwardedProps: L,
+    additionalProps: {
+      ref: A,
+      role: "presentation",
+      onKeyDown: Ie
+    },
+    className: ae.root,
+    ownerState: oe
+  }), ne = D.backdrop, De = he({
+    elementType: ne,
+    externalSlotProps: I.backdrop,
+    additionalProps: {
+      "aria-hidden": !0,
+      onClick: Me,
+      open: y
+    },
+    className: ae.backdrop,
+    ownerState: oe
+  });
+  return !N && !y && (!j || R) ? null : /* @__PURE__ */ M(
+    J,
+    {
+      ref: Oe,
+      container: u,
+      disablePortal: h,
+      children: /* @__PURE__ */ ke(ce, b({}, Ae, {
+        children: [!P && ne ? /* @__PURE__ */ M(ne, b({}, De)) : null, /* @__PURE__ */ M(X, {
+          disableEnforceFocus: v,
+          disableAutoFocus: f,
+          disableRestoreFocus: x,
+          isEnabled: ee,
+          open: y,
+          children: /* @__PURE__ */ a.cloneElement(s, Z)
+        })]
+      }))
+    }
+  );
+});
+process.env.NODE_ENV !== "production" && (Ne.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: Q.isRequired,
+  /**
+   * 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,
+  /**
+   * 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([le, 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,
+  /**
+   * @ignore
+   */
+  onKeyDown: 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 po = ["addEndListener", "appear", "children", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"], mo = {
+  entering: {
+    opacity: 1
+  },
+  entered: {
+    opacity: 1
+  }
+}, Se = /* @__PURE__ */ a.forwardRef(function(n, r) {
+  const t = Be(), i = {
+    enter: t.transitions.duration.enteringScreen,
+    exit: t.transitions.duration.leavingScreen
+  }, {
+    addEndListener: s,
+    appear: l = !0,
+    children: c,
+    easing: u,
+    in: f,
+    onEnter: v,
+    onEntered: E,
+    onEntering: h,
+    onExit: x,
+    onExited: m,
+    onExiting: P,
+    style: N,
+    timeout: k = i,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: w = Le
+  } = n, d = z(n, po), g = a.useRef(null), y = Y(g, c.ref, r), C = (p) => (T) => {
+    if (p) {
+      const A = g.current;
+      T === void 0 ? p(A) : p(A, T);
+    }
+  }, O = C(h), I = C((p, T) => {
+    _e(p);
+    const A = de({
+      style: N,
+      timeout: k,
+      easing: u
+    }, {
+      mode: "enter"
+    });
+    p.style.webkitTransition = t.transitions.create("opacity", A), p.style.transition = t.transitions.create("opacity", A), v && v(p, T);
+  }), D = C(E), L = C(P), R = C((p) => {
+    const T = de({
+      style: N,
+      timeout: k,
+      easing: u
+    }, {
+      mode: "exit"
+    });
+    p.style.webkitTransition = t.transitions.create("opacity", T), p.style.transition = t.transitions.create("opacity", T), x && x(p);
+  }), F = C(m);
+  return /* @__PURE__ */ M(w, b({
+    appear: l,
+    in: f,
+    nodeRef: g,
+    onEnter: I,
+    onEntered: D,
+    onEntering: O,
+    onExit: R,
+    onExited: F,
+    onExiting: L,
+    addEndListener: (p) => {
+      s && s(g.current, p);
+    },
+    timeout: k
+  }, d, {
+    children: (p, T) => /* @__PURE__ */ a.cloneElement(c, b({
+      style: b({
+        opacity: 0,
+        visibility: p === "exited" && !f ? "hidden" : void 0
+      }, mo[p], N, c.props.style),
+      ref: y
+    }, T))
+  }));
+});
+process.env.NODE_ENV !== "production" && (Se.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn 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: Q.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 bo(o) {
+  return xe("MuiBackdrop", o);
+}
+ge("MuiBackdrop", ["root", "invisible"]);
+const ho = ["children", "className", "component", "components", "componentsProps", "invisible", "open", "slotProps", "slots", "TransitionComponent", "transitionDuration"], Eo = (o) => {
+  const {
+    classes: n,
+    invisible: r
+  } = o;
+  return Te({
+    root: ["root", r && "invisible"]
+  }, bo, n);
+}, yo = se("div", {
+  name: "MuiBackdrop",
+  slot: "Root",
+  overridesResolver: (o, n) => {
+    const {
+      ownerState: r
+    } = o;
+    return [n.root, r.invisible && n.invisible];
+  }
+})(({
+  ownerState: o
+}) => b({
+  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"
+})), Ce = /* @__PURE__ */ a.forwardRef(function(n, r) {
+  var t, i, s;
+  const l = ve({
+    props: n,
+    name: "MuiBackdrop"
+  }), {
+    children: c,
+    className: u,
+    component: f = "div",
+    components: v = {},
+    componentsProps: E = {},
+    invisible: h = !1,
+    open: x,
+    slotProps: m = {},
+    slots: P = {},
+    TransitionComponent: N = Se,
+    transitionDuration: k
+  } = l, w = z(l, ho), d = b({}, l, {
+    component: f,
+    invisible: h
+  }), g = Eo(d), y = (t = m.root) != null ? t : E.root;
+  return /* @__PURE__ */ M(N, b({
+    in: x,
+    timeout: k
+  }, w, {
+    children: /* @__PURE__ */ M(yo, b({
+      "aria-hidden": !0
+    }, y, {
+      as: (i = (s = P.root) != null ? s : v.Root) != null ? i : f,
+      className: q(g.root, u, y == null ? void 0 : y.className),
+      ownerState: b({}, d, y == null ? void 0 : y.ownerState),
+      classes: g,
+      ref: r,
+      children: c
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (Ce.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 go = ["BackdropComponent", "BackdropProps", "classes", "className", "closeAfterTransition", "children", "component", "components", "componentsProps", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted", "slotProps", "slots", "theme"], To = se("div", {
+  name: "MuiModal",
+  slot: "Root",
+  overridesResolver: (o, n) => {
+    const {
+      ownerState: r
+    } = o;
+    return [n.root, !r.open && r.exited && n.hidden];
+  }
+})(({
+  theme: o,
+  ownerState: n
+}) => b({
+  position: "fixed",
+  zIndex: (o.vars || o).zIndex.modal,
+  right: 0,
+  bottom: 0,
+  top: 0,
+  left: 0
+}, !n.open && n.exited && {
+  visibility: "hidden"
+})), vo = se(Ce, {
+  name: "MuiModal",
+  slot: "Backdrop",
+  overridesResolver: (o, n) => n.backdrop
+})({
+  zIndex: -1
+}), xo = /* @__PURE__ */ a.forwardRef(function(n, r) {
+  var t, i, s, l, c, u;
+  const f = ve({
+    name: "MuiModal",
+    props: n
+  }), {
+    BackdropComponent: v = vo,
+    BackdropProps: E,
+    classes: h,
+    className: x,
+    closeAfterTransition: m = !1,
+    children: P,
+    component: N,
+    components: k = {},
+    componentsProps: w = {},
+    disableAutoFocus: d = !1,
+    disableEnforceFocus: g = !1,
+    disableEscapeKeyDown: y = !1,
+    disablePortal: C = !1,
+    disableRestoreFocus: O = !1,
+    disableScrollLock: I = !1,
+    hideBackdrop: D = !1,
+    keepMounted: L = !1,
+    slotProps: R,
+    slots: F,
+    // eslint-disable-next-line react/prop-types
+    theme: B
+  } = f, p = z(f, go), [T, A] = a.useState(!0), j = {
+    closeAfterTransition: m,
+    disableAutoFocus: d,
+    disableEnforceFocus: g,
+    disableEscapeKeyDown: y,
+    disablePortal: C,
+    disableRestoreFocus: O,
+    disableScrollLock: I,
+    hideBackdrop: D,
+    keepMounted: L
+  }, _ = b({}, f, j, {
+    exited: T
+  }), G = (t = (i = F == null ? void 0 : F.root) != null ? i : k.Root) != null ? t : To, $ = (s = (l = F == null ? void 0 : F.backdrop) != null ? l : k.Backdrop) != null ? s : v, U = (c = R == null ? void 0 : R.root) != null ? c : w.root, K = (u = R == null ? void 0 : R.backdrop) != null ? u : w.backdrop;
+  return /* @__PURE__ */ M(Ne, b({
+    slots: {
+      root: G,
+      backdrop: $
+    },
+    slotProps: {
+      root: () => b({}, re(U, _), !Pe(G) && {
+        as: N,
+        theme: B
+      }, {
+        className: q(x, U == null ? void 0 : U.className, h == null ? void 0 : h.root, !_.open && _.exited && (h == null ? void 0 : h.hidden))
+      }),
+      backdrop: () => b({}, E, re(K, _), {
+        className: q(K == null ? void 0 : K.className, h == null ? void 0 : h.backdrop)
+      })
+    },
+    onTransitionEnter: () => A(!1),
+    onTransitionExited: () => A(!0),
+    ref: r
+  }, p, j, {
+    children: P
+  }));
+});
+process.env.NODE_ENV !== "production" && (xo.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: Q.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([le, 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])
+});
+export {
+  Ce as B,
+  Se as F,
+  le as H,
+  xo as M,
+  We as g
+};