@blockend/widget 1.0.60 → 1.0.61

package/dist/getChainIds-DXEtLb1g.js

@@ -0,0 +1,1888 @@
+import { P as e, d as M, _ as Z, p as z, e as U, b as he, i as me, s as ee, E as Pe, g as ke, h as Me, u as ln, l as cn } from "./index-BYmiFoJh.js";
+import * as u from "react";
+import ue, { isValidElement as de, cloneElement as pe, Children as un } from "react";
+import { jsx as A, jsxs as Ne } from "react/jsx-runtime";
+import { h as dn, o as Y, _ as pn, p as Le, q as fn, b as re, s as hn, l as Q, r as mn, j as bn, T as gn, n as We, t as Ve, v as En, w as we, x as yn, y as Tn, m as Ae, P as Rn, H as xn } from "./useRegisterError-DGMdKFc9.js";
+import { getWallet as vn, WalletType as Cn } from "graz";
+function Pn(n) {
+  const {
+    prototype: t = {}
+  } = n;
+  return !!t.isReactComponent;
+}
+function kn(n, t, s, o, i) {
+  const r = n[t], a = i || t;
+  if (r == 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 l;
+  return typeof r == "function" && !Pn(r) && (l = "Did you accidentally provide a plain function component instead?"), l !== void 0 ? new Error(`Invalid ${o} \`${a}\` supplied to \`${s}\`. Expected an element type that can hold a ref. ${l} For more information see https://mui.com/r/caveat-with-refs-guide`) : null;
+}
+const Mn = dn(e.elementType, kn);
+function _e(...n) {
+  return n.reduce((t, s) => s == null ? t : function(...i) {
+    t.apply(this, i), s.apply(this, i);
+  }, () => {
+  });
+}
+function Se(n) {
+  return Y(n).defaultView || window;
+}
+function Nn(n) {
+  const t = n.documentElement.clientWidth;
+  return Math.abs(window.innerWidth - t);
+}
+function wn(n) {
+  if (n === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return n;
+}
+function Ie(n, t) {
+  var s = function(r) {
+    return t && de(r) ? t(r) : r;
+  }, o = /* @__PURE__ */ Object.create(null);
+  return n && un.map(n, function(i) {
+    return i;
+  }).forEach(function(i) {
+    o[i.key] = s(i);
+  }), o;
+}
+function Sn(n, t) {
+  n = n || {}, t = t || {};
+  function s(b) {
+    return b in t ? t[b] : n[b];
+  }
+  var o = /* @__PURE__ */ Object.create(null), i = [];
+  for (var r in n)
+    r in t ? i.length && (o[r] = i, i = []) : i.push(r);
+  var a, l = {};
+  for (var c in t) {
+    if (o[c])
+      for (a = 0; a < o[c].length; a++) {
+        var d = o[c][a];
+        l[o[c][a]] = s(d);
+      }
+    l[c] = s(c);
+  }
+  for (a = 0; a < i.length; a++)
+    l[i[a]] = s(i[a]);
+  return l;
+}
+function X(n, t, s) {
+  return s[t] != null ? s[t] : n.props[t];
+}
+function In(n, t) {
+  return Ie(n.children, function(s) {
+    return pe(s, {
+      onExited: t.bind(null, s),
+      in: !0,
+      appear: X(s, "appear", n),
+      enter: X(s, "enter", n),
+      exit: X(s, "exit", n)
+    });
+  });
+}
+function On(n, t, s) {
+  var o = Ie(n.children), i = Sn(t, o);
+  return Object.keys(i).forEach(function(r) {
+    var a = i[r];
+    if (de(a)) {
+      var l = r in t, c = r in o, d = t[r], b = de(d) && !d.props.in;
+      c && (!l || b) ? i[r] = pe(a, {
+        onExited: s.bind(null, a),
+        in: !0,
+        exit: X(a, "exit", n),
+        enter: X(a, "enter", n)
+      }) : !c && l && !b ? i[r] = pe(a, {
+        in: !1
+      }) : c && l && de(d) && (i[r] = pe(a, {
+        onExited: s.bind(null, a),
+        in: d.props.in,
+        exit: X(a, "exit", n),
+        enter: X(a, "enter", n)
+      }));
+    }
+  }), i;
+}
+var Bn = Object.values || function(n) {
+  return Object.keys(n).map(function(t) {
+    return n[t];
+  });
+}, Fn = {
+  component: "div",
+  childFactory: function(t) {
+    return t;
+  }
+}, Oe = /* @__PURE__ */ function(n) {
+  pn(t, n);
+  function t(o, i) {
+    var r;
+    r = n.call(this, o, i) || this;
+    var a = r.handleExited.bind(wn(r));
+    return r.state = {
+      contextValue: {
+        isMounting: !0
+      },
+      handleExited: a,
+      firstRender: !0
+    }, r;
+  }
+  var s = t.prototype;
+  return s.componentDidMount = function() {
+    this.mounted = !0, this.setState({
+      contextValue: {
+        isMounting: !1
+      }
+    });
+  }, s.componentWillUnmount = function() {
+    this.mounted = !1;
+  }, t.getDerivedStateFromProps = function(i, r) {
+    var a = r.children, l = r.handleExited, c = r.firstRender;
+    return {
+      children: c ? In(i, l) : On(i, a, l),
+      firstRender: !1
+    };
+  }, s.handleExited = function(i, r) {
+    var a = Ie(this.props.children);
+    i.key in a || (i.props.onExited && i.props.onExited(r), this.mounted && this.setState(function(l) {
+      var c = M({}, l.children);
+      return delete c[i.key], {
+        children: c
+      };
+    }));
+  }, s.render = function() {
+    var i = this.props, r = i.component, a = i.childFactory, l = Z(i, ["component", "childFactory"]), c = this.state.contextValue, d = Bn(this.state.children).map(a);
+    return delete l.appear, delete l.enter, delete l.exit, r === null ? /* @__PURE__ */ ue.createElement(Le.Provider, {
+      value: c
+    }, d) : /* @__PURE__ */ ue.createElement(Le.Provider, {
+      value: c
+    }, /* @__PURE__ */ ue.createElement(r, l, d));
+  }, t;
+}(ue.Component);
+Oe.propTypes = z.env.NODE_ENV !== "production" ? {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: e.any,
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: e.node,
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: e.bool,
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: e.bool,
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: e.bool,
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: e.func
+} : {};
+Oe.defaultProps = Fn;
+function qe(n) {
+  const {
+    className: t,
+    classes: s,
+    pulsate: o = !1,
+    rippleX: i,
+    rippleY: r,
+    rippleSize: a,
+    in: l,
+    onExited: c,
+    timeout: d
+  } = n, [b, y] = u.useState(!1), x = U(t, s.ripple, s.rippleVisible, o && s.ripplePulsate), v = {
+    width: a,
+    height: a,
+    top: -(a / 2) + r,
+    left: -(a / 2) + i
+  }, p = U(s.child, b && s.childLeaving, o && s.childPulsate);
+  return !l && !b && y(!0), u.useEffect(() => {
+    if (!l && c != null) {
+      const w = setTimeout(c, d);
+      return () => {
+        clearTimeout(w);
+      };
+    }
+  }, [c, l, d]), /* @__PURE__ */ A("span", {
+    className: x,
+    style: v,
+    children: /* @__PURE__ */ A("span", {
+      className: p
+    })
+  });
+}
+z.env.NODE_ENV !== "production" && (qe.propTypes = {
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object.isRequired,
+  className: e.string,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  in: e.bool,
+  /**
+   * @ignore - injected from TransitionGroup
+   */
+  onExited: e.func,
+  /**
+   * If `true`, the ripple pulsates, typically indicating the keyboard focus state of an element.
+   */
+  pulsate: e.bool,
+  /**
+   * Diameter of the ripple.
+   */
+  rippleSize: e.number,
+  /**
+   * Horizontal position of the ripple center.
+   */
+  rippleX: e.number,
+  /**
+   * Vertical position of the ripple center.
+   */
+  rippleY: e.number,
+  /**
+   * exit delay
+   */
+  timeout: e.number.isRequired
+});
+const H = he("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]), Dn = ["center", "classes", "className"];
+let be = (n) => n, $e, je, Ue, He;
+const Ce = 550, Ln = 80, Vn = Pe($e || ($e = be`
+  0% {
+    transform: scale(0);
+    opacity: 0.1;
+  }
+
+  100% {
+    transform: scale(1);
+    opacity: 0.3;
+  }
+`)), An = Pe(je || (je = be`
+  0% {
+    opacity: 1;
+  }
+
+  100% {
+    opacity: 0;
+  }
+`)), _n = Pe(Ue || (Ue = be`
+  0% {
+    transform: scale(1);
+  }
+
+  50% {
+    transform: scale(0.92);
+  }
+
+  100% {
+    transform: scale(1);
+  }
+`)), $n = ee("span", {
+  name: "MuiTouchRipple",
+  slot: "Root"
+})({
+  overflow: "hidden",
+  pointerEvents: "none",
+  position: "absolute",
+  zIndex: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  borderRadius: "inherit"
+}), jn = ee(qe, {
+  name: "MuiTouchRipple",
+  slot: "Ripple"
+})(He || (He = be`
+  opacity: 0;
+  position: absolute;
+
+  &.${0} {
+    opacity: 0.3;
+    transform: scale(1);
+    animation-name: ${0};
+    animation-duration: ${0}ms;
+    animation-timing-function: ${0};
+  }
+
+  &.${0} {
+    animation-duration: ${0}ms;
+  }
+
+  & .${0} {
+    opacity: 1;
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: 50%;
+    background-color: currentColor;
+  }
+
+  & .${0} {
+    opacity: 0;
+    animation-name: ${0};
+    animation-duration: ${0}ms;
+    animation-timing-function: ${0};
+  }
+
+  & .${0} {
+    position: absolute;
+    /* @noflip */
+    left: 0px;
+    top: 0;
+    animation-name: ${0};
+    animation-duration: 2500ms;
+    animation-timing-function: ${0};
+    animation-iteration-count: infinite;
+    animation-delay: 200ms;
+  }
+`), H.rippleVisible, Vn, Ce, ({
+  theme: n
+}) => n.transitions.easing.easeInOut, H.ripplePulsate, ({
+  theme: n
+}) => n.transitions.duration.shorter, H.child, H.childLeaving, An, Ce, ({
+  theme: n
+}) => n.transitions.easing.easeInOut, H.childPulsate, _n, ({
+  theme: n
+}) => n.transitions.easing.easeInOut), Ye = /* @__PURE__ */ u.forwardRef(function(t, s) {
+  const o = me({
+    props: t,
+    name: "MuiTouchRipple"
+  }), {
+    center: i = !1,
+    classes: r = {},
+    className: a
+  } = o, l = Z(o, Dn), [c, d] = u.useState([]), b = u.useRef(0), y = u.useRef(null);
+  u.useEffect(() => {
+    y.current && (y.current(), y.current = null);
+  }, [c]);
+  const x = u.useRef(!1), v = fn(), p = u.useRef(null), w = u.useRef(null), B = u.useCallback((f) => {
+    const {
+      pulsate: T,
+      rippleX: C,
+      rippleY: k,
+      rippleSize: I,
+      cb: _
+    } = f;
+    d((P) => [...P, /* @__PURE__ */ A(jn, {
+      classes: {
+        ripple: U(r.ripple, H.ripple),
+        rippleVisible: U(r.rippleVisible, H.rippleVisible),
+        ripplePulsate: U(r.ripplePulsate, H.ripplePulsate),
+        child: U(r.child, H.child),
+        childLeaving: U(r.childLeaving, H.childLeaving),
+        childPulsate: U(r.childPulsate, H.childPulsate)
+      },
+      timeout: Ce,
+      pulsate: T,
+      rippleX: C,
+      rippleY: k,
+      rippleSize: I
+    }, b.current)]), b.current += 1, y.current = _;
+  }, [r]), S = u.useCallback((f = {}, T = {}, C = () => {
+  }) => {
+    const {
+      pulsate: k = !1,
+      center: I = i || T.pulsate,
+      fakeElement: _ = !1
+      // For test purposes
+    } = T;
+    if ((f == null ? void 0 : f.type) === "mousedown" && x.current) {
+      x.current = !1;
+      return;
+    }
+    (f == null ? void 0 : f.type) === "touchstart" && (x.current = !0);
+    const P = _ ? null : w.current, V = P ? P.getBoundingClientRect() : {
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0
+    };
+    let D, L, E;
+    if (I || f === void 0 || f.clientX === 0 && f.clientY === 0 || !f.clientX && !f.touches)
+      D = Math.round(V.width / 2), L = Math.round(V.height / 2);
+    else {
+      const {
+        clientX: O,
+        clientY: g
+      } = f.touches && f.touches.length > 0 ? f.touches[0] : f;
+      D = Math.round(O - V.left), L = Math.round(g - V.top);
+    }
+    if (I)
+      E = Math.sqrt((2 * V.width ** 2 + V.height ** 2) / 3), E % 2 === 0 && (E += 1);
+    else {
+      const O = Math.max(Math.abs((P ? P.clientWidth : 0) - D), D) * 2 + 2, g = Math.max(Math.abs((P ? P.clientHeight : 0) - L), L) * 2 + 2;
+      E = Math.sqrt(O ** 2 + g ** 2);
+    }
+    f != null && f.touches ? p.current === null && (p.current = () => {
+      B({
+        pulsate: k,
+        rippleX: D,
+        rippleY: L,
+        rippleSize: E,
+        cb: C
+      });
+    }, v.start(Ln, () => {
+      p.current && (p.current(), p.current = null);
+    })) : B({
+      pulsate: k,
+      rippleX: D,
+      rippleY: L,
+      rippleSize: E,
+      cb: C
+    });
+  }, [i, B, v]), F = u.useCallback(() => {
+    S({}, {
+      pulsate: !0
+    });
+  }, [S]), h = u.useCallback((f, T) => {
+    if (v.clear(), (f == null ? void 0 : f.type) === "touchend" && p.current) {
+      p.current(), p.current = null, v.start(0, () => {
+        h(f, T);
+      });
+      return;
+    }
+    p.current = null, d((C) => C.length > 0 ? C.slice(1) : C), y.current = T;
+  }, [v]);
+  return u.useImperativeHandle(s, () => ({
+    pulsate: F,
+    start: S,
+    stop: h
+  }), [F, S, h]), /* @__PURE__ */ A($n, M({
+    className: U(H.root, r.root, a),
+    ref: w
+  }, l, {
+    children: /* @__PURE__ */ A(Oe, {
+      component: null,
+      exit: !0,
+      children: c
+    })
+  }));
+});
+z.env.NODE_ENV !== "production" && (Ye.propTypes = {
+  /**
+   * If `true`, the ripple starts at the center of the component
+   * rather than at the point of interaction.
+   */
+  center: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string
+});
+function Un(n) {
+  return ke("MuiButtonBase", n);
+}
+const Hn = he("MuiButtonBase", ["root", "disabled", "focusVisible"]), Kn = ["action", "centerRipple", "children", "className", "component", "disabled", "disableRipple", "disableTouchRipple", "focusRipple", "focusVisibleClassName", "LinkComponent", "onBlur", "onClick", "onContextMenu", "onDragLeave", "onFocus", "onFocusVisible", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseLeave", "onMouseUp", "onTouchEnd", "onTouchMove", "onTouchStart", "tabIndex", "TouchRippleProps", "touchRippleRef", "type"], zn = (n) => {
+  const {
+    disabled: t,
+    focusVisible: s,
+    focusVisibleClassName: o,
+    classes: i
+  } = n, a = Me({
+    root: ["root", t && "disabled", s && "focusVisible"]
+  }, Un, i);
+  return s && o && (a.root += ` ${o}`), a;
+}, Wn = ee("button", {
+  name: "MuiButtonBase",
+  slot: "Root",
+  overridesResolver: (n, t) => t.root
+})({
+  display: "inline-flex",
+  alignItems: "center",
+  justifyContent: "center",
+  position: "relative",
+  boxSizing: "border-box",
+  WebkitTapHighlightColor: "transparent",
+  backgroundColor: "transparent",
+  // Reset default value
+  // We disable the focus ring for mouse, touch and keyboard users.
+  outline: 0,
+  border: 0,
+  margin: 0,
+  // Remove the margin in Safari
+  borderRadius: 0,
+  padding: 0,
+  // Remove the padding in Firefox
+  cursor: "pointer",
+  userSelect: "none",
+  verticalAlign: "middle",
+  MozAppearance: "none",
+  // Reset
+  WebkitAppearance: "none",
+  // Reset
+  textDecoration: "none",
+  // So we take precedent over the style of a native <a /> element.
+  color: "inherit",
+  "&::-moz-focus-inner": {
+    borderStyle: "none"
+    // Remove Firefox dotted outline.
+  },
+  [`&.${Hn.disabled}`]: {
+    pointerEvents: "none",
+    // Disable link interactions
+    cursor: "default"
+  },
+  "@media print": {
+    colorAdjust: "exact"
+  }
+}), qn = /* @__PURE__ */ u.forwardRef(function(t, s) {
+  const o = me({
+    props: t,
+    name: "MuiButtonBase"
+  }), {
+    action: i,
+    centerRipple: r = !1,
+    children: a,
+    className: l,
+    component: c = "button",
+    disabled: d = !1,
+    disableRipple: b = !1,
+    disableTouchRipple: y = !1,
+    focusRipple: x = !1,
+    LinkComponent: v = "a",
+    onBlur: p,
+    onClick: w,
+    onContextMenu: B,
+    onDragLeave: S,
+    onFocus: F,
+    onFocusVisible: h,
+    onKeyDown: f,
+    onKeyUp: T,
+    onMouseDown: C,
+    onMouseLeave: k,
+    onMouseUp: I,
+    onTouchEnd: _,
+    onTouchMove: P,
+    onTouchStart: V,
+    tabIndex: D = 0,
+    TouchRippleProps: L,
+    touchRippleRef: E,
+    type: O
+  } = o, g = Z(o, Kn), R = u.useRef(null), N = u.useRef(null), ge = re(N, E), {
+    isFocusVisibleRef: se,
+    onFocus: Ee,
+    onBlur: ie,
+    ref: ae
+  } = hn(), [$, K] = u.useState(!1);
+  d && $ && K(!1), u.useImperativeHandle(i, () => ({
+    focusVisible: () => {
+      K(!0), R.current.focus();
+    }
+  }), []);
+  const [W, le] = u.useState(!1);
+  u.useEffect(() => {
+    le(!0);
+  }, []);
+  const G = W && !b && !d;
+  u.useEffect(() => {
+    $ && x && !b && W && N.current.pulsate();
+  }, [b, x, $, W]);
+  function j(m, Fe, an = y) {
+    return Q((De) => (Fe && Fe(De), !an && N.current && N.current[m](De), !0));
+  }
+  const ne = j("start", C), ye = j("stop", B), Te = j("stop", S), q = j("stop", I), J = j("stop", (m) => {
+    $ && m.preventDefault(), k && k(m);
+  }), Je = j("start", V), Qe = j("stop", _), Ze = j("stop", P), en = j("stop", (m) => {
+    ie(m), se.current === !1 && K(!1), p && p(m);
+  }, !1), nn = Q((m) => {
+    R.current || (R.current = m.currentTarget), Ee(m), se.current === !0 && (K(!0), h && h(m)), F && F(m);
+  }), Re = () => {
+    const m = R.current;
+    return c && c !== "button" && !(m.tagName === "A" && m.href);
+  }, xe = u.useRef(!1), tn = Q((m) => {
+    x && !xe.current && $ && N.current && m.key === " " && (xe.current = !0, N.current.stop(m, () => {
+      N.current.start(m);
+    })), m.target === m.currentTarget && Re() && m.key === " " && m.preventDefault(), f && f(m), m.target === m.currentTarget && Re() && m.key === "Enter" && !d && (m.preventDefault(), w && w(m));
+  }), on = Q((m) => {
+    x && m.key === " " && N.current && $ && !m.defaultPrevented && (xe.current = !1, N.current.stop(m, () => {
+      N.current.pulsate(m);
+    })), T && T(m), w && m.target === m.currentTarget && Re() && m.key === " " && !m.defaultPrevented && w(m);
+  });
+  let ce = c;
+  ce === "button" && (g.href || g.to) && (ce = v);
+  const te = {};
+  ce === "button" ? (te.type = O === void 0 ? "button" : O, te.disabled = d) : (!g.href && !g.to && (te.role = "button"), d && (te["aria-disabled"] = d));
+  const rn = re(s, ae, R);
+  z.env.NODE_ENV !== "production" && u.useEffect(() => {
+    G && N.current;
+  }, [G]);
+  const Be = M({}, o, {
+    centerRipple: r,
+    component: c,
+    disabled: d,
+    disableRipple: b,
+    disableTouchRipple: y,
+    focusRipple: x,
+    tabIndex: D,
+    focusVisible: $
+  }), sn = zn(Be);
+  return /* @__PURE__ */ Ne(Wn, M({
+    as: ce,
+    className: U(sn.root, l),
+    ownerState: Be,
+    onBlur: en,
+    onClick: w,
+    onContextMenu: ye,
+    onFocus: nn,
+    onKeyDown: tn,
+    onKeyUp: on,
+    onMouseDown: ne,
+    onMouseLeave: J,
+    onMouseUp: q,
+    onDragLeave: Te,
+    onTouchEnd: Qe,
+    onTouchMove: Ze,
+    onTouchStart: Je,
+    ref: rn,
+    tabIndex: d ? -1 : D,
+    type: O
+  }, te, g, {
+    children: [a, G ? (
+      /* TouchRipple is only needed client-side, x2 boost on the server. */
+      /* @__PURE__ */ A(Ye, M({
+        ref: ge,
+        center: r
+      }, L))
+    ) : null]
+  }));
+});
+z.env.NODE_ENV !== "production" && (qn.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A ref for imperative actions.
+   * It currently only supports `focusVisible()` action.
+   */
+  action: mn,
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: e.bool,
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: Mn,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: e.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: e.bool,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: e.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: e.string,
+  /**
+   * @ignore
+   */
+  href: e.any,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: e.elementType,
+  /**
+   * @ignore
+   */
+  onBlur: e.func,
+  /**
+   * @ignore
+   */
+  onClick: e.func,
+  /**
+   * @ignore
+   */
+  onContextMenu: e.func,
+  /**
+   * @ignore
+   */
+  onDragLeave: e.func,
+  /**
+   * @ignore
+   */
+  onFocus: e.func,
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: e.func,
+  /**
+   * @ignore
+   */
+  onKeyDown: e.func,
+  /**
+   * @ignore
+   */
+  onKeyUp: e.func,
+  /**
+   * @ignore
+   */
+  onMouseDown: e.func,
+  /**
+   * @ignore
+   */
+  onMouseLeave: e.func,
+  /**
+   * @ignore
+   */
+  onMouseUp: e.func,
+  /**
+   * @ignore
+   */
+  onTouchEnd: e.func,
+  /**
+   * @ignore
+   */
+  onTouchMove: e.func,
+  /**
+   * @ignore
+   */
+  onTouchStart: e.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * @default 0
+   */
+  tabIndex: e.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: e.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: e.oneOfType([e.func, e.shape({
+    current: e.shape({
+      pulsate: e.func.isRequired,
+      start: e.func.isRequired,
+      stop: e.func.isRequired
+    })
+  })]),
+  /**
+   * @ignore
+   */
+  type: e.oneOfType([e.oneOf(["button", "reset", "submit"]), e.string])
+});
+const Yn = ["addEndListener", "appear", "children", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"], Xn = {
+  entering: {
+    opacity: 1
+  },
+  entered: {
+    opacity: 1
+  }
+}, Xe = /* @__PURE__ */ u.forwardRef(function(t, s) {
+  const o = bn(), i = {
+    enter: o.transitions.duration.enteringScreen,
+    exit: o.transitions.duration.leavingScreen
+  }, {
+    addEndListener: r,
+    appear: a = !0,
+    children: l,
+    easing: c,
+    in: d,
+    onEnter: b,
+    onEntered: y,
+    onEntering: x,
+    onExit: v,
+    onExited: p,
+    onExiting: w,
+    style: B,
+    timeout: S = i,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: F = gn
+  } = t, h = Z(t, Yn), f = u.useRef(null), T = re(f, We(l), s), C = (E) => (O) => {
+    if (E) {
+      const g = f.current;
+      O === void 0 ? E(g) : E(g, O);
+    }
+  }, k = C(x), I = C((E, O) => {
+    En(E);
+    const g = Ve({
+      style: B,
+      timeout: S,
+      easing: c
+    }, {
+      mode: "enter"
+    });
+    E.style.webkitTransition = o.transitions.create("opacity", g), E.style.transition = o.transitions.create("opacity", g), b && b(E, O);
+  }), _ = C(y), P = C(w), V = C((E) => {
+    const O = Ve({
+      style: B,
+      timeout: S,
+      easing: c
+    }, {
+      mode: "exit"
+    });
+    E.style.webkitTransition = o.transitions.create("opacity", O), E.style.transition = o.transitions.create("opacity", O), v && v(E);
+  }), D = C(p);
+  return /* @__PURE__ */ A(F, M({
+    appear: a,
+    in: d,
+    nodeRef: f,
+    onEnter: I,
+    onEntered: _,
+    onEntering: k,
+    onExit: V,
+    onExited: D,
+    onExiting: P,
+    addEndListener: (E) => {
+      r && r(f.current, E);
+    },
+    timeout: S
+  }, h, {
+    children: (E, O) => /* @__PURE__ */ u.cloneElement(l, M({
+      style: M({
+        opacity: 0,
+        visibility: E === "exited" && !d ? "hidden" : void 0
+      }, Xn[E], B, l.props.style),
+      ref: T
+    }, O))
+  }));
+});
+z.env.NODE_ENV !== "production" && (Xe.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: e.func,
+  /**
+   * Perform the enter transition when it first mounts if `in` is also `true`.
+   * Set this to `false` to disable this behavior.
+   * @default true
+   */
+  appear: e.bool,
+  /**
+   * A single child content element.
+   */
+  children: we.isRequired,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: e.oneOfType([e.shape({
+    enter: e.string,
+    exit: e.string
+  }), e.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: e.bool,
+  /**
+   * @ignore
+   */
+  onEnter: e.func,
+  /**
+   * @ignore
+   */
+  onEntered: e.func,
+  /**
+   * @ignore
+   */
+  onEntering: e.func,
+  /**
+   * @ignore
+   */
+  onExit: e.func,
+  /**
+   * @ignore
+   */
+  onExited: e.func,
+  /**
+   * @ignore
+   */
+  onExiting: e.func,
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   * @default {
+   *   enter: theme.transitions.duration.enteringScreen,
+   *   exit: theme.transitions.duration.leavingScreen,
+   * }
+   */
+  timeout: e.oneOfType([e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+function Gn(n) {
+  return ke("MuiBackdrop", n);
+}
+he("MuiBackdrop", ["root", "invisible"]);
+const Jn = ["children", "className", "component", "components", "componentsProps", "invisible", "open", "slotProps", "slots", "TransitionComponent", "transitionDuration"], Qn = (n) => {
+  const {
+    classes: t,
+    invisible: s
+  } = n;
+  return Me({
+    root: ["root", s && "invisible"]
+  }, Gn, t);
+}, Zn = ee("div", {
+  name: "MuiBackdrop",
+  slot: "Root",
+  overridesResolver: (n, t) => {
+    const {
+      ownerState: s
+    } = n;
+    return [t.root, s.invisible && t.invisible];
+  }
+})(({
+  ownerState: n
+}) => M({
+  position: "fixed",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  right: 0,
+  bottom: 0,
+  top: 0,
+  left: 0,
+  backgroundColor: "rgba(0, 0, 0, 0.5)",
+  WebkitTapHighlightColor: "transparent"
+}, n.invisible && {
+  backgroundColor: "transparent"
+})), Ge = /* @__PURE__ */ u.forwardRef(function(t, s) {
+  var o, i, r;
+  const a = me({
+    props: t,
+    name: "MuiBackdrop"
+  }), {
+    children: l,
+    className: c,
+    component: d = "div",
+    components: b = {},
+    componentsProps: y = {},
+    invisible: x = !1,
+    open: v,
+    slotProps: p = {},
+    slots: w = {},
+    TransitionComponent: B = Xe,
+    transitionDuration: S
+  } = a, F = Z(a, Jn), h = M({}, a, {
+    component: d,
+    invisible: x
+  }), f = Qn(h), T = (o = p.root) != null ? o : y.root;
+  return /* @__PURE__ */ A(B, M({
+    in: v,
+    timeout: S
+  }, F, {
+    children: /* @__PURE__ */ A(Zn, M({
+      "aria-hidden": !0
+    }, T, {
+      as: (i = (r = w.root) != null ? r : b.Root) != null ? i : d,
+      className: U(f.root, c, T == null ? void 0 : T.className),
+      ownerState: M({}, h, T == null ? void 0 : T.ownerState),
+      classes: f,
+      ref: s,
+      children: l
+    }))
+  }));
+});
+z.env.NODE_ENV !== "production" && (Ge.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * The components used for each slot inside.
+   *
+   * This prop is an alias for the `slots` prop.
+   * It's recommended to use the `slots` prop instead.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Root: e.elementType
+  }),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `slotProps` prop.
+   * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    root: e.object
+  }),
+  /**
+   * If `true`, the backdrop is invisible.
+   * It can be used when rendering a popover or a custom select component.
+   * @default false
+   */
+  invisible: e.bool,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool.isRequired,
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `componentsProps` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slotProps: e.shape({
+    root: e.object
+  }),
+  /**
+   * The components used for each slot inside.
+   *
+   * This prop is an alias for the `components` prop, which will be deprecated in the future.
+   *
+   * @default {}
+   */
+  slots: e.shape({
+    root: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @default Fade
+   */
+  TransitionComponent: e.elementType,
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   */
+  transitionDuration: e.oneOfType([e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+function et(n) {
+  const t = Y(n);
+  return t.body === n ? Se(n).innerWidth > t.documentElement.clientWidth : n.scrollHeight > n.clientHeight;
+}
+function oe(n, t) {
+  t ? n.setAttribute("aria-hidden", "true") : n.removeAttribute("aria-hidden");
+}
+function Ke(n) {
+  return parseInt(Se(n).getComputedStyle(n).paddingRight, 10) || 0;
+}
+function nt(n) {
+  const s = ["TEMPLATE", "SCRIPT", "STYLE", "LINK", "MAP", "META", "NOSCRIPT", "PICTURE", "COL", "COLGROUP", "PARAM", "SLOT", "SOURCE", "TRACK"].indexOf(n.tagName) !== -1, o = n.tagName === "INPUT" && n.getAttribute("type") === "hidden";
+  return s || o;
+}
+function ze(n, t, s, o, i) {
+  const r = [t, s, ...o];
+  [].forEach.call(n.children, (a) => {
+    const l = r.indexOf(a) === -1, c = !nt(a);
+    l && c && oe(a, i);
+  });
+}
+function ve(n, t) {
+  let s = -1;
+  return n.some((o, i) => t(o) ? (s = i, !0) : !1), s;
+}
+function tt(n, t) {
+  const s = [], o = n.container;
+  if (!t.disableScrollLock) {
+    if (et(o)) {
+      const a = Nn(Y(o));
+      s.push({
+        value: o.style.paddingRight,
+        property: "padding-right",
+        el: o
+      }), o.style.paddingRight = `${Ke(o) + a}px`;
+      const l = Y(o).querySelectorAll(".mui-fixed");
+      [].forEach.call(l, (c) => {
+        s.push({
+          value: c.style.paddingRight,
+          property: "padding-right",
+          el: c
+        }), c.style.paddingRight = `${Ke(c) + a}px`;
+      });
+    }
+    let r;
+    if (o.parentNode instanceof DocumentFragment)
+      r = Y(o).body;
+    else {
+      const a = o.parentElement, l = Se(o);
+      r = (a == null ? void 0 : a.nodeName) === "HTML" && l.getComputedStyle(a).overflowY === "scroll" ? a : o;
+    }
+    s.push({
+      value: r.style.overflow,
+      property: "overflow",
+      el: r
+    }, {
+      value: r.style.overflowX,
+      property: "overflow-x",
+      el: r
+    }, {
+      value: r.style.overflowY,
+      property: "overflow-y",
+      el: r
+    }), r.style.overflow = "hidden";
+  }
+  return () => {
+    s.forEach(({
+      value: r,
+      el: a,
+      property: l
+    }) => {
+      r ? a.style.setProperty(l, r) : a.style.removeProperty(l);
+    });
+  };
+}
+function ot(n) {
+  const t = [];
+  return [].forEach.call(n.children, (s) => {
+    s.getAttribute("aria-hidden") === "true" && t.push(s);
+  }), t;
+}
+class rt {
+  constructor() {
+    this.containers = void 0, this.modals = void 0, this.modals = [], this.containers = [];
+  }
+  add(t, s) {
+    let o = this.modals.indexOf(t);
+    if (o !== -1)
+      return o;
+    o = this.modals.length, this.modals.push(t), t.modalRef && oe(t.modalRef, !1);
+    const i = ot(s);
+    ze(s, t.mount, t.modalRef, i, !0);
+    const r = ve(this.containers, (a) => a.container === s);
+    return r !== -1 ? (this.containers[r].modals.push(t), o) : (this.containers.push({
+      modals: [t],
+      container: s,
+      restore: null,
+      hiddenSiblings: i
+    }), o);
+  }
+  mount(t, s) {
+    const o = ve(this.containers, (r) => r.modals.indexOf(t) !== -1), i = this.containers[o];
+    i.restore || (i.restore = tt(i, s));
+  }
+  remove(t, s = !0) {
+    const o = this.modals.indexOf(t);
+    if (o === -1)
+      return o;
+    const i = ve(this.containers, (a) => a.modals.indexOf(t) !== -1), r = this.containers[i];
+    if (r.modals.splice(r.modals.indexOf(t), 1), this.modals.splice(o, 1), r.modals.length === 0)
+      r.restore && r.restore(), t.modalRef && oe(t.modalRef, s), ze(r.container, t.mount, t.modalRef, r.hiddenSiblings, !1), this.containers.splice(i, 1);
+    else {
+      const a = r.modals[r.modals.length - 1];
+      a.modalRef && oe(a.modalRef, !1);
+    }
+    return o;
+  }
+  isTopModal(t) {
+    return this.modals.length > 0 && this.modals[this.modals.length - 1] === t;
+  }
+}
+const st = ["input", "select", "textarea", "a[href]", "button", "[tabindex]", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])'].join(",");
+function it(n) {
+  const t = parseInt(n.getAttribute("tabindex") || "", 10);
+  return Number.isNaN(t) ? n.contentEditable === "true" || (n.nodeName === "AUDIO" || n.nodeName === "VIDEO" || n.nodeName === "DETAILS") && n.getAttribute("tabindex") === null ? 0 : n.tabIndex : t;
+}
+function at(n) {
+  if (n.tagName !== "INPUT" || n.type !== "radio" || !n.name)
+    return !1;
+  const t = (o) => n.ownerDocument.querySelector(`input[type="radio"]${o}`);
+  let s = t(`[name="${n.name}"]:checked`);
+  return s || (s = t(`[name="${n.name}"]`)), s !== n;
+}
+function lt(n) {
+  return !(n.disabled || n.tagName === "INPUT" && n.type === "hidden" || at(n));
+}
+function ct(n) {
+  const t = [], s = [];
+  return Array.from(n.querySelectorAll(st)).forEach((o, i) => {
+    const r = it(o);
+    r === -1 || !lt(o) || (r === 0 ? t.push(o) : s.push({
+      documentOrder: i,
+      tabIndex: r,
+      node: o
+    }));
+  }), s.sort((o, i) => o.tabIndex === i.tabIndex ? o.documentOrder - i.documentOrder : o.tabIndex - i.tabIndex).map((o) => o.node).concat(t);
+}
+function ut() {
+  return !0;
+}
+function fe(n) {
+  const {
+    children: t,
+    disableAutoFocus: s = !1,
+    disableEnforceFocus: o = !1,
+    disableRestoreFocus: i = !1,
+    getTabbable: r = ct,
+    isEnabled: a = ut,
+    open: l
+  } = n, c = u.useRef(!1), d = u.useRef(null), b = u.useRef(null), y = u.useRef(null), x = u.useRef(null), v = u.useRef(!1), p = u.useRef(null), w = re(We(t), p), B = u.useRef(null);
+  u.useEffect(() => {
+    !l || !p.current || (v.current = !s);
+  }, [s, l]), u.useEffect(() => {
+    if (!l || !p.current)
+      return;
+    const h = Y(p.current);
+    return p.current.contains(h.activeElement) || (p.current.hasAttribute("tabIndex") || (z.env.NODE_ENV, p.current.setAttribute("tabIndex", "-1")), v.current && p.current.focus()), () => {
+      i || (y.current && y.current.focus && (c.current = !0, y.current.focus()), y.current = null);
+    };
+  }, [l]), u.useEffect(() => {
+    if (!l || !p.current)
+      return;
+    const h = Y(p.current), f = (k) => {
+      B.current = k, !(o || !a() || k.key !== "Tab") && h.activeElement === p.current && k.shiftKey && (c.current = !0, b.current && b.current.focus());
+    }, T = () => {
+      const k = p.current;
+      if (k === null)
+        return;
+      if (!h.hasFocus() || !a() || c.current) {
+        c.current = !1;
+        return;
+      }
+      if (k.contains(h.activeElement) || o && h.activeElement !== d.current && h.activeElement !== b.current)
+        return;
+      if (h.activeElement !== x.current)
+        x.current = null;
+      else if (x.current !== null)
+        return;
+      if (!v.current)
+        return;
+      let I = [];
+      if ((h.activeElement === d.current || h.activeElement === b.current) && (I = r(p.current)), I.length > 0) {
+        var _, P;
+        const V = !!((_ = B.current) != null && _.shiftKey && ((P = B.current) == null ? void 0 : P.key) === "Tab"), D = I[0], L = I[I.length - 1];
+        typeof D != "string" && typeof L != "string" && (V ? L.focus() : D.focus());
+      } else
+        k.focus();
+    };
+    h.addEventListener("focusin", T), h.addEventListener("keydown", f, !0);
+    const C = setInterval(() => {
+      h.activeElement && h.activeElement.tagName === "BODY" && T();
+    }, 50);
+    return () => {
+      clearInterval(C), h.removeEventListener("focusin", T), h.removeEventListener("keydown", f, !0);
+    };
+  }, [s, o, i, a, l, r]);
+  const S = (h) => {
+    y.current === null && (y.current = h.relatedTarget), v.current = !0, x.current = h.target;
+    const f = t.props.onFocus;
+    f && f(h);
+  }, F = (h) => {
+    y.current === null && (y.current = h.relatedTarget), v.current = !0;
+  };
+  return /* @__PURE__ */ Ne(u.Fragment, {
+    children: [/* @__PURE__ */ A("div", {
+      tabIndex: l ? 0 : -1,
+      onFocus: F,
+      ref: d,
+      "data-testid": "sentinelStart"
+    }), /* @__PURE__ */ u.cloneElement(t, {
+      ref: w,
+      onFocus: S
+    }), /* @__PURE__ */ A("div", {
+      tabIndex: l ? 0 : -1,
+      onFocus: F,
+      ref: b,
+      "data-testid": "sentinelEnd"
+    })]
+  });
+}
+z.env.NODE_ENV !== "production" && (fe.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: we,
+  /**
+   * If `true`, the focus trap will not automatically shift focus to itself when it opens, and
+   * replace it to the last focused element when it closes.
+   * This also works correctly with any focus trap children that have the `disableAutoFocus` prop.
+   *
+   * Generally this should never be set to `true` as it makes the focus trap less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableAutoFocus: e.bool,
+  /**
+   * If `true`, the focus trap will not prevent focus from leaving the focus trap while open.
+   *
+   * Generally this should never be set to `true` as it makes the focus trap less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableEnforceFocus: e.bool,
+  /**
+   * If `true`, the focus trap will not restore focus to previously focused element once
+   * focus trap is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: e.bool,
+  /**
+   * Returns an array of ordered tabbable nodes (i.e. in tab order) within the root.
+   * For instance, you can provide the "tabbable" npm dependency.
+   * @param {HTMLElement} root
+   */
+  getTabbable: e.func,
+  /**
+   * This prop extends the `open` prop.
+   * It allows to toggle the open state without having to wait for a rerender when changing the `open` prop.
+   * This prop should be memoized.
+   * It can be used to support multiple focus trap mounted at the same time.
+   * @default function defaultIsEnabled(): boolean {
+   *   return true;
+   * }
+   */
+  isEnabled: e.func,
+  /**
+   * If `true`, focus is locked.
+   */
+  open: e.bool.isRequired
+});
+z.env.NODE_ENV !== "production" && (fe.propTypes = yn(fe.propTypes));
+function dt(n) {
+  return typeof n == "function" ? n() : n;
+}
+function pt(n) {
+  return n ? n.props.hasOwnProperty("in") : !1;
+}
+const ft = new rt();
+function ht(n) {
+  const {
+    container: t,
+    disableEscapeKeyDown: s = !1,
+    disableScrollLock: o = !1,
+    // @ts-ignore internal logic - Base UI supports the manager as a prop too
+    manager: i = ft,
+    closeAfterTransition: r = !1,
+    onTransitionEnter: a,
+    onTransitionExited: l,
+    children: c,
+    onClose: d,
+    open: b,
+    rootRef: y
+  } = n, x = u.useRef({}), v = u.useRef(null), p = u.useRef(null), w = re(p, y), [B, S] = u.useState(!b), F = pt(c);
+  let h = !0;
+  (n["aria-hidden"] === "false" || n["aria-hidden"] === !1) && (h = !1);
+  const f = () => Y(v.current), T = () => (x.current.modalRef = p.current, x.current.mount = v.current, x.current), C = () => {
+    i.mount(T(), {
+      disableScrollLock: o
+    }), p.current && (p.current.scrollTop = 0);
+  }, k = Q(() => {
+    const g = dt(t) || f().body;
+    i.add(T(), g), p.current && C();
+  }), I = u.useCallback(() => i.isTopModal(T()), [i]), _ = Q((g) => {
+    v.current = g, g && (b && I() ? C() : p.current && oe(p.current, h));
+  }), P = u.useCallback(() => {
+    i.remove(T(), h);
+  }, [h, i]);
+  u.useEffect(() => () => {
+    P();
+  }, [P]), u.useEffect(() => {
+    b ? k() : (!F || !r) && P();
+  }, [b, P, F, r, k]);
+  const V = (g) => (R) => {
+    var N;
+    (N = g.onKeyDown) == null || N.call(g, R), !(R.key !== "Escape" || R.which === 229 || // Wait until IME is settled.
+    !I()) && (s || (R.stopPropagation(), d && d(R, "escapeKeyDown")));
+  }, D = (g) => (R) => {
+    var N;
+    (N = g.onClick) == null || N.call(g, R), R.target === R.currentTarget && d && d(R, "backdropClick");
+  };
+  return {
+    getRootProps: (g = {}) => {
+      const R = Tn(n);
+      delete R.onTransitionEnter, delete R.onTransitionExited;
+      const N = M({}, R, g);
+      return M({
+        role: "presentation"
+      }, N, {
+        onKeyDown: V(N),
+        ref: w
+      });
+    },
+    getBackdropProps: (g = {}) => {
+      const R = g;
+      return M({
+        "aria-hidden": !0
+      }, R, {
+        onClick: D(R),
+        open: b
+      });
+    },
+    getTransitionProps: () => {
+      const g = () => {
+        S(!1), a && a();
+      }, R = () => {
+        S(!0), l && l(), r && P();
+      };
+      return {
+        onEnter: _e(g, c == null ? void 0 : c.props.onEnter),
+        onExited: _e(R, c == null ? void 0 : c.props.onExited)
+      };
+    },
+    rootRef: w,
+    portalRef: _,
+    isTopModal: I,
+    exited: B,
+    hasTransition: F
+  };
+}
+function mt(n) {
+  return ke("MuiModal", n);
+}
+he("MuiModal", ["root", "hidden", "backdrop"]);
+const bt = ["BackdropComponent", "BackdropProps", "classes", "className", "closeAfterTransition", "children", "container", "component", "components", "componentsProps", "disableAutoFocus", "disableEnforceFocus", "disableEscapeKeyDown", "disablePortal", "disableRestoreFocus", "disableScrollLock", "hideBackdrop", "keepMounted", "onBackdropClick", "onClose", "onTransitionEnter", "onTransitionExited", "open", "slotProps", "slots", "theme"], gt = (n) => {
+  const {
+    open: t,
+    exited: s,
+    classes: o
+  } = n;
+  return Me({
+    root: ["root", !t && s && "hidden"],
+    backdrop: ["backdrop"]
+  }, mt, o);
+}, Et = ee("div", {
+  name: "MuiModal",
+  slot: "Root",
+  overridesResolver: (n, t) => {
+    const {
+      ownerState: s
+    } = n;
+    return [t.root, !s.open && s.exited && t.hidden];
+  }
+})(({
+  theme: n,
+  ownerState: t
+}) => M({
+  position: "fixed",
+  zIndex: (n.vars || n).zIndex.modal,
+  right: 0,
+  bottom: 0,
+  top: 0,
+  left: 0
+}, !t.open && t.exited && {
+  visibility: "hidden"
+})), yt = ee(Ge, {
+  name: "MuiModal",
+  slot: "Backdrop",
+  overridesResolver: (n, t) => t.backdrop
+})({
+  zIndex: -1
+}), Tt = /* @__PURE__ */ u.forwardRef(function(t, s) {
+  var o, i, r, a, l, c;
+  const d = me({
+    name: "MuiModal",
+    props: t
+  }), {
+    BackdropComponent: b = yt,
+    BackdropProps: y,
+    className: x,
+    closeAfterTransition: v = !1,
+    children: p,
+    container: w,
+    component: B,
+    components: S = {},
+    componentsProps: F = {},
+    disableAutoFocus: h = !1,
+    disableEnforceFocus: f = !1,
+    disableEscapeKeyDown: T = !1,
+    disablePortal: C = !1,
+    disableRestoreFocus: k = !1,
+    disableScrollLock: I = !1,
+    hideBackdrop: _ = !1,
+    keepMounted: P = !1,
+    onBackdropClick: V,
+    open: D,
+    slotProps: L,
+    slots: E
+    // eslint-disable-next-line react/prop-types
+  } = d, O = Z(d, bt), g = M({}, d, {
+    closeAfterTransition: v,
+    disableAutoFocus: h,
+    disableEnforceFocus: f,
+    disableEscapeKeyDown: T,
+    disablePortal: C,
+    disableRestoreFocus: k,
+    disableScrollLock: I,
+    hideBackdrop: _,
+    keepMounted: P
+  }), {
+    getRootProps: R,
+    getBackdropProps: N,
+    getTransitionProps: ge,
+    portalRef: se,
+    isTopModal: Ee,
+    exited: ie,
+    hasTransition: ae
+  } = ht(M({}, g, {
+    rootRef: s
+  })), $ = M({}, g, {
+    exited: ie
+  }), K = gt($), W = {};
+  if (p.props.tabIndex === void 0 && (W.tabIndex = "-1"), ae) {
+    const {
+      onEnter: q,
+      onExited: J
+    } = ge();
+    W.onEnter = q, W.onExited = J;
+  }
+  const le = (o = (i = E == null ? void 0 : E.root) != null ? i : S.Root) != null ? o : Et, G = (r = (a = E == null ? void 0 : E.backdrop) != null ? a : S.Backdrop) != null ? r : b, j = (l = L == null ? void 0 : L.root) != null ? l : F.root, ne = (c = L == null ? void 0 : L.backdrop) != null ? c : F.backdrop, ye = Ae({
+    elementType: le,
+    externalSlotProps: j,
+    externalForwardedProps: O,
+    getSlotProps: R,
+    additionalProps: {
+      ref: s,
+      as: B
+    },
+    ownerState: $,
+    className: U(x, j == null ? void 0 : j.className, K == null ? void 0 : K.root, !$.open && $.exited && (K == null ? void 0 : K.hidden))
+  }), Te = Ae({
+    elementType: G,
+    externalSlotProps: ne,
+    additionalProps: y,
+    getSlotProps: (q) => N(M({}, q, {
+      onClick: (J) => {
+        V && V(J), q != null && q.onClick && q.onClick(J);
+      }
+    })),
+    className: U(ne == null ? void 0 : ne.className, y == null ? void 0 : y.className, K == null ? void 0 : K.backdrop),
+    ownerState: $
+  });
+  return !P && !D && (!ae || ie) ? null : /* @__PURE__ */ A(Rn, {
+    ref: se,
+    container: w,
+    disablePortal: C,
+    children: /* @__PURE__ */ Ne(le, M({}, ye, {
+      children: [!_ && b ? /* @__PURE__ */ A(G, M({}, Te)) : null, /* @__PURE__ */ A(fe, {
+        disableEnforceFocus: f,
+        disableAutoFocus: h,
+        disableRestoreFocus: k,
+        isEnabled: Ee,
+        open: D,
+        children: /* @__PURE__ */ u.cloneElement(p, W)
+      })]
+    }))
+  });
+});
+z.env.NODE_ENV !== "production" && (Tt.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * A backdrop component. This prop enables custom backdrop rendering.
+   * @deprecated Use `slots.backdrop` instead. While this prop currently works, it will be removed in the next major version.
+   * Use the `slots.backdrop` prop to make your application ready for the next version of Material UI.
+   * @default styled(Backdrop, {
+   *   name: 'MuiModal',
+   *   slot: 'Backdrop',
+   *   overridesResolver: (props, styles) => {
+   *     return styles.backdrop;
+   *   },
+   * })({
+   *   zIndex: -1,
+   * })
+   */
+  BackdropComponent: e.elementType,
+  /**
+   * Props applied to the [`Backdrop`](/material-ui/api/backdrop/) element.
+   * @deprecated Use `slotProps.backdrop` instead.
+   */
+  BackdropProps: e.object,
+  /**
+   * A single child content element.
+   */
+  children: we.isRequired,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * When set to true the Modal waits until a nested Transition is completed before closing.
+   * @default false
+   */
+  closeAfterTransition: e.bool,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * The components used for each slot inside.
+   *
+   * This prop is an alias for the `slots` prop.
+   * It's recommended to use the `slots` prop instead.
+   *
+   * @default {}
+   */
+  components: e.shape({
+    Backdrop: e.elementType,
+    Root: e.elementType
+  }),
+  /**
+   * The extra props for the slot components.
+   * You can override the existing props or add new ones.
+   *
+   * This prop is an alias for the `slotProps` prop.
+   * It's recommended to use the `slotProps` prop instead, as `componentsProps` will be deprecated in the future.
+   *
+   * @default {}
+   */
+  componentsProps: e.shape({
+    backdrop: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * An HTML element or function that returns one.
+   * The `container` will have the portal children appended to it.
+   *
+   * You can also provide a callback, which is called in a React layout effect.
+   * This lets you set the container from a ref, and also makes server-side rendering possible.
+   *
+   * By default, it uses the body of the top-level document object,
+   * so it's simply `document.body` most of the time.
+   */
+  container: e.oneOfType([xn, e.func]),
+  /**
+   * If `true`, the modal will not automatically shift focus to itself when it opens, and
+   * replace it to the last focused element when it closes.
+   * This also works correctly with any modal children that have the `disableAutoFocus` prop.
+   *
+   * Generally this should never be set to `true` as it makes the modal less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableAutoFocus: e.bool,
+  /**
+   * If `true`, the modal will not prevent focus from leaving the modal while open.
+   *
+   * Generally this should never be set to `true` as it makes the modal less
+   * accessible to assistive technologies, like screen readers.
+   * @default false
+   */
+  disableEnforceFocus: e.bool,
+  /**
+   * If `true`, hitting escape will not fire the `onClose` callback.
+   * @default false
+   */
+  disableEscapeKeyDown: e.bool,
+  /**
+   * The `children` will be under the DOM hierarchy of the parent component.
+   * @default false
+   */
+  disablePortal: e.bool,
+  /**
+   * If `true`, the modal will not restore focus to previously focused element once
+   * modal is hidden or unmounted.
+   * @default false
+   */
+  disableRestoreFocus: e.bool,
+  /**
+   * Disable the scroll lock behavior.
+   * @default false
+   */
+  disableScrollLock: e.bool,
+  /**
+   * If `true`, the backdrop is not rendered.
+   * @default false
+   */
+  hideBackdrop: e.bool,
+  /**
+   * Always keep the children in the DOM.
+   * This prop can be useful in SEO situation or
+   * when you want to maximize the responsiveness of the Modal.
+   * @default false
+   */
+  keepMounted: e.bool,
+  /**
+   * Callback fired when the backdrop is clicked.
+   * @deprecated Use the `onClose` prop with the `reason` argument to handle the `backdropClick` events.
+   */
+  onBackdropClick: e.func,
+  /**
+   * Callback fired when the component requests to be closed.
+   * The `reason` parameter can optionally be used to control the response to `onClose`.
+   *
+   * @param {object} event The event source of the callback.
+   * @param {string} reason Can be: `"escapeKeyDown"`, `"backdropClick"`.
+   */
+  onClose: e.func,
+  /**
+   * A function called when a transition enters.
+   */
+  onTransitionEnter: e.func,
+  /**
+   * A function called when a transition has exited.
+   */
+  onTransitionExited: e.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: e.bool.isRequired,
+  /**
+   * The props used for each slot inside the Modal.
+   * @default {}
+   */
+  slotProps: e.shape({
+    backdrop: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside the Modal.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: e.shape({
+    backdrop: e.elementType,
+    root: e.elementType
+  }),
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+function Mt({ fill: n }) {
+  return /* @__PURE__ */ A("svg", { width: "12", height: "12", viewBox: "0 0 12 12", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ A("path", { d: "M1 1L11 11M9.57143 1L1 11", stroke: n, "stroke-width": "2" }) });
+}
+async function Nt() {
+  var r;
+  let t = await vn(Cn.KEPLR).getChainInfosWithoutEndpoints(), s = ((r = ln.getState()) == null ? void 0 : r.cosmosChains) || [];
+  const o = cn.keyBy(t, "chainId");
+  let i = [];
+  return s.forEach((a) => {
+    if (o[a.chainId]) i.push(a.chainId);
+    else
+      return;
+  }), i;
+}
+export {
+  qn as B,
+  Mt as C,
+  Xe as F,
+  Tt as M,
+  Oe as T,
+  wn as _,
+  Ge as a,
+  fe as b,
+  Nn as c,
+  Mn as e,
+  Nt as g,
+  Se as o
+};