@ariakit/react-core 0.0.1 → 0.1.0

package/cjs/__chunks/GV5LATA3.cjs

@@ -0,0 +1,326 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _6622YWGRcjs = require('./6622YWGR.cjs');
+
+
+var _44UMDBZEcjs = require('./44UMDBZE.cjs');
+
+
+var _NVMBKFRBcjs = require('./NVMBKFRB.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+
+
+
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+// src/composite/composite.tsx
+var _react = require('react');
+var _array = require('@ariakit/core/utils/array');
+var _dom = require('@ariakit/core/utils/dom');
+
+
+
+
+
+var _events = require('@ariakit/core/utils/events');
+var _focus = require('@ariakit/core/utils/focus');
+var _jsxruntime = require('react/jsx-runtime');
+function isGrid(items) {
+  return items.some((item) => !!item.rowId);
+}
+function isPrintableKey(event) {
+  return event.key.length === 1 && !event.ctrlKey && !event.metaKey;
+}
+function isModifierKey(event) {
+  return event.key === "Shift" || event.key === "Control" || event.key === "Alt" || event.key === "Meta";
+}
+function canProxyKeyboardEvent(event, state) {
+  if (!_events.isSelfTarget.call(void 0, event))
+    return false;
+  if (isModifierKey(event))
+    return false;
+  const target = event.target;
+  if (!target)
+    return true;
+  if (_dom.isTextField.call(void 0, target)) {
+    if (isPrintableKey(event))
+      return false;
+    const grid = isGrid(state.renderedItems);
+    const focusingInputOnly = state.activeId === null;
+    const allowHorizontalNavigationOnItems = grid && !focusingInputOnly;
+    const isHomeOrEnd = event.key === "Home" || event.key === "End";
+    if (!allowHorizontalNavigationOnItems && isHomeOrEnd)
+      return false;
+  }
+  return !event.isPropagationStopped();
+}
+function useKeyboardEventProxy(store, onKeyboardEvent, previousElementRef) {
+  return _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+    _optionalChain([onKeyboardEvent, 'optionalCall', _ => _(event)]);
+    if (event.defaultPrevented)
+      return;
+    const state = store.getState();
+    const activeElement = _optionalChain([_6622YWGRcjs.getEnabledItem.call(void 0, store, state.activeId), 'optionalAccess', _2 => _2.element]);
+    if (!activeElement)
+      return;
+    if (!canProxyKeyboardEvent(event, state))
+      return;
+    const { view, ...eventInit } = event;
+    const previousElement = _optionalChain([previousElementRef, 'optionalAccess', _3 => _3.current]);
+    if (activeElement !== previousElement) {
+      activeElement.focus();
+    }
+    if (!_events.fireKeyboardEvent.call(void 0, activeElement, event.type, eventInit)) {
+      event.preventDefault();
+    }
+    if (event.currentTarget.contains(activeElement)) {
+      event.stopPropagation();
+    }
+  });
+}
+function findFirstEnabledItemInTheLastRow(items) {
+  return _6622YWGRcjs.findFirstEnabledItem.call(void 0, 
+    _array.flatten2DArray.call(void 0, _array.reverseArray.call(void 0, _6622YWGRcjs.groupItemsByRows.call(void 0, items)))
+  );
+}
+function useScheduleFocus(store) {
+  const [scheduled, setScheduled] = _react.useState.call(void 0, false);
+  const schedule = _react.useCallback.call(void 0, () => setScheduled(true), []);
+  const activeItem = store.useState(
+    (state) => _6622YWGRcjs.getEnabledItem.call(void 0, store, state.activeId)
+  );
+  _react.useEffect.call(void 0, () => {
+    const activeElement = _optionalChain([activeItem, 'optionalAccess', _4 => _4.element]);
+    if (!scheduled)
+      return;
+    if (!activeElement)
+      return;
+    setScheduled(false);
+    _focus.focusIntoView.call(void 0, activeElement);
+  }, [activeItem, scheduled]);
+  return schedule;
+}
+var useComposite = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({
+    store,
+    composite = true,
+    focusOnMove = composite,
+    moveOnKeyPress = true,
+    ...props
+  }) => {
+    const previousElementRef = _react.useRef.call(void 0, null);
+    const scheduleFocus = useScheduleFocus(store);
+    const moves = store.useState("moves");
+    _5QY4WCTRcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (!composite)
+        return;
+      if (!focusOnMove)
+        return;
+      if (!moves)
+        return;
+      const { activeId: activeId2 } = store.getState();
+      const itemElement = _optionalChain([_6622YWGRcjs.getEnabledItem.call(void 0, store, activeId2), 'optionalAccess', _5 => _5.element]);
+      if (!itemElement)
+        return;
+      scheduleFocus();
+    }, [moves, composite, focusOnMove]);
+    _5QY4WCTRcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (!composite)
+        return;
+      if (!moves)
+        return;
+      const { baseElement, activeId: activeId2 } = store.getState();
+      const isSelfAcive = activeId2 === null;
+      if (!isSelfAcive)
+        return;
+      if (!baseElement)
+        return;
+      const previousElement = previousElementRef.current;
+      previousElementRef.current = null;
+      if (previousElement) {
+        _events.fireBlurEvent.call(void 0, previousElement, { relatedTarget: baseElement });
+      }
+      if (_focus.hasFocus.call(void 0, baseElement)) {
+        _events.fireFocusEvent.call(void 0, baseElement, { relatedTarget: previousElement });
+      } else {
+        baseElement.focus();
+      }
+    }, [moves, composite]);
+    const activeId = store.useState("activeId");
+    const virtualFocus = store.useState("virtualFocus");
+    _5QY4WCTRcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (!composite)
+        return;
+      if (!virtualFocus)
+        return;
+      const previousElement = previousElementRef.current;
+      previousElementRef.current = null;
+      if (!previousElement)
+        return;
+      const activeElement = _optionalChain([_6622YWGRcjs.getEnabledItem.call(void 0, store, activeId), 'optionalAccess', _6 => _6.element]);
+      const relatedTarget = activeElement || _dom.getActiveElement.call(void 0, previousElement);
+      _events.fireBlurEvent.call(void 0, previousElement, { relatedTarget });
+    }, [activeId, virtualFocus, composite]);
+    const onKeyDownCapture = useKeyboardEventProxy(
+      store,
+      props.onKeyDownCapture,
+      previousElementRef
+    );
+    const onKeyUpCapture = useKeyboardEventProxy(
+      store,
+      props.onKeyUpCapture,
+      previousElementRef
+    );
+    const onFocusCaptureProp = props.onFocusCapture;
+    const onFocusCapture = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onFocusCaptureProp, 'optionalCall', _7 => _7(event)]);
+      if (event.defaultPrevented)
+        return;
+      const { virtualFocus: virtualFocus2 } = store.getState();
+      if (!virtualFocus2)
+        return;
+      const previousActiveElement = event.relatedTarget;
+      const isSilentlyFocused = _6622YWGRcjs.silentlyFocused.call(void 0, event.currentTarget);
+      if (_events.isSelfTarget.call(void 0, event) && isSilentlyFocused) {
+        event.stopPropagation();
+        previousElementRef.current = previousActiveElement;
+      }
+    });
+    const onFocusProp = props.onFocus;
+    const onFocus = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onFocusProp, 'optionalCall', _8 => _8(event)]);
+      if (event.defaultPrevented)
+        return;
+      if (!composite)
+        return;
+      const { relatedTarget } = event;
+      const { virtualFocus: virtualFocus2 } = store.getState();
+      if (virtualFocus2) {
+        if (_events.isSelfTarget.call(void 0, event) && !_6622YWGRcjs.isItem.call(void 0, store, relatedTarget)) {
+          queueMicrotask(scheduleFocus);
+        }
+      } else if (_events.isSelfTarget.call(void 0, event)) {
+        store.setActiveId(null);
+      }
+    });
+    const onBlurCaptureProp = props.onBlurCapture;
+    const onBlurCapture = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onBlurCaptureProp, 'optionalCall', _9 => _9(event)]);
+      if (event.defaultPrevented)
+        return;
+      const { virtualFocus: virtualFocus2, activeId: activeId2 } = store.getState();
+      if (!virtualFocus2)
+        return;
+      const activeElement = _optionalChain([_6622YWGRcjs.getEnabledItem.call(void 0, store, activeId2), 'optionalAccess', _10 => _10.element]);
+      const nextActiveElement = event.relatedTarget;
+      const nextActiveElementIsItem = _6622YWGRcjs.isItem.call(void 0, store, nextActiveElement);
+      const previousElement = previousElementRef.current;
+      previousElementRef.current = null;
+      if (_events.isSelfTarget.call(void 0, event) && nextActiveElementIsItem) {
+        if (nextActiveElement === activeElement) {
+          if (previousElement && previousElement !== nextActiveElement) {
+            _events.fireBlurEvent.call(void 0, previousElement, event);
+          }
+        } else if (activeElement) {
+          _events.fireBlurEvent.call(void 0, activeElement, event);
+        }
+        event.stopPropagation();
+      } else {
+        const targetIsItem = _6622YWGRcjs.isItem.call(void 0, store, event.target);
+        if (!targetIsItem && activeElement) {
+          _events.fireBlurEvent.call(void 0, activeElement, event);
+        }
+      }
+    });
+    const onKeyDownProp = props.onKeyDown;
+    const moveOnKeyPressProp = _5QY4WCTRcjs.useBooleanEvent.call(void 0, moveOnKeyPress);
+    const onKeyDown = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onKeyDownProp, 'optionalCall', _11 => _11(event)]);
+      if (event.defaultPrevented)
+        return;
+      if (!_events.isSelfTarget.call(void 0, event))
+        return;
+      const { orientation, items, renderedItems, activeId: activeId2 } = store.getState();
+      const activeItem = _6622YWGRcjs.getEnabledItem.call(void 0, store, activeId2);
+      if (activeItem)
+        return;
+      const isVertical = orientation !== "horizontal";
+      const isHorizontal = orientation !== "vertical";
+      const grid = isGrid(renderedItems);
+      const up = () => {
+        if (grid) {
+          const item = items && findFirstEnabledItemInTheLastRow(items);
+          return _optionalChain([item, 'optionalAccess', _12 => _12.id]);
+        }
+        return store.last();
+      };
+      const keyMap = {
+        ArrowUp: (grid || isVertical) && up,
+        ArrowRight: (grid || isHorizontal) && store.first,
+        ArrowDown: (grid || isVertical) && store.first,
+        ArrowLeft: (grid || isHorizontal) && store.last,
+        Home: store.first,
+        End: store.last,
+        PageUp: store.first,
+        PageDown: store.last
+      };
+      const action = keyMap[event.key];
+      if (action) {
+        const id = action();
+        if (id !== void 0) {
+          if (!moveOnKeyPressProp(event))
+            return;
+          event.preventDefault();
+          store.move(id);
+        }
+      }
+    });
+    props = _5QY4WCTRcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _NVMBKFRBcjs.CompositeContext.Provider, { value: store, children: element }),
+      [store]
+    );
+    const activeDescendant = store.useState(
+      (state) => state.virtualFocus ? _optionalChain([_6622YWGRcjs.getEnabledItem.call(void 0, store, state.activeId), 'optionalAccess', _13 => _13.id]) : void 0
+    );
+    props = {
+      "aria-activedescendant": activeDescendant,
+      ...props,
+      ref: _5QY4WCTRcjs.useForkRef.call(void 0, composite ? store.setBaseElement : null, props.ref),
+      onKeyDownCapture,
+      onKeyUpCapture,
+      onFocusCapture,
+      onFocus,
+      onBlurCapture,
+      onKeyDown
+    };
+    const focusable = store.useState(
+      (state) => composite && (state.virtualFocus || state.activeId === null)
+    );
+    props = _44UMDBZEcjs.useFocusable.call(void 0, { focusable, ...props });
+    return props;
+  }
+);
+var Composite = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useComposite(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Composite.displayName = "Composite";
+}
+
+
+
+
+exports.useComposite = useComposite; exports.Composite = Composite;

