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/@ariakit/react-core/cjs/__chunks/23HLSVKM.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _IO6J4PANcjs = require('./IO6J4PAN.cjs');
+
+
+var _LYIGAIJFcjs = require('./LYIGAIJF.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/toolbar/toolbar-item.ts
+var useToolbarItem = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _LYIGAIJFcjs.useToolbarContext.call(void 0, );
+    store = store || context;
+    props = _IO6J4PANcjs.useCompositeItem.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store }, props));
+    return props;
+  }
+);
+var ToolbarItem = _RNZNGEL4cjs.createMemoComponent.call(void 0, (props) => {
+  const htmlProps = useToolbarItem(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "button", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  ToolbarItem.displayName = "ToolbarItem";
+}
+
+
+
+
+exports.useToolbarItem = useToolbarItem; exports.ToolbarItem = ToolbarItem;

node_modules/@ariakit/react-core/cjs/__chunks/2BIO7R5N.cjs

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

node_modules/@ariakit/react-core/cjs/__chunks/2KDFQUU7.cjs

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _KSAZE5E2cjs = require('./KSAZE5E2.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-group.ts
+var useCompositeGroup = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    props = _KSAZE5E2cjs.useGroup.call(void 0, props);
+    return props;
+  }
+);
+var CompositeGroup = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCompositeGroup(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CompositeGroup.displayName = "CompositeGroup";
+}
+
+
+
+
+exports.useCompositeGroup = useCompositeGroup; exports.CompositeGroup = CompositeGroup;

node_modules/@ariakit/react-core/cjs/__chunks/2WCJJQSK.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+var _UVBBMANLcjs = require('./UVBBMANL.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/select/select-context.tsx
+var _react = require('react');
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_UVBBMANLcjs.PopoverContextProvider, _UZNYSPKPcjs.CompositeContextProvider],
+  [_UVBBMANLcjs.PopoverScopedContextProvider, _UZNYSPKPcjs.CompositeScopedContextProvider]
+);
+var useSelectContext = ctx.useContext;
+var useSelectScopedContext = ctx.useScopedContext;
+var useSelectProviderContext = ctx.useProviderContext;
+var SelectContextProvider = ctx.ContextProvider;
+var SelectScopedContextProvider = ctx.ScopedContextProvider;
+var SelectItemCheckedContext = _react.createContext.call(void 0, false);
+
+
+
+
+
+
+
+
+exports.useSelectContext = useSelectContext; exports.useSelectScopedContext = useSelectScopedContext; exports.useSelectProviderContext = useSelectProviderContext; exports.SelectContextProvider = SelectContextProvider; exports.SelectScopedContextProvider = SelectScopedContextProvider; exports.SelectItemCheckedContext = SelectItemCheckedContext;

node_modules/@ariakit/react-core/cjs/__chunks/344F3DYO.cjs

@@ -0,0 +1,77 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _KREY6HXDcjs = require('./KREY6HXD.cjs');
+
+
+
+var _V24PR4PWcjs = require('./V24PR4PW.cjs');
+
+// src/dialog/utils/use-prevent-body-scroll.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _misc = require('@ariakit/core/utils/misc');
+var _platform = require('@ariakit/core/utils/platform');
+function getPaddingProperty(documentElement) {
+  const documentLeft = documentElement.getBoundingClientRect().left;
+  const scrollbarX = Math.round(documentLeft) + documentElement.scrollLeft;
+  return scrollbarX ? "paddingLeft" : "paddingRight";
+}
+function usePreventBodyScroll(contentElement, contentId, enabled) {
+  const isRootDialog = _KREY6HXDcjs.useRootDialog.call(void 0, {
+    attribute: "data-dialog-prevent-body-scroll",
+    contentElement,
+    contentId,
+    enabled
+  });
+  _react.useEffect.call(void 0, () => {
+    if (!isRootDialog())
+      return;
+    if (!contentElement)
+      return;
+    const doc = _dom.getDocument.call(void 0, contentElement);
+    const win = _dom.getWindow.call(void 0, contentElement);
+    const { documentElement, body } = doc;
+    const cssScrollbarWidth = documentElement.style.getPropertyValue("--scrollbar-width");
+    const scrollbarWidth = cssScrollbarWidth ? parseInt(cssScrollbarWidth) : win.innerWidth - documentElement.clientWidth;
+    const setScrollbarWidthProperty = () => _V24PR4PWcjs.setCSSProperty.call(void 0, 
+      documentElement,
+      "--scrollbar-width",
+      `${scrollbarWidth}px`
+    );
+    const paddingProperty = getPaddingProperty(documentElement);
+    const setStyle = () => _V24PR4PWcjs.assignStyle.call(void 0, body, {
+      overflow: "hidden",
+      [paddingProperty]: `${scrollbarWidth}px`
+    });
+    const setIOSStyle = () => {
+      var _a, _b;
+      const { scrollX, scrollY, visualViewport } = win;
+      const offsetLeft = (_a = visualViewport == null ? void 0 : visualViewport.offsetLeft) != null ? _a : 0;
+      const offsetTop = (_b = visualViewport == null ? void 0 : visualViewport.offsetTop) != null ? _b : 0;
+      const restoreStyle = _V24PR4PWcjs.assignStyle.call(void 0, body, {
+        position: "fixed",
+        overflow: "hidden",
+        top: `${-(scrollY - Math.floor(offsetTop))}px`,
+        left: `${-(scrollX - Math.floor(offsetLeft))}px`,
+        right: "0",
+        [paddingProperty]: `${scrollbarWidth}px`
+      });
+      return () => {
+        restoreStyle();
+        if (process.env.NODE_ENV !== "test") {
+          win.scrollTo(scrollX, scrollY);
+        }
+      };
+    };
+    const isIOS = _platform.isApple.call(void 0, ) && !_platform.isMac.call(void 0, );
+    return _misc.chain.call(void 0, 
+      setScrollbarWidthProperty(),
+      isIOS ? setIOSStyle() : setStyle()
+    );
+  }, [isRootDialog, contentElement]);
+}
+
+
+
+exports.usePreventBodyScroll = usePreventBodyScroll;

node_modules/@ariakit/react-core/cjs/__chunks/3QW6ELTG.cjs

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _UVBBMANLcjs = require('./UVBBMANL.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/popover/popover-anchor.ts
+var usePopoverAnchor = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _UVBBMANLcjs.usePopoverProviderContext.call(void 0, );
+    store = store || context;
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, store == null ? void 0 : store.setAnchorElement, props.ref)
+    });
+    return props;
+  }
+);
+var PopoverAnchor = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = usePopoverAnchor(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  PopoverAnchor.displayName = "PopoverAnchor";
+}
+
+
+
+
+exports.usePopoverAnchor = usePopoverAnchor; exports.PopoverAnchor = PopoverAnchor;

node_modules/@ariakit/react-core/cjs/__chunks/3W6FH6JK.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _UVBBMANLcjs = require('./UVBBMANL.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/hovercard/hovercard-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_UVBBMANLcjs.PopoverContextProvider],
+  [_UVBBMANLcjs.PopoverScopedContextProvider]
+);
+var useHovercardContext = ctx.useContext;
+var useHovercardScopedContext = ctx.useScopedContext;
+var useHovercardProviderContext = ctx.useProviderContext;
+var HovercardContextProvider = ctx.ContextProvider;
+var HovercardScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useHovercardContext = useHovercardContext; exports.useHovercardScopedContext = useHovercardScopedContext; exports.useHovercardProviderContext = useHovercardProviderContext; exports.HovercardContextProvider = HovercardContextProvider; exports.HovercardScopedContextProvider = HovercardScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/3WCBE6SU.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+var _UVBBMANLcjs = require('./UVBBMANL.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/combobox/combobox-context.tsx
+var _react = require('react');
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_UVBBMANLcjs.PopoverContextProvider, _UZNYSPKPcjs.CompositeContextProvider],
+  [_UVBBMANLcjs.PopoverScopedContextProvider, _UZNYSPKPcjs.CompositeScopedContextProvider]
+);
+var useComboboxContext = ctx.useContext;
+var useComboboxScopedContext = ctx.useScopedContext;
+var useComboboxProviderContext = ctx.useProviderContext;
+var ComboboxContextProvider = ctx.ContextProvider;
+var ComboboxScopedContextProvider = ctx.ScopedContextProvider;
+var ComboboxItemValueContext = _react.createContext.call(void 0, 
+  void 0
+);
+var ComboboxItemCheckedContext = _react.createContext.call(void 0, false);
+
+
+
+
+
+
+
+
+
+exports.useComboboxContext = useComboboxContext; exports.useComboboxScopedContext = useComboboxScopedContext; exports.useComboboxProviderContext = useComboboxProviderContext; exports.ComboboxContextProvider = ComboboxContextProvider; exports.ComboboxScopedContextProvider = ComboboxScopedContextProvider; exports.ComboboxItemValueContext = ComboboxItemValueContext; exports.ComboboxItemCheckedContext = ComboboxItemCheckedContext;

node_modules/@ariakit/react-core/cjs/__chunks/3XQOWQTT.cjs

@@ -0,0 +1,36 @@
+"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; } }"use client";
+
+
+var _LUL2YWZ3cjs = require('./LUL2YWZ3.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/tab/tab-store.ts
+var _react = require('react');
+var _tabstore = require('@ariakit/core/tab/tab-store'); var Core = _interopRequireWildcard(_tabstore);
+function useTabStoreProps(store, update, props) {
+  store = _LUL2YWZ3cjs.useCompositeStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "selectedId", "setSelectedId");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "selectOnMove");
+  const [panels, updatePanels] = _OLOZ5JT2cjs.useStore.call(void 0, () => store.panels, {});
+  _EO6LS72Hcjs.useUpdateEffect.call(void 0, updatePanels, [store, updatePanels]);
+  return _react.useMemo.call(void 0, () => _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, store), { panels }), [store, panels]);
+}
+function useTabStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createTabStore, props);
+  return useTabStoreProps(store, update, props);
+}
+
+
+
+
+exports.useTabStoreProps = useTabStoreProps; exports.useTabStore = useTabStore;

node_modules/@ariakit/react-core/cjs/__chunks/4VMHQGZH.cjs

@@ -0,0 +1,26 @@
+"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; } }"use client";
+
+
+var _OZ4FTKEHcjs = require('./OZ4FTKEH.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+// src/tooltip/tooltip-store.ts
+var _tooltipstore = require('@ariakit/core/tooltip/tooltip-store'); var Core = _interopRequireWildcard(_tooltipstore);
+function useTooltipStoreProps(store, update, props) {
+  store = _OZ4FTKEHcjs.useHovercardStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "type");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "skipTimeout");
+  return store;
+}
+function useTooltipStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createTooltipStore, props);
+  return useTooltipStoreProps(store, update, props);
+}
+
+
+
+
+exports.useTooltipStoreProps = useTooltipStoreProps; exports.useTooltipStore = useTooltipStore;

node_modules/@ariakit/react-core/cjs/__chunks/5GTNIPQ6.cjs

@@ -0,0 +1,80 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _V24PR4PWcjs = require('./V24PR4PW.cjs');
+
+// src/dialog/utils/walk-tree-outside.ts
+var _dom = require('@ariakit/core/utils/dom');
+var _misc = require('@ariakit/core/utils/misc');
+var ignoreTags = ["SCRIPT", "STYLE"];
+function getSnapshotPropertyName(id) {
+  return `__ariakit-dialog-snapshot-${id}`;
+}
+function inSnapshot(id, element) {
+  const doc = _dom.getDocument.call(void 0, element);
+  const propertyName = getSnapshotPropertyName(id);
+  if (!doc.body[propertyName])
+    return true;
+  do {
+    if (element === doc.body)
+      return false;
+    if (!!element[propertyName])
+      return true;
+    if (!element.parentElement)
+      return false;
+    element = element.parentElement;
+  } while (true);
+}
+function isValidElement(id, element, ignoredElements) {
+  if (ignoreTags.includes(element.tagName))
+    return false;
+  if (!inSnapshot(id, element))
+    return false;
+  return !ignoredElements.some(
+    (enabledElement) => enabledElement && _dom.contains.call(void 0, element, enabledElement)
+  );
+}
+function walkTreeOutside(id, elements, callback, ancestorCallback) {
+  for (let element of elements) {
+    if (!(element == null ? void 0 : element.isConnected))
+      continue;
+    const hasAncestorAlready = elements.some((maybeAncestor) => {
+      if (!maybeAncestor)
+        return false;
+      if (maybeAncestor === element)
+        return false;
+      return maybeAncestor.contains(element);
+    });
+    const doc = _dom.getDocument.call(void 0, element);
+    const originalElement = element;
+    while (element.parentElement && element !== doc.body) {
+      ancestorCallback == null ? void 0 : ancestorCallback(element.parentElement, originalElement);
+      if (!hasAncestorAlready) {
+        for (const child of element.parentElement.children) {
+          if (isValidElement(id, child, elements)) {
+            callback(child, originalElement);
+          }
+        }
+      }
+      element = element.parentElement;
+    }
+  }
+}
+function createWalkTreeSnapshot(id, elements) {
+  const { body } = _dom.getDocument.call(void 0, elements[0]);
+  const cleanups = [];
+  const markElement = (element) => {
+    cleanups.push(_V24PR4PWcjs.setProperty.call(void 0, element, getSnapshotPropertyName(id), true));
+  };
+  walkTreeOutside(id, elements, markElement);
+  return _misc.chain.call(void 0, 
+    _V24PR4PWcjs.setProperty.call(void 0, body, getSnapshotPropertyName(id), true),
+    () => cleanups.forEach((fn) => fn())
+  );
+}
+
+
+
+
+
+exports.isValidElement = isValidElement; exports.walkTreeOutside = walkTreeOutside; exports.createWalkTreeSnapshot = createWalkTreeSnapshot;

node_modules/@ariakit/react-core/cjs/__chunks/5UTRYT6E.cjs

@@ -0,0 +1,52 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _DAJUUBUIcjs = require('./DAJUUBUI.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/button/button.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var useButton = _RNZNGEL4cjs.createHook.call(void 0, (props) => {
+  const ref = _react.useRef.call(void 0, null);
+  const tagName = _EO6LS72Hcjs.useTagName.call(void 0, ref, props.as || "button");
+  const [isNativeButton, setIsNativeButton] = _react.useState.call(void 0, 
+    () => !!tagName && _dom.isButton.call(void 0, { tagName, type: props.type })
+  );
+  _react.useEffect.call(void 0, () => {
+    if (!ref.current)
+      return;
+    setIsNativeButton(_dom.isButton.call(void 0, ref.current));
+  }, []);
+  props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+    role: !isNativeButton && tagName !== "a" ? "button" : void 0
+  }, props), {
+    ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref)
+  });
+  props = _DAJUUBUIcjs.useCommand.call(void 0, props);
+  return props;
+});
+var Button = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useButton(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "button", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Button.displayName = "Button";
+}
+
+
+
+
+exports.useButton = useButton; exports.Button = Button;

node_modules/@ariakit/react-core/cjs/__chunks/5ZOCN23X.cjs

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+// src/dialog/utils/use-nested-dialogs.tsx
+
+
+
+
+
+
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+var _store = require('@ariakit/core/utils/store');
+var _jsxruntime = require('react/jsx-runtime');
+var NestedDialogsContext = _react.createContext.call(void 0, {});
+function useNestedDialogs(store) {
+  const context = _react.useContext.call(void 0, NestedDialogsContext);
+  const [dialogs, setDialogs] = _react.useState.call(void 0, []);
+  const add = _react.useCallback.call(void 0, 
+    (dialog) => {
+      var _a;
+      setDialogs((dialogs2) => [...dialogs2, dialog]);
+      return _misc.chain.call(void 0, (_a = context.add) == null ? void 0 : _a.call(context, dialog), () => {
+        setDialogs((dialogs2) => dialogs2.filter((d) => d !== dialog));
+      });
+    },
+    [context]
+  );
+  _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+    return _store.sync.call(void 0, store, ["open", "contentElement"], (state) => {
+      var _a;
+      if (!state.open)
+        return;
+      if (!state.contentElement)
+        return;
+      return (_a = context.add) == null ? void 0 : _a.call(context, store);
+    });
+  }, [store, context]);
+  const providerValue = _react.useMemo.call(void 0, () => ({ store, add }), [store, add]);
+  const wrapElement = _react.useCallback.call(void 0, 
+    (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NestedDialogsContext.Provider, { value: providerValue, children: element }),
+    [providerValue]
+  );
+  return { wrapElement, nestedDialogs: dialogs };
+}
+
+
+
+exports.useNestedDialogs = useNestedDialogs;

node_modules/@ariakit/react-core/cjs/__chunks/62JWM3VQ.cjs

@@ -0,0 +1,49 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _F2A2ZQDBcjs = require('./F2A2ZQDB.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/dialog/dialog-description.ts
+var _react = require('react');
+var useDialogDescription = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const setDescriptionId = _react.useContext.call(void 0, _F2A2ZQDBcjs.DialogDescriptionContext);
+    const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+    _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+      setDescriptionId == null ? void 0 : setDescriptionId(id);
+      return () => setDescriptionId == null ? void 0 : setDescriptionId(void 0);
+    }, [setDescriptionId, id]);
+    props = _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      id
+    }, props);
+    return props;
+  }
+);
+var DialogDescription = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useDialogDescription(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "p", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  DialogDescription.displayName = "DialogDescription";
+}
+
+
+
+
+exports.useDialogDescription = useDialogDescription; exports.DialogDescription = DialogDescription;

node_modules/@ariakit/react-core/cjs/__chunks/63UPRTFZ.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/checkbox/checkbox-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, );
+var useCheckboxContext = ctx.useContext;
+var useCheckboxScopedContext = ctx.useScopedContext;
+var useCheckboxProviderContext = ctx.useProviderContext;
+var CheckboxContextProvider = ctx.ContextProvider;
+var CheckboxScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useCheckboxContext = useCheckboxContext; exports.useCheckboxScopedContext = useCheckboxScopedContext; exports.useCheckboxProviderContext = useCheckboxProviderContext; exports.CheckboxContextProvider = CheckboxContextProvider; exports.CheckboxScopedContextProvider = CheckboxScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/65LGW5LY.cjs

@@ -0,0 +1,285 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _XB3G2EO2cjs = require('./XB3G2EO2.cjs');
+
+
+var _CVD2AZE2cjs = require('./CVD2AZE2.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+var _CJDHQUBRcjs = require('./CJDHQUBR.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.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(() => {
+    element == null ? void 0 : element.focus();
+  });
+}
+var usePortal = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      preserveTabOrder,
+      preserveTabOrderAnchor,
+      portalElement,
+      portalRef,
+      portal = true
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "preserveTabOrder",
+      "preserveTabOrderAnchor",
+      "portalElement",
+      "portalRef",
+      "portal"
+    ]);
+    const ref = _react.useRef.call(void 0, null);
+    const refProp = _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref);
+    const context = _react.useContext.call(void 0, _CVD2AZE2cjs.PortalContext);
+    const [portalNode, setPortalNode] = _react.useState.call(void 0, null);
+    const [anchorPortalNode, setAnchorPortalNode] = _react.useState.call(void 0, null);
+    const outerBeforeRef = _react.useRef.call(void 0, null);
+    const innerBeforeRef = _react.useRef.call(void 0, null);
+    const innerAfterRef = _react.useRef.call(void 0, null);
+    const outerAfterRef = _react.useRef.call(void 0, null);
+    _EO6LS72Hcjs.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 ? `portal/${element.id}` : getRandomId();
+      }
+      setPortalNode(portalEl);
+      _CJDHQUBRcjs.setRef.call(void 0, portalRef, portalEl);
+      if (isPortalInDocument)
+        return;
+      return () => {
+        portalEl.remove();
+        _CJDHQUBRcjs.setRef.call(void 0, portalRef, null);
+      };
+    }, [portal, portalElement, context, portalRef]);
+    _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (!preserveTabOrder)
+        return;
+      if (!preserveTabOrderAnchor)
+        return;
+      const doc = _dom.getDocument.call(void 0, preserveTabOrderAnchor);
+      const element = doc.createElement("span");
+      element.style.position = "fixed";
+      preserveTabOrderAnchor.insertAdjacentElement("afterend", element);
+      setAnchorPortalNode(element);
+      return () => {
+        element.remove();
+        setAnchorPortalNode(null);
+      };
+    }, [preserveTabOrder, preserveTabOrderAnchor]);
+    _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";
+        cancelAnimationFrame(raf);
+        if (focusing) {
+          return _focus.restoreFocusIn.call(void 0, portalNode);
+        }
+        raf = requestAnimationFrame(() => {
+          _focus.disableFocusIn.call(void 0, portalNode, true);
+        });
+      };
+      portalNode.addEventListener("focusin", onFocus, true);
+      portalNode.addEventListener("focusout", onFocus, true);
+      return () => {
+        cancelAnimationFrame(raf);
+        portalNode.removeEventListener("focusin", onFocus, true);
+        portalNode.removeEventListener("focusout", onFocus, true);
+      };
+    }, [portalNode, preserveTabOrder]);
+    props = _EO6LS72Hcjs.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, _CVD2AZE2cjs.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" },
+              hidden: true
+            }
+          );
+        }
+        element = /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          preserveTabOrder && portalNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _XB3G2EO2cjs.FocusTrap,
+            {
+              ref: innerBeforeRef,
+              className: "__focus-trap-inner-before",
+              onFocus: (event) => {
+                if (_events.isFocusEventOutside.call(void 0, event, portalNode)) {
+                  queueFocus(_focus.getNextTabbable.call(void 0, ));
+                } else {
+                  queueFocus(outerBeforeRef.current);
+                }
+              }
+            }
+          ),
+          element,
+          preserveTabOrder && portalNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _XB3G2EO2cjs.FocusTrap,
+            {
+              ref: innerAfterRef,
+              className: "__focus-trap-inner-after",
+              onFocus: (event) => {
+                if (_events.isFocusEventOutside.call(void 0, event, portalNode)) {
+                  queueFocus(_focus.getPreviousTabbable.call(void 0, ));
+                } else {
+                  queueFocus(outerAfterRef.current);
+                }
+              }
+            }
+          )
+        ] });
+        if (portalNode) {
+          element = _reactdom.createPortal.call(void 0, element, portalNode);
+        }
+        let preserveTabOrderElement = /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          preserveTabOrder && portalNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _XB3G2EO2cjs.FocusTrap,
+            {
+              ref: outerBeforeRef,
+              className: "__focus-trap-outer-before",
+              onFocus: (event) => {
+                const fromOuter = event.relatedTarget === outerAfterRef.current;
+                if (!fromOuter && _events.isFocusEventOutside.call(void 0, event, portalNode)) {
+                  queueFocus(innerBeforeRef.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": portalNode == null ? void 0 : portalNode.id, style: { position: "fixed" } }),
+          preserveTabOrder && portalNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _XB3G2EO2cjs.FocusTrap,
+            {
+              ref: outerAfterRef,
+              className: "__focus-trap-outer-after",
+              onFocus: (event) => {
+                if (_events.isFocusEventOutside.call(void 0, event, portalNode)) {
+                  queueFocus(innerAfterRef.current);
+                } else {
+                  const nextTabbable = _focus.getNextTabbable.call(void 0, );
+                  if (nextTabbable === innerBeforeRef.current) {
+                    requestAnimationFrame(() => {
+                      var _a2;
+                      return (_a2 = _focus.getNextTabbable.call(void 0, )) == null ? void 0 : _a2.focus();
+                    });
+                    return;
+                  }
+                  queueFocus(nextTabbable);
+                }
+              }
+            }
+          )
+        ] });
+        if (anchorPortalNode && preserveTabOrder) {
+          preserveTabOrderElement = _reactdom.createPortal.call(void 0, 
+            preserveTabOrderElement,
+            anchorPortalNode
+          );
+        }
+        return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          preserveTabOrderElement,
+          element
+        ] });
+      },
+      [
+        portalNode,
+        context,
+        portal,
+        props.id,
+        preserveTabOrder,
+        anchorPortalNode
+      ]
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      ref: refProp
+    });
+    return props;
+  }
+);
+var Portal = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = usePortal(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Portal.displayName = "Portal";
+}
+
+
+
+
+exports.usePortal = usePortal; exports.Portal = Portal;

node_modules/@ariakit/react-core/cjs/__chunks/6IUEXB4L.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+// src/dialog/utils/supports-inert.ts
+function supportsInert() {
+  return "inert" in HTMLElement.prototype;
+}
+
+
+
+exports.supportsInert = supportsInert;

node_modules/@ariakit/react-core/cjs/__chunks/6LVRCU4J.cjs

