@notificationapi/react 0.0.37 → 1.0.1

package/dist/assets/NotificationPreferencesPopup.js

@@ -0,0 +1,1694 @@
+import { jsx as E, jsxs as Z } from "react/jsx-runtime";
+import * as d from "react";
+import { useContext as Fe } from "react";
+import { Preferences as We } from "../components/Preferences/Preferences.js";
+import { NotificationAPIContext as Be } from "../components/Provider/context.js";
+import { W as Ae } from "./WebPushOptInMessage.js";
+import { P as e, g as z, a as H, s as j, u as Y, c as $, f as X, m as ae, h as V } from "./DefaultPropsProvider.js";
+import { u as ve } from "./useTheme.js";
+import { u as ee, f as ge } from "./ButtonBase.js";
+import { T as je, a as Le, g as he } from "./utils.js";
+import { o as K, e as le, g as Re, a as $e, P as Ue, H as Ke } from "./Portal.js";
+import { u as ne, e as Ve } from "./resolveComponentProps.js";
+import { c as ye } from "./PreferenceInput.js";
+import { P as ke } from "./Paper.js";
+import { a as _e } from "./Divider.js";
+import { T as qe } from "./Typography.js";
+function oe(o) {
+  return K(o).defaultView || window;
+}
+function ze(o = window) {
+  const t = o.document.documentElement.clientWidth;
+  return o.innerWidth - t;
+}
+const He = {
+  entering: {
+    opacity: 1
+  },
+  entered: {
+    opacity: 1
+  }
+}, ce = /* @__PURE__ */ d.forwardRef(function(t, r) {
+  const n = ve(), i = {
+    enter: n.transitions.duration.enteringScreen,
+    exit: n.transitions.duration.leavingScreen
+  }, {
+    addEndListener: s,
+    appear: a = !0,
+    children: l,
+    easing: f,
+    in: y,
+    onEnter: S,
+    onEntered: x,
+    onEntering: C,
+    onExit: h,
+    onExited: b,
+    onExiting: M,
+    style: v,
+    timeout: R = i,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: P = je,
+    ...c
+  } = t, m = d.useRef(null), w = ne(m, Re(l), r), T = (g) => (p) => {
+    if (g) {
+      const u = m.current;
+      p === void 0 ? g(u) : g(u, p);
+    }
+  }, k = T(C), N = T((g, p) => {
+    Le(g);
+    const u = he({
+      style: v,
+      timeout: R,
+      easing: f
+    }, {
+      mode: "enter"
+    });
+    g.style.webkitTransition = n.transitions.create("opacity", u), g.style.transition = n.transitions.create("opacity", u), S && S(g, p);
+  }), D = T(x), F = T(M), W = T((g) => {
+    const p = he({
+      style: v,
+      timeout: R,
+      easing: f
+    }, {
+      mode: "exit"
+    });
+    g.style.webkitTransition = n.transitions.create("opacity", p), g.style.transition = n.transitions.create("opacity", p), h && h(g);
+  }), I = T(b);
+  return /* @__PURE__ */ E(P, {
+    appear: a,
+    in: y,
+    nodeRef: m,
+    onEnter: N,
+    onEntered: D,
+    onEntering: k,
+    onExit: W,
+    onExited: I,
+    onExiting: F,
+    addEndListener: (g) => {
+      s && s(m.current, g);
+    },
+    timeout: R,
+    ...c,
+    children: (g, {
+      ownerState: p,
+      ...u
+    }) => /* @__PURE__ */ d.cloneElement(l, {
+      style: {
+        opacity: 0,
+        visibility: g === "exited" && !y ? "hidden" : void 0,
+        ...He[g],
+        ...v,
+        ...l.props.style
+      },
+      ref: w,
+      ...u
+    })
+  });
+});
+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 `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: le.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 Ye(o) {
+  return H("MuiBackdrop", o);
+}
+z("MuiBackdrop", ["root", "invisible"]);
+const Xe = (o) => {
+  const {
+    classes: t,
+    invisible: r
+  } = o;
+  return X({
+    root: ["root", r && "invisible"]
+  }, Ye, t);
+}, Ge = j("div", {
+  name: "MuiBackdrop",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, r.invisible && t.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"
+    }
+  }]
+}), de = /* @__PURE__ */ d.forwardRef(function(t, r) {
+  const n = Y({
+    props: t,
+    name: "MuiBackdrop"
+  }), {
+    children: i,
+    className: s,
+    component: a = "div",
+    invisible: l = !1,
+    open: f,
+    components: y = {},
+    componentsProps: S = {},
+    slotProps: x = {},
+    slots: C = {},
+    TransitionComponent: h,
+    transitionDuration: b,
+    ...M
+  } = n, v = {
+    ...n,
+    component: a,
+    invisible: l
+  }, R = Xe(v), P = {
+    transition: h,
+    root: y.Root,
+    ...C
+  }, c = {
+    ...S,
+    ...x
+  }, m = {
+    slots: P,
+    slotProps: c
+  }, [w, T] = ee("root", {
+    elementType: Ge,
+    externalForwardedProps: m,
+    className: $(R.root, s),
+    ownerState: v
+  }), [k, N] = ee("transition", {
+    elementType: ce,
+    externalForwardedProps: m,
+    ownerState: v
+  });
+  return /* @__PURE__ */ E(k, {
+    in: f,
+    timeout: b,
+    ...M,
+    ...N,
+    children: /* @__PURE__ */ E(w, {
+      "aria-hidden": !0,
+      ...T,
+      classes: R,
+      ref: r,
+      children: i
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (de.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * The components used for each slot inside.
+   *
+   * @deprecated Use the `slots` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Root: e.elementType
+  }),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * @deprecated Use the `slotProps` prop instead. This prop will be removed in v7. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    root: e.object
+  }),
+  /**
+   * If `true`, the backdrop is invisible.
+   * It can be used when rendering a popover or a custom select component.
+   * @default false
+   */
+  invisible: e.bool,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool.isRequired,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    root: e.oneOfType([e.func, e.object]),
+    transition: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    root: e.elementType,
+    transition: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Fade
+   * @deprecated Use `slots.transition` instead. This prop will be removed in v7. 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 Je(o) {
+  const t = K(o);
+  return t.body === o ? oe(o).innerWidth > t.documentElement.clientWidth : o.scrollHeight > o.clientHeight;
+}
+function q(o, t) {
+  t ? o.setAttribute("aria-hidden", "true") : o.removeAttribute("aria-hidden");
+}
+function xe(o) {
+  return parseInt(oe(o).getComputedStyle(o).paddingRight, 10) || 0;
+}
+function Qe(o) {
+  const r = ["TEMPLATE", "SCRIPT", "STYLE", "LINK", "MAP", "META", "NOSCRIPT", "PICTURE", "COL", "COLGROUP", "PARAM", "SLOT", "SOURCE", "TRACK"].includes(o.tagName), n = o.tagName === "INPUT" && o.getAttribute("type") === "hidden";
+  return r || n;
+}
+function Te(o, t, r, n, i) {
+  const s = [t, r, ...n];
+  [].forEach.call(o.children, (a) => {
+    const l = !s.includes(a), f = !Qe(a);
+    l && f && q(a, i);
+  });
+}
+function se(o, t) {
+  let r = -1;
+  return o.some((n, i) => t(n) ? (r = i, !0) : !1), r;
+}
+function Ze(o, t) {
+  const r = [], n = o.container;
+  if (!t.disableScrollLock) {
+    if (Je(n)) {
+      const a = ze(oe(n));
+      r.push({
+        value: n.style.paddingRight,
+        property: "padding-right",
+        el: n
+      }), n.style.paddingRight = `${xe(n) + a}px`;
+      const l = K(n).querySelectorAll(".mui-fixed");
+      [].forEach.call(l, (f) => {
+        r.push({
+          value: f.style.paddingRight,
+          property: "padding-right",
+          el: f
+        }), f.style.paddingRight = `${xe(f) + a}px`;
+      });
+    }
+    let s;
+    if (n.parentNode instanceof DocumentFragment)
+      s = K(n).body;
+    else {
+      const a = n.parentElement, l = oe(n);
+      s = (a == null ? void 0 : a.nodeName) === "HTML" && l.getComputedStyle(a).overflowY === "scroll" ? a : 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: a,
+      property: l
+    }) => {
+      s ? a.style.setProperty(l, s) : a.style.removeProperty(l);
+    });
+  };
+}
+function eo(o) {
+  const t = [];
+  return [].forEach.call(o.children, (r) => {
+    r.getAttribute("aria-hidden") === "true" && t.push(r);
+  }), t;
+}
+class oo {
+  constructor() {
+    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 && q(t.modalRef, !1);
+    const i = eo(r);
+    Te(r, t.mount, t.modalRef, i, !0);
+    const s = se(this.containers, (a) => a.container === r);
+    return s !== -1 ? (this.containers[s].modals.push(t), n) : (this.containers.push({
+      modals: [t],
+      container: r,
+      restore: null,
+      hiddenSiblings: i
+    }), n);
+  }
+  mount(t, r) {
+    const n = se(this.containers, (s) => s.modals.includes(t)), i = this.containers[n];
+    i.restore || (i.restore = Ze(i, r));
+  }
+  remove(t, r = !0) {
+    const n = this.modals.indexOf(t);
+    if (n === -1)
+      return n;
+    const i = se(this.containers, (a) => a.modals.includes(t)), s = this.containers[i];
+    if (s.modals.splice(s.modals.indexOf(t), 1), this.modals.splice(n, 1), s.modals.length === 0)
+      s.restore && s.restore(), t.modalRef && q(t.modalRef, r), Te(s.container, t.mount, t.modalRef, s.hiddenSiblings, !1), this.containers.splice(i, 1);
+    else {
+      const a = s.modals[s.modals.length - 1];
+      a.modalRef && q(a.modalRef, !1);
+    }
+    return n;
+  }
+  isTopModal(t) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === t;
+  }
+}
+const to = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])'].join(",");
+function no(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 ro(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 so(o) {
+  return !(o.disabled || o.tagName === "INPUT" && o.type === "hidden" || ro(o));
+}
+function io(o) {
+  const t = [], r = [];
+  return Array.from(o.querySelectorAll(to)).forEach((n, i) => {
+    const s = no(n);
+    s === -1 || !so(n) || (s === 0 ? t.push(n) : r.push({
+      documentOrder: i,
+      tabIndex: s,
+      node: n
+    }));
+  }), r.sort((n, i) => n.tabIndex === i.tabIndex ? n.documentOrder - i.documentOrder : n.tabIndex - i.tabIndex).map((n) => n.node).concat(t);
+}
+function ao() {
+  return !0;
+}
+function te(o) {
+  const {
+    children: t,
+    disableAutoFocus: r = !1,
+    disableEnforceFocus: n = !1,
+    disableRestoreFocus: i = !1,
+    getTabbable: s = io,
+    isEnabled: a = ao,
+    open: l
+  } = o, f = d.useRef(!1), y = d.useRef(null), S = d.useRef(null), x = d.useRef(null), C = d.useRef(null), h = d.useRef(!1), b = d.useRef(null), M = ne(Re(t), b), v = d.useRef(null);
+  d.useEffect(() => {
+    !l || !b.current || (h.current = !r);
+  }, [r, l]), d.useEffect(() => {
+    if (!l || !b.current)
+      return;
+    const c = K(b.current);
+    return b.current.contains(c.activeElement) || (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")), h.current && b.current.focus()), () => {
+      i || (x.current && x.current.focus && (f.current = !0, x.current.focus()), x.current = null);
+    };
+  }, [l]), d.useEffect(() => {
+    if (!l || !b.current)
+      return;
+    const c = K(b.current), m = (k) => {
+      v.current = k, !(n || !a() || k.key !== "Tab") && c.activeElement === b.current && k.shiftKey && (f.current = !0, S.current && S.current.focus());
+    }, w = () => {
+      var D, F;
+      const k = b.current;
+      if (k === null)
+        return;
+      if (!c.hasFocus() || !a() || f.current) {
+        f.current = !1;
+        return;
+      }
+      if (k.contains(c.activeElement) || n && c.activeElement !== y.current && c.activeElement !== S.current)
+        return;
+      if (c.activeElement !== C.current)
+        C.current = null;
+      else if (C.current !== null)
+        return;
+      if (!h.current)
+        return;
+      let N = [];
+      if ((c.activeElement === y.current || c.activeElement === S.current) && (N = s(b.current)), N.length > 0) {
+        const W = !!((D = v.current) != null && D.shiftKey && ((F = v.current) == null ? void 0 : F.key) === "Tab"), I = N[0], B = N[N.length - 1];
+        typeof I != "string" && typeof B != "string" && (W ? B.focus() : I.focus());
+      } else
+        k.focus();
+    };
+    c.addEventListener("focusin", w), c.addEventListener("keydown", m, !0);
+    const T = setInterval(() => {
+      c.activeElement && c.activeElement.tagName === "BODY" && w();
+    }, 50);
+    return () => {
+      clearInterval(T), c.removeEventListener("focusin", w), c.removeEventListener("keydown", m, !0);
+    };
+  }, [r, n, i, a, l, s]);
+  const R = (c) => {
+    x.current === null && (x.current = c.relatedTarget), h.current = !0, C.current = c.target;
+    const m = t.props.onFocus;
+    m && m(c);
+  }, P = (c) => {
+    x.current === null && (x.current = c.relatedTarget), h.current = !0;
+  };
+  return /* @__PURE__ */ Z(d.Fragment, {
+    children: [/* @__PURE__ */ E("div", {
+      tabIndex: l ? 0 : -1,
+      onFocus: P,
+      ref: y,
+      "data-testid": "sentinelStart"
+    }), /* @__PURE__ */ d.cloneElement(t, {
+      ref: M,
+      onFocus: R
+    }), /* @__PURE__ */ E("div", {
+      tabIndex: l ? 0 : -1,
+      onFocus: P,
+      ref: S,
+      "data-testid": "sentinelEnd"
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (te.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: le,
+  /**
+   * 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" && (te.propTypes = $e(te.propTypes));
+function lo(o) {
+  return typeof o == "function" ? o() : o;
+}
+function co(o) {
+  return o ? o.props.hasOwnProperty("in") : !1;
+}
+const Ee = () => {
+}, Q = new oo();
+function po(o) {
+  const {
+    container: t,
+    disableEscapeKeyDown: r = !1,
+    disableScrollLock: n = !1,
+    closeAfterTransition: i = !1,
+    onTransitionEnter: s,
+    onTransitionExited: a,
+    children: l,
+    onClose: f,
+    open: y,
+    rootRef: S
+  } = o, x = d.useRef({}), C = d.useRef(null), h = d.useRef(null), b = ne(h, S), [M, v] = d.useState(!y), R = co(l);
+  let P = !0;
+  (o["aria-hidden"] === "false" || o["aria-hidden"] === !1) && (P = !1);
+  const c = () => K(C.current), m = () => (x.current.modalRef = h.current, x.current.mount = C.current, x.current), w = () => {
+    Q.mount(m(), {
+      disableScrollLock: n
+    }), h.current && (h.current.scrollTop = 0);
+  }, T = ge(() => {
+    const p = lo(t) || c().body;
+    Q.add(m(), p), h.current && w();
+  }), k = () => Q.isTopModal(m()), N = ge((p) => {
+    C.current = p, p && (y && k() ? w() : h.current && q(h.current, P));
+  }), D = d.useCallback(() => {
+    Q.remove(m(), P);
+  }, [P]);
+  d.useEffect(() => () => {
+    D();
+  }, [D]), d.useEffect(() => {
+    y ? T() : (!R || !i) && D();
+  }, [y, D, R, i, T]);
+  const F = (p) => (u) => {
+    var O;
+    (O = p.onKeyDown) == null || O.call(p, u), !(u.key !== "Escape" || u.which === 229 || // Wait until IME is settled.
+    !k()) && (r || (u.stopPropagation(), f && f(u, "escapeKeyDown")));
+  }, W = (p) => (u) => {
+    var O;
+    (O = p.onClick) == null || O.call(p, u), u.target === u.currentTarget && f && f(u, "backdropClick");
+  };
+  return {
+    getRootProps: (p = {}) => {
+      const u = Ve(o);
+      delete u.onTransitionEnter, delete u.onTransitionExited;
+      const O = {
+        ...u,
+        ...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",
+        ...O,
+        onKeyDown: F(O),
+        ref: b
+      };
+    },
+    getBackdropProps: (p = {}) => {
+      const u = p;
+      return {
+        "aria-hidden": !0,
+        ...u,
+        onClick: W(u),
+        open: y
+      };
+    },
+    getTransitionProps: () => {
+      const p = () => {
+        v(!1), s && s();
+      }, u = () => {
+        v(!0), a && a(), i && D();
+      };
+      return {
+        onEnter: ye(p, (l == null ? void 0 : l.props.onEnter) ?? Ee),
+        onExited: ye(u, (l == null ? void 0 : l.props.onExited) ?? Ee)
+      };
+    },
+    rootRef: b,
+    portalRef: N,
+    isTopModal: k,
+    exited: M,
+    hasTransition: R
+  };
+}
+function uo(o) {
+  return H("MuiModal", o);
+}
+z("MuiModal", ["root", "hidden", "backdrop"]);
+const fo = (o) => {
+  const {
+    open: t,
+    exited: r,
+    classes: n
+  } = o;
+  return X({
+    root: ["root", !t && r && "hidden"],
+    backdrop: ["backdrop"]
+  }, uo, n);
+}, bo = j("div", {
+  name: "MuiModal",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, !r.open && r.exited && t.hidden];
+  }
+})(ae(({
+  theme: o
+}) => ({
+  position: "fixed",
+  zIndex: (o.vars || o).zIndex.modal,
+  right: 0,
+  bottom: 0,
+  top: 0,
+  left: 0,
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => !t.open && t.exited,
+    style: {
+      visibility: "hidden"
+    }
+  }]
+}))), mo = j(de, {
+  name: "MuiModal",
+  slot: "Backdrop",
+  overridesResolver: (o, t) => t.backdrop
+})({
+  zIndex: -1
+}), Ce = /* @__PURE__ */ d.forwardRef(function(t, r) {
+  const n = Y({
+    name: "MuiModal",
+    props: t
+  }), {
+    BackdropComponent: i = mo,
+    BackdropProps: s,
+    classes: a,
+    className: l,
+    closeAfterTransition: f = !1,
+    children: y,
+    container: S,
+    component: x,
+    components: C = {},
+    componentsProps: h = {},
+    disableAutoFocus: b = !1,
+    disableEnforceFocus: M = !1,
+    disableEscapeKeyDown: v = !1,
+    disablePortal: R = !1,
+    disableRestoreFocus: P = !1,
+    disableScrollLock: c = !1,
+    hideBackdrop: m = !1,
+    keepMounted: w = !1,
+    onBackdropClick: T,
+    onClose: k,
+    onTransitionEnter: N,
+    onTransitionExited: D,
+    open: F,
+    slotProps: W = {},
+    slots: I = {},
+    // eslint-disable-next-line react/prop-types
+    theme: B,
+    ...g
+  } = n, p = {
+    ...n,
+    closeAfterTransition: f,
+    disableAutoFocus: b,
+    disableEnforceFocus: M,
+    disableEscapeKeyDown: v,
+    disablePortal: R,
+    disableRestoreFocus: P,
+    disableScrollLock: c,
+    hideBackdrop: m,
+    keepMounted: w
+  }, {
+    getRootProps: u,
+    getBackdropProps: O,
+    getTransitionProps: re,
+    portalRef: L,
+    isTopModal: Ne,
+    exited: ue,
+    hasTransition: fe
+  } = po({
+    ...p,
+    rootRef: r
+  }), _ = {
+    ...p,
+    exited: ue
+  }, A = fo(_), G = {};
+  if (y.props.tabIndex === void 0 && (G.tabIndex = "-1"), fe) {
+    const {
+      onEnter: U,
+      onExited: J
+    } = re();
+    G.onEnter = U, G.onExited = J;
+  }
+  const be = {
+    ...g,
+    slots: {
+      root: C.Root,
+      backdrop: C.Backdrop,
+      ...I
+    },
+    slotProps: {
+      ...h,
+      ...W
+    }
+  }, [De, Oe] = ee("root", {
+    elementType: bo,
+    externalForwardedProps: be,
+    getSlotProps: u,
+    additionalProps: {
+      ref: r,
+      as: x
+    },
+    ownerState: _,
+    className: $(l, A == null ? void 0 : A.root, !_.open && _.exited && (A == null ? void 0 : A.hidden))
+  }), [Me, me] = ee("backdrop", {
+    elementType: i,
+    externalForwardedProps: be,
+    additionalProps: s,
+    getSlotProps: (U) => O({
+      ...U,
+      onClick: (J) => {
+        T && T(J), U != null && U.onClick && U.onClick(J);
+      }
+    }),
+    className: $(s == null ? void 0 : s.className, A == null ? void 0 : A.backdrop),
+    ownerState: _
+  }), Ie = ne(s == null ? void 0 : s.ref, me.ref);
+  return !w && !F && (!fe || ue) ? null : /* @__PURE__ */ E(Ue, {
+    ref: L,
+    container: S,
+    disablePortal: R,
+    children: /* @__PURE__ */ Z(De, {
+      ...Oe,
+      children: [!m && i ? /* @__PURE__ */ E(Me, {
+        ...me,
+        ref: Ie
+      }) : null, /* @__PURE__ */ E(te, {
+        disableEnforceFocus: M,
+        disableAutoFocus: b,
+        disableRestoreFocus: P,
+        isEnabled: Ne,
+        open: F,
+        children: /* @__PURE__ */ d.cloneElement(y, G)
+      })]
+    })
+  });
+});
+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 `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',
+   *   overridesResolver: (props, styles) => {
+   *     return styles.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: le.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 v7. 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 v7. 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([Ke, 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,
+  /**
+   * 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])
+});
+function go(o) {
+  return H("MuiDialog", o);
+}
+const ie = z("MuiDialog", ["root", "scrollPaper", "scrollBody", "container", "paper", "paperScrollPaper", "paperScrollBody", "paperWidthFalse", "paperWidthXs", "paperWidthSm", "paperWidthMd", "paperWidthLg", "paperWidthXl", "paperFullWidth", "paperFullScreen"]), pe = /* @__PURE__ */ d.createContext({});
+process.env.NODE_ENV !== "production" && (pe.displayName = "DialogContext");
+const ho = j(de, {
+  name: "MuiDialog",
+  slot: "Backdrop",
+  overrides: (o, t) => t.backdrop
+})({
+  // Improve scrollable dialog support.
+  zIndex: -1
+}), yo = (o) => {
+  const {
+    classes: t,
+    scroll: r,
+    maxWidth: n,
+    fullWidth: i,
+    fullScreen: s
+  } = o, a = {
+    root: ["root"],
+    container: ["container", `scroll${V(r)}`],
+    paper: ["paper", `paperScroll${V(r)}`, `paperWidth${V(String(n))}`, i && "paperFullWidth", s && "paperFullScreen"]
+  };
+  return X(a, go, t);
+}, xo = j(Ce, {
+  name: "MuiDialog",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})({
+  "@media print": {
+    // Use !important to override the Modal inline-style.
+    position: "absolute !important"
+  }
+}), To = j("div", {
+  name: "MuiDialog",
+  slot: "Container",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.container, t[`scroll${V(r.scroll)}`]];
+  }
+})({
+  height: "100%",
+  "@media print": {
+    height: "auto"
+  },
+  // We disable the focus ring for mouse, touch and keyboard users.
+  outline: 0,
+  variants: [{
+    props: {
+      scroll: "paper"
+    },
+    style: {
+      display: "flex",
+      justifyContent: "center",
+      alignItems: "center"
+    }
+  }, {
+    props: {
+      scroll: "body"
+    },
+    style: {
+      overflowY: "auto",
+      overflowX: "hidden",
+      textAlign: "center",
+      "&::after": {
+        content: '""',
+        display: "inline-block",
+        verticalAlign: "middle",
+        height: "100%",
+        width: "0"
+      }
+    }
+  }]
+}), Eo = j(ke, {
+  name: "MuiDialog",
+  slot: "Paper",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.paper, t[`scrollPaper${V(r.scroll)}`], t[`paperWidth${V(String(r.maxWidth))}`], r.fullWidth && t.paperFullWidth, r.fullScreen && t.paperFullScreen];
+  }
+})(ae(({
+  theme: o
+}) => ({
+  margin: 32,
+  position: "relative",
+  overflowY: "auto",
+  "@media print": {
+    overflowY: "visible",
+    boxShadow: "none"
+  },
+  variants: [{
+    props: {
+      scroll: "paper"
+    },
+    style: {
+      display: "flex",
+      flexDirection: "column",
+      maxHeight: "calc(100% - 64px)"
+    }
+  }, {
+    props: {
+      scroll: "body"
+    },
+    style: {
+      display: "inline-block",
+      verticalAlign: "middle",
+      textAlign: "initial"
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => !t.maxWidth,
+    style: {
+      maxWidth: "calc(100% - 64px)"
+    }
+  }, {
+    props: {
+      maxWidth: "xs"
+    },
+    style: {
+      maxWidth: o.breakpoints.unit === "px" ? Math.max(o.breakpoints.values.xs, 444) : `max(${o.breakpoints.values.xs}${o.breakpoints.unit}, 444px)`,
+      [`&.${ie.paperScrollBody}`]: {
+        [o.breakpoints.down(Math.max(o.breakpoints.values.xs, 444) + 32 * 2)]: {
+          maxWidth: "calc(100% - 64px)"
+        }
+      }
+    }
+  }, ...Object.keys(o.breakpoints.values).filter((t) => t !== "xs").map((t) => ({
+    props: {
+      maxWidth: t
+    },
+    style: {
+      maxWidth: `${o.breakpoints.values[t]}${o.breakpoints.unit}`,
+      [`&.${ie.paperScrollBody}`]: {
+        [o.breakpoints.down(o.breakpoints.values[t] + 32 * 2)]: {
+          maxWidth: "calc(100% - 64px)"
+        }
+      }
+    }
+  })), {
+    props: ({
+      ownerState: t
+    }) => t.fullWidth,
+    style: {
+      width: "calc(100% - 64px)"
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => t.fullScreen,
+    style: {
+      margin: 0,
+      width: "100%",
+      maxWidth: "100%",
+      height: "100%",
+      maxHeight: "none",
+      borderRadius: 0,
+      [`&.${ie.paperScrollBody}`]: {
+        margin: 0,
+        maxWidth: "100%"
+      }
+    }
+  }]
+}))), Pe = /* @__PURE__ */ d.forwardRef(function(t, r) {
+  const n = Y({
+    props: t,
+    name: "MuiDialog"
+  }), i = ve(), s = {
+    enter: i.transitions.duration.enteringScreen,
+    exit: i.transitions.duration.leavingScreen
+  }, {
+    "aria-describedby": a,
+    "aria-labelledby": l,
+    "aria-modal": f = !0,
+    BackdropComponent: y,
+    BackdropProps: S,
+    children: x,
+    className: C,
+    disableEscapeKeyDown: h = !1,
+    fullScreen: b = !1,
+    fullWidth: M = !1,
+    maxWidth: v = "sm",
+    onBackdropClick: R,
+    onClick: P,
+    onClose: c,
+    open: m,
+    PaperComponent: w = ke,
+    PaperProps: T = {},
+    scroll: k = "paper",
+    TransitionComponent: N = ce,
+    transitionDuration: D = s,
+    TransitionProps: F,
+    ...W
+  } = n, I = {
+    ...n,
+    disableEscapeKeyDown: h,
+    fullScreen: b,
+    fullWidth: M,
+    maxWidth: v,
+    scroll: k
+  }, B = yo(I), g = d.useRef(), p = (L) => {
+    g.current = L.target === L.currentTarget;
+  }, u = (L) => {
+    P && P(L), g.current && (g.current = null, R && R(L), c && c(L, "backdropClick"));
+  }, O = _e(l), re = d.useMemo(() => ({
+    titleId: O
+  }), [O]);
+  return /* @__PURE__ */ E(xo, {
+    className: $(B.root, C),
+    closeAfterTransition: !0,
+    components: {
+      Backdrop: ho
+    },
+    componentsProps: {
+      backdrop: {
+        transitionDuration: D,
+        as: y,
+        ...S
+      }
+    },
+    disableEscapeKeyDown: h,
+    onClose: c,
+    open: m,
+    ref: r,
+    onClick: u,
+    ownerState: I,
+    ...W,
+    children: /* @__PURE__ */ E(N, {
+      appear: !0,
+      in: m,
+      timeout: D,
+      role: "presentation",
+      ...F,
+      children: /* @__PURE__ */ E(To, {
+        className: $(B.container),
+        onMouseDown: p,
+        ownerState: I,
+        children: /* @__PURE__ */ E(Eo, {
+          as: w,
+          elevation: 24,
+          role: "dialog",
+          "aria-describedby": a,
+          "aria-labelledby": O,
+          "aria-modal": f,
+          ...T,
+          className: $(B.paper, T.className),
+          ownerState: I,
+          children: /* @__PURE__ */ E(pe.Provider, {
+            value: re,
+            children: x
+          })
+        })
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Pe.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The id(s) of the element(s) that describe the dialog.
+   */
+  "aria-describedby": e.string,
+  /**
+   * The id(s) of the element(s) that label the dialog.
+   */
+  "aria-labelledby": e.string,
+  /**
+   * Informs assistive technologies that the element is modal.
+   * It's added on the element with role="dialog".
+   * @default true
+   */
+  "aria-modal": e.oneOfType([e.oneOf(["false", "true"]), e.bool]),
+  /**
+   * 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,
+  /**
+   * @ignore
+   */
+  BackdropProps: e.object,
+  /**
+   * Dialog children, usually the included sub-components.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * If `true`, hitting escape will not fire the `onClose` callback.
+   * @default false
+   */
+  disableEscapeKeyDown: e.bool,
+  /**
+   * If `true`, the dialog is full-screen.
+   * @default false
+   */
+  fullScreen: e.bool,
+  /**
+   * If `true`, the dialog stretches to `maxWidth`.
+   *
+   * Notice that the dialog width grow is limited by the default margin.
+   * @default false
+   */
+  fullWidth: e.bool,
+  /**
+   * Determine the max-width of the dialog.
+   * The dialog width grows with the size of the screen.
+   * Set to `false` to disable `maxWidth`.
+   * @default 'sm'
+   */
+  maxWidth: e.oneOfType([e.oneOf(["xs", "sm", "md", "lg", "xl", !1]), e.string]),
+  /**
+   * Callback fired when the backdrop is clicked.
+   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
+   */
+  onBackdropClick: e.func,
+  /**
+   * @ignore
+   */
+  onClick: e.func,
+  /**
+   * Callback fired when the component requests to be closed.
+   *
+   * @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 component used to render the body of the dialog.
+   * @default Paper
+   */
+  PaperComponent: e.elementType,
+  /**
+   * Props applied to the [`Paper`](https://mui.com/material-ui/api/paper/) element.
+   * @default {}
+   */
+  PaperProps: e.object,
+  /**
+   * Determine the container for scrolling the dialog.
+   * @default 'paper'
+   */
+  scroll: e.oneOf(["body", "paper"]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](https://mui.com/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Fade
+   */
+  TransitionComponent: e.elementType,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   * @default {
+   *   enter: theme.transitions.duration.enteringScreen,
+   *   exit: theme.transitions.duration.leavingScreen,
+   * }
+   */
+  transitionDuration: e.oneOfType([e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })]),
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
+   */
+  TransitionProps: e.object
+});
+function vo(o) {
+  return H("MuiDialogContent", o);
+}
+z("MuiDialogContent", ["root", "dividers"]);
+function Ro(o) {
+  return H("MuiDialogTitle", o);
+}
+const ko = z("MuiDialogTitle", ["root"]), Co = (o) => {
+  const {
+    classes: t,
+    dividers: r
+  } = o;
+  return X({
+    root: ["root", r && "dividers"]
+  }, vo, t);
+}, Po = j("div", {
+  name: "MuiDialogContent",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, r.dividers && t.dividers];
+  }
+})(ae(({
+  theme: o
+}) => ({
+  flex: "1 1 auto",
+  // Add iOS momentum scrolling for iOS < 13.0
+  WebkitOverflowScrolling: "touch",
+  overflowY: "auto",
+  padding: "20px 24px",
+  variants: [{
+    props: ({
+      ownerState: t
+    }) => t.dividers,
+    style: {
+      padding: "16px 24px",
+      borderTop: `1px solid ${(o.vars || o).palette.divider}`,
+      borderBottom: `1px solid ${(o.vars || o).palette.divider}`
+    }
+  }, {
+    props: ({
+      ownerState: t
+    }) => !t.dividers,
+    style: {
+      [`.${ko.root} + &`]: {
+        paddingTop: 0
+      }
+    }
+  }]
+}))), Se = /* @__PURE__ */ d.forwardRef(function(t, r) {
+  const n = Y({
+    props: t,
+    name: "MuiDialogContent"
+  }), {
+    className: i,
+    dividers: s = !1,
+    ...a
+  } = n, l = {
+    ...n,
+    dividers: s
+  }, f = Co(l);
+  return /* @__PURE__ */ E(Po, {
+    className: $(f.root, i),
+    ownerState: l,
+    ref: r,
+    ...a
+  });
+});
+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 `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,
+  /**
+   * Display the top and bottom dividers.
+   * @default false
+   */
+  dividers: e.bool,
+  /**
+   * 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 So = (o) => {
+  const {
+    classes: t
+  } = o;
+  return X({
+    root: ["root"]
+  }, Ro, t);
+}, wo = j(qe, {
+  name: "MuiDialogTitle",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})({
+  padding: "16px 24px",
+  flex: "0 0 auto"
+}), we = /* @__PURE__ */ d.forwardRef(function(t, r) {
+  const n = Y({
+    props: t,
+    name: "MuiDialogTitle"
+  }), {
+    className: i,
+    id: s,
+    ...a
+  } = n, l = n, f = So(l), {
+    titleId: y = s
+  } = d.useContext(pe);
+  return /* @__PURE__ */ E(wo, {
+    component: "h2",
+    className: $(f.root, i),
+    ownerState: l,
+    ref: r,
+    variant: "h6",
+    id: s ?? y,
+    ...a
+  });
+});
+process.env.NODE_ENV !== "production" && (we.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,
+  /**
+   * @ignore
+   */
+  id: e.string,
+  /**
+   * 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])
+});
+function _o(o) {
+  const t = Fe(Be);
+  if (!t)
+    return null;
+  const r = {
+    open: o.open === void 0 ? !0 : o.open,
+    onClose: o.onClose || (() => {
+    }),
+    collapse: o.collapse === void 0 ? !1 : o.collapse
+  };
+  return /* @__PURE__ */ Z(
+    Pe,
+    {
+      open: r.open,
+      onClose: r.onClose,
+      maxWidth: "sm",
+      fullWidth: !0,
+      PaperProps: {
+        style: { borderRadius: 8 }
+      },
+      "aria-hidden": !r.open,
+      scroll: "body",
+      children: [
+        /* @__PURE__ */ E(we, { children: "Notification Preferences" }),
+        /* @__PURE__ */ Z(Se, { children: [
+          /* @__PURE__ */ E(We, {}),
+          t.webPushOptInMessage && /* @__PURE__ */ E("div", { children: /* @__PURE__ */ E(
+            Ae,
+            {
+              hideAfterInteraction: !1,
+              descriptionStyle: { fontSize: 12 }
+            }
+          ) })
+        ] })
+      ]
+    }
+  );
+}
+export {
+  Ce as M,
+  _o as N,
+  oe as o
+};