package/cjs/__chunks/GWL7P7EG.cjs

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _743OAGBPcjs = require('./743OAGBP.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+// src/popover/popover-dismiss.ts
+var usePopoverDismiss = _UYIFJ7U3cjs.createHook.call(void 0, (props) => {
+  props = _743OAGBPcjs.useDialogDismiss.call(void 0, props);
+  return props;
+});
+var PopoverDismiss = _UYIFJ7U3cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = usePopoverDismiss(props);
+    return _UYIFJ7U3cjs.createElement.call(void 0, "button", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  PopoverDismiss.displayName = "PopoverDismiss";
+}
+
+
+
+
+exports.usePopoverDismiss = usePopoverDismiss; exports.PopoverDismiss = PopoverDismiss;

package/cjs/__chunks/H5Z2A5K2.cjs

@@ -0,0 +1,29 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+var _ND6THRTEcjs = require('./ND6THRTE.cjs');
+
+
+var _F6IOE5QTcjs = require('./F6IOE5QT.cjs');
+
+// src/dialog/dialog-store.ts
+var _dialogstore = require('@ariakit/core/dialog/dialog-store'); var Core = _interopRequireWildcard(_dialogstore);
+function useDialogStoreOptions(props) {
+  return _ND6THRTEcjs.useDisclosureStoreOptions.call(void 0, props);
+}
+function useDialogStoreProps(store, props) {
+  return _ND6THRTEcjs.useDisclosureStoreProps.call(void 0, store, props);
+}
+function useDialogStore(props = {}) {
+  const options = useDialogStoreOptions(props);
+  const store = _F6IOE5QTcjs.useStore.call(void 0, 
+    () => Core.createDialogStore({ ...props, ...options })
+  );
+  return useDialogStoreProps(store, props);
+}
+
+
+
+
+
+exports.useDialogStoreOptions = useDialogStoreOptions; exports.useDialogStoreProps = useDialogStoreProps; exports.useDialogStore = useDialogStore;

package/cjs/__chunks/HRWXWXME.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/tab/tab-context.ts
+var _react = require('react');
+var TabContext = _react.createContext.call(void 0, void 0);
+
+
+
+exports.TabContext = TabContext;

package/cjs/__chunks/IVRU7X3P.cjs

@@ -0,0 +1,213 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _MAH7ORCZcjs = require('./MAH7ORCZ.cjs');
+
+
+var _NS56XHXGcjs = require('./NS56XHXG.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+
+var _2X5K3J7Ycjs = require('./2X5K3J7Y.cjs');
+
+// src/portal/portal.tsx
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+
+
+
+
+
+var _focus = require('@ariakit/core/utils/focus');
+var _reactdom = require('react-dom');
+var _jsxruntime = require('react/jsx-runtime');
+function getRootElement(element) {
+  return _dom.getDocument.call(void 0, element).body;
+}
+function getPortalElement(element, portalElement) {
+  if (!portalElement) {
+    return _dom.getDocument.call(void 0, element).createElement("div");
+  }
+  if (typeof portalElement === "function") {
+    return portalElement(element);
+  }
+  return portalElement;
+}
+function getRandomId(prefix = "id") {
+  return `${prefix ? `${prefix}-` : ""}${Math.random().toString(36).substr(2, 6)}`;
+}
+function queueFocus(element) {
+  queueMicrotask(() => {
+    _optionalChain([element, 'optionalAccess', _ => _.focus, 'call', _2 => _2()]);
+  });
+}
+var usePortal = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ preserveTabOrder, portalElement, portalRef, portal = true, ...props }) => {
+    const ref = _react.useRef.call(void 0, null);
+    const refProp = _5QY4WCTRcjs.useForkRef.call(void 0, ref, props.ref);
+    const context = _react.useContext.call(void 0, _NS56XHXGcjs.PortalContext);
+    const [portalNode, setPortalNode] = _react.useState.call(void 0, null);
+    const beforeOutsideRef = _react.useRef.call(void 0, null);
+    const beforeInsideRef = _react.useRef.call(void 0, null);
+    const afterInsideRef = _react.useRef.call(void 0, null);
+    const afterOutsideRef = _react.useRef.call(void 0, null);
+    _5QY4WCTRcjs.useSafeLayoutEffect.call(void 0, () => {
+      const element = ref.current;
+      if (!element || !portal) {
+        setPortalNode(null);
+        return;
+      }
+      const portalEl = getPortalElement(element, portalElement);
+      if (!portalEl) {
+        setPortalNode(null);
+        return;
+      }
+      const isPortalInDocument = portalEl.isConnected;
+      if (!isPortalInDocument) {
+        const rootElement = context || getRootElement(element);
+        rootElement.appendChild(portalEl);
+      }
+      if (!portalEl.id) {
+        portalEl.id = element.id ? `${element.id}-portal` : getRandomId();
+      }
+      setPortalNode(portalEl);
+      _2X5K3J7Ycjs.setRef.call(void 0, portalRef, portalEl);
+      if (isPortalInDocument)
+        return;
+      return () => {
+        portalEl.remove();
+        _2X5K3J7Ycjs.setRef.call(void 0, portalRef, null);
+      };
+    }, [portal, portalElement, context, portalRef]);
+    _react.useEffect.call(void 0, () => {
+      if (!portalNode)
+        return;
+      if (!preserveTabOrder)
+        return;
+      let raf = 0;
+      const onFocus = (event) => {
+        if (!_events.isFocusEventOutside.call(void 0, event))
+          return;
+        const focusing = event.type === "focusin";
+        if (focusing)
+          return _focus.restoreFocusIn.call(void 0, portalNode);
+        cancelAnimationFrame(raf);
+        raf = requestAnimationFrame(() => {
+          _focus.disableFocusIn.call(void 0, portalNode, true);
+        });
+      };
+      portalNode.addEventListener("focusin", onFocus, true);
+      portalNode.addEventListener("focusout", onFocus, true);
+      return () => {
+        portalNode.removeEventListener("focusin", onFocus, true);
+        portalNode.removeEventListener("focusout", onFocus, true);
+      };
+    }, [portalNode, preserveTabOrder]);
+    props = _5QY4WCTRcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => {
+        element = // While the portal node is not in the DOM, we need to pass the
+        // current context to the portal context, otherwise it's going to
+        // reset to the body element on nested portals.
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _NS56XHXGcjs.PortalContext.Provider, { value: portalNode || context, children: element });
+        if (!portal)
+          return element;
+        if (!portalNode) {
+          return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { ref: refProp, id: props.id, style: { position: "fixed" } });
+        }
+        element = /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          preserveTabOrder && portalNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _MAH7ORCZcjs.FocusTrap,
+            {
+              ref: beforeInsideRef,
+              onFocus: (event) => {
+                if (_events.isFocusEventOutside.call(void 0, event, portalNode)) {
+                  queueFocus(_focus.getNextTabbable.call(void 0, ));
+                } else {
+                  queueFocus(beforeOutsideRef.current);
+                }
+              }
+            }
+          ),
+          element,
+          preserveTabOrder && portalNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _MAH7ORCZcjs.FocusTrap,
+            {
+              ref: afterInsideRef,
+              onFocus: (event) => {
+                if (_events.isFocusEventOutside.call(void 0, event, portalNode)) {
+                  queueFocus(_focus.getPreviousTabbable.call(void 0, ));
+                } else {
+                  queueFocus(afterOutsideRef.current);
+                }
+              }
+            }
+          )
+        ] });
+        if (portalNode) {
+          element = _reactdom.createPortal.call(void 0, element, portalNode);
+        }
+        element = /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          preserveTabOrder && portalNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _MAH7ORCZcjs.FocusTrap,
+            {
+              ref: beforeOutsideRef,
+              onFocus: (event) => {
+                if (_events.isFocusEventOutside.call(void 0, event, portalNode)) {
+                  queueFocus(beforeInsideRef.current);
+                } else {
+                  queueFocus(_focus.getPreviousTabbable.call(void 0, ));
+                }
+              }
+            }
+          ),
+          preserveTabOrder && // We're using position: fixed here so that the browser doesn't
+          // add margin to the element when setting gap on a parent element.
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { "aria-owns": _optionalChain([portalNode, 'optionalAccess', _3 => _3.id]), style: { position: "fixed" } }),
+          element,
+          preserveTabOrder && portalNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _MAH7ORCZcjs.FocusTrap,
+            {
+              ref: afterOutsideRef,
+              onFocus: (event) => {
+                if (_events.isFocusEventOutside.call(void 0, event, portalNode)) {
+                  queueFocus(afterInsideRef.current);
+                } else {
+                  queueFocus(_focus.getNextTabbable.call(void 0, ));
+                }
+              }
+            }
+          )
+        ] });
+        return element;
+      },
+      [portalNode, context, portal, props.id, preserveTabOrder]
+    );
+    props = {
+      ...props,
+      ref: refProp
+    };
+    return props;
+  }
+);
+var Portal = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = usePortal(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Portal.displayName = "Portal";
+}
+
+
+
+
+exports.usePortal = usePortal; exports.Portal = Portal;