@@ -0,0 +1,715 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _BZTDJIVTcjs = require('./BZTDJIVT.cjs');
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/collection/collection-renderer.tsx
+
+
+
+
+
+
+
+
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _misc = require('@ariakit/core/utils/misc');
+var _reactdom = require('react-dom');
+var _jsxruntime = require('react/jsx-runtime');
+var CollectionRendererContext = _react.createContext.call(void 0, null);
+function createTask() {
+  let raf = 0;
+  const run = (cb) => {
+    if (raf)
+      return;
+    raf = requestAnimationFrame(() => {
+      raf = 0;
+      cb();
+    });
+  };
+  const cancel = () => {
+    cancelAnimationFrame(raf);
+    raf = 0;
+  };
+  return { run, cancel };
+}
+function findNearestIndex(items, target, getValue) {
+  let left = 0;
+  let right = getItemsLength(items) - 1;
+  while (left <= right) {
+    const index = (left + right) / 2 | 0;
+    const value = getValue(index);
+    if (value === target)
+      return index;
+    else if (value < target)
+      left = index + 1;
+    else
+      right = index - 1;
+  }
+  if (left > 0)
+    return left - 1;
+  return 0;
+}
+function getItemsLength(items) {
+  return typeof items === "number" ? items : items.length;
+}
+function getItemObject(item) {
+  if (!item || typeof item !== "object") {
+    return { value: item };
+  }
+  return item;
+}
+function getItemId(item, index, baseId) {
+  var _a;
+  _misc.invariant.call(void 0, baseId, "CollectionRenderer must be given an `id` prop.");
+  const defaultId = `${baseId}/${index}`;
+  return (_a = getItemObject(item).id) != null ? _a : defaultId;
+}
+function getItem(items, index) {
+  if (typeof items === "number") {
+    if (index >= items)
+      return null;
+    return {};
+  }
+  const item = items[index];
+  if (!item)
+    return null;
+  if (typeof item === "object")
+    return item;
+  return { value: item };
+}
+function getItemSize(item, horizontal, fallbackElement) {
+  var _a, _b, _c, _d, _e;
+  const itemObject = getItemObject(item);
+  horizontal = itemObject.orientation === "horizontal";
+  const prop = horizontal ? "width" : "height";
+  const style = itemObject.style;
+  if (style) {
+    const size = style[prop];
+    if (typeof size === "number")
+      return size;
+  }
+  const items = itemObject.items;
+  if (items == null ? void 0 : items.length) {
+    const hasSameOrientation = !itemObject.orientation || horizontal && itemObject.orientation === "horizontal" || !horizontal && itemObject.orientation === "vertical";
+    const paddingStart = (_b = (_a = itemObject.paddingStart) != null ? _a : itemObject.padding) != null ? _b : 0;
+    const paddingEnd = (_d = (_c = itemObject.paddingEnd) != null ? _c : itemObject.padding) != null ? _d : 0;
+    const padding = hasSameOrientation ? paddingStart + paddingEnd : 0;
+    const initialSize = ((_e = itemObject.gap) != null ? _e : 0) * (items.length - 1) + padding;
+    if (hasSameOrientation && itemObject.itemSize) {
+      return initialSize + itemObject.itemSize * items.length;
+    }
+    const totalSize = items.reduce(
+      (sum, item2) => sum + getItemSize(item2, horizontal),
+      initialSize
+    );
+    if (totalSize !== initialSize)
+      return totalSize;
+  }
+  const element = fallbackElement !== false ? itemObject.element || fallbackElement : null;
+  if (element == null ? void 0 : element.isConnected) {
+    return element.getBoundingClientRect()[prop];
+  }
+  return 0;
+}
+function getAverageSize(props) {
+  const length = getItemsLength(props.items);
+  let currentIndex = 0;
+  let averageSize = props.estimatedItemSize;
+  const setAverageSize = (size) => {
+    const prevIndex = currentIndex;
+    currentIndex = currentIndex + 1;
+    averageSize = (averageSize * prevIndex + size) / currentIndex;
+  };
+  for (let index = 0; index < length; index += 1) {
+    const item = getItem(props.items, index);
+    const itemId = getItemId(item, index, props.baseId);
+    const itemData = props.data.get(itemId);
+    const fallbackElement = props.elements.get(itemId);
+    const size = getItemSize(item, props.horizontal, fallbackElement);
+    if (size) {
+      setAverageSize(size);
+    } else if (itemData == null ? void 0 : itemData.rendered) {
+      setAverageSize(itemData.end - itemData.start);
+    }
+  }
+  return averageSize;
+}
+function getScrollOffset(scroller, horizontal) {
+  if ("scrollX" in scroller) {
+    return horizontal ? scroller.scrollX : scroller.scrollY;
+  }
+  return horizontal ? scroller.scrollLeft : scroller.scrollTop;
+}
+function getViewport(scroller) {
+  const { defaultView, documentElement } = scroller.ownerDocument;
+  if (scroller === documentElement)
+    return defaultView;
+  return scroller;
+}
+function useScroller(rendererRef) {
+  const [scroller, setScroller] = _react.useState.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    const renderer = rendererRef == null ? void 0 : rendererRef.current;
+    if (!renderer)
+      return;
+    const scroller2 = _dom.getScrollingElement.call(void 0, renderer);
+    if (!scroller2)
+      return;
+    setScroller(scroller2);
+  }, [rendererRef]);
+  return scroller;
+}
+function getRendererOffset(renderer, scroller, horizontal) {
+  const win = _dom.getWindow.call(void 0, renderer);
+  const htmlElement = win == null ? void 0 : win.document.documentElement;
+  const rendererRect = renderer.getBoundingClientRect();
+  const rendererOffset = horizontal ? rendererRect.left : rendererRect.top;
+  if (scroller === htmlElement) {
+    const scrollOffset2 = getScrollOffset(win, horizontal);
+    return scrollOffset2 + rendererOffset;
+  }
+  const scrollerRect = scroller.getBoundingClientRect();
+  const scrollerOffset = horizontal ? scrollerRect.left : scrollerRect.top;
+  const scrollOffset = getScrollOffset(scroller, horizontal);
+  return rendererOffset - scrollerOffset + scrollOffset;
+}
+function getOffsets(renderer, scroller, horizontal) {
+  const scrollOffset = getScrollOffset(scroller, horizontal);
+  const rendererOffset = getRendererOffset(renderer, scroller, horizontal);
+  const scrollSize = horizontal ? scroller.clientWidth : scroller.clientHeight;
+  const start = scrollOffset - rendererOffset;
+  const end = start + scrollSize;
+  return { start, end };
+}
+function getItemsEnd(props) {
+  const length = getItemsLength(props.items);
+  const totalPadding = props.paddingStart + props.paddingEnd;
+  if (!length)
+    return totalPadding;
+  const lastIndex = length - 1;
+  const totalGap = lastIndex * props.gap;
+  if (props.itemSize != null) {
+    return length * props.itemSize + totalGap + totalPadding;
+  }
+  const defaultEnd = length * props.estimatedItemSize + totalGap + totalPadding;
+  if (!props.baseId)
+    return defaultEnd;
+  const lastItem = getItem(props.items, lastIndex);
+  const lastItemId = getItemId(lastItem, lastIndex, props.baseId);
+  const lastItemData = props.data.get(lastItemId);
+  if (lastItemData == null ? void 0 : lastItemData.end)
+    return lastItemData.end + props.paddingEnd;
+  if (!Array.isArray(props.items))
+    return defaultEnd;
+  const end = props.items.reduce(
+    (sum, item) => sum + getItemSize(item, props.horizontal, false),
+    0
+  );
+  if (!end)
+    return defaultEnd;
+  return end + totalGap + totalPadding;
+}
+function getData(props) {
+  var _a;
+  const length = getItemsLength(props.items);
+  let nextData;
+  let start = props.paddingStart;
+  const avgSize = getAverageSize(props);
+  for (let index = 0; index < length; index += 1) {
+    const item = getItem(props.items, index);
+    const itemId = getItemId(item, index, props.baseId);
+    const itemData = props.data.get(itemId);
+    const prevRendered = (_a = itemData == null ? void 0 : itemData.rendered) != null ? _a : false;
+    const setSize = (size2, rendered = prevRendered) => {
+      start = start ? start + props.gap : start;
+      const end = start + size2;
+      const nextItemData = { index, rendered, start, end };
+      if (!_misc.shallowEqual.call(void 0, itemData, nextItemData)) {
+        if (!nextData) {
+          nextData = new Map(props.data);
+        }
+        nextData.set(itemId, { index, rendered, start, end });
+      }
+      start = end;
+    };
+    const size = getItemSize(
+      item,
+      props.horizontal,
+      props.elements.get(itemId)
+    );
+    if (size) {
+      setSize(size, true);
+    } else if (itemData == null ? void 0 : itemData.rendered) {
+      setSize(itemData.end - itemData.start, true);
+    } else {
+      setSize(avgSize);
+    }
+  }
+  return nextData;
+}
+function useCollectionRenderer(_a) {
+  var _b = _a, {
+    store,
+    items: itemsProp,
+    initialItems = 0,
+    gap = 0,
+    itemSize,
+    estimatedItemSize = 40,
+    overscan: overscanProp,
+    orientation: orientationProp,
+    padding = 0,
+    paddingStart = padding,
+    paddingEnd = padding,
+    persistentIndices,
+    renderOnScroll = true,
+    renderOnResize = !!renderOnScroll,
+    children: renderItem
+  } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+    "store",
+    "items",
+    "initialItems",
+    "gap",
+    "itemSize",
+    "estimatedItemSize",
+    "overscan",
+    "orientation",
+    "padding",
+    "paddingStart",
+    "paddingEnd",
+    "persistentIndices",
+    "renderOnScroll",
+    "renderOnResize",
+    "children"
+  ]);
+  var _a2, _b2;
+  const context = _BZTDJIVTcjs.useCollectionContext.call(void 0, );
+  store = store || context;
+  const items = _OLOZ5JT2cjs.useStoreState.call(void 0, 
+    store,
+    (state) => itemsProp != null ? itemsProp : state == null ? void 0 : state.items
+  );
+  _misc.invariant.call(void 0, 
+    items != null,
+    process.env.NODE_ENV !== "production" && "CollectionRenderer must be either wrapped in a Collection component or be given an `items` prop."
+  );
+  let parent = _react.useContext.call(void 0, CollectionRendererContext);
+  if (store && (parent == null ? void 0 : parent.store) !== store) {
+    parent = null;
+  }
+  const parentData = parent == null ? void 0 : parent.childrenData;
+  const orientation = (_a2 = orientationProp != null ? orientationProp : parent == null ? void 0 : parent.orientation) != null ? _a2 : "vertical";
+  const overscan = (_b2 = overscanProp != null ? overscanProp : parent == null ? void 0 : parent.overscan) != null ? _b2 : 1;
+  const ref = _react.useRef.call(void 0, null);
+  const baseId = _EO6LS72Hcjs.useId.call(void 0, props.id);
+  const horizontal = orientation === "horizontal";
+  const elements = _react.useMemo.call(void 0, () => /* @__PURE__ */ new Map(), []);
+  const [elementsUpdated, updateElements] = _EO6LS72Hcjs.useForceUpdate.call(void 0, );
+  const [defaultVisibleIndices, setVisibleIndices] = _react.useState.call(void 0, () => {
+    if (!initialItems)
+      return [];
+    const length = getItemsLength(items);
+    const initialLength = Math.min(length, Math.abs(initialItems));
+    return Array.from({ length: initialLength }, (_, index) => {
+      if (initialItems < 0)
+        return length - index - 1;
+      return index;
+    });
+  });
+  const visibleIndices = _react.useMemo.call(void 0, () => {
+    if (!persistentIndices)
+      return defaultVisibleIndices;
+    const nextIndices = defaultVisibleIndices.slice();
+    persistentIndices.forEach((index) => {
+      if (index < 0)
+        return;
+      if (nextIndices.includes(index))
+        return;
+      nextIndices.push(index);
+    });
+    nextIndices.sort((a, b) => a - b);
+    if (_misc.shallowEqual.call(void 0, defaultVisibleIndices, nextIndices)) {
+      return defaultVisibleIndices;
+    }
+    return nextIndices;
+  }, [defaultVisibleIndices, persistentIndices]);
+  const [data, setData] = _react.useState.call(void 0, () => {
+    if (!baseId)
+      return /* @__PURE__ */ new Map();
+    const data2 = (parentData == null ? void 0 : parentData.get(baseId)) || /* @__PURE__ */ new Map();
+    if (itemSize != null)
+      return data2;
+    if (!items)
+      return data2;
+    const nextData = getData({
+      baseId,
+      items,
+      data: data2,
+      gap,
+      elements,
+      horizontal,
+      paddingStart,
+      itemSize,
+      estimatedItemSize
+    });
+    return nextData || data2;
+  });
+  const totalSize = _react.useMemo.call(void 0, () => {
+    return getItemsEnd({
+      baseId,
+      items,
+      data,
+      gap,
+      horizontal,
+      itemSize,
+      estimatedItemSize,
+      paddingStart,
+      paddingEnd
+    });
+  }, [
+    baseId,
+    items,
+    data,
+    gap,
+    horizontal,
+    itemSize,
+    estimatedItemSize,
+    paddingStart,
+    paddingEnd
+  ]);
+  _react.useEffect.call(void 0, () => {
+    if (!baseId)
+      return;
+    parentData == null ? void 0 : parentData.set(baseId, data);
+  }, [baseId, parentData, data]);
+  _react.useEffect.call(void 0, () => {
+    if (itemSize != null)
+      return;
+    if (!baseId)
+      return;
+    if (!items)
+      return;
+    const nextData = getData({
+      baseId,
+      items,
+      data,
+      gap,
+      elements,
+      horizontal,
+      paddingStart,
+      itemSize,
+      estimatedItemSize
+    });
+    if (nextData) {
+      setData(nextData);
+    }
+  }, [
+    elementsUpdated,
+    itemSize,
+    baseId,
+    items,
+    data,
+    gap,
+    elements,
+    horizontal,
+    paddingStart,
+    estimatedItemSize
+  ]);
+  const scroller = useScroller(items ? ref : null);
+  const offsetsRef = _react.useRef.call(void 0, { start: 0, end: 0 });
+  const processVisibleIndices = _react.useCallback.call(void 0, () => {
+    const offsets = offsetsRef.current;
+    if (!items)
+      return;
+    if (!baseId)
+      return;
+    if (!offsets.end)
+      return;
+    if (!data.size && !itemSize)
+      return;
+    const length = getItemsLength(items);
+    const getItemOffset = (index, prop = "start") => {
+      var _a3;
+      if (itemSize) {
+        const start2 = itemSize * index + gap * index + paddingStart;
+        if (prop === "start")
+          return start2;
+        return start2 + itemSize;
+      }
+      const item = getItem(items, index);
+      const itemId = getItemId(item, index, baseId);
+      const itemData = data.get(itemId);
+      return (_a3 = itemData == null ? void 0 : itemData[prop]) != null ? _a3 : 0;
+    };
+    const initialStart = findNearestIndex(items, offsets.start, getItemOffset);
+    let initialEnd = initialStart;
+    while (initialEnd < length && getItemOffset(initialEnd) < offsets.end) {
+      initialEnd += 1;
+    }
+    const finalOverscan = initialEnd - initialStart ? overscan : 0;
+    const start = Math.max(initialStart - finalOverscan, 0);
+    const end = Math.min(initialEnd + finalOverscan, length);
+    const indices = Array.from(
+      { length: end - start },
+      (_, index) => index + start
+    );
+    setVisibleIndices((prevIndices) => {
+      if (_misc.shallowEqual.call(void 0, prevIndices, indices))
+        return prevIndices;
+      return indices;
+    });
+  }, [
+    elementsUpdated,
+    items,
+    baseId,
+    data,
+    itemSize,
+    gap,
+    paddingStart,
+    overscan
+  ]);
+  _react.useEffect.call(void 0, processVisibleIndices, [processVisibleIndices]);
+  const processVisibleIndicesEvent = _EO6LS72Hcjs.useEvent.call(void 0, processVisibleIndices);
+  _react.useEffect.call(void 0, () => {
+    const renderer = ref.current;
+    if (!renderer)
+      return;
+    if (!scroller)
+      return;
+    offsetsRef.current = getOffsets(renderer, scroller, horizontal);
+    processVisibleIndicesEvent();
+  }, [scroller, horizontal, processVisibleIndicesEvent]);
+  const mayRenderOnScroll = !!renderOnScroll;
+  const renderOnScrollProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, renderOnScroll);
+  _react.useEffect.call(void 0, () => {
+    if (!mayRenderOnScroll)
+      return;
+    const renderer = ref.current;
+    if (!renderer)
+      return;
+    if (!scroller)
+      return;
+    const viewport = getViewport(scroller);
+    if (!viewport)
+      return;
+    const task = createTask();
+    const onScroll = (event) => {
+      task.run(() => {
+        if (!renderOnScrollProp(event))
+          return;
+        offsetsRef.current = getOffsets(renderer, scroller, horizontal);
+        processVisibleIndicesEvent();
+      });
+    };
+    viewport.addEventListener("scroll", onScroll, { passive: true });
+    return () => {
+      task.cancel();
+      viewport.removeEventListener("scroll", onScroll);
+    };
+  }, [
+    mayRenderOnScroll,
+    scroller,
+    renderOnScrollProp,
+    horizontal,
+    processVisibleIndicesEvent
+  ]);
+  const mayRenderOnResize = !!renderOnResize;
+  const renderOnResizeProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, renderOnResize);
+  _react.useEffect.call(void 0, () => {
+    if (!mayRenderOnResize)
+      return;
+    const renderer = ref.current;
+    if (!renderer)
+      return;
+    if (!scroller)
+      return;
+    const viewport = getViewport(scroller);
+    if (!viewport)
+      return;
+    const task = createTask();
+    if (viewport === scroller) {
+      if (typeof ResizeObserver !== "function")
+        return;
+      let firstRun = true;
+      const observer = new ResizeObserver(() => {
+        if (firstRun) {
+          firstRun = false;
+          return;
+        }
+        task.run(() => {
+          if (!renderOnResizeProp(scroller))
+            return;
+          offsetsRef.current = getOffsets(renderer, scroller, horizontal);
+          processVisibleIndicesEvent();
+        });
+      });
+      observer.observe(scroller);
+      return () => {
+        task.cancel();
+        observer.disconnect();
+      };
+    }
+    const onResize = () => {
+      task.run(() => {
+        if (!renderOnResizeProp(scroller))
+          return;
+        offsetsRef.current = getOffsets(renderer, scroller, horizontal);
+        processVisibleIndicesEvent();
+      });
+    };
+    viewport.addEventListener("resize", onResize, { passive: true });
+    return () => {
+      task.cancel();
+      viewport.removeEventListener("resize", onResize);
+    };
+  }, [
+    mayRenderOnResize,
+    scroller,
+    renderOnResizeProp,
+    horizontal,
+    processVisibleIndicesEvent
+  ]);
+  _react.useEffect.call(void 0, () => {
+    if (typeof IntersectionObserver !== "function")
+      return;
+    const renderer = ref.current;
+    if (!renderer)
+      return;
+    if (!scroller)
+      return;
+    const viewport = getViewport(scroller);
+    if (!viewport)
+      return;
+    const observer = new IntersectionObserver(
+      () => {
+        offsetsRef.current = getOffsets(renderer, scroller, horizontal);
+        processVisibleIndicesEvent();
+      },
+      { root: scroller === viewport ? scroller : null }
+    );
+    observer.observe(renderer);
+    return () => {
+      observer.disconnect();
+    };
+  }, [scroller, processVisibleIndicesEvent]);
+  const elementObserver = _react.useMemo.call(void 0, () => {
+    if (typeof ResizeObserver !== "function")
+      return;
+    return new ResizeObserver(() => {
+      _reactdom.flushSync.call(void 0, updateElements);
+    });
+  }, [updateElements]);
+  const itemRef = _react.useCallback.call(void 0, 
+    (element) => {
+      if (!element)
+        return;
+      if (itemSize)
+        return;
+      updateElements();
+      elements.set(element.id, element);
+      elementObserver == null ? void 0 : elementObserver.observe(element);
+    },
+    [itemSize, elements, updateElements, elementObserver]
+  );
+  const getItemProps = _react.useCallback.call(void 0, 
+    (item, index) => {
+      var _a3, _b3;
+      const itemId = getItemId(item, index, baseId);
+      const offset = itemSize ? paddingStart + itemSize * index + gap * index : (_b3 = (_a3 = data.get(itemId)) == null ? void 0 : _a3.start) != null ? _b3 : 0;
+      const baseItemProps = {
+        id: itemId,
+        ref: itemRef,
+        index,
+        style: {
+          position: "absolute",
+          left: horizontal ? offset : 0,
+          top: horizontal ? 0 : offset
+        }
+      };
+      if (itemSize) {
+        baseItemProps.style[horizontal ? "width" : "height"] = itemSize;
+      }
+      if (item == null)
+        return baseItemProps;
+      const itemProps = getItemObject(item);
+      return _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, itemProps), baseItemProps), {
+        style: _AV6KTKLEcjs.__spreadValues.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, itemProps.style), baseItemProps.style)
+      });
+    },
+    [baseId, data, itemSize, paddingStart, gap, horizontal, itemRef]
+  );
+  const itemsProps = _react.useMemo.call(void 0, () => {
+    return visibleIndices.map((index) => {
+      if (index < 0)
+        return;
+      const item = getItem(items, index);
+      if (!item)
+        return;
+      return getItemProps(item, index);
+    }).filter((value) => value != null);
+  }, [items, visibleIndices, getItemProps]);
+  const children = itemsProps == null ? void 0 : itemsProps.map((itemProps) => {
+    return renderItem == null ? void 0 : renderItem(itemProps);
+  });
+  const styleProp = props.style;
+  const sizeProperty = horizontal ? "width" : "height";
+  const style = _react.useMemo.call(void 0, 
+    () => _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      flex: "none",
+      position: "relative",
+      [sizeProperty]: totalSize
+    }, styleProp),
+    [styleProp, sizeProperty, totalSize]
+  );
+  const childrenData = _react.useMemo.call(void 0, () => /* @__PURE__ */ new Map(), []);
+  const providerValue = _react.useMemo.call(void 0, 
+    () => ({ store, orientation, overscan, childrenData }),
+    [store, orientation, overscan, childrenData]
+  );
+  props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+    props,
+    (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, CollectionRendererContext.Provider, { value: providerValue, children: element }),
+    [providerValue]
+  );
+  props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+    id: baseId
+  }, props), {
+    style,
+    ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref)
+  });
+  return _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), { children });
+}
+var CollectionRenderer = _RNZNGEL4cjs.forwardRef.call(void 0, function CollectionRenderer2(props) {
+  const htmlProps = useCollectionRenderer(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+var getCollectionRendererItem = getItem;
+var getCollectionRendererItemId = getItemId;
+
+
+
+
+
+
+exports.useCollectionRenderer = useCollectionRenderer; exports.CollectionRenderer = CollectionRenderer; exports.getCollectionRendererItem = getCollectionRendererItem; exports.getCollectionRendererItemId = getCollectionRendererItemId;

node_modules/@ariakit/react-core/cjs/__chunks/6PUZ4NWR.cjs

@@ -0,0 +1,137 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _6ZZYUFPWcjs = require('./6ZZYUFPW.cjs');
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-typeahead.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+var _misc = require('@ariakit/core/utils/misc');
+var chars = "";
+function clearChars() {
+  chars = "";
+}
+function isValidTypeaheadEvent(event) {
+  const target = event.target;
+  if (target && _dom.isTextField.call(void 0, target))
+    return false;
+  if (event.key === " " && chars.length)
+    return true;
+  return event.key.length === 1 && !event.ctrlKey && !event.altKey && !event.metaKey && /^[\p{Letter}\p{Number}]$/u.test(event.key);
+}
+function isSelfTargetOrItem(event, items) {
+  if (_events.isSelfTarget.call(void 0, event))
+    return true;
+  const target = event.target;
+  if (!target)
+    return false;
+  const isItem = items.some((item) => item.element === target);
+  return isItem;
+}
+function getEnabledItems(items) {
+  return items.filter((item) => !item.disabled);
+}
+function itemTextStartsWith(item, text) {
+  var _a;
+  const itemText = ((_a = item.element) == null ? void 0 : _a.textContent) || item.children;
+  if (!itemText)
+    return false;
+  return _misc.normalizeString.call(void 0, itemText).trim().toLowerCase().startsWith(text.toLowerCase());
+}
+function getSameInitialItems(items, char, activeId) {
+  if (!activeId)
+    return items;
+  const activeItem = items.find((item) => item.id === activeId);
+  if (!activeItem)
+    return items;
+  if (!itemTextStartsWith(activeItem, char))
+    return items;
+  if (chars !== char && itemTextStartsWith(activeItem, chars))
+    return items;
+  chars = char;
+  return _6ZZYUFPWcjs.flipItems.call(void 0, 
+    items.filter((item) => itemTextStartsWith(item, chars)),
+    activeId
+  ).filter((item) => item.id !== activeId);
+}
+var useCompositeTypeahead = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store, typeahead = true } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store", "typeahead"]);
+    const context = _UZNYSPKPcjs.useCompositeContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "CompositeTypeahead must be a Composite component"
+    );
+    const onKeyDownCaptureProp = props.onKeyDownCapture;
+    const cleanupTimeoutRef = _react.useRef.call(void 0, 0);
+    const onKeyDownCapture = _EO6LS72Hcjs.useEvent.call(void 0, 
+      (event) => {
+        onKeyDownCaptureProp == null ? void 0 : onKeyDownCaptureProp(event);
+        if (event.defaultPrevented)
+          return;
+        if (!typeahead)
+          return;
+        if (!store)
+          return;
+        const { items, activeId } = store.getState();
+        if (!isValidTypeaheadEvent(event))
+          return clearChars();
+        let enabledItems = getEnabledItems(items);
+        if (!isSelfTargetOrItem(event, enabledItems))
+          return clearChars();
+        event.preventDefault();
+        window.clearTimeout(cleanupTimeoutRef.current);
+        cleanupTimeoutRef.current = window.setTimeout(() => {
+          chars = "";
+        }, 500);
+        const char = event.key.toLowerCase();
+        chars += char;
+        enabledItems = getSameInitialItems(enabledItems, char, activeId);
+        const item = enabledItems.find(
+          (item2) => itemTextStartsWith(item2, chars)
+        );
+        if (item) {
+          store.move(item.id);
+        } else {
+          clearChars();
+        }
+      }
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      onKeyDownCapture
+    });
+    return props;
+  }
+);
+var CompositeTypeahead = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCompositeTypeahead(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CompositeTypeahead.displayName = "CompositeTypeahead";
+}
+
+
+
+
+exports.useCompositeTypeahead = useCompositeTypeahead; exports.CompositeTypeahead = CompositeTypeahead;

node_modules/@ariakit/react-core/cjs/__chunks/6ZZYUFPW.cjs

@@ -0,0 +1,88 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+// src/composite/utils.ts
+var _dom = require('@ariakit/core/utils/dom');
+var NULL_ITEM = { id: null };
+function flipItems(items, activeId, shouldInsertNullItem = false) {
+  const index = items.findIndex((item) => item.id === activeId);
+  return [
+    ...items.slice(index + 1),
+    ...shouldInsertNullItem ? [NULL_ITEM] : [],
+    ...items.slice(0, index)
+  ];
+}
+function findFirstEnabledItem(items, excludeId) {
+  return items.find((item) => {
+    if (excludeId) {
+      return !item.disabled && item.id !== excludeId;
+    }
+    return !item.disabled;
+  });
+}
+function getEnabledItem(store, id) {
+  if (!id)
+    return null;
+  return store.item(id) || null;
+}
+function groupItemsByRows(items) {
+  const rows = [];
+  for (const item of items) {
+    const row = rows.find((currentRow) => {
+      var _a;
+      return ((_a = currentRow[0]) == null ? void 0 : _a.rowId) === item.rowId;
+    });
+    if (row) {
+      row.push(item);
+    } else {
+      rows.push([item]);
+    }
+  }
+  return rows;
+}
+function selectTextField(element, collapseToEnd = false) {
+  if (_dom.isTextField.call(void 0, element)) {
+    element.setSelectionRange(
+      collapseToEnd ? element.value.length : 0,
+      element.value.length
+    );
+  } else if (element.isContentEditable) {
+    const selection = _dom.getDocument.call(void 0, element).getSelection();
+    selection == null ? void 0 : selection.selectAllChildren(element);
+    if (collapseToEnd) {
+      selection == null ? void 0 : selection.collapseToEnd();
+    }
+  }
+}
+var FOCUS_SILENTLY = Symbol("FOCUS_SILENTLY");
+function focusSilently(element) {
+  element[FOCUS_SILENTLY] = true;
+  element.focus({ preventScroll: true });
+}
+function silentlyFocused(element) {
+  const isSilentlyFocused = element[FOCUS_SILENTLY];
+  delete element[FOCUS_SILENTLY];
+  return isSilentlyFocused;
+}
+function isItem(store, element, exclude) {
+  if (!element)
+    return false;
+  if (element === exclude)
+    return false;
+  const item = store.item(element.id);
+  if (!item)
+    return false;
+  if (exclude && item.element === exclude)
+    return false;
+  return true;
+}
+
+
+
+
+
+
+
+
+
+
+exports.flipItems = flipItems; exports.findFirstEnabledItem = findFirstEnabledItem; exports.getEnabledItem = getEnabledItem; exports.groupItemsByRows = groupItemsByRows; exports.selectTextField = selectTextField; exports.focusSilently = focusSilently; exports.silentlyFocused = silentlyFocused; exports.isItem = isItem;

node_modules/@ariakit/react-core/cjs/__chunks/7566TIRW.cjs

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _75KXQZJXcjs = require('./75KXQZJX.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/focusable/focusable-container.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var useFocusableContainer = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { autoFocusOnShow = true } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["autoFocusOnShow"]);
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _75KXQZJXcjs.FocusableContext.Provider, { value: autoFocusOnShow, children: element }),
+      [autoFocusOnShow]
+    );
+    return props;
+  }
+);
+var FocusableContainer = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useFocusableContainer(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  FocusableContainer.displayName = "FocusableContainer";
+}
+
+
+
+
+exports.useFocusableContainer = useFocusableContainer; exports.FocusableContainer = FocusableContainer;

node_modules/@ariakit/react-core/cjs/__chunks/75KXQZJX.cjs

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

node_modules/@ariakit/react-core/cjs/__chunks/7LBZXSLY.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/menubar/menubar-context.ts
+var _react = require('react');
+var menubar = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_UZNYSPKPcjs.CompositeContextProvider],
+  [_UZNYSPKPcjs.CompositeScopedContextProvider]
+);
+var useMenubarContext = menubar.useContext;
+var useMenubarScopedContext = menubar.useScopedContext;
+var useMenubarProviderContext = menubar.useProviderContext;
+var MenubarContextProvider = menubar.ContextProvider;
+var MenubarScopedContextProvider = menubar.ScopedContextProvider;
+var MenuItemCheckedContext = _react.createContext.call(void 0, 
+  void 0
+);
+
+
+
+
+
+
+
+
+exports.useMenubarContext = useMenubarContext; exports.useMenubarScopedContext = useMenubarScopedContext; exports.useMenubarProviderContext = useMenubarProviderContext; exports.MenubarContextProvider = MenubarContextProvider; exports.MenubarScopedContextProvider = MenubarScopedContextProvider; exports.MenuItemCheckedContext = MenuItemCheckedContext;

node_modules/@ariakit/react-core/cjs/__chunks/7TN63K2T.cjs

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+// src/dialog/utils/use-previous-mouse-down-ref.ts
+var _react = require('react');
+var _events = require('@ariakit/core/utils/events');
+function usePreviousMouseDownRef(enabled) {
+  const previousMouseDownRef = _react.useRef.call(void 0, );
+  _react.useEffect.call(void 0, () => {
+    if (!enabled) {
+      previousMouseDownRef.current = null;
+      return;
+    }
+    const onMouseDown = (event) => {
+      previousMouseDownRef.current = event.target;
+    };
+    return _events.addGlobalEventListener.call(void 0, "mousedown", onMouseDown, true);
+  }, [enabled]);
+  return previousMouseDownRef;
+}
+
+
+
+exports.usePreviousMouseDownRef = usePreviousMouseDownRef;

