@adyen/bento-vue3 1.85.0 → 1.86.1

package/dist/chunks/popper-container.BefZxTzP.js

@@ -0,0 +1,1432 @@
+import { computed as S, unref as V, ref as z, shallowRef as oe, watch as ot, getCurrentScope as ie, onScopeDispose as re, shallowReadonly as Z, defineComponent as le, toRefs as se, openBlock as Rt, createBlock as ce, mergeProps as St, withCtx as ae, renderSlot as fe, createElementBlock as ue, createCommentVNode as de } from "vue";
+import { B as me } from "./focus-trap.CBvh2H_m.js";
+import { _ as pe } from "./_plugin-vue_export-helper.CHgC5LLL.js";
+import "../assets/popper-container.css";
+const Vt = ["top", "right", "bottom", "left"], Et = ["start", "end"], Lt = /* @__PURE__ */ Vt.reduce((t, e) => t.concat(e, e + "-" + Et[0], e + "-" + Et[1]), []), et = Math.min, G = Math.max, st = Math.round, lt = Math.floor, _ = (t) => ({
+  x: t,
+  y: t
+}), ge = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, he = {
+  start: "end",
+  end: "start"
+};
+function ht(t, e, n) {
+  return G(t, et(e, n));
+}
+function J(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function I(t) {
+  return t.split("-")[0];
+}
+function B(t) {
+  return t.split("-")[1];
+}
+function It(t) {
+  return t === "x" ? "y" : "x";
+}
+function yt(t) {
+  return t === "y" ? "height" : "width";
+}
+const we = /* @__PURE__ */ new Set(["top", "bottom"]);
+function U(t) {
+  return we.has(I(t)) ? "y" : "x";
+}
+function xt(t) {
+  return It(U(t));
+}
+function jt(t, e, n) {
+  n === void 0 && (n = !1);
+  const o = B(t), i = xt(t), l = yt(i);
+  let r = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return e.reference[l] > e.floating[l] && (r = at(r)), [r, at(r)];
+}
+function ve(t) {
+  const e = at(t);
+  return [ct(t), e, ct(e)];
+}
+function ct(t) {
+  return t.replace(/start|end/g, (e) => he[e]);
+}
+const Ct = ["left", "right"], Dt = ["right", "left"], ye = ["top", "bottom"], xe = ["bottom", "top"];
+function be(t, e, n) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? Dt : Ct : e ? Ct : Dt;
+    case "left":
+    case "right":
+      return e ? ye : xe;
+    default:
+      return [];
+  }
+}
+function Oe(t, e, n, o) {
+  const i = B(t);
+  let l = be(I(t), n === "start", o);
+  return i && (l = l.map((r) => r + "-" + i), e && (l = l.concat(l.map(ct)))), l;
+}
+function at(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => ge[e]);
+}
+function Ae(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function zt(t) {
+  return typeof t != "number" ? Ae(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function ft(t) {
+  const {
+    x: e,
+    y: n,
+    width: o,
+    height: i
+  } = t;
+  return {
+    width: o,
+    height: i,
+    top: n,
+    left: e,
+    right: e + o,
+    bottom: n + i,
+    x: e,
+    y: n
+  };
+}
+function Pt(t, e, n) {
+  let {
+    reference: o,
+    floating: i
+  } = t;
+  const l = U(e), r = xt(e), s = yt(r), c = I(e), a = 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 (c) {
+    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 (B(e)) {
+    case "start":
+      f[r] -= p * (n && a ? -1 : 1);
+      break;
+    case "end":
+      f[r] += p * (n && a ? -1 : 1);
+      break;
+  }
+  return f;
+}
+async function Te(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const {
+    x: o,
+    y: i,
+    platform: l,
+    rects: r,
+    elements: s,
+    strategy: c
+  } = t, {
+    boundary: a = "clippingAncestors",
+    rootBoundary: u = "viewport",
+    elementContext: d = "floating",
+    altBoundary: p = !1,
+    padding: f = 0
+  } = J(e, t), m = zt(f), w = s[p ? d === "floating" ? "reference" : "floating" : d], h = ft(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: a,
+    rootBoundary: u,
+    strategy: c
+  })), v = d === "floating" ? {
+    x: o,
+    y: i,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference, x = await (l.getOffsetParent == null ? void 0 : l.getOffsetParent(s.floating)), b = await (l.isElement == null ? void 0 : l.isElement(x)) ? await (l.getScale == null ? void 0 : l.getScale(x)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, O = ft(l.convertOffsetParentRelativeRectToViewportRelativeRect ? await l.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: s,
+    rect: v,
+    offsetParent: x,
+    strategy: c
+  }) : 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 Re = async (t, e, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: i = "absolute",
+    middleware: l = [],
+    platform: r
+  } = n, s = l.filter(Boolean), c = await (r.isRTL == null ? void 0 : r.isRTL(e));
+  let a = await r.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  }), {
+    x: u,
+    y: d
+  } = Pt(a, o, c), p = o, f = {}, m = 0;
+  for (let w = 0; w < s.length; w++) {
+    var g;
+    const {
+      name: h,
+      fn: v
+    } = s[w], {
+      x,
+      y: b,
+      data: O,
+      reset: A
+    } = await v({
+      x: u,
+      y: d,
+      initialPlacement: o,
+      placement: p,
+      strategy: i,
+      middlewareData: f,
+      rects: a,
+      platform: {
+        ...r,
+        detectOverflow: (g = r.detectOverflow) != null ? g : Te
+      },
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    u = x ?? u, d = b ?? d, f = {
+      ...f,
+      [h]: {
+        ...f[h],
+        ...O
+      }
+    }, A && m <= 50 && (m++, typeof A == "object" && (A.placement && (p = A.placement), A.rects && (a = A.rects === !0 ? await r.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: i
+    }) : A.rects), {
+      x: u,
+      y: d
+    } = Pt(a, p, c)), w = -1);
+  }
+  return {
+    x: u,
+    y: d,
+    placement: p,
+    strategy: i,
+    middlewareData: f
+  };
+}, Se = (t) => ({
+  name: "arrow",
+  options: t,
+  async fn(e) {
+    const {
+      x: n,
+      y: o,
+      placement: i,
+      rects: l,
+      platform: r,
+      elements: s,
+      middlewareData: c
+    } = e, {
+      element: a,
+      padding: u = 0
+    } = J(t, e) || {};
+    if (a == null)
+      return {};
+    const d = zt(u), p = {
+      x: n,
+      y: o
+    }, f = xt(i), m = yt(f), g = await r.getDimensions(a), w = f === "y", h = w ? "top" : "left", v = w ? "bottom" : "right", x = 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(a));
+    let y = A ? A[x] : 0;
+    (!y || !await (r.isElement == null ? void 0 : r.isElement(A))) && (y = s.floating[x] || l.floating[m]);
+    const H = b / 2 - O / 2, E = y / 2 - g[m] / 2 - 1, T = et(d[h], E), C = et(d[v], E), N = T, Y = y - g[m] - C, R = y / 2 - g[m] / 2 + H, q = ht(N, R, Y), W = !c.arrow && B(i) != null && R !== q && l.reference[m] / 2 - (R < N ? T : C) - g[m] / 2 < 0, D = W ? R < N ? R - N : R - Y : 0;
+    return {
+      [f]: p[f] + D,
+      data: {
+        [f]: q,
+        centerOffset: R - q - D,
+        ...W && {
+          alignmentOffset: D
+        }
+      },
+      reset: W
+    };
+  }
+});
+function Ee(t, e, n) {
+  return (t ? [...n.filter((i) => B(i) === t), ...n.filter((i) => B(i) !== t)] : n.filter((i) => I(i) === i)).filter((i) => t ? B(i) === t || (e ? ct(i) !== i : !1) : !0);
+}
+const Le = 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: c,
+        elements: a
+      } = e, {
+        crossAxis: u = !1,
+        alignment: d,
+        allowedPlacements: p = Lt,
+        autoAlignment: f = !0,
+        ...m
+      } = J(t, e), g = d !== void 0 || p === Lt ? Ee(d || null, f, p) : p, w = await c.detectOverflow(e, m), h = ((n = r.autoPlacement) == null ? void 0 : n.index) || 0, v = g[h];
+      if (v == null)
+        return {};
+      const x = jt(v, l, await (c.isRTL == null ? void 0 : c.isRTL(a.floating)));
+      if (s !== v)
+        return {
+          reset: {
+            placement: g[0]
+          }
+        };
+      const b = [w[I(v)], w[x[0]], w[x[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 y = O.map((T) => {
+        const C = B(T.placement);
+        return [T.placement, C && u ? (
+          // Check along the mainAxis and main crossAxis side.
+          T.overflows.slice(0, 2).reduce((N, Y) => N + Y, 0)
+        ) : (
+          // Check only the mainAxis.
+          T.overflows[0]
+        ), T.overflows];
+      }).sort((T, C) => T[1] - C[1]), E = ((i = y.filter((T) => T[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        B(T[0]) ? 2 : 3
+      ).every((C) => C <= 0))[0]) == null ? void 0 : i[0]) || y[0][0];
+      return E !== s ? {
+        data: {
+          index: h + 1,
+          overflows: O
+        },
+        reset: {
+          placement: E
+        }
+      } : {};
+    }
+  };
+}, Ce = 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: c,
+        elements: a
+      } = e, {
+        mainAxis: u = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: p,
+        fallbackStrategy: f = "bestFit",
+        fallbackAxisSideDirection: m = "none",
+        flipAlignment: g = !0,
+        ...w
+      } = J(t, e);
+      if ((n = l.arrow) != null && n.alignmentOffset)
+        return {};
+      const h = I(i), v = U(s), x = I(s) === s, b = await (c.isRTL == null ? void 0 : c.isRTL(a.floating)), O = p || (x || !g ? [at(s)] : ve(s)), A = m !== "none";
+      !p && A && O.push(...Oe(s, g, m, b));
+      const y = [s, ...O], H = await c.detectOverflow(e, w), E = [];
+      let T = ((o = l.flip) == null ? void 0 : o.overflows) || [];
+      if (u && E.push(H[h]), d) {
+        const R = jt(i, r, b);
+        E.push(H[R[0]], H[R[1]]);
+      }
+      if (T = [...T, {
+        placement: i,
+        overflows: E
+      }], !E.every((R) => R <= 0)) {
+        var C, N;
+        const R = (((C = l.flip) == null ? void 0 : C.index) || 0) + 1, q = y[R];
+        if (q && (!(d === "alignment" ? v !== U(q) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        T.every((P) => U(P.placement) === v ? P.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: R,
+              overflows: T
+            },
+            reset: {
+              placement: q
+            }
+          };
+        let W = (N = T.filter((D) => D.overflows[0] <= 0).sort((D, P) => D.overflows[1] - P.overflows[1])[0]) == null ? void 0 : N.placement;
+        if (!W)
+          switch (f) {
+            case "bestFit": {
+              var Y;
+              const D = (Y = T.filter((P) => {
+                if (A) {
+                  const j = U(P.placement);
+                  return j === v || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  j === "y";
+                }
+                return !0;
+              }).map((P) => [P.placement, P.overflows.filter((j) => j > 0).reduce((j, ne) => j + ne, 0)]).sort((P, j) => P[1] - j[1])[0]) == null ? void 0 : Y[0];
+              D && (W = D);
+              break;
+            }
+            case "initialPlacement":
+              W = s;
+              break;
+          }
+        if (i !== W)
+          return {
+            reset: {
+              placement: W
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function Ft(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function Mt(t) {
+  return Vt.some((e) => t[e] >= 0);
+}
+const De = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const {
+        rects: n,
+        platform: o
+      } = e, {
+        strategy: i = "referenceHidden",
+        ...l
+      } = J(t, e);
+      switch (i) {
+        case "referenceHidden": {
+          const r = await o.detectOverflow(e, {
+            ...l,
+            elementContext: "reference"
+          }), s = Ft(r, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: s,
+              referenceHidden: Mt(s)
+            }
+          };
+        }
+        case "escaped": {
+          const r = await o.detectOverflow(e, {
+            ...l,
+            altBoundary: !0
+          }), s = Ft(r, n.floating);
+          return {
+            data: {
+              escapedOffsets: s,
+              escaped: Mt(s)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, Pe = /* @__PURE__ */ new Set(["left", "top"]);
+async function Fe(t, e) {
+  const {
+    placement: n,
+    platform: o,
+    elements: i
+  } = t, l = await (o.isRTL == null ? void 0 : o.isRTL(i.floating)), r = I(n), s = B(n), c = U(n) === "y", a = Pe.has(r) ? -1 : 1, u = l && c ? -1 : 1, d = J(e, t);
+  let {
+    mainAxis: p,
+    crossAxis: f,
+    alignmentAxis: m
+  } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: d.mainAxis || 0,
+    crossAxis: d.crossAxis || 0,
+    alignmentAxis: d.alignmentAxis
+  };
+  return s && typeof m == "number" && (f = s === "end" ? m * -1 : m), c ? {
+    x: f * u,
+    y: p * a
+  } : {
+    x: p * a,
+    y: f * u
+  };
+}
+const Me = 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, c = await Fe(e, t);
+      return r === ((n = s.offset) == null ? void 0 : n.placement) && (o = s.arrow) != null && o.alignmentOffset ? {} : {
+        x: i + c.x,
+        y: l + c.y,
+        data: {
+          ...c,
+          placement: r
+        }
+      };
+    }
+  };
+}, _e = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: o,
+        placement: i,
+        platform: l
+      } = e, {
+        mainAxis: r = !0,
+        crossAxis: s = !1,
+        limiter: c = {
+          fn: (h) => {
+            let {
+              x: v,
+              y: x
+            } = h;
+            return {
+              x: v,
+              y: x
+            };
+          }
+        },
+        ...a
+      } = J(t, e), u = {
+        x: n,
+        y: o
+      }, d = await l.detectOverflow(e, a), p = U(I(i)), f = It(p);
+      let m = u[f], g = u[p];
+      if (r) {
+        const h = f === "y" ? "top" : "left", v = f === "y" ? "bottom" : "right", x = m + d[h], b = m - d[v];
+        m = ht(x, m, b);
+      }
+      if (s) {
+        const h = p === "y" ? "top" : "left", v = p === "y" ? "bottom" : "right", x = g + d[h], b = g - d[v];
+        g = ht(x, g, b);
+      }
+      const w = c.fn({
+        ...e,
+        [f]: m,
+        [p]: g
+      });
+      return {
+        ...w,
+        data: {
+          x: w.x - n,
+          y: w.y - o,
+          enabled: {
+            [f]: r,
+            [p]: s
+          }
+        }
+      };
+    }
+  };
+};
+function ut() {
+  return typeof window < "u";
+}
+function Q(t) {
+  return bt(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function L(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function $(t) {
+  var e;
+  return (e = (bt(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function bt(t) {
+  return ut() ? t instanceof Node || t instanceof L(t).Node : !1;
+}
+function F(t) {
+  return ut() ? t instanceof Element || t instanceof L(t).Element : !1;
+}
+function k(t) {
+  return ut() ? t instanceof HTMLElement || t instanceof L(t).HTMLElement : !1;
+}
+function _t(t) {
+  return !ut() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof L(t).ShadowRoot;
+}
+const Be = /* @__PURE__ */ new Set(["inline", "contents"]);
+function rt(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: o,
+    display: i
+  } = M(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && !Be.has(i);
+}
+const ke = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function $e(t) {
+  return ke.has(Q(t));
+}
+const He = [":popover-open", ":modal"];
+function dt(t) {
+  return He.some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+const Ne = ["transform", "translate", "scale", "rotate", "perspective"], We = ["transform", "translate", "scale", "rotate", "perspective", "filter"], Ve = ["paint", "layout", "strict", "content"];
+function Ot(t) {
+  const e = At(), n = F(t) ? M(t) : t;
+  return Ne.some((o) => n[o] ? n[o] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !e && (n.filter ? n.filter !== "none" : !1) || We.some((o) => (n.willChange || "").includes(o)) || Ve.some((o) => (n.contain || "").includes(o));
+}
+function Ie(t) {
+  let e = X(t);
+  for (; k(e) && !nt(e); ) {
+    if (Ot(e))
+      return e;
+    if (dt(e))
+      return null;
+    e = X(e);
+  }
+  return null;
+}
+function At() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+const je = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function nt(t) {
+  return je.has(Q(t));
+}
+function M(t) {
+  return L(t).getComputedStyle(t);
+}
+function mt(t) {
+  return F(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function X(t) {
+  if (Q(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.
+    _t(t) && t.host || // Fallback.
+    $(t)
+  );
+  return _t(e) ? e.host : e;
+}
+function Ut(t) {
+  const e = X(t);
+  return nt(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : k(e) && rt(e) ? e : Ut(e);
+}
+function it(t, e, n) {
+  var o;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const i = Ut(t), l = i === ((o = t.ownerDocument) == null ? void 0 : o.body), r = L(i);
+  if (l) {
+    const s = wt(r);
+    return e.concat(r, r.visualViewport || [], rt(i) ? i : [], s && n ? it(s) : []);
+  }
+  return e.concat(i, it(i, [], n));
+}
+function wt(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+function Xt(t) {
+  const e = M(t);
+  let n = parseFloat(e.width) || 0, o = parseFloat(e.height) || 0;
+  const i = k(t), l = i ? t.offsetWidth : n, r = i ? t.offsetHeight : o, s = st(n) !== l || st(o) !== r;
+  return s && (n = l, o = r), {
+    width: n,
+    height: o,
+    $: s
+  };
+}
+function Tt(t) {
+  return F(t) ? t : t.contextElement;
+}
+function tt(t) {
+  const e = Tt(t);
+  if (!k(e))
+    return _(1);
+  const n = e.getBoundingClientRect(), {
+    width: o,
+    height: i,
+    $: l
+  } = Xt(e);
+  let r = (l ? st(n.width) : n.width) / o, s = (l ? st(n.height) : n.height) / i;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!s || !Number.isFinite(s)) && (s = 1), {
+    x: r,
+    y: s
+  };
+}
+const ze = /* @__PURE__ */ _(0);
+function Yt(t) {
+  const e = L(t);
+  return !At() || !e.visualViewport ? ze : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function Ue(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== L(t) ? !1 : e;
+}
+function K(t, e, n, o) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const i = t.getBoundingClientRect(), l = Tt(t);
+  let r = _(1);
+  e && (o ? F(o) && (r = tt(o)) : r = tt(t));
+  const s = Ue(l, n, o) ? Yt(l) : _(0);
+  let c = (i.left + s.x) / r.x, a = (i.top + s.y) / r.y, u = i.width / r.x, d = i.height / r.y;
+  if (l) {
+    const p = L(l), f = o && F(o) ? L(o) : o;
+    let m = p, g = wt(m);
+    for (; g && o && f !== m; ) {
+      const w = tt(g), h = g.getBoundingClientRect(), v = M(g), x = h.left + (g.clientLeft + parseFloat(v.paddingLeft)) * w.x, b = h.top + (g.clientTop + parseFloat(v.paddingTop)) * w.y;
+      c *= w.x, a *= w.y, u *= w.x, d *= w.y, c += x, a += b, m = L(g), g = wt(m);
+    }
+  }
+  return ft({
+    width: u,
+    height: d,
+    x: c,
+    y: a
+  });
+}
+function pt(t, e) {
+  const n = mt(t).scrollLeft;
+  return e ? e.left + n : K($(t)).left + n;
+}
+function qt(t, e) {
+  const n = t.getBoundingClientRect(), o = n.left + e.scrollLeft - pt(t, n), i = n.top + e.scrollTop;
+  return {
+    x: o,
+    y: i
+  };
+}
+function Xe(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: o,
+    strategy: i
+  } = t;
+  const l = i === "fixed", r = $(o), s = e ? dt(e.floating) : !1;
+  if (o === r || s && l)
+    return n;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, a = _(1);
+  const u = _(0), d = k(o);
+  if ((d || !d && !l) && ((Q(o) !== "body" || rt(r)) && (c = mt(o)), k(o))) {
+    const f = K(o);
+    a = tt(o), u.x = f.x + o.clientLeft, u.y = f.y + o.clientTop;
+  }
+  const p = r && !d && !l ? qt(r, c) : _(0);
+  return {
+    width: n.width * a.x,
+    height: n.height * a.y,
+    x: n.x * a.x - c.scrollLeft * a.x + u.x + p.x,
+    y: n.y * a.y - c.scrollTop * a.y + u.y + p.y
+  };
+}
+function Ye(t) {
+  return Array.from(t.getClientRects());
+}
+function qe(t) {
+  const e = $(t), n = mt(t), o = t.ownerDocument.body, i = G(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth), l = G(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
+  let r = -n.scrollLeft + pt(t);
+  const s = -n.scrollTop;
+  return M(o).direction === "rtl" && (r += G(e.clientWidth, o.clientWidth) - i), {
+    width: i,
+    height: l,
+    x: r,
+    y: s
+  };
+}
+const Bt = 25;
+function Ge(t, e) {
+  const n = L(t), o = $(t), i = n.visualViewport;
+  let l = o.clientWidth, r = o.clientHeight, s = 0, c = 0;
+  if (i) {
+    l = i.width, r = i.height;
+    const u = At();
+    (!u || u && e === "fixed") && (s = i.offsetLeft, c = i.offsetTop);
+  }
+  const a = pt(o);
+  if (a <= 0) {
+    const u = o.ownerDocument, d = u.body, p = getComputedStyle(d), f = u.compatMode === "CSS1Compat" && parseFloat(p.marginLeft) + parseFloat(p.marginRight) || 0, m = Math.abs(o.clientWidth - d.clientWidth - f);
+    m <= Bt && (l -= m);
+  } else a <= Bt && (l += a);
+  return {
+    width: l,
+    height: r,
+    x: s,
+    y: c
+  };
+}
+const Ke = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function Je(t, e) {
+  const n = K(t, !0, e === "fixed"), o = n.top + t.clientTop, i = n.left + t.clientLeft, l = k(t) ? tt(t) : _(1), r = t.clientWidth * l.x, s = t.clientHeight * l.y, c = i * l.x, a = o * l.y;
+  return {
+    width: r,
+    height: s,
+    x: c,
+    y: a
+  };
+}
+function kt(t, e, n) {
+  let o;
+  if (e === "viewport")
+    o = Ge(t, n);
+  else if (e === "document")
+    o = qe($(t));
+  else if (F(e))
+    o = Je(e, n);
+  else {
+    const i = Yt(t);
+    o = {
+      x: e.x - i.x,
+      y: e.y - i.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return ft(o);
+}
+function Gt(t, e) {
+  const n = X(t);
+  return n === e || !F(n) || nt(n) ? !1 : M(n).position === "fixed" || Gt(n, e);
+}
+function Qe(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let o = it(t, [], !1).filter((s) => F(s) && Q(s) !== "body"), i = null;
+  const l = M(t).position === "fixed";
+  let r = l ? X(t) : t;
+  for (; F(r) && !nt(r); ) {
+    const s = M(r), c = Ot(r);
+    !c && s.position === "fixed" && (i = null), (l ? !c && !i : !c && s.position === "static" && !!i && Ke.has(i.position) || rt(r) && !c && Gt(t, r)) ? o = o.filter((u) => u !== r) : i = s, r = X(r);
+  }
+  return e.set(t, o), o;
+}
+function Ze(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: o,
+    strategy: i
+  } = t;
+  const r = [...n === "clippingAncestors" ? dt(e) ? [] : Qe(e, this._c) : [].concat(n), o], s = r[0], c = r.reduce((a, u) => {
+    const d = kt(e, u, i);
+    return a.top = G(d.top, a.top), a.right = et(d.right, a.right), a.bottom = et(d.bottom, a.bottom), a.left = G(d.left, a.left), a;
+  }, kt(e, s, i));
+  return {
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
+  };
+}
+function tn(t) {
+  const {
+    width: e,
+    height: n
+  } = Xt(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function en(t, e, n) {
+  const o = k(e), i = $(e), l = n === "fixed", r = K(t, !0, l, e);
+  let s = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = _(0);
+  function a() {
+    c.x = pt(i);
+  }
+  if (o || !o && !l)
+    if ((Q(e) !== "body" || rt(i)) && (s = mt(e)), o) {
+      const f = K(e, !0, l, e);
+      c.x = f.x + e.clientLeft, c.y = f.y + e.clientTop;
+    } else i && a();
+  l && !o && i && a();
+  const u = i && !o && !l ? qt(i, s) : _(0), d = r.left + s.scrollLeft - c.x - u.x, p = r.top + s.scrollTop - c.y - u.y;
+  return {
+    x: d,
+    y: p,
+    width: r.width,
+    height: r.height
+  };
+}
+function gt(t) {
+  return M(t).position === "static";
+}
+function $t(t, e) {
+  if (!k(t) || M(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let n = t.offsetParent;
+  return $(t) === n && (n = n.ownerDocument.body), n;
+}
+function Kt(t, e) {
+  const n = L(t);
+  if (dt(t))
+    return n;
+  if (!k(t)) {
+    let i = X(t);
+    for (; i && !nt(i); ) {
+      if (F(i) && !gt(i))
+        return i;
+      i = X(i);
+    }
+    return n;
+  }
+  let o = $t(t, e);
+  for (; o && $e(o) && gt(o); )
+    o = $t(o, e);
+  return o && nt(o) && gt(o) && !Ot(o) ? n : o || Ie(t) || n;
+}
+const nn = async function(t) {
+  const e = this.getOffsetParent || Kt, n = this.getDimensions, o = await n(t.floating);
+  return {
+    reference: en(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function on(t) {
+  return M(t).direction === "rtl";
+}
+const rn = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Xe,
+  getDocumentElement: $,
+  getClippingRect: Ze,
+  getOffsetParent: Kt,
+  getElementRects: nn,
+  getClientRects: Ye,
+  getDimensions: tn,
+  getScale: tt,
+  isElement: F,
+  isRTL: on
+};
+function Jt(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function ln(t, e) {
+  let n = null, o;
+  const i = $(t);
+  function l() {
+    var s;
+    clearTimeout(o), (s = n) == null || s.disconnect(), n = null;
+  }
+  function r(s, c) {
+    s === void 0 && (s = !1), c === void 0 && (c = 1), l();
+    const a = t.getBoundingClientRect(), {
+      left: u,
+      top: d,
+      width: p,
+      height: f
+    } = a;
+    if (s || e(), !p || !f)
+      return;
+    const m = lt(d), g = lt(i.clientWidth - (u + p)), w = lt(i.clientHeight - (d + f)), h = lt(u), x = {
+      rootMargin: -m + "px " + -g + "px " + -w + "px " + -h + "px",
+      threshold: G(0, et(1, c)) || 1
+    };
+    let b = !0;
+    function O(A) {
+      const y = A[0].intersectionRatio;
+      if (y !== c) {
+        if (!b)
+          return r();
+        y ? r(!1, y) : o = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 1e3);
+      }
+      y === 1 && !Jt(a, t.getBoundingClientRect()) && r(), b = !1;
+    }
+    try {
+      n = new IntersectionObserver(O, {
+        ...x,
+        // Handle <iframe>s
+        root: i.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(O, x);
+    }
+    n.observe(t);
+  }
+  return r(!0), l;
+}
+function Ht(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: c = !1
+  } = o, a = Tt(t), u = i || l ? [...a ? it(a) : [], ...it(e)] : [];
+  u.forEach((h) => {
+    i && h.addEventListener("scroll", n, {
+      passive: !0
+    }), l && h.addEventListener("resize", n);
+  });
+  const d = a && s ? ln(a, n) : null;
+  let p = -1, f = null;
+  r && (f = new ResizeObserver((h) => {
+    let [v] = h;
+    v && v.target === a && f && (f.unobserve(e), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
+      var x;
+      (x = f) == null || x.observe(e);
+    })), n();
+  }), a && !c && f.observe(a), f.observe(e));
+  let m, g = c ? K(t) : null;
+  c && w();
+  function w() {
+    const h = K(t);
+    g && !Jt(g, h) && 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, c && cancelAnimationFrame(m);
+  };
+}
+const sn = Me, cn = Le, an = _e, fn = Ce, Tn = De, un = Se, dn = (t, e, n) => {
+  const o = /* @__PURE__ */ new Map(), i = {
+    platform: rn,
+    ...n
+  }, l = {
+    ...i.platform,
+    _c: o
+  };
+  return Re(t, e, {
+    ...i,
+    platform: l
+  });
+};
+function mn(t) {
+  return t != null && typeof t == "object" && "$el" in t;
+}
+function vt(t) {
+  if (mn(t)) {
+    const e = t.$el;
+    return bt(e) && Q(e) === "#comment" ? null : e;
+  }
+  return t;
+}
+function pn(t) {
+  return {
+    name: "arrow",
+    options: t,
+    fn(e) {
+      const n = vt(V(t.element));
+      return n == null ? {} : un({
+        element: n,
+        padding: t.padding
+      }).fn(e);
+    }
+  };
+}
+function Qt(t) {
+  return typeof window > "u" ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function Nt(t, e) {
+  const n = Qt(t);
+  return Math.round(e * n) / n;
+}
+function gn(t, e, n) {
+  n === void 0 && (n = {});
+  const o = n.whileElementsMounted, i = S(() => {
+    var y;
+    return (y = V(n.open)) != null ? y : !0;
+  }), l = S(() => V(n.middleware)), r = S(() => {
+    var y;
+    return (y = V(n.placement)) != null ? y : "bottom";
+  }), s = S(() => {
+    var y;
+    return (y = V(n.strategy)) != null ? y : "absolute";
+  }), c = S(() => {
+    var y;
+    return (y = V(n.transform)) != null ? y : !0;
+  }), a = S(() => vt(t.value)), u = S(() => vt(e.value)), d = z(0), p = z(0), f = z(s.value), m = z(r.value), g = oe({}), w = z(!1), h = S(() => {
+    const y = {
+      position: f.value,
+      left: "0",
+      top: "0"
+    };
+    if (!u.value)
+      return y;
+    const H = Nt(u.value, d.value), E = Nt(u.value, p.value);
+    return c.value ? {
+      ...y,
+      transform: "translate(" + H + "px, " + E + "px)",
+      ...Qt(u.value) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: f.value,
+      left: H + "px",
+      top: E + "px"
+    };
+  });
+  let v;
+  function x() {
+    a.value == null || u.value == null || dn(a.value, u.value, {
+      middleware: l.value,
+      placement: r.value,
+      strategy: s.value
+    }).then((y) => {
+      d.value = y.x, p.value = y.y, f.value = y.strategy, m.value = y.placement, g.value = y.middlewareData, w.value = !0;
+    });
+  }
+  function b() {
+    typeof v == "function" && (v(), v = void 0);
+  }
+  function O() {
+    if (b(), o === void 0) {
+      x();
+      return;
+    }
+    if (a.value != null && u.value != null) {
+      v = o(a.value, u.value, x);
+      return;
+    }
+  }
+  function A() {
+    i.value || (w.value = !1);
+  }
+  return ot([l, r, s], x, {
+    flush: "sync"
+  }), ot([a, u], O, {
+    flush: "sync"
+  }), ot(i, A, {
+    flush: "sync"
+  }), ie() && re(b), {
+    x: Z(d),
+    y: Z(p),
+    strategy: Z(f),
+    placement: Z(m),
+    middlewareData: Z(g),
+    isPositioned: Z(w),
+    floatingStyles: h,
+    update: x
+  };
+}
+var Zt = /* @__PURE__ */ ((t) => (t.TOP = "top", t.RIGHT = "right", t.BOTTOM = "bottom", t.LEFT = "left", t))(Zt || {}), te = /* @__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))(te || {}), ee = /* @__PURE__ */ ((t) => (t.TOOLTIP = "tooltip", t.POPOVER = "dialog", t))(ee || {});
+const Wt = { ...Zt, ...te }, hn = (t, e) => t ? e[1] + 7 : e[1], wn = (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
+  };
+}, vn = {
+  name: "sameWidth",
+  fn: ({ elements: t }) => (t.floating.style.width = `${t.reference.offsetWidth}px`, {})
+}, yn = {}, xn = /* @__PURE__ */ le({
+  ...yn,
+  __name: "popper-container",
+  props: {
+    /**
+     * The aria role assigned to the container. Defaults to null, which means it's not set if nothing is passed.
+     */
+    ariaRole: {
+      type: String,
+      default: null,
+      validator: (t) => Object.values(ee).includes(t)
+    },
+    /**
+     * 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, @see {@link https://floating-ui.com/docs/arrow#padding}
+     */
+    arrow: { type: Object, default: void 0 },
+    /**
+     * Disables wrapping focus-trap component.
+     * Mostly useful for the storybook demo.
+     */
+    disabledFocusTrap: { type: Boolean, default: !1 },
+    /**
+     * 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.
+     * @see {@link https://floating-ui.com/docs/flip#fallbackplacements}
+     */
+    fallbackPosition: {
+      type: [Array, String],
+      default: null
+    },
+    /**
+     * 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}
+     */
+    fixedPositioning: { type: Boolean, default: !1 },
+    /**
+     * The id to be set on the component. Use it for accessibility purposes.
+     */
+    id: { type: String, default: null },
+    /**
+     * 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.
+     */
+    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
+    },
+    /**
+     * Position relative to the target element
+     * @see {@link https://floating-ui.com/docs/computeposition#placement}
+     */
+    position: {
+      type: String,
+      default: Wt.AUTO,
+      validator: (t) => Object.values(Wt).includes(t)
+    },
+    /**
+     * Reference to the DOM element or Vue component for positioning
+     */
+    targetElement: { type: [Element, Object], required: !0 },
+    /**
+     * Activates focus trap for both arrow and tab keys.
+     */
+    trapAll: { type: Boolean, default: !1 },
+    /**
+     * Configurations for the focus-trap when trap-all is active.
+     */
+    trapAllOptions: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["placement"],
+  setup(t, { emit: e }) {
+    var b;
+    const n = t, o = e, { position: i } = se(n), l = z(), r = z(null), s = z(n.position), c = S(
+      () => n.targetElement.$el ? n.targetElement.$el : n.targetElement
+    ), a = S(
+      () => l.value.$el ? l.value.$el : l.value
+    ), u = S(() => (n == null ? void 0 : n.position) !== "auto" && (n == null ? void 0 : n.fallbackPosition) !== "auto"), d = S(() => {
+      switch (n.position) {
+        case "auto-start":
+          return { alignment: "start", crossAxis: !0 };
+        case "auto-end":
+          return { alignment: "end", crossAxis: !0 };
+        default:
+          return;
+      }
+    }), p = S(() => n.fixedPositioning ? "fixed" : "absolute"), { floatingStyles: f, middlewareData: m, placement: g, update: w } = gn(c, l, {
+      placement: i,
+      middleware: [
+        // Adds flip modifier if fallbackPosition is not set to auto
+        ...u.value ? [
+          fn({
+            fallbackPlacements: wn(n.fallbackPosition).fallbackPlacements
+          })
+        ] : [],
+        // Adds autoposition middlelare if position is set to any auto variants
+        ...u.value ? [] : [cn(d.value)],
+        // Add shifting middle in case popper is still not fully visible in view port
+        an(),
+        // Adds offset middlelare if offset property is set
+        ...n.offset ? [sn(hn(n.arrow, n.offset))] : [],
+        // Adds arrow middlelare if arrow property is set, can set additional padding property
+        ...n.arrow ? [pn({ element: r, padding: n.arrow.padding || 0 })] : [],
+        // Adds same width middleware to keep popper width same as referenced element's width
+        ...n.matchWidth ? [vn] : [],
+        // If there is additional custom middleware to add via the property then add it
+        ...((b = n.middleware) == null ? void 0 : b.length) > 0 ? n.middleware : []
+      ],
+      strategy: p,
+      // 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: Ht } : []
+    });
+    let h;
+    ot(
+      () => n.isHidden,
+      () => {
+        n.isHidden !== null && !n.isHidden ? h = Ht(c == null ? void 0 : c.value, a == null ? void 0 : a.value, w) : n.isHidden !== null && n.isHidden && typeof h == "function" && h();
+      }
+    ), ot(
+      () => g.value,
+      () => {
+        s.value !== g.value && (s.value = g.value, o("placement", s.value));
+      }
+    );
+    const v = S(() => {
+      var O, A;
+      return {
+        position: "absolute",
+        left: ((O = m.value.arrow) == null ? void 0 : O.x) != null ? `${m.value.arrow.x}px` : "",
+        top: ((A = m.value.arrow) == null ? void 0 : A.y) != null ? `${m.value.arrow.y}px` : ""
+      };
+    }), x = S(() => {
+      var O;
+      return {
+        class: n.arrow.classes,
+        style: v.value,
+        // Applies a data-hide attribute to arrow element depending on center offset.
+        ...((O = m.value.arrow) == null ? void 0 : O.centerOffset) !== 0 ? { "data-hide": "" } : {}
+      };
+    });
+    return (O, A) => (Rt(), ce(V(me), St(O.$attrs, {
+      id: t.id,
+      ref_key: "popperContainerRef",
+      ref: l,
+      class: "b-popper-container",
+      "data-popper-placement": V(g),
+      disabled: t.disabledFocusTrap,
+      style: V(f),
+      role: t.ariaRole,
+      "trap-all": t.trapAll,
+      "trap-all-options": t.trapAllOptions
+    }), {
+      default: ae(() => [
+        fe(O.$slots, "default", {}, void 0, !0),
+        n.arrow ? (Rt(), ue("span", St({ key: 0 }, x.value, {
+          ref_key: "floatingArrow",
+          ref: r,
+          class: "b-popper-container__arrow",
+          "data-testid": "arrow"
+        }), null, 16)) : de("", !0)
+      ]),
+      _: 3
+    }, 16, ["id", "data-popper-placement", "disabled", "style", "role", "trap-all", "trap-all-options"]));
+  }
+}), Rn = /* @__PURE__ */ pe(xn, [["__scopeId", "data-v-78f222b8"]]);
+export {
+  Rn as P,
+  ee as a,
+  Wt as b,
+  Zt as c,
+  te as d,
+  Tn as h,
+  sn as o
+};
+//# sourceMappingURL=popper-container.BefZxTzP.js.map