@tencentcloud/chat-uikit-react 2.3.1 → 3.0.1

package/dist/external_modules/mui-CbGEJVT2.js

@@ -0,0 +1,2473 @@
+import * as m from "react";
+import { useLayoutEffect as Dt } from "react";
+import { P as u } from "./react-vendors-3raCpd-g.js";
+import * as rt from "react-dom";
+import { jsx as U, jsxs as st } from "react/jsx-runtime";
+const ue = Math.min, G = Math.max, fe = Math.round, le = Math.floor, j = (e) => ({
+  x: e,
+  y: e
+}), Mt = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Ft = {
+  start: "end",
+  end: "start"
+};
+function _e(e, t, o) {
+  return G(e, ue(t, o));
+}
+function Ee(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Z(e) {
+  return e.split("-")[0];
+}
+function ve(e) {
+  return e.split("-")[1];
+}
+function it(e) {
+  return e === "x" ? "y" : "x";
+}
+function ct(e) {
+  return e === "y" ? "height" : "width";
+}
+const Lt = /* @__PURE__ */ new Set(["top", "bottom"]);
+function z(e) {
+  return Lt.has(Z(e)) ? "y" : "x";
+}
+function lt(e) {
+  return it(z(e));
+}
+function Vt(e, t, o) {
+  o === void 0 && (o = !1);
+  const n = ve(e), r = lt(e), s = ct(r);
+  let i = r === "x" ? n === (o ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return t.reference[s] > t.floating[s] && (i = de(i)), [i, de(i)];
+}
+function It(e) {
+  const t = de(e);
+  return [Se(e), t, Se(t)];
+}
+function Se(e) {
+  return e.replace(/start|end/g, (t) => Ft[t]);
+}
+const We = ["left", "right"], Ue = ["right", "left"], Bt = ["top", "bottom"], $t = ["bottom", "top"];
+function _t(e, t, o) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return o ? t ? Ue : We : t ? We : Ue;
+    case "left":
+    case "right":
+      return t ? Bt : $t;
+    default:
+      return [];
+  }
+}
+function Wt(e, t, o, n) {
+  const r = ve(e);
+  let s = _t(Z(e), o === "start", n);
+  return r && (s = s.map((i) => i + "-" + r), t && (s = s.concat(s.map(Se)))), s;
+}
+function de(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Mt[t]);
+}
+function Ut(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function jt(e) {
+  return typeof e != "number" ? Ut(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function pe(e) {
+  const {
+    x: t,
+    y: o,
+    width: n,
+    height: r
+  } = e;
+  return {
+    width: n,
+    height: r,
+    top: o,
+    left: t,
+    right: t + n,
+    bottom: o + r,
+    x: t,
+    y: o
+  };
+}
+function je(e, t, o) {
+  let {
+    reference: n,
+    floating: r
+  } = e;
+  const s = z(t), i = lt(t), c = ct(i), l = Z(t), a = s === "y", f = n.x + n.width / 2 - r.width / 2, d = n.y + n.height / 2 - r.height / 2, h = n[c] / 2 - r[c] / 2;
+  let p;
+  switch (l) {
+    case "top":
+      p = {
+        x: f,
+        y: n.y - r.height
+      };
+      break;
+    case "bottom":
+      p = {
+        x: f,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      p = {
+        x: n.x + n.width,
+        y: d
+      };
+      break;
+    case "left":
+      p = {
+        x: n.x - r.width,
+        y: d
+      };
+      break;
+    default:
+      p = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (ve(t)) {
+    case "start":
+      p[i] -= h * (o && a ? -1 : 1);
+      break;
+    case "end":
+      p[i] += h * (o && a ? -1 : 1);
+      break;
+  }
+  return p;
+}
+const Kt = async (e, t, o) => {
+  const {
+    placement: n = "bottom",
+    strategy: r = "absolute",
+    middleware: s = [],
+    platform: i
+  } = o, c = s.filter(Boolean), l = await (i.isRTL == null ? void 0 : i.isRTL(t));
+  let a = await i.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: r
+  }), {
+    x: f,
+    y: d
+  } = je(a, n, l), h = n, p = {}, g = 0;
+  for (let E = 0; E < c.length; E++) {
+    const {
+      name: T,
+      fn: w
+    } = c[E], {
+      x: R,
+      y: x,
+      data: N,
+      reset: v
+    } = await w({
+      x: f,
+      y: d,
+      initialPlacement: n,
+      placement: h,
+      strategy: r,
+      middlewareData: p,
+      rects: a,
+      platform: i,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    f = R ?? f, d = x ?? d, p = {
+      ...p,
+      [T]: {
+        ...p[T],
+        ...N
+      }
+    }, v && g <= 50 && (g++, typeof v == "object" && (v.placement && (h = v.placement), v.rects && (a = v.rects === !0 ? await i.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: r
+    }) : v.rects), {
+      x: f,
+      y: d
+    } = je(a, h, l)), E = -1);
+  }
+  return {
+    x: f,
+    y: d,
+    placement: h,
+    strategy: r,
+    middlewareData: p
+  };
+};
+async function at(e, t) {
+  var o;
+  t === void 0 && (t = {});
+  const {
+    x: n,
+    y: r,
+    platform: s,
+    rects: i,
+    elements: c,
+    strategy: l
+  } = e, {
+    boundary: a = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: d = "floating",
+    altBoundary: h = !1,
+    padding: p = 0
+  } = Ee(t, e), g = jt(p), T = c[h ? d === "floating" ? "reference" : "floating" : d], w = pe(await s.getClippingRect({
+    element: (o = await (s.isElement == null ? void 0 : s.isElement(T))) == null || o ? T : T.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(c.floating)),
+    boundary: a,
+    rootBoundary: f,
+    strategy: l
+  })), R = d === "floating" ? {
+    x: n,
+    y: r,
+    width: i.floating.width,
+    height: i.floating.height
+  } : i.reference, x = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(c.floating)), N = await (s.isElement == null ? void 0 : s.isElement(x)) ? await (s.getScale == null ? void 0 : s.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, v = pe(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: R,
+    offsetParent: x,
+    strategy: l
+  }) : R);
+  return {
+    top: (w.top - v.top + g.top) / N.y,
+    bottom: (v.bottom - w.bottom + g.bottom) / N.y,
+    left: (w.left - v.left + g.left) / N.x,
+    right: (v.right - w.right + g.right) / N.x
+  };
+}
+const qt = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var o, n;
+      const {
+        placement: r,
+        middlewareData: s,
+        rects: i,
+        initialPlacement: c,
+        platform: l,
+        elements: a
+      } = t, {
+        mainAxis: f = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: h,
+        fallbackStrategy: p = "bestFit",
+        fallbackAxisSideDirection: g = "none",
+        flipAlignment: E = !0,
+        ...T
+      } = Ee(e, t);
+      if ((o = s.arrow) != null && o.alignmentOffset)
+        return {};
+      const w = Z(r), R = z(c), x = Z(c) === c, N = await (l.isRTL == null ? void 0 : l.isRTL(a.floating)), v = h || (x || !E ? [de(c)] : It(c)), D = g !== "none";
+      !h && D && v.push(...Wt(c, E, g, N));
+      const S = [c, ...v], M = await at(t, T), k = [];
+      let L = ((n = s.flip) == null ? void 0 : n.overflows) || [];
+      if (f && k.push(M[w]), d) {
+        const F = Vt(r, i, N);
+        k.push(M[F[0]], M[F[1]]);
+      }
+      if (L = [...L, {
+        placement: r,
+        overflows: k
+      }], !k.every((F) => F <= 0)) {
+        var y, b;
+        const F = (((y = s.flip) == null ? void 0 : y.index) || 0) + 1, B = S[F];
+        if (B && (!(d === "alignment" ? R !== z(B) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        L.every((O) => O.overflows[0] > 0 && z(O.placement) === R)))
+          return {
+            data: {
+              index: F,
+              overflows: L
+            },
+            reset: {
+              placement: B
+            }
+          };
+        let P = (b = L.filter((A) => A.overflows[0] <= 0).sort((A, O) => A.overflows[1] - O.overflows[1])[0]) == null ? void 0 : b.placement;
+        if (!P)
+          switch (p) {
+            case "bestFit": {
+              var C;
+              const A = (C = L.filter((O) => {
+                if (D) {
+                  const V = z(O.placement);
+                  return V === R || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  V === "y";
+                }
+                return !0;
+              }).map((O) => [O.placement, O.overflows.filter((V) => V > 0).reduce((V, $) => V + $, 0)]).sort((O, V) => O[1] - V[1])[0]) == null ? void 0 : C[0];
+              A && (P = A);
+              break;
+            }
+            case "initialPlacement":
+              P = c;
+              break;
+          }
+        if (r !== P)
+          return {
+            reset: {
+              placement: P
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, zt = /* @__PURE__ */ new Set(["left", "top"]);
+async function Yt(e, t) {
+  const {
+    placement: o,
+    platform: n,
+    elements: r
+  } = e, s = await (n.isRTL == null ? void 0 : n.isRTL(r.floating)), i = Z(o), c = ve(o), l = z(o) === "y", a = zt.has(i) ? -1 : 1, f = s && l ? -1 : 1, d = Ee(t, e);
+  let {
+    mainAxis: h,
+    crossAxis: p,
+    alignmentAxis: g
+  } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: d.mainAxis || 0,
+    crossAxis: d.crossAxis || 0,
+    alignmentAxis: d.alignmentAxis
+  };
+  return c && typeof g == "number" && (p = c === "end" ? g * -1 : g), l ? {
+    x: p * f,
+    y: h * a
+  } : {
+    x: h * a,
+    y: p * f
+  };
+}
+const Xt = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var o, n;
+      const {
+        x: r,
+        y: s,
+        placement: i,
+        middlewareData: c
+      } = t, l = await Yt(t, e);
+      return i === ((o = c.offset) == null ? void 0 : o.placement) && (n = c.arrow) != null && n.alignmentOffset ? {} : {
+        x: r + l.x,
+        y: s + l.y,
+        data: {
+          ...l,
+          placement: i
+        }
+      };
+    }
+  };
+}, Gt = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: o,
+        y: n,
+        placement: r
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: i = !1,
+        limiter: c = {
+          fn: (T) => {
+            let {
+              x: w,
+              y: R
+            } = T;
+            return {
+              x: w,
+              y: R
+            };
+          }
+        },
+        ...l
+      } = Ee(e, t), a = {
+        x: o,
+        y: n
+      }, f = await at(t, l), d = z(Z(r)), h = it(d);
+      let p = a[h], g = a[d];
+      if (s) {
+        const T = h === "y" ? "top" : "left", w = h === "y" ? "bottom" : "right", R = p + f[T], x = p - f[w];
+        p = _e(R, p, x);
+      }
+      if (i) {
+        const T = d === "y" ? "top" : "left", w = d === "y" ? "bottom" : "right", R = g + f[T], x = g - f[w];
+        g = _e(R, g, x);
+      }
+      const E = c.fn({
+        ...t,
+        [h]: p,
+        [d]: g
+      });
+      return {
+        ...E,
+        data: {
+          x: E.x - o,
+          y: E.y - n,
+          enabled: {
+            [h]: s,
+            [d]: i
+          }
+        }
+      };
+    }
+  };
+};
+function Re() {
+  return typeof window < "u";
+}
+function te(e) {
+  return ut(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function I(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function q(e) {
+  var t;
+  return (t = (ut(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function ut(e) {
+  return Re() ? e instanceof Node || e instanceof I(e).Node : !1;
+}
+function _(e) {
+  return Re() ? e instanceof Element || e instanceof I(e).Element : !1;
+}
+function K(e) {
+  return Re() ? e instanceof HTMLElement || e instanceof I(e).HTMLElement : !1;
+}
+function Ke(e) {
+  return !Re() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof I(e).ShadowRoot;
+}
+const Zt = /* @__PURE__ */ new Set(["inline", "contents"]);
+function ie(e) {
+  const {
+    overflow: t,
+    overflowX: o,
+    overflowY: n,
+    display: r
+  } = W(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + n + o) && !Zt.has(r);
+}
+const Jt = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function Qt(e) {
+  return Jt.has(te(e));
+}
+const Ht = [":popover-open", ":modal"];
+function Te(e) {
+  return Ht.some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+const en = ["transform", "translate", "scale", "rotate", "perspective"], tn = ["transform", "translate", "scale", "rotate", "perspective", "filter"], nn = ["paint", "layout", "strict", "content"];
+function De(e) {
+  const t = Me(), o = _(e) ? W(e) : e;
+  return en.some((n) => o[n] ? o[n] !== "none" : !1) || (o.containerType ? o.containerType !== "normal" : !1) || !t && (o.backdropFilter ? o.backdropFilter !== "none" : !1) || !t && (o.filter ? o.filter !== "none" : !1) || tn.some((n) => (o.willChange || "").includes(n)) || nn.some((n) => (o.contain || "").includes(n));
+}
+function on(e) {
+  let t = Y(e);
+  for (; K(t) && !ee(t); ) {
+    if (De(t))
+      return t;
+    if (Te(t))
+      return null;
+    t = Y(t);
+  }
+  return null;
+}
+function Me() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const rn = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function ee(e) {
+  return rn.has(te(e));
+}
+function W(e) {
+  return I(e).getComputedStyle(e);
+}
+function Ne(e) {
+  return _(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function Y(e) {
+  if (te(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    Ke(e) && e.host || // Fallback.
+    q(e)
+  );
+  return Ke(t) ? t.host : t;
+}
+function ft(e) {
+  const t = Y(e);
+  return ee(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : K(t) && ie(t) ? t : ft(t);
+}
+function re(e, t, o) {
+  var n;
+  t === void 0 && (t = []), o === void 0 && (o = !0);
+  const r = ft(e), s = r === ((n = e.ownerDocument) == null ? void 0 : n.body), i = I(r);
+  if (s) {
+    const c = ke(i);
+    return t.concat(i, i.visualViewport || [], ie(r) ? r : [], c && o ? re(c) : []);
+  }
+  return t.concat(r, re(r, [], o));
+}
+function ke(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function dt(e) {
+  const t = W(e);
+  let o = parseFloat(t.width) || 0, n = parseFloat(t.height) || 0;
+  const r = K(e), s = r ? e.offsetWidth : o, i = r ? e.offsetHeight : n, c = fe(o) !== s || fe(n) !== i;
+  return c && (o = s, n = i), {
+    width: o,
+    height: n,
+    $: c
+  };
+}
+function Fe(e) {
+  return _(e) ? e : e.contextElement;
+}
+function H(e) {
+  const t = Fe(e);
+  if (!K(t))
+    return j(1);
+  const o = t.getBoundingClientRect(), {
+    width: n,
+    height: r,
+    $: s
+  } = dt(t);
+  let i = (s ? fe(o.width) : o.width) / n, c = (s ? fe(o.height) : o.height) / r;
+  return (!i || !Number.isFinite(i)) && (i = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: i,
+    y: c
+  };
+}
+const sn = /* @__PURE__ */ j(0);
+function pt(e) {
+  const t = I(e);
+  return !Me() || !t.visualViewport ? sn : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function cn(e, t, o) {
+  return t === void 0 && (t = !1), !o || t && o !== I(e) ? !1 : t;
+}
+function J(e, t, o, n) {
+  t === void 0 && (t = !1), o === void 0 && (o = !1);
+  const r = e.getBoundingClientRect(), s = Fe(e);
+  let i = j(1);
+  t && (n ? _(n) && (i = H(n)) : i = H(e));
+  const c = cn(s, o, n) ? pt(s) : j(0);
+  let l = (r.left + c.x) / i.x, a = (r.top + c.y) / i.y, f = r.width / i.x, d = r.height / i.y;
+  if (s) {
+    const h = I(s), p = n && _(n) ? I(n) : n;
+    let g = h, E = ke(g);
+    for (; E && n && p !== g; ) {
+      const T = H(E), w = E.getBoundingClientRect(), R = W(E), x = w.left + (E.clientLeft + parseFloat(R.paddingLeft)) * T.x, N = w.top + (E.clientTop + parseFloat(R.paddingTop)) * T.y;
+      l *= T.x, a *= T.y, f *= T.x, d *= T.y, l += x, a += N, g = I(E), E = ke(g);
+    }
+  }
+  return pe({
+    width: f,
+    height: d,
+    x: l,
+    y: a
+  });
+}
+function Le(e, t) {
+  const o = Ne(e).scrollLeft;
+  return t ? t.left + o : J(q(e)).left + o;
+}
+function mt(e, t, o) {
+  o === void 0 && (o = !1);
+  const n = e.getBoundingClientRect(), r = n.left + t.scrollLeft - (o ? 0 : (
+    // RTL <body> scrollbar.
+    Le(e, n)
+  )), s = n.top + t.scrollTop;
+  return {
+    x: r,
+    y: s
+  };
+}
+function ln(e) {
+  let {
+    elements: t,
+    rect: o,
+    offsetParent: n,
+    strategy: r
+  } = e;
+  const s = r === "fixed", i = q(n), c = t ? Te(t.floating) : !1;
+  if (n === i || c && s)
+    return o;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, a = j(1);
+  const f = j(0), d = K(n);
+  if ((d || !d && !s) && ((te(n) !== "body" || ie(i)) && (l = Ne(n)), K(n))) {
+    const p = J(n);
+    a = H(n), f.x = p.x + n.clientLeft, f.y = p.y + n.clientTop;
+  }
+  const h = i && !d && !s ? mt(i, l, !0) : j(0);
+  return {
+    width: o.width * a.x,
+    height: o.height * a.y,
+    x: o.x * a.x - l.scrollLeft * a.x + f.x + h.x,
+    y: o.y * a.y - l.scrollTop * a.y + f.y + h.y
+  };
+}
+function an(e) {
+  return Array.from(e.getClientRects());
+}
+function un(e) {
+  const t = q(e), o = Ne(e), n = e.ownerDocument.body, r = G(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), s = G(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
+  let i = -o.scrollLeft + Le(e);
+  const c = -o.scrollTop;
+  return W(n).direction === "rtl" && (i += G(t.clientWidth, n.clientWidth) - r), {
+    width: r,
+    height: s,
+    x: i,
+    y: c
+  };
+}
+function fn(e, t) {
+  const o = I(e), n = q(e), r = o.visualViewport;
+  let s = n.clientWidth, i = n.clientHeight, c = 0, l = 0;
+  if (r) {
+    s = r.width, i = r.height;
+    const a = Me();
+    (!a || a && t === "fixed") && (c = r.offsetLeft, l = r.offsetTop);
+  }
+  return {
+    width: s,
+    height: i,
+    x: c,
+    y: l
+  };
+}
+const dn = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function pn(e, t) {
+  const o = J(e, !0, t === "fixed"), n = o.top + e.clientTop, r = o.left + e.clientLeft, s = K(e) ? H(e) : j(1), i = e.clientWidth * s.x, c = e.clientHeight * s.y, l = r * s.x, a = n * s.y;
+  return {
+    width: i,
+    height: c,
+    x: l,
+    y: a
+  };
+}
+function qe(e, t, o) {
+  let n;
+  if (t === "viewport")
+    n = fn(e, o);
+  else if (t === "document")
+    n = un(q(e));
+  else if (_(t))
+    n = pn(t, o);
+  else {
+    const r = pt(e);
+    n = {
+      x: t.x - r.x,
+      y: t.y - r.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return pe(n);
+}
+function gt(e, t) {
+  const o = Y(e);
+  return o === t || !_(o) || ee(o) ? !1 : W(o).position === "fixed" || gt(o, t);
+}
+function mn(e, t) {
+  const o = t.get(e);
+  if (o)
+    return o;
+  let n = re(e, [], !1).filter((c) => _(c) && te(c) !== "body"), r = null;
+  const s = W(e).position === "fixed";
+  let i = s ? Y(e) : e;
+  for (; _(i) && !ee(i); ) {
+    const c = W(i), l = De(i);
+    !l && c.position === "fixed" && (r = null), (s ? !l && !r : !l && c.position === "static" && !!r && dn.has(r.position) || ie(i) && !l && gt(e, i)) ? n = n.filter((f) => f !== i) : r = c, i = Y(i);
+  }
+  return t.set(e, n), n;
+}
+function gn(e) {
+  let {
+    element: t,
+    boundary: o,
+    rootBoundary: n,
+    strategy: r
+  } = e;
+  const i = [...o === "clippingAncestors" ? Te(t) ? [] : mn(t, this._c) : [].concat(o), n], c = i[0], l = i.reduce((a, f) => {
+    const d = qe(t, f, r);
+    return a.top = G(d.top, a.top), a.right = ue(d.right, a.right), a.bottom = ue(d.bottom, a.bottom), a.left = G(d.left, a.left), a;
+  }, qe(t, c, r));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
+  };
+}
+function hn(e) {
+  const {
+    width: t,
+    height: o
+  } = dt(e);
+  return {
+    width: t,
+    height: o
+  };
+}
+function yn(e, t, o) {
+  const n = K(t), r = q(t), s = o === "fixed", i = J(e, !0, s, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = j(0);
+  function a() {
+    l.x = Le(r);
+  }
+  if (n || !n && !s)
+    if ((te(t) !== "body" || ie(r)) && (c = Ne(t)), n) {
+      const p = J(t, !0, s, t);
+      l.x = p.x + t.clientLeft, l.y = p.y + t.clientTop;
+    } else r && a();
+  s && !n && r && a();
+  const f = r && !n && !s ? mt(r, c) : j(0), d = i.left + c.scrollLeft - l.x - f.x, h = i.top + c.scrollTop - l.y - f.y;
+  return {
+    x: d,
+    y: h,
+    width: i.width,
+    height: i.height
+  };
+}
+function Oe(e) {
+  return W(e).position === "static";
+}
+function ze(e, t) {
+  if (!K(e) || W(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let o = e.offsetParent;
+  return q(e) === o && (o = o.ownerDocument.body), o;
+}
+function ht(e, t) {
+  const o = I(e);
+  if (Te(e))
+    return o;
+  if (!K(e)) {
+    let r = Y(e);
+    for (; r && !ee(r); ) {
+      if (_(r) && !Oe(r))
+        return r;
+      r = Y(r);
+    }
+    return o;
+  }
+  let n = ze(e, t);
+  for (; n && Qt(n) && Oe(n); )
+    n = ze(n, t);
+  return n && ee(n) && Oe(n) && !De(n) ? o : n || on(e) || o;
+}
+const bn = async function(e) {
+  const t = this.getOffsetParent || ht, o = this.getDimensions, n = await o(e.floating);
+  return {
+    reference: yn(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function xn(e) {
+  return W(e).direction === "rtl";
+}
+const wn = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: ln,
+  getDocumentElement: q,
+  getClippingRect: gn,
+  getOffsetParent: ht,
+  getElementRects: bn,
+  getClientRects: an,
+  getDimensions: hn,
+  getScale: H,
+  isElement: _,
+  isRTL: xn
+};
+function yt(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function En(e, t) {
+  let o = null, n;
+  const r = q(e);
+  function s() {
+    var c;
+    clearTimeout(n), (c = o) == null || c.disconnect(), o = null;
+  }
+  function i(c, l) {
+    c === void 0 && (c = !1), l === void 0 && (l = 1), s();
+    const a = e.getBoundingClientRect(), {
+      left: f,
+      top: d,
+      width: h,
+      height: p
+    } = a;
+    if (c || t(), !h || !p)
+      return;
+    const g = le(d), E = le(r.clientWidth - (f + h)), T = le(r.clientHeight - (d + p)), w = le(f), x = {
+      rootMargin: -g + "px " + -E + "px " + -T + "px " + -w + "px",
+      threshold: G(0, ue(1, l)) || 1
+    };
+    let N = !0;
+    function v(D) {
+      const S = D[0].intersectionRatio;
+      if (S !== l) {
+        if (!N)
+          return i();
+        S ? i(!1, S) : n = setTimeout(() => {
+          i(!1, 1e-7);
+        }, 1e3);
+      }
+      S === 1 && !yt(a, e.getBoundingClientRect()) && i(), N = !1;
+    }
+    try {
+      o = new IntersectionObserver(v, {
+        ...x,
+        // Handle <iframe>s
+        root: r.ownerDocument
+      });
+    } catch {
+      o = new IntersectionObserver(v, x);
+    }
+    o.observe(e);
+  }
+  return i(!0), s;
+}
+function Ye(e, t, o, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: r = !0,
+    ancestorResize: s = !0,
+    elementResize: i = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: l = !1
+  } = n, a = Fe(e), f = r || s ? [...a ? re(a) : [], ...re(t)] : [];
+  f.forEach((w) => {
+    r && w.addEventListener("scroll", o, {
+      passive: !0
+    }), s && w.addEventListener("resize", o);
+  });
+  const d = a && c ? En(a, o) : null;
+  let h = -1, p = null;
+  i && (p = new ResizeObserver((w) => {
+    let [R] = w;
+    R && R.target === a && p && (p.unobserve(t), cancelAnimationFrame(h), h = requestAnimationFrame(() => {
+      var x;
+      (x = p) == null || x.observe(t);
+    })), o();
+  }), a && !l && p.observe(a), p.observe(t));
+  let g, E = l ? J(e) : null;
+  l && T();
+  function T() {
+    const w = J(e);
+    E && !yt(E, w) && o(), E = w, g = requestAnimationFrame(T);
+  }
+  return o(), () => {
+    var w;
+    f.forEach((R) => {
+      r && R.removeEventListener("scroll", o), s && R.removeEventListener("resize", o);
+    }), d == null || d(), (w = p) == null || w.disconnect(), p = null, l && cancelAnimationFrame(g);
+  };
+}
+const vn = Xt, Rn = Gt, Tn = qt, Nn = (e, t, o) => {
+  const n = /* @__PURE__ */ new Map(), r = {
+    platform: wn,
+    ...o
+  }, s = {
+    ...r.platform,
+    _c: n
+  };
+  return Kt(e, t, {
+    ...r,
+    platform: s
+  });
+};
+var Cn = typeof document < "u", On = function() {
+}, ae = Cn ? Dt : On;
+function me(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let o, n, r;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (o = e.length, o !== t.length) return !1;
+      for (n = o; n-- !== 0; )
+        if (!me(e[n], t[n]))
+          return !1;
+      return !0;
+    }
+    if (r = Object.keys(e), o = r.length, o !== Object.keys(t).length)
+      return !1;
+    for (n = o; n-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, r[n]))
+        return !1;
+    for (n = o; n-- !== 0; ) {
+      const s = r[n];
+      if (!(s === "_owner" && e.$$typeof) && !me(e[s], t[s]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function bt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function Xe(e, t) {
+  const o = bt(e);
+  return Math.round(t * o) / o;
+}
+function Pe(e) {
+  const t = m.useRef(e);
+  return ae(() => {
+    t.current = e;
+  }), t;
+}
+function Pn(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: o = "absolute",
+    middleware: n = [],
+    platform: r,
+    elements: {
+      reference: s,
+      floating: i
+    } = {},
+    transform: c = !0,
+    whileElementsMounted: l,
+    open: a
+  } = e, [f, d] = m.useState({
+    x: 0,
+    y: 0,
+    strategy: o,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [h, p] = m.useState(n);
+  me(h, n) || p(n);
+  const [g, E] = m.useState(null), [T, w] = m.useState(null), R = m.useCallback((O) => {
+    O !== D.current && (D.current = O, E(O));
+  }, []), x = m.useCallback((O) => {
+    O !== S.current && (S.current = O, w(O));
+  }, []), N = s || g, v = i || T, D = m.useRef(null), S = m.useRef(null), M = m.useRef(f), k = l != null, L = Pe(l), y = Pe(r), b = Pe(a), C = m.useCallback(() => {
+    if (!D.current || !S.current)
+      return;
+    const O = {
+      placement: t,
+      strategy: o,
+      middleware: h
+    };
+    y.current && (O.platform = y.current), Nn(D.current, S.current, O).then((V) => {
+      const $ = {
+        ...V,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: b.current !== !1
+      };
+      F.current && !me(M.current, $) && (M.current = $, rt.flushSync(() => {
+        d($);
+      }));
+    });
+  }, [h, t, o, y, b]);
+  ae(() => {
+    a === !1 && M.current.isPositioned && (M.current.isPositioned = !1, d((O) => ({
+      ...O,
+      isPositioned: !1
+    })));
+  }, [a]);
+  const F = m.useRef(!1);
+  ae(() => (F.current = !0, () => {
+    F.current = !1;
+  }), []), ae(() => {
+    if (N && (D.current = N), v && (S.current = v), N && v) {
+      if (L.current)
+        return L.current(N, v, C);
+      C();
+    }
+  }, [N, v, C, L, k]);
+  const B = m.useMemo(() => ({
+    reference: D,
+    floating: S,
+    setReference: R,
+    setFloating: x
+  }), [R, x]), P = m.useMemo(() => ({
+    reference: N,
+    floating: v
+  }), [N, v]), A = m.useMemo(() => {
+    const O = {
+      position: o,
+      left: 0,
+      top: 0
+    };
+    if (!P.floating)
+      return O;
+    const V = Xe(P.floating, f.x), $ = Xe(P.floating, f.y);
+    return c ? {
+      ...O,
+      transform: "translate(" + V + "px, " + $ + "px)",
+      ...bt(P.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: o,
+      left: V,
+      top: $
+    };
+  }, [o, c, P.floating, f.x, f.y]);
+  return m.useMemo(() => ({
+    ...f,
+    update: C,
+    refs: B,
+    elements: P,
+    floatingStyles: A
+  }), [f, C, B, P, A]);
+}
+const Ge = (e, t) => ({
+  ...vn(e),
+  options: [e, t]
+}), An = (e, t) => ({
+  ...Rn(e),
+  options: [e, t]
+}), Sn = (e, t) => ({
+  ...Tn(e),
+  options: [e, t]
+});
+function xt(e, t) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...n) {
+    return e(...n) || t(...n);
+  };
+}
+function kn(e) {
+  const {
+    prototype: t = {}
+  } = e;
+  return !!t.isReactComponent;
+}
+function wt(e, t, o, n, r) {
+  const s = e[t], i = r || t;
+  if (s == null || // When server-side rendering React doesn't warn either.
+  // This is not an accurate check for SSR.
+  // This is only in place for Emotion compat.
+  // TODO: Revisit once https://github.com/facebook/react/issues/20047 is resolved.
+  typeof window > "u")
+    return null;
+  let c;
+  const l = s.type;
+  return typeof l == "function" && !kn(l) && (c = "Did you accidentally use a plain function component for an element instead?"), c !== void 0 ? new Error(`Invalid ${n} \`${i}\` supplied to \`${o}\`. Expected an element that can hold a ref. ${c} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const Ve = xt(u.element, wt);
+Ve.isRequired = xt(u.element.isRequired, wt);
+const Dn = "exact-prop: ​";
+function Et(e) {
+  return process.env.NODE_ENV === "production" ? e : {
+    ...e,
+    [Dn]: (t) => {
+      const o = Object.keys(t).filter((n) => !e.hasOwnProperty(n));
+      return o.length > 0 ? new Error(`The following props are not supported: ${o.map((n) => `\`${n}\``).join(", ")}. Please remove them.`) : null;
+    }
+  };
+}
+function ge(e, t, o, n, r) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const s = e[t], i = r || t;
+  return s == null ? null : s && s.nodeType !== 1 ? new Error(`Invalid ${n} \`${i}\` supplied to \`${o}\`. Expected an HTMLElement.`) : null;
+}
+function Ze(...e) {
+  return e.reduce((t, o) => o == null ? t : function(...r) {
+    t.apply(this, r), o.apply(this, r);
+  }, () => {
+  });
+}
+function Q(e) {
+  return e && e.ownerDocument || document;
+}
+function he(e) {
+  return Q(e).defaultView || window;
+}
+function Je(e, t) {
+  typeof e == "function" ? e(t) : e && (e.current = t);
+}
+const ye = typeof window < "u" ? m.useLayoutEffect : m.useEffect;
+function Qe(e) {
+  const t = m.useRef(e);
+  return ye(() => {
+    t.current = e;
+  }), m.useRef((...o) => (
+    // @ts-expect-error hide `this`
+    (0, t.current)(...o)
+  )).current;
+}
+function ne(...e) {
+  const t = m.useRef(void 0), o = m.useCallback((n) => {
+    const r = e.map((s) => {
+      if (s == null)
+        return null;
+      if (typeof s == "function") {
+        const i = s, c = i(n);
+        return typeof c == "function" ? c : () => {
+          i(null);
+        };
+      }
+      return s.current = n, () => {
+        s.current = null;
+      };
+    });
+    return () => {
+      r.forEach((s) => s == null ? void 0 : s());
+    };
+  }, e);
+  return m.useMemo(() => e.every((n) => n == null) ? null : (n) => {
+    t.current && (t.current(), t.current = void 0), n != null && (t.current = o(n));
+  }, e);
+}
+function He(e) {
+  try {
+    return e.matches(":focus-visible");
+  } catch {
+    process.env.NODE_ENV !== "production" && !/jsdom/.test(window.navigator.userAgent) && console.warn(["MUI: The `:focus-visible` pseudo class is not supported in this browser.", "Some components rely on this feature to work properly."].join(`
+`));
+  }
+  return !1;
+}
+function Mn(e = window) {
+  const t = e.document.documentElement.clientWidth;
+  return e.innerWidth - t;
+}
+function Ie(e, t, o = void 0) {
+  const n = {};
+  for (const r in e) {
+    const s = e[r];
+    let i = "", c = !0;
+    for (let l = 0; l < s.length; l += 1) {
+      const a = s[l];
+      a && (i += (c === !0 ? "" : " ") + t(a), c = !1, o && o[a] && (i += " " + o[a]));
+    }
+    n[r] = i;
+  }
+  return n;
+}
+const Fn = {
+  active: "active",
+  checked: "checked",
+  completed: "completed",
+  disabled: "disabled",
+  error: "error",
+  expanded: "expanded",
+  focused: "focused",
+  focusVisible: "focusVisible",
+  open: "open",
+  readOnly: "readOnly",
+  required: "required",
+  selected: "selected"
+};
+function Ln(e) {
+  return typeof e == "string";
+}
+function Vn(e, t, o) {
+  return e === void 0 || Ln(e) ? t : {
+    ...t,
+    ownerState: {
+      ...t.ownerState,
+      ...o
+    }
+  };
+}
+function vt(e) {
+  var t, o, n = "";
+  if (typeof e == "string" || typeof e == "number") n += e;
+  else if (typeof e == "object") if (Array.isArray(e)) {
+    var r = e.length;
+    for (t = 0; t < r; t++) e[t] && (o = vt(e[t])) && (n && (n += " "), n += o);
+  } else for (o in e) e[o] && (n && (n += " "), n += o);
+  return n;
+}
+function et() {
+  for (var e, t, o = 0, n = "", r = arguments.length; o < r; o++) (e = arguments[o]) && (t = vt(e)) && (n && (n += " "), n += t);
+  return n;
+}
+function be(e, t = []) {
+  if (e === void 0)
+    return {};
+  const o = {};
+  return Object.keys(e).filter((n) => n.match(/^on[A-Z]/) && typeof e[n] == "function" && !t.includes(n)).forEach((n) => {
+    o[n] = e[n];
+  }), o;
+}
+function tt(e) {
+  if (e === void 0)
+    return {};
+  const t = {};
+  return Object.keys(e).filter((o) => !(o.match(/^on[A-Z]/) && typeof e[o] == "function")).forEach((o) => {
+    t[o] = e[o];
+  }), t;
+}
+function In(e) {
+  const {
+    getSlotProps: t,
+    additionalProps: o,
+    externalSlotProps: n,
+    externalForwardedProps: r,
+    className: s
+  } = e;
+  if (!t) {
+    const p = et(o == null ? void 0 : o.className, s, r == null ? void 0 : r.className, n == null ? void 0 : n.className), g = {
+      ...o == null ? void 0 : o.style,
+      ...r == null ? void 0 : r.style,
+      ...n == null ? void 0 : n.style
+    }, E = {
+      ...o,
+      ...r,
+      ...n
+    };
+    return p.length > 0 && (E.className = p), Object.keys(g).length > 0 && (E.style = g), {
+      props: E,
+      internalRef: void 0
+    };
+  }
+  const i = be({
+    ...r,
+    ...n
+  }), c = tt(n), l = tt(r), a = t(i), f = et(a == null ? void 0 : a.className, o == null ? void 0 : o.className, s, r == null ? void 0 : r.className, n == null ? void 0 : n.className), d = {
+    ...a == null ? void 0 : a.style,
+    ...o == null ? void 0 : o.style,
+    ...r == null ? void 0 : r.style,
+    ...n == null ? void 0 : n.style
+  }, h = {
+    ...a,
+    ...o,
+    ...l,
+    ...c
+  };
+  return f.length > 0 && (h.className = f), Object.keys(d).length > 0 && (h.style = d), {
+    props: h,
+    internalRef: a.ref
+  };
+}
+function Bn(e, t, o) {
+  return typeof e == "function" ? e(t, o) : e;
+}
+function xe(e) {
+  var d;
+  const {
+    elementType: t,
+    externalSlotProps: o,
+    ownerState: n,
+    skipResolvingSlotProps: r = !1,
+    ...s
+  } = e, i = r ? {} : Bn(o, n), {
+    props: c,
+    internalRef: l
+  } = In({
+    ...s,
+    externalSlotProps: i
+  }), a = ne(l, i == null ? void 0 : i.ref, (d = e.additionalProps) == null ? void 0 : d.ref);
+  return Vn(t, {
+    ...c,
+    ref: a
+  }, n);
+}
+function Rt(e) {
+  var t;
+  return parseInt(m.version, 10) >= 19 ? ((t = e == null ? void 0 : e.props) == null ? void 0 : t.ref) || null : (e == null ? void 0 : e.ref) || null;
+}
+function $n(e) {
+  return typeof e == "function" ? e() : e;
+}
+const se = /* @__PURE__ */ m.forwardRef(function(t, o) {
+  const {
+    children: n,
+    container: r,
+    disablePortal: s = !1
+  } = t, [i, c] = m.useState(null), l = ne(/* @__PURE__ */ m.isValidElement(n) ? Rt(n) : null, o);
+  if (ye(() => {
+    s || c($n(r) || document.body);
+  }, [r, s]), ye(() => {
+    if (i && !s)
+      return Je(o, i), () => {
+        Je(o, null);
+      };
+  }, [o, i, s]), s) {
+    if (/* @__PURE__ */ m.isValidElement(n)) {
+      const a = {
+        ref: l
+      };
+      return /* @__PURE__ */ m.cloneElement(n, a);
+    }
+    return n;
+  }
+  return i && /* @__PURE__ */ rt.createPortal(n, i);
+});
+process.env.NODE_ENV !== "production" && (se.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: u.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: u.oneOfType([ge, u.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: u.bool
+});
+process.env.NODE_ENV !== "production" && (se.propTypes = Et(se.propTypes));
+const _n = {
+  disableDefaultClasses: !1
+}, Tt = /* @__PURE__ */ m.createContext(_n);
+process.env.NODE_ENV !== "production" && (Tt.displayName = "ClassNameConfiguratorContext");
+function Be(e) {
+  const {
+    disableDefaultClasses: t
+  } = m.useContext(Tt);
+  return (o) => t ? "" : e(o);
+}
+function Wn(e) {
+  const {
+    rootElementName: t = "",
+    componentName: o
+  } = e, [n, r] = m.useState(t.toUpperCase());
+  process.env.NODE_ENV !== "production" && m.useEffect(() => {
+    t && n !== t.toUpperCase() && console.error(`useRootElementName: the \`rootElementName\` prop of ${o ? `the ${o} component` : "a component"} expected the '${t}' element, but a '${n.toLowerCase()}' was rendered instead`, "This may cause hydration issues in an SSR context, for example in a Next.js app");
+  }, [t, n, o]);
+  const s = m.useCallback((i) => {
+    r((i == null ? void 0 : i.tagName) ?? "");
+  }, []);
+  return [n, s];
+}
+const Nt = "base";
+function Un(e) {
+  return `${Nt}--${e}`;
+}
+function jn(e, t) {
+  return `${Nt}-${e}-${t}`;
+}
+function Ce(e, t) {
+  const o = Fn[t];
+  return o ? Un(o) : jn(e, t);
+}
+function $e(e, t) {
+  const o = {};
+  return t.forEach((n) => {
+    o[n] = Ce(e, n);
+  }), o;
+}
+const Ct = "Popup";
+function Kn(e) {
+  return Ce(Ct, e);
+}
+$e(Ct, ["root", "open"]);
+const Ot = /* @__PURE__ */ m.createContext(null);
+process.env.NODE_ENV !== "production" && (Ot.displayName = "TransitionContext");
+function qn(e) {
+  const [t, o] = m.useState(!0), n = m.useRef(!1), r = m.useRef(0), [s, i] = m.useState(!1), c = m.useRef(e);
+  m.useEffect(() => {
+    !e && // checking registeredTransitions.current instead of hasTransition to avoid this effect re-firing whenever hasTransition changes
+    r.current > 0 && // prevents waiting for a pending transition right after mounting
+    c.current !== e && (n.current = !0, o(!1)), c.current = e;
+  }, [e]);
+  const l = m.useCallback(() => {
+    n.current = !1, o(!0);
+  }, []), a = m.useCallback(() => (r.current += 1, i(!0), () => {
+    r.current -= 1, r.current === 0 && i(!1);
+  }), []);
+  let f;
+  return s ? e ? f = !1 : f = !n.current && t : f = !e, {
+    contextValue: m.useMemo(() => ({
+      requestedEnter: e,
+      onExited: l,
+      registerTransition: a,
+      hasExited: f
+    }), [l, e, a, f]),
+    hasExited: f
+  };
+}
+const Pt = /* @__PURE__ */ m.createContext(null);
+process.env.NODE_ENV !== "production" && (Pt.displayName = "PopupContext");
+function zn(e) {
+  const {
+    open: t
+  } = e;
+  return Ie({
+    root: ["root", t && "open"]
+  }, Be(Kn));
+}
+function Yn(e) {
+  return typeof e == "function" ? e() : e;
+}
+const Xn = /* @__PURE__ */ m.forwardRef(function(t, o) {
+  const {
+    anchor: n,
+    children: r,
+    container: s,
+    disablePortal: i = !1,
+    keepMounted: c = !1,
+    middleware: l,
+    offset: a = 0,
+    open: f = !1,
+    placement: d = "bottom",
+    slotProps: h = {},
+    slots: p = {},
+    strategy: g = "absolute",
+    ...E
+  } = t, {
+    refs: T,
+    elements: w,
+    floatingStyles: R,
+    update: x,
+    placement: N
+  } = Pn({
+    elements: {
+      reference: Yn(n)
+    },
+    open: f,
+    middleware: l ?? [Ge(a ?? 0), Sn(), An()],
+    placement: d,
+    strategy: g,
+    whileElementsMounted: c ? void 0 : Ye
+  }), v = ne(T.setFloating, o);
+  ye(() => {
+    if (c && f && w.reference && w.floating)
+      return Ye(w.reference, w.floating, x);
+  }, [c, f, w, x]);
+  const D = {
+    ...t,
+    disablePortal: i,
+    keepMounted: c,
+    offset: Ge,
+    open: f,
+    placement: d,
+    finalPlacement: N,
+    strategy: g
+  }, {
+    contextValue: S,
+    hasExited: M
+  } = qn(f), k = c && M ? "hidden" : void 0, L = zn(D), y = (p == null ? void 0 : p.root) ?? "div", b = xe({
+    elementType: y,
+    externalSlotProps: h.root,
+    externalForwardedProps: E,
+    ownerState: D,
+    className: L.root,
+    additionalProps: {
+      ref: v,
+      role: "tooltip",
+      style: {
+        ...R,
+        visibility: k
+      }
+    }
+  }), C = m.useMemo(() => ({
+    placement: N
+  }), [N]);
+  return c || !M ? /* @__PURE__ */ U(se, {
+    disablePortal: i,
+    container: s,
+    children: /* @__PURE__ */ U(Pt.Provider, {
+      value: C,
+      children: /* @__PURE__ */ U(Ot.Provider, {
+        value: S,
+        children: /* @__PURE__ */ U(y, {
+          ...b,
+          children: r
+        })
+      })
+    })
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (Xn.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * An HTML element, [virtual element](https://floating-ui.com/docs/virtual-elements),
+   * or a function that returns either.
+   * It's used to set the position of the popup.
+   */
+  anchor: u.oneOfType([ge, u.object, u.func]),
+  /**
+   * @ignore
+   */
+  children: u.oneOfType([u.node, u.func]),
+  /**
+   * An HTML element or function that returns one. The container will have the portal children appended to it.
+   * By default, it uses the body of the top-level document object, so it's `document.body` in these cases.
+   */
+  container: u.oneOfType([ge, u.func]),
+  /**
+   * If `true`, the popup will be rendered where it is defined, without the use of portals.
+   * @default false
+   */
+  disablePortal: u.bool,
+  /**
+   * If `true`, the popup will exist in the DOM even if it's closed.
+   * Its visibility will be controlled by the `visibility` CSS property.
+   *
+   * Otherwise, a closed popup will be removed from the DOM.
+   *
+   * @default false
+   */
+  keepMounted: u.bool,
+  /**
+   * Collection of Floating UI middleware to use when positioning the popup.
+   * If not provided, the [`offset`](https://floating-ui.com/docs/offset)
+   * and [`flip`](https://floating-ui.com/docs/flip) functions will be used.
+   *
+   * @see https://floating-ui.com/docs/computePosition#middleware
+   */
+  middleware: u.arrayOf(u.oneOfType([u.oneOf([!1]), u.shape({
+    fn: u.func.isRequired,
+    name: u.string.isRequired,
+    options: u.any
+  })])),
+  /**
+   * Distance between a popup and the trigger element.
+   * This prop is ignored when custom `middleware` is provided.
+   *
+   * @default 0
+   * @see https://floating-ui.com/docs/offset
+   */
+  offset: u.oneOfType([u.func, u.number, u.shape({
+    alignmentAxis: u.number,
+    crossAxis: u.number,
+    mainAxis: u.number
+  })]),
+  /**
+   * If `true`, the popup is visible.
+   *
+   * @default false
+   */
+  open: u.bool,
+  /**
+   * Determines where to place the popup relative to the trigger element.
+   *
+   * @default 'bottom'
+   * @see https://floating-ui.com/docs/computePosition#placement
+   */
+  placement: u.oneOf(["bottom-end", "bottom-start", "bottom", "left-end", "left-start", "left", "right-end", "right-start", "right", "top-end", "top-start", "top"]),
+  /**
+   * The props used for each slot inside the Popup.
+   *
+   * @default {}
+   */
+  slotProps: u.shape({
+    root: u.oneOfType([u.func, u.object])
+  }),
+  /**
+   * The components used for each slot inside the Popup.
+   * Either a string to use a HTML element or a component.
+   *
+   * @default {}
+   */
+  slots: u.shape({
+    root: u.elementType
+  }),
+  /**
+   * The type of CSS position property to use (absolute or fixed).
+   *
+   * @default 'absolute'
+   * @see https://floating-ui.com/docs/computePosition#strategy
+   */
+  strategy: u.oneOf(["absolute", "fixed"])
+});
+function Gn(e) {
+  const t = Q(e);
+  return t.body === e ? he(e).innerWidth > t.documentElement.clientWidth : e.scrollHeight > e.clientHeight;
+}
+function oe(e, t) {
+  t ? e.setAttribute("aria-hidden", "true") : e.removeAttribute("aria-hidden");
+}
+function nt(e) {
+  return parseInt(he(e).getComputedStyle(e).paddingRight, 10) || 0;
+}
+function Zn(e) {
+  const o = ["TEMPLATE", "SCRIPT", "STYLE", "LINK", "MAP", "META", "NOSCRIPT", "PICTURE", "COL", "COLGROUP", "PARAM", "SLOT", "SOURCE", "TRACK"].includes(e.tagName), n = e.tagName === "INPUT" && e.getAttribute("type") === "hidden";
+  return o || n;
+}
+function ot(e, t, o, n, r) {
+  const s = [t, o, ...n];
+  [].forEach.call(e.children, (i) => {
+    const c = !s.includes(i), l = !Zn(i);
+    c && l && oe(i, r);
+  });
+}
+function Ae(e, t) {
+  let o = -1;
+  return e.some((n, r) => t(n) ? (o = r, !0) : !1), o;
+}
+function Jn(e, t) {
+  const o = [], n = e.container;
+  if (!t.disableScrollLock) {
+    if (Gn(n)) {
+      const i = Mn(he(n));
+      o.push({
+        value: n.style.paddingRight,
+        property: "padding-right",
+        el: n
+      }), n.style.paddingRight = `${nt(n) + i}px`;
+      const c = Q(n).querySelectorAll(".mui-fixed");
+      [].forEach.call(c, (l) => {
+        o.push({
+          value: l.style.paddingRight,
+          property: "padding-right",
+          el: l
+        }), l.style.paddingRight = `${nt(l) + i}px`;
+      });
+    }
+    let s;
+    if (n.parentNode instanceof DocumentFragment)
+      s = Q(n).body;
+    else {
+      const i = n.parentElement, c = he(n);
+      s = (i == null ? void 0 : i.nodeName) === "HTML" && c.getComputedStyle(i).overflowY === "scroll" ? i : n;
+    }
+    o.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 () => {
+    o.forEach(({
+      value: s,
+      el: i,
+      property: c
+    }) => {
+      s ? i.style.setProperty(c, s) : i.style.removeProperty(c);
+    });
+  };
+}
+function Qn(e) {
+  const t = [];
+  return [].forEach.call(e.children, (o) => {
+    o.getAttribute("aria-hidden") === "true" && t.push(o);
+  }), t;
+}
+class Hn {
+  constructor() {
+    this.modals = [], this.containers = [];
+  }
+  add(t, o) {
+    let n = this.modals.indexOf(t);
+    if (n !== -1)
+      return n;
+    n = this.modals.length, this.modals.push(t), t.modalRef && oe(t.modalRef, !1);
+    const r = Qn(o);
+    ot(o, t.mount, t.modalRef, r, !0);
+    const s = Ae(this.containers, (i) => i.container === o);
+    return s !== -1 ? (this.containers[s].modals.push(t), n) : (this.containers.push({
+      modals: [t],
+      container: o,
+      restore: null,
+      hiddenSiblings: r
+    }), n);
+  }
+  mount(t, o) {
+    const n = Ae(this.containers, (s) => s.modals.includes(t)), r = this.containers[n];
+    r.restore || (r.restore = Jn(r, o));
+  }
+  remove(t, o = !0) {
+    const n = this.modals.indexOf(t);
+    if (n === -1)
+      return n;
+    const r = Ae(this.containers, (i) => i.modals.includes(t)), s = this.containers[r];
+    if (s.modals.splice(s.modals.indexOf(t), 1), this.modals.splice(n, 1), s.modals.length === 0)
+      s.restore && s.restore(), t.modalRef && oe(t.modalRef, o), ot(s.container, t.mount, t.modalRef, s.hiddenSiblings, !1), this.containers.splice(r, 1);
+    else {
+      const i = s.modals[s.modals.length - 1];
+      i.modalRef && oe(i.modalRef, !1);
+    }
+    return n;
+  }
+  isTopModal(t) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === t;
+  }
+}
+function eo(e) {
+  return typeof e == "function" ? e() : e;
+}
+function to(e) {
+  return e ? e.props.hasOwnProperty("in") : !1;
+}
+const no = new Hn();
+function oo(e) {
+  const {
+    container: t,
+    disableEscapeKeyDown: o = !1,
+    disableScrollLock: n = !1,
+    // @ts-ignore internal logic - Base UI supports the manager as a prop too
+    manager: r = no,
+    closeAfterTransition: s = !1,
+    onTransitionEnter: i,
+    onTransitionExited: c,
+    children: l,
+    onClose: a,
+    open: f,
+    rootRef: d
+  } = e, h = m.useRef({}), p = m.useRef(null), g = m.useRef(null), E = ne(g, d), [T, w] = m.useState(!f), R = to(l);
+  let x = !0;
+  (e["aria-hidden"] === "false" || e["aria-hidden"] === !1) && (x = !1);
+  const N = () => Q(p.current), v = () => (h.current.modalRef = g.current, h.current.mount = p.current, h.current), D = () => {
+    r.mount(v(), {
+      disableScrollLock: n
+    }), g.current && (g.current.scrollTop = 0);
+  }, S = Qe(() => {
+    const P = eo(t) || N().body;
+    r.add(v(), P), g.current && D();
+  }), M = m.useCallback(() => r.isTopModal(v()), [r]), k = Qe((P) => {
+    p.current = P, P && (f && M() ? D() : g.current && oe(g.current, x));
+  }), L = m.useCallback(() => {
+    r.remove(v(), x);
+  }, [x, r]);
+  m.useEffect(() => () => {
+    L();
+  }, [L]), m.useEffect(() => {
+    f ? S() : (!R || !s) && L();
+  }, [f, L, R, s, S]);
+  const y = (P) => (A) => {
+    var O;
+    (O = P.onKeyDown) == null || O.call(P, A), !(A.key !== "Escape" || A.which === 229 || // Wait until IME is settled.
+    !M()) && (o || (A.stopPropagation(), a && a(A, "escapeKeyDown")));
+  }, b = (P) => (A) => {
+    var O;
+    (O = P.onClick) == null || O.call(P, A), A.target === A.currentTarget && a && a(A, "backdropClick");
+  };
+  return {
+    getRootProps: (P = {}) => {
+      const A = be(e);
+      delete A.onTransitionEnter, delete A.onTransitionExited;
+      const O = {
+        ...A,
+        ...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: y(O),
+        ref: E
+      };
+    },
+    getBackdropProps: (P = {}) => {
+      const A = P;
+      return {
+        "aria-hidden": !0,
+        ...A,
+        onClick: b(A),
+        open: f
+      };
+    },
+    getTransitionProps: () => {
+      const P = () => {
+        w(!1), i && i();
+      }, A = () => {
+        w(!0), c && c(), s && L();
+      };
+      return {
+        onEnter: Ze(P, l == null ? void 0 : l.props.onEnter),
+        onExited: Ze(A, l == null ? void 0 : l.props.onExited)
+      };
+    },
+    rootRef: E,
+    portalRef: k,
+    isTopModal: M,
+    exited: T,
+    hasTransition: R
+  };
+}
+const ro = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])'].join(",");
+function so(e) {
+  const t = parseInt(e.getAttribute("tabindex") || "", 10);
+  return Number.isNaN(t) ? e.contentEditable === "true" || (e.nodeName === "AUDIO" || e.nodeName === "VIDEO" || e.nodeName === "DETAILS") && e.getAttribute("tabindex") === null ? 0 : e.tabIndex : t;
+}
+function io(e) {
+  if (e.tagName !== "INPUT" || e.type !== "radio" || !e.name)
+    return !1;
+  const t = (n) => e.ownerDocument.querySelector(`input[type="radio"]${n}`);
+  let o = t(`[name="${e.name}"]:checked`);
+  return o || (o = t(`[name="${e.name}"]`)), o !== e;
+}
+function co(e) {
+  return !(e.disabled || e.tagName === "INPUT" && e.type === "hidden" || io(e));
+}
+function lo(e) {
+  const t = [], o = [];
+  return Array.from(e.querySelectorAll(ro)).forEach((n, r) => {
+    const s = so(n);
+    s === -1 || !co(n) || (s === 0 ? t.push(n) : o.push({
+      documentOrder: r,
+      tabIndex: s,
+      node: n
+    }));
+  }), o.sort((n, r) => n.tabIndex === r.tabIndex ? n.documentOrder - r.documentOrder : n.tabIndex - r.tabIndex).map((n) => n.node).concat(t);
+}
+function ao() {
+  return !0;
+}
+function we(e) {
+  const {
+    children: t,
+    disableAutoFocus: o = !1,
+    disableEnforceFocus: n = !1,
+    disableRestoreFocus: r = !1,
+    getTabbable: s = lo,
+    isEnabled: i = ao,
+    open: c
+  } = e, l = m.useRef(!1), a = m.useRef(null), f = m.useRef(null), d = m.useRef(null), h = m.useRef(null), p = m.useRef(!1), g = m.useRef(null), E = ne(Rt(t), g), T = m.useRef(null);
+  m.useEffect(() => {
+    !c || !g.current || (p.current = !o);
+  }, [o, c]), m.useEffect(() => {
+    if (!c || !g.current)
+      return;
+    const x = Q(g.current);
+    return g.current.contains(x.activeElement) || (g.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(`
+`)), g.current.setAttribute("tabIndex", "-1")), p.current && g.current.focus()), () => {
+      r || (d.current && d.current.focus && (l.current = !0, d.current.focus()), d.current = null);
+    };
+  }, [c]), m.useEffect(() => {
+    if (!c || !g.current)
+      return;
+    const x = Q(g.current), N = (S) => {
+      T.current = S, !(n || !i() || S.key !== "Tab") && x.activeElement === g.current && S.shiftKey && (l.current = !0, f.current && f.current.focus());
+    }, v = () => {
+      var k, L;
+      const S = g.current;
+      if (S === null)
+        return;
+      if (!x.hasFocus() || !i() || l.current) {
+        l.current = !1;
+        return;
+      }
+      if (S.contains(x.activeElement) || n && x.activeElement !== a.current && x.activeElement !== f.current)
+        return;
+      if (x.activeElement !== h.current)
+        h.current = null;
+      else if (h.current !== null)
+        return;
+      if (!p.current)
+        return;
+      let M = [];
+      if ((x.activeElement === a.current || x.activeElement === f.current) && (M = s(g.current)), M.length > 0) {
+        const y = !!((k = T.current) != null && k.shiftKey && ((L = T.current) == null ? void 0 : L.key) === "Tab"), b = M[0], C = M[M.length - 1];
+        typeof b != "string" && typeof C != "string" && (y ? C.focus() : b.focus());
+      } else
+        S.focus();
+    };
+    x.addEventListener("focusin", v), x.addEventListener("keydown", N, !0);
+    const D = setInterval(() => {
+      x.activeElement && x.activeElement.tagName === "BODY" && v();
+    }, 50);
+    return () => {
+      clearInterval(D), x.removeEventListener("focusin", v), x.removeEventListener("keydown", N, !0);
+    };
+  }, [o, n, r, i, c, s]);
+  const w = (x) => {
+    d.current === null && (d.current = x.relatedTarget), p.current = !0, h.current = x.target;
+    const N = t.props.onFocus;
+    N && N(x);
+  }, R = (x) => {
+    d.current === null && (d.current = x.relatedTarget), p.current = !0;
+  };
+  return /* @__PURE__ */ st(m.Fragment, {
+    children: [/* @__PURE__ */ U("div", {
+      tabIndex: c ? 0 : -1,
+      onFocus: R,
+      ref: a,
+      "data-testid": "sentinelStart"
+    }), /* @__PURE__ */ m.cloneElement(t, {
+      ref: E,
+      onFocus: w
+    }), /* @__PURE__ */ U("div", {
+      tabIndex: c ? 0 : -1,
+      onFocus: R,
+      ref: f,
+      "data-testid": "sentinelEnd"
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (we.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: Ve,
+  /**
+   * 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: u.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: u.bool,
+  /**
+   * If `true`, the focus trap will not restore focus to previously focused element once
+   * focus trap is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: u.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: u.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: u.func,
+  /**
+   * If `true`, focus is locked.
+   */
+  open: u.bool.isRequired
+});
+process.env.NODE_ENV !== "production" && (we.propTypes = Et(we.propTypes));
+const At = "Modal";
+function uo(e) {
+  return Ce(At, e);
+}
+$e(At, ["root", "hidden", "backdrop"]);
+const fo = (e) => {
+  const {
+    open: t,
+    exited: o
+  } = e;
+  return Ie({
+    root: ["root", !t && o && "hidden"],
+    backdrop: ["backdrop"]
+  }, Be(uo));
+}, po = /* @__PURE__ */ m.forwardRef(function(t, o) {
+  const {
+    children: n,
+    closeAfterTransition: r = !1,
+    container: s,
+    disableAutoFocus: i = !1,
+    disableEnforceFocus: c = !1,
+    disableEscapeKeyDown: l = !1,
+    disablePortal: a = !1,
+    disableRestoreFocus: f = !1,
+    disableScrollLock: d = !1,
+    hideBackdrop: h = !1,
+    keepMounted: p = !1,
+    onBackdropClick: g,
+    onClose: E,
+    onKeyDown: T,
+    open: w,
+    onTransitionEnter: R,
+    onTransitionExited: x,
+    slotProps: N = {},
+    slots: v = {},
+    ...D
+  } = t, S = {
+    ...t,
+    closeAfterTransition: r,
+    disableAutoFocus: i,
+    disableEnforceFocus: c,
+    disableEscapeKeyDown: l,
+    disablePortal: a,
+    disableRestoreFocus: f,
+    disableScrollLock: d,
+    hideBackdrop: h,
+    keepMounted: p
+  }, {
+    getRootProps: M,
+    getBackdropProps: k,
+    getTransitionProps: L,
+    portalRef: y,
+    isTopModal: b,
+    exited: C,
+    hasTransition: F
+  } = oo({
+    ...S,
+    rootRef: o
+  }), B = {
+    ...S,
+    exited: C,
+    hasTransition: F
+  }, P = fo(B), A = {};
+  if (n.props.tabIndex === void 0 && (A.tabIndex = "-1"), F) {
+    const {
+      onEnter: X,
+      onExited: ce
+    } = L();
+    A.onEnter = X, A.onExited = ce;
+  }
+  const O = v.root ?? "div", V = xe({
+    elementType: O,
+    externalSlotProps: N.root,
+    externalForwardedProps: D,
+    getSlotProps: M,
+    className: P.root,
+    ownerState: B
+  }), $ = v.backdrop, kt = xe({
+    elementType: $,
+    externalSlotProps: N.backdrop,
+    getSlotProps: (X) => k({
+      ...X,
+      onClick: (ce) => {
+        g && g(ce), X != null && X.onClick && X.onClick(ce);
+      }
+    }),
+    className: P.backdrop,
+    ownerState: B
+  });
+  return !p && !w && (!F || C) ? null : /* @__PURE__ */ U(se, {
+    ref: y,
+    container: s,
+    disablePortal: a,
+    children: /* @__PURE__ */ st(O, {
+      ...V,
+      children: [!h && $ ? /* @__PURE__ */ U($, {
+        ...kt
+      }) : null, /* @__PURE__ */ U(we, {
+        disableEnforceFocus: c,
+        disableAutoFocus: i,
+        disableRestoreFocus: f,
+        isEnabled: b,
+        open: w,
+        children: /* @__PURE__ */ m.cloneElement(n, A)
+      })]
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (po.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: Ve.isRequired,
+  /**
+   * When set to true the Modal waits until a nested Transition is completed before closing.
+   * @default false
+   */
+  closeAfterTransition: u.bool,
+  /**
+   * 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: u.oneOfType([ge, u.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: u.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: u.bool,
+  /**
+   * If `true`, hitting escape will not fire the `onClose` callback.
+   * @default false
+   */
+  disableEscapeKeyDown: u.bool,
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: u.bool,
+  /**
+   * If `true`, the modal will not restore focus to previously focused element once
+   * modal is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: u.bool,
+  /**
+   * Disable the scroll lock behavior.
+   * @default false
+   */
+  disableScrollLock: u.bool,
+  /**
+   * If `true`, the backdrop is not rendered.
+   * @default false
+   */
+  hideBackdrop: u.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: u.bool,
+  /**
+   * Callback fired when the backdrop is clicked.
+   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
+   */
+  onBackdropClick: u.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: u.func,
+  /**
+   * A function called when a transition enters.
+   */
+  onTransitionEnter: u.func,
+  /**
+   * A function called when a transition has exited.
+   */
+  onTransitionExited: u.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: u.bool.isRequired,
+  /**
+   * The props used for each slot inside the Modal.
+   * @default {}
+   */
+  slotProps: u.shape({
+    backdrop: u.oneOfType([u.func, u.object]),
+    root: u.oneOfType([u.func, u.object])
+  }),
+  /**
+   * The components used for each slot inside the Modal.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: u.shape({
+    backdrop: u.elementType,
+    root: u.elementType
+  })
+});
+const St = "Button";
+function mo(e) {
+  return Ce(St, e);
+}
+$e(St, ["root", "active", "disabled", "focusVisible"]);
+function go(e = {}) {
+  const {
+    disabled: t = !1,
+    focusableWhenDisabled: o,
+    href: n,
+    rootRef: r,
+    tabIndex: s,
+    to: i,
+    type: c,
+    rootElementName: l
+  } = e, a = m.useRef(null), [f, d] = m.useState(!1), [h, p] = m.useState(!1);
+  t && !o && h && p(!1);
+  const [g, E] = Wn({
+    rootElementName: l ?? (n || i ? "a" : void 0),
+    componentName: "Button"
+  }), T = (y) => (b) => {
+    var C;
+    h && b.preventDefault(), (C = y.onMouseLeave) == null || C.call(y, b);
+  }, w = (y) => (b) => {
+    var C;
+    He(b.target) || p(!1), (C = y.onBlur) == null || C.call(y, b);
+  }, R = (y) => (b) => {
+    var C, F;
+    a.current || (a.current = b.currentTarget), He(b.target) && (p(!0), (C = y.onFocusVisible) == null || C.call(y, b)), (F = y.onFocus) == null || F.call(y, b);
+  }, x = () => {
+    const y = a.current;
+    return g === "BUTTON" || g === "INPUT" && ["button", "submit", "reset"].includes(y == null ? void 0 : y.type) || g === "A" && (y == null ? void 0 : y.href);
+  }, N = (y) => (b) => {
+    var C;
+    t || (C = y.onClick) == null || C.call(y, b);
+  }, v = (y) => (b) => {
+    var C;
+    t || (d(!0), document.addEventListener("mouseup", () => {
+      d(!1);
+    }, {
+      once: !0
+    })), (C = y.onMouseDown) == null || C.call(y, b);
+  }, D = (y) => (b) => {
+    var C, F;
+    (C = y.onKeyDown) == null || C.call(y, b), !b.defaultMuiPrevented && (b.target === b.currentTarget && !x() && b.key === " " && b.preventDefault(), b.target === b.currentTarget && b.key === " " && !t && d(!0), b.target === b.currentTarget && !x() && b.key === "Enter" && !t && ((F = y.onClick) == null || F.call(y, b), b.preventDefault()));
+  }, S = (y) => (b) => {
+    var C, F;
+    b.target === b.currentTarget && d(!1), (C = y.onKeyUp) == null || C.call(y, b), b.target === b.currentTarget && !x() && !t && b.key === " " && !b.defaultMuiPrevented && ((F = y.onClick) == null || F.call(y, b));
+  }, M = ne(E, r, a), k = {};
+  return s !== void 0 && (k.tabIndex = s), g === "BUTTON" ? (k.type = c ?? "button", o ? k["aria-disabled"] = t : k.disabled = t) : g === "INPUT" ? c && ["button", "submit", "reset"].includes(c) && (o ? k["aria-disabled"] = t : k.disabled = t) : g !== "" && (!n && !i && (k.role = "button", k.tabIndex = s ?? 0), t && (k["aria-disabled"] = t, k.tabIndex = o ? s ?? 0 : -1)), {
+    getRootProps: (y = {}) => {
+      const b = {
+        ...be(e),
+        ...be(y)
+      }, C = {
+        type: c,
+        ...b,
+        ...k,
+        ...y,
+        onBlur: w(b),
+        onClick: N(b),
+        onFocus: R(b),
+        onKeyDown: D(b),
+        onKeyUp: S(b),
+        onMouseDown: v(b),
+        onMouseLeave: T(b),
+        ref: M
+      };
+      return delete C.onFocusVisible, C;
+    },
+    focusVisible: h,
+    setFocusVisible: p,
+    active: f,
+    rootRef: M
+  };
+}
+const ho = (e) => {
+  const {
+    active: t,
+    disabled: o,
+    focusVisible: n
+  } = e;
+  return Ie({
+    root: ["root", o && "disabled", n && "focusVisible", t && "active"]
+  }, Be(mo));
+}, yo = /* @__PURE__ */ m.forwardRef(function(t, o) {
+  const {
+    action: n,
+    children: r,
+    disabled: s,
+    focusableWhenDisabled: i = !1,
+    onFocusVisible: c,
+    slotProps: l = {},
+    slots: a = {},
+    rootElementName: f = "button",
+    ...d
+  } = t, h = m.useRef(null);
+  let p = f;
+  typeof a.root == "string" ? p = a.root : (d.href || d.to) && (p = "a");
+  const {
+    active: g,
+    focusVisible: E,
+    setFocusVisible: T,
+    getRootProps: w
+  } = go({
+    ...t,
+    focusableWhenDisabled: i,
+    rootElementName: p
+  });
+  m.useImperativeHandle(n, () => ({
+    focusVisible: () => {
+      T(!0), h.current.focus();
+    }
+  }), [T]);
+  const R = {
+    ...t,
+    active: g,
+    focusableWhenDisabled: i,
+    focusVisible: E
+  }, x = ho(R), N = d.href || d.to ? "a" : "button", v = a.root ?? N, D = xe({
+    elementType: v,
+    getSlotProps: w,
+    externalForwardedProps: d,
+    externalSlotProps: l.root,
+    additionalProps: {
+      ref: o
+    },
+    ownerState: R,
+    className: x.root
+  });
+  return /* @__PURE__ */ U(v, {
+    ...D,
+    children: r
+  });
+});
+process.env.NODE_ENV !== "production" && (yo.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A ref for imperative actions. It currently only supports `focusVisible()` action.
+   */
+  action: u.oneOfType([u.func, u.shape({
+    current: u.shape({
+      focusVisible: u.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  children: u.node,
+  /**
+   * @ignore
+   */
+  className: u.string,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: u.bool,
+  /**
+   * If `true`, allows a disabled button to receive focus.
+   * @default false
+   */
+  focusableWhenDisabled: u.bool,
+  /**
+   * @ignore
+   */
+  href: u.string,
+  /**
+   * @ignore
+   */
+  onFocusVisible: u.func,
+  /**
+   * The HTML element that is ultimately rendered, for example 'button' or 'a'
+   * @default 'button'
+   */
+  rootElementName: u.string,
+  /**
+   * The props used for each slot inside the Button.
+   * @default {}
+   */
+  slotProps: u.shape({
+    root: u.oneOfType([u.func, u.object])
+  }),
+  /**
+   * The components used for each slot inside the Button.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: u.shape({
+    root: u.elementType
+  }),
+  /**
+   * @ignore
+   */
+  to: u.string
+});
+export {
+  yo as B,
+  po as M,
+  Xn as P
+};