@amateescu/portal-ui-components 0.0.47 → 0.0.49

package/dist/Modal-BnD35xWv.js

@@ -0,0 +1,1325 @@
+import * as c from "react";
+import { P as e, b as ee, g as te, u as ne, s as Y, q as ce, c as q, t as de, f as oe, m as ye } from "./DefaultPropsProvider-BQx1AiAq.js";
+import { u as ge } from "./useTheme-9dlwNzrD.js";
+import { jsx as M, jsxs as Te } from "react/jsx-runtime";
+import { a as Ie } from "./createSimplePaletteValueFilter-Bz8RuRaa.js";
+import { i as Fe } from "./integerPropType-BihGt2aU.js";
+import { o as A, g as re, e as se, a as xe } from "./getReactElementRef-CIbXfZbo.js";
+import { a as G, u as ue, d as pe } from "./ButtonBase-ugYh038t.js";
+import { u as K, e as Ae } from "./useSlot-B1oIMjd_.js";
+import * as De from "react-dom";
+import { T as Be, g as fe, r as je } from "./utils-6k-H8qFR.js";
+function be(...t) {
+  return t.reduce((n, r) => r == null ? n : function(...i) {
+    n.apply(this, i), r.apply(this, i);
+  }, () => {
+  });
+}
+function xt(t, n = 166) {
+  let r;
+  function o(...i) {
+    const s = () => {
+      t.apply(this, i);
+    };
+    clearTimeout(r), r = setTimeout(s, n);
+  }
+  return o.clear = () => {
+    clearTimeout(r);
+  }, o;
+}
+function _(t) {
+  return A(t).defaultView || window;
+}
+function me(t, n) {
+  typeof t == "function" ? t(n) : t && (t.current = n);
+}
+const Le = {
+  entering: {
+    opacity: 1
+  },
+  entered: {
+    opacity: 1
+  }
+}, Re = /* @__PURE__ */ c.forwardRef(function(n, r) {
+  const o = ge(), i = {
+    enter: o.transitions.duration.enteringScreen,
+    exit: o.transitions.duration.leavingScreen
+  }, {
+    addEndListener: s,
+    appear: a = !0,
+    children: l,
+    easing: u,
+    in: h,
+    onEnter: T,
+    onEntered: v,
+    onEntering: x,
+    onExit: y,
+    onExited: b,
+    onExiting: S,
+    style: R,
+    timeout: k = i,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: N = Be,
+    ...f
+  } = n, m = c.useRef(null), C = G(m, re(l), r), w = (E) => (p) => {
+    if (E) {
+      const d = m.current;
+      p === void 0 ? E(d) : E(d, p);
+    }
+  }, g = w(x), O = w((E, p) => {
+    je(E);
+    const d = fe({
+      style: R,
+      timeout: k,
+      easing: u
+    }, {
+      mode: "enter"
+    });
+    E.style.webkitTransition = o.transitions.create("opacity", d), E.style.transition = o.transitions.create("opacity", d), T && T(E, p);
+  }), P = w(v), F = w(S), I = w((E) => {
+    const p = fe({
+      style: R,
+      timeout: k,
+      easing: u
+    }, {
+      mode: "exit"
+    });
+    E.style.webkitTransition = o.transitions.create("opacity", p), E.style.transition = o.transitions.create("opacity", p), y && y(E);
+  }), D = w(b);
+  return /* @__PURE__ */ M(N, {
+    appear: a,
+    in: h,
+    nodeRef: m,
+    onEnter: O,
+    onEntered: P,
+    onEntering: g,
+    onExit: I,
+    onExited: D,
+    onExiting: F,
+    addEndListener: (E) => {
+      s && s(m.current, E);
+    },
+    timeout: k,
+    ...f,
+    children: (E, {
+      ownerState: p,
+      ...d
+    }) => /* @__PURE__ */ c.cloneElement(l, {
+      style: {
+        opacity: 0,
+        visibility: E === "exited" && !h ? "hidden" : void 0,
+        ...Le[E],
+        ...R,
+        ...l.props.style
+      },
+      ref: C,
+      ...d
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Re.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: se.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 $e(t) {
+  return ee("MuiPaper", t);
+}
+te("MuiPaper", ["root", "rounded", "outlined", "elevation", "elevation0", "elevation1", "elevation2", "elevation3", "elevation4", "elevation5", "elevation6", "elevation7", "elevation8", "elevation9", "elevation10", "elevation11", "elevation12", "elevation13", "elevation14", "elevation15", "elevation16", "elevation17", "elevation18", "elevation19", "elevation20", "elevation21", "elevation22", "elevation23", "elevation24"]);
+const He = (t) => {
+  const {
+    square: n,
+    elevation: r,
+    variant: o,
+    classes: i
+  } = t, s = {
+    root: ["root", o, !n && "rounded", o === "elevation" && `elevation${r}`]
+  };
+  return oe(s, $e, i);
+}, Ue = Y("div", {
+  name: "MuiPaper",
+  slot: "Root",
+  overridesResolver: (t, n) => {
+    const {
+      ownerState: r
+    } = t;
+    return [n.root, n[r.variant], !r.square && n.rounded, r.variant === "elevation" && n[`elevation${r.elevation}`]];
+  }
+})(ye(({
+  theme: t
+}) => ({
+  backgroundColor: (t.vars || t).palette.background.paper,
+  color: (t.vars || t).palette.text.primary,
+  transition: t.transitions.create("box-shadow"),
+  variants: [{
+    props: ({
+      ownerState: n
+    }) => !n.square,
+    style: {
+      borderRadius: t.shape.borderRadius
+    }
+  }, {
+    props: {
+      variant: "outlined"
+    },
+    style: {
+      border: `1px solid ${(t.vars || t).palette.divider}`
+    }
+  }, {
+    props: {
+      variant: "elevation"
+    },
+    style: {
+      boxShadow: "var(--Paper-shadow)",
+      backgroundImage: "var(--Paper-overlay)"
+    }
+  }]
+}))), Ve = /* @__PURE__ */ c.forwardRef(function(n, r) {
+  const o = ne({
+    props: n,
+    name: "MuiPaper"
+  }), i = ge(), {
+    className: s,
+    component: a = "div",
+    elevation: l = 1,
+    square: u = !1,
+    variant: h = "elevation",
+    ...T
+  } = o, v = {
+    ...o,
+    component: a,
+    elevation: l,
+    square: u,
+    variant: h
+  }, x = He(v);
+  return process.env.NODE_ENV !== "production" && i.shadows[l] === void 0 && console.error([`MUI: The elevation provided <Paper elevation={${l}}> is not available in the theme.`, `Please make sure that \`theme.shadows[${l}]\` is defined.`].join(`
+`)), /* @__PURE__ */ M(Ue, {
+    as: a,
+    ownerState: v,
+    className: q(x.root, s),
+    ref: r,
+    ...T,
+    style: {
+      ...h === "elevation" && {
+        "--Paper-shadow": (i.vars || i).shadows[l],
+        ...i.vars && {
+          "--Paper-overlay": i.vars.overlays?.[l]
+        },
+        ...!i.vars && i.palette.mode === "dark" && {
+          "--Paper-overlay": `linear-gradient(${ce("#fff", de(l))}, ${ce("#fff", de(l))})`
+        }
+      },
+      ...T.style
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (Ve.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,
+  /**
+   * Shadow depth, corresponds to `dp` in the spec.
+   * It accepts values between 0 and 24 inclusive.
+   * @default 1
+   */
+  elevation: Ie(Fe, (t) => {
+    const {
+      elevation: n,
+      variant: r
+    } = t;
+    return n > 0 && r === "outlined" ? new Error(`MUI: Combining \`elevation={${n}}\` with \`variant="${r}"\` has no effect. Either use \`elevation={0}\` or use a different \`variant\`.`) : null;
+  }),
+  /**
+   * If `true`, rounded corners are disabled.
+   * @default false
+   */
+  square: e.bool,
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * 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 variant to use.
+   * @default 'elevation'
+   */
+  variant: e.oneOfType([e.oneOf(["elevation", "outlined"]), e.string])
+});
+function Pe(t, n, r, o, i) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const s = t[n], a = i || n;
+  return s == null ? null : s && s.nodeType !== 1 ? new Error(`Invalid ${o} \`${a}\` supplied to \`${r}\`. Expected an HTMLElement.`) : null;
+}
+function qe(t) {
+  return typeof t == "function" ? t() : t;
+}
+const W = /* @__PURE__ */ c.forwardRef(function(n, r) {
+  const {
+    children: o,
+    container: i,
+    disablePortal: s = !1
+  } = n, [a, l] = c.useState(null), u = G(/* @__PURE__ */ c.isValidElement(o) ? re(o) : null, r);
+  if (ue(() => {
+    s || l(qe(i) || document.body);
+  }, [i, s]), ue(() => {
+    if (a && !s)
+      return me(r, a), () => {
+        me(r, null);
+      };
+  }, [r, a, s]), s) {
+    if (/* @__PURE__ */ c.isValidElement(o)) {
+      const h = {
+        ref: u
+      };
+      return /* @__PURE__ */ c.cloneElement(o, h);
+    }
+    return o;
+  }
+  return a && /* @__PURE__ */ De.createPortal(o, a);
+});
+process.env.NODE_ENV !== "production" && (W.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The children to render into the `container`.
+   */
+  children: e.node,
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: e.oneOfType([Pe, e.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: e.bool
+});
+process.env.NODE_ENV !== "production" && (W.propTypes = xe(W.propTypes));
+function U(t) {
+  let n = t.activeElement;
+  for (; n?.shadowRoot?.activeElement != null; )
+    n = n.shadowRoot.activeElement;
+  return n;
+}
+const Ke = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])'].join(",");
+function _e(t) {
+  const n = parseInt(t.getAttribute("tabindex") || "", 10);
+  return Number.isNaN(n) ? t.contentEditable === "true" || (t.nodeName === "AUDIO" || t.nodeName === "VIDEO" || t.nodeName === "DETAILS") && t.getAttribute("tabindex") === null ? 0 : t.tabIndex : n;
+}
+function We(t) {
+  if (t.tagName !== "INPUT" || t.type !== "radio" || !t.name)
+    return !1;
+  const n = (o) => t.ownerDocument.querySelector(`input[type="radio"]${o}`);
+  let r = n(`[name="${t.name}"]:checked`);
+  return r || (r = n(`[name="${t.name}"]`)), r !== t;
+}
+function ze(t) {
+  return !(t.disabled || t.tagName === "INPUT" && t.type === "hidden" || We(t));
+}
+function Ye(t) {
+  const n = [], r = [];
+  return Array.from(t.querySelectorAll(Ke)).forEach((o, i) => {
+    const s = _e(o);
+    s === -1 || !ze(o) || (s === 0 ? n.push(o) : r.push({
+      documentOrder: i,
+      tabIndex: s,
+      node: o
+    }));
+  }), r.sort((o, i) => o.tabIndex === i.tabIndex ? o.documentOrder - i.documentOrder : o.tabIndex - i.tabIndex).map((o) => o.node).concat(n);
+}
+function Ge() {
+  return !0;
+}
+function z(t) {
+  const {
+    children: n,
+    disableAutoFocus: r = !1,
+    disableEnforceFocus: o = !1,
+    disableRestoreFocus: i = !1,
+    getTabbable: s = Ye,
+    isEnabled: a = Ge,
+    open: l
+  } = t, u = c.useRef(!1), h = c.useRef(null), T = c.useRef(null), v = c.useRef(null), x = c.useRef(null), y = c.useRef(!1), b = c.useRef(null), S = G(re(n), b), R = c.useRef(null);
+  c.useEffect(() => {
+    !l || !b.current || (y.current = !r);
+  }, [r, l]), c.useEffect(() => {
+    if (!l || !b.current)
+      return;
+    const f = A(b.current), m = U(f);
+    return b.current.contains(m) || (b.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(`
+`)), b.current.setAttribute("tabIndex", "-1")), y.current && b.current.focus()), () => {
+      i || (v.current && v.current.focus && (u.current = !0, v.current.focus()), v.current = null);
+    };
+  }, [l]), c.useEffect(() => {
+    if (!l || !b.current)
+      return;
+    const f = A(b.current), m = (g) => {
+      if (R.current = g, o || !a() || g.key !== "Tab")
+        return;
+      U(f) === b.current && g.shiftKey && (u.current = !0, T.current && T.current.focus());
+    }, C = () => {
+      const g = b.current;
+      if (g === null)
+        return;
+      const O = U(f);
+      if (!f.hasFocus() || !a() || u.current) {
+        u.current = !1;
+        return;
+      }
+      if (g.contains(O) || o && O !== h.current && O !== T.current)
+        return;
+      if (O !== x.current)
+        x.current = null;
+      else if (x.current !== null)
+        return;
+      if (!y.current)
+        return;
+      let P = [];
+      if ((O === h.current || O === T.current) && (P = s(b.current)), P.length > 0) {
+        const F = !!(R.current?.shiftKey && R.current?.key === "Tab"), I = P[0], D = P[P.length - 1];
+        typeof I != "string" && typeof D != "string" && (F ? D.focus() : I.focus());
+      } else
+        g.focus();
+    };
+    f.addEventListener("focusin", C), f.addEventListener("keydown", m, !0);
+    const w = setInterval(() => {
+      const g = U(f);
+      g && g.tagName === "BODY" && C();
+    }, 50);
+    return () => {
+      clearInterval(w), f.removeEventListener("focusin", C), f.removeEventListener("keydown", m, !0);
+    };
+  }, [r, o, i, a, l, s]);
+  const k = (f) => {
+    v.current === null && (v.current = f.relatedTarget), y.current = !0, x.current = f.target;
+    const m = n.props.onFocus;
+    m && m(f);
+  }, N = (f) => {
+    v.current === null && (v.current = f.relatedTarget), y.current = !0;
+  };
+  return /* @__PURE__ */ Te(c.Fragment, {
+    children: [/* @__PURE__ */ M("div", {
+      tabIndex: l ? 0 : -1,
+      onFocus: N,
+      ref: h,
+      "data-testid": "sentinelStart"
+    }), /* @__PURE__ */ c.cloneElement(n, {
+      ref: S,
+      onFocus: k
+    }), /* @__PURE__ */ M("div", {
+      tabIndex: l ? 0 : -1,
+      onFocus: N,
+      ref: T,
+      "data-testid": "sentinelEnd"
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (z.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A single child content element.
+   */
+  children: se,
+  /**
+   * 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" && (z.propTypes = xe(z.propTypes));
+function Xe(t = window) {
+  const n = t.document.documentElement.clientWidth;
+  return t.innerWidth - n;
+}
+function Je(t) {
+  const n = A(t);
+  return n.body === t ? _(t).innerWidth > n.documentElement.clientWidth : t.scrollHeight > t.clientHeight;
+}
+function L(t, n) {
+  n ? t.setAttribute("aria-hidden", "true") : t.removeAttribute("aria-hidden");
+}
+function he(t) {
+  return parseFloat(_(t).getComputedStyle(t).paddingRight) || 0;
+}
+function Qe(t) {
+  const r = ["TEMPLATE", "SCRIPT", "STYLE", "LINK", "MAP", "META", "NOSCRIPT", "PICTURE", "COL", "COLGROUP", "PARAM", "SLOT", "SOURCE", "TRACK"].includes(t.tagName), o = t.tagName === "INPUT" && t.getAttribute("type") === "hidden";
+  return r || o;
+}
+function ve(t, n, r, o, i) {
+  const s = [n, r, ...o];
+  [].forEach.call(t.children, (a) => {
+    const l = !s.includes(a), u = !Qe(a);
+    l && u && L(a, i);
+  });
+}
+function Z(t, n) {
+  let r = -1;
+  return t.some((o, i) => n(o) ? (r = i, !0) : !1), r;
+}
+function Ze(t, n) {
+  const r = [], o = t.container;
+  if (!n.disableScrollLock) {
+    if (Je(o)) {
+      const a = Xe(_(o));
+      r.push({
+        value: o.style.paddingRight,
+        property: "padding-right",
+        el: o
+      }), o.style.paddingRight = `${he(o) + a}px`;
+      const l = A(o).querySelectorAll(".mui-fixed");
+      [].forEach.call(l, (u) => {
+        r.push({
+          value: u.style.paddingRight,
+          property: "padding-right",
+          el: u
+        }), u.style.paddingRight = `${he(u) + a}px`;
+      });
+    }
+    let s;
+    if (o.parentNode instanceof DocumentFragment)
+      s = A(o).body;
+    else {
+      const a = o.parentElement, l = _(o);
+      s = a?.nodeName === "HTML" && l.getComputedStyle(a).overflowY === "scroll" ? a : o;
+    }
+    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: a,
+      property: l
+    }) => {
+      s ? a.style.setProperty(l, s) : a.style.removeProperty(l);
+    });
+  };
+}
+function et(t) {
+  const n = [];
+  return [].forEach.call(t.children, (r) => {
+    r.getAttribute("aria-hidden") === "true" && n.push(r);
+  }), n;
+}
+class tt {
+  constructor() {
+    this.modals = [], this.containers = [];
+  }
+  add(n, r) {
+    let o = this.modals.indexOf(n);
+    if (o !== -1)
+      return o;
+    o = this.modals.length, this.modals.push(n), n.modalRef && L(n.modalRef, !1);
+    const i = et(r);
+    ve(r, n.mount, n.modalRef, i, !0);
+    const s = Z(this.containers, (a) => a.container === r);
+    return s !== -1 ? (this.containers[s].modals.push(n), o) : (this.containers.push({
+      modals: [n],
+      container: r,
+      restore: null,
+      hiddenSiblings: i
+    }), o);
+  }
+  mount(n, r) {
+    const o = Z(this.containers, (s) => s.modals.includes(n)), i = this.containers[o];
+    i.restore || (i.restore = Ze(i, r));
+  }
+  remove(n, r = !0) {
+    const o = this.modals.indexOf(n);
+    if (o === -1)
+      return o;
+    const i = Z(this.containers, (a) => a.modals.includes(n)), s = this.containers[i];
+    if (s.modals.splice(s.modals.indexOf(n), 1), this.modals.splice(o, 1), s.modals.length === 0)
+      s.restore && s.restore(), n.modalRef && L(n.modalRef, r), ve(s.container, n.mount, n.modalRef, s.hiddenSiblings, !1), this.containers.splice(i, 1);
+    else {
+      const a = s.modals[s.modals.length - 1];
+      a.modalRef && L(a.modalRef, !1);
+    }
+    return o;
+  }
+  isTopModal(n) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === n;
+  }
+}
+function nt(t) {
+  return ee("MuiBackdrop", t);
+}
+te("MuiBackdrop", ["root", "invisible"]);
+const ot = (t) => {
+  const {
+    classes: n,
+    invisible: r
+  } = t;
+  return oe({
+    root: ["root", r && "invisible"]
+  }, nt, n);
+}, rt = Y("div", {
+  name: "MuiBackdrop",
+  slot: "Root",
+  overridesResolver: (t, n) => {
+    const {
+      ownerState: r
+    } = t;
+    return [n.root, r.invisible && n.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"
+    }
+  }]
+}), ke = /* @__PURE__ */ c.forwardRef(function(n, r) {
+  const o = ne({
+    props: n,
+    name: "MuiBackdrop"
+  }), {
+    children: i,
+    className: s,
+    component: a = "div",
+    invisible: l = !1,
+    open: u,
+    components: h = {},
+    componentsProps: T = {},
+    slotProps: v = {},
+    slots: x = {},
+    TransitionComponent: y,
+    transitionDuration: b,
+    ...S
+  } = o, R = {
+    ...o,
+    component: a,
+    invisible: l
+  }, k = ot(R), N = {
+    transition: y,
+    root: h.Root,
+    ...x
+  }, f = {
+    ...T,
+    ...v
+  }, m = {
+    component: a,
+    slots: N,
+    slotProps: f
+  }, [C, w] = K("root", {
+    elementType: rt,
+    externalForwardedProps: m,
+    className: q(k.root, s),
+    ownerState: R
+  }), [g, O] = K("transition", {
+    elementType: Re,
+    externalForwardedProps: m,
+    ownerState: R
+  });
+  return /* @__PURE__ */ M(g, {
+    in: u,
+    timeout: b,
+    ...S,
+    ...O,
+    children: /* @__PURE__ */ M(C, {
+      "aria-hidden": !0,
+      ...w,
+      ref: r,
+      children: i
+    })
+  });
+});
+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 `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 a future major release. 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 a future major release. 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
+   * @deprecated Use `slots.transition` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  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
+  })])
+});
+function st(t) {
+  return typeof t == "function" ? t() : t;
+}
+function it(t) {
+  return t ? t.props.hasOwnProperty("in") : !1;
+}
+const Ee = () => {
+}, V = new tt();
+function at(t) {
+  const {
+    container: n,
+    disableEscapeKeyDown: r = !1,
+    disableScrollLock: o = !1,
+    closeAfterTransition: i = !1,
+    onTransitionEnter: s,
+    onTransitionExited: a,
+    children: l,
+    onClose: u,
+    open: h,
+    rootRef: T
+  } = t, v = c.useRef({}), x = c.useRef(null), y = c.useRef(null), b = G(y, T), [S, R] = c.useState(!h), k = it(l);
+  let N = !0;
+  (t["aria-hidden"] === "false" || t["aria-hidden"] === !1) && (N = !1);
+  const f = () => A(x.current), m = () => (v.current.modalRef = y.current, v.current.mount = x.current, v.current), C = () => {
+    V.mount(m(), {
+      disableScrollLock: o
+    }), y.current && (y.current.scrollTop = 0);
+  }, w = pe(() => {
+    const p = st(n) || f().body;
+    V.add(m(), p), y.current && C();
+  }), g = () => V.isTopModal(m()), O = pe((p) => {
+    x.current = p, p && (h && g() ? C() : y.current && L(y.current, N));
+  }), P = c.useCallback(() => {
+    V.remove(m(), N);
+  }, [N]);
+  c.useEffect(() => () => {
+    P();
+  }, [P]), c.useEffect(() => {
+    h ? w() : (!k || !i) && P();
+  }, [h, P, k, i, w]);
+  const F = (p) => (d) => {
+    p.onKeyDown?.(d), !(d.key !== "Escape" || d.which === 229 || // Wait until IME is settled.
+    !g()) && (r || (d.stopPropagation(), u && u(d, "escapeKeyDown")));
+  }, I = (p) => (d) => {
+    p.onClick?.(d), d.target === d.currentTarget && u && u(d, "backdropClick");
+  };
+  return {
+    getRootProps: (p = {}) => {
+      const d = Ae(t);
+      delete d.onTransitionEnter, delete d.onTransitionExited;
+      const $ = {
+        ...d,
+        ...p
+      };
+      return {
+        /*
+         * Marking an element with the role presentation indicates to assistive technology
+         * that this element should be ignored; it exists to support the web application and
+         * is not meant for humans to interact with directly.
+         * https://github.com/evcohen/eslint-plugin-jsx-a11y/blob/master/docs/rules/no-static-element-interactions.md
+         */
+        role: "presentation",
+        ...$,
+        onKeyDown: F($),
+        ref: b
+      };
+    },
+    getBackdropProps: (p = {}) => {
+      const d = p;
+      return {
+        "aria-hidden": !0,
+        ...d,
+        onClick: I(d),
+        open: h
+      };
+    },
+    getTransitionProps: () => {
+      const p = () => {
+        R(!1), s && s();
+      }, d = () => {
+        R(!0), a && a(), i && P();
+      };
+      return {
+        onEnter: be(p, l?.props.onEnter ?? Ee),
+        onExited: be(d, l?.props.onExited ?? Ee)
+      };
+    },
+    rootRef: b,
+    portalRef: O,
+    isTopModal: g,
+    exited: S,
+    hasTransition: k
+  };
+}
+function lt(t) {
+  return ee("MuiModal", t);
+}
+te("MuiModal", ["root", "hidden", "backdrop"]);
+const ct = (t) => {
+  const {
+    open: n,
+    exited: r,
+    classes: o
+  } = t;
+  return oe({
+    root: ["root", !n && r && "hidden"],
+    backdrop: ["backdrop"]
+  }, lt, o);
+}, dt = Y("div", {
+  name: "MuiModal",
+  slot: "Root",
+  overridesResolver: (t, n) => {
+    const {
+      ownerState: r
+    } = t;
+    return [n.root, !r.open && r.exited && n.hidden];
+  }
+})(ye(({
+  theme: t
+}) => ({
+  position: "fixed",
+  zIndex: (t.vars || t).zIndex.modal,
+  right: 0,
+  bottom: 0,
+  top: 0,
+  left: 0,
+  variants: [{
+    props: ({
+      ownerState: n
+    }) => !n.open && n.exited,
+    style: {
+      visibility: "hidden"
+    }
+  }]
+}))), ut = Y(ke, {
+  name: "MuiModal",
+  slot: "Backdrop"
+})({
+  zIndex: -1
+}), pt = /* @__PURE__ */ c.forwardRef(function(n, r) {
+  const o = ne({
+    name: "MuiModal",
+    props: n
+  }), {
+    BackdropComponent: i = ut,
+    BackdropProps: s,
+    classes: a,
+    className: l,
+    closeAfterTransition: u = !1,
+    children: h,
+    container: T,
+    component: v,
+    components: x = {},
+    componentsProps: y = {},
+    disableAutoFocus: b = !1,
+    disableEnforceFocus: S = !1,
+    disableEscapeKeyDown: R = !1,
+    disablePortal: k = !1,
+    disableRestoreFocus: N = !1,
+    disableScrollLock: f = !1,
+    hideBackdrop: m = !1,
+    keepMounted: C = !1,
+    onClose: w,
+    onTransitionEnter: g,
+    onTransitionExited: O,
+    open: P,
+    slotProps: F = {},
+    slots: I = {},
+    // eslint-disable-next-line react/prop-types
+    theme: D,
+    ...X
+  } = o, E = {
+    ...o,
+    closeAfterTransition: u,
+    disableAutoFocus: b,
+    disableEnforceFocus: S,
+    disableEscapeKeyDown: R,
+    disablePortal: k,
+    disableRestoreFocus: N,
+    disableScrollLock: f,
+    hideBackdrop: m,
+    keepMounted: C
+  }, {
+    getRootProps: p,
+    getBackdropProps: d,
+    getTransitionProps: $,
+    portalRef: Ne,
+    isTopModal: we,
+    exited: ie,
+    hasTransition: ae
+  } = at({
+    ...E,
+    rootRef: r
+  }), B = {
+    ...E,
+    exited: ie
+  }, J = ct(B), H = {};
+  if (h.props.tabIndex === void 0 && (H.tabIndex = "-1"), ae) {
+    const {
+      onEnter: j,
+      onExited: Q
+    } = $();
+    H.onEnter = j, H.onExited = Q;
+  }
+  const le = {
+    slots: {
+      root: x.Root,
+      backdrop: x.Backdrop,
+      ...I
+    },
+    slotProps: {
+      ...y,
+      ...F
+    }
+  }, [Oe, Ce] = K("root", {
+    ref: r,
+    elementType: dt,
+    externalForwardedProps: {
+      ...le,
+      ...X,
+      component: v
+    },
+    getSlotProps: p,
+    ownerState: B,
+    className: q(l, J?.root, !B.open && B.exited && J?.hidden)
+  }), [Se, Me] = K("backdrop", {
+    ref: s?.ref,
+    elementType: i,
+    externalForwardedProps: le,
+    shouldForwardComponentProp: !0,
+    additionalProps: s,
+    getSlotProps: (j) => d({
+      ...j,
+      onClick: (Q) => {
+        j?.onClick && j.onClick(Q);
+      }
+    }),
+    className: q(s?.className, J?.backdrop),
+    ownerState: B
+  });
+  return !C && !P && (!ae || ie) ? null : /* @__PURE__ */ M(W, {
+    ref: Ne,
+    container: T,
+    disablePortal: k,
+    children: /* @__PURE__ */ Te(Oe, {
+      ...Ce,
+      children: [!m && i ? /* @__PURE__ */ M(Se, {
+        ...Me
+      }) : null, /* @__PURE__ */ M(z, {
+        disableEnforceFocus: S,
+        disableAutoFocus: b,
+        disableRestoreFocus: N,
+        isEnabled: we,
+        open: P,
+        children: /* @__PURE__ */ c.cloneElement(h, H)
+      })]
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (pt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm 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',
+   * })({
+   *   zIndex: -1,
+   * })
+   */
+  BackdropComponent: e.elementType,
+  /**
+   * Props applied to the [`Backdrop`](https://mui.com/material-ui/api/backdrop/) element.
+   * @deprecated Use `slotProps.backdrop` instead.
+   */
+  BackdropProps: e.object,
+  /**
+   * A single child content element.
+   */
+  children: se.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.
+   *
+   * @deprecated Use the `slots` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @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.
+   *
+   * @deprecated Use the `slotProps` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @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.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: e.oneOfType([Pe, 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 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,
+  /**
+   * A function called when a transition enters.
+   */
+  onTransitionEnter: e.func,
+  /**
+   * A function called when a transition has exited.
+   */
+  onTransitionExited: 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 {
+  ke as B,
+  Re as F,
+  Pe as H,
+  pt as M,
+  Ve as P,
+  U as a,
+  W as b,
+  z as c,
+  xt as d,
+  Xe as g,
+  _ as o
+};