@caipira/tamandua 0.0.57 → 0.0.59

package/dist/floating-ui.vue-B5QcGNjh.js

@@ -0,0 +1,1018 @@
+import { computed as F, unref as X, ref as Y, shallowRef as Pt, watch as et, getCurrentScope as Mt, onScopeDispose as Ft, shallowReadonly as k } from "vue";
+const Bt = ["top", "right", "bottom", "left"], at = ["start", "end"], ft = /* @__PURE__ */ Bt.reduce((t, e) => t.concat(e, e + "-" + at[0], e + "-" + at[1]), []), z = Math.min, A = Math.max, Q = Math.round, J = Math.floor, B = (t) => ({
+  x: t,
+  y: t
+}), Vt = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Wt = {
+  start: "end",
+  end: "start"
+};
+function ut(t, e, n) {
+  return A(t, z(e, n));
+}
+function U(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function N(t) {
+  return t.split("-")[0];
+}
+function D(t) {
+  return t.split("-")[1];
+}
+function yt(t) {
+  return t === "x" ? "y" : "x";
+}
+function xt(t) {
+  return t === "y" ? "height" : "width";
+}
+function K(t) {
+  return ["top", "bottom"].includes(N(t)) ? "y" : "x";
+}
+function bt(t) {
+  return yt(K(t));
+}
+function Nt(t, e, n) {
+  n === void 0 && (n = !1);
+  const o = D(t), i = bt(t), s = xt(i);
+  let r = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return e.reference[s] > e.floating[s] && (r = dt(r)), [r, dt(r)];
+}
+function $t(t) {
+  return t.replace(/start|end/g, (e) => Wt[e]);
+}
+function dt(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => Vt[e]);
+}
+function _t(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function kt(t) {
+  return typeof t != "number" ? _t(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function Z(t) {
+  const {
+    x: e,
+    y: n,
+    width: o,
+    height: i
+  } = t;
+  return {
+    width: o,
+    height: i,
+    top: n,
+    left: e,
+    right: e + o,
+    bottom: n + i,
+    x: e,
+    y: n
+  };
+}
+function mt(t, e, n) {
+  let {
+    reference: o,
+    floating: i
+  } = t;
+  const s = K(e), r = bt(e), c = xt(r), l = N(e), a = s === "y", f = o.x + o.width / 2 - i.width / 2, u = o.y + o.height / 2 - i.height / 2, m = o[c] / 2 - i[c] / 2;
+  let d;
+  switch (l) {
+    case "top":
+      d = {
+        x: f,
+        y: o.y - i.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: f,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      d = {
+        x: o.x + o.width,
+        y: u
+      };
+      break;
+    case "left":
+      d = {
+        x: o.x - i.width,
+        y: u
+      };
+      break;
+    default:
+      d = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (D(e)) {
+    case "start":
+      d[r] -= m * (n && a ? -1 : 1);
+      break;
+    case "end":
+      d[r] += m * (n && a ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const Ht = async (t, e, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: i = "absolute",
+    middleware: s = [],
+    platform: r
+  } = n, c = s.filter(Boolean), l = await (r.isRTL == null ? void 0 : r.isRTL(e));
+  let a = await r.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  }), {
+    x: f,
+    y: u
+  } = mt(a, o, l), m = o, d = {}, w = 0;
+  for (let g = 0; g < c.length; g++) {
+    const {
+      name: v,
+      fn: h
+    } = c[g], {
+      x: p,
+      y,
+      data: R,
+      reset: b
+    } = await h({
+      x: f,
+      y: u,
+      initialPlacement: o,
+      placement: m,
+      strategy: i,
+      middlewareData: d,
+      rects: a,
+      platform: r,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    f = p ?? f, u = y ?? u, d = {
+      ...d,
+      [v]: {
+        ...d[v],
+        ...R
+      }
+    }, b && w <= 50 && (w++, typeof b == "object" && (b.placement && (m = b.placement), b.rects && (a = b.rects === !0 ? await r.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: i
+    }) : b.rects), {
+      x: f,
+      y: u
+    } = mt(a, m, l)), g = -1);
+  }
+  return {
+    x: f,
+    y: u,
+    placement: m,
+    strategy: i,
+    middlewareData: d
+  };
+};
+async function ot(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const {
+    x: o,
+    y: i,
+    platform: s,
+    rects: r,
+    elements: c,
+    strategy: l
+  } = t, {
+    boundary: a = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: u = "floating",
+    altBoundary: m = !1,
+    padding: d = 0
+  } = U(e, t), w = kt(d), v = c[m ? u === "floating" ? "reference" : "floating" : u], h = Z(await s.getClippingRect({
+    element: (n = await (s.isElement == null ? void 0 : s.isElement(v))) == null || n ? v : v.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(c.floating)),
+    boundary: a,
+    rootBoundary: f,
+    strategy: l
+  })), p = u === "floating" ? {
+    x: o,
+    y: i,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference, y = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(c.floating)), R = await (s.isElement == null ? void 0 : s.isElement(y)) ? await (s.getScale == null ? void 0 : s.getScale(y)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, b = Z(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: p,
+    offsetParent: y,
+    strategy: l
+  }) : p);
+  return {
+    top: (h.top - b.top + w.top) / R.y,
+    bottom: (b.bottom - h.bottom + w.bottom) / R.y,
+    left: (h.left - b.left + w.left) / R.x,
+    right: (b.right - h.right + w.right) / R.x
+  };
+}
+function zt(t, e, n) {
+  return (t ? [...n.filter((i) => D(i) === t), ...n.filter((i) => D(i) !== t)] : n.filter((i) => N(i) === i)).filter((i) => t ? D(i) === t || (e ? $t(i) !== i : !1) : !0);
+}
+const It = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "autoPlacement",
+    options: t,
+    async fn(e) {
+      var n, o, i;
+      const {
+        rects: s,
+        middlewareData: r,
+        placement: c,
+        platform: l,
+        elements: a
+      } = e, {
+        crossAxis: f = !1,
+        alignment: u,
+        allowedPlacements: m = ft,
+        autoAlignment: d = !0,
+        ...w
+      } = U(t, e), g = u !== void 0 || m === ft ? zt(u || null, d, m) : m, v = await ot(e, w), h = ((n = r.autoPlacement) == null ? void 0 : n.index) || 0, p = g[h];
+      if (p == null)
+        return {};
+      const y = Nt(p, s, await (l.isRTL == null ? void 0 : l.isRTL(a.floating)));
+      if (c !== p)
+        return {
+          reset: {
+            placement: g[0]
+          }
+        };
+      const R = [v[N(p)], v[y[0]], v[y[1]]], b = [...((o = r.autoPlacement) == null ? void 0 : o.overflows) || [], {
+        placement: p,
+        overflows: R
+      }], O = g[h + 1];
+      if (O)
+        return {
+          data: {
+            index: h + 1,
+            overflows: b
+          },
+          reset: {
+            placement: O
+          }
+        };
+      const x = b.map((S) => {
+        const j = D(S.placement);
+        return [S.placement, j && f ? (
+          // Check along the mainAxis and main crossAxis side.
+          S.overflows.slice(0, 2).reduce((Lt, Dt) => Lt + Dt, 0)
+        ) : (
+          // Check only the mainAxis.
+          S.overflows[0]
+        ), S.overflows];
+      }).sort((S, j) => S[1] - j[1]), M = ((i = x.filter((S) => S[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        D(S[0]) ? 2 : 3
+      ).every((j) => j <= 0))[0]) == null ? void 0 : i[0]) || x[0][0];
+      return M !== c ? {
+        data: {
+          index: h + 1,
+          overflows: b
+        },
+        reset: {
+          placement: M
+        }
+      } : {};
+    }
+  };
+};
+async function jt(t, e) {
+  const {
+    placement: n,
+    platform: o,
+    elements: i
+  } = t, s = await (o.isRTL == null ? void 0 : o.isRTL(i.floating)), r = N(n), c = D(n), l = K(n) === "y", a = ["left", "top"].includes(r) ? -1 : 1, f = s && l ? -1 : 1, u = U(e, t);
+  let {
+    mainAxis: m,
+    crossAxis: d,
+    alignmentAxis: w
+  } = typeof u == "number" ? {
+    mainAxis: u,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: 0,
+    crossAxis: 0,
+    alignmentAxis: null,
+    ...u
+  };
+  return c && typeof w == "number" && (d = c === "end" ? w * -1 : w), l ? {
+    x: d * f,
+    y: m * a
+  } : {
+    x: m * a,
+    y: d * f
+  };
+}
+const Xt = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var n, o;
+      const {
+        x: i,
+        y: s,
+        placement: r,
+        middlewareData: c
+      } = e, l = await jt(e, t);
+      return r === ((n = c.offset) == null ? void 0 : n.placement) && (o = c.arrow) != null && o.alignmentOffset ? {} : {
+        x: i + l.x,
+        y: s + l.y,
+        data: {
+          ...l,
+          placement: r
+        }
+      };
+    }
+  };
+}, Yt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: o,
+        placement: i
+      } = e, {
+        mainAxis: s = !0,
+        crossAxis: r = !1,
+        limiter: c = {
+          fn: (v) => {
+            let {
+              x: h,
+              y: p
+            } = v;
+            return {
+              x: h,
+              y: p
+            };
+          }
+        },
+        ...l
+      } = U(t, e), a = {
+        x: n,
+        y: o
+      }, f = await ot(e, l), u = K(N(i)), m = yt(u);
+      let d = a[m], w = a[u];
+      if (s) {
+        const v = m === "y" ? "top" : "left", h = m === "y" ? "bottom" : "right", p = d + f[v], y = d - f[h];
+        d = ut(p, d, y);
+      }
+      if (r) {
+        const v = u === "y" ? "top" : "left", h = u === "y" ? "bottom" : "right", p = w + f[v], y = w - f[h];
+        w = ut(p, w, y);
+      }
+      const g = c.fn({
+        ...e,
+        [m]: d,
+        [u]: w
+      });
+      return {
+        ...g,
+        data: {
+          x: g.x - n,
+          y: g.y - o
+        }
+      };
+    }
+  };
+}, qt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    async fn(e) {
+      const {
+        placement: n,
+        rects: o,
+        platform: i,
+        elements: s
+      } = e, {
+        apply: r = () => {
+        },
+        ...c
+      } = U(t, e), l = await ot(e, c), a = N(n), f = D(n), u = K(n) === "y", {
+        width: m,
+        height: d
+      } = o.floating;
+      let w, g;
+      a === "top" || a === "bottom" ? (w = a, g = f === (await (i.isRTL == null ? void 0 : i.isRTL(s.floating)) ? "start" : "end") ? "left" : "right") : (g = a, w = f === "end" ? "top" : "bottom");
+      const v = d - l[w], h = m - l[g], p = !e.middlewareData.shift;
+      let y = v, R = h;
+      if (u) {
+        const O = m - l.left - l.right;
+        R = f || p ? z(h, O) : O;
+      } else {
+        const O = d - l.top - l.bottom;
+        y = f || p ? z(v, O) : O;
+      }
+      if (p && !f) {
+        const O = A(l.left, 0), x = A(l.right, 0), _ = A(l.top, 0), M = A(l.bottom, 0);
+        u ? R = m - 2 * (O !== 0 || x !== 0 ? O + x : A(l.left, l.right)) : y = d - 2 * (_ !== 0 || M !== 0 ? _ + M : A(l.top, l.bottom));
+      }
+      await r({
+        ...e,
+        availableWidth: R,
+        availableHeight: y
+      });
+      const b = await i.getDimensions(s.floating);
+      return m !== b.width || d !== b.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function $(t) {
+  return it(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function C(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function P(t) {
+  var e;
+  return (e = (it(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function it(t) {
+  return t instanceof Node || t instanceof C(t).Node;
+}
+function T(t) {
+  return t instanceof Element || t instanceof C(t).Element;
+}
+function L(t) {
+  return t instanceof HTMLElement || t instanceof C(t).HTMLElement;
+}
+function ht(t) {
+  return typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof C(t).ShadowRoot;
+}
+function G(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: o,
+    display: i
+  } = E(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !["inline", "contents"].includes(i);
+}
+function Ut(t) {
+  return ["table", "td", "th"].includes($(t));
+}
+function rt(t) {
+  const e = st(), n = E(t);
+  return n.transform !== "none" || n.perspective !== "none" || (n.containerType ? n.containerType !== "normal" : !1) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !e && (n.filter ? n.filter !== "none" : !1) || ["transform", "perspective", "filter"].some((o) => (n.willChange || "").includes(o)) || ["paint", "layout", "strict", "content"].some((o) => (n.contain || "").includes(o));
+}
+function Kt(t) {
+  let e = V(t);
+  for (; L(e) && !I(e); ) {
+    if (rt(e))
+      return e;
+    e = V(e);
+  }
+  return null;
+}
+function st() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function I(t) {
+  return ["html", "body", "#document"].includes($(t));
+}
+function E(t) {
+  return C(t).getComputedStyle(t);
+}
+function tt(t) {
+  return T(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.pageXOffset,
+    scrollTop: t.pageYOffset
+  };
+}
+function V(t) {
+  if ($(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.
+    ht(t) && t.host || // Fallback.
+    P(t)
+  );
+  return ht(e) ? e.host : e;
+}
+function Rt(t) {
+  const e = V(t);
+  return I(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : L(e) && G(e) ? e : Rt(e);
+}
+function q(t, e, n) {
+  var o;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const i = Rt(t), s = i === ((o = t.ownerDocument) == null ? void 0 : o.body), r = C(i);
+  return s ? e.concat(r, r.visualViewport || [], G(i) ? i : [], r.frameElement && n ? q(r.frameElement) : []) : e.concat(i, q(i, [], n));
+}
+function Ot(t) {
+  const e = E(t);
+  let n = parseFloat(e.width) || 0, o = parseFloat(e.height) || 0;
+  const i = L(t), s = i ? t.offsetWidth : n, r = i ? t.offsetHeight : o, c = Q(n) !== s || Q(o) !== r;
+  return c && (n = s, o = r), {
+    width: n,
+    height: o,
+    $: c
+  };
+}
+function lt(t) {
+  return T(t) ? t : t.contextElement;
+}
+function H(t) {
+  const e = lt(t);
+  if (!L(e))
+    return B(1);
+  const n = e.getBoundingClientRect(), {
+    width: o,
+    height: i,
+    $: s
+  } = Ot(e);
+  let r = (s ? Q(n.width) : n.width) / o, c = (s ? Q(n.height) : n.height) / i;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: r,
+    y: c
+  };
+}
+const Gt = /* @__PURE__ */ B(0);
+function At(t) {
+  const e = C(t);
+  return !st() || !e.visualViewport ? Gt : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function Jt(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== C(t) ? !1 : e;
+}
+function W(t, e, n, o) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const i = t.getBoundingClientRect(), s = lt(t);
+  let r = B(1);
+  e && (o ? T(o) && (r = H(o)) : r = H(t));
+  const c = Jt(s, n, o) ? At(s) : B(0);
+  let l = (i.left + c.x) / r.x, a = (i.top + c.y) / r.y, f = i.width / r.x, u = i.height / r.y;
+  if (s) {
+    const m = C(s), d = o && T(o) ? C(o) : o;
+    let w = m, g = w.frameElement;
+    for (; g && o && d !== w; ) {
+      const v = H(g), h = g.getBoundingClientRect(), p = E(g), y = h.left + (g.clientLeft + parseFloat(p.paddingLeft)) * v.x, R = h.top + (g.clientTop + parseFloat(p.paddingTop)) * v.y;
+      l *= v.x, a *= v.y, f *= v.x, u *= v.y, l += y, a += R, w = C(g), g = w.frameElement;
+    }
+  }
+  return Z({
+    width: f,
+    height: u,
+    x: l,
+    y: a
+  });
+}
+const Qt = [":popover-open", ":modal"];
+function ct(t) {
+  return Qt.some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+function Zt(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: o,
+    strategy: i
+  } = t;
+  const s = i === "fixed", r = P(o), c = e ? ct(e.floating) : !1;
+  if (o === r || c && s)
+    return n;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, a = B(1);
+  const f = B(0), u = L(o);
+  if ((u || !u && !s) && (($(o) !== "body" || G(r)) && (l = tt(o)), L(o))) {
+    const m = W(o);
+    a = H(o), f.x = m.x + o.clientLeft, f.y = m.y + o.clientTop;
+  }
+  return {
+    width: n.width * a.x,
+    height: n.height * a.y,
+    x: n.x * a.x - l.scrollLeft * a.x + f.x,
+    y: n.y * a.y - l.scrollTop * a.y + f.y
+  };
+}
+function te(t) {
+  return Array.from(t.getClientRects());
+}
+function Ct(t) {
+  return W(P(t)).left + tt(t).scrollLeft;
+}
+function ee(t) {
+  const e = P(t), n = tt(t), o = t.ownerDocument.body, i = A(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth), s = A(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
+  let r = -n.scrollLeft + Ct(t);
+  const c = -n.scrollTop;
+  return E(o).direction === "rtl" && (r += A(e.clientWidth, o.clientWidth) - i), {
+    width: i,
+    height: s,
+    x: r,
+    y: c
+  };
+}
+function ne(t, e) {
+  const n = C(t), o = P(t), i = n.visualViewport;
+  let s = o.clientWidth, r = o.clientHeight, c = 0, l = 0;
+  if (i) {
+    s = i.width, r = i.height;
+    const a = st();
+    (!a || a && e === "fixed") && (c = i.offsetLeft, l = i.offsetTop);
+  }
+  return {
+    width: s,
+    height: r,
+    x: c,
+    y: l
+  };
+}
+function oe(t, e) {
+  const n = W(t, !0, e === "fixed"), o = n.top + t.clientTop, i = n.left + t.clientLeft, s = L(t) ? H(t) : B(1), r = t.clientWidth * s.x, c = t.clientHeight * s.y, l = i * s.x, a = o * s.y;
+  return {
+    width: r,
+    height: c,
+    x: l,
+    y: a
+  };
+}
+function gt(t, e, n) {
+  let o;
+  if (e === "viewport")
+    o = ne(t, n);
+  else if (e === "document")
+    o = ee(P(t));
+  else if (T(e))
+    o = oe(e, n);
+  else {
+    const i = At(t);
+    o = {
+      ...e,
+      x: e.x - i.x,
+      y: e.y - i.y
+    };
+  }
+  return Z(o);
+}
+function Et(t, e) {
+  const n = V(t);
+  return n === e || !T(n) || I(n) ? !1 : E(n).position === "fixed" || Et(n, e);
+}
+function ie(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let o = q(t, [], !1).filter((c) => T(c) && $(c) !== "body"), i = null;
+  const s = E(t).position === "fixed";
+  let r = s ? V(t) : t;
+  for (; T(r) && !I(r); ) {
+    const c = E(r), l = rt(r);
+    !l && c.position === "fixed" && (i = null), (s ? !l && !i : !l && c.position === "static" && !!i && ["absolute", "fixed"].includes(i.position) || G(r) && !l && Et(t, r)) ? o = o.filter((f) => f !== r) : i = c, r = V(r);
+  }
+  return e.set(t, o), o;
+}
+function re(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: o,
+    strategy: i
+  } = t;
+  const r = [...n === "clippingAncestors" ? ct(e) ? [] : ie(e, this._c) : [].concat(n), o], c = r[0], l = r.reduce((a, f) => {
+    const u = gt(e, f, i);
+    return a.top = A(u.top, a.top), a.right = z(u.right, a.right), a.bottom = z(u.bottom, a.bottom), a.left = A(u.left, a.left), a;
+  }, gt(e, c, i));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
+  };
+}
+function se(t) {
+  const {
+    width: e,
+    height: n
+  } = Ot(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function le(t, e, n) {
+  const o = L(e), i = P(e), s = n === "fixed", r = W(t, !0, s, e);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = B(0);
+  if (o || !o && !s)
+    if (($(e) !== "body" || G(i)) && (c = tt(e)), o) {
+      const u = W(e, !0, s, e);
+      l.x = u.x + e.clientLeft, l.y = u.y + e.clientTop;
+    } else
+      i && (l.x = Ct(i));
+  const a = r.left + c.scrollLeft - l.x, f = r.top + c.scrollTop - l.y;
+  return {
+    x: a,
+    y: f,
+    width: r.width,
+    height: r.height
+  };
+}
+function nt(t) {
+  return E(t).position === "static";
+}
+function pt(t, e) {
+  return !L(t) || E(t).position === "fixed" ? null : e ? e(t) : t.offsetParent;
+}
+function St(t, e) {
+  const n = C(t);
+  if (ct(t))
+    return n;
+  if (!L(t)) {
+    let i = V(t);
+    for (; i && !I(i); ) {
+      if (T(i) && !nt(i))
+        return i;
+      i = V(i);
+    }
+    return n;
+  }
+  let o = pt(t, e);
+  for (; o && Ut(o) && nt(o); )
+    o = pt(o, e);
+  return o && I(o) && nt(o) && !rt(o) ? n : o || Kt(t) || n;
+}
+const ce = async function(t) {
+  const e = this.getOffsetParent || St, n = this.getDimensions, o = await n(t.floating);
+  return {
+    reference: le(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function ae(t) {
+  return E(t).direction === "rtl";
+}
+const fe = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Zt,
+  getDocumentElement: P,
+  getClippingRect: re,
+  getOffsetParent: St,
+  getElementRects: ce,
+  getClientRects: te,
+  getDimensions: se,
+  getScale: H,
+  isElement: T,
+  isRTL: ae
+};
+function ue(t, e) {
+  let n = null, o;
+  const i = P(t);
+  function s() {
+    var c;
+    clearTimeout(o), (c = n) == null || c.disconnect(), n = null;
+  }
+  function r(c, l) {
+    c === void 0 && (c = !1), l === void 0 && (l = 1), s();
+    const {
+      left: a,
+      top: f,
+      width: u,
+      height: m
+    } = t.getBoundingClientRect();
+    if (c || e(), !u || !m)
+      return;
+    const d = J(f), w = J(i.clientWidth - (a + u)), g = J(i.clientHeight - (f + m)), v = J(a), p = {
+      rootMargin: -d + "px " + -w + "px " + -g + "px " + -v + "px",
+      threshold: A(0, z(1, l)) || 1
+    };
+    let y = !0;
+    function R(b) {
+      const O = b[0].intersectionRatio;
+      if (O !== l) {
+        if (!y)
+          return r();
+        O ? r(!1, O) : o = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 1e3);
+      }
+      y = !1;
+    }
+    try {
+      n = new IntersectionObserver(R, {
+        ...p,
+        // Handle <iframe>s
+        root: i.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(R, p);
+    }
+    n.observe(t);
+  }
+  return r(!0), s;
+}
+function ge(t, e, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: i = !0,
+    ancestorResize: s = !0,
+    elementResize: r = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: l = !1
+  } = o, a = lt(t), f = i || s ? [...a ? q(a) : [], ...q(e)] : [];
+  f.forEach((h) => {
+    i && h.addEventListener("scroll", n, {
+      passive: !0
+    }), s && h.addEventListener("resize", n);
+  });
+  const u = a && c ? ue(a, n) : null;
+  let m = -1, d = null;
+  r && (d = new ResizeObserver((h) => {
+    let [p] = h;
+    p && p.target === a && d && (d.unobserve(e), cancelAnimationFrame(m), m = requestAnimationFrame(() => {
+      var y;
+      (y = d) == null || y.observe(e);
+    })), n();
+  }), a && !l && d.observe(a), d.observe(e));
+  let w, g = l ? W(t) : null;
+  l && v();
+  function v() {
+    const h = W(t);
+    g && (h.x !== g.x || h.y !== g.y || h.width !== g.width || h.height !== g.height) && n(), g = h, w = requestAnimationFrame(v);
+  }
+  return n(), () => {
+    var h;
+    f.forEach((p) => {
+      i && p.removeEventListener("scroll", n), s && p.removeEventListener("resize", n);
+    }), u?.(), (h = d) == null || h.disconnect(), d = null, l && cancelAnimationFrame(w);
+  };
+}
+const pe = Xt, we = It, ve = Yt, ye = qt, de = (t, e, n) => {
+  const o = /* @__PURE__ */ new Map(), i = {
+    platform: fe,
+    ...n
+  }, s = {
+    ...i.platform,
+    _c: o
+  };
+  return Ht(t, e, {
+    ...i,
+    platform: s
+  });
+};
+function me(t) {
+  return t != null && typeof t == "object" && "$el" in t;
+}
+function wt(t) {
+  if (me(t)) {
+    const e = t.$el;
+    return it(e) && $(e) === "#comment" ? null : e;
+  }
+  return t;
+}
+function Tt(t) {
+  return typeof window > "u" ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function vt(t, e) {
+  const n = Tt(t);
+  return Math.round(e * n) / n;
+}
+function xe(t, e, n) {
+  n === void 0 && (n = {});
+  const o = n.whileElementsMounted, i = F(() => {
+    var x;
+    return (x = X(n.open)) != null ? x : !0;
+  }), s = F(() => X(n.middleware)), r = F(() => {
+    var x;
+    return (x = X(n.placement)) != null ? x : "bottom";
+  }), c = F(() => {
+    var x;
+    return (x = X(n.strategy)) != null ? x : "absolute";
+  }), l = F(() => {
+    var x;
+    return (x = X(n.transform)) != null ? x : !0;
+  }), a = F(() => wt(t.value)), f = F(() => wt(e.value)), u = Y(0), m = Y(0), d = Y(c.value), w = Y(r.value), g = Pt({}), v = Y(!1), h = F(() => {
+    const x = {
+      position: d.value,
+      left: "0",
+      top: "0"
+    };
+    if (!f.value)
+      return x;
+    const _ = vt(f.value, u.value), M = vt(f.value, m.value);
+    return l.value ? {
+      ...x,
+      transform: "translate(" + _ + "px, " + M + "px)",
+      ...Tt(f.value) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: d.value,
+      left: _ + "px",
+      top: M + "px"
+    };
+  });
+  let p;
+  function y() {
+    a.value == null || f.value == null || de(a.value, f.value, {
+      middleware: s.value,
+      placement: r.value,
+      strategy: c.value
+    }).then((x) => {
+      u.value = x.x, m.value = x.y, d.value = x.strategy, w.value = x.placement, g.value = x.middlewareData, v.value = !0;
+    });
+  }
+  function R() {
+    typeof p == "function" && (p(), p = void 0);
+  }
+  function b() {
+    if (R(), o === void 0) {
+      y();
+      return;
+    }
+    if (a.value != null && f.value != null) {
+      p = o(a.value, f.value, y);
+      return;
+    }
+  }
+  function O() {
+    i.value || (v.value = !1);
+  }
+  return et([s, r, c], y, {
+    flush: "sync"
+  }), et([a, f], b, {
+    flush: "sync"
+  }), et(i, O, {
+    flush: "sync"
+  }), Mt() && Ft(R), {
+    x: k(u),
+    y: k(m),
+    strategy: k(d),
+    placement: k(w),
+    middlewareData: k(g),
+    isPositioned: k(v),
+    floatingStyles: h,
+    update: y
+  };
+}
+export {
+  ve as a,
+  ge as b,
+  we as c,
+  pe as o,
+  ye as s,
+  xe as u
+};