@bigbinary/neeto-atoms 1.0.97 → 1.0.99

package/dist/cjs/{floating-ui.react-dom-B4Aw6O7R.js → floating-ui.react-dom--alWUjS1.js}

@@ -1,5 +1,6 @@
 'use strict';
 
+var floatingUi_utils_dom = require('./floating-ui.utils.dom-BGEmL7pd.js');
 var React = require('react');
 var ReactDOM = require('react-dom');
 
@@ -24,148 +25,15 @@ function _interopNamespace(e) {
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var ReactDOM__namespace = /*#__PURE__*/_interopNamespace(ReactDOM);
 
-/**
- * Custom positioning reference element.
- * @see https://floating-ui.com/docs/virtual-elements
- */
-
-const sides = ['top', 'right', 'bottom', 'left'];
-const min = Math.min;
-const max = Math.max;
-const round = Math.round;
-const floor = Math.floor;
-const createCoords = v => ({
-  x: v,
-  y: v
-});
-const oppositeSideMap = {
-  left: 'right',
-  right: 'left',
-  bottom: 'top',
-  top: 'bottom'
-};
-function clamp(start, value, end) {
-  return max(start, min(value, end));
-}
-function evaluate(value, param) {
-  return typeof value === 'function' ? value(param) : value;
-}
-function getSide(placement) {
-  return placement.split('-')[0];
-}
-function getAlignment(placement) {
-  return placement.split('-')[1];
-}
-function getOppositeAxis(axis) {
-  return axis === 'x' ? 'y' : 'x';
-}
-function getAxisLength(axis) {
-  return axis === 'y' ? 'height' : 'width';
-}
-function getSideAxis(placement) {
-  const firstChar = placement[0];
-  return firstChar === 't' || firstChar === 'b' ? 'y' : 'x';
-}
-function getAlignmentAxis(placement) {
-  return getOppositeAxis(getSideAxis(placement));
-}
-function getAlignmentSides(placement, rects, rtl) {
-  if (rtl === void 0) {
-    rtl = false;
-  }
-  const alignment = getAlignment(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const length = getAxisLength(alignmentAxis);
-  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
-  if (rects.reference[length] > rects.floating[length]) {
-    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
-  }
-  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
-}
-function getExpandedPlacements(placement) {
-  const oppositePlacement = getOppositePlacement(placement);
-  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
-}
-function getOppositeAlignmentPlacement(placement) {
-  return placement.includes('start') ? placement.replace('start', 'end') : placement.replace('end', 'start');
-}
-const lrPlacement = ['left', 'right'];
-const rlPlacement = ['right', 'left'];
-const tbPlacement = ['top', 'bottom'];
-const btPlacement = ['bottom', 'top'];
-function getSideList(side, isStart, rtl) {
-  switch (side) {
-    case 'top':
-    case 'bottom':
-      if (rtl) return isStart ? rlPlacement : lrPlacement;
-      return isStart ? lrPlacement : rlPlacement;
-    case 'left':
-    case 'right':
-      return isStart ? tbPlacement : btPlacement;
-    default:
-      return [];
-  }
-}
-function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
-  const alignment = getAlignment(placement);
-  let list = getSideList(getSide(placement), direction === 'start', rtl);
-  if (alignment) {
-    list = list.map(side => side + "-" + alignment);
-    if (flipAlignment) {
-      list = list.concat(list.map(getOppositeAlignmentPlacement));
-    }
-  }
-  return list;
-}
-function getOppositePlacement(placement) {
-  const side = getSide(placement);
-  return oppositeSideMap[side] + placement.slice(side.length);
-}
-function expandPaddingObject(padding) {
-  return {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0,
-    ...padding
-  };
-}
-function getPaddingObject(padding) {
-  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
-    top: padding,
-    right: padding,
-    bottom: padding,
-    left: padding
-  };
-}
-function rectToClientRect(rect) {
-  const {
-    x,
-    y,
-    width,
-    height
-  } = rect;
-  return {
-    width,
-    height,
-    top: y,
-    left: x,
-    right: x + width,
-    bottom: y + height,
-    x,
-    y
-  };
-}
-
 function computeCoordsFromPlacement(_ref, placement, rtl) {
   let {
     reference,
     floating
   } = _ref;
-  const sideAxis = getSideAxis(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const alignLength = getAxisLength(alignmentAxis);
-  const side = getSide(placement);
+  const sideAxis = floatingUi_utils_dom.getSideAxis(placement);
+  const alignmentAxis = floatingUi_utils_dom.getAlignmentAxis(placement);
+  const alignLength = floatingUi_utils_dom.getAxisLength(alignmentAxis);
+  const side = floatingUi_utils_dom.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;
@@ -202,7 +70,7 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
         y: reference.y
       };
   }