node_modules/@ariakit/react-core/cjs/__chunks/7YLCVXZ7.cjs

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+// src/dialog/utils/is-backdrop.ts
+function isBackdrop(element, ...ids) {
+  if (!element)
+    return false;
+  const backdrop = element.getAttribute("data-backdrop");
+  if (backdrop == null)
+    return false;
+  if (backdrop === "")
+    return true;
+  if (backdrop === "true")
+    return true;
+  if (!ids.length)
+    return true;
+  return ids.some((id) => backdrop === id);
+}
+
+
+
+exports.isBackdrop = isBackdrop;

node_modules/@ariakit/react-core/cjs/__chunks/7ZVTEFD7.cjs

@@ -0,0 +1,80 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _5UTRYT6Ecjs = require('./5UTRYT6E.cjs');
+
+
+var _F2A2ZQDBcjs = require('./F2A2ZQDB.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/dialog/dialog-dismiss.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var useDialogDismiss = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _F2A2ZQDBcjs.useDialogScopedContext.call(void 0, );
+    store = store || context;
+    const onClickProp = props.onClick;
+    const onClick = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onClickProp == null ? void 0 : onClickProp(event);
+      if (event.defaultPrevented)
+        return;
+      store == null ? void 0 : store.hide();
+    });
+    const children = _react.useMemo.call(void 0, 
+      () => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+        "svg",
+        {
+          "aria-label": "Dismiss popup",
+          display: "block",
+          fill: "none",
+          stroke: "currentColor",
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          strokeWidth: "1.5pt",
+          viewBox: "0 0 16 16",
+          height: "1em",
+          width: "1em",
+          children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "line", { x1: "4", y1: "4", x2: "12", y2: "12" }),
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "line", { x1: "4", y1: "12", x2: "12", y2: "4" })
+          ]
+        }
+      ),
+      []
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      "data-dialog-dismiss": "",
+      children
+    }, props), {
+      onClick
+    });
+    props = _5UTRYT6Ecjs.useButton.call(void 0, props);
+    return props;
+  }
+);
+var DialogDismiss = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useDialogDismiss(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "button", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  DialogDismiss.displayName = "DialogDismiss";
+}
+
+
+
+
+exports.useDialogDismiss = useDialogDismiss; exports.DialogDismiss = DialogDismiss;

node_modules/@ariakit/react-core/cjs/__chunks/ACTXAOA6.cjs

@@ -0,0 +1,29 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _KRB7URW5cjs = require('./KRB7URW5.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/hovercard/hovercard-description.ts
+var useHovercardDescription = _RNZNGEL4cjs.createHook.call(void 0, 
+  (props) => {
+    props = _KRB7URW5cjs.usePopoverDescription.call(void 0, props);
+    return props;
+  }
+);
+var HovercardDescription = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useHovercardDescription(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "p", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  HovercardDescription.displayName = "HovercardDescription";
+}
+
+
+
+
+exports.useHovercardDescription = useHovercardDescription; exports.HovercardDescription = HovercardDescription;

node_modules/@ariakit/react-core/cjs/__chunks/AH3CUB6N.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+// src/popover/popover-arrow-path.ts
+var POPOVER_ARROW_PATH = "M23,27.8c1.1,1.2,3.4,2.2,5,2.2h2H0h2c1.7,0,3.9-1,5-2.2l6.6-7.2c0.7-0.8,2-0.8,2.7,0L23,27.8L23,27.8z";
+
+
+
+exports.POPOVER_ARROW_PATH = POPOVER_ARROW_PATH;

node_modules/@ariakit/react-core/cjs/__chunks/AV6KTKLE.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+
+
+
+
+exports.__spreadValues = __spreadValues; exports.__spreadProps = __spreadProps; exports.__objRest = __objRest;

node_modules/@ariakit/react-core/cjs/__chunks/AZV52Y77.cjs

@@ -0,0 +1,104 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _AH3CUB6Ncjs = require('./AH3CUB6N.cjs');
+
+
+var _UVBBMANLcjs = require('./UVBBMANL.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/popover/popover-arrow.tsx
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+var defaultSize = 30;
+var halfDefaultSize = defaultSize / 2;
+var rotateMap = {
+  top: `rotate(180 ${halfDefaultSize} ${halfDefaultSize})`,
+  right: `rotate(-90 ${halfDefaultSize} ${halfDefaultSize})`,
+  bottom: `rotate(0 ${halfDefaultSize} ${halfDefaultSize})`,
+  left: `rotate(90 ${halfDefaultSize} ${halfDefaultSize})`
+};
+function useComputedStyle(store) {
+  const [style, setStyle] = _react.useState.call(void 0, );
+  const contentElement = store.useState("contentElement");
+  _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+    if (!contentElement)
+      return;
+    const win = _dom.getWindow.call(void 0, contentElement);
+    const computedStyle = win.getComputedStyle(contentElement);
+    setStyle(computedStyle);
+  }, [contentElement]);
+  return style;
+}
+var usePopoverArrow = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store, size = defaultSize } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store", "size"]);
+    const context = _UVBBMANLcjs.usePopoverContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "PopoverArrow must be wrapped in a Popover component."
+    );
+    const dir = store.useState(
+      (state) => state.currentPlacement.split("-")[0]
+    );
+    const style = useComputedStyle(store);
+    const fill = (style == null ? void 0 : style.getPropertyValue("background-color")) || "none";
+    const stroke = (style == null ? void 0 : style.getPropertyValue(`border-${dir}-color`)) || "none";
+    const borderWidth = (style == null ? void 0 : style.getPropertyValue(`border-${dir}-width`)) || "0px";
+    const strokeWidth = parseInt(borderWidth) * 2 * (defaultSize / size);
+    const transform = rotateMap[dir];
+    const children = _react.useMemo.call(void 0, 
+      () => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "svg", { display: "block", viewBox: "0 0 30 30", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { transform, children: [
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { fill: "none", d: _AH3CUB6Ncjs.POPOVER_ARROW_PATH }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { stroke: "none", d: _AH3CUB6Ncjs.POPOVER_ARROW_PATH })
+      ] }) }),
+      [transform]
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      children,
+      "aria-hidden": true
+    }, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, store.setArrowElement, props.ref),
+      style: _AV6KTKLEcjs.__spreadValues.call(void 0, {
+        // server side rendering
+        position: "absolute",
+        fontSize: size,
+        width: "1em",
+        height: "1em",
+        pointerEvents: "none",
+        fill,
+        stroke,
+        strokeWidth
+      }, props.style)
+    });
+    return props;
+  }
+);
+var PopoverArrow = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = usePopoverArrow(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  PopoverArrow.displayName = "PopoverArrow";
+}
+
+
+
+
+exports.usePopoverArrow = usePopoverArrow; exports.PopoverArrow = PopoverArrow;

node_modules/@ariakit/react-core/cjs/__chunks/BBS4RP44.cjs

@@ -0,0 +1,185 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _63UPRTFZcjs = require('./63UPRTFZ.cjs');
+
+
+var _ERFHNHONcjs = require('./ERFHNHON.cjs');
+
+
+var _DAJUUBUIcjs = require('./DAJUUBUI.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/checkbox/checkbox.tsx
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+function setMixed(element, mixed) {
+  if (mixed) {
+    element.indeterminate = true;
+  } else if (element.indeterminate) {
+    element.indeterminate = false;
+  }
+}
+function isNativeCheckbox(tagName, type) {
+  return tagName === "input" && (!type || type === "checkbox");
+}
+function getPrimitiveValue(value) {
+  if (Array.isArray(value)) {
+    return value.toString();
+  }
+  return value;
+}
+var useCheckbox = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      name,
+      value: valueProp,
+      checked: checkedProp,
+      defaultChecked
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "name",
+      "value",
+      "checked",
+      "defaultChecked"
+    ]);
+    const context = _63UPRTFZcjs.useCheckboxContext.call(void 0, );
+    store = store || context;
+    const [_checked, setChecked] = _react.useState.call(void 0, defaultChecked != null ? defaultChecked : false);
+    const checked = _OLOZ5JT2cjs.useStoreState.call(void 0, store, (state) => {
+      if (checkedProp !== void 0)
+        return checkedProp;
+      if ((state == null ? void 0 : state.value) === void 0)
+        return _checked;
+      if (valueProp != null) {
+        if (Array.isArray(state.value)) {
+          const primitiveValue = getPrimitiveValue(valueProp);
+          return state.value.includes(primitiveValue);
+        }
+        return state.value === valueProp;
+      }
+      if (Array.isArray(state.value))
+        return false;
+      if (typeof state.value === "boolean")
+        return state.value;
+      return false;
+    });
+    const ref = _react.useRef.call(void 0, null);
+    const tagName = _EO6LS72Hcjs.useTagName.call(void 0, ref, props.as || "input");
+    const nativeCheckbox = isNativeCheckbox(tagName, props.type);
+    const mixed = checked ? checked === "mixed" : void 0;
+    const isChecked = checked === "mixed" ? false : checked;
+    const disabled = _misc.disabledFromProps.call(void 0, props);
+    const [propertyUpdated, schedulePropertyUpdate] = _EO6LS72Hcjs.useForceUpdate.call(void 0, );
+    _react.useEffect.call(void 0, () => {
+      const element = ref.current;
+      if (!element)
+        return;
+      setMixed(element, mixed);
+      if (nativeCheckbox)
+        return;
+      element.checked = isChecked;
+      if (name !== void 0) {
+        element.name = name;
+      }
+      if (valueProp !== void 0) {
+        element.value = `${valueProp}`;
+      }
+    }, [propertyUpdated, mixed, nativeCheckbox, isChecked, name, valueProp]);
+    const onChangeProp = props.onChange;
+    const onChange = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      if (disabled) {
+        event.stopPropagation();
+        event.preventDefault();
+        return;
+      }
+      setMixed(event.currentTarget, mixed);
+      if (!nativeCheckbox) {
+        event.currentTarget.checked = !event.currentTarget.checked;
+        schedulePropertyUpdate();
+      }
+      onChangeProp == null ? void 0 : onChangeProp(event);
+      if (event.defaultPrevented)
+        return;
+      const elementChecked = event.currentTarget.checked;
+      setChecked(elementChecked);
+      store == null ? void 0 : store.setValue((prevValue) => {
+        if (valueProp == null)
+          return elementChecked;
+        const primitiveValue = getPrimitiveValue(valueProp);
+        if (!Array.isArray(prevValue)) {
+          return prevValue === primitiveValue ? false : primitiveValue;
+        }
+        if (elementChecked) {
+          if (prevValue.includes(primitiveValue)) {
+            return prevValue;
+          }
+          return [...prevValue, primitiveValue];
+        }
+        return prevValue.filter((v) => v !== primitiveValue);
+      });
+    });
+    const onClickProp = props.onClick;
+    const onClick = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onClickProp == null ? void 0 : onClickProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (nativeCheckbox)
+        return;
+      onChange(event);
+    });
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _ERFHNHONcjs.CheckboxCheckedContext.Provider, { value: isChecked, children: element }),
+      [isChecked]
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      role: !nativeCheckbox ? "checkbox" : void 0,
+      type: nativeCheckbox ? "checkbox" : void 0,
+      "aria-checked": checked
+    }, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      onChange,
+      onClick
+    });
+    props = _DAJUUBUIcjs.useCommand.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { clickOnEnter: !nativeCheckbox }, props));
+    return _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      name: nativeCheckbox ? name : void 0,
+      value: nativeCheckbox ? valueProp : void 0,
+      checked: isChecked
+    }, props);
+  }
+);
+var Checkbox = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useCheckbox(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "input", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Checkbox.displayName = "Checkbox";
+}
+
+
+
+
+exports.useCheckbox = useCheckbox; exports.Checkbox = Checkbox;

node_modules/@ariakit/react-core/cjs/__chunks/BZTDJIVT.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/collection/collection-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, );
+var useCollectionContext = ctx.useContext;
+var useCollectionScopedContext = ctx.useScopedContext;
+var useCollectionProviderContext = ctx.useProviderContext;
+var CollectionContextProvider = ctx.ContextProvider;
+var CollectionScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useCollectionContext = useCollectionContext; exports.useCollectionScopedContext = useCollectionScopedContext; exports.useCollectionProviderContext = useCollectionProviderContext; exports.CollectionContextProvider = CollectionContextProvider; exports.CollectionScopedContextProvider = CollectionScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/CDNJPIEG.cjs

@@ -0,0 +1,25 @@
+"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; } }"use client";
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+// src/collection/collection-store.ts
+var _collectionstore = require('@ariakit/core/collection/collection-store'); var Core = _interopRequireWildcard(_collectionstore);
+function useCollectionStoreProps(store, update, props) {
+  _EO6LS72Hcjs.useUpdateEffect.call(void 0, update, [props.store]);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "items", "setItems");
+  return store;
+}
+function useCollectionStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createCollectionStore, props);
+  return useCollectionStoreProps(store, update, props);
+}
+
+
+
+
+exports.useCollectionStoreProps = useCollectionStoreProps; exports.useCollectionStore = useCollectionStore;

node_modules/@ariakit/react-core/cjs/__chunks/CFKRWKZR.cjs

@@ -0,0 +1,32 @@
+"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; } }"use client";
+
+
+var _LUL2YWZ3cjs = require('./LUL2YWZ3.cjs');
+
+
+var _NRGWVSB5cjs = require('./NRGWVSB5.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+// src/combobox/combobox-store.ts
+var _comboboxstore = require('@ariakit/core/combobox/combobox-store'); var Core = _interopRequireWildcard(_comboboxstore);
+function useComboboxStoreProps(store, update, props) {
+  store = _NRGWVSB5cjs.usePopoverStoreProps.call(void 0, store, update, props);
+  store = _LUL2YWZ3cjs.useCompositeStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "value", "setValue");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "selectedValue", "setSelectedValue");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "resetValueOnHide");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "resetValueOnSelect");
+  return store;
+}
+function useComboboxStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createComboboxStore, props);
+  return useComboboxStoreProps(store, update, props);
+}
+
+
+
+
+exports.useComboboxStoreProps = useComboboxStoreProps; exports.useComboboxStore = useComboboxStore;

node_modules/@ariakit/react-core/cjs/__chunks/CGIHR7QS.cjs

@@ -0,0 +1,58 @@
+"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; } }"use client";
+
+
+var _NGEKJJDHcjs = require('./NGEKJJDH.cjs');
+
+
+var _7LBZXSLYcjs = require('./7LBZXSLY.cjs');
+
+
+var _3WCBE6SUcjs = require('./3WCBE6SU.cjs');
+
+
+var _LUL2YWZ3cjs = require('./LUL2YWZ3.cjs');
+
+
+var _OZ4FTKEHcjs = require('./OZ4FTKEH.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/menu/menu-store.ts
+var _menustore = require('@ariakit/core/menu/menu-store'); var Core = _interopRequireWildcard(_menustore);
+function useMenuStoreProps(store, update, props) {
+  _EO6LS72Hcjs.useUpdateEffect.call(void 0, update, [props.combobox, props.parent, props.menubar]);
+  store = _LUL2YWZ3cjs.useCompositeStoreProps.call(void 0, store, update, props);
+  store = _OZ4FTKEHcjs.useHovercardStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "values", "setValues");
+  return Object.assign(store, {
+    combobox: props.combobox,
+    parent: props.parent,
+    menubar: props.menubar
+  });
+}
+function useMenuStore(props = {}) {
+  const parent = _NGEKJJDHcjs.useMenuContext.call(void 0, );
+  const menubar = _7LBZXSLYcjs.useMenubarContext.call(void 0, );
+  const combobox = _3WCBE6SUcjs.useComboboxProviderContext.call(void 0, );
+  props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+    parent: props.parent !== void 0 ? props.parent : parent,
+    menubar: props.menubar !== void 0 ? props.menubar : menubar,
+    combobox: props.combobox !== void 0 ? props.combobox : combobox
+  });
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createMenuStore, props);
+  return useMenuStoreProps(store, update, props);
+}
+
+
+
+
+exports.useMenuStoreProps = useMenuStoreProps; exports.useMenuStore = useMenuStore;

node_modules/@ariakit/react-core/cjs/__chunks/CJDHQUBR.cjs

@@ -0,0 +1,66 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/utils/misc.ts
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+}
+function isValidElementWithRef(element) {
+  if (!element)
+    return false;
+  if (!_react.isValidElement.call(void 0, element))
+    return false;
+  if (!("ref" in element))
+    return false;
+  return true;
+}
+function getRefProperty(element) {
+  if (!isValidElementWithRef(element))
+    return null;
+  return element.ref;
+}
+function mergeProps(base, overrides) {
+  const props = _AV6KTKLEcjs.__spreadValues.call(void 0, {}, base);
+  for (const key in overrides) {
+    if (!_misc.hasOwnProperty.call(void 0, overrides, key))
+      continue;
+    if (key === "className") {
+      const prop = "className";
+      props[prop] = base[prop] ? `${base[prop]} ${overrides[prop]}` : overrides[prop];
+      continue;
+    }
+    if (key === "style") {
+      const prop = "style";
+      props[prop] = base[prop] ? _AV6KTKLEcjs.__spreadValues.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, base[prop]), overrides[prop]) : overrides[prop];
+      continue;
+    }
+    const overrideValue = overrides[key];
+    if (typeof overrideValue === "function" && key.startsWith("on")) {
+      const baseValue = base[key];
+      if (typeof baseValue === "function") {
+        props[key] = (...args) => {
+          overrideValue(...args);
+          baseValue(...args);
+        };
+        continue;
+      }
+    }
+    props[key] = overrideValue;
+  }
+  return props;
+}
+
+
+
+
+
+
+exports.setRef = setRef; exports.isValidElementWithRef = isValidElementWithRef; exports.getRefProperty = getRefProperty; exports.mergeProps = mergeProps;

node_modules/@ariakit/react-core/cjs/__chunks/CVD2AZE2.cjs

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

node_modules/@ariakit/react-core/cjs/__chunks/D4TG5DM4.cjs

@@ -0,0 +1,128 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _3WCBE6SUcjs = require('./3WCBE6SU.cjs');
+
+
+var _YPVQYY4Jcjs = require('./YPVQYY4J.cjs');
+
+
+var _Z3GCTNW4cjs = require('./Z3GCTNW4.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/combobox/combobox-list.tsx
+var _react = require('react');
+var _events = require('@ariakit/core/utils/events');
+var _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+var useComboboxList = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store, focusable = true, alwaysVisible } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store", "focusable", "alwaysVisible"]);
+    const context = _3WCBE6SUcjs.useComboboxProviderContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "ComboboxList must receive a `store` prop or be wrapped in a ComboboxProvider component."
+    );
+    const ref = _react.useRef.call(void 0, null);
+    const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+    const onKeyDownProp = props.onKeyDown;
+    const onKeyDown = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onKeyDownProp == null ? void 0 : onKeyDownProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (event.key === "Escape") {
+        store == null ? void 0 : store.move(null);
+      }
+    });
+    const restoreVirtualFocus = _react.useRef.call(void 0, false);
+    const onFocusVisibleProp = props.onFocusVisible;
+    const onFocusVisible = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onFocusVisibleProp == null ? void 0 : onFocusVisibleProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (event.type !== "focus")
+        return;
+      if (!store)
+        return;
+      const { virtualFocus } = store.getState();
+      if (!virtualFocus)
+        return;
+      const { relatedTarget, currentTarget } = event;
+      if (relatedTarget && currentTarget.contains(relatedTarget))
+        return;
+      restoreVirtualFocus.current = true;
+      store.setState("virtualFocus", false);
+    });
+    const onBlurProp = props.onBlur;
+    const onBlur = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onBlurProp == null ? void 0 : onBlurProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!restoreVirtualFocus.current)
+        return;
+      if (!_events.isFocusEventOutside.call(void 0, event))
+        return;
+      restoreVirtualFocus.current = false;
+      store == null ? void 0 : store.setState("virtualFocus", true);
+    });
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _3WCBE6SUcjs.ComboboxScopedContextProvider, { value: store, children: element }),
+      [store]
+    );
+    const mounted = store.useState("mounted");
+    const hidden = _YPVQYY4Jcjs.isHidden.call(void 0, mounted, props.hidden, alwaysVisible);
+    const style = hidden ? _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props.style), { display: "none" }) : props.style;
+    const multiSelectable = store.useState(
+      (state) => Array.isArray(state.selectedValue)
+    );
+    const role = _EO6LS72Hcjs.useAttribute.call(void 0, ref, "role", props.role);
+    const isCompositeRole = role === "listbox" || role === "tree" || role === "grid";
+    const ariaMultiSelectable = isCompositeRole ? multiSelectable || void 0 : void 0;
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      id,
+      hidden,
+      role: "listbox",
+      tabIndex: focusable ? -1 : void 0,
+      "aria-multiselectable": ariaMultiSelectable
+    }, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, id ? store.setContentElement : null, ref, props.ref),
+      style,
+      onKeyDown,
+      onFocusVisible,
+      onBlur
+    });
+    props = _Z3GCTNW4cjs.useFocusable.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { focusable }, props));
+    return props;
+  }
+);
+var ComboboxList = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useComboboxList(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  ComboboxList.displayName = "ComboboxList";
+}
+
+
+
+
+exports.useComboboxList = useComboboxList; exports.ComboboxList = ComboboxList;

node_modules/@ariakit/react-core/cjs/__chunks/DAJUUBUI.cjs

@@ -0,0 +1,155 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _Z3GCTNW4cjs = require('./Z3GCTNW4.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/command/command.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+
+
+
+
+var _events = require('@ariakit/core/utils/events');
+var _misc = require('@ariakit/core/utils/misc');
+var _platform = require('@ariakit/core/utils/platform');
+function isNativeClick(event) {
+  if (!event.isTrusted)
+    return false;
+  const element = event.currentTarget;
+  if (event.key === "Enter") {
+    return _dom.isButton.call(void 0, element) || element.tagName === "SUMMARY" || element.tagName === "A";
+  }
+  if (event.key === " ") {
+    return _dom.isButton.call(void 0, element) || element.tagName === "SUMMARY" || element.tagName === "INPUT" || element.tagName === "SELECT";
+  }
+  return false;
+}
+var symbol = Symbol("command");
+var useCommand = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { clickOnEnter = true, clickOnSpace = true } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["clickOnEnter", "clickOnSpace"]);
+    const ref = _react.useRef.call(void 0, null);
+    const tagName = _EO6LS72Hcjs.useTagName.call(void 0, ref, props.as);
+    const type = props.type;
+    const [isNativeButton, setIsNativeButton] = _react.useState.call(void 0, 
+      () => !!tagName && _dom.isButton.call(void 0, { tagName, type })
+    );
+    _react.useEffect.call(void 0, () => {
+      if (!ref.current)
+        return;
+      setIsNativeButton(_dom.isButton.call(void 0, ref.current));
+    }, []);
+    const [active, setActive] = _react.useState.call(void 0, false);
+    const activeRef = _react.useRef.call(void 0, false);
+    const disabled = _misc.disabledFromProps.call(void 0, props);
+    const [isDuplicate, metadataProps] = _EO6LS72Hcjs.useMetadataProps.call(void 0, props, symbol, true);
+    const onKeyDownProp = props.onKeyDown;
+    const onKeyDown = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onKeyDownProp == null ? void 0 : onKeyDownProp(event);
+      const element = event.currentTarget;
+      if (event.defaultPrevented)
+        return;
+      if (isDuplicate)
+        return;
+      if (disabled)
+        return;
+      if (!_events.isSelfTarget.call(void 0, event))
+        return;
+      if (_dom.isTextField.call(void 0, element))
+        return;
+      if (element.isContentEditable)
+        return;
+      const isEnter = clickOnEnter && event.key === "Enter";
+      const isSpace = clickOnSpace && event.key === " ";
+      const shouldPreventEnter = event.key === "Enter" && !clickOnEnter;
+      const shouldPreventSpace = event.key === " " && !clickOnSpace;
+      if (shouldPreventEnter || shouldPreventSpace) {
+        event.preventDefault();
+        return;
+      }
+      if (isEnter || isSpace) {
+        const nativeClick = isNativeClick(event);
+        if (isEnter) {
+          if (!nativeClick) {
+            event.preventDefault();
+            const _a2 = event, { view } = _a2, eventInit = _AV6KTKLEcjs.__objRest.call(void 0, _a2, ["view"]);
+            const click = () => _events.fireClickEvent.call(void 0, element, eventInit);
+            if (_platform.isFirefox.call(void 0, )) {
+              _events.queueBeforeEvent.call(void 0, element, "keyup", click);
+            } else {
+              queueMicrotask(click);
+            }
+          }
+        } else if (isSpace) {
+          activeRef.current = true;
+          if (!nativeClick) {
+            event.preventDefault();
+            setActive(true);
+          }
+        }
+      }
+    });
+    const onKeyUpProp = props.onKeyUp;
+    const onKeyUp = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onKeyUpProp == null ? void 0 : onKeyUpProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (isDuplicate)
+        return;
+      if (disabled)
+        return;
+      if (event.metaKey)
+        return;
+      const isSpace = clickOnSpace && event.key === " ";
+      if (activeRef.current && isSpace) {
+        activeRef.current = false;
+        if (!isNativeClick(event)) {
+          event.preventDefault();
+          setActive(false);
+          const element = event.currentTarget;
+          const _a2 = event, { view } = _a2, eventInit = _AV6KTKLEcjs.__objRest.call(void 0, _a2, ["view"]);
+          queueMicrotask(() => _events.fireClickEvent.call(void 0, element, eventInit));
+        }
+      }
+    });
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      "data-active": active ? "" : void 0,
+      type: isNativeButton ? "button" : void 0
+    }, metadataProps), props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      onKeyDown,
+      onKeyUp
+    });
+    props = _Z3GCTNW4cjs.useFocusable.call(void 0, props);
+    return props;
+  }
+);
+var Command = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  props = useCommand(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "button", props);
+});
+if (process.env.NODE_ENV !== "production") {
+  Command.displayName = "Command";
+}
+
+
+
+
+exports.useCommand = useCommand; exports.Command = Command;

node_modules/@ariakit/react-core/cjs/__chunks/DTEFSZZZ.cjs

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _TK6GOI2Vcjs = require('./TK6GOI2V.cjs');
+
+
+var _F2A2ZQDBcjs = require('./F2A2ZQDB.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/dialog/dialog-heading.ts
+var _react = require('react');
+var useDialogHeading = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const setHeadingId = _react.useContext.call(void 0, _F2A2ZQDBcjs.DialogHeadingContext);
+    const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+    _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+      setHeadingId == null ? void 0 : setHeadingId(id);
+      return () => setHeadingId == null ? void 0 : setHeadingId(void 0);
+    }, [setHeadingId, id]);
+    props = _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      id
+    }, props);
+    props = _TK6GOI2Vcjs.useHeading.call(void 0, props);
+    return props;
+  }
+);
+var DialogHeading = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useDialogHeading(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "h1", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  DialogHeading.displayName = "DialogHeading";
+}
+
+
+
+
+exports.useDialogHeading = useDialogHeading; exports.DialogHeading = DialogHeading;

node_modules/@ariakit/react-core/cjs/__chunks/EO6LS72H.cjs

