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/lib/Composite/Composite.js

@@ -0,0 +1,363 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_rollupPluginBabelHelpers-8f9a8751.js');
+var createComponent = require('reakit-system/createComponent');
+var createHook = require('reakit-system/createHook');
+require('reakit-utils/shallowEqual');
+var React = require('react');
+var useForkRef = require('reakit-utils/useForkRef');
+require('reakit-utils/isButton');
+var reakitWarning = require('reakit-warning');
+var useLiveRef = require('reakit-utils/useLiveRef');
+var isSelfTarget = require('reakit-utils/isSelfTarget');
+require('reakit-utils/useIsomorphicEffect');
+require('reakit-utils/hasFocusWithin');
+require('reakit-utils/isPortalEvent');
+require('reakit-utils/dom');
+require('reakit-utils/tabbable');
+var Role_Role = require('../Role/Role.js');
+var Tabbable_Tabbable = require('../Tabbable/Tabbable.js');
+var useCreateElement = require('reakit-system/useCreateElement');
+var getDocument = require('reakit-utils/getDocument');
+var fireBlurEvent = require('reakit-utils/fireBlurEvent');
+var fireKeyboardEvent = require('reakit-utils/fireKeyboardEvent');
+var canUseDOM = require('reakit-utils/canUseDOM');
+var getNextActiveElementOnBlur = require('reakit-utils/getNextActiveElementOnBlur');
+var reverse = require('../reverse-4756a49e.js');
+var getCurrentId = require('../getCurrentId-eade2850.js');
+var findEnabledItemById = require('../findEnabledItemById-03112678.js');
+var __keys = require('../__keys-3b597476.js');
+var userFocus = require('../userFocus-0afea51a.js');
+
+var isIE11 = canUseDOM.canUseDOM && "msCrypto" in window;
+
+function canProxyKeyboardEvent(event) {
+  if (!isSelfTarget.isSelfTarget(event)) return false;
+  if (event.metaKey) return false;
+  if (event.key === "Tab") return false;
+  return true;
+}
+
+function useKeyboardEventProxy(virtual, currentItem, htmlEventHandler) {
+  var eventHandlerRef = useLiveRef.useLiveRef(htmlEventHandler);
+  return React.useCallback(function (event) {
+    var _eventHandlerRef$curr;
+
+    (_eventHandlerRef$curr = eventHandlerRef.current) === null || _eventHandlerRef$curr === void 0 ? void 0 : _eventHandlerRef$curr.call(eventHandlerRef, event);
+    if (event.defaultPrevented) return;
+
+    if (virtual && canProxyKeyboardEvent(event)) {
+      var currentElement = currentItem === null || currentItem === void 0 ? void 0 : currentItem.ref.current;
+
+      if (currentElement) {
+        if (!fireKeyboardEvent.fireKeyboardEvent(currentElement, event.type, event)) {
+          event.preventDefault();
+        } // The event will be triggered on the composite item and then
+        // propagated up to this composite element again, so we can pretend
+        // that it wasn't called on this component in the first place.
+
+
+        if (event.currentTarget.contains(currentElement)) {
+          event.stopPropagation();
+        }
+      }
+    }
+  }, [virtual, currentItem]);
+} // istanbul ignore next
+
+
+function useActiveElementRef(elementRef) {
+  var activeElementRef = React.useRef(null);
+  React.useEffect(function () {
+    var document = getDocument.getDocument(elementRef.current);
+
+    var onFocus = function onFocus(event) {
+      var target = event.target;
+      activeElementRef.current = target;
+    };
+
+    document.addEventListener("focus", onFocus, true);
+    return function () {
+      document.removeEventListener("focus", onFocus, true);
+    };
+  }, []);
+  return activeElementRef;
+}
+
+function findFirstEnabledItemInTheLastRow(items) {
+  return getCurrentId.findFirstEnabledItem(reverse.flatten(reverse.reverse(reverse.groupItems(items))));
+}
+
+function isItem(items, element) {
+  return items === null || items === void 0 ? void 0 : items.some(function (item) {
+    return !!element && item.ref.current === element;
+  });
+}
+
+function useScheduleUserFocus(currentItem) {
+  var currentItemRef = useLiveRef.useLiveRef(currentItem);
+
+  var _React$useReducer = React.useReducer(function (n) {
+    return n + 1;
+  }, 0),
+      scheduled = _React$useReducer[0],
+      schedule = _React$useReducer[1];
+
+  React.useEffect(function () {
+    var _currentItemRef$curre;
+
+    var currentElement = (_currentItemRef$curre = currentItemRef.current) === null || _currentItemRef$curre === void 0 ? void 0 : _currentItemRef$curre.ref.current;
+
+    if (scheduled && currentElement) {
+      userFocus.userFocus(currentElement);
+    }
+  }, [scheduled]);
+  return schedule;
+}
+
+var useComposite = createHook.createHook({
+  name: "Composite",
+  compose: [Tabbable_Tabbable.useTabbable],
+  keys: __keys.COMPOSITE_KEYS,
+  useOptions: function useOptions(options) {
+    return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, options), {}, {
+      currentId: getCurrentId.getCurrentId(options)
+    });
+  },
+  useProps: function useProps(options, _ref) {
+    var htmlRef = _ref.ref,
+        htmlOnFocusCapture = _ref.onFocusCapture,
+        htmlOnFocus = _ref.onFocus,
+        htmlOnBlurCapture = _ref.onBlurCapture,
+        htmlOnKeyDown = _ref.onKeyDown,
+        htmlOnKeyDownCapture = _ref.onKeyDownCapture,
+        htmlOnKeyUpCapture = _ref.onKeyUpCapture,
+        htmlProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_ref, ["ref", "onFocusCapture", "onFocus", "onBlurCapture", "onKeyDown", "onKeyDownCapture", "onKeyUpCapture"]);
+
+    var ref = React.useRef(null);
+    var currentItem = findEnabledItemById.findEnabledItemById(options.items, options.currentId);
+    var previousElementRef = React.useRef(null);
+    var onFocusCaptureRef = useLiveRef.useLiveRef(htmlOnFocusCapture);
+    var onFocusRef = useLiveRef.useLiveRef(htmlOnFocus);
+    var onBlurCaptureRef = useLiveRef.useLiveRef(htmlOnBlurCapture);
+    var onKeyDownRef = useLiveRef.useLiveRef(htmlOnKeyDown);
+    var scheduleUserFocus = useScheduleUserFocus(currentItem); // IE 11 doesn't support event.relatedTarget, so we use the active element
+    // ref instead.
+
+    var activeElementRef = isIE11 ? useActiveElementRef(ref) : undefined;
+    React.useEffect(function () {
+      var element = ref.current;
+
+      if (options.unstable_moves && !currentItem) {
+        process.env.NODE_ENV !== "production" ? reakitWarning.warning(!element, "Can't focus composite component because `ref` wasn't passed to component.", "See https://reakit.io/docs/composite") : void 0; // If composite.move(null) has been called, the composite container
+        // will receive focus.
+
+        element === null || element === void 0 ? void 0 : element.focus();
+      }
+    }, [options.unstable_moves, currentItem]);
+    var onKeyDownCapture = useKeyboardEventProxy(options.unstable_virtual, currentItem, htmlOnKeyDownCapture);
+    var onKeyUpCapture = useKeyboardEventProxy(options.unstable_virtual, currentItem, htmlOnKeyUpCapture);
+    var onFocusCapture = React.useCallback(function (event) {
+      var _onFocusCaptureRef$cu;
+
+      (_onFocusCaptureRef$cu = onFocusCaptureRef.current) === null || _onFocusCaptureRef$cu === void 0 ? void 0 : _onFocusCaptureRef$cu.call(onFocusCaptureRef, event);
+      if (event.defaultPrevented) return;
+      if (!options.unstable_virtual) return; // IE11 doesn't support event.relatedTarget, so we use the active
+      // element ref instead.
+
+      var previousActiveElement = (activeElementRef === null || activeElementRef === void 0 ? void 0 : activeElementRef.current) || event.relatedTarget;
+      var previousActiveElementWasItem = isItem(options.items, previousActiveElement);
+
+      if (isSelfTarget.isSelfTarget(event) && previousActiveElementWasItem) {
+        // Composite has been focused as a result of an item receiving focus.
+        // The composite item will move focus back to the composite
+        // container. In this case, we don't want to propagate this
+        // additional event nor call the onFocus handler passed to
+        // <Composite onFocus={...} />.
+        event.stopPropagation(); // We keep track of the previous active item element so we can
+        // manually fire a blur event on it later when the focus is moved to
+        // another item on the onBlurCapture event below.
+
+        previousElementRef.current = previousActiveElement;
+      }
+    }, [options.unstable_virtual, options.items]);
+    var onFocus = React.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 (options.unstable_virtual) {
+        if (isSelfTarget.isSelfTarget(event)) {
+          // This means that the composite element has been focused while the
+          // composite item has not. For example, by clicking on the
+          // composite element without touching any item, or by tabbing into
+          // the composite element. In this case, we want to trigger focus on
+          // the item, just like it would happen with roving tabindex.
+          // When it receives focus, the composite item will put focus back
+          // on the composite element, in which case hasItemWithFocus will be
+          // true.
+          scheduleUserFocus();
+        }
+      } else if (isSelfTarget.isSelfTarget(event)) {
+        var _options$setCurrentId;
+
+        // When the roving tabindex composite gets intentionally focused (for
+        // example, by clicking directly on it, and not on an item), we make
+        // sure to set the current id to null (which means the composite
+        // itself is focused).
+        (_options$setCurrentId = options.setCurrentId) === null || _options$setCurrentId === void 0 ? void 0 : _options$setCurrentId.call(options, null);
+      }
+    }, [options.unstable_virtual, options.setCurrentId]);
+    var onBlurCapture = React.useCallback(function (event) {
+      var _onBlurCaptureRef$cur;
+
+      (_onBlurCaptureRef$cur = onBlurCaptureRef.current) === null || _onBlurCaptureRef$cur === void 0 ? void 0 : _onBlurCaptureRef$cur.call(onBlurCaptureRef, event);
+      if (event.defaultPrevented) return;
+      if (!options.unstable_virtual) return; // When virtual is set to true, we move focus from the composite
+      // container (this component) to the composite item that is being
+      // selected. Then we move focus back to the composite container. This
+      // is so we can provide the same API as the roving tabindex method,
+      // which means people can attach onFocus/onBlur handlers on the
+      // CompositeItem component regardless of whether it's virtual or not.
+      // This sequence of blurring and focusing items and composite may be
+      // confusing, so we ignore intermediate focus and blurs by stopping its
+      // propagation and not calling the passed onBlur handler (htmlOnBlur).
+
+      var currentElement = (currentItem === null || currentItem === void 0 ? void 0 : currentItem.ref.current) || null;
+      var nextActiveElement = getNextActiveElementOnBlur.getNextActiveElementOnBlur(event);
+      var nextActiveElementIsItem = isItem(options.items, nextActiveElement);
+
+      if (isSelfTarget.isSelfTarget(event) && nextActiveElementIsItem) {
+        // This is an intermediate blur event: blurring the composite
+        // container to focus an item (nextActiveElement).
+        if (nextActiveElement === currentElement) {
+          // The next active element will be the same as the current item in
+          // the state in two scenarios:
+          //   - Moving focus with keyboard: the state is updated before the
+          // blur event is triggered, so here the current item is already
+          // pointing to the next active element.
+          //   - Clicking on the current active item with a pointer: this
+          // will trigger blur on the composite element and then the next
+          // active element will be the same as the current item. Clicking on
+          // an item other than the current one doesn't end up here as the
+          // currentItem state will be updated only after it.
+          if (previousElementRef.current && previousElementRef.current !== nextActiveElement) {
+            // If there's a previous active item and it's not a click action,
+            // then we fire a blur event on it so it will work just like if
+            // it had DOM focus before (like when using roving tabindex).
+            fireBlurEvent.fireBlurEvent(previousElementRef.current, event);
+          }
+        } else if (currentElement) {
+          // This will be true when the next active element is not the
+          // current element, but there's a current item. This will only
+          // happen when clicking with a pointer on a different item, when
+          // there's already an item selected, in which case currentElement
+          // is the item that is getting blurred, and nextActiveElement is
+          // the item that is being clicked.
+          fireBlurEvent.fireBlurEvent(currentElement, event);
+        } // We want to ignore intermediate blur events, so we stop its
+        // propagation and return early so onFocus will not be called.
+
+
+        event.stopPropagation();
+      } else {
+        var targetIsItem = isItem(options.items, event.target);
+
+        if (!targetIsItem && currentElement) {
+          // If target is not a composite item, it may be the composite
+          // element itself (isSelfTarget) or a tabbable element inside the
+          // composite widget. This may be triggered by clicking outside the
+          // composite widget or by tabbing out of it. In either cases we
+          // want to fire a blur event on the current item.
+          fireBlurEvent.fireBlurEvent(currentElement, event);
+        }
+      }
+    }, [options.unstable_virtual, options.items, currentItem]);
+    var onKeyDown = React.useCallback(function (event) {
+      var _onKeyDownRef$current, _options$groups;
+
+      (_onKeyDownRef$current = onKeyDownRef.current) === null || _onKeyDownRef$current === void 0 ? void 0 : _onKeyDownRef$current.call(onKeyDownRef, event);
+      if (event.defaultPrevented) return;
+      if (options.currentId !== null) return;
+      if (!isSelfTarget.isSelfTarget(event)) return;
+      var isVertical = options.orientation !== "horizontal";
+      var isHorizontal = options.orientation !== "vertical";
+      var isGrid = !!((_options$groups = options.groups) !== null && _options$groups !== void 0 && _options$groups.length);
+
+      var up = function up() {
+        if (isGrid) {
+          var item = findFirstEnabledItemInTheLastRow(options.items);
+
+          if (item !== null && item !== void 0 && item.id) {
+            var _options$move;
+
+            (_options$move = options.move) === null || _options$move === void 0 ? void 0 : _options$move.call(options, item.id);
+          }
+        } else {
+          var _options$last;
+
+          (_options$last = options.last) === null || _options$last === void 0 ? void 0 : _options$last.call(options);
+        }
+      };
+
+      var keyMap = {
+        ArrowUp: (isGrid || isVertical) && up,
+        ArrowRight: (isGrid || isHorizontal) && options.first,
+        ArrowDown: (isGrid || isVertical) && options.first,
+        ArrowLeft: (isGrid || isHorizontal) && options.last,
+        Home: options.first,
+        End: options.last,
+        PageUp: options.first,
+        PageDown: options.last
+      };
+      var action = keyMap[event.key];
+
+      if (action) {
+        event.preventDefault();
+        action();
+      }
+    }, [options.currentId, options.orientation, options.groups, options.items, options.move, options.last, options.first]);
+    return _rollupPluginBabelHelpers._objectSpread2({
+      ref: useForkRef.useForkRef(ref, htmlRef),
+      id: options.baseId,
+      onFocus: onFocus,
+      onFocusCapture: onFocusCapture,
+      onBlurCapture: onBlurCapture,
+      onKeyDownCapture: onKeyDownCapture,
+      onKeyDown: onKeyDown,
+      onKeyUpCapture: onKeyUpCapture,
+      "aria-activedescendant": options.unstable_virtual ? (currentItem === null || currentItem === void 0 ? void 0 : currentItem.id) || undefined : undefined
+    }, htmlProps);
+  },
+  useComposeProps: function useComposeProps(options, htmlProps) {
+    htmlProps = Role_Role.useRole(options, htmlProps, true);
+    var tabbableHTMLProps = Tabbable_Tabbable.useTabbable(options, htmlProps, true);
+
+    if (options.unstable_virtual || options.currentId === null) {
+      // Composite will only be tabbable by default if the focus is managed
+      // using aria-activedescendant, which requires DOM focus on the container
+      // element (the composite)
+      return _rollupPluginBabelHelpers._objectSpread2({
+        tabIndex: 0
+      }, tabbableHTMLProps);
+    }
+
+    return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, htmlProps), {}, {
+      ref: tabbableHTMLProps.ref
+    });
+  }
+});
+var Composite = createComponent.createComponent({
+  as: "div",
+  useHook: useComposite,
+  useCreateElement: function useCreateElement$1(type, props, children) {
+    process.env.NODE_ENV !== "production" ? reakitWarning.useWarning(!props["aria-label"] && !props["aria-labelledby"], "You should provide either `aria-label` or `aria-labelledby` props.", "See https://reakit.io/docs/composite") : void 0;
+    return useCreateElement.useCreateElement(type, props, children);
+  }
+});
+
+exports.Composite = Composite;
+exports.useComposite = useComposite;

