@beeq/core 1.8.0-beta.1 → 1.8.0-beta.11

package/dist/beeq/p-38d4bd8a.js

@@ -1,1939 +0,0 @@
-/*!
- * 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 c = Math.floor;
-
-const createCoords = t => ({
-  x: t,
-  y: t
-});
-
-const r = {
-  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 c = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
-  if (e.reference[s] > e.floating[s]) {
-    c = getOppositePlacement(c);
-  }
-  return [ c, getOppositePlacement(c) ];
-}
-
-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 c = [ "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 : c;
-
-   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 => r[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 c = getAlignmentAxis(e);
-  const r = getAxisLength(c);
-  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[r] / 2 - i[r] / 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[c] -= g * (n && a ? -1 : 1);
-    break;
-
-   case "end":
-    d[c] += 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: c} = n;
-  const r = s.filter(Boolean);
-  const l = await (c.isRTL == null ? void 0 : c.isRTL(e));
-  let a = await c.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 < r.length; n++) {
-    const {name: s, fn: p} = r[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: c,
-      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 c.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: c, elements: r, 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 = r[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(r.floating)),
-    boundary: a,
-    rootBoundary: f,
-    strategy: l
-  }));
-  const y = u === "floating" ? {
-    x: o,
-    y: i,
-    width: c.floating.width,
-    height: c.floating.height
-  } : c.reference;
-  const v = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(r.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: r,
-    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: c, platform: r, 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 r.getDimensions(f);
-    const w = m === "y";
-    const y = w ? "top" : "left";
-    const v = w ? "bottom" : "right";
-    const x = w ? "clientHeight" : "clientWidth";
-    const A = c.reference[p] + c.reference[m] - d[m] - c.floating[p];
-    const b = d[m] - c.reference[m];
-    const O = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(f));
-    let S = O ? O[x] : 0;
-    // DOM platform can return `window` as the `offsetParent`.
-        if (!S || !await (r.isElement == null ? void 0 : r.isElement(O))) {
-      S = l.floating[x] || c.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 = S / 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 = S - h[p] - E;
-    const N = S / 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 && c.reference[p] / 2 - (N < T ? P : E) - h[p] / 2 < 0;
-    const F = D ? N < T ? N - T : N - L : 0;
-    return {
-      [m]: d[m] + F,
-      data: {
-        [m]: B,
-        centerOffset: N - B - F,
-        ...D && {
-          alignmentOffset: F
-        }
-      },
-      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: c, middlewareData: r, 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 = r.autoPlacement) == null ? void 0 : o.index) || 0;
-      const v = h[y];
-      if (v == null) {
-        return {};
-      }
-      const x = getAlignmentSides(v, c, 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 = r.autoPlacement) == null ? void 0 : i.overflows) || [], {
-        placement: v,
-        overflows: A
-      } ];
-      const O = h[y + 1];
-      // There are more placements to check.
-            if (O) {
-        return {
-          data: {
-            index: y + 1,
-            overflows: b
-          },
-          reset: {
-            placement: O
-          }
-        };
-      }
-      const S = 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 = S.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]) || S[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: c, initialPlacement: r, 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(r);
-      const v = getSide(r) === r;
-      const x = await (l.isRTL == null ? void 0 : l.isRTL(a.floating));
-      const A = g || (v || !p ? [ getOppositePlacement(r) ] : getExpandedPlacements(r));
-      const b = m !== "none";
-      if (!g && b) {
-        A.push(...getOppositeAxisPlacements(r, p, m, x));
-      }
-      const O = [ r, ...A ];
-      const S = await detectOverflow(e, h);
-      const C = [];
-      let R = ((o = s.flip) == null ? void 0 : o.overflows) || [];
-      if (f) {
-        C.push(S[w]);
-      }
-      if (u) {
-        const t = getAlignmentSides(i, c, x);
-        C.push(S[t[0]], S[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 = O[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 = r;
-            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 c = i(...t.map((t => t.bottom)));
-  return {
-    x: e,
-    y: n,
-    width: s - e,
-    height: c - 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: c, platform: r, 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 (r.getClientRects == null ? void 0 : r.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 c = o ? t.left : e.left;
-            const r = o ? t.right : e.right;
-            const l = r - c;
-            const a = s - i;
-            return {
-              top: i,
-              bottom: s,
-              left: c,
-              right: r,
-              width: l,
-              height: a,
-              x: c,
-              y: i
-            };
-          }
-          const t = getSide(n) === "left";
-          const e = i(...d.map((t => t.right)));
-          const s = o(...d.map((t => t.left)));
-          const c = d.filter((n => t ? n.left === s : n.right === e));
-          const r = c[0].top;
-          const l = c[c.length - 1].bottom;
-          const a = s;
-          const f = e;
-          const u = f - a;
-          const g = l - r;
-          return {
-            top: r,
-            bottom: l,
-            left: a,
-            right: f,
-            width: u,
-            height: g,
-            x: a,
-            y: r
-          };
-        }
-        return m;
-      }
-      const h = await r.getElementRects({
-        reference: {
-          getBoundingClientRect
-        },
-        floating: s.floating,
-        strategy: l
-      });
-      if (c.reference.x !== h.reference.x || c.reference.y !== h.reference.y || c.reference.width !== h.reference.width || c.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 c = getSide(n);
-  const r = getAlignment(n);
-  const l = getSideAxis(n) === "y";
-  const a = [ "left", "top" ].includes(c) ? -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: 0,
-    crossAxis: 0,
-    alignmentAxis: null,
-    ...u
-  };
-  if (r && typeof m === "number") {
-    d = r === "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: c, middlewareData: r} = 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 (c === ((n = r.offset) == null ? void 0 : n.placement) && (o = r.arrow) != null && o.alignmentOffset) {
-        return {};
-      }
-      return {
-        x: i + l.x,
-        y: s + l.y,
-        data: {
-          ...l,
-          placement: c
-        }
-      };
-    }
-  };
-};
-
-/**
- * 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: c = false, limiter: r = {
-        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 (c) {
-        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 = r.fn({
-        ...e,
-        [g]: d,
-        [u]: m
-      });
-      return {
-        ...p,
-        data: {
-          x: p.x - n,
-          y: p.y - o
-        }
-      };
-    }
-  };
-};
-
-/**
- * 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: c} = e;
-      const {offset: r = 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(r, 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 = c.offset) == null ? void 0 : w[u]) || 0 : 0) + (e ? 0 : h.crossAxis);
-        const o = s.reference[u] + s.reference[t] + (e ? 0 : ((y = c.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) {
-      const {placement: n, rects: s, platform: c, elements: r} = e;
-      const {apply: l = (() => {}), ...a} = evaluate(t, e);
-      const f = await detectOverflow(e, a);
-      const u = getSide(n);
-      const g = getAlignment(n);
-      const d = getSideAxis(n) === "y";
-      const {width: m, height: p} = s.floating;
-      let h;
-      let w;
-      if (u === "top" || u === "bottom") {
-        h = u;
-        w = g === (await (c.isRTL == null ? void 0 : c.isRTL(r.floating)) ? "start" : "end") ? "left" : "right";
-      } else {
-        w = u;
-        h = g === "end" ? "top" : "bottom";
-      }
-      const y = p - f.top - f.bottom;
-      const v = m - f.left - f.right;
-      const x = o(p - f[h], y);
-      const A = o(m - f[w], v);
-      const b = !e.middlewareData.shift;
-      let O = x;
-      let S = A;
-      if (d) {
-        S = g || b ? o(A, v) : v;
-      } else {
-        O = g || b ? o(x, y) : y;
-      }
-      if (b && !g) {
-        const t = i(f.left, 0);
-        const e = i(f.right, 0);
-        const n = i(f.top, 0);
-        const o = i(f.bottom, 0);
-        if (d) {
-          S = m - 2 * (t !== 0 || e !== 0 ? t + e : i(f.left, f.right));
-        } else {
-          O = p - 2 * (n !== 0 || o !== 0 ? n + o : i(f.top, f.bottom));
-        }
-      }
-      await l({
-        ...e,
-        availableWidth: S,
-        availableHeight: O
-      });
-      const C = await c.getDimensions(r.floating);
-      if (m !== C.width || p !== C.height) {
-        return {
-          reset: {
-            rects: true
-          }
-        };
-      }
-      return {};
-    }
-  };
-};
-
-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) {
-  return t instanceof Node || t instanceof getWindow(t).Node;
-}
-
-function isElement(t) {
-  return t instanceof Element || t instanceof getWindow(t).Element;
-}
-
-function isHTMLElement(t) {
-  return t instanceof HTMLElement || t instanceof getWindow(t).HTMLElement;
-}
-
-function isShadowRoot(t) {
-  // Browsers without `ShadowRoot` support.
-  if (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 c = getWindow(i);
-  if (s) {
-    const t = getFrameElement(c);
-    return e.concat(c, c.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 c = i ? t.offsetWidth : n;
-  const r = i ? t.offsetHeight : o;
-  const l = s(n) !== c || s(o) !== r;
-  if (l) {
-    n = c;
-    o = r;
-  }
-  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, $: c} = getCssDimensions(e);
-  let r = (c ? s(n.width) : n.width) / o;
-  let l = (c ? s(n.height) : n.height) / i;
-  // 0, NaN, or Infinity should always fallback to 1.
-    if (!r || !Number.isFinite(r)) {
-    r = 1;
-  }
-  if (!l || !Number.isFinite(l)) {
-    l = 1;
-  }
-  return {
-    x: r,
-    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 c = createCoords(1);
-  if (e) {
-    if (o) {
-      if (isElement(o)) {
-        c = getScale(o);
-      }
-    } else {
-      c = getScale(t);
-    }
-  }
-  const r = shouldAddVisualOffsets(s, n, o) ? getVisualOffsets(s) : createCoords(0);
-  let l = (i.left + r.x) / c.x;
-  let a = (i.top + r.y) / c.y;
-  let f = i.width / c.x;
-  let u = i.height / c.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 c = e.top + (i.clientTop + parseFloat(o.paddingTop)) * t.y;
-      l *= t.x;
-      a *= t.y;
-      f *= t.x;
-      u *= t.y;
-      l += s;
-      a += c;
-      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 c = getDocumentElement(o);
-  const r = e ? isTopLayer(e.floating) : false;
-  if (o === c || r && 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(c)) {
-      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());
-}
-
-function getWindowScrollBarX(t) {
-  // If <html> has a CSS width greater than the viewport, then this will be
-  // incorrect for RTL.
-  return getBoundingClientRect(getDocumentElement(t)).left + getNodeScroll(t).scrollLeft;
-}
-
-// 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 c = i(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
-  let r = -n.scrollLeft + getWindowScrollBarX(t);
-  const l = -n.scrollTop;
-  if (getComputedStyle(o).direction === "rtl") {
-    r += i(e.clientWidth, o.clientWidth) - s;
-  }
-  return {
-    width: s,
-    height: c,
-    x: r,
-    y: l
-  };
-}
-
-function getViewportRect(t, e) {
-  const n = getWindow(t);
-  const o = getDocumentElement(t);
-  const i = n.visualViewport;
-  let s = o.clientWidth;
-  let c = o.clientHeight;
-  let r = 0;
-  let l = 0;
-  if (i) {
-    s = i.width;
-    c = i.height;
-    const t = isWebKit();
-    if (!t || t && e === "fixed") {
-      r = i.offsetLeft;
-      l = i.offsetTop;
-    }
-  }
-  return {
-    width: s,
-    height: c,
-    x: r,
-    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 c = t.clientWidth * s.x;
-  const r = t.clientHeight * s.y;
-  const l = i * s.x;
-  const a = o * s.y;
-  return {
-    width: c,
-    height: r,
-    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 c = s ? getParentNode(t) : t;
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-    while (isElement(c) && !isLastTraversableNode(c)) {
-    const e = getComputedStyle(c);
-    const n = isContainingBlock(c);
-    if (!n && e.position === "fixed") {
-      i = null;
-    }
-    const r = s ? !n && !i : !n && e.position === "static" && !!i && [ "absolute", "fixed" ].includes(i.position) || isOverflowElement(c) && !n && hasFixedPositionAncestor(t, c);
-    if (r) {
-      // Drop non-containing blocks.
-      o = o.filter((t => t !== c));
-    } else {
-      // Record last containing block for next iteration.
-      i = e;
-    }
-    c = getParentNode(c);
-  }
-  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: c} = t;
-  const r = n === "clippingAncestors" ? isTopLayer(e) ? [] : getClippingElementAncestors(e, this._c) : [].concat(n);
-  const l = [ ...r, s ];
-  const a = l[0];
-  const f = l.reduce(((t, n) => {
-    const s = getClientRectFromClippingAncestor(e, n, c);
-    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, c));
-  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 c = getBoundingClientRect(t, true, s, e);
-  let r = {
-    scrollLeft: 0,
-    scrollTop: 0
-  };
-  const l = createCoords(0);
-  if (o || !o && !s) {
-    if (getNodeName(e) !== "body" || isOverflowElement(i)) {
-      r = 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) {
-      l.x = getWindowScrollBarX(i);
-    }
-  }
-  const a = c.left + r.scrollLeft - l.x;
-  const f = c.top + r.scrollTop - l.y;
-  return {
-    x: a,
-    y: f,
-    width: c.width,
-    height: c.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);
-  }
-  return t.offsetParent;
-}
-
-// 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 r = 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 = c(u);
-    const p = c(r.clientWidth - (f + g));
-    const h = c(r.clientHeight - (u + d));
-    const w = c(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: r.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: c = typeof ResizeObserver === "function", layoutShift: r = 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 && r ? observeMove(a, n) : null;
-  let g = -1;
-  let d = null;
-  if (c) {
-    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 {
-  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-38d4bd8a.js.map