@ballistix.digital/react-components 3.0.1 → 3.1.1

package/dist/index.js

@@ -598,6 +598,15 @@ function isOverflowElement(element) {
 function isTableElement(element) {
   return ['table', 'td', 'th'].includes(getNodeName(element));
 }
+function isTopLayer(element) {
+  return [':popover-open', ':modal'].some(selector => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
+  });
+}
 function isContainingBlock(element) {
   const webkit = isWebKit();
   const css = getComputedStyle(element);
@@ -606,6 +615,9 @@ function isContainingBlock(element) {
 function getContainingBlock(element) {
   let currentNode = getParentNode(element);
   while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isTopLayer(currentNode)) {
+      return null;
+    }
     if (isContainingBlock(currentNode)) {
       return currentNode;
     }
@@ -631,8 +643,8 @@ function getNodeScroll(element) {
     };
   }
   return {
-    scrollLeft: element.pageXOffset,
-    scrollTop: element.pageYOffset
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
   };
 }
 function getParentNode(node) {
@@ -740,7 +752,7 @@ function isJSDOM() {
 }
 function isMouseLikePointerType(pointerType, strict) {
   const values = ['mouse', 'pen'];
-  if (!strict) {
+  {
     values.push('', undefined);
   }
   return values.includes(pointerType);
@@ -1197,10 +1209,12 @@ const flip$2 = function (options) {
         return {};
       }
       const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
       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') {
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
+      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
         fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
       const placements = [initialPlacement, ...fallbackPlacements];
@@ -1238,8 +1252,15 @@ const flip$2 = function (options) {
           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];
+                var _overflowsData$filter2;
+                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
+                  if (hasFallbackAxisSideDirection) {
+                    const currentSideAxis = getSideAxis(d.placement);
+                    return currentSideAxis === initialSideAxis ||
+                    currentSideAxis === 'y';
+                  }
+                  return true;
+                }).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$filter2[0];
                 if (placement) {
                   resetPlacement = placement;
                 }
@@ -1516,16 +1537,6 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
     y
   });
 }
