@react-aria/utils 3.9.0 → 3.11.2

package/dist/main.js

@@ -1,938 +1,893 @@
-var {
-  clamp,
-  snapValueToStep
-} = require("@react-stately/utils");
-
-exports.snapValueToStep = snapValueToStep;
-exports.clamp = clamp;
-
-var _clsx = $parcel$interopDefault(require("clsx"));
-
-var _babelRuntimeHelpersExtends = $parcel$interopDefault(require("@babel/runtime/helpers/extends"));
-
-var {
-  useSSRSafeId
-} = require("@react-aria/ssr");
-
-var _react2 = require("react");
-
-var _react = $parcel$interopDefault(_react2);
+var $4yb13$react = require("react");
+var $4yb13$reactariassr = require("@react-aria/ssr");
+var $4yb13$clsx = require("clsx");
+var $4yb13$reactstatelyutils = require("@react-stately/utils");
+
+function $parcel$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || dest.hasOwnProperty(key)) {
+      return;
+    }
 
-var {
-  useEffect,
-  useRef,
-  useState,
-  useCallback,
-  useLayoutEffect: _useLayoutEffect
-} = _react2;
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
 
+  return dest;
+}
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
 function $parcel$interopDefault(a) {
   return a && a.__esModule ? a.default : a;
 }
+var $9cb40cfcb5f505fc$exports = {};
 
-// During SSR, React emits a warning when calling useLayoutEffect.
-// Since neither useLayoutEffect nor useEffect run on the server,
-// we can suppress this by replace it with a noop on the server.
-const useLayoutEffect = typeof window !== 'undefined' ? _react.useLayoutEffect : () => {};
-exports.useLayoutEffect = useLayoutEffect;
-let $f09fcd7f5f367fc80aacfeac62ed2$var$idsUpdaterMap = new Map();
-/**
- * If a default is not provided, generate an id.
- * @param defaultId - Default component id.
- */
-
-function useId(defaultId) {
-  let isRendering = useRef(true);
-  isRendering.current = true;
-  let [value, setValue] = useState(defaultId);
-  let nextId = useRef(null);
-  let res = useSSRSafeId(value); // don't memo this, we want it new each render so that the Effects always run
-
-  let updateValue = val => {
-    if (!isRendering.current) {
-      setValue(val);
-    } else {
-      nextId.current = val;
-    }
-  };
-
-  $f09fcd7f5f367fc80aacfeac62ed2$var$idsUpdaterMap.set(res, updateValue);
-  useLayoutEffect(() => {
-    isRendering.current = false;
-  }, [updateValue]);
-  useLayoutEffect(() => {
-    let r = res;
-    return () => {
-      $f09fcd7f5f367fc80aacfeac62ed2$var$idsUpdaterMap.delete(r);
-    };
-  }, [res]);
-  useEffect(() => {
-    let newId = nextId.current;
-
-    if (newId) {
-      setValue(newId);
-      nextId.current = null;
-    }
-  }, [setValue, updateValue]);
-  return res;
-}
-/**
- * Merges two ids.
- * Different ids will trigger a side-effect and re-render components hooked up with `useId`.
- */
+$parcel$export($9cb40cfcb5f505fc$exports, "useId", () => $9cb40cfcb5f505fc$export$f680877a34711e37);
+$parcel$export($9cb40cfcb5f505fc$exports, "mergeIds", () => $9cb40cfcb5f505fc$export$cd8c9cb68f842629);
+$parcel$export($9cb40cfcb5f505fc$exports, "useSlotId", () => $9cb40cfcb5f505fc$export$b4cc09c592e8fdb8);
 
+var $0f45c9b5be6ae2e8$exports = {};
 
-exports.useId = useId;
+$parcel$export($0f45c9b5be6ae2e8$exports, "useLayoutEffect", () => $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c);
 