node_modules/reakit/lib/Composite/CompositeGroup.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_rollupPluginBabelHelpers-8f9a8751.js');
+var createComponent = require('reakit-system/createComponent');
+var createHook = require('reakit-system/createHook');
+require('reakit-utils/shallowEqual');
+var React = require('react');
+var useForkRef = require('reakit-utils/useForkRef');
+var useIsomorphicEffect = require('reakit-utils/useIsomorphicEffect');
+require('../Role/Role.js');
+var findEnabledItemById = require('../findEnabledItemById-03112678.js');
+var __keys = require('../__keys-3b597476.js');
+require('../Id/IdProvider.js');
+var Id_Id = require('../Id/Id.js');
+var Group_Group = require('../Group/Group.js');
+
+var useCompositeGroup = createHook.createHook({
+  name: "CompositeGroup",
+  compose: [Group_Group.useGroup, Id_Id.unstable_useId],
+  keys: __keys.COMPOSITE_GROUP_KEYS,
+  propsAreEqual: function propsAreEqual(prev, next) {
+    if (!next.id || prev.id !== next.id) {
+      return Group_Group.useGroup.unstable_propsAreEqual(prev, next);
+    }
+
+    var prevCurrentId = prev.currentId,
+        prevMoves = prev.unstable_moves,
+        prevProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(prev, ["currentId", "unstable_moves"]);
+
+    var nextCurrentId = next.currentId,
+        nextMoves = next.unstable_moves,
+        nextProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(next, ["currentId", "unstable_moves"]);
+
+    if (prev.items && next.items) {
+      var prevCurrentItem = findEnabledItemById.findEnabledItemById(prev.items, prevCurrentId);
+      var nextCurrentItem = findEnabledItemById.findEnabledItemById(next.items, nextCurrentId);
+      var prevGroupId = prevCurrentItem === null || prevCurrentItem === void 0 ? void 0 : prevCurrentItem.groupId;
+      var nextGroupId = nextCurrentItem === null || nextCurrentItem === void 0 ? void 0 : nextCurrentItem.groupId;
+
+      if (next.id === nextGroupId || next.id === prevGroupId) {
+        return false;
+      }
+    }
+
+    return Group_Group.useGroup.unstable_propsAreEqual(prevProps, nextProps);
+  },
+  useProps: function useProps(options, _ref) {
+    var htmlRef = _ref.ref,
+        htmlProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_ref, ["ref"]);
+
+    var ref = React.useRef(null);
+    var id = options.id; // We need this to be called before CompositeItems' register
+
+    useIsomorphicEffect.useIsomorphicEffect(function () {
+      var _options$registerGrou;
+
+      if (!id) return undefined;
+      (_options$registerGrou = options.registerGroup) === null || _options$registerGrou === void 0 ? void 0 : _options$registerGrou.call(options, {
+        id: id,
+        ref: ref
+      });
+      return function () {
+        var _options$unregisterGr;
+
+        (_options$unregisterGr = options.unregisterGroup) === null || _options$unregisterGr === void 0 ? void 0 : _options$unregisterGr.call(options, id);
+      };
+    }, [id, options.registerGroup, options.unregisterGroup]);
+    return _rollupPluginBabelHelpers._objectSpread2({
+      ref: useForkRef.useForkRef(ref, htmlRef)
+    }, htmlProps);
+  }
+});
+var CompositeGroup = createComponent.createComponent({
+  as: "div",
+  useHook: useCompositeGroup
+});
+
+exports.CompositeGroup = CompositeGroup;
+exports.useCompositeGroup = useCompositeGroup;