@@ -0,0 +1,287 @@
+"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; } }"use client";
+
+
+var _CJDHQUBRcjs = require('./CJDHQUBR.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/utils/hooks.ts
+
+
+
+
+
+
+
+
+var _react = require('react'); var React = _interopRequireWildcard(_react);
+
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+var _misc = require('@ariakit/core/utils/misc');
+var _React = _AV6KTKLEcjs.__spreadValues.call(void 0, {}, React);
+var useReactId = _React.useId;
+var useReactDeferredValue = _React.useDeferredValue;
+var useReactInsertionEffect = _React.useInsertionEffect;
+var useSafeLayoutEffect = _dom.canUseDOM ? _react.useLayoutEffect : _react.useEffect;
+function useInitialValue(value) {
+  const [initialValue] = _react.useState.call(void 0, value);
+  return initialValue;
+}
+function useLazyValue(init) {
+  const ref = _react.useRef.call(void 0, );
+  if (ref.current === void 0) {
+    ref.current = init();
+  }
+  return ref.current;
+}
+function useLiveRef(value) {
+  const ref = _react.useRef.call(void 0, value);
+  useSafeLayoutEffect(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+function usePreviousValue(value) {
+  const [previousValue, setPreviousValue] = _react.useState.call(void 0, value);
+  if (value !== previousValue) {
+    setPreviousValue(value);
+  }
+  return previousValue;
+}
+function useEvent(callback) {
+  const ref = _react.useRef.call(void 0, () => {
+    throw new Error("Cannot call an event handler while rendering.");
+  });
+  if (useReactInsertionEffect) {
+    useReactInsertionEffect(() => {
+      ref.current = callback;
+    });
+  } else {
+    ref.current = callback;
+  }
+  return _react.useCallback.call(void 0, (...args) => {
+    var _a;
+    return (_a = ref.current) == null ? void 0 : _a.call(ref, ...args);
+  }, []);
+}
+function useMergeRefs(...refs) {
+  return _react.useMemo.call(void 0, () => {
+    if (!refs.some(Boolean))
+      return;
+    return (value) => {
+      refs.forEach((ref) => _CJDHQUBRcjs.setRef.call(void 0, ref, value));
+    };
+  }, refs);
+}
+function useRefId(ref, deps) {
+  const [id, setId] = _react.useState.call(void 0, void 0);
+  useSafeLayoutEffect(() => {
+    var _a;
+    setId((_a = ref == null ? void 0 : ref.current) == null ? void 0 : _a.id);
+  }, deps);
+  return id;
+}
+function useId(defaultId) {
+  if (useReactId) {
+    const reactId = useReactId();
+    if (defaultId)
+      return defaultId;
+    return reactId;
+  }
+  const [id, setId] = _react.useState.call(void 0, defaultId);
+  useSafeLayoutEffect(() => {
+    if (defaultId || id)
+      return;
+    const random = Math.random().toString(36).substr(2, 6);
+    setId(`id-${random}`);
+  }, [defaultId, id]);
+  return defaultId || id;
+}
+function useDeferredValue(value) {
+  if (useReactDeferredValue) {
+    return useReactDeferredValue(value);
+  }
+  const [deferredValue, setDeferredValue] = _react.useState.call(void 0, value);
+  _react.useEffect.call(void 0, () => {
+    const raf = requestAnimationFrame(() => setDeferredValue(value));
+    return () => cancelAnimationFrame(raf);
+  }, [value]);
+  return deferredValue;
+}
+function useTagName(refOrElement, type) {
+  const stringOrUndefined = (type2) => {
+    if (typeof type2 !== "string")
+      return;
+    return type2;
+  };
+  const [tagName, setTagName] = _react.useState.call(void 0, () => stringOrUndefined(type));
+  useSafeLayoutEffect(() => {
+    const element = refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement;
+    setTagName((element == null ? void 0 : element.tagName.toLowerCase()) || stringOrUndefined(type));
+  }, [refOrElement, type]);
+  return tagName;
+}
+function useAttribute(refOrElement, attributeName, defaultValue) {
+  const [attribute, setAttribute] = _react.useState.call(void 0, defaultValue);
+  useSafeLayoutEffect(() => {
+    const element = refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement;
+    const value = element == null ? void 0 : element.getAttribute(attributeName);
+    if (value == null)
+      return;
+    setAttribute(value);
+  }, [refOrElement, attributeName]);
+  return attribute;
+}
+function useUpdateEffect(effect, deps) {
+  const mounted = _react.useRef.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (mounted.current) {
+      return effect();
+    }
+    mounted.current = true;
+  }, deps);
+  _react.useEffect.call(void 0, 
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+}
+function useUpdateLayoutEffect(effect, deps) {
+  const mounted = _react.useRef.call(void 0, false);
+  useSafeLayoutEffect(() => {
+    if (mounted.current) {
+      return effect();
+    }
+    mounted.current = true;
+  }, deps);
+  useSafeLayoutEffect(
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+}
+function useControlledState(defaultState, state, setState) {
+  const [localState, setLocalState] = _react.useState.call(void 0, defaultState);
+  const nextState = state !== void 0 ? state : localState;
+  const stateRef = useLiveRef(state);
+  const setStateRef = useLiveRef(setState);
+  const nextStateRef = useLiveRef(nextState);
+  const setNextState = _react.useCallback.call(void 0, (prevValue) => {
+    const setStateProp = setStateRef.current;
+    if (setStateProp) {
+      if (isSetNextState(setStateProp)) {
+        setStateProp(prevValue);
+      } else {
+        const nextValue = _misc.applyState.call(void 0, prevValue, nextStateRef.current);
+        nextStateRef.current = nextValue;
+        setStateProp(nextValue);
+      }
+    }
+    if (stateRef.current === void 0) {
+      setLocalState(prevValue);
+    }
+  }, []);
+  defineSetNextState(setNextState);
+  return [nextState, setNextState];
+}
+var SET_NEXT_STATE = Symbol("setNextState");
+function isSetNextState(arg) {
+  return arg[SET_NEXT_STATE] === true;
+}
+function defineSetNextState(arg) {
+  if (!isSetNextState(arg)) {
+    Object.defineProperty(arg, SET_NEXT_STATE, { value: true });
+  }
+}
+function useForceUpdate() {
+  return _react.useReducer.call(void 0, () => [], []);
+}
+function useBooleanEvent(booleanOrCallback) {
+  return useEvent(
+    typeof booleanOrCallback === "function" ? booleanOrCallback : () => booleanOrCallback
+  );
+}
+function useWrapElement(props, callback, deps = []) {
+  const wrapElement = _react.useCallback.call(void 0, 
+    (element) => {
+      if (props.wrapElement) {
+        element = props.wrapElement(element);
+      }
+      return callback(element);
+    },
+    [...deps, props.wrapElement]
+  );
+  return _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), { wrapElement });
+}
+function usePortalRef(portalProp = false, portalRefProp) {
+  const [portalNode, setPortalNode] = _react.useState.call(void 0, null);
+  const portalRef = useMergeRefs(setPortalNode, portalRefProp);
+  const domReady = !portalProp || portalNode;
+  return { portalRef, portalNode, domReady };
+}
+function useMetadataProps(props, key, value) {
+  const parent = props.onLoadedMetadataCapture;
+  const onLoadedMetadataCapture = _react.useMemo.call(void 0, () => {
+    return Object.assign(() => {
+    }, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, parent), { [key]: value }));
+  }, [parent, key, value]);
+  return [parent == null ? void 0 : parent[key], { onLoadedMetadataCapture }];
+}
+function useIsMouseMoving() {
+  _react.useEffect.call(void 0, () => {
+    _events.addGlobalEventListener.call(void 0, "mousemove", setMouseMoving, true);
+    _events.addGlobalEventListener.call(void 0, "mousedown", resetMouseMoving, true);
+    _events.addGlobalEventListener.call(void 0, "mouseup", resetMouseMoving, true);
+    _events.addGlobalEventListener.call(void 0, "keydown", resetMouseMoving, true);
+    _events.addGlobalEventListener.call(void 0, "scroll", resetMouseMoving, true);
+  }, []);
+  const isMouseMoving = useEvent(() => mouseMoving);
+  return isMouseMoving;
+}
+var mouseMoving = false;
+var previousScreenX = 0;
+var previousScreenY = 0;
+function hasMouseMovement(event) {
+  const movementX = event.movementX || event.screenX - previousScreenX;
+  const movementY = event.movementY || event.screenY - previousScreenY;
+  previousScreenX = event.screenX;
+  previousScreenY = event.screenY;
+  return movementX || movementY || process.env.NODE_ENV === "test";
+}
+function setMouseMoving(event) {
+  if (!hasMouseMovement(event))
+    return;
+  mouseMoving = true;
+}
+function resetMouseMoving() {
+  mouseMoving = false;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.useSafeLayoutEffect = useSafeLayoutEffect; exports.useInitialValue = useInitialValue; exports.useLazyValue = useLazyValue; exports.useLiveRef = useLiveRef; exports.usePreviousValue = usePreviousValue; exports.useEvent = useEvent; exports.useMergeRefs = useMergeRefs; exports.useRefId = useRefId; exports.useId = useId; exports.useDeferredValue = useDeferredValue; exports.useTagName = useTagName; exports.useAttribute = useAttribute; exports.useUpdateEffect = useUpdateEffect; exports.useUpdateLayoutEffect = useUpdateLayoutEffect; exports.useControlledState = useControlledState; exports.useForceUpdate = useForceUpdate; exports.useBooleanEvent = useBooleanEvent; exports.useWrapElement = useWrapElement; exports.usePortalRef = usePortalRef; exports.useMetadataProps = useMetadataProps; exports.useIsMouseMoving = useIsMouseMoving;

node_modules/@ariakit/react-core/cjs/__chunks/ERFHNHON.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+// src/checkbox/checkbox-checked-context.ts
+var _react = require('react');
+var CheckboxCheckedContext = _react.createContext.call(void 0, false);
+
+
+
+exports.CheckboxCheckedContext = CheckboxCheckedContext;

node_modules/@ariakit/react-core/cjs/__chunks/EUHOCOY2.cjs

@@ -0,0 +1,22 @@
+"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; } }"use client";
+
+
+var _LUL2YWZ3cjs = require('./LUL2YWZ3.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+// src/menubar/menubar-store.ts
+var _menubarstore = require('@ariakit/core/menubar/menubar-store'); var Core = _interopRequireWildcard(_menubarstore);
+function useMenubarStoreProps(store, update, props) {
+  return _LUL2YWZ3cjs.useCompositeStoreProps.call(void 0, store, update, props);
+}
+function useMenubarStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createMenubarStore, props);
+  return useMenubarStoreProps(store, update, props);
+}
+
+
+
+
+exports.useMenubarStoreProps = useMenubarStoreProps; exports.useMenubarStore = useMenubarStore;

node_modules/@ariakit/react-core/cjs/__chunks/F2A2ZQDB.cjs

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _S6UU7NA4cjs = require('./S6UU7NA4.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/dialog/dialog-context.tsx
+var _react = require('react');
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_S6UU7NA4cjs.DisclosureContextProvider],
+  [_S6UU7NA4cjs.DisclosureScopedContextProvider]
+);
+var useDialogContext = ctx.useContext;
+var useDialogScopedContext = ctx.useScopedContext;
+var useDialogProviderContext = ctx.useProviderContext;
+var DialogContextProvider = ctx.ContextProvider;
+var DialogScopedContextProvider = ctx.ScopedContextProvider;
+var DialogHeadingContext = _react.createContext.call(void 0, void 0);
+var DialogDescriptionContext = _react.createContext.call(void 0, void 0);
+
+
+
+
+
+
+
+
+
+exports.useDialogContext = useDialogContext; exports.useDialogScopedContext = useDialogScopedContext; exports.useDialogProviderContext = useDialogProviderContext; exports.DialogContextProvider = DialogContextProvider; exports.DialogScopedContextProvider = DialogScopedContextProvider; exports.DialogHeadingContext = DialogHeadingContext; exports.DialogDescriptionContext = DialogDescriptionContext;

node_modules/@ariakit/react-core/cjs/__chunks/F34KLJKG.cjs

@@ -0,0 +1,50 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _QOD2KY3Ncjs = require('./QOD2KY3N.cjs');
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-separator.ts
+var _misc = require('@ariakit/core/utils/misc');
+var useCompositeSeparator = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _UZNYSPKPcjs.useCompositeContext.call(void 0, );
+    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 = _QOD2KY3Ncjs.useSeparator.call(void 0, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), { orientation }));
+    return props;
+  }
+);
+var CompositeSeparator = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCompositeSeparator(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "hr", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CompositeSeparator.displayName = "CompositeSeparator";
+}
+
+
+
+
+exports.useCompositeSeparator = useCompositeSeparator; exports.CompositeSeparator = CompositeSeparator;

node_modules/@ariakit/react-core/cjs/__chunks/FE3YCURH.cjs

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

node_modules/@ariakit/react-core/cjs/__chunks/FROYTN4B.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _BZTDJIVTcjs = require('./BZTDJIVT.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/form/form-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_BZTDJIVTcjs.CollectionContextProvider],
+  [_BZTDJIVTcjs.CollectionScopedContextProvider]
+);
+var useFormContext = ctx.useContext;
+var useFormScopedContext = ctx.useScopedContext;
+var useFormProviderContext = ctx.useProviderContext;
+var FormContextProvider = ctx.ContextProvider;
+var FormScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useFormContext = useFormContext; exports.useFormScopedContext = useFormScopedContext; exports.useFormProviderContext = useFormProviderContext; exports.FormContextProvider = FormContextProvider; exports.FormScopedContextProvider = FormScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/G2ZXRZ2R.cjs

@@ -0,0 +1,155 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _HEEQY4DZcjs = require('./HEEQY4DZ.cjs');
+
+
+var _IO6J4PANcjs = require('./IO6J4PAN.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/radio/radio.ts
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+function getIsChecked(value, storeValue) {
+  if (storeValue === void 0)
+    return;
+  if (value != null && storeValue != null) {
+    return storeValue === value;
+  }
+  return !!storeValue;
+}
+function isNativeRadio(tagName, type) {
+  return tagName === "input" && (!type || type === "radio");
+}
+var useRadio = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store, name, value, checked } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store", "name", "value", "checked"]);
+    const context = _HEEQY4DZcjs.useRadioContext.call(void 0, );
+    store = store || context;
+    const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+    const ref = _react.useRef.call(void 0, null);
+    const isChecked = _OLOZ5JT2cjs.useStoreState.call(void 0, 
+      store,
+      (state) => checked != null ? checked : getIsChecked(value, state == null ? void 0 : state.value)
+    );
+    _react.useEffect.call(void 0, () => {
+      if (!id)
+        return;
+      if (!isChecked)
+        return;
+      const isActiveItem = (store == null ? void 0 : store.getState().activeId) === id;
+      if (isActiveItem)
+        return;
+      store == null ? void 0 : store.setActiveId(id);
+    }, [store, isChecked, id]);
+    const onChangeProp = props.onChange;
+    const tagName = _EO6LS72Hcjs.useTagName.call(void 0, ref, props.as || "input");
+    const nativeRadio = isNativeRadio(tagName, props.type);
+    const disabled = _misc.disabledFromProps.call(void 0, props);
+    const [propertyUpdated, schedulePropertyUpdate] = _EO6LS72Hcjs.useForceUpdate.call(void 0, );
+    _react.useEffect.call(void 0, () => {
+      const element = ref.current;
+      if (!element)
+        return;
+      if (nativeRadio)
+        return;
+      if (isChecked !== void 0) {
+        element.checked = isChecked;
+      }
+      if (name !== void 0) {
+        element.name = name;
+      }
+      if (value !== void 0) {
+        element.value = `${value}`;
+      }
+    }, [propertyUpdated, nativeRadio, isChecked, name, value]);
+    const onChange = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      if (disabled) {
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      if (!nativeRadio) {
+        event.currentTarget.checked = true;
+        schedulePropertyUpdate();
+      }
+      onChangeProp == null ? void 0 : onChangeProp(event);
+      if (event.defaultPrevented)
+        return;
+      store == null ? void 0 : store.setValue(value);
+    });
+    const onClickProp = props.onClick;
+    const onClick = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onClickProp == null ? void 0 : onClickProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (nativeRadio)
+        return;
+      onChange(event);
+    });
+    const onFocusProp = props.onFocus;
+    const onFocus = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onFocusProp == null ? void 0 : onFocusProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!nativeRadio)
+        return;
+      if (!store)
+        return;
+      const { moves, activeId } = store.getState();
+      if (!moves)
+        return;
+      if (id && activeId !== id)
+        return;
+      onChange(event);
+    });
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      id,
+      role: !nativeRadio ? "radio" : void 0,
+      type: nativeRadio ? "radio" : void 0,
+      "aria-checked": isChecked
+    }, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      onChange,
+      onClick,
+      onFocus
+    });
+    props = _IO6J4PANcjs.useCompositeItem.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store, clickOnEnter: !nativeRadio }, props));
+    return _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      name: nativeRadio ? name : void 0,
+      value: nativeRadio ? value : void 0,
+      checked: isChecked
+    }, props);
+  }
+);
+var Radio = _RNZNGEL4cjs.createMemoComponent.call(void 0, (props) => {
+  const htmlProps = useRadio(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "input", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Radio.displayName = "Radio";
+}
+
+
+
+
+exports.useRadio = useRadio; exports.Radio = Radio;

node_modules/@ariakit/react-core/cjs/__chunks/GJX4AG2L.cjs

@@ -0,0 +1,69 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-row.tsx
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+var useCompositeRow = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      "aria-setsize": ariaSetSize,
+      "aria-posinset": ariaPosInSet
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "aria-setsize",
+      "aria-posinset"
+    ]);
+    const context = _UZNYSPKPcjs.useCompositeContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "CompositeRow must be wrapped in a Composite component."
+    );
+    const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+    const baseElement = store.useState(
+      (state) => state.baseElement || void 0
+    );
+    const providerValue = _react.useMemo.call(void 0, 
+      () => ({ id, baseElement, ariaSetSize, ariaPosInSet }),
+      [id, baseElement, ariaSetSize, ariaPosInSet]
+    );
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _UZNYSPKPcjs.CompositeRowContext.Provider, { value: providerValue, children: element }),
+      [providerValue]
+    );
+    props = _AV6KTKLEcjs.__spreadValues.call(void 0, { id }, props);
+    return props;
+  }
+);
+var CompositeRow = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useCompositeRow(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  CompositeRow.displayName = "CompositeRow";
+}
+
+
+
+
+exports.useCompositeRow = useCompositeRow; exports.CompositeRow = CompositeRow;

node_modules/@ariakit/react-core/cjs/__chunks/H6OLBVHA.cjs

@@ -0,0 +1,364 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+
+
+
+var _6ZZYUFPWcjs = require('./6ZZYUFPW.cjs');
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+var _Z3GCTNW4cjs = require('./Z3GCTNW4.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.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 _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+function isGrid(items) {
+  return items.some((item) => !!item.rowId);
+}
+function isPrintableKey(event) {
+  const target = event.target;
+  if (target && !_dom.isTextField.call(void 0, target))
+    return false;
+  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 useKeyboardEventProxy(store, onKeyboardEvent, previousElementRef) {
+  return _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+    var _a;
+    onKeyboardEvent == null ? void 0 : onKeyboardEvent(event);
+    if (event.defaultPrevented)
+      return;
+    if (event.isPropagationStopped())
+      return;
+    if (!_events.isSelfTarget.call(void 0, event))
+      return;
+    if (isModifierKey(event))
+      return;
+    if (isPrintableKey(event))
+      return;
+    const state = store.getState();
+    const activeElement = (_a = _6ZZYUFPWcjs.getEnabledItem.call(void 0, store, state.activeId)) == null ? void 0 : _a.element;
+    if (!activeElement)
+      return;
+    const _b = event, { view } = _b, eventInit = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["view"]);
+    const previousElement = previousElementRef == null ? void 0 : previousElementRef.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 _6ZZYUFPWcjs.findFirstEnabledItem.call(void 0, 
+    _array.flatten2DArray.call(void 0, _array.reverseArray.call(void 0, _6ZZYUFPWcjs.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) => _6ZZYUFPWcjs.getEnabledItem.call(void 0, store, state.activeId)
+  );
+  _react.useEffect.call(void 0, () => {
+    const activeElement = activeItem == null ? void 0 : activeItem.element;
+    if (!scheduled)
+      return;
+    if (!activeElement)
+      return;
+    setScheduled(false);
+    activeElement.focus({ preventScroll: true });
+  }, [activeItem, scheduled]);
+  return schedule;
+}
+var useComposite = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      composite = true,
+      focusOnMove = composite,
+      moveOnKeyPress = true
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "composite",
+      "focusOnMove",
+      "moveOnKeyPress"
+    ]);
+    const context = _UZNYSPKPcjs.useCompositeProviderContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "Composite must receive a `store` prop or be wrapped in a CompositeProvider component."
+    );
+    const previousElementRef = _react.useRef.call(void 0, null);
+    const scheduleFocus = useScheduleFocus(store);
+    const moves = store.useState("moves");
+    _react.useEffect.call(void 0, () => {
+      var _a2;
+      if (!store)
+        return;
+      if (!moves)
+        return;
+      if (!composite)
+        return;
+      if (!focusOnMove)
+        return;
+      const { activeId: activeId2 } = store.getState();
+      const itemElement = (_a2 = _6ZZYUFPWcjs.getEnabledItem.call(void 0, store, activeId2)) == null ? void 0 : _a2.element;
+      if (!itemElement)
+        return;
+      _focus.focusIntoView.call(void 0, itemElement);
+    }, [store, moves, composite, focusOnMove]);
+    _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (!store)
+        return;
+      if (!moves)
+        return;
+      if (!composite)
+        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)) {
+        baseElement.focus();
+      }
+    }, [store, moves, composite]);
+    const activeId = store.useState("activeId");
+    const virtualFocus = store.useState("virtualFocus");
+    _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+      var _a2;
+      if (!store)
+        return;
+      if (!composite)
+        return;
+      if (!virtualFocus)
+        return;
+      const previousElement = previousElementRef.current;
+      previousElementRef.current = null;
+      if (!previousElement)
+        return;
+      const activeElement = (_a2 = _6ZZYUFPWcjs.getEnabledItem.call(void 0, store, activeId)) == null ? void 0 : _a2.element;
+      const relatedTarget = activeElement || _dom.getActiveElement.call(void 0, previousElement);
+      if (relatedTarget === previousElement)
+        return;
+      _events.fireBlurEvent.call(void 0, previousElement, { relatedTarget });
+    }, [store, activeId, virtualFocus, composite]);
+    const onKeyDownCapture = useKeyboardEventProxy(
+      store,
+      props.onKeyDownCapture,
+      previousElementRef
+    );
+    const onKeyUpCapture = useKeyboardEventProxy(
+      store,
+      props.onKeyUpCapture,
+      previousElementRef
+    );
+    const onFocusCaptureProp = props.onFocusCapture;
+    const onFocusCapture = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onFocusCaptureProp == null ? void 0 : onFocusCaptureProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!store)
+        return;
+      const { virtualFocus: virtualFocus2 } = store.getState();
+      if (!virtualFocus2)
+        return;
+      const previousActiveElement = event.relatedTarget;
+      const isSilentlyFocused = _6ZZYUFPWcjs.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 = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onFocusProp == null ? void 0 : onFocusProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!composite)
+        return;
+      if (!store)
+        return;
+      const { relatedTarget } = event;
+      const { virtualFocus: virtualFocus2 } = store.getState();
+      if (virtualFocus2) {
+        if (_events.isSelfTarget.call(void 0, event) && !_6ZZYUFPWcjs.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 = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      var _a2;
+      onBlurCaptureProp == null ? void 0 : onBlurCaptureProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!store)
+        return;
+      const { virtualFocus: virtualFocus2, activeId: activeId2 } = store.getState();
+      if (!virtualFocus2)
+        return;
+      const activeElement = (_a2 = _6ZZYUFPWcjs.getEnabledItem.call(void 0, store, activeId2)) == null ? void 0 : _a2.element;
+      const nextActiveElement = event.relatedTarget;
+      const nextActiveElementIsItem = _6ZZYUFPWcjs.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);
+        } else if (previousElement) {
+          _events.fireBlurEvent.call(void 0, previousElement, event);
+        }
+        event.stopPropagation();
+      } else {
+        const targetIsItem = _6ZZYUFPWcjs.isItem.call(void 0, store, event.target);
+        if (!targetIsItem && activeElement) {
+          _events.fireBlurEvent.call(void 0, activeElement, event);
+        }
+      }
+    });
+    const onKeyDownProp = props.onKeyDown;
+    const moveOnKeyPressProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, moveOnKeyPress);
+    const onKeyDown = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      var _a2;
+      onKeyDownProp == null ? void 0 : onKeyDownProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!store)
+        return;
+      if (!_events.isSelfTarget.call(void 0, event))
+        return;
+      const { orientation, items, renderedItems, activeId: activeId2 } = store.getState();
+      const activeItem = _6ZZYUFPWcjs.getEnabledItem.call(void 0, store, activeId2);
+      if ((_a2 = activeItem == null ? void 0 : activeItem.element) == null ? void 0 : _a2.isConnected)
+        return;
+      const isVertical = orientation !== "horizontal";
+      const isHorizontal = orientation !== "vertical";
+      const grid = isGrid(renderedItems);
+      const isHorizontalKey = event.key === "ArrowLeft" || event.key === "ArrowRight" || event.key === "Home" || event.key === "End";
+      if (isHorizontalKey && _dom.isTextField.call(void 0, event.currentTarget))
+        return;
+      const up = () => {
+        if (grid) {
+          const item = items && findFirstEnabledItemInTheLastRow(items);
+          return item == null ? void 0 : item.id;
+        }
+        return store == null ? void 0 : 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 = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _UZNYSPKPcjs.CompositeContextProvider, { value: store, children: element }),
+      [store]
+    );
+    const activeDescendant = store.useState((state) => {
+      var _a2;
+      if (!store)
+        return;
+      if (!composite)
+        return;
+      if (!state.virtualFocus)
+        return;
+      return (_a2 = _6ZZYUFPWcjs.getEnabledItem.call(void 0, store, state.activeId)) == null ? void 0 : _a2.id;
+    });
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      "aria-activedescendant": activeDescendant
+    }, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.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 = _Z3GCTNW4cjs.useFocusable.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { focusable }, props));
+    return props;
+  }
+);
+var Composite = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useComposite(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Composite.displayName = "Composite";
+}
+
+
+
+
+exports.useComposite = useComposite; exports.Composite = Composite;

node_modules/@ariakit/react-core/cjs/__chunks/HEEQY4DZ.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/radio/radio-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_UZNYSPKPcjs.CompositeContextProvider],
+  [_UZNYSPKPcjs.CompositeScopedContextProvider]
+);
+var useRadioContext = ctx.useContext;
+var useRadioScopedContext = ctx.useScopedContext;
+var useRadioProviderContext = ctx.useProviderContext;
+var RadioContextProvider = ctx.ContextProvider;
+var RadioScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useRadioContext = useRadioContext; exports.useRadioScopedContext = useRadioScopedContext; exports.useRadioProviderContext = useRadioProviderContext; exports.RadioContextProvider = RadioContextProvider; exports.RadioScopedContextProvider = RadioScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/I2KHXDVL.cjs

