@jobber/components 7.10.0 → 7.11.0

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

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

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

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

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

@@ -0,0 +1,185 @@
+'use strict';
+
+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(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(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(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;
+}
+
+exports.getComputedStyle = getComputedStyle;
+exports.getContainingBlock = getContainingBlock;
+exports.getDocumentElement = getDocumentElement;
+exports.getFrameElement = getFrameElement;
+exports.getNodeName = getNodeName;
+exports.getNodeScroll = getNodeScroll;
+exports.getOverflowAncestors = getOverflowAncestors;
+exports.getParentNode = getParentNode;
+exports.getWindow = getWindow;
+exports.isContainingBlock = isContainingBlock;
+exports.isElement = isElement;
+exports.isHTMLElement = isHTMLElement;
+exports.isLastTraversableNode = isLastTraversableNode;
+exports.isNode = isNode;
+exports.isOverflowElement = isOverflowElement;
+exports.isShadowRoot = isShadowRoot;
+exports.isTableElement = isTableElement;
+exports.isTopLayer = isTopLayer;
+exports.isWebKit = isWebKit;