node_modules/reakit/lib/Composite/CompositeItem.js

@@ -0,0 +1,320 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_rollupPluginBabelHelpers-8f9a8751.js');
+var createComponent = require('reakit-system/createComponent');
+var createHook = require('reakit-system/createHook');
+require('reakit-utils/shallowEqual');
+var React = require('react');
+var useForkRef = require('reakit-utils/useForkRef');
+require('reakit-utils/isButton');
+var reakitWarning = require('reakit-warning');
+var useLiveRef = require('reakit-utils/useLiveRef');
+var isSelfTarget = require('reakit-utils/isSelfTarget');
+require('reakit-utils/useIsomorphicEffect');
+var hasFocusWithin = require('reakit-utils/hasFocusWithin');
+var isPortalEvent = require('reakit-utils/isPortalEvent');
+require('reakit-utils/dom');
+require('reakit-utils/tabbable');
+require('../Role/Role.js');
+require('../Tabbable/Tabbable.js');
+var Clickable_Clickable = require('../Clickable/Clickable.js');
+var getDocument = require('reakit-utils/getDocument');
+var getCurrentId = require('../getCurrentId-eade2850.js');
+var __keys = require('../__keys-3b597476.js');
+var userFocus = require('../userFocus-0afea51a.js');
+var isTextField = require('reakit-utils/isTextField');
+var ensureFocus = require('reakit-utils/ensureFocus');
+require('../Id/IdProvider.js');
+var Id_Id = require('../Id/Id.js');
+require('reakit-utils/fireEvent');
+var setTextFieldValue = require('../setTextFieldValue-b0584ae1.js');
+
+function getWidget(itemElement) {
+  return itemElement.querySelector("[data-composite-item-widget]");
+}
+
+function useItem(options) {
+  return React.useMemo(function () {
+    var _options$items;
+
+    return (_options$items = options.items) === null || _options$items === void 0 ? void 0 : _options$items.find(function (item) {
+      return options.id && item.id === options.id;
+    });
+  }, [options.items, options.id]);
+}
+
+function targetIsAnotherItem(event, items) {
+  if (isSelfTarget.isSelfTarget(event)) return false;
+
+  for (var _iterator = _rollupPluginBabelHelpers._createForOfIteratorHelperLoose(items), _step; !(_step = _iterator()).done;) {
+    var item = _step.value;
+
+    if (item.ref.current === event.target) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+var useCompositeItem = createHook.createHook({
+  name: "CompositeItem",
+  compose: [Clickable_Clickable.useClickable, Id_Id.unstable_useId],
+  keys: __keys.COMPOSITE_ITEM_KEYS,
+  propsAreEqual: function propsAreEqual(prev, next) {
+    if (!next.id || prev.id !== next.id) {
+      return Clickable_Clickable.useClickable.unstable_propsAreEqual(prev, next);
+    }
+
+    var prevCurrentId = prev.currentId,
+        prevMoves = prev.unstable_moves,
+        prevProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(prev, ["currentId", "unstable_moves"]);
+
+    var nextCurrentId = next.currentId,
+        nextMoves = next.unstable_moves,
+        nextProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(next, ["currentId", "unstable_moves"]);
+
+    if (nextCurrentId !== prevCurrentId) {
+      if (next.id === nextCurrentId || next.id === prevCurrentId) {
+        return false;
+      }
+    } else if (prevMoves !== nextMoves) {
+      return false;
+    }
+
+    return Clickable_Clickable.useClickable.unstable_propsAreEqual(prevProps, nextProps);
+  },
+  useOptions: function useOptions(options) {
+    return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, options), {}, {
+      id: options.id,
+      currentId: getCurrentId.getCurrentId(options),
+      unstable_clickOnSpace: options.unstable_hasActiveWidget ? false : options.unstable_clickOnSpace
+    });
+  },
+  useProps: function useProps(options, _ref) {
+    var _options$items2;
+
+    var htmlRef = _ref.ref,
+        _ref$tabIndex = _ref.tabIndex,
+        htmlTabIndex = _ref$tabIndex === void 0 ? 0 : _ref$tabIndex,
+        htmlOnMouseDown = _ref.onMouseDown,
+        htmlOnFocus = _ref.onFocus,
+        htmlOnBlurCapture = _ref.onBlurCapture,
+        htmlOnKeyDown = _ref.onKeyDown,
+        htmlOnClick = _ref.onClick,
+        htmlProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_ref, ["ref", "tabIndex", "onMouseDown", "onFocus", "onBlurCapture", "onKeyDown", "onClick"]);
+
+    var ref = React.useRef(null);
+    var id = options.id;
+    var trulyDisabled = options.disabled && !options.focusable;
+    var isCurrentItem = options.currentId === id;
+    var isCurrentItemRef = useLiveRef.useLiveRef(isCurrentItem);
+    var hasFocusedComposite = React.useRef(false);
+    var item = useItem(options);
+    var onMouseDownRef = useLiveRef.useLiveRef(htmlOnMouseDown);
+    var onFocusRef = useLiveRef.useLiveRef(htmlOnFocus);
+    var onBlurCaptureRef = useLiveRef.useLiveRef(htmlOnBlurCapture);
+    var onKeyDownRef = useLiveRef.useLiveRef(htmlOnKeyDown);
+    var onClickRef = useLiveRef.useLiveRef(htmlOnClick);
+    var shouldTabIndex = !options.unstable_virtual && !options.unstable_hasActiveWidget && isCurrentItem || // We don't want to set tabIndex="-1" when using CompositeItem as a
+    // standalone component, without state props.
+    !((_options$items2 = options.items) !== null && _options$items2 !== void 0 && _options$items2.length);
+    React.useEffect(function () {
+      var _options$registerItem;
+
+      if (!id) return undefined;
+      (_options$registerItem = options.registerItem) === null || _options$registerItem === void 0 ? void 0 : _options$registerItem.call(options, {
+        id: id,
+        ref: ref,
+        disabled: !!trulyDisabled
+      });
+      return function () {
+        var _options$unregisterIt;
+
+        (_options$unregisterIt = options.unregisterItem) === null || _options$unregisterIt === void 0 ? void 0 : _options$unregisterIt.call(options, id);
+      };
+    }, [id, trulyDisabled, options.registerItem, options.unregisterItem]);
+    React.useEffect(function () {
+      var element = ref.current;
+
+      if (!element) {
+        process.env.NODE_ENV !== "production" ? reakitWarning.warning(true, "Can't focus composite item component because `ref` wasn't passed to component.", "See https://reakit.io/docs/composite") : void 0;
+        return;
+      } // `moves` will be incremented whenever next, previous, up, down, first,
+      // last or move have been called. This means that the composite item will
+      // be focused whenever some of these functions are called. We're using
+      // isCurrentItemRef instead of isCurrentItem because we don't want to
+      // focus the item if isCurrentItem changes (and options.moves doesn't).
+
+
+      if (options.unstable_moves && isCurrentItemRef.current) {
+        userFocus.userFocus(element);
+      }
+    }, [options.unstable_moves]);
+    var onMouseDown = React.useCallback(function (event) {
+      var _onMouseDownRef$curre;
+
+      (_onMouseDownRef$curre = onMouseDownRef.current) === null || _onMouseDownRef$curre === void 0 ? void 0 : _onMouseDownRef$curre.call(onMouseDownRef, event);
+      userFocus.setUserFocus(event.currentTarget, true);
+    }, []);
+    var onFocus = React.useCallback(function (event) {
+      var _onFocusRef$current, _options$setCurrentId;
+
+      var shouldFocusComposite = userFocus.hasUserFocus(event.currentTarget);
+      userFocus.setUserFocus(event.currentTarget, false);
+      (_onFocusRef$current = onFocusRef.current) === null || _onFocusRef$current === void 0 ? void 0 : _onFocusRef$current.call(onFocusRef, event);
+      if (event.defaultPrevented) return;
+      if (isPortalEvent.isPortalEvent(event)) return;
+      if (!id) return;
+      if (targetIsAnotherItem(event, options.items)) return;
+      (_options$setCurrentId = options.setCurrentId) === null || _options$setCurrentId === void 0 ? void 0 : _options$setCurrentId.call(options, id); // When using aria-activedescendant, we want to make sure that the
+      // composite container receives focus, not the composite item.
+      // But we don't want to do this if the target is another focusable
+      // element inside the composite item, such as CompositeItemWidget.
+
+      if (shouldFocusComposite && options.unstable_virtual && options.baseId && isSelfTarget.isSelfTarget(event)) {
+        var target = event.target;
+        var composite = getDocument.getDocument(target).getElementById(options.baseId);
+
+        if (composite) {
+          hasFocusedComposite.current = true;
+          ensureFocus.ensureFocus(composite);
+        }
+      }
+    }, [id, options.items, options.setCurrentId, options.unstable_virtual, options.baseId]);
+    var onBlurCapture = React.useCallback(function (event) {
+      var _onBlurCaptureRef$cur;
+
+      (_onBlurCaptureRef$cur = onBlurCaptureRef.current) === null || _onBlurCaptureRef$cur === void 0 ? void 0 : _onBlurCaptureRef$cur.call(onBlurCaptureRef, event);
+      if (event.defaultPrevented) return;
+
+      if (options.unstable_virtual && hasFocusedComposite.current) {
+        // When hasFocusedComposite is true, composite has been focused right
+        // after focusing this item. This is an intermediate blur event, so
+        // we ignore it.
+        hasFocusedComposite.current = false;
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    }, [options.unstable_virtual]);
+    var onKeyDown = React.useCallback(function (event) {
+      var _onKeyDownRef$current;
+
+      if (!isSelfTarget.isSelfTarget(event)) return;
+      var isVertical = options.orientation !== "horizontal";
+      var isHorizontal = options.orientation !== "vertical";
+      var isGrid = !!(item !== null && item !== void 0 && item.groupId);
+      var keyMap = {
+        ArrowUp: (isGrid || isVertical) && options.up,
+        ArrowRight: (isGrid || isHorizontal) && options.next,
+        ArrowDown: (isGrid || isVertical) && options.down,
+        ArrowLeft: (isGrid || isHorizontal) && options.previous,
+        Home: function Home() {
+          if (!isGrid || event.ctrlKey) {
+            var _options$first;
+
+            (_options$first = options.first) === null || _options$first === void 0 ? void 0 : _options$first.call(options);
+          } else {
+            var _options$previous;
+
+            (_options$previous = options.previous) === null || _options$previous === void 0 ? void 0 : _options$previous.call(options, true);
+          }
+        },
+        End: function End() {
+          if (!isGrid || event.ctrlKey) {
+            var _options$last;
+
+            (_options$last = options.last) === null || _options$last === void 0 ? void 0 : _options$last.call(options);
+          } else {
+            var _options$next;
+
+            (_options$next = options.next) === null || _options$next === void 0 ? void 0 : _options$next.call(options, true);
+          }
+        },
+        PageUp: function PageUp() {
+          if (isGrid) {
+            var _options$up;
+
+            (_options$up = options.up) === null || _options$up === void 0 ? void 0 : _options$up.call(options, true);
+          } else {
+            var _options$first2;
+
+            (_options$first2 = options.first) === null || _options$first2 === void 0 ? void 0 : _options$first2.call(options);
+          }
+        },
+        PageDown: function PageDown() {
+          if (isGrid) {
+            var _options$down;
+
+            (_options$down = options.down) === null || _options$down === void 0 ? void 0 : _options$down.call(options, true);
+          } else {
+            var _options$last2;
+
+            (_options$last2 = options.last) === null || _options$last2 === void 0 ? void 0 : _options$last2.call(options);
+          }
+        }
+      };
+      var action = keyMap[event.key];
+
+      if (action) {
+        event.preventDefault();
+        action();
+        return;
+      }
+
+      (_onKeyDownRef$current = onKeyDownRef.current) === null || _onKeyDownRef$current === void 0 ? void 0 : _onKeyDownRef$current.call(onKeyDownRef, event);
+      if (event.defaultPrevented) return;
+
+      if (event.key.length === 1 && event.key !== " ") {
+        var widget = getWidget(event.currentTarget);
+
+        if (widget && isTextField.isTextField(widget)) {
+          widget.focus();
+          setTextFieldValue.setTextFieldValue(widget, "");
+        }
+      } else if (event.key === "Delete" || event.key === "Backspace") {
+        var _widget = getWidget(event.currentTarget);
+
+        if (_widget && isTextField.isTextField(_widget)) {
+          event.preventDefault();
+          setTextFieldValue.setTextFieldValue(_widget, "");
+        }
+      }
+    }, [options.orientation, item, options.up, options.next, options.down, options.previous, options.first, options.last]);
+    var onClick = React.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;
+      var element = event.currentTarget;
+      var widget = getWidget(element);
+
+      if (widget && !hasFocusWithin.hasFocusWithin(widget)) {
+        // If there's a widget inside the composite item, we make sure it's
+        // focused when pressing enter, space or clicking on the composite item.
+        widget.focus();
+      }
+    }, []);
+    return _rollupPluginBabelHelpers._objectSpread2({
+      ref: useForkRef.useForkRef(ref, htmlRef),
+      id: id,
+      tabIndex: shouldTabIndex ? htmlTabIndex : -1,
+      "aria-selected": options.unstable_virtual && isCurrentItem ? true : undefined,
+      onMouseDown: onMouseDown,
+      onFocus: onFocus,
+      onBlurCapture: onBlurCapture,
+      onKeyDown: onKeyDown,
+      onClick: onClick
+    }, htmlProps);
+  }
+});
+var CompositeItem = createComponent.createComponent({
+  as: "button",
+  memo: true,
+  useHook: useCompositeItem
+});
+
+exports.CompositeItem = CompositeItem;
+exports.useCompositeItem = useCompositeItem;