@@ -0,0 +1,321 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+
+var _KXQOQQ5Bcjs = require('./KXQOQQ5B.cjs');
+
+
+var _OUEE5HOScjs = require('./OUEE5HOS.cjs');
+
+
+var _ZL5DC555cjs = require('./ZL5DC555.cjs');
+
+
+
+var _3W6FH6JKcjs = require('./3W6FH6JK.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/hovercard/hovercard.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 _misc = require('@ariakit/core/utils/misc');
+var _store = require('@ariakit/core/utils/store');
+var _jsxruntime = require('react/jsx-runtime');
+function isMovingOnHovercard(target, card, anchor, nested) {
+  if (_focus.hasFocusWithin.call(void 0, card))
+    return true;
+  if (!target)
+    return false;
+  if (_dom.contains.call(void 0, card, target))
+    return true;
+  if (anchor && _dom.contains.call(void 0, anchor, target))
+    return true;
+  if (nested == null ? void 0 : nested.some((card2) => isMovingOnHovercard(target, card2, anchor))) {
+    return true;
+  }
+  return false;
+}
+function useAutoFocusOnHide(_a) {
+  var _b = _a, {
+    store
+  } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+    "store"
+  ]);
+  const [autoFocusOnHide, setAutoFocusOnHide] = _react.useState.call(void 0, false);
+  const mounted = store.useState("mounted");
+  _react.useEffect.call(void 0, () => {
+    if (!mounted) {
+      setAutoFocusOnHide(false);
+    }
+  }, [mounted]);
+  const onFocusProp = props.onFocus;
+  const onFocus = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+    onFocusProp == null ? void 0 : onFocusProp(event);
+    if (event.defaultPrevented)
+      return;
+    setAutoFocusOnHide(true);
+  });
+  const finalFocusRef = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    return _store.sync.call(void 0, store, ["anchorElement"], (state) => {
+      finalFocusRef.current = state.anchorElement;
+    });
+  }, []);
+  props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+    autoFocusOnHide,
+    finalFocus: finalFocusRef
+  }, props), {
+    onFocus
+  });
+  return props;
+}
+var NestedHovercardContext = _react.createContext.call(void 0, null);
+var useHovercard = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      modal = false,
+      portal = !!modal,
+      hideOnEscape = true,
+      hideOnHoverOutside = true,
+      disablePointerEventsOnApproach = !!hideOnHoverOutside
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "modal",
+      "portal",
+      "hideOnEscape",
+      "hideOnHoverOutside",
+      "disablePointerEventsOnApproach"
+    ]);
+    const context = _3W6FH6JKcjs.useHovercardProviderContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "Hovercard must receive a `store` prop or be wrapped in a HovercardProvider component."
+    );
+    const ref = _react.useRef.call(void 0, null);
+    const [nestedHovercards, setNestedHovercards] = _react.useState.call(void 0, []);
+    const hideTimeoutRef = _react.useRef.call(void 0, 0);
+    const enterPointRef = _react.useRef.call(void 0, null);
+    const { portalRef, domReady } = _EO6LS72Hcjs.usePortalRef.call(void 0, portal, props.portalRef);
+    const mayHideOnHoverOutside = !!hideOnHoverOutside;
+    const hideOnHoverOutsideProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, hideOnHoverOutside);
+    const mayDisablePointerEvents = !!disablePointerEventsOnApproach;
+    const disablePointerEventsProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, 
+      disablePointerEventsOnApproach
+    );
+    const open = store.useState("open");
+    const mounted = store.useState("mounted");
+    _react.useEffect.call(void 0, () => {
+      if (!domReady)
+        return;
+      if (!mounted)
+        return;
+      if (!mayHideOnHoverOutside && !mayDisablePointerEvents)
+        return;
+      const element = ref.current;
+      if (!element)
+        return;
+      const onMouseMove = (event) => {
+        if (!store)
+          return;
+        const { anchorElement, hideTimeout, timeout } = store.getState();
+        const enterPoint = enterPointRef.current;
+        const [target] = event.composedPath();
+        const anchor = anchorElement;
+        if (isMovingOnHovercard(target, element, anchor, nestedHovercards)) {
+          enterPointRef.current = target && anchor && _dom.contains.call(void 0, anchor, target) ? _KXQOQQ5Bcjs.getEventPoint.call(void 0, event) : null;
+          window.clearTimeout(hideTimeoutRef.current);
+          hideTimeoutRef.current = 0;
+          return;
+        }
+        if (hideTimeoutRef.current)
+          return;
+        if (enterPoint) {
+          const currentPoint = _KXQOQQ5Bcjs.getEventPoint.call(void 0, event);
+          const polygon = _KXQOQQ5Bcjs.getElementPolygon.call(void 0, element, enterPoint);
+          if (_KXQOQQ5Bcjs.isPointInPolygon.call(void 0, currentPoint, polygon)) {
+            enterPointRef.current = currentPoint;
+            if (!disablePointerEventsProp(event))
+              return;
+            event.preventDefault();
+            event.stopPropagation();
+            return;
+          }
+        }
+        if (!hideOnHoverOutsideProp(event))
+          return;
+        hideTimeoutRef.current = window.setTimeout(() => {
+          hideTimeoutRef.current = 0;
+          store == null ? void 0 : store.hide();
+        }, hideTimeout != null ? hideTimeout : timeout);
+      };
+      return _misc.chain.call(void 0, 
+        _events.addGlobalEventListener.call(void 0, "mousemove", onMouseMove, true),
+        () => clearTimeout(hideTimeoutRef.current)
+      );
+    }, [
+      store,
+      domReady,
+      mounted,
+      mayHideOnHoverOutside,
+      mayDisablePointerEvents,
+      nestedHovercards,
+      disablePointerEventsProp,
+      hideOnHoverOutsideProp
+    ]);
+    _react.useEffect.call(void 0, () => {
+      if (!domReady)
+        return;
+      if (!mounted)
+        return;
+      if (!mayDisablePointerEvents)
+        return;
+      const disableEvent = (event) => {
+        const element = ref.current;
+        if (!element)
+          return;
+        const enterPoint = enterPointRef.current;
+        if (!enterPoint)
+          return;
+        const polygon = _KXQOQQ5Bcjs.getElementPolygon.call(void 0, element, enterPoint);
+        if (_KXQOQQ5Bcjs.isPointInPolygon.call(void 0, _KXQOQQ5Bcjs.getEventPoint.call(void 0, event), polygon)) {
+          if (!disablePointerEventsProp(event))
+            return;
+          event.preventDefault();
+          event.stopPropagation();
+        }
+      };
+      return _misc.chain.call(void 0, 
+        // Note: we may need to add pointer events here in the future.
+        _events.addGlobalEventListener.call(void 0, "mouseenter", disableEvent, true),
+        _events.addGlobalEventListener.call(void 0, "mouseover", disableEvent, true),
+        _events.addGlobalEventListener.call(void 0, "mouseout", disableEvent, true),
+        _events.addGlobalEventListener.call(void 0, "mouseleave", disableEvent, true)
+      );
+    }, [domReady, mounted, mayDisablePointerEvents, disablePointerEventsProp]);
+    _react.useEffect.call(void 0, () => {
+      if (!domReady)
+        return;
+      if (open)
+        return;
+      store == null ? void 0 : store.setAutoFocusOnShow(false);
+    }, [store, domReady, open]);
+    const openRef = _EO6LS72Hcjs.useLiveRef.call(void 0, open);
+    _react.useEffect.call(void 0, () => {
+      if (!domReady)
+        return;
+      return () => {
+        if (!openRef.current) {
+          store == null ? void 0 : store.setAutoFocusOnShow(false);
+        }
+      };
+    }, [store, domReady]);
+    const registerOnParent = _react.useContext.call(void 0, NestedHovercardContext);
+    _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (modal)
+        return;
+      if (!portal)
+        return;
+      if (!mounted)
+        return;
+      if (!domReady)
+        return;
+      const element = ref.current;
+      if (!element)
+        return;
+      return registerOnParent == null ? void 0 : registerOnParent(element);
+    }, [modal, portal, mounted, domReady]);
+    const registerNestedHovercard = _react.useCallback.call(void 0, 
+      (element) => {
+        setNestedHovercards((prevElements) => [...prevElements, element]);
+        const parentUnregister = registerOnParent == null ? void 0 : registerOnParent(element);
+        return () => {
+          setNestedHovercards(
+            (prevElements) => prevElements.filter((item) => item !== element)
+          );
+          parentUnregister == null ? void 0 : parentUnregister();
+        };
+      },
+      [registerOnParent]
+    );
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _3W6FH6JKcjs.HovercardScopedContextProvider, { value: store, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NestedHovercardContext.Provider, { value: registerNestedHovercard, children: element }) }),
+      [store, registerNestedHovercard]
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref)
+    });
+    props = useAutoFocusOnHide(_AV6KTKLEcjs.__spreadValues.call(void 0, { store }, props));
+    const autoFocusOnShow = store.useState(
+      (state) => modal || state.autoFocusOnShow
+    );
+    props = _OUEE5HOScjs.usePopover.call(void 0, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      store,
+      modal,
+      portal,
+      autoFocusOnShow
+    }, props), {
+      portalRef,
+      hideOnEscape(event) {
+        if (_misc.isFalsyBooleanCallback.call(void 0, hideOnEscape, event))
+          return false;
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            store == null ? void 0 : store.hide();
+          });
+        });
+        return true;
+      }
+    }));
+    return props;
+  }
+);
+var Hovercard = _ZL5DC555cjs.createDialogComponent.call(void 0, 
+  _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+    const htmlProps = useHovercard(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+  }),
+  _3W6FH6JKcjs.useHovercardProviderContext
+);
+if (process.env.NODE_ENV !== "production") {
+  Hovercard.displayName = "Hovercard";
+}
+
+
+
+
+exports.useHovercard = useHovercard; exports.Hovercard = Hovercard;

node_modules/@ariakit/react-core/cjs/__chunks/I65V32V2.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/tab/tab-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_UZNYSPKPcjs.CompositeContextProvider],
+  [_UZNYSPKPcjs.CompositeScopedContextProvider]
+);
+var useTabContext = ctx.useContext;
+var useTabScopedContext = ctx.useScopedContext;
+var useTabProviderContext = ctx.useProviderContext;
+var TabContextProvider = ctx.ContextProvider;
+var TabScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useTabContext = useTabContext; exports.useTabScopedContext = useTabScopedContext; exports.useTabProviderContext = useTabProviderContext; exports.TabContextProvider = TabContextProvider; exports.TabScopedContextProvider = TabScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/IO6J4PAN.cjs

@@ -0,0 +1,410 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _DAJUUBUIcjs = require('./DAJUUBUI.cjs');
+
+
+var _R5A2WTWBcjs = require('./R5A2WTWB.cjs');
+
+
+
+
+var _6ZZYUFPWcjs = require('./6ZZYUFPW.cjs');
+
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-item.tsx
+var _react = require('react');
+
+
+
+
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+var _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+function isEditableElement(element) {
+  if (element.isContentEditable)
+    return true;
+  if (_dom.isTextField.call(void 0, element))
+    return true;
+  return element.tagName === "INPUT" && !_dom.isButton.call(void 0, element);
+}
+function getNextPageOffset(scrollingElement, pageUp = false) {
+  const height = scrollingElement.clientHeight;
+  const { top } = scrollingElement.getBoundingClientRect();
+  const pageSize = Math.max(height * 0.875, height - 40) * 1.5;
+  const pageOffset = pageUp ? height - pageSize + top : pageSize + top;
+  if (scrollingElement.tagName === "HTML") {
+    return pageOffset + scrollingElement.scrollTop;
+  }
+  return pageOffset;
+}
+function getItemOffset(itemElement, pageUp = false) {
+  const { top } = itemElement.getBoundingClientRect();
+  if (pageUp) {
+    return top + itemElement.clientHeight;
+  }
+  return top;
+}
+function findNextPageItemId(element, store, next, pageUp = false) {
+  var _a;
+  if (!store)
+    return;
+  if (!next)
+    return;
+  const { renderedItems } = store.getState();
+  const scrollingElement = _dom.getScrollingElement.call(void 0, element);
+  if (!scrollingElement)
+    return;
+  const nextPageOffset = getNextPageOffset(scrollingElement, pageUp);
+  let id;
+  let prevDifference;
+  for (let i = 0; i < renderedItems.length; i += 1) {
+    const previousId = id;
+    id = next(i);
+    if (!id)
+      break;
+    if (id === previousId)
+      continue;
+    const itemElement = (_a = _6ZZYUFPWcjs.getEnabledItem.call(void 0, store, id)) == null ? void 0 : _a.element;
+    if (!itemElement)
+      continue;
+    const itemOffset = getItemOffset(itemElement, pageUp);
+    const difference = itemOffset - nextPageOffset;
+    const absDifference = Math.abs(difference);
+    if (pageUp && difference <= 0 || !pageUp && difference >= 0) {
+      if (prevDifference !== void 0 && prevDifference < absDifference) {
+        id = previousId;
+      }
+      break;
+    }
+    prevDifference = absDifference;
+  }
+  return id;
+}
+function targetIsAnotherItem(event, store) {
+  if (_events.isSelfTarget.call(void 0, event))
+    return false;
+  return _6ZZYUFPWcjs.isItem.call(void 0, store, event.target);
+}
+function useRole(ref, props) {
+  const roleProp = props.role;
+  const [role, setRole] = _react.useState.call(void 0, roleProp);
+  _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+    const element = ref.current;
+    if (!element)
+      return;
+    setRole(element.getAttribute("role") || roleProp);
+  }, [roleProp]);
+  return role;
+}
+function requiresAriaSelected(role) {
+  return role === "option" || role === "treeitem";
+}
+function supportsAriaSelected(role) {
+  if (role === "option")
+    return true;
+  if (role === "tab")
+    return true;
+  if (role === "treeitem")
+    return true;
+  if (role === "gridcell")
+    return true;
+  if (role === "row")
+    return true;
+  if (role === "columnheader")
+    return true;
+  if (role === "rowheader")
+    return true;
+  return false;
+}
+var useCompositeItem = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      rowId: rowIdProp,
+      preventScrollOnKeyDown = false,
+      moveOnKeyPress = true,
+      tabbable = false,
+      getItem: getItemProp,
+      "aria-setsize": ariaSetSizeProp,
+      "aria-posinset": ariaPosInSetProp
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "rowId",
+      "preventScrollOnKeyDown",
+      "moveOnKeyPress",
+      "tabbable",
+      "getItem",
+      "aria-setsize",
+      "aria-posinset"
+    ]);
+    const context = _UZNYSPKPcjs.useCompositeContext.call(void 0, );
+    store = store || context;
+    const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+    const ref = _react.useRef.call(void 0, null);
+    const row = _react.useContext.call(void 0, _UZNYSPKPcjs.CompositeRowContext);
+    const rowId = _OLOZ5JT2cjs.useStoreState.call(void 0, store, (state) => {
+      if (rowIdProp)
+        return rowIdProp;
+      if (!state)
+        return;
+      if (!(row == null ? void 0 : row.baseElement))
+        return;
+      if (row.baseElement !== state.baseElement)
+        return;
+      return row.id;
+    });
+    const disabled = _misc.disabledFromProps.call(void 0, props);
+    const trulyDisabled = disabled && !props.accessibleWhenDisabled;
+    const getItem = _react.useCallback.call(void 0, 
+      (item) => {
+        const nextItem = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, item), {
+          id: id || item.id,
+          rowId,
+          disabled: !!trulyDisabled
+        });
+        if (getItemProp) {
+          return getItemProp(nextItem);
+        }
+        return nextItem;
+      },
+      [id, rowId, trulyDisabled, getItemProp]
+    );
+    const onFocusProp = props.onFocus;
+    const hasFocusedComposite = _react.useRef.call(void 0, false);
+    const onFocus = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onFocusProp == null ? void 0 : onFocusProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (_events.isPortalEvent.call(void 0, event))
+        return;
+      if (!id)
+        return;
+      if (!store)
+        return;
+      const { activeId, virtualFocus: virtualFocus2, baseElement: baseElement2 } = store.getState();
+      if (targetIsAnotherItem(event, store))
+        return;
+      if (activeId !== id) {
+        store.setActiveId(id);
+      }
+      if (!virtualFocus2)
+        return;
+      if (!_events.isSelfTarget.call(void 0, event))
+        return;
+      if (isEditableElement(event.currentTarget))
+        return;
+      if (!(baseElement2 == null ? void 0 : baseElement2.isConnected))
+        return;
+      hasFocusedComposite.current = true;
+      const fromComposite = event.relatedTarget === baseElement2 || _6ZZYUFPWcjs.isItem.call(void 0, store, event.relatedTarget);
+      if (fromComposite) {
+        _6ZZYUFPWcjs.focusSilently.call(void 0, baseElement2);
+      } else {
+        baseElement2.focus();
+      }
+    });
+    const onBlurCaptureProp = props.onBlurCapture;
+    const onBlurCapture = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onBlurCaptureProp == null ? void 0 : onBlurCaptureProp(event);
+      if (event.defaultPrevented)
+        return;
+      const state = store == null ? void 0 : store.getState();
+      if ((state == null ? void 0 : state.virtualFocus) && hasFocusedComposite.current) {
+        hasFocusedComposite.current = false;
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    });
+    const onKeyDownProp = props.onKeyDown;
+    const preventScrollOnKeyDownProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, preventScrollOnKeyDown);
+    const moveOnKeyPressProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, moveOnKeyPress);
+    const onKeyDown = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onKeyDownProp == null ? void 0 : onKeyDownProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!_events.isSelfTarget.call(void 0, event))
+        return;
+      if (!store)
+        return;
+      const { currentTarget } = event;
+      const state = store.getState();
+      const item = store.item(id);
+      const isGrid = !!(item == null ? void 0 : item.rowId);
+      const isVertical = state.orientation !== "horizontal";
+      const isHorizontal = state.orientation !== "vertical";
+      const canHomeEnd = () => {
+        if (isGrid)
+          return true;
+        if (isHorizontal)
+          return true;
+        if (!state.baseElement)
+          return true;
+        if (!_dom.isTextField.call(void 0, state.baseElement))
+          return true;
+        return false;
+      };
+      const keyMap = {
+        ArrowUp: (isGrid || isVertical) && store.up,
+        ArrowRight: (isGrid || isHorizontal) && store.next,
+        ArrowDown: (isGrid || isVertical) && store.down,
+        ArrowLeft: (isGrid || isHorizontal) && store.previous,
+        Home: () => {
+          if (!canHomeEnd())
+            return;
+          if (!isGrid || event.ctrlKey) {
+            return store == null ? void 0 : store.first();
+          }
+          return store == null ? void 0 : store.previous(-1);
+        },
+        End: () => {
+          if (!canHomeEnd())
+            return;
+          if (!isGrid || event.ctrlKey) {
+            return store == null ? void 0 : store.last();
+          }
+          return store == null ? void 0 : store.next(-1);
+        },
+        PageUp: () => {
+          return findNextPageItemId(currentTarget, store, store == null ? void 0 : store.up, true);
+        },
+        PageDown: () => {
+          return findNextPageItemId(currentTarget, store, store == null ? void 0 : store.down);
+        }
+      };
+      const action = keyMap[event.key];
+      if (action) {
+        const nextId = action();
+        if (preventScrollOnKeyDownProp(event) || nextId !== void 0) {
+          if (!moveOnKeyPressProp(event))
+            return;
+          event.preventDefault();
+          store.move(nextId);
+        }
+      }
+    });
+    const baseElement = _OLOZ5JT2cjs.useStoreState.call(void 0, 
+      store,
+      (state) => (state == null ? void 0 : state.baseElement) || void 0
+    );
+    const providerValue = _react.useMemo.call(void 0, 
+      () => ({ id, baseElement }),
+      [id, baseElement]
+    );
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _UZNYSPKPcjs.CompositeItemContext.Provider, { value: providerValue, children: element }),
+      [providerValue]
+    );
+    const isActiveItem = _OLOZ5JT2cjs.useStoreState.call(void 0, 
+      store,
+      (state) => !!state && state.activeId === id
+    );
+    const virtualFocus = _OLOZ5JT2cjs.useStoreState.call(void 0, store, "virtualFocus");
+    const role = useRole(ref, props);
+    let ariaSelected;
+    if (isActiveItem) {
+      if (requiresAriaSelected(role)) {
+        ariaSelected = true;
+      } else if (virtualFocus && supportsAriaSelected(role)) {
+        ariaSelected = true;
+      }
+    }
+    const ariaSetSize = _OLOZ5JT2cjs.useStoreState.call(void 0, store, (state) => {
+      if (ariaSetSizeProp != null)
+        return ariaSetSizeProp;
+      if (!state)
+        return;
+      if (!(row == null ? void 0 : row.ariaSetSize))
+        return;
+      if (row.baseElement !== state.baseElement)
+        return;
+      return row.ariaSetSize;
+    });
+    const ariaPosInSet = _OLOZ5JT2cjs.useStoreState.call(void 0, store, (state) => {
+      if (ariaPosInSetProp != null)
+        return ariaPosInSetProp;
+      if (!state)
+        return;
+      if (!(row == null ? void 0 : row.ariaPosInSet))
+        return;
+      if (row.baseElement !== state.baseElement)
+        return;
+      const itemsInRow = state.renderedItems.filter(
+        (item) => item.rowId === rowId
+      );
+      return row.ariaPosInSet + itemsInRow.findIndex((item) => item.id === id);
+    });
+    const isTabbable = _OLOZ5JT2cjs.useStoreState.call(void 0, store, (state) => {
+      if (!(state == null ? void 0 : state.renderedItems.length))
+        return true;
+      if (state.virtualFocus)
+        return false;
+      if (tabbable)
+        return true;
+      return state.activeId === id;
+    });
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      id,
+      "aria-selected": ariaSelected,
+      "data-active-item": isActiveItem ? "" : void 0
+    }, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      tabIndex: isTabbable ? props.tabIndex : -1,
+      onFocus,
+      onBlurCapture,
+      onKeyDown
+    });
+    props = _DAJUUBUIcjs.useCommand.call(void 0, props);
+    props = _R5A2WTWBcjs.useCollectionItem.call(void 0, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      store
+    }, props), {
+      getItem,
+      shouldRegisterItem: !!id ? props.shouldRegisterItem : false
+    }));
+    return _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      "aria-setsize": ariaSetSize,
+      "aria-posinset": ariaPosInSet
+    });
+  }
+);
+var CompositeItem = _RNZNGEL4cjs.createMemoComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCompositeItem(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "button", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CompositeItem.displayName = "CompositeItem";
+}
+
+
+
+
+exports.useCompositeItem = useCompositeItem; exports.CompositeItem = CompositeItem;

node_modules/@ariakit/react-core/cjs/__chunks/IPYAEPOT.cjs

@@ -0,0 +1,134 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-hover.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _focus = require('@ariakit/core/utils/focus');
+var _misc = require('@ariakit/core/utils/misc');
+function getMouseDestination(event) {
+  const relatedTarget = event.relatedTarget;
+  if ((relatedTarget == null ? void 0 : relatedTarget.nodeType) === Node.ELEMENT_NODE) {
+    return relatedTarget;
+  }
+  return null;
+}
+function hoveringInside(event) {
+  const nextElement = getMouseDestination(event);
+  if (!nextElement)
+    return false;
+  return _dom.contains.call(void 0, event.currentTarget, nextElement);
+}
+var symbol = Symbol("composite-hover");
+function movingToAnotherItem(event) {
+  let dest = getMouseDestination(event);
+  if (!dest)
+    return false;
+  do {
+    if (_misc.hasOwnProperty.call(void 0, dest, symbol) && dest[symbol])
+      return true;
+    dest = dest.parentElement;
+  } while (dest);
+  return false;
+}
+var useCompositeHover = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      focusOnHover = true,
+      blurOnHoverEnd = !!focusOnHover
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "focusOnHover",
+      "blurOnHoverEnd"
+    ]);
+    const context = _UZNYSPKPcjs.useCompositeContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "CompositeHover must be wrapped in a Composite component."
+    );
+    const isMouseMoving = _EO6LS72Hcjs.useIsMouseMoving.call(void 0, );
+    const onMouseMoveProp = props.onMouseMove;
+    const focusOnHoverProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, focusOnHover);
+    const onMouseMove = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onMouseMoveProp == null ? void 0 : onMouseMoveProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!isMouseMoving())
+        return;
+      if (!focusOnHoverProp(event))
+        return;
+      if (!_focus.hasFocusWithin.call(void 0, event.currentTarget)) {
+        const baseElement = store == null ? void 0 : store.getState().baseElement;
+        if (baseElement && !_focus.hasFocus.call(void 0, baseElement)) {
+          baseElement.focus();
+        }
+      }
+      store == null ? void 0 : store.setActiveId(event.currentTarget.id);
+    });
+    const onMouseLeaveProp = props.onMouseLeave;
+    const blurOnHoverEndProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, blurOnHoverEnd);
+    const onMouseLeave = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      var _a2;
+      onMouseLeaveProp == null ? void 0 : onMouseLeaveProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!isMouseMoving())
+        return;
+      if (hoveringInside(event))
+        return;
+      if (movingToAnotherItem(event))
+        return;
+      if (!focusOnHoverProp(event))
+        return;
+      if (!blurOnHoverEndProp(event))
+        return;
+      store == null ? void 0 : store.setActiveId(null);
+      (_a2 = store == null ? void 0 : store.getState().baseElement) == null ? void 0 : _a2.focus();
+    });
+    const ref = _react.useCallback.call(void 0, (element) => {
+      if (!element)
+        return;
+      element[symbol] = true;
+    }, []);
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      onMouseMove,
+      onMouseLeave
+    });
+    return props;
+  }
+);
+var CompositeHover = _RNZNGEL4cjs.createMemoComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCompositeHover(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CompositeHover.displayName = "CompositeHover";
+}
+
+
+
+
+exports.useCompositeHover = useCompositeHover; exports.CompositeHover = CompositeHover;

node_modules/@ariakit/react-core/cjs/__chunks/J3OG6T3B.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _2BIO7R5Ncjs = require('./2BIO7R5N.cjs');
+
+// src/heading/heading-level.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+function HeadingLevel({ level, children }) {
+  const contextLevel = _react.useContext.call(void 0, _2BIO7R5Ncjs.HeadingContext);
+  const nextLevel = Math.max(
+    Math.min(level || contextLevel + 1, 6),
+    1
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _2BIO7R5Ncjs.HeadingContext.Provider, { value: nextLevel, children });
+}
+
+
+
+exports.HeadingLevel = HeadingLevel;

node_modules/@ariakit/react-core/cjs/__chunks/JAQJG42R.cjs

@@ -0,0 +1,27 @@
+"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; } }"use client";
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+// src/disclosure/disclosure-store.ts
+var _disclosurestore = require('@ariakit/core/disclosure/disclosure-store'); var Core = _interopRequireWildcard(_disclosurestore);
+function useDisclosureStoreProps(store, update, props) {
+  _EO6LS72Hcjs.useUpdateEffect.call(void 0, update, [props.store, props.disclosure]);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "open", "setOpen");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "mounted", "setMounted");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "animated");
+  return store;
+}
+function useDisclosureStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createDisclosureStore, props);
+  return useDisclosureStoreProps(store, update, props);
+}
+
+
+
+
+exports.useDisclosureStoreProps = useDisclosureStoreProps; exports.useDisclosureStore = useDisclosureStore;

node_modules/@ariakit/react-core/cjs/__chunks/JF225FQ5.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+// src/dialog/utils/prepend-hidden-dismiss.ts
+var _dom = require('@ariakit/core/utils/dom');
+function prependHiddenDismiss(container, onClick) {
+  const document = _dom.getDocument.call(void 0, container);
+  const button = document.createElement("button");
+  button.type = "button";
+  button.tabIndex = -1;
+  button.textContent = "Dismiss popup";
+  Object.assign(button.style, {
+    border: "0px",
+    clip: "rect(0 0 0 0)",
+    height: "1px",
+    margin: "-1px",
+    overflow: "hidden",
+    padding: "0px",
+    position: "absolute",
+    whiteSpace: "nowrap",
+    width: "1px"
+  });
+  button.addEventListener("click", onClick);
+  container.prepend(button);
+  const removeHiddenDismiss = () => {
+    button.removeEventListener("click", onClick);
+    button.remove();
+  };
+  return removeHiddenDismiss;
+}
+
+
+
+exports.prependHiddenDismiss = prependHiddenDismiss;

node_modules/@ariakit/react-core/cjs/__chunks/JQS6X2I5.cjs

