@adyen/bento-vue2 1.84.2 → 1.86.0

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

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