-const topLayerSelectors = [':popover-open', ':modal'];
-function isTopLayer(element) {
-  return topLayerSelectors.some(selector => {
-    try {
-      return element.matches(selector);
-    } catch (e) {
-      return false;
-    }
-  });
-}
 function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
   let {
     elements,
@@ -2871,6 +2882,14 @@ const FloatingArrow = React__namespace.forwardRef(function FloatingArrow(props,
     }
   }
   const clipPathId = useId();
+  const [isRTL, setIsRTL] = React__namespace.useState(false);
+  index(() => {
+    if (!floating) return;
+    const isRTL = getComputedStyle(floating).direction === 'rtl';
+    if (isRTL) {
+      setIsRTL(true);
+    }
+  }, [floating]);
   if (!floating) {
     return null;
   }
@@ -2879,7 +2898,6 @@ const FloatingArrow = React__namespace.forwardRef(function FloatingArrow(props,
   const svgX = width / 2 * (tipRadius / -8 + 1);
   const svgY = height / 2 * tipRadius / 4;
   const [side, alignment] = placement.split('-');
-  const isRTL = platform.isRTL(floating);
   const isCustomShape = !!d;
   const isVerticalSide = side === 'top' || side === 'bottom';
   const yOffsetProp = staticOffset && alignment === 'end' ? 'bottom' : 'top';
@@ -2982,10 +3000,7 @@ function useHover(context, props) {
     onOpenChange,
     dataRef,
     events,
-    elements: {
-      domReference,
-      floating
-    }
+    elements
   } = context;
   const {
     enabled = true,
@@ -2999,6 +3014,7 @@ function useHover(context, props) {
   const parentId = useFloatingParentNodeId();
   const handleCloseRef = useLatestRef(handleClose);
   const delayRef = useLatestRef(delay);
+  const openRef = useLatestRef(open);
   const pointerTypeRef = React__namespace.useRef();
   const timeoutRef = React__namespace.useRef(-1);
   const handlerRef = React__namespace.useRef();
@@ -3012,9 +3028,7 @@ function useHover(context, props) {
     return (type == null ? void 0 : type.includes('mouse')) && type !== 'mousedown';
   }, [dataRef]);
   React__namespace.useEffect(() => {
-    if (!enabled) {
-      return;
-    }
+    if (!enabled) return;
     function onOpenChange(_ref) {
       let {
         open
@@ -3031,20 +3045,20 @@ function useHover(context, props) {
     };
   }, [enabled, events]);
   React__namespace.useEffect(() => {
-    if (!enabled || !handleCloseRef.current || !open) {
-      return;
-    }
+    if (!enabled) return;
+    if (!handleCloseRef.current) return;
+    if (!open) return;
     function onLeave(event) {
       if (isHoverOpen()) {
         onOpenChange(false, event, 'hover');
       }
     }
-    const html = getDocument(floating).documentElement;
+    const html = getDocument(elements.floating).documentElement;
     html.addEventListener('mouseleave', onLeave);
     return () => {
       html.removeEventListener('mouseleave', onLeave);
     };
-  }, [floating, open, onOpenChange, enabled, handleCloseRef, isHoverOpen]);
+  }, [elements.floating, open, onOpenChange, enabled, handleCloseRef, isHoverOpen]);
   const closeWithDelay = React__namespace.useCallback(function (event, runElseBranch, reason) {
     if (runElseBranch === void 0) {
       runElseBranch = true;
@@ -3067,16 +3081,14 @@ function useHover(context, props) {
   });
   const clearPointerEvents = useEffectEvent(() => {
     if (performedPointerEventsMutationRef.current) {
-      const body = getDocument(floating).body;
+      const body = getDocument(elements.floating).body;
       body.style.pointerEvents = '';
       body.removeAttribute(safePolygonIdentifier);
       performedPointerEventsMutationRef.current = false;
     }
   });
   React__namespace.useEffect(() => {
-    if (!enabled) {
-      return;
-    }
+    if (!enabled) return;
     function isClickLikeOpenEvent() {
       return dataRef.current.openEvent ? ['click', 'mousedown'].includes(dataRef.current.openEvent.type) : false;
     }
@@ -3089,7 +3101,9 @@ function useHover(context, props) {
       const openDelay = getDelay(delayRef.current, 'open', pointerTypeRef.current);
       if (openDelay) {
         timeoutRef.current = window.setTimeout(() => {
-          onOpenChange(true, event, 'hover');
+          if (!openRef.current) {
+            onOpenChange(true, event, 'hover');
+          }
         }, openDelay);
       } else {
         onOpenChange(true, event, 'hover');
@@ -3098,7 +3112,7 @@ function useHover(context, props) {
     function onMouseLeave(event) {
       if (isClickLikeOpenEvent()) return;
       unbindMouseMoveRef.current();
-      const doc = getDocument(floating);
+      const doc = getDocument(elements.floating);
       clearTimeout(restTimeoutRef.current);
       if (handleCloseRef.current && dataRef.current.floatingContext) {
         if (!open) {
@@ -3122,7 +3136,7 @@ function useHover(context, props) {
         };
         return;
       }
-      const shouldClose = pointerTypeRef.current === 'touch' ? !contains(floating, event.relatedTarget) : true;
+      const shouldClose = pointerTypeRef.current === 'touch' ? !contains(elements.floating, event.relatedTarget) : true;
       if (shouldClose) {
         closeWithDelay(event);
       }
@@ -3142,50 +3156,51 @@ function useHover(context, props) {
         }
       })(event);
     }
-    if (isElement(domReference)) {
-      const ref = domReference;
+    if (isElement(elements.domReference)) {
+      var _elements$floating;
+      const ref = elements.domReference;
       open && ref.addEventListener('mouseleave', onScrollMouseLeave);
-      floating == null || floating.addEventListener('mouseleave', onScrollMouseLeave);
+      (_elements$floating = elements.floating) == null || _elements$floating.addEventListener('mouseleave', onScrollMouseLeave);
       move && ref.addEventListener('mousemove', onMouseEnter, {
         once: true
       });
       ref.addEventListener('mouseenter', onMouseEnter);
       ref.addEventListener('mouseleave', onMouseLeave);
       return () => {
+        var _elements$floating2;
         open && ref.removeEventListener('mouseleave', onScrollMouseLeave);
-        floating == null || floating.removeEventListener('mouseleave', onScrollMouseLeave);
+        (_elements$floating2 = elements.floating) == null || _elements$floating2.removeEventListener('mouseleave', onScrollMouseLeave);
         move && ref.removeEventListener('mousemove', onMouseEnter);
         ref.removeEventListener('mouseenter', onMouseEnter);
         ref.removeEventListener('mouseleave', onMouseLeave);
       };
     }
-  }, [domReference, floating, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, tree, delayRef, handleCloseRef, dataRef]);
+  }, [elements, enabled, context, mouseOnly, restMs, move, closeWithDelay, cleanupMouseMoveHandler, clearPointerEvents, onOpenChange, open, openRef, tree, delayRef, handleCloseRef, dataRef]);
   index(() => {
     var _handleCloseRef$curre;
-    if (!enabled) {
-      return;
-    }
+    if (!enabled) return;
     if (open && (_handleCloseRef$curre = handleCloseRef.current) != null && _handleCloseRef$curre.__options.blockPointerEvents && isHoverOpen()) {
-      const body = getDocument(floating).body;
+      const body = getDocument(elements.floating).body;
       body.setAttribute(safePolygonIdentifier, '');
       body.style.pointerEvents = 'none';
       performedPointerEventsMutationRef.current = true;
-      if (isElement(domReference) && floating) {
+      const floatingEl = elements.floating;
+      if (isElement(elements.domReference) && floatingEl) {
         var _tree$nodesRef$curren;
-        const ref = domReference;
+        const ref = elements.domReference;
         const parentFloating = tree == null || (_tree$nodesRef$curren = tree.nodesRef.current.find(node => node.id === parentId)) == null || (_tree$nodesRef$curren = _tree$nodesRef$curren.context) == null ? void 0 : _tree$nodesRef$curren.elements.floating;
         if (parentFloating) {
           parentFloating.style.pointerEvents = '';
         }
         ref.style.pointerEvents = 'auto';
-        floating.style.pointerEvents = 'auto';
+        floatingEl.style.pointerEvents = 'auto';
         return () => {
           ref.style.pointerEvents = '';
-          floating.style.pointerEvents = '';
+          floatingEl.style.pointerEvents = '';
         };
       }
     }
-  }, [enabled, open, parentId, floating, domReference, tree, handleCloseRef, isHoverOpen]);
+  }, [enabled, open, parentId, elements, tree, handleCloseRef, isHoverOpen]);
   index(() => {
     if (!open) {
       pointerTypeRef.current = undefined;
@@ -3200,51 +3215,50 @@ function useHover(context, props) {
       clearTimeout(restTimeoutRef.current);
       clearPointerEvents();
     };
-  }, [enabled, domReference, cleanupMouseMoveHandler, clearPointerEvents]);
-  return React__namespace.useMemo(() => {
-    if (!enabled) {
-      return {};
-    }
+  }, [enabled, elements.domReference, cleanupMouseMoveHandler, clearPointerEvents]);
+  const reference = React__namespace.useMemo(() => {
     function setPointerRef(event) {
       pointerTypeRef.current = event.pointerType;
     }
     return {
-      reference: {
-        onPointerDown: setPointerRef,
-        onPointerEnter: setPointerRef,
-        onMouseMove(event) {
-          const {
-            nativeEvent
-          } = event;
-          function handleMouseMove() {
-            if (!blockMouseMoveRef.current) {
-              onOpenChange(true, nativeEvent, 'hover');
-            }
-          }
-          if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) {
-            return;
-          }
-          if (open || restMs === 0) {
-            return;
-          }
-          clearTimeout(restTimeoutRef.current);
-          if (pointerTypeRef.current === 'touch') {
-            handleMouseMove();
-          } else {
-            restTimeoutRef.current = window.setTimeout(handleMouseMove, restMs);
+      onPointerDown: setPointerRef,
+      onPointerEnter: setPointerRef,
+      onMouseMove(event) {
+        const {
+          nativeEvent
+        } = event;
+        function handleMouseMove() {
+          if (!blockMouseMoveRef.current && !openRef.current) {
+            onOpenChange(true, nativeEvent, 'hover');
           }
         }
-      },
-      floating: {
-        onMouseEnter() {
-          clearTimeout(timeoutRef.current);
-        },
-        onMouseLeave(event) {
-          closeWithDelay(event.nativeEvent, false);
+        if (mouseOnly && !isMouseLikePointerType(pointerTypeRef.current)) {
+          return;
+        }
+        if (open || restMs === 0) {
+          return;
+        }
+        clearTimeout(restTimeoutRef.current);
+        if (pointerTypeRef.current === 'touch') {
+          handleMouseMove();
+        } else {
+          restTimeoutRef.current = window.setTimeout(handleMouseMove, restMs);
         }
       }
     };
-  }, [enabled, mouseOnly, open, restMs, onOpenChange, closeWithDelay]);
+  }, [mouseOnly, onOpenChange, open, openRef, restMs]);
+  const floating = React__namespace.useMemo(() => ({
+    onMouseEnter() {
+      clearTimeout(timeoutRef.current);
+    },
+    onMouseLeave(event) {
+      closeWithDelay(event.nativeEvent, false);
+    }
+  }), [closeWithDelay]);
+  return React__namespace.useMemo(() => enabled ? {
+    reference,
+    floating
+  } : {}, [enabled, reference, floating]);
 }
 const NOOP = () => {};
 React__namespace.createContext({
@@ -3339,8 +3353,8 @@ React__namespace.forwardRef(function FloatingOverlay(props, ref) {
     const scrollbarX = Math.round(document.documentElement.getBoundingClientRect().left) + document.documentElement.scrollLeft;
     const paddingProp = scrollbarX ? 'paddingLeft' : 'paddingRight';
     const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
-    const scrollX = bodyStyle.left ? parseFloat(bodyStyle.left) : window.pageXOffset;
-    const scrollY = bodyStyle.top ? parseFloat(bodyStyle.top) : window.pageYOffset;
+    const scrollX = bodyStyle.left ? parseFloat(bodyStyle.left) : window.scrollX;
+    const scrollY = bodyStyle.top ? parseFloat(bodyStyle.top) : window.scrollY;
     bodyStyle.overflow = 'hidden';
     if (scrollbarWidth) {
       bodyStyle[paddingProp] = scrollbarWidth + "px";
@@ -3413,11 +3427,7 @@ function useDismiss(context, props) {
   const {
     open,
     onOpenChange,
-    elements: {
-      reference,
-      domReference,
-      floating
-    },
+    elements,
     dataRef
   } = context;
   const {
@@ -3495,7 +3505,7 @@ function useDismiss(context, props) {
     }
     const target = getTarget(event);
     const inertSelector = "[" + createAttribute('inert') + "]";
-    const markers = getDocument(floating).querySelectorAll(inertSelector);
+    const markers = getDocument(elements.floating).querySelectorAll(inertSelector);
     let targetRootAncestor = isElement(target) ? target : null;
     while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
       const nextParent = getParentNode(targetRootAncestor);
@@ -3505,7 +3515,7 @@ function useDismiss(context, props) {
       targetRootAncestor = nextParent;
     }
     if (markers.length && isElement(target) && !isRootElement(target) &&
-    !contains(target, floating) &&
+    !contains(target, elements.floating) &&
     Array.from(markers).every(marker => !contains(targetRootAncestor, marker))) {
       return;
     }
@@ -3528,7 +3538,7 @@ function useDismiss(context, props) {
       var _node$context;
       return isEventTargetWithin(event, (_node$context = node.context) == null ? void 0 : _node$context.elements.floating);
     });
-    if (isEventTargetWithin(event, floating) || isEventTargetWithin(event, domReference) || targetIsInsideChildren) {
+    if (isEventTargetWithin(event, elements.floating) || isEventTargetWithin(event, elements.domReference) || targetIsInsideChildren) {
       return;
     }
     const children = tree ? getChildren(tree.nodesRef.current, nodeId) : [];
@@ -3565,19 +3575,19 @@ function useDismiss(context, props) {
     function onScroll(event) {
       onOpenChange(false, event, 'ancestor-scroll');
     }
-    const doc = getDocument(floating);
+    const doc = getDocument(elements.floating);
     escapeKey && doc.addEventListener('keydown', escapeKeyCapture ? closeOnEscapeKeyDownCapture : closeOnEscapeKeyDown, escapeKeyCapture);
     outsidePress && doc.addEventListener(outsidePressEvent, outsidePressCapture ? closeOnPressOutsideCapture : closeOnPressOutside, outsidePressCapture);
     let ancestors = [];
     if (ancestorScroll) {
-      if (isElement(domReference)) {
-        ancestors = getOverflowAncestors(domReference);
+      if (isElement(elements.domReference)) {
+        ancestors = getOverflowAncestors(elements.domReference);
       }
-      if (isElement(floating)) {
-        ancestors = ancestors.concat(getOverflowAncestors(floating));
+      if (isElement(elements.floating)) {
+        ancestors = ancestors.concat(getOverflowAncestors(elements.floating));
       }
-      if (!isElement(reference) && reference && reference.contextElement) {
-        ancestors = ancestors.concat(getOverflowAncestors(reference.contextElement));
+      if (!isElement(elements.reference) && elements.reference && elements.reference.contextElement) {
+        ancestors = ancestors.concat(getOverflowAncestors(elements.reference.contextElement));
       }
     }
     ancestors = ancestors.filter(ancestor => {
@@ -3596,37 +3606,34 @@ function useDismiss(context, props) {
         ancestor.removeEventListener('scroll', onScroll);
       });
     };
-  }, [dataRef, floating, domReference, reference, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);
+  }, [dataRef, elements, escapeKey, outsidePress, outsidePressEvent, open, onOpenChange, ancestorScroll, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, escapeKeyCapture, closeOnEscapeKeyDownCapture, closeOnPressOutside, outsidePressCapture, closeOnPressOutsideCapture]);
   React__namespace.useEffect(() => {
     insideReactTreeRef.current = false;
   }, [outsidePress, outsidePressEvent]);
-  return React__namespace.useMemo(() => {
-    if (!enabled) {
-      return {};
-    }
-    return {
-      reference: {
-        onKeyDown: closeOnEscapeKeyDown,
-        [bubbleHandlerKeys[referencePressEvent]]: event => {
-          if (referencePress) {
-            onOpenChange(false, event.nativeEvent, 'reference-press');
-          }
-        }
-      },
-      floating: {
-        onKeyDown: closeOnEscapeKeyDown,
-        onMouseDown() {
-          endedOrStartedInsideRef.current = true;
-        },
-        onMouseUp() {
-          endedOrStartedInsideRef.current = true;
-        },
-        [captureHandlerKeys[outsidePressEvent]]: () => {
-          insideReactTreeRef.current = true;
-        }
+  const reference = React__namespace.useMemo(() => ({
+    onKeyDown: closeOnEscapeKeyDown,
+    [bubbleHandlerKeys[referencePressEvent]]: event => {
+      if (referencePress) {
+        onOpenChange(false, event.nativeEvent, 'reference-press');
       }
-    };
-  }, [enabled, referencePress, outsidePressEvent, referencePressEvent, onOpenChange, closeOnEscapeKeyDown]);
+    }
+  }), [closeOnEscapeKeyDown, onOpenChange, referencePress, referencePressEvent]);
+  const floating = React__namespace.useMemo(() => ({
+    onKeyDown: closeOnEscapeKeyDown,
+    onMouseDown() {
+      endedOrStartedInsideRef.current = true;
+    },
+    onMouseUp() {
+      endedOrStartedInsideRef.current = true;
+    },
+    [captureHandlerKeys[outsidePressEvent]]: () => {
+      insideReactTreeRef.current = true;
+    }
+  }), [closeOnEscapeKeyDown, outsidePressEvent]);
+  return React__namespace.useMemo(() => enabled ? {
+    reference,
+    floating
+  } : {}, [enabled, reference, floating]);
 }
 function useFloatingRootContext(options) {
   const {
@@ -3768,9 +3775,7 @@ function useFocus(context, props) {
     onOpenChange,
     events,
     dataRef,
-    elements: {
-      domReference
-    }
+    elements
   } = context;
   const {
     enabled = true,
@@ -3780,12 +3785,10 @@ function useFocus(context, props) {
   const timeoutRef = React__namespace.useRef();
   const keyboardModalityRef = React__namespace.useRef(true);
   React__namespace.useEffect(() => {
-    if (!enabled) {
-      return;
-    }
-    const win = getWindow(domReference);
+    if (!enabled) return;
+    const win = getWindow(elements.domReference);
     function onBlur() {
-      if (!open && isHTMLElement(domReference) && domReference === activeElement(getDocument(domReference))) {
+      if (!open && isHTMLElement(elements.domReference) && elements.domReference === activeElement(getDocument(elements.domReference))) {
         blockFocusRef.current = true;
       }
     }
@@ -3798,11 +3801,9 @@ function useFocus(context, props) {
       win.removeEventListener('blur', onBlur);
       win.removeEventListener('keydown', onKeyDown, true);
     };
-  }, [domReference, open, enabled]);
+  }, [elements.domReference, open, enabled]);
   React__namespace.useEffect(() => {
-    if (!enabled) {
-      return;
-    }
+    if (!enabled) return;
     function onOpenChange(_ref) {
       let {
         reason
@@ -3821,51 +3822,48 @@ function useFocus(context, props) {
       clearTimeout(timeoutRef.current);
     };
   }, []);
-  return React__namespace.useMemo(() => {
-    if (!enabled) {
-      return {};
-    }
-    return {
-      reference: {
-        onPointerDown(event) {
-          if (isVirtualPointerEvent(event.nativeEvent)) return;
-          keyboardModalityRef.current = false;
-        },
-        onMouseLeave() {
-          blockFocusRef.current = false;
-        },
-        onFocus(event) {
-          if (blockFocusRef.current) return;
-          const target = getTarget(event.nativeEvent);
-          if (visibleOnly && isElement(target)) {
-            try {
-              if (isSafari() && isMac()) throw Error();
-              if (!target.matches(':focus-visible')) return;
-            } catch (e) {
-              if (!keyboardModalityRef.current && !isTypeableElement(target)) {
-                return;
-              }
-            }
+  const reference = React__namespace.useMemo(() => ({
+    onPointerDown(event) {
+      if (isVirtualPointerEvent(event.nativeEvent)) return;
+      keyboardModalityRef.current = false;
+    },
+    onMouseLeave() {
+      blockFocusRef.current = false;
+    },
+    onFocus(event) {
+      if (blockFocusRef.current) return;
+      const target = getTarget(event.nativeEvent);
+      if (visibleOnly && isElement(target)) {
+        try {
+          if (isSafari() && isMac()) throw Error();
+          if (!target.matches(':focus-visible')) return;
+        } catch (e) {
+          if (!keyboardModalityRef.current && !isTypeableElement(target)) {
+            return;
           }
-          onOpenChange(true, event.nativeEvent, 'focus');
-        },
-        onBlur(event) {
-          blockFocusRef.current = false;
-          const relatedTarget = event.relatedTarget;
-          const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute('focus-guard')) && relatedTarget.getAttribute('data-type') === 'outside';
-          timeoutRef.current = window.setTimeout(() => {
-            var _dataRef$current$floa;
-            const activeEl = activeElement(domReference ? domReference.ownerDocument : document);
-            if (!relatedTarget && activeEl === domReference) return;
-            if (contains((_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.refs.floating.current, activeEl) || contains(domReference, activeEl) || movedToFocusGuard) {
-              return;
-            }
-            onOpenChange(false, event.nativeEvent, 'focus');
-          });
         }
       }
-    };
-  }, [enabled, visibleOnly, dataRef, domReference, onOpenChange]);
+      onOpenChange(true, event.nativeEvent, 'focus');
+    },
+    onBlur(event) {
+      blockFocusRef.current = false;
+      const relatedTarget = event.relatedTarget;
+      const nativeEvent = event.nativeEvent;
+      const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute('focus-guard')) && relatedTarget.getAttribute('data-type') === 'outside';
+      timeoutRef.current = window.setTimeout(() => {
+        var _dataRef$current$floa;
+        const activeEl = activeElement(elements.domReference ? elements.domReference.ownerDocument : document);
+        if (!relatedTarget && activeEl === elements.domReference) return;
+        if (contains((_dataRef$current$floa = dataRef.current.floatingContext) == null ? void 0 : _dataRef$current$floa.refs.floating.current, activeEl) || contains(elements.domReference, activeEl) || movedToFocusGuard) {
+          return;
+        }
+        onOpenChange(false, nativeEvent, 'focus');
+      });
+    }
+  }), [dataRef, elements.domReference, onOpenChange, visibleOnly]);
+  return React__namespace.useMemo(() => enabled ? {
+    reference
+  } : {}, [enabled, reference]);
 }
 const ACTIVE_KEY = 'active';
 const SELECTED_KEY = 'selected';
@@ -3928,13 +3926,15 @@ function useInteractions(propsList) {
   if (propsList === void 0) {
     propsList = [];
   }
-  const deps = propsList;
+  const referenceDeps = propsList.map(key => key == null ? void 0 : key.reference);
+  const floatingDeps = propsList.map(key => key == null ? void 0 : key.floating);
+  const itemDeps = propsList.map(key => key == null ? void 0 : key.item);
   const getReferenceProps = React__namespace.useCallback(userProps => mergeProps(userProps, propsList, 'reference'),
-  deps);
+  referenceDeps);
   const getFloatingProps = React__namespace.useCallback(userProps => mergeProps(userProps, propsList, 'floating'),
-  deps);
+  floatingDeps);
   const getItemProps = React__namespace.useCallback(userProps => mergeProps(userProps, propsList, 'item'),
-  propsList.map(key => key == null ? void 0 : key.item));
+  itemDeps);
   return React__namespace.useMemo(() => ({
     getReferenceProps,
     getFloatingProps,
@@ -3959,8 +3959,34 @@ function useRole(context, props) {
   const referenceId = useId();
   const parentId = useFloatingParentNodeId();
   const isNested = parentId != null;
-  return React__namespace.useMemo(() => {
-    if (!enabled) return {};
+  const reference = React__namespace.useMemo(() => {
+    if (ariaRole === 'tooltip' || role === 'label') {
+      return {
+        ["aria-" + (role === 'label' ? 'labelledby' : 'describedby')]: open ? floatingId : undefined
+      };
+    }
+    return {
+      'aria-expanded': open ? 'true' : 'false',
+      'aria-haspopup': ariaRole === 'alertdialog' ? 'dialog' : ariaRole,
+      'aria-controls': open ? floatingId : undefined,
+      ...(ariaRole === 'listbox' && {
+        role: 'combobox'
+      }),
+      ...(ariaRole === 'menu' && {
+        id: referenceId
+      }),
+      ...(ariaRole === 'menu' && isNested && {
+        role: 'menuitem'
+      }),
+      ...(role === 'select' && {
+        'aria-autocomplete': 'none'
+      }),
+      ...(role === 'combobox' && {
+        'aria-autocomplete': 'list'
+      })
+    };
+  }, [ariaRole, floatingId, isNested, open, referenceId, role]);
+  const floating = React__namespace.useMemo(() => {
     const floatingProps = {
       id: floatingId,
       ...(ariaRole && {
@@ -3968,71 +3994,49 @@ function useRole(context, props) {
       })
     };
     if (ariaRole === 'tooltip' || role === 'label') {
-      return {
-        reference: {
-          ["aria-" + (role === 'label' ? 'labelledby' : 'describedby')]: open ? floatingId : undefined
-        },
-        floating: floatingProps
-      };
+      return floatingProps;
     }
     return {
-      reference: {
-        'aria-expanded': open ? 'true' : 'false',
-        'aria-haspopup': ariaRole === 'alertdialog' ? 'dialog' : ariaRole,
-        'aria-controls': open ? floatingId : undefined,
-        ...(ariaRole === 'listbox' && {
-          role: 'combobox'
-        }),
-        ...(ariaRole === 'menu' && {
-          id: referenceId
-        }),
-        ...(ariaRole === 'menu' && isNested && {
-          role: 'menuitem'
-        }),
-        ...(role === 'select' && {
-          'aria-autocomplete': 'none'
-        }),
-        ...(role === 'combobox' && {
-          'aria-autocomplete': 'list'
-        })
-      },
-      floating: {
-        ...floatingProps,
-        ...(ariaRole === 'menu' && {
-          'aria-labelledby': referenceId
-        })
-      },
-      item(_ref) {
-        let {
-          active,
-          selected
-        } = _ref;
-        const commonProps = {
-          role: 'option',
-          ...(active && {
-            id: floatingId + "-option"
-          })
+      ...floatingProps,
+      ...(ariaRole === 'menu' && {
+        'aria-labelledby': referenceId
+      })
+    };
+  }, [ariaRole, floatingId, referenceId, role]);
+  const item = React__namespace.useCallback(_ref => {
+    let {
+      active,
+      selected
+    } = _ref;
+    const commonProps = {
+      role: 'option',
+      ...(active && {
+        id: floatingId + "-option"
+      })
+    };
+    switch (role) {
+      case 'select':
+        return {
+          ...commonProps,
+          'aria-selected': active && selected
         };
-        switch (role) {
-          case 'select':
-            return {
-              ...commonProps,
-              'aria-selected': active && selected
-            };
-          case 'combobox':
-            {
-              return {
-                ...commonProps,
-                ...(active && {
-                  'aria-selected': true
-                })
-              };
-            }
+      case 'combobox':
+        {
+          return {
+            ...commonProps,
+            ...(active && {
+              'aria-selected': true
+            })
+          };
         }
-        return {};
-      }
-    };
-  }, [enabled, role, ariaRole, open, floatingId, referenceId, isNested]);
+    }
+    return {};
+  }, [floatingId, role]);
+  return React__namespace.useMemo(() => enabled ? {
+    reference,
+    floating,
+    item
+  } : {}, [enabled, reference, floating, item]);
 }
 
 var TooltipElement = function (props) {
@@ -8728,23 +8732,25 @@ var moment$1 = {exports: {}};
 	        };
 	    }
 	    function isValid(m) {
-	        if (m._isValid == null) {
-	            var flags = getParsingFlags(m),
-	                parsedParts = some.call(flags.parsedDateParts, function (i) {
-	                    return i != null;
-	                }),
-	                isNowValid =
-	                    !isNaN(m._d.getTime()) &&
-	                    flags.overflow < 0 &&
-	                    !flags.empty &&
-	                    !flags.invalidEra &&
-	                    !flags.invalidMonth &&
-	                    !flags.invalidWeekday &&
-	                    !flags.weekdayMismatch &&
-	                    !flags.nullInput &&
-	                    !flags.invalidFormat &&
-	                    !flags.userInvalidated &&
-	                    (!flags.meridiem || (flags.meridiem && parsedParts));
+	        var flags = null,
+	            parsedParts = false,
+	            isNowValid = m._d && !isNaN(m._d.getTime());
+	        if (isNowValid) {
+	            flags = getParsingFlags(m);
+	            parsedParts = some.call(flags.parsedDateParts, function (i) {
+	                return i != null;
+	            });
+	            isNowValid =
+	                flags.overflow < 0 &&
+	                !flags.empty &&
+	                !flags.invalidEra &&
+	                !flags.invalidMonth &&
+	                !flags.invalidWeekday &&
+	                !flags.weekdayMismatch &&
+	                !flags.nullInput &&
+	                !flags.invalidFormat &&
+	                !flags.userInvalidated &&
+	                (!flags.meridiem || (flags.meridiem && parsedParts));
 	            if (m._strict) {
 	                isNowValid =
 	                    isNowValid &&
@@ -8752,11 +8758,11 @@ var moment$1 = {exports: {}};
 	                    flags.unusedTokens.length === 0 &&
 	                    flags.bigHour === undefined;
 	            }
-	            if (Object.isFrozen == null || !Object.isFrozen(m)) {
-	                m._isValid = isNowValid;
-	            } else {
-	                return isNowValid;
-	            }
+	        }
+	        if (Object.isFrozen == null || !Object.isFrozen(m)) {
+	            m._isValid = isNowValid;
+	        } else {
+	            return isNowValid;
 	        }
 	        return m._isValid;
 	    }
@@ -9137,11 +9143,56 @@ var moment$1 = {exports: {}};
 	        var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
 	        return isFunction(format) ? format(output) : format.replace(/%s/i, output);
 	    }
-	    var aliases = {};
-	    function addUnitAlias(unit, shorthand) {
-	        var lowerCase = unit.toLowerCase();
-	        aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
-	    }
+	    var aliases = {
+	        D: 'date',
+	        dates: 'date',
+	        date: 'date',
+	        d: 'day',
+	        days: 'day',
+	        day: 'day',
+	        e: 'weekday',
+	        weekdays: 'weekday',
+	        weekday: 'weekday',
+	        E: 'isoWeekday',
+	        isoweekdays: 'isoWeekday',
+	        isoweekday: 'isoWeekday',
+	        DDD: 'dayOfYear',
+	        dayofyears: 'dayOfYear',
+	        dayofyear: 'dayOfYear',
+	        h: 'hour',
+	        hours: 'hour',
+	        hour: 'hour',
+	        ms: 'millisecond',
+	        milliseconds: 'millisecond',
+	        millisecond: 'millisecond',
+	        m: 'minute',
+	        minutes: 'minute',
+	        minute: 'minute',
+	        M: 'month',
+	        months: 'month',
+	        month: 'month',
+	        Q: 'quarter',
+	        quarters: 'quarter',
+	        quarter: 'quarter',
+	        s: 'second',
+	        seconds: 'second',
+	        second: 'second',
+	        gg: 'weekYear',
+	        weekyears: 'weekYear',
+	        weekyear: 'weekYear',
+	        GG: 'isoWeekYear',
+	        isoweekyears: 'isoWeekYear',
+	        isoweekyear: 'isoWeekYear',
+	        w: 'week',
+	        weeks: 'week',
+	        week: 'week',
+	        W: 'isoWeek',
+	        isoweeks: 'isoWeek',
+	        isoweek: 'isoWeek',
+	        y: 'year',
+	        years: 'year',
+	        year: 'year',
+	    };
 	    function normalizeUnits(units) {
 	        return typeof units === 'string'
 	            ? aliases[units] || aliases[units.toLowerCase()]
@@ -9161,10 +9212,24 @@ var moment$1 = {exports: {}};
 	        }
 	        return normalizedInput;
 	    }
-	    var priorities = {};
-	    function addUnitPriority(unit, priority) {
-	        priorities[unit] = priority;
-	    }
+	    var priorities = {
+	        date: 9,
+	        day: 11,
+	        weekday: 11,
+	        isoWeekday: 11,
+	        dayOfYear: 4,
+	        hour: 13,
+	        millisecond: 16,
+	        minute: 14,
+	        month: 8,
+	        quarter: 7,
+	        second: 15,
+	        weekYear: 1,
+	        isoWeekYear: 1,
+	        week: 5,
+	        isoWeek: 5,
+	        year: 1,
+	    };
 	    function getPrioritizedUnits(unitsObj) {
 	        var units = [],
 	            u;
@@ -9178,83 +9243,6 @@ var moment$1 = {exports: {}};
 	        });
 	        return units;
 	    }
-	    function isLeapYear(year) {
-	        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
-	    }
-	    function absFloor(number) {
-	        if (number < 0) {
-	            return Math.ceil(number) || 0;
-	        } else {
-	            return Math.floor(number);
-	        }
-	    }
-	    function toInt(argumentForCoercion) {
-	        var coercedNumber = +argumentForCoercion,
-	            value = 0;
-	        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
-	            value = absFloor(coercedNumber);
-	        }
-	        return value;
-	    }
-	    function makeGetSet(unit, keepTime) {
-	        return function (value) {
-	            if (value != null) {
-	                set$1(this, unit, value);
-	                hooks.updateOffset(this, keepTime);
-	                return this;
-	            } else {
-	                return get(this, unit);
-	            }
-	        };
-	    }
-	    function get(mom, unit) {
-	        return mom.isValid()
-	            ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]()
-	            : NaN;
-	    }
-	    function set$1(mom, unit, value) {
-	        if (mom.isValid() && !isNaN(value)) {
-	            if (
-	                unit === 'FullYear' &&
-	                isLeapYear(mom.year()) &&
-	                mom.month() === 1 &&
-	                mom.date() === 29
-	            ) {
-	                value = toInt(value);
-	                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](
-	                    value,
-	                    mom.month(),
-	                    daysInMonth(value, mom.month())
-	                );
-	            } else {
-	                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
-	            }
-	        }
-	    }
-	    function stringGet(units) {
-	        units = normalizeUnits(units);
-	        if (isFunction(this[units])) {
-	            return this[units]();
-	        }
-	        return this;
-	    }
-	    function stringSet(units, value) {
-	        if (typeof units === 'object') {
-	            units = normalizeObjectUnits(units);
-	            var prioritized = getPrioritizedUnits(units),
-	                i,
-	                prioritizedLen = prioritized.length;
-	            for (i = 0; i < prioritizedLen; i++) {
-	                this[prioritized[i].unit](units[prioritized[i].unit]);
-	            }
-	        } else {
-	            units = normalizeUnits(units);
-	            if (isFunction(this[units])) {
-	                return this[units](value);
-	            }
-	        }
-	        return this;
-	    }
 	    var match1 = /\d/,
 	        match2 = /\d\d/,
 	        match3 = /\d{3}/,
@@ -9273,6 +9261,8 @@ var moment$1 = {exports: {}};
 	        matchTimestamp = /[+-]?\d+(\.\d{1,3})?/,
 	        matchWord =
 	            /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i,
+	        match1to2NoLeadingZero = /^[1-9]\d?/,
+	        match1to2HasZero = /^([1-9]\d|\d)/,
 	        regexes;
 	    regexes = {};
 	    function addRegexToken(token, regex, strictRegex) {
@@ -9303,6 +9293,21 @@ var moment$1 = {exports: {}};
 	    function regexEscape(s) {
 	        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
 	    }
+	    function absFloor(number) {
+	        if (number < 0) {
+	            return Math.ceil(number) || 0;
+	        } else {
+	            return Math.floor(number);
+	        }
+	    }
+	    function toInt(argumentForCoercion) {
+	        var coercedNumber = +argumentForCoercion,
+	            value = 0;
+	        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+	            value = absFloor(coercedNumber);
+	        }
+	        return value;
+	    }
 	    var tokens = {};
 	    function addParseToken(token, callback) {
 	        var i,
@@ -9332,6 +9337,9 @@ var moment$1 = {exports: {}};
 	            tokens[token](input, config._a, config, token);
 	        }
 	    }
+	    function isLeapYear(year) {
+	        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+	    }
 	    var YEAR = 0,
 	        MONTH = 1,
 	        DATE = 2,
@@ -9341,6 +9349,137 @@ var moment$1 = {exports: {}};
 	        MILLISECOND = 6,
 	        WEEK = 7,
 	        WEEKDAY = 8;
+	    addFormatToken('Y', 0, 0, function () {
+	        var y = this.year();
+	        return y <= 9999 ? zeroFill(y, 4) : '+' + y;
+	    });
+	    addFormatToken(0, ['YY', 2], 0, function () {
+	        return this.year() % 100;
+	    });
+	    addFormatToken(0, ['YYYY', 4], 0, 'year');
+	    addFormatToken(0, ['YYYYY', 5], 0, 'year');
+	    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
+	    addRegexToken('Y', matchSigned);
+	    addRegexToken('YY', match1to2, match2);
+	    addRegexToken('YYYY', match1to4, match4);
+	    addRegexToken('YYYYY', match1to6, match6);
+	    addRegexToken('YYYYYY', match1to6, match6);
+	    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+	    addParseToken('YYYY', function (input, array) {
+	        array[YEAR] =
+	            input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+	    });
+	    addParseToken('YY', function (input, array) {
+	        array[YEAR] = hooks.parseTwoDigitYear(input);
+	    });
+	    addParseToken('Y', function (input, array) {
+	        array[YEAR] = parseInt(input, 10);
+	    });
+	    function daysInYear(year) {
+	        return isLeapYear(year) ? 366 : 365;
+	    }
+	    hooks.parseTwoDigitYear = function (input) {
+	        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+	    };
+	    var getSetYear = makeGetSet('FullYear', true);
+	    function getIsLeapYear() {
+	        return isLeapYear(this.year());
+	    }
+	    function makeGetSet(unit, keepTime) {
+	        return function (value) {
+	            if (value != null) {
+	                set$1(this, unit, value);
+	                hooks.updateOffset(this, keepTime);
+	                return this;
+	            } else {
+	                return get(this, unit);
+	            }
+	        };
+	    }
+	    function get(mom, unit) {
+	        if (!mom.isValid()) {
+	            return NaN;
+	        }
+	        var d = mom._d,
+	            isUTC = mom._isUTC;
+	        switch (unit) {
+	            case 'Milliseconds':
+	                return isUTC ? d.getUTCMilliseconds() : d.getMilliseconds();
+	            case 'Seconds':
+	                return isUTC ? d.getUTCSeconds() : d.getSeconds();
+	            case 'Minutes':
+	                return isUTC ? d.getUTCMinutes() : d.getMinutes();
+	            case 'Hours':
+	                return isUTC ? d.getUTCHours() : d.getHours();
+	            case 'Date':
+	                return isUTC ? d.getUTCDate() : d.getDate();
+	            case 'Day':
+	                return isUTC ? d.getUTCDay() : d.getDay();
+	            case 'Month':
+	                return isUTC ? d.getUTCMonth() : d.getMonth();
+	            case 'FullYear':
+	                return isUTC ? d.getUTCFullYear() : d.getFullYear();
+	            default:
+	                return NaN;
+	        }
+	    }
+	    function set$1(mom, unit, value) {
+	        var d, isUTC, year, month, date;
+	        if (!mom.isValid() || isNaN(value)) {
+	            return;
+	        }
+	        d = mom._d;
+	        isUTC = mom._isUTC;
+	        switch (unit) {
+	            case 'Milliseconds':
+	                return void (isUTC
+	                    ? d.setUTCMilliseconds(value)
+	                    : d.setMilliseconds(value));
+	            case 'Seconds':
+	                return void (isUTC ? d.setUTCSeconds(value) : d.setSeconds(value));
+	            case 'Minutes':
+	                return void (isUTC ? d.setUTCMinutes(value) : d.setMinutes(value));
+	            case 'Hours':
+	                return void (isUTC ? d.setUTCHours(value) : d.setHours(value));
+	            case 'Date':
+	                return void (isUTC ? d.setUTCDate(value) : d.setDate(value));
+	            case 'FullYear':
+	                break;
+	            default:
+	                return;
+	        }
+	        year = value;
+	        month = mom.month();
+	        date = mom.date();
+	        date = date === 29 && month === 1 && !isLeapYear(year) ? 28 : date;
+	        void (isUTC
+	            ? d.setUTCFullYear(year, month, date)
+	            : d.setFullYear(year, month, date));
+	    }
+	    function stringGet(units) {
+	        units = normalizeUnits(units);
+	        if (isFunction(this[units])) {
+	            return this[units]();
+	        }
+	        return this;
+	    }
+	    function stringSet(units, value) {
+	        if (typeof units === 'object') {
+	            units = normalizeObjectUnits(units);
+	            var prioritized = getPrioritizedUnits(units),
+	                i,
+	                prioritizedLen = prioritized.length;
+	            for (i = 0; i < prioritizedLen; i++) {
+	                this[prioritized[i].unit](units[prioritized[i].unit]);
+	            }
+	        } else {
+	            units = normalizeUnits(units);
+	            if (isFunction(this[units])) {
+	                return this[units](value);
+	            }
+	        }
+	        return this;
+	    }
 	    function mod(n, x) {
 	        return ((n % x) + x) % x;
 	    }
@@ -9379,9 +9518,7 @@ var moment$1 = {exports: {}};
 	    addFormatToken('MMMM', 0, 0, function (format) {
 	        return this.localeData().months(this, format);
 	    });
-	    addUnitAlias('month', 'M');
-	    addUnitPriority('month', 8);
-	    addRegexToken('M', match1to2);
+	    addRegexToken('M', match1to2, match1to2NoLeadingZero);
 	    addRegexToken('MM', match1to2, match2);
 	    addRegexToken('MMM', function (isStrict, locale) {
 	        return locale.monthsShortRegex(isStrict);
@@ -9524,7 +9661,6 @@ var moment$1 = {exports: {}};
 	        }
 	    }
 	    function setMonth(mom, value) {
-	        var dayOfMonth;
 	        if (!mom.isValid()) {
 	            return mom;
 	        }
@@ -9538,8 +9674,12 @@ var moment$1 = {exports: {}};
 	                }
 	            }
 	        }
-	        dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
-	        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+	        var month = value,
+	            date = mom.date();
+	        date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month));
+	        void (mom._isUTC
+	            ? mom._d.setUTCMonth(month, date)
+	            : mom._d.setMonth(month, date));
 	        return mom;
 	    }
 	    function getSetMonth(value) {
@@ -9600,24 +9740,21 @@ var moment$1 = {exports: {}};
 	            longPieces = [],
 	            mixedPieces = [],
 	            i,
-	            mom;
+	            mom,
+	            shortP,
+	            longP;
 	        for (i = 0; i < 12; i++) {
 	            mom = createUTC([2000, i]);
-	            shortPieces.push(this.monthsShort(mom, ''));
-	            longPieces.push(this.months(mom, ''));
-	            mixedPieces.push(this.months(mom, ''));
-	            mixedPieces.push(this.monthsShort(mom, ''));
+	            shortP = regexEscape(this.monthsShort(mom, ''));
+	            longP = regexEscape(this.months(mom, ''));
+	            shortPieces.push(shortP);
+	            longPieces.push(longP);
+	            mixedPieces.push(longP);
+	            mixedPieces.push(shortP);
 	        }
 	        shortPieces.sort(cmpLenRev);
 	        longPieces.sort(cmpLenRev);
 	        mixedPieces.sort(cmpLenRev);
-	        for (i = 0; i < 12; i++) {
-	            shortPieces[i] = regexEscape(shortPieces[i]);
-	            longPieces[i] = regexEscape(longPieces[i]);
-	        }
-	        for (i = 0; i < 24; i++) {
-	            mixedPieces[i] = regexEscape(mixedPieces[i]);
-	        }
 	        this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
 	        this._monthsShortRegex = this._monthsRegex;
 	        this._monthsStrictRegex = new RegExp(
@@ -9629,44 +9766,6 @@ var moment$1 = {exports: {}};
 	            'i'
 	        );
 	    }
-	    addFormatToken('Y', 0, 0, function () {
-	        var y = this.year();
-	        return y <= 9999 ? zeroFill(y, 4) : '+' + y;
-	    });
-	    addFormatToken(0, ['YY', 2], 0, function () {
-	        return this.year() % 100;
-	    });
-	    addFormatToken(0, ['YYYY', 4], 0, 'year');
-	    addFormatToken(0, ['YYYYY', 5], 0, 'year');
-	    addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
-	    addUnitAlias('year', 'y');
-	    addUnitPriority('year', 1);
-	    addRegexToken('Y', matchSigned);
-	    addRegexToken('YY', match1to2, match2);
-	    addRegexToken('YYYY', match1to4, match4);
-	    addRegexToken('YYYYY', match1to6, match6);
-	    addRegexToken('YYYYYY', match1to6, match6);
-	    addParseToken(['YYYYY', 'YYYYYY'], YEAR);
-	    addParseToken('YYYY', function (input, array) {
-	        array[YEAR] =
-	            input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
-	    });
-	    addParseToken('YY', function (input, array) {
-	        array[YEAR] = hooks.parseTwoDigitYear(input);
-	    });
-	    addParseToken('Y', function (input, array) {
-	        array[YEAR] = parseInt(input, 10);
-	    });
-	    function daysInYear(year) {
-	        return isLeapYear(year) ? 366 : 365;
-	    }
-	    hooks.parseTwoDigitYear = function (input) {
-	        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
-	    };
-	    var getSetYear = makeGetSet('FullYear', true);
-	    function getIsLeapYear() {
-	        return isLeapYear(this.year());
-	    }
 	    function createDate(y, m, d, h, M, s, ms) {
 	        var date;
 	        if (y < 100 && y >= 0) {
@@ -9747,13 +9846,9 @@ var moment$1 = {exports: {}};
 	    }
 	    addFormatToken('w', ['ww', 2], 'wo', 'week');
 	    addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
-	    addUnitAlias('week', 'w');
-	    addUnitAlias('isoWeek', 'W');
-	    addUnitPriority('week', 5);
-	    addUnitPriority('isoWeek', 5);
-	    addRegexToken('w', match1to2);
+	    addRegexToken('w', match1to2, match1to2NoLeadingZero);
 	    addRegexToken('ww', match1to2, match2);
-	    addRegexToken('W', match1to2);
+	    addRegexToken('W', match1to2, match1to2NoLeadingZero);
 	    addRegexToken('WW', match1to2, match2);
 	    addWeekParseToken(
 	        ['w', 'ww', 'W', 'WW'],
@@ -9794,12 +9889,6 @@ var moment$1 = {exports: {}};
 	    });
 	    addFormatToken('e', 0, 0, 'weekday');
 	    addFormatToken('E', 0, 0, 'isoWeekday');
-	    addUnitAlias('day', 'd');
-	    addUnitAlias('weekday', 'e');
-	    addUnitAlias('isoWeekday', 'E');
-	    addUnitPriority('day', 11);
-	    addUnitPriority('weekday', 11);
-	    addUnitPriority('isoWeekday', 11);
 	    addRegexToken('d', match1to2);
 	    addRegexToken('e', match1to2);
 	    addRegexToken('E', match1to2);
@@ -9863,22 +9952,22 @@ var moment$1 = {exports: {}};
 	        return m === true
 	            ? shiftWeekdays(weekdays, this._week.dow)
 	            : m
-	            ? weekdays[m.day()]
-	            : weekdays;
+	              ? weekdays[m.day()]
+	              : weekdays;
 	    }
 	    function localeWeekdaysShort(m) {
 	        return m === true
 	            ? shiftWeekdays(this._weekdaysShort, this._week.dow)
 	            : m
-	            ? this._weekdaysShort[m.day()]
-	            : this._weekdaysShort;
+	              ? this._weekdaysShort[m.day()]
+	              : this._weekdaysShort;
 	    }
 	    function localeWeekdaysMin(m) {
 	        return m === true
 	            ? shiftWeekdays(this._weekdaysMin, this._week.dow)
 	            : m
-	            ? this._weekdaysMin[m.day()]
-	            : this._weekdaysMin;
+	              ? this._weekdaysMin[m.day()]
+	              : this._weekdaysMin;
 	    }
 	    function handleStrictParse$1(weekdayName, format, strict) {
 	        var i,
@@ -10014,7 +10103,7 @@ var moment$1 = {exports: {}};
 	        if (!this.isValid()) {
 	            return input != null ? this : NaN;
 	        }
-	        var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+	        var day = get(this, 'Day');
 	        if (input != null) {
 	            input = parseWeekday(input, this.localeData());
 	            return this.add(input - day, 'd');
@@ -10184,16 +10273,14 @@ var moment$1 = {exports: {}};
 	    }
 	    meridiem('a', true);
 	    meridiem('A', false);
-	    addUnitAlias('hour', 'h');
-	    addUnitPriority('hour', 13);
 	    function matchMeridiem(isStrict, locale) {
 	        return locale._meridiemParse;
 	    }
 	    addRegexToken('a', matchMeridiem);
 	    addRegexToken('A', matchMeridiem);
-	    addRegexToken('H', match1to2);
-	    addRegexToken('h', match1to2);
-	    addRegexToken('k', match1to2);
+	    addRegexToken('H', match1to2, match1to2HasZero);
+	    addRegexToken('h', match1to2, match1to2NoLeadingZero);
+	    addRegexToken('k', match1to2, match1to2NoLeadingZero);
 	    addRegexToken('HH', match1to2, match2);
 	    addRegexToken('hh', match1to2, match2);
 	    addRegexToken('kk', match1to2, match2);
@@ -10313,7 +10400,7 @@ var moment$1 = {exports: {}};
 	        return globalLocale;
 	    }
 	    function isLocaleNameSane(name) {
-	        return name.match('^[^/\\\\]*$') != null;
+	        return !!(name && name.match('^[^/\\\\]*$'));
 	    }
 	    function loadLocale(name) {
 	        var oldLocale = null,
@@ -10465,21 +10552,21 @@ var moment$1 = {exports: {}};
 	                a[MONTH] < 0 || a[MONTH] > 11
 	                    ? MONTH
 	                    : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH])
-	                    ? DATE
-	                    : a[HOUR] < 0 ||
-	                      a[HOUR] > 24 ||
-	                      (a[HOUR] === 24 &&
-	                          (a[MINUTE] !== 0 ||
-	                              a[SECOND] !== 0 ||
-	                              a[MILLISECOND] !== 0))
-	                    ? HOUR
-	                    : a[MINUTE] < 0 || a[MINUTE] > 59
-	                    ? MINUTE
-	                    : a[SECOND] < 0 || a[SECOND] > 59
-	                    ? SECOND
-	                    : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
-	                    ? MILLISECOND
-	                    : -1;
+	                      ? DATE
+	                      : a[HOUR] < 0 ||
+	                          a[HOUR] > 24 ||
+	                          (a[HOUR] === 24 &&
+	                              (a[MINUTE] !== 0 ||
+	                                  a[SECOND] !== 0 ||
+	                                  a[MILLISECOND] !== 0))
+	                        ? HOUR
+	                        : a[MINUTE] < 0 || a[MINUTE] > 59
+	                          ? MINUTE
+	                          : a[SECOND] < 0 || a[SECOND] > 59
+	                            ? SECOND
+	                            : a[MILLISECOND] < 0 || a[MILLISECOND] > 999
+	                              ? MILLISECOND
+	                              : -1;
 	            if (
 	                getParsingFlags(m)._overflowDayOfYear &&
 	                (overflow < YEAR || overflow > DATE)
@@ -11222,8 +11309,7 @@ var moment$1 = {exports: {}};
 	            i;
 	        for (i = 0; i < len; i++) {
 	            if (
-	                (dontConvert && array1[i] !== array2[i]) ||
-	                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))
+	                (toInt(array1[i]) !== toInt(array2[i]))
 	            ) {
 	                diffs++;
 	            }
@@ -11635,16 +11721,16 @@ var moment$1 = {exports: {}};
 	        return diff < -6
 	            ? 'sameElse'
 	            : diff < -1
-	            ? 'lastWeek'
-	            : diff < 0
-	            ? 'lastDay'
-	            : diff < 1
-	            ? 'sameDay'
-	            : diff < 2
-	            ? 'nextDay'
-	            : diff < 7
-	            ? 'nextWeek'
-	            : 'sameElse';
+	              ? 'lastWeek'
+	              : diff < 0
+	                ? 'lastDay'
+	                : diff < 1
+	                  ? 'sameDay'
+	                  : diff < 2
+	                    ? 'nextDay'
+	                    : diff < 7
+	                      ? 'nextWeek'
+	                      : 'sameElse';
 	    }
 	    function calendar$1(time, formats) {
 	        if (arguments.length === 1) {
@@ -12328,14 +12414,20 @@ var moment$1 = {exports: {}};
 	            mixedPieces = [],
 	            i,
 	            l,
+	            erasName,
+	            erasAbbr,
+	            erasNarrow,
 	            eras = this.eras();
 	        for (i = 0, l = eras.length; i < l; ++i) {
-	            namePieces.push(regexEscape(eras[i].name));
-	            abbrPieces.push(regexEscape(eras[i].abbr));
-	            narrowPieces.push(regexEscape(eras[i].narrow));
-	            mixedPieces.push(regexEscape(eras[i].name));
-	            mixedPieces.push(regexEscape(eras[i].abbr));
-	            mixedPieces.push(regexEscape(eras[i].narrow));
+	            erasName = regexEscape(eras[i].name);
+	            erasAbbr = regexEscape(eras[i].abbr);
+	            erasNarrow = regexEscape(eras[i].narrow);
+	            namePieces.push(erasName);
+	            abbrPieces.push(erasAbbr);
+	            narrowPieces.push(erasNarrow);
+	            mixedPieces.push(erasName);
+	            mixedPieces.push(erasAbbr);
+	            mixedPieces.push(erasNarrow);
 	        }
 	        this._erasRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
 	        this._erasNameRegex = new RegExp('^(' + namePieces.join('|') + ')', 'i');
@@ -12358,10 +12450,6 @@ var moment$1 = {exports: {}};
 	    addWeekYearFormatToken('ggggg', 'weekYear');
 	    addWeekYearFormatToken('GGGG', 'isoWeekYear');
 	    addWeekYearFormatToken('GGGGG', 'isoWeekYear');
-	    addUnitAlias('weekYear', 'gg');
-	    addUnitAlias('isoWeekYear', 'GG');
-	    addUnitPriority('weekYear', 1);
-	    addUnitPriority('isoWeekYear', 1);
 	    addRegexToken('G', matchSigned);
 	    addRegexToken('g', matchSigned);
 	    addRegexToken('GG', match1to2, match2);
@@ -12384,7 +12472,7 @@ var moment$1 = {exports: {}};
 	            this,
 	            input,
 	            this.week(),
-	            this.weekday(),
+	            this.weekday() + this.localeData()._week.dow,
 	            this.localeData()._week.dow,
 	            this.localeData()._week.doy
 	        );
@@ -12434,8 +12522,6 @@ var moment$1 = {exports: {}};
 	        return this;
 	    }
 	    addFormatToken('Q', 0, 'Qo', 'quarter');
-	    addUnitAlias('quarter', 'Q');
-	    addUnitPriority('quarter', 7);
 	    addRegexToken('Q', match1);
 	    addParseToken('Q', function (input, array) {
 	        array[MONTH] = (toInt(input) - 1) * 3;
@@ -12446,9 +12532,7 @@ var moment$1 = {exports: {}};
 	            : this.month((input - 1) * 3 + (this.month() % 3));
 	    }
 	    addFormatToken('D', ['DD', 2], 'Do', 'date');
-	    addUnitAlias('date', 'D');
-	    addUnitPriority('date', 9);
-	    addRegexToken('D', match1to2);
+	    addRegexToken('D', match1to2, match1to2NoLeadingZero);
 	    addRegexToken('DD', match1to2, match2);
 	    addRegexToken('Do', function (isStrict, locale) {
 	        return isStrict
@@ -12461,8 +12545,6 @@ var moment$1 = {exports: {}};
 	    });
 	    var getSetDayOfMonth = makeGetSet('Date', true);
 	    addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
-	    addUnitAlias('dayOfYear', 'DDD');
-	    addUnitPriority('dayOfYear', 4);
 	    addRegexToken('DDD', match1to3);
 	    addRegexToken('DDDD', match3);
 	    addParseToken(['DDD', 'DDDD'], function (input, array, config) {
@@ -12476,16 +12558,12 @@ var moment$1 = {exports: {}};
 	        return input == null ? dayOfYear : this.add(input - dayOfYear, 'd');
 	    }
 	    addFormatToken('m', ['mm', 2], 0, 'minute');
-	    addUnitAlias('minute', 'm');
-	    addUnitPriority('minute', 14);
-	    addRegexToken('m', match1to2);
+	    addRegexToken('m', match1to2, match1to2HasZero);
 	    addRegexToken('mm', match1to2, match2);
 	    addParseToken(['m', 'mm'], MINUTE);
 	    var getSetMinute = makeGetSet('Minutes', false);
 	    addFormatToken('s', ['ss', 2], 0, 'second');
-	    addUnitAlias('second', 's');
-	    addUnitPriority('second', 15);
-	    addRegexToken('s', match1to2);
+	    addRegexToken('s', match1to2, match1to2HasZero);
 	    addRegexToken('ss', match1to2, match2);
 	    addParseToken(['s', 'ss'], SECOND);
 	    var getSetSecond = makeGetSet('Seconds', false);
@@ -12514,8 +12592,6 @@ var moment$1 = {exports: {}};
 	    addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
 	        return this.millisecond() * 1000000;
 	    });
-	    addUnitAlias('millisecond', 'ms');
-	    addUnitPriority('millisecond', 16);
 	    addRegexToken('S', match1to3, match1);
 	    addRegexToken('SS', match1to3, match2);
 	    addRegexToken('SSS', match1to3, match3);
@@ -12773,12 +12849,12 @@ var moment$1 = {exports: {}};
 	                    toInt((number % 100) / 10) === 1
 	                        ? 'th'
 	                        : b === 1
-	                        ? 'st'
-	                        : b === 2
-	                        ? 'nd'
-	                        : b === 3
-	                        ? 'rd'
-	                        : 'th';
+	                          ? 'st'
+	                          : b === 2
+	                            ? 'nd'
+	                            : b === 3
+	                              ? 'rd'
+	                              : 'th';
 	            return number + output;
 	        },
 	    });
@@ -12907,17 +12983,6 @@ var moment$1 = {exports: {}};
 	            }
 	        }
 	    }
-	    function valueOf$1() {
-	        if (!this.isValid()) {
-	            return NaN;
-	        }
-	        return (
-	            this._milliseconds +
-	            this._days * 864e5 +
-	            (this._months % 12) * 2592e6 +
-	            toInt(this._months / 12) * 31536e6
-	        );
-	    }
 	    function makeAs(alias) {
 	        return function () {
 	            return this.as(alias);
@@ -12931,7 +12996,8 @@ var moment$1 = {exports: {}};
 	        asWeeks = makeAs('w'),
 	        asMonths = makeAs('M'),
 	        asQuarters = makeAs('Q'),
-	        asYears = makeAs('y');
+	        asYears = makeAs('y'),
+	        valueOf$1 = asMilliseconds;
 	    function clone$1() {
 	        return createDuration(this);
 	    }
@@ -13145,7 +13211,7 @@ var moment$1 = {exports: {}};
 	    addParseToken('x', function (input, array, config) {
 	        config._d = new Date(toInt(input));
 	    });
-	    hooks.version = '2.29.4';
+	    hooks.version = '2.30.1';
 	    setHookCallback(createLocal);
 	    hooks.fn = proto;
 	    hooks.min = min;
@@ -13497,34 +13563,45 @@ var classnames$1 = {exports: {}};
 (function (module) {
 	(function () {
 		var hasOwn = {}.hasOwnProperty;
-		function classNames() {
-			var classes = [];
+		function classNames () {
+			var classes = '';
 			for (var i = 0; i < arguments.length; i++) {
 				var arg = arguments[i];
-				if (!arg) continue;
-				var argType = typeof arg;
-				if (argType === 'string' || argType === 'number') {
-					classes.push(arg);
-				} else if (Array.isArray(arg)) {
-					if (arg.length) {
-						var inner = classNames.apply(null, arg);
-						if (inner) {
-							classes.push(inner);
-						}
-					}
-				} else if (argType === 'object') {
-					if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
-						classes.push(arg.toString());
-						continue;
-					}
-					for (var key in arg) {
-						if (hasOwn.call(arg, key) && arg[key]) {
-							classes.push(key);
-						}
-					}
+				if (arg) {
+					classes = appendClass(classes, parseValue(arg));
 				}
 			}
-			return classes.join(' ');
+			return classes;
+		}
+		function parseValue (arg) {
+			if (typeof arg === 'string' || typeof arg === 'number') {
+				return arg;
+			}
+			if (typeof arg !== 'object') {
+				return '';
+			}
+			if (Array.isArray(arg)) {
+				return classNames.apply(null, arg);
+			}
+			if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {
+				return arg.toString();
+			}
+			var classes = '';
+			for (var key in arg) {
+				if (hasOwn.call(arg, key) && arg[key]) {
+					classes = appendClass(classes, key);
+				}
+			}
+			return classes;
+		}
+		function appendClass (value, newClass) {
+			if (!newClass) {
+				return value;
+			}
+			if (value) {
+				return value + ' ' + newClass;
+			}
+			return value + newClass;
 		}
 		if (module.exports) {
 			classNames.default = classNames;