package/cjs/__chunks/IYRMREW7.cjs

@@ -0,0 +1,29 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+var _WYGT6WVDcjs = require('./WYGT6WVD.cjs');
+
+
+var _F6IOE5QTcjs = require('./F6IOE5QT.cjs');
+
+// src/hovercard/hovercard-store.ts
+var _hovercardstore = require('@ariakit/core/hovercard/hovercard-store'); var Core = _interopRequireWildcard(_hovercardstore);
+function useHovercardStoreOptions(props) {
+  return _WYGT6WVDcjs.usePopoverStoreOptions.call(void 0, props);
+}
+function useHovercardStoreProps(store, props) {
+  return _WYGT6WVDcjs.usePopoverStoreProps.call(void 0, store, props);
+}
+function useHovercardStore(props = {}) {
+  const options = useHovercardStoreOptions(props);
+  const store = _F6IOE5QTcjs.useStore.call(void 0, 
+    () => Core.createHovercardStore({ ...props, ...options })
+  );
+  return useHovercardStoreProps(store, props);
+}
+
+
+
+
+
+exports.useHovercardStoreOptions = useHovercardStoreOptions; exports.useHovercardStoreProps = useHovercardStoreProps; exports.useHovercardStore = useHovercardStore;

package/cjs/__chunks/IZT4J627.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _ET6BKYQAcjs = require('./ET6BKYQA.cjs');
+
+
+var _NVMBKFRBcjs = require('./NVMBKFRB.cjs');
+
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+// src/composite/composite-separator.ts
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+var useCompositeSeparator = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({ store, ...props }) => {
+    const context = _react.useContext.call(void 0, _NVMBKFRBcjs.CompositeContext);
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "CompositeSeparator must be wrapped in a Composite component"
+    );
+    const orientation = store.useState(
+      (state) => state.orientation === "horizontal" ? "vertical" : "horizontal"
+    );
+    props = _ET6BKYQAcjs.useSeparator.call(void 0, { ...props, orientation });
+    return props;
+  }
+);
+var CompositeSeparator = _UYIFJ7U3cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCompositeSeparator(props);
+    return _UYIFJ7U3cjs.createElement.call(void 0, "hr", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CompositeSeparator.displayName = "CompositeSeparator";
+}
+
+
+
+
+exports.useCompositeSeparator = useCompositeSeparator; exports.CompositeSeparator = CompositeSeparator;

package/cjs/__chunks/K56WQU76.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/group/group-label-context.ts
+var _react = require('react');
+var GroupLabelContext = _react.createContext.call(void 0, void 0);
+
+
+
+exports.GroupLabelContext = GroupLabelContext;