@hybridcore/ui 1.0.2 → 1.1.0

package/dist/Button-BZR43NHz.js

@@ -0,0 +1,2025 @@
+import { a as l, _ as j } from "./extends-C3382pL0.js";
+import * as d from "react";
+import { P as n, c as $ } from "./createTheme-agWfFD64.js";
+import { c as _, g as H, u as Y, a as G, r as Vo } from "./chainPropTypes-DtBfUj5o.js";
+import { g as U, s as L, r as Ho, a as eo } from "./styled-Iq9jsO4F.js";
+import { u as So } from "./useTheme-CeyGVuQP.js";
+import { jsxs as co, jsx as N } from "react/jsx-runtime";
+import { T as Uo, r as Ko, g as ho } from "./utils-C13eMoWa.js";
+import { e as po, a as Oo } from "./exactProp-CI8dagM-.js";
+import { u as J, b as yo, s as Eo, a as To, B as qo } from "./ButtonBase-B6WYZgVU.js";
+import { o as V } from "./ownerDocument-CUrv0DIK.js";
+import { o as uo } from "./ownerWindow-niciwP7I.js";
+import { c as Co, u as Yo } from "./useId-BHG98T5I.js";
+import { i as Go } from "./isHostComponent-kiaBvYVo.js";
+import * as Xo from "react-dom";
+import { P as Do } from "./Paper-CaiWdndQ.js";
+function Io(o, e, t, r, s) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const i = o[e], a = s || e;
+  return i == null ? null : i && i.nodeType !== 1 ? new Error(`Invalid ${r} \`${a}\` supplied to \`${t}\`. Expected an HTMLElement.`) : null;
+}
+function Zo(o) {
+  const e = o.documentElement.clientWidth;
+  return Math.abs(window.innerWidth - e);
+}
+function Jo(o, e, t) {
+  return o === void 0 || Go(o) ? e : l({}, e, {
+    ownerState: l({}, e.ownerState, t)
+  });
+}
+function Bo(o, e = []) {
+  if (o === void 0)
+    return {};
+  const t = {};
+  return Object.keys(o).filter((r) => r.match(/^on[A-Z]/) && typeof o[r] == "function" && !e.includes(r)).forEach((r) => {
+    t[r] = o[r];
+  }), t;
+}
+function ko(o) {
+  if (o === void 0)
+    return {};
+  const e = {};
+  return Object.keys(o).filter((t) => !(t.match(/^on[A-Z]/) && typeof o[t] == "function")).forEach((t) => {
+    e[t] = o[t];
+  }), e;
+}
+function Qo(o) {
+  const {
+    getSlotProps: e,
+    additionalProps: t,
+    externalSlotProps: r,
+    externalForwardedProps: s,
+    className: i
+  } = o;
+  if (!e) {
+    const h = _(t == null ? void 0 : t.className, i, s == null ? void 0 : s.className, r == null ? void 0 : r.className), f = l({}, t == null ? void 0 : t.style, s == null ? void 0 : s.style, r == null ? void 0 : r.style), S = l({}, t, s, r);
+    return h.length > 0 && (S.className = h), Object.keys(f).length > 0 && (S.style = f), {
+      props: S,
+      internalRef: void 0
+    };
+  }
+  const a = Bo(l({}, s, r)), c = ko(r), p = ko(s), b = e(a), m = _(b == null ? void 0 : b.className, t == null ? void 0 : t.className, i, s == null ? void 0 : s.className, r == null ? void 0 : r.className), v = l({}, b == null ? void 0 : b.style, t == null ? void 0 : t.style, s == null ? void 0 : s.style, r == null ? void 0 : r.style), y = l({}, b, t, p, c);
+  return m.length > 0 && (y.className = m), Object.keys(v).length > 0 && (y.style = v), {
+    props: y,
+    internalRef: b.ref
+  };
+}
+function oe(o, e, t) {
+  return typeof o == "function" ? o(e, t) : o;
+}
+const ee = ["elementType", "externalSlotProps", "ownerState", "skipResolvingSlotProps"];
+function Po(o) {
+  var e;
+  const {
+    elementType: t,
+    externalSlotProps: r,
+    ownerState: s,
+    skipResolvingSlotProps: i = !1
+  } = o, a = j(o, ee), c = i ? {} : oe(r, s), {
+    props: p,
+    internalRef: b
+  } = Qo(l({}, a, {
+    externalSlotProps: c
+  })), m = J(b, c == null ? void 0 : c.ref, (e = o.additionalProps) == null ? void 0 : e.ref);
+  return Jo(t, l({}, p, {
+    ref: m
+  }), s);
+}
+function ne(o) {
+  const e = V(o);
+  return e.body === o ? uo(o).innerWidth > e.documentElement.clientWidth : o.scrollHeight > o.clientHeight;
+}
+function Z(o, e) {
+  e ? o.setAttribute("aria-hidden", "true") : o.removeAttribute("aria-hidden");
+}
+function Ro(o) {
+  return parseInt(uo(o).getComputedStyle(o).paddingRight, 10) || 0;
+}
+function te(o) {
+  const t = ["TEMPLATE", "SCRIPT", "STYLE", "LINK", "MAP", "META", "NOSCRIPT", "PICTURE", "COL", "COLGROUP", "PARAM", "SLOT", "SOURCE", "TRACK"].indexOf(o.tagName) !== -1, r = o.tagName === "INPUT" && o.getAttribute("type") === "hidden";
+  return t || r;
+}
+function No(o, e, t, r, s) {
+  const i = [e, t, ...r];
+  [].forEach.call(o.children, (a) => {
+    const c = i.indexOf(a) === -1, p = !te(a);
+    c && p && Z(a, s);
+  });
+}
+function ao(o, e) {
+  let t = -1;
+  return o.some((r, s) => e(r) ? (t = s, !0) : !1), t;
+}
+function re(o, e) {
+  const t = [], r = o.container;
+  if (!e.disableScrollLock) {
+    if (ne(r)) {
+      const a = Zo(V(r));
+      t.push({
+        value: r.style.paddingRight,
+        property: "padding-right",
+        el: r
+      }), r.style.paddingRight = `${Ro(r) + a}px`;
+      const c = V(r).querySelectorAll(".mui-fixed");
+      [].forEach.call(c, (p) => {
+        t.push({
+          value: p.style.paddingRight,
+          property: "padding-right",
+          el: p
+        }), p.style.paddingRight = `${Ro(p) + a}px`;
+      });
+    }
+    let i;
+    if (r.parentNode instanceof DocumentFragment)
+      i = V(r).body;
+    else {
+      const a = r.parentElement, c = uo(r);
+      i = (a == null ? void 0 : a.nodeName) === "HTML" && c.getComputedStyle(a).overflowY === "scroll" ? a : r;
+    }
+    t.push({
+      value: i.style.overflow,
+      property: "overflow",
+      el: i
+    }, {
+      value: i.style.overflowX,
+      property: "overflow-x",
+      el: i
+    }, {
+      value: i.style.overflowY,
+      property: "overflow-y",
+      el: i
+    }), i.style.overflow = "hidden";
+  }
+  return () => {
+    t.forEach(({
+      value: i,
+      el: a,
+      property: c
+    }) => {
+      i ? a.style.setProperty(c, i) : a.style.removeProperty(c);
+    });
+  };
+}
+function ie(o) {
+  const e = [];
+  return [].forEach.call(o.children, (t) => {
+    t.getAttribute("aria-hidden") === "true" && e.push(t);
+  }), e;
+}
+class se {
+  constructor() {
+    this.containers = void 0, this.modals = void 0, this.modals = [], this.containers = [];
+  }
+  add(e, t) {
+    let r = this.modals.indexOf(e);
+    if (r !== -1)
+      return r;
+    r = this.modals.length, this.modals.push(e), e.modalRef && Z(e.modalRef, !1);
+    const s = ie(t);
+    No(t, e.mount, e.modalRef, s, !0);
+    const i = ao(this.containers, (a) => a.container === t);
+    return i !== -1 ? (this.containers[i].modals.push(e), r) : (this.containers.push({
+      modals: [e],
+      container: t,
+      restore: null,
+      hiddenSiblings: s
+    }), r);
+  }
+  mount(e, t) {
+    const r = ao(this.containers, (i) => i.modals.indexOf(e) !== -1), s = this.containers[r];
+    s.restore || (s.restore = re(s, t));
+  }
+  remove(e, t = !0) {
+    const r = this.modals.indexOf(e);
+    if (r === -1)
+      return r;
+    const s = ao(this.containers, (a) => a.modals.indexOf(e) !== -1), i = this.containers[s];
+    if (i.modals.splice(i.modals.indexOf(e), 1), this.modals.splice(r, 1), i.modals.length === 0)
+      i.restore && i.restore(), e.modalRef && Z(e.modalRef, t), No(i.container, e.mount, e.modalRef, i.hiddenSiblings, !1), this.containers.splice(s, 1);
+    else {
+      const a = i.modals[i.modals.length - 1];
+      a.modalRef && Z(a.modalRef, !1);
+    }
+    return r;
+  }
+  isTopModal(e) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === e;
+  }
+}
+const ae = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])'].join(",");
+function le(o) {
+  const e = parseInt(o.getAttribute("tabindex") || "", 10);
+  return Number.isNaN(e) ? o.contentEditable === "true" || (o.nodeName === "AUDIO" || o.nodeName === "VIDEO" || o.nodeName === "DETAILS") && o.getAttribute("tabindex") === null ? 0 : o.tabIndex : e;
+}
+function ce(o) {
+  if (o.tagName !== "INPUT" || o.type !== "radio" || !o.name)
+    return !1;
+  const e = (r) => o.ownerDocument.querySelector(`input[type="radio"]${r}`);
+  let t = e(`[name="${o.name}"]:checked`);
+  return t || (t = e(`[name="${o.name}"]`)), t !== o;
+}
+function de(o) {
+  return !(o.disabled || o.tagName === "INPUT" && o.type === "hidden" || ce(o));
+}
+function pe(o) {
+  const e = [], t = [];
+  return Array.from(o.querySelectorAll(ae)).forEach((r, s) => {
+    const i = le(r);
+    i === -1 || !de(r) || (i === 0 ? e.push(r) : t.push({
+      documentOrder: s,
+      tabIndex: i,
+      node: r
+    }));
+  }), t.sort((r, s) => r.tabIndex === s.tabIndex ? r.documentOrder - s.documentOrder : r.tabIndex - s.tabIndex).map((r) => r.node).concat(e);
+}
+function ue() {
+  return !0;
+}
+function to(o) {
+  const {
+    children: e,
+    disableAutoFocus: t = !1,
+    disableEnforceFocus: r = !1,
+    disableRestoreFocus: s = !1,
+    getTabbable: i = pe,
+    isEnabled: a = ue,
+    open: c
+  } = o, p = d.useRef(!1), b = d.useRef(null), m = d.useRef(null), v = d.useRef(null), y = d.useRef(null), h = d.useRef(!1), f = d.useRef(null), S = J(e.ref, f), O = d.useRef(null);
+  d.useEffect(() => {
+    !c || !f.current || (h.current = !t);
+  }, [t, c]), d.useEffect(() => {
+    if (!c || !f.current)
+      return;
+    const u = V(f.current);
+    return f.current.contains(u.activeElement) || (f.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(`
+`)), f.current.setAttribute("tabIndex", "-1")), h.current && f.current.focus()), () => {
+      s || (v.current && v.current.focus && (p.current = !0, v.current.focus()), v.current = null);
+    };
+  }, [c]), d.useEffect(() => {
+    if (!c || !f.current)
+      return;
+    const u = V(f.current), k = (T) => {
+      O.current = T, !(r || !a() || T.key !== "Tab") && u.activeElement === f.current && T.shiftKey && (p.current = !0, m.current && m.current.focus());
+    }, E = () => {
+      const T = f.current;
+      if (T === null)
+        return;
+      if (!u.hasFocus() || !a() || p.current) {
+        p.current = !1;
+        return;
+      }
+      if (T.contains(u.activeElement) || r && u.activeElement !== b.current && u.activeElement !== m.current)
+        return;
+      if (u.activeElement !== y.current)
+        y.current = null;
+      else if (y.current !== null)
+        return;
+      if (!h.current)
+        return;
+      let I = [];
+      if ((u.activeElement === b.current || u.activeElement === m.current) && (I = i(f.current)), I.length > 0) {
+        var z, B;
+        const F = !!((z = O.current) != null && z.shiftKey && ((B = O.current) == null ? void 0 : B.key) === "Tab"), w = I[0], A = I[I.length - 1];
+        typeof w != "string" && typeof A != "string" && (F ? A.focus() : w.focus());
+      } else
+        T.focus();
+    };
+    u.addEventListener("focusin", E), u.addEventListener("keydown", k, !0);
+    const P = setInterval(() => {
+      u.activeElement && u.activeElement.tagName === "BODY" && E();
+    }, 50);
+    return () => {
+      clearInterval(P), u.removeEventListener("focusin", E), u.removeEventListener("keydown", k, !0);
+    };
+  }, [t, r, s, a, c, i]);
+  const D = (u) => {
+    v.current === null && (v.current = u.relatedTarget), h.current = !0, y.current = u.target;
+    const k = e.props.onFocus;
+    k && k(u);
+  }, R = (u) => {
+    v.current === null && (v.current = u.relatedTarget), h.current = !0;
+  };
+  return /* @__PURE__ */ co(d.Fragment, {
+    children: [/* @__PURE__ */ N("div", {
+      tabIndex: c ? 0 : -1,
+      onFocus: R,
+      ref: b,
+      "data-testid": "sentinelStart"
+    }), /* @__PURE__ */ d.cloneElement(e, {
+      ref: S,
+      onFocus: D
+    }), /* @__PURE__ */ N("div", {
+      tabIndex: c ? 0 : -1,
+      onFocus: R,
+      ref: m,
+      "data-testid": "sentinelEnd"
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (to.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: po,
+  /**
+   * 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: n.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: n.bool,
+  /**
+   * If `true`, the focus trap will not restore focus to previously focused element once
+   * focus trap is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: n.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: n.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: n.func,
+  /**
+   * If `true`, focus is locked.
+   */
+  open: n.bool.isRequired
+});
+process.env.NODE_ENV !== "production" && (to.propTypes = Oo(to.propTypes));
+function fe(o) {
+  return typeof o == "function" ? o() : o;
+}
+const ro = /* @__PURE__ */ d.forwardRef(function(e, t) {
+  const {
+    children: r,
+    container: s,
+    disablePortal: i = !1
+  } = e, [a, c] = d.useState(null), p = J(/* @__PURE__ */ d.isValidElement(r) ? r.ref : null, t);
+  if (yo(() => {
+    i || c(fe(s) || document.body);
+  }, [s, i]), yo(() => {
+    if (a && !i)
+      return Eo(t, a), () => {
+        Eo(t, null);
+      };
+  }, [t, a, i]), i) {
+    if (/* @__PURE__ */ d.isValidElement(r)) {
+      const b = {
+        ref: p
+      };
+      return /* @__PURE__ */ d.cloneElement(r, b);
+    }
+    return /* @__PURE__ */ N(d.Fragment, {
+      children: r
+    });
+  }
+  return /* @__PURE__ */ N(d.Fragment, {
+    children: a && /* @__PURE__ */ Xo.createPortal(r, a)
+  });
+});
+process.env.NODE_ENV !== "production" && (ro.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: n.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: n.oneOfType([Io, n.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: n.bool
+});
+process.env.NODE_ENV !== "production" && (ro.propTypes = Oo(ro.propTypes));
+const be = ["addEndListener", "appear", "children", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"], ge = {
+  entering: {
+    opacity: 1
+  },
+  entered: {
+    opacity: 1
+  }
+}, fo = /* @__PURE__ */ d.forwardRef(function(e, t) {
+  const r = So(), s = {
+    enter: r.transitions.duration.enteringScreen,
+    exit: r.transitions.duration.leavingScreen
+  }, {
+    addEndListener: i,
+    appear: a = !0,
+    children: c,
+    easing: p,
+    in: b,
+    onEnter: m,
+    onEntered: v,
+    onEntering: y,
+    onExit: h,
+    onExited: f,
+    onExiting: S,
+    style: O,
+    timeout: D = s,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: R = Uo
+  } = e, u = j(e, be), k = d.useRef(null), E = J(k, c.ref, t), P = (x) => (W) => {
+    if (x) {
+      const g = k.current;
+      W === void 0 ? x(g) : x(g, W);
+    }
+  }, T = P(y), I = P((x, W) => {
+    Ko(x);
+    const g = ho({
+      style: O,
+      timeout: D,
+      easing: p
+    }, {
+      mode: "enter"
+    });
+    x.style.webkitTransition = r.transitions.create("opacity", g), x.style.transition = r.transitions.create("opacity", g), m && m(x, W);
+  }), z = P(v), B = P(S), F = P((x) => {
+    const W = ho({
+      style: O,
+      timeout: D,
+      easing: p
+    }, {
+      mode: "exit"
+    });
+    x.style.webkitTransition = r.transitions.create("opacity", W), x.style.transition = r.transitions.create("opacity", W), h && h(x);
+  }), w = P(f);
+  return /* @__PURE__ */ N(R, l({
+    appear: a,
+    in: b,
+    nodeRef: k,
+    onEnter: I,
+    onEntered: z,
+    onEntering: T,
+    onExit: F,
+    onExited: w,
+    onExiting: B,
+    addEndListener: (x) => {
+      i && i(k.current, x);
+    },
+    timeout: D
+  }, u, {
+    children: (x, W) => /* @__PURE__ */ d.cloneElement(c, l({
+      style: l({
+        opacity: 0,
+        visibility: x === "exited" && !b ? "hidden" : void 0
+      }, ge[x], O, c.props.style),
+      ref: E
+    }, W))
+  }));
+});
+process.env.NODE_ENV !== "production" && (fo.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: n.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: n.bool,
+  /**
+   * A single child content element.
+   */
+  children: po.isRequired,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: n.oneOfType([n.shape({
+    enter: n.string,
+    exit: n.string
+  }), n.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: n.bool,
+  /**
+   * @ignore
+   */
+  onEnter: n.func,
+  /**
+   * @ignore
+   */
+  onEntered: n.func,
+  /**
+   * @ignore
+   */
+  onEntering: n.func,
+  /**
+   * @ignore
+   */
+  onExit: n.func,
+  /**
+   * @ignore
+   */
+  onExited: n.func,
+  /**
+   * @ignore
+   */
+  onExiting: n.func,
+  /**
+   * @ignore
+   */
+  style: n.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: n.oneOfType([n.number, n.shape({
+    appear: n.number,
+    enter: n.number,
+    exit: n.number
+  })])
+});
+function me(o) {
+  return U("MuiBackdrop", o);
+}
+H("MuiBackdrop", ["root", "invisible"]);
+const ve = ["children", "className", "component", "components", "componentsProps", "invisible", "open", "slotProps", "slots", "TransitionComponent", "transitionDuration"], xe = (o) => {
+  const {
+    classes: e,
+    invisible: t
+  } = o;
+  return G({
+    root: ["root", t && "invisible"]
+  }, me, e);
+}, he = L("div", {
+  name: "MuiBackdrop",
+  slot: "Root",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.root, t.invisible && e.invisible];
+  }
+})(({
+  ownerState: o
+}) => l({
+  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"
+})), bo = /* @__PURE__ */ d.forwardRef(function(e, t) {
+  var r, s, i;
+  const a = Y({
+    props: e,
+    name: "MuiBackdrop"
+  }), {
+    children: c,
+    className: p,
+    component: b = "div",
+    components: m = {},
+    componentsProps: v = {},
+    invisible: y = !1,
+    open: h,
+    slotProps: f = {},
+    slots: S = {},
+    TransitionComponent: O = fo,
+    transitionDuration: D
+  } = a, R = j(a, ve), u = l({}, a, {
+    component: b,
+    invisible: y
+  }), k = xe(u), E = (r = f.root) != null ? r : v.root;
+  return /* @__PURE__ */ N(O, l({
+    in: h,
+    timeout: D
+  }, R, {
+    children: /* @__PURE__ */ N(he, l({
+      "aria-hidden": !0
+    }, E, {
+      as: (s = (i = S.root) != null ? i : m.Root) != null ? s : b,
+      className: _(k.root, p, E == null ? void 0 : E.className),
+      ownerState: l({}, u, E == null ? void 0 : E.ownerState),
+      classes: k,
+      ref: t,
+      children: c
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (bo.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: n.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * @ignore
+   */
+  className: n.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: n.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: n.shape({
+    Root: n.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: n.shape({
+    root: n.object
+  }),
+  /**
+   * If `true`, the backdrop is invisible.
+   * It can be used when rendering a popover or a custom select component.
+   * @default false
+   */
+  invisible: n.bool,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: n.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: n.shape({
+    root: n.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: n.shape({
+    root: n.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: n.oneOfType([n.arrayOf(n.oneOfType([n.func, n.object, n.bool])), n.func, n.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: n.elementType,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   */
+  transitionDuration: n.oneOfType([n.number, n.shape({
+    appear: n.number,
+    enter: n.number,
+    exit: n.number
+  })])
+});
+function ye(o) {
+  return typeof o == "function" ? o() : o;
+}
+function Ee(o) {
+  return o ? o.props.hasOwnProperty("in") : !1;
+}
+const Te = new se();
+function Ce(o) {
+  const {
+    container: e,
+    disableEscapeKeyDown: t = !1,
+    disableScrollLock: r = !1,
+    // @ts-ignore internal logic - Base UI supports the manager as a prop too
+    manager: s = Te,
+    closeAfterTransition: i = !1,
+    onTransitionEnter: a,
+    onTransitionExited: c,
+    children: p,
+    onClose: b,
+    open: m,
+    rootRef: v
+  } = o, y = d.useRef({}), h = d.useRef(null), f = d.useRef(null), S = J(f, v), [O, D] = d.useState(!m), R = Ee(p);
+  let u = !0;
+  (o["aria-hidden"] === "false" || o["aria-hidden"] === !1) && (u = !1);
+  const k = () => V(h.current), E = () => (y.current.modalRef = f.current, y.current.mount = h.current, y.current), P = () => {
+    s.mount(E(), {
+      disableScrollLock: r
+    }), f.current && (f.current.scrollTop = 0);
+  }, T = To(() => {
+    const g = ye(e) || k().body;
+    s.add(E(), g), f.current && P();
+  }), I = d.useCallback(() => s.isTopModal(E()), [s]), z = To((g) => {
+    h.current = g, g && (m && I() ? P() : f.current && Z(f.current, u));
+  }), B = d.useCallback(() => {
+    s.remove(E(), u);
+  }, [u, s]);
+  d.useEffect(() => () => {
+    B();
+  }, [B]), d.useEffect(() => {
+    m ? T() : (!R || !i) && B();
+  }, [m, B, R, i, T]);
+  const F = (g) => (C) => {
+    var M;
+    (M = g.onKeyDown) == null || M.call(g, C), !(C.key !== "Escape" || C.which === 229 || // Wait until IME is settled.
+    !I()) && (t || (C.stopPropagation(), b && b(C, "escapeKeyDown")));
+  }, w = (g) => (C) => {
+    var M;
+    (M = g.onClick) == null || M.call(g, C), C.target === C.currentTarget && b && b(C, "backdropClick");
+  };
+  return {
+    getRootProps: (g = {}) => {
+      const C = Bo(o);
+      delete C.onTransitionEnter, delete C.onTransitionExited;
+      const M = l({}, C, g);
+      return l({
+        role: "presentation"
+      }, M, {
+        onKeyDown: F(M),
+        ref: S
+      });
+    },
+    getBackdropProps: (g = {}) => {
+      const C = g;
+      return l({
+        "aria-hidden": !0
+      }, C, {
+        onClick: w(C),
+        open: m
+      });
+    },
+    getTransitionProps: () => {
+      const g = () => {
+        D(!1), a && a();
+      }, C = () => {
+        D(!0), c && c(), i && B();
+      };
+      return {
+        onEnter: Co(g, p == null ? void 0 : p.props.onEnter),
+        onExited: Co(C, p == null ? void 0 : p.props.onExited)
+      };
+    },
+    rootRef: S,
+    portalRef: z,
+    isTopModal: I,
+    exited: O,
+    hasTransition: R
+  };
+}
+function ke(o) {
+  return U("MuiModal", o);
+}
+H("MuiModal", ["root", "hidden", "backdrop"]);
+const Pe = ["BackdropComponent", "BackdropProps", "classes", "className", "closeAfterTransition", "children", "container", "component", "components", "componentsProps", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted", "onBackdropClick", "onClose", "onTransitionEnter", "onTransitionExited", "open", "slotProps", "slots", "theme"], Re = (o) => {
+  const {
+    open: e,
+    exited: t,
+    classes: r
+  } = o;
+  return G({
+    root: ["root", !e && t && "hidden"],
+    backdrop: ["backdrop"]
+  }, ke, r);
+}, Ne = L("div", {
+  name: "MuiModal",
+  slot: "Root",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.root, !t.open && t.exited && e.hidden];
+  }
+})(({
+  theme: o,
+  ownerState: e
+}) => l({
+  position: "fixed",
+  zIndex: (o.vars || o).zIndex.modal,
+  right: 0,
+  bottom: 0,
+  top: 0,
+  left: 0
+}, !e.open && e.exited && {
+  visibility: "hidden"
+})), Se = L(bo, {
+  name: "MuiModal",
+  slot: "Backdrop",
+  overridesResolver: (o, e) => e.backdrop
+})({
+  zIndex: -1
+}), Mo = /* @__PURE__ */ d.forwardRef(function(e, t) {
+  var r, s, i, a, c, p;
+  const b = Y({
+    name: "MuiModal",
+    props: e
+  }), {
+    BackdropComponent: m = Se,
+    BackdropProps: v,
+    className: y,
+    closeAfterTransition: h = !1,
+    children: f,
+    container: S,
+    component: O,
+    components: D = {},
+    componentsProps: R = {},
+    disableAutoFocus: u = !1,
+    disableEnforceFocus: k = !1,
+    disableEscapeKeyDown: E = !1,
+    disablePortal: P = !1,
+    disableRestoreFocus: T = !1,
+    disableScrollLock: I = !1,
+    hideBackdrop: z = !1,
+    keepMounted: B = !1,
+    onBackdropClick: F,
+    open: w,
+    slotProps: A,
+    slots: x
+    // eslint-disable-next-line react/prop-types
+  } = b, W = j(b, Pe), g = l({}, b, {
+    closeAfterTransition: h,
+    disableAutoFocus: u,
+    disableEnforceFocus: k,
+    disableEscapeKeyDown: E,
+    disablePortal: P,
+    disableRestoreFocus: T,
+    disableScrollLock: I,
+    hideBackdrop: z,
+    keepMounted: B
+  }), {
+    getRootProps: C,
+    getBackdropProps: M,
+    getTransitionProps: wo,
+    portalRef: Ao,
+    isTopModal: _o,
+    exited: go,
+    hasTransition: mo
+  } = Ce(l({}, g, {
+    rootRef: t
+  })), X = l({}, g, {
+    exited: go
+  }), K = Re(X), Q = {};
+  if (f.props.tabIndex === void 0 && (Q.tabIndex = "-1"), mo) {
+    const {
+      onEnter: q,
+      onExited: oo
+    } = wo();
+    Q.onEnter = q, Q.onExited = oo;
+  }
+  const vo = (r = (s = x == null ? void 0 : x.root) != null ? s : D.Root) != null ? r : Ne, xo = (i = (a = x == null ? void 0 : x.backdrop) != null ? a : D.Backdrop) != null ? i : m, io = (c = A == null ? void 0 : A.root) != null ? c : R.root, so = (p = A == null ? void 0 : A.backdrop) != null ? p : R.backdrop, Lo = Po({
+    elementType: vo,
+    externalSlotProps: io,
+    externalForwardedProps: W,
+    getSlotProps: C,
+    additionalProps: {
+      ref: t,
+      as: O
+    },
+    ownerState: X,
+    className: _(y, io == null ? void 0 : io.className, K == null ? void 0 : K.root, !X.open && X.exited && (K == null ? void 0 : K.hidden))
+  }), jo = Po({
+    elementType: xo,
+    externalSlotProps: so,
+    additionalProps: v,
+    getSlotProps: (q) => M(l({}, q, {
+      onClick: (oo) => {
+        F && F(oo), q != null && q.onClick && q.onClick(oo);
+      }
+    })),
+    className: _(so == null ? void 0 : so.className, v == null ? void 0 : v.className, K == null ? void 0 : K.backdrop),
+    ownerState: X
+  });
+  return !B && !w && (!mo || go) ? null : /* @__PURE__ */ N(ro, {
+    ref: Ao,
+    container: S,
+    disablePortal: P,
+    children: /* @__PURE__ */ co(vo, l({}, Lo, {
+      children: [!z && m ? /* @__PURE__ */ N(xo, l({}, jo)) : null, /* @__PURE__ */ N(to, {
+        disableEnforceFocus: k,
+        disableAutoFocus: u,
+        disableRestoreFocus: T,
+        isEnabled: _o,
+        open: w,
+        children: /* @__PURE__ */ d.cloneElement(f, Q)
+      })]
+    }))
+  });
+});
+process.env.NODE_ENV !== "production" && (Mo.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: n.elementType,
+  /**
+   * Props applied to the [`Backdrop`](/material-ui/api/backdrop/) element.
+   * @deprecated Use `slotProps.backdrop` instead.
+   */
+  BackdropProps: n.object,
+  /**
+   * A single child content element.
+   */
+  children: po.isRequired,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * @ignore
+   */
+  className: n.string,
+  /**
+   * When set to true the Modal waits until a nested Transition is completed before closing.
+   * @default false
+   */
+  closeAfterTransition: n.bool,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: n.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: n.shape({
+    Backdrop: n.elementType,
+    Root: n.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: n.shape({
+    backdrop: n.oneOfType([n.func, n.object]),
+    root: n.oneOfType([n.func, n.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: n.oneOfType([Io, n.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: n.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: n.bool,
+  /**
+   * If `true`, hitting escape will not fire the `onClose` callback.
+   * @default false
+   */
+  disableEscapeKeyDown: n.bool,
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: n.bool,
+  /**
+   * If `true`, the modal will not restore focus to previously focused element once
+   * modal is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: n.bool,
+  /**
+   * Disable the scroll lock behavior.
+   * @default false
+   */
+  disableScrollLock: n.bool,
+  /**
+   * If `true`, the backdrop is not rendered.
+   * @default false
+   */
+  hideBackdrop: n.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: n.bool,
+  /**
+   * Callback fired when the backdrop is clicked.
+   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
+   */
+  onBackdropClick: n.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: n.func,
+  /**
+   * A function called when a transition enters.
+   */
+  onTransitionEnter: n.func,
+  /**
+   * A function called when a transition has exited.
+   */
+  onTransitionExited: n.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: n.bool.isRequired,
+  /**
+   * The props used for each slot inside the Modal.
+   * @default {}
+   */
+  slotProps: n.shape({
+    backdrop: n.oneOfType([n.func, n.object]),
+    root: n.oneOfType([n.func, n.object])
+  }),
+  /**
+   * The components used for each slot inside the Modal.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: n.shape({
+    backdrop: n.elementType,
+    root: n.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: n.oneOfType([n.arrayOf(n.oneOfType([n.func, n.object, n.bool])), n.func, n.object])
+});
+function Oe(o) {
+  return U("MuiDialog", o);
+}
+const lo = H("MuiDialog", ["root", "scrollPaper", "scrollBody", "container", "paper", "paperScrollPaper", "paperScrollBody", "paperWidthFalse", "paperWidthXs", "paperWidthSm", "paperWidthMd", "paperWidthLg", "paperWidthXl", "paperFullWidth", "paperFullScreen"]), $o = /* @__PURE__ */ d.createContext({});
+process.env.NODE_ENV !== "production" && ($o.displayName = "DialogContext");
+const De = ["aria-describedby", "aria-labelledby", "BackdropComponent", "BackdropProps", "children", "className", "disableEscapeKeyDown", "fullScreen", "fullWidth", "maxWidth", "onBackdropClick", "onClick", "onClose", "open", "PaperComponent", "PaperProps", "scroll", "TransitionComponent", "transitionDuration", "TransitionProps"], Ie = L(bo, {
+  name: "MuiDialog",
+  slot: "Backdrop",
+  overrides: (o, e) => e.backdrop
+})({
+  // Improve scrollable dialog support.
+  zIndex: -1
+}), Be = (o) => {
+  const {
+    classes: e,
+    scroll: t,
+    maxWidth: r,
+    fullWidth: s,
+    fullScreen: i
+  } = o, a = {
+    root: ["root"],
+    container: ["container", `scroll${$(t)}`],
+    paper: ["paper", `paperScroll${$(t)}`, `paperWidth${$(String(r))}`, s && "paperFullWidth", i && "paperFullScreen"]
+  };
+  return G(a, Oe, e);
+}, Me = L(Mo, {
+  name: "MuiDialog",
+  slot: "Root",
+  overridesResolver: (o, e) => e.root
+})({
+  "@media print": {
+    // Use !important to override the Modal inline-style.
+    position: "absolute !important"
+  }
+}), $e = L("div", {
+  name: "MuiDialog",
+  slot: "Container",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.container, e[`scroll${$(t.scroll)}`]];
+  }
+})(({
+  ownerState: o
+}) => l({
+  height: "100%",
+  "@media print": {
+    height: "auto"
+  },
+  // We disable the focus ring for mouse, touch and keyboard users.
+  outline: 0
+}, o.scroll === "paper" && {
+  display: "flex",
+  justifyContent: "center",
+  alignItems: "center"
+}, o.scroll === "body" && {
+  overflowY: "auto",
+  overflowX: "hidden",
+  textAlign: "center",
+  "&::after": {
+    content: '""',
+    display: "inline-block",
+    verticalAlign: "middle",
+    height: "100%",
+    width: "0"
+  }
+})), We = L(Do, {
+  name: "MuiDialog",
+  slot: "Paper",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.paper, e[`scrollPaper${$(t.scroll)}`], e[`paperWidth${$(String(t.maxWidth))}`], t.fullWidth && e.paperFullWidth, t.fullScreen && e.paperFullScreen];
+  }
+})(({
+  theme: o,
+  ownerState: e
+}) => l({
+  margin: 32,
+  position: "relative",
+  overflowY: "auto",
+  // Fix IE11 issue, to remove at some point.
+  "@media print": {
+    overflowY: "visible",
+    boxShadow: "none"
+  }
+}, e.scroll === "paper" && {
+  display: "flex",
+  flexDirection: "column",
+  maxHeight: "calc(100% - 64px)"
+}, e.scroll === "body" && {
+  display: "inline-block",
+  verticalAlign: "middle",
+  textAlign: "left"
+  // 'initial' doesn't work on IE11
+}, !e.maxWidth && {
+  maxWidth: "calc(100% - 64px)"
+}, e.maxWidth === "xs" && {
+  maxWidth: o.breakpoints.unit === "px" ? Math.max(o.breakpoints.values.xs, 444) : `max(${o.breakpoints.values.xs}${o.breakpoints.unit}, 444px)`,
+  [`&.${lo.paperScrollBody}`]: {
+    [o.breakpoints.down(Math.max(o.breakpoints.values.xs, 444) + 32 * 2)]: {
+      maxWidth: "calc(100% - 64px)"
+    }
+  }
+}, e.maxWidth && e.maxWidth !== "xs" && {
+  maxWidth: `${o.breakpoints.values[e.maxWidth]}${o.breakpoints.unit}`,
+  [`&.${lo.paperScrollBody}`]: {
+    [o.breakpoints.down(o.breakpoints.values[e.maxWidth] + 32 * 2)]: {
+      maxWidth: "calc(100% - 64px)"
+    }
+  }
+}, e.fullWidth && {
+  width: "calc(100% - 64px)"
+}, e.fullScreen && {
+  margin: 0,
+  width: "100%",
+  maxWidth: "100%",
+  height: "100%",
+  maxHeight: "none",
+  borderRadius: 0,
+  [`&.${lo.paperScrollBody}`]: {
+    margin: 0,
+    maxWidth: "100%"
+  }
+})), ze = /* @__PURE__ */ d.forwardRef(function(e, t) {
+  const r = Y({
+    props: e,
+    name: "MuiDialog"
+  }), s = So(), i = {
+    enter: s.transitions.duration.enteringScreen,
+    exit: s.transitions.duration.leavingScreen
+  }, {
+    "aria-describedby": a,
+    "aria-labelledby": c,
+    BackdropComponent: p,
+    BackdropProps: b,
+    children: m,
+    className: v,
+    disableEscapeKeyDown: y = !1,
+    fullScreen: h = !1,
+    fullWidth: f = !1,
+    maxWidth: S = "sm",
+    onBackdropClick: O,
+    onClick: D,
+    onClose: R,
+    open: u,
+    PaperComponent: k = Do,
+    PaperProps: E = {},
+    scroll: P = "paper",
+    TransitionComponent: T = fo,
+    transitionDuration: I = i,
+    TransitionProps: z
+  } = r, B = j(r, De), F = l({}, r, {
+    disableEscapeKeyDown: y,
+    fullScreen: h,
+    fullWidth: f,
+    maxWidth: S,
+    scroll: P
+  }), w = Be(F), A = d.useRef(), x = (M) => {
+    A.current = M.target === M.currentTarget;
+  }, W = (M) => {
+    D && D(M), A.current && (A.current = null, O && O(M), R && R(M, "backdropClick"));
+  }, g = Yo(c), C = d.useMemo(() => ({
+    titleId: g
+  }), [g]);
+  return /* @__PURE__ */ N(Me, l({
+    className: _(w.root, v),
+    closeAfterTransition: !0,
+    components: {
+      Backdrop: Ie
+    },
+    componentsProps: {
+      backdrop: l({
+        transitionDuration: I,
+        as: p
+      }, b)
+    },
+    disableEscapeKeyDown: y,
+    onClose: R,
+    open: u,
+    ref: t,
+    onClick: W,
+    ownerState: F
+  }, B, {
+    children: /* @__PURE__ */ N(T, l({
+      appear: !0,
+      in: u,
+      timeout: I,
+      role: "presentation"
+    }, z, {
+      children: /* @__PURE__ */ N($e, {
+        className: _(w.container),
+        onMouseDown: x,
+        ownerState: F,
+        children: /* @__PURE__ */ N(We, l({
+          as: k,
+          elevation: 24,
+          role: "dialog",
+          "aria-describedby": a,
+          "aria-labelledby": g
+        }, E, {
+          className: _(w.paper, E.className),
+          ownerState: F,
+          children: /* @__PURE__ */ N($o.Provider, {
+            value: C,
+            children: m
+          })
+        }))
+      })
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (ze.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": n.string,
+  /**
+   * The id(s) of the element(s) that label the dialog.
+   */
+  "aria-labelledby": n.string,
+  /**
+   * 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: n.elementType,
+  /**
+   * @ignore
+   */
+  BackdropProps: n.object,
+  /**
+   * Dialog children, usually the included sub-components.
+   */
+  children: n.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * @ignore
+   */
+  className: n.string,
+  /**
+   * If `true`, hitting escape will not fire the `onClose` callback.
+   * @default false
+   */
+  disableEscapeKeyDown: n.bool,
+  /**
+   * If `true`, the dialog is full-screen.
+   * @default false
+   */
+  fullScreen: n.bool,
+  /**
+   * If `true`, the dialog stretches to `maxWidth`.
+   *
+   * Notice that the dialog width grow is limited by the default margin.
+   * @default false
+   */
+  fullWidth: n.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: n.oneOfType([n.oneOf(["xs", "sm", "md", "lg", "xl", !1]), n.string]),
+  /**
+   * Callback fired when the backdrop is clicked.
+   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
+   */
+  onBackdropClick: n.func,
+  /**
+   * @ignore
+   */
+  onClick: n.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: n.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: n.bool.isRequired,
+  /**
+   * The component used to render the body of the dialog.
+   * @default Paper
+   */
+  PaperComponent: n.elementType,
+  /**
+   * Props applied to the [`Paper`](/material-ui/api/paper/) element.
+   * @default {}
+   */
+  PaperProps: n.object,
+  /**
+   * Determine the container for scrolling the dialog.
+   * @default 'paper'
+   */
+  scroll: n.oneOf(["body", "paper"]),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: n.oneOfType([n.arrayOf(n.oneOfType([n.func, n.object, n.bool])), n.func, n.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: n.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: n.oneOfType([n.number, n.shape({
+    appear: n.number,
+    enter: n.number,
+    exit: n.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: n.object
+});
+function Fe(o) {
+  return U("MuiDialogActions", o);
+}
+H("MuiDialogActions", ["root", "spacing"]);
+const we = ["className", "disableSpacing"], Ae = (o) => {
+  const {
+    classes: e,
+    disableSpacing: t
+  } = o;
+  return G({
+    root: ["root", !t && "spacing"]
+  }, Fe, e);
+}, _e = L("div", {
+  name: "MuiDialogActions",
+  slot: "Root",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.root, !t.disableSpacing && e.spacing];
+  }
+})(({
+  ownerState: o
+}) => l({
+  display: "flex",
+  alignItems: "center",
+  padding: 8,
+  justifyContent: "flex-end",
+  flex: "0 0 auto"
+}, !o.disableSpacing && {
+  "& > :not(style) ~ :not(style)": {
+    marginLeft: 8
+  }
+})), Le = /* @__PURE__ */ d.forwardRef(function(e, t) {
+  const r = Y({
+    props: e,
+    name: "MuiDialogActions"
+  }), {
+    className: s,
+    disableSpacing: i = !1
+  } = r, a = j(r, we), c = l({}, r, {
+    disableSpacing: i
+  }), p = Ae(c);
+  return /* @__PURE__ */ N(_e, l({
+    className: _(p.root, s),
+    ownerState: c,
+    ref: t
+  }, a));
+});
+process.env.NODE_ENV !== "production" && (Le.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: n.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * @ignore
+   */
+  className: n.string,
+  /**
+   * If `true`, the actions do not have additional margin.
+   * @default false
+   */
+  disableSpacing: n.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: n.oneOfType([n.arrayOf(n.oneOfType([n.func, n.object, n.bool])), n.func, n.object])
+});
+function je(o) {
+  return U("MuiDialogContent", o);
+}
+H("MuiDialogContent", ["root", "dividers"]);
+function mn(o) {
+  return U("MuiDialogTitle", o);
+}
+const Ve = H("MuiDialogTitle", ["root"]), He = ["className", "dividers"], Ue = (o) => {
+  const {
+    classes: e,
+    dividers: t
+  } = o;
+  return G({
+    root: ["root", t && "dividers"]
+  }, je, e);
+}, Ke = L("div", {
+  name: "MuiDialogContent",
+  slot: "Root",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.root, t.dividers && e.dividers];
+  }
+})(({
+  theme: o,
+  ownerState: e
+}) => l({
+  flex: "1 1 auto",
+  // Add iOS momentum scrolling for iOS < 13.0
+  WebkitOverflowScrolling: "touch",
+  overflowY: "auto",
+  padding: "20px 24px"
+}, e.dividers ? {
+  padding: "16px 24px",
+  borderTop: `1px solid ${(o.vars || o).palette.divider}`,
+  borderBottom: `1px solid ${(o.vars || o).palette.divider}`
+} : {
+  [`.${Ve.root} + &`]: {
+    paddingTop: 0
+  }
+})), qe = /* @__PURE__ */ d.forwardRef(function(e, t) {
+  const r = Y({
+    props: e,
+    name: "MuiDialogContent"
+  }), {
+    className: s,
+    dividers: i = !1
+  } = r, a = j(r, He), c = l({}, r, {
+    dividers: i
+  }), p = Ue(c);
+  return /* @__PURE__ */ N(Ke, l({
+    className: _(p.root, s),
+    ownerState: c,
+    ref: t
+  }, a));
+});
+process.env.NODE_ENV !== "production" && (qe.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: n.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * @ignore
+   */
+  className: n.string,
+  /**
+   * Display the top and bottom dividers.
+   * @default false
+   */
+  dividers: n.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: n.oneOfType([n.arrayOf(n.oneOfType([n.func, n.object, n.bool])), n.func, n.object])
+});
+function Ye(o) {
+  return U("MuiButton", o);
+}
+const no = H("MuiButton", ["root", "text", "textInherit", "textPrimary", "textSecondary", "textSuccess", "textError", "textInfo", "textWarning", "outlined", "outlinedInherit", "outlinedPrimary", "outlinedSecondary", "outlinedSuccess", "outlinedError", "outlinedInfo", "outlinedWarning", "contained", "containedInherit", "containedPrimary", "containedSecondary", "containedSuccess", "containedError", "containedInfo", "containedWarning", "disableElevation", "focusVisible", "disabled", "colorInherit", "colorPrimary", "colorSecondary", "colorSuccess", "colorError", "colorInfo", "colorWarning", "textSizeSmall", "textSizeMedium", "textSizeLarge", "outlinedSizeSmall", "outlinedSizeMedium", "outlinedSizeLarge", "containedSizeSmall", "containedSizeMedium", "containedSizeLarge", "sizeMedium", "sizeSmall", "sizeLarge", "fullWidth", "startIcon", "endIcon", "icon", "iconSizeSmall", "iconSizeMedium", "iconSizeLarge"]), Wo = /* @__PURE__ */ d.createContext({});
+process.env.NODE_ENV !== "production" && (Wo.displayName = "ButtonGroupContext");
+const zo = /* @__PURE__ */ d.createContext(void 0);
+process.env.NODE_ENV !== "production" && (zo.displayName = "ButtonGroupButtonContext");
+const Ge = ["children", "color", "component", "className", "disabled", "disableElevation", "disableFocusRipple", "endIcon", "focusVisibleClassName", "fullWidth", "size", "startIcon", "type", "variant"], Xe = (o) => {
+  const {
+    color: e,
+    disableElevation: t,
+    fullWidth: r,
+    size: s,
+    variant: i,
+    classes: a
+  } = o, c = {
+    root: ["root", i, `${i}${$(e)}`, `size${$(s)}`, `${i}Size${$(s)}`, `color${$(e)}`, t && "disableElevation", r && "fullWidth"],
+    label: ["label"],
+    startIcon: ["icon", "startIcon", `iconSize${$(s)}`],
+    endIcon: ["icon", "endIcon", `iconSize${$(s)}`]
+  }, p = G(c, Ye, a);
+  return l({}, a, p);
+}, Fo = (o) => l({}, o.size === "small" && {
+  "& > *:nth-of-type(1)": {
+    fontSize: 18
+  }
+}, o.size === "medium" && {
+  "& > *:nth-of-type(1)": {
+    fontSize: 20
+  }
+}, o.size === "large" && {
+  "& > *:nth-of-type(1)": {
+    fontSize: 22
+  }
+}), Ze = L(qo, {
+  shouldForwardProp: (o) => Ho(o) || o === "classes",
+  name: "MuiButton",
+  slot: "Root",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.root, e[t.variant], e[`${t.variant}${$(t.color)}`], e[`size${$(t.size)}`], e[`${t.variant}Size${$(t.size)}`], t.color === "inherit" && e.colorInherit, t.disableElevation && e.disableElevation, t.fullWidth && e.fullWidth];
+  }
+})(({
+  theme: o,
+  ownerState: e
+}) => {
+  var t, r;
+  const s = o.palette.mode === "light" ? o.palette.grey[300] : o.palette.grey[800], i = o.palette.mode === "light" ? o.palette.grey.A100 : o.palette.grey[700];
+  return l({}, o.typography.button, {
+    minWidth: 64,
+    padding: "6px 16px",
+    borderRadius: (o.vars || o).shape.borderRadius,
+    transition: o.transitions.create(["background-color", "box-shadow", "border-color", "color"], {
+      duration: o.transitions.duration.short
+    }),
+    "&:hover": l({
+      textDecoration: "none",
+      backgroundColor: o.vars ? `rgba(${o.vars.palette.text.primaryChannel} / ${o.vars.palette.action.hoverOpacity})` : eo(o.palette.text.primary, o.palette.action.hoverOpacity),
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: "transparent"
+      }
+    }, e.variant === "text" && e.color !== "inherit" && {
+      backgroundColor: o.vars ? `rgba(${o.vars.palette[e.color].mainChannel} / ${o.vars.palette.action.hoverOpacity})` : eo(o.palette[e.color].main, o.palette.action.hoverOpacity),
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: "transparent"
+      }
+    }, e.variant === "outlined" && e.color !== "inherit" && {
+      border: `1px solid ${(o.vars || o).palette[e.color].main}`,
+      backgroundColor: o.vars ? `rgba(${o.vars.palette[e.color].mainChannel} / ${o.vars.palette.action.hoverOpacity})` : eo(o.palette[e.color].main, o.palette.action.hoverOpacity),
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: "transparent"
+      }
+    }, e.variant === "contained" && {
+      backgroundColor: o.vars ? o.vars.palette.Button.inheritContainedHoverBg : i,
+      boxShadow: (o.vars || o).shadows[4],
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        boxShadow: (o.vars || o).shadows[2],
+        backgroundColor: (o.vars || o).palette.grey[300]
+      }
+    }, e.variant === "contained" && e.color !== "inherit" && {
+      backgroundColor: (o.vars || o).palette[e.color].dark,
+      // Reset on touch devices, it doesn't add specificity
+      "@media (hover: none)": {
+        backgroundColor: (o.vars || o).palette[e.color].main
+      }
+    }),
+    "&:active": l({}, e.variant === "contained" && {
+      boxShadow: (o.vars || o).shadows[8]
+    }),
+    [`&.${no.focusVisible}`]: l({}, e.variant === "contained" && {
+      boxShadow: (o.vars || o).shadows[6]
+    }),
+    [`&.${no.disabled}`]: l({
+      color: (o.vars || o).palette.action.disabled
+    }, e.variant === "outlined" && {
+      border: `1px solid ${(o.vars || o).palette.action.disabledBackground}`
+    }, e.variant === "contained" && {
+      color: (o.vars || o).palette.action.disabled,
+      boxShadow: (o.vars || o).shadows[0],
+      backgroundColor: (o.vars || o).palette.action.disabledBackground
+    })
+  }, e.variant === "text" && {
+    padding: "6px 8px"
+  }, e.variant === "text" && e.color !== "inherit" && {
+    color: (o.vars || o).palette[e.color].main
+  }, e.variant === "outlined" && {
+    padding: "5px 15px",
+    border: "1px solid currentColor"
+  }, e.variant === "outlined" && e.color !== "inherit" && {
+    color: (o.vars || o).palette[e.color].main,
+    border: o.vars ? `1px solid rgba(${o.vars.palette[e.color].mainChannel} / 0.5)` : `1px solid ${eo(o.palette[e.color].main, 0.5)}`
+  }, e.variant === "contained" && {
+    color: o.vars ? (
+      // this is safe because grey does not change between default light/dark mode
+      o.vars.palette.text.primary
+    ) : (t = (r = o.palette).getContrastText) == null ? void 0 : t.call(r, o.palette.grey[300]),
+    backgroundColor: o.vars ? o.vars.palette.Button.inheritContainedBg : s,
+    boxShadow: (o.vars || o).shadows[2]
+  }, e.variant === "contained" && e.color !== "inherit" && {
+    color: (o.vars || o).palette[e.color].contrastText,
+    backgroundColor: (o.vars || o).palette[e.color].main
+  }, e.color === "inherit" && {
+    color: "inherit",
+    borderColor: "currentColor"
+  }, e.size === "small" && e.variant === "text" && {
+    padding: "4px 5px",
+    fontSize: o.typography.pxToRem(13)
+  }, e.size === "large" && e.variant === "text" && {
+    padding: "8px 11px",
+    fontSize: o.typography.pxToRem(15)
+  }, e.size === "small" && e.variant === "outlined" && {
+    padding: "3px 9px",
+    fontSize: o.typography.pxToRem(13)
+  }, e.size === "large" && e.variant === "outlined" && {
+    padding: "7px 21px",
+    fontSize: o.typography.pxToRem(15)
+  }, e.size === "small" && e.variant === "contained" && {
+    padding: "4px 10px",
+    fontSize: o.typography.pxToRem(13)
+  }, e.size === "large" && e.variant === "contained" && {
+    padding: "8px 22px",
+    fontSize: o.typography.pxToRem(15)
+  }, e.fullWidth && {
+    width: "100%"
+  });
+}, ({
+  ownerState: o
+}) => o.disableElevation && {
+  boxShadow: "none",
+  "&:hover": {
+    boxShadow: "none"
+  },
+  [`&.${no.focusVisible}`]: {
+    boxShadow: "none"
+  },
+  "&:active": {
+    boxShadow: "none"
+  },
+  [`&.${no.disabled}`]: {
+    boxShadow: "none"
+  }
+}), Je = L("span", {
+  name: "MuiButton",
+  slot: "StartIcon",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.startIcon, e[`iconSize${$(t.size)}`]];
+  }
+})(({
+  ownerState: o
+}) => l({
+  display: "inherit",
+  marginRight: 8,
+  marginLeft: -4
+}, o.size === "small" && {
+  marginLeft: -2
+}, Fo(o))), Qe = L("span", {
+  name: "MuiButton",
+  slot: "EndIcon",
+  overridesResolver: (o, e) => {
+    const {
+      ownerState: t
+    } = o;
+    return [e.endIcon, e[`iconSize${$(t.size)}`]];
+  }
+})(({
+  ownerState: o
+}) => l({
+  display: "inherit",
+  marginRight: -4,
+  marginLeft: 8
+}, o.size === "small" && {
+  marginRight: -2
+}, Fo(o))), on = /* @__PURE__ */ d.forwardRef(function(e, t) {
+  const r = d.useContext(Wo), s = d.useContext(zo), i = Vo(r, e), a = Y({
+    props: i,
+    name: "MuiButton"
+  }), {
+    children: c,
+    color: p = "primary",
+    component: b = "button",
+    className: m,
+    disabled: v = !1,
+    disableElevation: y = !1,
+    disableFocusRipple: h = !1,
+    endIcon: f,
+    focusVisibleClassName: S,
+    fullWidth: O = !1,
+    size: D = "medium",
+    startIcon: R,
+    type: u,
+    variant: k = "text"
+  } = a, E = j(a, Ge), P = l({}, a, {
+    color: p,
+    component: b,
+    disabled: v,
+    disableElevation: y,
+    disableFocusRipple: h,
+    fullWidth: O,
+    size: D,
+    type: u,
+    variant: k
+  }), T = Xe(P), I = R && /* @__PURE__ */ N(Je, {
+    className: T.startIcon,
+    ownerState: P,
+    children: R
+  }), z = f && /* @__PURE__ */ N(Qe, {
+    className: T.endIcon,
+    ownerState: P,
+    children: f
+  }), B = s || "";
+  return /* @__PURE__ */ co(Ze, l({
+    ownerState: P,
+    className: _(r.className, T.root, m, B),
+    component: b,
+    disabled: v,
+    focusRipple: !h,
+    focusVisibleClassName: _(T.focusVisible, S),
+    ref: t,
+    type: u
+  }, E, {
+    classes: T,
+    children: [I, c, z]
+  }));
+});
+process.env.NODE_ENV !== "production" && (on.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: n.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: n.object,
+  /**
+   * @ignore
+   */
+  className: n.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: n.oneOfType([n.oneOf(["inherit", "primary", "secondary", "success", "error", "info", "warning"]), n.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: n.elementType,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: n.bool,
+  /**
+   * If `true`, no elevation is used.
+   * @default false
+   */
+  disableElevation: n.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: n.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: n.bool,
+  /**
+   * Element placed after the children.
+   */
+  endIcon: n.node,
+  /**
+   * @ignore
+   */
+  focusVisibleClassName: n.string,
+  /**
+   * If `true`, the button will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: n.bool,
+  /**
+   * The URL to link to when the button is clicked.
+   * If defined, an `a` element will be used as the root node.
+   */
+  href: n.string,
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense button styling.
+   * @default 'medium'
+   */
+  size: n.oneOfType([n.oneOf(["small", "medium", "large"]), n.string]),
+  /**
+   * Element placed before the children.
+   */
+  startIcon: n.node,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: n.oneOfType([n.arrayOf(n.oneOfType([n.func, n.object, n.bool])), n.func, n.object]),
+  /**
+   * @ignore
+   */
+  type: n.oneOfType([n.oneOf(["button", "reset", "submit"]), n.string]),
+  /**
+   * The variant to use.
+   * @default 'text'
+   */
+  variant: n.oneOfType([n.oneOf(["contained", "outlined", "text"]), n.string])
+});
+export {
+  on as B,
+  ze as D,
+  Io as H,
+  Mo as M,
+  qe as a,
+  Le as b,
+  $o as c,
+  Zo as d,
+  mn as g,
+  Po as u
+};