-function mergeIds(idA, idB) {
-  if (idA === idB) {
-    return idA;
-  }
+const $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c = typeof window !== 'undefined' ? ($parcel$interopDefault($4yb13$react)).useLayoutEffect : ()=>{
+};
 
-  let setIdA = $f09fcd7f5f367fc80aacfeac62ed2$var$idsUpdaterMap.get(idA);
 
-  if (setIdA) {
-    setIdA(idB);
-    return idB;
-  }
-
-  let setIdB = $f09fcd7f5f367fc80aacfeac62ed2$var$idsUpdaterMap.get(idB);
 
-  if (setIdB) {
-    setIdB(idA);
-    return idA;
-  }
 
-  return idB;
-}
-/**
- * Used to generate an id, and after render, check if that id is rendered so we know
- * if we can use it in places such as labelledby.
- */
-
-
-exports.mergeIds = mergeIds;
-
-function useSlotId() {
-  let id = useId();
-  let [resolvedId, setResolvedId] = useState(id);
-  useLayoutEffect(() => {
-    let setCurr = $f09fcd7f5f367fc80aacfeac62ed2$var$idsUpdaterMap.get(id);
-
-    if (setCurr && !document.getElementById(id)) {
-      setResolvedId(null);
-    } else {
-      setResolvedId(id);
+let $9cb40cfcb5f505fc$var$idsUpdaterMap = new Map();
+function $9cb40cfcb5f505fc$export$f680877a34711e37(defaultId) {
+    let isRendering = $4yb13$react.useRef(true);
+    isRendering.current = true;
+    let [value, setValue] = $4yb13$react.useState(defaultId);
+    let nextId = $4yb13$react.useRef(null);
+    let res = $4yb13$reactariassr.useSSRSafeId(value);
+    // don't memo this, we want it new each render so that the Effects always run
+    let updateValue = (val)=>{
+        if (!isRendering.current) setValue(val);
+        else nextId.current = val;
+    };
+    $9cb40cfcb5f505fc$var$idsUpdaterMap.set(res, updateValue);
+    $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c(()=>{
+        isRendering.current = false;
+    }, [
+        updateValue
+    ]);
+    $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c(()=>{
+        let r = res;
+        return ()=>{
+            $9cb40cfcb5f505fc$var$idsUpdaterMap.delete(r);
+        };
+    }, [
+        res
+    ]);
+    $4yb13$react.useEffect(()=>{
+        let newId = nextId.current;
+        if (newId) {
+            setValue(newId);
+            nextId.current = null;
+        }
+    }, [
+        setValue,
+        updateValue
+    ]);
+    return res;
+}
+function $9cb40cfcb5f505fc$export$cd8c9cb68f842629(idA, idB) {
+    if (idA === idB) return idA;
+    let setIdA = $9cb40cfcb5f505fc$var$idsUpdaterMap.get(idA);
+    if (setIdA) {
+        setIdA(idB);
+        return idB;
     }
-  }, [id]);
-  return resolvedId;
-}
-
-exports.useSlotId = useSlotId;
-
-/*
- * 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.
- */
-
-/**
- * Calls all functions in the order they were chained with the same arguments.
- */
-function chain() {
-  for (var _len = arguments.length, callbacks = new Array(_len), _key = 0; _key < _len; _key++) {
-    callbacks[_key] = arguments[_key];
-  }
-
-  return function () {
-    for (let callback of callbacks) {
-      if (typeof callback === 'function') {
-        callback(...arguments);
-      }
+    let setIdB = $9cb40cfcb5f505fc$var$idsUpdaterMap.get(idB);
+    if (setIdB) {
+        setIdB(idA);
+        return idA;
     }
-  };
+    return idB;
 }
-
-exports.chain = chain;
-
-/**
- * Merges multiple props objects together. Event handlers are chained,
- * classNames are combined, and ids are deduplicated - different ids
- * will trigger a side-effect and re-render components hooked up with `useId`.
- * For all other props, the last prop object overrides all previous ones.
- * @param args - Multiple sets of props to merge together.
- */
-function mergeProps() {
-  // Start with a base clone of the first argument. This is a lot faster than starting
-  // with an empty object and adding properties as we go.
-  let result = _babelRuntimeHelpersExtends({}, arguments.length <= 0 ? undefined : arguments[0]);
-
-  for (let i = 1; i < arguments.length; i++) {
-    let props = i < 0 || arguments.length <= i ? undefined : arguments[i];
-
-    for (let key in props) {
-      let a = result[key];
-      let b = props[key]; // Chain events
-
-      if (typeof a === 'function' && typeof b === 'function' && // This is a lot faster than a regex.
-      key[0] === 'o' && key[1] === 'n' && key.charCodeAt(2) >=
-      /* 'A' */
-      65 && key.charCodeAt(2) <=
-      /* 'Z' */
-      90) {
-        result[key] = chain(a, b); // Merge classnames, sometimes classNames are empty string which eval to false, so we just need to do a type check
-      } else if ((key === 'className' || key === 'UNSAFE_className') && typeof a === 'string' && typeof b === 'string') {
-        result[key] = _clsx(a, b);
-      } else if (key === 'id' && a && b) {
-        result.id = mergeIds(a, b); // Override others
-      } else {
-        result[key] = b !== undefined ? b : a;
-      }
-    }
-  }
-
-  return result;
+function $9cb40cfcb5f505fc$export$b4cc09c592e8fdb8(depArray = []) {
+    let id = $9cb40cfcb5f505fc$export$f680877a34711e37();
+    let [resolvedId, setResolvedId] = $c9669ae44cabacb1$export$14d238f342723f25(id);
+    let updateId = $4yb13$react.useCallback(()=>{
+        setResolvedId(function*() {
+            yield id;
+            yield document.getElementById(id) ? id : null;
+        });
+    }, [
+        id,
+        setResolvedId
+    ]);
+    $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c(updateId, [
+        id,
+        updateId,
+        ...depArray
+    ]);
+    return resolvedId;
+}
+
+
+var $c8b46e09042b5ebf$exports = {};
+
+$parcel$export($c8b46e09042b5ebf$exports, "chain", () => $c8b46e09042b5ebf$export$e08e3b67e392101e);
+function $c8b46e09042b5ebf$export$e08e3b67e392101e(...callbacks) {
+    return (...args)=>{
+        for (let callback of callbacks)if (typeof callback === 'function') callback(...args);
+    };
 }
 
-exports.mergeProps = mergeProps;
-const $a736ffc3e05a0bfc1508098ba395b41$var$DOMPropNames = new Set(['id']);
-const $a736ffc3e05a0bfc1508098ba395b41$var$labelablePropNames = new Set(['aria-label', 'aria-labelledby', 'aria-describedby', 'aria-details']);
-const $a736ffc3e05a0bfc1508098ba395b41$var$propRe = /^(data-.*)$/;
 
-function filterDOMProps(props, opts) {
-  if (opts === void 0) {
-    opts = {};
-  }
+var $f8671bdf1f2f88a8$exports = {};
 
-  let {
-    labelable,
-    propNames
-  } = opts;
-  let filteredProps = {};
+$parcel$export($f8671bdf1f2f88a8$exports, "mergeProps", () => $f8671bdf1f2f88a8$export$9d1611c77c2fe928);
 
-  for (const prop in props) {
-    if (Object.prototype.hasOwnProperty.call(props, prop) && ($a736ffc3e05a0bfc1508098ba395b41$var$DOMPropNames.has(prop) || labelable && $a736ffc3e05a0bfc1508098ba395b41$var$labelablePropNames.has(prop) || propNames != null && propNames.has(prop) || $a736ffc3e05a0bfc1508098ba395b41$var$propRe.test(prop))) {
-      filteredProps[prop] = props[prop];
-    }
-  }
 
-  return filteredProps;
-}
-
-exports.filterDOMProps = filterDOMProps;
 
-// Currently necessary for Safari and old Edge:
-// https://caniuse.com/#feat=mdn-api_htmlelement_focus_preventscroll_option
-// See https://bugs.webkit.org/show_bug.cgi?id=178583
-//
-// Original licensing for the following methods can be found in the
-// NOTICE file in the root directory of this source tree.
-// See https://github.com/calvellido/focus-options-polyfill
-function focusWithoutScrolling(element) {
-  if ($d2a175ba498dd7834499f256dfb330bc$var$supportsPreventScroll()) {
-    element.focus({
-      preventScroll: true
-    });
-  } else {
-    let scrollableElements = $d2a175ba498dd7834499f256dfb330bc$var$getScrollableElements(element);
-    element.focus();
-    $d2a175ba498dd7834499f256dfb330bc$var$restoreScrollPosition(scrollableElements);
-  }
-}
-
-exports.focusWithoutScrolling = focusWithoutScrolling;
-let $d2a175ba498dd7834499f256dfb330bc$var$supportsPreventScrollCached = null;
-
-function $d2a175ba498dd7834499f256dfb330bc$var$supportsPreventScroll() {
-  if ($d2a175ba498dd7834499f256dfb330bc$var$supportsPreventScrollCached == null) {
-    $d2a175ba498dd7834499f256dfb330bc$var$supportsPreventScrollCached = false;
-
-    try {
-      var focusElem = document.createElement('div');
-      focusElem.focus({
-        get preventScroll() {
-          $d2a175ba498dd7834499f256dfb330bc$var$supportsPreventScrollCached = true;
-          return true;
+function $f8671bdf1f2f88a8$export$9d1611c77c2fe928(...args) {
+    // Start with a base clone of the first argument. This is a lot faster than starting
+    // with an empty object and adding properties as we go.
+    let result = {
+        ...args[0]
+    };
+    for(let i = 1; i < args.length; i++){
+        let props = args[i];
+        for(let key in props){
+            let a = result[key];
+            let b = props[key];
+            // Chain events
+            if (typeof a === 'function' && typeof b === 'function' && // This is a lot faster than a regex.
+            key[0] === 'o' && key[1] === 'n' && key.charCodeAt(2) >= /* 'A' */ 65 && key.charCodeAt(2) <= /* 'Z' */ 90) result[key] = $c8b46e09042b5ebf$export$e08e3b67e392101e(a, b);
+            else if ((key === 'className' || key === 'UNSAFE_className') && typeof a === 'string' && typeof b === 'string') result[key] = ($parcel$interopDefault($4yb13$clsx))(a, b);
+            else if (key === 'id' && a && b) result.id = $9cb40cfcb5f505fc$export$cd8c9cb68f842629(a, b);
+            else result[key] = b !== undefined ? b : a;
         }
-
-      });
-    } catch (e) {// Ignore
     }
-  }
-
-  return $d2a175ba498dd7834499f256dfb330bc$var$supportsPreventScrollCached;
+    return result;
+}
+
+
+var $0848bd72487fb188$exports = {};
+
+$parcel$export($0848bd72487fb188$exports, "filterDOMProps", () => $0848bd72487fb188$export$457c3d6518dd4c6f);
+const $0848bd72487fb188$var$DOMPropNames = new Set([
+    'id'
+]);
+const $0848bd72487fb188$var$labelablePropNames = new Set([
+    'aria-label',
+    'aria-labelledby',
+    'aria-describedby',
+    'aria-details'
+]);
+const $0848bd72487fb188$var$propRe = /^(data-.*)$/;
+function $0848bd72487fb188$export$457c3d6518dd4c6f(props, opts = {
+}) {
+    let { labelable: labelable , propNames: propNames  } = opts;
+    let filteredProps = {
+    };
+    for(const prop in props)if (Object.prototype.hasOwnProperty.call(props, prop) && ($0848bd72487fb188$var$DOMPropNames.has(prop) || labelable && $0848bd72487fb188$var$labelablePropNames.has(prop) || (propNames === null || propNames === void 0 ? void 0 : propNames.has(prop)) || $0848bd72487fb188$var$propRe.test(prop))) filteredProps[prop] = props[prop];
+    return filteredProps;
 }
 
-function $d2a175ba498dd7834499f256dfb330bc$var$getScrollableElements(element) {
-  var parent = element.parentNode;
-  var scrollableElements = [];
-  var rootScrollingElement = document.scrollingElement || document.documentElement;
 
-  while (parent instanceof HTMLElement && parent !== rootScrollingElement) {
-    if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth) {
-      scrollableElements.push({
-        element: parent,
-        scrollTop: parent.scrollTop,
-        scrollLeft: parent.scrollLeft
-      });
-    }
-
-    parent = parent.parentNode;
-  }
+var $c04e92e3451996a2$exports = {};
 
-  if (rootScrollingElement instanceof HTMLElement) {
-    scrollableElements.push({
-      element: rootScrollingElement,
-      scrollTop: rootScrollingElement.scrollTop,
-      scrollLeft: rootScrollingElement.scrollLeft
+$parcel$export($c04e92e3451996a2$exports, "focusWithoutScrolling", () => $c04e92e3451996a2$export$de79e2c695e052f3);
+function $c04e92e3451996a2$export$de79e2c695e052f3(element) {
+    if ($c04e92e3451996a2$var$supportsPreventScroll()) element.focus({
+        preventScroll: true
     });
-  }
-
-  return scrollableElements;
-}
-
-function $d2a175ba498dd7834499f256dfb330bc$var$restoreScrollPosition(scrollableElements) {
-  for (let {
-    element,
-    scrollTop,
-    scrollLeft
-  } of scrollableElements) {
-    element.scrollTop = scrollTop;
-    element.scrollLeft = scrollLeft;
-  }
-}
-
-function getOffset(element, reverse, orientation) {
-  if (orientation === void 0) {
-    orientation = 'horizontal';
-  }
-
-  let rect = element.getBoundingClientRect();
-
-  if (reverse) {
-    return orientation === 'horizontal' ? rect.right : rect.bottom;
-  }
-
-  return orientation === 'horizontal' ? rect.left : rect.top;
+    else {
+        let scrollableElements = $c04e92e3451996a2$var$getScrollableElements(element);
+        element.focus();
+        $c04e92e3451996a2$var$restoreScrollPosition(scrollableElements);
+    }
 }
-
-exports.getOffset = getOffset;
-// mapped to a set of CSS properties that are transitioning for that element.
-// This is necessary rather than a simple count of transitions because of browser
-// bugs, e.g. Chrome sometimes fires both transitionend and transitioncancel rather
-// than one or the other. So we need to track what's actually transitioning so that
-// we can ignore these duplicate events.
-let $a39a8553a97349a69bcc0255658c67ab$var$transitionsByElement = new Map(); // A list of callbacks to call once there are no transitioning elements.
-
-let $a39a8553a97349a69bcc0255658c67ab$var$transitionCallbacks = new Set();
-
-function $a39a8553a97349a69bcc0255658c67ab$var$setupGlobalEvents() {
-  if (typeof window === 'undefined') {
-    return;
-  }
-
-  let onTransitionStart = e => {
-    // Add the transitioning property to the list for this element.
-    let transitions = $a39a8553a97349a69bcc0255658c67ab$var$transitionsByElement.get(e.target);
-
-    if (!transitions) {
-      transitions = new Set();
-      $a39a8553a97349a69bcc0255658c67ab$var$transitionsByElement.set(e.target, transitions); // The transitioncancel event must be registered on the element itself, rather than as a global
-      // event. This enables us to handle when the node is deleted from the document while it is transitioning.
-      // In that case, the cancel event would have nowhere to bubble to so we need to handle it directly.
-
-      e.target.addEventListener('transitioncancel', onTransitionEnd);
+let $c04e92e3451996a2$var$supportsPreventScrollCached = null;
+function $c04e92e3451996a2$var$supportsPreventScroll() {
+    if ($c04e92e3451996a2$var$supportsPreventScrollCached == null) {
+        $c04e92e3451996a2$var$supportsPreventScrollCached = false;
+        try {
+            var focusElem = document.createElement('div');
+            focusElem.focus({
+                get preventScroll () {
+                    $c04e92e3451996a2$var$supportsPreventScrollCached = true;
+                    return true;
+                }
+            });
+        } catch (e) {
+        // Ignore
+        }
     }
-
-    transitions.add(e.propertyName);
-  };
-
-  let onTransitionEnd = e => {
-    // Remove property from list of transitioning properties.
-    let properties = $a39a8553a97349a69bcc0255658c67ab$var$transitionsByElement.get(e.target);
-
-    if (!properties) {
-      return;
+    return $c04e92e3451996a2$var$supportsPreventScrollCached;
+}
+function $c04e92e3451996a2$var$getScrollableElements(element) {
+    var parent = element.parentNode;
+    var scrollableElements = [];
+    var rootScrollingElement = document.scrollingElement || document.documentElement;
+    while(parent instanceof HTMLElement && parent !== rootScrollingElement){
+        if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth) scrollableElements.push({
+            element: parent,
+            scrollTop: parent.scrollTop,
+            scrollLeft: parent.scrollLeft
+        });
+        parent = parent.parentNode;
     }
-
-    properties.delete(e.propertyName); // If empty, remove transitioncancel event, and remove the element from the list of transitioning elements.
-
-    if (properties.size === 0) {
-      e.target.removeEventListener('transitioncancel', onTransitionEnd);
-      $a39a8553a97349a69bcc0255658c67ab$var$transitionsByElement.delete(e.target);
-    } // If no transitioning elements, call all of the queued callbacks.
-
-
-    if ($a39a8553a97349a69bcc0255658c67ab$var$transitionsByElement.size === 0) {
-      for (let cb of $a39a8553a97349a69bcc0255658c67ab$var$transitionCallbacks) {
-        cb();
-      }
-
-      $a39a8553a97349a69bcc0255658c67ab$var$transitionCallbacks.clear();
-    }
-  };
-
-  document.body.addEventListener('transitionrun', onTransitionStart);
-  document.body.addEventListener('transitionend', onTransitionEnd);
+    if (rootScrollingElement instanceof HTMLElement) scrollableElements.push({
+        element: rootScrollingElement,
+        scrollTop: rootScrollingElement.scrollTop,
+        scrollLeft: rootScrollingElement.scrollLeft
+    });
+    return scrollableElements;
 }
-
-if (typeof document !== 'undefined') {
-  if (document.readyState !== 'loading') {
-    $a39a8553a97349a69bcc0255658c67ab$var$setupGlobalEvents();
-  } else {
-    document.addEventListener('DOMContentLoaded', $a39a8553a97349a69bcc0255658c67ab$var$setupGlobalEvents);
-  }
-}
-
-function runAfterTransition(fn) {
-  // Wait one frame to see if an animation starts, e.g. a transition on mount.
-  requestAnimationFrame(() => {
-    // If no transitions are running, call the function immediately.
-    // Otherwise, add it to a list of callbacks to run at the end of the animation.
-    if ($a39a8553a97349a69bcc0255658c67ab$var$transitionsByElement.size === 0) {
-      fn();
-    } else {
-      $a39a8553a97349a69bcc0255658c67ab$var$transitionCallbacks.add(fn);
+function $c04e92e3451996a2$var$restoreScrollPosition(scrollableElements) {
+    for (let { element: element , scrollTop: scrollTop , scrollLeft: scrollLeft  } of scrollableElements){
+        element.scrollTop = scrollTop;
+        element.scrollLeft = scrollLeft;
     }
-  });
 }
 
-exports.runAfterTransition = runAfterTransition;
-// Keep track of elements that we are currently handling dragging for via useDrag1D.
-// If there's an ancestor and a descendant both using useDrag1D(), and the user starts
-// dragging the descendant, we don't want useDrag1D events to fire for the ancestor.
-const $f9e3d2838685addd749dc9b533488cd5$var$draggingElements = []; // created for splitview, this should be reusable for things like sliders/dials
-// It also handles keyboard events on the target allowing for increment/decrement by a given stepsize as well as minifying/maximizing and toggling between minified and previous size
-// It can also take a 'reverse' param to say if we should measure from the right/bottom instead of the top/left
-// It can also handle either a vertical or horizontal movement, but not both at the same time
-
-function useDrag1D(props) {
-  console.warn('useDrag1D is deprecated, please use `useMove` instead https://react-spectrum.adobe.com/react-aria/useMove.html');
-  let {
-    containerRef,
-    reverse,
-    orientation,
-    onHover,
-    onDrag,
-    onPositionChange,
-    onIncrement,
-    onDecrement,
-    onIncrementToMax,
-    onDecrementToMin,
-    onCollapseToggle
-  } = props;
-
-  let getPosition = e => orientation === 'horizontal' ? e.clientX : e.clientY;
-
-  let getNextOffset = e => {
-    let containerOffset = getOffset(containerRef.current, reverse, orientation);
-    let mouseOffset = getPosition(e);
-    let nextOffset = reverse ? containerOffset - mouseOffset : mouseOffset - containerOffset;
-    return nextOffset;
-  };
-
-  let dragging = useRef(false);
-  let prevPosition = useRef(0); // Keep track of the current handlers in a ref so that the events can access them.
-
-  let handlers = useRef({
-    onPositionChange,
-    onDrag
-  });
-  handlers.current.onDrag = onDrag;
-  handlers.current.onPositionChange = onPositionChange;
-
-  let onMouseDragged = e => {
-    e.preventDefault();
-    let nextOffset = getNextOffset(e);
-
-    if (!dragging.current) {
-      dragging.current = true;
-
-      if (handlers.current.onDrag) {
-        handlers.current.onDrag(true);
-      }
-
-      if (handlers.current.onPositionChange) {
-        handlers.current.onPositionChange(nextOffset);
-      }
-    }
 
-    if (prevPosition.current === nextOffset) {
-      return;
-    }
+var $3c2f1aac5bde4425$exports = {};
 
-    prevPosition.current = nextOffset;
-
-    if (onPositionChange) {
-      onPositionChange(nextOffset);
-    }
-  };
+$parcel$export($3c2f1aac5bde4425$exports, "getOffset", () => $3c2f1aac5bde4425$export$622cea445a1c5b7d);
+function $3c2f1aac5bde4425$export$622cea445a1c5b7d(element, reverse, orientation = 'horizontal') {
+    let rect = element.getBoundingClientRect();
+    if (reverse) return orientation === 'horizontal' ? rect.right : rect.bottom;
+    return orientation === 'horizontal' ? rect.left : rect.top;
+}
 
-  let onMouseUp = e => {
-    const target = e.target;
-    dragging.current = false;
-    let nextOffset = getNextOffset(e);
 
-    if (handlers.current.onDrag) {
-      handlers.current.onDrag(false);
-    }
+var $ffdf7f150515ae1d$exports = {};
 
-    if (handlers.current.onPositionChange) {
-      handlers.current.onPositionChange(nextOffset);
-    }
+$parcel$export($ffdf7f150515ae1d$exports, "clamp", () => $4yb13$reactstatelyutils.clamp);
+$parcel$export($ffdf7f150515ae1d$exports, "snapValueToStep", () => $4yb13$reactstatelyutils.snapValueToStep);
 
-    $f9e3d2838685addd749dc9b533488cd5$var$draggingElements.splice($f9e3d2838685addd749dc9b533488cd5$var$draggingElements.indexOf(target), 1);
-    window.removeEventListener('mouseup', onMouseUp, false);
-    window.removeEventListener('mousemove', onMouseDragged, false);
-  };
 
-  let onMouseDown = e => {
-    const target = e.currentTarget; // If we're already handling dragging on a descendant with useDrag1D, then
-    // we don't want to handle the drag motion on this target as well.
 
-    if ($f9e3d2838685addd749dc9b533488cd5$var$draggingElements.some(elt => target.contains(elt))) {
-      return;
-    }
-
-    $f9e3d2838685addd749dc9b533488cd5$var$draggingElements.push(target);
-    window.addEventListener('mousemove', onMouseDragged, false);
-    window.addEventListener('mouseup', onMouseUp, false);
-  };
+var $77d877ca9d59887c$exports = {};
 
-  let onMouseEnter = () => {
-    if (onHover) {
-      onHover(true);
-    }
-  };
-
-  let onMouseOut = () => {
-    if (onHover) {
-      onHover(false);
-    }
-  };
-
-  let onKeyDown = e => {
-    switch (e.key) {
-      case 'Left':
-      case 'ArrowLeft':
-        if (orientation === 'horizontal') {
-          e.preventDefault();
-
-          if (onDecrement && !reverse) {
-            onDecrement();
-          } else if (onIncrement && reverse) {
-            onIncrement();
-          }
+$parcel$export($77d877ca9d59887c$exports, "runAfterTransition", () => $77d877ca9d59887c$export$24490316f764c430);
+/*
+ * 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.
+ */ // We store a global list of elements that are currently transitioning,
+// mapped to a set of CSS properties that are transitioning for that element.
+// This is necessary rather than a simple count of transitions because of browser
+// bugs, e.g. Chrome sometimes fires both transitionend and transitioncancel rather
+// than one or the other. So we need to track what's actually transitioning so that
+// we can ignore these duplicate events.
+let $77d877ca9d59887c$var$transitionsByElement = new Map();
+// A list of callbacks to call once there are no transitioning elements.
+let $77d877ca9d59887c$var$transitionCallbacks = new Set();
+function $77d877ca9d59887c$var$setupGlobalEvents() {
+    if (typeof window === 'undefined') return;
+    let onTransitionStart = (e)=>{
+        // Add the transitioning property to the list for this element.
+        let transitions = $77d877ca9d59887c$var$transitionsByElement.get(e.target);
+        if (!transitions) {
+            transitions = new Set();
+            $77d877ca9d59887c$var$transitionsByElement.set(e.target, transitions);
+            // The transitioncancel event must be registered on the element itself, rather than as a global
+            // event. This enables us to handle when the node is deleted from the document while it is transitioning.
+            // In that case, the cancel event would have nowhere to bubble to so we need to handle it directly.
+            e.target.addEventListener('transitioncancel', onTransitionEnd);
         }
-
-        break;
-
-      case 'Up':
-      case 'ArrowUp':
-        if (orientation === 'vertical') {
-          e.preventDefault();
-
-          if (onDecrement && !reverse) {
-            onDecrement();
-          } else if (onIncrement && reverse) {
-            onIncrement();
-          }
+        transitions.add(e.propertyName);
+    };
+    let onTransitionEnd = (e)=>{
+        // Remove property from list of transitioning properties.
+        let properties = $77d877ca9d59887c$var$transitionsByElement.get(e.target);
+        if (!properties) return;
+        properties.delete(e.propertyName);
+        // If empty, remove transitioncancel event, and remove the element from the list of transitioning elements.
+        if (properties.size === 0) {
+            e.target.removeEventListener('transitioncancel', onTransitionEnd);
+            $77d877ca9d59887c$var$transitionsByElement.delete(e.target);
         }
-
-        break;
-
-      case 'Right':
-      case 'ArrowRight':
-        if (orientation === 'horizontal') {
-          e.preventDefault();
-
-          if (onIncrement && !reverse) {
-            onIncrement();
-          } else if (onDecrement && reverse) {
-            onDecrement();
-          }
+        // If no transitioning elements, call all of the queued callbacks.
+        if ($77d877ca9d59887c$var$transitionsByElement.size === 0) {
+            for (let cb of $77d877ca9d59887c$var$transitionCallbacks)cb();
+            $77d877ca9d59887c$var$transitionCallbacks.clear();
         }
+    };
+    document.body.addEventListener('transitionrun', onTransitionStart);
+    document.body.addEventListener('transitionend', onTransitionEnd);
+}
+if (typeof document !== 'undefined') {
+    if (document.readyState !== 'loading') $77d877ca9d59887c$var$setupGlobalEvents();
+    else document.addEventListener('DOMContentLoaded', $77d877ca9d59887c$var$setupGlobalEvents);
+}
+function $77d877ca9d59887c$export$24490316f764c430(fn) {
+    // Wait one frame to see if an animation starts, e.g. a transition on mount.
+    requestAnimationFrame(()=>{
+        // If no transitions are running, call the function immediately.
+        // Otherwise, add it to a list of callbacks to run at the end of the animation.
+        if ($77d877ca9d59887c$var$transitionsByElement.size === 0) fn();
+        else $77d877ca9d59887c$var$transitionCallbacks.add(fn);
+    });
+}
 
-        break;
 
-      case 'Down':
-      case 'ArrowDown':
-        if (orientation === 'vertical') {
-          e.preventDefault();
+var $2c2c2dc0d37fb43b$exports = {};
 
-          if (onIncrement && !reverse) {
-            onIncrement();
-          } else if (onDecrement && reverse) {
-            onDecrement();
-          }
-        }
+$parcel$export($2c2c2dc0d37fb43b$exports, "useDrag1D", () => $2c2c2dc0d37fb43b$export$7bbed75feba39706);
 
-        break;
 
-      case 'Home':
+// Keep track of elements that we are currently handling dragging for via useDrag1D.
+// If there's an ancestor and a descendant both using useDrag1D(), and the user starts
+// dragging the descendant, we don't want useDrag1D events to fire for the ancestor.
+const $2c2c2dc0d37fb43b$var$draggingElements = [];
+function $2c2c2dc0d37fb43b$export$7bbed75feba39706(props) {
+    console.warn('useDrag1D is deprecated, please use `useMove` instead https://react-spectrum.adobe.com/react-aria/useMove.html');
+    let { containerRef: containerRef , reverse: reverse , orientation: orientation , onHover: onHover , onDrag: onDrag , onPositionChange: onPositionChange , onIncrement: onIncrement , onDecrement: onDecrement , onIncrementToMax: onIncrementToMax , onDecrementToMin: onDecrementToMin , onCollapseToggle: onCollapseToggle  } = props;
+    let getPosition = (e)=>orientation === 'horizontal' ? e.clientX : e.clientY
+    ;
+    let getNextOffset = (e)=>{
+        let containerOffset = $3c2f1aac5bde4425$export$622cea445a1c5b7d(containerRef.current, reverse, orientation);
+        let mouseOffset = getPosition(e);
+        let nextOffset = reverse ? containerOffset - mouseOffset : mouseOffset - containerOffset;
+        return nextOffset;
+    };
+    let dragging = $4yb13$react.useRef(false);
+    let prevPosition = $4yb13$react.useRef(0);
+    // Keep track of the current handlers in a ref so that the events can access them.
+    let handlers = $4yb13$react.useRef({
+        onPositionChange: onPositionChange,
+        onDrag: onDrag
+    });
+    handlers.current.onDrag = onDrag;
+    handlers.current.onPositionChange = onPositionChange;
+    let onMouseDragged = (e)=>{
         e.preventDefault();
-
-        if (onDecrementToMin) {
-          onDecrementToMin();
+        let nextOffset = getNextOffset(e);
+        if (!dragging.current) {
+            dragging.current = true;
+            if (handlers.current.onDrag) handlers.current.onDrag(true);
+            if (handlers.current.onPositionChange) handlers.current.onPositionChange(nextOffset);
         }
-
-        break;
-
-      case 'End':
-        e.preventDefault();
-
-        if (onIncrementToMax) {
-          onIncrementToMax();
+        if (prevPosition.current === nextOffset) return;
+        prevPosition.current = nextOffset;
+        if (onPositionChange) onPositionChange(nextOffset);
+    };
+    let onMouseUp = (e)=>{
+        const target = e.target;
+        dragging.current = false;
+        let nextOffset = getNextOffset(e);
+        if (handlers.current.onDrag) handlers.current.onDrag(false);
+        if (handlers.current.onPositionChange) handlers.current.onPositionChange(nextOffset);
+        $2c2c2dc0d37fb43b$var$draggingElements.splice($2c2c2dc0d37fb43b$var$draggingElements.indexOf(target), 1);
+        window.removeEventListener('mouseup', onMouseUp, false);
+        window.removeEventListener('mousemove', onMouseDragged, false);
+    };
+    let onMouseDown = (e)=>{
+        const target = e.currentTarget;
+        // If we're already handling dragging on a descendant with useDrag1D, then
+        // we don't want to handle the drag motion on this target as well.
+        if ($2c2c2dc0d37fb43b$var$draggingElements.some((elt)=>target.contains(elt)
+        )) return;
+        $2c2c2dc0d37fb43b$var$draggingElements.push(target);
+        window.addEventListener('mousemove', onMouseDragged, false);
+        window.addEventListener('mouseup', onMouseUp, false);
+    };
+    let onMouseEnter = ()=>{
+        if (onHover) onHover(true);
+    };
+    let onMouseOut = ()=>{
+        if (onHover) onHover(false);
+    };
+    let onKeyDown = (e)=>{
+        switch(e.key){
+            case 'Left':
+            case 'ArrowLeft':
+                if (orientation === 'horizontal') {
+                    e.preventDefault();
+                    if (onDecrement && !reverse) onDecrement();
+                    else if (onIncrement && reverse) onIncrement();
+                }
+                break;
+            case 'Up':
+            case 'ArrowUp':
+                if (orientation === 'vertical') {
+                    e.preventDefault();
+                    if (onDecrement && !reverse) onDecrement();
+                    else if (onIncrement && reverse) onIncrement();
+                }
+                break;
+            case 'Right':
+            case 'ArrowRight':
+                if (orientation === 'horizontal') {
+                    e.preventDefault();
+                    if (onIncrement && !reverse) onIncrement();
+                    else if (onDecrement && reverse) onDecrement();
+                }
+                break;
+            case 'Down':
+            case 'ArrowDown':
+                if (orientation === 'vertical') {
+                    e.preventDefault();
+                    if (onIncrement && !reverse) onIncrement();
+                    else if (onDecrement && reverse) onDecrement();
+                }
+                break;
+            case 'Home':
+                e.preventDefault();
+                if (onDecrementToMin) onDecrementToMin();
+                break;
+            case 'End':
+                e.preventDefault();
+                if (onIncrementToMax) onIncrementToMax();
+                break;
+            case 'Enter':
+                e.preventDefault();
+                if (onCollapseToggle) onCollapseToggle();
+                break;
         }
+    };
+    return {
+        onMouseDown: onMouseDown,
+        onMouseEnter: onMouseEnter,
+        onMouseOut: onMouseOut,
+        onKeyDown: onKeyDown
+    };
+}
 
-        break;
-
-      case 'Enter':
-        e.preventDefault();
 
-        if (onCollapseToggle) {
-          onCollapseToggle();
-        }
+var $63cc7c3704144db2$exports = {};
+
+$parcel$export($63cc7c3704144db2$exports, "useGlobalListeners", () => $63cc7c3704144db2$export$4eaf04e54aa8eed6);
+
+function $63cc7c3704144db2$export$4eaf04e54aa8eed6() {
+    let globalListeners = $4yb13$react.useRef(new Map());
+    let addGlobalListener = $4yb13$react.useCallback((eventTarget, type, listener, options)=>{
+        // Make sure we remove the listener after it is called with the `once` option.
+        let fn = (options === null || options === void 0 ? void 0 : options.once) ? (...args)=>{
+            globalListeners.current.delete(listener);
+            listener(...args);
+        } : listener;
+        globalListeners.current.set(listener, {
+            type: type,
+            eventTarget: eventTarget,
+            fn: fn,
+            options: options
+        });
+        eventTarget.addEventListener(type, listener, options);
+    }, []);
+    let removeGlobalListener = $4yb13$react.useCallback((eventTarget, type, listener, options)=>{
+        var ref;
+        let fn = ((ref = globalListeners.current.get(listener)) === null || ref === void 0 ? void 0 : ref.fn) || listener;
+        eventTarget.removeEventListener(type, fn, options);
+        globalListeners.current.delete(listener);
+    }, []);
+    let removeAllGlobalListeners = $4yb13$react.useCallback(()=>{
+        globalListeners.current.forEach((value, key)=>{
+            removeGlobalListener(value.eventTarget, value.type, key, value.options);
+        });
+    }, [
+        removeGlobalListener
+    ]);
+    // eslint-disable-next-line arrow-body-style
+    $4yb13$react.useEffect(()=>{
+        return removeAllGlobalListeners;
+    }, [
+        removeAllGlobalListeners
+    ]);
+    return {
+        addGlobalListener: addGlobalListener,
+        removeGlobalListener: removeGlobalListener,
+        removeAllGlobalListeners: removeAllGlobalListeners
+    };
+}
 
-        break;
-    }
-  };
 
-  return {
-    onMouseDown,
-    onMouseEnter,
-    onMouseOut,
-    onKeyDown
-  };
+var $65a536162b81d6f7$exports = {};
+
+$parcel$export($65a536162b81d6f7$exports, "useLabels", () => $65a536162b81d6f7$export$d6875122194c7b44);
+
+function $65a536162b81d6f7$export$d6875122194c7b44(props, defaultLabel) {
+    let { id: id , 'aria-label': label , 'aria-labelledby': labelledBy  } = props;
+    // If there is both an aria-label and aria-labelledby,
+    // combine them by pointing to the element itself.
+    id = $9cb40cfcb5f505fc$export$f680877a34711e37(id);
+    if (labelledBy && label) {
+        let ids = new Set([
+            ...labelledBy.trim().split(/\s+/),
+            id
+        ]);
+        labelledBy = [
+            ...ids
+        ].join(' ');
+    } else if (labelledBy) labelledBy = labelledBy.trim().split(/\s+/).join(' ');
+    // If no labels are provided, use the default
+    if (!label && !labelledBy && defaultLabel) label = defaultLabel;
+    return {
+        id: id,
+        'aria-label': label,
+        'aria-labelledby': labelledBy
+    };
 }
 
-exports.useDrag1D = useDrag1D;
 
-function useGlobalListeners() {
-  let globalListeners = useRef(new Map());
-  let addGlobalListener = useCallback((eventTarget, type, listener, options) => {
-    globalListeners.current.set(listener, {
-      type,
-      eventTarget,
-      options
-    });
-    eventTarget.addEventListener(type, listener, options);
-  }, []);
-  let removeGlobalListener = useCallback((eventTarget, type, listener, options) => {
-    eventTarget.removeEventListener(type, listener, options);
-    globalListeners.current.delete(listener);
-  }, []);
-  let removeAllGlobalListeners = useCallback(() => {
-    globalListeners.current.forEach((value, key) => {
-      removeGlobalListener(value.eventTarget, value.type, key, value.options);
-    });
-  }, [removeGlobalListener]);
-  useEffect(() => {
-    return removeAllGlobalListeners;
-  }, [removeAllGlobalListeners]);
-  return {
-    addGlobalListener,
-    removeGlobalListener,
-    removeAllGlobalListeners
-  };
-}
+var $64342c62277f2e75$exports = {};
 
-exports.useGlobalListeners = useGlobalListeners;
+$parcel$export($64342c62277f2e75$exports, "useObjectRef", () => $64342c62277f2e75$export$4338b53315abf666);
 
-/**
- * Merges aria-label and aria-labelledby into aria-labelledby when both exist.
- * @param props - Aria label props.
- * @param defaultLabel - Default value for aria-label when not present.
- */
-function useLabels(props, defaultLabel) {
-  let {
-    id,
-    'aria-label': label,
-    'aria-labelledby': labelledBy
-  } = props; // If there is both an aria-label and aria-labelledby,
-  // combine them by pointing to the element itself.
 
-  id = useId(id);
+function $64342c62277f2e75$export$4338b53315abf666(forwardedRef) {
+    const objRef = $4yb13$react.useRef();
+    /**
+   * We're using `useLayoutEffect` here instead of `useEffect` because we want
+   * to make sure that the `ref` value is up to date before other places in the
+   * the execution cycle try to read it.
+   */ $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c(()=>{
+        if (!forwardedRef) return;
+        if (typeof forwardedRef === 'function') forwardedRef(objRef.current);
+        else forwardedRef.current = objRef.current;
+    }, [
+        forwardedRef
+    ]);
+    return objRef;
+}
 
-  if (labelledBy && label) {
-    let ids = new Set([...labelledBy.trim().split(/\s+/), id]);
-    labelledBy = [...ids].join(' ');
-  } else if (labelledBy) {
-    labelledBy = labelledBy.trim().split(/\s+/).join(' ');
-  } // If no labels are provided, use the default
 
+var $c836e78d22a1ec24$exports = {};
 
-  if (!label && !labelledBy && defaultLabel) {
-    label = defaultLabel;
-  }
+$parcel$export($c836e78d22a1ec24$exports, "useUpdateEffect", () => $c836e78d22a1ec24$export$496315a1608d9602);
 
-  return {
-    id,
-    'aria-label': label,
-    'aria-labelledby': labelledBy
-  };
+function $c836e78d22a1ec24$export$496315a1608d9602(effect, dependencies) {
+    const isInitialMount = $4yb13$react.useRef(true);
+    $4yb13$react.useEffect(()=>{
+        if (isInitialMount.current) isInitialMount.current = false;
+        else effect();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, dependencies);
 }
 
-exports.useLabels = useLabels;
 
-// Like useEffect, but only called for updates after the initial render.
-function useUpdateEffect(effect, dependencies) {
-  const isInitialMount = useRef(true);
-  useEffect(() => {
-    if (isInitialMount.current) {
-      isInitialMount.current = false;
-    } else {
-      effect();
-    } // eslint-disable-next-line react-hooks/exhaustive-deps
 
-  }, dependencies);
-}
+var $edd995a4953bc6e7$exports = {};
 
-exports.useUpdateEffect = useUpdateEffect;
+$parcel$export($edd995a4953bc6e7$exports, "useResizeObserver", () => $edd995a4953bc6e7$export$683480f191c0e3ea);
 
-function $f58f1969071f2661185e38312efabfc$var$hasResizeObserver() {
-  return typeof window.ResizeObserver !== 'undefined';
+function $edd995a4953bc6e7$var$hasResizeObserver() {
+    return typeof window.ResizeObserver !== 'undefined';
+}
+function $edd995a4953bc6e7$export$683480f191c0e3ea(options) {
+    const { ref: ref , onResize: onResize  } = options;
+    $4yb13$react.useEffect(()=>{
+        let element = ref === null || ref === void 0 ? void 0 : ref.current;
+        if (!element) return;
+        if (!$edd995a4953bc6e7$var$hasResizeObserver()) {
+            window.addEventListener('resize', onResize, false);
+            return ()=>{
+                window.removeEventListener('resize', onResize, false);
+            };
+        } else {
+            const resizeObserverInstance = new window.ResizeObserver((entries)=>{
+                if (!entries.length) return;
+                onResize();
+            });
+            resizeObserverInstance.observe(element);
+            return ()=>{
+                if (element) resizeObserverInstance.unobserve(element);
+            };
+        }
+    }, [
+        onResize,
+        ref
+    ]);
 }
 
-function useResizeObserver(options) {
-  const {
-    ref,
-    onResize
-  } = options;
-  useEffect(() => {
-    let element = ref == null ? void 0 : ref.current;
 
-    if (!element) {
-      return;
-    }
+var $301b497f58a86f18$exports = {};
 
-    if (!$f58f1969071f2661185e38312efabfc$var$hasResizeObserver()) {
-      window.addEventListener('resize', onResize, false);
-      return () => {
-        window.removeEventListener('resize', onResize, false);
-      };
-    } else {
-      const resizeObserverInstance = new window.ResizeObserver(entries => {
-        if (!entries.length) {
-          return;
-        }
+$parcel$export($301b497f58a86f18$exports, "useSyncRef", () => $301b497f58a86f18$export$4debdb1a3f0fa79e);
 
-        onResize();
-      });
-      resizeObserverInstance.observe(element);
-      return () => {
-        if (element) {
-          resizeObserverInstance.unobserve(element);
+function $301b497f58a86f18$export$4debdb1a3f0fa79e(context, ref) {
+    $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c(()=>{
+        if (context && context.ref && ref) {
+            context.ref.current = ref.current;
+            return ()=>{
+                context.ref.current = null;
+            };
         }
-      };
-    }
-  }, [onResize, ref]);
-}
-
-exports.useResizeObserver = useResizeObserver;
-
-// Syncs ref from context with ref passed to hook
-function useSyncRef(context, ref) {
-  useLayoutEffect(() => {
-    if (context && context.ref && ref) {
-      context.ref.current = ref.current;
-      return () => {
-        context.ref.current = null;
-      };
-    }
-  }, [context, ref]);
+    }, [
+        context,
+        ref
+    ]);
 }
 
-exports.useSyncRef = useSyncRef;
 
-function getScrollParent(node) {
-  while (node && !$e9be933e81f272fbb0513fcc706c7$var$isScrollable(node)) {
-    node = node.parentElement;
-  }
+var $28d5ee6fb7b9d3be$exports = {};
 
-  return node || document.scrollingElement || document.documentElement;
+$parcel$export($28d5ee6fb7b9d3be$exports, "getScrollParent", () => $28d5ee6fb7b9d3be$export$cfa2225e87938781);
+function $28d5ee6fb7b9d3be$export$cfa2225e87938781(node) {
+    while(node && !$28d5ee6fb7b9d3be$var$isScrollable(node))node = node.parentElement;
+    return node || document.scrollingElement || document.documentElement;
 }
-
-exports.getScrollParent = getScrollParent;
-
-function $e9be933e81f272fbb0513fcc706c7$var$isScrollable(node) {
-  let style = window.getComputedStyle(node);
-  return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+function $28d5ee6fb7b9d3be$var$isScrollable(node) {
+    let style = window.getComputedStyle(node);
+    return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
 }
 
-// @ts-ignore
-let $f1a92c0e19f2e1ad09851454bf93009$var$visualViewport = typeof window !== 'undefined' && window.visualViewport;
-
-function useViewportSize() {
-  let [size, setSize] = useState(() => $f1a92c0e19f2e1ad09851454bf93009$var$getViewportSize());
-  useEffect(() => {
-    // Use visualViewport api to track available height even on iOS virtual keyboard opening
-    let onResize = () => {
-      setSize(size => {
-        let newSize = $f1a92c0e19f2e1ad09851454bf93009$var$getViewportSize();
-
-        if (newSize.width === size.width && newSize.height === size.height) {
-          return size;
-        }
 
-        return newSize;
-      });
-    };
+var $74242139898ffa11$exports = {};
 
-    if (!$f1a92c0e19f2e1ad09851454bf93009$var$visualViewport) {
-      window.addEventListener('resize', onResize);
-    } else {
-      $f1a92c0e19f2e1ad09851454bf93009$var$visualViewport.addEventListener('resize', onResize);
-    }
+$parcel$export($74242139898ffa11$exports, "useViewportSize", () => $74242139898ffa11$export$d699905dd57c73ca);
 
-    return () => {
-      if (!$f1a92c0e19f2e1ad09851454bf93009$var$visualViewport) {
-        window.removeEventListener('resize', onResize);
-      } else {
-        $f1a92c0e19f2e1ad09851454bf93009$var$visualViewport.removeEventListener('resize', onResize);
-      }
+// @ts-ignore
+let $74242139898ffa11$var$visualViewport = typeof window !== 'undefined' && window.visualViewport;
+function $74242139898ffa11$export$d699905dd57c73ca() {
+    let [size1, setSize] = $4yb13$react.useState(()=>$74242139898ffa11$var$getViewportSize()
+    );
+    $4yb13$react.useEffect(()=>{
+        // Use visualViewport api to track available height even on iOS virtual keyboard opening
+        let onResize = ()=>{
+            setSize((size)=>{
+                let newSize = $74242139898ffa11$var$getViewportSize();
+                if (newSize.width === size.width && newSize.height === size.height) return size;
+                return newSize;
+            });
+        };
+        if (!$74242139898ffa11$var$visualViewport) window.addEventListener('resize', onResize);
+        else $74242139898ffa11$var$visualViewport.addEventListener('resize', onResize);
+        return ()=>{
+            if (!$74242139898ffa11$var$visualViewport) window.removeEventListener('resize', onResize);
+            else $74242139898ffa11$var$visualViewport.removeEventListener('resize', onResize);
+        };
+    }, []);
+    return size1;
+}
+function $74242139898ffa11$var$getViewportSize() {
+    return {
+        width: ($74242139898ffa11$var$visualViewport === null || $74242139898ffa11$var$visualViewport === void 0 ? void 0 : $74242139898ffa11$var$visualViewport.width) || window.innerWidth,
+        height: ($74242139898ffa11$var$visualViewport === null || $74242139898ffa11$var$visualViewport === void 0 ? void 0 : $74242139898ffa11$var$visualViewport.height) || window.innerHeight
     };
-  }, []);
-  return size;
 }
 
-exports.useViewportSize = useViewportSize;
 
-function $f1a92c0e19f2e1ad09851454bf93009$var$getViewportSize() {
-  return {
-    width: ($f1a92c0e19f2e1ad09851454bf93009$var$visualViewport == null ? void 0 : $f1a92c0e19f2e1ad09851454bf93009$var$visualViewport.width) || window.innerWidth,
-    height: ($f1a92c0e19f2e1ad09851454bf93009$var$visualViewport == null ? void 0 : $f1a92c0e19f2e1ad09851454bf93009$var$visualViewport.height) || window.innerHeight
-  };
+var $f09914ec3e240844$exports = {};
+
+$parcel$export($f09914ec3e240844$exports, "useDescription", () => $f09914ec3e240844$export$f8aeda7b10753fa1);
+
+
+let $f09914ec3e240844$var$descriptionId = 0;
+const $f09914ec3e240844$var$descriptionNodes = new Map();
+function $f09914ec3e240844$export$f8aeda7b10753fa1(description) {
+    let [id1, setId] = $4yb13$react.useState(null);
+    $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c(()=>{
+        if (!description) return;
+        let desc = $f09914ec3e240844$var$descriptionNodes.get(description);
+        if (!desc) {
+            let id = `react-aria-description-${$f09914ec3e240844$var$descriptionId++}`;
+            setId(id);
+            let node = document.createElement('div');
+            node.id = id;
+            node.style.display = 'none';
+            node.textContent = description;
+            document.body.appendChild(node);
+            desc = {
+                refCount: 0,
+                element: node
+            };
+            $f09914ec3e240844$var$descriptionNodes.set(description, desc);
+        } else setId(desc.element.id);
+        desc.refCount++;
+        return ()=>{
+            if (--desc.refCount === 0) {
+                desc.element.remove();
+                $f09914ec3e240844$var$descriptionNodes.delete(description);
+            }
+        };
+    }, [
+        description
+    ]);
+    return {
+        'aria-describedby': description ? id1 : undefined
+    };
 }
 
-let $bd5928122fc632cc7302c36df9f$var$descriptionId = 0;
-const $bd5928122fc632cc7302c36df9f$var$descriptionNodes = new Map();
-
-function useDescription(description) {
-  let [id, setId] = useState(null);
 
-  _useLayoutEffect(() => {
-    if (!description) {
-      return;
-    }
-
-    let desc = $bd5928122fc632cc7302c36df9f$var$descriptionNodes.get(description);
-
-    if (!desc) {
-      let id = "react-aria-description-" + $bd5928122fc632cc7302c36df9f$var$descriptionId++;
-      setId(id);
-      let node = document.createElement('div');
-      node.id = id;
-      node.style.display = 'none';
-      node.textContent = description;
-      document.body.appendChild(node);
-      desc = {
-        refCount: 0,
-        element: node
-      };
-      $bd5928122fc632cc7302c36df9f$var$descriptionNodes.set(description, desc);
-    } else {
-      setId(desc.element.id);
-    }
+var $a24e8d2bd0f1fa11$exports = {};
 
-    desc.refCount++;
-    return () => {
-      if (--desc.refCount === 0) {
-        desc.element.remove();
-        $bd5928122fc632cc7302c36df9f$var$descriptionNodes.delete(description);
-      }
-    };
-  }, [description]);
-
-  return {
-    'aria-describedby': description ? id : undefined
-  };
+$parcel$export($a24e8d2bd0f1fa11$exports, "isMac", () => $a24e8d2bd0f1fa11$export$9ac100e40613ea10);
+$parcel$export($a24e8d2bd0f1fa11$exports, "isIPhone", () => $a24e8d2bd0f1fa11$export$186c6964ca17d99);
+$parcel$export($a24e8d2bd0f1fa11$exports, "isIPad", () => $a24e8d2bd0f1fa11$export$7bef049ce92e4224);
+$parcel$export($a24e8d2bd0f1fa11$exports, "isIOS", () => $a24e8d2bd0f1fa11$export$fedb369cb70207f1);
+$parcel$export($a24e8d2bd0f1fa11$exports, "isAppleDevice", () => $a24e8d2bd0f1fa11$export$e1865c3bedcd822b);
+$parcel$export($a24e8d2bd0f1fa11$exports, "isWebKit", () => $a24e8d2bd0f1fa11$export$78551043582a6a98);
+$parcel$export($a24e8d2bd0f1fa11$exports, "isChrome", () => $a24e8d2bd0f1fa11$export$6446a186d09e379e);
+$parcel$export($a24e8d2bd0f1fa11$exports, "isAndroid", () => $a24e8d2bd0f1fa11$export$a11b0059900ceec8);
+/*
+ * 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 $a24e8d2bd0f1fa11$var$testUserAgent(re) {
+    return typeof window !== 'undefined' && window.navigator != null ? re.test(window.navigator.userAgent) : false;
 }
-
-exports.useDescription = useDescription;
-
-function $ffc9ede5fda79bf280c1bec834e32f$var$testUserAgent(re) {
-  return typeof window !== 'undefined' && window.navigator != null ? re.test(window.navigator.userAgent) : false;
+function $a24e8d2bd0f1fa11$var$testPlatform(re) {
+    return typeof window !== 'undefined' && window.navigator != null ? re.test(window.navigator.platform) : false;
 }
-
-function $ffc9ede5fda79bf280c1bec834e32f$var$testPlatform(re) {
-  return typeof window !== 'undefined' && window.navigator != null ? re.test(window.navigator.platform) : false;
+function $a24e8d2bd0f1fa11$export$9ac100e40613ea10() {
+    return $a24e8d2bd0f1fa11$var$testPlatform(/^Mac/);
 }
-
-function isMac() {
-  return $ffc9ede5fda79bf280c1bec834e32f$var$testPlatform(/^Mac/);
+function $a24e8d2bd0f1fa11$export$186c6964ca17d99() {
+    return $a24e8d2bd0f1fa11$var$testPlatform(/^iPhone/);
 }
-
-exports.isMac = isMac;
-
-function isIPhone() {
-  return $ffc9ede5fda79bf280c1bec834e32f$var$testPlatform(/^iPhone/);
+function $a24e8d2bd0f1fa11$export$7bef049ce92e4224() {
+    return $a24e8d2bd0f1fa11$var$testPlatform(/^iPad/) || $a24e8d2bd0f1fa11$export$9ac100e40613ea10() && navigator.maxTouchPoints > 1;
 }
-
-exports.isIPhone = isIPhone;
-
-function isIPad() {
-  return $ffc9ede5fda79bf280c1bec834e32f$var$testPlatform(/^iPad/) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
-  isMac() && navigator.maxTouchPoints > 1;
+function $a24e8d2bd0f1fa11$export$fedb369cb70207f1() {
+    return $a24e8d2bd0f1fa11$export$186c6964ca17d99() || $a24e8d2bd0f1fa11$export$7bef049ce92e4224();
 }
-
-exports.isIPad = isIPad;
-
-function isIOS() {
-  return isIPhone() || isIPad();
+function $a24e8d2bd0f1fa11$export$e1865c3bedcd822b() {
+    return $a24e8d2bd0f1fa11$export$9ac100e40613ea10() || $a24e8d2bd0f1fa11$export$fedb369cb70207f1();
 }
-
-exports.isIOS = isIOS;
-
-function isAppleDevice() {
-  return isMac() || isIOS();
+function $a24e8d2bd0f1fa11$export$78551043582a6a98() {
+    return $a24e8d2bd0f1fa11$var$testUserAgent(/AppleWebKit/) && !$a24e8d2bd0f1fa11$export$6446a186d09e379e();
 }
-
-exports.isAppleDevice = isAppleDevice;
-
-function isWebKit() {
-  return $ffc9ede5fda79bf280c1bec834e32f$var$testUserAgent(/AppleWebKit/) && !isChrome();
+function $a24e8d2bd0f1fa11$export$6446a186d09e379e() {
+    return $a24e8d2bd0f1fa11$var$testUserAgent(/Chrome/);
+}
+function $a24e8d2bd0f1fa11$export$a11b0059900ceec8() {
+    return $a24e8d2bd0f1fa11$var$testUserAgent(/Android/);
 }
 
-exports.isWebKit = isWebKit;
 
-function isChrome() {
-  return $ffc9ede5fda79bf280c1bec834e32f$var$testUserAgent(/Chrome/);
-}
+var $dd92848a7fc64973$exports = {};
 
-exports.isChrome = isChrome;
+$parcel$export($dd92848a7fc64973$exports, "useEvent", () => $dd92848a7fc64973$export$90fc3a17d93f704c);
 
-function isAndroid() {
-  return $ffc9ede5fda79bf280c1bec834e32f$var$testUserAgent(/Android/);
+function $dd92848a7fc64973$export$90fc3a17d93f704c(ref, event, handler1, options) {
+    let handlerRef = $4yb13$react.useRef(handler1);
+    handlerRef.current = handler1;
+    let isDisabled = handler1 == null;
+    $4yb13$react.useEffect(()=>{
+        if (isDisabled) return;
+        let element = ref.current;
+        let handler = (e)=>handlerRef.current.call(this, e)
+        ;
+        element.addEventListener(event, handler, options);
+        return ()=>{
+            element.removeEventListener(event, handler, options);
+        };
+    }, [
+        ref,
+        event,
+        options,
+        isDisabled
+    ]);
 }
 
-exports.isAndroid = isAndroid;
 
-function useEvent(ref, event, handler, options) {
-  let handlerRef = useRef(handler);
-  handlerRef.current = handler;
-  let isDisabled = handler == null;
-  useEffect(() => {
-    if (isDisabled) {
-      return;
-    }
+var $c9669ae44cabacb1$exports = {};
 
-    let element = ref.current;
+$parcel$export($c9669ae44cabacb1$exports, "useValueEffect", () => $c9669ae44cabacb1$export$14d238f342723f25);
 
-    let handler = e => handlerRef.current.call(this, e);
 
-    element.addEventListener(event, handler, options);
-    return () => {
-      element.removeEventListener(event, handler, options);
+function $c9669ae44cabacb1$export$14d238f342723f25(defaultValue) {
+    let [value, setValue] = $4yb13$react.useState(defaultValue);
+    let valueRef = $4yb13$react.useRef(value);
+    let effect = $4yb13$react.useRef(null);
+    valueRef.current = value;
+    // Store the function in a ref so we can always access the current version
+    // which has the proper `value` in scope.
+    let nextRef = $4yb13$react.useRef(null);
+    nextRef.current = ()=>{
+        // Run the generator to the next yield.
+        let newValue = effect.current.next();
+        // If the generator is done, reset the effect.
+        if (newValue.done) {
+            effect.current = null;
+            return;
+        }
+        // If the value is the same as the current value,
+        // then continue to the next yield. Otherwise,
+        // set the value in state and wait for the next layout effect.
+        if (value === newValue.value) nextRef.current();
+        else setValue(newValue.value);
     };
-  }, [ref, event, options, isDisabled]);
+    $0f45c9b5be6ae2e8$export$e5c5a5f917a5871c(()=>{
+        // If there is an effect currently running, continue to the next yield.
+        if (effect.current) nextRef.current();
+    });
+    let queue = $4yb13$react.useCallback((fn)=>{
+        effect.current = fn(valueRef.current);
+        nextRef.current();
+    }, [
+        effect,
+        nextRef
+    ]);
+    return [
+        value,
+        queue
+    ];
+}
+
+
+var $bd4c92bf9c1b9da2$exports = {};
+
+$parcel$export($bd4c92bf9c1b9da2$exports, "scrollIntoView", () => $bd4c92bf9c1b9da2$export$53a0910f038337bd);
+function $bd4c92bf9c1b9da2$export$53a0910f038337bd(scrollView, element) {
+    let offsetX = $bd4c92bf9c1b9da2$var$relativeOffset(scrollView, element, 'left');
+    let offsetY = $bd4c92bf9c1b9da2$var$relativeOffset(scrollView, element, 'top');
+    let width = element.offsetWidth;
+    let height = element.offsetHeight;
+    let x = scrollView.scrollLeft;
+    let y = scrollView.scrollTop;
+    let maxX = x + scrollView.offsetWidth;
+    let maxY = y + scrollView.offsetHeight;
+    if (offsetX <= x) x = offsetX;
+    else if (offsetX + width > maxX) x += offsetX + width - maxX;
+    if (offsetY <= y) y = offsetY;
+    else if (offsetY + height > maxY) y += offsetY + height - maxY;
+    scrollView.scrollLeft = x;
+    scrollView.scrollTop = y;
 }
+/**
+ * Computes the offset left or top from child to ancestor by accumulating
+ * offsetLeft or offsetTop through intervening offsetParents.
+ */ function $bd4c92bf9c1b9da2$var$relativeOffset(ancestor, child, axis) {
+    const prop = axis === 'left' ? 'offsetLeft' : 'offsetTop';
+    let sum = 0;
+    while(child.offsetParent){
+        sum += child[prop];
+        if (child.offsetParent === ancestor) break;
+        else if (child.offsetParent.contains(ancestor)) {
+            // If the ancestor is not `position:relative`, then we stop at
+            // _its_ offset parent, and we subtract off _its_ offset, so that
+            // we end up with the proper offset from child to ancestor.
+            sum -= ancestor[prop];
+            break;
+        }
+        child = child.offsetParent;
+    }
+    return sum;
+}
+
+
+$parcel$exportWildcard(module.exports, $9cb40cfcb5f505fc$exports);
+$parcel$exportWildcard(module.exports, $c8b46e09042b5ebf$exports);
+$parcel$exportWildcard(module.exports, $f8671bdf1f2f88a8$exports);
+$parcel$exportWildcard(module.exports, $0848bd72487fb188$exports);
+$parcel$exportWildcard(module.exports, $c04e92e3451996a2$exports);
+$parcel$exportWildcard(module.exports, $3c2f1aac5bde4425$exports);
+$parcel$exportWildcard(module.exports, $ffdf7f150515ae1d$exports);
+$parcel$exportWildcard(module.exports, $77d877ca9d59887c$exports);
+$parcel$exportWildcard(module.exports, $2c2c2dc0d37fb43b$exports);
+$parcel$exportWildcard(module.exports, $63cc7c3704144db2$exports);
+$parcel$exportWildcard(module.exports, $65a536162b81d6f7$exports);
+$parcel$exportWildcard(module.exports, $64342c62277f2e75$exports);
+$parcel$exportWildcard(module.exports, $c836e78d22a1ec24$exports);
+$parcel$exportWildcard(module.exports, $0f45c9b5be6ae2e8$exports);
+$parcel$exportWildcard(module.exports, $edd995a4953bc6e7$exports);
+$parcel$exportWildcard(module.exports, $301b497f58a86f18$exports);
+$parcel$exportWildcard(module.exports, $28d5ee6fb7b9d3be$exports);
+$parcel$exportWildcard(module.exports, $74242139898ffa11$exports);
+$parcel$exportWildcard(module.exports, $f09914ec3e240844$exports);
+$parcel$exportWildcard(module.exports, $a24e8d2bd0f1fa11$exports);
+$parcel$exportWildcard(module.exports, $dd92848a7fc64973$exports);
+$parcel$exportWildcard(module.exports, $c9669ae44cabacb1$exports);
+$parcel$exportWildcard(module.exports, $bd4c92bf9c1b9da2$exports);
+
 
-exports.useEvent = useEvent;
 //# sourceMappingURL=main.js.map