@@ -0,0 +1,189 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _6ZZYUFPWcjs = require('./6ZZYUFPW.cjs');
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-container.ts
+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');
+function getFirstTabbable(container) {
+  _focus.restoreFocusIn.call(void 0, container);
+  const tabbable = _focus.getFirstTabbableIn.call(void 0, container);
+  _focus.disableFocusIn.call(void 0, container);
+  return tabbable;
+}
+var useCompositeContainer = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _UZNYSPKPcjs.useCompositeContext.call(void 0, );
+    store = store || context;
+    const ref = _react.useRef.call(void 0, null);
+    const isOpenRef = _react.useRef.call(void 0, false);
+    const open = (collapseToEnd = false) => {
+      const container = ref.current;
+      if (!container)
+        return;
+      _focus.restoreFocusIn.call(void 0, container);
+      const tabbable = _focus.getFirstTabbableIn.call(void 0, container);
+      if (!tabbable) {
+        _focus.disableFocusIn.call(void 0, container);
+        return;
+      }
+      isOpenRef.current = true;
+      queueMicrotask(() => {
+        tabbable.focus();
+        if (_dom.isTextField.call(void 0, tabbable) || tabbable.isContentEditable) {
+          _6ZZYUFPWcjs.selectTextField.call(void 0, tabbable, collapseToEnd);
+        }
+      });
+    };
+    const close = () => {
+      const container = ref.current;
+      if (!container)
+        return;
+      isOpenRef.current = false;
+      _focus.disableFocusIn.call(void 0, container);
+    };
+    const renderedItems = _OLOZ5JT2cjs.useStoreState.call(void 0, store, "renderedItems");
+    _react.useEffect.call(void 0, () => {
+      const container = ref.current;
+      if (!container)
+        return;
+      const isOpen = isOpenRef.current;
+      if (!isOpen && (renderedItems == null ? void 0 : renderedItems.length)) {
+        _focus.disableFocusIn.call(void 0, container);
+      }
+    }, [renderedItems]);
+    const onFocusProp = props.onFocus;
+    const onFocus = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onFocusProp == null ? void 0 : onFocusProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!store)
+        return;
+      const isOpen = isOpenRef.current;
+      if (_events.isSelfTarget.call(void 0, event)) {
+        isOpenRef.current = false;
+        const { baseElement } = store.getState();
+        const composite = baseElement;
+        const selector = "[data-composite-container]";
+        const containers = composite == null ? void 0 : composite.querySelectorAll(selector);
+        containers == null ? void 0 : containers.forEach((container) => _focus.disableFocusIn.call(void 0, container));
+      } else if (!isOpen) {
+        isOpenRef.current = true;
+        _focus.restoreFocusIn.call(void 0, event.currentTarget);
+        store == null ? void 0 : store.setState("moves", 0);
+      }
+    });
+    const onBlurProp = props.onBlur;
+    const onBlur = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onBlurProp == null ? void 0 : onBlurProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (_events.isFocusEventOutside.call(void 0, event)) {
+        close();
+      }
+    });
+    const onKeyDownProp = props.onKeyDown;
+    const onKeyDown = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onKeyDownProp == null ? void 0 : onKeyDownProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (event.altKey)
+        return;
+      if (event.ctrlKey)
+        return;
+      if (event.metaKey)
+        return;
+      if (event.shiftKey)
+        return;
+      const container = event.currentTarget;
+      if (_events.isSelfTarget.call(void 0, event)) {
+        if (event.key.length === 1 && event.key !== " ") {
+          const tabbable = getFirstTabbable(container);
+          if (!tabbable)
+            return;
+          if (_dom.isTextField.call(void 0, tabbable) || tabbable.isContentEditable) {
+            event.stopPropagation();
+            open();
+          }
+        } else if (event.key === "Delete" || event.key === "Backspace") {
+          const tabbable = getFirstTabbable(container);
+          if (!tabbable)
+            return;
+          if (_dom.isTextField.call(void 0, tabbable) || tabbable.isContentEditable) {
+            open();
+            const onInput = () => queueMicrotask(() => container.focus());
+            container.addEventListener("input", onInput, { once: true });
+          }
+        }
+      } else if (event.key === "Escape") {
+        queueMicrotask(() => container.focus());
+      } else if (event.key === "Enter") {
+        const target = event.target;
+        const isInput = target.tagName === "INPUT" && !_dom.isButton.call(void 0, target) || target.tagName === "TEXTAREA";
+        if (isInput || target.isContentEditable) {
+          event.preventDefault();
+          queueMicrotask(() => container.focus());
+        }
+      }
+    });
+    const onClickProp = props.onClick;
+    const onClick = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onClickProp == null ? void 0 : onClickProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (_events.isSelfTarget.call(void 0, event) && !event.detail) {
+        open(true);
+      }
+    });
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      "data-composite-container": ""
+    }, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      onFocus,
+      onBlur,
+      onKeyDown,
+      onClick
+    });
+    return props;
+  }
+);
+var CompositeContainer = _RNZNGEL4cjs.createMemoComponent.call(void 0, (props) => {
+  const htmlProps = useCompositeContainer(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  CompositeContainer.displayName = "CompositeContainer";
+}
+
+
+
+
+exports.useCompositeContainer = useCompositeContainer; exports.CompositeContainer = CompositeContainer;

node_modules/@ariakit/react-core/cjs/__chunks/JVDUGICD.cjs

@@ -0,0 +1,151 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _VV6WA3I6cjs = require('./VV6WA3I6.cjs');
+
+
+var _7TN63K2Tcjs = require('./7TN63K2T.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/dialog/utils/use-hide-on-interact-outside.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+function isInDocument(target) {
+  if (target.tagName === "HTML")
+    return true;
+  return _dom.contains.call(void 0, _dom.getDocument.call(void 0, target).body, target);
+}
+function isDisclosure(disclosure, target) {
+  if (!disclosure)
+    return false;
+  if (_dom.contains.call(void 0, disclosure, target))
+    return true;
+  const activeId = target.getAttribute("aria-activedescendant");
+  if (activeId) {
+    const activeElement = _dom.getDocument.call(void 0, disclosure).getElementById(activeId);
+    if (activeElement) {
+      return _dom.contains.call(void 0, disclosure, activeElement);
+    }
+  }
+  return false;
+}
+function isMouseEventOnDialog(event, dialog) {
+  if (!("clientY" in event))
+    return false;
+  const rect = dialog.getBoundingClientRect();
+  if (rect.width === 0 || rect.height === 0)
+    return false;
+  return rect.top <= event.clientY && event.clientY <= rect.top + rect.height && rect.left <= event.clientX && event.clientX <= rect.left + rect.width;
+}
+function useEventOutside({
+  store,
+  type,
+  listener,
+  capture,
+  domReady
+}) {
+  const callListener = _EO6LS72Hcjs.useEvent.call(void 0, listener);
+  const open = store.useState("open");
+  const focusedRef = _react.useRef.call(void 0, false);
+  _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+    if (!open)
+      return;
+    if (!domReady)
+      return;
+    const { contentElement } = store.getState();
+    if (!contentElement)
+      return;
+    const onFocus = () => {
+      focusedRef.current = true;
+    };
+    contentElement.addEventListener("focusin", onFocus, true);
+    return () => contentElement.removeEventListener("focusin", onFocus, true);
+  }, [store, open, domReady]);
+  _react.useEffect.call(void 0, () => {
+    if (!open)
+      return;
+    const onEvent = (event) => {
+      const { contentElement, disclosureElement } = store.getState();
+      const target = event.target;
+      if (!contentElement)
+        return;
+      if (!target)
+        return;
+      if (!isInDocument(target))
+        return;
+      if (_dom.contains.call(void 0, contentElement, target))
+        return;
+      if (isDisclosure(disclosureElement, target))
+        return;
+      if (target.hasAttribute("data-focus-trap"))
+        return;
+      if (isMouseEventOnDialog(event, contentElement))
+        return;
+      const focused = focusedRef.current;
+      if (focused && !_VV6WA3I6cjs.isElementMarked.call(void 0, target, contentElement.id))
+        return;
+      callListener(event);
+    };
+    return _events.addGlobalEventListener.call(void 0, type, onEvent, capture);
+  }, [open, capture]);
+}
+function shouldHideOnInteractOutside(hideOnInteractOutside, event) {
+  if (typeof hideOnInteractOutside === "function") {
+    return hideOnInteractOutside(event);
+  }
+  return !!hideOnInteractOutside;
+}
+function useHideOnInteractOutside(store, hideOnInteractOutside, domReady) {
+  const open = store.useState("open");
+  const previousMouseDownRef = _7TN63K2Tcjs.usePreviousMouseDownRef.call(void 0, open);
+  const props = { store, domReady, capture: true };
+  useEventOutside(_AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+    type: "click",
+    listener: (event) => {
+      const { contentElement } = store.getState();
+      const previousMouseDown = previousMouseDownRef.current;
+      if (!previousMouseDown)
+        return;
+      if (!_dom.isVisible.call(void 0, previousMouseDown))
+        return;
+      if (!_VV6WA3I6cjs.isElementMarked.call(void 0, previousMouseDown, contentElement == null ? void 0 : contentElement.id))
+        return;
+      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event))
+        return;
+      store.hide();
+    }
+  }));
+  useEventOutside(_AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+    type: "focusin",
+    listener: (event) => {
+      const { contentElement } = store.getState();
+      if (!contentElement)
+        return;
+      if (event.target === _dom.getDocument.call(void 0, contentElement))
+        return;
+      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event))
+        return;
+      store.hide();
+    }
+  }));
+  useEventOutside(_AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+    type: "contextmenu",
+    listener: (event) => {
+      if (!shouldHideOnInteractOutside(hideOnInteractOutside, event))
+        return;
+      store.hide();
+    }
+  }));
+}
+
+
+
+exports.useHideOnInteractOutside = useHideOnInteractOutside;

node_modules/@ariakit/react-core/cjs/__chunks/KIDFNQ4E.cjs

@@ -0,0 +1,22 @@
+"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; } }"use client";
+
+
+var _LUL2YWZ3cjs = require('./LUL2YWZ3.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+// src/toolbar/toolbar-store.ts
+var _toolbarstore = require('@ariakit/core/toolbar/toolbar-store'); var Core = _interopRequireWildcard(_toolbarstore);
+function useToolbarStoreProps(store, update, props) {
+  return _LUL2YWZ3cjs.useCompositeStoreProps.call(void 0, store, update, props);
+}
+function useToolbarStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createToolbarStore, props);
+  return useToolbarStoreProps(store, update, props);
+}
+
+
+
+
+exports.useToolbarStoreProps = useToolbarStoreProps; exports.useToolbarStore = useToolbarStore;

node_modules/@ariakit/react-core/cjs/__chunks/KQN7YDDZ.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _YU7XEYUJcjs = require('./YU7XEYUJ.cjs');
+
+
+var _2WCJJQSKcjs = require('./2WCJJQSK.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/select/select-arrow.ts
+var useSelectArrow = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _2WCJJQSKcjs.useSelectContext.call(void 0, );
+    store = store || context;
+    props = _YU7XEYUJcjs.usePopoverDisclosureArrow.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store }, props));
+    return props;
+  }
+);
+var SelectArrow = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useSelectArrow(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "span", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  SelectArrow.displayName = "SelectArrow";
+}
+
+
+
+
+exports.useSelectArrow = useSelectArrow; exports.SelectArrow = SelectArrow;

node_modules/@ariakit/react-core/cjs/__chunks/KRB7URW5.cjs

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _62JWM3VQcjs = require('./62JWM3VQ.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/popover/popover-description.ts
+var usePopoverDescription = _RNZNGEL4cjs.createHook.call(void 0, 
+  (props) => {
+    props = _62JWM3VQcjs.useDialogDescription.call(void 0, props);
+    return props;
+  }
+);
+var PopoverDescription = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = usePopoverDescription(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "p", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  PopoverDescription.displayName = "PopoverDescription";
+}
+
+
+
+
+exports.usePopoverDescription = usePopoverDescription; exports.PopoverDescription = PopoverDescription;

node_modules/@ariakit/react-core/cjs/__chunks/KREY6HXD.cjs

@@ -0,0 +1,47 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+// src/dialog/utils/use-root-dialog.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _reactdom = require('react-dom');
+function useRootDialog({
+  attribute,
+  contentId,
+  contentElement,
+  enabled
+}) {
+  const [updated, retry] = _EO6LS72Hcjs.useForceUpdate.call(void 0, );
+  const isRootDialog = _react.useCallback.call(void 0, () => {
+    if (!enabled)
+      return false;
+    if (!contentElement)
+      return false;
+    const { body } = _dom.getDocument.call(void 0, contentElement);
+    const id = body.getAttribute(attribute);
+    return !id || id === contentId;
+  }, [updated, enabled, contentElement, attribute, contentId]);
+  _react.useEffect.call(void 0, () => {
+    if (!enabled)
+      return;
+    if (!contentId)
+      return;
+    if (!contentElement)
+      return;
+    const { body } = _dom.getDocument.call(void 0, contentElement);
+    if (isRootDialog()) {
+      body.setAttribute(attribute, contentId);
+      return () => body.removeAttribute(attribute);
+    }
+    const observer = new MutationObserver(() => _reactdom.flushSync.call(void 0, retry));
+    observer.observe(body, { attributeFilter: [attribute] });
+    return () => observer.disconnect();
+  }, [updated, enabled, contentId, contentElement, isRootDialog, attribute]);
+  return isRootDialog;
+}
+
+
+
+exports.useRootDialog = useRootDialog;

node_modules/@ariakit/react-core/cjs/__chunks/KSAZE5E2.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _FE3YCURHcjs = require('./FE3YCURH.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/group/group.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var useGroup = _RNZNGEL4cjs.createHook.call(void 0, (props) => {
+  const [labelId, setLabelId] = _react.useState.call(void 0, );
+  props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+    props,
+    (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _FE3YCURHcjs.GroupLabelContext.Provider, { value: setLabelId, children: element }),
+    []
+  );
+  props = _AV6KTKLEcjs.__spreadValues.call(void 0, {
+    role: "group",
+    "aria-labelledby": labelId
+  }, props);
+  return props;
+});
+var Group = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useGroup(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Group.displayName = "Group";
+}
+
+
+
+
+exports.useGroup = useGroup; exports.Group = Group;

node_modules/@ariakit/react-core/cjs/__chunks/KSPMHEYZ.cjs

@@ -0,0 +1,63 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _PZL34OVOcjs = require('./PZL34OVO.cjs');
+
+
+var _7YLCVXZ7cjs = require('./7YLCVXZ7.cjs');
+
+
+var _5GTNIPQ6cjs = require('./5GTNIPQ6.cjs');
+
+
+
+
+var _V24PR4PWcjs = require('./V24PR4PW.cjs');
+
+
+var _6IUEXB4Lcjs = require('./6IUEXB4L.cjs');
+
+// src/dialog/utils/disable-tree.ts
+var _dom = require('@ariakit/core/utils/dom');
+var _focus = require('@ariakit/core/utils/focus');
+var _misc = require('@ariakit/core/utils/misc');
+function disableTree(element, ignoredElements) {
+  if (!("style" in element))
+    return _misc.noop;
+  if (_6IUEXB4Lcjs.supportsInert.call(void 0, )) {
+    return _V24PR4PWcjs.setProperty.call(void 0, element, "inert", true);
+  }
+  const tabbableElements = _focus.getAllTabbableIn.call(void 0, element, true);
+  const enableElements = tabbableElements.map((element2) => {
+    if (ignoredElements == null ? void 0 : ignoredElements.some((el) => el && _dom.contains.call(void 0, el, element2)))
+      return _misc.noop;
+    return _V24PR4PWcjs.setAttribute.call(void 0, element2, "tabindex", "-1");
+  });
+  return _misc.chain.call(void 0, 
+    ...enableElements,
+    _PZL34OVOcjs.hideElementFromAccessibilityTree.call(void 0, element),
+    _V24PR4PWcjs.assignStyle.call(void 0, element, {
+      pointerEvents: "none",
+      userSelect: "none",
+      cursor: "default"
+    })
+  );
+}
+function disableTreeOutside(id, elements) {
+  const cleanups = [];
+  const ids = elements.map((el) => el == null ? void 0 : el.id);
+  _5GTNIPQ6cjs.walkTreeOutside.call(void 0, id, elements, (element) => {
+    if (_7YLCVXZ7cjs.isBackdrop.call(void 0, element, ...ids))
+      return;
+    cleanups.unshift(disableTree(element, elements));
+  });
+  const restoreTreeOutside = () => {
+    cleanups.forEach((fn) => fn());
+  };
+  return restoreTreeOutside;
+}
+
+
+
+
+exports.disableTree = disableTree; exports.disableTreeOutside = disableTreeOutside;

node_modules/@ariakit/react-core/cjs/__chunks/KXQOQQ5B.cjs

@@ -0,0 +1,89 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+// src/hovercard/utils/polygon.ts
+function getEventPoint(event) {
+  return [event.clientX, event.clientY];
+}
+function isPointInPolygon(point, polygon) {
+  const [x, y] = point;
+  let inside = false;
+  const length = polygon.length;
+  for (let l = length, i = 0, j = l - 1; i < l; j = i++) {
+    const [xi, yi] = polygon[i];
+    const [xj, yj] = polygon[j];
+    const [, vy] = polygon[j === 0 ? l - 1 : j - 1] || [0, 0];
+    const where = (yi - yj) * (x - xi) - (xi - xj) * (y - yi);
+    if (yj < yi) {
+      if (y >= yj && y < yi) {
+        if (where === 0)
+          return true;
+        if (where > 0) {
+          if (y === yj) {
+            if (y > vy) {
+              inside = !inside;
+            }
+          } else {
+            inside = !inside;
+          }
+        }
+      }
+    } else if (yi < yj) {
+      if (y > yi && y <= yj) {
+        if (where === 0)
+          return true;
+        if (where < 0) {
+          if (y === yj) {
+            if (y < vy) {
+              inside = !inside;
+            }
+          } else {
+            inside = !inside;
+          }
+        }
+      }
+    } else if (y == yi && (x >= xj && x <= xi || x >= xi && x <= xj)) {
+      return true;
+    }
+  }
+  return inside;
+}
+function getEnterPointPlacement(enterPoint, rect) {
+  const { top, right, bottom, left } = rect;
+  const [x, y] = enterPoint;
+  const placementX = x < left ? "left" : x > right ? "right" : null;
+  const placementY = y < top ? "top" : y > bottom ? "bottom" : null;
+  return [placementX, placementY];
+}
+function getElementPolygon(element, enterPoint) {
+  const rect = element.getBoundingClientRect();
+  const { top, right, bottom, left } = rect;
+  const [x, y] = getEnterPointPlacement(enterPoint, rect);
+  const polygon = [enterPoint];
+  if (x) {
+    if (y !== "top") {
+      polygon.push([x === "left" ? left : right, top]);
+    }
+    polygon.push([x === "left" ? right : left, top]);
+    polygon.push([x === "left" ? right : left, bottom]);
+    if (y !== "bottom") {
+      polygon.push([x === "left" ? left : right, bottom]);
+    }
+  } else if (y === "top") {
+    polygon.push([left, top]);
+    polygon.push([left, bottom]);
+    polygon.push([right, bottom]);
+    polygon.push([right, top]);
+  } else {
+    polygon.push([left, bottom]);
+    polygon.push([left, top]);
+    polygon.push([right, top]);
+    polygon.push([right, bottom]);
+  }
+  return polygon;
+}
+
+
+
+
+
+exports.getEventPoint = getEventPoint; exports.isPointInPolygon = isPointInPolygon; exports.getElementPolygon = getElementPolygon;

node_modules/@ariakit/react-core/cjs/__chunks/LAUATD5O.cjs

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/role/role.ts
+var elements = [
+  "a",
+  "button",
+  "details",
+  "dialog",
+  "div",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "section",
+  "select",
+  "span",
+  "textarea",
+  "ul",
+  "svg"
+];
+var useRole = _RNZNGEL4cjs.createHook.call(void 0, (props) => {
+  return props;
+});
+var Role = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", props);
+});
+if (process.env.NODE_ENV !== "production") {
+  Role.displayName = "Role";
+}
+Object.assign(
+  Role,
+  elements.reduce((acc, element) => {
+    acc[element] = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+      return _RNZNGEL4cjs.createElement.call(void 0, element, props);
+    });
+    return acc;
+  }, {})
+);
+
+
+
+
+exports.useRole = useRole; exports.Role = Role;

node_modules/@ariakit/react-core/cjs/__chunks/LFHNPG2L.cjs

@@ -0,0 +1,87 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _5UTRYT6Ecjs = require('./5UTRYT6E.cjs');
+
+
+var _S6UU7NA4cjs = require('./S6UU7NA4.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/disclosure/disclosure.ts
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+var symbol = Symbol("disclosure");
+var useDisclosure = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store, toggleOnClick = true } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store", "toggleOnClick"]);
+    const context = _S6UU7NA4cjs.useDisclosureProviderContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "Disclosure must receive a `store` prop or be wrapped in a DisclosureProvider component."
+    );
+    const ref = _react.useRef.call(void 0, null);
+    const [expanded, setExpanded] = _react.useState.call(void 0, false);
+    const disclosureElement = store.useState("disclosureElement");
+    const open = store.useState("open");
+    _react.useEffect.call(void 0, () => {
+      let isCurrentDisclosure = disclosureElement === ref.current;
+      if (!(disclosureElement == null ? void 0 : disclosureElement.isConnected)) {
+        store == null ? void 0 : store.setDisclosureElement(ref.current);
+        isCurrentDisclosure = true;
+      }
+      setExpanded(open && isCurrentDisclosure);
+    }, [disclosureElement, store, open]);
+    const onClickProp = props.onClick;
+    const toggleOnClickProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, toggleOnClick);
+    const [isDuplicate, metadataProps] = _EO6LS72Hcjs.useMetadataProps.call(void 0, props, symbol, true);
+    const onClick = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onClickProp == null ? void 0 : onClickProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (isDuplicate)
+        return;
+      if (!toggleOnClickProp(event))
+        return;
+      store == null ? void 0 : store.setDisclosureElement(event.currentTarget);
+      store == null ? void 0 : store.toggle();
+    });
+    const contentElement = store.useState("contentElement");
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      "aria-expanded": expanded,
+      "aria-controls": contentElement == null ? void 0 : contentElement.id
+    }, metadataProps), props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      onClick
+    });
+    props = _5UTRYT6Ecjs.useButton.call(void 0, props);
+    return props;
+  }
+);
+var Disclosure = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useDisclosure(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "button", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Disclosure.displayName = "Disclosure";
+}
+
+
+
+
+exports.useDisclosure = useDisclosure; exports.Disclosure = Disclosure;

node_modules/@ariakit/react-core/cjs/__chunks/LICANQTI.cjs

@@ -0,0 +1,70 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _QCG6J6X5cjs = require('./QCG6J6X5.cjs');
+
+
+var _3QW6ELTGcjs = require('./3QW6ELTG.cjs');
+
+
+
+var _UVBBMANLcjs = require('./UVBBMANL.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/popover/popover-disclosure.tsx
+var _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+var usePopoverDisclosure = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _UVBBMANLcjs.usePopoverProviderContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "PopoverDisclosure must receive a `store` prop or be wrapped in a PopoverProvider component."
+    );
+    const onClickProp = props.onClick;
+    const onClick = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      store == null ? void 0 : store.setAnchorElement(event.currentTarget);
+      onClickProp == null ? void 0 : onClickProp(event);
+    });
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _UVBBMANLcjs.PopoverScopedContextProvider, { value: store, children: element }),
+      [store]
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      onClick
+    });
+    props = _3QW6ELTGcjs.usePopoverAnchor.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store }, props));
+    props = _QCG6J6X5cjs.useDialogDisclosure.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store }, props));
+    return props;
+  }
+);
+var PopoverDisclosure = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = usePopoverDisclosure(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "button", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  PopoverDisclosure.displayName = "PopoverDisclosure";
+}
+
+
+
+
+exports.usePopoverDisclosure = usePopoverDisclosure; exports.PopoverDisclosure = PopoverDisclosure;

node_modules/@ariakit/react-core/cjs/__chunks/LUL2YWZ3.cjs

@@ -0,0 +1,32 @@
+"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; } }"use client";
+
+
+var _CDNJPIEGcjs = require('./CDNJPIEG.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+// src/composite/composite-store.ts
+var _compositestore = require('@ariakit/core/composite/composite-store'); var Core = _interopRequireWildcard(_compositestore);
+function useCompositeStoreProps(store, update, props) {
+  store = _CDNJPIEGcjs.useCollectionStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "activeId", "setActiveId");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "includesBaseElement");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "virtualFocus");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "orientation");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "rtl");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "focusLoop");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "focusWrap");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "focusShift");
+  return store;
+}
+function useCompositeStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createCompositeStore, props);
+  return useCompositeStoreProps(store, update, props);
+}
+
+
+
+
+exports.useCompositeStoreProps = useCompositeStoreProps; exports.useCompositeStore = useCompositeStore;

node_modules/@ariakit/react-core/cjs/__chunks/LY6FB2NE.cjs