node_modules/reakit/lib/Composite/CompositeItemWidget.js

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_rollupPluginBabelHelpers-8f9a8751.js');
+var createComponent = require('reakit-system/createComponent');
+var createHook = require('reakit-system/createHook');
+require('reakit-utils/shallowEqual');
+var React = require('react');
+var useLiveRef = require('reakit-utils/useLiveRef');
+var isSelfTarget = require('reakit-utils/isSelfTarget');
+var Role_Role = require('../Role/Role.js');
+var getDocument = require('reakit-utils/getDocument');
+var __keys = require('../__keys-3b597476.js');
+var isTextField = require('reakit-utils/isTextField');
+require('reakit-utils/fireEvent');
+var setTextFieldValue = require('../setTextFieldValue-b0584ae1.js');
+
+function focusCurrentItem(widget, currentId) {
+  if (currentId) {
+    var _getDocument$getEleme;
+
+    (_getDocument$getEleme = getDocument.getDocument(widget).getElementById(currentId)) === null || _getDocument$getEleme === void 0 ? void 0 : _getDocument$getEleme.focus();
+  }
+}
+
+function getTextFieldValue(element) {
+  return element.value;
+}
+
+var unstable_useCompositeItemWidget = createHook.createHook({
+  name: "CompositeItemWidget",
+  compose: Role_Role.useRole,
+  keys: __keys.COMPOSITE_ITEM_WIDGET_KEYS,
+  useProps: function useProps(options, _ref) {
+    var htmlOnFocus = _ref.onFocus,
+        htmlOnBlur = _ref.onBlur,
+        htmlOnKeyDown = _ref.onKeyDown,
+        htmlProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_ref, ["onFocus", "onBlur", "onKeyDown"]);
+
+    var initialValue = React.useRef("");
+    var onFocusRef = useLiveRef.useLiveRef(htmlOnFocus);
+    var onBlurRef = useLiveRef.useLiveRef(htmlOnBlur);
+    var onKeyDownRef = useLiveRef.useLiveRef(htmlOnKeyDown);
+    var onFocus = React.useCallback(function (event) {
+      var _onFocusRef$current, _options$unstable_set;
+
+      (_onFocusRef$current = onFocusRef.current) === null || _onFocusRef$current === void 0 ? void 0 : _onFocusRef$current.call(onFocusRef, event);
+      (_options$unstable_set = options.unstable_setHasActiveWidget) === null || _options$unstable_set === void 0 ? void 0 : _options$unstable_set.call(options, true);
+
+      if (isTextField.isTextField(event.currentTarget)) {
+        initialValue.current = getTextFieldValue(event.currentTarget);
+      }
+    }, [options.unstable_setHasActiveWidget]);
+    var onBlur = React.useCallback(function (event) {
+      var _onBlurRef$current, _options$unstable_set2;
+
+      (_onBlurRef$current = onBlurRef.current) === null || _onBlurRef$current === void 0 ? void 0 : _onBlurRef$current.call(onBlurRef, event);
+      (_options$unstable_set2 = options.unstable_setHasActiveWidget) === null || _options$unstable_set2 === void 0 ? void 0 : _options$unstable_set2.call(options, false);
+    }, [options.unstable_setHasActiveWidget]);
+    var onKeyDown = React.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 (!isSelfTarget.isSelfTarget(event)) return;
+      if (event.nativeEvent.isComposing) return;
+      var element = event.currentTarget;
+
+      if (event.key === "Enter") {
+        if (isTextField.isTextField(element)) {
+          var isMultilineTextField = element.tagName === "TEXTAREA"; // Make sure we can create new lines using Shift+Enter
+
+          if (isMultilineTextField && event.shiftKey) return; // Make sure it'll not trigger a click on the parent button
+
+          event.preventDefault();
+          focusCurrentItem(element, options.currentId);
+        }
+      } else if (event.key === "Escape") {
+        focusCurrentItem(element, options.currentId);
+
+        if (isTextField.isTextField(element)) {
+          setTextFieldValue.setTextFieldValue(element, initialValue.current);
+        }
+      }
+    }, [options.currentId]);
+    return _rollupPluginBabelHelpers._objectSpread2({
+      tabIndex: options.unstable_hasActiveWidget ? 0 : -1,
+      "data-composite-item-widget": true,
+      onFocus: onFocus,
+      onBlur: onBlur,
+      onKeyDown: onKeyDown
+    }, htmlProps);
+  }
+});
+var unstable_CompositeItemWidget = createComponent.createComponent({
+  as: "div",
+  useHook: unstable_useCompositeItemWidget
+});
+
+exports.unstable_CompositeItemWidget = unstable_CompositeItemWidget;
+exports.unstable_useCompositeItemWidget = unstable_useCompositeItemWidget;

