fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/reakit/es/Menu/Menu.js

@@ -0,0 +1,149 @@
+import { a as _objectSpread2, _ as _objectWithoutPropertiesLoose } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import { useContext, useMemo, useCallback } from 'react';
+import 'reakit-utils/useForkRef';
+import 'reakit-utils/isButton';
+import { useWarning } from 'reakit-warning';
+import { useLiveRef } from 'reakit-utils/useLiveRef';
+import 'reakit-utils/isSelfTarget';
+import 'reakit-utils/useIsomorphicEffect';
+import 'reakit-utils/hasFocusWithin';
+import { isPortalEvent } from 'reakit-utils/isPortalEvent';
+import 'reakit-utils/dom';
+import 'reakit-utils/tabbable';
+import '../Role/Role.js';
+import '../Tabbable/Tabbable.js';
+import 'reakit-utils/useUpdateEffect';
+import { useCreateElement } from 'reakit-system/useCreateElement';
+import 'reakit-utils/getDocument';
+import 'reakit-utils/fireBlurEvent';
+import 'reakit-utils/fireKeyboardEvent';
+import 'reakit-utils/canUseDOM';
+import 'reakit-utils/getNextActiveElementOnBlur';
+import '../reverse-30eaa122.js';
+import '../getCurrentId-5aa9849e.js';
+import '../findEnabledItemById-8ddca752.js';
+import '../__keys-6742f591.js';
+import '../userFocus-e16425e3.js';
+import '../Composite/Composite.js';
+import 'reakit-utils/ensureFocus';
+import '../__keys-e6a5cfbe.js';
+import '../Disclosure/DisclosureContent.js';
+import 'react-dom';
+import '../Portal/Portal.js';
+import 'reakit-utils/removeItemFromArray';
+import { M as MenuContext } from '../MenuContext-6af6cf92.js';
+import '../Dialog/Dialog.js';
+import 'body-scroll-lock';
+import 'reakit-utils/closest';
+import 'reakit-utils/getActiveElement';
+import 'reakit-utils/contains';
+import '../DialogBackdropContext-8775f78b.js';
+import 'reakit-utils/isEmpty';
+import '../__keys-ed7b48af.js';
+import '../__keys-26bb1730.js';
+import { usePopover } from '../Popover/Popover.js';
+import { useMenuBar } from './MenuBar.js';
+import { M as MENU_KEYS } from '../__keys-f74df4e0.js';
+
+function usePlacementDir(placement) {
+  return useMemo(function () {
+    var _placement$split;
+
+    return placement === null || placement === void 0 ? void 0 : (_placement$split = placement.split("-")) === null || _placement$split === void 0 ? void 0 : _placement$split[0];
+  }, [placement]);
+}
+
+var useMenu = createHook({
+  name: "Menu",
+  compose: [useMenuBar, usePopover],
+  keys: MENU_KEYS,
+  useOptions: function useOptions(options) {
+    var parent = useContext(MenuContext);
+    var parentIsMenuBar = (parent === null || parent === void 0 ? void 0 : parent.role) === "menubar";
+    return _objectSpread2(_objectSpread2({
+      unstable_autoFocusOnHide: !parentIsMenuBar,
+      modal: false
+    }, options), {}, {
+      // will be handled by MenuButton
+      unstable_autoFocusOnShow: false,
+      // will be handled differently from usePopover/useDialog
+      hideOnEsc: false
+    });
+  },
+  useProps: function useProps(options, _ref) {
+    var htmlOnKeyDown = _ref.onKeyDown,
+        htmlProps = _objectWithoutPropertiesLoose(_ref, ["onKeyDown"]);
+
+    var onKeyDownRef = useLiveRef(htmlOnKeyDown);
+    var parent = useContext(MenuContext);
+    var hasParent = !!parent;
+    var ancestorMenuBar = parent;
+
+    while (ancestorMenuBar && ancestorMenuBar.role !== "menubar") {
+      ancestorMenuBar = ancestorMenuBar.parent;
+    }
+
+    var _ref2 = ancestorMenuBar || {},
+        next = _ref2.next,
+        previous = _ref2.previous,
+        orientation = _ref2.orientation;
+
+    var ancestorIsHorizontal = orientation === "horizontal";
+    var dir = usePlacementDir(options.placement);
+    var onKeyDown = useCallback(function (event) {
+      var _onKeyDownRef$current;
+
+      (_onKeyDownRef$current = onKeyDownRef.current) === null || _onKeyDownRef$current === void 0 ? void 0 : _onKeyDownRef$current.call(onKeyDownRef, event);
+      if (event.defaultPrevented) return;
+
+      if (event.key === "Escape") {
+        var _options$hide;
+
+        if (!hasParent) {
+          // On Esc, only stop propagation if there's no parent menu.
+          // Otherwise, pressing Esc should close all menus
+          event.stopPropagation();
+        }
+
+        (_options$hide = options.hide) === null || _options$hide === void 0 ? void 0 : _options$hide.call(options);
+      } else if (hasParent && !isPortalEvent(event)) {
+        // Moves to the next menu button in a horizontal menu bar or close
+        // the menu if it's a sub menu
+        var ArrowRight = ancestorIsHorizontal && dir !== "left" ? next : dir === "left" && options.hide;
+        var ArrowLeft = ancestorIsHorizontal && dir !== "right" ? previous : dir === "right" && options.hide;
+        var keyMap = {
+          ArrowRight: ArrowRight,
+          ArrowLeft: ArrowLeft
+        };
+        var action = keyMap[event.key];
+
+        if (action) {
+          event.preventDefault();
+
+          if (hasParent) {
+            event.stopPropagation();
+          }
+
+          action();
+        }
+      }
+    }, [hasParent, ancestorIsHorizontal, next, previous, dir, options.hide]);
+    return _objectSpread2({
+      role: "menu",
+      onKeyDown: onKeyDown
+    }, htmlProps);
+  }
+});
+var Menu = createComponent({
+  as: "div",
+  useHook: useMenu,
+  useCreateElement: function useCreateElement$1(type, props, children) {
+    process.env.NODE_ENV !== "production" ? useWarning(!props["aria-label"] && !props["aria-labelledby"], "You should provide either `aria-label` or `aria-labelledby` props.", "See https://reakit.io/docs/menu") : void 0;
+    return useCreateElement(type, props, children);
+  }
+});
+
+export { Menu, useMenu };

node_modules/reakit/es/Menu/MenuArrow.js