@@ -0,0 +1,187 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _6LVRCU4Jcjs = require('./6LVRCU4J.cjs');
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-renderer.tsx
+var _react = require('react');
+function getItemObject(item) {
+  if (!item || typeof item !== "object") {
+    return { value: item };
+  }
+  return item;
+}
+function countItems(items) {
+  if (!items)
+    return [0];
+  if (typeof items === "number") {
+    return Array.from({ length: items }, (_, index) => index + 1);
+  }
+  return items.reduce((count, item, index) => {
+    var _a, _b;
+    const object = getItemObject(item);
+    if (!object.items) {
+    }
+    if (!object.items) {
+      count[index] = index + 1;
+      return count;
+    }
+    const prevCount = (_a = count[index - 1]) != null ? _a : 0;
+    const itemsCount = (_b = countItems(object.items)[object.items.length - 1]) != null ? _b : 0;
+    count[index] = prevCount + itemsCount;
+    return count;
+  }, []);
+}
+function findFirst(items, offset = 1) {
+  for (let index = offset > 0 ? 0 : items.length - 1; index >= 0 && index < items.length; index += offset) {
+    const item = items[index];
+    const object = getItemObject(item);
+    if (object.items && findFirst(object.items, offset) !== -1)
+      return index;
+    if (!object.disabled)
+      return index;
+  }
+  return -1;
+}
+function findLast(items) {
+  return findFirst(items, -1);
+}
+function findById(items, id, baseId) {
+  return items.findIndex((item, index) => {
+    var _a;
+    const itemId = _6LVRCU4Jcjs.getCollectionRendererItemId.call(void 0, item, index, baseId);
+    if (itemId === id)
+      return true;
+    const object = getItemObject(item);
+    if ((_a = object.items) == null ? void 0 : _a.length)
+      return findById(object.items, id, itemId) !== -1;
+    const ids = id.split("/");
+    if (ids.length === 1)
+      return false;
+    return ids.some((id2) => itemId === id2);
+  });
+}
+function useCompositeRenderer(_a) {
+  var _b = _a, {
+    store,
+    orientation: orientationProp,
+    persistentIndices: persistentIndicesProp,
+    children: renderItem,
+    "aria-setsize": ariaSetSize,
+    "aria-posinset": ariaPosInSet = 1
+  } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+    "store",
+    "orientation",
+    "persistentIndices",
+    "children",
+    "aria-setsize",
+    "aria-posinset"
+  ]);
+  const context = _UZNYSPKPcjs.useCompositeContext.call(void 0, );
+  store = store || context;
+  const orientation = _OLOZ5JT2cjs.useStoreState.call(void 0, 
+    store,
+    (state) => (orientationProp != null ? orientationProp : (state == null ? void 0 : state.orientation) === "both") ? "vertical" : state == null ? void 0 : state.orientation
+  );
+  const items = _OLOZ5JT2cjs.useStoreState.call(void 0, store, (state) => {
+    var _a2;
+    if (!state)
+      return props.items;
+    if ("mounted" in state && !state.mounted)
+      return 0;
+    return (_a2 = props.items) != null ? _a2 : state.items;
+  });
+  const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+  const itemsCount = _react.useMemo.call(void 0, () => countItems(items), [items]);
+  const setSize = _react.useMemo.call(void 0, 
+    () => {
+      var _a2;
+      return (_a2 = ariaSetSize != null ? ariaSetSize : itemsCount[itemsCount.length - 1]) != null ? _a2 : 0;
+    },
+    [ariaSetSize, itemsCount]
+  );
+  const firstIndex = _react.useMemo.call(void 0, () => {
+    if (!items)
+      return -1;
+    if (typeof items === "number")
+      return 0;
+    if (!items.length)
+      return -1;
+    return findFirst(items);
+  }, [items]);
+  const lastIndex = _react.useMemo.call(void 0, () => {
+    if (!items)
+      return -1;
+    if (typeof items === "number")
+      return items - 1;
+    if (!items.length)
+      return -1;
+    return findLast(items);
+  }, [items]);
+  const activeId = _OLOZ5JT2cjs.useStoreState.call(void 0, store, "activeId");
+  const activeIndex = _react.useMemo.call(void 0, () => {
+    if (!id)
+      return -1;
+    if (!items)
+      return -1;
+    if (activeId == null)
+      return -1;
+    if (typeof items === "number")
+      return -1;
+    if (!items.length)
+      return -1;
+    return findById(items, activeId, id);
+  }, [id, items, activeId]);
+  const persistentIndices = _react.useMemo.call(void 0, () => {
+    const indices = [firstIndex, activeIndex, lastIndex].filter(
+      (index) => index >= 0
+    );
+    if (persistentIndicesProp) {
+      return [...persistentIndicesProp, ...indices];
+    }
+    return indices;
+  }, [firstIndex, activeIndex, lastIndex, persistentIndicesProp]);
+  return _6LVRCU4Jcjs.useCollectionRenderer.call(void 0, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+    id,
+    store,
+    orientation,
+    persistentIndices
+  }, props), {
+    children: (item) => {
+      var _a2;
+      const nextItem = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, item), {
+        "aria-setsize": setSize,
+        "aria-posinset": ariaPosInSet + ((_a2 = itemsCount[item.index - 1]) != null ? _a2 : 0)
+      });
+      return renderItem == null ? void 0 : renderItem(nextItem);
+    }
+  }));
+}
+var CompositeRenderer = _RNZNGEL4cjs.forwardRef.call(void 0, function CompositeRenderer2(props) {
+  const htmlProps = useCompositeRenderer(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+
+
+
+
+exports.useCompositeRenderer = useCompositeRenderer; exports.CompositeRenderer = CompositeRenderer;

node_modules/@ariakit/react-core/cjs/__chunks/LYIGAIJF.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/toolbar/toolbar-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_UZNYSPKPcjs.CompositeContextProvider],
+  [_UZNYSPKPcjs.CompositeScopedContextProvider]
+);
+var useToolbarContext = ctx.useContext;
+var useToolbarScopedContext = ctx.useScopedContext;
+var useToolbarProviderContext = ctx.useProviderContext;
+var ToolbarContextProvider = ctx.ContextProvider;
+var ToolbarScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useToolbarContext = useToolbarContext; exports.useToolbarScopedContext = useToolbarScopedContext; exports.useToolbarProviderContext = useToolbarProviderContext; exports.ToolbarContextProvider = ToolbarContextProvider; exports.ToolbarScopedContextProvider = ToolbarScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/M5JJ43AT.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _3W6FH6JKcjs = require('./3W6FH6JK.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/tooltip/tooltip-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_3W6FH6JKcjs.HovercardContextProvider],
+  [_3W6FH6JKcjs.HovercardScopedContextProvider]
+);
+var useTooltipContext = ctx.useContext;
+var useTooltipScopedContext = ctx.useScopedContext;
+var useTooltipProviderContext = ctx.useProviderContext;
+var TooltipContextProvider = ctx.ContextProvider;
+var TooltipScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useTooltipContext = useTooltipContext; exports.useTooltipScopedContext = useTooltipScopedContext; exports.useTooltipProviderContext = useTooltipProviderContext; exports.TooltipContextProvider = TooltipContextProvider; exports.TooltipScopedContextProvider = TooltipScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/N3XK7EAH.cjs

@@ -0,0 +1,132 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _FROYTN4Bcjs = require('./FROYTN4B.cjs');
+
+
+var _R5A2WTWBcjs = require('./R5A2WTWB.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/form/form-control.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+var _misc = require('@ariakit/core/utils/misc');
+function getNamedElement(ref, name) {
+  const element = ref.current;
+  if (!element)
+    return null;
+  if (element.name === name)
+    return element;
+  if (element.form) {
+    return element.form.elements.namedItem(name);
+  }
+  const document = _dom.getDocument.call(void 0, element);
+  return document.getElementsByName(name)[0];
+}
+function useItem(store, name, type) {
+  return store.useState(
+    (state) => state.items.find((item) => item.type === type && item.name === name)
+  );
+}
+var useFormControl = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      name: nameProp,
+      getItem: getItemProp,
+      touchOnBlur = true
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "name",
+      "getItem",
+      "touchOnBlur"
+    ]);
+    const context = _FROYTN4Bcjs.useFormContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "FormControl must be wrapped in a Form component."
+    );
+    const name = `${nameProp}`;
+    const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+    const ref = _react.useRef.call(void 0, null);
+    store.useValidate(async () => {
+      const element = getNamedElement(ref, name);
+      if (!element)
+        return;
+      await Promise.resolve();
+      if ("validity" in element && !element.validity.valid) {
+        store == null ? void 0 : store.setError(name, element.validationMessage);
+      }
+    });
+    const getItem = _react.useCallback.call(void 0, 
+      (item) => {
+        const nextItem = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, item), { id: id || item.id, name, type: "field" });
+        if (getItemProp) {
+          return getItemProp(nextItem);
+        }
+        return nextItem;
+      },
+      [id, name, getItemProp]
+    );
+    const onBlurProp = props.onBlur;
+    const touchOnBlurProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, touchOnBlur);
+    const onBlur = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onBlurProp == null ? void 0 : onBlurProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (!touchOnBlurProp(event))
+        return;
+      store == null ? void 0 : store.setFieldTouched(name, true);
+    });
+    const label = useItem(store, name, "label");
+    const error = useItem(store, name, "error");
+    const description = useItem(store, name, "description");
+    const describedBy = _misc.cx.call(void 0, 
+      error == null ? void 0 : error.id,
+      description == null ? void 0 : description.id,
+      props["aria-describedby"]
+    );
+    const invalid = store.useState(
+      () => !!(store == null ? void 0 : store.getError(name)) && store.getFieldTouched(name)
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      id,
+      "aria-labelledby": label == null ? void 0 : label.id,
+      "aria-invalid": invalid
+    }, props), {
+      "aria-describedby": describedBy || void 0,
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      onBlur
+    });
+    props = _R5A2WTWBcjs.useCollectionItem.call(void 0, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store }, props), { name, getItem }));
+    return props;
+  }
+);
+var FormControl = _RNZNGEL4cjs.createMemoComponent.call(void 0, (props) => {
+  const htmlProps = useFormControl(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "input", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  FormControl.displayName = "FormControl";
+}
+
+
+
+
+exports.useFormControl = useFormControl; exports.FormControl = FormControl;

node_modules/@ariakit/react-core/cjs/__chunks/NGEKJJDH.cjs

@@ -0,0 +1,53 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+
+
+
+var _7LBZXSLYcjs = require('./7LBZXSLY.cjs');
+
+
+
+var _UZNYSPKPcjs = require('./UZNYSPKP.cjs');
+
+
+
+var _3W6FH6JKcjs = require('./3W6FH6JK.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/menu/menu-context.ts
+var _react = require('react');
+var menu = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_UZNYSPKPcjs.CompositeContextProvider, _3W6FH6JKcjs.HovercardContextProvider],
+  [_UZNYSPKPcjs.CompositeScopedContextProvider, _3W6FH6JKcjs.HovercardScopedContextProvider]
+);
+var useMenuContext = menu.useContext;
+var useMenuScopedContext = menu.useScopedContext;
+var useMenuProviderContext = menu.useProviderContext;
+var MenuContextProvider = menu.ContextProvider;
+var MenuScopedContextProvider = menu.ScopedContextProvider;
+var useMenuBarContext = _7LBZXSLYcjs.useMenubarContext;
+var useMenuBarScopedContext = _7LBZXSLYcjs.useMenubarScopedContext;
+var useMenuBarProviderContext = _7LBZXSLYcjs.useMenubarProviderContext;
+var MenuBarContextProvider = _7LBZXSLYcjs.MenubarContextProvider;
+var MenuBarScopedContextProvider = _7LBZXSLYcjs.MenubarScopedContextProvider;
+var MenuItemCheckedContext = _react.createContext.call(void 0, 
+  void 0
+);
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.useMenuContext = useMenuContext; exports.useMenuScopedContext = useMenuScopedContext; exports.useMenuProviderContext = useMenuProviderContext; exports.MenuContextProvider = MenuContextProvider; exports.MenuScopedContextProvider = MenuScopedContextProvider; exports.useMenuBarContext = useMenuBarContext; exports.useMenuBarScopedContext = useMenuBarScopedContext; exports.useMenuBarProviderContext = useMenuBarProviderContext; exports.MenuBarContextProvider = MenuBarContextProvider; exports.MenuBarScopedContextProvider = MenuBarScopedContextProvider; exports.MenuItemCheckedContext = MenuItemCheckedContext;

node_modules/@ariakit/react-core/cjs/__chunks/NNINKJTT.cjs

@@ -0,0 +1,164 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _NGEKJJDHcjs = require('./NGEKJJDH.cjs');
+
+
+var _7LBZXSLYcjs = require('./7LBZXSLY.cjs');
+
+
+var _IPYAEPOTcjs = require('./IPYAEPOT.cjs');
+
+
+var _IO6J4PANcjs = require('./IO6J4PAN.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/menu/menu-item.ts
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+var _focus = require('@ariakit/core/utils/focus');
+var _misc = require('@ariakit/core/utils/misc');
+function menuHasFocus(baseElement, items, currentTarget) {
+  var _a;
+  if (!baseElement)
+    return false;
+  if (_focus.hasFocusWithin.call(void 0, baseElement))
+    return true;
+  const expandedItem = items == null ? void 0 : items.find((item) => {
+    var _a2;
+    if (item.element === currentTarget)
+      return false;
+    return ((_a2 = item.element) == null ? void 0 : _a2.getAttribute("aria-expanded")) === "true";
+  });
+  const expandedMenuId = (_a = expandedItem == null ? void 0 : expandedItem.element) == null ? void 0 : _a.getAttribute("aria-controls");
+  if (!expandedMenuId)
+    return false;
+  const doc = _dom.getDocument.call(void 0, baseElement);
+  const expandedMenu = doc.getElementById(expandedMenuId);
+  if (!expandedMenu)
+    return false;
+  if (_focus.hasFocusWithin.call(void 0, expandedMenu))
+    return true;
+  return !!expandedMenu.querySelector("[role=menuitem][aria-expanded=true]");
+}
+var useMenuItem = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      hideOnClick = true,
+      preventScrollOnKeyDown = true,
+      focusOnHover,
+      blurOnHoverEnd
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "hideOnClick",
+      "preventScrollOnKeyDown",
+      "focusOnHover",
+      "blurOnHoverEnd"
+    ]);
+    const menuContext = _NGEKJJDHcjs.useMenuScopedContext.call(void 0, true);
+    const menubarContext = _7LBZXSLYcjs.useMenubarScopedContext.call(void 0, );
+    store = store || menuContext || menubarContext;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "MenuItem must be wrapped in a MenuList, Menu or Menubar component"
+    );
+    const onClickProp = props.onClick;
+    const hideOnClickProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, hideOnClick);
+    const hideMenu = "hideAll" in store ? store.hideAll : void 0;
+    const isWithinMenu = !!hideMenu;
+    const onClick = _EO6LS72Hcjs.useEvent.call(void 0, (event) => {
+      onClickProp == null ? void 0 : onClickProp(event);
+      if (event.defaultPrevented)
+        return;
+      if (_events.isDownloading.call(void 0, event))
+        return;
+      if (_events.isOpeningInNewTab.call(void 0, event))
+        return;
+      if (!hideMenu)
+        return;
+      const popupType = event.currentTarget.getAttribute("aria-haspopup");
+      if (popupType === "menu")
+        return;
+      if (!hideOnClickProp(event))
+        return;
+      hideMenu();
+    });
+    const contentElement = _OLOZ5JT2cjs.useStoreState.call(void 0, 
+      store,
+      (state) => "contentElement" in state ? state.contentElement : null
+    );
+    const role = _dom.getPopupItemRole.call(void 0, contentElement, "menuitem");
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      role
+    }, props), {
+      onClick
+    });
+    props = _IO6J4PANcjs.useCompositeItem.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store, preventScrollOnKeyDown }, props));
+    props = _IPYAEPOTcjs.useCompositeHover.call(void 0, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      store
+    }, props), {
+      focusOnHover(event) {
+        const getFocusOnHover = () => {
+          if (typeof focusOnHover === "function")
+            return focusOnHover(event);
+          if (focusOnHover != null)
+            return focusOnHover;
+          return true;
+        };
+        if (!store)
+          return false;
+        if (!getFocusOnHover())
+          return false;
+        const { baseElement, items } = store.getState();
+        if (isWithinMenu) {
+          if (event.currentTarget.hasAttribute("aria-expanded")) {
+            event.currentTarget.focus();
+          }
+          return true;
+        }
+        if (menuHasFocus(baseElement, items, event.currentTarget)) {
+          event.currentTarget.focus();
+          return true;
+        }
+        return false;
+      },
+      blurOnHoverEnd(event) {
+        if (typeof blurOnHoverEnd === "function")
+          return blurOnHoverEnd(event);
+        if (blurOnHoverEnd != null)
+          return blurOnHoverEnd;
+        return isWithinMenu;
+      }
+    }));
+    return props;
+  }
+);
+var MenuItem = _RNZNGEL4cjs.createMemoComponent.call(void 0, (props) => {
+  const htmlProps = useMenuItem(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  MenuItem.displayName = "MenuItem";
+}
+
+
+
+
+exports.useMenuItem = useMenuItem; exports.MenuItem = MenuItem;

node_modules/@ariakit/react-core/cjs/__chunks/NONPPWSF.cjs

@@ -0,0 +1,45 @@
+"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; } }"use client";
+
+
+var _3WCBE6SUcjs = require('./3WCBE6SU.cjs');
+
+
+var _LUL2YWZ3cjs = require('./LUL2YWZ3.cjs');
+
+
+var _NRGWVSB5cjs = require('./NRGWVSB5.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/select/select-store.ts
+var _selectstore = require('@ariakit/core/select/select-store'); var Core = _interopRequireWildcard(_selectstore);
+function useSelectStoreProps(store, update, props) {
+  _EO6LS72Hcjs.useUpdateEffect.call(void 0, update, [props.combobox]);
+  store = _LUL2YWZ3cjs.useCompositeStoreProps.call(void 0, store, update, props);
+  store = _NRGWVSB5cjs.usePopoverStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "value", "setValue");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "setValueOnMove");
+  return Object.assign(store, { combobox: props.combobox });
+}
+function useSelectStore(props = {}) {
+  const combobox = _3WCBE6SUcjs.useComboboxProviderContext.call(void 0, );
+  props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+    combobox: props.combobox !== void 0 ? props.combobox : combobox
+  });
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createSelectStore, props);
+  return useSelectStoreProps(store, update, props);
+}
+
+
+
+
+exports.useSelectStoreProps = useSelectStoreProps; exports.useSelectStore = useSelectStore;

node_modules/@ariakit/react-core/cjs/__chunks/NRGWVSB5.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; } }"use client";
+
+
+var _W5LJEMLBcjs = require('./W5LJEMLB.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+// src/popover/popover-store.ts
+var _popoverstore = require('@ariakit/core/popover/popover-store'); var Core = _interopRequireWildcard(_popoverstore);
+function usePopoverStoreProps(store, update, props) {
+  _EO6LS72Hcjs.useUpdateEffect.call(void 0, update, [props.popover]);
+  store = _W5LJEMLBcjs.useDialogStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "placement");
+  return store;
+}
+function usePopoverStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createPopoverStore, props);
+  return usePopoverStoreProps(store, update, props);
+}
+
+
+
+
+exports.usePopoverStoreProps = usePopoverStoreProps; exports.usePopoverStore = usePopoverStore;

node_modules/@ariakit/react-core/cjs/__chunks/NY3D6JQT.cjs

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _UXFBTIBYcjs = require('./UXFBTIBY.cjs');
+
+
+var _3W6FH6JKcjs = require('./3W6FH6JK.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/hovercard/hovercard-dismiss.ts
+var useHovercardDismiss = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _3W6FH6JKcjs.useHovercardScopedContext.call(void 0, );
+    store = store || context;
+    props = _UXFBTIBYcjs.usePopoverDismiss.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store }, props));
+    return props;
+  }
+);
+var HovercardDismiss = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useHovercardDismiss(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "button", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  HovercardDismiss.displayName = "HovercardDismiss";
+}
+
+
+
+
+exports.useHovercardDismiss = useHovercardDismiss; exports.HovercardDismiss = HovercardDismiss;

node_modules/@ariakit/react-core/cjs/__chunks/ODJ76C5W.cjs

@@ -0,0 +1,62 @@
+"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; } }"use client";
+
+
+var _CDNJPIEGcjs = require('./CDNJPIEG.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/form/form-store.ts
+var _react = require('react');
+var _formstore = require('@ariakit/core/form/form-store'); var Core = _interopRequireWildcard(_formstore);
+function useFormStoreProps(store, update, props) {
+  store = _CDNJPIEGcjs.useCollectionStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "values", "setValues");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "errors", "setErrors");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "touched", "setTouched");
+  const useValue = _react.useCallback.call(void 0, 
+    (name) => store.useState(() => store.getValue(name)),
+    [store]
+  );
+  const useValidate = _react.useCallback.call(void 0, 
+    (callback) => {
+      callback = _EO6LS72Hcjs.useEvent.call(void 0, callback);
+      const items = store.useState("items");
+      _react.useEffect.call(void 0, () => store.onValidate(callback), [items, callback]);
+    },
+    [store]
+  );
+  const useSubmit = _react.useCallback.call(void 0, 
+    (callback) => {
+      callback = _EO6LS72Hcjs.useEvent.call(void 0, callback);
+      const items = store.useState("items");
+      _react.useEffect.call(void 0, () => store.onSubmit(callback), [items, callback]);
+    },
+    [store]
+  );
+  return _react.useMemo.call(void 0, 
+    () => _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, store), {
+      useValue,
+      useValidate,
+      useSubmit
+    }),
+    []
+  );
+}
+function useFormStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createFormStore, props);
+  return useFormStoreProps(store, update, props);
+}
+
+
+
+
+exports.useFormStoreProps = useFormStoreProps; exports.useFormStore = useFormStore;

node_modules/@ariakit/react-core/cjs/__chunks/OLOZ5JT2.cjs

@@ -0,0 +1,93 @@
+"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; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }"use client";
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/utils/store.tsx
+var _react = require('react'); var React = _interopRequireWildcard(_react);
+var _misc = require('@ariakit/core/utils/misc');
+var _store = require('@ariakit/core/utils/store');
+var _indexjs = require('use-sync-external-store/shim/index.js'); var _indexjs2 = _interopRequireDefault(_indexjs);
+var { useSyncExternalStore } = _indexjs2.default;
+var noopSubscribe = () => () => {
+};
+function useStoreState(store, keyOrSelector = _misc.identity) {
+  const storeSubscribe = React.useCallback(
+    (callback) => {
+      if (!store)
+        return noopSubscribe();
+      return _store.subscribe.call(void 0, store, null, callback);
+    },
+    [store]
+  );
+  const getSnapshot = () => {
+    const key = typeof keyOrSelector === "string" ? keyOrSelector : null;
+    const selector = typeof keyOrSelector === "function" ? keyOrSelector : null;
+    const state = store == null ? void 0 : store.getState();
+    if (selector)
+      return selector(state);
+    if (!state)
+      return;
+    if (!key)
+      return;
+    if (!_misc.hasOwnProperty.call(void 0, state, key))
+      return;
+    return state[key];
+  };
+  return useSyncExternalStore(storeSubscribe, getSnapshot, getSnapshot);
+}
+function useStoreProps(store, props, key, setKey) {
+  const value = _misc.hasOwnProperty.call(void 0, props, key) ? props[key] : void 0;
+  const setValue = setKey ? props[setKey] : void 0;
+  const propsRef = _EO6LS72Hcjs.useLiveRef.call(void 0, { value, setValue });
+  _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+    return _store.sync.call(void 0, store, [key], (state, prev) => {
+      const { value: value2, setValue: setValue2 } = propsRef.current;
+      if (!setValue2)
+        return;
+      if (state[key] === prev[key])
+        return;
+      if (state[key] === value2)
+        return;
+      setValue2(state[key]);
+    });
+  }, [store, key]);
+  _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+    if (value === void 0)
+      return;
+    store.setState(key, value);
+    return _store.batch.call(void 0, store, [key], () => {
+      if (value === void 0)
+        return;
+      store.setState(key, value);
+    });
+  });
+}
+function useStore(createStore, props) {
+  const [store, setStore] = React.useState(() => createStore(props));
+  _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => _store.init.call(void 0, store), [store]);
+  const useState2 = React.useCallback(
+    (keyOrSelector) => useStoreState(store, keyOrSelector),
+    [store]
+  );
+  const memoizedStore = React.useMemo(
+    () => _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, store), { useState: useState2 }),
+    [store, useState2]
+  );
+  const updateStore = _EO6LS72Hcjs.useEvent.call(void 0, () => {
+    setStore((store2) => createStore(_AV6KTKLEcjs.__spreadValues.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), store2.getState())));
+  });
+  return [memoizedStore, updateStore];
+}
+
+
+
+
+
+exports.useStoreState = useStoreState; exports.useStoreProps = useStoreProps; exports.useStore = useStore;

node_modules/@ariakit/react-core/cjs/__chunks/OUEE5HOS.cjs

@@ -0,0 +1,386 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _ZL5DC555cjs = require('./ZL5DC555.cjs');
+
+
+
+var _UVBBMANLcjs = require('./UVBBMANL.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/popover/popover.tsx
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+
+
+
+
+
+
+
+
+
+var _dom = require('@floating-ui/dom');
+var _jsxruntime = require('react/jsx-runtime');
+function createDOMRect(x = 0, y = 0, width = 0, height = 0) {
+  if (typeof DOMRect === "function") {
+    return new DOMRect(x, y, width, height);
+  }
+  const rect = {
+    x,
+    y,
+    width,
+    height,
+    top: y,
+    right: x + width,
+    bottom: y + height,
+    left: x
+  };
+  return _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, rect), { toJSON: () => rect });
+}
+function getDOMRect(anchorRect) {
+  if (!anchorRect)
+    return createDOMRect();
+  const { x, y, width, height } = anchorRect;
+  return createDOMRect(x, y, width, height);
+}
+function getAnchorElement(anchorElement, getAnchorRect) {
+  const contextElement = anchorElement || void 0;
+  return {
+    contextElement,
+    getBoundingClientRect: () => {
+      const anchor = anchorElement;
+      const anchorRect = getAnchorRect == null ? void 0 : getAnchorRect(anchor);
+      if (anchorRect || !anchor) {
+        return getDOMRect(anchorRect);
+      }
+      return anchor.getBoundingClientRect();
+    }
+  };
+}
+function isValidPlacement(flip2) {
+  return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(flip2);
+}
+function roundByDPR(value) {
+  const dpr = window.devicePixelRatio || 1;
+  return Math.round(value * dpr) / dpr;
+}
+function getOffsetMiddleware(arrowElement, props) {
+  return _dom.offset.call(void 0, ({ placement }) => {
+    var _a;
+    const arrowOffset = ((arrowElement == null ? void 0 : arrowElement.clientHeight) || 0) / 2;
+    const finalGutter = typeof props.gutter === "number" ? props.gutter + arrowOffset : (_a = props.gutter) != null ? _a : arrowOffset;
+    const hasAlignment = !!placement.split("-")[1];
+    return {
+      crossAxis: !hasAlignment ? props.shift : void 0,
+      mainAxis: finalGutter,
+      alignmentAxis: props.shift
+    };
+  });
+}
+function getFlipMiddleware(props) {
+  if (props.flip === false)
+    return;
+  const fallbackPlacements = typeof props.flip === "string" ? props.flip.split(" ") : void 0;
+  _misc.invariant.call(void 0, 
+    !fallbackPlacements || fallbackPlacements.every(isValidPlacement),
+    process.env.NODE_ENV !== "production" && "`flip` expects a spaced-delimited list of placements"
+  );
+  return _dom.flip.call(void 0, {
+    padding: props.overflowPadding,
+    fallbackPlacements
+  });
+}
+function getShiftMiddleware(props) {
+  if (!props.slide && !props.overlap)
+    return;
+  return _dom.shift.call(void 0, {
+    mainAxis: props.slide,
+    crossAxis: props.overlap,
+    padding: props.overflowPadding,
+    limiter: _dom.limitShift.call(void 0, )
+  });
+}
+function getSizeMiddleware(props) {
+  return _dom.size.call(void 0, {
+    padding: props.overflowPadding,
+    apply({ elements, availableWidth, availableHeight, rects }) {
+      const wrapper = elements.floating;
+      const referenceWidth = Math.round(rects.reference.width);
+      availableWidth = Math.floor(availableWidth);
+      availableHeight = Math.floor(availableHeight);
+      wrapper.style.setProperty(
+        "--popover-anchor-width",
+        `${referenceWidth}px`
+      );
+      wrapper.style.setProperty(
+        "--popover-available-width",
+        `${availableWidth}px`
+      );
+      wrapper.style.setProperty(
+        "--popover-available-height",
+        `${availableHeight}px`
+      );
+      if (props.sameWidth) {
+        wrapper.style.width = `${referenceWidth}px`;
+      }
+      if (props.fitViewport) {
+        wrapper.style.maxWidth = `${availableWidth}px`;
+        wrapper.style.maxHeight = `${availableHeight}px`;
+      }
+    }
+  });
+}
+function getArrowMiddleware(arrowElement, props) {
+  if (!arrowElement)
+    return;
+  return _dom.arrow.call(void 0, {
+    element: arrowElement,
+    padding: props.arrowPadding
+  });
+}
+var usePopover = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      modal = false,
+      portal = !!modal,
+      preserveTabOrder = true,
+      autoFocusOnShow = true,
+      wrapperProps,
+      fixed = false,
+      flip: flip2 = true,
+      shift: shift2 = 0,
+      slide = true,
+      overlap = false,
+      sameWidth = false,
+      fitViewport = false,
+      gutter,
+      arrowPadding = 4,
+      overflowPadding = 8,
+      getAnchorRect,
+      updatePosition
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "modal",
+      "portal",
+      "preserveTabOrder",
+      "autoFocusOnShow",
+      "wrapperProps",
+      "fixed",
+      "flip",
+      "shift",
+      "slide",
+      "overlap",
+      "sameWidth",
+      "fitViewport",
+      "gutter",
+      "arrowPadding",
+      "overflowPadding",
+      "getAnchorRect",
+      "updatePosition"
+    ]);
+    const context = _UVBBMANLcjs.usePopoverProviderContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "Popover must receive a `store` prop or be wrapped in a PopoverProvider component."
+    );
+    const arrowElement = store.useState("arrowElement");
+    const anchorElement = store.useState("anchorElement");
+    const disclosureElement = store.useState("disclosureElement");
+    const popoverElement = store.useState("popoverElement");
+    const contentElement = store.useState("contentElement");
+    const placement = store.useState("placement");
+    const mounted = store.useState("mounted");
+    const rendered = store.useState("rendered");
+    const [positioned, setPositioned] = _react.useState.call(void 0, false);
+    const { portalRef, domReady } = _EO6LS72Hcjs.usePortalRef.call(void 0, portal, props.portalRef);
+    const getAnchorRectProp = _EO6LS72Hcjs.useEvent.call(void 0, getAnchorRect);
+    const updatePositionProp = _EO6LS72Hcjs.useEvent.call(void 0, updatePosition);
+    const hasCustomUpdatePosition = !!updatePosition;
+    _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (!(popoverElement == null ? void 0 : popoverElement.isConnected))
+        return;
+      popoverElement.style.setProperty(
+        "--popover-overflow-padding",
+        `${overflowPadding}px`
+      );
+      const anchor = getAnchorElement(anchorElement, getAnchorRectProp);
+      const updatePosition2 = async () => {
+        if (!mounted)
+          return;
+        const middleware = [
+          getOffsetMiddleware(arrowElement, { gutter, shift: shift2 }),
+          getFlipMiddleware({ flip: flip2, overflowPadding }),
+          getShiftMiddleware({ slide, shift: shift2, overlap, overflowPadding }),
+          getArrowMiddleware(arrowElement, { arrowPadding }),
+          getSizeMiddleware({
+            sameWidth,
+            fitViewport,
+            overflowPadding
+          })
+        ];
+        const pos = await _dom.computePosition.call(void 0, anchor, popoverElement, {
+          placement,
+          strategy: fixed ? "fixed" : "absolute",
+          middleware
+        });
+        store == null ? void 0 : store.setState("currentPlacement", pos.placement);
+        setPositioned(true);
+        const x = roundByDPR(pos.x);
+        const y = roundByDPR(pos.y);
+        Object.assign(popoverElement.style, {
+          top: "0",
+          left: "0",
+          transform: `translate3d(${x}px,${y}px,0)`
+        });
+        if (arrowElement && pos.middlewareData.arrow) {
+          const { x: arrowX, y: arrowY } = pos.middlewareData.arrow;
+          const dir = pos.placement.split("-")[0];
+          Object.assign(arrowElement.style, {
+            left: arrowX != null ? `${arrowX}px` : "",
+            top: arrowY != null ? `${arrowY}px` : "",
+            [dir]: "100%"
+          });
+        }
+      };
+      const update = async () => {
+        if (hasCustomUpdatePosition) {
+          await updatePositionProp({ updatePosition: updatePosition2 });
+          setPositioned(true);
+        } else {
+          await updatePosition2();
+        }
+      };
+      const cancelAutoUpdate = _dom.autoUpdate.call(void 0, anchor, popoverElement, update, {
+        // JSDOM doesn't support ResizeObserver
+        elementResize: typeof ResizeObserver === "function"
+      });
+      return () => {
+        setPositioned(false);
+        cancelAutoUpdate();
+      };
+    }, [
+      store,
+      rendered,
+      popoverElement,
+      arrowElement,
+      anchorElement,
+      popoverElement,
+      placement,
+      mounted,
+      domReady,
+      fixed,
+      flip2,
+      shift2,
+      slide,
+      overlap,
+      sameWidth,
+      fitViewport,
+      gutter,
+      arrowPadding,
+      overflowPadding,
+      getAnchorRectProp,
+      hasCustomUpdatePosition,
+      updatePositionProp
+    ]);
+    _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+      if (!mounted)
+        return;
+      if (!domReady)
+        return;
+      if (!(popoverElement == null ? void 0 : popoverElement.isConnected))
+        return;
+      if (!(contentElement == null ? void 0 : contentElement.isConnected))
+        return;
+      const applyZIndex = () => {
+        popoverElement.style.zIndex = getComputedStyle(contentElement).zIndex;
+      };
+      applyZIndex();
+      let raf = requestAnimationFrame(() => {
+        raf = requestAnimationFrame(applyZIndex);
+      });
+      return () => cancelAnimationFrame(raf);
+    }, [mounted, domReady, popoverElement, contentElement]);
+    const position = fixed ? "fixed" : "absolute";
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        "div",
+        _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+          role: "presentation"
+        }, wrapperProps), {
+          style: _AV6KTKLEcjs.__spreadValues.call(void 0, {
+            // https://floating-ui.com/docs/computeposition#initial-layout
+            position,
+            top: 0,
+            left: 0,
+            width: "max-content"
+          }, wrapperProps == null ? void 0 : wrapperProps.style),
+          ref: store == null ? void 0 : store.setPopoverElement,
+          children: element
+        })
+      ),
+      [store, position, wrapperProps]
+    );
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _UVBBMANLcjs.PopoverScopedContextProvider, { value: store, children: element }),
+      [store]
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      // data-placing is not part of the public API. We're setting this here so
+      // we can wait for the popover to be positioned before other components
+      // move focus into it. For example, this attribute is observed by the
+      // Combobox component with the autoSelect behavior.
+      "data-placing": !positioned ? "" : void 0
+    }, props), {
+      style: _AV6KTKLEcjs.__spreadValues.call(void 0, {
+        position: "relative"
+      }, props.style)
+    });
+    props = _ZL5DC555cjs.useDialog.call(void 0, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      store,
+      modal,
+      portal,
+      preserveTabOrder,
+      preserveTabOrderAnchor: disclosureElement || anchorElement,
+      autoFocusOnShow: positioned && autoFocusOnShow
+    }, props), {
+      portalRef
+    }));
+    return props;
+  }
+);
+var Popover = _ZL5DC555cjs.createDialogComponent.call(void 0, 
+  _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+    const htmlProps = usePopover(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+  }),
+  _UVBBMANLcjs.usePopoverProviderContext
+);
+if (process.env.NODE_ENV !== "production") {
+  Popover.displayName = "Popover";
+}
+
+
+
+
+exports.usePopover = usePopover; exports.Popover = Popover;