node_modules/reakit/lib/Composite/CompositeState.js

@@ -0,0 +1,939 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_rollupPluginBabelHelpers-8f9a8751.js');
+var React = require('react');
+var useIsomorphicEffect = require('reakit-utils/useIsomorphicEffect');
+var useSealedState = require('reakit-utils/useSealedState');
+var getDocument = require('reakit-utils/getDocument');
+var reverse = require('../reverse-4756a49e.js');
+var getCurrentId = require('../getCurrentId-eade2850.js');
+var findEnabledItemById = require('../findEnabledItemById-03112678.js');
+require('../Id/IdProvider.js');
+var applyState = require('reakit-utils/applyState');
+var Id_IdState = require('../Id/IdState.js');
+
+function isElementPreceding(element1, element2) {
+  return Boolean(element2.compareDocumentPosition(element1) & Node.DOCUMENT_POSITION_PRECEDING);
+}
+
+function findDOMIndex(items, item) {
+  return items.findIndex(function (currentItem) {
+    if (!currentItem.ref.current || !item.ref.current) {
+      return false;
+    }
+
+    return isElementPreceding(item.ref.current, currentItem.ref.current);
+  });
+}
+
+function getMaxLength(rows) {
+  var maxLength = 0;
+
+  for (var _iterator = _rollupPluginBabelHelpers._createForOfIteratorHelperLoose(rows), _step; !(_step = _iterator()).done;) {
+    var length = _step.value.length;
+
+    if (length > maxLength) {
+      maxLength = length;
+    }
+  }
+
+  return maxLength;
+}
+
+/**
+ * Turns [row1, row1, row2, row2] into [row1, row2, row1, row2]
+ */
+
+function verticalizeItems(items) {
+  var groups = reverse.groupItems(items);
+  var maxLength = getMaxLength(groups);
+  var verticalized = [];
+
+  for (var i = 0; i < maxLength; i += 1) {
+    for (var _iterator = _rollupPluginBabelHelpers._createForOfIteratorHelperLoose(groups), _step; !(_step = _iterator()).done;) {
+      var group = _step.value;
+
+      if (group[i]) {
+        verticalized.push(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, group[i]), {}, {
+          // If there's no groupId, it means that it's not a grid composite,
+          // but a single row instead. So, instead of verticalizing it, that
+          // is, assigning a different groupId based on the column index, we
+          // keep it undefined so they will be part of the same group.
+          // It's useful when using up/down on one-dimensional composites.
+          groupId: group[i].groupId ? "" + i : undefined
+        }));
+      }
+    }
+  }
+
+  return verticalized;
+}
+
+function createEmptyItem(groupId) {
+  return {
+    id: "__EMPTY_ITEM__",
+    disabled: true,
+    ref: {
+      current: null
+    },
+    groupId: groupId
+  };
+}
+/**
+ * Turns [[row1, row1], [row2]] into [[row1, row1], [row2, row2]]
+ */
+
+
+function fillGroups(groups, currentId, shift) {
+  var maxLength = getMaxLength(groups);
+
+  for (var _iterator = _rollupPluginBabelHelpers._createForOfIteratorHelperLoose(groups), _step; !(_step = _iterator()).done;) {
+    var group = _step.value;
+
+    for (var i = 0; i < maxLength; i += 1) {
+      var item = group[i];
+
+      if (!item || shift && item.disabled) {
+        var isFrist = i === 0;
+        var previousItem = isFrist && shift ? getCurrentId.findFirstEnabledItem(group) : group[i - 1];
+        group[i] = previousItem && currentId !== (previousItem === null || previousItem === void 0 ? void 0 : previousItem.id) && shift ? previousItem : createEmptyItem(previousItem === null || previousItem === void 0 ? void 0 : previousItem.groupId);
+      }
+    }
+  }
+
+  return groups;
+}
+
+var nullItem = {
+  id: null,
+  ref: {
+    current: null
+  }
+};
+function placeItemsAfter(items, id, shouldInsertNullItem) {
+  var index = items.findIndex(function (item) {
+    return item.id === id;
+  });
+  return [].concat(items.slice(index + 1), shouldInsertNullItem ? [nullItem] : [], items.slice(0, index));
+}
+
+function getItemsInGroup(items, groupId) {
+  return items.filter(function (item) {
+    return item.groupId === groupId;
+  });
+}
+
+var map = {
+  horizontal: "vertical",
+  vertical: "horizontal"
+};
+function getOppositeOrientation(orientation) {
+  return orientation && map[orientation];
+}
+
+function addItemAtIndex(array, item, index) {
+  if (!(index in array)) {
+    return [].concat(array, [item]);
+  }
+
+  return [].concat(array.slice(0, index), [item], array.slice(index));
+}
+
+function sortBasedOnDOMPosition(items) {
+  var pairs = items.map(function (item, index) {
+    return [index, item];
+  });
+  var isOrderDifferent = false;
+  pairs.sort(function (_ref, _ref2) {
+    var indexA = _ref[0],
+        a = _ref[1];
+    var indexB = _ref2[0],
+        b = _ref2[1];
+    var elementA = a.ref.current;
+    var elementB = b.ref.current;
+    if (!elementA || !elementB) return 0; // a before b
+
+    if (isElementPreceding(elementA, elementB)) {
+      if (indexA > indexB) {
+        isOrderDifferent = true;
+      }
+
+      return -1;
+    } // a after b
+
+
+    if (indexA < indexB) {
+      isOrderDifferent = true;
+    }
+
+    return 1;
+  });
+
+  if (isOrderDifferent) {
+    return pairs.map(function (_ref3) {
+      var _ = _ref3[0],
+          item = _ref3[1];
+      return item;
+    });
+  }
+
+  return items;
+}
+
+function setItemsBasedOnDOMPosition(items, setItems) {
+  var sortedItems = sortBasedOnDOMPosition(items);
+
+  if (items !== sortedItems) {
+    setItems(sortedItems);
+  }
+}
+
+function getCommonParent(items) {
+  var _firstItem$ref$curren;
+
+  var firstItem = items[0],
+      nextItems = items.slice(1);
+  var parentElement = firstItem === null || firstItem === void 0 ? void 0 : (_firstItem$ref$curren = firstItem.ref.current) === null || _firstItem$ref$curren === void 0 ? void 0 : _firstItem$ref$curren.parentElement;
+
+  var _loop = function _loop() {
+    var parent = parentElement;
+
+    if (nextItems.every(function (item) {
+      return parent.contains(item.ref.current);
+    })) {
+      return {
+        v: parentElement
+      };
+    }
+
+    parentElement = parentElement.parentElement;
+  };
+
+  while (parentElement) {
+    var _ret = _loop();
+
+    if (typeof _ret === "object") return _ret.v;
+  }
+
+  return getDocument.getDocument(parentElement).body;
+} // istanbul ignore next: JSDOM doesn't support IntersectionObverser
+// See https://github.com/jsdom/jsdom/issues/2032
+
+
+function useIntersectionObserver(items, setItems) {
+  var previousItems = React.useRef([]);
+  React.useEffect(function () {
+    var callback = function callback() {
+      var hasPreviousItems = !!previousItems.current.length; // We don't want to sort items if items have been just registered.
+
+      if (hasPreviousItems) {
+        setItemsBasedOnDOMPosition(items, setItems);
+      }
+
+      previousItems.current = items;
+    };
+
+    var root = getCommonParent(items);
+    var observer = new IntersectionObserver(callback, {
+      root: root
+    });
+
+    for (var _iterator = _rollupPluginBabelHelpers._createForOfIteratorHelperLoose(items), _step; !(_step = _iterator()).done;) {
+      var item = _step.value;
+
+      if (item.ref.current) {
+        observer.observe(item.ref.current);
+      }
+    }
+
+    return function () {
+      observer.disconnect();
+    };
+  }, [items]);
+}
+
+function useTimeoutObserver(items, setItems) {
+  React.useEffect(function () {
+    var callback = function callback() {
+      return setItemsBasedOnDOMPosition(items, setItems);
+    };
+
+    var timeout = setTimeout(callback, 250);
+    return function () {
+      return clearTimeout(timeout);
+    };
+  });
+}
+
+function useSortBasedOnDOMPosition(items, setItems) {
+  if (typeof IntersectionObserver === "function") {
+    useIntersectionObserver(items, setItems);
+  } else {
+    useTimeoutObserver(items, setItems);
+  }
+}
+
+function reducer(state, action) {
+  var virtual = state.unstable_virtual,
+      rtl = state.rtl,
+      orientation = state.orientation,
+      items = state.items,
+      groups = state.groups,
+      currentId = state.currentId,
+      loop = state.loop,
+      wrap = state.wrap,
+      pastIds = state.pastIds,
+      shift = state.shift,
+      moves = state.unstable_moves,
+      includesBaseElement = state.unstable_includesBaseElement,
+      initialVirtual = state.initialVirtual,
+      initialRTL = state.initialRTL,
+      initialOrientation = state.initialOrientation,
+      initialCurrentId = state.initialCurrentId,
+      initialLoop = state.initialLoop,
+      initialWrap = state.initialWrap,
+      initialShift = state.initialShift,
+      hasSetCurrentId = state.hasSetCurrentId;
+
+  switch (action.type) {
+    case "registerGroup":
+      {
+        var _group = action.group; // If there are no groups yet, just add it as the first one
+
+        if (groups.length === 0) {
+          return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+            groups: [_group]
+          });
+        } // Finds the group index based on DOM position
+
+
+        var index = findDOMIndex(groups, _group);
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          groups: addItemAtIndex(groups, _group, index)
+        });
+      }
+
+    case "unregisterGroup":
+      {
+        var _id = action.id;
+        var nextGroups = groups.filter(function (group) {
+          return group.id !== _id;
+        }); // The group isn't registered, so do nothing
+
+        if (nextGroups.length === groups.length) {
+          return state;
+        }
+
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          groups: nextGroups
+        });
+      }
+
+    case "registerItem":
+      {
+        var _item = action.item; // Finds the item group based on the DOM hierarchy
+
+        var _group2 = groups.find(function (r) {
+          var _r$ref$current;
+
+          return (_r$ref$current = r.ref.current) === null || _r$ref$current === void 0 ? void 0 : _r$ref$current.contains(_item.ref.current);
+        }); // Group will be null if it's a one-dimensional composite
+
+
+        var nextItem = _rollupPluginBabelHelpers._objectSpread2({
+          groupId: _group2 === null || _group2 === void 0 ? void 0 : _group2.id
+        }, _item);
+
+        var _index = findDOMIndex(items, nextItem);
+
+        var nextState = _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          items: addItemAtIndex(items, nextItem, _index)
+        });
+
+        if (!hasSetCurrentId && !moves && initialCurrentId === undefined) {
+          var _findFirstEnabledItem;
+
+          // Sets currentId to the first enabled item. This runs whenever an item
+          // is registered because the first enabled item may be registered
+          // asynchronously.
+          return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, nextState), {}, {
+            currentId: (_findFirstEnabledItem = getCurrentId.findFirstEnabledItem(nextState.items)) === null || _findFirstEnabledItem === void 0 ? void 0 : _findFirstEnabledItem.id
+          });
+        }
+
+        return nextState;
+      }
+
+    case "unregisterItem":
+      {
+        var _id2 = action.id;
+        var nextItems = items.filter(function (item) {
+          return item.id !== _id2;
+        }); // The item isn't registered, so do nothing
+
+        if (nextItems.length === items.length) {
+          return state;
+        } // Filters out the item that is being removed from the pastIds list
+
+
+        var nextPastIds = pastIds.filter(function (pastId) {
+          return pastId !== _id2;
+        });
+
+        var _nextState = _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          pastIds: nextPastIds,
+          items: nextItems
+        }); // If the current item is the item that is being removed, focus pastId
+
+
+        if (currentId && currentId === _id2) {
+          var nextId = includesBaseElement ? null : getCurrentId.getCurrentId(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, _nextState), {}, {
+            currentId: nextPastIds[0]
+          }));
+          return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, _nextState), {}, {
+            currentId: nextId
+          });
+        }
+
+        return _nextState;
+      }
+
+    case "move":
+      {
+        var _id3 = action.id; // move() does nothing
+
+        if (_id3 === undefined) {
+          return state;
+        } // Removes the current item and the item that is receiving focus from the
+        // pastIds list
+
+
+        var filteredPastIds = pastIds.filter(function (pastId) {
+          return pastId !== currentId && pastId !== _id3;
+        }); // If there's a currentId, add it to the pastIds list so it can be focused
+        // if the new item gets removed or disabled
+
+        var _nextPastIds = currentId ? [currentId].concat(filteredPastIds) : filteredPastIds;
+
+        var _nextState2 = _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          pastIds: _nextPastIds
+        }); // move(null) will focus the composite element itself, not an item
+
+
+        if (_id3 === null) {
+          return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, _nextState2), {}, {
+            unstable_moves: moves + 1,
+            currentId: getCurrentId.getCurrentId(_nextState2, _id3)
+          });
+        }
+
+        var _item2 = findEnabledItemById.findEnabledItemById(items, _id3);
+
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, _nextState2), {}, {
+          unstable_moves: _item2 ? moves + 1 : moves,
+          currentId: getCurrentId.getCurrentId(_nextState2, _item2 === null || _item2 === void 0 ? void 0 : _item2.id)
+        });
+      }
+
+    case "next":
+      {
+        // If there's no item focused, we just move the first one
+        if (currentId == null) {
+          return reducer(state, _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+            type: "first"
+          }));
+        } // RTL doesn't make sense on vertical navigation
+
+
+        var isHorizontal = orientation !== "vertical";
+        var isRTL = rtl && isHorizontal;
+        var allItems = isRTL ? reverse.reverse(items) : items;
+        var currentItem = allItems.find(function (item) {
+          return item.id === currentId;
+        }); // If there's no item focused, we just move the first one
+
+        if (!currentItem) {
+          return reducer(state, _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+            type: "first"
+          }));
+        }
+
+        var isGrid = !!currentItem.groupId;
+        var currentIndex = allItems.indexOf(currentItem);
+
+        var _nextItems = allItems.slice(currentIndex + 1);
+
+        var nextItemsInGroup = getItemsInGroup(_nextItems, currentItem.groupId); // Home, End
+
+        if (action.allTheWay) {
+          // We reverse so we can get the last enabled item in the group. If it's
+          // RTL, nextItems and nextItemsInGroup are already reversed and don't
+          // have the items before the current one anymore. So we have to get
+          // items in group again with allItems.
+          var _nextItem2 = getCurrentId.findFirstEnabledItem(isRTL ? getItemsInGroup(allItems, currentItem.groupId) : reverse.reverse(nextItemsInGroup));
+
+          return reducer(state, _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+            type: "move",
+            id: _nextItem2 === null || _nextItem2 === void 0 ? void 0 : _nextItem2.id
+          }));
+        }
+
+        var oppositeOrientation = getOppositeOrientation( // If it's a grid and orientation is not set, it's a next/previous
+        // call, which is inherently horizontal. up/down will call next with
+        // orientation set to vertical by default (see below on up/down cases).
+        isGrid ? orientation || "horizontal" : orientation);
+        var canLoop = loop && loop !== oppositeOrientation;
+        var canWrap = isGrid && wrap && wrap !== oppositeOrientation;
+        var hasNullItem = // `previous` and `up` will set action.hasNullItem, but when calling
+        // next directly, hasNullItem will only be true if it's not a grid and
+        // loop is set to true, which means that pressing right or down keys on
+        // grids will never focus the composite element. On one-dimensional
+        // composites that don't loop, pressing right or down keys also doesn't
+        // focus the composite element.
+        action.hasNullItem || !isGrid && canLoop && includesBaseElement;
+
+        if (canLoop) {
+          var loopItems = canWrap && !hasNullItem ? allItems : getItemsInGroup(allItems, currentItem.groupId); // Turns [0, 1, current, 3, 4] into [3, 4, 0, 1]
+
+          var sortedItems = placeItemsAfter(loopItems, currentId, hasNullItem);
+
+          var _nextItem3 = getCurrentId.findFirstEnabledItem(sortedItems, currentId);
+
+          return reducer(state, _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+            type: "move",
+            id: _nextItem3 === null || _nextItem3 === void 0 ? void 0 : _nextItem3.id
+          }));
+        }
+
+        if (canWrap) {
+          var _nextItem4 = getCurrentId.findFirstEnabledItem( // We can use nextItems, which contains all the next items, including
+          // items from other groups, to wrap between groups. However, if there
+          // is a null item (the composite element), we'll only use the next
+          // items in the group. So moving next from the last item will focus
+          // the composite element (null). On grid composites, horizontal
+          // navigation never focuses the composite element, only vertical.
+          hasNullItem ? nextItemsInGroup : _nextItems, currentId);
+
+          var _nextId = hasNullItem ? (_nextItem4 === null || _nextItem4 === void 0 ? void 0 : _nextItem4.id) || null : _nextItem4 === null || _nextItem4 === void 0 ? void 0 : _nextItem4.id;
+
+          return reducer(state, _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+            type: "move",
+            id: _nextId
+          }));
+        }
+
+        var _nextItem = getCurrentId.findFirstEnabledItem(nextItemsInGroup, currentId);
+
+        if (!_nextItem && hasNullItem) {
+          return reducer(state, _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+            type: "move",
+            id: null
+          }));
+        }
+
+        return reducer(state, _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+          type: "move",
+          id: _nextItem === null || _nextItem === void 0 ? void 0 : _nextItem.id
+        }));
+      }
+
+    case "previous":
+      {
+        // If currentId is initially set to null, the composite element will be
+        // focusable while navigating with arrow keys. But, if it's a grid, we
+        // don't want to focus the composite element with horizontal navigation.
+        var _isGrid = !!groups.length;
+
+        var _hasNullItem = !_isGrid && includesBaseElement;
+
+        var _nextState3 = reducer(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          items: reverse.reverse(items)
+        }), _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+          type: "next",
+          hasNullItem: _hasNullItem
+        }));
+
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, _nextState3), {}, {
+          items: items
+        });
+      }
+
+    case "down":
+      {
+        var shouldShift = shift && !action.allTheWay; // First, we make sure groups have the same number of items by filling it
+        // with disabled fake items. Then, we reorganize the items list so
+        // [1-1, 1-2, 2-1, 2-2] becomes [1-1, 2-1, 1-2, 2-2].
+
+        var verticalItems = verticalizeItems(reverse.flatten(fillGroups(reverse.groupItems(items), currentId, shouldShift)));
+
+        var _canLoop = loop && loop !== "horizontal"; // Pressing down arrow key will only focus the composite element if loop
+        // is true or vertical.
+
+
+        var _hasNullItem2 = _canLoop && includesBaseElement;
+
+        var _nextState4 = reducer(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          orientation: "vertical",
+          items: verticalItems
+        }), _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+          type: "next",
+          hasNullItem: _hasNullItem2
+        }));
+
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, _nextState4), {}, {
+          orientation: orientation,
+          items: items
+        });
+      }
+
+    case "up":
+      {
+        var _shouldShift = shift && !action.allTheWay;
+
+        var _verticalItems = verticalizeItems(reverse.reverse(reverse.flatten(fillGroups(reverse.groupItems(items), currentId, _shouldShift)))); // If currentId is initially set to null, we'll always focus the
+        // composite element when the up arrow key is pressed in the first row.
+
+
+        var _hasNullItem3 = includesBaseElement;
+
+        var _nextState5 = reducer(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          orientation: "vertical",
+          items: _verticalItems
+        }), _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+          type: "next",
+          hasNullItem: _hasNullItem3
+        }));
+
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, _nextState5), {}, {
+          orientation: orientation,
+          items: items
+        });
+      }
+
+    case "first":
+      {
+        var firstItem = getCurrentId.findFirstEnabledItem(items);
+        return reducer(state, _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+          type: "move",
+          id: firstItem === null || firstItem === void 0 ? void 0 : firstItem.id
+        }));
+      }
+
+    case "last":
+      {
+        var _nextState6 = reducer(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          items: reverse.reverse(items)
+        }), _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, action), {}, {
+          type: "first"
+        }));
+
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, _nextState6), {}, {
+          items: items
+        });
+      }
+
+    case "sort":
+      {
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          items: sortBasedOnDOMPosition(items),
+          groups: sortBasedOnDOMPosition(groups)
+        });
+      }
+
+    case "setVirtual":
+      return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+        unstable_virtual: applyState.applyState(action.virtual, virtual)
+      });
+
+    case "setRTL":
+      return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+        rtl: applyState.applyState(action.rtl, rtl)
+      });
+
+    case "setOrientation":
+      return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+        orientation: applyState.applyState(action.orientation, orientation)
+      });
+
+    case "setCurrentId":
+      {
+        var nextCurrentId = getCurrentId.getCurrentId(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          currentId: applyState.applyState(action.currentId, currentId)
+        }));
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          currentId: nextCurrentId,
+          hasSetCurrentId: true
+        });
+      }
+
+    case "setLoop":
+      return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+        loop: applyState.applyState(action.loop, loop)
+      });
+
+    case "setWrap":
+      return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+        wrap: applyState.applyState(action.wrap, wrap)
+      });
+
+    case "setShift":
+      return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+        shift: applyState.applyState(action.shift, shift)
+      });
+
+    case "setIncludesBaseElement":
+      {
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          unstable_includesBaseElement: applyState.applyState(action.includesBaseElement, includesBaseElement)
+        });
+      }
+
+    case "reset":
+      return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+        unstable_virtual: initialVirtual,
+        rtl: initialRTL,
+        orientation: initialOrientation,
+        currentId: getCurrentId.getCurrentId(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          currentId: initialCurrentId
+        })),
+        loop: initialLoop,
+        wrap: initialWrap,
+        shift: initialShift,
+        unstable_moves: 0,
+        pastIds: []
+      });
+
+    case "setItems":
+      {
+        return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, state), {}, {
+          items: action.items
+        });
+      }
+
+    default:
+      throw new Error();
+  }
+}
+
+function useAction(fn) {
+  return React.useCallback(fn, []);
+}
+
+function useIsUnmountedRef() {
+  var isUnmountedRef = React.useRef(false);
+  useIsomorphicEffect.useIsomorphicEffect(function () {
+    return function () {
+      isUnmountedRef.current = true;
+    };
+  }, []);
+  return isUnmountedRef;
+}
+
+function useCompositeState(initialState) {
+  if (initialState === void 0) {
+    initialState = {};
+  }
+
+  var _useSealedState = useSealedState.useSealedState(initialState),
+      _useSealedState$unsta = _useSealedState.unstable_virtual,
+      virtual = _useSealedState$unsta === void 0 ? false : _useSealedState$unsta,
+      _useSealedState$rtl = _useSealedState.rtl,
+      rtl = _useSealedState$rtl === void 0 ? false : _useSealedState$rtl,
+      orientation = _useSealedState.orientation,
+      currentId = _useSealedState.currentId,
+      _useSealedState$loop = _useSealedState.loop,
+      loop = _useSealedState$loop === void 0 ? false : _useSealedState$loop,
+      _useSealedState$wrap = _useSealedState.wrap,
+      wrap = _useSealedState$wrap === void 0 ? false : _useSealedState$wrap,
+      _useSealedState$shift = _useSealedState.shift,
+      shift = _useSealedState$shift === void 0 ? false : _useSealedState$shift,
+      unstable_includesBaseElement = _useSealedState.unstable_includesBaseElement,
+      sealed = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_useSealedState, ["unstable_virtual", "rtl", "orientation", "currentId", "loop", "wrap", "shift", "unstable_includesBaseElement"]);
+
+  var idState = Id_IdState.unstable_useIdState(sealed);
+
+  var _React$useReducer = React.useReducer(reducer, {
+    unstable_virtual: virtual,
+    rtl: rtl,
+    orientation: orientation,
+    items: [],
+    groups: [],
+    currentId: currentId,
+    loop: loop,
+    wrap: wrap,
+    shift: shift,
+    unstable_moves: 0,
+    pastIds: [],
+    unstable_includesBaseElement: unstable_includesBaseElement != null ? unstable_includesBaseElement : currentId === null,
+    initialVirtual: virtual,
+    initialRTL: rtl,
+    initialOrientation: orientation,
+    initialCurrentId: currentId,
+    initialLoop: loop,
+    initialWrap: wrap,
+    initialShift: shift
+  }),
+      _React$useReducer$ = _React$useReducer[0],
+      pastIds = _React$useReducer$.pastIds,
+      initialVirtual = _React$useReducer$.initialVirtual,
+      initialRTL = _React$useReducer$.initialRTL,
+      initialOrientation = _React$useReducer$.initialOrientation,
+      initialCurrentId = _React$useReducer$.initialCurrentId,
+      initialLoop = _React$useReducer$.initialLoop,
+      initialWrap = _React$useReducer$.initialWrap,
+      initialShift = _React$useReducer$.initialShift,
+      hasSetCurrentId = _React$useReducer$.hasSetCurrentId,
+      state = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_React$useReducer$, ["pastIds", "initialVirtual", "initialRTL", "initialOrientation", "initialCurrentId", "initialLoop", "initialWrap", "initialShift", "hasSetCurrentId"]),
+      dispatch = _React$useReducer[1];
+
+  var _React$useState = React.useState(false),
+      hasActiveWidget = _React$useState[0],
+      setHasActiveWidget = _React$useState[1]; // register/unregister may be called when this component is unmounted. We
+  // store the unmounted state here so we don't update the state if it's true.
+  // This only happens in a very specific situation.
+  // See https://github.com/reakit/reakit/issues/650
+
+
+  var isUnmountedRef = useIsUnmountedRef();
+  var setItems = React.useCallback(function (items) {
+    return dispatch({
+      type: "setItems",
+      items: items
+    });
+  }, []);
+  useSortBasedOnDOMPosition(state.items, setItems);
+  return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, idState), state), {}, {
+    unstable_hasActiveWidget: hasActiveWidget,
+    unstable_setHasActiveWidget: setHasActiveWidget,
+    registerItem: useAction(function (item) {
+      if (isUnmountedRef.current) return;
+      dispatch({
+        type: "registerItem",
+        item: item
+      });
+    }),
+    unregisterItem: useAction(function (id) {
+      if (isUnmountedRef.current) return;
+      dispatch({
+        type: "unregisterItem",
+        id: id
+      });
+    }),
+    registerGroup: useAction(function (group) {
+      if (isUnmountedRef.current) return;
+      dispatch({
+        type: "registerGroup",
+        group: group
+      });
+    }),
+    unregisterGroup: useAction(function (id) {
+      if (isUnmountedRef.current) return;
+      dispatch({
+        type: "unregisterGroup",
+        id: id
+      });
+    }),
+    move: useAction(function (id) {
+      return dispatch({
+        type: "move",
+        id: id
+      });
+    }),
+    next: useAction(function (allTheWay) {
+      return dispatch({
+        type: "next",
+        allTheWay: allTheWay
+      });
+    }),
+    previous: useAction(function (allTheWay) {
+      return dispatch({
+        type: "previous",
+        allTheWay: allTheWay
+      });
+    }),
+    up: useAction(function (allTheWay) {
+      return dispatch({
+        type: "up",
+        allTheWay: allTheWay
+      });
+    }),
+    down: useAction(function (allTheWay) {
+      return dispatch({
+        type: "down",
+        allTheWay: allTheWay
+      });
+    }),
+    first: useAction(function () {
+      return dispatch({
+        type: "first"
+      });
+    }),
+    last: useAction(function () {
+      return dispatch({
+        type: "last"
+      });
+    }),
+    sort: useAction(function () {
+      return dispatch({
+        type: "sort"
+      });
+    }),
+    unstable_setVirtual: useAction(function (value) {
+      return dispatch({
+        type: "setVirtual",
+        virtual: value
+      });
+    }),
+    setRTL: useAction(function (value) {
+      return dispatch({
+        type: "setRTL",
+        rtl: value
+      });
+    }),
+    setOrientation: useAction(function (value) {
+      return dispatch({
+        type: "setOrientation",
+        orientation: value
+      });
+    }),
+    setCurrentId: useAction(function (value) {
+      return dispatch({
+        type: "setCurrentId",
+        currentId: value
+      });
+    }),
+    setLoop: useAction(function (value) {
+      return dispatch({
+        type: "setLoop",
+        loop: value
+      });
+    }),
+    setWrap: useAction(function (value) {
+      return dispatch({
+        type: "setWrap",
+        wrap: value
+      });
+    }),
+    setShift: useAction(function (value) {
+      return dispatch({
+        type: "setShift",
+        shift: value
+      });
+    }),
+    unstable_setIncludesBaseElement: useAction(function (value) {
+      return dispatch({
+        type: "setIncludesBaseElement",
+        includesBaseElement: value
+      });
+    }),
+    reset: useAction(function () {
+      return dispatch({
+        type: "reset"
+      });
+    })
+  });
+}
+
+exports.useCompositeState = useCompositeState;

