@tencentcloud/chat-uikit-react 3.0.3 → 3.4.2

package/dist/external_modules/mui-BhvHeL5-.js

@@ -0,0 +1,2253 @@
+import * as m from "react";
+import { useLayoutEffect as kt } from "react";
+import { P as p } from "./react-vendors-3raCpd-g.js";
+import * as et from "react-dom";
+import { jsx as K, jsxs as tt } from "react/jsx-runtime";
+const ue = Math.min, Y = Math.max, fe = Math.round, le = Math.floor, H = (e) => ({
+  x: e,
+  y: e
+}), Mt = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Lt = {
+  start: "end",
+  end: "start"
+};
+function Ie(e, t, o) {
+  return Y(e, ue(t, o));
+}
+function xe(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function G(e) {
+  return e.split("-")[0];
+}
+function we(e) {
+  return e.split("-")[1];
+}
+function nt(e) {
+  return e === "x" ? "y" : "x";
+}
+function ot(e) {
+  return e === "y" ? "height" : "width";
+}
+const Dt = /* @__PURE__ */ new Set(["top", "bottom"]);
+function z(e) {
+  return Dt.has(G(e)) ? "y" : "x";
+}
+function rt(e) {
+  return nt(z(e));
+}
+function Ft(e, t, o) {
+  o === void 0 && (o = !1);
+  const n = we(e), r = rt(e), i = ot(r);
+  let s = r === "x" ? n === (o ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return t.reference[i] > t.floating[i] && (s = de(s)), [s, de(s)];
+}
+function It(e) {
+  const t = de(e);
+  return [Ae(e), t, Ae(t)];
+}
+function Ae(e) {
+  return e.replace(/start|end/g, (t) => Lt[t]);
+}
+const Ve = ["left", "right"], $e = ["right", "left"], Vt = ["top", "bottom"], $t = ["bottom", "top"];
+function Bt(e, t, o) {
+  switch (e) {
+    case "top":
+    case "bottom":
+      return o ? t ? $e : Ve : t ? Ve : $e;
+    case "left":
+    case "right":
+      return t ? Vt : $t;
+    default:
+      return [];
+  }
+}
+function _t(e, t, o, n) {
+  const r = we(e);
+  let i = Bt(G(e), o === "start", n);
+  return r && (i = i.map((s) => s + "-" + r), t && (i = i.concat(i.map(Ae)))), i;
+}
+function de(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Mt[t]);
+}
+function Wt(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function Ht(e) {
+  return typeof e != "number" ? Wt(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 Be(e, t, o) {
+  let {
+    reference: n,
+    floating: r
+  } = e;
+  const i = z(t), s = rt(t), c = ot(s), l = G(t), a = i === "y", u = n.x + n.width / 2 - r.width / 2, f = n.y + n.height / 2 - r.height / 2, g = n[c] / 2 - r[c] / 2;
+  let d;
+  switch (l) {
+    case "top":
+      d = {
+        x: u,
+        y: n.y - r.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: u,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      d = {
+        x: n.x + n.width,
+        y: f
+      };
+      break;
+    case "left":
+      d = {
+        x: n.x - r.width,
+        y: f
+      };
+      break;
+    default:
+      d = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (we(t)) {
+    case "start":
+      d[s] -= g * (o && a ? -1 : 1);
+      break;
+    case "end":
+      d[s] += g * (o && a ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const jt = async (e, t, o) => {
+  const {
+    placement: n = "bottom",
+    strategy: r = "absolute",
+    middleware: i = [],
+    platform: s
+  } = o, c = i.filter(Boolean), l = await (s.isRTL == null ? void 0 : s.isRTL(t));
+  let a = await s.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: r
+  }), {
+    x: u,
+    y: f
+  } = Be(a, n, l), g = n, d = {}, h = 0;
+  for (let x = 0; x < c.length; x++) {
+    const {
+      name: R,
+      fn: b
+    } = c[x], {
+      x: v,
+      y,
+      data: T,
+      reset: w
+    } = await b({
+      x: u,
+      y: f,
+      initialPlacement: n,
+      placement: g,
+      strategy: r,
+      middlewareData: d,
+      rects: a,
+      platform: s,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    u = v ?? u, f = y ?? f, d = {
+      ...d,
+      [R]: {
+        ...d[R],
+        ...T
+      }
+    }, w && h <= 50 && (h++, typeof w == "object" && (w.placement && (g = w.placement), w.rects && (a = w.rects === !0 ? await s.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: r
+    }) : w.rects), {
+      x: u,
+      y: f
+    } = Be(a, g, l)), x = -1);
+  }
+  return {
+    x: u,
+    y: f,
+    placement: g,
+    strategy: r,
+    middlewareData: d
+  };
+};
+async function it(e, t) {
+  var o;
+  t === void 0 && (t = {});
+  const {
+    x: n,
+    y: r,
+    platform: i,
+    rects: s,
+    elements: c,
+    strategy: l
+  } = e, {
+    boundary: a = "clippingAncestors",
+    rootBoundary: u = "viewport",
+    elementContext: f = "floating",
+    altBoundary: g = !1,
+    padding: d = 0
+  } = xe(t, e), h = Ht(d), R = c[g ? f === "floating" ? "reference" : "floating" : f], b = pe(await i.getClippingRect({
+    element: (o = await (i.isElement == null ? void 0 : i.isElement(R))) == null || o ? R : R.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(c.floating)),
+    boundary: a,
+    rootBoundary: u,
+    strategy: l
+  })), v = f === "floating" ? {
+    x: n,
+    y: r,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, y = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(c.floating)), T = await (i.isElement == null ? void 0 : i.isElement(y)) ? await (i.getScale == null ? void 0 : i.getScale(y)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, w = pe(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: v,
+    offsetParent: y,
+    strategy: l
+  }) : v);
+  return {
+    top: (b.top - w.top + h.top) / T.y,
+    bottom: (w.bottom - b.bottom + h.bottom) / T.y,
+    left: (b.left - w.left + h.left) / T.x,
+    right: (w.right - b.right + h.right) / T.x
+  };
+}
+const Ut = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var o, n;
+      const {
+        placement: r,
+        middlewareData: i,
+        rects: s,
+        initialPlacement: c,
+        platform: l,
+        elements: a
+      } = t, {
+        mainAxis: u = !0,
+        crossAxis: f = !0,
+        fallbackPlacements: g,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: h = "none",
+        flipAlignment: x = !0,
+        ...R
+      } = xe(e, t);
+      if ((o = i.arrow) != null && o.alignmentOffset)
+        return {};
+      const b = G(r), v = z(c), y = G(c) === c, T = await (l.isRTL == null ? void 0 : l.isRTL(a.floating)), w = g || (y || !x ? [de(c)] : It(c)), P = h !== "none";
+      !g && P && w.push(..._t(c, x, h, T));
+      const S = [c, ...w], A = await it(t, R), L = [];
+      let N = ((n = i.flip) == null ? void 0 : n.overflows) || [];
+      if (u && L.push(A[b]), f) {
+        const M = Ft(r, s, T);
+        L.push(A[M[0]], A[M[1]]);
+      }
+      if (N = [...N, {
+        placement: r,
+        overflows: L
+      }], !L.every((M) => M <= 0)) {
+        var D, I;
+        const M = (((D = i.flip) == null ? void 0 : D.index) || 0) + 1, $ = S[M];
+        if ($ && (!(f === "alignment" ? v !== z($) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        N.every((E) => z(E.placement) === v ? E.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: M,
+              overflows: N
+            },
+            reset: {
+              placement: $
+            }
+          };
+        let C = (I = N.filter((O) => O.overflows[0] <= 0).sort((O, E) => O.overflows[1] - E.overflows[1])[0]) == null ? void 0 : I.placement;
+        if (!C)
+          switch (d) {
+            case "bestFit": {
+              var k;
+              const O = (k = N.filter((E) => {
+                if (P) {
+                  const F = z(E.placement);
+                  return F === v || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  F === "y";
+                }
+                return !0;
+              }).map((E) => [E.placement, E.overflows.filter((F) => F > 0).reduce((F, B) => F + B, 0)]).sort((E, F) => E[1] - F[1])[0]) == null ? void 0 : k[0];
+              O && (C = O);
+              break;
+            }
+            case "initialPlacement":
+              C = c;
+              break;
+          }
+        if (r !== C)
+          return {
+            reset: {
+              placement: C
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, Kt = /* @__PURE__ */ new Set(["left", "top"]);
+async function zt(e, t) {
+  const {
+    placement: o,
+    platform: n,
+    elements: r
+  } = e, i = await (n.isRTL == null ? void 0 : n.isRTL(r.floating)), s = G(o), c = we(o), l = z(o) === "y", a = Kt.has(s) ? -1 : 1, u = i && l ? -1 : 1, f = xe(t, e);
+  let {
+    mainAxis: g,
+    crossAxis: d,
+    alignmentAxis: h
+  } = typeof f == "number" ? {
+    mainAxis: f,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: f.mainAxis || 0,
+    crossAxis: f.crossAxis || 0,
+    alignmentAxis: f.alignmentAxis
+  };
+  return c && typeof h == "number" && (d = c === "end" ? h * -1 : h), l ? {
+    x: d * u,
+    y: g * a
+  } : {
+    x: g * a,
+    y: d * u
+  };
+}
+const qt = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var o, n;
+      const {
+        x: r,
+        y: i,
+        placement: s,
+        middlewareData: c
+      } = t, l = await zt(t, e);
+      return s === ((o = c.offset) == null ? void 0 : o.placement) && (n = c.arrow) != null && n.alignmentOffset ? {} : {
+        x: r + l.x,
+        y: i + l.y,
+        data: {
+          ...l,
+          placement: s
+        }
+      };
+    }
+  };
+}, Xt = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: o,
+        y: n,
+        placement: r
+      } = t, {
+        mainAxis: i = !0,
+        crossAxis: s = !1,
+        limiter: c = {
+          fn: (R) => {
+            let {
+              x: b,
+              y: v
+            } = R;
+            return {
+              x: b,
+              y: v
+            };
+          }
+        },
+        ...l
+      } = xe(e, t), a = {
+        x: o,
+        y: n
+      }, u = await it(t, l), f = z(G(r)), g = nt(f);
+      let d = a[g], h = a[f];
+      if (i) {
+        const R = g === "y" ? "top" : "left", b = g === "y" ? "bottom" : "right", v = d + u[R], y = d - u[b];
+        d = Ie(v, d, y);
+      }
+      if (s) {
+        const R = f === "y" ? "top" : "left", b = f === "y" ? "bottom" : "right", v = h + u[R], y = h - u[b];
+        h = Ie(v, h, y);
+      }
+      const x = c.fn({
+        ...t,
+        [g]: d,
+        [f]: h
+      });
+      return {
+        ...x,
+        data: {
+          x: x.x - o,
+          y: x.y - n,
+          enabled: {
+            [g]: i,
+            [f]: s
+          }
+        }
+      };
+    }
+  };
+};
+function Ee() {
+  return typeof window < "u";
+}
+function te(e) {
+  return st(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function V(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function U(e) {
+  var t;
+  return (t = (st(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function st(e) {
+  return Ee() ? e instanceof Node || e instanceof V(e).Node : !1;
+}
+function _(e) {
+  return Ee() ? e instanceof Element || e instanceof V(e).Element : !1;
+}
+function j(e) {
+  return Ee() ? e instanceof HTMLElement || e instanceof V(e).HTMLElement : !1;
+}
+function _e(e) {
+  return !Ee() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof V(e).ShadowRoot;
+}
+const Yt = /* @__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) && !Yt.has(r);
+}
+const Gt = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function Zt(e) {
+  return Gt.has(te(e));
+}
+const Jt = [":popover-open", ":modal"];
+function ve(e) {
+  return Jt.some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+const Qt = ["transform", "translate", "scale", "rotate", "perspective"], en = ["transform", "translate", "scale", "rotate", "perspective", "filter"], tn = ["paint", "layout", "strict", "content"];
+function ke(e) {
+  const t = Me(), o = _(e) ? W(e) : e;
+  return Qt.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) || en.some((n) => (o.willChange || "").includes(n)) || tn.some((n) => (o.contain || "").includes(n));
+}
+function nn(e) {
+  let t = q(e);
+  for (; j(t) && !ee(t); ) {
+    if (ke(t))
+      return t;
+    if (ve(t))
+      return null;
+    t = q(t);
+  }
+  return null;
+}
+function Me() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const on = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function ee(e) {
+  return on.has(te(e));
+}
+function W(e) {
+  return V(e).getComputedStyle(e);
+}
+function Re(e) {
+  return _(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function q(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.
+    _e(e) && e.host || // Fallback.
+    U(e)
+  );
+  return _e(t) ? t.host : t;
+}
+function ct(e) {
+  const t = q(e);
+  return ee(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : j(t) && ie(t) ? t : ct(t);
+}
+function oe(e, t, o) {
+  var n;
+  t === void 0 && (t = []), o === void 0 && (o = !0);
+  const r = ct(e), i = r === ((n = e.ownerDocument) == null ? void 0 : n.body), s = V(r);
+  if (i) {
+    const c = Ne(s);
+    return t.concat(s, s.visualViewport || [], ie(r) ? r : [], c && o ? oe(c) : []);
+  }
+  return t.concat(r, oe(r, [], o));
+}
+function Ne(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function lt(e) {
+  const t = W(e);
+  let o = parseFloat(t.width) || 0, n = parseFloat(t.height) || 0;
+  const r = j(e), i = r ? e.offsetWidth : o, s = r ? e.offsetHeight : n, c = fe(o) !== i || fe(n) !== s;
+  return c && (o = i, n = s), {
+    width: o,
+    height: n,
+    $: c
+  };
+}
+function Le(e) {
+  return _(e) ? e : e.contextElement;
+}
+function Q(e) {
+  const t = Le(e);
+  if (!j(t))
+    return H(1);
+  const o = t.getBoundingClientRect(), {
+    width: n,
+    height: r,
+    $: i
+  } = lt(t);
+  let s = (i ? fe(o.width) : o.width) / n, c = (i ? fe(o.height) : o.height) / r;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+const rn = /* @__PURE__ */ H(0);
+function at(e) {
+  const t = V(e);
+  return !Me() || !t.visualViewport ? rn : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function sn(e, t, o) {
+  return t === void 0 && (t = !1), !o || t && o !== V(e) ? !1 : t;
+}
+function Z(e, t, o, n) {
+  t === void 0 && (t = !1), o === void 0 && (o = !1);
+  const r = e.getBoundingClientRect(), i = Le(e);
+  let s = H(1);
+  t && (n ? _(n) && (s = Q(n)) : s = Q(e));
+  const c = sn(i, o, n) ? at(i) : H(0);
+  let l = (r.left + c.x) / s.x, a = (r.top + c.y) / s.y, u = r.width / s.x, f = r.height / s.y;
+  if (i) {
+    const g = V(i), d = n && _(n) ? V(n) : n;
+    let h = g, x = Ne(h);
+    for (; x && n && d !== h; ) {
+      const R = Q(x), b = x.getBoundingClientRect(), v = W(x), y = b.left + (x.clientLeft + parseFloat(v.paddingLeft)) * R.x, T = b.top + (x.clientTop + parseFloat(v.paddingTop)) * R.y;
+      l *= R.x, a *= R.y, u *= R.x, f *= R.y, l += y, a += T, h = V(x), x = Ne(h);
+    }
+  }
+  return pe({
+    width: u,
+    height: f,
+    x: l,
+    y: a
+  });
+}
+function Te(e, t) {
+  const o = Re(e).scrollLeft;
+  return t ? t.left + o : Z(U(e)).left + o;
+}
+function ut(e, t) {
+  const o = e.getBoundingClientRect(), n = o.left + t.scrollLeft - Te(e, o), r = o.top + t.scrollTop;
+  return {
+    x: n,
+    y: r
+  };
+}
+function cn(e) {
+  let {
+    elements: t,
+    rect: o,
+    offsetParent: n,
+    strategy: r
+  } = e;
+  const i = r === "fixed", s = U(n), c = t ? ve(t.floating) : !1;
+  if (n === s || c && i)
+    return o;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, a = H(1);
+  const u = H(0), f = j(n);
+  if ((f || !f && !i) && ((te(n) !== "body" || ie(s)) && (l = Re(n)), j(n))) {
+    const d = Z(n);
+    a = Q(n), u.x = d.x + n.clientLeft, u.y = d.y + n.clientTop;
+  }
+  const g = s && !f && !i ? ut(s, l) : H(0);
+  return {
+    width: o.width * a.x,
+    height: o.height * a.y,
+    x: o.x * a.x - l.scrollLeft * a.x + u.x + g.x,
+    y: o.y * a.y - l.scrollTop * a.y + u.y + g.y
+  };
+}
+function ln(e) {
+  return Array.from(e.getClientRects());
+}
+function an(e) {
+  const t = U(e), o = Re(e), n = e.ownerDocument.body, r = Y(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), i = Y(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
+  let s = -o.scrollLeft + Te(e);
+  const c = -o.scrollTop;
+  return W(n).direction === "rtl" && (s += Y(t.clientWidth, n.clientWidth) - r), {
+    width: r,
+    height: i,
+    x: s,
+    y: c
+  };
+}
+const We = 25;
+function un(e, t) {
+  const o = V(e), n = U(e), r = o.visualViewport;
+  let i = n.clientWidth, s = n.clientHeight, c = 0, l = 0;
+  if (r) {
+    i = r.width, s = r.height;
+    const u = Me();
+    (!u || u && t === "fixed") && (c = r.offsetLeft, l = r.offsetTop);
+  }
+  const a = Te(n);
+  if (a <= 0) {
+    const u = n.ownerDocument, f = u.body, g = getComputedStyle(f), d = u.compatMode === "CSS1Compat" && parseFloat(g.marginLeft) + parseFloat(g.marginRight) || 0, h = Math.abs(n.clientWidth - f.clientWidth - d);
+    h <= We && (i -= h);
+  } else a <= We && (i += a);
+  return {
+    width: i,
+    height: s,
+    x: c,
+    y: l
+  };
+}
+const fn = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function dn(e, t) {
+  const o = Z(e, !0, t === "fixed"), n = o.top + e.clientTop, r = o.left + e.clientLeft, i = j(e) ? Q(e) : H(1), s = e.clientWidth * i.x, c = e.clientHeight * i.y, l = r * i.x, a = n * i.y;
+  return {
+    width: s,
+    height: c,
+    x: l,
+    y: a
+  };
+}
+function He(e, t, o) {
+  let n;
+  if (t === "viewport")
+    n = un(e, o);
+  else if (t === "document")
+    n = an(U(e));
+  else if (_(t))
+    n = dn(t, o);
+  else {
+    const r = at(e);
+    n = {
+      x: t.x - r.x,
+      y: t.y - r.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return pe(n);
+}
+function ft(e, t) {
+  const o = q(e);
+  return o === t || !_(o) || ee(o) ? !1 : W(o).position === "fixed" || ft(o, t);
+}
+function pn(e, t) {
+  const o = t.get(e);
+  if (o)
+    return o;
+  let n = oe(e, [], !1).filter((c) => _(c) && te(c) !== "body"), r = null;
+  const i = W(e).position === "fixed";
+  let s = i ? q(e) : e;
+  for (; _(s) && !ee(s); ) {
+    const c = W(s), l = ke(s);
+    !l && c.position === "fixed" && (r = null), (i ? !l && !r : !l && c.position === "static" && !!r && fn.has(r.position) || ie(s) && !l && ft(e, s)) ? n = n.filter((u) => u !== s) : r = c, s = q(s);
+  }
+  return t.set(e, n), n;
+}
+function mn(e) {
+  let {
+    element: t,
+    boundary: o,
+    rootBoundary: n,
+    strategy: r
+  } = e;
+  const s = [...o === "clippingAncestors" ? ve(t) ? [] : pn(t, this._c) : [].concat(o), n], c = s[0], l = s.reduce((a, u) => {
+    const f = He(t, u, r);
+    return a.top = Y(f.top, a.top), a.right = ue(f.right, a.right), a.bottom = ue(f.bottom, a.bottom), a.left = Y(f.left, a.left), a;
+  }, He(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
+  } = lt(e);
+  return {
+    width: t,
+    height: o
+  };
+}
+function gn(e, t, o) {
+  const n = j(t), r = U(t), i = o === "fixed", s = Z(e, !0, i, t);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = H(0);
+  function a() {
+    l.x = Te(r);
+  }
+  if (n || !n && !i)
+    if ((te(t) !== "body" || ie(r)) && (c = Re(t)), n) {
+      const d = Z(t, !0, i, t);
+      l.x = d.x + t.clientLeft, l.y = d.y + t.clientTop;
+    } else r && a();
+  i && !n && r && a();
+  const u = r && !n && !i ? ut(r, c) : H(0), f = s.left + c.scrollLeft - l.x - u.x, g = s.top + c.scrollTop - l.y - u.y;
+  return {
+    x: f,
+    y: g,
+    width: s.width,
+    height: s.height
+  };
+}
+function Ce(e) {
+  return W(e).position === "static";
+}
+function je(e, t) {
+  if (!j(e) || W(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let o = e.offsetParent;
+  return U(e) === o && (o = o.ownerDocument.body), o;
+}
+function dt(e, t) {
+  const o = V(e);
+  if (ve(e))
+    return o;
+  if (!j(e)) {
+    let r = q(e);
+    for (; r && !ee(r); ) {
+      if (_(r) && !Ce(r))
+        return r;
+      r = q(r);
+    }
+    return o;
+  }
+  let n = je(e, t);
+  for (; n && Zt(n) && Ce(n); )
+    n = je(n, t);
+  return n && ee(n) && Ce(n) && !ke(n) ? o : n || nn(e) || o;
+}
+const yn = async function(e) {
+  const t = this.getOffsetParent || dt, o = this.getDimensions, n = await o(e.floating);
+  return {
+    reference: gn(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function bn(e) {
+  return W(e).direction === "rtl";
+}
+const xn = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: cn,
+  getDocumentElement: U,
+  getClippingRect: mn,
+  getOffsetParent: dt,
+  getElementRects: yn,
+  getClientRects: ln,
+  getDimensions: hn,
+  getScale: Q,
+  isElement: _,
+  isRTL: bn
+};
+function pt(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function wn(e, t) {
+  let o = null, n;
+  const r = U(e);
+  function i() {
+    var c;
+    clearTimeout(n), (c = o) == null || c.disconnect(), o = null;
+  }
+  function s(c, l) {
+    c === void 0 && (c = !1), l === void 0 && (l = 1), i();
+    const a = e.getBoundingClientRect(), {
+      left: u,
+      top: f,
+      width: g,
+      height: d
+    } = a;
+    if (c || t(), !g || !d)
+      return;
+    const h = le(f), x = le(r.clientWidth - (u + g)), R = le(r.clientHeight - (f + d)), b = le(u), y = {
+      rootMargin: -h + "px " + -x + "px " + -R + "px " + -b + "px",
+      threshold: Y(0, ue(1, l)) || 1
+    };
+    let T = !0;
+    function w(P) {
+      const S = P[0].intersectionRatio;
+      if (S !== l) {
+        if (!T)
+          return s();
+        S ? s(!1, S) : n = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      S === 1 && !pt(a, e.getBoundingClientRect()) && s(), T = !1;
+    }
+    try {
+      o = new IntersectionObserver(w, {
+        ...y,
+        // Handle <iframe>s
+        root: r.ownerDocument
+      });
+    } catch {
+      o = new IntersectionObserver(w, y);
+    }
+    o.observe(e);
+  }
+  return s(!0), i;
+}
+function Ue(e, t, o, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: r = !0,
+    ancestorResize: i = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: l = !1
+  } = n, a = Le(e), u = r || i ? [...a ? oe(a) : [], ...oe(t)] : [];
+  u.forEach((b) => {
+    r && b.addEventListener("scroll", o, {
+      passive: !0
+    }), i && b.addEventListener("resize", o);
+  });
+  const f = a && c ? wn(a, o) : null;
+  let g = -1, d = null;
+  s && (d = new ResizeObserver((b) => {
+    let [v] = b;
+    v && v.target === a && d && (d.unobserve(t), cancelAnimationFrame(g), g = requestAnimationFrame(() => {
+      var y;
+      (y = d) == null || y.observe(t);
+    })), o();
+  }), a && !l && d.observe(a), d.observe(t));
+  let h, x = l ? Z(e) : null;
+  l && R();
+  function R() {
+    const b = Z(e);
+    x && !pt(x, b) && o(), x = b, h = requestAnimationFrame(R);
+  }
+  return o(), () => {
+    var b;
+    u.forEach((v) => {
+      r && v.removeEventListener("scroll", o), i && v.removeEventListener("resize", o);
+    }), f == null || f(), (b = d) == null || b.disconnect(), d = null, l && cancelAnimationFrame(h);
+  };
+}
+const En = qt, vn = Xt, Rn = Ut, Tn = (e, t, o) => {
+  const n = /* @__PURE__ */ new Map(), r = {
+    platform: xn,
+    ...o
+  }, i = {
+    ...r.platform,
+    _c: n
+  };
+  return jt(e, t, {
+    ...r,
+    platform: i
+  });
+};
+var Cn = typeof document < "u", On = function() {
+}, ae = Cn ? kt : 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 i = r[n];
+      if (!(i === "_owner" && e.$$typeof) && !me(e[i], t[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+function mt(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function Ke(e, t) {
+  const o = mt(e);
+  return Math.round(t * o) / o;
+}
+function Oe(e) {
+  const t = m.useRef(e);
+  return ae(() => {
+    t.current = e;
+  }), t;
+}
+function Sn(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: o = "absolute",
+    middleware: n = [],
+    platform: r,
+    elements: {
+      reference: i,
+      floating: s
+    } = {},
+    transform: c = !0,
+    whileElementsMounted: l,
+    open: a
+  } = e, [u, f] = m.useState({
+    x: 0,
+    y: 0,
+    strategy: o,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [g, d] = m.useState(n);
+  me(g, n) || d(n);
+  const [h, x] = m.useState(null), [R, b] = m.useState(null), v = m.useCallback((E) => {
+    E !== P.current && (P.current = E, x(E));
+  }, []), y = m.useCallback((E) => {
+    E !== S.current && (S.current = E, b(E));
+  }, []), T = i || h, w = s || R, P = m.useRef(null), S = m.useRef(null), A = m.useRef(u), L = l != null, N = Oe(l), D = Oe(r), I = Oe(a), k = m.useCallback(() => {
+    if (!P.current || !S.current)
+      return;
+    const E = {
+      placement: t,
+      strategy: o,
+      middleware: g
+    };
+    D.current && (E.platform = D.current), Tn(P.current, S.current, E).then((F) => {
+      const B = {
+        ...F,
+        // 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: I.current !== !1
+      };
+      M.current && !me(A.current, B) && (A.current = B, et.flushSync(() => {
+        f(B);
+      }));
+    });
+  }, [g, t, o, D, I]);
+  ae(() => {
+    a === !1 && A.current.isPositioned && (A.current.isPositioned = !1, f((E) => ({
+      ...E,
+      isPositioned: !1
+    })));
+  }, [a]);
+  const M = m.useRef(!1);
+  ae(() => (M.current = !0, () => {
+    M.current = !1;
+  }), []), ae(() => {
+    if (T && (P.current = T), w && (S.current = w), T && w) {
+      if (N.current)
+        return N.current(T, w, k);
+      k();
+    }
+  }, [T, w, k, N, L]);
+  const $ = m.useMemo(() => ({
+    reference: P,
+    floating: S,
+    setReference: v,
+    setFloating: y
+  }), [v, y]), C = m.useMemo(() => ({
+    reference: T,
+    floating: w
+  }), [T, w]), O = m.useMemo(() => {
+    const E = {
+      position: o,
+      left: 0,
+      top: 0
+    };
+    if (!C.floating)
+      return E;
+    const F = Ke(C.floating, u.x), B = Ke(C.floating, u.y);
+    return c ? {
+      ...E,
+      transform: "translate(" + F + "px, " + B + "px)",
+      ...mt(C.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: o,
+      left: F,
+      top: B
+    };
+  }, [o, c, C.floating, u.x, u.y]);
+  return m.useMemo(() => ({
+    ...u,
+    update: k,
+    refs: $,
+    elements: C,
+    floatingStyles: O
+  }), [u, k, $, C, O]);
+}
+const ze = (e, t) => ({
+  ...En(e),
+  options: [e, t]
+}), An = (e, t) => ({
+  ...vn(e),
+  options: [e, t]
+}), Nn = (e, t) => ({
+  ...Rn(e),
+  options: [e, t]
+});
+function ht(e, t) {
+  return process.env.NODE_ENV === "production" ? () => null : function(...n) {
+    return e(...n) || t(...n);
+  };
+}
+function Pn(e) {
+  const {
+    prototype: t = {}
+  } = e;
+  return !!t.isReactComponent;
+}
+function gt(e, t, o, n, r) {
+  const i = e[t], s = r || t;
+  if (i == 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 = i.type;
+  return typeof l == "function" && !Pn(l) && (c = "Did you accidentally use a plain function component for an element instead?"), c !== void 0 ? new Error(`Invalid ${n} \`${s}\` 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 De = ht(p.element, gt);
+De.isRequired = ht(p.element.isRequired, gt);
+const kn = "exact-prop: ​";
+function yt(e) {
+  return process.env.NODE_ENV === "production" ? e : {
+    ...e,
+    [kn]: (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 he(e, t, o, n, r) {
+  if (process.env.NODE_ENV === "production")
+    return null;
+  const i = e[t], s = r || t;
+  return i == null ? null : i && i.nodeType !== 1 ? new Error(`Invalid ${n} \`${s}\` supplied to \`${o}\`. Expected an HTMLElement.`) : null;
+}
+function qe(...e) {
+  return e.reduce((t, o) => o == null ? t : function(...r) {
+    t.apply(this, r), o.apply(this, r);
+  }, () => {
+  });
+}
+function J(e) {
+  return e && e.ownerDocument || document;
+}
+function ge(e) {
+  return J(e).defaultView || window;
+}
+function Xe(e, t) {
+  typeof e == "function" ? e(t) : e && (e.current = t);
+}
+const ye = typeof window < "u" ? m.useLayoutEffect : m.useEffect;
+function Ye(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 se(...e) {
+  const t = m.useRef(void 0), o = m.useCallback((n) => {
+    const r = e.map((i) => {
+      if (i == null)
+        return null;
+      if (typeof i == "function") {
+        const s = i, c = s(n);
+        return typeof c == "function" ? c : () => {
+          s(null);
+        };
+      }
+      return i.current = n, () => {
+        i.current = null;
+      };
+    });
+    return () => {
+      r.forEach((i) => i == null ? void 0 : i());
+    };
+  }, 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 Mn(e = window) {
+  const t = e.document.documentElement.clientWidth;
+  return e.innerWidth - t;
+}
+function bt(e, t, o = void 0) {
+  const n = {};
+  for (const r in e) {
+    const i = e[r];
+    let s = "", c = !0;
+    for (let l = 0; l < i.length; l += 1) {
+      const a = i[l];
+      a && (s += (c === !0 ? "" : " ") + t(a), c = !1, o && o[a] && (s += " " + o[a]));
+    }
+    n[r] = s;
+  }
+  return n;
+}
+const Ln = {
+  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 Dn(e) {
+  return typeof e == "string";
+}
+function Fn(e, t, o) {
+  return e === void 0 || Dn(e) ? t : {
+    ...t,
+    ownerState: {
+      ...t.ownerState,
+      ...o
+    }
+  };
+}
+function xt(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 = xt(e[t])) && (n && (n += " "), n += o);
+  } else for (o in e) e[o] && (n && (n += " "), n += o);
+  return n;
+}
+function Ge() {
+  for (var e, t, o = 0, n = "", r = arguments.length; o < r; o++) (e = arguments[o]) && (t = xt(e)) && (n && (n += " "), n += t);
+  return n;
+}
+function wt(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 Ze(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: i
+  } = e;
+  if (!t) {
+    const d = Ge(o == null ? void 0 : o.className, i, r == null ? void 0 : r.className, n == null ? void 0 : n.className), h = {
+      ...o == null ? void 0 : o.style,
+      ...r == null ? void 0 : r.style,
+      ...n == null ? void 0 : n.style
+    }, x = {
+      ...o,
+      ...r,
+      ...n
+    };
+    return d.length > 0 && (x.className = d), Object.keys(h).length > 0 && (x.style = h), {
+      props: x,
+      internalRef: void 0
+    };
+  }
+  const s = wt({
+    ...r,
+    ...n
+  }), c = Ze(n), l = Ze(r), a = t(s), u = Ge(a == null ? void 0 : a.className, o == null ? void 0 : o.className, i, r == null ? void 0 : r.className, n == null ? void 0 : n.className), f = {
+    ...a == null ? void 0 : a.style,
+    ...o == null ? void 0 : o.style,
+    ...r == null ? void 0 : r.style,
+    ...n == null ? void 0 : n.style
+  }, g = {
+    ...a,
+    ...o,
+    ...l,
+    ...c
+  };
+  return u.length > 0 && (g.className = u), Object.keys(f).length > 0 && (g.style = f), {
+    props: g,
+    internalRef: a.ref
+  };
+}
+function Vn(e, t, o) {
+  return typeof e == "function" ? e(t, o) : e;
+}
+function Pe(e) {
+  var f;
+  const {
+    elementType: t,
+    externalSlotProps: o,
+    ownerState: n,
+    skipResolvingSlotProps: r = !1,
+    ...i
+  } = e, s = r ? {} : Vn(o, n), {
+    props: c,
+    internalRef: l
+  } = In({
+    ...i,
+    externalSlotProps: s
+  }), a = se(l, s == null ? void 0 : s.ref, (f = e.additionalProps) == null ? void 0 : f.ref);
+  return Fn(t, {
+    ...c,
+    ref: a
+  }, n);
+}
+function Et(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 re = /* @__PURE__ */ m.forwardRef(function(t, o) {
+  const {
+    children: n,
+    container: r,
+    disablePortal: i = !1
+  } = t, [s, c] = m.useState(null), l = se(/* @__PURE__ */ m.isValidElement(n) ? Et(n) : null, o);
+  if (ye(() => {
+    i || c($n(r) || document.body);
+  }, [r, i]), ye(() => {
+    if (s && !i)
+      return Xe(o, s), () => {
+        Xe(o, null);
+      };
+  }, [o, s, i]), i) {
+    if (/* @__PURE__ */ m.isValidElement(n)) {
+      const a = {
+        ref: l
+      };
+      return /* @__PURE__ */ m.cloneElement(n, a);
+    }
+    return n;
+  }
+  return s && /* @__PURE__ */ et.createPortal(n, s);
+});
+process.env.NODE_ENV !== "production" && (re.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: p.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: p.oneOfType([he, p.func]),
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: p.bool
+});
+process.env.NODE_ENV !== "production" && (re.propTypes = yt(re.propTypes));
+const Bn = {
+  disableDefaultClasses: !1
+}, vt = /* @__PURE__ */ m.createContext(Bn);
+process.env.NODE_ENV !== "production" && (vt.displayName = "ClassNameConfiguratorContext");
+function Rt(e) {
+  const {
+    disableDefaultClasses: t
+  } = m.useContext(vt);
+  return (o) => t ? "" : e(o);
+}
+const Tt = "base";
+function _n(e) {
+  return `${Tt}--${e}`;
+}
+function Wn(e, t) {
+  return `${Tt}-${e}-${t}`;
+}
+function Fe(e, t) {
+  const o = Ln[t];
+  return o ? _n(o) : Wn(e, t);
+}
+function Ct(e, t) {
+  const o = {};
+  return t.forEach((n) => {
+    o[n] = Fe(e, n);
+  }), o;
+}
+const Ot = "Popup";
+function Hn(e) {
+  return Fe(Ot, e);
+}
+Ct(Ot, ["root", "open"]);
+const St = /* @__PURE__ */ m.createContext(null);
+process.env.NODE_ENV !== "production" && (St.displayName = "TransitionContext");
+function jn(e) {
+  const [t, o] = m.useState(!0), n = m.useRef(!1), r = m.useRef(0), [i, s] = 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, s(!0), () => {
+    r.current -= 1, r.current === 0 && s(!1);
+  }), []);
+  let u;
+  return i ? e ? u = !1 : u = !n.current && t : u = !e, {
+    contextValue: m.useMemo(() => ({
+      requestedEnter: e,
+      onExited: l,
+      registerTransition: a,
+      hasExited: u
+    }), [l, e, a, u]),
+    hasExited: u
+  };
+}
+const At = /* @__PURE__ */ m.createContext(null);
+process.env.NODE_ENV !== "production" && (At.displayName = "PopupContext");
+function Un(e) {
+  const {
+    open: t
+  } = e;
+  return bt({
+    root: ["root", t && "open"]
+  }, Rt(Hn));
+}
+function Kn(e) {
+  return typeof e == "function" ? e() : e;
+}
+const zn = /* @__PURE__ */ m.forwardRef(function(t, o) {
+  const {
+    anchor: n,
+    children: r,
+    container: i,
+    disablePortal: s = !1,
+    keepMounted: c = !1,
+    middleware: l,
+    offset: a = 0,
+    open: u = !1,
+    placement: f = "bottom",
+    slotProps: g = {},
+    slots: d = {},
+    strategy: h = "absolute",
+    ...x
+  } = t, {
+    refs: R,
+    elements: b,
+    floatingStyles: v,
+    update: y,
+    placement: T
+  } = Sn({
+    elements: {
+      reference: Kn(n)
+    },
+    open: u,
+    middleware: l ?? [ze(a ?? 0), Nn(), An()],
+    placement: f,
+    strategy: h,
+    whileElementsMounted: c ? void 0 : Ue
+  }), w = se(R.setFloating, o);
+  ye(() => {
+    if (c && u && b.reference && b.floating)
+      return Ue(b.reference, b.floating, y);
+  }, [c, u, b, y]);
+  const P = {
+    ...t,
+    disablePortal: s,
+    keepMounted: c,
+    offset: ze,
+    open: u,
+    placement: f,
+    finalPlacement: T,
+    strategy: h
+  }, {
+    contextValue: S,
+    hasExited: A
+  } = jn(u), L = c && A ? "hidden" : void 0, N = Un(P), D = (d == null ? void 0 : d.root) ?? "div", I = Pe({
+    elementType: D,
+    externalSlotProps: g.root,
+    externalForwardedProps: x,
+    ownerState: P,
+    className: N.root,
+    additionalProps: {
+      ref: w,
+      role: "tooltip",
+      style: {
+        ...v,
+        visibility: L
+      }
+    }
+  }), k = m.useMemo(() => ({
+    placement: T
+  }), [T]);
+  return c || !A ? /* @__PURE__ */ K(re, {
+    disablePortal: s,
+    container: i,
+    children: /* @__PURE__ */ K(At.Provider, {
+      value: k,
+      children: /* @__PURE__ */ K(St.Provider, {
+        value: S,
+        children: /* @__PURE__ */ K(D, {
+          ...I,
+          children: r
+        })
+      })
+    })
+  }) : null;
+});
+process.env.NODE_ENV !== "production" && (zn.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: p.oneOfType([he, p.object, p.func]),
+  /**
+   * @ignore
+   */
+  children: p.oneOfType([p.node, p.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: p.oneOfType([he, p.func]),
+  /**
+   * If `true`, the popup will be rendered where it is defined, without the use of portals.
+   * @default false
+   */
+  disablePortal: p.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: p.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: p.arrayOf(p.oneOfType([p.oneOf([!1]), p.shape({
+    fn: p.func.isRequired,
+    name: p.string.isRequired,
+    options: p.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: p.oneOfType([p.func, p.number, p.shape({
+    alignmentAxis: p.number,
+    crossAxis: p.number,
+    mainAxis: p.number
+  })]),
+  /**
+   * If `true`, the popup is visible.
+   *
+   * @default false
+   */
+  open: p.bool,
+  /**
+   * Determines where to place the popup relative to the trigger element.
+   *
+   * @default 'bottom'
+   * @see https://floating-ui.com/docs/computePosition#placement
+   */
+  placement: p.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: p.shape({
+    root: p.oneOfType([p.func, p.object])
+  }),
+  /**
+   * The components used for each slot inside the Popup.
+   * Either a string to use a HTML element or a component.
+   *
+   * @default {}
+   */
+  slots: p.shape({
+    root: p.elementType
+  }),
+  /**
+   * The type of CSS position property to use (absolute or fixed).
+   *
+   * @default 'absolute'
+   * @see https://floating-ui.com/docs/computePosition#strategy
+   */
+  strategy: p.oneOf(["absolute", "fixed"])
+});
+function qn(e) {
+  const t = J(e);
+  return t.body === e ? ge(e).innerWidth > t.documentElement.clientWidth : e.scrollHeight > e.clientHeight;
+}
+function ne(e, t) {
+  t ? e.setAttribute("aria-hidden", "true") : e.removeAttribute("aria-hidden");
+}
+function Je(e) {
+  return parseInt(ge(e).getComputedStyle(e).paddingRight, 10) || 0;
+}
+function Xn(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 Qe(e, t, o, n, r) {
+  const i = [t, o, ...n];
+  [].forEach.call(e.children, (s) => {
+    const c = !i.includes(s), l = !Xn(s);
+    c && l && ne(s, r);
+  });
+}
+function Se(e, t) {
+  let o = -1;
+  return e.some((n, r) => t(n) ? (o = r, !0) : !1), o;
+}
+function Yn(e, t) {
+  const o = [], n = e.container;
+  if (!t.disableScrollLock) {
+    if (qn(n)) {
+      const s = Mn(ge(n));
+      o.push({
+        value: n.style.paddingRight,
+        property: "padding-right",
+        el: n
+      }), n.style.paddingRight = `${Je(n) + s}px`;
+      const c = J(n).querySelectorAll(".mui-fixed");
+      [].forEach.call(c, (l) => {
+        o.push({
+          value: l.style.paddingRight,
+          property: "padding-right",
+          el: l
+        }), l.style.paddingRight = `${Je(l) + s}px`;
+      });
+    }
+    let i;
+    if (n.parentNode instanceof DocumentFragment)
+      i = J(n).body;
+    else {
+      const s = n.parentElement, c = ge(n);
+      i = (s == null ? void 0 : s.nodeName) === "HTML" && c.getComputedStyle(s).overflowY === "scroll" ? s : n;
+    }
+    o.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 () => {
+    o.forEach(({
+      value: i,
+      el: s,
+      property: c
+    }) => {
+      i ? s.style.setProperty(c, i) : s.style.removeProperty(c);
+    });
+  };
+}
+function Gn(e) {
+  const t = [];
+  return [].forEach.call(e.children, (o) => {
+    o.getAttribute("aria-hidden") === "true" && t.push(o);
+  }), t;
+}
+class Zn {
+  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 && ne(t.modalRef, !1);
+    const r = Gn(o);
+    Qe(o, t.mount, t.modalRef, r, !0);
+    const i = Se(this.containers, (s) => s.container === o);
+    return i !== -1 ? (this.containers[i].modals.push(t), n) : (this.containers.push({
+      modals: [t],
+      container: o,
+      restore: null,
+      hiddenSiblings: r
+    }), n);
+  }
+  mount(t, o) {
+    const n = Se(this.containers, (i) => i.modals.includes(t)), r = this.containers[n];
+    r.restore || (r.restore = Yn(r, o));
+  }
+  remove(t, o = !0) {
+    const n = this.modals.indexOf(t);
+    if (n === -1)
+      return n;
+    const r = Se(this.containers, (s) => s.modals.includes(t)), i = this.containers[r];
+    if (i.modals.splice(i.modals.indexOf(t), 1), this.modals.splice(n, 1), i.modals.length === 0)
+      i.restore && i.restore(), t.modalRef && ne(t.modalRef, o), Qe(i.container, t.mount, t.modalRef, i.hiddenSiblings, !1), this.containers.splice(r, 1);
+    else {
+      const s = i.modals[i.modals.length - 1];
+      s.modalRef && ne(s.modalRef, !1);
+    }
+    return n;
+  }
+  isTopModal(t) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === t;
+  }
+}
+function Jn(e) {
+  return typeof e == "function" ? e() : e;
+}
+function Qn(e) {
+  return e ? e.props.hasOwnProperty("in") : !1;
+}
+const eo = new Zn();
+function to(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 = eo,
+    closeAfterTransition: i = !1,
+    onTransitionEnter: s,
+    onTransitionExited: c,
+    children: l,
+    onClose: a,
+    open: u,
+    rootRef: f
+  } = e, g = m.useRef({}), d = m.useRef(null), h = m.useRef(null), x = se(h, f), [R, b] = m.useState(!u), v = Qn(l);
+  let y = !0;
+  (e["aria-hidden"] === "false" || e["aria-hidden"] === !1) && (y = !1);
+  const T = () => J(d.current), w = () => (g.current.modalRef = h.current, g.current.mount = d.current, g.current), P = () => {
+    r.mount(w(), {
+      disableScrollLock: n
+    }), h.current && (h.current.scrollTop = 0);
+  }, S = Ye(() => {
+    const C = Jn(t) || T().body;
+    r.add(w(), C), h.current && P();
+  }), A = m.useCallback(() => r.isTopModal(w()), [r]), L = Ye((C) => {
+    d.current = C, C && (u && A() ? P() : h.current && ne(h.current, y));
+  }), N = m.useCallback(() => {
+    r.remove(w(), y);
+  }, [y, r]);
+  m.useEffect(() => () => {
+    N();
+  }, [N]), m.useEffect(() => {
+    u ? S() : (!v || !i) && N();
+  }, [u, N, v, i, S]);
+  const D = (C) => (O) => {
+    var E;
+    (E = C.onKeyDown) == null || E.call(C, O), !(O.key !== "Escape" || O.which === 229 || // Wait until IME is settled.
+    !A()) && (o || (O.stopPropagation(), a && a(O, "escapeKeyDown")));
+  }, I = (C) => (O) => {
+    var E;
+    (E = C.onClick) == null || E.call(C, O), O.target === O.currentTarget && a && a(O, "backdropClick");
+  };
+  return {
+    getRootProps: (C = {}) => {
+      const O = wt(e);
+      delete O.onTransitionEnter, delete O.onTransitionExited;
+      const E = {
+        ...O,
+        ...C
+      };
+      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",
+        ...E,
+        onKeyDown: D(E),
+        ref: x
+      };
+    },
+    getBackdropProps: (C = {}) => {
+      const O = C;
+      return {
+        "aria-hidden": !0,
+        ...O,
+        onClick: I(O),
+        open: u
+      };
+    },
+    getTransitionProps: () => {
+      const C = () => {
+        b(!1), s && s();
+      }, O = () => {
+        b(!0), c && c(), i && N();
+      };
+      return {
+        onEnter: qe(C, l == null ? void 0 : l.props.onEnter),
+        onExited: qe(O, l == null ? void 0 : l.props.onExited)
+      };
+    },
+    rootRef: x,
+    portalRef: L,
+    isTopModal: A,
+    exited: R,
+    hasTransition: v
+  };
+}
+const no = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])'].join(",");
+function oo(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 ro(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 io(e) {
+  return !(e.disabled || e.tagName === "INPUT" && e.type === "hidden" || ro(e));
+}
+function so(e) {
+  const t = [], o = [];
+  return Array.from(e.querySelectorAll(no)).forEach((n, r) => {
+    const i = oo(n);
+    i === -1 || !io(n) || (i === 0 ? t.push(n) : o.push({
+      documentOrder: r,
+      tabIndex: i,
+      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 co() {
+  return !0;
+}
+function be(e) {
+  const {
+    children: t,
+    disableAutoFocus: o = !1,
+    disableEnforceFocus: n = !1,
+    disableRestoreFocus: r = !1,
+    getTabbable: i = so,
+    isEnabled: s = co,
+    open: c
+  } = e, l = m.useRef(!1), a = m.useRef(null), u = m.useRef(null), f = m.useRef(null), g = m.useRef(null), d = m.useRef(!1), h = m.useRef(null), x = se(Et(t), h), R = m.useRef(null);
+  m.useEffect(() => {
+    !c || !h.current || (d.current = !o);
+  }, [o, c]), m.useEffect(() => {
+    if (!c || !h.current)
+      return;
+    const y = J(h.current);
+    return h.current.contains(y.activeElement) || (h.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(`
+`)), h.current.setAttribute("tabIndex", "-1")), d.current && h.current.focus()), () => {
+      r || (f.current && f.current.focus && (l.current = !0, f.current.focus()), f.current = null);
+    };
+  }, [c]), m.useEffect(() => {
+    if (!c || !h.current)
+      return;
+    const y = J(h.current), T = (S) => {
+      R.current = S, !(n || !s() || S.key !== "Tab") && y.activeElement === h.current && S.shiftKey && (l.current = !0, u.current && u.current.focus());
+    }, w = () => {
+      var L, N;
+      const S = h.current;
+      if (S === null)
+        return;
+      if (!y.hasFocus() || !s() || l.current) {
+        l.current = !1;
+        return;
+      }
+      if (S.contains(y.activeElement) || n && y.activeElement !== a.current && y.activeElement !== u.current)
+        return;
+      if (y.activeElement !== g.current)
+        g.current = null;
+      else if (g.current !== null)
+        return;
+      if (!d.current)
+        return;
+      let A = [];
+      if ((y.activeElement === a.current || y.activeElement === u.current) && (A = i(h.current)), A.length > 0) {
+        const D = !!((L = R.current) != null && L.shiftKey && ((N = R.current) == null ? void 0 : N.key) === "Tab"), I = A[0], k = A[A.length - 1];
+        typeof I != "string" && typeof k != "string" && (D ? k.focus() : I.focus());
+      } else
+        S.focus();
+    };
+    y.addEventListener("focusin", w), y.addEventListener("keydown", T, !0);
+    const P = setInterval(() => {
+      y.activeElement && y.activeElement.tagName === "BODY" && w();
+    }, 50);
+    return () => {
+      clearInterval(P), y.removeEventListener("focusin", w), y.removeEventListener("keydown", T, !0);
+    };
+  }, [o, n, r, s, c, i]);
+  const b = (y) => {
+    f.current === null && (f.current = y.relatedTarget), d.current = !0, g.current = y.target;
+    const T = t.props.onFocus;
+    T && T(y);
+  }, v = (y) => {
+    f.current === null && (f.current = y.relatedTarget), d.current = !0;
+  };
+  return /* @__PURE__ */ tt(m.Fragment, {
+    children: [/* @__PURE__ */ K("div", {
+      tabIndex: c ? 0 : -1,
+      onFocus: v,
+      ref: a,
+      "data-testid": "sentinelStart"
+    }), /* @__PURE__ */ m.cloneElement(t, {
+      ref: x,
+      onFocus: b
+    }), /* @__PURE__ */ K("div", {
+      tabIndex: c ? 0 : -1,
+      onFocus: v,
+      ref: u,
+      "data-testid": "sentinelEnd"
+    })]
+  });
+}
+process.env.NODE_ENV !== "production" && (be.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: De,
+  /**
+   * 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: p.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: p.bool,
+  /**
+   * If `true`, the focus trap will not restore focus to previously focused element once
+   * focus trap is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: p.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: p.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: p.func,
+  /**
+   * If `true`, focus is locked.
+   */
+  open: p.bool.isRequired
+});
+process.env.NODE_ENV !== "production" && (be.propTypes = yt(be.propTypes));
+const Nt = "Modal";
+function lo(e) {
+  return Fe(Nt, e);
+}
+Ct(Nt, ["root", "hidden", "backdrop"]);
+const ao = (e) => {
+  const {
+    open: t,
+    exited: o
+  } = e;
+  return bt({
+    root: ["root", !t && o && "hidden"],
+    backdrop: ["backdrop"]
+  }, Rt(lo));
+}, uo = /* @__PURE__ */ m.forwardRef(function(t, o) {
+  const {
+    children: n,
+    closeAfterTransition: r = !1,
+    container: i,
+    disableAutoFocus: s = !1,
+    disableEnforceFocus: c = !1,
+    disableEscapeKeyDown: l = !1,
+    disablePortal: a = !1,
+    disableRestoreFocus: u = !1,
+    disableScrollLock: f = !1,
+    hideBackdrop: g = !1,
+    keepMounted: d = !1,
+    onBackdropClick: h,
+    onClose: x,
+    onKeyDown: R,
+    open: b,
+    onTransitionEnter: v,
+    onTransitionExited: y,
+    slotProps: T = {},
+    slots: w = {},
+    ...P
+  } = t, S = {
+    ...t,
+    closeAfterTransition: r,
+    disableAutoFocus: s,
+    disableEnforceFocus: c,
+    disableEscapeKeyDown: l,
+    disablePortal: a,
+    disableRestoreFocus: u,
+    disableScrollLock: f,
+    hideBackdrop: g,
+    keepMounted: d
+  }, {
+    getRootProps: A,
+    getBackdropProps: L,
+    getTransitionProps: N,
+    portalRef: D,
+    isTopModal: I,
+    exited: k,
+    hasTransition: M
+  } = to({
+    ...S,
+    rootRef: o
+  }), $ = {
+    ...S,
+    exited: k,
+    hasTransition: M
+  }, C = ao($), O = {};
+  if (n.props.tabIndex === void 0 && (O.tabIndex = "-1"), M) {
+    const {
+      onEnter: X,
+      onExited: ce
+    } = N();
+    O.onEnter = X, O.onExited = ce;
+  }
+  const E = w.root ?? "div", F = Pe({
+    elementType: E,
+    externalSlotProps: T.root,
+    externalForwardedProps: P,
+    getSlotProps: A,
+    className: C.root,
+    ownerState: $
+  }), B = w.backdrop, Pt = Pe({
+    elementType: B,
+    externalSlotProps: T.backdrop,
+    getSlotProps: (X) => L({
+      ...X,
+      onClick: (ce) => {
+        h && h(ce), X != null && X.onClick && X.onClick(ce);
+      }
+    }),
+    className: C.backdrop,
+    ownerState: $
+  });
+  return !d && !b && (!M || k) ? null : /* @__PURE__ */ K(re, {
+    ref: D,
+    container: i,
+    disablePortal: a,
+    children: /* @__PURE__ */ tt(E, {
+      ...F,
+      children: [!g && B ? /* @__PURE__ */ K(B, {
+        ...Pt
+      }) : null, /* @__PURE__ */ K(be, {
+        disableEnforceFocus: c,
+        disableAutoFocus: s,
+        disableRestoreFocus: u,
+        isEnabled: I,
+        open: b,
+        children: /* @__PURE__ */ m.cloneElement(n, O)
+      })]
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (uo.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: De.isRequired,
+  /**
+   * When set to true the Modal waits until a nested Transition is completed before closing.
+   * @default false
+   */
+  closeAfterTransition: p.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: p.oneOfType([he, p.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: p.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: p.bool,
+  /**
+   * If `true`, hitting escape will not fire the `onClose` callback.
+   * @default false
+   */
+  disableEscapeKeyDown: p.bool,
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: p.bool,
+  /**
+   * If `true`, the modal will not restore focus to previously focused element once
+   * modal is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: p.bool,
+  /**
+   * Disable the scroll lock behavior.
+   * @default false
+   */
+  disableScrollLock: p.bool,
+  /**
+   * If `true`, the backdrop is not rendered.
+   * @default false
+   */
+  hideBackdrop: p.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: p.bool,
+  /**
+   * Callback fired when the backdrop is clicked.
+   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
+   */
+  onBackdropClick: p.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: p.func,
+  /**
+   * A function called when a transition enters.
+   */
+  onTransitionEnter: p.func,
+  /**
+   * A function called when a transition has exited.
+   */
+  onTransitionExited: p.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: p.bool.isRequired,
+  /**
+   * The props used for each slot inside the Modal.
+   * @default {}
+   */
+  slotProps: p.shape({
+    backdrop: p.oneOfType([p.func, p.object]),
+    root: p.oneOfType([p.func, p.object])
+  }),
+  /**
+   * The components used for each slot inside the Modal.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: p.shape({
+    backdrop: p.elementType,
+    root: p.elementType
+  })
+});
+export {
+  uo as M,
+  zn as P
+};