-  switch (getAlignment(placement)) {
+  switch (floatingUi_utils_dom.getAlignment(placement)) {
     case 'start':
       coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
@@ -240,11 +108,11 @@ async function detectOverflow(state, options) {
     elementContext = 'floating',
     altBoundary = false,
     padding = 0
-  } = evaluate(options, state);
-  const paddingObject = getPaddingObject(padding);
+  } = floatingUi_utils_dom.evaluate(options, state);
+  const paddingObject = floatingUi_utils_dom.getPaddingObject(padding);
   const altContext = elementContext === 'floating' ? 'reference' : 'floating';
   const element = elements[altBoundary ? altContext : elementContext];
-  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+  const clippingClientRect = floatingUi_utils_dom.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,
@@ -264,7 +132,7 @@ async function detectOverflow(state, options) {
     x: 1,
     y: 1
   };
-  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+  const elementClientRect = floatingUi_utils_dom.rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
     elements,
     rect,
     offsetParent,
@@ -398,17 +266,17 @@ const arrow$3 = options => ({
     const {
       element,
       padding = 0
-    } = evaluate(options, state) || {};
+    } = floatingUi_utils_dom.evaluate(options, state) || {};
     if (element == null) {
       return {};
     }
-    const paddingObject = getPaddingObject(padding);
+    const paddingObject = floatingUi_utils_dom.getPaddingObject(padding);
     const coords = {
       x,
       y
     };
-    const axis = getAlignmentAxis(placement);
-    const length = getAxisLength(axis);
+    const axis = floatingUi_utils_dom.getAlignmentAxis(placement);
+    const length = floatingUi_utils_dom.getAxisLength(axis);
     const arrowDimensions = await platform.getDimensions(element);
     const isYAxis = axis === 'y';
     const minProp = isYAxis ? 'top' : 'left';
@@ -428,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 = min(paddingObject[minProp], largestPossiblePadding);
-    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+    const minPadding = floatingUi_utils_dom.min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = floatingUi_utils_dom.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 = clamp(min$1, center, max);
+    const offset = floatingUi_utils_dom.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 shouldAddOffset = !middlewareData.arrow && floatingUi_utils_dom.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,
@@ -489,7 +357,7 @@ const flip$2 = function (options) {
         fallbackAxisSideDirection = 'none',
         flipAlignment = true,
         ...detectOverflowOptions
-      } = evaluate(options, state);
+      } = floatingUi_utils_dom.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
@@ -498,14 +366,14 @@ const flip$2 = function (options) {
       if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
       }
-      const side = getSide(placement);
-      const initialSideAxis = getSideAxis(initialPlacement);
-      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const side = floatingUi_utils_dom.getSide(placement);
+      const initialSideAxis = floatingUi_utils_dom.getSideAxis(initialPlacement);
+      const isBasePlacement = floatingUi_utils_dom.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 fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [floatingUi_utils_dom.getOppositePlacement(initialPlacement)] : floatingUi_utils_dom.getExpandedPlacements(initialPlacement));
       const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
       if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