node_modules/reakit/lib/Composite/index.js

@@ -0,0 +1,64 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../_rollupPluginBabelHelpers-8f9a8751.js');
+require('reakit-system/createComponent');
+require('reakit-system/createHook');
+require('reakit-utils/shallowEqual');
+require('react');
+require('reakit-utils/useForkRef');
+require('reakit-utils/isButton');
+require('reakit-warning');
+require('reakit-utils/useLiveRef');
+require('reakit-utils/isSelfTarget');
+require('reakit-utils/useIsomorphicEffect');
+require('reakit-utils/hasFocusWithin');
+require('reakit-utils/isPortalEvent');
+require('reakit-utils/dom');
+require('reakit-utils/tabbable');
+require('../Role/Role.js');
+require('../Tabbable/Tabbable.js');
+require('../Clickable/Clickable.js');
+require('reakit-utils/useSealedState');
+require('reakit-system/useCreateElement');
+require('reakit-utils/getDocument');
+require('reakit-utils/fireBlurEvent');
+require('reakit-utils/fireKeyboardEvent');
+require('reakit-utils/canUseDOM');
+require('reakit-utils/getNextActiveElementOnBlur');
+require('../reverse-4756a49e.js');
+require('../getCurrentId-eade2850.js');
+require('../findEnabledItemById-03112678.js');
+require('../__keys-3b597476.js');
+require('../userFocus-0afea51a.js');
+var Composite_Composite = require('./Composite.js');
+require('reakit-utils/isTextField');
+require('reakit-utils/ensureFocus');
+require('../Id/IdProvider.js');
+require('../Id/Id.js');
+require('reakit-utils/fireEvent');
+require('../setTextFieldValue-b0584ae1.js');
+var Composite_CompositeItem = require('./CompositeItem.js');
+require('../Group/Group.js');
+var Composite_CompositeGroup = require('./CompositeGroup.js');
+require('reakit-utils/applyState');
+require('../Id/IdState.js');
+var Composite_CompositeState = require('./CompositeState.js');
+var Composite_CompositeItemWidget = require('./CompositeItemWidget.js');
+
+
+
+exports.Composite = Composite_Composite.Composite;
+exports.unstable_Composite = Composite_Composite.Composite;
+exports.useComposite = Composite_Composite.useComposite;
+exports.CompositeItem = Composite_CompositeItem.CompositeItem;
+exports.unstable_CompositeItem = Composite_CompositeItem.CompositeItem;
+exports.useCompositeItem = Composite_CompositeItem.useCompositeItem;
+exports.CompositeGroup = Composite_CompositeGroup.CompositeGroup;
+exports.unstable_CompositeGroup = Composite_CompositeGroup.CompositeGroup;
+exports.useCompositeGroup = Composite_CompositeGroup.useCompositeGroup;
+exports.unstable_useCompositeState = Composite_CompositeState.useCompositeState;
+exports.useCompositeState = Composite_CompositeState.useCompositeState;
+exports.unstable_CompositeItemWidget = Composite_CompositeItemWidget.unstable_CompositeItemWidget;
+exports.unstable_useCompositeItemWidget = Composite_CompositeItemWidget.unstable_useCompositeItemWidget;