@adyen/bento-vue3 1.4.1 → 1.5.0

package/dist/popper-container.js

@@ -1,233 +1,1279 @@
-import { createPopper as d } from "@popperjs/core";
-import { defineComponent as n, resolveComponent as f, openBlock as s, createBlock as c, mergeProps as m, withCtx as h, renderSlot as u, createElementBlock as T, normalizeClass as y, createCommentVNode as _ } from "vue";
-import { B as b } from "./chunks/index.fdb0c13d.js";
-import { _ as O } from "./chunks/_plugin-vue_export-helper.dad06003.js";
-import "./assets/index8.css";
-var o = /* @__PURE__ */ ((e) => (e.TOP = "top", e.RIGHT = "right", e.BOTTOM = "bottom", e.LEFT = "left", e))(o || {}), a = /* @__PURE__ */ ((e) => (e.AUTO = "auto", e.AUTO_START = "auto-start", e.AUTO_END = "auto-end", e.TOP_START = "top-start", e.TOP_END = "top-end", e.RIGHT_START = "right-start", e.RIGHT_END = "right-end", e.BOTTOM_START = "bottom-start", e.BOTTOM_END = "bottom-end", e.LEFT_START = "left-start", e.LEFT_END = "left-end", e))(a || {}), p = /* @__PURE__ */ ((e) => (e.TOOLTIP = "tooltip", e.POPOVER = "dialog", e))(p || {});
-const i = { ...o, ...a }, g = (e, t) => ({
+import { unref as B, computed as R, ref as j, shallowRef as Ut, watch as Z, getCurrentScope as Xt, onScopeDispose as Yt, shallowReadonly as q, defineComponent as qt, toRefs as Gt, openBlock as yt, createBlock as Kt, mergeProps as xt, withCtx as Jt, renderSlot as Qt, createElementBlock as Zt, createCommentVNode as te } from "vue";
+import { B as ee } from "./chunks/index.604da8e9.js";
+import { _ as ne } from "./chunks/_plugin-vue_export-helper.dad06003.js";
+import "./assets/index27.css";
+const oe = ["top", "right", "bottom", "left"], bt = ["start", "end"], Ot = /* @__PURE__ */ oe.reduce((t, e) => t.concat(e, e + "-" + bt[0], e + "-" + bt[1]), []), K = Math.min, X = Math.max, ot = Math.round, nt = Math.floor, z = (t) => ({
+  x: t,
+  y: t
+}), ie = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, re = {
+  start: "end",
+  end: "start"
+};
+function ft(t, e, n) {
+  return X(t, K(e, n));
+}
+function Q(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function H(t) {
+  return t.split("-")[0];
+}
+function M(t) {
+  return t.split("-")[1];
+}
+function Dt(t) {
+  return t === "x" ? "y" : "x";
+}
+function dt(t) {
+  return t === "y" ? "height" : "width";
+}
+function st(t) {
+  return ["top", "bottom"].includes(H(t)) ? "y" : "x";
+}
+function mt(t) {
+  return Dt(st(t));
+}
+function Ct(t, e, n) {
+  n === void 0 && (n = !1);
+  const o = M(t), i = mt(t), l = dt(i);
+  let r = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return e.reference[l] > e.floating[l] && (r = rt(r)), [r, rt(r)];
+}
+function le(t) {
+  const e = rt(t);
+  return [it(t), e, it(e)];
+}
+function it(t) {
+  return t.replace(/start|end/g, (e) => re[e]);
+}
+function se(t, e, n) {
+  const o = ["left", "right"], i = ["right", "left"], l = ["top", "bottom"], r = ["bottom", "top"];
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? i : o : e ? o : i;
+    case "left":
+    case "right":
+      return e ? l : r;
+    default:
+      return [];
+  }
+}
+function ce(t, e, n, o) {
+  const i = M(t);
+  let l = se(H(t), n === "start", o);
+  return i && (l = l.map((r) => r + "-" + i), e && (l = l.concat(l.map(it)))), l;
+}
+function rt(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => ie[e]);
+}
+function ae(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function Pt(t) {
+  return typeof t != "number" ? ae(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function lt(t) {
+  return {
+    ...t,
+    top: t.y,
+    left: t.x,
+    right: t.x + t.width,
+    bottom: t.y + t.height
+  };
+}
+function At(t, e, n) {
+  let {
+    reference: o,
+    floating: i
+  } = t;
+  const l = st(e), r = mt(e), s = dt(r), a = H(e), c = l === "y", u = o.x + o.width / 2 - i.width / 2, d = o.y + o.height / 2 - i.height / 2, p = o[s] / 2 - i[s] / 2;
+  let f;
+  switch (a) {
+    case "top":
+      f = {
+        x: u,
+        y: o.y - i.height
+      };
+      break;
+    case "bottom":
+      f = {
+        x: u,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      f = {
+        x: o.x + o.width,
+        y: d
+      };
+      break;
+    case "left":
+      f = {
+        x: o.x - i.width,
+        y: d
+      };
+      break;
+    default:
+      f = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (M(e)) {
+    case "start":
+      f[r] -= p * (n && c ? -1 : 1);
+      break;
+    case "end":
+      f[r] += p * (n && c ? -1 : 1);
+      break;
+  }
+  return f;
+}
+const fe = async (t, e, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: i = "absolute",
+    middleware: l = [],
+    platform: r
+  } = n, s = l.filter(Boolean), a = await (r.isRTL == null ? void 0 : r.isRTL(e));
+  let c = await r.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  }), {
+    x: u,
+    y: d
+  } = At(c, o, a), p = o, f = {}, m = 0;
+  for (let g = 0; g < s.length; g++) {
+    const {
+      name: w,
+      fn: h
+    } = s[g], {
+      x: v,
+      y,
+      data: b,
+      reset: O
+    } = await h({
+      x: u,
+      y: d,
+      initialPlacement: o,
+      placement: p,
+      strategy: i,
+      middlewareData: f,
+      rects: c,
+      platform: r,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    u = v ?? u, d = y ?? d, f = {
+      ...f,
+      [w]: {
+        ...f[w],
+        ...b
+      }
+    }, O && m <= 50 && (m++, typeof O == "object" && (O.placement && (p = O.placement), O.rects && (c = O.rects === !0 ? await r.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: i
+    }) : O.rects), {
+      x: u,
+      y: d
+    } = At(c, p, a)), g = -1);
+  }
+  return {
+    x: u,
+    y: d,
+    placement: p,
+    strategy: i,
+    middlewareData: f
+  };
+};
+async function pt(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const {
+    x: o,
+    y: i,
+    platform: l,
+    rects: r,
+    elements: s,
+    strategy: a
+  } = t, {
+    boundary: c = "clippingAncestors",
+    rootBoundary: u = "viewport",
+    elementContext: d = "floating",
+    altBoundary: p = !1,
+    padding: f = 0
+  } = Q(e, t), m = Pt(f), w = s[p ? d === "floating" ? "reference" : "floating" : d], h = lt(await l.getClippingRect({
+    element: (n = await (l.isElement == null ? void 0 : l.isElement(w))) == null || n ? w : w.contextElement || await (l.getDocumentElement == null ? void 0 : l.getDocumentElement(s.floating)),
+    boundary: c,
+    rootBoundary: u,
+    strategy: a
+  })), v = d === "floating" ? {
+    ...r.floating,
+    x: o,
+    y: i
+  } : r.reference, y = await (l.getOffsetParent == null ? void 0 : l.getOffsetParent(s.floating)), b = await (l.isElement == null ? void 0 : l.isElement(y)) ? await (l.getScale == null ? void 0 : l.getScale(y)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, O = lt(l.convertOffsetParentRelativeRectToViewportRelativeRect ? await l.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: s,
+    rect: v,
+    offsetParent: y,
+    strategy: a
+  }) : v);
+  return {
+    top: (h.top - O.top + m.top) / b.y,
+    bottom: (O.bottom - h.bottom + m.bottom) / b.y,
+    left: (h.left - O.left + m.left) / b.x,
+    right: (O.right - h.right + m.right) / b.x
+  };
+}
+const ue = (t) => ({
   name: "arrow",
-  options: {
+  options: t,
+  async fn(e) {
+    const {
+      x: n,
+      y: o,
+      placement: i,
+      rects: l,
+      platform: r,
+      elements: s,
+      middlewareData: a
+    } = e, {
+      element: c,
+      padding: u = 0
+    } = Q(t, e) || {};
+    if (c == null)
+      return {};
+    const d = Pt(u), p = {
+      x: n,
+      y: o
+    }, f = mt(i), m = dt(f), g = await r.getDimensions(c), w = f === "y", h = w ? "top" : "left", v = w ? "bottom" : "right", y = w ? "clientHeight" : "clientWidth", b = l.reference[m] + l.reference[f] - p[f] - l.floating[m], O = p[f] - l.reference[f], A = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(c));
+    let x = A ? A[y] : 0;
+    (!x || !await (r.isElement == null ? void 0 : r.isElement(A))) && (x = s.floating[y] || l.floating[m]);
+    const D = b / 2 - O / 2, C = x / 2 - g[m] / 2 - 1, T = K(d[h], C), P = K(d[v], C), E = T, U = x - g[m] - P, S = x / 2 - g[m] / 2 + D, F = ft(E, S, U), k = !a.arrow && M(i) != null && S !== F && l.reference[m] / 2 - (S < E ? T : P) - g[m] / 2 < 0, N = k ? S < E ? S - E : S - U : 0;
+    return {
+      [f]: p[f] + N,
+      data: {
+        [f]: F,
+        centerOffset: S - F - N,
+        ...k && {
+          alignmentOffset: N
+        }
+      },
+      reset: k
+    };
+  }
+});
+function de(t, e, n) {
+  return (t ? [...n.filter((i) => M(i) === t), ...n.filter((i) => M(i) !== t)] : n.filter((i) => H(i) === i)).filter((i) => t ? M(i) === t || (e ? it(i) !== i : !1) : !0);
+}
+const me = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "autoPlacement",
+    options: t,
+    async fn(e) {
+      var n, o, i;
+      const {
+        rects: l,
+        middlewareData: r,
+        placement: s,
+        platform: a,
+        elements: c
+      } = e, {
+        crossAxis: u = !1,
+        alignment: d,
+        allowedPlacements: p = Ot,
+        autoAlignment: f = !0,
+        ...m
+      } = Q(t, e), g = d !== void 0 || p === Ot ? de(d || null, f, p) : p, w = await pt(e, m), h = ((n = r.autoPlacement) == null ? void 0 : n.index) || 0, v = g[h];
+      if (v == null)
+        return {};
+      const y = Ct(v, l, await (a.isRTL == null ? void 0 : a.isRTL(c.floating)));
+      if (s !== v)
+        return {
+          reset: {
+            placement: g[0]
+          }
+        };
+      const b = [w[H(v)], w[y[0]], w[y[1]]], O = [...((o = r.autoPlacement) == null ? void 0 : o.overflows) || [], {
+        placement: v,
+        overflows: b
+      }], A = g[h + 1];
+      if (A)
+        return {
+          data: {
+            index: h + 1,
+            overflows: O
+          },
+          reset: {
+            placement: A
+          }
+        };
+      const x = O.map((T) => {
+        const P = M(T.placement);
+        return [T.placement, P && u ? (
+          // Check along the mainAxis and main crossAxis side.
+          T.overflows.slice(0, 2).reduce((E, U) => E + U, 0)
+        ) : (
+          // Check only the mainAxis.
+          T.overflows[0]
+        ), T.overflows];
+      }).sort((T, P) => T[1] - P[1]), C = ((i = x.filter((T) => T[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        M(T[0]) ? 2 : 3
+      ).every((P) => P <= 0))[0]) == null ? void 0 : i[0]) || x[0][0];
+      return C !== s ? {
+        data: {
+          index: h + 1,
+          overflows: O
+        },
+        reset: {
+          placement: C
+        }
+      } : {};
+    }
+  };
+}, pe = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var n, o;
+      const {
+        placement: i,
+        middlewareData: l,
+        rects: r,
+        initialPlacement: s,
+        platform: a,
+        elements: c
+      } = e, {
+        mainAxis: u = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: p,
+        fallbackStrategy: f = "bestFit",
+        fallbackAxisSideDirection: m = "none",
+        flipAlignment: g = !0,
+        ...w
+      } = Q(t, e);
+      if ((n = l.arrow) != null && n.alignmentOffset)
+        return {};
+      const h = H(i), v = H(s) === s, y = await (a.isRTL == null ? void 0 : a.isRTL(c.floating)), b = p || (v || !g ? [rt(s)] : le(s));
+      !p && m !== "none" && b.push(...ce(s, g, m, y));
+      const O = [s, ...b], A = await pt(e, w), x = [];
+      let D = ((o = l.flip) == null ? void 0 : o.overflows) || [];
+      if (u && x.push(A[h]), d) {
+        const E = Ct(i, r, y);
+        x.push(A[E[0]], A[E[1]]);
+      }
+      if (D = [...D, {
+        placement: i,
+        overflows: x
+      }], !x.every((E) => E <= 0)) {
+        var C, T;
+        const E = (((C = l.flip) == null ? void 0 : C.index) || 0) + 1, U = O[E];
+        if (U)
+          return {
+            data: {
+              index: E,
+              overflows: D
+            },
+            reset: {
+              placement: U
+            }
+          };
+        let S = (T = D.filter((F) => F.overflows[0] <= 0).sort((F, k) => F.overflows[1] - k.overflows[1])[0]) == null ? void 0 : T.placement;
+        if (!S)
+          switch (f) {
+            case "bestFit": {
+              var P;
+              const F = (P = D.map((k) => [k.placement, k.overflows.filter((N) => N > 0).reduce((N, zt) => N + zt, 0)]).sort((k, N) => k[1] - N[1])[0]) == null ? void 0 : P[0];
+              F && (S = F);
+              break;
+            }
+            case "initialPlacement":
+              S = s;
+              break;
+          }
+        if (i !== S)
+          return {
+            reset: {
+              placement: S
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function ge(t, e) {
+  const {
+    placement: n,
+    platform: o,
+    elements: i
+  } = t, l = await (o.isRTL == null ? void 0 : o.isRTL(i.floating)), r = H(n), s = M(n), a = st(n) === "y", c = ["left", "top"].includes(r) ? -1 : 1, u = l && a ? -1 : 1, d = Q(e, t);
+  let {
+    mainAxis: p,
+    crossAxis: f,
+    alignmentAxis: m
+  } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: 0,
+    crossAxis: 0,
+    alignmentAxis: null,
+    ...d
+  };
+  return s && typeof m == "number" && (f = s === "end" ? m * -1 : m), a ? {
+    x: f * u,
+    y: p * c
+  } : {
+    x: p * c,
+    y: f * u
+  };
+}
+const he = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var n, o;
+      const {
+        x: i,
+        y: l,
+        placement: r,
+        middlewareData: s
+      } = e, a = await ge(e, t);
+      return r === ((n = s.offset) == null ? void 0 : n.placement) && (o = s.arrow) != null && o.alignmentOffset ? {} : {
+        x: i + a.x,
+        y: l + a.y,
+        data: {
+          ...a,
+          placement: r
+        }
+      };
+    }
+  };
+}, we = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: o,
+        placement: i
+      } = e, {
+        mainAxis: l = !0,
+        crossAxis: r = !1,
+        limiter: s = {
+          fn: (w) => {
+            let {
+              x: h,
+              y: v
+            } = w;
+            return {
+              x: h,
+              y: v
+            };
+          }
+        },
+        ...a
+      } = Q(t, e), c = {
+        x: n,
+        y: o
+      }, u = await pt(e, a), d = st(H(i)), p = Dt(d);
+      let f = c[p], m = c[d];
+      if (l) {
+        const w = p === "y" ? "top" : "left", h = p === "y" ? "bottom" : "right", v = f + u[w], y = f - u[h];
+        f = ft(v, f, y);
+      }
+      if (r) {
+        const w = d === "y" ? "top" : "left", h = d === "y" ? "bottom" : "right", v = m + u[w], y = m - u[h];
+        m = ft(v, m, y);
+      }
+      const g = s.fn({
+        ...e,
+        [p]: f,
+        [d]: m
+      });
+      return {
+        ...g,
+        data: {
+          x: g.x - n,
+          y: g.y - o
+        }
+      };
+    }
+  };
+};
+function V(t) {
+  return gt(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function _(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function I(t) {
+  var e;
+  return (e = (gt(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function gt(t) {
+  return t instanceof Node || t instanceof _(t).Node;
+}
+function W(t) {
+  return t instanceof Element || t instanceof _(t).Element;
+}
+function $(t) {
+  return t instanceof HTMLElement || t instanceof _(t).HTMLElement;
+}
+function Tt(t) {
+  return typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof _(t).ShadowRoot;
+}
+function et(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: o,
+    display: i
+  } = L(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !["inline", "contents"].includes(i);
+}
+function ve(t) {
+  return ["table", "td", "th"].includes(V(t));
+}
+function ht(t) {
+  const e = wt(), n = L(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 ye(t) {
+  let e = J(t);
+  for (; $(e) && !ct(e); ) {
+    if (ht(e))
+      return e;
+    e = J(e);
+  }
+  return null;
+}
+function wt() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function ct(t) {
+  return ["html", "body", "#document"].includes(V(t));
+}
+function L(t) {
+  return _(t).getComputedStyle(t);
+}
+function at(t) {
+  return W(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.pageXOffset,
+    scrollTop: t.pageYOffset
+  };
+}
+function J(t) {
+  if (V(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.
+    Tt(t) && t.host || // Fallback.
+    I(t)
+  );
+  return Tt(e) ? e.host : e;
+}
+function Ft(t) {
+  const e = J(t);
+  return ct(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : $(e) && et(e) ? e : Ft(e);
+}
+function tt(t, e, n) {
+  var o;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const i = Ft(t), l = i === ((o = t.ownerDocument) == null ? void 0 : o.body), r = _(i);
+  return l ? e.concat(r, r.visualViewport || [], et(i) ? i : [], r.frameElement && n ? tt(r.frameElement) : []) : e.concat(i, tt(i, [], n));
+}
+function kt(t) {
+  const e = L(t);
+  let n = parseFloat(e.width) || 0, o = parseFloat(e.height) || 0;
+  const i = $(t), l = i ? t.offsetWidth : n, r = i ? t.offsetHeight : o, s = ot(n) !== l || ot(o) !== r;
+  return s && (n = l, o = r), {
+    width: n,
+    height: o,
+    $: s
+  };
+}
+function vt(t) {
+  return W(t) ? t : t.contextElement;
+}
+function G(t) {
+  const e = vt(t);
+  if (!$(e))
+    return z(1);
+  const n = e.getBoundingClientRect(), {
+    width: o,
+    height: i,
+    $: l
+  } = kt(e);
+  let r = (l ? ot(n.width) : n.width) / o, s = (l ? ot(n.height) : n.height) / i;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!s || !Number.isFinite(s)) && (s = 1), {
+    x: r,
+    y: s
+  };
+}
+const xe = /* @__PURE__ */ z(0);
+function Bt(t) {
+  const e = _(t);
+  return !wt() || !e.visualViewport ? xe : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function be(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== _(t) ? !1 : e;
+}
+function Y(t, e, n, o) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const i = t.getBoundingClientRect(), l = vt(t);
+  let r = z(1);
+  e && (o ? W(o) && (r = G(o)) : r = G(t));
+  const s = be(l, n, o) ? Bt(l) : z(0);
+  let a = (i.left + s.x) / r.x, c = (i.top + s.y) / r.y, u = i.width / r.x, d = i.height / r.y;
+  if (l) {
+    const p = _(l), f = o && W(o) ? _(o) : o;
+    let m = p, g = m.frameElement;
+    for (; g && o && f !== m; ) {
+      const w = G(g), h = g.getBoundingClientRect(), v = L(g), y = h.left + (g.clientLeft + parseFloat(v.paddingLeft)) * w.x, b = h.top + (g.clientTop + parseFloat(v.paddingTop)) * w.y;
+      a *= w.x, c *= w.y, u *= w.x, d *= w.y, a += y, c += b, m = _(g), g = m.frameElement;
+    }
+  }
+  return lt({
+    width: u,
+    height: d,
+    x: a,
+    y: c
+  });
+}
+const Oe = [":popover-open", ":modal"];
+function Mt(t) {
+  return Oe.some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+function Ae(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: o,
+    strategy: i
+  } = t;
+  const l = i === "fixed", r = I(o), s = e ? Mt(e.floating) : !1;
+  if (o === r || s && l)
+    return n;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, c = z(1);
+  const u = z(0), d = $(o);
+  if ((d || !d && !l) && ((V(o) !== "body" || et(r)) && (a = at(o)), $(o))) {
+    const p = Y(o);
+    c = G(o), u.x = p.x + o.clientLeft, u.y = p.y + o.clientTop;
+  }
+  return {
+    width: n.width * c.x,
+    height: n.height * c.y,
+    x: n.x * c.x - a.scrollLeft * c.x + u.x,
+    y: n.y * c.y - a.scrollTop * c.y + u.y
+  };
+}
+function Te(t) {
+  return Array.from(t.getClientRects());
+}
+function $t(t) {
+  return Y(I(t)).left + at(t).scrollLeft;
+}
+function Re(t) {
+  const e = I(t), n = at(t), o = t.ownerDocument.body, i = X(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth), l = X(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
+  let r = -n.scrollLeft + $t(t);
+  const s = -n.scrollTop;
+  return L(o).direction === "rtl" && (r += X(e.clientWidth, o.clientWidth) - i), {
+    width: i,
+    height: l,
+    x: r,
+    y: s
+  };
+}
+function Ee(t, e) {
+  const n = _(t), o = I(t), i = n.visualViewport;
+  let l = o.clientWidth, r = o.clientHeight, s = 0, a = 0;
+  if (i) {
+    l = i.width, r = i.height;
+    const c = wt();
+    (!c || c && e === "fixed") && (s = i.offsetLeft, a = i.offsetTop);
+  }
+  return {
+    width: l,
+    height: r,
+    x: s,
+    y: a
+  };
+}
+function Se(t, e) {
+  const n = Y(t, !0, e === "fixed"), o = n.top + t.clientTop, i = n.left + t.clientLeft, l = $(t) ? G(t) : z(1), r = t.clientWidth * l.x, s = t.clientHeight * l.y, a = i * l.x, c = o * l.y;
+  return {
+    width: r,
+    height: s,
+    x: a,
+    y: c
+  };
+}
+function Rt(t, e, n) {
+  let o;
+  if (e === "viewport")
+    o = Ee(t, n);
+  else if (e === "document")
+    o = Re(I(t));
+  else if (W(e))
+    o = Se(e, n);
+  else {
+    const i = Bt(t);
+    o = {
+      ...e,
+      x: e.x - i.x,
+      y: e.y - i.y
+    };
+  }
+  return lt(o);
+}
+function Nt(t, e) {
+  const n = J(t);
+  return n === e || !W(n) || ct(n) ? !1 : L(n).position === "fixed" || Nt(n, e);
+}
+function _e(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let o = tt(t, [], !1).filter((s) => W(s) && V(s) !== "body"), i = null;
+  const l = L(t).position === "fixed";
+  let r = l ? J(t) : t;
+  for (; W(r) && !ct(r); ) {
+    const s = L(r), a = ht(r);
+    !a && s.position === "fixed" && (i = null), (l ? !a && !i : !a && s.position === "static" && !!i && ["absolute", "fixed"].includes(i.position) || et(r) && !a && Nt(t, r)) ? o = o.filter((u) => u !== r) : i = s, r = J(r);
+  }
+  return e.set(t, o), o;
+}
+function Le(t) {
+  let {
     element: e,
-    padding: t.padding || 0
-  }
-}), w = (e, t) => ({
-  name: "offset",
-  options: { offset: e ? [t[0], t[1] + 7] : t }
-}), A = (e) => ({
-  name: "flip",
-  options: {
-    fallbackPlacements: Array.isArray(e) ? e : [e]
-  }
-}), M = {
-  name: "applyArrowHide",
-  enabled: !0,
-  phase: "write",
-  fn({ state: e }) {
-    const { arrow: t } = e.elements;
-    t && (e.modifiersData.arrow.centerOffset !== 0 ? t.setAttribute("data-hide", "") : t.removeAttribute("data-hide"));
-  }
-}, $ = {
-  name: "sameWidth",
-  enabled: !0,
-  phase: "beforeWrite",
-  requires: ["computeStyles"],
-  fn: ({ state: e }) => {
-    e.styles.popper.width = `${e.rects.reference.width}px`;
-  },
-  effect: ({ state: e }) => {
-    e.elements.popper.style.width = `${e.elements.reference.offsetWidth}px`;
+    boundary: n,
+    rootBoundary: o,
+    strategy: i
+  } = t;
+  const r = [...n === "clippingAncestors" ? _e(e, this._c) : [].concat(n), o], s = r[0], a = r.reduce((c, u) => {
+    const d = Rt(e, u, i);
+    return c.top = X(d.top, c.top), c.right = K(d.right, c.right), c.bottom = K(d.bottom, c.bottom), c.left = X(d.left, c.left), c;
+  }, Rt(e, s, i));
+  return {
+    width: a.right - a.left,
+    height: a.bottom - a.top,
+    x: a.left,
+    y: a.top
+  };
+}
+function De(t) {
+  const {
+    width: e,
+    height: n
+  } = kt(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function Ce(t, e, n) {
+  const o = $(e), i = I(e), l = n === "fixed", r = Y(t, !0, l, e);
+  let s = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = z(0);
+  if (o || !o && !l)
+    if ((V(e) !== "body" || et(i)) && (s = at(e)), o) {
+      const d = Y(e, !0, l, e);
+      a.x = d.x + e.clientLeft, a.y = d.y + e.clientTop;
+    } else
+      i && (a.x = $t(i));
+  const c = r.left + s.scrollLeft - a.x, u = r.top + s.scrollTop - a.y;
+  return {
+    x: c,
+    y: u,
+    width: r.width,
+    height: r.height
+  };
+}
+function Et(t, e) {
+  return !$(t) || L(t).position === "fixed" ? null : e ? e(t) : t.offsetParent;
+}
+function Ht(t, e) {
+  const n = _(t);
+  if (!$(t) || Mt(t))
+    return n;
+  let o = Et(t, e);
+  for (; o && ve(o) && L(o).position === "static"; )
+    o = Et(o, e);
+  return o && (V(o) === "html" || V(o) === "body" && L(o).position === "static" && !ht(o)) ? n : o || ye(t) || n;
+}
+const Pe = async function(t) {
+  const e = this.getOffsetParent || Ht, n = this.getDimensions;
+  return {
+    reference: Ce(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      ...await n(t.floating)
+    }
+  };
+};
+function Fe(t) {
+  return L(t).direction === "rtl";
+}
+const ke = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Ae,
+  getDocumentElement: I,
+  getClippingRect: Le,
+  getOffsetParent: Ht,
+  getElementRects: Pe,
+  getClientRects: Te,
+  getDimensions: De,
+  getScale: G,
+  isElement: W,
+  isRTL: Fe
+};
+function Be(t, e) {
+  let n = null, o;
+  const i = I(t);
+  function l() {
+    var s;
+    clearTimeout(o), (s = n) == null || s.disconnect(), n = null;
   }
-}, R = n({
-  components: { BentoFocusTrap: b },
+  function r(s, a) {
+    s === void 0 && (s = !1), a === void 0 && (a = 1), l();
+    const {
+      left: c,
+      top: u,
+      width: d,
+      height: p
+    } = t.getBoundingClientRect();
+    if (s || e(), !d || !p)
+      return;
+    const f = nt(u), m = nt(i.clientWidth - (c + d)), g = nt(i.clientHeight - (u + p)), w = nt(c), v = {
+      rootMargin: -f + "px " + -m + "px " + -g + "px " + -w + "px",
+      threshold: X(0, K(1, a)) || 1
+    };
+    let y = !0;
+    function b(O) {
+      const A = O[0].intersectionRatio;
+      if (A !== a) {
+        if (!y)
+          return r();
+        A ? r(!1, A) : o = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 100);
+      }
+      y = !1;
+    }
+    try {
+      n = new IntersectionObserver(b, {
+        ...v,
+        // Handle <iframe>s
+        root: i.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(b, v);
+    }
+    n.observe(t);
+  }
+  return r(!0), l;
+}
+function St(t, e, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: i = !0,
+    ancestorResize: l = !0,
+    elementResize: r = typeof ResizeObserver == "function",
+    layoutShift: s = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = o, c = vt(t), u = i || l ? [...c ? tt(c) : [], ...tt(e)] : [];
+  u.forEach((h) => {
+    i && h.addEventListener("scroll", n, {
+      passive: !0
+    }), l && h.addEventListener("resize", n);
+  });
+  const d = c && s ? Be(c, n) : null;
+  let p = -1, f = null;
+  r && (f = new ResizeObserver((h) => {
+    let [v] = h;
+    v && v.target === c && f && (f.unobserve(e), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
+      var y;
+      (y = f) == null || y.observe(e);
+    })), n();
+  }), c && !a && f.observe(c), f.observe(e));
+  let m, g = a ? Y(t) : null;
+  a && w();
+  function w() {
+    const h = Y(t);
+    g && (h.x !== g.x || h.y !== g.y || h.width !== g.width || h.height !== g.height) && n(), g = h, m = requestAnimationFrame(w);
+  }
+  return n(), () => {
+    var h;
+    u.forEach((v) => {
+      i && v.removeEventListener("scroll", n), l && v.removeEventListener("resize", n);
+    }), d == null || d(), (h = f) == null || h.disconnect(), f = null, a && cancelAnimationFrame(m);
+  };
+}
+const Me = me, $e = we, Ne = pe, He = ue, Ve = (t, e, n) => {
+  const o = /* @__PURE__ */ new Map(), i = {
+    platform: ke,
+    ...n
+  }, l = {
+    ...i.platform,
+    _c: o
+  };
+  return fe(t, e, {
+    ...i,
+    platform: l
+  });
+};
+function We(t) {
+  return t != null && typeof t == "object" && "$el" in t;
+}
+function ut(t) {
+  if (We(t)) {
+    const e = t.$el;
+    return gt(e) && V(e) === "#comment" ? null : e;
+  }
+  return t;
+}
+function Ie(t) {
+  return {
+    name: "arrow",
+    options: t,
+    fn(e) {
+      const n = ut(B(t.element));
+      return n == null ? {} : He({
+        element: n,
+        padding: t.padding
+      }).fn(e);
+    }
+  };
+}
+function Vt(t) {
+  return typeof window > "u" ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function _t(t, e) {
+  const n = Vt(t);
+  return Math.round(e * n) / n;
+}
+function je(t, e, n) {
+  n === void 0 && (n = {});
+  const o = n.whileElementsMounted, i = R(() => {
+    var x;
+    return (x = B(n.open)) != null ? x : !0;
+  }), l = R(() => B(n.middleware)), r = R(() => {
+    var x;
+    return (x = B(n.placement)) != null ? x : "bottom";
+  }), s = R(() => {
+    var x;
+    return (x = B(n.strategy)) != null ? x : "absolute";
+  }), a = R(() => {
+    var x;
+    return (x = B(n.transform)) != null ? x : !0;
+  }), c = R(() => ut(t.value)), u = R(() => ut(e.value)), d = j(0), p = j(0), f = j(s.value), m = j(r.value), g = Ut({}), w = j(!1), h = R(() => {
+    const x = {
+      position: f.value,
+      left: "0",
+      top: "0"
+    };
+    if (!u.value)
+      return x;
+    const D = _t(u.value, d.value), C = _t(u.value, p.value);
+    return a.value ? {
+      ...x,
+      transform: "translate(" + D + "px, " + C + "px)",
+      ...Vt(u.value) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: f.value,
+      left: D + "px",
+      top: C + "px"
+    };
+  });
+  let v;
+  function y() {
+    c.value == null || u.value == null || Ve(c.value, u.value, {
+      middleware: l.value,
+      placement: r.value,
+      strategy: s.value
+    }).then((x) => {
+      d.value = x.x, p.value = x.y, f.value = x.strategy, m.value = x.placement, g.value = x.middlewareData, w.value = !0;
+    });
+  }
+  function b() {
+    typeof v == "function" && (v(), v = void 0);
+  }
+  function O() {
+    if (b(), o === void 0) {
+      y();
+      return;
+    }
+    if (c.value != null && u.value != null) {
+      v = o(c.value, u.value, y);
+      return;
+    }
+  }
+  function A() {
+    i.value || (w.value = !1);
+  }
+  return Z([l, r, s], y, {
+    flush: "sync"
+  }), Z([c, u], O, {
+    flush: "sync"
+  }), Z(i, A, {
+    flush: "sync"
+  }), Xt() && Yt(b), {
+    x: q(d),
+    y: q(p),
+    strategy: q(f),
+    placement: q(m),
+    middlewareData: q(g),
+    isPositioned: q(w),
+    floatingStyles: h,
+    update: y
+  };
+}
+var Wt = /* @__PURE__ */ ((t) => (t.TOP = "top", t.RIGHT = "right", t.BOTTOM = "bottom", t.LEFT = "left", t))(Wt || {}), It = /* @__PURE__ */ ((t) => (t.AUTO = "auto", t.AUTO_START = "auto-start", t.AUTO_END = "auto-end", t.TOP_START = "top-start", t.TOP_END = "top-end", t.RIGHT_START = "right-start", t.RIGHT_END = "right-end", t.BOTTOM_START = "bottom-start", t.BOTTOM_END = "bottom-end", t.LEFT_START = "left-start", t.LEFT_END = "left-end", t))(It || {}), jt = /* @__PURE__ */ ((t) => (t.TOOLTIP = "tooltip", t.POPOVER = "dialog", t))(jt || {});
+const Lt = { ...Wt, ...It }, ze = (t, e) => t ? e[1] + 7 : e[1], Ue = (t) => {
+  let e = Array.isArray(t) ? t : [t];
+  return e = e.filter((n) => n !== "auto" && n !== "auto-start" && n !== "auto-end").map((n) => n), {
+    fallbackPlacements: e
+  };
+}, Xe = {
+  name: "sameWidth",
+  fn: ({ elements: t }) => (t.floating.style.width = `${t.reference.offsetWidth}px`, {})
+}, Ye = {}, qe = /* @__PURE__ */ qt({
+  ...Ye,
+  __name: "popper-container",
   props: {
     /**
-     * The id to be set on the component. Use it for accessibility purposes.
-     */
-    id: { type: String, default: null },
-    /**
-     * Reference to the DOM element or Vue component for positioning
-     */
-    targetElement: { type: [Element, Object], required: !0 },
-    /**
-     * Position relative to the target element
-     * @see {@link https://popper.js.org/docs/v2/constructors/#placement}
+     * The aria role assigned to the container. Defaults to null, which means it's not set if nothing is passed.
      */
-    position: {
+    ariaRole: {
       type: String,
-      default: i.AUTO,
-      validator: (e) => Object.values(i).includes(e)
+      default: null,
+      validator: (t) => Object.values(jt).includes(t)
     },
-    /**
-     * Instructs popover to be visible outside of the containing container.
-     * Useful when component would be used in limited containers like Modal, Side panel, etc.
-     * https://popper.js.org/docs/v2/constructors/#strategy
-     */
-    fixedPositioning: { type: Boolean, default: !1 },
     /**
      * Indicates if container should have additional arrow, pointing at target element
      * Can be just a boolean flag, or an object with additional configuration:
      * @property {Array<string>} arrow.classes – apply any additional classes to the arrow element.
-     * @property {string} arrow.padding – useful when content has rounded corners, https://popper.js.org/docs/v2/modifiers/arrow/#padding
+     * @property {string} arrow.padding – useful when content has rounded corners, @see {@link https://floating-ui.com/docs/arrow#padding}
      */
     arrow: { type: Object, default: void 0 },
-    /**
-     * Allows to displace a popper container from its target element.
-     * @see {@link https://popper.js.org/docs/v2/modifiers/offset/}
-     */
-    offset: {
-      type: Array,
-      default: () => [0, 0],
-      validator: (e) => (e == null ? void 0 : e.length) === 2
-    },
-    /**
-     * Instructs popper container to have the same width as target element.
-     */
-    matchWidth: { type: Boolean, default: !1 },
     /**
      * Disables wrapping focus-trap component.
      * Mostly useful for the storybook demo.
      */
     disabledFocusTrap: { type: Boolean, default: !1 },
-    /**
-     * Custom set of modifiers. Useful for low-level control over Popper behavior in some really complex use cases.
-     */
-    modifiers: { type: Array, default: null },
     /**
      * Allows to configure to fallback position to the one specified, it could be 'auto' or ['right', 'top', ...].
      * Useful when not using auto as starting placement.
-     * https://popper.js.org/docs/v2/modifiers/flip/#fallbackplacements
+     * @see {@link https://floating-ui.com/docs/flip#fallbackplacements}
      */
     fallbackPosition: {
       type: [Array, String],
       default: null
     },
     /**
-     * The aria role assigned to the container. Defaults to null, which means it's not set if nothing is passed.
+     * Instructs popover to be visible outside of the containing container.
+     * Useful when component would be used in limited containers like Modal, Side panel, etc.
+     * @see {@link https://floating-ui.com/docs/usefloating#strategy}
      */
-    ariaRole: {
-      type: String,
-      default: null,
-      validator: (e) => Object.values(p).includes(e)
-    }
-  },
-  data: () => ({
-    popper: null,
-    emittedPosition: null
-  }),
-  computed: {
-    strategy() {
-      return this.fixedPositioning ? "fixed" : "absolute";
-    },
+    fixedPositioning: { type: Boolean, default: !1 },
     /**
-     * Retrieves all the popper modifiers to be applied to popover.
-     * Read utils file for more info on each modifier.
+     * The id to be set on the component. Use it for accessibility purposes.
      */
-    allModifiers() {
-      const e = this.modifiers || [];
-      return [
-        // Create arrow modifier if arrow props are set
-        ...this.arrow ? [g(this.$refs.arrow, this.arrow)] : [],
-        // Create offset modifier
-        w(this.arrow, this.offset),
-        // Apply data-hide attribute to arrow element depnding on center offset.
-        M,
-        // If matchWidth set to true, set the width of popover to same as target element.
-        ...this.matchWidth ? [$] : [],
-        // Emits position of popover when position is updated.
-        {
-          name: "trackPosition",
-          enabled: !0,
-          phase: "afterWrite",
-          fn: ({ state: r }) => {
-            this.emittedPosition !== r.placement && (this.emittedPosition = r.placement, this.$emit("position", this.emittedPosition));
-          }
-        },
-        // Sets Flip modifier if fallbackPosition is set
-        ...this.fallbackPosition ? [A(this.fallbackPosition)] : [],
-        ...e || []
-      ];
-    },
+    id: { type: String, default: null },
     /**
-     * Sets default arrow classes if none have been set.
+     * If hiding / showing popper element then use this property to tell the popper when to update it's position.
+     * This will drastically help improve performance, as we will not need to track hidden elements.
      */
-    arrowClasses() {
-      var e;
-      return ((e = this == null ? void 0 : this.arrow) == null ? void 0 : e.classes) ?? [];
-    }
-  },
-  watch: {
-    targetElement(e) {
-      this.destroyPopper(), this.$refs.popperContainerRef.$el && e && this.initPopper();
-    },
-    position(e) {
-      this.updatePopperOptions({ placement: e });
-    },
-    strategy(e) {
-      this.updatePopperOptions({ strategy: e });
+    isHidden: { type: Boolean, default: null },
+    /**
+     * Instructs popper container to have the same width as target element.
+     */
+    matchWidth: { type: Boolean, default: !1 },
+    /**
+     * Custom set of middleware. Useful for low-level control over Popper behavior in some really complex use cases.
+     * @see {@link https://floating-ui.com/docs/middleware}
+     */
+    middleware: { type: Array, default: null },
+    /**
+     * Allows to displace a popper container from its target element.
+     * @see {@link https://floating-ui.com/docs/offset#options}
+     */
+    offset: {
+      type: Array,
+      default: () => [0, 0],
+      validator: (t) => (t == null ? void 0 : t.length) === 2
     },
-    async arrow(e) {
-      e && await this.$nextTick(), this.updateModifiers();
+    /**
+     * Position relative to the target element
+     * @see {@link https://floating-ui.com/docs/computeposition#placement}
+     */
+    position: {
+      type: String,
+      default: Lt.AUTO,
+      validator: (t) => Object.values(Lt).includes(t)
     },
-    offset: "updateModifiers",
-    matchWidth: "updateModifiers"
-  },
-  mounted() {
-    this.initPopper();
-  },
-  beforeUnmount() {
-    this.destroyPopper();
+    /**
+     * Reference to the DOM element or Vue component for positioning
+     */
+    targetElement: { type: [Element, Object], required: !0 }
   },
-  methods: {
-    initPopper() {
-      const e = this.targetElement.$el ? this.targetElement.$el : this.targetElement;
-      this.popper = d(
-        e,
-        this.$refs.popperContainerRef.$el,
-        {
-          placement: this.position,
-          strategy: this.strategy,
-          modifiers: this.allModifiers
-        }
-      );
-    },
-    destroyPopper() {
-      this.popper && this.popper.destroy();
-    },
-    updatePopperOptions(e) {
-      this.popper && this.popper.setOptions(e);
-    },
-    updateModifiers() {
-      this.updatePopperOptions({ modifiers: this.allModifiers });
-    }
+  emits: ["placement"],
+  setup(t, { emit: e }) {
+    var y;
+    const n = t, { position: o } = Gt(n), i = j(), l = j(null), r = j(n.position), s = R(
+      () => n.targetElement.$el ? n.targetElement.$el : n.targetElement
+    ), a = R(
+      () => i.value.$el ? i.value.$el : i.value
+    ), c = R(() => (n == null ? void 0 : n.position) !== "auto" && (n == null ? void 0 : n.fallbackPosition) !== "auto"), u = R(() => {
+      switch (n.position) {
+        case "auto-start":
+          return { alignment: "start", crossAxis: !0 };
+        case "auto-end":
+          return { alignment: "end", crossAxis: !0 };
+        default:
+          return;
+      }
+    }), d = R(() => n.fixedPositioning ? "fixed" : "absolute"), { floatingStyles: p, middlewareData: f, placement: m, update: g } = je(s, i, {
+      placement: o,
+      middleware: [
+        // Adds flip modifier if fallbackPosition is not set to auto
+        ...c.value ? [
+          Ne({
+            fallbackPlacements: Ue(n.fallbackPosition).fallbackPlacements
+          })
+        ] : [],
+        // Adds autoposition middlelare if position is set to any auto variants
+        ...c.value ? [] : [Me(u.value)],
+        // Add shifting middle in case popper is still not fully visible in view port
+        $e(),
+        // Adds offset middlelare if offset property is set
+        ...n.offset ? [he(ze(n.arrow, n.offset))] : [],
+        // Adds arrow middlelare if arrow property is set, can set additional padding property
+        ...n.arrow ? [Ie({ element: l, padding: n.arrow.padding || 0 })] : [],
+        // Adds same width middleware to keep popper width same as referenced element's width
+        ...n.matchWidth ? [Xe] : [],
+        // If there is additional custom middleware to add via the property then add it
+        ...((y = n.middleware) == null ? void 0 : y.length) > 0 ? n.middleware : []
+      ],
+      strategy: d,
+      // If we're mounting the element with a `v-if` then we need to auto update it while it's mounted
+      ...n.isHidden === null ? { whileElementsMounted: St } : []
+    });
+    let w;
+    Z(
+      () => n.isHidden,
+      () => {
+        n.isHidden !== null && !n.isHidden ? w = St(s == null ? void 0 : s.value, a == null ? void 0 : a.value, g) : n.isHidden !== null && n.isHidden && typeof w == "function" && w();
+      }
+    ), Z(
+      () => m.value,
+      () => {
+        r.value !== m.value && (r.value = m.value, e("placement", r.value));
+      }
+    );
+    const h = R(() => {
+      var b, O;
+      return {
+        position: "absolute",
+        left: ((b = f.value.arrow) == null ? void 0 : b.x) != null ? `${f.value.arrow.x}px` : "",
+        top: ((O = f.value.arrow) == null ? void 0 : O.y) != null ? `${f.value.arrow.y}px` : ""
+      };
+    }), v = R(() => {
+      var b;
+      return {
+        class: n.arrow.classes,
+        style: h.value,
+        // Applies a data-hide attribute to arrow element depending on center offset.
+        ...((b = f.value.arrow) == null ? void 0 : b.centerOffset) !== 0 ? { "data-hide": "" } : {}
+      };
+    });
+    return (b, O) => (yt(), Kt(B(ee), xt(b.$attrs, {
+      id: t.id,
+      ref_key: "popperContainerRef",
+      ref: i,
+      class: "b-popper-container",
+      "data-popper-placement": B(m),
+      disabled: t.disabledFocusTrap,
+      style: B(p),
+      role: t.ariaRole
+    }), {
+      default: Jt(() => [
+        Qt(b.$slots, "default", {}, void 0, !0),
+        n.arrow ? (yt(), Zt("span", xt({ key: 0 }, B(v), {
+          ref_key: "floatingArrow",
+          ref: l,
+          class: "b-popper-container__arrow",
+          "data-testid": "arrow"
+        }), null, 16)) : te("", !0)
+      ]),
+      _: 3
+    }, 16, ["id", "data-popper-placement", "disabled", "style", "role"]));
   }
 });
-function S(e, t, r, v, k, B) {
-  const l = f("bento-focus-trap");
-  return s(), c(l, m({
-    id: e.id,
-    ref: "popperContainerRef",
-    disabled: e.disabledFocusTrap,
-    class: "b-popper-container",
-    role: e.ariaRole
-  }, e.$attrs), {
-    default: h(() => [
-      u(e.$slots, "default", {}, void 0, !0),
-      e.arrow ? (s(), T("span", {
-        key: 0,
-        ref: "arrow",
-        class: y([e.arrowClasses, "b-popper-container__arrow"]),
-        "data-testid": "arrow"
-      }, null, 2)) : _("", !0)
-    ]),
-    _: 3
-  }, 16, ["id", "disabled", "role"]);
-}
-const N = /* @__PURE__ */ O(R, [["render", S], ["__scopeId", "data-v-a5dcb2cd"]]);
+const Qe = /* @__PURE__ */ ne(qe, [["__scopeId", "data-v-339046b9"]]);
 export {
-  N as PopperContainer,
-  p as PopperContainerAriaRole,
-  i as PopperContainerPosition,
-  o as PopperContainerPositionBasic,
-  a as PopperContainerPositionExtended
+  Qe as PopperContainer,
+  jt as PopperContainerAriaRole,
+  Lt as PopperContainerPosition,
+  Wt as PopperContainerPositionBasic,
+  It as PopperContainerPositionExtended
 };
 //# sourceMappingURL=popper-container.js.map