@dreamcommerce/aurora 3.1.46-1 → 3.1.46-3

package/build/esm/external/@radix-ui/react-menu/dist/index.mjs.js

@@ -0,0 +1,988 @@
+import { forwardRef, useRef, useEffect, useState, useCallback, Fragment } from 'react';
+import { slicedToArray as _slicedToArray, objectWithoutProperties as _objectWithoutProperties, objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../../_virtual/_rollupPluginBabelHelpers.js';
+import { composeEventHandlers } from '../../primitive/dist/index.mjs.js';
+import { jsx } from 'react/jsx-runtime';
+import { createContextScope } from '../../react-context/dist/index.mjs.js';
+import { useCallbackRef } from '../../react-use-callback-ref/dist/index.mjs.js';
+import { Slot } from '../../react-slot/dist/index.mjs.js';
+import { Primitive, dispatchDiscreteCustomEvent } from '../../react-primitive/dist/index.mjs.js';
+import { createCollection } from '../../react-collection/dist/index.mjs.js';
+import { useComposedRefs, composeRefs } from '../external/@radix-ui/react-compose-refs/dist/index.mjs.js';
+import { useDirection } from '../../react-direction/dist/index.mjs.js';
+import { DismissableLayer } from '../../react-dismissable-layer/dist/index.mjs.js';
+import { useFocusGuards } from '../../react-focus-guards/dist/index.mjs.js';
+import { FocusScope } from '../../react-focus-scope/dist/index.mjs.js';
+import { useId } from '../../react-id/dist/index.mjs.js';
+import { createPopperScope, Anchor, Content, Arrow, Root as Root2 } from '../../react-popper/dist/index.mjs.js';
+import { Portal as Portal$1 } from '../../react-portal/dist/index.mjs.js';
+import { Presence } from '../external/@radix-ui/react-presence/dist/index.mjs.js';
+import { createRovingFocusGroupScope, Root, Item } from '../../react-roving-focus/dist/index.mjs.js';
+import { hideOthers } from '../../../aria-hidden/dist/es2015/index.js';
+import ReactRemoveScroll from '../../../react-remove-scroll/dist/es2015/Combination.js';
+
+var _excluded = ["__scopeMenu"],
+  _excluded2 = ["forceMount"],
+  _excluded3 = ["__scopeMenu", "loop", "trapFocus", "onOpenAutoFocus", "onCloseAutoFocus", "disableOutsidePointerEvents", "onEntryFocus", "onEscapeKeyDown", "onPointerDownOutside", "onFocusOutside", "onInteractOutside", "onDismiss", "disableOutsideScroll"],
+  _excluded4 = ["__scopeMenu"],
+  _excluded5 = ["__scopeMenu"],
+  _excluded6 = ["disabled", "onSelect"],
+  _excluded7 = ["__scopeMenu", "disabled", "textValue"],
+  _excluded8 = ["checked", "onCheckedChange"],
+  _excluded9 = ["value", "onValueChange"],
+  _excluded10 = ["value"],
+  _excluded11 = ["__scopeMenu", "forceMount"],
+  _excluded12 = ["__scopeMenu"],
+  _excluded13 = ["__scopeMenu"],
+  _excluded14 = ["forceMount"];
+var SELECTION_KEYS = ["Enter", " "];
+var FIRST_KEYS = ["ArrowDown", "PageUp", "Home"];
+var LAST_KEYS = ["ArrowUp", "PageDown", "End"];
+var FIRST_LAST_KEYS = [].concat(FIRST_KEYS, LAST_KEYS);
+var SUB_OPEN_KEYS = {
+  ltr: [].concat(SELECTION_KEYS, ["ArrowRight"]),
+  rtl: [].concat(SELECTION_KEYS, ["ArrowLeft"])
+};
+var SUB_CLOSE_KEYS = {
+  ltr: ["ArrowLeft"],
+  rtl: ["ArrowRight"]
+};
+var MENU_NAME = "Menu";
+var _createCollection = createCollection(MENU_NAME),
+  _createCollection2 = _slicedToArray(_createCollection, 3),
+  Collection = _createCollection2[0],
+  useCollection = _createCollection2[1],
+  createCollectionScope = _createCollection2[2];
+var _createContextScope = createContextScope(MENU_NAME, [createCollectionScope, createPopperScope, createRovingFocusGroupScope]),
+  _createContextScope2 = _slicedToArray(_createContextScope, 2),
+  createMenuContext = _createContextScope2[0],
+  createMenuScope = _createContextScope2[1];
+var usePopperScope = createPopperScope();
+var useRovingFocusGroupScope = createRovingFocusGroupScope();
+var _createMenuContext = createMenuContext(MENU_NAME),
+  _createMenuContext2 = _slicedToArray(_createMenuContext, 2),
+  MenuProvider = _createMenuContext2[0],
+  useMenuContext = _createMenuContext2[1];
+var _createMenuContext3 = createMenuContext(MENU_NAME),
+  _createMenuContext4 = _slicedToArray(_createMenuContext3, 2),
+  MenuRootProvider = _createMenuContext4[0],
+  useMenuRootContext = _createMenuContext4[1];
+var Menu = function Menu(props) {
+  var __scopeMenu = props.__scopeMenu,
+    _props$open = props.open,
+    open = _props$open === void 0 ? false : _props$open,
+    children = props.children,
+    dir = props.dir,
+    onOpenChange = props.onOpenChange,
+    _props$modal = props.modal,
+    modal = _props$modal === void 0 ? true : _props$modal;
+  var popperScope = usePopperScope(__scopeMenu);
+  var _React$useState = useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    content = _React$useState2[0],
+    setContent = _React$useState2[1];
+  var isUsingKeyboardRef = useRef(false);
+  var handleOpenChange = useCallbackRef(onOpenChange);
+  var direction = useDirection(dir);
+  useEffect(function () {
+    var handleKeyDown = function handleKeyDown() {
+      isUsingKeyboardRef.current = true;
+      document.addEventListener("pointerdown", handlePointer, {
+        capture: true,
+        once: true
+      });
+      document.addEventListener("pointermove", handlePointer, {
+        capture: true,
+        once: true
+      });
+    };
+    var handlePointer = function handlePointer() {
+      return isUsingKeyboardRef.current = false;
+    };
+    document.addEventListener("keydown", handleKeyDown, {
+      capture: true
+    });
+    return function () {
+      document.removeEventListener("keydown", handleKeyDown, {
+        capture: true
+      });
+      document.removeEventListener("pointerdown", handlePointer, {
+        capture: true
+      });
+      document.removeEventListener("pointermove", handlePointer, {
+        capture: true
+      });
+    };
+  }, []);
+  return /* @__PURE__ */jsx(Root2, _objectSpread2(_objectSpread2({}, popperScope), {}, {
+    children: /* @__PURE__ */jsx(MenuProvider, {
+      scope: __scopeMenu,
+      open: open,
+      onOpenChange: handleOpenChange,
+      content: content,
+      onContentChange: setContent,
+      children: /* @__PURE__ */jsx(MenuRootProvider, {
+        scope: __scopeMenu,
+        onClose: useCallback(function () {
+          return handleOpenChange(false);
+        }, [handleOpenChange]),
+        isUsingKeyboardRef: isUsingKeyboardRef,
+        dir: direction,
+        modal: modal,
+        children: children
+      })
+    })
+  }));
+};
+Menu.displayName = MENU_NAME;
+var ANCHOR_NAME = "MenuAnchor";
+var MenuAnchor = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeMenu = props.__scopeMenu,
+    anchorProps = _objectWithoutProperties(props, _excluded);
+  var popperScope = usePopperScope(__scopeMenu);
+  return /* @__PURE__ */jsx(Anchor, _objectSpread2(_objectSpread2(_objectSpread2({}, popperScope), anchorProps), {}, {
+    ref: forwardedRef
+  }));
+});
+MenuAnchor.displayName = ANCHOR_NAME;
+var PORTAL_NAME = "MenuPortal";
+var _createMenuContext5 = createMenuContext(PORTAL_NAME, {
+    forceMount: void 0
+  }),
+  _createMenuContext6 = _slicedToArray(_createMenuContext5, 2),
+  PortalProvider = _createMenuContext6[0],
+  usePortalContext = _createMenuContext6[1];
+var MenuPortal = function MenuPortal(props) {
+  var __scopeMenu = props.__scopeMenu,
+    forceMount = props.forceMount,
+    children = props.children,
+    container = props.container;
+  var context = useMenuContext(PORTAL_NAME, __scopeMenu);
+  return /* @__PURE__ */jsx(PortalProvider, {
+    scope: __scopeMenu,
+    forceMount: forceMount,
+    children: /* @__PURE__ */jsx(Presence, {
+      present: forceMount || context.open,
+      children: /* @__PURE__ */jsx(Portal$1, {
+        asChild: true,
+        container: container,
+        children: children
+      })
+    })
+  });
+};
+MenuPortal.displayName = PORTAL_NAME;
+var CONTENT_NAME = "MenuContent";
+var _createMenuContext7 = createMenuContext(CONTENT_NAME),
+  _createMenuContext8 = _slicedToArray(_createMenuContext7, 2),
+  MenuContentProvider = _createMenuContext8[0],
+  useMenuContentContext = _createMenuContext8[1];
+var MenuContent = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var portalContext = usePortalContext(CONTENT_NAME, props.__scopeMenu);
+  var _props$forceMount = props.forceMount,
+    forceMount = _props$forceMount === void 0 ? portalContext.forceMount : _props$forceMount,
+    contentProps = _objectWithoutProperties(props, _excluded2);
+  var context = useMenuContext(CONTENT_NAME, props.__scopeMenu);
+  var rootContext = useMenuRootContext(CONTENT_NAME, props.__scopeMenu);
+  return /* @__PURE__ */jsx(Collection.Provider, {
+    scope: props.__scopeMenu,
+    children: /* @__PURE__ */jsx(Presence, {
+      present: forceMount || context.open,
+      children: /* @__PURE__ */jsx(Collection.Slot, {
+        scope: props.__scopeMenu,
+        children: rootContext.modal ? /* @__PURE__ */jsx(MenuRootContentModal, _objectSpread2(_objectSpread2({}, contentProps), {}, {
+          ref: forwardedRef
+        })) : /* @__PURE__ */jsx(MenuRootContentNonModal, _objectSpread2(_objectSpread2({}, contentProps), {}, {
+          ref: forwardedRef
+        }))
+      })
+    })
+  });
+});
+var MenuRootContentModal = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var context = useMenuContext(CONTENT_NAME, props.__scopeMenu);
+  var ref = useRef(null);
+  var composedRefs = useComposedRefs(forwardedRef, ref);
+  useEffect(function () {
+    var content = ref.current;
+    if (content) return hideOthers(content);
+  }, []);
+  return /* @__PURE__ */jsx(MenuContentImpl, _objectSpread2(_objectSpread2({}, props), {}, {
+    ref: composedRefs,
+    trapFocus: context.open,
+    disableOutsidePointerEvents: context.open,
+    disableOutsideScroll: true,
+    onFocusOutside: composeEventHandlers(props.onFocusOutside, function (event) {
+      return event.preventDefault();
+    }, {
+      checkForDefaultPrevented: false
+    }),
+    onDismiss: function onDismiss() {
+      return context.onOpenChange(false);
+    }
+  }));
+});
+var MenuRootContentNonModal = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var context = useMenuContext(CONTENT_NAME, props.__scopeMenu);
+  return /* @__PURE__ */jsx(MenuContentImpl, _objectSpread2(_objectSpread2({}, props), {}, {
+    ref: forwardedRef,
+    trapFocus: false,
+    disableOutsidePointerEvents: false,
+    disableOutsideScroll: false,
+    onDismiss: function onDismiss() {
+      return context.onOpenChange(false);
+    }
+  }));
+});
+var MenuContentImpl = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeMenu = props.__scopeMenu,
+    _props$loop = props.loop,
+    loop = _props$loop === void 0 ? false : _props$loop,
+    trapFocus = props.trapFocus,
+    onOpenAutoFocus = props.onOpenAutoFocus,
+    onCloseAutoFocus = props.onCloseAutoFocus,
+    disableOutsidePointerEvents = props.disableOutsidePointerEvents,
+    onEntryFocus = props.onEntryFocus,
+    onEscapeKeyDown = props.onEscapeKeyDown,
+    onPointerDownOutside = props.onPointerDownOutside,
+    onFocusOutside = props.onFocusOutside,
+    onInteractOutside = props.onInteractOutside,
+    onDismiss = props.onDismiss,
+    disableOutsideScroll = props.disableOutsideScroll,
+    contentProps = _objectWithoutProperties(props, _excluded3);
+  var context = useMenuContext(CONTENT_NAME, __scopeMenu);
+  var rootContext = useMenuRootContext(CONTENT_NAME, __scopeMenu);
+  var popperScope = usePopperScope(__scopeMenu);
+  var rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenu);
+  var getItems = useCollection(__scopeMenu);
+  var _React$useState3 = useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    currentItemId = _React$useState4[0],
+    setCurrentItemId = _React$useState4[1];
+  var contentRef = useRef(null);
+  var composedRefs = useComposedRefs(forwardedRef, contentRef, context.onContentChange);
+  var timerRef = useRef(0);
+  var searchRef = useRef("");
+  var pointerGraceTimerRef = useRef(0);
+  var pointerGraceIntentRef = useRef(null);
+  var pointerDirRef = useRef("right");
+  var lastPointerXRef = useRef(0);
+  var ScrollLockWrapper = disableOutsideScroll ? ReactRemoveScroll : Fragment;
+  var scrollLockWrapperProps = disableOutsideScroll ? {
+    as: Slot,
+    allowPinchZoom: true
+  } : void 0;
+  var handleTypeaheadSearch = function handleTypeaheadSearch(key) {
+    var _items$find, _items$find2;
+    var search = searchRef.current + key;
+    var items = getItems().filter(function (item) {
+      return !item.disabled;
+    });
+    var currentItem = document.activeElement;
+    var currentMatch = (_items$find = items.find(function (item) {
+      return item.ref.current === currentItem;
+    })) === null || _items$find === void 0 ? void 0 : _items$find.textValue;
+    var values = items.map(function (item) {
+      return item.textValue;
+    });
+    var nextMatch = getNextMatch(values, search, currentMatch);
+    var newItem = (_items$find2 = items.find(function (item) {
+      return item.textValue === nextMatch;
+    })) === null || _items$find2 === void 0 ? void 0 : _items$find2.ref.current;
+    (function updateSearch(value) {
+      searchRef.current = value;
+      window.clearTimeout(timerRef.current);
+      if (value !== "") timerRef.current = window.setTimeout(function () {
+        return updateSearch("");
+      }, 1e3);
+    })(search);
+    if (newItem) {
+      setTimeout(function () {
+        return newItem.focus();
+      });
+    }
+  };
+  useEffect(function () {
+    return function () {
+      return window.clearTimeout(timerRef.current);
+    };
+  }, []);
+  useFocusGuards();
+  var isPointerMovingToSubmenu = useCallback(function (event) {
+    var _pointerGraceIntentRe, _pointerGraceIntentRe2;
+    var isMovingTowards = pointerDirRef.current === ((_pointerGraceIntentRe = pointerGraceIntentRef.current) === null || _pointerGraceIntentRe === void 0 ? void 0 : _pointerGraceIntentRe.side);
+    return isMovingTowards && isPointerInGraceArea(event, (_pointerGraceIntentRe2 = pointerGraceIntentRef.current) === null || _pointerGraceIntentRe2 === void 0 ? void 0 : _pointerGraceIntentRe2.area);
+  }, []);
+  return /* @__PURE__ */jsx(MenuContentProvider, {
+    scope: __scopeMenu,
+    searchRef: searchRef,
+    onItemEnter: useCallback(function (event) {
+      if (isPointerMovingToSubmenu(event)) event.preventDefault();
+    }, [isPointerMovingToSubmenu]),
+    onItemLeave: useCallback(function (event) {
+      var _contentRef$current;
+      if (isPointerMovingToSubmenu(event)) return;
+      (_contentRef$current = contentRef.current) === null || _contentRef$current === void 0 ? void 0 : _contentRef$current.focus();
+      setCurrentItemId(null);
+    }, [isPointerMovingToSubmenu]),
+    onTriggerLeave: useCallback(function (event) {
+      if (isPointerMovingToSubmenu(event)) event.preventDefault();
+    }, [isPointerMovingToSubmenu]),
+    pointerGraceTimerRef: pointerGraceTimerRef,
+    onPointerGraceIntentChange: useCallback(function (intent) {
+      pointerGraceIntentRef.current = intent;
+    }, []),
+    children: /* @__PURE__ */jsx(ScrollLockWrapper, _objectSpread2(_objectSpread2({}, scrollLockWrapperProps), {}, {
+      children: /* @__PURE__ */jsx(FocusScope, {
+        asChild: true,
+        trapped: trapFocus,
+        onMountAutoFocus: composeEventHandlers(onOpenAutoFocus, function (event) {
+          var _contentRef$current2;
+          event.preventDefault();
+          (_contentRef$current2 = contentRef.current) === null || _contentRef$current2 === void 0 ? void 0 : _contentRef$current2.focus({
+            preventScroll: true
+          });
+        }),
+        onUnmountAutoFocus: onCloseAutoFocus,
+        children: /* @__PURE__ */jsx(DismissableLayer, {
+          asChild: true,
+          disableOutsidePointerEvents: disableOutsidePointerEvents,
+          onEscapeKeyDown: onEscapeKeyDown,
+          onPointerDownOutside: onPointerDownOutside,
+          onFocusOutside: onFocusOutside,
+          onInteractOutside: onInteractOutside,
+          onDismiss: onDismiss,
+          children: /* @__PURE__ */jsx(Root, _objectSpread2(_objectSpread2({
+            asChild: true
+          }, rovingFocusGroupScope), {}, {
+            dir: rootContext.dir,
+            orientation: "vertical",
+            loop: loop,
+            currentTabStopId: currentItemId,
+            onCurrentTabStopIdChange: setCurrentItemId,
+            onEntryFocus: composeEventHandlers(onEntryFocus, function (event) {
+              if (!rootContext.isUsingKeyboardRef.current) event.preventDefault();
+            }),
+            preventScrollOnEntryFocus: true,
+            children: /* @__PURE__ */jsx(Content, _objectSpread2(_objectSpread2(_objectSpread2({
+              role: "menu",
+              "aria-orientation": "vertical",
+              "data-state": getOpenState(context.open),
+              "data-radix-menu-content": "",
+              dir: rootContext.dir
+            }, popperScope), contentProps), {}, {
+              ref: composedRefs,
+              style: _objectSpread2({
+                outline: "none"
+              }, contentProps.style),
+              onKeyDown: composeEventHandlers(contentProps.onKeyDown, function (event) {
+                var target = event.target;
+                var isKeyDownInside = target.closest("[data-radix-menu-content]") === event.currentTarget;
+                var isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
+                var isCharacterKey = event.key.length === 1;
+                if (isKeyDownInside) {
+                  if (event.key === "Tab") event.preventDefault();
+                  if (!isModifierKey && isCharacterKey) handleTypeaheadSearch(event.key);
+                }
+                var content = contentRef.current;
+                if (event.target !== content) return;
+                if (!FIRST_LAST_KEYS.includes(event.key)) return;
+                event.preventDefault();
+                var items = getItems().filter(function (item) {
+                  return !item.disabled;
+                });
+                var candidateNodes = items.map(function (item) {
+                  return item.ref.current;
+                });
+                if (LAST_KEYS.includes(event.key)) candidateNodes.reverse();
+                focusFirst(candidateNodes);
+              }),
+              onBlur: composeEventHandlers(props.onBlur, function (event) {
+                if (!event.currentTarget.contains(event.target)) {
+                  window.clearTimeout(timerRef.current);
+                  searchRef.current = "";
+                }
+              }),
+              onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse(function (event) {
+                var target = event.target;
+                var pointerXHasChanged = lastPointerXRef.current !== event.clientX;
+                if (event.currentTarget.contains(target) && pointerXHasChanged) {
+                  var newDir = event.clientX > lastPointerXRef.current ? "right" : "left";
+                  pointerDirRef.current = newDir;
+                  lastPointerXRef.current = event.clientX;
+                }
+              }))
+            }))
+          }))
+        })
+      })
+    }))
+  });
+});
+MenuContent.displayName = CONTENT_NAME;
+var GROUP_NAME = "MenuGroup";
+var MenuGroup = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeMenu = props.__scopeMenu,
+    groupProps = _objectWithoutProperties(props, _excluded4);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+    role: "group"
+  }, groupProps), {}, {
+    ref: forwardedRef
+  }));
+});
+MenuGroup.displayName = GROUP_NAME;
+var LABEL_NAME = "MenuLabel";
+var MenuLabel = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeMenu = props.__scopeMenu,
+    labelProps = _objectWithoutProperties(props, _excluded5);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({}, labelProps), {}, {
+    ref: forwardedRef
+  }));
+});
+MenuLabel.displayName = LABEL_NAME;
+var ITEM_NAME = "MenuItem";
+var ITEM_SELECT = "menu.itemSelect";
+var MenuItem = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var _props$disabled = props.disabled,
+    disabled = _props$disabled === void 0 ? false : _props$disabled,
+    onSelect = props.onSelect,
+    itemProps = _objectWithoutProperties(props, _excluded6);
+  var ref = useRef(null);
+  var rootContext = useMenuRootContext(ITEM_NAME, props.__scopeMenu);
+  var contentContext = useMenuContentContext(ITEM_NAME, props.__scopeMenu);
+  var composedRefs = useComposedRefs(forwardedRef, ref);
+  var isPointerDownRef = useRef(false);
+  var handleSelect = function handleSelect() {
+    var menuItem = ref.current;
+    if (!disabled && menuItem) {
+      var itemSelectEvent = new CustomEvent(ITEM_SELECT, {
+        bubbles: true,
+        cancelable: true
+      });
+      menuItem.addEventListener(ITEM_SELECT, function (event) {
+        return onSelect === null || onSelect === void 0 ? void 0 : onSelect(event);
+      }, {
+        once: true
+      });
+      dispatchDiscreteCustomEvent(menuItem, itemSelectEvent);
+      if (itemSelectEvent.defaultPrevented) {
+        isPointerDownRef.current = false;
+      } else {
+        rootContext.onClose();
+      }
+    }
+  };
+  return /* @__PURE__ */jsx(MenuItemImpl, _objectSpread2(_objectSpread2({}, itemProps), {}, {
+    ref: composedRefs,
+    disabled: disabled,
+    onClick: composeEventHandlers(props.onClick, handleSelect),
+    onPointerDown: function onPointerDown(event) {
+      var _props$onPointerDown;
+      (_props$onPointerDown = props.onPointerDown) === null || _props$onPointerDown === void 0 ? void 0 : _props$onPointerDown.call(props, event);
+      isPointerDownRef.current = true;
+    },
+    onPointerUp: composeEventHandlers(props.onPointerUp, function (event) {
+      var _event$currentTarget;
+      if (!isPointerDownRef.current) (_event$currentTarget = event.currentTarget) === null || _event$currentTarget === void 0 ? void 0 : _event$currentTarget.click();
+    }),
+    onKeyDown: composeEventHandlers(props.onKeyDown, function (event) {
+      var isTypingAhead = contentContext.searchRef.current !== "";
+      if (disabled || isTypingAhead && event.key === " ") return;
+      if (SELECTION_KEYS.includes(event.key)) {
+        event.currentTarget.click();
+        event.preventDefault();
+      }
+    })
+  }));
+});
+MenuItem.displayName = ITEM_NAME;
+var MenuItemImpl = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeMenu = props.__scopeMenu,
+    _props$disabled2 = props.disabled,
+    disabled = _props$disabled2 === void 0 ? false : _props$disabled2,
+    textValue = props.textValue,
+    itemProps = _objectWithoutProperties(props, _excluded7);
+  var contentContext = useMenuContentContext(ITEM_NAME, __scopeMenu);
+  var rovingFocusGroupScope = useRovingFocusGroupScope(__scopeMenu);
+  var ref = useRef(null);
+  var composedRefs = useComposedRefs(forwardedRef, ref);
+  var _React$useState5 = useState(false),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    isFocused = _React$useState6[0],
+    setIsFocused = _React$useState6[1];
+  var _React$useState7 = useState(""),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    textContent = _React$useState8[0],
+    setTextContent = _React$useState8[1];
+  useEffect(function () {
+    var menuItem = ref.current;
+    if (menuItem) {
+      var _menuItem$textContent;
+      setTextContent(((_menuItem$textContent = menuItem.textContent) !== null && _menuItem$textContent !== void 0 ? _menuItem$textContent : "").trim());
+    }
+  }, [itemProps.children]);
+  return /* @__PURE__ */jsx(Collection.ItemSlot, {
+    scope: __scopeMenu,
+    disabled: disabled,
+    textValue: textValue !== null && textValue !== void 0 ? textValue : textContent,
+    children: /* @__PURE__ */jsx(Item, _objectSpread2(_objectSpread2({
+      asChild: true
+    }, rovingFocusGroupScope), {}, {
+      focusable: !disabled,
+      children: /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+        role: "menuitem",
+        "data-highlighted": isFocused ? "" : void 0,
+        "aria-disabled": disabled || void 0,
+        "data-disabled": disabled ? "" : void 0
+      }, itemProps), {}, {
+        ref: composedRefs,
+        onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse(function (event) {
+          if (disabled) {
+            contentContext.onItemLeave(event);
+          } else {
+            contentContext.onItemEnter(event);
+            if (!event.defaultPrevented) {
+              var item = event.currentTarget;
+              item.focus({
+                preventScroll: true
+              });
+            }
+          }
+        })),
+        onPointerLeave: composeEventHandlers(props.onPointerLeave, whenMouse(function (event) {
+          return contentContext.onItemLeave(event);
+        })),
+        onFocus: composeEventHandlers(props.onFocus, function () {
+          return setIsFocused(true);
+        }),
+        onBlur: composeEventHandlers(props.onBlur, function () {
+          return setIsFocused(false);
+        })
+      }))
+    }))
+  });
+});
+var CHECKBOX_ITEM_NAME = "MenuCheckboxItem";
+var MenuCheckboxItem = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var _props$checked = props.checked,
+    checked = _props$checked === void 0 ? false : _props$checked,
+    onCheckedChange = props.onCheckedChange,
+    checkboxItemProps = _objectWithoutProperties(props, _excluded8);
+  return /* @__PURE__ */jsx(ItemIndicatorProvider, {
+    scope: props.__scopeMenu,
+    checked: checked,
+    children: /* @__PURE__ */jsx(MenuItem, _objectSpread2(_objectSpread2({
+      role: "menuitemcheckbox",
+      "aria-checked": isIndeterminate(checked) ? "mixed" : checked
+    }, checkboxItemProps), {}, {
+      ref: forwardedRef,
+      "data-state": getCheckedState(checked),
+      onSelect: composeEventHandlers(checkboxItemProps.onSelect, function () {
+        return onCheckedChange === null || onCheckedChange === void 0 ? void 0 : onCheckedChange(isIndeterminate(checked) ? true : !checked);
+      }, {
+        checkForDefaultPrevented: false
+      })
+    }))
+  });
+});
+MenuCheckboxItem.displayName = CHECKBOX_ITEM_NAME;
+var RADIO_GROUP_NAME = "MenuRadioGroup";
+var _createMenuContext9 = createMenuContext(RADIO_GROUP_NAME, {
+    value: void 0,
+    onValueChange: function onValueChange() {}
+  }),
+  _createMenuContext10 = _slicedToArray(_createMenuContext9, 2),
+  RadioGroupProvider = _createMenuContext10[0],
+  useRadioGroupContext = _createMenuContext10[1];
+var MenuRadioGroup = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var value = props.value,
+    onValueChange = props.onValueChange,
+    groupProps = _objectWithoutProperties(props, _excluded9);
+  var handleValueChange = useCallbackRef(onValueChange);
+  return /* @__PURE__ */jsx(RadioGroupProvider, {
+    scope: props.__scopeMenu,
+    value: value,
+    onValueChange: handleValueChange,
+    children: /* @__PURE__ */jsx(MenuGroup, _objectSpread2(_objectSpread2({}, groupProps), {}, {
+      ref: forwardedRef
+    }))
+  });
+});
+MenuRadioGroup.displayName = RADIO_GROUP_NAME;
+var RADIO_ITEM_NAME = "MenuRadioItem";
+var MenuRadioItem = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var value = props.value,
+    radioItemProps = _objectWithoutProperties(props, _excluded10);
+  var context = useRadioGroupContext(RADIO_ITEM_NAME, props.__scopeMenu);
+  var checked = value === context.value;
+  return /* @__PURE__ */jsx(ItemIndicatorProvider, {
+    scope: props.__scopeMenu,
+    checked: checked,
+    children: /* @__PURE__ */jsx(MenuItem, _objectSpread2(_objectSpread2({
+      role: "menuitemradio",
+      "aria-checked": checked
+    }, radioItemProps), {}, {
+      ref: forwardedRef,
+      "data-state": getCheckedState(checked),
+      onSelect: composeEventHandlers(radioItemProps.onSelect, function () {
+        var _context$onValueChang;
+        return (_context$onValueChang = context.onValueChange) === null || _context$onValueChang === void 0 ? void 0 : _context$onValueChang.call(context, value);
+      }, {
+        checkForDefaultPrevented: false
+      })
+    }))
+  });
+});
+MenuRadioItem.displayName = RADIO_ITEM_NAME;
+var ITEM_INDICATOR_NAME = "MenuItemIndicator";
+var _createMenuContext11 = createMenuContext(ITEM_INDICATOR_NAME, {
+    checked: false
+  }),
+  _createMenuContext12 = _slicedToArray(_createMenuContext11, 2),
+  ItemIndicatorProvider = _createMenuContext12[0],
+  useItemIndicatorContext = _createMenuContext12[1];
+var MenuItemIndicator = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeMenu = props.__scopeMenu,
+    forceMount = props.forceMount,
+    itemIndicatorProps = _objectWithoutProperties(props, _excluded11);
+  var indicatorContext = useItemIndicatorContext(ITEM_INDICATOR_NAME, __scopeMenu);
+  return /* @__PURE__ */jsx(Presence, {
+    present: forceMount || isIndeterminate(indicatorContext.checked) || indicatorContext.checked === true,
+    children: /* @__PURE__ */jsx(Primitive.span, _objectSpread2(_objectSpread2({}, itemIndicatorProps), {}, {
+      ref: forwardedRef,
+      "data-state": getCheckedState(indicatorContext.checked)
+    }))
+  });
+});
+MenuItemIndicator.displayName = ITEM_INDICATOR_NAME;
+var SEPARATOR_NAME = "MenuSeparator";
+var MenuSeparator = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeMenu = props.__scopeMenu,
+    separatorProps = _objectWithoutProperties(props, _excluded12);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+    role: "separator",
+    "aria-orientation": "horizontal"
+  }, separatorProps), {}, {
+    ref: forwardedRef
+  }));
+});
+MenuSeparator.displayName = SEPARATOR_NAME;
+var ARROW_NAME = "MenuArrow";
+var MenuArrow = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeMenu = props.__scopeMenu,
+    arrowProps = _objectWithoutProperties(props, _excluded13);
+  var popperScope = usePopperScope(__scopeMenu);
+  return /* @__PURE__ */jsx(Arrow, _objectSpread2(_objectSpread2(_objectSpread2({}, popperScope), arrowProps), {}, {
+    ref: forwardedRef
+  }));
+});
+MenuArrow.displayName = ARROW_NAME;
+var SUB_NAME = "MenuSub";
+var _createMenuContext13 = createMenuContext(SUB_NAME),
+  _createMenuContext14 = _slicedToArray(_createMenuContext13, 2),
+  MenuSubProvider = _createMenuContext14[0],
+  useMenuSubContext = _createMenuContext14[1];
+var MenuSub = function MenuSub(props) {
+  var __scopeMenu = props.__scopeMenu,
+    children = props.children,
+    _props$open2 = props.open,
+    open = _props$open2 === void 0 ? false : _props$open2,
+    onOpenChange = props.onOpenChange;
+  var parentMenuContext = useMenuContext(SUB_NAME, __scopeMenu);
+  var popperScope = usePopperScope(__scopeMenu);
+  var _React$useState9 = useState(null),
+    _React$useState10 = _slicedToArray(_React$useState9, 2),
+    trigger = _React$useState10[0],
+    setTrigger = _React$useState10[1];
+  var _React$useState11 = useState(null),
+    _React$useState12 = _slicedToArray(_React$useState11, 2),
+    content = _React$useState12[0],
+    setContent = _React$useState12[1];
+  var handleOpenChange = useCallbackRef(onOpenChange);
+  useEffect(function () {
+    if (parentMenuContext.open === false) handleOpenChange(false);
+    return function () {
+      return handleOpenChange(false);
+    };
+  }, [parentMenuContext.open, handleOpenChange]);
+  return /* @__PURE__ */jsx(Root2, _objectSpread2(_objectSpread2({}, popperScope), {}, {
+    children: /* @__PURE__ */jsx(MenuProvider, {
+      scope: __scopeMenu,
+      open: open,
+      onOpenChange: handleOpenChange,
+      content: content,
+      onContentChange: setContent,
+      children: /* @__PURE__ */jsx(MenuSubProvider, {
+        scope: __scopeMenu,
+        contentId: useId(),
+        triggerId: useId(),
+        trigger: trigger,
+        onTriggerChange: setTrigger,
+        children: children
+      })
+    })
+  }));
+};
+MenuSub.displayName = SUB_NAME;
+var SUB_TRIGGER_NAME = "MenuSubTrigger";
+var MenuSubTrigger = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var context = useMenuContext(SUB_TRIGGER_NAME, props.__scopeMenu);
+  var rootContext = useMenuRootContext(SUB_TRIGGER_NAME, props.__scopeMenu);
+  var subContext = useMenuSubContext(SUB_TRIGGER_NAME, props.__scopeMenu);
+  var contentContext = useMenuContentContext(SUB_TRIGGER_NAME, props.__scopeMenu);
+  var openTimerRef = useRef(null);
+  var pointerGraceTimerRef = contentContext.pointerGraceTimerRef,
+    onPointerGraceIntentChange = contentContext.onPointerGraceIntentChange;
+  var scope = {
+    __scopeMenu: props.__scopeMenu
+  };
+  var clearOpenTimer = useCallback(function () {
+    if (openTimerRef.current) window.clearTimeout(openTimerRef.current);
+    openTimerRef.current = null;
+  }, []);
+  useEffect(function () {
+    return clearOpenTimer;
+  }, [clearOpenTimer]);
+  useEffect(function () {
+    var pointerGraceTimer = pointerGraceTimerRef.current;
+    return function () {
+      window.clearTimeout(pointerGraceTimer);
+      onPointerGraceIntentChange(null);
+    };
+  }, [pointerGraceTimerRef, onPointerGraceIntentChange]);
+  return /* @__PURE__ */jsx(MenuAnchor, _objectSpread2(_objectSpread2({
+    asChild: true
+  }, scope), {}, {
+    children: /* @__PURE__ */jsx(MenuItemImpl, _objectSpread2(_objectSpread2({
+      id: subContext.triggerId,
+      "aria-haspopup": "menu",
+      "aria-expanded": context.open,
+      "aria-controls": subContext.contentId,
+      "data-state": getOpenState(context.open)
+    }, props), {}, {
+      ref: composeRefs(forwardedRef, subContext.onTriggerChange),
+      onClick: function onClick(event) {
+        var _props$onClick;
+        (_props$onClick = props.onClick) === null || _props$onClick === void 0 ? void 0 : _props$onClick.call(props, event);
+        if (props.disabled || event.defaultPrevented) return;
+        event.currentTarget.focus();
+        if (!context.open) context.onOpenChange(true);
+      },
+      onPointerMove: composeEventHandlers(props.onPointerMove, whenMouse(function (event) {
+        contentContext.onItemEnter(event);
+        if (event.defaultPrevented) return;
+        if (!props.disabled && !context.open && !openTimerRef.current) {
+          contentContext.onPointerGraceIntentChange(null);
+          openTimerRef.current = window.setTimeout(function () {
+            context.onOpenChange(true);
+            clearOpenTimer();
+          }, 100);
+        }
+      })),
+      onPointerLeave: composeEventHandlers(props.onPointerLeave, whenMouse(function (event) {
+        var _context$content;
+        clearOpenTimer();
+        var contentRect = (_context$content = context.content) === null || _context$content === void 0 ? void 0 : _context$content.getBoundingClientRect();
+        if (contentRect) {
+          var _context$content2;
+          var side = (_context$content2 = context.content) === null || _context$content2 === void 0 ? void 0 : _context$content2.dataset.side;
+          var rightSide = side === "right";
+          var bleed = rightSide ? -5 : 5;
+          var contentNearEdge = contentRect[rightSide ? "left" : "right"];
+          var contentFarEdge = contentRect[rightSide ? "right" : "left"];
+          contentContext.onPointerGraceIntentChange({
+            area: [
+            // Apply a bleed on clientX to ensure that our exit point is
+            // consistently within polygon bounds
+            {
+              x: event.clientX + bleed,
+              y: event.clientY
+            }, {
+              x: contentNearEdge,
+              y: contentRect.top
+            }, {
+              x: contentFarEdge,
+              y: contentRect.top
+            }, {
+              x: contentFarEdge,
+              y: contentRect.bottom
+            }, {
+              x: contentNearEdge,
+              y: contentRect.bottom
+            }],
+            side: side
+          });
+          window.clearTimeout(pointerGraceTimerRef.current);
+          pointerGraceTimerRef.current = window.setTimeout(function () {
+            return contentContext.onPointerGraceIntentChange(null);
+          }, 300);
+        } else {
+          contentContext.onTriggerLeave(event);
+          if (event.defaultPrevented) return;
+          contentContext.onPointerGraceIntentChange(null);
+        }
+      })),
+      onKeyDown: composeEventHandlers(props.onKeyDown, function (event) {
+        var isTypingAhead = contentContext.searchRef.current !== "";
+        if (props.disabled || isTypingAhead && event.key === " ") return;
+        if (SUB_OPEN_KEYS[rootContext.dir].includes(event.key)) {
+          var _context$content3;
+          context.onOpenChange(true);
+          (_context$content3 = context.content) === null || _context$content3 === void 0 ? void 0 : _context$content3.focus();
+          event.preventDefault();
+        }
+      })
+    }))
+  }));
+});
+MenuSubTrigger.displayName = SUB_TRIGGER_NAME;
+var SUB_CONTENT_NAME = "MenuSubContent";
+var MenuSubContent = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var portalContext = usePortalContext(CONTENT_NAME, props.__scopeMenu);
+  var _props$forceMount2 = props.forceMount,
+    forceMount = _props$forceMount2 === void 0 ? portalContext.forceMount : _props$forceMount2,
+    subContentProps = _objectWithoutProperties(props, _excluded14);
+  var context = useMenuContext(CONTENT_NAME, props.__scopeMenu);
+  var rootContext = useMenuRootContext(CONTENT_NAME, props.__scopeMenu);
+  var subContext = useMenuSubContext(SUB_CONTENT_NAME, props.__scopeMenu);
+  var ref = useRef(null);
+  var composedRefs = useComposedRefs(forwardedRef, ref);
+  return /* @__PURE__ */jsx(Collection.Provider, {
+    scope: props.__scopeMenu,
+    children: /* @__PURE__ */jsx(Presence, {
+      present: forceMount || context.open,
+      children: /* @__PURE__ */jsx(Collection.Slot, {
+        scope: props.__scopeMenu,
+        children: /* @__PURE__ */jsx(MenuContentImpl, _objectSpread2(_objectSpread2({
+          id: subContext.contentId,
+          "aria-labelledby": subContext.triggerId
+        }, subContentProps), {}, {
+          ref: composedRefs,
+          align: "start",
+          side: rootContext.dir === "rtl" ? "left" : "right",
+          disableOutsidePointerEvents: false,
+          disableOutsideScroll: false,
+          trapFocus: false,
+          onOpenAutoFocus: function onOpenAutoFocus(event) {
+            var _ref$current;
+            if (rootContext.isUsingKeyboardRef.current) (_ref$current = ref.current) === null || _ref$current === void 0 ? void 0 : _ref$current.focus();
+            event.preventDefault();
+          },
+          onCloseAutoFocus: function onCloseAutoFocus(event) {
+            return event.preventDefault();
+          },
+          onFocusOutside: composeEventHandlers(props.onFocusOutside, function (event) {
+            if (event.target !== subContext.trigger) context.onOpenChange(false);
+          }),
+          onEscapeKeyDown: composeEventHandlers(props.onEscapeKeyDown, function (event) {
+            rootContext.onClose();
+            event.preventDefault();
+          }),
+          onKeyDown: composeEventHandlers(props.onKeyDown, function (event) {
+            var isKeyDownInside = event.currentTarget.contains(event.target);
+            var isCloseKey = SUB_CLOSE_KEYS[rootContext.dir].includes(event.key);
+            if (isKeyDownInside && isCloseKey) {
+              var _subContext$trigger;
+              context.onOpenChange(false);
+              (_subContext$trigger = subContext.trigger) === null || _subContext$trigger === void 0 ? void 0 : _subContext$trigger.focus();
+              event.preventDefault();
+            }
+          })
+        }))
+      })
+    })
+  });
+});
+MenuSubContent.displayName = SUB_CONTENT_NAME;
+function getOpenState(open) {
+  return open ? "open" : "closed";
+}
+function isIndeterminate(checked) {
+  return checked === "indeterminate";
+}
+function getCheckedState(checked) {
+  return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
+}
+function focusFirst(candidates) {
+  var PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
+  var _iterator = _createForOfIteratorHelper(candidates),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var candidate = _step.value;
+      if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
+      candidate.focus();
+      if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+function wrapArray(array, startIndex) {
+  return array.map(function (_, index) {
+    return array[(startIndex + index) % array.length];
+  });
+}
+function getNextMatch(values, search, currentMatch) {
+  var isRepeated = search.length > 1 && Array.from(search).every(function (char) {
+    return char === search[0];
+  });
+  var normalizedSearch = isRepeated ? search[0] : search;
+  var currentMatchIndex = currentMatch ? values.indexOf(currentMatch) : -1;
+  var wrappedValues = wrapArray(values, Math.max(currentMatchIndex, 0));
+  var excludeCurrentMatch = normalizedSearch.length === 1;
+  if (excludeCurrentMatch) wrappedValues = wrappedValues.filter(function (v) {
+    return v !== currentMatch;
+  });
+  var nextMatch = wrappedValues.find(function (value) {
+    return value.toLowerCase().startsWith(normalizedSearch.toLowerCase());
+  });
+  return nextMatch !== currentMatch ? nextMatch : void 0;
+}
+function isPointInPolygon(point, polygon) {
+  var x = point.x,
+    y = point.y;
+  var inside = false;
+  for (var i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    var xi = polygon[i].x;
+    var yi = polygon[i].y;
+    var xj = polygon[j].x;
+    var yj = polygon[j].y;
+    var intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+function isPointerInGraceArea(event, area) {
+  if (!area) return false;
+  var cursorPos = {
+    x: event.clientX,
+    y: event.clientY
+  };
+  return isPointInPolygon(cursorPos, area);
+}
+function whenMouse(handler) {
+  return function (event) {
+    return event.pointerType === "mouse" ? handler(event) : void 0;
+  };
+}
+var Root3 = Menu;
+var Anchor2 = MenuAnchor;
+var Portal = MenuPortal;
+var Content2 = MenuContent;
+var Group = MenuGroup;
+var Label = MenuLabel;
+var Item2 = MenuItem;
+var CheckboxItem = MenuCheckboxItem;
+var RadioGroup = MenuRadioGroup;
+var RadioItem = MenuRadioItem;
+var ItemIndicator = MenuItemIndicator;
+var Separator = MenuSeparator;
+var Arrow2 = MenuArrow;
+var Sub = MenuSub;
+var SubTrigger = MenuSubTrigger;
+var SubContent = MenuSubContent;
+
+export { Anchor2 as Anchor, Arrow2 as Arrow, CheckboxItem, Content2 as Content, Group, Item2 as Item, ItemIndicator, Label, Menu, MenuAnchor, MenuArrow, MenuCheckboxItem, MenuContent, MenuGroup, MenuItem, MenuItemIndicator, MenuLabel, MenuPortal, MenuRadioGroup, MenuRadioItem, MenuSeparator, MenuSub, MenuSubContent, MenuSubTrigger, Portal, RadioGroup, RadioItem, Root3 as Root, Separator, Sub, SubContent, SubTrigger, createMenuScope };
+//# sourceMappingURL=index.mjs.js.map