@react-aria/selection 3.12.0 → 3.13.0

package/dist/main.js

@@ -13,31 +13,71 @@ $parcel$export(module.exports, "useSelectableItem", () => $433b1145b0781e10$expo
 $parcel$export(module.exports, "useSelectableList", () => $bd230acee196f50c$export$b95089534ab7c1fd);
 $parcel$export(module.exports, "ListKeyboardDelegate", () => $836f880b12dcae5c$export$a05409b8bb224a5a);
 $parcel$export(module.exports, "useTypeSelect", () => $a1189052f36475e8$export$e32c88dfddc6e1d8);
-
-
-
-
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ /*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
 
 function $ee0bdf4faa47f2a8$export$d3e3bd3e26688c04(e) {
     // Ctrl + Arrow Up/Arrow Down has a system wide meaning on macOS, so use Alt instead.
     // On Windows and Ubuntu, Alt + Space has a system wide meaning.
-    return $glPPV$reactariautils.isAppleDevice() ? e.altKey : e.ctrlKey;
+    return (0, $glPPV$reactariautils.isAppleDevice)() ? e.altKey : e.ctrlKey;
 }
 function $ee0bdf4faa47f2a8$export$16792effe837dba3(e) {
-    if ($glPPV$reactariautils.isMac()) return e.metaKey;
+    if ((0, $glPPV$reactariautils.isMac)()) return e.metaKey;
     return e.ctrlKey;
 }
 
 
 
-
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
 /**
  * Controls how long to wait before clearing the typeahead buffer.
  */ const $a1189052f36475e8$var$TYPEAHEAD_DEBOUNCE_WAIT_MS = 1000; // 1 second
 function $a1189052f36475e8$export$e32c88dfddc6e1d8(options) {
     let { keyboardDelegate: keyboardDelegate , selectionManager: selectionManager , onTypeSelect: onTypeSelect  } = options;
-    let state = $glPPV$react.useRef({
-        search: '',
+    let state = (0, $glPPV$react.useRef)({
+        search: "",
         timeout: null
     }).current;
     let onKeyDown = (e)=>{
@@ -47,9 +87,9 @@ function $a1189052f36475e8$export$e32c88dfddc6e1d8(options) {
         // When we time out, the search term becomes empty, hence the check on length.
         // Trimming is to account for the case of pressing the Spacebar more than once,
         // which should cycle through the selection/deselection of the focused item.
-        if (character === ' ' && state.search.trim().length > 0) {
+        if (character === " " && state.search.trim().length > 0) {
             e.preventDefault();
-            if (!('continuePropagation' in e)) e.stopPropagation();
+            if (!("continuePropagation" in e)) e.stopPropagation();
         }
         state.search += character;
         // Use the delegate to find a key to focus.
@@ -63,7 +103,7 @@ function $a1189052f36475e8$export$e32c88dfddc6e1d8(options) {
         }
         clearTimeout(state.timeout);
         state.timeout = setTimeout(()=>{
-            state.search = '';
+            state.search = "";
         }, $a1189052f36475e8$var$TYPEAHEAD_DEBOUNCE_WAIT_MS);
     };
     return {
@@ -80,103 +120,103 @@ function $a1189052f36475e8$var$getStringForKey(key) {
     // it is a Unicode character.
     // See https://www.w3.org/TR/uievents-key/
     if (key.length === 1 || !/^[A-Z]/i.test(key)) return key;
-    return '';
+    return "";
 }
 
 
 function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
-    let { selectionManager: manager , keyboardDelegate: delegate , ref: ref , autoFocus: autoFocus = false , shouldFocusWrap: shouldFocusWrap = false , disallowEmptySelection: disallowEmptySelection = false , disallowSelectAll: disallowSelectAll = false , selectOnFocus: selectOnFocus = manager.selectionBehavior === 'replace' , disallowTypeAhead: disallowTypeAhead = false , shouldUseVirtualFocus: shouldUseVirtualFocus , allowsTabNavigation: allowsTabNavigation = false , isVirtualized: isVirtualized , scrollRef: // If no scrollRef is provided, assume the collection ref is the scrollable region
+    let { selectionManager: manager , keyboardDelegate: delegate , ref: ref , autoFocus: autoFocus = false , shouldFocusWrap: shouldFocusWrap = false , disallowEmptySelection: disallowEmptySelection = false , disallowSelectAll: disallowSelectAll = false , selectOnFocus: selectOnFocus = manager.selectionBehavior === "replace" , disallowTypeAhead: disallowTypeAhead = false , shouldUseVirtualFocus: shouldUseVirtualFocus , allowsTabNavigation: allowsTabNavigation = false , isVirtualized: isVirtualized , scrollRef: // If no scrollRef is provided, assume the collection ref is the scrollable region
     scrollRef = ref  } = options;
-    let { direction: direction  } = $glPPV$reactariai18n.useLocale();
+    let { direction: direction  } = (0, $glPPV$reactariai18n.useLocale)();
     let onKeyDown = (e)=>{
         // Prevent option + tab from doing anything since it doesn't move focus to the cells, only buttons/checkboxes
-        if (e.altKey && e.key === 'Tab') e.preventDefault();
+        if (e.altKey && e.key === "Tab") e.preventDefault();
         // Keyboard events bubble through portals. Don't handle keyboard events
         // for elements outside the collection (e.g. menus).
         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 && !$ee0bdf4faa47f2a8$export$d3e3bd3e26688c04(e)) manager.replaceSelection(key);
+                if (e.shiftKey && manager.selectionMode === "multiple") manager.extendSelection(key);
+                else if (selectOnFocus && !(0, $ee0bdf4faa47f2a8$export$d3e3bd3e26688c04)(e)) manager.replaceSelection(key);
             }
         };
         switch(e.key){
-            case 'ArrowDown':
+            case "ArrowDown":
                 if (delegate.getKeyBelow) {
-                    var ref4, ref1;
+                    var _delegate_getFirstKey, _delegate_getFirstKey1;
                     e.preventDefault();
-                    let nextKey = manager.focusedKey != null ? delegate.getKeyBelow(manager.focusedKey) : (ref4 = delegate.getFirstKey) === null || ref4 === void 0 ? void 0 : ref4.call(delegate);
-                    if (nextKey == null && shouldFocusWrap) nextKey = (ref1 = delegate.getFirstKey) === null || ref1 === void 0 ? void 0 : ref1.call(delegate, manager.focusedKey);
+                    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':
+            case "ArrowUp":
                 if (delegate.getKeyAbove) {
-                    var ref2, ref3;
+                    var _delegate_getLastKey, _delegate_getLastKey1;
                     e.preventDefault();
-                    let nextKey = manager.focusedKey != null ? delegate.getKeyAbove(manager.focusedKey) : (ref2 = delegate.getLastKey) === null || ref2 === void 0 ? void 0 : ref2.call(delegate);
-                    if (nextKey == null && shouldFocusWrap) nextKey = (ref3 = delegate.getLastKey) === null || ref3 === void 0 ? void 0 : ref3.call(delegate, manager.focusedKey);
-                    navigateToKey(nextKey);
+                    let nextKey1 = manager.focusedKey != null ? delegate.getKeyAbove(manager.focusedKey) : (_delegate_getLastKey = delegate.getLastKey) === null || _delegate_getLastKey === void 0 ? void 0 : _delegate_getLastKey.call(delegate);
+                    if (nextKey1 == null && shouldFocusWrap) nextKey1 = (_delegate_getLastKey1 = delegate.getLastKey) === null || _delegate_getLastKey1 === void 0 ? void 0 : _delegate_getLastKey1.call(delegate, manager.focusedKey);
+                    navigateToKey(nextKey1);
                 }
                 break;
-            case 'ArrowLeft':
+            case "ArrowLeft":
                 if (delegate.getKeyLeftOf) {
                     e.preventDefault();
-                    let nextKey = delegate.getKeyLeftOf(manager.focusedKey);
-                    navigateToKey(nextKey, direction === 'rtl' ? 'first' : 'last');
+                    let nextKey2 = delegate.getKeyLeftOf(manager.focusedKey);
+                    navigateToKey(nextKey2, direction === "rtl" ? "first" : "last");
                 }
                 break;
-            case 'ArrowRight':
+            case "ArrowRight":
                 if (delegate.getKeyRightOf) {
                     e.preventDefault();
-                    let nextKey = delegate.getKeyRightOf(manager.focusedKey);
-                    navigateToKey(nextKey, direction === 'rtl' ? 'last' : 'first');
+                    let nextKey3 = delegate.getKeyRightOf(manager.focusedKey);
+                    navigateToKey(nextKey3, direction === "rtl" ? "last" : "first");
                 }
                 break;
-            case 'Home':
+            case "Home":
                 if (delegate.getFirstKey) {
                     e.preventDefault();
-                    let firstKey = delegate.getFirstKey(manager.focusedKey, $ee0bdf4faa47f2a8$export$16792effe837dba3(e));
+                    let firstKey = delegate.getFirstKey(manager.focusedKey, (0, $ee0bdf4faa47f2a8$export$16792effe837dba3)(e));
                     manager.setFocusedKey(firstKey);
-                    if ($ee0bdf4faa47f2a8$export$16792effe837dba3(e) && e.shiftKey && manager.selectionMode === 'multiple') manager.extendSelection(firstKey);
+                    if ((0, $ee0bdf4faa47f2a8$export$16792effe837dba3)(e) && e.shiftKey && manager.selectionMode === "multiple") manager.extendSelection(firstKey);
                     else if (selectOnFocus) manager.replaceSelection(firstKey);
                 }
                 break;
-            case 'End':
+            case "End":
                 if (delegate.getLastKey) {
                     e.preventDefault();
-                    let lastKey = delegate.getLastKey(manager.focusedKey, $ee0bdf4faa47f2a8$export$16792effe837dba3(e));
+                    let lastKey = delegate.getLastKey(manager.focusedKey, (0, $ee0bdf4faa47f2a8$export$16792effe837dba3)(e));
                     manager.setFocusedKey(lastKey);
-                    if ($ee0bdf4faa47f2a8$export$16792effe837dba3(e) && e.shiftKey && manager.selectionMode === 'multiple') manager.extendSelection(lastKey);
+                    if ((0, $ee0bdf4faa47f2a8$export$16792effe837dba3)(e) && e.shiftKey && manager.selectionMode === "multiple") manager.extendSelection(lastKey);
                     else if (selectOnFocus) manager.replaceSelection(lastKey);
                 }
                 break;
-            case 'PageDown':
+            case "PageDown":
                 if (delegate.getKeyPageBelow) {
                     e.preventDefault();
-                    let nextKey = delegate.getKeyPageBelow(manager.focusedKey);
-                    navigateToKey(nextKey);
+                    let nextKey4 = delegate.getKeyPageBelow(manager.focusedKey);
+                    navigateToKey(nextKey4);
                 }
                 break;
-            case 'PageUp':
+            case "PageUp":
                 if (delegate.getKeyPageAbove) {
                     e.preventDefault();
-                    let nextKey = delegate.getKeyPageAbove(manager.focusedKey);
-                    navigateToKey(nextKey);
+                    let nextKey5 = delegate.getKeyPageAbove(manager.focusedKey);
+                    navigateToKey(nextKey5);
                 }
                 break;
-            case 'a':
-                if ($ee0bdf4faa47f2a8$export$16792effe837dba3(e) && manager.selectionMode === 'multiple' && disallowSelectAll !== true) {
+            case "a":
+                if ((0, $ee0bdf4faa47f2a8$export$16792effe837dba3)(e) && manager.selectionMode === "multiple" && disallowSelectAll !== true) {
                     e.preventDefault();
                     manager.selectAll();
                 }
                 break;
-            case 'Escape':
+            case "Escape":
                 e.preventDefault();
                 if (!disallowEmptySelection) manager.clearSelection();
                 break;
-            case 'Tab':
+            case "Tab":
                 if (!allowsTabNavigation) {
                     // There may be elements that are "tabbable" inside a collection (e.g. in a grid cell).
                     // However, collections should be treated as a single tab stop, with arrow key navigation internally.
@@ -186,7 +226,7 @@ function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
                     // rather than the currently focused one.
                     if (e.shiftKey) ref.current.focus();
                     else {
-                        let walker = $glPPV$reactariafocus.getFocusableTreeWalker(ref.current, {
+                        let walker = (0, $glPPV$reactariafocus.getFocusableTreeWalker)(ref.current, {
                             tabbable: true
                         });
                         let next;
@@ -194,19 +234,19 @@ function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
                         do {
                             last = walker.lastChild();
                             if (last) next = last;
-                        }while (last)
-                        if (next && !next.contains(document.activeElement)) $glPPV$reactariautils.focusWithoutScrolling(next);
+                        }while (last);
+                        if (next && !next.contains(document.activeElement)) (0, $glPPV$reactariautils.focusWithoutScrolling)(next);
                     }
                     break;
                 }
         }
     };
     // Store the scroll position so we can restore it later.
-    let scrollPos = $glPPV$react.useRef({
+    let scrollPos = (0, $glPPV$react.useRef)({
         top: 0,
         left: 0
     });
-    $glPPV$reactariautils.useEvent(scrollRef, 'scroll', isVirtualized ? null : ()=>{
+    (0, $glPPV$reactariautils.useEvent)(scrollRef, "scroll", isVirtualized ? null : ()=>{
         scrollPos.current = {
             top: scrollRef.current.scrollTop,
             left: scrollRef.current.scrollLeft
@@ -232,9 +272,9 @@ function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
             // Attempt to detect whether the user is tabbing forward or backward into the collection
             // and either focus the first or last item accordingly.
             let relatedTarget = e.relatedTarget;
-            var _lastSelectedKey, _firstSelectedKey;
-            if (relatedTarget && e.currentTarget.compareDocumentPosition(relatedTarget) & Node.DOCUMENT_POSITION_FOLLOWING) navigateToFirstKey((_lastSelectedKey = manager.lastSelectedKey) !== null && _lastSelectedKey !== void 0 ? _lastSelectedKey : delegate.getLastKey());
-            else navigateToFirstKey((_firstSelectedKey = manager.firstSelectedKey) !== null && _firstSelectedKey !== void 0 ? _firstSelectedKey : delegate.getFirstKey());
+            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) {
             // Restore the scroll position to what it was before.
             scrollRef.current.scrollTop = scrollPos.current.top;
@@ -243,8 +283,8 @@ function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
             let element = scrollRef.current.querySelector(`[data-key="${manager.focusedKey}"]`);
             if (element) {
                 // This prevents a flash of focus on the first/last element in the collection
-                $glPPV$reactariautils.focusWithoutScrolling(element);
-                $glPPV$reactariautils.scrollIntoView(scrollRef.current, element);
+                (0, $glPPV$reactariautils.focusWithoutScrolling)(element);
+                (0, $glPPV$reactariautils.scrollIntoView)(scrollRef.current, element);
             }
         }
     };
@@ -252,35 +292,41 @@ function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
         // Don't set blurred and then focused again if moving focus within the collection.
         if (!e.currentTarget.contains(e.relatedTarget)) manager.setFocused(false);
     };
-    const autoFocusRef = $glPPV$react.useRef(autoFocus);
-    $glPPV$react.useEffect(()=>{
+    const autoFocusRef = (0, $glPPV$react.useRef)(autoFocus);
+    (0, $glPPV$react.useEffect)(()=>{
         if (autoFocusRef.current) {
             let focusedKey = null;
             // Check focus strategy to determine which item to focus
-            if (autoFocus === 'first') focusedKey = delegate.getFirstKey();
-            if (autoFocus === 'last') focusedKey = delegate.getLastKey();
+            if (autoFocus === "first") focusedKey = delegate.getFirstKey();
+            if (autoFocus === "last") focusedKey = delegate.getLastKey();
             // If there are any selected keys, make the first one the new focus target
             let selectedKeys = manager.selectedKeys;
             if (selectedKeys.size) focusedKey = selectedKeys.values().next().value;
             manager.setFocused(true);
             manager.setFocusedKey(focusedKey);
             // If no default focus key is selected, focus the collection itself.
-            if (focusedKey == null && !shouldUseVirtualFocus) $glPPV$reactariafocus.focusSafely(ref.current);
+            if (focusedKey == null && !shouldUseVirtualFocus) (0, $glPPV$reactariafocus.focusSafely)(ref.current);
         }
         autoFocusRef.current = false;
     // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
     // If not virtualized, scroll the focused element into view when the focusedKey changes.
     // When virtualized, Virtualizer handles this internally.
-    $glPPV$react.useEffect(()=>{
+    (0, $glPPV$react.useEffect)(()=>{
         if (!isVirtualized && manager.focusedKey && (scrollRef === null || scrollRef === void 0 ? void 0 : scrollRef.current)) {
             let element = scrollRef.current.querySelector(`[data-key="${manager.focusedKey}"]`);
-            if (element) $glPPV$reactariautils.scrollIntoView(scrollRef.current, element);
+            if (element) {
+                (0, $glPPV$reactariautils.scrollIntoView)(scrollRef.current, element);
+                (0, $glPPV$reactariautils.scrollIntoViewport)(element, {
+                    containingElement: ref.current
+                });
+            }
         }
     }, [
         isVirtualized,
         scrollRef,
-        manager.focusedKey
+        manager.focusedKey,
+        ref
     ]);
     let handlers = {
         onKeyDown: onKeyDown,
@@ -292,11 +338,11 @@ function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
             e.preventDefault();
         }
     };
-    let { typeSelectProps: typeSelectProps  } = $a1189052f36475e8$export$e32c88dfddc6e1d8({
+    let { typeSelectProps: typeSelectProps  } = (0, $a1189052f36475e8$export$e32c88dfddc6e1d8)({
         keyboardDelegate: delegate,
         selectionManager: manager
     });
-    if (!disallowTypeAhead) handlers = $glPPV$reactariautils.mergeProps(typeSelectProps, handlers);
+    if (!disallowTypeAhead) handlers = (0, $glPPV$reactariautils.mergeProps)(typeSelectProps, handlers);
     // If nothing is focused within the collection, make the collection itself tabbable.
     // This will be marshalled to either the first or last item depending on where focus came from.
     // If using virtual focus, don't set a tabIndex at all so that VoiceOver on iOS 14 doesn't try
@@ -312,7 +358,17 @@ function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
 }
 
 
-
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
 
 
 
@@ -320,24 +376,24 @@ function $b6837c2f80a3c32f$export$d6daf82dcd84e87c(options) {
 function $433b1145b0781e10$export$ecf600387e221c37(options) {
     let { selectionManager: manager , key: key , ref: ref , shouldSelectOnPressUp: shouldSelectOnPressUp , isVirtualized: isVirtualized , shouldUseVirtualFocus: shouldUseVirtualFocus , focus: focus , isDisabled: isDisabled , onAction: onAction , allowsDifferentPressOrigin: allowsDifferentPressOrigin  } = options;
     let onSelect = (e)=>{
-        if (e.pointerType === 'keyboard' && $ee0bdf4faa47f2a8$export$d3e3bd3e26688c04(e)) manager.toggleSelection(key);
+        if (e.pointerType === "keyboard" && (0, $ee0bdf4faa47f2a8$export$d3e3bd3e26688c04)(e)) manager.toggleSelection(key);
         else {
-            if (manager.selectionMode === 'none') return;
-            if (manager.selectionMode === 'single') {
+            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 && ($ee0bdf4faa47f2a8$export$16792effe837dba3(e) || e.pointerType === 'touch' || e.pointerType === 'virtual')) // if touch or virtual (VO) then we just want to toggle, otherwise it's impossible to multi select because they don't have modifier keys
+            else if (manager.selectionBehavior === "toggle" || e && ((0, $ee0bdf4faa47f2a8$export$16792effe837dba3)(e) || e.pointerType === "touch" || e.pointerType === "virtual")) // if touch or virtual (VO) then we just want to toggle, otherwise it's impossible to multi select because they don't have modifier keys
             manager.toggleSelection(key);
             else manager.replaceSelection(key);
         }
     };
     // Focus the associated DOM node when this item becomes the focusedKey
-    $glPPV$react.useEffect(()=>{
+    (0, $glPPV$react.useEffect)(()=>{
         let isFocused = key === manager.focusedKey;
         if (isFocused && manager.isFocused && !shouldUseVirtualFocus && document.activeElement !== ref.current) {
             if (focus) focus();
-            else $glPPV$reactariafocus.focusSafely(ref.current);
+            else (0, $glPPV$reactariafocus.focusSafely)(ref.current);
         }
     // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [
@@ -352,8 +408,7 @@ function $433b1145b0781e10$export$ecf600387e221c37(options) {
     // Set tabIndex to 0 if the element is focused, or -1 otherwise so that only the last focused
     // item is tabbable.  If using virtual focus, don't set a tabIndex at all so that VoiceOver
     // on iOS 14 doesn't try to move real DOM focus to the item anyway.
-    let itemProps = {
-    };
+    let itemProps = {};
     if (!shouldUseVirtualFocus && !isDisabled) itemProps = {
         tabIndex: key === manager.focusedKey ? 0 : -1,
         onFocus (e) {
@@ -370,13 +425,13 @@ function $433b1145b0781e10$export$ecf600387e221c37(options) {
     // With touch, onAction occurs on single tap, and long press enters selection mode.
     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 hasPrimaryAction = allowsActions && (manager.selectionBehavior === "replace" ? !allowsSelection : manager.isEmpty);
+    let hasSecondaryAction = allowsActions && allowsSelection && manager.selectionBehavior === "replace";
     let hasAction = hasPrimaryAction || hasSecondaryAction;
-    let modality = $glPPV$react.useRef(null);
+    let modality = (0, $glPPV$react.useRef)(null);
     let longPressEnabled = hasAction && allowsSelection;
-    let longPressEnabledOnPressStart = $glPPV$react.useRef(false);
-    let hadPrimaryActionOnPressStart = $glPPV$react.useRef(false);
+    let longPressEnabledOnPressStart = (0, $glPPV$react.useRef)(false);
+    let hadPrimaryActionOnPressStart = (0, $glPPV$react.useRef)(false);
     // By default, selection occurs on pointer down. This can be strange if selecting an
     // item causes the UI to disappear immediately (e.g. menus).
     // If shouldSelectOnPressUp is true, we use onPressUp instead of onPressStart.
@@ -384,28 +439,26 @@ function $433b1145b0781e10$export$ecf600387e221c37(options) {
     // we want to be able to have the pointer down on the trigger that opens the menu and
     // the pointer up on the menu item rather than requiring a separate press.
     // For keyboard events, selection still occurs on key down.
-    let itemPressProps = {
-    };
+    let itemPressProps = {};
     if (shouldSelectOnPressUp) {
         itemPressProps.onPressStart = (e)=>{
             modality.current = e.pointerType;
             longPressEnabledOnPressStart.current = longPressEnabled;
-            if (e.pointerType === 'keyboard' && (!hasAction || $433b1145b0781e10$var$isSelectionKey())) onSelect(e);
+            if (e.pointerType === "keyboard" && (!hasAction || $433b1145b0781e10$var$isSelectionKey())) onSelect(e);
         };
         // If allowsDifferentPressOrigin, make selection happen on pressUp (e.g. open menu on press down, selection on menu item happens on press up.)
         // Otherwise, have selection happen onPress (prevents listview row selection when clicking on interactable elements in the row)
         if (!allowsDifferentPressOrigin) itemPressProps.onPress = (e)=>{
-            if (hasPrimaryAction || hasSecondaryAction && e.pointerType !== 'mouse') {
-                if (e.pointerType === 'keyboard' && !$433b1145b0781e10$var$isActionKey()) return;
+            if (hasPrimaryAction || hasSecondaryAction && e.pointerType !== "mouse") {
+                if (e.pointerType === "keyboard" && !$433b1145b0781e10$var$isActionKey()) return;
                 onAction();
-            } else if (e.pointerType !== 'keyboard') onSelect(e);
+            } else if (e.pointerType !== "keyboard") onSelect(e);
         };
         else {
             itemPressProps.onPressUp = (e)=>{
-                if (e.pointerType !== 'keyboard') onSelect(e);
+                if (e.pointerType !== "keyboard") onSelect(e);
             };
-            itemPressProps.onPress = hasPrimaryAction ? ()=>onAction()
-             : null;
+            itemPressProps.onPress = hasPrimaryAction ? ()=>onAction() : null;
         }
     } else {
         itemPressProps.onPressStart = (e)=>{
@@ -415,24 +468,24 @@ function $433b1145b0781e10$export$ecf600387e221c37(options) {
             // Select on mouse down unless there is a primary action which will occur on mouse up.
             // For keyboard, select on key down. If there is an action, the Space key selects on key down,
             // and the Enter key performs onAction on key up.
-            if (e.pointerType === 'mouse' && !hasPrimaryAction || e.pointerType === 'keyboard' && (!onAction || $433b1145b0781e10$var$isSelectionKey())) onSelect(e);
+            if (e.pointerType === "mouse" && !hasPrimaryAction || e.pointerType === "keyboard" && (!onAction || $433b1145b0781e10$var$isSelectionKey())) onSelect(e);
         };
         itemPressProps.onPress = (e)=>{
             // Selection occurs on touch up. Primary actions always occur on pointer up.
             // Both primary and secondary actions occur on Enter key up. The only exception
             // is secondary actions, which occur on double click with a mouse.
-            if (e.pointerType === 'touch' || e.pointerType === 'pen' || e.pointerType === 'virtual' || e.pointerType === 'keyboard' && hasAction && $433b1145b0781e10$var$isActionKey() || e.pointerType === 'mouse' && hadPrimaryActionOnPressStart.current) {
+            if (e.pointerType === "touch" || e.pointerType === "pen" || e.pointerType === "virtual" || e.pointerType === "keyboard" && hasAction && $433b1145b0781e10$var$isActionKey() || e.pointerType === "mouse" && hadPrimaryActionOnPressStart.current) {
                 if (hasAction) onAction();
                 else onSelect(e);
             }
         };
     }
-    if (!isVirtualized) itemProps['data-key'] = key;
+    if (!isVirtualized) itemProps["data-key"] = key;
     itemPressProps.preventFocusOnPress = shouldUseVirtualFocus;
-    let { pressProps: pressProps , isPressed: isPressed  } = $glPPV$reactariainteractions.usePress(itemPressProps);
+    let { pressProps: pressProps , isPressed: isPressed  } = (0, $glPPV$reactariainteractions.usePress)(itemPressProps);
     // Double clicking with a mouse with selectionBehavior = 'replace' performs an action.
     let onDoubleClick = hasSecondaryAction ? (e)=>{
-        if (modality.current === 'mouse') {
+        if (modality.current === "mouse") {
             e.stopPropagation();
             e.preventDefault();
             onAction();
@@ -441,12 +494,12 @@ function $433b1145b0781e10$export$ecf600387e221c37(options) {
     // Long pressing an item with touch when selectionBehavior = 'replace' switches the selection behavior
     // to 'toggle'. This changes the single tap behavior from performing an action (i.e. navigating) to
     // selecting, and may toggle the appearance of a UI affordance like checkboxes on each item.
-    let { longPressProps: longPressProps  } = $glPPV$reactariainteractions.useLongPress({
+    let { longPressProps: longPressProps  } = (0, $glPPV$reactariainteractions.useLongPress)({
         isDisabled: !longPressEnabled,
         onLongPress (e) {
-            if (e.pointerType === 'touch') {
+            if (e.pointerType === "touch") {
                 onSelect(e);
-                manager.setSelectionBehavior('toggle');
+                manager.setSelectionBehavior("toggle");
             }
         }
     });
@@ -455,12 +508,10 @@ function $433b1145b0781e10$export$ecf600387e221c37(options) {
     // Use a capturing listener to ensure this runs before useDrag, regardless of
     // the order the props get merged.
     let onDragStartCapture = (e)=>{
-        if (modality.current === 'touch' && longPressEnabledOnPressStart.current) e.preventDefault();
+        if (modality.current === "touch" && longPressEnabledOnPressStart.current) e.preventDefault();
     };
     return {
-        itemProps: $glPPV$reactariautils.mergeProps(itemProps, allowsSelection || hasPrimaryAction ? pressProps : {
-        }, longPressEnabled ? longPressProps : {
-        }, {
+        itemProps: (0, $glPPV$reactariautils.mergeProps)(itemProps, allowsSelection || hasPrimaryAction ? pressProps : {}, longPressEnabled ? longPressProps : {}, {
             onDoubleClick: onDoubleClick,
             onDragStartCapture: onDragStartCapture
         }),
@@ -473,21 +524,41 @@ function $433b1145b0781e10$export$ecf600387e221c37(options) {
 }
 function $433b1145b0781e10$var$isActionKey() {
     let event = window.event;
-    return (event === null || event === void 0 ? void 0 : event.key) === 'Enter';
+    return (event === null || event === void 0 ? void 0 : event.key) === "Enter";
 }
 function $433b1145b0781e10$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';
+    return (event === null || event === void 0 ? void 0 : event.key) === " " || (event === null || event === void 0 ? void 0 : event.code) === "Space";
 }
 
 
-
-class $836f880b12dcae5c$export$a05409b8bb224a5a {
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ class $836f880b12dcae5c$export$a05409b8bb224a5a {
     getKeyBelow(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;
+            if (item.type === "item" && !this.disabledKeys.has(key)) return key;
             key = this.collection.getKeyAfter(key);
         }
     }
@@ -495,7 +566,7 @@ class $836f880b12dcae5c$export$a05409b8bb224a5a {
         key = this.collection.getKeyBefore(key);
         while(key != null){
             let item = this.collection.getItem(key);
-            if (item.type === 'item' && !this.disabledKeys.has(key)) return key;
+            if (item.type === "item" && !this.disabledKeys.has(key)) return key;
             key = this.collection.getKeyBefore(key);
         }
     }
@@ -503,7 +574,7 @@ class $836f880b12dcae5c$export$a05409b8bb224a5a {
         let key = this.collection.getFirstKey();
         while(key != null){
             let item = this.collection.getItem(key);
-            if (item.type === 'item' && !this.disabledKeys.has(key)) return key;
+            if (item.type === "item" && !this.disabledKeys.has(key)) return key;
             key = this.collection.getKeyAfter(key);
         }
     }
@@ -511,7 +582,7 @@ class $836f880b12dcae5c$export$a05409b8bb224a5a {
         let key = this.collection.getLastKey();
         while(key != null){
             let item = this.collection.getItem(key);
-            if (item.type === 'item' && !this.disabledKeys.has(key)) return key;
+            if (item.type === "item" && !this.disabledKeys.has(key)) return key;
             key = this.collection.getKeyBefore(key);
         }
     }
@@ -564,16 +635,15 @@ class $836f880b12dcae5c$export$a05409b8bb224a5a {
 
 
 function $bd230acee196f50c$export$b95089534ab7c1fd(props) {
-    let { selectionManager: selectionManager , collection: collection , disabledKeys: disabledKeys , ref: ref , keyboardDelegate: keyboardDelegate , autoFocus: autoFocus , shouldFocusWrap: shouldFocusWrap , isVirtualized: isVirtualized , disallowEmptySelection: disallowEmptySelection , selectOnFocus: selectOnFocus = selectionManager.selectionBehavior === 'replace' , disallowTypeAhead: disallowTypeAhead , shouldUseVirtualFocus: shouldUseVirtualFocus , allowsTabNavigation: allowsTabNavigation  } = props;
+    let { selectionManager: selectionManager , collection: collection , disabledKeys: disabledKeys , ref: ref , keyboardDelegate: keyboardDelegate , autoFocus: autoFocus , shouldFocusWrap: shouldFocusWrap , isVirtualized: isVirtualized , disallowEmptySelection: disallowEmptySelection , selectOnFocus: selectOnFocus = selectionManager.selectionBehavior === "replace" , disallowTypeAhead: disallowTypeAhead , shouldUseVirtualFocus: shouldUseVirtualFocus , allowsTabNavigation: allowsTabNavigation  } = props;
     // By default, a KeyboardDelegate is provided which uses the DOM to query layout information (e.g. for page up/page down).
     // When virtualized, the layout object will be passed in as a prop and override this.
-    let collator = $glPPV$reactariai18n.useCollator({
-        usage: 'search',
-        sensitivity: 'base'
+    let collator = (0, $glPPV$reactariai18n.useCollator)({
+        usage: "search",
+        sensitivity: "base"
     });
     let disabledBehavior = selectionManager.disabledBehavior;
-    let delegate = $glPPV$react.useMemo(()=>keyboardDelegate || new $836f880b12dcae5c$export$a05409b8bb224a5a(collection, disabledBehavior === 'selection' ? new Set() : disabledKeys, ref, collator)
-    , [
+    let delegate = (0, $glPPV$react.useMemo)(()=>keyboardDelegate || new (0, $836f880b12dcae5c$export$a05409b8bb224a5a)(collection, disabledBehavior === "selection" ? new Set() : disabledKeys, ref, collator), [
         keyboardDelegate,
         collection,
         disabledKeys,
@@ -581,7 +651,7 @@ function $bd230acee196f50c$export$b95089534ab7c1fd(props) {
         collator,
         disabledBehavior
     ]);
-    let { collectionProps: collectionProps  } = $b6837c2f80a3c32f$export$d6daf82dcd84e87c({
+    let { collectionProps: collectionProps  } = (0, $b6837c2f80a3c32f$export$d6daf82dcd84e87c)({
         ref: ref,
         selectionManager: selectionManager,
         keyboardDelegate: delegate,