@@ -0,0 +1,23 @@
+import '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import 'react';
+import 'reakit-utils/useForkRef';
+import '../Role/Role.js';
+import '../__keys-26bb1730.js';
+import { a as MENU_ARROW_KEYS } from '../__keys-f74df4e0.js';
+import { usePopoverArrow } from '../Popover/PopoverArrow.js';
+
+var useMenuArrow = createHook({
+  name: "MenuArrow",
+  compose: usePopoverArrow,
+  keys: MENU_ARROW_KEYS
+});
+var MenuArrow = createComponent({
+  as: "div",
+  memo: true,
+  useHook: useMenuArrow
+});
+
+export { MenuArrow, useMenuArrow };

node_modules/reakit/es/Menu/MenuBar.js

@@ -0,0 +1,140 @@
+import { _ as _objectWithoutPropertiesLoose, a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import { useState, useEffect, useRef, useCallback } from 'react';
+import { useForkRef } from 'reakit-utils/useForkRef';
+import 'reakit-utils/isButton';
+import { useWarning } from 'reakit-warning';
+import 'reakit-utils/useLiveRef';
+import 'reakit-utils/isSelfTarget';
+import 'reakit-utils/useIsomorphicEffect';
+import 'reakit-utils/hasFocusWithin';
+import 'reakit-utils/isPortalEvent';
+import 'reakit-utils/dom';
+import 'reakit-utils/tabbable';
+import '../Role/Role.js';
+import '../Tabbable/Tabbable.js';
+import { useCreateElement } from 'reakit-system/useCreateElement';
+import 'reakit-utils/getDocument';
+import 'reakit-utils/fireBlurEvent';
+import 'reakit-utils/fireKeyboardEvent';
+import 'reakit-utils/canUseDOM';
+import 'reakit-utils/getNextActiveElementOnBlur';
+import '../reverse-30eaa122.js';
+import '../getCurrentId-5aa9849e.js';
+import '../findEnabledItemById-8ddca752.js';
+import '../__keys-6742f591.js';
+import '../userFocus-e16425e3.js';
+import { useComposite } from '../Composite/Composite.js';
+import 'reakit-utils/removeItemFromArray';
+import { u as useMenuContext } from '../MenuContext-6af6cf92.js';
+import { closest } from 'reakit-utils/closest';
+import { b as MENU_BAR_KEYS } from '../__keys-f74df4e0.js';
+
+function useShortcuts(menuRef, _ref, timeout) {
+  var _ref$items = _ref.items,
+      items = _ref$items === void 0 ? [] : _ref$items,
+      move = _ref.move;
+
+  if (timeout === void 0) {
+    timeout = 500;
+  }
+
+  var _React$useState = useState(""),
+      keys = _React$useState[0],
+      setKeys = _React$useState[1];
+
+  useEffect(function () {
+    if (!keys) return undefined;
+    var timeoutId = setTimeout(function () {
+      return setKeys("");
+    }, timeout);
+    var stop = items.find(function (s) {
+      return Boolean(s.ref.current && s.ref.current.textContent && s.ref.current.textContent.toLowerCase().startsWith(keys));
+    });
+
+    if (stop) {
+      move(stop.id);
+    }
+
+    return function () {
+      return clearTimeout(timeoutId);
+    };
+  }, [keys, items, move, timeout]);
+  useEffect(function () {
+    var menu = menuRef.current;
+    if (!menu) return undefined;
+
+    var onKeyDown = function onKeyDown(event) {
+      var _target$getAttribute;
+
+      if (event.key.length > 1) return;
+      if (event.shiftKey) return;
+      if (event.metaKey) return;
+      if (event.ctrlKey) return;
+      if (event.altKey) return;
+      var target = event.target;
+      var role = (_target$getAttribute = target.getAttribute) === null || _target$getAttribute === void 0 ? void 0 : _target$getAttribute.call(target, "role");
+      var targetIsMenu = target === menu;
+      var targetIsMenuItem = role && role.indexOf("menuitem") !== -1 && closest(target, "[role=menu],[role=menubar]") === menu;
+      if (!targetIsMenu && !targetIsMenuItem) return;
+
+      if (/^[a-z0-9_-]$/i.test(event.key)) {
+        event.stopPropagation();
+        event.preventDefault();
+        setKeys(function (k) {
+          return "" + k + event.key;
+        });
+      }
+    }; // https://github.com/facebook/react/issues/11387#issuecomment-524113945
+
+
+    menu.addEventListener("keydown", onKeyDown);
+    return function () {
+      return menu.removeEventListener("keydown", onKeyDown);
+    };
+  }, [menuRef, setKeys]);
+}
+
+var useMenuBar = createHook({
+  name: "MenuBar",
+  compose: useComposite,
+  keys: MENU_BAR_KEYS,
+  useProps: function useProps(options, _ref) {
+    var htmlRef = _ref.ref,
+        htmlWrapElement = _ref.wrapElement,
+        _ref$role = _ref.role,
+        role = _ref$role === void 0 ? "menubar" : _ref$role,
+        htmlProps = _objectWithoutPropertiesLoose(_ref, ["ref", "wrapElement", "role"]);
+
+    var ref = useRef(null);
+    var wrap = useMenuContext(ref, role, options);
+    useShortcuts(ref, options);
+    var wrapElement = useCallback(function (element) {
+      element = wrap(element);
+
+      if (htmlWrapElement) {
+        return htmlWrapElement(element);
+      }
+
+      return element;
+    }, [wrap, htmlWrapElement]);
+    return _objectSpread2({
+      ref: useForkRef(ref, htmlRef),
+      role: role,
+      "aria-orientation": options.orientation,
+      wrapElement: wrapElement
+    }, htmlProps);
+  }
+});
+var MenuBar = createComponent({
+  as: "div",
+  useHook: useMenuBar,
+  useCreateElement: function useCreateElement$1(type, props, children) {
+    process.env.NODE_ENV !== "production" ? useWarning(!props["aria-label"] && !props["aria-labelledby"] && props.role !== "menubar", "You should provide either `aria-label` or `aria-labelledby` props.", "See https://reakit.io/docs/menu") : void 0;
+    return useCreateElement(type, props, children);
+  }
+});
+
+export { MenuBar, useMenuBar };

node_modules/reakit/es/Menu/MenuBarState.js

@@ -0,0 +1,45 @@
+import { _ as _objectWithoutPropertiesLoose, a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { useState, useCallback } from 'react';
+import 'reakit-utils/useIsomorphicEffect';
+import { useSealedState } from 'reakit-utils/useSealedState';
+import 'reakit-utils/getDocument';
+import '../reverse-30eaa122.js';
+import '../getCurrentId-5aa9849e.js';
+import '../findEnabledItemById-8ddca752.js';
+import '../Id/IdProvider.js';
+import 'reakit-utils/applyState';
+import '../Id/IdState.js';
+import { useCompositeState } from '../Composite/CompositeState.js';
+
+function useMenuBarState(initialState) {
+  if (initialState === void 0) {
+    initialState = {};
+  }
+
+  var _useSealedState = useSealedState(initialState),
+      _useSealedState$orien = _useSealedState.orientation,
+      orientation = _useSealedState$orien === void 0 ? "horizontal" : _useSealedState$orien,
+      _useSealedState$unsta = _useSealedState.unstable_values,
+      initialValues = _useSealedState$unsta === void 0 ? {} : _useSealedState$unsta,
+      sealed = _objectWithoutPropertiesLoose(_useSealedState, ["orientation", "unstable_values"]);
+
+  var _React$useState = useState(initialValues),
+      values = _React$useState[0],
+      setValues = _React$useState[1];
+
+  var composite = useCompositeState(_objectSpread2(_objectSpread2({}, sealed), {}, {
+    orientation: orientation
+  }));
+  return _objectSpread2(_objectSpread2({}, composite), {}, {
+    unstable_values: values,
+    unstable_setValue: useCallback(function (name, value) {
+      setValues(function (vals) {
+        var _objectSpread2$1;
+
+        return _objectSpread2(_objectSpread2({}, vals), {}, (_objectSpread2$1 = {}, _objectSpread2$1[name] = typeof value === "function" ? value(vals) : value, _objectSpread2$1));
+      });
+    }, [])
+  });
+}
+
+export { useMenuBarState };

node_modules/reakit/es/Menu/MenuButton.js

@@ -0,0 +1,224 @@
+import { _ as _objectWithoutPropertiesLoose, a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import { useContext, useRef, useCallback } from 'react';
+import { useForkRef } from 'reakit-utils/useForkRef';
+import 'reakit-utils/isButton';
+import 'reakit-warning';
+import { useLiveRef } from 'reakit-utils/useLiveRef';
+import 'reakit-utils/isSelfTarget';
+import 'reakit-utils/useIsomorphicEffect';
+import { hasFocusWithin } from 'reakit-utils/hasFocusWithin';
+import 'reakit-utils/isPortalEvent';
+import 'reakit-utils/dom';
+import 'reakit-utils/tabbable';
+import '../Role/Role.js';
+import '../Tabbable/Tabbable.js';
+import '../Clickable/Clickable.js';
+import '../Button/Button.js';
+import '../__keys-e6a5cfbe.js';
+import 'reakit-utils/removeItemFromArray';
+import { M as MenuContext } from '../MenuContext-6af6cf92.js';
+import '../__keys-ed7b48af.js';
+import '../__keys-26bb1730.js';
+import '../Disclosure/Disclosure.js';
+import '../Dialog/DialogDisclosure.js';
+import { c as MENU_BUTTON_KEYS } from '../__keys-f74df4e0.js';
+import { usePopoverDisclosure } from '../Popover/PopoverDisclosure.js';
+import { f as findVisibleSubmenu } from '../findVisibleSubmenu-1553e354.js';
+
+var noop = function noop() {};
+
+var useMenuButton = createHook({
+  name: "MenuButton",
+  compose: usePopoverDisclosure,
+  keys: MENU_BUTTON_KEYS,
+  propsAreEqual: function propsAreEqual(prev, next) {
+    var prevPopoverStyles = prev.unstable_popoverStyles,
+        prevArrowStyles = prev.unstable_arrowStyles,
+        prevCurrentId = prev.currentId,
+        prevMoves = prev.unstable_moves,
+        prevProps = _objectWithoutPropertiesLoose(prev, ["unstable_popoverStyles", "unstable_arrowStyles", "currentId", "unstable_moves"]);
+
+    var nextPopoverStyles = next.unstable_popoverStyles,
+        nextArrowStyles = next.unstable_arrowStyles,
+        nextCurrentId = next.currentId,
+        nextMoves = next.unstable_moves,
+        nextProps = _objectWithoutPropertiesLoose(next, ["unstable_popoverStyles", "unstable_arrowStyles", "currentId", "unstable_moves"]);
+
+    return usePopoverDisclosure.unstable_propsAreEqual(prevProps, nextProps);
+  },
+  useProps: function useProps(options, _ref) {
+    var htmlRef = _ref.ref,
+        htmlOnClick = _ref.onClick,
+        htmlOnKeyDown = _ref.onKeyDown,
+        htmlOnFocus = _ref.onFocus,
+        htmlOnMouseEnter = _ref.onMouseEnter,
+        htmlOnMouseDown = _ref.onMouseDown,
+        htmlProps = _objectWithoutPropertiesLoose(_ref, ["ref", "onClick", "onKeyDown", "onFocus", "onMouseEnter", "onMouseDown"]);
+
+    var parent = useContext(MenuContext);
+    var ref = useRef(null);
+    var hasPressedMouse = useRef(false);
+
+    var _options$placement$sp = options.placement.split("-"),
+        dir = _options$placement$sp[0];
+
+    var hasParent = !!parent;
+    var parentIsMenuBar = (parent === null || parent === void 0 ? void 0 : parent.role) === "menubar";
+    var disabled = options.disabled || htmlProps["aria-disabled"];
+    var onClickRef = useLiveRef(htmlOnClick);
+    var onKeyDownRef = useLiveRef(htmlOnKeyDown);
+    var onFocusRef = useLiveRef(htmlOnFocus);
+    var onMouseEnterRef = useLiveRef(htmlOnMouseEnter);
+    var onMouseDownRef = useLiveRef(htmlOnMouseDown);
+    var onKeyDown = useCallback(function (event) {
+      var _onKeyDownRef$current;
+
+      if (event.key === "Escape") {
+        var _options$hide;
+
+        // Doesn't prevent default on Escape, otherwise we can't close
+        // dialogs when MenuButton is focused
+        (_options$hide = options.hide) === null || _options$hide === void 0 ? void 0 : _options$hide.call(options);
+      } else if (!disabled) {
+        // setTimeout prevents scroll jump
+        var first = options.first && function () {
+          return setTimeout(options.first);
+        };
+
+        var last = options.last && function () {
+          return setTimeout(options.last);
+        };
+
+        var keyMap = {
+          Enter: first,
+          " ": first,
+          ArrowUp: (dir === "top" || dir === "bottom") && last,
+          ArrowRight: dir === "right" && first,
+          ArrowDown: (dir === "bottom" || dir === "top") && first,
+          ArrowLeft: dir === "left" && first
+        };
+        var action = keyMap[event.key];
+
+        if (action) {
+          var _options$show;
+
+          event.preventDefault();
+          event.stopPropagation();
+          (_options$show = options.show) === null || _options$show === void 0 ? void 0 : _options$show.call(options);
+          action();
+          return;
+        }
+      }
+
+      (_onKeyDownRef$current = onKeyDownRef.current) === null || _onKeyDownRef$current === void 0 ? void 0 : _onKeyDownRef$current.call(onKeyDownRef, event);
+    }, [disabled, options.hide, options.first, options.last, dir, options.show]);
+    var onMouseEnter = useCallback(function (event) {
+      var _onMouseEnterRef$curr;
+
+      (_onMouseEnterRef$curr = onMouseEnterRef.current) === null || _onMouseEnterRef$curr === void 0 ? void 0 : _onMouseEnterRef$curr.call(onMouseEnterRef, event);
+      if (event.defaultPrevented) return; // MenuButton's don't do anything on mouse over when they aren't
+      // cointained within a Menu/MenuBar
+
+      if (!parent) return;
+      var element = event.currentTarget;
+
+      if (parentIsMenuBar) {
+        // if MenuButton is an item inside a MenuBar, it'll only open
+        // if there's already another sibling expanded MenuButton
+        if (findVisibleSubmenu(parent.children)) {
+          element.focus();
+        }
+      } else {
+        // If it's in a Menu, open after a short delay
+        // TODO: Make the delay a prop?
+        setTimeout(function () {
+          if (hasFocusWithin(element)) {
+            var _options$show2;
+
+            (_options$show2 = options.show) === null || _options$show2 === void 0 ? void 0 : _options$show2.call(options);
+          }
+        }, 200);
+      }
+    }, [parent, parentIsMenuBar, options.show]);
+    var onMouseDown = useCallback(function (event) {
+      var _onMouseDownRef$curre;
+
+      // When in menu bar, the menu button can be activated either by focus
+      // or click, but we don't want both to trigger sequentially.
+      // Otherwise, onClick would toggle (hide) the menu right after it got
+      // shown on focus.
+      // This is also useful so we know if the menu button has been clicked
+      // using mouse or keyboard. On mouse click, we don't automatically
+      // focus the first menu item.
+      hasPressedMouse.current = true;
+      (_onMouseDownRef$curre = onMouseDownRef.current) === null || _onMouseDownRef$curre === void 0 ? void 0 : _onMouseDownRef$curre.call(onMouseDownRef, event);
+    }, []);
+    var onFocus = useCallback(function (event) {
+      var _onFocusRef$current;
+
+      (_onFocusRef$current = onFocusRef.current) === null || _onFocusRef$current === void 0 ? void 0 : _onFocusRef$current.call(onFocusRef, event);
+      if (event.defaultPrevented) return;
+      if (disabled) return;
+
+      if (parentIsMenuBar && !hasPressedMouse.current) {
+        var _options$show3;
+
+        (_options$show3 = options.show) === null || _options$show3 === void 0 ? void 0 : _options$show3.call(options);
+      }
+    }, [parentIsMenuBar, disabled, options.show]); // If disclosure is rendered as a menu bar item, it's toggable
+    // That is, you can click on the expanded disclosure to close its menu.
+
+    var onClick = useCallback(function (event) {
+      var _onClickRef$current;
+
+      (_onClickRef$current = onClickRef.current) === null || _onClickRef$current === void 0 ? void 0 : _onClickRef$current.call(onClickRef, event);
+      if (event.defaultPrevented) return; // If menu button is a menu item inside a menu (not menu bar), you
+      // can't close it by clicking on it again.
+
+      if (hasParent && !parentIsMenuBar) {
+        var _options$show4;
+
+        (_options$show4 = options.show) === null || _options$show4 === void 0 ? void 0 : _options$show4.call(options);
+      } else {
+        var _options$toggle;
+
+        // Otherwise, if menu button is a menu bar item or an orphan menu
+        // button, it's toggable.
+        (_options$toggle = options.toggle) === null || _options$toggle === void 0 ? void 0 : _options$toggle.call(options); // Focus the menu popover when it's opened with mouse click.
+
+        if (hasPressedMouse.current && !parentIsMenuBar && !options.visible) {
+          var _options$move;
+
+          (_options$move = options.move) === null || _options$move === void 0 ? void 0 : _options$move.call(options, null);
+        }
+      }
+
+      hasPressedMouse.current = false;
+    }, [hasParent, parentIsMenuBar, options.show, options.toggle, options.visible, options.move]);
+    return _objectSpread2({
+      ref: useForkRef(ref, htmlRef),
+      "aria-haspopup": "menu",
+      onKeyDown: onKeyDown,
+      onMouseEnter: onMouseEnter,
+      onMouseDown: onMouseDown,
+      onFocus: onFocus,
+      onClick: onClick
+    }, htmlProps);
+  },
+  useComposeOptions: function useComposeOptions(options) {
+    return _objectSpread2(_objectSpread2({}, options), {}, {
+      // Toggling is handled by MenuButton
+      toggle: noop
+    });
+  }
+});
+var MenuButton = createComponent({
+  as: "button",
+  memo: true,
+  useHook: useMenuButton
+});
+
+export { MenuButton, useMenuButton };

node_modules/reakit/es/Menu/MenuDisclosure.js

@@ -0,0 +1,45 @@
+import '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import 'react';
+import 'reakit-utils/useForkRef';
+import 'reakit-utils/isButton';
+import { useWarning } from 'reakit-warning';
+import 'reakit-utils/useLiveRef';
+import 'reakit-utils/isSelfTarget';
+import 'reakit-utils/useIsomorphicEffect';
+import 'reakit-utils/hasFocusWithin';
+import 'reakit-utils/isPortalEvent';
+import 'reakit-utils/dom';
+import 'reakit-utils/tabbable';
+import '../Role/Role.js';
+import '../Tabbable/Tabbable.js';
+import '../Clickable/Clickable.js';
+import '../Button/Button.js';
+import '../__keys-e6a5cfbe.js';
+import 'reakit-utils/removeItemFromArray';
+import '../MenuContext-6af6cf92.js';
+import '../__keys-ed7b48af.js';
+import '../__keys-26bb1730.js';
+import '../Disclosure/Disclosure.js';
+import '../Dialog/DialogDisclosure.js';
+import '../__keys-f74df4e0.js';
+import '../Popover/PopoverDisclosure.js';
+import '../findVisibleSubmenu-1553e354.js';
+import { useMenuButton } from './MenuButton.js';
+
+var useMenuDisclosure = createHook({
+  name: "MenuDisclosure",
+  compose: useMenuButton,
+  useProps: function useProps(_, htmlProps) {
+    process.env.NODE_ENV !== "production" ? useWarning(true, "`MenuDisclosure` has been renamed to `MenuButton`. Using `<MenuDisclosure />` will no longer work in future versions.", "See https://reakit.io/docs/menu") : void 0;
+    return htmlProps;
+  }
+});
+var MenuDisclosure = createComponent({
+  as: "button",
+  useHook: useMenuDisclosure
+});
+
+export { MenuDisclosure, useMenuDisclosure };

node_modules/reakit/es/Menu/MenuGroup.js

@@ -0,0 +1,23 @@
+import { a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import { useRole } from '../Role/Role.js';
+import { d as MENU_GROUP_KEYS } from '../__keys-f74df4e0.js';
+
+var useMenuGroup = createHook({
+  name: "MenuGroup",
+  compose: useRole,
+  keys: MENU_GROUP_KEYS,
+  useProps: function useProps(_, htmlProps) {
+    return _objectSpread2({
+      role: "group"
+    }, htmlProps);
+  }
+});
+var MenuGroup = createComponent({
+  as: "div",
+  useHook: useMenuGroup
+});
+
+export { MenuGroup, useMenuGroup };

node_modules/reakit/es/Menu/MenuItem.js

@@ -0,0 +1,236 @@
+import { _ as _objectWithoutPropertiesLoose, a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import { useRef, useCallback, useContext } from 'react';
+import 'reakit-utils/useForkRef';
+import 'reakit-utils/isButton';
+import 'reakit-warning';
+import { useLiveRef } from 'reakit-utils/useLiveRef';
+import 'reakit-utils/isSelfTarget';
+import 'reakit-utils/useIsomorphicEffect';
+import { hasFocusWithin } from 'reakit-utils/hasFocusWithin';
+import 'reakit-utils/isPortalEvent';
+import 'reakit-utils/dom';
+import 'reakit-utils/tabbable';
+import '../Role/Role.js';
+import '../Tabbable/Tabbable.js';
+import '../Clickable/Clickable.js';
+import 'reakit-utils/getDocument';
+import '../getCurrentId-5aa9849e.js';
+import '../__keys-6742f591.js';
+import '../userFocus-e16425e3.js';
+import 'reakit-utils/isTextField';
+import 'reakit-utils/ensureFocus';
+import '../Id/IdProvider.js';
+import '../Id/Id.js';
+import 'reakit-utils/fireEvent';
+import '../setTextFieldValue-0a221f4e.js';
+import { useCompositeItem } from '../Composite/CompositeItem.js';
+import 'reakit-utils/removeItemFromArray';
+import { M as MenuContext } from '../MenuContext-6af6cf92.js';
+import { contains } from 'reakit-utils/contains';
+import { e as MENU_ITEM_KEYS } from '../__keys-f74df4e0.js';
+import { f as findVisibleSubmenu } from '../findVisibleSubmenu-1553e354.js';
+
+function getTriangleArea(a, b, c) {
+  return Math.abs((a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)) / 2);
+}
+
+function isPointInTriangle(point, a, b, c) {
+  var A = getTriangleArea(a, b, c);
+  var A1 = getTriangleArea(point, b, c);
+  var A2 = getTriangleArea(a, point, c);
+  var A3 = getTriangleArea(a, b, point);
+  return A === A1 + A2 + A3;
+}
+
+function getSubmenuAnchorPoints(event, visibleSubmenu) {
+  var _visibleSubmenu$getBo = visibleSubmenu.getBoundingClientRect(),
+      top = _visibleSubmenu$getBo.top,
+      right = _visibleSubmenu$getBo.right,
+      bottom = _visibleSubmenu$getBo.bottom,
+      left = _visibleSubmenu$getBo.left; // If left is bigger than mouse's clientX, than the submenu is visible on
+  // the left side
+
+
+  var x = left > event.clientX ? left : right;
+  return [{
+    x: x,
+    y: top
+  }, {
+    x: x,
+    y: bottom
+  }];
+}
+
+function useTransitToSubmenu(menu, htmlOnMouseEnter) {
+  var onMouseEnterRef = useLiveRef(htmlOnMouseEnter);
+  var enterPointRef = useRef(null);
+  var submenuTopPointRef = useRef(null);
+  var submenuBottomPointRef = useRef(null);
+  var previousClientX = useRef(0);
+  var previousClientY = useRef(0);
+  var assignSubmenuAnchorPoints = useCallback(function (event) {
+    if (!(menu !== null && menu !== void 0 && menu.children.length)) return;
+    submenuTopPointRef.current = null;
+    submenuBottomPointRef.current = null;
+    var visibleSubmenu = findVisibleSubmenu(menu.children);
+    if (!visibleSubmenu) return;
+
+    var _getSubmenuAnchorPoin = getSubmenuAnchorPoints(event, visibleSubmenu);
+
+    submenuTopPointRef.current = _getSubmenuAnchorPoin[0];
+    submenuBottomPointRef.current = _getSubmenuAnchorPoin[1];
+  }, [menu === null || menu === void 0 ? void 0 : menu.children]);
+  var isMouseInTransitToSubmenu = useCallback(function (event) {
+    var isMoving = previousClientX.current !== event.clientX || previousClientY.current !== event.clientY;
+
+    if (event.isTrusted && !isMoving) {
+      // Safari sometimes triggers mousemove without a mouse movement
+      return true;
+    }
+
+    var movementX = Math.abs(previousClientX.current - event.clientX);
+    previousClientX.current = event.clientX;
+    previousClientY.current = event.clientY;
+
+    var hasAnchorPoints = function hasAnchorPoints() {
+      return submenuTopPointRef.current && submenuBottomPointRef.current;
+    };
+
+    if (event.type === "mouseleave" && !hasAnchorPoints()) {
+      assignSubmenuAnchorPoints(event);
+    }
+
+    if (!hasAnchorPoints()) return false;
+    return movementX && enterPointRef.current && isPointInTriangle({
+      x: event.clientX,
+      y: event.clientY
+    }, enterPointRef.current, submenuTopPointRef.current, submenuBottomPointRef.current);
+  }, [assignSubmenuAnchorPoints]);
+  var onMouseEnter = useCallback(function (event) {
+    var _onMouseEnterRef$curr;
+
+    (_onMouseEnterRef$curr = onMouseEnterRef.current) === null || _onMouseEnterRef$curr === void 0 ? void 0 : _onMouseEnterRef$curr.call(onMouseEnterRef, event);
+    if (event.defaultPrevented) return;
+    if ((menu === null || menu === void 0 ? void 0 : menu.role) === "menubar") return;
+    enterPointRef.current = {
+      x: event.clientX,
+      y: event.clientY
+    };
+    assignSubmenuAnchorPoints(event);
+  }, [menu === null || menu === void 0 ? void 0 : menu.role, assignSubmenuAnchorPoints]);
+  return {
+    onMouseEnter: onMouseEnter,
+    isMouseInTransitToSubmenu: isMouseInTransitToSubmenu
+  };
+}
+
+function getMouseDestination(event) {
+  var relatedTarget = event.relatedTarget;
+
+  if ((relatedTarget === null || relatedTarget === void 0 ? void 0 : relatedTarget.nodeType) === Node.ELEMENT_NODE) {
+    return event.relatedTarget;
+  } // IE 11
+
+
+  return event.toElement || null;
+}
+
+function hoveringInside(event) {
+  var nextElement = getMouseDestination(event);
+  if (!nextElement) return false;
+  return contains(event.currentTarget, nextElement);
+}
+
+function hoveringExpandedMenu(event, children) {
+  if (!(children !== null && children !== void 0 && children.length)) return false;
+  var nextElement = getMouseDestination(event);
+  if (!nextElement) return false;
+  var visibleSubmenu = findVisibleSubmenu(children);
+  return visibleSubmenu && contains(visibleSubmenu, nextElement);
+}
+
+function hoveringAnotherMenuItem(event, items) {
+  var nextElement = getMouseDestination(event);
+  if (!nextElement) return false;
+  return items === null || items === void 0 ? void 0 : items.some(function (item) {
+    return item.ref.current && contains(item.ref.current, nextElement);
+  });
+}
+
+var useMenuItem = createHook({
+  name: "MenuItem",
+  compose: useCompositeItem,
+  keys: MENU_ITEM_KEYS,
+  propsAreEqual: function propsAreEqual(prev, next) {
+    var prevPopoverStyles = prev.unstable_popoverStyles,
+        prevArrowStyles = prev.unstable_arrowStyles,
+        prevVisible = prev.visible,
+        prevProps = _objectWithoutPropertiesLoose(prev, ["unstable_popoverStyles", "unstable_arrowStyles", "visible"]);
+
+    var nextPopoverStyles = next.unstable_popoverStyles,
+        nextArrowStyles = next.unstable_arrowStyles,
+        nextVisible = next.visible,
+        nextProps = _objectWithoutPropertiesLoose(next, ["unstable_popoverStyles", "unstable_arrowStyles", "visible"]);
+
+    return useCompositeItem.unstable_propsAreEqual(prevProps, nextProps);
+  },
+  useProps: function useProps(options, _ref) {
+    var htmlOnMouseEnter = _ref.onMouseEnter,
+        htmlOnMouseMove = _ref.onMouseMove,
+        htmlOnMouseLeave = _ref.onMouseLeave,
+        htmlProps = _objectWithoutPropertiesLoose(_ref, ["onMouseEnter", "onMouseMove", "onMouseLeave"]);
+
+    var menu = useContext(MenuContext);
+    var onMouseMoveRef = useLiveRef(htmlOnMouseMove);
+    var onMouseLeaveRef = useLiveRef(htmlOnMouseLeave);
+
+    var _useTransitToSubmenu = useTransitToSubmenu(menu, htmlOnMouseEnter),
+        onMouseEnter = _useTransitToSubmenu.onMouseEnter,
+        isMouseInTransitToSubmenu = _useTransitToSubmenu.isMouseInTransitToSubmenu;
+
+    var onMouseMove = useCallback(function (event) {
+      var _onMouseMoveRef$curre, _options$move;
+
+      (_onMouseMoveRef$curre = onMouseMoveRef.current) === null || _onMouseMoveRef$curre === void 0 ? void 0 : _onMouseMoveRef$curre.call(onMouseMoveRef, event);
+      if (event.defaultPrevented) return;
+      if ((menu === null || menu === void 0 ? void 0 : menu.role) === "menubar") return;
+      if (isMouseInTransitToSubmenu(event)) return;
+      if (hasFocusWithin(event.currentTarget)) return;
+      (_options$move = options.move) === null || _options$move === void 0 ? void 0 : _options$move.call(options, event.currentTarget.id);
+    }, [options.move]);
+    var onMouseLeave = useCallback(function (event) {
+      var _onMouseLeaveRef$curr;
+
+      (_onMouseLeaveRef$curr = onMouseLeaveRef.current) === null || _onMouseLeaveRef$curr === void 0 ? void 0 : _onMouseLeaveRef$curr.call(onMouseLeaveRef, event);
+      if (event.defaultPrevented) return;
+      if ((menu === null || menu === void 0 ? void 0 : menu.role) === "menubar") return;
+      if (hoveringInside(event)) return; // If this item is a menu disclosure and mouse is leaving it to focus
+      // its respective submenu, we don't want to do anything.
+
+      if (hoveringExpandedMenu(event, menu === null || menu === void 0 ? void 0 : menu.children)) return; // Move focus to menu after blurring
+
+      if (!hoveringAnotherMenuItem(event, options.items)) {
+        var _options$move2;
+
+        if (isMouseInTransitToSubmenu(event)) return;
+        (_options$move2 = options.move) === null || _options$move2 === void 0 ? void 0 : _options$move2.call(options, null);
+      }
+    }, [menu === null || menu === void 0 ? void 0 : menu.role, menu === null || menu === void 0 ? void 0 : menu.children, options.items, options.move]);
+    return _objectSpread2({
+      role: "menuitem",
+      onMouseEnter: onMouseEnter,
+      onMouseMove: onMouseMove,
+      onMouseLeave: onMouseLeave
+    }, htmlProps);
+  }
+});
+var MenuItem = createComponent({
+  as: "button",
+  memo: true,
+  useHook: useMenuItem
+});
+
+export { MenuItem, useMenuItem };

node_modules/reakit/es/Menu/MenuItemCheckbox.js

@@ -0,0 +1,83 @@
+import { _ as _objectWithoutPropertiesLoose, a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import { useCallback } from 'react';
+import 'reakit-utils/useForkRef';
+import 'reakit-utils/isButton';
+import 'reakit-warning';
+import 'reakit-utils/useLiveRef';
+import 'reakit-utils/isSelfTarget';
+import 'reakit-utils/useIsomorphicEffect';
+import 'reakit-utils/hasFocusWithin';
+import 'reakit-utils/isPortalEvent';
+import 'reakit-utils/dom';
+import 'reakit-utils/tabbable';
+import '../Role/Role.js';
+import '../Tabbable/Tabbable.js';
+import '../Clickable/Clickable.js';
+import 'reakit-utils/removeIndexFromArray';
+import 'reakit-utils/createEvent';
+import { useCheckbox } from '../Checkbox/Checkbox.js';
+import 'reakit-utils/getDocument';
+import '../getCurrentId-5aa9849e.js';
+import '../__keys-6742f591.js';
+import '../userFocus-e16425e3.js';
+import 'reakit-utils/isTextField';
+import 'reakit-utils/ensureFocus';
+import '../Id/IdProvider.js';
+import '../Id/Id.js';
+import 'reakit-utils/fireEvent';
+import '../setTextFieldValue-0a221f4e.js';
+import '../Composite/CompositeItem.js';
+import 'reakit-utils/removeItemFromArray';
+import '../MenuContext-6af6cf92.js';
+import 'reakit-utils/contains';
+import { f as MENU_ITEM_CHECKBOX_KEYS } from '../__keys-f74df4e0.js';
+import '../findVisibleSubmenu-1553e354.js';
+import { useMenuItem } from './MenuItem.js';
+
+var useMenuItemCheckbox = createHook({
+  name: "MenuItemCheckbox",
+  compose: [useMenuItem, useCheckbox],
+  keys: MENU_ITEM_CHECKBOX_KEYS,
+  propsAreEqual: function propsAreEqual(prev, next) {
+    if (prev.name !== next.name) {
+      return useMenuItem.unstable_propsAreEqual(prev, next);
+    }
+
+    var prevValues = prev.unstable_values,
+        prevProps = _objectWithoutPropertiesLoose(prev, ["unstable_values"]);
+
+    var nextValues = next.unstable_values,
+        nextProps = _objectWithoutPropertiesLoose(next, ["unstable_values"]);
+
+    if (prevValues[next.name] !== nextValues[next.name]) {
+      return false;
+    }
+
+    return useMenuItem.unstable_propsAreEqual(prevProps, nextProps);
+  },
+  useOptions: function useOptions(options) {
+    var setState = useCallback(function (value) {
+      return options.unstable_setValue(options.name, value);
+    }, [options.unstable_setValue, options.name]);
+    return _objectSpread2(_objectSpread2({}, options), {}, {
+      state: options.unstable_values[options.name],
+      setState: setState
+    });
+  },
+  useProps: function useProps(options, htmlProps) {
+    return _objectSpread2({
+      role: "menuitemcheckbox",
+      name: options.name
+    }, htmlProps);
+  }
+});
+var MenuItemCheckbox = createComponent({
+  as: "button",
+  memo: true,
+  useHook: useMenuItemCheckbox
+});
+
+export { MenuItemCheckbox, useMenuItemCheckbox };

node_modules/reakit/es/Menu/MenuItemRadio.js

@@ -0,0 +1,84 @@
+import { _ as _objectWithoutPropertiesLoose, a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import { useCallback } from 'react';
+import 'reakit-utils/useForkRef';
+import 'reakit-utils/isButton';
+import 'reakit-warning';
+import 'reakit-utils/useLiveRef';
+import 'reakit-utils/isSelfTarget';
+import 'reakit-utils/useIsomorphicEffect';
+import 'reakit-utils/hasFocusWithin';
+import 'reakit-utils/isPortalEvent';
+import 'reakit-utils/dom';
+import 'reakit-utils/tabbable';
+import '../Role/Role.js';
+import '../Tabbable/Tabbable.js';
+import '../Clickable/Clickable.js';
+import 'reakit-utils/createEvent';
+import 'reakit-utils/getDocument';
+import '../getCurrentId-5aa9849e.js';
+import '../__keys-6742f591.js';
+import '../userFocus-e16425e3.js';
+import 'reakit-utils/isTextField';
+import 'reakit-utils/ensureFocus';
+import '../Id/IdProvider.js';
+import '../Id/Id.js';
+import 'reakit-utils/fireEvent';
+import '../setTextFieldValue-0a221f4e.js';
+import '../Composite/CompositeItem.js';
+import 'reakit-utils/removeItemFromArray';
+import '../MenuContext-6af6cf92.js';
+import 'reakit-utils/contains';
+import 'reakit-warning/warning';
+import '../__keys-d251e56b.js';
+import { useRadio } from '../Radio/Radio.js';
+import { g as MENU_ITEM_RADIO_KEYS } from '../__keys-f74df4e0.js';
+import '../findVisibleSubmenu-1553e354.js';
+import { useMenuItem } from './MenuItem.js';
+
+var useMenuItemRadio = createHook({
+  name: "MenuItemRadio",
+  compose: [useMenuItem, useRadio],
+  keys: MENU_ITEM_RADIO_KEYS,
+  propsAreEqual: function propsAreEqual(prev, next) {
+    if (prev.name !== next.name) {
+      return useMenuItem.unstable_propsAreEqual(prev, next);
+    }
+
+    var prevValues = prev.unstable_values,
+        prevProps = _objectWithoutPropertiesLoose(prev, ["unstable_values"]);
+
+    var nextValues = next.unstable_values,
+        nextProps = _objectWithoutPropertiesLoose(next, ["unstable_values"]);
+
+    if (prevValues[next.name] !== nextValues[next.name]) {
+      return false;
+    }
+
+    return useMenuItem.unstable_propsAreEqual(prevProps, nextProps);
+  },
+  useOptions: function useOptions(options) {
+    var setState = useCallback(function (value) {
+      return options.unstable_setValue(options.name, value);
+    }, [options.unstable_setValue, options.name]);
+    return _objectSpread2(_objectSpread2({}, options), {}, {
+      unstable_checkOnFocus: false,
+      state: options.unstable_values[options.name],
+      setState: setState
+    });
+  },
+  useProps: function useProps(_, htmlProps) {
+    return _objectSpread2({
+      role: "menuitemradio"
+    }, htmlProps);
+  }
+});
+var MenuItemRadio = createComponent({
+  as: "button",
+  memo: true,
+  useHook: useMenuItemRadio
+});
+
+export { MenuItemRadio, useMenuItemRadio };

node_modules/reakit/es/Menu/MenuSeparator.js

@@ -0,0 +1,29 @@
+import { _ as _objectWithoutPropertiesLoose, a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import { createComponent } from 'reakit-system/createComponent';
+import { createHook } from 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import '../Role/Role.js';
+import { h as MENU_SEPARATOR_KEYS } from '../__keys-f74df4e0.js';
+import { useSeparator } from '../Separator/Separator.js';
+
+var useMenuSeparator = createHook({
+  name: "MenuSeparator",
+  compose: useSeparator,
+  keys: MENU_SEPARATOR_KEYS,
+  useOptions: function useOptions(_ref) {
+    var _ref$orientation = _ref.orientation,
+        orientation = _ref$orientation === void 0 ? "vertical" : _ref$orientation,
+        options = _objectWithoutPropertiesLoose(_ref, ["orientation"]);
+
+    return _objectSpread2({
+      orientation: orientation === "vertical" ? "horizontal" : "vertical"
+    }, options);
+  }
+});
+var MenuSeparator = createComponent({
+  as: "hr",
+  memo: true,
+  useHook: useMenuSeparator
+});
+
+export { MenuSeparator, useMenuSeparator };

node_modules/reakit/es/Menu/MenuState.js

@@ -0,0 +1,54 @@
+import { _ as _objectWithoutPropertiesLoose, a as _objectSpread2 } from '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import 'reakit-utils/shallowEqual';
+import { useContext, useEffect } from 'react';
+import 'reakit-warning';
+import 'reakit-utils/useIsomorphicEffect';
+import 'reakit-utils/dom';
+import { useSealedState } from 'reakit-utils/useSealedState';
+import 'reakit-utils/getDocument';
+import '../reverse-30eaa122.js';
+import '../getCurrentId-5aa9849e.js';
+import '../findEnabledItemById-8ddca752.js';
+import '../Id/IdProvider.js';
+import 'reakit-utils/applyState';
+import '../Id/IdState.js';
+import '../Composite/CompositeState.js';
+import '@popperjs/core';
+import '../Disclosure/DisclosureState.js';
+import '../Dialog/DialogState.js';
+import { usePopoverState } from '../Popover/PopoverState.js';
+import 'reakit-utils/removeItemFromArray';
+import { M as MenuContext } from '../MenuContext-6af6cf92.js';
+import { useMenuBarState } from './MenuBarState.js';
+
+function useMenuState(initialState) {
+  if (initialState === void 0) {
+    initialState = {};
+  }
+
+  var parent = useContext(MenuContext);
+
+  var _useSealedState = useSealedState(initialState),
+      _useSealedState$orien = _useSealedState.orientation,
+      orientation = _useSealedState$orien === void 0 ? "vertical" : _useSealedState$orien,
+      _useSealedState$gutte = _useSealedState.gutter,
+      gutter = _useSealedState$gutte === void 0 ? 0 : _useSealedState$gutte,
+      sealed = _objectWithoutPropertiesLoose(_useSealedState, ["orientation", "gutter"]);
+
+  var placement = sealed.placement || (parent && parent.orientation === "vertical" ? "right-start" : "bottom-start");
+  var menuBar = useMenuBarState(_objectSpread2(_objectSpread2({}, sealed), {}, {
+    orientation: orientation
+  }));
+  var popover = usePopoverState(_objectSpread2(_objectSpread2({}, sealed), {}, {
+    placement: placement,
+    gutter: gutter
+  }));
+  useEffect(function () {
+    if (!popover.visible) {
+      menuBar.reset();
+    }
+  }, [popover.visible, menuBar.reset]);
+  return _objectSpread2(_objectSpread2({}, menuBar), popover);
+}
+
+export { useMenuState };

node_modules/reakit/es/Menu/index.js

@@ -0,0 +1,88 @@
+import '../_rollupPluginBabelHelpers-1f0bf8c2.js';
+import 'reakit-system/createComponent';
+import 'reakit-system/createHook';
+import 'reakit-utils/shallowEqual';
+import 'react';
+import 'reakit-utils/useForkRef';
+import 'reakit-utils/isButton';
+import 'reakit-warning';
+import 'reakit-utils/useLiveRef';
+import 'reakit-utils/isSelfTarget';
+import 'reakit-utils/useIsomorphicEffect';
+import 'reakit-utils/hasFocusWithin';
+import 'reakit-utils/isPortalEvent';
+import 'reakit-utils/dom';
+import 'reakit-utils/tabbable';
+import '../Role/Role.js';
+import '../Tabbable/Tabbable.js';
+import '../Clickable/Clickable.js';
+import '../Button/Button.js';
+import 'reakit-utils/removeIndexFromArray';
+import 'reakit-utils/createEvent';
+import '../Checkbox/Checkbox.js';
+import 'reakit-utils/useSealedState';
+import 'reakit-utils/useUpdateEffect';
+import 'reakit-system/useCreateElement';
+import 'reakit-utils/getDocument';
+import 'reakit-utils/fireBlurEvent';
+import 'reakit-utils/fireKeyboardEvent';
+import 'reakit-utils/canUseDOM';
+import 'reakit-utils/getNextActiveElementOnBlur';
+import '../reverse-30eaa122.js';
+import '../getCurrentId-5aa9849e.js';
+import '../findEnabledItemById-8ddca752.js';
+import '../__keys-6742f591.js';
+import '../userFocus-e16425e3.js';
+import '../Composite/Composite.js';
+import 'reakit-utils/isTextField';
+import 'reakit-utils/ensureFocus';
+import '../Id/IdProvider.js';
+import '../Id/Id.js';
+import 'reakit-utils/fireEvent';
+import '../setTextFieldValue-0a221f4e.js';
+import '../Composite/CompositeItem.js';
+import 'reakit-utils/applyState';
+import '../Id/IdState.js';
+import '../Composite/CompositeState.js';
+import '@popperjs/core';
+import '../Disclosure/DisclosureState.js';
+import '../Dialog/DialogState.js';
+import '../Popover/PopoverState.js';
+import '../__keys-e6a5cfbe.js';
+import '../Disclosure/DisclosureContent.js';
+import 'react-dom';
+import '../Portal/Portal.js';
+import 'reakit-utils/removeItemFromArray';
+import '../MenuContext-6af6cf92.js';
+import '../Dialog/Dialog.js';
+import 'body-scroll-lock';
+import 'reakit-utils/closest';
+import 'reakit-utils/getActiveElement';
+import 'reakit-utils/contains';
+import '../DialogBackdropContext-8775f78b.js';
+import 'reakit-utils/isEmpty';
+import '../__keys-ed7b48af.js';
+import '../__keys-26bb1730.js';
+import '../Popover/Popover.js';
+import '../Disclosure/Disclosure.js';
+import '../Dialog/DialogDisclosure.js';
+import 'reakit-warning/warning';
+import '../__keys-d251e56b.js';
+import '../Radio/Radio.js';
+export { MenuBar, useMenuBar } from './MenuBar.js';
+import '../__keys-f74df4e0.js';
+export { Menu, useMenu } from './Menu.js';
+import '../Popover/PopoverArrow.js';
+export { MenuArrow, useMenuArrow } from './MenuArrow.js';
+export { useMenuBarState } from './MenuBarState.js';
+import '../Popover/PopoverDisclosure.js';
+import '../findVisibleSubmenu-1553e354.js';
+export { MenuButton, useMenuButton } from './MenuButton.js';
+export { MenuDisclosure, useMenuDisclosure } from './MenuDisclosure.js';
+export { MenuGroup, useMenuGroup } from './MenuGroup.js';
+export { MenuItem, useMenuItem } from './MenuItem.js';
+export { MenuItemCheckbox, useMenuItemCheckbox } from './MenuItemCheckbox.js';
+export { MenuItemRadio, useMenuItemRadio } from './MenuItemRadio.js';
+import '../Separator/Separator.js';
+export { MenuSeparator, useMenuSeparator } from './MenuSeparator.js';
+export { useMenuState } from './MenuState.js';