@easypost/easy-ui 1.0.0-alpha.4 → 1.0.0-alpha.6

package/__chunks__/useTriggerWidth-156b038a.js

@@ -0,0 +1,2030 @@
+"use strict";
+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 __knownSymbol = (name, symbol) => {
+  if (symbol = Symbol[name])
+    return symbol;
+  throw Error("Symbol." + name + " is not defined");
+};
+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;
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")];
+  var isAwait = false;
+  var method;
+  var it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw")
+          throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object))
+            throw TypeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+const _import = require("./import-a1e0f814.js");
+const _import$1 = require("./import-2b302763.js");
+const _import$2 = require("./import-a2023d8f.js");
+const React = require("react");
+const realModule = require("./real-module-e36b1436.js");
+const _import$3 = require("./import-dea5a24d.js");
+const utilities_css = require("../utilities/css.js");
+function $feb5ffebff200149$export$d3e3bd3e26688c04(e) {
+  return _import.$c87311424ea30a05$export$e1865c3bedcd822b() ? e.altKey : e.ctrlKey;
+}
+function $feb5ffebff200149$export$16792effe837dba3(e) {
+  if (_import.$c87311424ea30a05$export$9ac100e40613ea10())
+    return e.metaKey;
+  return e.ctrlKey;
+}
+const $fb3050f43d946246$var$TYPEAHEAD_DEBOUNCE_WAIT_MS = 1e3;
+function $fb3050f43d946246$export$e32c88dfddc6e1d8(options) {
+  let { keyboardDelegate, selectionManager, onTypeSelect } = options;
+  let state = React.useRef({
+    search: "",
+    timeout: null
+  }).current;
+  let onKeyDown = (e) => {
+    let character = $fb3050f43d946246$var$getStringForKey(e.key);
+    if (!character || e.ctrlKey || e.metaKey || !e.currentTarget.contains(e.target))
+      return;
+    if (character === " " && state.search.trim().length > 0) {
+      e.preventDefault();
+      if (!("continuePropagation" in e))
+        e.stopPropagation();
+    }
+    state.search += character;
+    let key = keyboardDelegate.getKeyForSearch(state.search, selectionManager.focusedKey);
+    if (key == null)
+      key = keyboardDelegate.getKeyForSearch(state.search);
+    if (key != null) {
+      selectionManager.setFocusedKey(key);
+      if (onTypeSelect)
+        onTypeSelect(key);
+    }
+    clearTimeout(state.timeout);
+    state.timeout = setTimeout(() => {
+      state.search = "";
+    }, $fb3050f43d946246$var$TYPEAHEAD_DEBOUNCE_WAIT_MS);
+  };
+  return {
+    typeSelectProps: {
+      // Using a capturing listener to catch the keydown event before
+      // other hooks in order to handle the Spacebar event.
+      onKeyDownCapture: keyboardDelegate.getKeyForSearch ? onKeyDown : null
+    }
+  };
+}
+function $fb3050f43d946246$var$getStringForKey(key) {
+  if (key.length === 1 || !/^[A-Z]/i.test(key))
+    return key;
+  return "";
+}
+function $ae20dd8cbca75726$export$d6daf82dcd84e87c(options) {
+  let { selectionManager: manager, keyboardDelegate: delegate, ref, autoFocus = false, shouldFocusWrap = false, disallowEmptySelection = false, disallowSelectAll = false, selectOnFocus = manager.selectionBehavior === "replace", disallowTypeAhead = false, shouldUseVirtualFocus, allowsTabNavigation = false, isVirtualized, scrollRef = ref } = options;
+  let { direction } = realModule.$18f2051aff69b9bf$export$43bb16f9c6d9e3f7();
+  let onKeyDown = (e) => {
+    if (e.altKey && e.key === "Tab")
+      e.preventDefault();
+    if (!ref.current.contains(e.target))
+      return;
+    const navigateToKey = (key, childFocus) => {
+      if (key != null) {
+        manager.setFocusedKey(key, childFocus);
+        if (e.shiftKey && manager.selectionMode === "multiple")
+          manager.extendSelection(key);
+        else if (selectOnFocus && !$feb5ffebff200149$export$d3e3bd3e26688c04(e))
+          manager.replaceSelection(key);
+      }
+    };
+    switch (e.key) {
+      case "ArrowDown":
+        if (delegate.getKeyBelow) {
+          var _delegate_getFirstKey, _delegate_getFirstKey1;
+          e.preventDefault();
+          let nextKey = manager.focusedKey != null ? delegate.getKeyBelow(manager.focusedKey) : (_delegate_getFirstKey = delegate.getFirstKey) === null || _delegate_getFirstKey === void 0 ? void 0 : _delegate_getFirstKey.call(delegate);
+          if (nextKey == null && shouldFocusWrap)
+            nextKey = (_delegate_getFirstKey1 = delegate.getFirstKey) === null || _delegate_getFirstKey1 === void 0 ? void 0 : _delegate_getFirstKey1.call(delegate, manager.focusedKey);
+          navigateToKey(nextKey);
+        }
+        break;
+      case "ArrowUp":
+        if (delegate.getKeyAbove) {
+          var _delegate_getLastKey, _delegate_getLastKey1;
+          e.preventDefault();
+          let nextKey = manager.focusedKey != null ? delegate.getKeyAbove(manager.focusedKey) : (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate);
+          if (nextKey == null && shouldFocusWrap)
+            nextKey = (_delegate_getLastKey1 = delegate.getLastKey) === null || _delegate_getLastKey1 === void 0 ? void 0 : _delegate_getLastKey1.call(delegate, manager.focusedKey);
+          navigateToKey(nextKey);
+        }
+        break;
+      case "ArrowLeft":
+        if (delegate.getKeyLeftOf) {
+          var _delegate_getFirstKey2, _delegate_getLastKey2;
+          e.preventDefault();
+          let nextKey = delegate.getKeyLeftOf(manager.focusedKey);
+          if (nextKey == null && shouldFocusWrap)
+            nextKey = direction === "rtl" ? (_delegate_getFirstKey2 = delegate.getFirstKey) === null || _delegate_getFirstKey2 === void 0 ? void 0 : _delegate_getFirstKey2.call(delegate, manager.focusedKey) : (_delegate_getLastKey2 = delegate.getLastKey) === null || _delegate_getLastKey2 === void 0 ? void 0 : _delegate_getLastKey2.call(delegate, manager.focusedKey);
+          navigateToKey(nextKey, direction === "rtl" ? "first" : "last");
+        }
+        break;
+      case "ArrowRight":
+        if (delegate.getKeyRightOf) {
+          var _delegate_getLastKey3, _delegate_getFirstKey3;
+          e.preventDefault();
+          let nextKey = delegate.getKeyRightOf(manager.focusedKey);
+          if (nextKey == null && shouldFocusWrap)
+            nextKey = direction === "rtl" ? (_delegate_getLastKey3 = delegate.getLastKey) === null || _delegate_getLastKey3 === void 0 ? void 0 : _delegate_getLastKey3.call(delegate, manager.focusedKey) : (_delegate_getFirstKey3 = delegate.getFirstKey) === null || _delegate_getFirstKey3 === void 0 ? void 0 : _delegate_getFirstKey3.call(delegate, manager.focusedKey);
+          navigateToKey(nextKey, direction === "rtl" ? "last" : "first");
+        }
+        break;
+      case "Home":
+        if (delegate.getFirstKey) {
+          e.preventDefault();
+          let firstKey = delegate.getFirstKey(manager.focusedKey, $feb5ffebff200149$export$16792effe837dba3(e));
+          manager.setFocusedKey(firstKey);
+          if ($feb5ffebff200149$export$16792effe837dba3(e) && e.shiftKey && manager.selectionMode === "multiple")
+            manager.extendSelection(firstKey);
+          else if (selectOnFocus)
+            manager.replaceSelection(firstKey);
+        }
+        break;
+      case "End":
+        if (delegate.getLastKey) {
+          e.preventDefault();
+          let lastKey = delegate.getLastKey(manager.focusedKey, $feb5ffebff200149$export$16792effe837dba3(e));
+          manager.setFocusedKey(lastKey);
+          if ($feb5ffebff200149$export$16792effe837dba3(e) && e.shiftKey && manager.selectionMode === "multiple")
+            manager.extendSelection(lastKey);
+          else if (selectOnFocus)
+            manager.replaceSelection(lastKey);
+        }
+        break;
+      case "PageDown":
+        if (delegate.getKeyPageBelow) {
+          e.preventDefault();
+          let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
+          navigateToKey(nextKey);
+        }
+        break;
+      case "PageUp":
+        if (delegate.getKeyPageAbove) {
+          e.preventDefault();
+          let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
+          navigateToKey(nextKey);
+        }
+        break;
+      case "a":
+        if ($feb5ffebff200149$export$16792effe837dba3(e) && manager.selectionMode === "multiple" && disallowSelectAll !== true) {
+          e.preventDefault();
+          manager.selectAll();
+        }
+        break;
+      case "Escape":
+        e.preventDefault();
+        if (!disallowEmptySelection)
+          manager.clearSelection();
+        break;
+      case "Tab":
+        if (!allowsTabNavigation) {
+          if (e.shiftKey)
+            ref.current.focus();
+          else {
+            let walker = _import$1.$9bf71ea28793e738$export$2d6ec8fc375ceafa(ref.current, {
+              tabbable: true
+            });
+            let next;
+            let last;
+            do {
+              last = walker.lastChild();
+              if (last)
+                next = last;
+            } while (last);
+            if (next && !next.contains(document.activeElement))
+              _import.$7215afc6de606d6b$export$de79e2c695e052f3(next);
+          }
+          break;
+        }
+    }
+  };
+  let scrollPos = React.useRef({
+    top: 0,
+    left: 0
+  });
+  _import.$e9faafb641e167db$export$90fc3a17d93f704c(scrollRef, "scroll", isVirtualized ? null : () => {
+    scrollPos.current = {
+      top: scrollRef.current.scrollTop,
+      left: scrollRef.current.scrollLeft
+    };
+  });
+  let onFocus = (e) => {
+    if (manager.isFocused) {
+      if (!e.currentTarget.contains(e.target))
+        manager.setFocused(false);
+      return;
+    }
+    if (!e.currentTarget.contains(e.target))
+      return;
+    manager.setFocused(true);
+    if (manager.focusedKey == null) {
+      let navigateToFirstKey = (key) => {
+        if (key != null) {
+          manager.setFocusedKey(key);
+          if (selectOnFocus)
+            manager.replaceSelection(key);
+        }
+      };
+      let relatedTarget = e.relatedTarget;
+      var _manager_lastSelectedKey, _manager_firstSelectedKey;
+      if (relatedTarget && e.currentTarget.compareDocumentPosition(relatedTarget) & Node.DOCUMENT_POSITION_FOLLOWING)
+        navigateToFirstKey((_manager_lastSelectedKey = manager.lastSelectedKey) !== null && _manager_lastSelectedKey !== void 0 ? _manager_lastSelectedKey : delegate.getLastKey());
+      else
+        navigateToFirstKey((_manager_firstSelectedKey = manager.firstSelectedKey) !== null && _manager_firstSelectedKey !== void 0 ? _manager_firstSelectedKey : delegate.getFirstKey());
+    } else if (!isVirtualized) {
+      scrollRef.current.scrollTop = scrollPos.current.top;
+      scrollRef.current.scrollLeft = scrollPos.current.left;
+    }
+    if (!isVirtualized && manager.focusedKey != null) {
+      let element = scrollRef.current.querySelector(`[data-key="${manager.focusedKey}"]`);
+      if (element) {
+        _import.$7215afc6de606d6b$export$de79e2c695e052f3(element);
+        let modality = _import$1.$507fabe10e71c6fb$export$630ff653c5ada6a9();
+        if (modality === "keyboard")
+          _import.$2f04cbc44ee30ce0$export$c826860796309d1b(element, {
+            containingElement: ref.current
+          });
+      }
+    }
+  };
+  let onBlur = (e) => {
+    if (!e.currentTarget.contains(e.relatedTarget))
+      manager.setFocused(false);
+  };
+  const autoFocusRef = React.useRef(autoFocus);
+  React.useEffect(() => {
+    if (autoFocusRef.current) {
+      let focusedKey = null;
+      if (autoFocus === "first")
+        focusedKey = delegate.getFirstKey();
+      if (autoFocus === "last")
+        focusedKey = delegate.getLastKey();
+      let selectedKeys = manager.selectedKeys;
+      if (selectedKeys.size)
+        focusedKey = selectedKeys.values().next().value;
+      manager.setFocused(true);
+      manager.setFocusedKey(focusedKey);
+      if (focusedKey == null && !shouldUseVirtualFocus)
+        _import$1.$6a99195332edec8b$export$80f3e147d781571c(ref.current);
+    }
+    autoFocusRef.current = false;
+  }, []);
+  let lastFocusedKey = React.useRef(manager.focusedKey);
+  React.useEffect(() => {
+    let modality = _import$1.$507fabe10e71c6fb$export$630ff653c5ada6a9();
+    if (manager.isFocused && manager.focusedKey != null && (scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current)) {
+      let element = scrollRef.current.querySelector(`[data-key="${manager.focusedKey}"]`);
+      if (element && modality === "keyboard") {
+        if (!isVirtualized)
+          _import.$2f04cbc44ee30ce0$export$53a0910f038337bd(scrollRef.current, element);
+        _import.$2f04cbc44ee30ce0$export$c826860796309d1b(element, {
+          containingElement: ref.current
+        });
+      }
+    }
+    if (manager.isFocused && manager.focusedKey == null && lastFocusedKey.current != null)
+      _import$1.$6a99195332edec8b$export$80f3e147d781571c(ref.current);
+    lastFocusedKey.current = manager.focusedKey;
+  }, [
+    isVirtualized,
+    scrollRef,
+    manager.focusedKey,
+    manager.isFocused,
+    ref
+  ]);
+  let handlers = {
+    onKeyDown,
+    onFocus,
+    onBlur,
+    onMouseDown(e) {
+      if (scrollRef.current === e.target)
+        e.preventDefault();
+    }
+  };
+  let { typeSelectProps } = $fb3050f43d946246$export$e32c88dfddc6e1d8({
+    keyboardDelegate: delegate,
+    selectionManager: manager
+  });
+  if (!disallowTypeAhead)
+    handlers = _import.$3ef42575df84b30b$export$9d1611c77c2fe928(typeSelectProps, handlers);
+  let tabIndex;
+  if (!shouldUseVirtualFocus)
+    tabIndex = manager.focusedKey == null ? 0 : -1;
+  return {
+    collectionProps: __spreadProps(__spreadValues({}, handlers), {
+      tabIndex
+    })
+  };
+}
+function $880e95eb8b93ba9a$export$ecf600387e221c37(options) {
+  let { selectionManager: manager, key, ref, shouldSelectOnPressUp, shouldUseVirtualFocus, focus, isDisabled, onAction, allowsDifferentPressOrigin } = options;
+  let onSelect = (e) => {
+    if (e.pointerType === "keyboard" && $feb5ffebff200149$export$d3e3bd3e26688c04(e))
+      manager.toggleSelection(key);
+    else {
+      if (manager.selectionMode === "none")
+        return;
+      if (manager.selectionMode === "single") {
+        if (manager.isSelected(key) && !manager.disallowEmptySelection)
+          manager.toggleSelection(key);
+        else
+          manager.replaceSelection(key);
+      } else if (e && e.shiftKey)
+        manager.extendSelection(key);
+      else if (manager.selectionBehavior === "toggle" || e && ($feb5ffebff200149$export$16792effe837dba3(e) || e.pointerType === "touch" || e.pointerType === "virtual"))
+        manager.toggleSelection(key);
+      else
+        manager.replaceSelection(key);
+    }
+  };
+  React.useEffect(() => {
+    let isFocused = key === manager.focusedKey;
+    if (isFocused && manager.isFocused && !shouldUseVirtualFocus) {
+      if (focus)
+        focus();
+      else if (document.activeElement !== ref.current)
+        _import$1.$6a99195332edec8b$export$80f3e147d781571c(ref.current);
+    }
+  }, [
+    ref,
+    key,
+    manager.focusedKey,
+    manager.childFocusStrategy,
+    manager.isFocused,
+    shouldUseVirtualFocus
+  ]);
+  isDisabled = isDisabled || manager.isDisabled(key);
+  let itemProps = {};
+  if (!shouldUseVirtualFocus && !isDisabled)
+    itemProps = {
+      tabIndex: key === manager.focusedKey ? 0 : -1,
+      onFocus(e) {
+        if (e.target === ref.current)
+          manager.setFocusedKey(key);
+      }
+    };
+  else if (isDisabled)
+    itemProps.onMouseDown = (e) => {
+      e.preventDefault();
+    };
+  let allowsSelection = !isDisabled && manager.canSelectItem(key);
+  let allowsActions = onAction && !isDisabled;
+  let hasPrimaryAction = allowsActions && (manager.selectionBehavior === "replace" ? !allowsSelection : manager.isEmpty);
+  let hasSecondaryAction = allowsActions && allowsSelection && manager.selectionBehavior === "replace";
+  let hasAction = hasPrimaryAction || hasSecondaryAction;
+  let modality = React.useRef(null);
+  let longPressEnabled = hasAction && allowsSelection;
+  let longPressEnabledOnPressStart = React.useRef(false);
+  let hadPrimaryActionOnPressStart = React.useRef(false);
+  let itemPressProps = {};
+  if (shouldSelectOnPressUp) {
+    itemPressProps.onPressStart = (e) => {
+      modality.current = e.pointerType;
+      longPressEnabledOnPressStart.current = longPressEnabled;
+      if (e.pointerType === "keyboard" && (!hasAction || $880e95eb8b93ba9a$var$isSelectionKey()))
+        onSelect(e);
+    };
+    if (!allowsDifferentPressOrigin)
+      itemPressProps.onPress = (e) => {
+        if (hasPrimaryAction || hasSecondaryAction && e.pointerType !== "mouse") {
+          if (e.pointerType === "keyboard" && !$880e95eb8b93ba9a$var$isActionKey())
+            return;
+          onAction();
+        } else if (e.pointerType !== "keyboard")
+          onSelect(e);
+      };
+    else {
+      itemPressProps.onPressUp = (e) => {
+        if (e.pointerType !== "keyboard")
+          onSelect(e);
+      };
+      itemPressProps.onPress = hasPrimaryAction ? () => onAction() : null;
+    }
+  } else {
+    itemPressProps.onPressStart = (e) => {
+      modality.current = e.pointerType;
+      longPressEnabledOnPressStart.current = longPressEnabled;
+      hadPrimaryActionOnPressStart.current = hasPrimaryAction;
+      if (e.pointerType === "mouse" && !hasPrimaryAction || e.pointerType === "keyboard" && (!onAction || $880e95eb8b93ba9a$var$isSelectionKey()))
+        onSelect(e);
+    };
+    itemPressProps.onPress = (e) => {
+      if (e.pointerType === "touch" || e.pointerType === "pen" || e.pointerType === "virtual" || e.pointerType === "keyboard" && hasAction && $880e95eb8b93ba9a$var$isActionKey() || e.pointerType === "mouse" && hadPrimaryActionOnPressStart.current) {
+        if (hasAction)
+          onAction();
+        else
+          onSelect(e);
+      }
+    };
+  }
+  itemProps["data-key"] = key;
+  itemPressProps.preventFocusOnPress = shouldUseVirtualFocus;
+  let { pressProps, isPressed } = _import$1.$f6c31cce2adf654f$export$45712eceda6fad21(itemPressProps);
+  let onDoubleClick = hasSecondaryAction ? (e) => {
+    if (modality.current === "mouse") {
+      e.stopPropagation();
+      e.preventDefault();
+      onAction();
+    }
+  } : void 0;
+  let { longPressProps } = _import$1.$8a26561d2877236e$export$c24ed0104d07eab9({
+    isDisabled: !longPressEnabled,
+    onLongPress(e) {
+      if (e.pointerType === "touch") {
+        onSelect(e);
+        manager.setSelectionBehavior("toggle");
+      }
+    }
+  });
+  let onDragStartCapture = (e) => {
+    if (modality.current === "touch" && longPressEnabledOnPressStart.current)
+      e.preventDefault();
+  };
+  return {
+    itemProps: _import.$3ef42575df84b30b$export$9d1611c77c2fe928(itemProps, allowsSelection || hasPrimaryAction ? pressProps : {}, longPressEnabled ? longPressProps : {}, {
+      onDoubleClick,
+      onDragStartCapture
+    }),
+    isPressed,
+    isSelected: manager.isSelected(key),
+    isFocused: manager.isFocused && manager.focusedKey === key,
+    isDisabled,
+    allowsSelection,
+    hasAction
+  };
+}
+function $880e95eb8b93ba9a$var$isActionKey() {
+  let event = window.event;
+  return (event === null || event === void 0 ? void 0 : event.key) === "Enter";
+}
+function $880e95eb8b93ba9a$var$isSelectionKey() {
+  let event = window.event;
+  return (event === null || event === void 0 ? void 0 : event.key) === " " || (event === null || event === void 0 ? void 0 : event.code) === "Space";
+}
+class $2a25aae57d74318e$export$a05409b8bb224a5a {
+  getNextKey(key) {
+    key = this.collection.getKeyAfter(key);
+    while (key != null) {
+      let item = this.collection.getItem(key);
+      if (item.type === "item" && !this.disabledKeys.has(key))
+        return key;
+      key = this.collection.getKeyAfter(key);
+    }
+    return null;
+  }
+  getPreviousKey(key) {
+    key = this.collection.getKeyBefore(key);
+    while (key != null) {
+      let item = this.collection.getItem(key);
+      if (item.type === "item" && !this.disabledKeys.has(key))
+        return key;
+      key = this.collection.getKeyBefore(key);
+    }
+    return null;
+  }
+  findKey(key, nextKey, shouldSkip) {
+    let item = this.getItem(key);
+    if (!item)
+      return null;
+    let prevRect = item.getBoundingClientRect();
+    do {
+      key = nextKey(key);
+      item = this.getItem(key);
+    } while (item && shouldSkip(prevRect, item.getBoundingClientRect()));
+    return key;
+  }
+  isSameRow(prevRect, itemRect) {
+    return prevRect.top === itemRect.top || prevRect.left !== itemRect.left;
+  }
+  isSameColumn(prevRect, itemRect) {
+    return prevRect.left === itemRect.left || prevRect.top !== itemRect.top;
+  }
+  getKeyBelow(key) {
+    if (this.layout === "grid" && this.orientation === "vertical")
+      return this.findKey(key, (key2) => this.getNextKey(key2), this.isSameRow);
+    else
+      return this.getNextKey(key);
+  }
+  getKeyAbove(key) {
+    if (this.layout === "grid" && this.orientation === "vertical")
+      return this.findKey(key, (key2) => this.getPreviousKey(key2), this.isSameRow);
+    else
+      return this.getPreviousKey(key);
+  }
+  getNextColumn(key, right) {
+    return right ? this.getPreviousKey(key) : this.getNextKey(key);
+  }
+  getKeyRightOf(key) {
+    if (this.layout === "grid") {
+      if (this.orientation === "vertical")
+        return this.getNextColumn(key, this.direction === "rtl");
+      else
+        return this.findKey(key, (key2) => this.getNextColumn(key2, this.direction === "rtl"), this.isSameColumn);
+    } else if (this.orientation === "horizontal")
+      return this.getNextColumn(key, this.direction === "rtl");
+    return null;
+  }
+  getKeyLeftOf(key) {
+    if (this.layout === "grid") {
+      if (this.orientation === "vertical")
+        return this.getNextColumn(key, this.direction === "ltr");
+      else
+        return this.findKey(key, (key2) => this.getNextColumn(key2, this.direction === "ltr"), this.isSameColumn);
+    } else if (this.orientation === "horizontal")
+      return this.getNextColumn(key, this.direction === "ltr");
+    return null;
+  }
+  getFirstKey() {
+    let key = this.collection.getFirstKey();
+    while (key != null) {
+      let item = this.collection.getItem(key);
+      if (item.type === "item" && !this.disabledKeys.has(key))
+        return key;
+      key = this.collection.getKeyAfter(key);
+    }
+    return null;
+  }
+  getLastKey() {
+    let key = this.collection.getLastKey();
+    while (key != null) {
+      let item = this.collection.getItem(key);
+      if (item.type === "item" && !this.disabledKeys.has(key))
+        return key;
+      key = this.collection.getKeyBefore(key);
+    }
+    return null;
+  }
+  getItem(key) {
+    return this.ref.current.querySelector(`[data-key="${key}"]`);
+  }
+  getKeyPageAbove(key) {
+    let menu = this.ref.current;
+    let item = this.getItem(key);
+    if (!item)
+      return null;
+    if (!_import.$62d8ded9296f3872$export$2bb74740c4e19def(menu))
+      return this.getFirstKey();
+    let containerRect = menu.getBoundingClientRect();
+    let itemRect = item.getBoundingClientRect();
+    if (this.orientation === "horizontal") {
+      let containerX = containerRect.x - menu.scrollLeft;
+      let pageX = Math.max(0, itemRect.x - containerX + itemRect.width - containerRect.width);
+      while (item && itemRect.x - containerX > pageX) {
+        key = this.getKeyAbove(key);
+        item = key == null ? null : this.getItem(key);
+        itemRect = item === null || item === void 0 ? void 0 : item.getBoundingClientRect();
+      }
+    } else {
+      let containerY = containerRect.y - menu.scrollTop;
+      let pageY = Math.max(0, itemRect.y - containerY + itemRect.height - containerRect.height);
+      while (item && itemRect.y - containerY > pageY) {
+        key = this.getKeyAbove(key);
+        item = key == null ? null : this.getItem(key);
+        itemRect = item === null || item === void 0 ? void 0 : item.getBoundingClientRect();
+      }
+    }
+    return key !== null && key !== void 0 ? key : this.getFirstKey();
+  }
+  getKeyPageBelow(key) {
+    let menu = this.ref.current;
+    let item = this.getItem(key);
+    if (!item)
+      return null;
+    if (!_import.$62d8ded9296f3872$export$2bb74740c4e19def(menu))
+      return this.getLastKey();
+    let containerRect = menu.getBoundingClientRect();
+    let itemRect = item.getBoundingClientRect();
+    if (this.orientation === "horizontal") {
+      let containerX = containerRect.x - menu.scrollLeft;
+      let pageX = Math.min(menu.scrollWidth, itemRect.x - containerX - itemRect.width + containerRect.width);
+      while (item && itemRect.x - containerX < pageX) {
+        key = this.getKeyBelow(key);
+        item = key == null ? null : this.getItem(key);
+        itemRect = item === null || item === void 0 ? void 0 : item.getBoundingClientRect();
+      }
+    } else {
+      let containerY = containerRect.y - menu.scrollTop;
+      let pageY = Math.min(menu.scrollHeight, itemRect.y - containerY - itemRect.height + containerRect.height);
+      while (item && itemRect.y - containerY < pageY) {
+        key = this.getKeyBelow(key);
+        item = key == null ? null : this.getItem(key);
+        itemRect = item === null || item === void 0 ? void 0 : item.getBoundingClientRect();
+      }
+    }
+    return key !== null && key !== void 0 ? key : this.getLastKey();
+  }
+  getKeyForSearch(search, fromKey) {
+    if (!this.collator)
+      return null;
+    let collection = this.collection;
+    let key = fromKey || this.getFirstKey();
+    while (key != null) {
+      let item = collection.getItem(key);
+      let substring = item.textValue.slice(0, search.length);
+      if (item.textValue && this.collator.compare(substring, search) === 0)
+        return key;
+      key = this.getKeyBelow(key);
+    }
+    return null;
+  }
+  constructor(...args) {
+    if (args.length === 1) {
+      let opts = args[0];
+      this.collection = opts.collection;
+      this.ref = opts.ref;
+      this.disabledKeys = opts.disabledKeys || /* @__PURE__ */ new Set();
+      this.orientation = opts.orientation;
+      this.direction = opts.direction;
+      this.layout = opts.layout || "stack";
+    } else {
+      this.collection = args[0];
+      this.disabledKeys = args[1];
+      this.ref = args[2];
+      this.collator = args[3];
+      this.layout = "stack";
+      this.orientation = "vertical";
+    }
+    if (this.layout === "stack" && this.orientation === "vertical") {
+      this.getKeyLeftOf = void 0;
+      this.getKeyRightOf = void 0;
+    }
+  }
+}
+function $982254629710d113$export$b95089534ab7c1fd(props) {
+  let { selectionManager, collection, disabledKeys, ref, keyboardDelegate, autoFocus, shouldFocusWrap, isVirtualized, disallowEmptySelection, selectOnFocus = selectionManager.selectionBehavior === "replace", disallowTypeAhead, shouldUseVirtualFocus, allowsTabNavigation } = props;
+  let collator = realModule.$325a3faab7a68acd$export$a16aca283550c30d({
+    usage: "search",
+    sensitivity: "base"
+  });
+  let disabledBehavior = selectionManager.disabledBehavior;
+  let delegate = React.useMemo(() => keyboardDelegate || new $2a25aae57d74318e$export$a05409b8bb224a5a(collection, disabledBehavior === "selection" ? /* @__PURE__ */ new Set() : disabledKeys, ref, collator), [
+    keyboardDelegate,
+    collection,
+    disabledKeys,
+    ref,
+    collator,
+    disabledBehavior
+  ]);
+  let { collectionProps } = $ae20dd8cbca75726$export$d6daf82dcd84e87c({
+    ref,
+    selectionManager,
+    keyboardDelegate: delegate,
+    autoFocus,
+    shouldFocusWrap,
+    disallowEmptySelection,
+    selectOnFocus,
+    disallowTypeAhead,
+    shouldUseVirtualFocus,
+    allowsTabNavigation,
+    isVirtualized,
+    scrollRef: ref
+  });
+  return {
+    listProps: collectionProps
+  };
+}
+function $c1d7fb2ec91bae71$var$Item(props) {
+  return null;
+}
+$c1d7fb2ec91bae71$var$Item.getCollectionNode = function* getCollectionNode(props, context) {
+  let { childItems, title, children } = props;
+  let rendered = props.title || props.children;
+  let textValue = props.textValue || (typeof rendered === "string" ? rendered : "") || props["aria-label"] || "";
+  if (!textValue && !(context === null || context === void 0 ? void 0 : context.suppressTextValueWarning))
+    console.warn("<Item> with non-plain text contents is unsupported by type to select for accessibility. Please add a `textValue` prop.");
+  yield {
+    type: "item",
+    props,
+    rendered,
+    textValue,
+    "aria-label": props["aria-label"],
+    hasChildNodes: $c1d7fb2ec91bae71$var$hasChildItems(props),
+    *childNodes() {
+      if (childItems)
+        for (let child of childItems)
+          yield {
+            type: "item",
+            value: child
+          };
+      else if (title) {
+        let items = [];
+        React.Children.forEach(children, (child) => {
+          items.push({
+            type: "item",
+            element: child
+          });
+        });
+        yield* __yieldStar(items);
+      }
+    }
+  };
+};
+function $c1d7fb2ec91bae71$var$hasChildItems(props) {
+  if (props.hasChildItems != null)
+    return props.hasChildItems;
+  if (props.childItems)
+    return true;
+  if (props.title && React.Children.count(props.children) > 0)
+    return true;
+  return false;
+}
+let $c1d7fb2ec91bae71$export$6d08773d2e66f8f2 = $c1d7fb2ec91bae71$var$Item;
+function $9fc4852771d079eb$var$Section(props) {
+  return null;
+}
+$9fc4852771d079eb$var$Section.getCollectionNode = function* getCollectionNode2(props) {
+  let { children, title, items } = props;
+  yield {
+    type: "section",
+    props,
+    hasChildNodes: true,
+    rendered: title,
+    "aria-label": props["aria-label"],
+    *childNodes() {
+      if (typeof children === "function") {
+        if (!items)
+          throw new Error("props.children was a function but props.items is missing");
+        for (let item of items)
+          yield {
+            type: "item",
+            value: item,
+            renderer: children
+          };
+      } else {
+        let items2 = [];
+        React.Children.forEach(children, (child) => {
+          items2.push({
+            type: "item",
+            element: child
+          });
+        });
+        yield* __yieldStar(items2);
+      }
+    }
+  };
+};
+let $9fc4852771d079eb$export$6e2c8f0811a474ce = $9fc4852771d079eb$var$Section;
+class $eb2240fc39a57fa5$export$bf788dd355e3a401 {
+  build(props, context) {
+    this.context = context;
+    return $eb2240fc39a57fa5$var$iterable(() => this.iterateCollection(props));
+  }
+  *iterateCollection(props) {
+    let { children, items } = props;
+    if (typeof children === "function") {
+      if (!items)
+        throw new Error("props.children was a function but props.items is missing");
+      for (let item of props.items)
+        yield* __yieldStar(this.getFullNode({
+          value: item
+        }, {
+          renderer: children
+        }));
+    } else {
+      let items2 = [];
+      React.Children.forEach(children, (child) => {
+        items2.push(child);
+      });
+      let index = 0;
+      for (let item of items2) {
+        let nodes = this.getFullNode({
+          element: item,
+          index
+        }, {});
+        for (let node of nodes) {
+          index++;
+          yield node;
+        }
+      }
+    }
+  }
+  getKey(item, partialNode, state, parentKey) {
+    if (item.key != null)
+      return item.key;
+    if (partialNode.type === "cell" && partialNode.key != null)
+      return `${parentKey}${partialNode.key}`;
+    let v = partialNode.value;
+    if (v != null) {
+      var _v_key;
+      let key = (_v_key = v.key) !== null && _v_key !== void 0 ? _v_key : v.id;
+      if (key == null)
+        throw new Error("No key found for item");
+      return key;
+    }
+    return parentKey ? `${parentKey}.${partialNode.index}` : `$.${partialNode.index}`;
+  }
+  getChildState(state, partialNode) {
+    return {
+      renderer: partialNode.renderer || state.renderer
+    };
+  }
+  *getFullNode(partialNode, state, parentKey, parentNode) {
+    let element = partialNode.element;
+    if (!element && partialNode.value && state && state.renderer) {
+      let cached = this.cache.get(partialNode.value);
+      if (cached && (!cached.shouldInvalidate || !cached.shouldInvalidate(this.context))) {
+        cached.index = partialNode.index;
+        cached.parentKey = parentNode ? parentNode.key : null;
+        yield cached;
+        return;
+      }
+      element = state.renderer(partialNode.value);
+    }
+    if (React.isValidElement(element)) {
+      let type = element.type;
+      if (typeof type !== "function" && typeof type.getCollectionNode !== "function") {
+        let name = typeof element.type === "function" ? element.type.name : element.type;
+        throw new Error(`Unknown element <${name}> in collection.`);
+      }
+      let childNodes = type.getCollectionNode(element.props, this.context);
+      let index = partialNode.index;
+      let result = childNodes.next();
+      while (!result.done && result.value) {
+        let childNode = result.value;
+        partialNode.index = index;
+        let nodeKey = childNode.key;
+        if (!nodeKey)
+          nodeKey = childNode.element ? null : this.getKey(element, partialNode, state, parentKey);
+        let nodes = this.getFullNode(__spreadProps(__spreadValues({}, childNode), {
+          key: nodeKey,
+          index,
+          wrapper: $eb2240fc39a57fa5$var$compose(partialNode.wrapper, childNode.wrapper)
+        }), this.getChildState(state, childNode), parentKey ? `${parentKey}${element.key}` : element.key, parentNode);
+        let children = [
+          ...nodes
+        ];
+        for (let node2 of children) {
+          node2.value = childNode.value || partialNode.value;
+          if (node2.value)
+            this.cache.set(node2.value, node2);
+          if (partialNode.type && node2.type !== partialNode.type)
+            throw new Error(`Unsupported type <${$eb2240fc39a57fa5$var$capitalize(node2.type)}> in <${$eb2240fc39a57fa5$var$capitalize(parentNode.type)}>. Only <${$eb2240fc39a57fa5$var$capitalize(partialNode.type)}> is supported.`);
+          index++;
+          yield node2;
+        }
+        result = childNodes.next(children);
+      }
+      return;
+    }
+    if (partialNode.key == null)
+      return;
+    let builder = this;
+    let node = {
+      type: partialNode.type,
+      props: partialNode.props,
+      key: partialNode.key,
+      parentKey: parentNode ? parentNode.key : null,
+      value: partialNode.value,
+      level: parentNode ? parentNode.level + 1 : 0,
+      index: partialNode.index,
+      rendered: partialNode.rendered,
+      textValue: partialNode.textValue,
+      "aria-label": partialNode["aria-label"],
+      wrapper: partialNode.wrapper,
+      shouldInvalidate: partialNode.shouldInvalidate,
+      hasChildNodes: partialNode.hasChildNodes,
+      childNodes: $eb2240fc39a57fa5$var$iterable(function* () {
+        if (!partialNode.hasChildNodes)
+          return;
+        let index = 0;
+        for (let child of partialNode.childNodes()) {
+          if (child.key != null)
+            child.key = `${node.key}${child.key}`;
+          child.index = index;
+          let nodes = builder.getFullNode(child, builder.getChildState(state, child), node.key, node);
+          for (let node2 of nodes) {
+            index++;
+            yield node2;
+          }
+        }
+      })
+    };
+    yield node;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+}
+function $eb2240fc39a57fa5$var$iterable(iterator) {
+  let cache = [];
+  let iterable = null;
+  return {
+    *[Symbol.iterator]() {
+      for (let item of cache)
+        yield item;
+      if (!iterable)
+        iterable = iterator();
+      for (let item of iterable) {
+        cache.push(item);
+        yield item;
+      }
+    }
+  };
+}
+function $eb2240fc39a57fa5$var$compose(outer, inner) {
+  if (outer && inner)
+    return (element) => outer(inner(element));
+  if (outer)
+    return outer;
+  if (inner)
+    return inner;
+}
+function $eb2240fc39a57fa5$var$capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1);
+}
+function $7613b1592d41b092$export$6cd28814d92fa9c9(props, factory, context) {
+  let builder = React.useMemo(() => new $eb2240fc39a57fa5$export$bf788dd355e3a401(), []);
+  let { children, items, collection } = props;
+  let result = React.useMemo(() => {
+    if (collection)
+      return collection;
+    let nodes = builder.build({
+      children,
+      items
+    }, context);
+    return factory(nodes);
+  }, [
+    builder,
+    children,
+    items,
+    collection,
+    context,
+    factory
+  ]);
+  return result;
+}
+function $c5a24bc478652b5f$export$1005530eda016c13(node, collection) {
+  if (typeof collection.getChildren === "function")
+    return collection.getChildren(node.key);
+  return node.childNodes;
+}
+function $c5a24bc478652b5f$export$fbdeaa6a76694f71(iterable) {
+  return $c5a24bc478652b5f$export$5f3398f8733f90e2(iterable, 0);
+}
+function $c5a24bc478652b5f$export$5f3398f8733f90e2(iterable, index) {
+  if (index < 0)
+    return void 0;
+  let i = 0;
+  for (let item of iterable) {
+    if (i === index)
+      return item;
+    i++;
+  }
+}
+function $c5a24bc478652b5f$export$8c434b3a7a4dad6(collection, a, b) {
+  if (a.parentKey === b.parentKey)
+    return a.index - b.index;
+  let aAncestors = $c5a24bc478652b5f$var$getAncestors(collection, a);
+  let bAncestors = $c5a24bc478652b5f$var$getAncestors(collection, b);
+  let firstNonMatchingAncestor = aAncestors.slice(0, bAncestors.length).findIndex((a2, i) => a2 !== bAncestors[i]);
+  if (firstNonMatchingAncestor !== -1) {
+    a = aAncestors[firstNonMatchingAncestor];
+    b = bAncestors[firstNonMatchingAncestor];
+    return a.index - b.index;
+  }
+  return -1;
+}
+function $c5a24bc478652b5f$var$getAncestors(collection, node) {
+  let parents = [];
+  while ((node === null || node === void 0 ? void 0 : node.parentKey) != null) {
+    node = collection.getItem(node.parentKey);
+    parents.unshift(node);
+  }
+  return parents;
+}
+const $453cc9f0df89c0a5$var$cache = /* @__PURE__ */ new WeakMap();
+function $453cc9f0df89c0a5$export$77d5aafae4e095b2(collection) {
+  let count = $453cc9f0df89c0a5$var$cache.get(collection);
+  if (count != null)
+    return count;
+  count = 0;
+  let countItems = (items) => {
+    for (let item of items)
+      if (item.type === "section")
+        countItems($c5a24bc478652b5f$export$1005530eda016c13(item, collection));
+      else
+        count++;
+  };
+  countItems(collection);
+  $453cc9f0df89c0a5$var$cache.set(collection, count);
+  return count;
+}
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+var $2cbb7ca666678a14$exports = {};
+var $c0398ad35c3639b7$exports = {};
+$c0398ad35c3639b7$exports = {
+  "longPressMessage": `اضغط مطولاً أو اضغط على Alt + السهم لأسفل لفتح القائمة`
+};
+var $7af657c4165927c3$exports = {};
+$7af657c4165927c3$exports = {
+  "longPressMessage": `Натиснете продължително или натиснете Alt+ стрелка надолу, за да отворите менюто`
+};
+var $d95d4da6d531ab81$exports = {};
+$d95d4da6d531ab81$exports = {
+  "longPressMessage": `Dlouhým stiskem nebo stisknutím kláves Alt + šipka dolů otevřete nabídku`
+};
+var $24ebda9c775dca17$exports = {};
+$24ebda9c775dca17$exports = {
+  "longPressMessage": `Langt tryk eller tryk på Alt + pil ned for at åbne menuen`
+};
+var $743e0dfca6cab1e9$exports = {};
+$743e0dfca6cab1e9$exports = {
+  "longPressMessage": `Drücken Sie lange oder drücken Sie Alt + Nach-unten, um das Menü zu öffnen`
+};
+var $a2f41026e05f1c84$exports = {};
+$a2f41026e05f1c84$exports = {
+  "longPressMessage": `Πιέστε παρατεταμένα ή πατήστε Alt + κάτω βέλος για να ανοίξετε το μενού`
+};
+var $43b800e97c901737$exports = {};
+$43b800e97c901737$exports = {
+  "longPressMessage": `Long press or press Alt + ArrowDown to open menu`
+};
+var $442f5f6ac211e29f$exports = {};
+$442f5f6ac211e29f$exports = {
+  "longPressMessage": `Mantenga pulsado o pulse Alt + flecha abajo para abrir el menú`
+};
+var $dff280acfeb2d8ac$exports = {};
+$dff280acfeb2d8ac$exports = {
+  "longPressMessage": `Menüü avamiseks vajutage pikalt või vajutage klahve Alt + allanool`
+};
+var $51608325613944d7$exports = {};
+$51608325613944d7$exports = {
+  "longPressMessage": `Avaa valikko painamalla pohjassa tai näppäinyhdistelmällä Alt + Alanuoli`
+};
+var $c4a1b1eabeaa87be$exports = {};
+$c4a1b1eabeaa87be$exports = {
+  "longPressMessage": `Appuyez de manière prolongée ou appuyez sur Alt + Flèche vers le bas pour ouvrir le menu.`
+};
+var $8c74815cdee18d1b$exports = {};
+$8c74815cdee18d1b$exports = {
+  "longPressMessage": `לחץ לחיצה ארוכה או הקש Alt + ArrowDown כדי לפתוח את התפריט`
+};
+var $fd0e9ef6a7fe0ec9$exports = {};
+$fd0e9ef6a7fe0ec9$exports = {
+  "longPressMessage": `Dugo pritisnite ili pritisnite Alt + strelicu prema dolje za otvaranje izbornika`
+};
+var $a89a74a39eba465a$exports = {};
+$a89a74a39eba465a$exports = {
+  "longPressMessage": `Nyomja meg hosszan, vagy nyomja meg az Alt + lefele nyíl gombot a menü megnyitásához`
+};
+var $edc7c66594a0ae8a$exports = {};
+$edc7c66594a0ae8a$exports = {
+  "longPressMessage": `Premere a lungo o premere Alt + Freccia giù per aprire il menu`
+};
+var $f1ab51510712db52$exports = {};
+$f1ab51510712db52$exports = {
+  "longPressMessage": `長押しまたは Alt+下矢印キーでメニューを開く`
+};
+var $f9b672d9b82fa3d6$exports = {};
+$f9b672d9b82fa3d6$exports = {
+  "longPressMessage": `길게 누르거나 Alt + 아래쪽 화살표를 눌러 메뉴 열기`
+};
+var $a385f3910feda499$exports = {};
+$a385f3910feda499$exports = {
+  "longPressMessage": `Norėdami atidaryti meniu, nuspaudę palaikykite arba paspauskite „Alt + ArrowDown“.`
+};
+var $4f1bde932c441789$exports = {};
+$4f1bde932c441789$exports = {
+  "longPressMessage": `Lai atvērtu izvēlni, turiet nospiestu vai nospiediet taustiņu kombināciju Alt + lejupvērstā bultiņa`
+};
+var $914a51a8a594d5be$exports = {};
+$914a51a8a594d5be$exports = {
+  "longPressMessage": `Langt trykk eller trykk Alt + PilNed for å åpne menyen`
+};
+var $89aaf803103bb500$exports = {};
+$89aaf803103bb500$exports = {
+  "longPressMessage": `Druk lang op Alt + pijl-omlaag of druk op Alt om het menu te openen`
+};
+var $c685891476dbaaca$exports = {};
+$c685891476dbaaca$exports = {
+  "longPressMessage": `Naciśnij i przytrzymaj lub naciśnij klawisze Alt + Strzałka w dół, aby otworzyć menu`
+};
+var $885879b9b10c2959$exports = {};
+$885879b9b10c2959$exports = {
+  "longPressMessage": `Pressione e segure ou pressione Alt + Seta para baixo para abrir o menu`
+};
+var $6b39616688a51692$exports = {};
+$6b39616688a51692$exports = {
+  "longPressMessage": `Prima continuamente ou prima Alt + Seta Para Baixo para abrir o menu`
+};
+var $f26362aed63f47e2$exports = {};
+$f26362aed63f47e2$exports = {
+  "longPressMessage": `Apăsați lung sau apăsați pe Alt + săgeată în jos pentru a deschide meniul`
+};
+var $06cbade644558bf0$exports = {};
+$06cbade644558bf0$exports = {
+  "longPressMessage": `Нажмите и удерживайте или нажмите Alt + Стрелка вниз, чтобы открыть меню`
+};
+var $0a391ff68f9d59b1$exports = {};
+$0a391ff68f9d59b1$exports = {
+  "longPressMessage": `Ponuku otvoríte dlhým stlačením alebo stlačením klávesu Alt + klávesu so šípkou nadol`
+};
+var $8193cf0e649c7928$exports = {};
+$8193cf0e649c7928$exports = {
+  "longPressMessage": `Za odprtje menija pritisnite in držite gumb ali pritisnite Alt+puščica navzdol`
+};
+var $f398debcce5a5c55$exports = {};
+$f398debcce5a5c55$exports = {
+  "longPressMessage": `Dugo pritisnite ili pritisnite Alt + strelicu prema dole da otvorite meni`
+};
+var $9e9fef000aa4c013$exports = {};
+$9e9fef000aa4c013$exports = {
+  "longPressMessage": `Håll nedtryckt eller tryck på Alt + pil nedåt för att öppna menyn`
+};
+var $c016c8183bbe3d68$exports = {};
+$c016c8183bbe3d68$exports = {
+  "longPressMessage": `Menüyü açmak için uzun basın veya Alt + Aşağı Ok tuşuna basın`
+};
+var $ca4f6c8462244e62$exports = {};
+$ca4f6c8462244e62$exports = {
+  "longPressMessage": `Довго або звичайно натисніть комбінацію клавіш Alt і стрілка вниз, щоб відкрити меню`
+};
+var $2d9960c02ccac927$exports = {};
+$2d9960c02ccac927$exports = {
+  "longPressMessage": `长按或按 Alt + 向下方向键以打开菜单`
+};
+var $f1b682a4c8c5631c$exports = {};
+$f1b682a4c8c5631c$exports = {
+  "longPressMessage": `長按或按 Alt+向下鍵以開啟功能表`
+};
+$2cbb7ca666678a14$exports = {
+  "ar-AE": $c0398ad35c3639b7$exports,
+  "bg-BG": $7af657c4165927c3$exports,
+  "cs-CZ": $d95d4da6d531ab81$exports,
+  "da-DK": $24ebda9c775dca17$exports,
+  "de-DE": $743e0dfca6cab1e9$exports,
+  "el-GR": $a2f41026e05f1c84$exports,
+  "en-US": $43b800e97c901737$exports,
+  "es-ES": $442f5f6ac211e29f$exports,
+  "et-EE": $dff280acfeb2d8ac$exports,
+  "fi-FI": $51608325613944d7$exports,
+  "fr-FR": $c4a1b1eabeaa87be$exports,
+  "he-IL": $8c74815cdee18d1b$exports,
+  "hr-HR": $fd0e9ef6a7fe0ec9$exports,
+  "hu-HU": $a89a74a39eba465a$exports,
+  "it-IT": $edc7c66594a0ae8a$exports,
+  "ja-JP": $f1ab51510712db52$exports,
+  "ko-KR": $f9b672d9b82fa3d6$exports,
+  "lt-LT": $a385f3910feda499$exports,
+  "lv-LV": $4f1bde932c441789$exports,
+  "nb-NO": $914a51a8a594d5be$exports,
+  "nl-NL": $89aaf803103bb500$exports,
+  "pl-PL": $c685891476dbaaca$exports,
+  "pt-BR": $885879b9b10c2959$exports,
+  "pt-PT": $6b39616688a51692$exports,
+  "ro-RO": $f26362aed63f47e2$exports,
+  "ru-RU": $06cbade644558bf0$exports,
+  "sk-SK": $0a391ff68f9d59b1$exports,
+  "sl-SI": $8193cf0e649c7928$exports,
+  "sr-SP": $f398debcce5a5c55$exports,
+  "sv-SE": $9e9fef000aa4c013$exports,
+  "tr-TR": $c016c8183bbe3d68$exports,
+  "uk-UA": $ca4f6c8462244e62$exports,
+  "zh-CN": $2d9960c02ccac927$exports,
+  "zh-TW": $f1b682a4c8c5631c$exports
+};
+function $168583247155ddda$export$dc9c12ed27dd1b49(props, state, ref) {
+  let { type = "menu", isDisabled, trigger = "press" } = props;
+  let menuTriggerId = _import.$bdb11010cef70236$export$f680877a34711e37();
+  let { triggerProps, overlayProps } = _import$2.$628037886ba31236$export$f9d5c8beee7d008d({
+    type
+  }, state, ref);
+  let onKeyDown = (e) => {
+    if (isDisabled)
+      return;
+    if (trigger === "longPress" && !e.altKey)
+      return;
+    if (ref && ref.current)
+      switch (e.key) {
+        case "Enter":
+        case " ":
+          if (trigger === "longPress")
+            return;
+        case "ArrowDown":
+          if (!("continuePropagation" in e))
+            e.stopPropagation();
+          e.preventDefault();
+          state.toggle("first");
+          break;
+        case "ArrowUp":
+          if (!("continuePropagation" in e))
+            e.stopPropagation();
+          e.preventDefault();
+          state.toggle("last");
+          break;
+      }
+  };
+  let stringFormatter = realModule.$fca6afa0e843324b$export$f12b703ca79dfbb1(/* @__PURE__ */ $parcel$interopDefault($2cbb7ca666678a14$exports));
+  let { longPressProps } = _import$1.$8a26561d2877236e$export$c24ed0104d07eab9({
+    isDisabled: isDisabled || trigger !== "longPress",
+    accessibilityDescription: stringFormatter.format("longPressMessage"),
+    onLongPressStart() {
+      state.close();
+    },
+    onLongPress() {
+      state.open("first");
+    }
+  });
+  let pressProps = {
+    onPressStart(e) {
+      if (e.pointerType !== "touch" && e.pointerType !== "keyboard" && !isDisabled)
+        state.toggle(e.pointerType === "virtual" ? "first" : null);
+    },
+    onPress(e) {
+      if (e.pointerType === "touch" && !isDisabled)
+        state.toggle();
+    }
+  };
+  delete triggerProps.onPress;
+  return {
+    menuTriggerProps: __spreadProps(__spreadValues(__spreadValues({}, triggerProps), trigger === "press" ? pressProps : longPressProps), {
+      id: menuTriggerId,
+      onKeyDown
+    }),
+    menuProps: __spreadProps(__spreadValues({}, overlayProps), {
+      "aria-labelledby": menuTriggerId,
+      autoFocus: state.focusStrategy || true,
+      onClose: state.close
+    })
+  };
+}
+const $d5336fe17ce95402$export$6f49b4016bfc8d56 = /* @__PURE__ */ new WeakMap();
+function $d5336fe17ce95402$export$38eaa17faae8f579(props, state, ref) {
+  let _a = props, { shouldFocusWrap = true } = _a, otherProps = __objRest(_a, ["shouldFocusWrap"]);
+  if (!props["aria-label"] && !props["aria-labelledby"])
+    console.warn("An aria-label or aria-labelledby prop is required for accessibility.");
+  let domProps = _import.$65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, {
+    labelable: true
+  });
+  let { listProps } = $982254629710d113$export$b95089534ab7c1fd(__spreadProps(__spreadValues({}, otherProps), {
+    ref,
+    selectionManager: state.selectionManager,
+    collection: state.collection,
+    disabledKeys: state.disabledKeys,
+    shouldFocusWrap
+  }));
+  $d5336fe17ce95402$export$6f49b4016bfc8d56.set(state, {
+    onClose: props.onClose,
+    onAction: props.onAction
+  });
+  return {
+    menuProps: _import.$3ef42575df84b30b$export$9d1611c77c2fe928(domProps, __spreadProps(__spreadValues({
+      role: "menu",
+      // this forces AT to move their cursors into any open sub dialogs, the sub dialogs contain hidden close buttons in order to come back to this level of the menu
+      "aria-hidden": state.expandedKeys.size > 0 ? true : void 0
+    }, listProps), {
+      onKeyDown: (e) => {
+        if (e.key !== "Escape")
+          listProps.onKeyDown(e);
+      }
+    }))
+  };
+}
+function $a2e5df62f93c7633$export$9d32628fc2aea7da(props, state, ref) {
+  let { key, closeOnSelect, isVirtualized, "aria-haspopup": hasPopup } = props;
+  let { direction } = realModule.$18f2051aff69b9bf$export$43bb16f9c6d9e3f7();
+  let isTrigger = !!hasPopup;
+  let isOpen = state.expandedKeys.has(key);
+  var _props_isDisabled;
+  let isDisabled = (_props_isDisabled = props.isDisabled) !== null && _props_isDisabled !== void 0 ? _props_isDisabled : state.disabledKeys.has(key);
+  var _props_isSelected;
+  let isSelected = (_props_isSelected = props.isSelected) !== null && _props_isSelected !== void 0 ? _props_isSelected : state.selectionManager.isSelected(key);
+  let openTimeout = React.useRef();
+  let cancelOpenTimeout = React.useCallback(() => {
+    if (openTimeout.current) {
+      clearTimeout(openTimeout.current);
+      openTimeout.current = void 0;
+    }
+  }, [
+    openTimeout
+  ]);
+  let onSubmenuOpen = _import.$8ae05eaa5c114e9c$export$7f54fc3180508a52(() => {
+    cancelOpenTimeout();
+    state.setExpandedKeys(/* @__PURE__ */ new Set([
+      key
+    ]));
+  });
+  _import.$f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(() => {
+    return () => cancelOpenTimeout();
+  }, [
+    cancelOpenTimeout
+  ]);
+  let data = $d5336fe17ce95402$export$6f49b4016bfc8d56.get(state);
+  let onClose = props.onClose || data.onClose;
+  let onActionMenuDialogTrigger = React.useCallback(() => {
+    onSubmenuOpen();
+  }, []);
+  let onAction = isTrigger ? onActionMenuDialogTrigger : props.onAction || data.onAction;
+  let role = "menuitem";
+  if (state.selectionManager.selectionMode === "single")
+    role = "menuitemradio";
+  else if (state.selectionManager.selectionMode === "multiple")
+    role = "menuitemcheckbox";
+  let labelId = _import.$bdb11010cef70236$export$b4cc09c592e8fdb8();
+  let descriptionId = _import.$bdb11010cef70236$export$b4cc09c592e8fdb8();
+  let keyboardId = _import.$bdb11010cef70236$export$b4cc09c592e8fdb8();
+  let ariaProps = {
+    "aria-disabled": isDisabled || void 0,
+    role,
+    "aria-label": props["aria-label"],
+    "aria-labelledby": labelId,
+    "aria-describedby": [
+      descriptionId,
+      keyboardId
+    ].filter(Boolean).join(" ") || void 0
+  };
+  if (state.selectionManager.selectionMode !== "none")
+    ariaProps["aria-checked"] = isSelected;
+  if (isVirtualized) {
+    ariaProps["aria-posinset"] = state.collection.getItem(key).index;
+    ariaProps["aria-setsize"] = $453cc9f0df89c0a5$export$77d5aafae4e095b2(state.collection);
+  }
+  if (hasPopup != null) {
+    ariaProps["aria-haspopup"] = hasPopup;
+    ariaProps["aria-expanded"] = isOpen ? "true" : "false";
+  }
+  let onPressStart = (e) => {
+    if (e.pointerType === "keyboard" && onAction)
+      onAction(key);
+  };
+  let onPressUp = (e) => {
+    if (e.pointerType !== "keyboard") {
+      if (onAction)
+        onAction(key);
+      if (!isTrigger && onClose && (closeOnSelect !== null && closeOnSelect !== void 0 ? closeOnSelect : state.selectionManager.selectionMode !== "multiple"))
+        onClose();
+    }
+  };
+  let { itemProps, isFocused } = $880e95eb8b93ba9a$export$ecf600387e221c37({
+    selectionManager: state.selectionManager,
+    key,
+    ref,
+    shouldSelectOnPressUp: true,
+    allowsDifferentPressOrigin: true
+  });
+  let { pressProps, isPressed } = _import$1.$f6c31cce2adf654f$export$45712eceda6fad21({
+    onPressStart,
+    onPressUp,
+    isDisabled: isDisabled || isTrigger && state.expandedKeys.has(key)
+  });
+  let { hoverProps } = _import$1.$6179b936705e76d3$export$ae780daf29e6d456({
+    isDisabled,
+    onHoverStart() {
+      if (!_import$1.$507fabe10e71c6fb$export$b9b3dfddab17db27() && !(isTrigger && state.expandedKeys.has(key))) {
+        state.selectionManager.setFocused(true);
+        state.selectionManager.setFocusedKey(key);
+        let isFocused2 = key === state.selectionManager.focusedKey;
+        if (isFocused2 && state.selectionManager.isFocused && document.activeElement !== ref.current)
+          _import$1.$6a99195332edec8b$export$80f3e147d781571c(ref.current);
+      }
+    },
+    onHoverChange: (isHovered) => {
+      if (isHovered && isTrigger && !state.expandedKeys.has(key)) {
+        if (!openTimeout.current)
+          openTimeout.current = setTimeout(() => {
+            onSubmenuOpen();
+          }, 200);
+      } else if (!isHovered)
+        cancelOpenTimeout();
+    }
+  });
+  let { keyboardProps } = _import$1.$46d819fcbaf35654$export$8f71654801c2f7cd({
+    onKeyDown: (e) => {
+      if (e.repeat) {
+        e.continuePropagation();
+        return;
+      }
+      switch (e.key) {
+        case " ":
+          if (!isDisabled && state.selectionManager.selectionMode === "none" && !isTrigger && closeOnSelect !== false && onClose)
+            onClose();
+          break;
+        case "Enter":
+          if (!isDisabled && closeOnSelect !== false && !isTrigger && onClose)
+            onClose();
+          break;
+        case "ArrowRight":
+          if (isTrigger && direction === "ltr")
+            onSubmenuOpen();
+          else
+            e.continuePropagation();
+          break;
+        case "ArrowLeft":
+          if (isTrigger && direction === "rtl")
+            onSubmenuOpen();
+          else
+            e.continuePropagation();
+          break;
+        default:
+          e.continuePropagation();
+          break;
+      }
+    }
+  });
+  return {
+    menuItemProps: __spreadValues(__spreadValues({}, ariaProps), _import.$3ef42575df84b30b$export$9d1611c77c2fe928(itemProps, pressProps, hoverProps, keyboardProps)),
+    labelProps: {
+      id: labelId
+    },
+    descriptionProps: {
+      id: descriptionId
+    },
+    keyboardShortcutProps: {
+      id: keyboardId
+    },
+    isFocused,
+    isSelected,
+    isPressed,
+    isDisabled
+  };
+}
+function $3e5eb2498db5b506$export$73f7a44322579622(props) {
+  let { heading, "aria-label": ariaLabel } = props;
+  let headingId = _import.$bdb11010cef70236$export$f680877a34711e37();
+  return {
+    itemProps: {
+      role: "presentation"
+    },
+    headingProps: heading ? {
+      // Techincally, menus cannot contain headings according to ARIA.
+      // We hide the heading from assistive technology, using role="presentation",
+      // and only use it as a label for the nested group.
+      id: headingId,
+      role: "presentation"
+    } : {},
+    groupProps: {
+      role: "group",
+      "aria-label": ariaLabel,
+      "aria-labelledby": heading ? headingId : void 0
+    }
+  };
+}
+function $f4b273590fab9f93$export$52210f68a14655d0(props) {
+  let domProps = _import.$65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, {
+    labelable: true
+  });
+  let ariaOrientation;
+  if (props.orientation === "vertical")
+    ariaOrientation = "vertical";
+  if (props.elementType !== "hr")
+    return {
+      separatorProps: __spreadProps(__spreadValues({}, domProps), {
+        role: "separator",
+        "aria-orientation": ariaOrientation
+      })
+    };
+  return {
+    separatorProps: domProps
+  };
+}
+class $e40ea825a81a3709$export$52baac22726c72bf extends Set {
+  constructor(keys, anchorKey, currentKey) {
+    super(keys);
+    if (keys instanceof $e40ea825a81a3709$export$52baac22726c72bf) {
+      this.anchorKey = anchorKey || keys.anchorKey;
+      this.currentKey = currentKey || keys.currentKey;
+    } else {
+      this.anchorKey = anchorKey;
+      this.currentKey = currentKey;
+    }
+  }
+}
+function $7af3f5b51489e0b5$var$equalSets(setA, setB) {
+  if (setA.size !== setB.size)
+    return false;
+  for (let item of setA) {
+    if (!setB.has(item))
+      return false;
+  }
+  return true;
+}
+function $7af3f5b51489e0b5$export$253fe78d46329472(props) {
+  let { selectionMode = "none", disallowEmptySelection, allowDuplicateSelectionEvents, selectionBehavior: selectionBehaviorProp = "toggle", disabledBehavior = "all" } = props;
+  let isFocusedRef = React.useRef(false);
+  let [, setFocused] = React.useState(false);
+  let focusedKeyRef = React.useRef(null);
+  let childFocusStrategyRef = React.useRef(null);
+  let [, setFocusedKey] = React.useState(null);
+  let selectedKeysProp = React.useMemo(() => $7af3f5b51489e0b5$var$convertSelection(props.selectedKeys), [
+    props.selectedKeys
+  ]);
+  let defaultSelectedKeys = React.useMemo(() => $7af3f5b51489e0b5$var$convertSelection(props.defaultSelectedKeys, new $e40ea825a81a3709$export$52baac22726c72bf()), [
+    props.defaultSelectedKeys
+  ]);
+  let [selectedKeys, setSelectedKeys] = _import$3.$458b0a5536c1a7cf$export$40bfa8c7b0832715(selectedKeysProp, defaultSelectedKeys, props.onSelectionChange);
+  let disabledKeysProp = React.useMemo(() => props.disabledKeys ? new Set(props.disabledKeys) : /* @__PURE__ */ new Set(), [
+    props.disabledKeys
+  ]);
+  let [selectionBehavior, setSelectionBehavior] = React.useState(selectionBehaviorProp);
+  if (selectionBehaviorProp === "replace" && selectionBehavior === "toggle" && typeof selectedKeys === "object" && selectedKeys.size === 0)
+    setSelectionBehavior("replace");
+  let lastSelectionBehavior = React.useRef(selectionBehaviorProp);
+  React.useEffect(() => {
+    if (selectionBehaviorProp !== lastSelectionBehavior.current) {
+      setSelectionBehavior(selectionBehaviorProp);
+      lastSelectionBehavior.current = selectionBehaviorProp;
+    }
+  }, [
+    selectionBehaviorProp
+  ]);
+  return {
+    selectionMode,
+    disallowEmptySelection,
+    selectionBehavior,
+    setSelectionBehavior,
+    get isFocused() {
+      return isFocusedRef.current;
+    },
+    setFocused(f) {
+      isFocusedRef.current = f;
+      setFocused(f);
+    },
+    get focusedKey() {
+      return focusedKeyRef.current;
+    },
+    get childFocusStrategy() {
+      return childFocusStrategyRef.current;
+    },
+    setFocusedKey(k, childFocusStrategy = "first") {
+      focusedKeyRef.current = k;
+      childFocusStrategyRef.current = childFocusStrategy;
+      setFocusedKey(k);
+    },
+    selectedKeys,
+    setSelectedKeys(keys) {
+      if (allowDuplicateSelectionEvents || !$7af3f5b51489e0b5$var$equalSets(keys, selectedKeys))
+        setSelectedKeys(keys);
+    },
+    disabledKeys: disabledKeysProp,
+    disabledBehavior
+  };
+}
+function $7af3f5b51489e0b5$var$convertSelection(selection, defaultValue) {
+  if (!selection)
+    return defaultValue;
+  return selection === "all" ? "all" : new $e40ea825a81a3709$export$52baac22726c72bf(selection);
+}
+class $d496c0a20b6e58ec$export$6c8a5aaad13c9852 {
+  /**
+  * The type of selection that is allowed in the collection.
+  */
+  get selectionMode() {
+    return this.state.selectionMode;
+  }
+  /**
+  * Whether the collection allows empty selection.
+  */
+  get disallowEmptySelection() {
+    return this.state.disallowEmptySelection;
+  }
+  /**
+  * The selection behavior for the collection.
+  */
+  get selectionBehavior() {
+    return this.state.selectionBehavior;
+  }
+  /**
+  * Sets the selection behavior for the collection.
+  */
+  setSelectionBehavior(selectionBehavior) {
+    this.state.setSelectionBehavior(selectionBehavior);
+  }
+  /**
+  * Whether the collection is currently focused.
+  */
+  get isFocused() {
+    return this.state.isFocused;
+  }
+  /**
+  * Sets whether the collection is focused.
+  */
+  setFocused(isFocused) {
+    this.state.setFocused(isFocused);
+  }
+  /**
+  * The current focused key in the collection.
+  */
+  get focusedKey() {
+    return this.state.focusedKey;
+  }
+  /** Whether the first or last child of the focused key should receive focus. */
+  get childFocusStrategy() {
+    return this.state.childFocusStrategy;
+  }
+  /**
+  * Sets the focused key.
+  */
+  setFocusedKey(key, childFocusStrategy) {
+    if (key == null || this.collection.getItem(key))
+      this.state.setFocusedKey(key, childFocusStrategy);
+  }
+  /**
+  * The currently selected keys in the collection.
+  */
+  get selectedKeys() {
+    return this.state.selectedKeys === "all" ? new Set(this.getSelectAllKeys()) : this.state.selectedKeys;
+  }
+  /**
+  * The raw selection value for the collection.
+  * Either 'all' for select all, or a set of keys.
+  */
+  get rawSelection() {
+    return this.state.selectedKeys;
+  }
+  /**
+  * Returns whether a key is selected.
+  */
+  isSelected(key) {
+    if (this.state.selectionMode === "none")
+      return false;
+    key = this.getKey(key);
+    return this.state.selectedKeys === "all" ? this.canSelectItem(key) : this.state.selectedKeys.has(key);
+  }
+  /**
+  * Whether the selection is empty.
+  */
+  get isEmpty() {
+    return this.state.selectedKeys !== "all" && this.state.selectedKeys.size === 0;
+  }
+  /**
+  * Whether all items in the collection are selected.
+  */
+  get isSelectAll() {
+    if (this.isEmpty)
+      return false;
+    if (this.state.selectedKeys === "all")
+      return true;
+    if (this._isSelectAll != null)
+      return this._isSelectAll;
+    let allKeys = this.getSelectAllKeys();
+    let selectedKeys = this.state.selectedKeys;
+    this._isSelectAll = allKeys.every((k) => selectedKeys.has(k));
+    return this._isSelectAll;
+  }
+  get firstSelectedKey() {
+    let first = null;
+    for (let key of this.state.selectedKeys) {
+      let item = this.collection.getItem(key);
+      if (!first || item && $c5a24bc478652b5f$export$8c434b3a7a4dad6(this.collection, item, first) < 0)
+        first = item;
+    }
+    return first === null || first === void 0 ? void 0 : first.key;
+  }
+  get lastSelectedKey() {
+    let last = null;
+    for (let key of this.state.selectedKeys) {
+      let item = this.collection.getItem(key);
+      if (!last || item && $c5a24bc478652b5f$export$8c434b3a7a4dad6(this.collection, item, last) > 0)
+        last = item;
+    }
+    return last === null || last === void 0 ? void 0 : last.key;
+  }
+  get disabledKeys() {
+    return this.state.disabledKeys;
+  }
+  get disabledBehavior() {
+    return this.state.disabledBehavior;
+  }
+  /**
+  * Extends the selection to the given key.
+  */
+  extendSelection(toKey) {
+    if (this.selectionMode === "none")
+      return;
+    if (this.selectionMode === "single") {
+      this.replaceSelection(toKey);
+      return;
+    }
+    toKey = this.getKey(toKey);
+    let selection;
+    if (this.state.selectedKeys === "all")
+      selection = new $e40ea825a81a3709$export$52baac22726c72bf([
+        toKey
+      ], toKey, toKey);
+    else {
+      let selectedKeys = this.state.selectedKeys;
+      let anchorKey = selectedKeys.anchorKey || toKey;
+      selection = new $e40ea825a81a3709$export$52baac22726c72bf(selectedKeys, anchorKey, toKey);
+      for (let key of this.getKeyRange(anchorKey, selectedKeys.currentKey || toKey))
+        selection.delete(key);
+      for (let key of this.getKeyRange(toKey, anchorKey))
+        if (this.canSelectItem(key))
+          selection.add(key);
+    }
+    this.state.setSelectedKeys(selection);
+  }
+  getKeyRange(from, to) {
+    let fromItem = this.collection.getItem(from);
+    let toItem = this.collection.getItem(to);
+    if (fromItem && toItem) {
+      if ($c5a24bc478652b5f$export$8c434b3a7a4dad6(this.collection, fromItem, toItem) <= 0)
+        return this.getKeyRangeInternal(from, to);
+      return this.getKeyRangeInternal(to, from);
+    }
+    return [];
+  }
+  getKeyRangeInternal(from, to) {
+    let keys = [];
+    let key = from;
+    while (key) {
+      let item = this.collection.getItem(key);
+      if (item && item.type === "item" || item.type === "cell" && this.allowsCellSelection)
+        keys.push(key);
+      if (key === to)
+        return keys;
+      key = this.collection.getKeyAfter(key);
+    }
+    return [];
+  }
+  getKey(key) {
+    let item = this.collection.getItem(key);
+    if (!item)
+      return key;
+    if (item.type === "cell" && this.allowsCellSelection)
+      return key;
+    while (item.type !== "item" && item.parentKey != null)
+      item = this.collection.getItem(item.parentKey);
+    if (!item || item.type !== "item")
+      return null;
+    return item.key;
+  }
+  /**
+  * Toggles whether the given key is selected.
+  */
+  toggleSelection(key) {
+    if (this.selectionMode === "none")
+      return;
+    if (this.selectionMode === "single" && !this.isSelected(key)) {
+      this.replaceSelection(key);
+      return;
+    }
+    key = this.getKey(key);
+    if (key == null)
+      return;
+    let keys = new $e40ea825a81a3709$export$52baac22726c72bf(this.state.selectedKeys === "all" ? this.getSelectAllKeys() : this.state.selectedKeys);
+    if (keys.has(key))
+      keys.delete(key);
+    else if (this.canSelectItem(key)) {
+      keys.add(key);
+      keys.anchorKey = key;
+      keys.currentKey = key;
+    }
+    if (this.disallowEmptySelection && keys.size === 0)
+      return;
+    this.state.setSelectedKeys(keys);
+  }
+  /**
+  * Replaces the selection with only the given key.
+  */
+  replaceSelection(key) {
+    if (this.selectionMode === "none")
+      return;
+    key = this.getKey(key);
+    if (key == null)
+      return;
+    let selection = this.canSelectItem(key) ? new $e40ea825a81a3709$export$52baac22726c72bf([
+      key
+    ], key, key) : new $e40ea825a81a3709$export$52baac22726c72bf();
+    this.state.setSelectedKeys(selection);
+  }
+  /**
+  * Replaces the selection with the given keys.
+  */
+  setSelectedKeys(keys) {
+    if (this.selectionMode === "none")
+      return;
+    let selection = new $e40ea825a81a3709$export$52baac22726c72bf();
+    for (let key of keys) {
+      key = this.getKey(key);
+      if (key != null) {
+        selection.add(key);
+        if (this.selectionMode === "single")
+          break;
+      }
+    }
+    this.state.setSelectedKeys(selection);
+  }
+  getSelectAllKeys() {
+    let keys = [];
+    let addKeys = (key) => {
+      while (key) {
+        if (this.canSelectItem(key)) {
+          let item = this.collection.getItem(key);
+          if (item.type === "item")
+            keys.push(key);
+          if (item.hasChildNodes && (this.allowsCellSelection || item.type !== "item"))
+            addKeys($c5a24bc478652b5f$export$fbdeaa6a76694f71($c5a24bc478652b5f$export$1005530eda016c13(item, this.collection)).key);
+        }
+        key = this.collection.getKeyAfter(key);
+      }
+    };
+    addKeys(this.collection.getFirstKey());
+    return keys;
+  }
+  /**
+  * Selects all items in the collection.
+  */
+  selectAll() {
+    if (!this.isSelectAll && this.selectionMode === "multiple")
+      this.state.setSelectedKeys("all");
+  }
+  /**
+  * Removes all keys from the selection.
+  */
+  clearSelection() {
+    if (!this.disallowEmptySelection && (this.state.selectedKeys === "all" || this.state.selectedKeys.size > 0))
+      this.state.setSelectedKeys(new $e40ea825a81a3709$export$52baac22726c72bf());
+  }
+  /**
+  * Toggles between select all and an empty selection.
+  */
+  toggleSelectAll() {
+    if (this.isSelectAll)
+      this.clearSelection();
+    else
+      this.selectAll();
+  }
+  select(key, e) {
+    if (this.selectionMode === "none")
+      return;
+    if (this.selectionMode === "single") {
+      if (this.isSelected(key) && !this.disallowEmptySelection)
+        this.toggleSelection(key);
+      else
+        this.replaceSelection(key);
+    } else if (this.selectionBehavior === "toggle" || e && (e.pointerType === "touch" || e.pointerType === "virtual"))
+      this.toggleSelection(key);
+    else
+      this.replaceSelection(key);
+  }
+  /**
+  * Returns whether the current selection is equal to the given selection.
+  */
+  isSelectionEqual(selection) {
+    if (selection === this.state.selectedKeys)
+      return true;
+    let selectedKeys = this.selectedKeys;
+    if (selection.size !== selectedKeys.size)
+      return false;
+    for (let key of selection) {
+      if (!selectedKeys.has(key))
+        return false;
+    }
+    for (let key of selectedKeys) {
+      if (!selection.has(key))
+        return false;
+    }
+    return true;
+  }
+  canSelectItem(key) {
+    if (this.state.selectionMode === "none" || this.state.disabledKeys.has(key))
+      return false;
+    let item = this.collection.getItem(key);
+    if (!item || item.type === "cell" && !this.allowsCellSelection)
+      return false;
+    return true;
+  }
+  isDisabled(key) {
+    return this.state.disabledKeys.has(key) && this.state.disabledBehavior === "all";
+  }
+  constructor(collection, state, options) {
+    this.collection = collection;
+    this.state = state;
+    var _options_allowsCellSelection;
+    this.allowsCellSelection = (_options_allowsCellSelection = options === null || options === void 0 ? void 0 : options.allowsCellSelection) !== null && _options_allowsCellSelection !== void 0 ? _options_allowsCellSelection : false;
+    this._isSelectAll = null;
+  }
+}
+function $a28c903ee9ad8dc5$export$79fefeb1c2091ac3(props) {
+  let overlayTriggerState = _import$2.$fc909762b330b746$export$61c6a8c84e605fb6(props);
+  let [focusStrategy, setFocusStrategy] = React.useState(null);
+  return __spreadProps(__spreadValues({
+    focusStrategy
+  }, overlayTriggerState), {
+    open(focusStrategy2 = null) {
+      setFocusStrategy(focusStrategy2);
+      overlayTriggerState.open();
+    },
+    toggle(focusStrategy2 = null) {
+      setFocusStrategy(focusStrategy2);
+      overlayTriggerState.toggle();
+    }
+  });
+}
+const DEFAULT_MAX_ITEMS_UNTIL_SCROLL = 5;
+const DEFAULT_PLACEMENT = "bottom";
+const DEFAULT_WIDTH = "auto";
+const ITEM_HEIGHT = 32;
+const Y_PADDING_INSIDE_OVERLAY = 8;
+const OVERLAY_OFFSET = 8;
+const OVERLAY_PADDING_FROM_CONTAINER = 12;
+function getUnmergedPopoverStyles(width, triggerWidth) {
+  return __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, utilities_css.getComponentToken("menu", "item_height", `${utilities_css.pxToRem(ITEM_HEIGHT)}rem`)), utilities_css.getComponentToken("menu", "padding.y", `${utilities_css.pxToRem(Y_PADDING_INSIDE_OVERLAY)}rem`)), utilities_css.getComponentToken("menu", "min-width", width === "auto" ? `${triggerWidth}px` : void 0)), utilities_css.getResponsiveValue("menu", "width", width !== "auto" && width !== "fit-content" ? width : "auto"));
+}
+function useTriggerWidth(triggerRef) {
+  const [triggerWidth, setTriggerWidth] = React.useState(null);
+  _import.$9daab02d461809db$export$683480f191c0e3ea({
+    ref: triggerRef,
+    onResize: () => {
+      if (triggerRef.current) {
+        const { width } = triggerRef.current.getBoundingClientRect();
+        setTriggerWidth(width);
+      }
+    }
+  });
+  const initialRef = React.useRef(false);
+  React.useEffect(() => {
+    if (triggerRef.current && !initialRef.current) {
+      const { width } = triggerRef.current.getBoundingClientRect();
+      setTriggerWidth(width);
+      initialRef.current = true;
+    }
+  }, [triggerRef]);
+  return triggerWidth;
+}
+exports.$168583247155ddda$export$dc9c12ed27dd1b49 = $168583247155ddda$export$dc9c12ed27dd1b49;
+exports.$2a25aae57d74318e$export$a05409b8bb224a5a = $2a25aae57d74318e$export$a05409b8bb224a5a;
+exports.$3e5eb2498db5b506$export$73f7a44322579622 = $3e5eb2498db5b506$export$73f7a44322579622;
+exports.$453cc9f0df89c0a5$export$77d5aafae4e095b2 = $453cc9f0df89c0a5$export$77d5aafae4e095b2;
+exports.$7613b1592d41b092$export$6cd28814d92fa9c9 = $7613b1592d41b092$export$6cd28814d92fa9c9;
+exports.$7af3f5b51489e0b5$export$253fe78d46329472 = $7af3f5b51489e0b5$export$253fe78d46329472;
+exports.$880e95eb8b93ba9a$export$ecf600387e221c37 = $880e95eb8b93ba9a$export$ecf600387e221c37;
+exports.$982254629710d113$export$b95089534ab7c1fd = $982254629710d113$export$b95089534ab7c1fd;
+exports.$9fc4852771d079eb$export$6e2c8f0811a474ce = $9fc4852771d079eb$export$6e2c8f0811a474ce;
+exports.$a28c903ee9ad8dc5$export$79fefeb1c2091ac3 = $a28c903ee9ad8dc5$export$79fefeb1c2091ac3;
+exports.$a2e5df62f93c7633$export$9d32628fc2aea7da = $a2e5df62f93c7633$export$9d32628fc2aea7da;
+exports.$c1d7fb2ec91bae71$export$6d08773d2e66f8f2 = $c1d7fb2ec91bae71$export$6d08773d2e66f8f2;
+exports.$d496c0a20b6e58ec$export$6c8a5aaad13c9852 = $d496c0a20b6e58ec$export$6c8a5aaad13c9852;
+exports.$d5336fe17ce95402$export$38eaa17faae8f579 = $d5336fe17ce95402$export$38eaa17faae8f579;
+exports.$f4b273590fab9f93$export$52210f68a14655d0 = $f4b273590fab9f93$export$52210f68a14655d0;
+exports.$fb3050f43d946246$export$e32c88dfddc6e1d8 = $fb3050f43d946246$export$e32c88dfddc6e1d8;
+exports.DEFAULT_MAX_ITEMS_UNTIL_SCROLL = DEFAULT_MAX_ITEMS_UNTIL_SCROLL;
+exports.DEFAULT_PLACEMENT = DEFAULT_PLACEMENT;
+exports.DEFAULT_WIDTH = DEFAULT_WIDTH;
+exports.ITEM_HEIGHT = ITEM_HEIGHT;
+exports.OVERLAY_OFFSET = OVERLAY_OFFSET;
+exports.OVERLAY_PADDING_FROM_CONTAINER = OVERLAY_PADDING_FROM_CONTAINER;
+exports.Y_PADDING_INSIDE_OVERLAY = Y_PADDING_INSIDE_OVERLAY;
+exports.getUnmergedPopoverStyles = getUnmergedPopoverStyles;
+exports.useTriggerWidth = useTriggerWidth;