-        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+        fallbackPlacements.push(...floatingUi_utils_dom.getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
       const placements = [initialPlacement, ...fallbackPlacements];
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
@@ -515,7 +383,7 @@ const flip$2 = function (options) {
         overflows.push(overflow[side]);
       }
       if (checkCrossAxis) {
-        const sides = getAlignmentSides(placement, rects, rtl);
+        const sides = floatingUi_utils_dom.getAlignmentSides(placement, rects, rtl);
         overflows.push(overflow[sides[0]], overflow[sides[1]]);
       }
       overflowsData = [...overflowsData, {
@@ -529,11 +397,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 !== getSideAxis(nextPlacement) : false;
+          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== floatingUi_utils_dom.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)) {
+          overflowsData.every(d => floatingUi_utils_dom.getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
             // Try next placement and re-run the lifecycle.
             return {
               data: {
@@ -559,7 +427,7 @@ const flip$2 = function (options) {
                 var _overflowsData$filter2;
                 const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
                   if (hasFallbackAxisSideDirection) {
-                    const currentSideAxis = getSideAxis(d.placement);
+                    const currentSideAxis = floatingUi_utils_dom.getSideAxis(d.placement);
                     return currentSideAxis === initialSideAxis ||
                     // Create a bias to the `y` side axis due to horizontal
                     // reading directions favoring greater width.
@@ -599,7 +467,7 @@ function getSideOffsets(overflow, rect) {
   };
 }
 function isAnySideFullyClipped(overflow) {
-  return sides.some(side => overflow[side] >= 0);
+  return floatingUi_utils_dom.sides.some(side => overflow[side] >= 0);
 }
 /**
  * Provides data to hide the floating element in applicable situations, such as
@@ -621,7 +489,7 @@ const hide$2 = function (options) {
       const {
         strategy = 'referenceHidden',
         ...detectOverflowOptions
-      } = evaluate(options, state);
+      } = floatingUi_utils_dom.evaluate(options, state);
       switch (strategy) {
         case 'referenceHidden':
           {
@@ -672,12 +540,12 @@ async function convertValueToCoords(state, options) {
     elements
   } = state;
   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 side = floatingUi_utils_dom.getSide(placement);
+  const alignment = floatingUi_utils_dom.getAlignment(placement);
+  const isVertical = floatingUi_utils_dom.getSideAxis(placement) === 'y';
   const mainAxisMulti = originSides.has(side) ? -1 : 1;
   const crossAxisMulti = rtl && isVertical ? -1 : 1;
-  const rawValue = evaluate(options, state);
+  const rawValue = floatingUi_utils_dom.evaluate(options, state);
 
   // eslint-disable-next-line prefer-const
   let {
@@ -781,14 +649,14 @@ const shift$2 = function (options) {
           }
         },
         ...detectOverflowOptions
-      } = evaluate(options, state);
+      } = floatingUi_utils_dom.evaluate(options, state);
       const coords = {
         x,
         y
       };
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
-      const crossAxis = getSideAxis(getSide(placement));
-      const mainAxis = getOppositeAxis(crossAxis);
+      const crossAxis = floatingUi_utils_dom.getSideAxis(floatingUi_utils_dom.getSide(placement));
+      const mainAxis = floatingUi_utils_dom.getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
       let crossAxisCoord = coords[crossAxis];
       if (checkMainAxis) {
@@ -796,14 +664,14 @@ const shift$2 = function (options) {
         const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
         const min = mainAxisCoord + overflow[minSide];
         const max = mainAxisCoord - overflow[maxSide];
-        mainAxisCoord = clamp(min, mainAxisCoord, max);
+        mainAxisCoord = floatingUi_utils_dom.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 = clamp(min, crossAxisCoord, max);
+        crossAxisCoord = floatingUi_utils_dom.clamp(min, crossAxisCoord, max);
       }
       const limitedCoords = limiter.fn({
         ...state,
@@ -845,16 +713,16 @@ const limitShift$2 = function (options) {
         offset = 0,
         mainAxis: checkMainAxis = true,
         crossAxis: checkCrossAxis = true
-      } = evaluate(options, state);
+      } = floatingUi_utils_dom.evaluate(options, state);
       const coords = {
         x,
         y
       };
-      const crossAxis = getSideAxis(placement);
-      const mainAxis = getOppositeAxis(crossAxis);
+      const crossAxis = floatingUi_utils_dom.getSideAxis(placement);
+      const mainAxis = floatingUi_utils_dom.getOppositeAxis(crossAxis);
       let mainAxisCoord = coords[mainAxis];
       let crossAxisCoord = coords[crossAxis];
-      const rawOffset = evaluate(offset, state);
+      const rawOffset = floatingUi_utils_dom.evaluate(offset, state);
       const computedOffset = typeof rawOffset === 'number' ? {
         mainAxis: rawOffset,
         crossAxis: 0
@@ -876,7 +744,7 @@ const limitShift$2 = function (options) {
       if (checkCrossAxis) {
         var _middlewareData$offse, _middlewareData$offse2;
         const len = mainAxis === 'y' ? 'width' : 'height';
-        const isOriginSide = originSides.has(getSide(placement));
+        const isOriginSide = originSides.has(floatingUi_utils_dom.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) {
@@ -917,11 +785,11 @@ const size$2 = function (options) {
       const {
         apply = () => {},
         ...detectOverflowOptions
-      } = evaluate(options, state);
+      } = floatingUi_utils_dom.evaluate(options, state);
       const overflow = await platform.detectOverflow(state, detectOverflowOptions);
-      const side = getSide(placement);
-      const alignment = getAlignment(placement);
-      const isYAxis = getSideAxis(placement) === 'y';
+      const side = floatingUi_utils_dom.getSide(placement);
+      const alignment = floatingUi_utils_dom.getAlignment(placement);
+      const isYAxis = floatingUi_utils_dom.getSideAxis(placement) === 'y';
       const {
         width,
         height
@@ -937,8 +805,8 @@ const size$2 = function (options) {
       }
       const maximumClippingHeight = height - overflow.top - overflow.bottom;
       const maximumClippingWidth = width - overflow.left - overflow.right;
-      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
-      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
+      const overflowAvailableHeight = floatingUi_utils_dom.min(height - overflow[heightSide], maximumClippingHeight);
+      const overflowAvailableWidth = floatingUi_utils_dom.min(width - overflow[widthSide], maximumClippingWidth);
       const noShift = !state.middlewareData.shift;
       let availableHeight = overflowAvailableHeight;
       let availableWidth = overflowAvailableWidth;
@@ -949,14 +817,14 @@ const size$2 = function (options) {
         availableHeight = maximumClippingHeight;
       }
       if (noShift && !alignment) {
-        const xMin = max(overflow.left, 0);
-        const xMax = max(overflow.right, 0);
-        const yMin = max(overflow.top, 0);
-        const yMax = max(overflow.bottom, 0);
+        const xMin = floatingUi_utils_dom.max(overflow.left, 0);
+        const xMax = floatingUi_utils_dom.max(overflow.right, 0);
+        const yMin = floatingUi_utils_dom.max(overflow.top, 0);
+        const yMax = floatingUi_utils_dom.max(overflow.bottom, 0);
         if (isYAxis) {
-          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
+          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : floatingUi_utils_dom.max(overflow.left, overflow.right));
         } else {
-          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
+          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : floatingUi_utils_dom.max(overflow.top, overflow.bottom));
         }
       }
       await apply({
@@ -977,180 +845,16 @@ const size$2 = function (options) {
   };
 };
 
-function hasWindow() {
-  return typeof window !== 'undefined';
-}
-function getNodeName(node) {
-  if (isNode(node)) {
-    return (node.nodeName || '').toLowerCase();
-  }
-  // Mocked nodes in testing environments may not be instances of Node. By
-  // returning `#document` an infinite loop won't occur.
-  // https://github.com/floating-ui/floating-ui/issues/2317
-  return '#document';
-}
-function getWindow(node) {
-  var _node$ownerDocument;
-  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
-}
-function getDocumentElement(node) {
-  var _ref;
-  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
-}
-function isNode(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Node || value instanceof getWindow(value).Node;
-}
-function isElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof Element || value instanceof getWindow(value).Element;
-}
-function isHTMLElement(value) {
-  if (!hasWindow()) {
-    return false;
-  }
-  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
-}
-function isShadowRoot(value) {
-  if (!hasWindow() || typeof ShadowRoot === 'undefined') {
-    return false;
-  }
-  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
-}
-function isOverflowElement(element) {
-  const {
-    overflow,
-    overflowX,
-    overflowY,
-    display
-  } = getComputedStyle$1(element);
-  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== 'inline' && display !== 'contents';
-}
-function isTableElement(element) {
-  return /^(table|td|th)$/.test(getNodeName(element));
-}
-function isTopLayer(element) {
-  try {
-    if (element.matches(':popover-open')) {
-      return true;
-    }
-  } catch (_e) {
-    // no-op
-  }
-  try {
-    return element.matches(':modal');
-  } catch (_e) {
-    return false;
-  }
-}
-const willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
-const containRe = /paint|layout|strict|content/;
-const isNotNone = value => !!value && value !== 'none';
-let isWebKitValue;
-function isContainingBlock(elementOrCss) {
-  const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
-
-  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  // https://drafts.csswg.org/css-transforms-2/#individual-transforms
-  return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || '') || containRe.test(css.contain || '');
-}
-function getContainingBlock(element) {
-  let currentNode = getParentNode(element);
-  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    if (isContainingBlock(currentNode)) {
-      return currentNode;
-    } else if (isTopLayer(currentNode)) {
-      return null;
-    }
-    currentNode = getParentNode(currentNode);
-  }
-  return null;
-}
-function isWebKit() {
-  if (isWebKitValue == null) {
-    isWebKitValue = typeof CSS !== 'undefined' && CSS.supports && CSS.supports('-webkit-backdrop-filter', 'none');
-  }
-  return isWebKitValue;
-}
-function isLastTraversableNode(node) {
-  return /^(html|body|#document)$/.test(getNodeName(node));
-}
-function getComputedStyle$1(element) {
-  return getWindow(element).getComputedStyle(element);
-}
-function getNodeScroll(element) {
-  if (isElement(element)) {
-    return {
-      scrollLeft: element.scrollLeft,
-      scrollTop: element.scrollTop
-    };
-  }
-  return {
-    scrollLeft: element.scrollX,
-    scrollTop: element.scrollY
-  };
-}
-function getParentNode(node) {
-  if (getNodeName(node) === 'html') {
-    return node;
-  }
-  const result =
-  // Step into the shadow DOM of the parent of a slotted node.
-  node.assignedSlot ||
-  // DOM Element detected.
-  node.parentNode ||
-  // ShadowRoot detected.
-  isShadowRoot(node) && node.host ||
-  // Fallback.
-  getDocumentElement(node);
-  return isShadowRoot(result) ? result.host : result;
-}
-function getNearestOverflowAncestor(node) {
-  const parentNode = getParentNode(node);
-  if (isLastTraversableNode(parentNode)) {
-    return node.ownerDocument ? node.ownerDocument.body : node.body;
-  }
-  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
-    return parentNode;
-  }
-  return getNearestOverflowAncestor(parentNode);
-}
-function getOverflowAncestors(node, list, traverseIframes) {
-  var _node$ownerDocument2;
-  if (list === void 0) {
-    list = [];
-  }
-  if (traverseIframes === void 0) {
-    traverseIframes = true;
-  }
-  const scrollableAncestor = getNearestOverflowAncestor(node);
-  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
-  const win = getWindow(scrollableAncestor);
-  if (isBody) {
-    const frameElement = getFrameElement(win);
-    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
-  } else {
-    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
-  }
-}
-function getFrameElement(win) {
-  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
-}
-
 function getCssDimensions(element) {
-  const css = getComputedStyle$1(element);
+  const css = floatingUi_utils_dom.getComputedStyle(element);
   // In testing environments, the `width` and `height` properties are empty
   // strings for SVG elements, returning NaN. Fallback to `0` in this case.
   let width = parseFloat(css.width) || 0;
   let height = parseFloat(css.height) || 0;
-  const hasOffset = isHTMLElement(element);
+  const hasOffset = floatingUi_utils_dom.isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  const shouldFallback = floatingUi_utils_dom.round(width) !== offsetWidth || floatingUi_utils_dom.round(height) !== offsetHeight;
   if (shouldFallback) {
     width = offsetWidth;
     height = offsetHeight;
@@ -1163,13 +867,13 @@ function getCssDimensions(element) {
 }
 
 function unwrapElement(element) {
-  return !isElement(element) ? element.contextElement : element;
+  return !floatingUi_utils_dom.isElement(element) ? element.contextElement : element;
 }
 
 function getScale(element) {
   const domElement = unwrapElement(element);
-  if (!isHTMLElement(domElement)) {
-    return createCoords(1);
+  if (!floatingUi_utils_dom.isHTMLElement(domElement)) {
+    return floatingUi_utils_dom.createCoords(1);
   }
   const rect = domElement.getBoundingClientRect();
   const {
@@ -1177,8 +881,8 @@ function getScale(element) {
     height,
     $
   } = getCssDimensions(domElement);
-  let x = ($ ? round(rect.width) : rect.width) / width;
-  let y = ($ ? round(rect.height) : rect.height) / height;
+  let x = ($ ? floatingUi_utils_dom.round(rect.width) : rect.width) / width;
+  let y = ($ ? floatingUi_utils_dom.round(rect.height) : rect.height) / height;
 
   // 0, NaN, or Infinity should always fallback to 1.
 
@@ -1194,10 +898,10 @@ function getScale(element) {
   };
 }
 
-const noOffsets = /*#__PURE__*/createCoords(0);
+const noOffsets = /*#__PURE__*/floatingUi_utils_dom.createCoords(0);
 function getVisualOffsets(element) {
-  const win = getWindow(element);
-  if (!isWebKit() || !win.visualViewport) {
+  const win = floatingUi_utils_dom.getWindow(element);
+  if (!floatingUi_utils_dom.isWebKit() || !win.visualViewport) {
     return noOffsets;
   }
   return {
@@ -1209,7 +913,7 @@ function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
   if (isFixed === void 0) {
     isFixed = false;
   }
-  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== floatingUi_utils_dom.getWindow(element)) {
     return false;
   }
   return isFixed;
@@ -1224,30 +928,30 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   }
   const clientRect = element.getBoundingClientRect();
   const domElement = unwrapElement(element);
-  let scale = createCoords(1);
+  let scale = floatingUi_utils_dom.createCoords(1);
   if (includeScale) {
     if (offsetParent) {
-      if (isElement(offsetParent)) {
+      if (floatingUi_utils_dom.isElement(offsetParent)) {
         scale = getScale(offsetParent);
       }
     } else {
       scale = getScale(element);
     }
   }
-  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : floatingUi_utils_dom.createCoords(0);
   let x = (clientRect.left + visualOffsets.x) / scale.x;
   let y = (clientRect.top + visualOffsets.y) / scale.y;
   let width = clientRect.width / scale.x;
   let height = clientRect.height / scale.y;
   if (domElement) {
-    const win = getWindow(domElement);
-    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    const win = floatingUi_utils_dom.getWindow(domElement);
+    const offsetWin = offsetParent && floatingUi_utils_dom.isElement(offsetParent) ? floatingUi_utils_dom.getWindow(offsetParent) : offsetParent;
     let currentWin = win;
-    let currentIFrame = getFrameElement(currentWin);
+    let currentIFrame = floatingUi_utils_dom.getFrameElement(currentWin);
     while (currentIFrame && offsetParent && offsetWin !== currentWin) {
       const iframeScale = getScale(currentIFrame);
       const iframeRect = currentIFrame.getBoundingClientRect();
-      const css = getComputedStyle$1(currentIFrame);
+      const css = floatingUi_utils_dom.getComputedStyle(currentIFrame);
       const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
       const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
       x *= iframeScale.x;
@@ -1256,11 +960,11 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       height *= iframeScale.y;
       x += left;
       y += top;
-      currentWin = getWindow(currentIFrame);
-      currentIFrame = getFrameElement(currentWin);
+      currentWin = floatingUi_utils_dom.getWindow(currentIFrame);
+      currentIFrame = floatingUi_utils_dom.getFrameElement(currentWin);
     }
   }
-  return rectToClientRect({
+  return floatingUi_utils_dom.rectToClientRect({
     width,
     height,
     x,
@@ -1271,9 +975,9 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
 // If <html> has a CSS width greater than the viewport, then this will be
 // incorrect for RTL.
 function getWindowScrollBarX(element, rect) {
-  const leftScroll = getNodeScroll(element).scrollLeft;
+  const leftScroll = floatingUi_utils_dom.getNodeScroll(element).scrollLeft;
   if (!rect) {
-    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+    return getBoundingClientRect(floatingUi_utils_dom.getDocumentElement(element)).left + leftScroll;
   }
   return rect.left + leftScroll;
 }
@@ -1296,8 +1000,8 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     strategy
   } = _ref;
   const isFixed = strategy === 'fixed';
-  const documentElement = getDocumentElement(offsetParent);
-  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  const documentElement = floatingUi_utils_dom.getDocumentElement(offsetParent);
+  const topLayer = elements ? floatingUi_utils_dom.isTopLayer(elements.floating) : false;
   if (offsetParent === documentElement || topLayer && isFixed) {
     return rect;
   }
@@ -1305,12 +1009,12 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     scrollLeft: 0,
     scrollTop: 0
   };
-  let scale = createCoords(1);
-  const offsets = createCoords(0);
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  let scale = floatingUi_utils_dom.createCoords(1);
+  const offsets = floatingUi_utils_dom.createCoords(0);
+  const isOffsetParentAnElement = floatingUi_utils_dom.isHTMLElement(offsetParent);
   if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-      scroll = getNodeScroll(offsetParent);
+    if (floatingUi_utils_dom.getNodeName(offsetParent) !== 'body' || floatingUi_utils_dom.isOverflowElement(documentElement)) {
+      scroll = floatingUi_utils_dom.getNodeScroll(offsetParent);
     }
     if (isOffsetParentAnElement) {
       const offsetRect = getBoundingClientRect(offsetParent);
@@ -1319,7 +1023,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
       offsets.y = offsetRect.y + offsetParent.clientTop;
     }
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : floatingUi_utils_dom.createCoords(0);
   return {
     width: rect.width * scale.x,
     height: rect.height * scale.y,
@@ -1335,15 +1039,15 @@ function getClientRects(element) {
 // Gets the entire size of the scrollable document area, even extending outside
 // of the `<html>` and `<body>` rect bounds if horizontally scrollable.
 function getDocumentRect(element) {
-  const html = getDocumentElement(element);
-  const scroll = getNodeScroll(element);
+  const html = floatingUi_utils_dom.getDocumentElement(element);
+  const scroll = floatingUi_utils_dom.getNodeScroll(element);
   const body = element.ownerDocument.body;
-  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
-  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  const width = floatingUi_utils_dom.max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = floatingUi_utils_dom.max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
   let x = -scroll.scrollLeft + getWindowScrollBarX(element);
   const y = -scroll.scrollTop;
-  if (getComputedStyle$1(body).direction === 'rtl') {
-    x += max(html.clientWidth, body.clientWidth) - width;
+  if (floatingUi_utils_dom.getComputedStyle(body).direction === 'rtl') {
+    x += floatingUi_utils_dom.max(html.clientWidth, body.clientWidth) - width;
   }
   return {
     width,
@@ -1358,8 +1062,8 @@ function getDocumentRect(element) {
 // Most scrollbars leave 15-18px of space.
 const SCROLLBAR_MAX = 25;
 function getViewportRect(element, strategy) {
-  const win = getWindow(element);
-  const html = getDocumentElement(element);
+  const win = floatingUi_utils_dom.getWindow(element);
+  const html = floatingUi_utils_dom.getDocumentElement(element);
   const visualViewport = win.visualViewport;
   let width = html.clientWidth;
   let height = html.clientHeight;
@@ -1368,7 +1072,7 @@ function getViewportRect(element, strategy) {
   if (visualViewport) {
     width = visualViewport.width;
     height = visualViewport.height;
-    const visualViewportBased = isWebKit();
+    const visualViewportBased = floatingUi_utils_dom.isWebKit();
     if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
       x = visualViewport.offsetLeft;
       y = visualViewport.offsetTop;
@@ -1405,7 +1109,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 = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const scale = floatingUi_utils_dom.isHTMLElement(element) ? getScale(element) : floatingUi_utils_dom.createCoords(1);
   const width = element.clientWidth * scale.x;
   const height = element.clientHeight * scale.y;
   const x = left * scale.x;
@@ -1422,8 +1126,8 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
   if (clippingAncestor === 'viewport') {
     rect = getViewportRect(element, strategy);
   } else if (clippingAncestor === 'document') {
-    rect = getDocumentRect(getDocumentElement(element));
-  } else if (isElement(clippingAncestor)) {
+    rect = getDocumentRect(floatingUi_utils_dom.getDocumentElement(element));
+  } else if (floatingUi_utils_dom.isElement(clippingAncestor)) {
     rect = getInnerBoundingClientRect(clippingAncestor, strategy);
   } else {
     const visualOffsets = getVisualOffsets(element);
@@ -1434,14 +1138,14 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
       height: clippingAncestor.height
     };
   }
-  return rectToClientRect(rect);
+  return floatingUi_utils_dom.rectToClientRect(rect);
 }
 function hasFixedPositionAncestor(element, stopNode) {
-  const parentNode = getParentNode(element);
-  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+  const parentNode = floatingUi_utils_dom.getParentNode(element);
+  if (parentNode === stopNode || !floatingUi_utils_dom.isElement(parentNode) || floatingUi_utils_dom.isLastTraversableNode(parentNode)) {
     return false;
   }
-  return getComputedStyle$1(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+  return floatingUi_utils_dom.getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
 }
 
 // A "clipping ancestor" is an `overflow` element with the characteristic of
@@ -1452,19 +1156,19 @@ function getClippingElementAncestors(element, cache) {
   if (cachedResult) {
     return cachedResult;
   }
-  let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
+  let result = floatingUi_utils_dom.getOverflowAncestors(element, [], false).filter(el => floatingUi_utils_dom.isElement(el) && floatingUi_utils_dom.getNodeName(el) !== 'body');
   let currentContainingBlockComputedStyle = null;
-  const elementIsFixed = getComputedStyle$1(element).position === 'fixed';
-  let currentNode = elementIsFixed ? getParentNode(element) : element;
+  const elementIsFixed = floatingUi_utils_dom.getComputedStyle(element).position === 'fixed';
+  let currentNode = elementIsFixed ? floatingUi_utils_dom.getParentNode(element) : element;
 
   // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
-    const computedStyle = getComputedStyle$1(currentNode);
-    const currentNodeIsContaining = isContainingBlock(currentNode);
+  while (floatingUi_utils_dom.isElement(currentNode) && !floatingUi_utils_dom.isLastTraversableNode(currentNode)) {
+    const computedStyle = floatingUi_utils_dom.getComputedStyle(currentNode);
+    const currentNodeIsContaining = floatingUi_utils_dom.isContainingBlock(currentNode);
     if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
       currentContainingBlockComputedStyle = null;
     }
-    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === 'absolute' || currentContainingBlockComputedStyle.position === 'fixed') || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === 'absolute' || currentContainingBlockComputedStyle.position === 'fixed') || floatingUi_utils_dom.isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
     if (shouldDropCurrentNode) {
       // Drop non-containing blocks.
       result = result.filter(ancestor => ancestor !== currentNode);
@@ -1472,7 +1176,7 @@ function getClippingElementAncestors(element, cache) {
       // Record last containing block for next iteration.
       currentContainingBlockComputedStyle = computedStyle;
     }
-    currentNode = getParentNode(currentNode);
+    currentNode = floatingUi_utils_dom.getParentNode(currentNode);
   }
   cache.set(element, result);
   return result;
@@ -1487,7 +1191,7 @@ function getClippingRect(_ref) {
     rootBoundary,
     strategy
   } = _ref;
-  const elementClippingAncestors = boundary === 'clippingAncestors' ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const elementClippingAncestors = boundary === 'clippingAncestors' ? floatingUi_utils_dom.isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
   const clippingAncestors = [...elementClippingAncestors, rootBoundary];
   const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
   let top = firstRect.top;
@@ -1496,10 +1200,10 @@ function getClippingRect(_ref) {
   let left = firstRect.left;
   for (let i = 1; i < clippingAncestors.length; i++) {
     const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
-    top = max(rect.top, top);
-    right = min(rect.right, right);
-    bottom = min(rect.bottom, bottom);
-    left = max(rect.left, left);
+    top = floatingUi_utils_dom.max(rect.top, top);
+    right = floatingUi_utils_dom.min(rect.right, right);
+    bottom = floatingUi_utils_dom.min(rect.bottom, bottom);
+    left = floatingUi_utils_dom.max(rect.left, left);
   }
   return {
     width: right - left,
@@ -1521,15 +1225,15 @@ function getDimensions(element) {
 }
 
 function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-  const isOffsetParentAnElement = isHTMLElement(offsetParent);
-  const documentElement = getDocumentElement(offsetParent);
+  const isOffsetParentAnElement = floatingUi_utils_dom.isHTMLElement(offsetParent);
+  const documentElement = floatingUi_utils_dom.getDocumentElement(offsetParent);
   const isFixed = strategy === 'fixed';
   const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
   let scroll = {
     scrollLeft: 0,
     scrollTop: 0
   };
-  const offsets = createCoords(0);
+  const offsets = floatingUi_utils_dom.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.
@@ -1537,8 +1241,8 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
     offsets.x = getWindowScrollBarX(documentElement);
   }
   if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
-      scroll = getNodeScroll(offsetParent);
+    if (floatingUi_utils_dom.getNodeName(offsetParent) !== 'body' || floatingUi_utils_dom.isOverflowElement(documentElement)) {
+      scroll = floatingUi_utils_dom.getNodeScroll(offsetParent);
     }
     if (isOffsetParentAnElement) {
       const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
@@ -1551,7 +1255,7 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
   if (isFixed && !isOffsetParentAnElement && documentElement) {
     setLeftRTLScrollbarOffset();
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : floatingUi_utils_dom.createCoords(0);
   const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
   const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
   return {
@@ -1563,11 +1267,11 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
 }
 
 function isStaticPositioned(element) {
-  return getComputedStyle$1(element).position === 'static';
+  return floatingUi_utils_dom.getComputedStyle(element).position === 'static';
 }
 
 function getTrueOffsetParent(element, polyfill) {
-  if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
+  if (!floatingUi_utils_dom.isHTMLElement(element) || floatingUi_utils_dom.getComputedStyle(element).position === 'fixed') {
     return null;
   }
   if (polyfill) {
@@ -1579,7 +1283,7 @@ function getTrueOffsetParent(element, polyfill) {
   // 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(element) === rawOffsetParent) {
+  if (floatingUi_utils_dom.getDocumentElement(element) === rawOffsetParent) {
     rawOffsetParent = rawOffsetParent.ownerDocument.body;
   }
   return rawOffsetParent;
@@ -1588,28 +1292,28 @@ function getTrueOffsetParent(element, polyfill) {
 // Gets the closest ancestor positioned element. Handles some edge cases,
 // such as table ancestors and cross browser bugs.
 function getOffsetParent(element, polyfill) {
-  const win = getWindow(element);
-  if (isTopLayer(element)) {
+  const win = floatingUi_utils_dom.getWindow(element);
+  if (floatingUi_utils_dom.isTopLayer(element)) {
     return win;
   }
-  if (!isHTMLElement(element)) {
-    let svgOffsetParent = getParentNode(element);
-    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
-      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+  if (!floatingUi_utils_dom.isHTMLElement(element)) {
+    let svgOffsetParent = floatingUi_utils_dom.getParentNode(element);
+    while (svgOffsetParent && !floatingUi_utils_dom.isLastTraversableNode(svgOffsetParent)) {
+      if (floatingUi_utils_dom.isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
         return svgOffsetParent;
       }
-      svgOffsetParent = getParentNode(svgOffsetParent);
+      svgOffsetParent = floatingUi_utils_dom.getParentNode(svgOffsetParent);
     }
     return win;
   }
   let offsetParent = getTrueOffsetParent(element, polyfill);
-  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+  while (offsetParent && floatingUi_utils_dom.isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
     offsetParent = getTrueOffsetParent(offsetParent, polyfill);
   }
-  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+  if (offsetParent && floatingUi_utils_dom.isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !floatingUi_utils_dom.isContainingBlock(offsetParent)) {
     return win;
   }
-  return offsetParent || getContainingBlock(element) || win;
+  return offsetParent || floatingUi_utils_dom.getContainingBlock(element) || win;
 }
 
 const getElementRects = async function (data) {
@@ -1628,19 +1332,19 @@ const getElementRects = async function (data) {
 };
 
 function isRTL(element) {
-  return getComputedStyle$1(element).direction === 'rtl';
+  return floatingUi_utils_dom.getComputedStyle(element).direction === 'rtl';
 }
 
 const platform = {
   convertOffsetParentRelativeRectToViewportRelativeRect,
-  getDocumentElement,
+  getDocumentElement: floatingUi_utils_dom.getDocumentElement,
   getClippingRect,
   getOffsetParent,
   getElementRects,
   getClientRects,
   getDimensions,
   getScale,
-  isElement,
+  isElement: floatingUi_utils_dom.isElement,
   isRTL
 };
 
@@ -1652,7 +1356,7 @@ function rectsAreEqual(a, b) {
 function observeMove(element, onMove) {
   let io = null;
   let timeoutId;
-  const root = getDocumentElement(element);
+  const root = floatingUi_utils_dom.getDocumentElement(element);
   function cleanup() {
     var _io;
     clearTimeout(timeoutId);
@@ -1680,14 +1384,14 @@ function observeMove(element, onMove) {
     if (!width || !height) {
       return;
     }
-    const insetTop = floor(top);
-    const insetRight = floor(root.clientWidth - (left + width));
-    const insetBottom = floor(root.clientHeight - (top + height));
-    const insetLeft = floor(left);
+    const insetTop = floatingUi_utils_dom.floor(top);
+    const insetRight = floatingUi_utils_dom.floor(root.clientWidth - (left + width));
+    const insetBottom = floatingUi_utils_dom.floor(root.clientHeight - (top + height));
+    const insetLeft = floatingUi_utils_dom.floor(left);
     const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
     const options = {
       rootMargin,
-      threshold: max(0, min(1, threshold)) || 1
+      threshold: floatingUi_utils_dom.max(0, floatingUi_utils_dom.min(1, threshold)) || 1
     };
     let isFirstUpdate = true;
     function handleObserve(entries) {
@@ -1756,7 +1460,7 @@ function autoUpdate(reference, floating, update, options) {
     animationFrame = false
   } = options;
   const referenceEl = unwrapElement(reference);
-  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...(floating ? getOverflowAncestors(floating) : [])] : [];
+  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? floatingUi_utils_dom.getOverflowAncestors(referenceEl) : []), ...(floating ? floatingUi_utils_dom.getOverflowAncestors(floating) : [])] : [];
   ancestors.forEach(ancestor => {
     ancestorScroll && ancestor.addEventListener('scroll', update, {
       passive: true
@@ -2263,31 +1967,11 @@ const arrow = (options, deps) => {
 
 exports.arrow = arrow;
 exports.autoUpdate = autoUpdate;
-exports.clamp = clamp;
-exports.evaluate = evaluate;
 exports.flip = flip;
-exports.floor = floor;
-exports.getAlignment = getAlignment;
-exports.getAlignmentAxis = getAlignmentAxis;
-exports.getAxisLength = getAxisLength;
-exports.getComputedStyle = getComputedStyle$1;
-exports.getNodeName = getNodeName;
-exports.getPaddingObject = getPaddingObject;
-exports.getParentNode = getParentNode;
-exports.getSide = getSide;
-exports.getSideAxis = getSideAxis;
-exports.getWindow = getWindow;
 exports.hide = hide;
-exports.isElement = isElement;
-exports.isHTMLElement = isHTMLElement;
-exports.isLastTraversableNode = isLastTraversableNode;
-exports.isNode = isNode;
-exports.isOverflowElement = isOverflowElement;
-exports.isShadowRoot = isShadowRoot;
-exports.isWebKit = isWebKit;
 exports.limitShift = limitShift;
 exports.offset = offset;
 exports.shift = shift;
 exports.size = size;
 exports.useFloating = useFloating;
-//# sourceMappingURL=floating-ui.react-dom-B4Aw6O7R.js.map
+//# sourceMappingURL=floating-ui.react-dom--alWUjS1.js.map