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

package/dist/beeq/{p-38d4bd8a.js → p-c78ae3c2.js}

@@ -18,14 +18,14 @@ const i = Math.max;
 
 const s = Math.round;
 
-const c = Math.floor;
+const r = Math.floor;
 
 const createCoords = t => ({
   x: t,
   y: t
 });
 
-const r = {
+const c = {
   left: "right",
   right: "left",
   bottom: "top",
@@ -76,11 +76,11 @@ function getAlignmentSides(t, e, n) {
   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";
+  let r = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
   if (e.reference[s] > e.floating[s]) {
-    c = getOppositePlacement(c);
+    r = getOppositePlacement(r);
   }
-  return [ c, getOppositePlacement(c) ];
+  return [ r, getOppositePlacement(r) ];
 }
 
 function getExpandedPlacements(t) {
@@ -96,7 +96,7 @@ function getSideList(t, e, n) {
   const o = [ "left", "right" ];
   const i = [ "right", "left" ];
   const s = [ "top", "bottom" ];
-  const c = [ "bottom", "top" ];
+  const r = [ "bottom", "top" ];
   switch (t) {
    case "top":
    case "bottom":
@@ -105,7 +105,7 @@ function getSideList(t, e, n) {
 
    case "left":
    case "right":
-    return e ? s : c;
+    return e ? s : r;
 
    default:
     return [];
@@ -125,7 +125,7 @@ function getOppositeAxisPlacements(t, e, n, o) {
 }
 
 function getOppositePlacement(t) {
-  return t.replace(/left|right|bottom|top/g, (t => r[t]));
+  return t.replace(/left|right|bottom|top/g, (t => c[t]));
 }
 
 function expandPaddingObject(t) {
@@ -164,13 +164,13 @@ function rectToClientRect(t) {
 function computeCoordsFromPlacement(t, e, n) {
   let {reference: o, floating: i} = t;
   const s = getSideAxis(e);
-  const c = getAlignmentAxis(e);
-  const r = getAxisLength(c);
+  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[r] / 2 - i[r] / 2;
+  const g = o[c] / 2 - i[c] / 2;
   let d;
   switch (l) {
    case "top":
@@ -209,11 +209,11 @@ function computeCoordsFromPlacement(t, e, n) {
   }
   switch (getAlignment(e)) {
    case "start":
-    d[c] -= g * (n && a ? -1 : 1);
+    d[r] -= g * (n && a ? -1 : 1);
     break;
 
    case "end":
-    d[c] += g * (n && a ? -1 : 1);
+    d[r] += g * (n && a ? -1 : 1);
     break;
   }
   return d;
@@ -226,10 +226,10 @@ function computeCoordsFromPlacement(t, e, n) {
  * 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({
+  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
@@ -238,8 +238,8 @@ function computeCoordsFromPlacement(t, e, n) {
   let g = o;
   let d = {};
   let m = 0;
-  for (let n = 0; n < r.length; n++) {
-    const {name: s, fn: p} = r[n];
+  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,
@@ -248,7 +248,7 @@ function computeCoordsFromPlacement(t, e, n) {
       strategy: i,
       middlewareData: d,
       rects: a,
-      platform: c,
+      platform: r,
       elements: {
         reference: t,
         floating: e
@@ -270,7 +270,7 @@ function computeCoordsFromPlacement(t, e, n) {
           g = v.placement;
         }
         if (v.rects) {
-          a = v.rects === true ? await c.getElementRects({
+          a = v.rects === true ? await r.getElementRects({
             reference: t,
             floating: e,
             strategy: i
@@ -302,13 +302,13 @@ function computeCoordsFromPlacement(t, e, n) {
   if (e === void 0) {
     e = {};
   }
-  const {x: o, y: i, platform: s, rects: c, elements: r, strategy: l} = t;
+  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 = r[g ? p : u];
+  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(r.floating)),
+    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
@@ -316,10 +316,10 @@ function computeCoordsFromPlacement(t, e, n) {
   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));
+    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
@@ -328,7 +328,7 @@ function computeCoordsFromPlacement(t, e, n) {
     y: 1
   };
   const A = rectToClientRect(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: r,
+    elements: c,
     rect: y,
     offsetParent: v,
     strategy: l
@@ -349,7 +349,7 @@ function computeCoordsFromPlacement(t, e, n) {
   name: "arrow",
   options: t,
   async fn(e) {
-    const {x: n, y: i, placement: s, rects: c, platform: r, elements: l, middlewareData: a} = 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) {
@@ -362,44 +362,44 @@ function computeCoordsFromPlacement(t, e, n) {
     };
     const m = getAlignmentAxis(s);
     const p = getAxisLength(m);
-    const h = await r.getDimensions(f);
+    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 = 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;
+    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 (!S || !await (r.isElement == null ? void 0 : r.isElement(O))) {
-      S = l.floating[x] || c.floating[p];
+        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 = S / 2 - h[p] / 2 - 1;
+        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 = S - h[p] - E;
-    const N = S / 2 - h[p] / 2 + C;
+    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 && c.reference[p] / 2 - (N < T ? P : E) - h[p] / 2 < 0;
-    const F = D ? N < T ? N - T : N - L : 0;
+        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] + F,
+      [m]: d[m] + W,
       data: {
         [m]: B,
-        centerOffset: N - B - F,
+        centerOffset: N - B - W,
         ...D && {
-          alignmentOffset: F
+          alignmentOffset: W
         }
       },
       reset: D
@@ -431,16 +431,16 @@ function getPlacementList(t, e, n) {
     options: t,
     async fn(e) {
       var o, i, s;
-      const {rects: c, middlewareData: r, placement: l, platform: a, elements: f} = e;
+      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 = r.autoPlacement) == null ? void 0 : o.index) || 0;
+      const y = ((o = c.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)));
+      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 {
@@ -450,24 +450,24 @@ function getPlacementList(t, e, n) {
         };
       }
       const A = [ w[getSide(v)], w[x[0]], w[x[1]] ];
-      const b = [ ...((i = r.autoPlacement) == null ? void 0 : i.overflows) || [], {
+      const b = [ ...((i = c.autoPlacement) == null ? void 0 : i.overflows) || [], {
         placement: v,
         overflows: A
       } ];
-      const O = h[y + 1];
+      const S = h[y + 1];
       // There are more placements to check.
-            if (O) {
+            if (S) {
         return {
           data: {
             index: y + 1,
             overflows: b
           },
           reset: {
-            placement: O
+            placement: S
           }
         };
       }
-      const S = b.map((t => {
+      const O = b.map((t => {
         const e = getAlignment(t.placement);
         return [ t.placement, e && u ? 
         // Check along the mainAxis and main crossAxis side.
@@ -475,11 +475,11 @@ function getPlacementList(t, e, n) {
         // 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, 
+      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]) || S[0][0];
+      const R = ((s = C[0]) == null ? void 0 : s[0]) || O[0][0];
       if (R !== l) {
         return {
           data: {
@@ -510,7 +510,7 @@ function getPlacementList(t, e, n) {
     options: t,
     async fn(e) {
       var n, o;
-      const {placement: i, middlewareData: s, rects: c, initialPlacement: r, platform: l, elements: a} = e;
+      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
@@ -520,24 +520,24 @@ function getPlacementList(t, e, n) {
         return {};
       }
       const w = getSide(i);
-      const y = getSideAxis(r);
-      const v = getSide(r) === r;
+      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(r) ] : getExpandedPlacements(r));
+      const A = g || (v || !p ? [ getOppositePlacement(c) ] : getExpandedPlacements(c));
       const b = m !== "none";
       if (!g && b) {
-        A.push(...getOppositeAxisPlacements(r, p, m, x));
+        A.push(...getOppositeAxisPlacements(c, p, m, x));
       }
-      const O = [ r, ...A ];
-      const S = await detectOverflow(e, h);
+      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(S[w]);
+        C.push(O[w]);
       }
       if (u) {
-        const t = getAlignmentSides(i, c, x);
-        C.push(S[t[0]], S[t[1]]);
+        const t = getAlignmentSides(i, r, x);
+        C.push(O[t[0]], O[t[1]]);
       }
       R = [ ...R, {
         placement: i,
@@ -547,7 +547,7 @@ function getPlacementList(t, e, n) {
             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];
+        const e = S[t];
         if (e) {
           // Try next placement and re-run the lifecycle.
           return {
@@ -586,7 +586,7 @@ function getPlacementList(t, e, n) {
             }
 
            case "initialPlacement":
-            n = r;
+            n = c;
             break;
           }
         }
@@ -674,12 +674,12 @@ 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)));
+  const r = i(...t.map((t => t.bottom)));
   return {
     x: e,
     y: n,
     width: s - e,
-    height: c - n
+    height: r - n
   };
 }
 
@@ -711,12 +711,12 @@ function getRectsByLine(t) {
     name: "inline",
     options: t,
     async fn(e) {
-      const {placement: n, elements: s, rects: c, platform: r, strategy: l} = 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 (r.getClientRects == null ? void 0 : r.getClientRects(s.reference)) || []);
+      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);
@@ -734,52 +734,52 @@ function getRectsByLine(t) {
             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 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: c,
-              right: r,
+              left: r,
+              right: c,
               width: l,
               height: a,
-              x: c,
+              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 c = d.filter((n => t ? n.left === s : n.right === e));
-          const r = c[0].top;
-          const l = c[c.length - 1].bottom;
+          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 - r;
+          const g = l - c;
           return {
-            top: r,
+            top: c,
             bottom: l,
             left: a,
             right: f,
             width: u,
             height: g,
             x: a,
-            y: r
+            y: c
           };
         }
         return m;
       }
-      const h = await r.getElementRects({
+      const h = await c.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) {
+      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
@@ -796,10 +796,10 @@ function getRectsByLine(t) {
 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 r = getSide(n);
+  const c = getAlignment(n);
   const l = getSideAxis(n) === "y";
-  const a = [ "left", "top" ].includes(c) ? -1 : 1;
+  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
@@ -808,13 +808,12 @@ async function convertValueToCoords(t, e) {
     crossAxis: 0,
     alignmentAxis: null
   } : {
-    mainAxis: 0,
-    crossAxis: 0,
-    alignmentAxis: null,
-    ...u
+    mainAxis: u.mainAxis || 0,
+    crossAxis: u.crossAxis || 0,
+    alignmentAxis: u.alignmentAxis
   };
-  if (r && typeof m === "number") {
-    d = r === "end" ? m * -1 : m;
+  if (c && typeof m === "number") {
+    d = c === "end" ? m * -1 : m;
   }
   return l ? {
     x: d * f,
@@ -840,11 +839,11 @@ async function convertValueToCoords(t, e) {
     options: t,
     async fn(e) {
       var n, o;
-      const {x: i, y: s, placement: c, middlewareData: r} = e;
+      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 (c === ((n = r.offset) == null ? void 0 : n.placement) && (o = r.arrow) != null && o.alignmentOffset) {
+            if (r === ((n = c.offset) == null ? void 0 : n.placement) && (o = c.arrow) != null && o.alignmentOffset) {
         return {};
       }
       return {
@@ -852,7 +851,7 @@ async function convertValueToCoords(t, e) {
         y: s + l.y,
         data: {
           ...l,
-          placement: c
+          placement: r
         }
       };
     }
@@ -872,7 +871,7 @@ async function convertValueToCoords(t, e) {
     options: t,
     async fn(e) {
       const {x: n, y: o, placement: i} = e;
-      const {mainAxis: s = true, crossAxis: c = false, limiter: r = {
+      const {mainAxis: s = true, crossAxis: r = false, limiter: c = {
         fn: t => {
           let {x: e, y: n} = t;
           return {
@@ -897,14 +896,14 @@ async function convertValueToCoords(t, e) {
         const o = d - f[e];
         d = clamp(n, d, o);
       }
-      if (c) {
+      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 = r.fn({
+      const p = c.fn({
         ...e,
         [g]: d,
         [u]: m
@@ -913,7 +912,11 @@ async function convertValueToCoords(t, e) {
         ...p,
         data: {
           x: p.x - n,
-          y: p.y - o
+          y: p.y - o,
+          enabled: {
+            [g]: s,
+            [u]: r
+          }
         }
       };
     }
@@ -929,8 +932,8 @@ async function convertValueToCoords(t, e) {
   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 {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
@@ -939,7 +942,7 @@ async function convertValueToCoords(t, e) {
       const g = getOppositeAxis(u);
       let d = f[g];
       let m = f[u];
-      const p = evaluate(r, e);
+      const p = evaluate(c, e);
       const h = typeof p === "number" ? {
         mainAxis: p,
         crossAxis: 0
@@ -962,8 +965,8 @@ async function convertValueToCoords(t, e) {
         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);
+        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) {
@@ -991,52 +994,54 @@ async function convertValueToCoords(t, e) {
     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";
+      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 {
-        w = u;
-        h = g === "end" ? "top" : "bottom";
+        v = d;
+        y = m === "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;
+      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 (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));
+      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 {
-          O = p - 2 * (n !== 0 || o !== 0 ? n + o : i(f.top, f.bottom));
+          C = w - 2 * (n !== 0 || o !== 0 ? n + o : i(g.top, g.bottom));
         }
       }
-      await l({
+      await f({
         ...e,
-        availableWidth: S,
-        availableHeight: O
+        availableWidth: R,
+        availableHeight: C
       });
-      const C = await c.getDimensions(r.floating);
-      if (m !== C.width || p !== C.height) {
+      const P = await l.getDimensions(a.floating);
+      if (h !== P.width || w !== P.height) {
         return {
           reset: {
             rects: true
@@ -1048,6 +1053,10 @@ async function convertValueToCoords(t, e) {
   };
 };
 
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+
 function getNodeName(t) {
   if (isNode(t)) {
     return (t.nodeName || "").toLowerCase();
@@ -1069,20 +1078,28 @@ function getDocumentElement(t) {
 }
 
 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) {
-  // Browsers without `ShadowRoot` support.
-  if (typeof ShadowRoot === "undefined") {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
     return false;
   }
   return t instanceof ShadowRoot || t instanceof getWindow(t).ShadowRoot;
@@ -1190,10 +1207,10 @@ function getOverflowAncestors(t, e, n) {
   }
   const i = getNearestOverflowAncestor(t);
   const s = i === ((o = t.ownerDocument) == null ? void 0 : o.body);
-  const c = getWindow(i);
+  const r = getWindow(i);
   if (s) {
-    const t = getFrameElement(c);
-    return e.concat(c, c.visualViewport || [], isOverflowElement(i) ? i : [], t && n ? getOverflowAncestors(t) : []);
+    const t = getFrameElement(r);
+    return e.concat(r, r.visualViewport || [], isOverflowElement(i) ? i : [], t && n ? getOverflowAncestors(t) : []);
   }
   return e.concat(i, getOverflowAncestors(i, [], n));
 }
@@ -1209,12 +1226,12 @@ function getCssDimensions(t) {
     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;
+  const r = i ? t.offsetWidth : n;
+  const c = i ? t.offsetHeight : o;
+  const l = s(n) !== r || s(o) !== c;
   if (l) {
-    n = c;
-    o = r;
+    n = r;
+    o = c;
   }
   return {
     width: n,
@@ -1233,18 +1250,18 @@ function getScale(t) {
     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;
+  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 (!r || !Number.isFinite(r)) {
-    r = 1;
+    if (!c || !Number.isFinite(c)) {
+    c = 1;
   }
   if (!l || !Number.isFinite(l)) {
     l = 1;
   }
   return {
-    x: r,
+    x: c,
     y: l
   };
 }
@@ -1281,21 +1298,21 @@ function getBoundingClientRect(t, e, n, o) {
   }
   const i = t.getBoundingClientRect();
   const s = unwrapElement(t);
-  let c = createCoords(1);
+  let r = createCoords(1);
   if (e) {
     if (o) {
       if (isElement(o)) {
-        c = getScale(o);
+        r = getScale(o);
       }
     } else {
-      c = getScale(t);
+      r = 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;
+  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;
@@ -1306,13 +1323,13 @@ function getBoundingClientRect(t, e, n, o) {
       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;
+      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 += c;
+      a += r;
       n = getWindow(i);
       i = getFrameElement(n);
     }
@@ -1328,9 +1345,9 @@ function getBoundingClientRect(t, e, n, o) {
 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) {
+  const r = getDocumentElement(o);
+  const c = e ? isTopLayer(e.floating) : false;
+  if (o === r || c && s) {
     return n;
   }
   let l = {
@@ -1341,7 +1358,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(t) {
   const f = createCoords(0);
   const u = isHTMLElement(o);
   if (u || !u && !s) {
-    if (getNodeName(o) !== "body" || isOverflowElement(c)) {
+    if (getNodeName(o) !== "body" || isOverflowElement(r)) {
       l = getNodeScroll(o);
     }
     if (isHTMLElement(o)) {
@@ -1363,10 +1380,14 @@ 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;
+// 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
@@ -1376,16 +1397,16 @@ function getDocumentRect(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 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") {
-    r += i(e.clientWidth, o.clientWidth) - s;
+    c += i(e.clientWidth, o.clientWidth) - s;
   }
   return {
     width: s,
-    height: c,
-    x: r,
+    height: r,
+    x: c,
     y: l
   };
 }
@@ -1395,22 +1416,22 @@ function getViewportRect(t, e) {
   const o = getDocumentElement(t);
   const i = n.visualViewport;
   let s = o.clientWidth;
-  let c = o.clientHeight;
-  let r = 0;
+  let r = o.clientHeight;
+  let c = 0;
   let l = 0;
   if (i) {
     s = i.width;
-    c = i.height;
+    r = i.height;
     const t = isWebKit();
     if (!t || t && e === "fixed") {
-      r = i.offsetLeft;
+      c = i.offsetLeft;
       l = i.offsetTop;
     }
   }
   return {
     width: s,
-    height: c,
-    x: r,
+    height: r,
+    x: c,
     y: l
   };
 }
@@ -1421,13 +1442,13 @@ function getInnerBoundingClientRect(t, e) {
   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 r = t.clientWidth * s.x;
+  const c = t.clientHeight * s.y;
   const l = i * s.x;
   const a = o * s.y;
   return {
-    width: c,
-    height: r,
+    width: r,
+    height: c,
     x: l,
     y: a
   };
@@ -1471,23 +1492,23 @@ function getClippingElementAncestors(t, e) {
   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;
+  let r = 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);
+    while (isElement(r) && !isLastTraversableNode(r)) {
+    const e = getComputedStyle(r);
+    const n = isContainingBlock(r);
     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) {
+    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 !== c));
+      o = o.filter((t => t !== r));
     } else {
       // Record last containing block for next iteration.
       i = e;
     }
-    c = getParentNode(c);
+    r = getParentNode(r);
   }
   e.set(t, o);
   return o;
@@ -1496,18 +1517,18 @@ function getClippingElementAncestors(t, e) {
 // 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 ];
+  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, c);
+    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, c));
+  }), getClientRectFromClippingAncestor(e, a, r));
   return {
     width: f.right - f.left,
     height: f.bottom - f.top,
@@ -1528,31 +1549,42 @@ 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 = {
+  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)) {
-      r = getNodeScroll(e);
+      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);
     }
   }
-  const a = c.left + r.scrollLeft - l.x;
-  const f = c.top + r.scrollTop - l.y;
+  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: a,
-    y: f,
-    width: c.width,
-    height: c.height
+    x: u,
+    y: g,
+    width: r.width,
+    height: r.height
   };
 }
 
@@ -1567,7 +1599,15 @@ function getTrueOffsetParent(t, e) {
   if (e) {
     return e(t);
   }
-  return t.offsetParent;
+  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,
@@ -1633,7 +1673,7 @@ const f = {
 function observeMove(t, e) {
   let n = null;
   let s;
-  const r = getDocumentElement(t);
+  const c = getDocumentElement(t);
   function cleanup() {
     var t;
     clearTimeout(s);
@@ -1655,10 +1695,10 @@ function observeMove(t, 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 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,
@@ -1689,7 +1729,7 @@ function observeMove(t, e) {
       n = new IntersectionObserver(handleObserve, {
         ...v,
         // Handle <iframe>s
-        root: r.ownerDocument
+        root: c.ownerDocument
       });
     } catch (t) {
       n = new IntersectionObserver(handleObserve, v);
@@ -1711,7 +1751,7 @@ function observeMove(t, e) {
   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 {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 => {
@@ -1720,10 +1760,10 @@ function observeMove(t, e) {
     });
     s && t.addEventListener("resize", n);
   }));
-  const u = a && r ? observeMove(a, n) : null;
+  const u = a && c ? observeMove(a, n) : null;
   let g = -1;
   let d = null;
-  if (c) {
+  if (r) {
     d = new ResizeObserver((t => {
       let [o] = t;
       if (o && o.target === a && d) {
@@ -1852,6 +1892,10 @@ function observeMove(t, e) {
 };
 
 class w {
+  panel;
+  trigger;
+  options;
+  cleanUp;
   constructor(t, e, n) {
     this.trigger = t;
     this.panel = e;
@@ -1936,4 +1980,4 @@ class w {
 }
 
 export { w as F };
-//# sourceMappingURL=p-38d4bd8a.js.map
+//# sourceMappingURL=p-c78ae3c2.js.map