@devalok/shilp-sutra 0.9.0 → 0.9.1

package/dist/_chunks/vendor-client.js

@@ -0,0 +1,1835 @@
+"use client";
+import * as w from "react";
+import { useState as Se, useLayoutEffect as Ce } from "react";
+import { _ as Z, a as re, b as Re } from "./vendor-utils.js";
+import * as Ae from "react-dom";
+var ht = "right-scroll-bar-position", mt = "width-before-scroll-bar", Ee = "with-scroll-bars-hidden", Oe = "--removed-body-scroll-bar-size";
+function At(t, e) {
+  return typeof t == "function" ? t(e) : t && (t.current = e), t;
+}
+function Me(t, e) {
+  var n = Se(function() {
+    return {
+      // value
+      value: t,
+      // last callback
+      callback: e,
+      // "memoized" public interface
+      facade: {
+        get current() {
+          return n.value;
+        },
+        set current(r) {
+          var o = n.value;
+          o !== r && (n.value = r, n.callback(r, o));
+        }
+      }
+    };
+  })[0];
+  return n.callback = e, n.facade;
+}
+var Pe = typeof window < "u" ? w.useLayoutEffect : w.useEffect, It = /* @__PURE__ */ new WeakMap();
+function ke(t, e) {
+  var n = Me(null, function(r) {
+    return t.forEach(function(o) {
+      return At(o, r);
+    });
+  });
+  return Pe(function() {
+    var r = It.get(n);
+    if (r) {
+      var o = new Set(r), i = new Set(t), c = n.current;
+      o.forEach(function(s) {
+        i.has(s) || At(s, null);
+      }), i.forEach(function(s) {
+        o.has(s) || At(s, c);
+      });
+    }
+    It.set(n, t);
+  }, [t]), n;
+}
+function Le(t) {
+  return t;
+}
+function Te(t, e) {
+  e === void 0 && (e = Le);
+  var n = [], r = !1, o = {
+    read: function() {
+      if (r)
+        throw new Error("Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.");
+      return n.length ? n[n.length - 1] : t;
+    },
+    useMedium: function(i) {
+      var c = e(i, r);
+      return n.push(c), function() {
+        n = n.filter(function(s) {
+          return s !== c;
+        });
+      };
+    },
+    assignSyncMedium: function(i) {
+      for (r = !0; n.length; ) {
+        var c = n;
+        n = [], c.forEach(i);
+      }
+      n = {
+        push: function(s) {
+          return i(s);
+        },
+        filter: function() {
+          return n;
+        }
+      };
+    },
+    assignMedium: function(i) {
+      r = !0;
+      var c = [];
+      if (n.length) {
+        var s = n;
+        n = [], s.forEach(i), c = n;
+      }
+      var u = function() {
+        var l = c;
+        c = [], l.forEach(i);
+      }, f = function() {
+        return Promise.resolve().then(u);
+      };
+      f(), n = {
+        push: function(l) {
+          c.push(l), f();
+        },
+        filter: function(l) {
+          return c = c.filter(l), n;
+        }
+      };
+    }
+  };
+  return o;
+}
+function De(t) {
+  t === void 0 && (t = {});
+  var e = Te(null);
+  return e.options = Z({ async: !0, ssr: !1 }, t), e;
+}
+var oe = function(t) {
+  var e = t.sideCar, n = re(t, ["sideCar"]);
+  if (!e)
+    throw new Error("Sidecar: please provide `sideCar` property to import the right car");
+  var r = e.read();
+  if (!r)
+    throw new Error("Sidecar medium not found");
+  return w.createElement(r, Z({}, n));
+};
+oe.isSideCarExport = !0;
+function We(t, e) {
+  return t.useMedium(e), oe;
+}
+var ie = De(), Et = function() {
+}, xt = w.forwardRef(function(t, e) {
+  var n = w.useRef(null), r = w.useState({
+    onScrollCapture: Et,
+    onWheelCapture: Et,
+    onTouchMoveCapture: Et
+  }), o = r[0], i = r[1], c = t.forwardProps, s = t.children, u = t.className, f = t.removeScrollBar, l = t.enabled, a = t.shards, m = t.sideCar, h = t.noRelative, v = t.noIsolation, d = t.inert, g = t.allowPinchZoom, p = t.as, y = p === void 0 ? "div" : p, x = t.gapMode, b = re(t, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noRelative", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]), S = m, C = ke([n, e]), R = Z(Z({}, b), o);
+  return w.createElement(
+    w.Fragment,
+    null,
+    l && w.createElement(S, { sideCar: ie, removeScrollBar: f, shards: a, noRelative: h, noIsolation: v, inert: d, setCallbacks: i, allowPinchZoom: !!g, lockRef: n, gapMode: x }),
+    c ? w.cloneElement(w.Children.only(s), Z(Z({}, R), { ref: C })) : w.createElement(y, Z({}, R, { className: u, ref: C }), s)
+  );
+});
+xt.defaultProps = {
+  enabled: !0,
+  removeScrollBar: !0,
+  inert: !1
+};
+xt.classNames = {
+  fullWidth: mt,
+  zeroRight: ht
+};
+var Ne = function() {
+  if (typeof __webpack_nonce__ < "u")
+    return __webpack_nonce__;
+};
+function Be() {
+  if (!document)
+    return null;
+  var t = document.createElement("style");
+  t.type = "text/css";
+  var e = Ne();
+  return e && t.setAttribute("nonce", e), t;
+}
+function Fe(t, e) {
+  t.styleSheet ? t.styleSheet.cssText = e : t.appendChild(document.createTextNode(e));
+}
+function Ve(t) {
+  var e = document.head || document.getElementsByTagName("head")[0];
+  e.appendChild(t);
+}
+var He = function() {
+  var t = 0, e = null;
+  return {
+    add: function(n) {
+      t == 0 && (e = Be()) && (Fe(e, n), Ve(e)), t++;
+    },
+    remove: function() {
+      t--, !t && e && (e.parentNode && e.parentNode.removeChild(e), e = null);
+    }
+  };
+}, $e = function() {
+  var t = He();
+  return function(e, n) {
+    w.useEffect(function() {
+      return t.add(e), function() {
+        t.remove();
+      };
+    }, [e && n]);
+  };
+}, ce = function() {
+  var t = $e(), e = function(n) {
+    var r = n.styles, o = n.dynamic;
+    return t(r, o), null;
+  };
+  return e;
+}, Ie = {
+  left: 0,
+  top: 0,
+  right: 0,
+  gap: 0
+}, Ot = function(t) {
+  return parseInt(t || "", 10) || 0;
+}, ze = function(t) {
+  var e = window.getComputedStyle(document.body), n = e[t === "padding" ? "paddingLeft" : "marginLeft"], r = e[t === "padding" ? "paddingTop" : "marginTop"], o = e[t === "padding" ? "paddingRight" : "marginRight"];
+  return [Ot(n), Ot(r), Ot(o)];
+}, _e = function(t) {
+  if (t === void 0 && (t = "margin"), typeof window > "u")
+    return Ie;
+  var e = ze(t), n = document.documentElement.clientWidth, r = window.innerWidth;
+  return {
+    left: e[0],
+    top: e[1],
+    right: e[2],
+    gap: Math.max(0, r - n + e[2] - e[0])
+  };
+}, Xe = ce(), et = "data-scroll-locked", Ye = function(t, e, n, r) {
+  var o = t.left, i = t.top, c = t.right, s = t.gap;
+  return n === void 0 && (n = "margin"), `
+  .`.concat(Ee, ` {
+   overflow: hidden `).concat(r, `;
+   padding-right: `).concat(s, "px ").concat(r, `;
+  }
+  body[`).concat(et, `] {
+    overflow: hidden `).concat(r, `;
+    overscroll-behavior: contain;
+    `).concat([
+    e && "position: relative ".concat(r, ";"),
+    n === "margin" && `
+    padding-left: `.concat(o, `px;
+    padding-top: `).concat(i, `px;
+    padding-right: `).concat(c, `px;
+    margin-left:0;
+    margin-top:0;
+    margin-right: `).concat(s, "px ").concat(r, `;
+    `),
+    n === "padding" && "padding-right: ".concat(s, "px ").concat(r, ";")
+  ].filter(Boolean).join(""), `
+  }
+  
+  .`).concat(ht, ` {
+    right: `).concat(s, "px ").concat(r, `;
+  }
+  
+  .`).concat(mt, ` {
+    margin-right: `).concat(s, "px ").concat(r, `;
+  }
+  
+  .`).concat(ht, " .").concat(ht, ` {
+    right: 0 `).concat(r, `;
+  }
+  
+  .`).concat(mt, " .").concat(mt, ` {
+    margin-right: 0 `).concat(r, `;
+  }
+  
+  body[`).concat(et, `] {
+    `).concat(Oe, ": ").concat(s, `px;
+  }
+`);
+}, zt = function() {
+  var t = parseInt(document.body.getAttribute(et) || "0", 10);
+  return isFinite(t) ? t : 0;
+}, je = function() {
+  w.useEffect(function() {
+    return document.body.setAttribute(et, (zt() + 1).toString()), function() {
+      var t = zt() - 1;
+      t <= 0 ? document.body.removeAttribute(et) : document.body.setAttribute(et, t.toString());
+    };
+  }, []);
+}, qe = function(t) {
+  var e = t.noRelative, n = t.noImportant, r = t.gapMode, o = r === void 0 ? "margin" : r;
+  je();
+  var i = w.useMemo(function() {
+    return _e(o);
+  }, [o]);
+  return w.createElement(Xe, { styles: Ye(i, !e, o, n ? "" : "!important") });
+}, Lt = !1;
+if (typeof window < "u")
+  try {
+    var at = Object.defineProperty({}, "passive", {
+      get: function() {
+        return Lt = !0, !0;
+      }
+    });
+    window.addEventListener("test", at, at), window.removeEventListener("test", at, at);
+  } catch {
+    Lt = !1;
+  }
+var Q = Lt ? { passive: !1 } : !1, Ze = function(t) {
+  return t.tagName === "TEXTAREA";
+}, se = function(t, e) {
+  if (!(t instanceof Element))
+    return !1;
+  var n = window.getComputedStyle(t);
+  return (
+    // not-not-scrollable
+    n[e] !== "hidden" && // contains scroll inside self
+    !(n.overflowY === n.overflowX && !Ze(t) && n[e] === "visible")
+  );
+}, Ue = function(t) {
+  return se(t, "overflowY");
+}, Ge = function(t) {
+  return se(t, "overflowX");
+}, _t = function(t, e) {
+  var n = e.ownerDocument, r = e;
+  do {
+    typeof ShadowRoot < "u" && r instanceof ShadowRoot && (r = r.host);
+    var o = ae(t, r);
+    if (o) {
+      var i = le(t, r), c = i[1], s = i[2];
+      if (c > s)
+        return !0;
+    }
+    r = r.parentNode;
+  } while (r && r !== n.body);
+  return !1;
+}, Ke = function(t) {
+  var e = t.scrollTop, n = t.scrollHeight, r = t.clientHeight;
+  return [
+    e,
+    n,
+    r
+  ];
+}, Qe = function(t) {
+  var e = t.scrollLeft, n = t.scrollWidth, r = t.clientWidth;
+  return [
+    e,
+    n,
+    r
+  ];
+}, ae = function(t, e) {
+  return t === "v" ? Ue(e) : Ge(e);
+}, le = function(t, e) {
+  return t === "v" ? Ke(e) : Qe(e);
+}, Je = function(t, e) {
+  return t === "h" && e === "rtl" ? -1 : 1;
+}, tn = function(t, e, n, r, o) {
+  var i = Je(t, window.getComputedStyle(e).direction), c = i * r, s = n.target, u = e.contains(s), f = !1, l = c > 0, a = 0, m = 0;
+  do {
+    if (!s)
+      break;
+    var h = le(t, s), v = h[0], d = h[1], g = h[2], p = d - g - i * v;
+    (v || p) && ae(t, s) && (a += p, m += v);
+    var y = s.parentNode;
+    s = y && y.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? y.host : y;
+  } while (
+    // portaled content
+    !u && s !== document.body || // self content
+    u && (e.contains(s) || e === s)
+  );
+  return (l && Math.abs(a) < 1 || !l && Math.abs(m) < 1) && (f = !0), f;
+}, lt = function(t) {
+  return "changedTouches" in t ? [t.changedTouches[0].clientX, t.changedTouches[0].clientY] : [0, 0];
+}, Xt = function(t) {
+  return [t.deltaX, t.deltaY];
+}, Yt = function(t) {
+  return t && "current" in t ? t.current : t;
+}, en = function(t, e) {
+  return t[0] === e[0] && t[1] === e[1];
+}, nn = function(t) {
+  return `
+  .block-interactivity-`.concat(t, ` {pointer-events: none;}
+  .allow-interactivity-`).concat(t, ` {pointer-events: all;}
+`);
+}, rn = 0, J = [];
+function on(t) {
+  var e = w.useRef([]), n = w.useRef([0, 0]), r = w.useRef(), o = w.useState(rn++)[0], i = w.useState(ce)[0], c = w.useRef(t);
+  w.useEffect(function() {
+    c.current = t;
+  }, [t]), w.useEffect(function() {
+    if (t.inert) {
+      document.body.classList.add("block-interactivity-".concat(o));
+      var d = Re([t.lockRef.current], (t.shards || []).map(Yt), !0).filter(Boolean);
+      return d.forEach(function(g) {
+        return g.classList.add("allow-interactivity-".concat(o));
+      }), function() {
+        document.body.classList.remove("block-interactivity-".concat(o)), d.forEach(function(g) {
+          return g.classList.remove("allow-interactivity-".concat(o));
+        });
+      };
+    }
+  }, [t.inert, t.lockRef.current, t.shards]);
+  var s = w.useCallback(function(d, g) {
+    if ("touches" in d && d.touches.length === 2 || d.type === "wheel" && d.ctrlKey)
+      return !c.current.allowPinchZoom;
+    var p = lt(d), y = n.current, x = "deltaX" in d ? d.deltaX : y[0] - p[0], b = "deltaY" in d ? d.deltaY : y[1] - p[1], S, C = d.target, R = Math.abs(x) > Math.abs(b) ? "h" : "v";
+    if ("touches" in d && R === "h" && C.type === "range")
+      return !1;
+    var M = window.getSelection(), L = M && M.anchorNode, O = L ? L === C || L.contains(C) : !1;
+    if (O)
+      return !1;
+    var P = _t(R, C);
+    if (!P)
+      return !0;
+    if (P ? S = R : (S = R === "v" ? "h" : "v", P = _t(R, C)), !P)
+      return !1;
+    if (!r.current && "changedTouches" in d && (x || b) && (r.current = S), !S)
+      return !0;
+    var T = r.current || S;
+    return tn(T, g, d, T === "h" ? x : b);
+  }, []), u = w.useCallback(function(d) {
+    var g = d;
+    if (!(!J.length || J[J.length - 1] !== i)) {
+      var p = "deltaY" in g ? Xt(g) : lt(g), y = e.current.filter(function(S) {
+        return S.name === g.type && (S.target === g.target || g.target === S.shadowParent) && en(S.delta, p);
+      })[0];
+      if (y && y.should) {
+        g.cancelable && g.preventDefault();
+        return;
+      }
+      if (!y) {
+        var x = (c.current.shards || []).map(Yt).filter(Boolean).filter(function(S) {
+          return S.contains(g.target);
+        }), b = x.length > 0 ? s(g, x[0]) : !c.current.noIsolation;
+        b && g.cancelable && g.preventDefault();
+      }
+    }
+  }, []), f = w.useCallback(function(d, g, p, y) {
+    var x = { name: d, delta: g, target: p, should: y, shadowParent: cn(p) };
+    e.current.push(x), setTimeout(function() {
+      e.current = e.current.filter(function(b) {
+        return b !== x;
+      });
+    }, 1);
+  }, []), l = w.useCallback(function(d) {
+    n.current = lt(d), r.current = void 0;
+  }, []), a = w.useCallback(function(d) {
+    f(d.type, Xt(d), d.target, s(d, t.lockRef.current));
+  }, []), m = w.useCallback(function(d) {
+    f(d.type, lt(d), d.target, s(d, t.lockRef.current));
+  }, []);
+  w.useEffect(function() {
+    return J.push(i), t.setCallbacks({
+      onScrollCapture: a,
+      onWheelCapture: a,
+      onTouchMoveCapture: m
+    }), document.addEventListener("wheel", u, Q), document.addEventListener("touchmove", u, Q), document.addEventListener("touchstart", l, Q), function() {
+      J = J.filter(function(d) {
+        return d !== i;
+      }), document.removeEventListener("wheel", u, Q), document.removeEventListener("touchmove", u, Q), document.removeEventListener("touchstart", l, Q);
+    };
+  }, []);
+  var h = t.removeScrollBar, v = t.inert;
+  return w.createElement(
+    w.Fragment,
+    null,
+    v ? w.createElement(i, { styles: nn(o) }) : null,
+    h ? w.createElement(qe, { noRelative: t.noRelative, gapMode: t.gapMode }) : null
+  );
+}
+function cn(t) {
+  for (var e = null; t !== null; )
+    t instanceof ShadowRoot && (e = t.host, t = t.host), t = t.parentNode;
+  return e;
+}
+const sn = We(ie, on);
+var an = w.forwardRef(function(t, e) {
+  return w.createElement(xt, Z({}, t, { ref: e, sideCar: sn }));
+});
+an.classNames = xt.classNames;
+var ln = function(t) {
+  if (typeof document > "u")
+    return null;
+  var e = Array.isArray(t) ? t[0] : t;
+  return e.ownerDocument.body;
+}, tt = /* @__PURE__ */ new WeakMap(), ft = /* @__PURE__ */ new WeakMap(), ut = {}, Mt = 0, fe = function(t) {
+  return t && (t.host || fe(t.parentNode));
+}, fn = function(t, e) {
+  return e.map(function(n) {
+    if (t.contains(n))
+      return n;
+    var r = fe(n);
+    return r && t.contains(r) ? r : (console.error("aria-hidden", n, "in not contained inside", t, ". Doing nothing"), null);
+  }).filter(function(n) {
+    return !!n;
+  });
+}, un = function(t, e, n, r) {
+  var o = fn(e, Array.isArray(t) ? t : [t]);
+  ut[n] || (ut[n] = /* @__PURE__ */ new WeakMap());
+  var i = ut[n], c = [], s = /* @__PURE__ */ new Set(), u = new Set(o), f = function(a) {
+    !a || s.has(a) || (s.add(a), f(a.parentNode));
+  };
+  o.forEach(f);
+  var l = function(a) {
+    !a || u.has(a) || Array.prototype.forEach.call(a.children, function(m) {
+      if (s.has(m))
+        l(m);
+      else
+        try {
+          var h = m.getAttribute(r), v = h !== null && h !== "false", d = (tt.get(m) || 0) + 1, g = (i.get(m) || 0) + 1;
+          tt.set(m, d), i.set(m, g), c.push(m), d === 1 && v && ft.set(m, !0), g === 1 && m.setAttribute(n, "true"), v || m.setAttribute(r, "true");
+        } catch (p) {
+          console.error("aria-hidden: cannot operate on ", m, p);
+        }
+    });
+  };
+  return l(e), s.clear(), Mt++, function() {
+    c.forEach(function(a) {
+      var m = tt.get(a) - 1, h = i.get(a) - 1;
+      tt.set(a, m), i.set(a, h), m || (ft.has(a) || a.removeAttribute(r), ft.delete(a)), h || a.removeAttribute(n);
+    }), Mt--, Mt || (tt = /* @__PURE__ */ new WeakMap(), tt = /* @__PURE__ */ new WeakMap(), ft = /* @__PURE__ */ new WeakMap(), ut = {});
+  };
+}, vr = function(t, e, n) {
+  n === void 0 && (n = "data-aria-hidden");
+  var r = Array.from(Array.isArray(t) ? t : [t]), o = ln(t);
+  return o ? (r.push.apply(r, Array.from(o.querySelectorAll("[aria-live], script"))), un(r, o, n, "aria-hidden")) : function() {
+    return null;
+  };
+};
+const dn = ["top", "right", "bottom", "left"], U = Math.min, B = Math.max, vt = Math.round, dt = Math.floor, z = (t) => ({
+  x: t,
+  y: t
+}), hn = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, mn = {
+  start: "end",
+  end: "start"
+};
+function Tt(t, e, n) {
+  return B(t, U(e, n));
+}
+function Y(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function j(t) {
+  return t.split("-")[0];
+}
+function ot(t) {
+  return t.split("-")[1];
+}
+function Nt(t) {
+  return t === "x" ? "y" : "x";
+}
+function Bt(t) {
+  return t === "y" ? "height" : "width";
+}
+const gn = /* @__PURE__ */ new Set(["top", "bottom"]);
+function I(t) {
+  return gn.has(j(t)) ? "y" : "x";
+}
+function Ft(t) {
+  return Nt(I(t));
+}
+function vn(t, e, n) {
+  n === void 0 && (n = !1);
+  const r = ot(t), o = Ft(t), i = Bt(o);
+  let c = o === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return e.reference[i] > e.floating[i] && (c = pt(c)), [c, pt(c)];
+}
+function pn(t) {
+  const e = pt(t);
+  return [Dt(t), e, Dt(e)];
+}
+function Dt(t) {
+  return t.replace(/start|end/g, (e) => mn[e]);
+}
+const jt = ["left", "right"], qt = ["right", "left"], wn = ["top", "bottom"], yn = ["bottom", "top"];
+function xn(t, e, n) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? qt : jt : e ? jt : qt;
+    case "left":
+    case "right":
+      return e ? wn : yn;
+    default:
+      return [];
+  }
+}
+function bn(t, e, n, r) {
+  const o = ot(t);
+  let i = xn(j(t), n === "start", r);
+  return o && (i = i.map((c) => c + "-" + o), e && (i = i.concat(i.map(Dt)))), i;
+}
+function pt(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => hn[e]);
+}
+function Sn(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function ue(t) {
+  return typeof t != "number" ? Sn(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function wt(t) {
+  const {
+    x: e,
+    y: n,
+    width: r,
+    height: o
+  } = t;
+  return {
+    width: r,
+    height: o,
+    top: n,
+    left: e,
+    right: e + r,
+    bottom: n + o,
+    x: e,
+    y: n
+  };
+}
+function Zt(t, e, n) {
+  let {
+    reference: r,
+    floating: o
+  } = t;
+  const i = I(e), c = Ft(e), s = Bt(c), u = j(e), f = i === "y", l = r.x + r.width / 2 - o.width / 2, a = r.y + r.height / 2 - o.height / 2, m = r[s] / 2 - o[s] / 2;
+  let h;
+  switch (u) {
+    case "top":
+      h = {
+        x: l,
+        y: r.y - o.height
+      };
+      break;
+    case "bottom":
+      h = {
+        x: l,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      h = {
+        x: r.x + r.width,
+        y: a
+      };
+      break;
+    case "left":
+      h = {
+        x: r.x - o.width,
+        y: a
+      };
+      break;
+    default:
+      h = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  switch (ot(e)) {
+    case "start":
+      h[c] -= m * (n && f ? -1 : 1);
+      break;
+    case "end":
+      h[c] += m * (n && f ? -1 : 1);
+      break;
+  }
+  return h;
+}
+async function Cn(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const {
+    x: r,
+    y: o,
+    platform: i,
+    rects: c,
+    elements: s,
+    strategy: u
+  } = t, {
+    boundary: f = "clippingAncestors",
+    rootBoundary: l = "viewport",
+    elementContext: a = "floating",
+    altBoundary: m = !1,
+    padding: h = 0
+  } = Y(e, t), v = ue(h), g = s[m ? a === "floating" ? "reference" : "floating" : a], p = wt(await i.getClippingRect({
+    element: (n = await (i.isElement == null ? void 0 : i.isElement(g))) == null || n ? g : g.contextElement || await (i.getDocumentElement == null ? void 0 : i.getDocumentElement(s.floating)),
+    boundary: f,
+    rootBoundary: l,
+    strategy: u
+  })), y = a === "floating" ? {
+    x: r,
+    y: o,
+    width: c.floating.width,
+    height: c.floating.height
+  } : c.reference, x = await (i.getOffsetParent == null ? void 0 : i.getOffsetParent(s.floating)), b = await (i.isElement == null ? void 0 : i.isElement(x)) ? await (i.getScale == null ? void 0 : i.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, S = wt(i.convertOffsetParentRelativeRectToViewportRelativeRect ? await i.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: s,
+    rect: y,
+    offsetParent: x,
+    strategy: u
+  }) : y);
+  return {
+    top: (p.top - S.top + v.top) / b.y,
+    bottom: (S.bottom - p.bottom + v.bottom) / b.y,
+    left: (p.left - S.left + v.left) / b.x,
+    right: (S.right - p.right + v.right) / b.x
+  };
+}
+const Rn = async (t, e, n) => {
+  const {
+    placement: r = "bottom",
+    strategy: o = "absolute",
+    middleware: i = [],
+    platform: c
+  } = n, s = i.filter(Boolean), u = await (c.isRTL == null ? void 0 : c.isRTL(e));
+  let f = await c.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: o
+  }), {
+    x: l,
+    y: a
+  } = Zt(f, r, u), m = r, h = {}, v = 0;
+  for (let g = 0; g < s.length; g++) {
+    var d;
+    const {
+      name: p,
+      fn: y
+    } = s[g], {
+      x,
+      y: b,
+      data: S,
+      reset: C
+    } = await y({
+      x: l,
+      y: a,
+      initialPlacement: r,
+      placement: m,
+      strategy: o,
+      middlewareData: h,
+      rects: f,
+      platform: {
+        ...c,
+        detectOverflow: (d = c.detectOverflow) != null ? d : Cn
+      },
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    l = x ?? l, a = b ?? a, h = {
+      ...h,
+      [p]: {
+        ...h[p],
+        ...S
+      }
+    }, C && v <= 50 && (v++, typeof C == "object" && (C.placement && (m = C.placement), C.rects && (f = C.rects === !0 ? await c.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: o
+    }) : C.rects), {
+      x: l,
+      y: a
+    } = Zt(f, m, u)), g = -1);
+  }
+  return {
+    x: l,
+    y: a,
+    placement: m,
+    strategy: o,
+    middlewareData: h
+  };
+}, An = (t) => ({
+  name: "arrow",
+  options: t,
+  async fn(e) {
+    const {
+      x: n,
+      y: r,
+      placement: o,
+      rects: i,
+      platform: c,
+      elements: s,
+      middlewareData: u
+    } = e, {
+      element: f,
+      padding: l = 0
+    } = Y(t, e) || {};
+    if (f == null)
+      return {};
+    const a = ue(l), m = {
+      x: n,
+      y: r
+    }, h = Ft(o), v = Bt(h), d = await c.getDimensions(f), g = h === "y", p = g ? "top" : "left", y = g ? "bottom" : "right", x = g ? "clientHeight" : "clientWidth", b = i.reference[v] + i.reference[h] - m[h] - i.floating[v], S = m[h] - i.reference[h], C = await (c.getOffsetParent == null ? void 0 : c.getOffsetParent(f));
+    let R = C ? C[x] : 0;
+    (!R || !await (c.isElement == null ? void 0 : c.isElement(C))) && (R = s.floating[x] || i.floating[v]);
+    const M = b / 2 - S / 2, L = R / 2 - d[v] / 2 - 1, O = U(a[p], L), P = U(a[y], L), T = O, D = R - d[v] - P, E = R / 2 - d[v] / 2 + M, $ = Tt(T, E, D), k = !u.arrow && ot(o) != null && E !== $ && i.reference[v] / 2 - (E < T ? O : P) - d[v] / 2 < 0, W = k ? E < T ? E - T : E - D : 0;
+    return {
+      [h]: m[h] + W,
+      data: {
+        [h]: $,
+        centerOffset: E - $ - W,
+        ...k && {
+          alignmentOffset: W
+        }
+      },
+      reset: k
+    };
+  }
+}), En = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var n, r;
+      const {
+        placement: o,
+        middlewareData: i,
+        rects: c,
+        initialPlacement: s,
+        platform: u,
+        elements: f
+      } = e, {
+        mainAxis: l = !0,
+        crossAxis: a = !0,
+        fallbackPlacements: m,
+        fallbackStrategy: h = "bestFit",
+        fallbackAxisSideDirection: v = "none",
+        flipAlignment: d = !0,
+        ...g
+      } = Y(t, e);
+      if ((n = i.arrow) != null && n.alignmentOffset)
+        return {};
+      const p = j(o), y = I(s), x = j(s) === s, b = await (u.isRTL == null ? void 0 : u.isRTL(f.floating)), S = m || (x || !d ? [pt(s)] : pn(s)), C = v !== "none";
+      !m && C && S.push(...bn(s, d, v, b));
+      const R = [s, ...S], M = await u.detectOverflow(e, g), L = [];
+      let O = ((r = i.flip) == null ? void 0 : r.overflows) || [];
+      if (l && L.push(M[p]), a) {
+        const E = vn(o, c, b);
+        L.push(M[E[0]], M[E[1]]);
+      }
+      if (O = [...O, {
+        placement: o,
+        overflows: L
+      }], !L.every((E) => E <= 0)) {
+        var P, T;
+        const E = (((P = i.flip) == null ? void 0 : P.index) || 0) + 1, $ = R[E];
+        if ($ && (!(a === "alignment" ? y !== I($) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        O.every((A) => I(A.placement) === y ? A.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: E,
+              overflows: O
+            },
+            reset: {
+              placement: $
+            }
+          };
+        let k = (T = O.filter((W) => W.overflows[0] <= 0).sort((W, A) => W.overflows[1] - A.overflows[1])[0]) == null ? void 0 : T.placement;
+        if (!k)
+          switch (h) {
+            case "bestFit": {
+              var D;
+              const W = (D = O.filter((A) => {
+                if (C) {
+                  const N = I(A.placement);
+                  return N === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  N === "y";
+                }
+                return !0;
+              }).map((A) => [A.placement, A.overflows.filter((N) => N > 0).reduce((N, q) => N + q, 0)]).sort((A, N) => A[1] - N[1])[0]) == null ? void 0 : D[0];
+              W && (k = W);
+              break;
+            }
+            case "initialPlacement":
+              k = s;
+              break;
+          }
+        if (o !== k)
+          return {
+            reset: {
+              placement: k
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function Ut(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function Gt(t) {
+  return dn.some((e) => t[e] >= 0);
+}
+const On = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const {
+        rects: n,
+        platform: r
+      } = e, {
+        strategy: o = "referenceHidden",
+        ...i
+      } = Y(t, e);
+      switch (o) {
+        case "referenceHidden": {
+          const c = await r.detectOverflow(e, {
+            ...i,
+            elementContext: "reference"
+          }), s = Ut(c, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: s,
+              referenceHidden: Gt(s)
+            }
+          };
+        }
+        case "escaped": {
+          const c = await r.detectOverflow(e, {
+            ...i,
+            altBoundary: !0
+          }), s = Ut(c, n.floating);
+          return {
+            data: {
+              escapedOffsets: s,
+              escaped: Gt(s)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, de = /* @__PURE__ */ new Set(["left", "top"]);
+async function Mn(t, e) {
+  const {
+    placement: n,
+    platform: r,
+    elements: o
+  } = t, i = await (r.isRTL == null ? void 0 : r.isRTL(o.floating)), c = j(n), s = ot(n), u = I(n) === "y", f = de.has(c) ? -1 : 1, l = i && u ? -1 : 1, a = Y(e, t);
+  let {
+    mainAxis: m,
+    crossAxis: h,
+    alignmentAxis: v
+  } = typeof a == "number" ? {
+    mainAxis: a,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: a.mainAxis || 0,
+    crossAxis: a.crossAxis || 0,
+    alignmentAxis: a.alignmentAxis
+  };
+  return s && typeof v == "number" && (h = s === "end" ? v * -1 : v), u ? {
+    x: h * l,
+    y: m * f
+  } : {
+    x: m * f,
+    y: h * l
+  };
+}
+const Pn = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var n, r;
+      const {
+        x: o,
+        y: i,
+        placement: c,
+        middlewareData: s
+      } = e, u = await Mn(e, t);
+      return c === ((n = s.offset) == null ? void 0 : n.placement) && (r = s.arrow) != null && r.alignmentOffset ? {} : {
+        x: o + u.x,
+        y: i + u.y,
+        data: {
+          ...u,
+          placement: c
+        }
+      };
+    }
+  };
+}, kn = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: r,
+        placement: o,
+        platform: i
+      } = e, {
+        mainAxis: c = !0,
+        crossAxis: s = !1,
+        limiter: u = {
+          fn: (p) => {
+            let {
+              x: y,
+              y: x
+            } = p;
+            return {
+              x: y,
+              y: x
+            };
+          }
+        },
+        ...f
+      } = Y(t, e), l = {
+        x: n,
+        y: r
+      }, a = await i.detectOverflow(e, f), m = I(j(o)), h = Nt(m);
+      let v = l[h], d = l[m];
+      if (c) {
+        const p = h === "y" ? "top" : "left", y = h === "y" ? "bottom" : "right", x = v + a[p], b = v - a[y];
+        v = Tt(x, v, b);
+      }
+      if (s) {
+        const p = m === "y" ? "top" : "left", y = m === "y" ? "bottom" : "right", x = d + a[p], b = d - a[y];
+        d = Tt(x, d, b);
+      }
+      const g = u.fn({
+        ...e,
+        [h]: v,
+        [m]: d
+      });
+      return {
+        ...g,
+        data: {
+          x: g.x - n,
+          y: g.y - r,
+          enabled: {
+            [h]: c,
+            [m]: s
+          }
+        }
+      };
+    }
+  };
+}, Ln = function(t) {
+  return t === void 0 && (t = {}), {
+    options: t,
+    fn(e) {
+      const {
+        x: n,
+        y: r,
+        placement: o,
+        rects: i,
+        middlewareData: c
+      } = e, {
+        offset: s = 0,
+        mainAxis: u = !0,
+        crossAxis: f = !0
+      } = Y(t, e), l = {
+        x: n,
+        y: r
+      }, a = I(o), m = Nt(a);
+      let h = l[m], v = l[a];
+      const d = Y(s, e), g = typeof d == "number" ? {
+        mainAxis: d,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...d
+      };
+      if (u) {
+        const x = m === "y" ? "height" : "width", b = i.reference[m] - i.floating[x] + g.mainAxis, S = i.reference[m] + i.reference[x] - g.mainAxis;
+        h < b ? h = b : h > S && (h = S);
+      }
+      if (f) {
+        var p, y;
+        const x = m === "y" ? "width" : "height", b = de.has(j(o)), S = i.reference[a] - i.floating[x] + (b && ((p = c.offset) == null ? void 0 : p[a]) || 0) + (b ? 0 : g.crossAxis), C = i.reference[a] + i.reference[x] + (b ? 0 : ((y = c.offset) == null ? void 0 : y[a]) || 0) - (b ? g.crossAxis : 0);
+        v < S ? v = S : v > C && (v = C);
+      }
+      return {
+        [m]: h,
+        [a]: v
+      };
+    }
+  };
+}, Tn = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    async fn(e) {
+      var n, r;
+      const {
+        placement: o,
+        rects: i,
+        platform: c,
+        elements: s
+      } = e, {
+        apply: u = () => {
+        },
+        ...f
+      } = Y(t, e), l = await c.detectOverflow(e, f), a = j(o), m = ot(o), h = I(o) === "y", {
+        width: v,
+        height: d
+      } = i.floating;
+      let g, p;
+      a === "top" || a === "bottom" ? (g = a, p = m === (await (c.isRTL == null ? void 0 : c.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (p = a, g = m === "end" ? "top" : "bottom");
+      const y = d - l.top - l.bottom, x = v - l.left - l.right, b = U(d - l[g], y), S = U(v - l[p], x), C = !e.middlewareData.shift;
+      let R = b, M = S;
+      if ((n = e.middlewareData.shift) != null && n.enabled.x && (M = x), (r = e.middlewareData.shift) != null && r.enabled.y && (R = y), C && !m) {
+        const O = B(l.left, 0), P = B(l.right, 0), T = B(l.top, 0), D = B(l.bottom, 0);
+        h ? M = v - 2 * (O !== 0 || P !== 0 ? O + P : B(l.left, l.right)) : R = d - 2 * (T !== 0 || D !== 0 ? T + D : B(l.top, l.bottom));
+      }
+      await u({
+        ...e,
+        availableWidth: M,
+        availableHeight: R
+      });
+      const L = await c.getDimensions(s.floating);
+      return v !== L.width || d !== L.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function bt() {
+  return typeof window < "u";
+}
+function it(t) {
+  return he(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function F(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function X(t) {
+  var e;
+  return (e = (he(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function he(t) {
+  return bt() ? t instanceof Node || t instanceof F(t).Node : !1;
+}
+function V(t) {
+  return bt() ? t instanceof Element || t instanceof F(t).Element : !1;
+}
+function _(t) {
+  return bt() ? t instanceof HTMLElement || t instanceof F(t).HTMLElement : !1;
+}
+function Kt(t) {
+  return !bt() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof F(t).ShadowRoot;
+}
+const Dn = /* @__PURE__ */ new Set(["inline", "contents"]);
+function st(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: r,
+    display: o
+  } = H(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + r + n) && !Dn.has(o);
+}
+const Wn = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function Nn(t) {
+  return Wn.has(it(t));
+}
+const Bn = [":popover-open", ":modal"];
+function St(t) {
+  return Bn.some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+const Fn = ["transform", "translate", "scale", "rotate", "perspective"], Vn = ["transform", "translate", "scale", "rotate", "perspective", "filter"], Hn = ["paint", "layout", "strict", "content"];
+function Vt(t) {
+  const e = Ht(), n = V(t) ? H(t) : t;
+  return Fn.some((r) => n[r] ? n[r] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !e && (n.filter ? n.filter !== "none" : !1) || Vn.some((r) => (n.willChange || "").includes(r)) || Hn.some((r) => (n.contain || "").includes(r));
+}
+function $n(t) {
+  let e = G(t);
+  for (; _(e) && !rt(e); ) {
+    if (Vt(e))
+      return e;
+    if (St(e))
+      return null;
+    e = G(e);
+  }
+  return null;
+}
+function Ht() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const In = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function rt(t) {
+  return In.has(it(t));
+}
+function H(t) {
+  return F(t).getComputedStyle(t);
+}
+function Ct(t) {
+  return V(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function G(t) {
+  if (it(t) === "html")
+    return t;
+  const e = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    Kt(t) && t.host || // Fallback.
+    X(t)
+  );
+  return Kt(e) ? e.host : e;
+}
+function me(t) {
+  const e = G(t);
+  return rt(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : _(e) && st(e) ? e : me(e);
+}
+function ct(t, e, n) {
+  var r;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const o = me(t), i = o === ((r = t.ownerDocument) == null ? void 0 : r.body), c = F(o);
+  if (i) {
+    const s = Wt(c);
+    return e.concat(c, c.visualViewport || [], st(o) ? o : [], s && n ? ct(s) : []);
+  }
+  return e.concat(o, ct(o, [], n));
+}
+function Wt(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+function ge(t) {
+  const e = H(t);
+  let n = parseFloat(e.width) || 0, r = parseFloat(e.height) || 0;
+  const o = _(t), i = o ? t.offsetWidth : n, c = o ? t.offsetHeight : r, s = vt(n) !== i || vt(r) !== c;
+  return s && (n = i, r = c), {
+    width: n,
+    height: r,
+    $: s
+  };
+}
+function $t(t) {
+  return V(t) ? t : t.contextElement;
+}
+function nt(t) {
+  const e = $t(t);
+  if (!_(e))
+    return z(1);
+  const n = e.getBoundingClientRect(), {
+    width: r,
+    height: o,
+    $: i
+  } = ge(e);
+  let c = (i ? vt(n.width) : n.width) / r, s = (i ? vt(n.height) : n.height) / o;
+  return (!c || !Number.isFinite(c)) && (c = 1), (!s || !Number.isFinite(s)) && (s = 1), {
+    x: c,
+    y: s
+  };
+}
+const zn = /* @__PURE__ */ z(0);
+function ve(t) {
+  const e = F(t);
+  return !Ht() || !e.visualViewport ? zn : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function _n(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== F(t) ? !1 : e;
+}
+function K(t, e, n, r) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const o = t.getBoundingClientRect(), i = $t(t);
+  let c = z(1);
+  e && (r ? V(r) && (c = nt(r)) : c = nt(t));
+  const s = _n(i, n, r) ? ve(i) : z(0);
+  let u = (o.left + s.x) / c.x, f = (o.top + s.y) / c.y, l = o.width / c.x, a = o.height / c.y;
+  if (i) {
+    const m = F(i), h = r && V(r) ? F(r) : r;
+    let v = m, d = Wt(v);
+    for (; d && r && h !== v; ) {
+      const g = nt(d), p = d.getBoundingClientRect(), y = H(d), x = p.left + (d.clientLeft + parseFloat(y.paddingLeft)) * g.x, b = p.top + (d.clientTop + parseFloat(y.paddingTop)) * g.y;
+      u *= g.x, f *= g.y, l *= g.x, a *= g.y, u += x, f += b, v = F(d), d = Wt(v);
+    }
+  }
+  return wt({
+    width: l,
+    height: a,
+    x: u,
+    y: f
+  });
+}
+function Rt(t, e) {
+  const n = Ct(t).scrollLeft;
+  return e ? e.left + n : K(X(t)).left + n;
+}
+function pe(t, e) {
+  const n = t.getBoundingClientRect(), r = n.left + e.scrollLeft - Rt(t, n), o = n.top + e.scrollTop;
+  return {
+    x: r,
+    y: o
+  };
+}
+function Xn(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: r,
+    strategy: o
+  } = t;
+  const i = o === "fixed", c = X(r), s = e ? St(e.floating) : !1;
+  if (r === c || s && i)
+    return n;
+  let u = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, f = z(1);
+  const l = z(0), a = _(r);
+  if ((a || !a && !i) && ((it(r) !== "body" || st(c)) && (u = Ct(r)), _(r))) {
+    const h = K(r);
+    f = nt(r), l.x = h.x + r.clientLeft, l.y = h.y + r.clientTop;
+  }
+  const m = c && !a && !i ? pe(c, u) : z(0);
+  return {
+    width: n.width * f.x,
+    height: n.height * f.y,
+    x: n.x * f.x - u.scrollLeft * f.x + l.x + m.x,
+    y: n.y * f.y - u.scrollTop * f.y + l.y + m.y
+  };
+}
+function Yn(t) {
+  return Array.from(t.getClientRects());
+}
+function jn(t) {
+  const e = X(t), n = Ct(t), r = t.ownerDocument.body, o = B(e.scrollWidth, e.clientWidth, r.scrollWidth, r.clientWidth), i = B(e.scrollHeight, e.clientHeight, r.scrollHeight, r.clientHeight);
+  let c = -n.scrollLeft + Rt(t);
+  const s = -n.scrollTop;
+  return H(r).direction === "rtl" && (c += B(e.clientWidth, r.clientWidth) - o), {
+    width: o,
+    height: i,
+    x: c,
+    y: s
+  };
+}
+const Qt = 25;
+function qn(t, e) {
+  const n = F(t), r = X(t), o = n.visualViewport;
+  let i = r.clientWidth, c = r.clientHeight, s = 0, u = 0;
+  if (o) {
+    i = o.width, c = o.height;
+    const l = Ht();
+    (!l || l && e === "fixed") && (s = o.offsetLeft, u = o.offsetTop);
+  }
+  const f = Rt(r);
+  if (f <= 0) {
+    const l = r.ownerDocument, a = l.body, m = getComputedStyle(a), h = l.compatMode === "CSS1Compat" && parseFloat(m.marginLeft) + parseFloat(m.marginRight) || 0, v = Math.abs(r.clientWidth - a.clientWidth - h);
+    v <= Qt && (i -= v);
+  } else f <= Qt && (i += f);
+  return {
+    width: i,
+    height: c,
+    x: s,
+    y: u
+  };
+}
+const Zn = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function Un(t, e) {
+  const n = K(t, !0, e === "fixed"), r = n.top + t.clientTop, o = n.left + t.clientLeft, i = _(t) ? nt(t) : z(1), c = t.clientWidth * i.x, s = t.clientHeight * i.y, u = o * i.x, f = r * i.y;
+  return {
+    width: c,
+    height: s,
+    x: u,
+    y: f
+  };
+}
+function Jt(t, e, n) {
+  let r;
+  if (e === "viewport")
+    r = qn(t, n);
+  else if (e === "document")
+    r = jn(X(t));
+  else if (V(e))
+    r = Un(e, n);
+  else {
+    const o = ve(t);
+    r = {
+      x: e.x - o.x,
+      y: e.y - o.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return wt(r);
+}
+function we(t, e) {
+  const n = G(t);
+  return n === e || !V(n) || rt(n) ? !1 : H(n).position === "fixed" || we(n, e);
+}
+function Gn(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let r = ct(t, [], !1).filter((s) => V(s) && it(s) !== "body"), o = null;
+  const i = H(t).position === "fixed";
+  let c = i ? G(t) : t;
+  for (; V(c) && !rt(c); ) {
+    const s = H(c), u = Vt(c);
+    !u && s.position === "fixed" && (o = null), (i ? !u && !o : !u && s.position === "static" && !!o && Zn.has(o.position) || st(c) && !u && we(t, c)) ? r = r.filter((l) => l !== c) : o = s, c = G(c);
+  }
+  return e.set(t, r), r;
+}
+function Kn(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: r,
+    strategy: o
+  } = t;
+  const c = [...n === "clippingAncestors" ? St(e) ? [] : Gn(e, this._c) : [].concat(n), r], s = c[0], u = c.reduce((f, l) => {
+    const a = Jt(e, l, o);
+    return f.top = B(a.top, f.top), f.right = U(a.right, f.right), f.bottom = U(a.bottom, f.bottom), f.left = B(a.left, f.left), f;
+  }, Jt(e, s, o));
+  return {
+    width: u.right - u.left,
+    height: u.bottom - u.top,
+    x: u.left,
+    y: u.top
+  };
+}
+function Qn(t) {
+  const {
+    width: e,
+    height: n
+  } = ge(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function Jn(t, e, n) {
+  const r = _(e), o = X(e), i = n === "fixed", c = K(t, !0, i, e);
+  let s = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const u = z(0);
+  function f() {
+    u.x = Rt(o);
+  }
+  if (r || !r && !i)
+    if ((it(e) !== "body" || st(o)) && (s = Ct(e)), r) {
+      const h = K(e, !0, i, e);
+      u.x = h.x + e.clientLeft, u.y = h.y + e.clientTop;
+    } else o && f();
+  i && !r && o && f();
+  const l = o && !r && !i ? pe(o, s) : z(0), a = c.left + s.scrollLeft - u.x - l.x, m = c.top + s.scrollTop - u.y - l.y;
+  return {
+    x: a,
+    y: m,
+    width: c.width,
+    height: c.height
+  };
+}
+function Pt(t) {
+  return H(t).position === "static";
+}
+function te(t, e) {
+  if (!_(t) || H(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let n = t.offsetParent;
+  return X(t) === n && (n = n.ownerDocument.body), n;
+}
+function ye(t, e) {
+  const n = F(t);
+  if (St(t))
+    return n;
+  if (!_(t)) {
+    let o = G(t);
+    for (; o && !rt(o); ) {
+      if (V(o) && !Pt(o))
+        return o;
+      o = G(o);
+    }
+    return n;
+  }
+  let r = te(t, e);
+  for (; r && Nn(r) && Pt(r); )
+    r = te(r, e);
+  return r && rt(r) && Pt(r) && !Vt(r) ? n : r || $n(t) || n;
+}
+const tr = async function(t) {
+  const e = this.getOffsetParent || ye, n = this.getDimensions, r = await n(t.floating);
+  return {
+    reference: Jn(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function er(t) {
+  return H(t).direction === "rtl";
+}
+const nr = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Xn,
+  getDocumentElement: X,
+  getClippingRect: Kn,
+  getOffsetParent: ye,
+  getElementRects: tr,
+  getClientRects: Yn,
+  getDimensions: Qn,
+  getScale: nt,
+  isElement: V,
+  isRTL: er
+};
+function xe(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function rr(t, e) {
+  let n = null, r;
+  const o = X(t);
+  function i() {
+    var s;
+    clearTimeout(r), (s = n) == null || s.disconnect(), n = null;
+  }
+  function c(s, u) {
+    s === void 0 && (s = !1), u === void 0 && (u = 1), i();
+    const f = t.getBoundingClientRect(), {
+      left: l,
+      top: a,
+      width: m,
+      height: h
+    } = f;
+    if (s || e(), !m || !h)
+      return;
+    const v = dt(a), d = dt(o.clientWidth - (l + m)), g = dt(o.clientHeight - (a + h)), p = dt(l), x = {
+      rootMargin: -v + "px " + -d + "px " + -g + "px " + -p + "px",
+      threshold: B(0, U(1, u)) || 1
+    };
+    let b = !0;
+    function S(C) {
+      const R = C[0].intersectionRatio;
+      if (R !== u) {
+        if (!b)
+          return c();
+        R ? c(!1, R) : r = setTimeout(() => {
+          c(!1, 1e-7);
+        }, 1e3);
+      }
+      R === 1 && !xe(f, t.getBoundingClientRect()) && c(), b = !1;
+    }
+    try {
+      n = new IntersectionObserver(S, {
+        ...x,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(S, x);
+    }
+    n.observe(t);
+  }
+  return c(!0), i;
+}
+function pr(t, e, n, r) {
+  r === void 0 && (r = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: i = !0,
+    elementResize: c = typeof ResizeObserver == "function",
+    layoutShift: s = typeof IntersectionObserver == "function",
+    animationFrame: u = !1
+  } = r, f = $t(t), l = o || i ? [...f ? ct(f) : [], ...ct(e)] : [];
+  l.forEach((p) => {
+    o && p.addEventListener("scroll", n, {
+      passive: !0
+    }), i && p.addEventListener("resize", n);
+  });
+  const a = f && s ? rr(f, n) : null;
+  let m = -1, h = null;
+  c && (h = new ResizeObserver((p) => {
+    let [y] = p;
+    y && y.target === f && h && (h.unobserve(e), cancelAnimationFrame(m), m = requestAnimationFrame(() => {
+      var x;
+      (x = h) == null || x.observe(e);
+    })), n();
+  }), f && !u && h.observe(f), h.observe(e));
+  let v, d = u ? K(t) : null;
+  u && g();
+  function g() {
+    const p = K(t);
+    d && !xe(d, p) && n(), d = p, v = requestAnimationFrame(g);
+  }
+  return n(), () => {
+    var p;
+    l.forEach((y) => {
+      o && y.removeEventListener("scroll", n), i && y.removeEventListener("resize", n);
+    }), a == null || a(), (p = h) == null || p.disconnect(), h = null, u && cancelAnimationFrame(v);
+  };
+}
+const or = Pn, ir = kn, cr = En, sr = Tn, ar = On, ee = An, lr = Ln, fr = (t, e, n) => {
+  const r = /* @__PURE__ */ new Map(), o = {
+    platform: nr,
+    ...n
+  }, i = {
+    ...o.platform,
+    _c: r
+  };
+  return Rn(t, e, {
+    ...o,
+    platform: i
+  });
+};
+var ur = typeof document < "u", dr = function() {
+}, gt = ur ? Ce : dr;
+function yt(t, e) {
+  if (t === e)
+    return !0;
+  if (typeof t != typeof e)
+    return !1;
+  if (typeof t == "function" && t.toString() === e.toString())
+    return !0;
+  let n, r, o;
+  if (t && e && typeof t == "object") {
+    if (Array.isArray(t)) {
+      if (n = t.length, n !== e.length) return !1;
+      for (r = n; r-- !== 0; )
+        if (!yt(t[r], e[r]))
+          return !1;
+      return !0;
+    }
+    if (o = Object.keys(t), n = o.length, n !== Object.keys(e).length)
+      return !1;
+    for (r = n; r-- !== 0; )
+      if (!{}.hasOwnProperty.call(e, o[r]))
+        return !1;
+    for (r = n; r-- !== 0; ) {
+      const i = o[r];
+      if (!(i === "_owner" && t.$$typeof) && !yt(t[i], e[i]))
+        return !1;
+    }
+    return !0;
+  }
+  return t !== t && e !== e;
+}
+function be(t) {
+  return typeof window > "u" ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function ne(t, e) {
+  const n = be(t);
+  return Math.round(e * n) / n;
+}
+function kt(t) {
+  const e = w.useRef(t);
+  return gt(() => {
+    e.current = t;
+  }), e;
+}
+function wr(t) {
+  t === void 0 && (t = {});
+  const {
+    placement: e = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: o,
+    elements: {
+      reference: i,
+      floating: c
+    } = {},
+    transform: s = !0,
+    whileElementsMounted: u,
+    open: f
+  } = t, [l, a] = w.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: e,
+    middlewareData: {},
+    isPositioned: !1
+  }), [m, h] = w.useState(r);
+  yt(m, r) || h(r);
+  const [v, d] = w.useState(null), [g, p] = w.useState(null), y = w.useCallback((A) => {
+    A !== C.current && (C.current = A, d(A));
+  }, []), x = w.useCallback((A) => {
+    A !== R.current && (R.current = A, p(A));
+  }, []), b = i || v, S = c || g, C = w.useRef(null), R = w.useRef(null), M = w.useRef(l), L = u != null, O = kt(u), P = kt(o), T = kt(f), D = w.useCallback(() => {
+    if (!C.current || !R.current)
+      return;
+    const A = {
+      placement: e,
+      strategy: n,
+      middleware: m
+    };
+    P.current && (A.platform = P.current), fr(C.current, R.current, A).then((N) => {
+      const q = {
+        ...N,
+        // 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: T.current !== !1
+      };
+      E.current && !yt(M.current, q) && (M.current = q, Ae.flushSync(() => {
+        a(q);
+      }));
+    });
+  }, [m, e, n, P, T]);
+  gt(() => {
+    f === !1 && M.current.isPositioned && (M.current.isPositioned = !1, a((A) => ({
+      ...A,
+      isPositioned: !1
+    })));
+  }, [f]);
+  const E = w.useRef(!1);
+  gt(() => (E.current = !0, () => {
+    E.current = !1;
+  }), []), gt(() => {
+    if (b && (C.current = b), S && (R.current = S), b && S) {
+      if (O.current)
+        return O.current(b, S, D);
+      D();
+    }
+  }, [b, S, D, O, L]);
+  const $ = w.useMemo(() => ({
+    reference: C,
+    floating: R,
+    setReference: y,
+    setFloating: x
+  }), [y, x]), k = w.useMemo(() => ({
+    reference: b,
+    floating: S
+  }), [b, S]), W = w.useMemo(() => {
+    const A = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!k.floating)
+      return A;
+    const N = ne(k.floating, l.x), q = ne(k.floating, l.y);
+    return s ? {
+      ...A,
+      transform: "translate(" + N + "px, " + q + "px)",
+      ...be(k.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: N,
+      top: q
+    };
+  }, [n, s, k.floating, l.x, l.y]);
+  return w.useMemo(() => ({
+    ...l,
+    update: D,
+    refs: $,
+    elements: k,
+    floatingStyles: W
+  }), [l, D, $, k, W]);
+}
+const hr = (t) => {
+  function e(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return {
+    name: "arrow",
+    options: t,
+    fn(n) {
+      const {
+        element: r,
+        padding: o
+      } = typeof t == "function" ? t(n) : t;
+      return r && e(r) ? r.current != null ? ee({
+        element: r.current,
+        padding: o
+      }).fn(n) : {} : r ? ee({
+        element: r,
+        padding: o
+      }).fn(n) : {};
+    }
+  };
+}, yr = (t, e) => ({
+  ...or(t),
+  options: [t, e]
+}), xr = (t, e) => ({
+  ...ir(t),
+  options: [t, e]
+}), br = (t, e) => ({
+  ...lr(t),
+  options: [t, e]
+}), Sr = (t, e) => ({
+  ...cr(t),
+  options: [t, e]
+}), Cr = (t, e) => ({
+  ...sr(t),
+  options: [t, e]
+}), Rr = (t, e) => ({
+  ...ar(t),
+  options: [t, e]
+}), Ar = (t, e) => ({
+  ...hr(t),
+  options: [t, e]
+});
+export {
+  an as R,
+  Cr as a,
+  Ar as b,
+  Rr as c,
+  pr as d,
+  Sr as f,
+  vr as h,
+  br as l,
+  yr as o,
+  xr as s,
+  wr as u
+};