@jobber/components 6.65.0 → 6.66.0

package/dist/Modal/index.mjs

@@ -9,7 +9,7 @@ import { H as Heading } from '../Heading-es.js';
 import { B as Button } from '../Button-es.js';
 import { B as ButtonDismiss } from '../ButtonDismiss-es.js';
 import { n as noop } from '../noop-es.js';
-import { a as useFloatingNodeId, b as useFloating, i as useClick, e as useDismiss, j as useRole, f as useInteractions, u as useFloatingParentNodeId, F as FloatingTree, g as FloatingNode, h as FloatingPortal, k as FloatingOverlay, l as FloatingFocusManager } from '../floating-ui.react-es.js';
+import { a as useFloatingNodeId, b as useFloating, k as useClick, e as useDismiss, l as useRole, f as useInteractions, u as useFloatingParentNodeId, F as FloatingTree, g as FloatingNode, h as FloatingPortal, m as FloatingOverlay, n as FloatingFocusManager } from '../floating-ui.react-es.js';
 import { b as identity } from '../identity-es.js';
 import { A as AtlantisPortalContent } from '../AtlantisPortalContent-es.js';
 import '../Typography-es.js';

package/dist/Popover/PopoverContext.d.ts

@@ -1,10 +1,16 @@
+import { Placement } from "@floating-ui/react";
 import React, { CSSProperties } from "react";
 import { PopoverProviderProps } from "./Popover.types";
 interface PopoverContextProps {
     setArrowElement: (element: HTMLElement | null) => void;
     popperStyles: {
-        [key: string]: CSSProperties;
+        popper: CSSProperties;
+        arrow?: {
+            x?: number;
+            y?: number;
+        };
     };
+    placement?: Placement;
 }
 export declare function usePopoverContext(): PopoverContextProps;
 export declare function PopoverProvider({ children, preferredPlacement, attachTo, open, UNSAFE_className, UNSAFE_style, }: PopoverProviderProps): React.JSX.Element | null;

package/dist/Popover/index.cjs

@@ -5,7 +5,7 @@ require('../tslib.es6-cjs.js');
 require('react');
 require('classnames');
 require('react-dom');
-require('react-popper');
+require('../floating-ui.react-cjs.js');
 require('../useRefocusOnActivator-cjs.js');
 require('../AtlantisPortalContent-cjs.js');
 require('../AtlantisThemeContext-cjs.js');

package/dist/Popover/index.mjs

@@ -3,7 +3,7 @@ import '../tslib.es6-es.js';
 import 'react';
 import 'classnames';
 import 'react-dom';
-import 'react-popper';
+import '../floating-ui.react-es.js';
 import '../useRefocusOnActivator-es.js';
 import '../AtlantisPortalContent-es.js';
 import '../AtlantisThemeContext-es.js';

package/dist/Popover/usePopover.d.ts

@@ -1,13 +1,16 @@
 import { PopoverProps } from "./Popover.types";
 export declare const usePopover: ({ preferredPlacement, attachTo, open, }: Pick<PopoverProps, "preferredPlacement" | "attachTo" | "open">) => {
-    setPopperElement: import("react").Dispatch<import("react").SetStateAction<HTMLElement | null | undefined>>;
+    setPopperElement: ((node: HTMLElement | null) => void) & ((node: HTMLElement | null) => void);
     setArrowElement: import("react").Dispatch<import("react").SetStateAction<HTMLElement | null | undefined>>;
     popperStyles: {
-        [key: string]: import("react").CSSProperties;
+        popper: import("react").CSSProperties;
+        arrow: (Partial<import("@floating-ui/core").Coords> & {
+            centerOffset: number;
+            alignmentOffset?: number;
+        }) | undefined;
     };
+    placement: import("@floating-ui/utils").Placement;
     attributes: {
-        [key: string]: {
-            [key: string]: string;
-        } | undefined;
+        popper: {};
     };
 };

package/dist/Popover-cjs.js

@@ -4,40 +4,66 @@ var tslib_es6 = require('./tslib.es6-cjs.js');
 var React = require('react');
 var classnames = require('classnames');
 var ReactDOM = require('react-dom');
-var reactPopper = require('react-popper');
+var floatingUi_react = require('./floating-ui.react-cjs.js');
 var useRefocusOnActivator = require('./useRefocusOnActivator-cjs.js');
 var AtlantisPortalContent = require('./AtlantisPortalContent-cjs.js');
 var ButtonDismiss = require('./ButtonDismiss-cjs.js');
 
