@jobber/components 9.3.0 → 9.5.0

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

@@ -1,7 +1,6 @@
 'use strict';
 
 var React = require('react');
-var floatingUi_utils_dom = require('./floating-ui.utils.dom-cjs.js');
 var floatingUi_utils = require('./floating-ui.utils-cjs.js');
 var jsxRuntime = require('react/jsx-runtime');
 var ReactDOM = require('react-dom');
@@ -663,7 +662,7 @@ function contains(parent, child) {
   }
 
   // then fallback to custom implementation with Shadow DOM support
-  if (rootNode && floatingUi_utils_dom.isShadowRoot(rootNode)) {
+  if (rootNode && floatingUi_utils.isShadowRoot(rootNode)) {
     let next = child;
     while (next) {
       if (parent === next) {
@@ -705,7 +704,7 @@ function getDocument$1(node) {
   return (node == null ? void 0 : node.ownerDocument) || document;
 }
 function isTypeableElement(element) {
-  return floatingUi_utils_dom.isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
+  return floatingUi_utils.isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
 }
 function isTypeableCombobox(element) {
   if (!element) return false;
@@ -1227,7 +1226,7 @@ const FloatingArrow = /*#__PURE__*/React__namespace.forwardRef(function Floating
   // https://github.com/floating-ui/floating-ui/issues/2932
   index(() => {
     if (!floating) return;
-    const isRTL = floatingUi_utils_dom.getComputedStyle(floating).direction === 'rtl';
+    const isRTL = floatingUi_utils.getComputedStyle(floating).direction === 'rtl';
     if (isRTL) {
       setIsRTL(true);
     }
@@ -1500,7 +1499,7 @@ function applyAttributeToOthers(uncorrectedAvoidElements, body, ariaHidden, iner
       return;
     }
     [].forEach.call(parent.children, node => {
-      if (floatingUi_utils_dom.getNodeName(node) === 'script') return;
+      if (floatingUi_utils.getNodeName(node) === 'script') return;
       if (elementsToKeep.has(node)) {
         deep(node);
       } else {
@@ -1654,7 +1653,7 @@ function useFloatingPortalNode(props) {
     if (!uniqueId) return;
     if (portalNodeRef.current) return;
     let container = root || (portalContext == null ? void 0 : portalContext.portalNode);
-    if (container && !floatingUi_utils_dom.isNode(container)) container = container.current;
+    if (container && !floatingUi_utils.isNode(container)) container = container.current;
     container = container || document.body;
     let idWrapper = null;
     if (id) {
@@ -1802,7 +1801,7 @@ function clearDisconnectedPreviouslyFocusedElements() {
 }
 function addPreviouslyFocusedElement(element) {
   clearDisconnectedPreviouslyFocusedElements();
-  if (element && floatingUi_utils_dom.getNodeName(element) !== 'body') {
+  if (element && floatingUi_utils.getNodeName(element) !== 'body') {
     previouslyFocusedElements.push(element);
     if (previouslyFocusedElements.length > LIST_LIMIT) {
       previouslyFocusedElements = previouslyFocusedElements.slice(-20);
@@ -2008,13 +2007,13 @@ function FloatingFocusManager(props) {
         if (restoreFocus && currentTarget !== domReference && !(target != null && target.isConnected) && activeElement(getDocument$1(floatingFocusElement)) === getDocument$1(floatingFocusElement).body) {
           // Let `FloatingPortal` effect knows that focus is still inside the
           // floating tree.
-          if (floatingUi_utils_dom.isHTMLElement(floatingFocusElement)) {
+          if (floatingUi_utils.isHTMLElement(floatingFocusElement)) {
             floatingFocusElement.focus();
           }
           const prevTabbableIndex = tabbableIndexRef.current;
           const tabbableContent = getTabbableContent();
           const nodeToFocus = tabbableContent[prevTabbableIndex] || tabbableContent[tabbableContent.length - 1] || floatingFocusElement;
-          if (floatingUi_utils_dom.isHTMLElement(nodeToFocus)) {
+          if (floatingUi_utils.isHTMLElement(nodeToFocus)) {
             nodeToFocus.focus();
           }
         }
@@ -2043,7 +2042,7 @@ function FloatingFocusManager(props) {
         dataRef.current.insideReactTree = false;
       });
     }
-    if (floating && floatingUi_utils_dom.isHTMLElement(domReference)) {
+    if (floating && floatingUi_utils.isHTMLElement(domReference)) {
       domReference.addEventListener('focusout', handleFocusOutside);
       domReference.addEventListener('pointerdown', handlePointerDown);
       floating.addEventListener('focusout', handleFocusOutside);
@@ -2083,7 +2082,7 @@ function FloatingFocusManager(props) {
     };
   }, [disabled, domReference, floating, modal, orderRef, portalContext, isUntrappedTypeableCombobox, guards, useInert, tree, getNodeId, getInsideElements]);
   index(() => {
-    if (disabled || !floatingUi_utils_dom.isHTMLElement(floatingFocusElement)) return;
+    if (disabled || !floatingUi_utils.isHTMLElement(floatingFocusElement)) return;
     const doc = getDocument$1(floatingFocusElement);
     const previouslyFocusedElement = activeElement(doc);
 
@@ -2165,7 +2164,7 @@ function FloatingFocusManager(props) {
         const tabbableReturnElement = getFirstTabbableElement(returnElement);
         if (
         // eslint-disable-next-line react-hooks/exhaustive-deps
-        returnFocusRef.current && !preventReturnFocusRef.current && floatingUi_utils_dom.isHTMLElement(tabbableReturnElement) && (
+        returnFocusRef.current && !preventReturnFocusRef.current && floatingUi_utils.isHTMLElement(tabbableReturnElement) && (
         // If the focus moved somewhere else after mount, avoid returning focus
         // since it likely entered a different element which should be
         // respected: https://github.com/floating-ui/floating-ui/issues/2607
@@ -2356,10 +2355,10 @@ const FloatingOverlay = /*#__PURE__*/React__namespace.forwardRef(function Floati
 });
 
 function isButtonTarget(event) {
-  return floatingUi_utils_dom.isHTMLElement(event.target) && event.target.tagName === 'BUTTON';
+  return floatingUi_utils.isHTMLElement(event.target) && event.target.tagName === 'BUTTON';
 }
 function isAnchorTarget(event) {
-  return floatingUi_utils_dom.isHTMLElement(event.target) && event.target.tagName === 'A';
+  return floatingUi_utils.isHTMLElement(event.target) && event.target.tagName === 'A';
 }
 function isSpaceIgnored(element) {
   return isTypeableElement(element);
@@ -2584,10 +2583,10 @@ function useDismiss(context, props) {
     const target = getTarget(event);
     const inertSelector = "[" + createAttribute('inert') + "]";
     const markers = getDocument$1(elements.floating).querySelectorAll(inertSelector);
-    let targetRootAncestor = floatingUi_utils_dom.isElement(target) ? target : null;
-    while (targetRootAncestor && !floatingUi_utils_dom.isLastTraversableNode(targetRootAncestor)) {
-      const nextParent = floatingUi_utils_dom.getParentNode(targetRootAncestor);
-      if (floatingUi_utils_dom.isLastTraversableNode(nextParent) || !floatingUi_utils_dom.isElement(nextParent)) {
+    let targetRootAncestor = floatingUi_utils.isElement(target) ? target : null;
+    while (targetRootAncestor && !floatingUi_utils.isLastTraversableNode(targetRootAncestor)) {
+      const nextParent = floatingUi_utils.getParentNode(targetRootAncestor);
+      if (floatingUi_utils.isLastTraversableNode(nextParent) || !floatingUi_utils.isElement(nextParent)) {
         break;
       }
       targetRootAncestor = nextParent;
@@ -2595,7 +2594,7 @@ function useDismiss(context, props) {
 
     // Check if the click occurred on a third-party element injected after the
     // floating element rendered.
-    if (markers.length && floatingUi_utils_dom.isElement(target) && !isRootElement(target) &&
+    if (markers.length && floatingUi_utils.isElement(target) && !isRootElement(target) &&
     // Clicked on a direct ancestor (e.g. FloatingOverlay).
     !contains(target, elements.floating) &&
     // If the target root element contains none of the markers, then the
@@ -2605,9 +2604,9 @@ function useDismiss(context, props) {
     }
 
     // Check if the click occurred on the scrollbar
-    if (floatingUi_utils_dom.isHTMLElement(target) && floating) {
-      const lastTraversableNode = floatingUi_utils_dom.isLastTraversableNode(target);
-      const style = floatingUi_utils_dom.getComputedStyle(target);
+    if (floatingUi_utils.isHTMLElement(target) && floating) {
+      const lastTraversableNode = floatingUi_utils.isLastTraversableNode(target);
+      const style = floatingUi_utils.getComputedStyle(target);
       const scrollRe = /auto|scroll/;
       const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
       const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
@@ -2682,7 +2681,7 @@ function useDismiss(context, props) {
       },
       // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
       // Only apply to WebKit for the test to remain 0ms.
-      floatingUi_utils_dom.isWebKit() ? 5 : 0);
+      floatingUi_utils.isWebKit() ? 5 : 0);
     }
     const doc = getDocument$1(elements.floating);
     if (escapeKey) {
@@ -2693,14 +2692,14 @@ function useDismiss(context, props) {
     outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
     let ancestors = [];
     if (ancestorScroll) {
-      if (floatingUi_utils_dom.isElement(elements.domReference)) {
-        ancestors = floatingUi_utils_dom.getOverflowAncestors(elements.domReference);
+      if (floatingUi_utils.isElement(elements.domReference)) {
+        ancestors = floatingUi_utils.getOverflowAncestors(elements.domReference);
       }
-      if (floatingUi_utils_dom.isElement(elements.floating)) {
-        ancestors = ancestors.concat(floatingUi_utils_dom.getOverflowAncestors(elements.floating));
+      if (floatingUi_utils.isElement(elements.floating)) {
+        ancestors = ancestors.concat(floatingUi_utils.getOverflowAncestors(elements.floating));
       }
-      if (!floatingUi_utils_dom.isElement(elements.reference) && elements.reference && elements.reference.contextElement) {
-        ancestors = ancestors.concat(floatingUi_utils_dom.getOverflowAncestors(elements.reference.contextElement));
+      if (!floatingUi_utils.isElement(elements.reference) && elements.reference && elements.reference.contextElement) {
+        ancestors = ancestors.concat(floatingUi_utils.getOverflowAncestors(elements.reference.contextElement));
       }
     }
 
@@ -2773,7 +2772,7 @@ function useFloatingRootContext(options) {
   const nested = useFloatingParentNodeId() != null;
   if (process.env.NODE_ENV !== "production") {
     const optionDomReference = elementsProp.reference;
-    if (optionDomReference && !floatingUi_utils_dom.isElement(optionDomReference)) {
+    if (optionDomReference && !floatingUi_utils.isElement(optionDomReference)) {
       error('Cannot pass a virtual element to the `elements.reference` option,', 'as it must be a real DOM element. Use `refs.setPositionReference()`', 'instead.');
     }
   }
@@ -2849,7 +2848,7 @@ function useFloating(options) {
     }
   });
   const setPositionReference = React__namespace.useCallback(node => {
-    const computedPositionReference = floatingUi_utils_dom.isElement(node) ? {
+    const computedPositionReference = floatingUi_utils.isElement(node) ? {
       getBoundingClientRect: () => node.getBoundingClientRect(),
       getClientRects: () => node.getClientRects(),
       contextElement: node
@@ -2860,18 +2859,18 @@ function useFloating(options) {
     position.refs.setReference(computedPositionReference);
   }, [position.refs]);
   const setReference = React__namespace.useCallback(node => {
-    if (floatingUi_utils_dom.isElement(node) || node === null) {
+    if (floatingUi_utils.isElement(node) || node === null) {
       domReferenceRef.current = node;
       setDomReference(node);
     }
 
     // Backwards-compatibility for passing a virtual element to `reference`
     // after it has set the DOM reference.
-    if (floatingUi_utils_dom.isElement(position.refs.reference.current) || position.refs.reference.current === null ||
+    if (floatingUi_utils.isElement(position.refs.reference.current) || position.refs.reference.current === null ||
     // Don't allow setting virtual elements using the old technique back to
     // `null` to support `positionReference` + an unstable `reference`
     // callback ref.
-    node !== null && !floatingUi_utils_dom.isElement(node)) {
+    node !== null && !floatingUi_utils.isElement(node)) {
       position.refs.setReference(node);
     }
   }, [position.refs]);
@@ -3344,7 +3343,7 @@ function useListNavigation(context, props) {
         stopEvent(event);
       }
       onOpenChange(false, event.nativeEvent, 'list-navigation');
-      if (floatingUi_utils_dom.isHTMLElement(elements.domReference)) {
+      if (floatingUi_utils.isHTMLElement(elements.domReference)) {
         if (virtual) {
           tree == null || tree.events.emit('virtualfocus', elements.domReference);
         } else {

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

@@ -1,7 +1,6 @@
 'use strict';
 
 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');
 
@@ -949,12 +948,12 @@ const size$2 = function (options) {
 };
 
 function getCssDimensions(element) {
-  const css = floatingUi_utils_dom.getComputedStyle(element);
+  const css = floatingUi_utils.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 = floatingUi_utils_dom.isHTMLElement(element);
+  const hasOffset = floatingUi_utils.isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
   const shouldFallback = floatingUi_utils.round(width) !== offsetWidth || floatingUi_utils.round(height) !== offsetHeight;
@@ -970,12 +969,12 @@ function getCssDimensions(element) {
 }
 
 function unwrapElement(element) {
-  return !floatingUi_utils_dom.isElement(element) ? element.contextElement : element;
+  return !floatingUi_utils.isElement(element) ? element.contextElement : element;
 }
 
 function getScale(element) {
   const domElement = unwrapElement(element);
-  if (!floatingUi_utils_dom.isHTMLElement(domElement)) {
+  if (!floatingUi_utils.isHTMLElement(domElement)) {
     return floatingUi_utils.createCoords(1);
   }
   const rect = domElement.getBoundingClientRect();
@@ -1003,8 +1002,8 @@ function getScale(element) {
 
 const noOffsets = /*#__PURE__*/floatingUi_utils.createCoords(0);
 function getVisualOffsets(element) {
-  const win = floatingUi_utils_dom.getWindow(element);
-  if (!floatingUi_utils_dom.isWebKit() || !win.visualViewport) {
+  const win = floatingUi_utils.getWindow(element);
+  if (!floatingUi_utils.isWebKit() || !win.visualViewport) {
     return noOffsets;
   }
   return {
@@ -1016,7 +1015,7 @@ function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
   if (isFixed === void 0) {
     isFixed = false;
   }
-  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== floatingUi_utils_dom.getWindow(element)) {
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== floatingUi_utils.getWindow(element)) {
     return false;
   }
   return isFixed;
@@ -1034,7 +1033,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   let scale = floatingUi_utils.createCoords(1);
   if (includeScale) {
     if (offsetParent) {
-      if (floatingUi_utils_dom.isElement(offsetParent)) {
+      if (floatingUi_utils.isElement(offsetParent)) {
         scale = getScale(offsetParent);
       }
     } else {
@@ -1047,14 +1046,14 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   let width = clientRect.width / scale.x;
   let height = clientRect.height / scale.y;
   if (domElement) {
-    const win = floatingUi_utils_dom.getWindow(domElement);
-    const offsetWin = offsetParent && floatingUi_utils_dom.isElement(offsetParent) ? floatingUi_utils_dom.getWindow(offsetParent) : offsetParent;
+    const win = floatingUi_utils.getWindow(domElement);
+    const offsetWin = offsetParent && floatingUi_utils.isElement(offsetParent) ? floatingUi_utils.getWindow(offsetParent) : offsetParent;
     let currentWin = win;
-    let currentIFrame = floatingUi_utils_dom.getFrameElement(currentWin);
+    let currentIFrame = floatingUi_utils.getFrameElement(currentWin);
     while (currentIFrame && offsetParent && offsetWin !== currentWin) {
       const iframeScale = getScale(currentIFrame);
       const iframeRect = currentIFrame.getBoundingClientRect();
-      const css = floatingUi_utils_dom.getComputedStyle(currentIFrame);
+      const css = floatingUi_utils.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;
@@ -1063,8 +1062,8 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       height *= iframeScale.y;
       x += left;
       y += top;
-      currentWin = floatingUi_utils_dom.getWindow(currentIFrame);
-      currentIFrame = floatingUi_utils_dom.getFrameElement(currentWin);
+      currentWin = floatingUi_utils.getWindow(currentIFrame);
+      currentIFrame = floatingUi_utils.getFrameElement(currentWin);
     }
   }
   return floatingUi_utils.rectToClientRect({
@@ -1078,9 +1077,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 = floatingUi_utils_dom.getNodeScroll(element).scrollLeft;
+  const leftScroll = floatingUi_utils.getNodeScroll(element).scrollLeft;
   if (!rect) {
-    return getBoundingClientRect(floatingUi_utils_dom.getDocumentElement(element)).left + leftScroll;
+    return getBoundingClientRect(floatingUi_utils.getDocumentElement(element)).left + leftScroll;
   }
   return rect.left + leftScroll;
 }
@@ -1103,8 +1102,8 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     strategy
   } = _ref;
   const isFixed = strategy === 'fixed';
-  const documentElement = floatingUi_utils_dom.getDocumentElement(offsetParent);
-  const topLayer = elements ? floatingUi_utils_dom.isTopLayer(elements.floating) : false;
+  const documentElement = floatingUi_utils.getDocumentElement(offsetParent);
+  const topLayer = elements ? floatingUi_utils.isTopLayer(elements.floating) : false;
   if (offsetParent === documentElement || topLayer && isFixed) {
     return rect;
   }
@@ -1114,10 +1113,10 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
   };
   let scale = floatingUi_utils.createCoords(1);
   const offsets = floatingUi_utils.createCoords(0);
-  const isOffsetParentAnElement = floatingUi_utils_dom.isHTMLElement(offsetParent);
+  const isOffsetParentAnElement = floatingUi_utils.isHTMLElement(offsetParent);
   if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-    if (floatingUi_utils_dom.getNodeName(offsetParent) !== 'body' || floatingUi_utils_dom.isOverflowElement(documentElement)) {
-      scroll = floatingUi_utils_dom.getNodeScroll(offsetParent);
+    if (floatingUi_utils.getNodeName(offsetParent) !== 'body' || floatingUi_utils.isOverflowElement(documentElement)) {
+      scroll = floatingUi_utils.getNodeScroll(offsetParent);
     }
     if (isOffsetParentAnElement) {
       const offsetRect = getBoundingClientRect(offsetParent);
@@ -1142,14 +1141,14 @@ 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 = floatingUi_utils_dom.getDocumentElement(element);
-  const scroll = floatingUi_utils_dom.getNodeScroll(element);
+  const html = floatingUi_utils.getDocumentElement(element);
+  const scroll = floatingUi_utils.getNodeScroll(element);
   const body = element.ownerDocument.body;
   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') {
+  if (floatingUi_utils.getComputedStyle(body).direction === 'rtl') {
     x += floatingUi_utils.max(html.clientWidth, body.clientWidth) - width;
   }
   return {
@@ -1165,8 +1164,8 @@ function getDocumentRect(element) {
 // Most scrollbars leave 15-18px of space.
 const SCROLLBAR_MAX = 25;
 function getViewportRect(element, strategy) {
-  const win = floatingUi_utils_dom.getWindow(element);
-  const html = floatingUi_utils_dom.getDocumentElement(element);
+  const win = floatingUi_utils.getWindow(element);
+  const html = floatingUi_utils.getDocumentElement(element);
   const visualViewport = win.visualViewport;
   let width = html.clientWidth;
   let height = html.clientHeight;
@@ -1175,7 +1174,7 @@ function getViewportRect(element, strategy) {
   if (visualViewport) {
     width = visualViewport.width;
     height = visualViewport.height;
-    const visualViewportBased = floatingUi_utils_dom.isWebKit();
+    const visualViewportBased = floatingUi_utils.isWebKit();
     if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
       x = visualViewport.offsetLeft;
       y = visualViewport.offsetTop;
@@ -1212,7 +1211,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) : floatingUi_utils.createCoords(1);
+  const scale = floatingUi_utils.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;
@@ -1229,8 +1228,8 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
   if (clippingAncestor === 'viewport') {
     rect = getViewportRect(element, strategy);
   } else if (clippingAncestor === 'document') {
-    rect = getDocumentRect(floatingUi_utils_dom.getDocumentElement(element));
-  } else if (floatingUi_utils_dom.isElement(clippingAncestor)) {
+    rect = getDocumentRect(floatingUi_utils.getDocumentElement(element));
+  } else if (floatingUi_utils.isElement(clippingAncestor)) {
     rect = getInnerBoundingClientRect(clippingAncestor, strategy);
   } else {
     const visualOffsets = getVisualOffsets(element);
@@ -1244,11 +1243,11 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
   return floatingUi_utils.rectToClientRect(rect);
 }
 function hasFixedPositionAncestor(element, stopNode) {
-  const parentNode = floatingUi_utils_dom.getParentNode(element);
-  if (parentNode === stopNode || !floatingUi_utils_dom.isElement(parentNode) || floatingUi_utils_dom.isLastTraversableNode(parentNode)) {
+  const parentNode = floatingUi_utils.getParentNode(element);
+  if (parentNode === stopNode || !floatingUi_utils.isElement(parentNode) || floatingUi_utils.isLastTraversableNode(parentNode)) {
     return false;
   }
-  return floatingUi_utils_dom.getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
+  return floatingUi_utils.getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
 }
 
 // A "clipping ancestor" is an `overflow` element with the characteristic of
@@ -1259,19 +1258,19 @@ function getClippingElementAncestors(element, cache) {
   if (cachedResult) {
     return cachedResult;
   }
-  let result = floatingUi_utils_dom.getOverflowAncestors(element, [], false).filter(el => floatingUi_utils_dom.isElement(el) && floatingUi_utils_dom.getNodeName(el) !== 'body');
+  let result = floatingUi_utils.getOverflowAncestors(element, [], false).filter(el => floatingUi_utils.isElement(el) && floatingUi_utils.getNodeName(el) !== 'body');
   let currentContainingBlockComputedStyle = null;
-  const elementIsFixed = floatingUi_utils_dom.getComputedStyle(element).position === 'fixed';
-  let currentNode = elementIsFixed ? floatingUi_utils_dom.getParentNode(element) : element;
+  const elementIsFixed = floatingUi_utils.getComputedStyle(element).position === 'fixed';
+  let currentNode = elementIsFixed ? floatingUi_utils.getParentNode(element) : element;
 
   // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
-  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);
+  while (floatingUi_utils.isElement(currentNode) && !floatingUi_utils.isLastTraversableNode(currentNode)) {
+    const computedStyle = floatingUi_utils.getComputedStyle(currentNode);
+    const currentNodeIsContaining = floatingUi_utils.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') || floatingUi_utils_dom.isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === 'absolute' || currentContainingBlockComputedStyle.position === 'fixed') || floatingUi_utils.isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
     if (shouldDropCurrentNode) {
       // Drop non-containing blocks.
       result = result.filter(ancestor => ancestor !== currentNode);
@@ -1279,7 +1278,7 @@ function getClippingElementAncestors(element, cache) {
       // Record last containing block for next iteration.
       currentContainingBlockComputedStyle = computedStyle;
     }
-    currentNode = floatingUi_utils_dom.getParentNode(currentNode);
+    currentNode = floatingUi_utils.getParentNode(currentNode);
   }
   cache.set(element, result);
   return result;
@@ -1294,7 +1293,7 @@ function getClippingRect(_ref) {
     rootBoundary,
     strategy
   } = _ref;
-  const elementClippingAncestors = boundary === 'clippingAncestors' ? floatingUi_utils_dom.isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const elementClippingAncestors = boundary === 'clippingAncestors' ? floatingUi_utils.isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
   const clippingAncestors = [...elementClippingAncestors, rootBoundary];
   const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
   let top = firstRect.top;
@@ -1328,8 +1327,8 @@ function getDimensions(element) {
 }
 
 function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
-  const isOffsetParentAnElement = floatingUi_utils_dom.isHTMLElement(offsetParent);
-  const documentElement = floatingUi_utils_dom.getDocumentElement(offsetParent);
+  const isOffsetParentAnElement = floatingUi_utils.isHTMLElement(offsetParent);
+  const documentElement = floatingUi_utils.getDocumentElement(offsetParent);
   const isFixed = strategy === 'fixed';
   const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
   let scroll = {
@@ -1344,8 +1343,8 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
     offsets.x = getWindowScrollBarX(documentElement);
   }
   if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
-    if (floatingUi_utils_dom.getNodeName(offsetParent) !== 'body' || floatingUi_utils_dom.isOverflowElement(documentElement)) {
-      scroll = floatingUi_utils_dom.getNodeScroll(offsetParent);
+    if (floatingUi_utils.getNodeName(offsetParent) !== 'body' || floatingUi_utils.isOverflowElement(documentElement)) {
+      scroll = floatingUi_utils.getNodeScroll(offsetParent);
     }
     if (isOffsetParentAnElement) {
       const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
@@ -1370,11 +1369,11 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
 }
 
 function isStaticPositioned(element) {
-  return floatingUi_utils_dom.getComputedStyle(element).position === 'static';
+  return floatingUi_utils.getComputedStyle(element).position === 'static';
 }
 
 function getTrueOffsetParent(element, polyfill) {
-  if (!floatingUi_utils_dom.isHTMLElement(element) || floatingUi_utils_dom.getComputedStyle(element).position === 'fixed') {
+  if (!floatingUi_utils.isHTMLElement(element) || floatingUi_utils.getComputedStyle(element).position === 'fixed') {
     return null;
   }
   if (polyfill) {
@@ -1386,7 +1385,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 (floatingUi_utils_dom.getDocumentElement(element) === rawOffsetParent) {
+  if (floatingUi_utils.getDocumentElement(element) === rawOffsetParent) {
     rawOffsetParent = rawOffsetParent.ownerDocument.body;
   }
   return rawOffsetParent;
@@ -1395,28 +1394,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 = floatingUi_utils_dom.getWindow(element);
-  if (floatingUi_utils_dom.isTopLayer(element)) {
+  const win = floatingUi_utils.getWindow(element);
+  if (floatingUi_utils.isTopLayer(element)) {
     return win;
   }
-  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)) {
+  if (!floatingUi_utils.isHTMLElement(element)) {
+    let svgOffsetParent = floatingUi_utils.getParentNode(element);
+    while (svgOffsetParent && !floatingUi_utils.isLastTraversableNode(svgOffsetParent)) {
+      if (floatingUi_utils.isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
         return svgOffsetParent;
       }
-      svgOffsetParent = floatingUi_utils_dom.getParentNode(svgOffsetParent);
+      svgOffsetParent = floatingUi_utils.getParentNode(svgOffsetParent);
     }
     return win;
   }
   let offsetParent = getTrueOffsetParent(element, polyfill);
-  while (offsetParent && floatingUi_utils_dom.isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+  while (offsetParent && floatingUi_utils.isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
     offsetParent = getTrueOffsetParent(offsetParent, polyfill);
   }
-  if (offsetParent && floatingUi_utils_dom.isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !floatingUi_utils_dom.isContainingBlock(offsetParent)) {
+  if (offsetParent && floatingUi_utils.isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !floatingUi_utils.isContainingBlock(offsetParent)) {
     return win;
   }
-  return offsetParent || floatingUi_utils_dom.getContainingBlock(element) || win;
+  return offsetParent || floatingUi_utils.getContainingBlock(element) || win;
 }
 
 const getElementRects = async function (data) {
@@ -1435,19 +1434,19 @@ const getElementRects = async function (data) {
 };
 
 function isRTL(element) {
-  return floatingUi_utils_dom.getComputedStyle(element).direction === 'rtl';
+  return floatingUi_utils.getComputedStyle(element).direction === 'rtl';
 }
 
 const platform = {
   convertOffsetParentRelativeRectToViewportRelativeRect,
-  getDocumentElement: floatingUi_utils_dom.getDocumentElement,
+  getDocumentElement: floatingUi_utils.getDocumentElement,
   getClippingRect,
   getOffsetParent,
   getElementRects,
   getClientRects,
   getDimensions,
   getScale,
-  isElement: floatingUi_utils_dom.isElement,
+  isElement: floatingUi_utils.isElement,
   isRTL
 };
 
@@ -1459,7 +1458,7 @@ function rectsAreEqual(a, b) {
 function observeMove(element, onMove) {
   let io = null;
   let timeoutId;
-  const root = floatingUi_utils_dom.getDocumentElement(element);
+  const root = floatingUi_utils.getDocumentElement(element);
   function cleanup() {
     var _io;
     clearTimeout(timeoutId);
@@ -1563,7 +1562,7 @@ function autoUpdate(reference, floating, update, options) {
     animationFrame = false
   } = options;
   const referenceEl = unwrapElement(reference);
-  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? floatingUi_utils_dom.getOverflowAncestors(referenceEl) : []), ...(floating ? floatingUi_utils_dom.getOverflowAncestors(floating) : [])] : [];
+  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? floatingUi_utils.getOverflowAncestors(referenceEl) : []), ...(floating ? floatingUi_utils.getOverflowAncestors(floating) : [])] : [];
   ancestors.forEach(ancestor => {
     ancestorScroll && ancestor.addEventListener('scroll', update, {
       passive: true

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

@@ -1,5 +1,4 @@
-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, i 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 { l as getSideAxis, m as getAlignmentAxis, n as getSide, o as getAlignment, p as evaluate, q as getPaddingObject, r as rectToClientRect, s as getOppositePlacement, t as getExpandedPlacements, u as getOppositeAxisPlacements, v as getAlignmentSides, w as clamp, x as min, y as max, z as getAxisLength, A as sides, B as getOppositeAxis, C as placements, D as getOppositeAlignmentPlacement, E as getDocumentElement, b as isElement, i as isHTMLElement, F as createCoords, G as round, H as isTopLayer, g as getNodeName, I as isOverflowElement, J as getNodeScroll, K as getWindow, e as getParentNode, d as isLastTraversableNode, L as isTableElement, M as isContainingBlock, N as getContainingBlock, h as getComputedStyle$1, j as getOverflowAncestors, O as getFrameElement, k as isWebKit, f as floor } from './floating-ui.utils-es.js';
 import * as React from 'react';
 import { useLayoutEffect } from 'react';
 import * as ReactDOM from 'react-dom';

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

@@ -1,7 +1,6 @@
 import * as React from 'react';
 import { useLayoutEffect } from 'react';
-import { a as isShadowRoot, i as isHTMLElement, b as isElement, c as isNode, g as getNodeName, d as isLastTraversableNode, e as getParentNode, f as getComputedStyle$1, h as getOverflowAncestors, j as isWebKit } from './floating-ui.utils.dom-es.js';
-import { f as floor } from './floating-ui.utils-es.js';
+import { a as isShadowRoot, i as isHTMLElement, f as floor, b as isElement, c as isNode, g as getNodeName, d as isLastTraversableNode, e as getParentNode, h as getComputedStyle$1, j as getOverflowAncestors, k as isWebKit } from './floating-ui.utils-es.js';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import * as ReactDOM from 'react-dom';
 import { u as useFloating$1 } from './floating-ui.react-dom-es.js';