v-float 0.1.0

package/dist/v-float.es.js

@@ -0,0 +1,1956 @@
+var gt = Object.defineProperty;
+var Ie = (e) => {
+  throw TypeError(e);
+};
+var yt = (e, t, n) => t in e ? gt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var U = (e, t, n) => yt(e, typeof t != "symbol" ? t + "" : t, n), Ee = (e, t, n) => t.has(e) || Ie("Cannot " + n);
+var Te = (e, t, n) => (Ee(e, t, "read from private field"), n ? n.call(e) : t.get(e)), de = (e, t, n) => t.has(e) ? Ie("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n), Le = (e, t, n, o) => (Ee(e, t, "write to private field"), o ? o.call(e, n) : t.set(e, n), n), Oe = (e, t, n) => (Ee(e, t, "access private method"), n);
+import { ref as _, computed as O, toValue as T, shallowRef as Me, watch as ve, onWatcherCleanup as q, onScopeDispose as ae, watchPostEffect as re, getCurrentScope as wt, unref as xt, onMounted as bt, watchEffect as Ae, readonly as Et, shallowReactive as Tt } from "vue";
+function Ye(e, t) {
+  const n = it(e);
+  return Math.round(t * n) / n;
+}
+function it(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+let Lt = 0;
+function Ot() {
+  return `vfloat-id-${Lt++}`;
+}
+const Rt = ["top", "right", "bottom", "left"], ee = Math.min, G = Math.max, pe = Math.round, he = Math.floor, F = (e) => ({
+  x: e,
+  y: e
+}), Pt = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Ct = {
+  start: "end",
+  end: "start"
+};
+function De(e, t, n) {
+  return G(e, ee(t, n));
+}
+function oe(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function J(e) {
+  return e.split("-")[0];
+}
+function ue(e) {
+  return e.split("-")[1];
+}
+function rt(e) {
+  return e === "x" ? "y" : "x";
+}
+function He(e) {
+  return e === "y" ? "height" : "width";
+}
+function te(e) {
+  return ["top", "bottom"].includes(J(e)) ? "y" : "x";
+}
+function Fe(e) {
+  return rt(te(e));
+}
+function Mt(e, t, n) {
+  n === void 0 && (n = !1);
+  const o = ue(e), i = Fe(e), s = He(i);
+  let r = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return t.reference[s] > t.floating[s] && (r = me(r)), [r, me(r)];
+}
+function At(e) {
+  const t = me(e);
+  return [Ne(e), t, Ne(t)];
+}
+function Ne(e) {
+  return e.replace(/start|end/g, (t) => Ct[t]);
+}
+function Dt(e, t, n) {
+  const o = ["left", "right"], i = ["right", "left"], s = ["top", "bottom"], r = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? i : o : t ? o : i;
+    case "left":
+    case "right":
+      return t ? s : r;
+    default:
+      return [];
+  }
+}
+function Nt(e, t, n, o) {
+  const i = ue(e);
+  let s = Dt(J(e), n === "start", o);
+  return i && (s = s.map((r) => r + "-" + i), t && (s = s.concat(s.map(Ne)))), s;
+}
+function me(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Pt[t]);
+}
+function St(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function st(e) {
+  return typeof e != "number" ? St(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function ge(e) {
+  const {
+    x: t,
+    y: n,
+    width: o,
+    height: i
+  } = e;
+  return {
+    width: o,
+    height: i,
+    top: n,
+    left: t,
+    right: t + o,
+    bottom: n + i,
+    x: t,
+    y: n
+  };
+}
+function je(e, t, n) {
+  let {
+    reference: o,
+    floating: i
+  } = e;
+  const s = te(t), r = Fe(t), l = He(r), a = J(t), c = s === "y", f = o.x + o.width / 2 - i.width / 2, u = o.y + o.height / 2 - i.height / 2, m = o[l] / 2 - i[l] / 2;
+  let h;
+  switch (a) {
+    case "top":
+      h = {
+        x: f,
+        y: o.y - i.height
+      };
+      break;
+    case "bottom":
+      h = {
+        x: f,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      h = {
+        x: o.x + o.width,
+        y: u
+      };
+      break;
+    case "left":
+      h = {
+        x: o.x - i.width,
+        y: u
+      };
+      break;
+    default:
+      h = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (ue(t)) {
+    case "start":
+      h[r] -= m * (n && c ? -1 : 1);
+      break;
+    case "end":
+      h[r] += m * (n && c ? -1 : 1);
+      break;
+  }
+  return h;
+}
+const kt = async (e, t, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: i = "absolute",
+    middleware: s = [],
+    platform: r
+  } = n, l = s.filter(Boolean), a = await (r.isRTL == null ? void 0 : r.isRTL(t));
+  let c = await r.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: i
+  }), {
+    x: f,
+    y: u
+  } = je(c, o, a), m = o, h = {}, p = 0;
+  for (let d = 0; d < l.length; d++) {
+    const {
+      name: v,
+      fn: y
+    } = l[d], {
+      x: E,
+      y: x,
+      data: g,
+      reset: b
+    } = await y({
+      x: f,
+      y: u,
+      initialPlacement: o,
+      placement: m,
+      strategy: i,
+      middlewareData: h,
+      rects: c,
+      platform: r,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    f = E ?? f, u = x ?? u, h = {
+      ...h,
+      [v]: {
+        ...h[v],
+        ...g
+      }
+    }, b && p <= 50 && (p++, typeof b == "object" && (b.placement && (m = b.placement), b.rects && (c = b.rects === !0 ? await r.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: i
+    }) : b.rects), {
+      x: f,
+      y: u
+    } = je(c, m, a)), d = -1);
+  }
+  return {
+    x: f,
+    y: u,
+    placement: m,
+    strategy: i,
+    middlewareData: h
+  };
+};
+async function ye(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: o,
+    y: i,
+    platform: s,
+    rects: r,
+    elements: l,
+    strategy: a
+  } = e, {
+    boundary: c = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: u = "floating",
+    altBoundary: m = !1,
+    padding: h = 0
+  } = oe(t, e), p = st(h), v = l[m ? u === "floating" ? "reference" : "floating" : u], y = ge(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(l.floating)),
+    boundary: c,
+    rootBoundary: f,
+    strategy: a
+  })), E = u === "floating" ? {
+    x: o,
+    y: i,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference, x = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(l.floating)), g = await (s.isElement == null ? void 0 : s.isElement(x)) ? await (s.getScale == null ? void 0 : s.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, b = ge(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: E,
+    offsetParent: x,
+    strategy: a
+  }) : E);
+  return {
+    top: (y.top - b.top + p.top) / g.y,
+    bottom: (b.bottom - y.bottom + p.bottom) / g.y,
+    left: (y.left - b.left + p.left) / g.x,
+    right: (b.right - y.right + p.right) / g.x
+  };
+}
+const Ht = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: o,
+      placement: i,
+      rects: s,
+      platform: r,
+      elements: l,
+      middlewareData: a
+    } = t, {
+      element: c,
+      padding: f = 0
+    } = oe(e, t) || {};
+    if (c == null)
+      return {};
+    const u = st(f), m = {
+      x: n,
+      y: o
+    }, h = Fe(i), p = He(h), d = await r.getDimensions(c), v = h === "y", y = v ? "top" : "left", E = v ? "bottom" : "right", x = v ? "clientHeight" : "clientWidth", g = s.reference[p] + s.reference[h] - m[h] - s.floating[p], b = m[h] - s.reference[h], R = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(c));
+    let L = R ? R[x] : 0;
+    (!L || !await (r.isElement == null ? void 0 : r.isElement(R))) && (L = l.floating[x] || s.floating[p]);
+    const W = g / 2 - b / 2, k = L / 2 - d[p] / 2 - 1, A = ee(u[y], k), I = ee(u[E], k), w = A, C = L - d[p] - I, P = L / 2 - d[p] / 2 + W, Y = De(w, P, C), V = !a.arrow && ue(i) != null && P !== Y && s.reference[p] / 2 - (P < w ? A : I) - d[p] / 2 < 0, H = V ? P < w ? P - w : P - C : 0;
+    return {
+      [h]: m[h] + H,
+      data: {
+        [h]: Y,
+        centerOffset: P - Y - H,
+        ...V && {
+          alignmentOffset: H
+        }
+      },
+      reset: V
+    };
+  }
+}), Ft = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        placement: i,
+        middlewareData: s,
+        rects: r,
+        initialPlacement: l,
+        platform: a,
+        elements: c
+      } = t, {
+        mainAxis: f = !0,
+        crossAxis: u = !0,
+        fallbackPlacements: m,
+        fallbackStrategy: h = "bestFit",
+        fallbackAxisSideDirection: p = "none",
+        flipAlignment: d = !0,
+        ...v
+      } = oe(e, t);
+      if ((n = s.arrow) != null && n.alignmentOffset)
+        return {};
+      const y = J(i), E = te(l), x = J(l) === l, g = await (a.isRTL == null ? void 0 : a.isRTL(c.floating)), b = m || (x || !d ? [me(l)] : At(l)), R = p !== "none";
+      !m && R && b.push(...Nt(l, d, p, g));
+      const L = [l, ...b], W = await ye(t, v), k = [];
+      let A = ((o = s.flip) == null ? void 0 : o.overflows) || [];
+      if (f && k.push(W[y]), u) {
+        const P = Mt(i, r, g);
+        k.push(W[P[0]], W[P[1]]);
+      }
+      if (A = [...A, {
+        placement: i,
+        overflows: k
+      }], !k.every((P) => P <= 0)) {
+        var I, w;
+        const P = (((I = s.flip) == null ? void 0 : I.index) || 0) + 1, Y = L[P];
+        if (Y)
+          return {
+            data: {
+              index: P,
+              overflows: A
+            },
+            reset: {
+              placement: Y
+            }
+          };
+        let V = (w = A.filter((H) => H.overflows[0] <= 0).sort((H, j) => H.overflows[1] - j.overflows[1])[0]) == null ? void 0 : w.placement;
+        if (!V)
+          switch (h) {
+            case "bestFit": {
+              var C;
+              const H = (C = A.filter((j) => {
+                if (R) {
+                  const X = te(j.placement);
+                  return X === E || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  X === "y";
+                }
+                return !0;
+              }).map((j) => [j.placement, j.overflows.filter((X) => X > 0).reduce((X, mt) => X + mt, 0)]).sort((j, X) => j[1] - X[1])[0]) == null ? void 0 : C[0];
+              H && (V = H);
+              break;
+            }
+            case "initialPlacement":
+              V = l;
+              break;
+          }
+        if (i !== V)
+          return {
+            reset: {
+              placement: V
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function Xe(e, t) {
+  return {
+    top: e.top - t.height,
+    right: e.right - t.width,
+    bottom: e.bottom - t.height,
+    left: e.left - t.width
+  };
+}
+function _e(e) {
+  return Rt.some((t) => e[t] >= 0);
+}
+const Bt = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "hide",
+    options: e,
+    async fn(t) {
+      const {
+        rects: n
+      } = t, {
+        strategy: o = "referenceHidden",
+        ...i
+      } = oe(e, t);
+      switch (o) {
+        case "referenceHidden": {
+          const s = await ye(t, {
+            ...i,
+            elementContext: "reference"
+          }), r = Xe(s, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: r,
+              referenceHidden: _e(r)
+            }
+          };
+        }
+        case "escaped": {
+          const s = await ye(t, {
+            ...i,
+            altBoundary: !0
+          }), r = Xe(s, n.floating);
+          return {
+            data: {
+              escapedOffsets: r,
+              escaped: _e(r)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+async function $t(e, t) {
+  const {
+    placement: n,
+    platform: o,
+    elements: i
+  } = e, s = await (o.isRTL == null ? void 0 : o.isRTL(i.floating)), r = J(n), l = ue(n), a = te(n) === "y", c = ["left", "top"].includes(r) ? -1 : 1, f = s && a ? -1 : 1, u = oe(t, e);
+  let {
+    mainAxis: m,
+    crossAxis: h,
+    alignmentAxis: p
+  } = typeof u == "number" ? {
+    mainAxis: u,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: u.mainAxis || 0,
+    crossAxis: u.crossAxis || 0,
+    alignmentAxis: u.alignmentAxis
+  };
+  return l && typeof p == "number" && (h = l === "end" ? p * -1 : p), a ? {
+    x: h * f,
+    y: m * c
+  } : {
+    x: m * c,
+    y: h * f
+  };
+}
+const Vt = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, o;
+      const {
+        x: i,
+        y: s,
+        placement: r,
+        middlewareData: l
+      } = t, a = await $t(t, e);
+      return r === ((n = l.offset) == null ? void 0 : n.placement) && (o = l.arrow) != null && o.alignmentOffset ? {} : {
+        x: i + a.x,
+        y: s + a.y,
+        data: {
+          ...a,
+          placement: r
+        }
+      };
+    }
+  };
+}, Wt = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: o,
+        placement: i
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: r = !1,
+        limiter: l = {
+          fn: (v) => {
+            let {
+              x: y,
+              y: E
+            } = v;
+            return {
+              x: y,
+              y: E
+            };
+          }
+        },
+        ...a
+      } = oe(e, t), c = {
+        x: n,
+        y: o
+      }, f = await ye(t, a), u = te(J(i)), m = rt(u);
+      let h = c[m], p = c[u];
+      if (s) {
+        const v = m === "y" ? "top" : "left", y = m === "y" ? "bottom" : "right", E = h + f[v], x = h - f[y];
+        h = De(E, h, x);
+      }
+      if (r) {
+        const v = u === "y" ? "top" : "left", y = u === "y" ? "bottom" : "right", E = p + f[v], x = p - f[y];
+        p = De(E, p, x);
+      }
+      const d = l.fn({
+        ...t,
+        [m]: h,
+        [u]: p
+      });
+      return {
+        ...d,
+        data: {
+          x: d.x - n,
+          y: d.y - o,
+          enabled: {
+            [m]: s,
+            [u]: r
+          }
+        }
+      };
+    }
+  };
+};
+function we() {
+  return typeof window < "u";
+}
+function ie(e) {
+  return lt(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function M(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function $(e) {
+  var t;
+  return (t = (lt(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function lt(e) {
+  return we() ? e instanceof Node || e instanceof M(e).Node : !1;
+}
+function N(e) {
+  return we() ? e instanceof Element || e instanceof M(e).Element : !1;
+}
+function B(e) {
+  return we() ? e instanceof HTMLElement || e instanceof M(e).HTMLElement : !1;
+}
+function Ke(e) {
+  return !we() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof M(e).ShadowRoot;
+}
+function fe(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: o,
+    display: i
+  } = S(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + o + n) && !["inline", "contents"].includes(i);
+}
+function It(e) {
+  return ["table", "td", "th"].includes(ie(e));
+}
+function xe(e) {
+  return [":popover-open", ":modal"].some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function Be(e) {
+  const t = $e(), n = N(e) ? S(e) : e;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((o) => n[o] ? n[o] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !t && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !t && (n.filter ? n.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((o) => (n.willChange || "").includes(o)) || ["paint", "layout", "strict", "content"].some((o) => (n.contain || "").includes(o));
+}
+function Yt(e) {
+  let t = K(e);
+  for (; B(t) && !ne(t); ) {
+    if (Be(t))
+      return t;
+    if (xe(t))
+      return null;
+    t = K(t);
+  }
+  return null;
+}
+function $e() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function ne(e) {
+  return ["html", "body", "#document"].includes(ie(e));
+}
+function S(e) {
+  return M(e).getComputedStyle(e);
+}
+function be(e) {
+  return N(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function K(e) {
+  if (ie(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    Ke(e) && e.host || // Fallback.
+    $(e)
+  );
+  return Ke(t) ? t.host : t;
+}
+function ct(e) {
+  const t = K(e);
+  return ne(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : B(t) && fe(t) ? t : ct(t);
+}
+function Q(e, t, n) {
+  var o;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const i = ct(e), s = i === ((o = e.ownerDocument) == null ? void 0 : o.body), r = M(i);
+  if (s) {
+    const l = Se(r);
+    return t.concat(r, r.visualViewport || [], fe(i) ? i : [], l && n ? Q(l) : []);
+  }
+  return t.concat(i, Q(i, [], n));
+}
+function Se(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function at(e) {
+  const t = S(e);
+  let n = parseFloat(t.width) || 0, o = parseFloat(t.height) || 0;
+  const i = B(e), s = i ? e.offsetWidth : n, r = i ? e.offsetHeight : o, l = pe(n) !== s || pe(o) !== r;
+  return l && (n = s, o = r), {
+    width: n,
+    height: o,
+    $: l
+  };
+}
+function Ve(e) {
+  return N(e) ? e : e.contextElement;
+}
+function z(e) {
+  const t = Ve(e);
+  if (!B(t))
+    return F(1);
+  const n = t.getBoundingClientRect(), {
+    width: o,
+    height: i,
+    $: s
+  } = at(t);
+  let r = (s ? pe(n.width) : n.width) / o, l = (s ? pe(n.height) : n.height) / i;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: r,
+    y: l
+  };
+}
+const jt = /* @__PURE__ */ F(0);
+function ut(e) {
+  const t = M(e);
+  return !$e() || !t.visualViewport ? jt : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Xt(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== M(e) ? !1 : t;
+}
+function Z(e, t, n, o) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const i = e.getBoundingClientRect(), s = Ve(e);
+  let r = F(1);
+  t && (o ? N(o) && (r = z(o)) : r = z(e));
+  const l = Xt(s, n, o) ? ut(s) : F(0);
+  let a = (i.left + l.x) / r.x, c = (i.top + l.y) / r.y, f = i.width / r.x, u = i.height / r.y;
+  if (s) {
+    const m = M(s), h = o && N(o) ? M(o) : o;
+    let p = m, d = Se(p);
+    for (; d && o && h !== p; ) {
+      const v = z(d), y = d.getBoundingClientRect(), E = S(d), x = y.left + (d.clientLeft + parseFloat(E.paddingLeft)) * v.x, g = y.top + (d.clientTop + parseFloat(E.paddingTop)) * v.y;
+      a *= v.x, c *= v.y, f *= v.x, u *= v.y, a += x, c += g, p = M(d), d = Se(p);
+    }
+  }
+  return ge({
+    width: f,
+    height: u,
+    x: a,
+    y: c
+  });
+}
+function We(e, t) {
+  const n = be(e).scrollLeft;
+  return t ? t.left + n : Z($(e)).left + n;
+}
+function ft(e, t, n) {
+  n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), i = o.left + t.scrollLeft - (n ? 0 : (
+    // RTL <body> scrollbar.
+    We(e, o)
+  )), s = o.top + t.scrollTop;
+  return {
+    x: i,
+    y: s
+  };
+}
+function _t(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: o,
+    strategy: i
+  } = e;
+  const s = i === "fixed", r = $(o), l = t ? xe(t.floating) : !1;
+  if (o === r || l && s)
+    return n;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, c = F(1);
+  const f = F(0), u = B(o);
+  if ((u || !u && !s) && ((ie(o) !== "body" || fe(r)) && (a = be(o)), B(o))) {
+    const h = Z(o);
+    c = z(o), f.x = h.x + o.clientLeft, f.y = h.y + o.clientTop;
+  }
+  const m = r && !u && !s ? ft(r, a, !0) : F(0);
+  return {
+    width: n.width * c.x,
+    height: n.height * c.y,
+    x: n.x * c.x - a.scrollLeft * c.x + f.x + m.x,
+    y: n.y * c.y - a.scrollTop * c.y + f.y + m.y
+  };
+}
+function Kt(e) {
+  return Array.from(e.getClientRects());
+}
+function Ut(e) {
+  const t = $(e), n = be(e), o = e.ownerDocument.body, i = G(t.scrollWidth, t.clientWidth, o.scrollWidth, o.clientWidth), s = G(t.scrollHeight, t.clientHeight, o.scrollHeight, o.clientHeight);
+  let r = -n.scrollLeft + We(e);
+  const l = -n.scrollTop;
+  return S(o).direction === "rtl" && (r += G(t.clientWidth, o.clientWidth) - i), {
+    width: i,
+    height: s,
+    x: r,
+    y: l
+  };
+}
+function qt(e, t) {
+  const n = M(e), o = $(e), i = n.visualViewport;
+  let s = o.clientWidth, r = o.clientHeight, l = 0, a = 0;
+  if (i) {
+    s = i.width, r = i.height;
+    const c = $e();
+    (!c || c && t === "fixed") && (l = i.offsetLeft, a = i.offsetTop);
+  }
+  return {
+    width: s,
+    height: r,
+    x: l,
+    y: a
+  };
+}
+function Gt(e, t) {
+  const n = Z(e, !0, t === "fixed"), o = n.top + e.clientTop, i = n.left + e.clientLeft, s = B(e) ? z(e) : F(1), r = e.clientWidth * s.x, l = e.clientHeight * s.y, a = i * s.x, c = o * s.y;
+  return {
+    width: r,
+    height: l,
+    x: a,
+    y: c
+  };
+}
+function Ue(e, t, n) {
+  let o;
+  if (t === "viewport")
+    o = qt(e, n);
+  else if (t === "document")
+    o = Ut($(e));
+  else if (N(t))
+    o = Gt(t, n);
+  else {
+    const i = ut(e);
+    o = {
+      x: t.x - i.x,
+      y: t.y - i.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return ge(o);
+}
+function dt(e, t) {
+  const n = K(e);
+  return n === t || !N(n) || ne(n) ? !1 : S(n).position === "fixed" || dt(n, t);
+}
+function Jt(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let o = Q(e, [], !1).filter((l) => N(l) && ie(l) !== "body"), i = null;
+  const s = S(e).position === "fixed";
+  let r = s ? K(e) : e;
+  for (; N(r) && !ne(r); ) {
+    const l = S(r), a = Be(r);
+    !a && l.position === "fixed" && (i = null), (s ? !a && !i : !a && l.position === "static" && !!i && ["absolute", "fixed"].includes(i.position) || fe(r) && !a && dt(e, r)) ? o = o.filter((f) => f !== r) : i = l, r = K(r);
+  }
+  return t.set(e, o), o;
+}
+function Qt(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: o,
+    strategy: i
+  } = e;
+  const r = [...n === "clippingAncestors" ? xe(t) ? [] : Jt(t, this._c) : [].concat(n), o], l = r[0], a = r.reduce((c, f) => {
+    const u = Ue(t, f, i);
+    return c.top = G(u.top, c.top), c.right = ee(u.right, c.right), c.bottom = ee(u.bottom, c.bottom), c.left = G(u.left, c.left), c;
+  }, Ue(t, l, i));
+  return {
+    width: a.right - a.left,
+    height: a.bottom - a.top,
+    x: a.left,
+    y: a.top
+  };
+}
+function Zt(e) {
+  const {
+    width: t,
+    height: n
+  } = at(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function zt(e, t, n) {
+  const o = B(t), i = $(t), s = n === "fixed", r = Z(e, !0, s, t);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = F(0);
+  if (o || !o && !s)
+    if ((ie(t) !== "body" || fe(i)) && (l = be(t)), o) {
+      const m = Z(t, !0, s, t);
+      a.x = m.x + t.clientLeft, a.y = m.y + t.clientTop;
+    } else i && (a.x = We(i));
+  const c = i && !o && !s ? ft(i, l) : F(0), f = r.left + l.scrollLeft - a.x - c.x, u = r.top + l.scrollTop - a.y - c.y;
+  return {
+    x: f,
+    y: u,
+    width: r.width,
+    height: r.height
+  };
+}
+function Re(e) {
+  return S(e).position === "static";
+}
+function qe(e, t) {
+  if (!B(e) || S(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return $(e) === n && (n = n.ownerDocument.body), n;
+}
+function ht(e, t) {
+  const n = M(e);
+  if (xe(e))
+    return n;
+  if (!B(e)) {
+    let i = K(e);
+    for (; i && !ne(i); ) {
+      if (N(i) && !Re(i))
+        return i;
+      i = K(i);
+    }
+    return n;
+  }
+  let o = qe(e, t);
+  for (; o && It(o) && Re(o); )
+    o = qe(o, t);
+  return o && ne(o) && Re(o) && !Be(o) ? n : o || Yt(e) || n;
+}
+const en = async function(e) {
+  const t = this.getOffsetParent || ht, n = this.getDimensions, o = await n(e.floating);
+  return {
+    reference: zt(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function tn(e) {
+  return S(e).direction === "rtl";
+}
+const nn = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: _t,
+  getDocumentElement: $,
+  getClippingRect: Qt,
+  getOffsetParent: ht,
+  getElementRects: en,
+  getClientRects: Kt,
+  getDimensions: Zt,
+  getScale: z,
+  isElement: N,
+  isRTL: tn
+};
+function vt(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function on(e, t) {
+  let n = null, o;
+  const i = $(e);
+  function s() {
+    var l;
+    clearTimeout(o), (l = n) == null || l.disconnect(), n = null;
+  }
+  function r(l, a) {
+    l === void 0 && (l = !1), a === void 0 && (a = 1), s();
+    const c = e.getBoundingClientRect(), {
+      left: f,
+      top: u,
+      width: m,
+      height: h
+    } = c;
+    if (l || t(), !m || !h)
+      return;
+    const p = he(u), d = he(i.clientWidth - (f + m)), v = he(i.clientHeight - (u + h)), y = he(f), x = {
+      rootMargin: -p + "px " + -d + "px " + -v + "px " + -y + "px",
+      threshold: G(0, ee(1, a)) || 1
+    };
+    let g = !0;
+    function b(R) {
+      const L = R[0].intersectionRatio;
+      if (L !== a) {
+        if (!g)
+          return r();
+        L ? r(!1, L) : o = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 1e3);
+      }
+      L === 1 && !vt(c, e.getBoundingClientRect()) && r(), g = !1;
+    }
+    try {
+      n = new IntersectionObserver(b, {
+        ...x,
+        // Handle <iframe>s
+        root: i.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(b, x);
+    }
+    n.observe(e);
+  }
+  return r(!0), s;
+}
+function pt(e, t, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: i = !0,
+    ancestorResize: s = !0,
+    elementResize: r = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = o, c = Ve(e), f = i || s ? [...c ? Q(c) : [], ...Q(t)] : [];
+  f.forEach((y) => {
+    i && y.addEventListener("scroll", n, {
+      passive: !0
+    }), s && y.addEventListener("resize", n);
+  });
+  const u = c && l ? on(c, n) : null;
+  let m = -1, h = null;
+  r && (h = new ResizeObserver((y) => {
+    let [E] = y;
+    E && E.target === c && h && (h.unobserve(t), cancelAnimationFrame(m), m = requestAnimationFrame(() => {
+      var x;
+      (x = h) == null || x.observe(t);
+    })), n();
+  }), c && !a && h.observe(c), h.observe(t));
+  let p, d = a ? Z(e) : null;
+  a && v();
+  function v() {
+    const y = Z(e);
+    d && !vt(d, y) && n(), d = y, p = requestAnimationFrame(v);
+  }
+  return n(), () => {
+    var y;
+    f.forEach((E) => {
+      i && E.removeEventListener("scroll", n), s && E.removeEventListener("resize", n);
+    }), u == null || u(), (y = h) == null || y.disconnect(), h = null, a && cancelAnimationFrame(p);
+  };
+}
+const Rn = Vt, Pn = Wt, Cn = Ft, Mn = Bt, rn = Ht, sn = (e, t, n) => {
+  const o = /* @__PURE__ */ new Map(), i = {
+    platform: nn,
+    ...n
+  }, s = {
+    ...i.platform,
+    _c: o
+  };
+  return kt(e, t, {
+    ...i,
+    platform: s
+  });
+};
+function An(e, t, n = {}) {
+  const {
+    transform: o = !0,
+    middlewares: i,
+    whileElementsMounted: s,
+    open: r = _(!1),
+    setOpen: l = (x) => {
+      r.value = x;
+    }
+  } = n, a = O(() => T(n.placement) ?? "bottom"), c = O(() => T(n.strategy) ?? "absolute"), f = _(0), u = _(0), m = _(a.value), h = _(c.value), p = Me({}), d = _(!1), v = async () => {
+    if (!e.value || !t.value) return;
+    const x = await sn(e.value, t.value, {
+      placement: a.value,
+      strategy: c.value,
+      middleware: i
+    });
+    f.value = x.x, u.value = x.y, m.value = x.placement, h.value = x.strategy, p.value = x.middlewareData, d.value = r.value;
+  };
+  ve([a, c], () => {
+    r.value && v();
+  });
+  let y;
+  ve(
+    [e, t, r],
+    ([x, g, b]) => {
+      !b || !x || !g || (s ? y = s(x, g, v) : y = pt(x, g, v), q(() => {
+        y == null || y(), y = void 0;
+      }));
+    },
+    { immediate: !0 }
+  ), ae(() => y == null ? void 0 : y()), ve(r, (x) => {
+    x || (d.value = !1);
+  });
+  const E = O(() => {
+    const x = {
+      position: h.value,
+      left: "0",
+      top: "0"
+    };
+    if (!d.value || !t.value)
+      return x;
+    const g = Ye(t.value, f.value), b = Ye(t.value, u.value);
+    return T(o) ? {
+      ...x,
+      transform: `translate(${g}px, ${b}px)`,
+      ...it(t.value) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      ...x,
+      left: `${g}px`,
+      top: `${b}px`
+    };
+  });
+  return {
+    x: f,
+    y: u,
+    strategy: h,
+    placement: m,
+    middlewareData: p,
+    isPositioned: d,
+    floatingStyles: E,
+    update: v,
+    refs: {
+      anchorEl: e,
+      floatingEl: t
+    },
+    open: r,
+    setOpen: l
+  };
+}
+function Dn(e, t, n, o = {}) {
+  return pt(e, t, n, o);
+}
+function Nn(e, t = {}) {
+  const { middlewareData: n, placement: o } = e, { offset: i = "-12px" } = t, s = O(() => {
+    var a;
+    return ((a = n.value.arrow) == null ? void 0 : a.x) ?? 0;
+  }), r = O(() => {
+    var a;
+    return ((a = n.value.arrow) == null ? void 0 : a.y) ?? 0;
+  }), l = O(() => {
+    const a = {
+      top: "inset-block-end",
+      right: "inset-inline-start",
+      bottom: "inset-block-start",
+      left: "inset-inline-end"
+    }[T(o).split("-")[0]], c = s.value != null ? `${s.value}px` : "", f = r.value != null ? `${r.value}px` : "";
+    return {
+      "inset-inline-start": c,
+      "inset-block-start": f,
+      [a]: i
+    };
+  });
+  return {
+    arrowX: s,
+    arrowY: r,
+    arrowStyles: l
+  };
+}
+const Ge = 10;
+function ln(e) {
+  return e === "mouse" || e === "pen";
+}
+function cn(e, t, n) {
+  const { delay: o } = n, i = O(() => {
+    const c = T(o);
+    return (typeof c == "number" ? c : c.open) ?? 0;
+  }), s = O(() => {
+    const c = T(o);
+    return (typeof c == "number" ? c : c.close) ?? 0;
+  });
+  let r, l;
+  const a = () => {
+    clearTimeout(r), clearTimeout(l);
+  };
+  return ae(a), {
+    show: (c) => {
+      a();
+      const f = c ?? i.value;
+      f === 0 ? e() : r = setTimeout(e, f);
+    },
+    hide: (c) => {
+      a();
+      const f = c ?? s.value;
+      f === 0 ? t() : l = setTimeout(t, f);
+    },
+    showDelay: i,
+    hideDelay: s,
+    clearTimeouts: a
+  };
+}
+function Sn(e, t = {}) {
+  const {
+    open: n,
+    setOpen: o,
+    refs: { anchorEl: i, floatingEl: s }
+  } = e, {
+    enabled: r = !0,
+    delay: l = 0,
+    restMs: a = 0,
+    mouseOnly: c = !1
+  } = t, f = O(() => T(r)), u = O(() => T(a)), m = O(() => {
+    const w = i.value;
+    return !w || w instanceof HTMLElement ? w : w.contextElement ?? null;
+  }), { hide: h, show: p, showDelay: d, clearTimeouts: v } = cn(
+    () => {
+      n.value || o(!0);
+    },
+    () => {
+      n.value && o(!1);
+    },
+    { delay: l }
+  );
+  let y = null, E;
+  const x = O(() => d.value === 0 && u.value > 0);
+  function g(w) {
+    if (!f.value || !L(w) || !x.value || !y) return;
+    const C = { x: w.clientX, y: w.clientY }, P = Math.abs(C.x - y.x), Y = Math.abs(C.y - y.y);
+    (P > Ge || Y > Ge) && (y = C, clearTimeout(E), E = setTimeout(() => {
+      p(0);
+    }, u.value));
+  }
+  function b(w) {
+    !f.value || !L(w) || !x.value || (y = { x: w.clientX, y: w.clientY }, E = setTimeout(() => {
+      p(0);
+    }, u.value));
+  }
+  function R() {
+    clearTimeout(E), y = null;
+  }
+  re(() => {
+    const w = m.value;
+    !w || !f.value || !x.value || (w.addEventListener("pointerenter", b), w.addEventListener("pointermove", g), w.addEventListener("pointerleave", R), q(() => {
+      w.removeEventListener("pointerenter", b), w.removeEventListener("pointermove", g), w.removeEventListener("pointerleave", R);
+    }));
+  }), ae(() => {
+    clearTimeout(E);
+  });
+  function L(w) {
+    return !(T(c) && !ln(w.pointerType));
+  }
+  function W(w) {
+    !f.value || !L(w) || x.value || p();
+  }
+  function k(w) {
+    !f.value || !L(w) || v();
+  }
+  function A(w) {
+    var C;
+    !f.value || !L(w) || (C = s.value) != null && C.contains(w.relatedTarget) || h();
+  }
+  function I(w) {
+    var C;
+    !f.value || !L(w) || (C = m.value) != null && C.contains(w.relatedTarget) || h();
+  }
+  re(() => {
+    const w = m.value;
+    !w || !f.value || (w.addEventListener("pointerenter", W), w.addEventListener("pointerleave", A), q(() => {
+      w.removeEventListener("pointerenter", W), w.removeEventListener("pointerleave", A);
+    }));
+  }), re(() => {
+    const w = s.value;
+    !w || !f.value || (w.addEventListener("pointerenter", k), w.addEventListener("pointerleave", I), q(() => {
+      w.removeEventListener("pointerenter", k), w.removeEventListener("pointerleave", I);
+    }));
+  });
+}
+function an(e) {
+  return wt() ? (ae(e), !0) : !1;
+}
+const un = typeof window < "u" && typeof document < "u";
+typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
+const fn = Object.prototype.toString, dn = (e) => fn.call(e) === "[object Object]";
+function Pe(e) {
+  return Array.isArray(e) ? e : [e];
+}
+function hn(e, t, n) {
+  return ve(
+    e,
+    t,
+    {
+      ...n,
+      immediate: !0
+    }
+  );
+}
+const vn = un ? window : void 0;
+function pn(e) {
+  var t;
+  const n = T(e);
+  return (t = n == null ? void 0 : n.$el) != null ? t : n;
+}
+function D(...e) {
+  const t = [], n = () => {
+    t.forEach((l) => l()), t.length = 0;
+  }, o = (l, a, c, f) => (l.addEventListener(a, c, f), () => l.removeEventListener(a, c, f)), i = O(() => {
+    const l = Pe(T(e[0])).filter((a) => a != null);
+    return l.every((a) => typeof a != "string") ? l : void 0;
+  }), s = hn(
+    () => {
+      var l, a;
+      return [
+        (a = (l = i.value) == null ? void 0 : l.map((c) => pn(c))) != null ? a : [vn].filter((c) => c != null),
+        Pe(T(i.value ? e[1] : e[0])),
+        Pe(xt(i.value ? e[2] : e[1])),
+        // @ts-expect-error - TypeScript gets the correct types, but somehow still complains
+        T(i.value ? e[3] : e[2])
+      ];
+    },
+    ([l, a, c, f]) => {
+      if (n(), !(l != null && l.length) || !(a != null && a.length) || !(c != null && c.length))
+        return;
+      const u = dn(f) ? { ...f } : f;
+      t.push(
+        ...l.flatMap(
+          (m) => a.flatMap(
+            (h) => c.map((p) => o(m, h, p, u))
+          )
+        )
+      );
+    },
+    { flush: "post" }
+  ), r = () => {
+    s(), n();
+  };
+  return an(n), r;
+}
+function kn(e, t = {}) {
+  const {
+    open: n,
+    setOpen: o,
+    refs: { floatingEl: i, anchorEl: s }
+  } = e, { enabled: r = !0, requireFocusVisible: l = !0 } = t, a = O(() => s.value ? s.value instanceof HTMLElement ? s.value : s.value.contextElement : null);
+  let c = !1, f = !0, u;
+  D(window, "blur", () => {
+    !n.value && a.value && a.value === document.activeElement && (c = !0);
+  }), D(window, "focus", () => {
+    c = !1;
+  }), bt(() => {
+    Je() && Qe() && (D(
+      window,
+      "keydown",
+      () => {
+        f = !0;
+      },
+      { capture: !0 }
+    ), D(
+      window,
+      "pointerdown",
+      () => {
+        f = !1;
+      },
+      { capture: !0 }
+    ));
+  });
+  function m(p) {
+    if (c) {
+      c = !1;
+      return;
+    }
+    const d = p.target;
+    if (T(l) && d) {
+      if (Je() && Qe() && !p.relatedTarget) {
+        if (!f && !mn(d))
+          return;
+      } else if (!gn(d))
+        return;
+    }
+    o(!0);
+  }
+  function h(p) {
+    clearTimeout(u), u = window.setTimeout(() => {
+      var y;
+      const v = (((y = a.value) == null ? void 0 : y.ownerDocument) ?? document).activeElement;
+      !p.relatedTarget && v === a.value || i.value && v && i.value.contains(v) || o(!1);
+    }, 0);
+  }
+  re(() => {
+    if (!T(r)) return;
+    const p = a.value;
+    !p || !(p instanceof HTMLElement) || (p.addEventListener("focus", m), p.addEventListener("blur", h), q(() => {
+      p.removeEventListener("focus", m), p.removeEventListener("blur", h);
+    }));
+  }), ae(() => {
+    clearTimeout(u);
+  });
+}
+function Je() {
+  return navigator.platform.toUpperCase().indexOf("MAC") >= 0;
+}
+function Qe() {
+  return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+}
+function mn(e) {
+  return e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement || e instanceof HTMLSelectElement;
+}
+function gn(e) {
+  return e.matches(":focus-visible");
+}
+function Hn(e, t = {}) {
+  const { open: n, setOpen: o, refs: i } = e, {
+    enabled: s = !0,
+    event: r = "click",
+    toggle: l = !0,
+    ignoreMouse: a = !1,
+    keyboardHandlers: c = !0
+  } = t;
+  let f, u = !1;
+  const m = O(() => T(s)), h = O(
+    () => i.anchorEl.value instanceof HTMLElement ? i.anchorEl.value : null
+  );
+  function p() {
+    n.value ? T(l) && o(!1) : o(!0);
+  }
+  function d(g) {
+    f = g.pointerType;
+  }
+  function v(g) {
+    if (g.button !== 0 || T(r) === "click" || Ze(f) && T(a)) return;
+    const b = g.target;
+    !n.value && b === h.value && g.preventDefault(), p();
+  }
+  function y() {
+    if (T(r) === "mousedown" && f) {
+      f = void 0;
+      return;
+    }
+    if (Ze(f) && T(a)) {
+      f = void 0;
+      return;
+    }
+    p(), f = void 0;
+  }
+  function E(g) {
+    if (f = void 0, g.defaultPrevented || !T(c) || ze(g))
+      return;
+    const b = h.value;
+    b && (g.key === " " && !et(b) && (g.preventDefault(), u = !0), g.key === "Enter" && p());
+  }
+  function x(g) {
+    const b = h.value;
+    b && (g.defaultPrevented || !T(c) || ze(g) || et(b) || g.key === " " && u && (u = !1, p()));
+  }
+  re(() => {
+    const g = h.value;
+    !m.value || !g || (g.addEventListener("pointerdown", d), g.addEventListener("mousedown", v), g.addEventListener("click", y), g.addEventListener("keydown", E), g.addEventListener("keyup", x), q(() => {
+      g.removeEventListener("pointerdown", d), g.removeEventListener("mousedown", v), g.removeEventListener("click", y), g.removeEventListener("keydown", E), g.removeEventListener("keyup", x);
+    }));
+  });
+}
+function Ze(e, t) {
+  return e === void 0 ? !1 : e === "mouse";
+}
+function ze(e) {
+  return e.target instanceof HTMLElement && e.target.tagName === "BUTTON";
+}
+function yn(e) {
+  return e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement || e instanceof HTMLElement && e.isContentEditable;
+}
+function et(e) {
+  return yn(e);
+}
+function wn() {
+  const e = _(!1);
+  return D(document, "compositionstart", () => {
+    e.value = !0;
+  }), D(document, "compositionend", () => {
+    e.value = !1;
+  }), {
+    isComposing: () => e.value
+  };
+}
+function xn(e) {
+  return {
+    escapeKey: typeof e == "boolean" ? e : (e == null ? void 0 : e.escapeKey) ?? !1,
+    outsidePress: typeof e == "boolean" ? e : (e == null ? void 0 : e.outsidePress) ?? !0
+  };
+}
+function Ce(e) {
+  return e instanceof Element && e instanceof HTMLElement;
+}
+function tt(e, t) {
+  return t ? "composedPath" in e && typeof e.composedPath == "function" ? e.composedPath().includes(t) : t.contains(e.target) : !1;
+}
+function bn(e, t) {
+  const n = t.offsetWidth - t.clientWidth, o = t.offsetHeight - t.clientHeight;
+  return n > 0 && e.clientX > t.clientWidth || o > 0 && e.clientY > t.clientHeight;
+}
+function Fn(e, t = {}) {
+  const {
+    enabled: n = !0,
+    escapeKey: o = !0,
+    outsidePress: i = !0,
+    outsidePressEvent: s = "pointerdown",
+    anchorPress: r = !1,
+    anchorPressEvent: l = "pointerdown",
+    ancestorScroll: a = !1,
+    capture: c
+  } = t, f = O(() => T(n)), u = e.refs.floatingEl, m = O(() => {
+    const g = e.refs.anchorEl.value;
+    return g ? g instanceof HTMLElement ? g : g.contextElement instanceof HTMLElement ? g.contextElement : null : null;
+  }), { isComposing: h } = wn(), { escapeKey: p, outsidePress: d } = xn(c);
+  let v = !1;
+  const y = (g) => {
+    !f.value || !e.open.value || !T(o) || g.key !== "Escape" || h() || e.setOpen(!1);
+  }, E = (g) => {
+    if (!f.value || !e.open.value)
+      return;
+    if (s === "click" && v) {
+      v = !1;
+      return;
+    }
+    const b = T(i);
+    if (!b || typeof b == "function" && !b(g))
+      return;
+    const R = g.target;
+    R && (Ce(R) && u.value && bn(g, R) || tt(g, m.value) || tt(g, u.value) || e.setOpen(!1));
+  }, x = () => {
+    f.value && e.open.value && T(r) && e.setOpen(!1);
+  };
+  Ae((g) => {
+    if (!f.value || !e.open.value || !T(a))
+      return;
+    const b = () => {
+      e.open.value && e.setOpen(!1);
+    }, R = [];
+    m.value && R.push(...Q(m.value).filter(Ce)), u.value && R.push(...Q(u.value).filter(Ce));
+    for (const L of R)
+      L.addEventListener("scroll", b, { passive: !0 });
+    g(() => {
+      for (const L of R)
+        L.removeEventListener("scroll", b);
+    });
+  }), D(document, "keydown", y, T(p)), D(document, s, E, T(d)), D(m, l, x), D(
+    u,
+    "mousedown",
+    () => {
+      v = !0;
+    },
+    { capture: !0 }
+  ), D(
+    u,
+    "mouseup",
+    () => {
+      v = !0;
+    },
+    { capture: !0 }
+  );
+}
+function Bn(e, t, n = {}) {
+  const { open: o, refs: i } = t;
+  let s;
+  const r = _({ x: null, y: null }), l = O(() => T(n.axis ?? "both")), a = O(() => T(n.enabled ?? !0)), c = O(() => T(n.x ?? null)), f = O(() => T(n.y ?? null)), u = (d, v) => {
+    r.value = {
+      x: d,
+      y: v
+    }, o.value && (i.anchorEl.value = En(
+      e.value,
+      l.value,
+      r.value
+    ));
+  };
+  Ae(() => {
+    const d = c.value, v = f.value;
+    a.value && d != null && v != null && u(d, v);
+  });
+  const m = (d) => {
+    s = d.pointerType, u(d.clientX, d.clientY);
+  }, h = (d) => {
+    s = d.pointerType, !o.value && nt(s, !0) && u(d.clientX, d.clientY);
+  }, p = (d) => {
+    o.value && nt(s, !0) && u(d.clientX, d.clientY);
+  };
+  return Ae(() => {
+    if (c.value != null || f.value != null) return;
+    const d = e.value;
+    !d || !a.value || (d.addEventListener("pointerenter", h), d.addEventListener("pointerdown", m), d.addEventListener("pointermove", p), q(() => {
+      d == null || d.removeEventListener("pointerenter", h), d == null || d.removeEventListener("pointerdown", m), d == null || d.removeEventListener("pointermove", p);
+    }));
+  }), {
+    coordinates: Et(r),
+    updatePosition: u
+  };
+}
+function En(e, t, n) {
+  let o = null, i = null;
+  const s = e;
+  return {
+    contextElement: s || void 0,
+    getBoundingClientRect: () => {
+      const r = (s == null ? void 0 : s.getBoundingClientRect()) ?? {
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+      }, l = t === "x" || t === "both", a = t === "y" || t === "both";
+      let c = 0, f = 0, u = r.x, m = r.y;
+      return s && (o == null && n.x != null && l && (o = r.x - n.x), i == null && n.y != null && a && (i = r.y - n.y), u -= o || 0, m -= i || 0), l && n.x != null ? u = n.x : (o = null, c = r.width), a && n.y != null ? m = n.y : (i = null, f = r.height), t === "both" && (c = 0, f = 0), {
+        width: c,
+        height: f,
+        x: u,
+        y: m,
+        top: m,
+        right: u + c,
+        bottom: m + f,
+        left: u
+      };
+    }
+  };
+}
+function nt(e, t) {
+  if (e === void 0) return !1;
+  const n = e === "mouse";
+  return t ? n : n || e === "pen";
+}
+function $n(e) {
+  return {
+    name: "arrow",
+    options: e,
+    fn(t) {
+      const n = T(e.element);
+      return n == null ? {} : rn({ element: n, padding: e.padding }).fn(t);
+    }
+  };
+}
+var se;
+class ot {
+  constructor(t, n = null, o = {}, i = !1) {
+    U(this, "id");
+    U(this, "data");
+    U(this, "parent");
+    U(this, "children");
+    de(this, se);
+    this.id = o.id ?? Ot(), this.data = t, this.parent = Me(n), this.children = Me([]), Le(this, se, i);
+  }
+  /**
+   * Adds an existing node instance to this node's children array.
+   * @internal
+   * @param childNode The TreeNode instance to add.
+   */
+  addChild(t) {
+    this.children.value = [...this.children.value, t];
+  }
+  /**
+   * Removes a specific child node instance from this node's children.
+   * @internal
+   * Note: This only removes the direct child link. Use the Tree's `removeNode` method for full removal including map updates and recursive deletion.
+   * @param childNode The child node instance to remove.
+   * @returns True if the child was found and removed, false otherwise.
+   */
+  _removeChildInstance(t) {
+    return this.children.value.includes(t) ? (this.children.value = this.children.value.filter((n) => n.id !== t.id), t.parent.value = null, !0) : !1;
+  }
+  /**
+   * Updates the node's data.
+   * If T is an object, performs a shallow merge using Object.assign.
+   * If T is a primitive, replaces the value.
+   * @param newData Partial data for objects, or the new value for primitives.
+   */
+  updateData(t) {
+    const n = this.data;
+    typeof n == "object" && n !== null && typeof t == "object" && t !== null ? this.data = Object.assign({}, n, t) : this.data = t;
+  }
+  /**
+   * Finds the first direct child matching the predicate.
+   * @param predicate Function to test each child node.
+   * @returns The matching child node or null if not found.
+   */
+  findChild(t) {
+    return this.children.value.find(t) ?? null;
+  }
+  /**
+   * Finds the first descendant node (including self) matching the predicate using DFS.
+   * @param predicate Function to test each node.
+   * @returns The matching descendant node or null if not found.
+   */
+  findDescendant(t) {
+    const n = [this];
+    for (; n.length > 0; ) {
+      const o = n.pop();
+      if (t(o))
+        return o;
+      for (let i = o.children.value.length - 1; i >= 0; i--)
+        n.push(o.children.value[i]);
+    }
+    return null;
+  }
+  /**
+   * Checks if this node is a descendant of the potential ancestor.
+   * @param potentialAncestor The node to check against.
+   * @returns True if this node is a descendant, false otherwise.
+   */
+  isDescendantOf(t) {
+    let n = this.parent.value;
+    for (; n; ) {
+      if (n.id === t.id)
+        return !0;
+      n = n.parent.value;
+    }
+    return !1;
+  }
+  /**
+   * Gets the path of nodes from the root to this node.
+   * @returns An array of nodes starting with the root and ending with this node.
+   */
+  getPath() {
+    const t = [];
+    let n = this;
+    for (; n; )
+      t.push(n), n = n.parent.value;
+    return t.reverse();
+  }
+  /** Checks if the node is the true root of the tree, distinct from an orphaned node. */
+  get isRoot() {
+    return Te(this, se);
+  }
+  /** Checks if the node is a leaf node (has no children). */
+  get isLeaf() {
+    return this.children.value.length === 0;
+  }
+}
+se = new WeakMap();
+var le, ce, ke;
+class Tn {
+  /**
+   * Creates a new Tree instance.
+   * @param initialRootData Data for the root node.
+   * @param options Configuration options for the tree behavior.
+   *
+   * @example
+   * ```ts
+   * const myTree = new Tree({ name: 'Root' });
+   * const childNode = myTree.addNode({ name: 'Child' }, myTree.root.id);
+   * ```
+   */
+  constructor(t, n) {
+    de(this, ce);
+    /** The root node of the tree. */
+    U(this, "root");
+    /** Readonly reactive map of node IDs to TreeNode instances for quick lookups. */
+    U(this, "nodeMap");
+    de(this, le);
+    Le(this, le, (n == null ? void 0 : n.deleteStrategy) ?? "recursive"), this.nodeMap = Tt(/* @__PURE__ */ new Map()), this.root = new ot(t, null, {}, !0), this.nodeMap.set(this.root.id, this.root);
+  }
+  /**
+   * Finds a node anywhere in the tree by its ID.
+   * @param id The ID of the node to find.
+   * @returns The node if found, otherwise null.
+   */
+  findNodeById(t) {
+    return this.nodeMap.get(t) ?? null;
+  }
+  /**
+   * Adds a new node to the tree.
+   * @param data The data for the new node.
+   * @param parentId The ID of the parent node. If null or undefined, adds to the root.
+   * @param nodeOptions Optional configuration for the new node (e.g., custom ID).
+   * @returns The newly created TreeNode, or null if the parent was not found.
+   */
+  addNode(t, n = null, o = {}) {
+    const i = n ? this.findNodeById(n) : this.root;
+    if (!i)
+      return console.error(`Tree addNode: Parent node with ID ${n} not found.`), null;
+    o.id && this.nodeMap.has(o.id) && (o.id = void 0);
+    const s = new ot(t, i, o);
+    return this.nodeMap.set(s.id, s), i.addChild(s), s;
+  }
+  /**
+   * Removes a node from the tree by its ID.
+   * Handles deletion of descendants based on the provided strategy or the tree's default.
+   * @param nodeId The ID of the node to remove.
+   * @param deleteStrategy Optional strategy override. If not provided, uses the tree's default strategy.
+   * @returns True if the node was successfully removed, false otherwise.
+   */
+  removeNode(t, n) {
+    const o = n ?? Te(this, le), i = this.findNodeById(t);
+    if (!i)
+      return !1;
+    if (i.isRoot)
+      return console.error("Tree removeNode: Cannot remove the root node."), !1;
+    const s = i.parent.value;
+    if (o === "recursive")
+      Oe(this, ce, ke).call(this, i);
+    else {
+      for (const r of i.children.value)
+        r.parent.value = null;
+      i.children.value = [], this.nodeMap.delete(i.id);
+    }
+    return s._removeChildInstance(i);
+  }
+  /**
+   * Moves a node to become a child of a new parent.
+   * @param nodeId The ID of the node to move.
+   * @param newParentId The ID of the new parent node. Set to null to move to the root level.
+   * @returns True if the node was successfully moved, false otherwise.
+   */
+  moveNode(t, n) {
+    const o = this.findNodeById(t);
+    if (!o)
+      return console.error(`Tree moveNode: Node with ID ${t} not found.`), !1;
+    if (o.isRoot)
+      return console.error("Tree moveNode: Cannot move the root node."), !1;
+    if (t === n)
+      return console.error("Tree moveNode: Cannot move a node to be a child of itself."), !1;
+    const i = n ? this.findNodeById(n) : this.root;
+    if (!i)
+      return console.error(`Tree moveNode: New parent node with ID ${n} not found.`), !1;
+    if (i.isDescendantOf(o))
+      return console.error("Tree moveNode: Cannot move a node to become its own descendant."), !1;
+    const s = o.parent.value;
+    if (s) {
+      if (!s._removeChildInstance(o))
+        return console.error("Tree moveNode: Failed to remove node from its original parent."), !1;
+    } else if (o.isRoot) {
+      if (o.isRoot)
+        return console.error("Tree moveNode: Attempting to move the root node, which is not allowed."), !1;
+    }
+    return i.addChild(o), o.parent.value = i, !0;
+  }
+  /**
+   * Traverses the tree using either Depth-First Search (DFS) or Breadth-First Search (BFS).
+   * @param strategy The traversal strategy ('dfs' or 'bfs'). Defaults to 'dfs'.
+   * @param startNode The node to start traversal from. Defaults to the root node.
+   * @returns An array of nodes in the order they were visited.
+   */
+  traverse(t = "dfs", n = this.root) {
+    const o = [];
+    if (!n)
+      return console.warn("Tree traverse: Start node is null, returning empty array."), o;
+    if (t === "dfs") {
+      const i = [n];
+      for (; i.length > 0; ) {
+        const s = i.pop();
+        o.push(s);
+        for (let r = s.children.value.length - 1; r >= 0; r--)
+          i.push(s.children.value[r]);
+      }
+    } else {
+      const i = [n];
+      for (; i.length > 0; ) {
+        const s = i.shift();
+        o.push(s);
+        for (const r of s.children.value)
+          i.push(r);
+      }
+    }
+    return o;
+  }
+  /**
+   * Clears the internal node map. This is crucial for allowing garbage collection
+   * when the Tree instance is no longer needed, especially in scenarios like
+   * Vue components where the instance might be tied to the component lifecycle.
+   * Call this method when you are finished with the Tree instance (e.g., in `onScopeDispose`).
+   */
+  dispose() {
+    this.nodeMap.clear();
+  }
+}
+le = new WeakMap(), ce = new WeakSet(), // --- Internal Recursive Helper for Deletion/Cleanup ---
+ke = function(t) {
+  const n = [...t.children.value];
+  for (const o of n)
+    Oe(this, ce, ke).call(this, o);
+  this.nodeMap.delete(t.id), t.children.value = [];
+};
+function Vn(e, t = {}) {
+  const n = new Tn(e, t);
+  return {
+    // Wrap original Tree methods in arrow functions to preserve context
+    get nodeMap() {
+      return n.nodeMap;
+    },
+    get root() {
+      return n.root;
+    },
+    findNodeById: (r) => n.findNodeById(r),
+    moveNode: (r, l) => n.moveNode(r, l),
+    dispose: () => n.dispose(),
+    addNode: (r, l) => n.addNode(r, l),
+    removeNode: (r, l) => n.removeNode(r, l),
+    traverse: (r, l) => n.traverse(r, l),
+    isTopmost: (r) => {
+      const l = n.findNodeById(r);
+      if (!l || !l.data.open.value)
+        return !1;
+      let a = l.parent.value;
+      for (; a; ) {
+        if (a.data.open.value)
+          return !1;
+        a = a.parent.value;
+      }
+      return !0;
+    },
+    getAllOpenNodes: () => {
+      const r = [];
+      for (const l of n.nodeMap.values())
+        l.data.open.value && r.push(l);
+      return r;
+    },
+    forEach: (r, l, a = {}) => {
+      const { relationship: c = "self-and-children", applyToMatching: f = !0 } = a, u = n.findNodeById(r);
+      if (!u)
+        return;
+      const m = [], h = /* @__PURE__ */ new Set(), p = (v) => {
+        v && !h.has(v.id) && (m.push(v), h.add(v.id));
+      }, d = (v) => {
+        for (const y of v)
+          p(y);
+      };
+      if (c === "ancestors-only")
+        for (const v of u.getPath())
+          v.id !== u.id && p(v);
+      else if (c === "siblings-only") {
+        if (u.parent.value)
+          for (const v of u.parent.value.children.value)
+            v.id !== u.id && p(v);
+      } else if (c === "descendants-only")
+        for (const v of n.traverse("dfs", u))
+          v.id !== u.id && p(v);
+      else if (c === "children-only")
+        d(u.children.value);
+      else if (c === "self-and-ancestors")
+        d(u.getPath());
+      else if (c === "self-and-children")
+        p(u), d(u.children.value);
+      else if (c === "self-and-descendants")
+        d(n.traverse("dfs", u));
+      else if (c === "self-and-siblings")
+        p(u), u.parent.value && d(u.parent.value.children.value);
+      else if (c === "self-ancestors-and-children")
+        d(u.getPath()), d(u.children.value);
+      else if (c === "full-branch")
+        d(u.getPath()), d(n.traverse("dfs", u));
+      else if (c === "all-except-branch") {
+        const v = /* @__PURE__ */ new Set();
+        for (const y of u.getPath())
+          v.add(y.id);
+        for (const y of n.traverse("dfs", u))
+          v.add(y.id);
+        for (const y of n.nodeMap.values())
+          !v.has(y.id) === f && l(y);
+        return;
+      } else {
+        console.warn(`forEach: Unknown relationship "${c}".`);
+        return;
+      }
+      if (f)
+        for (const v of m)
+          l(v);
+      else
+        for (const v of n.nodeMap.values())
+          h.has(v.id) || l(v);
+    }
+  };
+}
+export {
+  Tn as Tree,
+  ot as TreeNode,
+  $n as arrow,
+  Dn as autoUpdate,
+  Cn as flip,
+  Mn as hide,
+  Rn as offset,
+  Pn as shift,
+  Nn as useArrow,
+  Hn as useClick,
+  Bn as useClientPoint,
+  Fn as useDismiss,
+  An as useFloating,
+  Vn as useFloatingTree,
+  kn as useFocus,
+  Sn as useHover
+};