node_modules/@ariakit/react-core/cjs/__chunks/OZ4FTKEH.cjs

@@ -0,0 +1,27 @@
+"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; } }"use client";
+
+
+var _NRGWVSB5cjs = require('./NRGWVSB5.cjs');
+
+
+
+var _OLOZ5JT2cjs = require('./OLOZ5JT2.cjs');
+
+// src/hovercard/hovercard-store.ts
+var _hovercardstore = require('@ariakit/core/hovercard/hovercard-store'); var Core = _interopRequireWildcard(_hovercardstore);
+function useHovercardStoreProps(store, update, props) {
+  store = _NRGWVSB5cjs.usePopoverStoreProps.call(void 0, store, update, props);
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "timeout");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "showTimeout");
+  _OLOZ5JT2cjs.useStoreProps.call(void 0, store, props, "hideTimeout");
+  return store;
+}
+function useHovercardStore(props = {}) {
+  const [store, update] = _OLOZ5JT2cjs.useStore.call(void 0, Core.createHovercardStore, props);
+  return useHovercardStoreProps(store, update, props);
+}
+
+
+
+
+exports.useHovercardStoreProps = useHovercardStoreProps; exports.useHovercardStore = useHovercardStore;

node_modules/@ariakit/react-core/cjs/__chunks/PZL34OVO.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _7YLCVXZ7cjs = require('./7YLCVXZ7.cjs');
+
+
+var _5GTNIPQ6cjs = require('./5GTNIPQ6.cjs');
+
+
+var _V24PR4PWcjs = require('./V24PR4PW.cjs');
+
+// src/dialog/utils/disable-accessibility-tree-outside.ts
+function hideElementFromAccessibilityTree(element) {
+  return _V24PR4PWcjs.setAttribute.call(void 0, element, "aria-hidden", "true");
+}
+function disableAccessibilityTreeOutside(id, elements) {
+  const cleanups = [];
+  const ids = elements.map((el) => el == null ? void 0 : el.id);
+  _5GTNIPQ6cjs.walkTreeOutside.call(void 0, id, elements, (element) => {
+    if (_7YLCVXZ7cjs.isBackdrop.call(void 0, element, ...ids))
+      return;
+    cleanups.unshift(hideElementFromAccessibilityTree(element));
+  });
+  const restoreAccessibilityTree = () => {
+    cleanups.forEach((fn) => fn());
+  };
+  return restoreAccessibilityTree;
+}
+
+
+
+
+exports.hideElementFromAccessibilityTree = hideElementFromAccessibilityTree; exports.disableAccessibilityTreeOutside = disableAccessibilityTreeOutside;

node_modules/@ariakit/react-core/cjs/__chunks/QCG6J6X5.cjs

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _LFHNPG2Lcjs = require('./LFHNPG2L.cjs');
+
+
+var _F2A2ZQDBcjs = require('./F2A2ZQDB.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/dialog/dialog-disclosure.ts
+var _dom = require('@ariakit/core/utils/dom');
+var _misc = require('@ariakit/core/utils/misc');
+var useDialogDisclosure = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    const context = _F2A2ZQDBcjs.useDialogProviderContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "DialogDisclosure must receive a `store` prop or be wrapped in a DialogProvider component."
+    );
+    const contentElement = store.useState("contentElement");
+    props = _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      "aria-haspopup": _dom.getPopupRole.call(void 0, contentElement, "dialog")
+    }, props);
+    props = _LFHNPG2Lcjs.useDisclosure.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store }, props));
+    return props;
+  }
+);
+var DialogDisclosure = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useDialogDisclosure(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "button", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  DialogDisclosure.displayName = "DialogDisclosure";
+}
+
+
+
+
+exports.useDialogDisclosure = useDialogDisclosure; exports.DialogDisclosure = DialogDisclosure;

node_modules/@ariakit/react-core/cjs/__chunks/QOD2KY3N.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/separator/separator.ts
+var useSeparator = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { orientation = "horizontal" } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["orientation"]);
+    props = _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      role: "separator",
+      "aria-orientation": orientation
+    }, props);
+    return props;
+  }
+);
+var Separator = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useSeparator(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "hr", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Separator.displayName = "Separator";
+}
+
+
+
+
+exports.useSeparator = useSeparator; exports.Separator = Separator;

node_modules/@ariakit/react-core/cjs/__chunks/QQCFY3MB.cjs

@@ -0,0 +1,44 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _FE3YCURHcjs = require('./FE3YCURH.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/group/group-label.ts
+var _react = require('react');
+var useGroupLabel = _RNZNGEL4cjs.createHook.call(void 0, (props) => {
+  const setLabelId = _react.useContext.call(void 0, _FE3YCURHcjs.GroupLabelContext);
+  const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+  _EO6LS72Hcjs.useSafeLayoutEffect.call(void 0, () => {
+    setLabelId == null ? void 0 : setLabelId(id);
+    return () => setLabelId == null ? void 0 : setLabelId(void 0);
+  }, [setLabelId, id]);
+  props = _AV6KTKLEcjs.__spreadValues.call(void 0, {
+    id,
+    "aria-hidden": true
+  }, props);
+  return props;
+});
+var GroupLabel = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useGroupLabel(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  GroupLabel.displayName = "GroupLabel";
+}
+
+
+
+
+exports.useGroupLabel = useGroupLabel; exports.GroupLabel = GroupLabel;

node_modules/@ariakit/react-core/cjs/__chunks/R5A2WTWB.cjs

@@ -0,0 +1,71 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _BZTDJIVTcjs = require('./BZTDJIVT.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/collection/collection-item.ts
+var _react = require('react');
+var _misc = require('@ariakit/core/utils/misc');
+var useCollectionItem = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store,
+      shouldRegisterItem = true,
+      getItem = _misc.identity,
+      element: element
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "shouldRegisterItem",
+      "getItem",
+      // @ts-expect-error This prop may come from a collection renderer.
+      "element"
+    ]);
+    const context = _BZTDJIVTcjs.useCollectionContext.call(void 0, );
+    store = store || context;
+    const id = _EO6LS72Hcjs.useId.call(void 0, props.id);
+    const ref = _react.useRef.call(void 0, element);
+    _react.useEffect.call(void 0, () => {
+      const element2 = ref.current;
+      if (!id)
+        return;
+      if (!element2)
+        return;
+      if (!shouldRegisterItem)
+        return;
+      const item = getItem({ id, element: element2 });
+      return store == null ? void 0 : store.renderItem(item);
+    }, [id, shouldRegisterItem, getItem, store]);
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref)
+    });
+    return props;
+  }
+);
+var CollectionItem = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCollectionItem(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CollectionItem.displayName = "CollectionItem";
+}
+
+
+
+
+exports.useCollectionItem = useCollectionItem; exports.CollectionItem = CollectionItem;

node_modules/@ariakit/react-core/cjs/__chunks/R66IWXK6.cjs

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/visually-hidden/visually-hidden.ts
+var useVisuallyHidden = _RNZNGEL4cjs.createHook.call(void 0, (props) => {
+  props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+    style: _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      border: 0,
+      clip: "rect(0 0 0 0)",
+      height: "1px",
+      margin: "-1px",
+      overflow: "hidden",
+      padding: 0,
+      position: "absolute",
+      whiteSpace: "nowrap",
+      width: "1px"
+    }, props.style)
+  });
+  return props;
+});
+var VisuallyHidden = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useVisuallyHidden(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "span", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  VisuallyHidden.displayName = "VisuallyHidden";
+}
+
+
+
+
+exports.useVisuallyHidden = useVisuallyHidden; exports.VisuallyHidden = VisuallyHidden;

node_modules/@ariakit/react-core/cjs/__chunks/RNGIWUQW.cjs

@@ -0,0 +1,82 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _7LBZXSLYcjs = require('./7LBZXSLY.cjs');
+
+
+var _EUHOCOY2cjs = require('./EUHOCOY2.cjs');
+
+
+var _H6OLBVHAcjs = require('./H6OLBVHA.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/menubar/menubar.tsx
+var _jsxruntime = require('react/jsx-runtime');
+var useMenubar = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, {
+      store: storeProp,
+      composite = true,
+      orientation: orientationProp,
+      virtualFocus,
+      focusLoop,
+      rtl
+    } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, [
+      "store",
+      "composite",
+      "orientation",
+      "virtualFocus",
+      "focusLoop",
+      "rtl"
+    ]);
+    const context = _7LBZXSLYcjs.useMenubarProviderContext.call(void 0, );
+    storeProp = storeProp || context;
+    const store = _EUHOCOY2cjs.useMenubarStore.call(void 0, {
+      store: storeProp,
+      orientation: orientationProp,
+      virtualFocus,
+      focusLoop,
+      rtl
+    });
+    const orientation = store.useState(
+      (state) => !composite || state.orientation === "both" ? void 0 : state.orientation
+    );
+    props = _EO6LS72Hcjs.useWrapElement.call(void 0, 
+      props,
+      (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _7LBZXSLYcjs.MenubarScopedContextProvider, { value: store, children: element }),
+      [store]
+    );
+    if (composite) {
+      props = _AV6KTKLEcjs.__spreadValues.call(void 0, {
+        role: "menubar",
+        "aria-orientation": orientation
+      }, props);
+    }
+    props = _H6OLBVHAcjs.useComposite.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, { store, composite }, props));
+    return props;
+  }
+);
+var Menubar = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useMenubar(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Menubar.displayName = "Menubar";
+}
+
+
+
+
+exports.useMenubar = useMenubar; exports.Menubar = Menubar;

node_modules/@ariakit/react-core/cjs/__chunks/RNZNGEL4.cjs

@@ -0,0 +1,144 @@
+"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; } }"use client";
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _CJDHQUBRcjs = require('./CJDHQUBR.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/utils/system.tsx
+var _react = require('react'); var React = _interopRequireWildcard(_react);
+var _misc = require('@ariakit/core/utils/misc');
+var _jsxruntime = require('react/jsx-runtime');
+function isRenderProp(children) {
+  return typeof children === "function";
+}
+function forwardRef2(render) {
+  const Role = React.forwardRef((props, ref) => render(_AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), { ref })));
+  Role.displayName = render.displayName || render.name;
+  return Role;
+}
+function memo2(Component, propsAreEqual) {
+  const Role = React.memo(Component, propsAreEqual);
+  Role.displayName = Component.displayName || Component.name;
+  return Role;
+}
+function createComponent(render) {
+  const Role = (props, ref) => render(_AV6KTKLEcjs.__spreadValues.call(void 0, { ref }, props));
+  return React.forwardRef(Role);
+}
+function createMemoComponent(render) {
+  const Role = createComponent(render);
+  return React.memo(Role);
+}
+function createElement(Type, props) {
+  const _a = props, { as: As, wrapElement, render } = _a, rest = _AV6KTKLEcjs.__objRest.call(void 0, _a, ["as", "wrapElement", "render"]);
+  let element;
+  const mergedRef = _EO6LS72Hcjs.useMergeRefs.call(void 0, props.ref, _CJDHQUBRcjs.getRefProperty.call(void 0, render));
+  if (process.env.NODE_ENV !== "production") {
+    React.useEffect(() => {
+      if (!As)
+        return;
+      console.warn(
+        "The `as` prop is deprecated. Use the `render` prop instead.",
+        "See https://ariakit.org/guide/composition"
+      );
+    }, [As]);
+  }
+  if (As && typeof As !== "string") {
+    element = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, As, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, rest), { render }));
+  } else if (React.isValidElement(render)) {
+    const renderProps = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, render.props), { ref: mergedRef });
+    element = React.cloneElement(render, _CJDHQUBRcjs.mergeProps.call(void 0, rest, renderProps));
+  } else if (render) {
+    element = render(rest);
+  } else if (isRenderProp(props.children)) {
+    if (process.env.NODE_ENV !== "production") {
+      React.useEffect(() => {
+        console.warn(
+          "The `children` prop as a function is deprecated. Use the `render` prop instead.",
+          "See https://ariakit.org/guide/composition"
+        );
+      }, []);
+    }
+    const _b = rest, { children } = _b, otherProps = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["children"]);
+    element = props.children(otherProps);
+  } else if (As) {
+    element = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, As, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, rest));
+  } else {
+    element = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Type, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, rest));
+  }
+  if (wrapElement) {
+    return wrapElement(element);
+  }
+  return element;
+}
+function createHook(useProps) {
+  const useRole = (props = {}) => {
+    const htmlProps = useProps(props);
+    const copy = {};
+    for (const prop in htmlProps) {
+      if (_misc.hasOwnProperty.call(void 0, htmlProps, prop) && htmlProps[prop] !== void 0) {
+        copy[prop] = htmlProps[prop];
+      }
+    }
+    return copy;
+  };
+  return useRole;
+}
+function createStoreContext(providers = [], scopedProviders = []) {
+  const context = React.createContext(void 0);
+  const scopedContext = React.createContext(void 0);
+  const useContext2 = () => React.useContext(context);
+  const useScopedContext = (onlyScoped = false) => {
+    const scoped = React.useContext(scopedContext);
+    const store = useContext2();
+    if (onlyScoped)
+      return scoped;
+    return scoped || store;
+  };
+  const useProviderContext = () => {
+    const scoped = React.useContext(scopedContext);
+    const store = useContext2();
+    if (scoped && scoped === store)
+      return;
+    return store;
+  };
+  const ContextProvider = (props) => {
+    return providers.reduceRight(
+      (children, Provider) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Provider, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), { children })),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, context.Provider, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props))
+    );
+  };
+  const ScopedContextProvider = (props) => {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, ContextProvider, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), { children: scopedProviders.reduceRight(
+      (children, Provider) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Provider, _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), { children })),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, scopedContext.Provider, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props))
+    ) }));
+  };
+  return {
+    context,
+    scopedContext,
+    useContext: useContext2,
+    useScopedContext,
+    useProviderContext,
+    ContextProvider,
+    ScopedContextProvider
+  };
+}
+
+
+
+
+
+
+
+
+
+exports.forwardRef = forwardRef2; exports.memo = memo2; exports.createComponent = createComponent; exports.createMemoComponent = createMemoComponent; exports.createElement = createElement; exports.createHook = createHook; exports.createStoreContext = createStoreContext;

node_modules/@ariakit/react-core/cjs/__chunks/S6UU7NA4.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/disclosure/disclosure-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, );
+var useDisclosureContext = ctx.useContext;
+var useDisclosureScopedContext = ctx.useScopedContext;
+var useDisclosureProviderContext = ctx.useProviderContext;
+var DisclosureContextProvider = ctx.ContextProvider;
+var DisclosureScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.useDisclosureContext = useDisclosureContext; exports.useDisclosureScopedContext = useDisclosureScopedContext; exports.useDisclosureProviderContext = useDisclosureProviderContext; exports.DisclosureContextProvider = DisclosureContextProvider; exports.DisclosureScopedContextProvider = DisclosureScopedContextProvider;

node_modules/@ariakit/react-core/cjs/__chunks/T4KYZJUY.cjs

@@ -0,0 +1,73 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _ERFHNHONcjs = require('./ERFHNHON.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/checkbox/checkbox-check.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var checkmark = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  "svg",
+  {
+    display: "block",
+    fill: "none",
+    stroke: "currentColor",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    strokeWidth: "1.5pt",
+    viewBox: "0 0 16 16",
+    height: "1em",
+    width: "1em",
+    children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "polyline", { points: "4,8 7,12 12,4" })
+  }
+);
+function getChildren(props) {
+  if (props.checked) {
+    return props.children || checkmark;
+  }
+  if (typeof props.children === "function") {
+    return props.children;
+  }
+  return null;
+}
+var useCheckboxCheck = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store, checked } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store", "checked"]);
+    const context = _react.useContext.call(void 0, _ERFHNHONcjs.CheckboxCheckedContext);
+    checked = checked != null ? checked : context;
+    const children = getChildren({ checked, children: props.children });
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+      "aria-hidden": true
+    }, props), {
+      children,
+      style: _AV6KTKLEcjs.__spreadValues.call(void 0, {
+        width: "1em",
+        height: "1em",
+        pointerEvents: "none"
+      }, props.style)
+    });
+    return props;
+  }
+);
+var CheckboxCheck = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useCheckboxCheck(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "span", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  CheckboxCheck.displayName = "CheckboxCheck";
+}
+
+
+
+
+exports.useCheckboxCheck = useCheckboxCheck; exports.CheckboxCheck = CheckboxCheck;

node_modules/@ariakit/react-core/cjs/__chunks/T7WLYFYV.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _7LBZXSLYcjs = require('./7LBZXSLY.cjs');
+
+
+var _EUHOCOY2cjs = require('./EUHOCOY2.cjs');
+
+// src/menubar/menubar-provider.tsx
+var _jsxruntime = require('react/jsx-runtime');
+function MenubarProvider(props = {}) {
+  const store = _EUHOCOY2cjs.useMenubarStore.call(void 0, props);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _7LBZXSLYcjs.MenubarContextProvider, { value: store, children: props.children });
+}
+
+
+
+exports.MenubarProvider = MenubarProvider;

node_modules/@ariakit/react-core/cjs/__chunks/TGTVGYEZ.cjs

@@ -0,0 +1,127 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _3W6FH6JKcjs = require('./3W6FH6JK.cjs');
+
+
+var _Z3GCTNW4cjs = require('./Z3GCTNW4.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/hovercard/hovercard-anchor.ts
+var _react = require('react');
+var _events = require('@ariakit/core/utils/events');
+var _misc = require('@ariakit/core/utils/misc');
+var useHovercardAnchor = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store, showOnHover = true } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store", "showOnHover"]);
+    const context = _3W6FH6JKcjs.useHovercardProviderContext.call(void 0, );
+    store = store || context;
+    _misc.invariant.call(void 0, 
+      store,
+      process.env.NODE_ENV !== "production" && "HovercardAnchor must receive a `store` prop or be wrapped in a HovercardProvider component."
+    );
+    const disabled = _misc.disabledFromProps.call(void 0, props);
+    const showTimeoutRef = _react.useRef.call(void 0, 0);
+    _react.useEffect.call(void 0, () => () => window.clearTimeout(showTimeoutRef.current), []);
+    _react.useEffect.call(void 0, () => {
+      const onMouseLeave = (event) => {
+        if (!store)
+          return;
+        const { anchorElement } = store.getState();
+        if (!anchorElement)
+          return;
+        if (event.target !== anchorElement)
+          return;
+        window.clearTimeout(showTimeoutRef.current);
+        showTimeoutRef.current = 0;
+      };
+      return _events.addGlobalEventListener.call(void 0, "mouseleave", onMouseLeave, true);
+    }, [store]);
+    const onMouseMoveProp = props.onMouseMove;
+    const showOnHoverProp = _EO6LS72Hcjs.useBooleanEvent.call(void 0, showOnHover);
+    const isMouseMoving = _EO6LS72Hcjs.useIsMouseMoving.call(void 0, );
+    const onMouseMove = _EO6LS72Hcjs.useEvent.call(void 0, 
+      (event) => {
+        onMouseMoveProp == null ? void 0 : onMouseMoveProp(event);
+        if (disabled)
+          return;
+        if (!store)
+          return;
+        if (event.defaultPrevented)
+          return;
+        if (showTimeoutRef.current)
+          return;
+        if (!isMouseMoving())
+          return;
+        if (!showOnHoverProp(event))
+          return;
+        const element = event.currentTarget;
+        store.setAnchorElement(element);
+        store.setDisclosureElement(element);
+        const { showTimeout, timeout } = store.getState();
+        const showHovercard = () => {
+          showTimeoutRef.current = 0;
+          if (!isMouseMoving())
+            return;
+          store == null ? void 0 : store.setAnchorElement(element);
+          store == null ? void 0 : store.show();
+          queueMicrotask(() => {
+            store == null ? void 0 : store.setDisclosureElement(element);
+          });
+        };
+        const timeoutMs = showTimeout != null ? showTimeout : timeout;
+        if (timeoutMs === 0) {
+          showHovercard();
+        } else {
+          showTimeoutRef.current = window.setTimeout(showHovercard, timeoutMs);
+        }
+      }
+    );
+    const ref = _react.useCallback.call(void 0, 
+      (element) => {
+        if (!store)
+          return;
+        const { anchorElement } = store.getState();
+        if (anchorElement == null ? void 0 : anchorElement.isConnected)
+          return;
+        store.setAnchorElement(element);
+      },
+      [store]
+    );
+    props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {}, props), {
+      ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref),
+      onMouseMove
+    });
+    props = _Z3GCTNW4cjs.useFocusable.call(void 0, props);
+    return props;
+  }
+);
+var HovercardAnchor = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useHovercardAnchor(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "a", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  HovercardAnchor.displayName = "HovercardAnchor";
+}
+
+
+
+
+exports.useHovercardAnchor = useHovercardAnchor; exports.HovercardAnchor = HovercardAnchor;

node_modules/@ariakit/react-core/cjs/__chunks/TK6GOI2V.cjs

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _2BIO7R5Ncjs = require('./2BIO7R5N.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+
+var _EO6LS72Hcjs = require('./EO6LS72H.cjs');
+
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/heading/heading.tsx
+var _react = require('react');
+var _jsxruntime = require('react/jsx-runtime');
+var useHeading = _RNZNGEL4cjs.createHook.call(void 0, (props) => {
+  const ref = _react.useRef.call(void 0, null);
+  const level = _react.useContext.call(void 0, _2BIO7R5Ncjs.HeadingContext) || 1;
+  const Element = `h${level}`;
+  const tagName = _EO6LS72Hcjs.useTagName.call(void 0, ref, Element);
+  const isNativeHeading = _react.useMemo.call(void 0, 
+    () => !!tagName && /^h\d$/.test(tagName),
+    [tagName]
+  );
+  props = _AV6KTKLEcjs.__spreadProps.call(void 0, _AV6KTKLEcjs.__spreadValues.call(void 0, {
+    render: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Element, {}),
+    role: !isNativeHeading ? "heading" : void 0,
+    "aria-level": !isNativeHeading ? level : void 0
+  }, props), {
+    ref: _EO6LS72Hcjs.useMergeRefs.call(void 0, ref, props.ref)
+  });
+  return props;
+});
+var Heading = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useHeading(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "h1", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  Heading.displayName = "Heading";
+}
+
+
+
+
+exports.useHeading = useHeading; exports.Heading = Heading;

node_modules/@ariakit/react-core/cjs/__chunks/TUDQDX77.cjs

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _QQCFY3MBcjs = require('./QQCFY3MB.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/composite/composite-group-label.ts
+var useCompositeGroupLabel = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    props = _QQCFY3MBcjs.useGroupLabel.call(void 0, props);
+    return props;
+  }
+);
+var CompositeGroupLabel = _RNZNGEL4cjs.createComponent.call(void 0, 
+  (props) => {
+    const htmlProps = useCompositeGroupLabel(props);
+    return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+  }
+);
+if (process.env.NODE_ENV !== "production") {
+  CompositeGroupLabel.displayName = "CompositeGroupLabel";
+}
+
+
+
+
+exports.useCompositeGroupLabel = useCompositeGroupLabel; exports.CompositeGroupLabel = CompositeGroupLabel;

node_modules/@ariakit/react-core/cjs/__chunks/UKXZY6PK.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+var _KSAZE5E2cjs = require('./KSAZE5E2.cjs');
+
+
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+
+var _AV6KTKLEcjs = require('./AV6KTKLE.cjs');
+
+// src/form/form-group.ts
+var useFormGroup = _RNZNGEL4cjs.createHook.call(void 0, 
+  (_a) => {
+    var _b = _a, { store } = _b, props = _AV6KTKLEcjs.__objRest.call(void 0, _b, ["store"]);
+    props = _KSAZE5E2cjs.useGroup.call(void 0, props);
+    return props;
+  }
+);
+var FormGroup = _RNZNGEL4cjs.createComponent.call(void 0, (props) => {
+  const htmlProps = useFormGroup(props);
+  return _RNZNGEL4cjs.createElement.call(void 0, "div", htmlProps);
+});
+if (process.env.NODE_ENV !== "production") {
+  FormGroup.displayName = "FormGroup";
+}
+
+
+
+
+exports.useFormGroup = useFormGroup; exports.FormGroup = FormGroup;

node_modules/@ariakit/react-core/cjs/__chunks/UVBBMANL.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
+
+
+
+var _F2A2ZQDBcjs = require('./F2A2ZQDB.cjs');
+
+
+var _RNZNGEL4cjs = require('./RNZNGEL4.cjs');
+
+// src/popover/popover-context.tsx
+var ctx = _RNZNGEL4cjs.createStoreContext.call(void 0, 
+  [_F2A2ZQDBcjs.DialogContextProvider],
+  [_F2A2ZQDBcjs.DialogScopedContextProvider]
+);
+var usePopoverContext = ctx.useContext;
+var usePopoverScopedContext = ctx.useScopedContext;
+var usePopoverProviderContext = ctx.useProviderContext;
+var PopoverContextProvider = ctx.ContextProvider;
+var PopoverScopedContextProvider = ctx.ScopedContextProvider;
+
+
+
+
+
+
+
+exports.usePopoverContext = usePopoverContext; exports.usePopoverScopedContext = usePopoverScopedContext; exports.usePopoverProviderContext = usePopoverProviderContext; exports.PopoverContextProvider = PopoverContextProvider; exports.PopoverScopedContextProvider = PopoverScopedContextProvider;