@sparrowengg/integrations-templates-frontend 8.0.2 → 8.0.4

package/dist/es/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -1,5 +1,36 @@
-import { getSideAxis, getAlignmentAxis, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, getAxisLength, clamp, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, getAlignmentSides, min, max, getOppositeAxis, sides } from '../../utils/dist/floating-ui.utils.js';
+import { getSideAxis, getAlignmentAxis, getSide, getAlignment, evaluate, clamp, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, getAlignmentSides, min, max, getAxisLength, getPaddingObject, rectToClientRect, getOppositeAxis, sides } from '../../utils/dist/floating-ui.utils.js';
 
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 function computeCoordsFromPlacement(_ref, placement, rtl) {
   let {
     reference,
@@ -9,31 +40,31 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
   const alignmentAxis = getAlignmentAxis(placement);
   const alignLength = getAxisLength(alignmentAxis);
   const side = getSide(placement);
-  const isVertical = sideAxis === 'y';
+  const isVertical = sideAxis === "y";
   const commonX = reference.x + reference.width / 2 - floating.width / 2;
   const commonY = reference.y + reference.height / 2 - floating.height / 2;
   const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
   let coords;
   switch (side) {
-    case 'top':
+    case "top":
       coords = {
         x: commonX,
         y: reference.y - floating.height
       };
       break;
-    case 'bottom':
+    case "bottom":
       coords = {
         x: commonX,
         y: reference.y + reference.height
       };
       break;
-    case 'right':
+    case "right":
       coords = {
         x: reference.x + reference.width,
         y: commonY
       };
       break;
-    case 'left':
+    case "left":
       coords = {
         x: reference.x - floating.width,
         y: commonY
@@ -46,24 +77,15 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
       };
   }
   switch (getAlignment(placement)) {
-    case 'start':
+    case "start":
       coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
-    case 'end':
+    case "end":
       coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
       break;
   }
   return coords;
 }
-
-/**
- * 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(state, options) {
   var _await$platform$isEle;
   if (options === void 0) {
@@ -78,29 +100,29 @@ async function detectOverflow(state, options) {
     strategy
   } = state;
   const {
-    boundary = 'clippingAncestors',
-    rootBoundary = 'viewport',
-    elementContext = 'floating',
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
     altBoundary = false,
     padding = 0
   } = evaluate(options, state);
   const paddingObject = getPaddingObject(padding);
-  const altContext = elementContext === 'floating' ? 'reference' : 'floating';
+  const altContext = elementContext === "floating" ? "reference" : "floating";
   const element = elements[altBoundary ? altContext : elementContext];
   const clippingClientRect = rectToClientRect(await platform.getClippingRect({
-    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
+    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating)),
     boundary,
     rootBoundary,
     strategy
   }));
-  const rect = elementContext === 'floating' ? {
+  const rect = elementContext === "floating" ? {
     x,
     y,
     width: rects.floating.width,
     height: rects.floating.height
   } : rects.reference;
   const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
-  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
+  const offsetScale = await (platform.isElement == null ? void 0 : platform.isElement(offsetParent)) ? await (platform.getScale == null ? void 0 : platform.getScale(offsetParent)) || {
     x: 1,
     y: 1
   } : {
@@ -120,28 +142,17 @@ async function detectOverflow(state, options) {
     right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
   };
 }
-
-// Maximum number of resets that can occur before bailing to avoid infinite reset loops.
 const MAX_RESET_COUNT = 50;
-
-/**
- * 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 = async (reference, floating, config) => {
   const {
-    placement = 'bottom',
-    strategy = 'absolute',
+    placement = "bottom",
+    strategy = "absolute",
     middleware = [],
     platform
   } = config;
-  const platformWithDetectOverflow = platform.detectOverflow ? platform : {
-    ...platform,
+  const platformWithDetectOverflow = platform.detectOverflow ? platform : __spreadProps(__spreadValues({}, platform), {
     detectOverflow
-  };
+  });
   const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
   let rects = await platform.getElementRects({
     reference,
@@ -185,13 +196,10 @@ const computePosition = async (reference, floating, config) => {
     });
     x = nextX != null ? nextX : x;
     y = nextY != null ? nextY : y;
-    middlewareData[name] = {
-      ...middlewareData[name],
-      ...data
-    };
+    middlewareData[name] = __spreadValues(__spreadValues({}, middlewareData[name]), data);
     if (reset && resetCount < MAX_RESET_COUNT) {
       resetCount++;
-      if (typeof reset === 'object') {
+      if (typeof reset === "object") {
         if (reset.placement) {
           statefulPlacement = reset.placement;
         }
@@ -218,14 +226,8 @@ const computePosition = async (reference, floating, config) => {
     middlewareData
   };
 };
-
-/**
- * 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 = options => ({
-  name: 'arrow',
+const arrow = (options) => ({
+  name: "arrow",
   options,
   async fn(state) {
     const {
@@ -237,7 +239,6 @@ const arrow = options => ({
       elements,
       middlewareData
     } = state;
-    // Since `element` is required, we don't Partial<> the type.
     const {
       element,
       padding = 0
@@ -253,66 +254,45 @@ const arrow = options => ({
     const axis = getAlignmentAxis(placement);
     const length = getAxisLength(axis);
     const arrowDimensions = await platform.getDimensions(element);
-    const isYAxis = axis === 'y';
-    const minProp = isYAxis ? 'top' : 'left';
-    const maxProp = isYAxis ? 'bottom' : 'right';
-    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';
+    const isYAxis = axis === "y";
+    const minProp = isYAxis ? "top" : "left";
+    const maxProp = isYAxis ? "bottom" : "right";
+    const clientProp = isYAxis ? "clientHeight" : "clientWidth";
     const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
     const startDiff = coords[axis] - rects.reference[axis];
     const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
     let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
-
-    // DOM platform can return `window` as the `offsetParent`.
-    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {
+    if (!clientSize || !await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent))) {
       clientSize = elements.floating[clientProp] || rects.floating[length];
     }
     const centerToReference = endDiff / 2 - startDiff / 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 largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
     const minPadding = min(paddingObject[minProp], largestPossiblePadding);
     const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
-
-    // Make sure the arrow doesn't overflow the floating element if the center
-    // point is outside the floating element's bounds.
     const min$1 = minPadding;
-    const max = clientSize - arrowDimensions[length] - maxPadding;
+    const max2 = clientSize - arrowDimensions[length] - maxPadding;
     const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-    const offset = clamp(min$1, center, max);
-
-    // 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 shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
-    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
+    const offset2 = clamp(min$1, center, max2);
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
     return {
       [axis]: coords[axis] + alignmentOffset,
-      data: {
-        [axis]: offset,
-        centerOffset: center - offset - alignmentOffset,
-        ...(shouldAddOffset && {
-          alignmentOffset
-        })
-      },
+      data: __spreadValues({
+        [axis]: offset2,
+        centerOffset: center - offset2 - alignmentOffset
+      }, shouldAddOffset && {
+        alignmentOffset
+      }),
       reset: shouldAddOffset
     };
   }
 });
-
-/**
- * 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 = function (options) {
+const flip = function(options) {
   if (options === void 0) {
     options = {};
   }
   return {
-    name: 'flip',
+    name: "flip",
     options,
     async fn(state) {
       var _middlewareData$arrow, _middlewareData$flip;
@@ -324,20 +304,21 @@ const flip = function (options) {
         platform,
         elements
       } = state;
-      const {
+      const _a = evaluate(options, state), {
         mainAxis: checkMainAxis = true,
         crossAxis: checkCrossAxis = true,
         fallbackPlacements: specifiedFallbackPlacements,
-        fallbackStrategy = 'bestFit',
-        fallbackAxisSideDirection = 'none',
-        flipAlignment = true,
-        ...detectOverflowOptions
-      } = evaluate(options, state);
-
-      // 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
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "mainAxis",
+        "crossAxis",
+        "fallbackPlacements",
+        "fallbackStrategy",
+        "fallbackAxisSideDirection",
+        "flipAlignment"
+      ]);
       if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
       }
@@ -346,11 +327,11 @@ const flip = function (options) {
       const isBasePlacement = getSide(initialPlacement) === initialPlacement;
       const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
       const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
-      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
       if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
         fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
-      const placements = [initialPlacement, ...fallbackPlacements];
+      const placements2 = [initialPlacement, ...fallbackPlacements];
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
       const overflows = [];
       let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
@@ -358,26 +339,22 @@ const flip = function (options) {
         overflows.push(overflow[side]);
       }
       if (checkCrossAxis) {
-        const sides = getAlignmentSides(placement, rects, rtl);
-        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+        const sides2 = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
       }
       overflowsData = [...overflowsData, {
         placement,
         overflows
       }];
-
-      // One or more sides is overflowing.
-      if (!overflows.every(side => side <= 0)) {
+      if (!overflows.every((side2) => side2 <= 0)) {
         var _middlewareData$flip2, _overflowsData$filter;
         const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
-        const nextPlacement = placements[nextIndex];
+        const nextPlacement = placements2[nextIndex];
         if (nextPlacement) {
-          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== getSideAxis(nextPlacement) : false;
-          if (!ignoreCrossAxisOverflow ||
-          // We leave the current main axis only if every placement on that axis
+          const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
+          if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
           // overflows the main axis.
-          overflowsData.every(d => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
-            // Try next placement and re-run the lifecycle.
+          overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
             return {
               data: {
                 index: nextIndex,
@@ -389,33 +366,26 @@ const flip = function (options) {
             };
           }
         }
-
-        // 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 resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
-
-        // Otherwise fallback.
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
         if (!resetPlacement) {
           switch (fallbackStrategy) {
-            case 'bestFit':
-              {
-                var _overflowsData$filter2;
-                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
-                  if (hasFallbackAxisSideDirection) {
-                    const currentSideAxis = getSideAxis(d.placement);
-                    return currentSideAxis === initialSideAxis ||
-                    // Create a bias to the `y` side axis due to horizontal
-                    // reading directions favoring greater width.
-                    currentSideAxis === 'y';
-                  }
-                  return true;
-                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
-                if (placement) {
-                  resetPlacement = placement;
+            case "bestFit": {
+              var _overflowsData$filter2;
+              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+                if (hasFallbackAxisSideDirection) {
+                  const currentSideAxis = getSideAxis(d.placement);
+                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  currentSideAxis === "y";
                 }
-                break;
+                return true;
+              }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              if (placement2) {
+                resetPlacement = placement2;
               }
-            case 'initialPlacement':
+              break;
+            }
+            case "initialPlacement":
               resetPlacement = initialPlacement;
               break;
           }
@@ -432,7 +402,6 @@ const flip = function (options) {
     }
   };
 };
-
 function getSideOffsets(overflow, rect) {
   return {
     top: overflow.top - rect.height,
@@ -442,72 +411,58 @@ function getSideOffsets(overflow, rect) {
   };
 }
 function isAnySideFullyClipped(overflow) {
-  return sides.some(side => overflow[side] >= 0);
+  return sides.some((side) => overflow[side] >= 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 = function (options) {
+const hide = function(options) {
   if (options === void 0) {
     options = {};
   }
   return {
-    name: 'hide',
+    name: "hide",
     options,
     async fn(state) {
       const {
         rects,
         platform
       } = state;
-      const {
-        strategy = 'referenceHidden',
-        ...detectOverflowOptions
-      } = evaluate(options, state);
+      const _a = evaluate(options, state), {
+        strategy = "referenceHidden"
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "strategy"
+      ]);
       switch (strategy) {
-        case 'referenceHidden':
-          {
-            const overflow = await platform.detectOverflow(state, {
-              ...detectOverflowOptions,
-              elementContext: 'reference'
-            });
-            const offsets = getSideOffsets(overflow, rects.reference);
-            return {
-              data: {
-                referenceHiddenOffsets: offsets,
-                referenceHidden: isAnySideFullyClipped(offsets)
-              }
-            };
-          }
-        case 'escaped':
-          {
-            const overflow = await platform.detectOverflow(state, {
-              ...detectOverflowOptions,
-              altBoundary: true
-            });
-            const offsets = getSideOffsets(overflow, rects.floating);
-            return {
-              data: {
-                escapedOffsets: offsets,
-                escaped: isAnySideFullyClipped(offsets)
-              }
-            };
-          }
-        default:
-          {
-            return {};
-          }
+        case "referenceHidden": {
+          const overflow = await platform.detectOverflow(state, __spreadProps(__spreadValues({}, detectOverflowOptions), {
+            elementContext: "reference"
+          }));
+          const offsets = getSideOffsets(overflow, rects.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: offsets,
+              referenceHidden: isAnySideFullyClipped(offsets)
+            }
+          };
+        }
+        case "escaped": {
+          const overflow = await platform.detectOverflow(state, __spreadProps(__spreadValues({}, detectOverflowOptions), {
+            altBoundary: true
+          }));
+          const offsets = getSideOffsets(overflow, rects.floating);
+          return {
+            data: {
+              escapedOffsets: offsets,
+              escaped: isAnySideFullyClipped(offsets)
+            }
+          };
+        }
+        default: {
+          return {};
+        }
       }
     }
   };
 };
-
-const originSides = /*#__PURE__*/new Set(['left', 'top']);
-
-// For type backwards-compatibility, the `OffsetOptions` type was also
-// Derivable.
-
+const originSides = /* @__PURE__ */ new Set(["left", "top"]);
 async function convertValueToCoords(state, options) {
   const {
     placement,
@@ -517,17 +472,15 @@ async function convertValueToCoords(state, options) {
   const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
   const side = getSide(placement);
   const alignment = getAlignment(placement);
-  const isVertical = getSideAxis(placement) === 'y';
+  const isVertical = getSideAxis(placement) === "y";
   const mainAxisMulti = originSides.has(side) ? -1 : 1;
   const crossAxisMulti = rtl && isVertical ? -1 : 1;
   const rawValue = evaluate(options, state);
-
-  // eslint-disable-next-line prefer-const
   let {
     mainAxis,
     crossAxis,
     alignmentAxis
-  } = typeof rawValue === 'number' ? {
+  } = typeof rawValue === "number" ? {
     mainAxis: rawValue,
     crossAxis: 0,
     alignmentAxis: null
@@ -536,8 +489,8 @@ async function convertValueToCoords(state, options) {
     crossAxis: rawValue.crossAxis || 0,
     alignmentAxis: rawValue.alignmentAxis
   };
-  if (alignment && typeof alignmentAxis === 'number') {
-    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
   }
   return isVertical ? {
     x: crossAxis * crossAxisMulti,
@@ -547,20 +500,12 @@ async function convertValueToCoords(state, options) {
     y: crossAxis * crossAxisMulti
   };
 }
-
-/**
- * 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 = function (options) {
+const offset = function(options) {
   if (options === void 0) {
     options = 0;
   }
   return {
-    name: 'offset',
+    name: "offset",
     options,
     async fn(state) {
       var _middlewareData$offse, _middlewareData$arrow;
@@ -571,35 +516,25 @@ const offset = function (options) {
         middlewareData
       } = state;
       const diffCoords = await convertValueToCoords(state, options);
-
-      // If the placement is the same and the arrow caused an alignment offset
-      // then we don't need to change the positioning coordinates.
       if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
       }
       return {
         x: x + diffCoords.x,
         y: y + diffCoords.y,
-        data: {
-          ...diffCoords,
+        data: __spreadProps(__spreadValues({}, diffCoords), {
           placement
-        }
+        })
       };
     }
   };
 };
-
-/**
- * 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 = function (options) {
+const shift = function(options) {
   if (options === void 0) {
     options = {};
   }
   return {
-    name: 'shift',
+    name: "shift",
     options,
     async fn(state) {
       const {
@@ -608,23 +543,26 @@ const shift = function (options) {
         placement,
         platform
       } = state;
-      const {
+      const _a = evaluate(options, state), {
         mainAxis: checkMainAxis = true,
         crossAxis: checkCrossAxis = false,
         limiter = {
-          fn: _ref => {
+          fn: (_ref) => {
             let {
-              x,
-              y
+              x: x2,
+              y: y2
             } = _ref;
             return {
-              x,
-              y
+              x: x2,
+              y: y2
             };
           }
-        },
-        ...detectOverflowOptions
-      } = evaluate(options, state);
+        }
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "mainAxis",
+        "crossAxis",
+        "limiter"
+      ]);
       const coords = {
         x,
         y
@@ -635,26 +573,24 @@ const shift = function (options) {
       let mainAxisCoord = coords[mainAxis];
       let crossAxisCoord = coords[crossAxis];
       if (checkMainAxis) {
-        const minSide = mainAxis === 'y' ? 'top' : 'left';
-        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
-        const min = mainAxisCoord + overflow[minSide];
-        const max = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = clamp(min, mainAxisCoord, max);
+        const minSide = mainAxis === "y" ? "top" : "left";
+        const maxSide = mainAxis === "y" ? "bottom" : "right";
+        const min2 = mainAxisCoord + overflow[minSide];
+        const max2 = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = clamp(min2, mainAxisCoord, max2);
       }
       if (checkCrossAxis) {
-        const minSide = crossAxis === 'y' ? 'top' : 'left';
-        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
-        const min = crossAxisCoord + overflow[minSide];
-        const max = crossAxisCoord - overflow[maxSide];
-        crossAxisCoord = clamp(min, crossAxisCoord, max);
+        const minSide = crossAxis === "y" ? "top" : "left";
+        const maxSide = crossAxis === "y" ? "bottom" : "right";
+        const min2 = crossAxisCoord + overflow[minSide];
+        const max2 = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = clamp(min2, crossAxisCoord, max2);
       }
-      const limitedCoords = limiter.fn({
-        ...state,
+      const limitedCoords = limiter.fn(__spreadProps(__spreadValues({}, state), {
         [mainAxis]: mainAxisCoord,
         [crossAxis]: crossAxisCoord
-      });
-      return {
-        ...limitedCoords,
+      }));
+      return __spreadProps(__spreadValues({}, limitedCoords), {
         data: {
           x: limitedCoords.x - x,
           y: limitedCoords.y - y,
@@ -663,14 +599,11 @@ const shift = function (options) {
             [crossAxis]: checkCrossAxis
           }
         }
-      };
+      });
     }
   };
 };
-/**
- * Built-in `limiter` that will stop `shift()` at a certain point.
- */
-const limitShift = function (options) {
+const limitShift = function(options) {
   if (options === void 0) {
     options = {};
   }
@@ -685,7 +618,7 @@ const limitShift = function (options) {
         middlewareData
       } = state;
       const {
-        offset = 0,
+        offset: offset2 = 0,
         mainAxis: checkMainAxis = true,
         crossAxis: checkCrossAxis = true
       } = evaluate(options, state);
@@ -697,17 +630,16 @@ const limitShift = function (options) {
       const mainAxis = getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
       let crossAxisCoord = coords[crossAxis];
-      const rawOffset = evaluate(offset, state);
-      const computedOffset = typeof rawOffset === 'number' ? {
+      const rawOffset = evaluate(offset2, state);
+      const computedOffset = typeof rawOffset === "number" ? {
         mainAxis: rawOffset,
         crossAxis: 0
-      } : {
+      } : __spreadValues({
         mainAxis: 0,
-        crossAxis: 0,
-        ...rawOffset
-      };
+        crossAxis: 0
+      }, rawOffset);
       if (checkMainAxis) {
-        const len = mainAxis === 'y' ? 'height' : 'width';
+        const len = mainAxis === "y" ? "height" : "width";
         const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
         const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
         if (mainAxisCoord < limitMin) {
@@ -718,7 +650,7 @@ const limitShift = function (options) {
       }
       if (checkCrossAxis) {
         var _middlewareData$offse, _middlewareData$offse2;
-        const len = mainAxis === 'y' ? 'width' : 'height';
+        const len = mainAxis === "y" ? "width" : "height";
         const isOriginSide = originSides.has(getSide(placement));
         const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
         const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
@@ -735,19 +667,12 @@ const limitShift = function (options) {
     }
   };
 };
-
-/**
- * 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 = function (options) {
+const size = function(options) {
   if (options === void 0) {
     options = {};
   }
   return {
-    name: 'size',
+    name: "size",
     options,
     async fn(state) {
       var _state$middlewareData, _state$middlewareData2;
@@ -757,26 +682,28 @@ const size = function (options) {
         platform,
         elements
       } = state;
-      const {
-        apply = () => {},
-        ...detectOverflowOptions
-      } = evaluate(options, state);
+      const _a = evaluate(options, state), {
+        apply = () => {
+        }
+      } = _a, detectOverflowOptions = __objRest(_a, [
+        "apply"
+      ]);
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
       const side = getSide(placement);
       const alignment = getAlignment(placement);
-      const isYAxis = getSideAxis(placement) === 'y';
+      const isYAxis = getSideAxis(placement) === "y";
       const {
         width,
         height
       } = rects.floating;
       let heightSide;
       let widthSide;
-      if (side === 'top' || side === 'bottom') {
+      if (side === "top" || side === "bottom") {
         heightSide = side;
-        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';
+        widthSide = alignment === (await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
       } else {
         widthSide = side;
-        heightSide = alignment === 'end' ? 'top' : 'bottom';
+        heightSide = alignment === "end" ? "top" : "bottom";
       }
       const maximumClippingHeight = height - overflow.top - overflow.bottom;
       const maximumClippingWidth = width - overflow.left - overflow.right;
@@ -802,11 +729,10 @@ const size = function (options) {
           availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
         }
       }
-      await apply({
-        ...state,
+      await apply(__spreadProps(__spreadValues({}, state), {
         availableWidth,
         availableHeight
-      });
+      }));
       const nextDimensions = await platform.getDimensions(elements.floating);
       if (width !== nextDimensions.width || height !== nextDimensions.height) {
         return {