@jobber/components 8.23.0 → 8.23.1

package/dist/floating-ui.react-dom-cjs.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index_esm = require('./index.esm-cjs.js');
+var floatingUi_utils = require('./floating-ui.utils-cjs.js');
 var floatingUi_utils_dom = require('./floating-ui.utils.dom-cjs.js');
 var React = require('react');
 var ReactDOM = require('react-dom');
@@ -30,10 +30,10 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
     reference,
     floating
   } = _ref;
-  const sideAxis = index_esm.getSideAxis(placement);
-  const alignmentAxis = index_esm.getAlignmentAxis(placement);
-  const alignLength = index_esm.getAxisLength(alignmentAxis);
-  const side = index_esm.getSide(placement);
+  const sideAxis = floatingUi_utils.getSideAxis(placement);
+  const alignmentAxis = floatingUi_utils.getAlignmentAxis(placement);
+  const alignLength = floatingUi_utils.getAxisLength(alignmentAxis);
+  const side = floatingUi_utils.getSide(placement);
   const isVertical = sideAxis === 'y';
   const commonX = reference.x + reference.width / 2 - floating.width / 2;
   const commonY = reference.y + reference.height / 2 - floating.height / 2;
@@ -70,7 +70,7 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
         y: reference.y
       };
   }
-  switch (index_esm.getAlignment(placement)) {
+  switch (floatingUi_utils.getAlignment(placement)) {
     case 'start':
       coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
@@ -108,11 +108,11 @@ async function detectOverflow(state, options) {
     elementContext = 'floating',
     altBoundary = false,
     padding = 0
-  } = index_esm.evaluate(options, state);
-  const paddingObject = index_esm.getPaddingObject(padding);
+  } = floatingUi_utils.evaluate(options, state);
+  const paddingObject = floatingUi_utils.getPaddingObject(padding);
   const altContext = elementContext === 'floating' ? 'reference' : 'floating';
   const element = elements[altBoundary ? altContext : elementContext];
-  const clippingClientRect = index_esm.rectToClientRect(await platform.getClippingRect({
+  const clippingClientRect = floatingUi_utils.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))),
     boundary,
     rootBoundary,
@@ -132,7 +132,7 @@ async function detectOverflow(state, options) {
     x: 1,
     y: 1
   };
-  const elementClientRect = index_esm.rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+  const elementClientRect = floatingUi_utils.rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
     elements,
     rect,
     offsetParent,
@@ -266,17 +266,17 @@ const arrow$3 = options => ({
     const {
       element,
       padding = 0
-    } = index_esm.evaluate(options, state) || {};
+    } = floatingUi_utils.evaluate(options, state) || {};
     if (element == null) {
       return {};
     }
-    const paddingObject = index_esm.getPaddingObject(padding);
+    const paddingObject = floatingUi_utils.getPaddingObject(padding);
     const coords = {
       x,
       y
     };
-    const axis = index_esm.getAlignmentAxis(placement);
-    const length = index_esm.getAxisLength(axis);
+    const axis = floatingUi_utils.getAlignmentAxis(placement);
+    const length = floatingUi_utils.getAxisLength(axis);
     const arrowDimensions = await platform.getDimensions(element);
     const isYAxis = axis === 'y';
     const minProp = isYAxis ? 'top' : 'left';
@@ -296,21 +296,21 @@ const arrow$3 = options => ({
     // 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 = index_esm.min(paddingObject[minProp], largestPossiblePadding);
-    const maxPadding = index_esm.min(paddingObject[maxProp], largestPossiblePadding);
+    const minPadding = floatingUi_utils.min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = floatingUi_utils.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 center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-    const offset = index_esm.clamp(min$1, center, max);
+    const offset = floatingUi_utils.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 && index_esm.getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const shouldAddOffset = !middlewareData.arrow && floatingUi_utils.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;
     return {
       [axis]: coords[axis] + alignmentOffset,
@@ -327,10 +327,10 @@ const arrow$3 = options => ({
 });
 
 function getPlacementList(alignment, autoAlignment, allowedPlacements) {
-  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => index_esm.getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => index_esm.getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => index_esm.getSide(placement) === placement);
+  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => floatingUi_utils.getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => floatingUi_utils.getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => floatingUi_utils.getSide(placement) === placement);
   return allowedPlacementsSortedByAlignment.filter(placement => {
     if (alignment) {
-      return index_esm.getAlignment(placement) === alignment || (autoAlignment ? index_esm.getOppositeAlignmentPlacement(placement) !== placement : false);
+      return floatingUi_utils.getAlignment(placement) === alignment || (autoAlignment ? floatingUi_utils.getOppositeAlignmentPlacement(placement) !== placement : false);
     }
     return true;
   });
@@ -360,18 +360,18 @@ const autoPlacement$2 = function (options) {
       const {
         crossAxis = false,
         alignment,
-        allowedPlacements = index_esm.placements,
+        allowedPlacements = floatingUi_utils.placements,
         autoAlignment = true,
         ...detectOverflowOptions
-      } = index_esm.evaluate(options, state);
-      const placements$1 = alignment !== undefined || allowedPlacements === index_esm.placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
+      } = floatingUi_utils.evaluate(options, state);
+      const placements$1 = alignment !== undefined || allowedPlacements === floatingUi_utils.placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
       const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
       const currentPlacement = placements$1[currentIndex];
       if (currentPlacement == null) {
         return {};
       }
-      const alignmentSides = index_esm.getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
+      const alignmentSides = floatingUi_utils.getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
 
       // Make `computeCoords` start from the right place.
       if (placement !== currentPlacement) {
@@ -381,7 +381,7 @@ const autoPlacement$2 = function (options) {
           }
         };
       }
-      const currentOverflows = [overflow[index_esm.getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];
+      const currentOverflows = [overflow[floatingUi_utils.getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];
       const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {
         placement: currentPlacement,
         overflows: currentOverflows
@@ -401,7 +401,7 @@ const autoPlacement$2 = function (options) {
         };
       }
       const placementsSortedByMostSpace = allOverflows.map(d => {
-        const alignment = index_esm.getAlignment(d.placement);
+        const alignment = floatingUi_utils.getAlignment(d.placement);
         return [d.placement, alignment && crossAxis ?
         // Check along the mainAxis and main crossAxis side.
         d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :
@@ -411,7 +411,7 @@ const autoPlacement$2 = function (options) {
       const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,
       // Aligned placements should not check their opposite crossAxis
       // side.
-      index_esm.getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));
+      floatingUi_utils.getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));
       const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
       if (resetPlacement !== placement) {
         return {
@@ -460,7 +460,7 @@ const flip$2 = function (options) {
         fallbackAxisSideDirection = 'none',
         flipAlignment = true,
         ...detectOverflowOptions
-      } = index_esm.evaluate(options, state);
+      } = floatingUi_utils.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
@@ -469,14 +469,14 @@ const flip$2 = function (options) {
       if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
       }
-      const side = index_esm.getSide(placement);
-      const initialSideAxis = index_esm.getSideAxis(initialPlacement);
-      const isBasePlacement = index_esm.getSide(initialPlacement) === initialPlacement;
+      const side = floatingUi_utils.getSide(placement);
+      const initialSideAxis = floatingUi_utils.getSideAxis(initialPlacement);
+      const isBasePlacement = floatingUi_utils.getSide(initialPlacement) === initialPlacement;
       const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [index_esm.getOppositePlacement(initialPlacement)] : index_esm.getExpandedPlacements(initialPlacement));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [floatingUi_utils.getOppositePlacement(initialPlacement)] : floatingUi_utils.getExpandedPlacements(initialPlacement));
       const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
       if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
-        fallbackPlacements.push(...index_esm.getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+        fallbackPlacements.push(...floatingUi_utils.getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
       const placements = [initialPlacement, ...fallbackPlacements];
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
@@ -486,7 +486,7 @@ const flip$2 = function (options) {
         overflows.push(overflow[side]);
       }
       if (checkCrossAxis) {
-        const sides = index_esm.getAlignmentSides(placement, rects, rtl);
+        const sides = floatingUi_utils.getAlignmentSides(placement, rects, rtl);
         overflows.push(overflow[sides[0]], overflow[sides[1]]);
       }
       overflowsData = [...overflowsData, {
@@ -500,11 +500,11 @@ const flip$2 = function (options) {
         const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
         const nextPlacement = placements[nextIndex];
         if (nextPlacement) {
-          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== index_esm.getSideAxis(nextPlacement) : false;
+          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== floatingUi_utils.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 => index_esm.getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
+          overflowsData.every(d => floatingUi_utils.getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
             // Try next placement and re-run the lifecycle.
             return {
               data: {
@@ -530,7 +530,7 @@ const flip$2 = function (options) {
                 var _overflowsData$filter2;
                 const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
                   if (hasFallbackAxisSideDirection) {
-                    const currentSideAxis = index_esm.getSideAxis(d.placement);
+                    const currentSideAxis = floatingUi_utils.getSideAxis(d.placement);
                     return currentSideAxis === initialSideAxis ||
                     // Create a bias to the `y` side axis due to horizontal
                     // reading directions favoring greater width.
@@ -570,7 +570,7 @@ function getSideOffsets(overflow, rect) {
   };
 }
 function isAnySideFullyClipped(overflow) {
-  return index_esm.sides.some(side => overflow[side] >= 0);
+  return floatingUi_utils.sides.some(side => overflow[side] >= 0);
 }
 /**
  * Provides data to hide the floating element in applicable situations, such as
@@ -592,7 +592,7 @@ const hide$2 = function (options) {
       const {
         strategy = 'referenceHidden',
         ...detectOverflowOptions
-      } = index_esm.evaluate(options, state);
+      } = floatingUi_utils.evaluate(options, state);
       switch (strategy) {
         case 'referenceHidden':
           {
@@ -643,12 +643,12 @@ async function convertValueToCoords(state, options) {
     elements
   } = state;
   const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-  const side = index_esm.getSide(placement);
-  const alignment = index_esm.getAlignment(placement);
-  const isVertical = index_esm.getSideAxis(placement) === 'y';
+  const side = floatingUi_utils.getSide(placement);
+  const alignment = floatingUi_utils.getAlignment(placement);
+  const isVertical = floatingUi_utils.getSideAxis(placement) === 'y';
   const mainAxisMulti = originSides.has(side) ? -1 : 1;
   const crossAxisMulti = rtl && isVertical ? -1 : 1;
-  const rawValue = index_esm.evaluate(options, state);
+  const rawValue = floatingUi_utils.evaluate(options, state);
 
   // eslint-disable-next-line prefer-const
   let {
@@ -752,14 +752,14 @@ const shift$2 = function (options) {
           }
         },
         ...detectOverflowOptions
-      } = index_esm.evaluate(options, state);
+      } = floatingUi_utils.evaluate(options, state);
       const coords = {
         x,
         y
       };
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
-      const crossAxis = index_esm.getSideAxis(index_esm.getSide(placement));
-      const mainAxis = index_esm.getOppositeAxis(crossAxis);
+      const crossAxis = floatingUi_utils.getSideAxis(floatingUi_utils.getSide(placement));
+      const mainAxis = floatingUi_utils.getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
       let crossAxisCoord = coords[crossAxis];
       if (checkMainAxis) {
@@ -767,14 +767,14 @@ const shift$2 = function (options) {
         const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
         const min = mainAxisCoord + overflow[minSide];
         const max = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = index_esm.clamp(min, mainAxisCoord, max);
+        mainAxisCoord = floatingUi_utils.clamp(min, mainAxisCoord, max);
       }
       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 = index_esm.clamp(min, crossAxisCoord, max);
+        crossAxisCoord = floatingUi_utils.clamp(min, crossAxisCoord, max);
       }
       const limitedCoords = limiter.fn({
         ...state,
@@ -816,16 +816,16 @@ const limitShift$2 = function (options) {
         offset = 0,
         mainAxis: checkMainAxis = true,
         crossAxis: checkCrossAxis = true
-      } = index_esm.evaluate(options, state);
+      } = floatingUi_utils.evaluate(options, state);
       const coords = {
         x,
         y
       };
-      const crossAxis = index_esm.getSideAxis(placement);
-      const mainAxis = index_esm.getOppositeAxis(crossAxis);
+      const crossAxis = floatingUi_utils.getSideAxis(placement);
+      const mainAxis = floatingUi_utils.getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
       let crossAxisCoord = coords[crossAxis];
-      const rawOffset = index_esm.evaluate(offset, state);
+      const rawOffset = floatingUi_utils.evaluate(offset, state);
       const computedOffset = typeof rawOffset === 'number' ? {
         mainAxis: rawOffset,
         crossAxis: 0
@@ -847,7 +847,7 @@ const limitShift$2 = function (options) {
       if (checkCrossAxis) {
         var _middlewareData$offse, _middlewareData$offse2;
         const len = mainAxis === 'y' ? 'width' : 'height';
-        const isOriginSide = originSides.has(index_esm.getSide(placement));
+        const isOriginSide = originSides.has(floatingUi_utils.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);
         if (crossAxisCoord < limitMin) {
@@ -888,11 +888,11 @@ const size$2 = function (options) {
       const {
         apply = () => {},
         ...detectOverflowOptions
-      } = index_esm.evaluate(options, state);
+      } = floatingUi_utils.evaluate(options, state);
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
-      const side = index_esm.getSide(placement);
-      const alignment = index_esm.getAlignment(placement);
-      const isYAxis = index_esm.getSideAxis(placement) === 'y';
+      const side = floatingUi_utils.getSide(placement);
+      const alignment = floatingUi_utils.getAlignment(placement);
+      const isYAxis = floatingUi_utils.getSideAxis(placement) === 'y';
       const {
         width,
         height
@@ -908,8 +908,8 @@ const size$2 = function (options) {
       }
       const maximumClippingHeight = height - overflow.top - overflow.bottom;
       const maximumClippingWidth = width - overflow.left - overflow.right;
-      const overflowAvailableHeight = index_esm.min(height - overflow[heightSide], maximumClippingHeight);
-      const overflowAvailableWidth = index_esm.min(width - overflow[widthSide], maximumClippingWidth);
+      const overflowAvailableHeight = floatingUi_utils.min(height - overflow[heightSide], maximumClippingHeight);
+      const overflowAvailableWidth = floatingUi_utils.min(width - overflow[widthSide], maximumClippingWidth);
       const noShift = !state.middlewareData.shift;
       let availableHeight = overflowAvailableHeight;
       let availableWidth = overflowAvailableWidth;
@@ -920,14 +920,14 @@ const size$2 = function (options) {
         availableHeight = maximumClippingHeight;
       }
       if (noShift && !alignment) {
-        const xMin = index_esm.max(overflow.left, 0);
-        const xMax = index_esm.max(overflow.right, 0);
-        const yMin = index_esm.max(overflow.top, 0);
-        const yMax = index_esm.max(overflow.bottom, 0);
+        const xMin = floatingUi_utils.max(overflow.left, 0);
+        const xMax = floatingUi_utils.max(overflow.right, 0);
+        const yMin = floatingUi_utils.max(overflow.top, 0);
+        const yMax = floatingUi_utils.max(overflow.bottom, 0);
         if (isYAxis) {
-          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : index_esm.max(overflow.left, overflow.right));
+          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : floatingUi_utils.max(overflow.left, overflow.right));
         } else {
-          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : index_esm.max(overflow.top, overflow.bottom));
+          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : floatingUi_utils.max(overflow.top, overflow.bottom));
         }
       }
       await apply({
@@ -957,7 +957,7 @@ function getCssDimensions(element) {
   const hasOffset = floatingUi_utils_dom.isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = index_esm.round(width) !== offsetWidth || index_esm.round(height) !== offsetHeight;
+  const shouldFallback = floatingUi_utils.round(width) !== offsetWidth || floatingUi_utils.round(height) !== offsetHeight;
   if (shouldFallback) {
     width = offsetWidth;
     height = offsetHeight;
@@ -976,7 +976,7 @@ function unwrapElement(element) {
 function getScale(element) {
   const domElement = unwrapElement(element);
   if (!floatingUi_utils_dom.isHTMLElement(domElement)) {
-    return index_esm.createCoords(1);
+    return floatingUi_utils.createCoords(1);
   }
   const rect = domElement.getBoundingClientRect();
   const {
@@ -984,8 +984,8 @@ function getScale(element) {
     height,
     $
   } = getCssDimensions(domElement);
-  let x = ($ ? index_esm.round(rect.width) : rect.width) / width;
-  let y = ($ ? index_esm.round(rect.height) : rect.height) / height;
+  let x = ($ ? floatingUi_utils.round(rect.width) : rect.width) / width;
+  let y = ($ ? floatingUi_utils.round(rect.height) : rect.height) / height;
 
   // 0, NaN, or Infinity should always fallback to 1.
 
@@ -1001,7 +1001,7 @@ function getScale(element) {
   };
 }
 
-const noOffsets = /*#__PURE__*/index_esm.createCoords(0);
+const noOffsets = /*#__PURE__*/floatingUi_utils.createCoords(0);
 function getVisualOffsets(element) {
   const win = floatingUi_utils_dom.getWindow(element);
   if (!floatingUi_utils_dom.isWebKit() || !win.visualViewport) {
@@ -1031,7 +1031,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   }
   const clientRect = element.getBoundingClientRect();
   const domElement = unwrapElement(element);
-  let scale = index_esm.createCoords(1);
+  let scale = floatingUi_utils.createCoords(1);
   if (includeScale) {
     if (offsetParent) {
       if (floatingUi_utils_dom.isElement(offsetParent)) {
@@ -1041,7 +1041,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       scale = getScale(element);
     }
   }
-  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : index_esm.createCoords(0);
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : floatingUi_utils.createCoords(0);
   let x = (clientRect.left + visualOffsets.x) / scale.x;
   let y = (clientRect.top + visualOffsets.y) / scale.y;
   let width = clientRect.width / scale.x;
@@ -1067,7 +1067,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       currentIFrame = floatingUi_utils_dom.getFrameElement(currentWin);
     }
   }
-  return index_esm.rectToClientRect({
+  return floatingUi_utils.rectToClientRect({
     width,
     height,
     x,
@@ -1112,8 +1112,8 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     scrollLeft: 0,
     scrollTop: 0
   };
-  let scale = index_esm.createCoords(1);
-  const offsets = index_esm.createCoords(0);
+  let scale = floatingUi_utils.createCoords(1);
+  const offsets = floatingUi_utils.createCoords(0);
   const isOffsetParentAnElement = floatingUi_utils_dom.isHTMLElement(offsetParent);
   if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
     if (floatingUi_utils_dom.getNodeName(offsetParent) !== 'body' || floatingUi_utils_dom.isOverflowElement(documentElement)) {
@@ -1126,7 +1126,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
       offsets.y = offsetRect.y + offsetParent.clientTop;
     }
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : index_esm.createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : floatingUi_utils.createCoords(0);
   return {
     width: rect.width * scale.x,
     height: rect.height * scale.y,
@@ -1145,12 +1145,12 @@ function getDocumentRect(element) {
   const html = floatingUi_utils_dom.getDocumentElement(element);
   const scroll = floatingUi_utils_dom.getNodeScroll(element);
   const body = element.ownerDocument.body;
-  const width = index_esm.max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
-  const height = index_esm.max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  const width = floatingUi_utils.max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = floatingUi_utils.max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
   let x = -scroll.scrollLeft + getWindowScrollBarX(element);
   const y = -scroll.scrollTop;
   if (floatingUi_utils_dom.getComputedStyle(body).direction === 'rtl') {
-    x += index_esm.max(html.clientWidth, body.clientWidth) - width;
+    x += floatingUi_utils.max(html.clientWidth, body.clientWidth) - width;
   }
   return {
     width,
@@ -1212,7 +1212,7 @@ function getInnerBoundingClientRect(element, strategy) {
   const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
   const top = clientRect.top + element.clientTop;
   const left = clientRect.left + element.clientLeft;
-  const scale = floatingUi_utils_dom.isHTMLElement(element) ? getScale(element) : index_esm.createCoords(1);
+  const scale = floatingUi_utils_dom.isHTMLElement(element) ? getScale(element) : floatingUi_utils.createCoords(1);
   const width = element.clientWidth * scale.x;
   const height = element.clientHeight * scale.y;
   const x = left * scale.x;
@@ -1241,7 +1241,7 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
       height: clippingAncestor.height
     };
   }
-  return index_esm.rectToClientRect(rect);
+  return floatingUi_utils.rectToClientRect(rect);
 }
 function hasFixedPositionAncestor(element, stopNode) {
   const parentNode = floatingUi_utils_dom.getParentNode(element);
@@ -1303,10 +1303,10 @@ function getClippingRect(_ref) {
   let left = firstRect.left;
   for (let i = 1; i < clippingAncestors.length; i++) {
     const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
-    top = index_esm.max(rect.top, top);
-    right = index_esm.min(rect.right, right);
-    bottom = index_esm.min(rect.bottom, bottom);
-    left = index_esm.max(rect.left, left);
+    top = floatingUi_utils.max(rect.top, top);
+    right = floatingUi_utils.min(rect.right, right);
+    bottom = floatingUi_utils.min(rect.bottom, bottom);
+    left = floatingUi_utils.max(rect.left, left);
   }
   return {
     width: right - left,
@@ -1336,7 +1336,7 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
     scrollLeft: 0,
     scrollTop: 0
   };
-  const offsets = index_esm.createCoords(0);
+  const offsets = floatingUi_utils.createCoords(0);
 
   // 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.
@@ -1358,7 +1358,7 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
   if (isFixed && !isOffsetParentAnElement && documentElement) {
     setLeftRTLScrollbarOffset();
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : index_esm.createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : floatingUi_utils.createCoords(0);
   const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
   const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
   return {
@@ -1487,14 +1487,14 @@ function observeMove(element, onMove) {
     if (!width || !height) {
       return;
     }
-    const insetTop = index_esm.floor(top);
-    const insetRight = index_esm.floor(root.clientWidth - (left + width));
-    const insetBottom = index_esm.floor(root.clientHeight - (top + height));
-    const insetLeft = index_esm.floor(left);
+    const insetTop = floatingUi_utils.floor(top);
+    const insetRight = floatingUi_utils.floor(root.clientWidth - (left + width));
+    const insetBottom = floatingUi_utils.floor(root.clientHeight - (top + height));
+    const insetLeft = floatingUi_utils.floor(left);
     const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
     const options = {
       rootMargin,
-      threshold: index_esm.max(0, index_esm.min(1, threshold)) || 1
+      threshold: floatingUi_utils.max(0, floatingUi_utils.min(1, threshold)) || 1
     };
     let isFirstUpdate = true;
     function handleObserve(entries) {

package/dist/floating-ui.react-dom-es.js

@@ -1,4 +1,4 @@
-import { g as getSideAxis, b as getAlignmentAxis, c as getSide, d as getAlignment, e as evaluate, h as getPaddingObject, r as rectToClientRect, j as getOppositePlacement, k as getExpandedPlacements, l as getOppositeAxisPlacements, m as getAlignmentSides, n as clamp, o as min, p as max, q as getAxisLength, s as sides, u as getOppositeAxis, v as placements, w as getOppositeAlignmentPlacement, x as createCoords, y as round, f as floor } from './index.esm-es.js';
+import { g as getSideAxis, a as getAlignmentAxis, b as getSide, c as getAlignment, e as evaluate, d as getPaddingObject, r as rectToClientRect, h as getOppositePlacement, i as getExpandedPlacements, j as getOppositeAxisPlacements, k as getAlignmentSides, l as clamp, m as min, n as max, o as getAxisLength, s as sides, p as getOppositeAxis, q as placements, t as getOppositeAlignmentPlacement, u as createCoords, v as round, f as floor } from './floating-ui.utils-es.js';
 import { k as getDocumentElement, b as isElement, a as isHTMLElement, l as isTopLayer, g as getNodeName, m as isOverflowElement, n as getNodeScroll, o as getWindow, e as getParentNode, d as isLastTraversableNode, p as isTableElement, q as isContainingBlock, r as getContainingBlock, f as getComputedStyle$1, h as getOverflowAncestors, s as getFrameElement, j as isWebKit } from './floating-ui.utils.dom-es.js';
 import * as React from 'react';
 import { useLayoutEffect } from 'react';