+const POPOVER_OFFSET = 10;
+const POPOVER_SHIFT_PADDING = 8;
+const POPOVER_ARROW_PADDING = 6;
 const usePopover = ({ preferredPlacement, attachTo, open, }) => {
-    const [popperElement, setPopperElement] = React.useState();
     const [arrowElement, setArrowElement] = React.useState();
     const modifiers = React.useMemo(() => {
+        const baseModifiers = [
+            floatingUi_react.offset(POPOVER_OFFSET),
+            floatingUi_react.shift({
+                mainAxis: true,
+                crossAxis: false,
+                padding: POPOVER_SHIFT_PADDING,
+            }),
+        ];
+        const placementMiddleware = preferredPlacement === "auto"
+            ? floatingUi_react.autoPlacement({
+                allowedPlacements: ["top", "bottom", "left", "right"],
+            })
+            : floatingUi_react.flip({
+                fallbackPlacements: ["top", "bottom", "left", "right"],
+            });
         return [
-            {
-                name: "arrow",
-                options: { element: arrowElement, padding: 10 },
-            },
-            {
-                name: "offset",
-                options: {
-                    offset: [0, 10],
-                },
-            },
-            {
-                name: "flip",
-                options: {
-                    fallbackPlacements: ["auto"],
-                },
-            },
+            ...baseModifiers,
+            placementMiddleware,
+            floatingUi_react.arrow({
+                element: arrowElement || null,
+                padding: POPOVER_ARROW_PADDING,
+            }),
         ];
-    }, [arrowElement]);
-    const { styles: popperStyles, attributes } = reactPopper.usePopper(isHTMLElement(attachTo) ? attachTo : attachTo.current, popperElement, {
-        modifiers,
-        placement: preferredPlacement,
+    }, [arrowElement, preferredPlacement]);
+    const referenceElement = isHTMLElement(attachTo)
+        ? attachTo
+        : attachTo.current;
+    const { refs, floatingStyles, middlewareData, placement } = floatingUi_react.useFloating({
+        placement: preferredPlacement === "auto" ? undefined : preferredPlacement,
+        strategy: "absolute",
+        middleware: modifiers,
+        elements: {
+            reference: referenceElement || null,
+        },
+        // Only use this option when the floating element is conditionally rendered
+        // (which we are), not hidden with css. https://floating-ui.com/docs/autoUpdate
+        whileElementsMounted: floatingUi_react.autoUpdate,
     });
     useRefocusOnActivator.useRefocusOnActivator_2(open);
-    return { setPopperElement, setArrowElement, popperStyles, attributes };
+    return {
+        setPopperElement: refs.setFloating,
+        setArrowElement,
+        popperStyles: {
+            popper: floatingStyles,
+            arrow: middlewareData.arrow,
+        },
+        placement,
+        attributes: { popper: {} },
+    };
 };
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isHTMLElement(el) {
@@ -55,7 +81,7 @@ const usePopoverStyles = () => {
 };
 
 const PopoverContext = React.createContext({
-    popperStyles: {},
+    popperStyles: { popper: {} },
     setArrowElement: () => {
         // noop
     },
@@ -63,8 +89,8 @@ const PopoverContext = React.createContext({
 function usePopoverContext() {
     return React.useContext(PopoverContext);
 }
-function PopoverProvider({ children, preferredPlacement, attachTo, open, UNSAFE_className, UNSAFE_style, }) {
-    const { setPopperElement, setArrowElement, popperStyles, attributes } = usePopover({
+function PopoverProvider({ children, preferredPlacement = "auto", attachTo, open, UNSAFE_className, UNSAFE_style, }) {
+    const { setPopperElement, setArrowElement, popperStyles, placement } = usePopover({
         preferredPlacement,
         attachTo,
         open,
@@ -74,15 +100,16 @@ function PopoverProvider({ children, preferredPlacement, attachTo, open, UNSAFE_
     return (React.createElement(PopoverContext.Provider, { value: {
             setArrowElement,
             popperStyles,
+            placement,
         } },
-        React.createElement(PopoverWrapper, { attributes: attributes, UNSAFE_className: UNSAFE_className, UNSAFE_style: UNSAFE_style, setPopperElement: setPopperElement }, children)));
+        React.createElement(PopoverWrapper, { UNSAFE_className: UNSAFE_className, UNSAFE_style: UNSAFE_style, setPopperElement: setPopperElement, placement: placement }, children)));
 }
-function PopoverWrapper({ children, attributes, setPopperElement, UNSAFE_className, UNSAFE_style, }) {
+function PopoverWrapper({ children, setPopperElement, UNSAFE_className, UNSAFE_style, placement, }) {
     const popoverStyles = usePopoverStyles();
     const { popperStyles } = usePopoverContext();
     const classes = classnames(popoverStyles.container, UNSAFE_className === null || UNSAFE_className === void 0 ? void 0 : UNSAFE_className.container);
     const content = (React.createElement(AtlantisPortalContent.AtlantisPortalContent, null,
-        React.createElement("div", Object.assign({ role: "dialog", "data-elevation": "elevated", ref: setPopperElement, style: Object.assign(Object.assign({}, popperStyles.popper), UNSAFE_style === null || UNSAFE_style === void 0 ? void 0 : UNSAFE_style.container), className: classes }, attributes.popper, { "data-testid": "ATL-Popover-Container" }), children)));
+        React.createElement("div", { role: "dialog", "data-elevation": "elevated", ref: setPopperElement, style: Object.assign(Object.assign({}, popperStyles.popper), UNSAFE_style === null || UNSAFE_style === void 0 ? void 0 : UNSAFE_style.container), className: classes, "data-popover-placement": placement, "data-testid": "ATL-Popover-Container" }, children)));
     return ReactDOM.createPortal(content, document.body);
 }
 
@@ -94,10 +121,30 @@ function Popover({ onRequestClose, children, attachTo, open, preferredPlacement
 }
 Popover.Provider = PopoverProvider;
 Popover.Arrow = function PopoverArrow({ UNSAFE_className, UNSAFE_style, }) {
-    const { setArrowElement, popperStyles } = usePopoverContext();
+    var _a, _b, _c, _d;
+    const { setArrowElement, popperStyles, placement } = usePopoverContext();
     const popoverStyles = usePopoverStyles();
     const classes = classnames(popoverStyles.arrow, UNSAFE_className === null || UNSAFE_className === void 0 ? void 0 : UNSAFE_className.arrow);
-    return (React.createElement("div", { ref: setArrowElement, className: classes, style: Object.assign(Object.assign({}, popperStyles.arrow), UNSAFE_style === null || UNSAFE_style === void 0 ? void 0 : UNSAFE_style.arrow), "data-testid": "ATL-Popover-Arrow" }));
+    // the arrow will get positioned opposite to the placement side
+    const staticSideMap = {
+        top: "bottom",
+        right: "left",
+        bottom: "top",
+        left: "right",
+    };
+    const staticSide = staticSideMap[placement];
+    const arrowStyles = {
+        position: "absolute",
+        // only left or top will be defined at a time
+        left: ((_a = popperStyles.arrow) === null || _a === void 0 ? void 0 : _a.x) != null ? `${(_b = popperStyles.arrow) === null || _b === void 0 ? void 0 : _b.x}px` : "",
+        top: ((_c = popperStyles.arrow) === null || _c === void 0 ? void 0 : _c.y) != null ? `${(_d = popperStyles.arrow) === null || _d === void 0 ? void 0 : _d.y}px` : "",
+        right: "",
+        bottom: "",
+        [staticSide]: "var(--popover--position--offset)",
+        width: "var(--base-unit)",
+        height: "var(--base-unit)",
+    };
+    return (React.createElement("div", { ref: setArrowElement, className: classes, style: Object.assign(Object.assign({}, arrowStyles), UNSAFE_style === null || UNSAFE_style === void 0 ? void 0 : UNSAFE_style.arrow), "data-testid": "ATL-Popover-Arrow" }));
 };
 Popover.DismissButton = function PopoverDismissButton(props) {
     var _a;

package/dist/Popover-es.js

@@ -2,40 +2,66 @@ import { _ as __rest } from './tslib.es6-es.js';
 import React__default, { useState, useMemo, createContext, useContext } from 'react';
 import classnames from 'classnames';
 import ReactDOM__default from 'react-dom';
-import { usePopper } from 'react-popper';
+import { i as arrow, b as useFloating, d as autoUpdate, o as offset, s as shift, c as autoPlacement, j as flip } from './floating-ui.react-es.js';
 import { u as useRefocusOnActivator_2 } from './useRefocusOnActivator-es.js';
 import { A as AtlantisPortalContent } from './AtlantisPortalContent-es.js';
 import { B as ButtonDismiss } from './ButtonDismiss-es.js';
 
+const POPOVER_OFFSET = 10;
+const POPOVER_SHIFT_PADDING = 8;
+const POPOVER_ARROW_PADDING = 6;
 const usePopover = ({ preferredPlacement, attachTo, open, }) => {
-    const [popperElement, setPopperElement] = useState();
     const [arrowElement, setArrowElement] = useState();
     const modifiers = useMemo(() => {
+        const baseModifiers = [
+            offset(POPOVER_OFFSET),
+            shift({
+                mainAxis: true,
+                crossAxis: false,
+                padding: POPOVER_SHIFT_PADDING,
+            }),
+        ];
+        const placementMiddleware = preferredPlacement === "auto"
+            ? autoPlacement({
+                allowedPlacements: ["top", "bottom", "left", "right"],
+            })
+            : flip({
+                fallbackPlacements: ["top", "bottom", "left", "right"],
+            });
         return [
-            {
-                name: "arrow",
-                options: { element: arrowElement, padding: 10 },
-            },
-            {
-                name: "offset",
-                options: {
-                    offset: [0, 10],
-                },
-            },
-            {
-                name: "flip",
-                options: {
-                    fallbackPlacements: ["auto"],
-                },
-            },
+            ...baseModifiers,
+            placementMiddleware,
+            arrow({
+                element: arrowElement || null,
+                padding: POPOVER_ARROW_PADDING,
+            }),
         ];
-    }, [arrowElement]);
-    const { styles: popperStyles, attributes } = usePopper(isHTMLElement(attachTo) ? attachTo : attachTo.current, popperElement, {
-        modifiers,
-        placement: preferredPlacement,
+    }, [arrowElement, preferredPlacement]);
+    const referenceElement = isHTMLElement(attachTo)
+        ? attachTo
+        : attachTo.current;
+    const { refs, floatingStyles, middlewareData, placement } = useFloating({
+        placement: preferredPlacement === "auto" ? undefined : preferredPlacement,
+        strategy: "absolute",
+        middleware: modifiers,
+        elements: {
+            reference: referenceElement || null,
+        },
+        // Only use this option when the floating element is conditionally rendered
+        // (which we are), not hidden with css. https://floating-ui.com/docs/autoUpdate
+        whileElementsMounted: autoUpdate,
     });
     useRefocusOnActivator_2(open);
-    return { setPopperElement, setArrowElement, popperStyles, attributes };
+    return {
+        setPopperElement: refs.setFloating,
+        setArrowElement,
+        popperStyles: {
+            popper: floatingStyles,
+            arrow: middlewareData.arrow,
+        },
+        placement,
+        attributes: { popper: {} },
+    };
 };
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isHTMLElement(el) {
@@ -53,7 +79,7 @@ const usePopoverStyles = () => {
 };
 
 const PopoverContext = createContext({
-    popperStyles: {},
+    popperStyles: { popper: {} },
     setArrowElement: () => {
         // noop
     },
@@ -61,8 +87,8 @@ const PopoverContext = createContext({
 function usePopoverContext() {
     return useContext(PopoverContext);
 }
-function PopoverProvider({ children, preferredPlacement, attachTo, open, UNSAFE_className, UNSAFE_style, }) {
-    const { setPopperElement, setArrowElement, popperStyles, attributes } = usePopover({
+function PopoverProvider({ children, preferredPlacement = "auto", attachTo, open, UNSAFE_className, UNSAFE_style, }) {
+    const { setPopperElement, setArrowElement, popperStyles, placement } = usePopover({
         preferredPlacement,
         attachTo,
         open,
@@ -72,15 +98,16 @@ function PopoverProvider({ children, preferredPlacement, attachTo, open, UNSAFE_
     return (React__default.createElement(PopoverContext.Provider, { value: {
             setArrowElement,
             popperStyles,
+            placement,
         } },
-        React__default.createElement(PopoverWrapper, { attributes: attributes, UNSAFE_className: UNSAFE_className, UNSAFE_style: UNSAFE_style, setPopperElement: setPopperElement }, children)));
+        React__default.createElement(PopoverWrapper, { UNSAFE_className: UNSAFE_className, UNSAFE_style: UNSAFE_style, setPopperElement: setPopperElement, placement: placement }, children)));
 }
-function PopoverWrapper({ children, attributes, setPopperElement, UNSAFE_className, UNSAFE_style, }) {
+function PopoverWrapper({ children, setPopperElement, UNSAFE_className, UNSAFE_style, placement, }) {
     const popoverStyles = usePopoverStyles();
     const { popperStyles } = usePopoverContext();
     const classes = classnames(popoverStyles.container, UNSAFE_className === null || UNSAFE_className === void 0 ? void 0 : UNSAFE_className.container);
     const content = (React__default.createElement(AtlantisPortalContent, null,
-        React__default.createElement("div", Object.assign({ role: "dialog", "data-elevation": "elevated", ref: setPopperElement, style: Object.assign(Object.assign({}, popperStyles.popper), UNSAFE_style === null || UNSAFE_style === void 0 ? void 0 : UNSAFE_style.container), className: classes }, attributes.popper, { "data-testid": "ATL-Popover-Container" }), children)));
+        React__default.createElement("div", { role: "dialog", "data-elevation": "elevated", ref: setPopperElement, style: Object.assign(Object.assign({}, popperStyles.popper), UNSAFE_style === null || UNSAFE_style === void 0 ? void 0 : UNSAFE_style.container), className: classes, "data-popover-placement": placement, "data-testid": "ATL-Popover-Container" }, children)));
     return ReactDOM__default.createPortal(content, document.body);
 }
 
@@ -92,10 +119,30 @@ function Popover({ onRequestClose, children, attachTo, open, preferredPlacement
 }
 Popover.Provider = PopoverProvider;
 Popover.Arrow = function PopoverArrow({ UNSAFE_className, UNSAFE_style, }) {
-    const { setArrowElement, popperStyles } = usePopoverContext();
+    var _a, _b, _c, _d;
+    const { setArrowElement, popperStyles, placement } = usePopoverContext();
     const popoverStyles = usePopoverStyles();
     const classes = classnames(popoverStyles.arrow, UNSAFE_className === null || UNSAFE_className === void 0 ? void 0 : UNSAFE_className.arrow);
-    return (React__default.createElement("div", { ref: setArrowElement, className: classes, style: Object.assign(Object.assign({}, popperStyles.arrow), UNSAFE_style === null || UNSAFE_style === void 0 ? void 0 : UNSAFE_style.arrow), "data-testid": "ATL-Popover-Arrow" }));
+    // the arrow will get positioned opposite to the placement side
+    const staticSideMap = {
+        top: "bottom",
+        right: "left",
+        bottom: "top",
+        left: "right",
+    };
+    const staticSide = staticSideMap[placement];
+    const arrowStyles = {
+        position: "absolute",
+        // only left or top will be defined at a time
+        left: ((_a = popperStyles.arrow) === null || _a === void 0 ? void 0 : _a.x) != null ? `${(_b = popperStyles.arrow) === null || _b === void 0 ? void 0 : _b.x}px` : "",
+        top: ((_c = popperStyles.arrow) === null || _c === void 0 ? void 0 : _c.y) != null ? `${(_d = popperStyles.arrow) === null || _d === void 0 ? void 0 : _d.y}px` : "",
+        right: "",
+        bottom: "",
+        [staticSide]: "var(--popover--position--offset)",
+        width: "var(--base-unit)",
+        height: "var(--base-unit)",
+    };
+    return (React__default.createElement("div", { ref: setArrowElement, className: classes, style: Object.assign(Object.assign({}, arrowStyles), UNSAFE_style === null || UNSAFE_style === void 0 ? void 0 : UNSAFE_style.arrow), "data-testid": "ATL-Popover-Arrow" }));
 };
 Popover.DismissButton = function PopoverDismissButton(props) {
     var _a;

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

@@ -2186,9 +2186,41 @@ function getAlignmentSides(placement, rects, rtl) {
   }
   return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
 }
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
 function getOppositeAlignmentPlacement(placement) {
   return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
 }
+function getSideList(side, isStart, rtl) {
+  const lr = ['left', 'right'];
+  const rl = ['right', 'left'];
+  const tb = ['top', 'bottom'];
+  const bt = ['bottom', 'top'];
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case 'left':
+    case 'right':
+      return isStart ? tb : bt;
+    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) {
   return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
 }
@@ -2430,6 +2462,88 @@ async function detectOverflow(state, options) {
   };
 }
 
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow$2 = options => ({
+  name: 'arrow',
+  options,
+  async fn(state) {
+    const {
+      x,
+      y,
+      placement,
+      rects,
+      platform,
+      elements,
+      middlewareData
+    } = state;
+    // Since `element` is required, we don't Partial<> the type.
+    const {
+      element,
+      padding = 0
+    } = evaluate(options, state) || {};
+    if (element == null) {
+      return {};
+    }
+    const paddingObject = getPaddingObject(padding);
+    const coords = {
+      x,
+      y
+    };
+    const axis = getAlignmentAxis(placement);
+    const length = getAxisLength(axis);
+    const arrowDimensions = await platform.getDimensions(element);
+    const isYAxis = axis === 'y';
+    const minProp = isYAxis ? 'top' : 'left';
+    const maxProp = isYAxis ? 'bottom' : 'right';
+    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';
+    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+    const startDiff = coords[axis] - rects.reference[axis];
+    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
+    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+
+    // DOM platform can return `window` as the `offsetParent`.
+    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {
+      clientSize = elements.floating[clientProp] || rects.floating[length];
+    }
+    const centerToReference = endDiff / 2 - startDiff / 2;
+
+    // If the padding is large enough that it causes the arrow to no longer be
+    // centered, modify the padding so that it is centered.
+    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+
+    // Make sure the arrow doesn't overflow the floating element if the center
+    // point is outside the floating element's bounds.
+    const min$1 = minPadding;
+    const max = clientSize - arrowDimensions[length] - maxPadding;
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset = clamp(min$1, center, max);
+
+    // If the reference is small enough that the arrow's padding causes it to
+    // to point to nothing for an aligned placement, adjust the offset of the
+    // floating element itself. To ensure `shift()` continues to take action,
+    // a single reset is performed when this is true.
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
+    return {
+      [axis]: coords[axis] + alignmentOffset,
+      data: {
+        [axis]: offset,
+        centerOffset: center - offset - alignmentOffset,
+        ...(shouldAddOffset && {
+          alignmentOffset
+        })
+      },
+      reset: shouldAddOffset
+    };
+  }
+});
+
 function getPlacementList(alignment, autoAlignment, allowedPlacements) {
   const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);
   return allowedPlacementsSortedByAlignment.filter(placement => {
@@ -2533,6 +2647,121 @@ const autoPlacement$1 = function (options) {
   };
 };
 
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip$1 = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'flip',
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform,
+        elements
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = 'bestFit',
+        fallbackAxisSideDirection = 'none',
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+
+      // If a reset by the arrow was caused due to an alignment offset being
+      // added, we should skip any logic now since `flip()` has already done its
+      // work.
+      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      const side = getSide(placement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+
+      // One or more sides is overflowing.
+      if (!overflows.every(side => side <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements[nextIndex];
+        if (nextPlacement) {
+          // Try next placement and re-run the lifecycle.
+          return {
+            data: {
+              index: nextIndex,
+              overflows: overflowsData
+            },
+            reset: {
+              placement: nextPlacement
+            }
+          };
+        }
+
+        // First, find the candidates that fit on the mainAxis side of overflow,
+        // then find the placement that fits the best on the main crossAxis side.
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+
+        // Otherwise fallback.
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
+            case 'bestFit':
+              {
+                var _overflowsData$map$so;
+                const placement = (_overflowsData$map$so = overflowsData.map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
+                if (placement) {
+                  resetPlacement = placement;
+                }
+                break;
+              }
+            case 'initialPlacement':
+              resetPlacement = initialPlacement;
+              break;
+          }
+        }
+        if (placement !== resetPlacement) {
+          return {
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+      }
+      return {};
+    }
+  };
+};
+
 // For type backwards-compatibility, the `OffsetOptions` type was also
 // Derivable.
 async function convertValueToCoords(state, options) {
@@ -3640,6 +3869,44 @@ function useFloating$1(options) {
   }), [data, update, refs, elements, floatingStyles]);
 }
 
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow$1 = options => {
+  function isRef(value) {
+    return {}.hasOwnProperty.call(value, 'current');
+  }
+  return {
+    name: 'arrow',
+    options,
+    fn(state) {
+      const {
+        element,
+        padding
+      } = typeof options === 'function' ? options(state) : options;
+      if (element && isRef(element)) {
+        if (element.current != null) {
+          return arrow$2({
+            element: element.current,
+            padding
+          }).fn(state);
+        }
+        return {};
+      }
+      if (element) {
+        return arrow$2({
+          element,
+          padding
+        }).fn(state);
+      }
+      return {};
+    }
+  };
+};
+
 /**
  * Modifies the placement by translating the floating element along the
  * specified axes.
@@ -3662,6 +3929,17 @@ const shift = (options, deps) => ({
   options: [options, deps]
 });
 
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip = (options, deps) => ({
+  ...flip$1(options),
+  options: [options, deps]
+});
+
 /**
  * Optimizes the visibility of the floating element by choosing the placement
  * that has the most space available automatically, without needing to specify a
@@ -3673,6 +3951,17 @@ const autoPlacement = (options, deps) => ({
   options: [options, deps]
 });
 
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow = (options, deps) => ({
+  ...arrow$1(options),
+  options: [options, deps]
+});
+
 // https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379
 const SafeReact = {
   ...React__namespace
@@ -5597,8 +5886,10 @@ exports.FloatingNode = FloatingNode;
 exports.FloatingOverlay = FloatingOverlay;
 exports.FloatingPortal = FloatingPortal;
 exports.FloatingTree = FloatingTree;
+exports.arrow = arrow;
 exports.autoPlacement = autoPlacement;
 exports.autoUpdate = autoUpdate;
+exports.flip = flip;
 exports.offset = offset;
 exports.shift = shift;
 exports.useClick = useClick;

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

@@ -2165,9 +2165,41 @@ function getAlignmentSides(placement, rects, rtl) {
   }
   return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
 }
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
 function getOppositeAlignmentPlacement(placement) {
   return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
 }
+function getSideList(side, isStart, rtl) {
+  const lr = ['left', 'right'];
+  const rl = ['right', 'left'];
+  const tb = ['top', 'bottom'];
+  const bt = ['bottom', 'top'];
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case 'left':
+    case 'right':
+      return isStart ? tb : bt;
+    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) {
   return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
 }
@@ -2409,6 +2441,88 @@ async function detectOverflow(state, options) {
   };
 }
 
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow$2 = options => ({
+  name: 'arrow',
+  options,
+  async fn(state) {
+    const {
+      x,
+      y,
+      placement,
+      rects,
+      platform,
+      elements,
+      middlewareData
+    } = state;
+    // Since `element` is required, we don't Partial<> the type.
+    const {
+      element,
+      padding = 0
+    } = evaluate(options, state) || {};
+    if (element == null) {
+      return {};
+    }
+    const paddingObject = getPaddingObject(padding);
+    const coords = {
+      x,
+      y
+    };
+    const axis = getAlignmentAxis(placement);
+    const length = getAxisLength(axis);
+    const arrowDimensions = await platform.getDimensions(element);
+    const isYAxis = axis === 'y';
+    const minProp = isYAxis ? 'top' : 'left';
+    const maxProp = isYAxis ? 'bottom' : 'right';
+    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';
+    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+    const startDiff = coords[axis] - rects.reference[axis];
+    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
+    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+
+    // DOM platform can return `window` as the `offsetParent`.
+    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {
+      clientSize = elements.floating[clientProp] || rects.floating[length];
+    }
+    const centerToReference = endDiff / 2 - startDiff / 2;
+
+    // If the padding is large enough that it causes the arrow to no longer be
+    // centered, modify the padding so that it is centered.
+    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+
+    // Make sure the arrow doesn't overflow the floating element if the center
+    // point is outside the floating element's bounds.
+    const min$1 = minPadding;
+    const max = clientSize - arrowDimensions[length] - maxPadding;
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset = clamp(min$1, center, max);
+
+    // If the reference is small enough that the arrow's padding causes it to
+    // to point to nothing for an aligned placement, adjust the offset of the
+    // floating element itself. To ensure `shift()` continues to take action,
+    // a single reset is performed when this is true.
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
+    return {
+      [axis]: coords[axis] + alignmentOffset,
+      data: {
+        [axis]: offset,
+        centerOffset: center - offset - alignmentOffset,
+        ...(shouldAddOffset && {
+          alignmentOffset
+        })
+      },
+      reset: shouldAddOffset
+    };
+  }
+});
+
 function getPlacementList(alignment, autoAlignment, allowedPlacements) {
   const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);
   return allowedPlacementsSortedByAlignment.filter(placement => {
@@ -2512,6 +2626,121 @@ const autoPlacement$1 = function (options) {
   };
 };
 
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip$1 = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'flip',
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform,
+        elements
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = 'bestFit',
+        fallbackAxisSideDirection = 'none',
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+
+      // If a reset by the arrow was caused due to an alignment offset being
+      // added, we should skip any logic now since `flip()` has already done its
+      // work.
+      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      const side = getSide(placement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+
+      // One or more sides is overflowing.
+      if (!overflows.every(side => side <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements[nextIndex];
+        if (nextPlacement) {
+          // Try next placement and re-run the lifecycle.
+          return {
+            data: {
+              index: nextIndex,
+              overflows: overflowsData
+            },
+            reset: {
+              placement: nextPlacement
+            }
+          };
+        }
+
+        // First, find the candidates that fit on the mainAxis side of overflow,
+        // then find the placement that fits the best on the main crossAxis side.
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+
+        // Otherwise fallback.
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
+            case 'bestFit':
+              {
+                var _overflowsData$map$so;
+                const placement = (_overflowsData$map$so = overflowsData.map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
+                if (placement) {
+                  resetPlacement = placement;
+                }
+                break;
+              }
+            case 'initialPlacement':
+              resetPlacement = initialPlacement;
+              break;
+          }
+        }
+        if (placement !== resetPlacement) {
+          return {
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+      }
+      return {};
+    }
+  };
+};
+
 // For type backwards-compatibility, the `OffsetOptions` type was also
 // Derivable.
 async function convertValueToCoords(state, options) {
@@ -3619,6 +3848,44 @@ function useFloating$1(options) {
   }), [data, update, refs, elements, floatingStyles]);
 }
 
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow$1 = options => {
+  function isRef(value) {
+    return {}.hasOwnProperty.call(value, 'current');
+  }
+  return {
+    name: 'arrow',
+    options,
+    fn(state) {
+      const {
+        element,
+        padding
+      } = typeof options === 'function' ? options(state) : options;
+      if (element && isRef(element)) {
+        if (element.current != null) {
+          return arrow$2({
+            element: element.current,
+            padding
+          }).fn(state);
+        }
+        return {};
+      }
+      if (element) {
+        return arrow$2({
+          element,
+          padding
+        }).fn(state);
+      }
+      return {};
+    }
+  };
+};
+
 /**
  * Modifies the placement by translating the floating element along the
  * specified axes.
@@ -3641,6 +3908,17 @@ const shift = (options, deps) => ({
   options: [options, deps]
 });
 
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+const flip = (options, deps) => ({
+  ...flip$1(options),
+  options: [options, deps]
+});
+
 /**
  * Optimizes the visibility of the floating element by choosing the placement
  * that has the most space available automatically, without needing to specify a
@@ -3652,6 +3930,17 @@ const autoPlacement = (options, deps) => ({
   options: [options, deps]
 });
 
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * This wraps the core `arrow` middleware to allow React refs as the element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+const arrow = (options, deps) => ({
+  ...arrow$1(options),
+  options: [options, deps]
+});
+
 // https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379
 const SafeReact = {
   ...React
@@ -5571,4 +5860,4 @@ function useRole(context, props) {
   } : {}, [enabled, reference, floating, item]);
 }
 
-export { FloatingTree as F, useFloatingNodeId as a, useFloating as b, autoPlacement as c, autoUpdate as d, useDismiss as e, useInteractions as f, FloatingNode as g, FloatingPortal as h, useClick as i, useRole as j, FloatingOverlay as k, FloatingFocusManager as l, offset as o, shift as s, useFloatingParentNodeId as u };
+export { FloatingTree as F, useFloatingNodeId as a, useFloating as b, autoPlacement as c, autoUpdate as d, useDismiss as e, useInteractions as f, FloatingNode as g, FloatingPortal as h, arrow as i, flip as j, useClick as k, useRole as l, FloatingOverlay as m, FloatingFocusManager as n, offset as o, shift as s, useFloatingParentNodeId as u };

package/dist/styles.css

@@ -9099,58 +9099,37 @@ input.oOrjwubmsVA- {
 }
 
 .uClo-5-xhAc- {
-  visibility: hidden;
-}
-
-.uClo-5-xhAc-,
-.uClo-5-xhAc-::before {
   position: absolute;
   width: 16px;
   width: var(--base-unit);
   height: 16px;
   height: var(--base-unit);
-  background: inherit;
-}
-
-.uClo-5-xhAc-::before {
-  content: "";
-  visibility: visible;
   border: 1px solid hsl(200, 13%, 87%);
   border: var(--border-base) solid var(--color-border);
-  -webkit-transform: rotate(45deg);
-          transform: rotate(45deg);
+  background: inherit;
   -webkit-transform-origin: center;
           transform-origin: center;
   clip-path: polygon(-4px -4px, 15.3px 0, 0 15.3px);
 }
 
-.rY8OtuArIi0-[data-popper-placement^="top"] > .uClo-5-xhAc- {
-  bottom: var(--popover--position--offset);
-}
+/* Arrow rotation based on placement */
 
-.rY8OtuArIi0-[data-popper-placement^="top"] > .uClo-5-xhAc-::before {
+.rY8OtuArIi0-[data-popover-placement^="top"] > .uClo-5-xhAc- {
   -webkit-transform: rotate(-135deg);
           transform: rotate(-135deg);
 }
 
-.rY8OtuArIi0-[data-popper-placement^="bottom"] > .uClo-5-xhAc- {
-  top: var(--popover--position--offset);
-}
-
-.rY8OtuArIi0-[data-popper-placement^="left"] > .uClo-5-xhAc- {
-  right: var(--popover--position--offset);
+.rY8OtuArIi0-[data-popover-placement^="bottom"] > .uClo-5-xhAc- {
+  -webkit-transform: rotate(45deg);
+          transform: rotate(45deg);
 }
 
-.rY8OtuArIi0-[data-popper-placement^="left"] > .uClo-5-xhAc-::before {
+.rY8OtuArIi0-[data-popover-placement^="left"] > .uClo-5-xhAc- {
   -webkit-transform: rotate(135deg);
           transform: rotate(135deg);
 }
 
-.rY8OtuArIi0-[data-popper-placement^="right"] > .uClo-5-xhAc- {
-  left: var(--popover--position--offset);
-}
-
-.rY8OtuArIi0-[data-popper-placement^="right"] > .uClo-5-xhAc-::before {
+.rY8OtuArIi0-[data-popover-placement^="right"] > .uClo-5-xhAc- {
   -webkit-transform: rotate(-45deg);
           transform: rotate(-45deg);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jobber/components",
-  "version": "6.65.0",
+  "version": "6.66.0",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.cjs",
@@ -542,5 +542,5 @@
     "> 1%",
     "IE 10"
   ],
-  "gitHead": "338b1fb6602a28436cd0702a28cef1014bfae49c"
+  "gitHead": "c4b9bf8f3dab846ea63b3f772f993a5232de10af"
 }