@beeq/core 1.8.0-beta.3 → 1.8.0-beta.4

package/dist/beeq/p-c78ae3c2.js

@@ -0,0 +1,1983 @@
+/*!
+ * Built by Endavans
+ * © https://beeq.design - Apache 2 License.
+ */
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+const t = [ "top", "right", "bottom", "left" ];
+
+const e = [ "start", "end" ];
+
+const n =  t.reduce(((t, n) => t.concat(n, n + "-" + e[0], n + "-" + e[1])), []);
+
+const o = Math.min;
+
+const i = Math.max;
+
+const s = Math.round;
+
+const r = Math.floor;
+
+const createCoords = t => ({
+  x: t,
+  y: t
+});
+
+const c = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+
+const l = {
+  start: "end",
+  end: "start"
+};
+
+function clamp(t, e, n) {
+  return i(t, o(e, n));
+}
+
+function evaluate(t, e) {
+  return typeof t === "function" ? t(e) : t;
+}
+
+function getSide(t) {
+  return t.split("-")[0];
+}
+
+function getAlignment(t) {
+  return t.split("-")[1];
+}
+
+function getOppositeAxis(t) {
+  return t === "x" ? "y" : "x";
+}
+
+function getAxisLength(t) {
+  return t === "y" ? "height" : "width";
+}
+
+function getSideAxis(t) {
+  return [ "top", "bottom" ].includes(getSide(t)) ? "y" : "x";
+}
+
+function getAlignmentAxis(t) {
+  return getOppositeAxis(getSideAxis(t));
+}
+
+function getAlignmentSides(t, e, n) {
+  if (n === void 0) {
+    n = false;
+  }
+  const o = getAlignment(t);
+  const i = getAlignmentAxis(t);
+  const s = getAxisLength(i);
+  let r = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  if (e.reference[s] > e.floating[s]) {
+    r = getOppositePlacement(r);
+  }
+  return [ r, getOppositePlacement(r) ];
+}
+
+function getExpandedPlacements(t) {
+  const e = getOppositePlacement(t);
+  return [ getOppositeAlignmentPlacement(t), e, getOppositeAlignmentPlacement(e) ];
+}
+
+function getOppositeAlignmentPlacement(t) {
+  return t.replace(/start|end/g, (t => l[t]));
+}
+
+function getSideList(t, e, n) {
+  const o = [ "left", "right" ];
+  const i = [ "right", "left" ];
+  const s = [ "top", "bottom" ];
+  const r = [ "bottom", "top" ];
+  switch (t) {
+   case "top":
+   case "bottom":
+    if (n) return e ? i : o;
+    return e ? o : i;
+
+   case "left":
+   case "right":
+    return e ? s : r;
+
+   default:
+    return [];
+  }
+}
+
+function getOppositeAxisPlacements(t, e, n, o) {
+  const i = getAlignment(t);
+  let s = getSideList(getSide(t), n === "start", o);
+  if (i) {
+    s = s.map((t => t + "-" + i));
+    if (e) {
+      s = s.concat(s.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return s;
+}
+
+function getOppositePlacement(t) {
+  return t.replace(/left|right|bottom|top/g, (t => c[t]));
+}
+
+function expandPaddingObject(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+
+function getPaddingObject(t) {
+  return typeof t !== "number" ? expandPaddingObject(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+
+function rectToClientRect(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 computeCoordsFromPlacement(t, e, n) {
+  let {reference: o, floating: i} = t;
+  const s = getSideAxis(e);
+  const r = getAlignmentAxis(e);
+  const c = getAxisLength(r);
+  const l = getSide(e);
+  const a = s === "y";
+  const f = o.x + o.width / 2 - i.width / 2;
+  const u = o.y + o.height / 2 - i.height / 2;
+  const g = o[c] / 2 - i[c] / 2;
+  let d;
+  switch (l) {
+   case "top":
+    d = {
+      x: f,
+      y: o.y - i.height
+    };
+    break;
+
+   case "bottom":
+    d = {
+      x: f,
+      y: o.y + o.height
+    };
+    break;
+
+   case "right":
+    d = {
+      x: o.x + o.width,
+      y: u
+    };
+    break;
+
+   case "left":
+    d = {
+      x: o.x - i.width,
+      y: u
+    };
+    break;
+
+   default:
+    d = {
+      x: o.x,
+      y: o.y
+    };
+  }
+  switch (getAlignment(e)) {
+   case "start":
+    d[r] -= g * (n && a ? -1 : 1);
+    break;
+
+   case "end":
+    d[r] += g * (n && a ? -1 : 1);
+    break;
+  }
+  return d;
+}
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ *
+ * This export does not have any `platform` interface logic. You will need to
+ * write one for the platform you are using Floating UI with.
+ */ const computePosition$1 = async (t, e, n) => {
+  const {placement: o = "bottom", strategy: i = "absolute", middleware: s = [], platform: r} = n;
+  const c = s.filter(Boolean);
+  const l = await (r.isRTL == null ? void 0 : r.isRTL(e));
+  let a = await r.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  });
+  let {x: f, y: u} = computeCoordsFromPlacement(a, o, l);
+  let g = o;
+  let d = {};
+  let m = 0;
+  for (let n = 0; n < c.length; n++) {
+    const {name: s, fn: p} = c[n];
+    const {x: h, y: w, data: y, reset: v} = await p({
+      x: f,
+      y: u,
+      initialPlacement: o,
+      placement: g,
+      strategy: i,
+      middlewareData: d,
+      rects: a,
+      platform: r,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    f = h != null ? h : f;
+    u = w != null ? w : u;
+    d = {
+      ...d,
+      [s]: {
+        ...d[s],
+        ...y
+      }
+    };
+    if (v && m <= 50) {
+      m++;
+      if (typeof v === "object") {
+        if (v.placement) {
+          g = v.placement;
+        }
+        if (v.rects) {
+          a = v.rects === true ? await r.getElementRects({
+            reference: t,
+            floating: e,
+            strategy: i
+          }) : v.rects;
+        }
+        ({x: f, y: u} = computeCoordsFromPlacement(a, g, l));
+      }
+      n = -1;
+    }
+  }
+  return {
+    x: f,
+    y: u,
+    placement: g,
+    strategy: i,
+    middlewareData: d
+  };
+};
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */ async function detectOverflow(t, e) {
+  var n;
+  if (e === void 0) {
+    e = {};
+  }
+  const {x: o, y: i, platform: s, rects: r, elements: c, strategy: l} = t;
+  const {boundary: a = "clippingAncestors", rootBoundary: f = "viewport", elementContext: u = "floating", altBoundary: g = false, padding: d = 0} = evaluate(e, t);
+  const m = getPaddingObject(d);
+  const p = u === "floating" ? "reference" : "floating";
+  const h = c[g ? p : u];
+  const w = rectToClientRect(await s.getClippingRect({
+    element: ((n = await (s.isElement == null ? void 0 : s.isElement(h))) != null ? n : true) ? h : h.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(c.floating)),
+    boundary: a,
+    rootBoundary: f,
+    strategy: l
+  }));
+  const y = u === "floating" ? {
+    x: o,
+    y: i,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference;
+  const v = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(c.floating));
+  const x = await (s.isElement == null ? void 0 : s.isElement(v)) ? await (s.getScale == null ? void 0 : s.getScale(v)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  };
+  const A = rectToClientRect(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: y,
+    offsetParent: v,
+    strategy: l
+  }) : y);
+  return {
+    top: (w.top - A.top + m.top) / x.y,
+    bottom: (A.bottom - w.bottom + m.bottom) / x.y,
+    left: (w.left - A.left + m.left) / x.x,
+    right: (A.right - w.right + m.right) / x.x
+  };
+}
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */ const arrow$1 = t => ({
+  name: "arrow",
+  options: t,
+  async fn(e) {
+    const {x: n, y: i, placement: s, rects: r, platform: c, elements: l, middlewareData: a} = e;
+    // Since `element` is required, we don't Partial<> the type.
+        const {element: f, padding: u = 0} = evaluate(t, e) || {};
+    if (f == null) {
+      return {};
+    }
+    const g = getPaddingObject(u);
+    const d = {
+      x: n,
+      y: i
+    };
+    const m = getAlignmentAxis(s);
+    const p = getAxisLength(m);
+    const h = await c.getDimensions(f);
+    const w = m === "y";
+    const y = w ? "top" : "left";
+    const v = w ? "bottom" : "right";
+    const x = w ? "clientHeight" : "clientWidth";
+    const A = r.reference[p] + r.reference[m] - d[m] - r.floating[p];
+    const b = d[m] - r.reference[m];
+    const S = await (c.getOffsetParent == null ? void 0 : c.getOffsetParent(f));
+    let O = S ? S[x] : 0;
+    // DOM platform can return `window` as the `offsetParent`.
+        if (!O || !await (c.isElement == null ? void 0 : c.isElement(S))) {
+      O = l.floating[x] || r.floating[p];
+    }
+    const C = A / 2 - b / 2;
+    // If the padding is large enough that it causes the arrow to no longer be
+    // centered, modify the padding so that it is centered.
+        const R = O / 2 - h[p] / 2 - 1;
+    const P = o(g[y], R);
+    const E = o(g[v], R);
+    // Make sure the arrow doesn't overflow the floating element if the center
+    // point is outside the floating element's bounds.
+        const T = P;
+    const L = O - h[p] - E;
+    const N = O / 2 - h[p] / 2 + C;
+    const B = clamp(T, N, L);
+    // If the reference is small enough that the arrow's padding causes it to
+    // to point to nothing for an aligned placement, adjust the offset of the
+    // floating element itself. To ensure `shift()` continues to take action,
+    // a single reset is performed when this is true.
+        const D = !a.arrow && getAlignment(s) != null && N !== B && r.reference[p] / 2 - (N < T ? P : E) - h[p] / 2 < 0;
+    const W = D ? N < T ? N - T : N - L : 0;
+    return {
+      [m]: d[m] + W,
+      data: {
+        [m]: B,
+        centerOffset: N - B - W,
+        ...D && {
+          alignmentOffset: W
+        }
+      },
+      reset: D
+    };
+  }
+});
+
+function getPlacementList(t, e, n) {
+  const o = t ? [ ...n.filter((e => getAlignment(e) === t)), ...n.filter((e => getAlignment(e) !== t)) ] : n.filter((t => getSide(t) === t));
+  return o.filter((n => {
+    if (t) {
+      return getAlignment(n) === t || (e ? getOppositeAlignmentPlacement(n) !== n : false);
+    }
+    return true;
+  }));
+}
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */ const autoPlacement = function(t) {
+  if (t === void 0) {
+    t = {};
+  }
+  return {
+    name: "autoPlacement",
+    options: t,
+    async fn(e) {
+      var o, i, s;
+      const {rects: r, middlewareData: c, placement: l, platform: a, elements: f} = e;
+      const {crossAxis: u = false, alignment: g, allowedPlacements: d = n, autoAlignment: m = true, ...p} = evaluate(t, e);
+      const h = g !== undefined || d === n ? getPlacementList(g || null, m, d) : d;
+      const w = await detectOverflow(e, p);
+      const y = ((o = c.autoPlacement) == null ? void 0 : o.index) || 0;
+      const v = h[y];
+      if (v == null) {
+        return {};
+      }
+      const x = getAlignmentSides(v, r, await (a.isRTL == null ? void 0 : a.isRTL(f.floating)));
+      // Make `computeCoords` start from the right place.
+            if (l !== v) {
+        return {
+          reset: {
+            placement: h[0]
+          }
+        };
+      }
+      const A = [ w[getSide(v)], w[x[0]], w[x[1]] ];
+      const b = [ ...((i = c.autoPlacement) == null ? void 0 : i.overflows) || [], {
+        placement: v,
+        overflows: A
+      } ];
+      const S = h[y + 1];
+      // There are more placements to check.
+            if (S) {
+        return {
+          data: {
+            index: y + 1,
+            overflows: b
+          },
+          reset: {
+            placement: S
+          }
+        };
+      }
+      const O = b.map((t => {
+        const e = getAlignment(t.placement);
+        return [ t.placement, e && u ? 
+        // Check along the mainAxis and main crossAxis side.
+        t.overflows.slice(0, 2).reduce(((t, e) => t + e), 0) : 
+        // Check only the mainAxis.
+        t.overflows[0], t.overflows ];
+      })).sort(((t, e) => t[1] - e[1]));
+      const C = O.filter((t => t[2].slice(0, 
+      // Aligned placements should not check their opposite crossAxis
+      // side.
+      getAlignment(t[0]) ? 2 : 3).every((t => t <= 0))));
+      const R = ((s = C[0]) == null ? void 0 : s[0]) || O[0][0];
+      if (R !== l) {
+        return {
+          data: {
+            index: y + 1,
+            overflows: b
+          },
+          reset: {
+            placement: R
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */ const flip$1 = function(t) {
+  if (t === void 0) {
+    t = {};
+  }
+  return {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var n, o;
+      const {placement: i, middlewareData: s, rects: r, initialPlacement: c, platform: l, elements: a} = e;
+      const {mainAxis: f = true, crossAxis: u = true, fallbackPlacements: g, fallbackStrategy: d = "bestFit", fallbackAxisSideDirection: m = "none", flipAlignment: p = true, ...h} = evaluate(t, e);
+      // If a reset by the arrow was caused due to an alignment offset being
+      // added, we should skip any logic now since `flip()` has already done its
+      // work.
+      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
+            if ((n = s.arrow) != null && n.alignmentOffset) {
+        return {};
+      }
+      const w = getSide(i);
+      const y = getSideAxis(c);
+      const v = getSide(c) === c;
+      const x = await (l.isRTL == null ? void 0 : l.isRTL(a.floating));
+      const A = g || (v || !p ? [ getOppositePlacement(c) ] : getExpandedPlacements(c));
+      const b = m !== "none";
+      if (!g && b) {
+        A.push(...getOppositeAxisPlacements(c, p, m, x));
+      }
+      const S = [ c, ...A ];
+      const O = await detectOverflow(e, h);
+      const C = [];
+      let R = ((o = s.flip) == null ? void 0 : o.overflows) || [];
+      if (f) {
+        C.push(O[w]);
+      }
+      if (u) {
+        const t = getAlignmentSides(i, r, x);
+        C.push(O[t[0]], O[t[1]]);
+      }
+      R = [ ...R, {
+        placement: i,
+        overflows: C
+      } ];
+      // One or more sides is overflowing.
+            if (!C.every((t => t <= 0))) {
+        var P, E;
+        const t = (((P = s.flip) == null ? void 0 : P.index) || 0) + 1;
+        const e = S[t];
+        if (e) {
+          // Try next placement and re-run the lifecycle.
+          return {
+            data: {
+              index: t,
+              overflows: R
+            },
+            reset: {
+              placement: e
+            }
+          };
+        }
+        // First, find the candidates that fit on the mainAxis side of overflow,
+        // then find the placement that fits the best on the main crossAxis side.
+                let n = (E = R.filter((t => t.overflows[0] <= 0)).sort(((t, e) => t.overflows[1] - e.overflows[1]))[0]) == null ? void 0 : E.placement;
+        // Otherwise fallback.
+                if (!n) {
+          switch (d) {
+           case "bestFit":
+            {
+              var T;
+              const t = (T = R.filter((t => {
+                if (b) {
+                  const e = getSideAxis(t.placement);
+                  return e === y || 
+                  // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  e === "y";
+                }
+                return true;
+              })).map((t => [ t.placement, t.overflows.filter((t => t > 0)).reduce(((t, e) => t + e), 0) ])).sort(((t, e) => t[1] - e[1]))[0]) == null ? void 0 : T[0];
+              if (t) {
+                n = t;
+              }
+              break;
+            }
+
+           case "initialPlacement":
+            n = c;
+            break;
+          }
+        }
+        if (i !== n) {
+          return {
+            reset: {
+              placement: n
+            }
+          };
+        }
+      }
+      return {};
+    }
+  };
+};
+
+function getSideOffsets(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+
+function isAnySideFullyClipped(e) {
+  return t.some((t => e[t] >= 0));
+}
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */ const hide$1 = function(t) {
+  if (t === void 0) {
+    t = {};
+  }
+  return {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const {rects: n} = e;
+      const {strategy: o = "referenceHidden", ...i} = evaluate(t, e);
+      switch (o) {
+       case "referenceHidden":
+        {
+          const t = await detectOverflow(e, {
+            ...i,
+            elementContext: "reference"
+          });
+          const o = getSideOffsets(t, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: o,
+              referenceHidden: isAnySideFullyClipped(o)
+            }
+          };
+        }
+
+       case "escaped":
+        {
+          const t = await detectOverflow(e, {
+            ...i,
+            altBoundary: true
+          });
+          const o = getSideOffsets(t, n.floating);
+          return {
+            data: {
+              escapedOffsets: o,
+              escaped: isAnySideFullyClipped(o)
+            }
+          };
+        }
+
+       default:
+        {
+          return {};
+        }
+      }
+    }
+  };
+};
+
+function getBoundingRect(t) {
+  const e = o(...t.map((t => t.left)));
+  const n = o(...t.map((t => t.top)));
+  const s = i(...t.map((t => t.right)));
+  const r = i(...t.map((t => t.bottom)));
+  return {
+    x: e,
+    y: n,
+    width: s - e,
+    height: r - n
+  };
+}
+
+function getRectsByLine(t) {
+  const e = t.slice().sort(((t, e) => t.y - e.y));
+  const n = [];
+  let o = null;
+  for (let t = 0; t < e.length; t++) {
+    const i = e[t];
+    if (!o || i.y - o.y > o.height / 2) {
+      n.push([ i ]);
+    } else {
+      n[n.length - 1].push(i);
+    }
+    o = i;
+  }
+  return n.map((t => rectToClientRect(getBoundingRect(t))));
+}
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */ const inline = function(t) {
+  if (t === void 0) {
+    t = {};
+  }
+  return {
+    name: "inline",
+    options: t,
+    async fn(e) {
+      const {placement: n, elements: s, rects: r, platform: c, strategy: l} = e;
+      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
+      // ClientRect's bounds, despite the event listener being triggered. A
+      // padding of 2 seems to handle this issue.
+            const {padding: a = 2, x: f, y: u} = evaluate(t, e);
+      const g = Array.from(await (c.getClientRects == null ? void 0 : c.getClientRects(s.reference)) || []);
+      const d = getRectsByLine(g);
+      const m = rectToClientRect(getBoundingRect(g));
+      const p = getPaddingObject(a);
+      function getBoundingClientRect() {
+        // There are two rects and they are disjoined.
+        if (d.length === 2 && d[0].left > d[1].right && f != null && u != null) {
+          // Find the first rect in which the point is fully inside.
+          return d.find((t => f > t.left - p.left && f < t.right + p.right && u > t.top - p.top && u < t.bottom + p.bottom)) || m;
+        }
+        // There are 2 or more connected rects.
+                if (d.length >= 2) {
+          if (getSideAxis(n) === "y") {
+            const t = d[0];
+            const e = d[d.length - 1];
+            const o = getSide(n) === "top";
+            const i = t.top;
+            const s = e.bottom;
+            const r = o ? t.left : e.left;
+            const c = o ? t.right : e.right;
+            const l = c - r;
+            const a = s - i;
+            return {
+              top: i,
+              bottom: s,
+              left: r,
+              right: c,
+              width: l,
+              height: a,
+              x: r,
+              y: i
+            };
+          }
+          const t = getSide(n) === "left";
+          const e = i(...d.map((t => t.right)));
+          const s = o(...d.map((t => t.left)));
+          const r = d.filter((n => t ? n.left === s : n.right === e));
+          const c = r[0].top;
+          const l = r[r.length - 1].bottom;
+          const a = s;
+          const f = e;
+          const u = f - a;
+          const g = l - c;
+          return {
+            top: c,
+            bottom: l,
+            left: a,
+            right: f,
+            width: u,
+            height: g,
+            x: a,
+            y: c
+          };
+        }
+        return m;
+      }
+      const h = await c.getElementRects({
+        reference: {
+          getBoundingClientRect
+        },
+        floating: s.floating,
+        strategy: l
+      });
+      if (r.reference.x !== h.reference.x || r.reference.y !== h.reference.y || r.reference.width !== h.reference.width || r.reference.height !== h.reference.height) {
+        return {
+          reset: {
+            rects: h
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
+
+// For type backwards-compatibility, the `OffsetOptions` type was also
+// Derivable.
+async function convertValueToCoords(t, e) {
+  const {placement: n, platform: o, elements: i} = t;
+  const s = await (o.isRTL == null ? void 0 : o.isRTL(i.floating));
+  const r = getSide(n);
+  const c = getAlignment(n);
+  const l = getSideAxis(n) === "y";
+  const a = [ "left", "top" ].includes(r) ? -1 : 1;
+  const f = s && l ? -1 : 1;
+  const u = evaluate(e, t);
+  // eslint-disable-next-line prefer-const
+    let {mainAxis: g, crossAxis: d, alignmentAxis: m} = typeof u === "number" ? {
+    mainAxis: u,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: u.mainAxis || 0,
+    crossAxis: u.crossAxis || 0,
+    alignmentAxis: u.alignmentAxis
+  };
+  if (c && typeof m === "number") {
+    d = c === "end" ? m * -1 : m;
+  }
+  return l ? {
+    x: d * f,
+    y: g * a
+  } : {
+    x: g * a,
+    y: d * f
+  };
+}
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */ const offset$1 = function(t) {
+  if (t === void 0) {
+    t = 0;
+  }
+  return {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var n, o;
+      const {x: i, y: s, placement: r, middlewareData: c} = e;
+      const l = await convertValueToCoords(e, t);
+      // If the placement is the same and the arrow caused an alignment offset
+      // then we don't need to change the positioning coordinates.
+            if (r === ((n = c.offset) == null ? void 0 : n.placement) && (o = c.arrow) != null && o.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: i + l.x,
+        y: s + l.y,
+        data: {
+          ...l,
+          placement: r
+        }
+      };
+    }
+  };
+};
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */ const shift$1 = function(t) {
+  if (t === void 0) {
+    t = {};
+  }
+  return {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {x: n, y: o, placement: i} = e;
+      const {mainAxis: s = true, crossAxis: r = false, limiter: c = {
+        fn: t => {
+          let {x: e, y: n} = t;
+          return {
+            x: e,
+            y: n
+          };
+        }
+      }, ...l} = evaluate(t, e);
+      const a = {
+        x: n,
+        y: o
+      };
+      const f = await detectOverflow(e, l);
+      const u = getSideAxis(getSide(i));
+      const g = getOppositeAxis(u);
+      let d = a[g];
+      let m = a[u];
+      if (s) {
+        const t = g === "y" ? "top" : "left";
+        const e = g === "y" ? "bottom" : "right";
+        const n = d + f[t];
+        const o = d - f[e];
+        d = clamp(n, d, o);
+      }
+      if (r) {
+        const t = u === "y" ? "top" : "left";
+        const e = u === "y" ? "bottom" : "right";
+        const n = m + f[t];
+        const o = m - f[e];
+        m = clamp(n, m, o);
+      }
+      const p = c.fn({
+        ...e,
+        [g]: d,
+        [u]: m
+      });
+      return {
+        ...p,
+        data: {
+          x: p.x - n,
+          y: p.y - o,
+          enabled: {
+            [g]: s,
+            [u]: r
+          }
+        }
+      };
+    }
+  };
+};
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */ const limitShift = function(t) {
+  if (t === void 0) {
+    t = {};
+  }
+  return {
+    options: t,
+    fn(e) {
+      const {x: n, y: o, placement: i, rects: s, middlewareData: r} = e;
+      const {offset: c = 0, mainAxis: l = true, crossAxis: a = true} = evaluate(t, e);
+      const f = {
+        x: n,
+        y: o
+      };
+      const u = getSideAxis(i);
+      const g = getOppositeAxis(u);
+      let d = f[g];
+      let m = f[u];
+      const p = evaluate(c, e);
+      const h = typeof p === "number" ? {
+        mainAxis: p,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...p
+      };
+      if (l) {
+        const t = g === "y" ? "height" : "width";
+        const e = s.reference[g] - s.floating[t] + h.mainAxis;
+        const n = s.reference[g] + s.reference[t] - h.mainAxis;
+        if (d < e) {
+          d = e;
+        } else if (d > n) {
+          d = n;
+        }
+      }
+      if (a) {
+        var w, y;
+        const t = g === "y" ? "width" : "height";
+        const e = [ "top", "left" ].includes(getSide(i));
+        const n = s.reference[u] - s.floating[t] + (e ? ((w = r.offset) == null ? void 0 : w[u]) || 0 : 0) + (e ? 0 : h.crossAxis);
+        const o = s.reference[u] + s.reference[t] + (e ? 0 : ((y = r.offset) == null ? void 0 : y[u]) || 0) - (e ? h.crossAxis : 0);
+        if (m < n) {
+          m = n;
+        } else if (m > o) {
+          m = o;
+        }
+      }
+      return {
+        [g]: d,
+        [u]: m
+      };
+    }
+  };
+};
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */ const size$1 = function(t) {
+  if (t === void 0) {
+    t = {};
+  }
+  return {
+    name: "size",
+    options: t,
+    async fn(e) {
+      var n, s;
+      const {placement: r, rects: c, platform: l, elements: a} = e;
+      const {apply: f = (() => {}), ...u} = evaluate(t, e);
+      const g = await detectOverflow(e, u);
+      const d = getSide(r);
+      const m = getAlignment(r);
+      const p = getSideAxis(r) === "y";
+      const {width: h, height: w} = c.floating;
+      let y;
+      let v;
+      if (d === "top" || d === "bottom") {
+        y = d;
+        v = m === (await (l.isRTL == null ? void 0 : l.isRTL(a.floating)) ? "start" : "end") ? "left" : "right";
+      } else {
+        v = d;
+        y = m === "end" ? "top" : "bottom";
+      }
+      const x = w - g.top - g.bottom;
+      const A = h - g.left - g.right;
+      const b = o(w - g[y], x);
+      const S = o(h - g[v], A);
+      const O = !e.middlewareData.shift;
+      let C = b;
+      let R = S;
+      if ((n = e.middlewareData.shift) != null && n.enabled.x) {
+        R = A;
+      }
+      if ((s = e.middlewareData.shift) != null && s.enabled.y) {
+        C = x;
+      }
+      if (O && !m) {
+        const t = i(g.left, 0);
+        const e = i(g.right, 0);
+        const n = i(g.top, 0);
+        const o = i(g.bottom, 0);
+        if (p) {
+          R = h - 2 * (t !== 0 || e !== 0 ? t + e : i(g.left, g.right));
+        } else {
+          C = w - 2 * (n !== 0 || o !== 0 ? n + o : i(g.top, g.bottom));
+        }
+      }
+      await f({
+        ...e,
+        availableWidth: R,
+        availableHeight: C
+      });
+      const P = await l.getDimensions(a.floating);
+      if (h !== P.width || w !== P.height) {
+        return {
+          reset: {
+            rects: true
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
+
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+
+function getNodeName(t) {
+  if (isNode(t)) {
+    return (t.nodeName || "").toLowerCase();
+  }
+  // Mocked nodes in testing environments may not be instances of Node. By
+  // returning `#document` an infinite loop won't occur.
+  // https://github.com/floating-ui/floating-ui/issues/2317
+    return "#document";
+}
+
+function getWindow(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+
+function getDocumentElement(t) {
+  var e;
+  return (e = (isNode(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+
+function isNode(t) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return t instanceof Node || t instanceof getWindow(t).Node;
+}
+
+function isElement(t) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return t instanceof Element || t instanceof getWindow(t).Element;
+}
+
+function isHTMLElement(t) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return t instanceof HTMLElement || t instanceof getWindow(t).HTMLElement;
+}
+
+function isShadowRoot(t) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return t instanceof ShadowRoot || t instanceof getWindow(t).ShadowRoot;
+}
+
+function isOverflowElement(t) {
+  const {overflow: e, overflowX: n, overflowY: o, display: i} = getComputedStyle(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + o + n) && ![ "inline", "contents" ].includes(i);
+}
+
+function isTableElement(t) {
+  return [ "table", "td", "th" ].includes(getNodeName(t));
+}
+
+function isTopLayer(t) {
+  return [ ":popover-open", ":modal" ].some((e => {
+    try {
+      return t.matches(e);
+    } catch (t) {
+      return false;
+    }
+  }));
+}
+
+function isContainingBlock(t) {
+  const e = isWebKit();
+  const n = isElement(t) ? getComputedStyle(t) : t;
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    return n.transform !== "none" || n.perspective !== "none" || (n.containerType ? n.containerType !== "normal" : false) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : false) || !e && (n.filter ? n.filter !== "none" : false) || [ "transform", "perspective", "filter" ].some((t => (n.willChange || "").includes(t))) || [ "paint", "layout", "strict", "content" ].some((t => (n.contain || "").includes(t)));
+}
+
+function getContainingBlock(t) {
+  let e = getParentNode(t);
+  while (isHTMLElement(e) && !isLastTraversableNode(e)) {
+    if (isContainingBlock(e)) {
+      return e;
+    } else if (isTopLayer(e)) {
+      return null;
+    }
+    e = getParentNode(e);
+  }
+  return null;
+}
+
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
+}
+
+function isLastTraversableNode(t) {
+  return [ "html", "body", "#document" ].includes(getNodeName(t));
+}
+
+function getComputedStyle(t) {
+  return getWindow(t).getComputedStyle(t);
+}
+
+function getNodeScroll(t) {
+  if (isElement(t)) {
+    return {
+      scrollLeft: t.scrollLeft,
+      scrollTop: t.scrollTop
+    };
+  }
+  return {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+
+function getParentNode(t) {
+  if (getNodeName(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.
+  isShadowRoot(t) && t.host || 
+  // Fallback.
+  getDocumentElement(t);
+  return isShadowRoot(e) ? e.host : e;
+}
+
+function getNearestOverflowAncestor(t) {
+  const e = getParentNode(t);
+  if (isLastTraversableNode(e)) {
+    return t.ownerDocument ? t.ownerDocument.body : t.body;
+  }
+  if (isHTMLElement(e) && isOverflowElement(e)) {
+    return e;
+  }
+  return getNearestOverflowAncestor(e);
+}
+
+function getOverflowAncestors(t, e, n) {
+  var o;
+  if (e === void 0) {
+    e = [];
+  }
+  if (n === void 0) {
+    n = true;
+  }
+  const i = getNearestOverflowAncestor(t);
+  const s = i === ((o = t.ownerDocument) == null ? void 0 : o.body);
+  const r = getWindow(i);
+  if (s) {
+    const t = getFrameElement(r);
+    return e.concat(r, r.visualViewport || [], isOverflowElement(i) ? i : [], t && n ? getOverflowAncestors(t) : []);
+  }
+  return e.concat(i, getOverflowAncestors(i, [], n));
+}
+
+function getFrameElement(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+
+function getCssDimensions(t) {
+  const e = getComputedStyle(t);
+  // In testing environments, the `width` and `height` properties are empty
+  // strings for SVG elements, returning NaN. Fallback to `0` in this case.
+    let n = parseFloat(e.width) || 0;
+  let o = parseFloat(e.height) || 0;
+  const i = isHTMLElement(t);
+  const r = i ? t.offsetWidth : n;
+  const c = i ? t.offsetHeight : o;
+  const l = s(n) !== r || s(o) !== c;
+  if (l) {
+    n = r;
+    o = c;
+  }
+  return {
+    width: n,
+    height: o,
+    $: l
+  };
+}
+
+function unwrapElement(t) {
+  return !isElement(t) ? t.contextElement : t;
+}
+
+function getScale(t) {
+  const e = unwrapElement(t);
+  if (!isHTMLElement(e)) {
+    return createCoords(1);
+  }
+  const n = e.getBoundingClientRect();
+  const {width: o, height: i, $: r} = getCssDimensions(e);
+  let c = (r ? s(n.width) : n.width) / o;
+  let l = (r ? s(n.height) : n.height) / i;
+  // 0, NaN, or Infinity should always fallback to 1.
+    if (!c || !Number.isFinite(c)) {
+    c = 1;
+  }
+  if (!l || !Number.isFinite(l)) {
+    l = 1;
+  }
+  return {
+    x: c,
+    y: l
+  };
+}
+
+const a =  createCoords(0);
+
+function getVisualOffsets(t) {
+  const e = getWindow(t);
+  if (!isWebKit() || !e.visualViewport) {
+    return a;
+  }
+  return {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+
+function shouldAddVisualOffsets(t, e, n) {
+  if (e === void 0) {
+    e = false;
+  }
+  if (!n || e && n !== getWindow(t)) {
+    return false;
+  }
+  return e;
+}
+
+function getBoundingClientRect(t, e, n, o) {
+  if (e === void 0) {
+    e = false;
+  }
+  if (n === void 0) {
+    n = false;
+  }
+  const i = t.getBoundingClientRect();
+  const s = unwrapElement(t);
+  let r = createCoords(1);
+  if (e) {
+    if (o) {
+      if (isElement(o)) {
+        r = getScale(o);
+      }
+    } else {
+      r = getScale(t);
+    }
+  }
+  const c = shouldAddVisualOffsets(s, n, o) ? getVisualOffsets(s) : createCoords(0);
+  let l = (i.left + c.x) / r.x;
+  let a = (i.top + c.y) / r.y;
+  let f = i.width / r.x;
+  let u = i.height / r.y;
+  if (s) {
+    const t = getWindow(s);
+    const e = o && isElement(o) ? getWindow(o) : o;
+    let n = t;
+    let i = getFrameElement(n);
+    while (i && o && e !== n) {
+      const t = getScale(i);
+      const e = i.getBoundingClientRect();
+      const o = getComputedStyle(i);
+      const s = e.left + (i.clientLeft + parseFloat(o.paddingLeft)) * t.x;
+      const r = e.top + (i.clientTop + parseFloat(o.paddingTop)) * t.y;
+      l *= t.x;
+      a *= t.y;
+      f *= t.x;
+      u *= t.y;
+      l += s;
+      a += r;
+      n = getWindow(i);
+      i = getFrameElement(n);
+    }
+  }
+  return rectToClientRect({
+    width: f,
+    height: u,
+    x: l,
+    y: a
+  });
+}
+
+function convertOffsetParentRelativeRectToViewportRelativeRect(t) {
+  let {elements: e, rect: n, offsetParent: o, strategy: i} = t;
+  const s = i === "fixed";
+  const r = getDocumentElement(o);
+  const c = e ? isTopLayer(e.floating) : false;
+  if (o === r || c && s) {
+    return n;
+  }
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let a = createCoords(1);
+  const f = createCoords(0);
+  const u = isHTMLElement(o);
+  if (u || !u && !s) {
+    if (getNodeName(o) !== "body" || isOverflowElement(r)) {
+      l = getNodeScroll(o);
+    }
+    if (isHTMLElement(o)) {
+      const t = getBoundingClientRect(o);
+      a = getScale(o);
+      f.x = t.x + o.clientLeft;
+      f.y = t.y + o.clientTop;
+    }
+  }
+  return {
+    width: n.width * a.x,
+    height: n.height * a.y,
+    x: n.x * a.x - l.scrollLeft * a.x + f.x,
+    y: n.y * a.y - l.scrollTop * a.y + f.y
+  };
+}
+
+function getClientRects(t) {
+  return Array.from(t.getClientRects());
+}
+
+// If <html> has a CSS width greater than the viewport, then this will be
+// incorrect for RTL.
+function getWindowScrollBarX(t, e) {
+  const n = getNodeScroll(t).scrollLeft;
+  if (!e) {
+    return getBoundingClientRect(getDocumentElement(t)).left + n;
+  }
+  return e.left + n;
+}
+
+// Gets the entire size of the scrollable document area, even extending outside
+// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
+function getDocumentRect(t) {
+  const e = getDocumentElement(t);
+  const n = getNodeScroll(t);
+  const o = t.ownerDocument.body;
+  const s = i(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth);
+  const r = i(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
+  let c = -n.scrollLeft + getWindowScrollBarX(t);
+  const l = -n.scrollTop;
+  if (getComputedStyle(o).direction === "rtl") {
+    c += i(e.clientWidth, o.clientWidth) - s;
+  }
+  return {
+    width: s,
+    height: r,
+    x: c,
+    y: l
+  };
+}
+
+function getViewportRect(t, e) {
+  const n = getWindow(t);
+  const o = getDocumentElement(t);
+  const i = n.visualViewport;
+  let s = o.clientWidth;
+  let r = o.clientHeight;
+  let c = 0;
+  let l = 0;
+  if (i) {
+    s = i.width;
+    r = i.height;
+    const t = isWebKit();
+    if (!t || t && e === "fixed") {
+      c = i.offsetLeft;
+      l = i.offsetTop;
+    }
+  }
+  return {
+    width: s,
+    height: r,
+    x: c,
+    y: l
+  };
+}
+
+// Returns the inner client rect, subtracting scrollbars if present.
+function getInnerBoundingClientRect(t, e) {
+  const n = getBoundingClientRect(t, true, e === "fixed");
+  const o = n.top + t.clientTop;
+  const i = n.left + t.clientLeft;
+  const s = isHTMLElement(t) ? getScale(t) : createCoords(1);
+  const r = t.clientWidth * s.x;
+  const c = t.clientHeight * s.y;
+  const l = i * s.x;
+  const a = o * s.y;
+  return {
+    width: r,
+    height: c,
+    x: l,
+    y: a
+  };
+}
+
+function getClientRectFromClippingAncestor(t, e, n) {
+  let o;
+  if (e === "viewport") {
+    o = getViewportRect(t, n);
+  } else if (e === "document") {
+    o = getDocumentRect(getDocumentElement(t));
+  } else if (isElement(e)) {
+    o = getInnerBoundingClientRect(e, n);
+  } else {
+    const n = getVisualOffsets(t);
+    o = {
+      ...e,
+      x: e.x - n.x,
+      y: e.y - n.y
+    };
+  }
+  return rectToClientRect(o);
+}
+
+function hasFixedPositionAncestor(t, e) {
+  const n = getParentNode(t);
+  if (n === e || !isElement(n) || isLastTraversableNode(n)) {
+    return false;
+  }
+  return getComputedStyle(n).position === "fixed" || hasFixedPositionAncestor(n, e);
+}
+
+// A "clipping ancestor" is an `overflow` element with the characteristic of
+// clipping (or hiding) child elements. This returns all clipping ancestors
+// of the given element up the tree.
+function getClippingElementAncestors(t, e) {
+  const n = e.get(t);
+  if (n) {
+    return n;
+  }
+  let o = getOverflowAncestors(t, [], false).filter((t => isElement(t) && getNodeName(t) !== "body"));
+  let i = null;
+  const s = getComputedStyle(t).position === "fixed";
+  let r = s ? getParentNode(t) : t;
+  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
+    while (isElement(r) && !isLastTraversableNode(r)) {
+    const e = getComputedStyle(r);
+    const n = isContainingBlock(r);
+    if (!n && e.position === "fixed") {
+      i = null;
+    }
+    const c = s ? !n && !i : !n && e.position === "static" && !!i && [ "absolute", "fixed" ].includes(i.position) || isOverflowElement(r) && !n && hasFixedPositionAncestor(t, r);
+    if (c) {
+      // Drop non-containing blocks.
+      o = o.filter((t => t !== r));
+    } else {
+      // Record last containing block for next iteration.
+      i = e;
+    }
+    r = getParentNode(r);
+  }
+  e.set(t, o);
+  return o;
+}
+
+// Gets the maximum area that the element is visible in due to any number of
+// clipping ancestors.
+function getClippingRect(t) {
+  let {element: e, boundary: n, rootBoundary: s, strategy: r} = t;
+  const c = n === "clippingAncestors" ? isTopLayer(e) ? [] : getClippingElementAncestors(e, this._c) : [].concat(n);
+  const l = [ ...c, s ];
+  const a = l[0];
+  const f = l.reduce(((t, n) => {
+    const s = getClientRectFromClippingAncestor(e, n, r);
+    t.top = i(s.top, t.top);
+    t.right = o(s.right, t.right);
+    t.bottom = o(s.bottom, t.bottom);
+    t.left = i(s.left, t.left);
+    return t;
+  }), getClientRectFromClippingAncestor(e, a, r));
+  return {
+    width: f.right - f.left,
+    height: f.bottom - f.top,
+    x: f.left,
+    y: f.top
+  };
+}
+
+function getDimensions(t) {
+  const {width: e, height: n} = getCssDimensions(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+
+function getRectRelativeToOffsetParent(t, e, n) {
+  const o = isHTMLElement(e);
+  const i = getDocumentElement(e);
+  const s = n === "fixed";
+  const r = getBoundingClientRect(t, true, s, e);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = createCoords(0);
+  if (o || !o && !s) {
+    if (getNodeName(e) !== "body" || isOverflowElement(i)) {
+      c = getNodeScroll(e);
+    }
+    if (o) {
+      const t = getBoundingClientRect(e, true, s, e);
+      l.x = t.x + e.clientLeft;
+      l.y = t.y + e.clientTop;
+    } else if (i) {
+      // If the <body> scrollbar appears on the left (e.g. RTL systems). Use
+      // Firefox with layout.scrollbar.side = 3 in about:config to test this.
+      l.x = getWindowScrollBarX(i);
+    }
+  }
+  let a = 0;
+  let f = 0;
+  if (i && !o && !s) {
+    const t = i.getBoundingClientRect();
+    f = t.top + c.scrollTop;
+    a = t.left + c.scrollLeft - 
+    // RTL <body> scrollbar.
+    getWindowScrollBarX(i, t);
+  }
+  const u = r.left + c.scrollLeft - l.x - a;
+  const g = r.top + c.scrollTop - l.y - f;
+  return {
+    x: u,
+    y: g,
+    width: r.width,
+    height: r.height
+  };
+}
+
+function isStaticPositioned(t) {
+  return getComputedStyle(t).position === "static";
+}
+
+function getTrueOffsetParent(t, e) {
+  if (!isHTMLElement(t) || getComputedStyle(t).position === "fixed") {
+    return null;
+  }
+  if (e) {
+    return e(t);
+  }
+  let n = t.offsetParent;
+  // Firefox returns the <html> element as the offsetParent if it's non-static,
+  // while Chrome and Safari return the <body> element. The <body> element must
+  // be used to perform the correct calculations even if the <html> element is
+  // non-static.
+    if (getDocumentElement(t) === n) {
+    n = n.ownerDocument.body;
+  }
+  return n;
+}
+
+// Gets the closest ancestor positioned element. Handles some edge cases,
+// such as table ancestors and cross browser bugs.
+function getOffsetParent(t, e) {
+  const n = getWindow(t);
+  if (isTopLayer(t)) {
+    return n;
+  }
+  if (!isHTMLElement(t)) {
+    let e = getParentNode(t);
+    while (e && !isLastTraversableNode(e)) {
+      if (isElement(e) && !isStaticPositioned(e)) {
+        return e;
+      }
+      e = getParentNode(e);
+    }
+    return n;
+  }
+  let o = getTrueOffsetParent(t, e);
+  while (o && isTableElement(o) && isStaticPositioned(o)) {
+    o = getTrueOffsetParent(o, e);
+  }
+  if (o && isLastTraversableNode(o) && isStaticPositioned(o) && !isContainingBlock(o)) {
+    return n;
+  }
+  return o || getContainingBlock(t) || n;
+}
+
+const getElementRects = async function(t) {
+  const e = this.getOffsetParent || getOffsetParent;
+  const n = this.getDimensions;
+  const o = await n(t.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+
+function isRTL(t) {
+  return getComputedStyle(t).direction === "rtl";
+}
+
+const f = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+
+// https://samthor.au/2021/observing-dom/
+function observeMove(t, e) {
+  let n = null;
+  let s;
+  const c = getDocumentElement(t);
+  function cleanup() {
+    var t;
+    clearTimeout(s);
+    (t = n) == null || t.disconnect();
+    n = null;
+  }
+  function refresh(l, a) {
+    if (l === void 0) {
+      l = false;
+    }
+    if (a === void 0) {
+      a = 1;
+    }
+    cleanup();
+    const {left: f, top: u, width: g, height: d} = t.getBoundingClientRect();
+    if (!l) {
+      e();
+    }
+    if (!g || !d) {
+      return;
+    }
+    const m = r(u);
+    const p = r(c.clientWidth - (f + g));
+    const h = r(c.clientHeight - (u + d));
+    const w = r(f);
+    const y = -m + "px " + -p + "px " + -h + "px " + -w + "px";
+    const v = {
+      rootMargin: y,
+      threshold: i(0, o(1, a)) || 1
+    };
+    let x = true;
+    function handleObserve(t) {
+      const e = t[0].intersectionRatio;
+      if (e !== a) {
+        if (!x) {
+          return refresh();
+        }
+        if (!e) {
+          // If the reference is clipped, the ratio is 0. Throttle the refresh
+          // to prevent an infinite loop of updates.
+          s = setTimeout((() => {
+            refresh(false, 1e-7);
+          }), 1e3);
+        } else {
+          refresh(false, e);
+        }
+      }
+      x = false;
+    }
+    // Older browsers don't support a `document` as the root and will throw an
+    // error.
+        try {
+      n = new IntersectionObserver(handleObserve, {
+        ...v,
+        // Handle <iframe>s
+        root: c.ownerDocument
+      });
+    } catch (t) {
+      n = new IntersectionObserver(handleObserve, v);
+    }
+    n.observe(t);
+  }
+  refresh(true);
+  return cleanup;
+}
+
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */ function autoUpdate(t, e, n, o) {
+  if (o === void 0) {
+    o = {};
+  }
+  const {ancestorScroll: i = true, ancestorResize: s = true, elementResize: r = typeof ResizeObserver === "function", layoutShift: c = typeof IntersectionObserver === "function", animationFrame: l = false} = o;
+  const a = unwrapElement(t);
+  const f = i || s ? [ ...a ? getOverflowAncestors(a) : [], ...getOverflowAncestors(e) ] : [];
+  f.forEach((t => {
+    i && t.addEventListener("scroll", n, {
+      passive: true
+    });
+    s && t.addEventListener("resize", n);
+  }));
+  const u = a && c ? observeMove(a, n) : null;
+  let g = -1;
+  let d = null;
+  if (r) {
+    d = new ResizeObserver((t => {
+      let [o] = t;
+      if (o && o.target === a && d) {
+        // Prevent update loops when using the `size` middleware.
+        // https://github.com/floating-ui/floating-ui/issues/1740
+        d.unobserve(e);
+        cancelAnimationFrame(g);
+        g = requestAnimationFrame((() => {
+          var t;
+          (t = d) == null || t.observe(e);
+        }));
+      }
+      n();
+    }));
+    if (a && !l) {
+      d.observe(a);
+    }
+    d.observe(e);
+  }
+  let m;
+  let p = l ? getBoundingClientRect(t) : null;
+  if (l) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const e = getBoundingClientRect(t);
+    if (p && (e.x !== p.x || e.y !== p.y || e.width !== p.width || e.height !== p.height)) {
+      n();
+    }
+    p = e;
+    m = requestAnimationFrame(frameLoop);
+  }
+  n();
+  return () => {
+    var t;
+    f.forEach((t => {
+      i && t.removeEventListener("scroll", n);
+      s && t.removeEventListener("resize", n);
+    }));
+    u == null || u();
+    (t = d) == null || t.disconnect();
+    d = null;
+    if (l) {
+      cancelAnimationFrame(m);
+    }
+  };
+}
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */ const u = offset$1;
+
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */ autoPlacement;
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */ const g = shift$1;
+
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */ const d = flip$1;
+
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */ const m = size$1;
+
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */ const p = hide$1;
+
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */ const h = arrow$1;
+
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */ inline;
+
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */ limitShift;
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */ const computePosition = (t, e, n) => {
+  // This caches the expensive `getClippingElementAncestors` function so that
+  // multiple lifecycle resets re-use the same result. It only lives for a
+  // single call. If other functions become expensive, we can add them as well.
+  const o = new Map;
+  const i = {
+    platform: f,
+    ...n
+  };
+  const s = {
+    ...i.platform,
+    _c: o
+  };
+  return computePosition$1(t, e, {
+    ...i,
+    platform: s
+  });
+};
+
+class w {
+  panel;
+  trigger;
+  options;
+  cleanUp;
+  constructor(t, e, n) {
+    this.trigger = t;
+    this.panel = e;
+    this.options = {
+      distance: 20,
+      placement: "bottom",
+      strategy: "fixed",
+      sameWidth: false,
+      ...n
+    };
+    this.init(n);
+  }
+  init(t) {
+    this.options = Object.assign(this.options, t);
+    this.update();
+  }
+  update() {
+    this.cleanUp = autoUpdate(this.trigger, this.panel, (() => {
+      (async () => {
+        const {x: t, y: e, placement: n, middlewareData: o} = await computePosition(this.trigger, this.panel, {
+          placement: this.options.placement,
+          strategy: this.options.strategy,
+          middleware: [ u({
+            mainAxis: this.options.distance,
+            crossAxis: this.options.skidding
+          }), d(), g(), m(this.options.sameWidth && {
+            apply({rects: t, elements: e}) {
+              Object.assign(e.floating.style, {
+                width: `${t.reference.width}px`
+              });
+            }
+          }), h({
+            element: this.options.arrow || null
+          }), this.positionChange(), p() ]
+        });
+        Object.assign(this.panel.style, {
+          top: "0",
+          left: "0",
+          transform: `translate(${this.roundByDPR(t)}px,${this.roundByDPR(e)}px)`
+        });
+        if (this.options.arrow) {
+          const {x: t, y: e} = o.arrow;
+          const i = {
+            top: "bottom",
+            right: "left",
+            bottom: "top",
+            left: "right"
+          }[n.split("-")[0]];
+          Object.assign(this.options.arrow.style, {
+            left: t != null ? `${t}px` : "",
+            top: e != null ? `${e}px` : "",
+            right: "",
+            bottom: "",
+            [i]: "-4px"
+          });
+        }
+        const {referenceHidden: i} = o.hide;
+        Object.assign(this.panel.style, {
+          visibility: i ? "hidden" : "visible"
+        });
+      })();
+    }));
+  }
+  destroy() {
+    if (!this.cleanUp) return;
+    this.cleanUp();
+  }
+  positionChange() {
+    return {
+      name: "positionChange",
+      fn: ({placement: t}) => {
+        if (typeof this.options.onPositionChange !== "function") return {};
+        this.options.onPositionChange(t);
+        return {};
+      }
+    };
+  }
+  roundByDPR(t) {
+    const e = window.devicePixelRatio || 1;
+    return Math.round(t * e) / e;
+  }
+}
+
+export { w as F };
+//# sourceMappingURL=p-c78ae3c2.js.map