@redsift/dashboard 6.1.0-alpha.0

package/index.js

@@ -0,0 +1,4832 @@
+import React, { forwardRef, useRef, useReducer, useMemo, useContext, useState, useLayoutEffect, useCallback, useEffect, useId } from 'react';
+import crossfilter from 'crossfilter2';
+import { DataGrid as DataGrid$1 } from '@redsift/table';
+import { redrawAll, config, rowChart, filterAll, pieChart } from 'dc';
+import 'd3-shape';
+import { scheme, successDangerScheme, neutral, PieChartLabelVariant, PieChartSize, PieChartTheme, PieChartVariant, StyledPieChartTitle, StyledPieChartCenterText, StyledPieChartLabel, StyledPieChartCaption } from '@redsift/charts';
+export { PieChartLabelVariant, PieChartSize, PieChartTheme, PieChartVariant } from '@redsift/charts';
+import styled, { css } from 'styled-components';
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+
+var classnames = {exports: {}};
+
+/*!
+  Copyright (c) 2018 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/classnames
+*/
+
+(function (module) {
+	/* global define */
+
+	(function () {
+
+		var hasOwn = {}.hasOwnProperty;
+
+		function classNames() {
+			var classes = [];
+
+			for (var i = 0; i < arguments.length; i++) {
+				var arg = arguments[i];
+				if (!arg) continue;
+
+				var argType = typeof arg;
+
+				if (argType === 'string' || argType === 'number') {
+					classes.push(arg);
+				} else if (Array.isArray(arg)) {
+					if (arg.length) {
+						var inner = classNames.apply(null, arg);
+						if (inner) {
+							classes.push(inner);
+						}
+					}
+				} else if (argType === 'object') {
+					if (arg.toString === Object.prototype.toString) {
+						for (var key in arg) {
+							if (hasOwn.call(arg, key) && arg[key]) {
+								classes.push(key);
+							}
+						}
+					} else {
+						classes.push(arg.toString());
+					}
+				}
+			}
+
+			return classes.join(' ');
+		}
+
+		if (module.exports) {
+			classNames.default = classNames;
+			module.exports = classNames;
+		} else {
+			window.classNames = classNames;
+		}
+	}());
+} (classnames));
+
+var classNames = classnames.exports;
+
+const initialState = {
+  tableFilters: []
+};
+const DashboardContext = /*#__PURE__*/React.createContext({
+  state: initialState
+});
+
+/**
+ * Context props.
+ */
+
+/**
+ * Reducer props.
+ */
+
+let DashboardReducerActionType;
+(function (DashboardReducerActionType) {
+  DashboardReducerActionType["FilterTable"] = "filter-table";
+  DashboardReducerActionType["FilterTableBatch"] = "filter-table-batch";
+})(DashboardReducerActionType || (DashboardReducerActionType = {}));
+
+const getFilter = (tableFilter, actionFilter) => {
+  return tableFilter.columnField === actionFilter.columnField && tableFilter.operatorValue === actionFilter.operatorValue;
+};
+const DashboardReducer = (state, action) => {
+  switch (action.type) {
+    case DashboardReducerActionType.FilterTable:
+      return _objectSpread2(_objectSpread2({}, state), {}, {
+        tableFilters: state.tableFilters.find(filter => getFilter(filter, action.filter)) ? state.tableFilters.map(filter => getFilter(filter, action.filter) ? action.filter : filter) : [...state.tableFilters, action.filter]
+      });
+    case DashboardReducerActionType.FilterTableBatch:
+      return _objectSpread2(_objectSpread2({}, state), {}, {
+        tableFilters: action.filter
+      });
+  }
+};
+
+const _excluded$5 = ["children", "className", "data"];
+const COMPONENT_NAME$5 = 'RedSiftDashboard';
+const CLASSNAME$5 = 'redsift-dashboard-container';
+const DEFAULT_PROPS$4 = {};
+const Dashboard = /*#__PURE__*/forwardRef((props, ref) => {
+  const providerRef = ref || useRef();
+  const {
+      children,
+      className,
+      data
+    } = props,
+    forwardedProps = _objectWithoutProperties(props, _excluded$5);
+  const [state, dispatch] = useReducer(DashboardReducer, {
+    tableFilters: []
+  });
+  const value = useMemo(() => ({
+    state,
+    dispatch,
+    ndx: crossfilter(data),
+    data
+  }), [state, data]);
+  return /*#__PURE__*/React.createElement("div", _extends({}, forwardedProps, {
+    className: classNames(Dashboard.className, className),
+    ref: providerRef
+  }), /*#__PURE__*/React.createElement(DashboardContext.Provider, {
+    value: value
+  }, children));
+});
+Dashboard.className = CLASSNAME$5;
+Dashboard.defaultProps = DEFAULT_PROPS$4;
+Dashboard.displayName = COMPONENT_NAME$5;
+
+const _excluded$4 = ["rows"];
+const DataGrid = _ref => {
+  let {
+      rows
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded$4);
+  const {
+    state,
+    data,
+    dispatch
+  } = useContext(DashboardContext);
+  const {
+    tableFilters
+  } = state;
+  const updateChartFilters = filterModel => {
+    dispatch === null || dispatch === void 0 ? void 0 : dispatch({
+      type: DashboardReducerActionType.FilterTableBatch,
+      filter: filterModel.items
+    });
+  };
+  return /*#__PURE__*/React.createElement(DataGrid$1, _extends({
+    rows: data || rows || []
+  }, props, {
+    filterModel: {
+      items: tableFilters
+    },
+    onFilterModelChange: updateChartFilters
+  }));
+};
+
+function sum(values, valueof) {
+  let sum = 0;
+  if (valueof === undefined) {
+    for (let value of values) {
+      if (value = +value) {
+        sum += value;
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if (value = +valueof(value, ++index, values)) {
+        sum += value;
+      }
+    }
+  }
+  return sum;
+}
+
+class InternMap extends Map {
+  constructor(entries, key = keyof) {
+    super();
+    Object.defineProperties(this, {_intern: {value: new Map()}, _key: {value: key}});
+    if (entries != null) for (const [key, value] of entries) this.set(key, value);
+  }
+  get(key) {
+    return super.get(intern_get(this, key));
+  }
+  has(key) {
+    return super.has(intern_get(this, key));
+  }
+  set(key, value) {
+    return super.set(intern_set(this, key), value);
+  }
+  delete(key) {
+    return super.delete(intern_delete(this, key));
+  }
+}
+
+function intern_get({_intern, _key}, value) {
+  const key = _key(value);
+  return _intern.has(key) ? _intern.get(key) : value;
+}
+
+function intern_set({_intern, _key}, value) {
+  const key = _key(value);
+  if (_intern.has(key)) return _intern.get(key);
+  _intern.set(key, value);
+  return value;
+}
+
+function intern_delete({_intern, _key}, value) {
+  const key = _key(value);
+  if (_intern.has(key)) {
+    value = _intern.get(key);
+    _intern.delete(key);
+  }
+  return value;
+}
+
+function keyof(value) {
+  return value !== null && typeof value === "object" ? value.valueOf() : value;
+}
+
+function initRange(domain, range) {
+  switch (arguments.length) {
+    case 0: break;
+    case 1: this.range(domain); break;
+    default: this.range(range).domain(domain); break;
+  }
+  return this;
+}
+
+const implicit = Symbol("implicit");
+
+function ordinal() {
+  var index = new InternMap(),
+      domain = [],
+      range = [],
+      unknown = implicit;
+
+  function scale(d) {
+    let i = index.get(d);
+    if (i === undefined) {
+      if (unknown !== implicit) return unknown;
+      index.set(d, i = domain.push(d) - 1);
+    }
+    return range[i % range.length];
+  }
+
+  scale.domain = function(_) {
+    if (!arguments.length) return domain.slice();
+    domain = [], index = new InternMap();
+    for (const value of _) {
+      if (index.has(value)) continue;
+      index.set(value, domain.push(value) - 1);
+    }
+    return scale;
+  };
+
+  scale.range = function(_) {
+    return arguments.length ? (range = Array.from(_), scale) : range.slice();
+  };
+
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+
+  scale.copy = function() {
+    return ordinal(domain, range).unknown(unknown);
+  };
+
+  initRange.apply(scale, arguments);
+
+  return scale;
+}
+
+function Transform(k, x, y) {
+  this.k = k;
+  this.x = x;
+  this.y = y;
+}
+
+Transform.prototype = {
+  constructor: Transform,
+  scale: function(k) {
+    return k === 1 ? this : new Transform(this.k * k, this.x, this.y);
+  },
+  translate: function(x, y) {
+    return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y);
+  },
+  apply: function(point) {
+    return [point[0] * this.k + this.x, point[1] * this.k + this.y];
+  },
+  applyX: function(x) {
+    return x * this.k + this.x;
+  },
+  applyY: function(y) {
+    return y * this.k + this.y;
+  },
+  invert: function(location) {
+    return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];
+  },
+  invertX: function(x) {
+    return (x - this.x) / this.k;
+  },
+  invertY: function(y) {
+    return (y - this.y) / this.k;
+  },
+  rescaleX: function(x) {
+    return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x));
+  },
+  rescaleY: function(y) {
+    return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y));
+  },
+  toString: function() {
+    return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")";
+  }
+};
+
+new Transform(1, 0, 0);
+
+Transform.prototype;
+
+/** Component Type. */
+
+/**
+ * JS falsy values.
+ * (excluding `NaN` as it can't be distinguished from `number`)
+ */
+
+/** Get types of the values of a record. */
+
+/**
+ * Color palette.
+ */
+const ColorPalette = {
+  primary: 'primary',
+  secondary: 'secondary',
+  error: 'error',
+  warning: 'warning',
+  info: 'info',
+  success: 'success'
+};
+
+// Material Design Icons v7.0.96
+var mdiRefresh = "M17.65,6.35C16.2,4.9 14.21,4 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20C15.73,20 18.84,17.45 19.73,14H17.65C16.83,16.33 14.61,18 12,18A6,6 0 0,1 6,12A6,6 0 0,1 12,6C13.66,6 15.14,6.69 16.22,7.78L13,11H20V4L17.65,6.35Z";
+
+function $parcel$export$5(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $704cf1d3b684cc5c$exports = {};
+
+$parcel$export$5($704cf1d3b684cc5c$exports, "SSRProvider", () => $704cf1d3b684cc5c$export$9f8ac96af4b1b2ae);
+$parcel$export$5($704cf1d3b684cc5c$exports, "useSSRSafeId", () => $704cf1d3b684cc5c$export$619500959fc48b26);
+$parcel$export$5($704cf1d3b684cc5c$exports, "useIsSSR", () => $704cf1d3b684cc5c$export$535bd6ca7f90a273);
+
+// Default context value to use in case there is no SSRProvider. This is fine for
+// client-only apps. In order to support multiple copies of React Aria potentially
+// being on the page at once, the prefix is set to a random number. SSRProvider
+// will reset this to zero for consistency between server and client, so in the
+// SSR case multiple copies of React Aria is not supported.
+const $704cf1d3b684cc5c$var$defaultContext = {
+    prefix: String(Math.round(Math.random() * 10000000000)),
+    current: 0
+};
+const $704cf1d3b684cc5c$var$SSRContext = /*#__PURE__*/ React.createContext($704cf1d3b684cc5c$var$defaultContext);
+function $704cf1d3b684cc5c$export$9f8ac96af4b1b2ae(props) {
+    let cur = useContext($704cf1d3b684cc5c$var$SSRContext);
+    let value = useMemo(()=>({
+            // If this is the first SSRProvider, start with an empty string prefix, otherwise
+            // append and increment the counter.
+            prefix: cur === $704cf1d3b684cc5c$var$defaultContext ? '' : `${cur.prefix}-${++cur.current}`,
+            current: 0
+        })
+    , [
+        cur
+    ]);
+    return(/*#__PURE__*/ React.createElement($704cf1d3b684cc5c$var$SSRContext.Provider, {
+        value: value
+    }, props.children));
+}
+let $704cf1d3b684cc5c$var$canUseDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);
+function $704cf1d3b684cc5c$export$619500959fc48b26(defaultId) {
+    let ctx = useContext($704cf1d3b684cc5c$var$SSRContext);
+    // If we are rendering in a non-DOM environment, and there's no SSRProvider,
+    // provide a warning to hint to the developer to add one.
+    if (ctx === $704cf1d3b684cc5c$var$defaultContext && !$704cf1d3b684cc5c$var$canUseDOM) console.warn('When server rendering, you must wrap your application in an <SSRProvider> to ensure consistent ids are generated between the client and server.');
+    return useMemo(()=>defaultId || `react-aria${ctx.prefix}-${++ctx.current}`
+    , [
+        defaultId
+    ]);
+}
+function $704cf1d3b684cc5c$export$535bd6ca7f90a273() {
+    let cur = useContext($704cf1d3b684cc5c$var$SSRContext);
+    let isInSSRContext = cur !== $704cf1d3b684cc5c$var$defaultContext;
+    let [isSSR, setIsSSR] = useState(isInSSRContext);
+    // If on the client, and the component was initially server rendered,
+    // then schedule a layout effect to update the component after hydration.
+    if (typeof window !== 'undefined' && isInSSRContext) // This if statement technically breaks the rules of hooks, but is safe
+    // because the condition never changes after mounting.
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    useLayoutEffect(()=>{
+        setIsSSR(false);
+    }, []);
+    return isSSR;
+}
+
+function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e))for(t=0;t<e.length;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);else for(t in e)e[t]&&(n&&(n+=" "),n+=t);return n}function clsx(){for(var e,t,f=0,n="";f<arguments.length;)(e=arguments[f++])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
+
+function $parcel$export$4(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $458b0a5536c1a7cf$exports = {};
+
+$parcel$export$4($458b0a5536c1a7cf$exports, "useControlledState", () => $458b0a5536c1a7cf$export$40bfa8c7b0832715);
+
+function $458b0a5536c1a7cf$export$40bfa8c7b0832715(value1, defaultValue, onChange) {
+    let [stateValue, setStateValue] = useState(value1 || defaultValue);
+    let ref = useRef(value1 !== undefined);
+    let wasControlled = ref.current;
+    let isControlled = value1 !== undefined;
+    // Internal state reference for useCallback
+    let stateRef = useRef(stateValue);
+    if (wasControlled !== isControlled) console.warn(`WARN: A component changed from ${wasControlled ? 'controlled' : 'uncontrolled'} to ${isControlled ? 'controlled' : 'uncontrolled'}.`);
+    ref.current = isControlled;
+    let setValue = useCallback((value2, ...args)=>{
+        let onChangeCaller = (value, ...onChangeArgs)=>{
+            if (onChange) {
+                if (!Object.is(stateRef.current, value)) onChange(value, ...onChangeArgs);
+            }
+            if (!isControlled) stateRef.current = value;
+        };
+        if (typeof value2 === 'function') {
+            console.warn('We can not support a function callback. See Github Issues for details https://github.com/adobe/react-spectrum/issues/2320');
+            // this supports functional updates https://reactjs.org/docs/hooks-reference.html#functional-updates
+            // when someone using useControlledState calls setControlledState(myFunc)
+            // this will call our useState setState with a function as well which invokes myFunc and calls onChange with the value from myFunc
+            // if we're in an uncontrolled state, then we also return the value of myFunc which to setState looks as though it was just called with myFunc from the beginning
+            // otherwise we just return the controlled value, which won't cause a rerender because React knows to bail out when the value is the same
+            let updateFunction = (oldValue, ...functionArgs)=>{
+                let interceptedValue = value2(isControlled ? stateRef.current : oldValue, ...functionArgs);
+                onChangeCaller(interceptedValue, ...args);
+                if (!isControlled) return interceptedValue;
+                return oldValue;
+            };
+            setStateValue(updateFunction);
+        } else {
+            if (!isControlled) setStateValue(value2);
+            onChangeCaller(value2, ...args);
+        }
+    }, [
+        isControlled,
+        onChange
+    ]);
+    // If a controlled component's value prop changes, we need to update stateRef
+    if (isControlled) stateRef.current = value1;
+    else value1 = stateValue;
+    return [
+        value1,
+        setValue
+    ];
+}
+
+
+var $9446cca9a3875146$exports = {};
+
+$parcel$export$4($9446cca9a3875146$exports, "clamp", () => $9446cca9a3875146$export$7d15b64cf5a3a4c4);
+$parcel$export$4($9446cca9a3875146$exports, "snapValueToStep", () => $9446cca9a3875146$export$cb6e0bb50bc19463);
+$parcel$export$4($9446cca9a3875146$exports, "toFixedNumber", () => $9446cca9a3875146$export$b6268554fba451f);
+function $9446cca9a3875146$export$7d15b64cf5a3a4c4(value, min = -Infinity, max = Infinity) {
+    let newValue = Math.min(Math.max(value, min), max);
+    return newValue;
+}
+function $9446cca9a3875146$export$cb6e0bb50bc19463(value, min, max, step) {
+    let remainder = (value - (isNaN(min) ? 0 : min)) % step;
+    let snappedValue = Math.abs(remainder) * 2 >= step ? value + Math.sign(remainder) * (step - Math.abs(remainder)) : value - remainder;
+    if (!isNaN(min)) {
+        if (snappedValue < min) snappedValue = min;
+        else if (!isNaN(max) && snappedValue > max) snappedValue = min + Math.floor((max - min) / step) * step;
+    } else if (!isNaN(max) && snappedValue > max) snappedValue = Math.floor(max / step) * step;
+    // correct floating point behavior by rounding to step precision
+    let string = step.toString();
+    let index = string.indexOf('.');
+    let precision = index >= 0 ? string.length - index : 0;
+    if (precision > 0) {
+        let pow = Math.pow(10, precision);
+        snappedValue = Math.round(snappedValue * pow) / pow;
+    }
+    return snappedValue;
+}
+function $9446cca9a3875146$export$b6268554fba451f(value, digits, base = 10) {
+    const pow = Math.pow(base, digits);
+    return Math.round(value * pow) / pow;
+}
+
+function $parcel$export$3(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $bdb11010cef70236$exports = {};
+
+$parcel$export$3($bdb11010cef70236$exports, "useId", () => $bdb11010cef70236$export$f680877a34711e37);
+$parcel$export$3($bdb11010cef70236$exports, "mergeIds", () => $bdb11010cef70236$export$cd8c9cb68f842629);
+$parcel$export$3($bdb11010cef70236$exports, "useSlotId", () => $bdb11010cef70236$export$b4cc09c592e8fdb8);
+
+var $f0a04ccd8dbdd83b$exports = {};
+
+$parcel$export$3($f0a04ccd8dbdd83b$exports, "useLayoutEffect", () => $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c);
+
+const $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c = typeof window !== 'undefined' ? React.useLayoutEffect : ()=>{
+};
+
+
+
+
+let $bdb11010cef70236$var$idsUpdaterMap = new Map();
+function $bdb11010cef70236$export$f680877a34711e37(defaultId) {
+    let [value, setValue] = useState(defaultId);
+    let nextId = useRef(null);
+    let res = $704cf1d3b684cc5c$export$619500959fc48b26(value);
+    let updateValue = useCallback((val)=>{
+        nextId.current = val;
+    }, []);
+    $bdb11010cef70236$var$idsUpdaterMap.set(res, updateValue);
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        let r = res;
+        return ()=>{
+            $bdb11010cef70236$var$idsUpdaterMap.delete(r);
+        };
+    }, [
+        res
+    ]);
+    // This cannot cause an infinite loop because the ref is updated first.
+    // eslint-disable-next-line
+    useEffect(()=>{
+        let newId = nextId.current;
+        if (newId) {
+            nextId.current = null;
+            setValue(newId);
+        }
+    });
+    return res;
+}
+function $bdb11010cef70236$export$cd8c9cb68f842629(idA, idB) {
+    if (idA === idB) return idA;
+    let setIdA = $bdb11010cef70236$var$idsUpdaterMap.get(idA);
+    if (setIdA) {
+        setIdA(idB);
+        return idB;
+    }
+    let setIdB = $bdb11010cef70236$var$idsUpdaterMap.get(idB);
+    if (setIdB) {
+        setIdB(idA);
+        return idA;
+    }
+    return idB;
+}
+function $bdb11010cef70236$export$b4cc09c592e8fdb8(depArray = []) {
+    let id = $bdb11010cef70236$export$f680877a34711e37();
+    let [resolvedId, setResolvedId] = $1dbecbe27a04f9af$export$14d238f342723f25(id);
+    let updateId = useCallback(()=>{
+        setResolvedId(function*() {
+            yield id;
+            yield document.getElementById(id) ? id : null;
+        });
+    }, [
+        id,
+        setResolvedId
+    ]);
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(updateId, [
+        id,
+        updateId,
+        ...depArray
+    ]);
+    return resolvedId;
+}
+
+
+var $ff5963eb1fccf552$exports = {};
+
+$parcel$export$3($ff5963eb1fccf552$exports, "chain", () => $ff5963eb1fccf552$export$e08e3b67e392101e);
+function $ff5963eb1fccf552$export$e08e3b67e392101e(...callbacks) {
+    return (...args)=>{
+        for (let callback of callbacks)if (typeof callback === 'function') callback(...args);
+    };
+}
+
+
+var $3ef42575df84b30b$exports = {};
+
+$parcel$export$3($3ef42575df84b30b$exports, "mergeProps", () => $3ef42575df84b30b$export$9d1611c77c2fe928);
+
+
+
+function $3ef42575df84b30b$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] = $ff5963eb1fccf552$export$e08e3b67e392101e(a, b);
+            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 = $bdb11010cef70236$export$cd8c9cb68f842629(a, b);
+            else result[key] = b !== undefined ? b : a;
+        }
+    }
+    return result;
+}
+
+
+var $5dc95899b306f630$exports = {};
+
+$parcel$export$3($5dc95899b306f630$exports, "mergeRefs", () => $5dc95899b306f630$export$c9058316764c140e);
+function $5dc95899b306f630$export$c9058316764c140e(...refs) {
+    return (value)=>{
+        for (let ref of refs){
+            if (typeof ref === 'function') ref(value);
+            else if (ref != null) ref.current = value;
+        }
+    };
+}
+
+
+var $65484d02dcb7eb3e$exports = {};
+
+$parcel$export$3($65484d02dcb7eb3e$exports, "filterDOMProps", () => $65484d02dcb7eb3e$export$457c3d6518dd4c6f);
+const $65484d02dcb7eb3e$var$DOMPropNames = new Set([
+    'id'
+]);
+const $65484d02dcb7eb3e$var$labelablePropNames = new Set([
+    'aria-label',
+    'aria-labelledby',
+    'aria-describedby',
+    'aria-details'
+]);
+const $65484d02dcb7eb3e$var$propRe = /^(data-.*)$/;
+function $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, opts = {
+}) {
+    let { labelable: labelable , propNames: propNames  } = opts;
+    let filteredProps = {
+    };
+    for(const prop in props)if (Object.prototype.hasOwnProperty.call(props, prop) && ($65484d02dcb7eb3e$var$DOMPropNames.has(prop) || labelable && $65484d02dcb7eb3e$var$labelablePropNames.has(prop) || (propNames === null || propNames === void 0 ? void 0 : propNames.has(prop)) || $65484d02dcb7eb3e$var$propRe.test(prop))) filteredProps[prop] = props[prop];
+    return filteredProps;
+}
+
+
+var $7215afc6de606d6b$exports = {};
+
+$parcel$export$3($7215afc6de606d6b$exports, "focusWithoutScrolling", () => $7215afc6de606d6b$export$de79e2c695e052f3);
+function $7215afc6de606d6b$export$de79e2c695e052f3(element) {
+    if ($7215afc6de606d6b$var$supportsPreventScroll()) element.focus({
+        preventScroll: true
+    });
+    else {
+        let scrollableElements = $7215afc6de606d6b$var$getScrollableElements(element);
+        element.focus();
+        $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements);
+    }
+}
+let $7215afc6de606d6b$var$supportsPreventScrollCached = null;
+function $7215afc6de606d6b$var$supportsPreventScroll() {
+    if ($7215afc6de606d6b$var$supportsPreventScrollCached == null) {
+        $7215afc6de606d6b$var$supportsPreventScrollCached = false;
+        try {
+            var focusElem = document.createElement('div');
+            focusElem.focus({
+                get preventScroll () {
+                    $7215afc6de606d6b$var$supportsPreventScrollCached = true;
+                    return true;
+                }
+            });
+        } catch (e) {
+        // Ignore
+        }
+    }
+    return $7215afc6de606d6b$var$supportsPreventScrollCached;
+}
+function $7215afc6de606d6b$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;
+    }
+    if (rootScrollingElement instanceof HTMLElement) scrollableElements.push({
+        element: rootScrollingElement,
+        scrollTop: rootScrollingElement.scrollTop,
+        scrollLeft: rootScrollingElement.scrollLeft
+    });
+    return scrollableElements;
+}
+function $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements) {
+    for (let { element: element , scrollTop: scrollTop , scrollLeft: scrollLeft  } of scrollableElements){
+        element.scrollTop = scrollTop;
+        element.scrollLeft = scrollLeft;
+    }
+}
+
+
+var $ab71dadb03a6fb2e$exports = {};
+
+$parcel$export$3($ab71dadb03a6fb2e$exports, "getOffset", () => $ab71dadb03a6fb2e$export$622cea445a1c5b7d);
+function $ab71dadb03a6fb2e$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;
+}
+
+
+var $103b0e103f1b5952$exports = {};
+
+$parcel$export$3($103b0e103f1b5952$exports, "clamp", () => $9446cca9a3875146$export$7d15b64cf5a3a4c4);
+$parcel$export$3($103b0e103f1b5952$exports, "snapValueToStep", () => $9446cca9a3875146$export$cb6e0bb50bc19463);
+
+
+
+var $bbed8b41f857bcc0$exports = {};
+
+$parcel$export$3($bbed8b41f857bcc0$exports, "runAfterTransition", () => $bbed8b41f857bcc0$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 $bbed8b41f857bcc0$var$transitionsByElement = new Map();
+// A list of callbacks to call once there are no transitioning elements.
+let $bbed8b41f857bcc0$var$transitionCallbacks = new Set();
+function $bbed8b41f857bcc0$var$setupGlobalEvents() {
+    if (typeof window === 'undefined') return;
+    let onTransitionStart = (e)=>{
+        // Add the transitioning property to the list for this element.
+        let transitions = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+        if (!transitions) {
+            transitions = new Set();
+            $bbed8b41f857bcc0$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);
+        }
+        transitions.add(e.propertyName);
+    };
+    let onTransitionEnd = (e)=>{
+        // Remove property from list of transitioning properties.
+        let properties = $bbed8b41f857bcc0$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);
+            $bbed8b41f857bcc0$var$transitionsByElement.delete(e.target);
+        }
+        // If no transitioning elements, call all of the queued callbacks.
+        if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) {
+            for (let cb of $bbed8b41f857bcc0$var$transitionCallbacks)cb();
+            $bbed8b41f857bcc0$var$transitionCallbacks.clear();
+        }
+    };
+    document.body.addEventListener('transitionrun', onTransitionStart);
+    document.body.addEventListener('transitionend', onTransitionEnd);
+}
+if (typeof document !== 'undefined') {
+    if (document.readyState !== 'loading') $bbed8b41f857bcc0$var$setupGlobalEvents();
+    else document.addEventListener('DOMContentLoaded', $bbed8b41f857bcc0$var$setupGlobalEvents);
+}
+function $bbed8b41f857bcc0$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 ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) fn();
+        else $bbed8b41f857bcc0$var$transitionCallbacks.add(fn);
+    });
+}
+
+
+var $9cc09df9fd7676be$exports = {};
+
+$parcel$export$3($9cc09df9fd7676be$exports, "useDrag1D", () => $9cc09df9fd7676be$export$7bbed75feba39706);
+
+
+// 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 $9cc09df9fd7676be$var$draggingElements = [];
+function $9cc09df9fd7676be$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 = $ab71dadb03a6fb2e$export$622cea445a1c5b7d(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: onPositionChange,
+        onDrag: 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;
+        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);
+        $9cc09df9fd7676be$var$draggingElements.splice($9cc09df9fd7676be$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 ($9cc09df9fd7676be$var$draggingElements.some((elt)=>target.contains(elt)
+        )) return;
+        $9cc09df9fd7676be$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
+    };
+}
+
+
+var $03deb23ff14920c4$exports = {};
+
+$parcel$export$3($03deb23ff14920c4$exports, "useGlobalListeners", () => $03deb23ff14920c4$export$4eaf04e54aa8eed6);
+
+function $03deb23ff14920c4$export$4eaf04e54aa8eed6() {
+    let globalListeners = useRef(new Map());
+    let addGlobalListener = 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 = 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 = useCallback(()=>{
+        globalListeners.current.forEach((value, key)=>{
+            removeGlobalListener(value.eventTarget, value.type, key, value.options);
+        });
+    }, [
+        removeGlobalListener
+    ]);
+    // eslint-disable-next-line arrow-body-style
+    useEffect(()=>{
+        return removeAllGlobalListeners;
+    }, [
+        removeAllGlobalListeners
+    ]);
+    return {
+        addGlobalListener: addGlobalListener,
+        removeGlobalListener: removeGlobalListener,
+        removeAllGlobalListeners: removeAllGlobalListeners
+    };
+}
+
+
+var $313b98861ee5dd6c$exports = {};
+
+$parcel$export$3($313b98861ee5dd6c$exports, "useLabels", () => $313b98861ee5dd6c$export$d6875122194c7b44);
+
+function $313b98861ee5dd6c$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 = $bdb11010cef70236$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
+    };
+}
+
+
+var $df56164dff5785e2$exports = {};
+
+$parcel$export$3($df56164dff5785e2$exports, "useObjectRef", () => $df56164dff5785e2$export$4338b53315abf666);
+
+
+function $df56164dff5785e2$export$4338b53315abf666(forwardedRef) {
+    const objRef = 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.
+   */ $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        if (!forwardedRef) return;
+        if (typeof forwardedRef === 'function') forwardedRef(objRef.current);
+        else forwardedRef.current = objRef.current;
+    }, [
+        forwardedRef
+    ]);
+    return objRef;
+}
+
+
+var $4f58c5f72bcf79f7$exports = {};
+
+$parcel$export$3($4f58c5f72bcf79f7$exports, "useUpdateEffect", () => $4f58c5f72bcf79f7$export$496315a1608d9602);
+
+function $4f58c5f72bcf79f7$export$496315a1608d9602(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 $9daab02d461809db$exports = {};
+
+$parcel$export$3($9daab02d461809db$exports, "useResizeObserver", () => $9daab02d461809db$export$683480f191c0e3ea);
+
+function $9daab02d461809db$var$hasResizeObserver() {
+    return typeof window.ResizeObserver !== 'undefined';
+}
+function $9daab02d461809db$export$683480f191c0e3ea(options) {
+    const { ref: ref , onResize: onResize  } = options;
+    useEffect(()=>{
+        let element = ref === null || ref === void 0 ? void 0 : ref.current;
+        if (!element) return;
+        if (!$9daab02d461809db$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
+    ]);
+}
+
+
+var $e7801be82b4b2a53$exports = {};
+
+$parcel$export$3($e7801be82b4b2a53$exports, "useSyncRef", () => $e7801be82b4b2a53$export$4debdb1a3f0fa79e);
+
+function $e7801be82b4b2a53$export$4debdb1a3f0fa79e(context, ref) {
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        if (context && context.ref && ref) {
+            context.ref.current = ref.current;
+            return ()=>{
+                context.ref.current = null;
+            };
+        }
+    }, [
+        context,
+        ref
+    ]);
+}
+
+
+var $62d8ded9296f3872$exports = {};
+
+$parcel$export$3($62d8ded9296f3872$exports, "getScrollParent", () => $62d8ded9296f3872$export$cfa2225e87938781);
+function $62d8ded9296f3872$export$cfa2225e87938781(node) {
+    while(node && !$62d8ded9296f3872$var$isScrollable(node))node = node.parentElement;
+    return node || document.scrollingElement || document.documentElement;
+}
+function $62d8ded9296f3872$var$isScrollable(node) {
+    let style = window.getComputedStyle(node);
+    return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+}
+
+
+var $5df64b3807dc15ee$exports = {};
+
+$parcel$export$3($5df64b3807dc15ee$exports, "useViewportSize", () => $5df64b3807dc15ee$export$d699905dd57c73ca);
+
+// @ts-ignore
+let $5df64b3807dc15ee$var$visualViewport = typeof window !== 'undefined' && window.visualViewport;
+function $5df64b3807dc15ee$export$d699905dd57c73ca() {
+    let [size1, setSize] = useState(()=>$5df64b3807dc15ee$var$getViewportSize()
+    );
+    useEffect(()=>{
+        // Use visualViewport api to track available height even on iOS virtual keyboard opening
+        let onResize = ()=>{
+            setSize((size)=>{
+                let newSize = $5df64b3807dc15ee$var$getViewportSize();
+                if (newSize.width === size.width && newSize.height === size.height) return size;
+                return newSize;
+            });
+        };
+        if (!$5df64b3807dc15ee$var$visualViewport) window.addEventListener('resize', onResize);
+        else $5df64b3807dc15ee$var$visualViewport.addEventListener('resize', onResize);
+        return ()=>{
+            if (!$5df64b3807dc15ee$var$visualViewport) window.removeEventListener('resize', onResize);
+            else $5df64b3807dc15ee$var$visualViewport.removeEventListener('resize', onResize);
+        };
+    }, []);
+    return size1;
+}
+function $5df64b3807dc15ee$var$getViewportSize() {
+    return {
+        width: ($5df64b3807dc15ee$var$visualViewport === null || $5df64b3807dc15ee$var$visualViewport === void 0 ? void 0 : $5df64b3807dc15ee$var$visualViewport.width) || window.innerWidth,
+        height: ($5df64b3807dc15ee$var$visualViewport === null || $5df64b3807dc15ee$var$visualViewport === void 0 ? void 0 : $5df64b3807dc15ee$var$visualViewport.height) || window.innerHeight
+    };
+}
+
+
+var $ef06256079686ba0$exports = {};
+
+$parcel$export$3($ef06256079686ba0$exports, "useDescription", () => $ef06256079686ba0$export$f8aeda7b10753fa1);
+
+
+let $ef06256079686ba0$var$descriptionId = 0;
+const $ef06256079686ba0$var$descriptionNodes = new Map();
+function $ef06256079686ba0$export$f8aeda7b10753fa1(description) {
+    let [id1, setId] = useState(null);
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        if (!description) return;
+        let desc = $ef06256079686ba0$var$descriptionNodes.get(description);
+        if (!desc) {
+            let id = `react-aria-description-${$ef06256079686ba0$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
+            };
+            $ef06256079686ba0$var$descriptionNodes.set(description, desc);
+        } else setId(desc.element.id);
+        desc.refCount++;
+        return ()=>{
+            if (--desc.refCount === 0) {
+                desc.element.remove();
+                $ef06256079686ba0$var$descriptionNodes.delete(description);
+            }
+        };
+    }, [
+        description
+    ]);
+    return {
+        'aria-describedby': description ? id1 : undefined
+    };
+}
+
+
+var $c87311424ea30a05$exports = {};
+
+$parcel$export$3($c87311424ea30a05$exports, "isMac", () => $c87311424ea30a05$export$9ac100e40613ea10);
+$parcel$export$3($c87311424ea30a05$exports, "isIPhone", () => $c87311424ea30a05$export$186c6964ca17d99);
+$parcel$export$3($c87311424ea30a05$exports, "isIPad", () => $c87311424ea30a05$export$7bef049ce92e4224);
+$parcel$export$3($c87311424ea30a05$exports, "isIOS", () => $c87311424ea30a05$export$fedb369cb70207f1);
+$parcel$export$3($c87311424ea30a05$exports, "isAppleDevice", () => $c87311424ea30a05$export$e1865c3bedcd822b);
+$parcel$export$3($c87311424ea30a05$exports, "isWebKit", () => $c87311424ea30a05$export$78551043582a6a98);
+$parcel$export$3($c87311424ea30a05$exports, "isChrome", () => $c87311424ea30a05$export$6446a186d09e379e);
+$parcel$export$3($c87311424ea30a05$exports, "isAndroid", () => $c87311424ea30a05$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 $c87311424ea30a05$var$testUserAgent(re) {
+    var ref;
+    if (typeof window === 'undefined' || window.navigator == null) return false;
+    return ((ref = window.navigator['userAgentData']) === null || ref === void 0 ? void 0 : ref.brands.some((brand)=>re.test(brand.brand)
+    )) || re.test(window.navigator.userAgent);
+}
+function $c87311424ea30a05$var$testPlatform(re) {
+    return typeof window !== 'undefined' && window.navigator != null ? re.test((window.navigator['userAgentData'] || window.navigator).platform) : false;
+}
+function $c87311424ea30a05$export$9ac100e40613ea10() {
+    return $c87311424ea30a05$var$testPlatform(/^Mac/i);
+}
+function $c87311424ea30a05$export$186c6964ca17d99() {
+    return $c87311424ea30a05$var$testPlatform(/^iPhone/i);
+}
+function $c87311424ea30a05$export$7bef049ce92e4224() {
+    return $c87311424ea30a05$var$testPlatform(/^iPad/i) || $c87311424ea30a05$export$9ac100e40613ea10() && navigator.maxTouchPoints > 1;
+}
+function $c87311424ea30a05$export$fedb369cb70207f1() {
+    return $c87311424ea30a05$export$186c6964ca17d99() || $c87311424ea30a05$export$7bef049ce92e4224();
+}
+function $c87311424ea30a05$export$e1865c3bedcd822b() {
+    return $c87311424ea30a05$export$9ac100e40613ea10() || $c87311424ea30a05$export$fedb369cb70207f1();
+}
+function $c87311424ea30a05$export$78551043582a6a98() {
+    return $c87311424ea30a05$var$testUserAgent(/AppleWebKit/i) && !$c87311424ea30a05$export$6446a186d09e379e();
+}
+function $c87311424ea30a05$export$6446a186d09e379e() {
+    return $c87311424ea30a05$var$testUserAgent(/Chrome/i);
+}
+function $c87311424ea30a05$export$a11b0059900ceec8() {
+    return $c87311424ea30a05$var$testUserAgent(/Android/i);
+}
+
+
+var $e9faafb641e167db$exports = {};
+
+$parcel$export$3($e9faafb641e167db$exports, "useEvent", () => $e9faafb641e167db$export$90fc3a17d93f704c);
+
+function $e9faafb641e167db$export$90fc3a17d93f704c(ref, event, handler1, options) {
+    let handlerRef = useRef(handler1);
+    handlerRef.current = handler1;
+    let isDisabled = handler1 == null;
+    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
+    ]);
+}
+
+
+var $1dbecbe27a04f9af$exports = {};
+
+$parcel$export$3($1dbecbe27a04f9af$exports, "useValueEffect", () => $1dbecbe27a04f9af$export$14d238f342723f25);
+
+
+function $1dbecbe27a04f9af$export$14d238f342723f25(defaultValue) {
+    let [value, setValue] = useState(defaultValue);
+    let valueRef = useRef(value);
+    let effect = 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 = 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);
+    };
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        // If there is an effect currently running, continue to the next yield.
+        if (effect.current) nextRef.current();
+    });
+    let queue = useCallback((fn)=>{
+        effect.current = fn(valueRef.current);
+        nextRef.current();
+    }, [
+        effect,
+        nextRef
+    ]);
+    return [
+        value,
+        queue
+    ];
+}
+
+
+var $2f04cbc44ee30ce0$exports = {};
+
+$parcel$export$3($2f04cbc44ee30ce0$exports, "scrollIntoView", () => $2f04cbc44ee30ce0$export$53a0910f038337bd);
+function $2f04cbc44ee30ce0$export$53a0910f038337bd(scrollView, element) {
+    let offsetX = $2f04cbc44ee30ce0$var$relativeOffset(scrollView, element, 'left');
+    let offsetY = $2f04cbc44ee30ce0$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 $2f04cbc44ee30ce0$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;
+}
+
+function $parcel$export$2(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $3b117e43dc0ca95d$exports = {};
+
+$parcel$export$2($3b117e43dc0ca95d$exports, "Pressable", () => $3b117e43dc0ca95d$export$27c701ed9e449e99);
+
+var $f6c31cce2adf654f$exports = {};
+
+$parcel$export$2($f6c31cce2adf654f$exports, "usePress", () => $f6c31cce2adf654f$export$45712eceda6fad21);
+
+// Note that state only matters here for iOS. Non-iOS gets user-select: none applied to the target element
+// rather than at the document level so we just need to apply/remove user-select: none for each pressed element individually
+let $14c0b72509d70225$var$state = 'default';
+let $14c0b72509d70225$var$savedUserSelect = '';
+let $14c0b72509d70225$var$modifiedElementMap = new WeakMap();
+function $14c0b72509d70225$export$16a4697467175487(target) {
+    if ($c87311424ea30a05$export$fedb369cb70207f1()) {
+        if ($14c0b72509d70225$var$state === 'default') {
+            $14c0b72509d70225$var$savedUserSelect = document.documentElement.style.webkitUserSelect;
+            document.documentElement.style.webkitUserSelect = 'none';
+        }
+        $14c0b72509d70225$var$state = 'disabled';
+    } else if (target) {
+        // If not iOS, store the target's original user-select and change to user-select: none
+        // Ignore state since it doesn't apply for non iOS
+        $14c0b72509d70225$var$modifiedElementMap.set(target, target.style.userSelect);
+        target.style.userSelect = 'none';
+    }
+}
+function $14c0b72509d70225$export$b0d6fa1ab32e3295(target) {
+    if ($c87311424ea30a05$export$fedb369cb70207f1()) {
+        // If the state is already default, there's nothing to do.
+        // If it is restoring, then there's no need to queue a second restore.
+        if ($14c0b72509d70225$var$state !== 'disabled') return;
+        $14c0b72509d70225$var$state = 'restoring';
+        // There appears to be a delay on iOS where selection still might occur
+        // after pointer up, so wait a bit before removing user-select.
+        setTimeout(()=>{
+            // Wait for any CSS transitions to complete so we don't recompute style
+            // for the whole page in the middle of the animation and cause jank.
+            $bbed8b41f857bcc0$export$24490316f764c430(()=>{
+                // Avoid race conditions
+                if ($14c0b72509d70225$var$state === 'restoring') {
+                    if (document.documentElement.style.webkitUserSelect === 'none') document.documentElement.style.webkitUserSelect = $14c0b72509d70225$var$savedUserSelect || '';
+                    $14c0b72509d70225$var$savedUserSelect = '';
+                    $14c0b72509d70225$var$state = 'default';
+                }
+            });
+        }, 300);
+    } else // If not iOS, restore the target's original user-select if any
+    // Ignore state since it doesn't apply for non iOS
+    if (target && $14c0b72509d70225$var$modifiedElementMap.has(target)) {
+        let targetOldUserSelect = $14c0b72509d70225$var$modifiedElementMap.get(target);
+        if (target.style.userSelect === 'none') target.style.userSelect = targetOldUserSelect;
+        if (target.getAttribute('style') === '') target.removeAttribute('style');
+        $14c0b72509d70225$var$modifiedElementMap.delete(target);
+    }
+}
+
+
+
+
+
+
+function $8a9cb279dc87e130$export$60278871457622de(event) {
+    // JAWS/NVDA with Firefox.
+    if (event.mozInputSource === 0 && event.isTrusted) return true;
+    return event.detail === 0 && !event.pointerType;
+}
+class $8a9cb279dc87e130$export$905e7fc544a71f36 {
+    isDefaultPrevented() {
+        return this.nativeEvent.defaultPrevented;
+    }
+    preventDefault() {
+        this.defaultPrevented = true;
+        this.nativeEvent.preventDefault();
+    }
+    stopPropagation() {
+        this.nativeEvent.stopPropagation();
+        this.isPropagationStopped = ()=>true
+        ;
+    }
+    isPropagationStopped() {
+        return false;
+    }
+    persist() {
+    }
+    constructor(type, nativeEvent){
+        this.nativeEvent = nativeEvent;
+        this.target = nativeEvent.target;
+        this.currentTarget = nativeEvent.currentTarget;
+        this.relatedTarget = nativeEvent.relatedTarget;
+        this.bubbles = nativeEvent.bubbles;
+        this.cancelable = nativeEvent.cancelable;
+        this.defaultPrevented = nativeEvent.defaultPrevented;
+        this.eventPhase = nativeEvent.eventPhase;
+        this.isTrusted = nativeEvent.isTrusted;
+        this.timeStamp = nativeEvent.timeStamp;
+        this.type = type;
+    }
+}
+function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
+    let stateRef = useRef({
+        isFocused: false,
+        onBlur: onBlur,
+        observer: null
+    });
+    stateRef.current.onBlur = onBlur;
+    // Clean up MutationObserver on unmount. See below.
+    // eslint-disable-next-line arrow-body-style
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        const state = stateRef.current;
+        return ()=>{
+            if (state.observer) {
+                state.observer.disconnect();
+                state.observer = null;
+            }
+        };
+    }, []);
+    // This function is called during a React onFocus event.
+    return useCallback((e1)=>{
+        // React does not fire onBlur when an element is disabled. https://github.com/facebook/react/issues/9142
+        // Most browsers fire a native focusout event in this case, except for Firefox. In that case, we use a
+        // MutationObserver to watch for the disabled attribute, and dispatch these events ourselves.
+        // For browsers that do, focusout fires before the MutationObserver, so onBlur should not fire twice.
+        if (e1.target instanceof HTMLButtonElement || e1.target instanceof HTMLInputElement || e1.target instanceof HTMLTextAreaElement || e1.target instanceof HTMLSelectElement) {
+            stateRef.current.isFocused = true;
+            let target = e1.target;
+            let onBlurHandler = (e)=>{
+                var // For backward compatibility, dispatch a (fake) React synthetic event.
+                _current, ref;
+                stateRef.current.isFocused = false;
+                if (target.disabled) (ref = (_current = stateRef.current).onBlur) === null || ref === void 0 ? void 0 : ref.call(_current, new $8a9cb279dc87e130$export$905e7fc544a71f36('blur', e));
+                // We no longer need the MutationObserver once the target is blurred.
+                if (stateRef.current.observer) {
+                    stateRef.current.observer.disconnect();
+                    stateRef.current.observer = null;
+                }
+            };
+            target.addEventListener('focusout', onBlurHandler, {
+                once: true
+            });
+            stateRef.current.observer = new MutationObserver(()=>{
+                if (stateRef.current.isFocused && target.disabled) {
+                    stateRef.current.observer.disconnect();
+                    target.dispatchEvent(new FocusEvent('blur'));
+                    target.dispatchEvent(new FocusEvent('focusout', {
+                        bubbles: true
+                    }));
+                }
+            });
+            stateRef.current.observer.observe(target, {
+                attributes: true,
+                attributeFilter: [
+                    'disabled'
+                ]
+            });
+        }
+    }, []);
+}
+
+
+
+const $ae1eeba8b9eafd08$export$5165eccb35aaadb5 = React.createContext(null);
+$ae1eeba8b9eafd08$export$5165eccb35aaadb5.displayName = 'PressResponderContext';
+
+
+function $f6c31cce2adf654f$var$usePressResponderContext(props) {
+    // Consume context from <PressResponder> and merge with props.
+    let context = useContext($ae1eeba8b9eafd08$export$5165eccb35aaadb5);
+    if (context) {
+        let { register: register , ...contextProps } = context;
+        props = $3ef42575df84b30b$export$9d1611c77c2fe928(contextProps, props);
+        register();
+    }
+    $e7801be82b4b2a53$export$4debdb1a3f0fa79e(context, props.ref);
+    return props;
+}
+function $f6c31cce2adf654f$export$45712eceda6fad21(props) {
+    let { onPress: onPress1 , onPressChange: onPressChange1 , onPressStart: onPressStart1 , onPressEnd: onPressEnd1 , onPressUp: onPressUp1 , isDisabled: isDisabled1 , isPressed: isPressedProp , preventFocusOnPress: preventFocusOnPress , shouldCancelOnPointerExit: shouldCancelOnPointerExit , allowTextSelectionOnPress: allowTextSelectionOnPress , // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ref: _ , ...domProps } = $f6c31cce2adf654f$var$usePressResponderContext(props);
+    let propsRef = useRef(null);
+    propsRef.current = {
+        onPress: onPress1,
+        onPressChange: onPressChange1,
+        onPressStart: onPressStart1,
+        onPressEnd: onPressEnd1,
+        onPressUp: onPressUp1,
+        isDisabled: isDisabled1,
+        shouldCancelOnPointerExit: shouldCancelOnPointerExit
+    };
+    let [isPressed, setPressed] = useState(false);
+    let ref = useRef({
+        isPressed: false,
+        ignoreEmulatedMouseEvents: false,
+        ignoreClickAfterPress: false,
+        didFirePressStart: false,
+        activePointerId: null,
+        target: null,
+        isOverTarget: false,
+        pointerType: null
+    });
+    let { addGlobalListener: addGlobalListener , removeAllGlobalListeners: removeAllGlobalListeners  } = $03deb23ff14920c4$export$4eaf04e54aa8eed6();
+    let pressProps1 = useMemo(()=>{
+        let state = ref.current;
+        let triggerPressStart = (originalEvent, pointerType)=>{
+            let { onPressStart: onPressStart , onPressChange: onPressChange , isDisabled: isDisabled  } = propsRef.current;
+            if (isDisabled || state.didFirePressStart) return;
+            if (onPressStart) onPressStart({
+                type: 'pressstart',
+                pointerType: pointerType,
+                target: originalEvent.currentTarget,
+                shiftKey: originalEvent.shiftKey,
+                metaKey: originalEvent.metaKey,
+                ctrlKey: originalEvent.ctrlKey,
+                altKey: originalEvent.altKey
+            });
+            if (onPressChange) onPressChange(true);
+            state.didFirePressStart = true;
+            setPressed(true);
+        };
+        let triggerPressEnd = (originalEvent, pointerType, wasPressed = true)=>{
+            let { onPressEnd: onPressEnd , onPressChange: onPressChange , onPress: onPress , isDisabled: isDisabled  } = propsRef.current;
+            if (!state.didFirePressStart) return;
+            state.ignoreClickAfterPress = true;
+            state.didFirePressStart = false;
+            if (onPressEnd) onPressEnd({
+                type: 'pressend',
+                pointerType: pointerType,
+                target: originalEvent.currentTarget,
+                shiftKey: originalEvent.shiftKey,
+                metaKey: originalEvent.metaKey,
+                ctrlKey: originalEvent.ctrlKey,
+                altKey: originalEvent.altKey
+            });
+            if (onPressChange) onPressChange(false);
+            setPressed(false);
+            if (onPress && wasPressed && !isDisabled) onPress({
+                type: 'press',
+                pointerType: pointerType,
+                target: originalEvent.currentTarget,
+                shiftKey: originalEvent.shiftKey,
+                metaKey: originalEvent.metaKey,
+                ctrlKey: originalEvent.ctrlKey,
+                altKey: originalEvent.altKey
+            });
+        };
+        let triggerPressUp = (originalEvent, pointerType)=>{
+            let { onPressUp: onPressUp , isDisabled: isDisabled  } = propsRef.current;
+            if (isDisabled) return;
+            if (onPressUp) onPressUp({
+                type: 'pressup',
+                pointerType: pointerType,
+                target: originalEvent.currentTarget,
+                shiftKey: originalEvent.shiftKey,
+                metaKey: originalEvent.metaKey,
+                ctrlKey: originalEvent.ctrlKey,
+                altKey: originalEvent.altKey
+            });
+        };
+        let cancel = (e)=>{
+            if (state.isPressed) {
+                if (state.isOverTarget) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType, false);
+                state.isPressed = false;
+                state.isOverTarget = false;
+                state.activePointerId = null;
+                state.pointerType = null;
+                removeAllGlobalListeners();
+                if (!allowTextSelectionOnPress) $14c0b72509d70225$export$b0d6fa1ab32e3295(state.target);
+            }
+        };
+        let pressProps = {
+            onKeyDown (e) {
+                if ($f6c31cce2adf654f$var$isValidKeyboardEvent(e.nativeEvent) && e.currentTarget.contains(e.target)) {
+                    if ($f6c31cce2adf654f$var$shouldPreventDefaultKeyboard(e.target)) e.preventDefault();
+                    e.stopPropagation();
+                    // If the event is repeating, it may have started on a different element
+                    // after which focus moved to the current element. Ignore these events and
+                    // only handle the first key down event.
+                    if (!state.isPressed && !e.repeat) {
+                        state.target = e.currentTarget;
+                        state.isPressed = true;
+                        triggerPressStart(e, 'keyboard');
+                        // Focus may move before the key up event, so register the event on the document
+                        // instead of the same element where the key down event occurred.
+                        addGlobalListener(document, 'keyup', onKeyUp, false);
+                    }
+                }
+            },
+            onKeyUp (e) {
+                if ($f6c31cce2adf654f$var$isValidKeyboardEvent(e.nativeEvent) && !e.repeat && e.currentTarget.contains(e.target)) triggerPressUp($f6c31cce2adf654f$var$createEvent(state.target, e), 'keyboard');
+            },
+            onClick (e) {
+                if (e && !e.currentTarget.contains(e.target)) return;
+                if (e && e.button === 0) {
+                    e.stopPropagation();
+                    if (isDisabled1) e.preventDefault();
+                    // If triggered from a screen reader or by using element.click(),
+                    // trigger as if it were a keyboard click.
+                    if (!state.ignoreClickAfterPress && !state.ignoreEmulatedMouseEvents && (state.pointerType === 'virtual' || $8a9cb279dc87e130$export$60278871457622de(e.nativeEvent))) {
+                        // Ensure the element receives focus (VoiceOver on iOS does not do this)
+                        if (!isDisabled1 && !preventFocusOnPress) $7215afc6de606d6b$export$de79e2c695e052f3(e.currentTarget);
+                        triggerPressStart(e, 'virtual');
+                        triggerPressUp(e, 'virtual');
+                        triggerPressEnd(e, 'virtual');
+                    }
+                    state.ignoreEmulatedMouseEvents = false;
+                    state.ignoreClickAfterPress = false;
+                }
+            }
+        };
+        let onKeyUp = (e)=>{
+            if (state.isPressed && $f6c31cce2adf654f$var$isValidKeyboardEvent(e)) {
+                if ($f6c31cce2adf654f$var$shouldPreventDefaultKeyboard(e.target)) e.preventDefault();
+                e.stopPropagation();
+                state.isPressed = false;
+                let target = e.target;
+                triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), 'keyboard', state.target.contains(target));
+                removeAllGlobalListeners();
+                // If the target is a link, trigger the click method to open the URL,
+                // but defer triggering pressEnd until onClick event handler.
+                if (state.target.contains(target) && $f6c31cce2adf654f$var$isHTMLAnchorLink(state.target) || state.target.getAttribute('role') === 'link') state.target.click();
+            }
+        };
+        if (typeof PointerEvent !== 'undefined') {
+            pressProps.onPointerDown = (e)=>{
+                // Only handle left clicks, and ignore events that bubbled through portals.
+                if (e.button !== 0 || !e.currentTarget.contains(e.target)) return;
+                // iOS safari fires pointer events from VoiceOver with incorrect coordinates/target.
+                // Ignore and let the onClick handler take care of it instead.
+                // https://bugs.webkit.org/show_bug.cgi?id=222627
+                // https://bugs.webkit.org/show_bug.cgi?id=223202
+                if ($f6c31cce2adf654f$var$isVirtualPointerEvent(e.nativeEvent)) {
+                    state.pointerType = 'virtual';
+                    return;
+                }
+                // Due to browser inconsistencies, especially on mobile browsers, we prevent
+                // default on pointer down and handle focusing the pressable element ourselves.
+                if ($f6c31cce2adf654f$var$shouldPreventDefault(e.currentTarget)) e.preventDefault();
+                state.pointerType = e.pointerType;
+                e.stopPropagation();
+                if (!state.isPressed) {
+                    state.isPressed = true;
+                    state.isOverTarget = true;
+                    state.activePointerId = e.pointerId;
+                    state.target = e.currentTarget;
+                    if (!isDisabled1 && !preventFocusOnPress) $7215afc6de606d6b$export$de79e2c695e052f3(e.currentTarget);
+                    if (!allowTextSelectionOnPress) $14c0b72509d70225$export$16a4697467175487(state.target);
+                    triggerPressStart(e, state.pointerType);
+                    addGlobalListener(document, 'pointermove', onPointerMove, false);
+                    addGlobalListener(document, 'pointerup', onPointerUp, false);
+                    addGlobalListener(document, 'pointercancel', onPointerCancel, false);
+                }
+            };
+            pressProps.onMouseDown = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                if (e.button === 0) {
+                    // Chrome and Firefox on touch Windows devices require mouse down events
+                    // to be canceled in addition to pointer events, or an extra asynchronous
+                    // focus event will be fired.
+                    if ($f6c31cce2adf654f$var$shouldPreventDefault(e.currentTarget)) e.preventDefault();
+                    e.stopPropagation();
+                }
+            };
+            pressProps.onPointerUp = (e)=>{
+                // iOS fires pointerup with zero width and height, so check the pointerType recorded during pointerdown.
+                if (!e.currentTarget.contains(e.target) || state.pointerType === 'virtual') return;
+                // Only handle left clicks
+                // Safari on iOS sometimes fires pointerup events, even
+                // when the touch isn't over the target, so double check.
+                if (e.button === 0 && $f6c31cce2adf654f$var$isOverTarget(e, e.currentTarget)) triggerPressUp(e, state.pointerType || e.pointerType);
+            };
+            // Safari on iOS < 13.2 does not implement pointerenter/pointerleave events correctly.
+            // Use pointer move events instead to implement our own hit testing.
+            // See https://bugs.webkit.org/show_bug.cgi?id=199803
+            let onPointerMove = (e)=>{
+                if (e.pointerId !== state.activePointerId) return;
+                if ($f6c31cce2adf654f$var$isOverTarget(e, state.target)) {
+                    if (!state.isOverTarget) {
+                        state.isOverTarget = true;
+                        triggerPressStart($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType);
+                    }
+                } else if (state.isOverTarget) {
+                    state.isOverTarget = false;
+                    triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType, false);
+                    if (propsRef.current.shouldCancelOnPointerExit) cancel(e);
+                }
+            };
+            let onPointerUp = (e)=>{
+                if (e.pointerId === state.activePointerId && state.isPressed && e.button === 0) {
+                    if ($f6c31cce2adf654f$var$isOverTarget(e, state.target)) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType);
+                    else if (state.isOverTarget) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType, false);
+                    state.isPressed = false;
+                    state.isOverTarget = false;
+                    state.activePointerId = null;
+                    state.pointerType = null;
+                    removeAllGlobalListeners();
+                    if (!allowTextSelectionOnPress) $14c0b72509d70225$export$b0d6fa1ab32e3295(state.target);
+                }
+            };
+            let onPointerCancel = (e)=>{
+                cancel(e);
+            };
+            pressProps.onDragStart = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                // Safari does not call onPointerCancel when a drag starts, whereas Chrome and Firefox do.
+                cancel(e);
+            };
+        } else {
+            pressProps.onMouseDown = (e)=>{
+                // Only handle left clicks
+                if (e.button !== 0 || !e.currentTarget.contains(e.target)) return;
+                // Due to browser inconsistencies, especially on mobile browsers, we prevent
+                // default on mouse down and handle focusing the pressable element ourselves.
+                if ($f6c31cce2adf654f$var$shouldPreventDefault(e.currentTarget)) e.preventDefault();
+                e.stopPropagation();
+                if (state.ignoreEmulatedMouseEvents) return;
+                state.isPressed = true;
+                state.isOverTarget = true;
+                state.target = e.currentTarget;
+                state.pointerType = $8a9cb279dc87e130$export$60278871457622de(e.nativeEvent) ? 'virtual' : 'mouse';
+                if (!isDisabled1 && !preventFocusOnPress) $7215afc6de606d6b$export$de79e2c695e052f3(e.currentTarget);
+                triggerPressStart(e, state.pointerType);
+                addGlobalListener(document, 'mouseup', onMouseUp, false);
+            };
+            pressProps.onMouseEnter = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                e.stopPropagation();
+                if (state.isPressed && !state.ignoreEmulatedMouseEvents) {
+                    state.isOverTarget = true;
+                    triggerPressStart(e, state.pointerType);
+                }
+            };
+            pressProps.onMouseLeave = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                e.stopPropagation();
+                if (state.isPressed && !state.ignoreEmulatedMouseEvents) {
+                    state.isOverTarget = false;
+                    triggerPressEnd(e, state.pointerType, false);
+                    if (propsRef.current.shouldCancelOnPointerExit) cancel(e);
+                }
+            };
+            pressProps.onMouseUp = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                if (!state.ignoreEmulatedMouseEvents && e.button === 0) triggerPressUp(e, state.pointerType);
+            };
+            let onMouseUp = (e)=>{
+                // Only handle left clicks
+                if (e.button !== 0) return;
+                state.isPressed = false;
+                removeAllGlobalListeners();
+                if (state.ignoreEmulatedMouseEvents) {
+                    state.ignoreEmulatedMouseEvents = false;
+                    return;
+                }
+                if ($f6c31cce2adf654f$var$isOverTarget(e, state.target)) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType);
+                else if (state.isOverTarget) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType, false);
+                state.isOverTarget = false;
+            };
+            pressProps.onTouchStart = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                e.stopPropagation();
+                let touch = $f6c31cce2adf654f$var$getTouchFromEvent(e.nativeEvent);
+                if (!touch) return;
+                state.activePointerId = touch.identifier;
+                state.ignoreEmulatedMouseEvents = true;
+                state.isOverTarget = true;
+                state.isPressed = true;
+                state.target = e.currentTarget;
+                state.pointerType = 'touch';
+                // Due to browser inconsistencies, especially on mobile browsers, we prevent default
+                // on the emulated mouse event and handle focusing the pressable element ourselves.
+                if (!isDisabled1 && !preventFocusOnPress) $7215afc6de606d6b$export$de79e2c695e052f3(e.currentTarget);
+                if (!allowTextSelectionOnPress) $14c0b72509d70225$export$16a4697467175487(state.target);
+                triggerPressStart(e, state.pointerType);
+                addGlobalListener(window, 'scroll', onScroll, true);
+            };
+            pressProps.onTouchMove = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                e.stopPropagation();
+                if (!state.isPressed) return;
+                let touch = $f6c31cce2adf654f$var$getTouchById(e.nativeEvent, state.activePointerId);
+                if (touch && $f6c31cce2adf654f$var$isOverTarget(touch, e.currentTarget)) {
+                    if (!state.isOverTarget) {
+                        state.isOverTarget = true;
+                        triggerPressStart(e, state.pointerType);
+                    }
+                } else if (state.isOverTarget) {
+                    state.isOverTarget = false;
+                    triggerPressEnd(e, state.pointerType, false);
+                    if (propsRef.current.shouldCancelOnPointerExit) cancel(e);
+                }
+            };
+            pressProps.onTouchEnd = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                e.stopPropagation();
+                if (!state.isPressed) return;
+                let touch = $f6c31cce2adf654f$var$getTouchById(e.nativeEvent, state.activePointerId);
+                if (touch && $f6c31cce2adf654f$var$isOverTarget(touch, e.currentTarget)) {
+                    triggerPressUp(e, state.pointerType);
+                    triggerPressEnd(e, state.pointerType);
+                } else if (state.isOverTarget) triggerPressEnd(e, state.pointerType, false);
+                state.isPressed = false;
+                state.activePointerId = null;
+                state.isOverTarget = false;
+                state.ignoreEmulatedMouseEvents = true;
+                if (!allowTextSelectionOnPress) $14c0b72509d70225$export$b0d6fa1ab32e3295(state.target);
+                removeAllGlobalListeners();
+            };
+            pressProps.onTouchCancel = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                e.stopPropagation();
+                if (state.isPressed) cancel(e);
+            };
+            let onScroll = (e)=>{
+                if (state.isPressed && e.target.contains(state.target)) cancel({
+                    currentTarget: state.target,
+                    shiftKey: false,
+                    ctrlKey: false,
+                    metaKey: false,
+                    altKey: false
+                });
+            };
+            pressProps.onDragStart = (e)=>{
+                if (!e.currentTarget.contains(e.target)) return;
+                cancel(e);
+            };
+        }
+        return pressProps;
+    }, [
+        addGlobalListener,
+        isDisabled1,
+        preventFocusOnPress,
+        removeAllGlobalListeners,
+        allowTextSelectionOnPress
+    ]);
+    // Remove user-select: none in case component unmounts immediately after pressStart
+    // eslint-disable-next-line arrow-body-style
+    useEffect(()=>{
+        return ()=>{
+            if (!allowTextSelectionOnPress) $14c0b72509d70225$export$b0d6fa1ab32e3295(ref.current.target);
+        };
+    }, [
+        allowTextSelectionOnPress
+    ]);
+    return {
+        isPressed: isPressedProp || isPressed,
+        pressProps: $3ef42575df84b30b$export$9d1611c77c2fe928(domProps, pressProps1)
+    };
+}
+function $f6c31cce2adf654f$var$isHTMLAnchorLink(target) {
+    return target.tagName === 'A' && target.hasAttribute('href');
+}
+function $f6c31cce2adf654f$var$isValidKeyboardEvent(event) {
+    const { key: key , code: code , target: target  } = event;
+    const element = target;
+    const { tagName: tagName , isContentEditable: isContentEditable  } = element;
+    const role = element.getAttribute('role');
+    // Accessibility for keyboards. Space and Enter only.
+    // "Spacebar" is for IE 11
+    return (key === 'Enter' || key === ' ' || key === 'Spacebar' || code === 'Space') && tagName !== 'INPUT' && tagName !== 'TEXTAREA' && isContentEditable !== true && (!$f6c31cce2adf654f$var$isHTMLAnchorLink(element) || role === 'button' && key !== 'Enter') && // An element with role='link' should only trigger with Enter key
+    !(role === 'link' && key !== 'Enter');
+}
+function $f6c31cce2adf654f$var$getTouchFromEvent(event) {
+    const { targetTouches: targetTouches  } = event;
+    if (targetTouches.length > 0) return targetTouches[0];
+    return null;
+}
+function $f6c31cce2adf654f$var$getTouchById(event, pointerId) {
+    const changedTouches = event.changedTouches;
+    for(let i = 0; i < changedTouches.length; i++){
+        const touch = changedTouches[i];
+        if (touch.identifier === pointerId) return touch;
+    }
+    return null;
+}
+function $f6c31cce2adf654f$var$createEvent(target, e) {
+    return {
+        currentTarget: target,
+        shiftKey: e.shiftKey,
+        ctrlKey: e.ctrlKey,
+        metaKey: e.metaKey,
+        altKey: e.altKey
+    };
+}
+function $f6c31cce2adf654f$var$getPointClientRect(point) {
+    let offsetX = point.width / 2 || point.radiusX || 0;
+    let offsetY = point.height / 2 || point.radiusY || 0;
+    return {
+        top: point.clientY - offsetY,
+        right: point.clientX + offsetX,
+        bottom: point.clientY + offsetY,
+        left: point.clientX - offsetX
+    };
+}
+function $f6c31cce2adf654f$var$areRectanglesOverlapping(a, b) {
+    // check if they cannot overlap on x axis
+    if (a.left > b.right || b.left > a.right) return false;
+    // check if they cannot overlap on y axis
+    if (a.top > b.bottom || b.top > a.bottom) return false;
+    return true;
+}
+function $f6c31cce2adf654f$var$isOverTarget(point, target) {
+    let rect = target.getBoundingClientRect();
+    let pointRect = $f6c31cce2adf654f$var$getPointClientRect(point);
+    return $f6c31cce2adf654f$var$areRectanglesOverlapping(rect, pointRect);
+}
+function $f6c31cce2adf654f$var$shouldPreventDefault(target) {
+    // We cannot prevent default if the target is a draggable element.
+    return !target.draggable;
+}
+function $f6c31cce2adf654f$var$shouldPreventDefaultKeyboard(target) {
+    return !((target.tagName === 'INPUT' || target.tagName === 'BUTTON') && target.type === 'submit');
+}
+function $f6c31cce2adf654f$var$isVirtualPointerEvent(event) {
+    // If the pointer size is zero, then we assume it's from a screen reader.
+    // Android TalkBack double tap will sometimes return a event with width and height of 1
+    // and pointerType === 'mouse' so we need to check for a specific combination of event attributes.
+    // Cannot use "event.pressure === 0" as the sole check due to Safari pointer events always returning pressure === 0
+    // instead of .5, see https://bugs.webkit.org/show_bug.cgi?id=206216. event.pointerType === 'mouse' is to distingush
+    // Talkback double tap from Windows Firefox touch screen press
+    return event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'mouse';
+}
+
+
+
+const $3b117e43dc0ca95d$export$27c701ed9e449e99 = /*#__PURE__*/ React.forwardRef(({ children: children , ...props }, ref)=>{
+    let newRef = useRef();
+    ref = ref !== null && ref !== void 0 ? ref : newRef;
+    let { pressProps: pressProps  } = $f6c31cce2adf654f$export$45712eceda6fad21({
+        ...props,
+        ref: ref
+    });
+    let child = React.Children.only(children);
+    return(/*#__PURE__*/ React.cloneElement(child, // @ts-ignore
+    {
+        ref: ref,
+        ...$3ef42575df84b30b$export$9d1611c77c2fe928(child.props, pressProps)
+    }));
+});
+
+
+var $f1ab8c75478c6f73$exports = {};
+
+$parcel$export$2($f1ab8c75478c6f73$exports, "PressResponder", () => $f1ab8c75478c6f73$export$3351871ee4b288b8);
+
+
+
+const $f1ab8c75478c6f73$export$3351871ee4b288b8 = /*#__PURE__*/ React.forwardRef(({ children: children , ...props }, ref)=>{
+    let isRegistered = useRef(false);
+    let prevContext = useContext($ae1eeba8b9eafd08$export$5165eccb35aaadb5);
+    let context = $3ef42575df84b30b$export$9d1611c77c2fe928(prevContext || {
+    }, {
+        ...props,
+        ref: ref || (prevContext === null || prevContext === void 0 ? void 0 : prevContext.ref),
+        register () {
+            isRegistered.current = true;
+            if (prevContext) prevContext.register();
+        }
+    });
+    $e7801be82b4b2a53$export$4debdb1a3f0fa79e(prevContext, ref);
+    useEffect(()=>{
+        if (!isRegistered.current) console.warn("A PressResponder was rendered without a pressable child. Either call the usePress hook, or wrap your DOM node with <Pressable> component.");
+    }, []);
+    return(/*#__PURE__*/ React.createElement($ae1eeba8b9eafd08$export$5165eccb35aaadb5.Provider, {
+        value: context
+    }, children));
+});
+
+
+var $a1ea59d68270f0dd$exports = {};
+
+$parcel$export$2($a1ea59d68270f0dd$exports, "useFocus", () => $a1ea59d68270f0dd$export$f8168d8dd8fd66e6);
+
+
+function $a1ea59d68270f0dd$export$f8168d8dd8fd66e6(props) {
+    let { isDisabled: isDisabled , onFocus: onFocusProp , onBlur: onBlurProp , onFocusChange: onFocusChange  } = props;
+    const onBlur = useCallback((e)=>{
+        if (e.target === e.currentTarget) {
+            if (onBlurProp) onBlurProp(e);
+            if (onFocusChange) onFocusChange(false);
+            return true;
+        }
+    }, [
+        onBlurProp,
+        onFocusChange
+    ]);
+    const onSyntheticFocus = $8a9cb279dc87e130$export$715c682d09d639cc(onBlur);
+    const onFocus = useCallback((e)=>{
+        if (e.target === e.currentTarget) {
+            if (onFocusProp) onFocusProp(e);
+            if (onFocusChange) onFocusChange(true);
+            onSyntheticFocus(e);
+        }
+    }, [
+        onFocusChange,
+        onFocusProp,
+        onSyntheticFocus
+    ]);
+    return {
+        focusProps: {
+            onFocus: !isDisabled && (onFocusProp || onFocusChange || onBlurProp) ? onFocus : undefined,
+            onBlur: !isDisabled && (onBlurProp || onFocusChange) ? onBlur : null
+        }
+    };
+}
+
+
+var $507fabe10e71c6fb$exports = {};
+
+$parcel$export$2($507fabe10e71c6fb$exports, "isFocusVisible", () => $507fabe10e71c6fb$export$b9b3dfddab17db27);
+$parcel$export$2($507fabe10e71c6fb$exports, "getInteractionModality", () => $507fabe10e71c6fb$export$630ff653c5ada6a9);
+$parcel$export$2($507fabe10e71c6fb$exports, "setInteractionModality", () => $507fabe10e71c6fb$export$8397ddfc504fdb9a);
+$parcel$export$2($507fabe10e71c6fb$exports, "useInteractionModality", () => $507fabe10e71c6fb$export$98e20ec92f614cfe);
+$parcel$export$2($507fabe10e71c6fb$exports, "useFocusVisible", () => $507fabe10e71c6fb$export$ffd9e5021c1fb2d6);
+$parcel$export$2($507fabe10e71c6fb$exports, "useFocusVisibleListener", () => $507fabe10e71c6fb$export$ec71b4b83ac08ec3);
+
+
+
+let $507fabe10e71c6fb$var$currentModality = null;
+let $507fabe10e71c6fb$var$changeHandlers = new Set();
+let $507fabe10e71c6fb$var$hasSetupGlobalListeners = false;
+let $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+let $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;
+// Only Tab or Esc keys will make focus visible on text input elements
+const $507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS = {
+    Tab: true,
+    Escape: true
+};
+function $507fabe10e71c6fb$var$triggerChangeHandlers(modality, e) {
+    for (let handler of $507fabe10e71c6fb$var$changeHandlers)handler(modality, e);
+}
+/**
+ * Helper function to determine if a KeyboardEvent is unmodified and could make keyboard focus styles visible.
+ */ function $507fabe10e71c6fb$var$isValidKey(e) {
+    // Control and Shift keys trigger when navigating back to the tab with keyboard.
+    return !(e.metaKey || !$c87311424ea30a05$export$9ac100e40613ea10() && e.altKey || e.ctrlKey || e.key === 'Control' || e.key === 'Shift' || e.key === 'Meta');
+}
+function $507fabe10e71c6fb$var$handleKeyboardEvent(e) {
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+    if ($507fabe10e71c6fb$var$isValidKey(e)) {
+        $507fabe10e71c6fb$var$currentModality = 'keyboard';
+        $507fabe10e71c6fb$var$triggerChangeHandlers('keyboard', e);
+    }
+}
+function $507fabe10e71c6fb$var$handlePointerEvent(e) {
+    $507fabe10e71c6fb$var$currentModality = 'pointer';
+    if (e.type === 'mousedown' || e.type === 'pointerdown') {
+        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+        $507fabe10e71c6fb$var$triggerChangeHandlers('pointer', e);
+    }
+}
+function $507fabe10e71c6fb$var$handleClickEvent(e) {
+    if ($8a9cb279dc87e130$export$60278871457622de(e)) {
+        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+        $507fabe10e71c6fb$var$currentModality = 'virtual';
+    }
+}
+function $507fabe10e71c6fb$var$handleFocusEvent(e) {
+    // Firefox fires two extra focus events when the user first clicks into an iframe:
+    // first on the window, then on the document. We ignore these events so they don't
+    // cause keyboard focus rings to appear.
+    if (e.target === window || e.target === document) return;
+    // If a focus event occurs without a preceding keyboard or pointer event, switch to virtual modality.
+    // This occurs, for example, when navigating a form with the next/previous buttons on iOS.
+    if (!$507fabe10e71c6fb$var$hasEventBeforeFocus && !$507fabe10e71c6fb$var$hasBlurredWindowRecently) {
+        $507fabe10e71c6fb$var$currentModality = 'virtual';
+        $507fabe10e71c6fb$var$triggerChangeHandlers('virtual', e);
+    }
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+    $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;
+}
+function $507fabe10e71c6fb$var$handleWindowBlur() {
+    // When the window is blurred, reset state. This is necessary when tabbing out of the window,
+    // for example, since a subsequent focus event won't be fired.
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+    $507fabe10e71c6fb$var$hasBlurredWindowRecently = true;
+}
+/**
+ * Setup global event listeners to control when keyboard focus style should be visible.
+ */ function $507fabe10e71c6fb$var$setupGlobalFocusEvents() {
+    if (typeof window === 'undefined' || $507fabe10e71c6fb$var$hasSetupGlobalListeners) return;
+    // Programmatic focus() calls shouldn't affect the current input modality.
+    // However, we need to detect other cases when a focus event occurs without
+    // a preceding user event (e.g. screen reader focus). Overriding the focus
+    // method on HTMLElement.prototype is a bit hacky, but works.
+    let focus = HTMLElement.prototype.focus;
+    HTMLElement.prototype.focus = function() {
+        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+        focus.apply(this, arguments);
+    };
+    document.addEventListener('keydown', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+    document.addEventListener('keyup', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+    document.addEventListener('click', $507fabe10e71c6fb$var$handleClickEvent, true);
+    // Register focus events on the window so they are sure to happen
+    // before React's event listeners (registered on the document).
+    window.addEventListener('focus', $507fabe10e71c6fb$var$handleFocusEvent, true);
+    window.addEventListener('blur', $507fabe10e71c6fb$var$handleWindowBlur, false);
+    if (typeof PointerEvent !== 'undefined') {
+        document.addEventListener('pointerdown', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        document.addEventListener('pointermove', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        document.addEventListener('pointerup', $507fabe10e71c6fb$var$handlePointerEvent, true);
+    } else {
+        document.addEventListener('mousedown', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        document.addEventListener('mousemove', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        document.addEventListener('mouseup', $507fabe10e71c6fb$var$handlePointerEvent, true);
+    }
+    $507fabe10e71c6fb$var$hasSetupGlobalListeners = true;
+}
+if (typeof document !== 'undefined') {
+    if (document.readyState !== 'loading') $507fabe10e71c6fb$var$setupGlobalFocusEvents();
+    else document.addEventListener('DOMContentLoaded', $507fabe10e71c6fb$var$setupGlobalFocusEvents);
+}
+function $507fabe10e71c6fb$export$b9b3dfddab17db27() {
+    return $507fabe10e71c6fb$var$currentModality !== 'pointer';
+}
+function $507fabe10e71c6fb$export$630ff653c5ada6a9() {
+    return $507fabe10e71c6fb$var$currentModality;
+}
+function $507fabe10e71c6fb$export$8397ddfc504fdb9a(modality) {
+    $507fabe10e71c6fb$var$currentModality = modality;
+    $507fabe10e71c6fb$var$triggerChangeHandlers(modality, null);
+}
+function $507fabe10e71c6fb$export$98e20ec92f614cfe() {
+    $507fabe10e71c6fb$var$setupGlobalFocusEvents();
+    let [modality, setModality] = useState($507fabe10e71c6fb$var$currentModality);
+    useEffect(()=>{
+        let handler = ()=>{
+            setModality($507fabe10e71c6fb$var$currentModality);
+        };
+        $507fabe10e71c6fb$var$changeHandlers.add(handler);
+        return ()=>{
+            $507fabe10e71c6fb$var$changeHandlers.delete(handler);
+        };
+    }, []);
+    return modality;
+}
+/**
+ * If this is attached to text input component, return if the event is a focus event (Tab/Escape keys pressed) so that
+ * focus visible style can be properly set.
+ */ function $507fabe10e71c6fb$var$isKeyboardFocusEvent(isTextInput, modality, e) {
+    return !(isTextInput && modality === 'keyboard' && e instanceof KeyboardEvent && !$507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS[e.key]);
+}
+function $507fabe10e71c6fb$export$ffd9e5021c1fb2d6(props = {
+}) {
+    let { isTextInput: isTextInput , autoFocus: autoFocus  } = props;
+    let [isFocusVisibleState, setFocusVisible] = useState(autoFocus || $507fabe10e71c6fb$export$b9b3dfddab17db27());
+    $507fabe10e71c6fb$export$ec71b4b83ac08ec3(($507fabe10e71c6fb$export$b9b3dfddab17db27)=>{
+        setFocusVisible($507fabe10e71c6fb$export$b9b3dfddab17db27);
+    }, [
+        isTextInput
+    ], {
+        isTextInput: isTextInput
+    });
+    return {
+        isFocusVisible: isFocusVisibleState
+    };
+}
+function $507fabe10e71c6fb$export$ec71b4b83ac08ec3(fn, deps, opts) {
+    $507fabe10e71c6fb$var$setupGlobalFocusEvents();
+    useEffect(()=>{
+        let handler = (modality, e)=>{
+            if (!$507fabe10e71c6fb$var$isKeyboardFocusEvent(opts === null || opts === void 0 ? void 0 : opts.isTextInput, modality, e)) return;
+            fn($507fabe10e71c6fb$export$b9b3dfddab17db27());
+        };
+        $507fabe10e71c6fb$var$changeHandlers.add(handler);
+        return ()=>{
+            $507fabe10e71c6fb$var$changeHandlers.delete(handler);
+        };
+    }, deps);
+}
+
+
+var $9ab94262bd0047c7$exports = {};
+
+$parcel$export$2($9ab94262bd0047c7$exports, "useFocusWithin", () => $9ab94262bd0047c7$export$420e68273165f4ec);
+
+
+function $9ab94262bd0047c7$export$420e68273165f4ec(props) {
+    let { isDisabled: isDisabled , onBlurWithin: onBlurWithin , onFocusWithin: onFocusWithin , onFocusWithinChange: onFocusWithinChange  } = props;
+    let state = useRef({
+        isFocusWithin: false
+    });
+    let onBlur = useCallback((e)=>{
+        // We don't want to trigger onBlurWithin and then immediately onFocusWithin again
+        // when moving focus inside the element. Only trigger if the currentTarget doesn't
+        // include the relatedTarget (where focus is moving).
+        if (state.current.isFocusWithin && !e.currentTarget.contains(e.relatedTarget)) {
+            state.current.isFocusWithin = false;
+            if (onBlurWithin) onBlurWithin(e);
+            if (onFocusWithinChange) onFocusWithinChange(false);
+        }
+    }, [
+        onBlurWithin,
+        onFocusWithinChange,
+        state
+    ]);
+    let onSyntheticFocus = $8a9cb279dc87e130$export$715c682d09d639cc(onBlur);
+    let onFocus = useCallback((e)=>{
+        if (!state.current.isFocusWithin) {
+            if (onFocusWithin) onFocusWithin(e);
+            if (onFocusWithinChange) onFocusWithinChange(true);
+            state.current.isFocusWithin = true;
+            onSyntheticFocus(e);
+        }
+    }, [
+        onFocusWithin,
+        onFocusWithinChange,
+        onSyntheticFocus
+    ]);
+    if (isDisabled) return {
+        focusWithinProps: {
+            onFocus: null,
+            onBlur: null
+        }
+    };
+    return {
+        focusWithinProps: {
+            onFocus: onFocus,
+            onBlur: onBlur
+        }
+    };
+}
+
+
+var $6179b936705e76d3$exports = {};
+
+$parcel$export$2($6179b936705e76d3$exports, "useHover", () => $6179b936705e76d3$export$ae780daf29e6d456);
+
+// iOS fires onPointerEnter twice: once with pointerType="touch" and again with pointerType="mouse".
+// We want to ignore these emulated events so they do not trigger hover behavior.
+// See https://bugs.webkit.org/show_bug.cgi?id=214609.
+let $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;
+let $6179b936705e76d3$var$hoverCount = 0;
+function $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents() {
+    $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = true;
+    // Clear globalIgnoreEmulatedMouseEvents after a short timeout. iOS fires onPointerEnter
+    // with pointerType="mouse" immediately after onPointerUp and before onFocus. On other
+    // devices that don't have this quirk, we don't want to ignore a mouse hover sometime in
+    // the distant future because a user previously touched the element.
+    setTimeout(()=>{
+        $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;
+    }, 50);
+}
+function $6179b936705e76d3$var$handleGlobalPointerEvent(e) {
+    if (e.pointerType === 'touch') $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents();
+}
+function $6179b936705e76d3$var$setupGlobalTouchEvents() {
+    if (typeof document === 'undefined') return;
+    if (typeof PointerEvent !== 'undefined') document.addEventListener('pointerup', $6179b936705e76d3$var$handleGlobalPointerEvent);
+    else document.addEventListener('touchend', $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents);
+    $6179b936705e76d3$var$hoverCount++;
+    return ()=>{
+        $6179b936705e76d3$var$hoverCount--;
+        if ($6179b936705e76d3$var$hoverCount > 0) return;
+        if (typeof PointerEvent !== 'undefined') document.removeEventListener('pointerup', $6179b936705e76d3$var$handleGlobalPointerEvent);
+        else document.removeEventListener('touchend', $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents);
+    };
+}
+function $6179b936705e76d3$export$ae780daf29e6d456(props) {
+    let { onHoverStart: onHoverStart , onHoverChange: onHoverChange , onHoverEnd: onHoverEnd , isDisabled: isDisabled  } = props;
+    let [isHovered, setHovered] = useState(false);
+    let state = useRef({
+        isHovered: false,
+        ignoreEmulatedMouseEvents: false,
+        pointerType: '',
+        target: null
+    }).current;
+    useEffect($6179b936705e76d3$var$setupGlobalTouchEvents, []);
+    let { hoverProps: hoverProps1 , triggerHoverEnd: triggerHoverEnd1  } = useMemo(()=>{
+        let triggerHoverStart = (event, pointerType)=>{
+            state.pointerType = pointerType;
+            if (isDisabled || pointerType === 'touch' || state.isHovered || !event.currentTarget.contains(event.target)) return;
+            state.isHovered = true;
+            let target = event.currentTarget;
+            state.target = target;
+            if (onHoverStart) onHoverStart({
+                type: 'hoverstart',
+                target: target,
+                pointerType: pointerType
+            });
+            if (onHoverChange) onHoverChange(true);
+            setHovered(true);
+        };
+        let triggerHoverEnd = (event, pointerType)=>{
+            state.pointerType = '';
+            state.target = null;
+            if (pointerType === 'touch' || !state.isHovered) return;
+            state.isHovered = false;
+            let target = event.currentTarget;
+            if (onHoverEnd) onHoverEnd({
+                type: 'hoverend',
+                target: target,
+                pointerType: pointerType
+            });
+            if (onHoverChange) onHoverChange(false);
+            setHovered(false);
+        };
+        let hoverProps = {
+        };
+        if (typeof PointerEvent !== 'undefined') {
+            hoverProps.onPointerEnter = (e)=>{
+                if ($6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents && e.pointerType === 'mouse') return;
+                triggerHoverStart(e, e.pointerType);
+            };
+            hoverProps.onPointerLeave = (e)=>{
+                if (!isDisabled && e.currentTarget.contains(e.target)) triggerHoverEnd(e, e.pointerType);
+            };
+        } else {
+            hoverProps.onTouchStart = ()=>{
+                state.ignoreEmulatedMouseEvents = true;
+            };
+            hoverProps.onMouseEnter = (e)=>{
+                if (!state.ignoreEmulatedMouseEvents && !$6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents) triggerHoverStart(e, 'mouse');
+                state.ignoreEmulatedMouseEvents = false;
+            };
+            hoverProps.onMouseLeave = (e)=>{
+                if (!isDisabled && e.currentTarget.contains(e.target)) triggerHoverEnd(e, 'mouse');
+            };
+        }
+        return {
+            hoverProps: hoverProps,
+            triggerHoverEnd: triggerHoverEnd
+        };
+    }, [
+        onHoverStart,
+        onHoverChange,
+        onHoverEnd,
+        isDisabled,
+        state
+    ]);
+    useEffect(()=>{
+        // Call the triggerHoverEnd as soon as isDisabled changes to true
+        // Safe to call triggerHoverEnd, it will early return if we aren't currently hovering
+        if (isDisabled) triggerHoverEnd1({
+            currentTarget: state.target
+        }, state.pointerType);
+    }, [
+        isDisabled
+    ]);
+    return {
+        hoverProps: hoverProps1,
+        isHovered: isHovered
+    };
+}
+
+
+var $e0b6e0b68ec7f50f$exports = {};
+
+$parcel$export$2($e0b6e0b68ec7f50f$exports, "useInteractOutside", () => $e0b6e0b68ec7f50f$export$872b660ac5a1ff98);
+
+function $e0b6e0b68ec7f50f$export$872b660ac5a1ff98(props) {
+    let { ref: ref , onInteractOutside: onInteractOutside , isDisabled: isDisabled , onInteractOutsideStart: onInteractOutsideStart  } = props;
+    let stateRef = useRef({
+        isPointerDown: false,
+        ignoreEmulatedMouseEvents: false,
+        onInteractOutside: onInteractOutside,
+        onInteractOutsideStart: onInteractOutsideStart
+    });
+    let state = stateRef.current;
+    state.onInteractOutside = onInteractOutside;
+    state.onInteractOutsideStart = onInteractOutsideStart;
+    useEffect(()=>{
+        if (isDisabled) return;
+        let onPointerDown = (e)=>{
+            if ($e0b6e0b68ec7f50f$var$isValidEvent(e, ref) && state.onInteractOutside) {
+                if (state.onInteractOutsideStart) state.onInteractOutsideStart(e);
+                state.isPointerDown = true;
+            }
+        };
+        // Use pointer events if available. Otherwise, fall back to mouse and touch events.
+        if (typeof PointerEvent !== 'undefined') {
+            let onPointerUp = (e)=>{
+                if (state.isPointerDown && state.onInteractOutside && $e0b6e0b68ec7f50f$var$isValidEvent(e, ref)) {
+                    state.isPointerDown = false;
+                    state.onInteractOutside(e);
+                }
+            };
+            // changing these to capture phase fixed combobox
+            document.addEventListener('pointerdown', onPointerDown, true);
+            document.addEventListener('pointerup', onPointerUp, true);
+            return ()=>{
+                document.removeEventListener('pointerdown', onPointerDown, true);
+                document.removeEventListener('pointerup', onPointerUp, true);
+            };
+        } else {
+            let onMouseUp = (e)=>{
+                if (state.ignoreEmulatedMouseEvents) state.ignoreEmulatedMouseEvents = false;
+                else if (state.isPointerDown && state.onInteractOutside && $e0b6e0b68ec7f50f$var$isValidEvent(e, ref)) {
+                    state.isPointerDown = false;
+                    state.onInteractOutside(e);
+                }
+            };
+            let onTouchEnd = (e)=>{
+                state.ignoreEmulatedMouseEvents = true;
+                if (state.onInteractOutside && state.isPointerDown && $e0b6e0b68ec7f50f$var$isValidEvent(e, ref)) {
+                    state.isPointerDown = false;
+                    state.onInteractOutside(e);
+                }
+            };
+            document.addEventListener('mousedown', onPointerDown, true);
+            document.addEventListener('mouseup', onMouseUp, true);
+            document.addEventListener('touchstart', onPointerDown, true);
+            document.addEventListener('touchend', onTouchEnd, true);
+            return ()=>{
+                document.removeEventListener('mousedown', onPointerDown, true);
+                document.removeEventListener('mouseup', onMouseUp, true);
+                document.removeEventListener('touchstart', onPointerDown, true);
+                document.removeEventListener('touchend', onTouchEnd, true);
+            };
+        }
+    }, [
+        ref,
+        state,
+        isDisabled
+    ]);
+}
+function $e0b6e0b68ec7f50f$var$isValidEvent(event, ref) {
+    if (event.button > 0) return false;
+    // if the event target is no longer in the document
+    if (event.target) {
+        const ownerDocument = event.target.ownerDocument;
+        if (!ownerDocument || !ownerDocument.documentElement.contains(event.target)) return false;
+    }
+    return ref.current && !ref.current.contains(event.target);
+}
+
+
+var $46d819fcbaf35654$exports = {};
+
+$parcel$export$2($46d819fcbaf35654$exports, "useKeyboard", () => $46d819fcbaf35654$export$8f71654801c2f7cd);
+function $93925083ecbb358c$export$48d1ea6320830260(handler) {
+    if (!handler) return;
+    let shouldStopPropagation = true;
+    return (e)=>{
+        let event = {
+            ...e,
+            preventDefault () {
+                e.preventDefault();
+            },
+            isDefaultPrevented () {
+                return e.isDefaultPrevented();
+            },
+            stopPropagation () {
+                console.error('stopPropagation is now the default behavior for events in React Spectrum. You can use continuePropagation() to revert this behavior.');
+            },
+            continuePropagation () {
+                shouldStopPropagation = false;
+            }
+        };
+        handler(event);
+        if (shouldStopPropagation) e.stopPropagation();
+    };
+}
+
+
+function $46d819fcbaf35654$export$8f71654801c2f7cd(props) {
+    return {
+        keyboardProps: props.isDisabled ? {
+        } : {
+            onKeyDown: $93925083ecbb358c$export$48d1ea6320830260(props.onKeyDown),
+            onKeyUp: $93925083ecbb358c$export$48d1ea6320830260(props.onKeyUp)
+        }
+    };
+}
+
+
+var $e8a7022cf87cba2a$exports = {};
+
+$parcel$export$2($e8a7022cf87cba2a$exports, "useMove", () => $e8a7022cf87cba2a$export$36da96379f79f245);
+
+
+
+function $e8a7022cf87cba2a$export$36da96379f79f245(props) {
+    let { onMoveStart: onMoveStart , onMove: onMove , onMoveEnd: onMoveEnd  } = props;
+    let state = useRef({
+        didMove: false,
+        lastPosition: null,
+        id: null
+    });
+    let { addGlobalListener: addGlobalListener , removeGlobalListener: removeGlobalListener  } = $03deb23ff14920c4$export$4eaf04e54aa8eed6();
+    let moveProps1 = useMemo(()=>{
+        let moveProps = {
+        };
+        let start = ()=>{
+            $14c0b72509d70225$export$16a4697467175487();
+            state.current.didMove = false;
+        };
+        let move = (originalEvent, pointerType, deltaX, deltaY)=>{
+            if (deltaX === 0 && deltaY === 0) return;
+            if (!state.current.didMove) {
+                state.current.didMove = true;
+                onMoveStart === null || onMoveStart === void 0 ? void 0 : onMoveStart({
+                    type: 'movestart',
+                    pointerType: pointerType,
+                    shiftKey: originalEvent.shiftKey,
+                    metaKey: originalEvent.metaKey,
+                    ctrlKey: originalEvent.ctrlKey,
+                    altKey: originalEvent.altKey
+                });
+            }
+            onMove({
+                type: 'move',
+                pointerType: pointerType,
+                deltaX: deltaX,
+                deltaY: deltaY,
+                shiftKey: originalEvent.shiftKey,
+                metaKey: originalEvent.metaKey,
+                ctrlKey: originalEvent.ctrlKey,
+                altKey: originalEvent.altKey
+            });
+        };
+        let end = (originalEvent, pointerType)=>{
+            $14c0b72509d70225$export$b0d6fa1ab32e3295();
+            if (state.current.didMove) onMoveEnd === null || onMoveEnd === void 0 ? void 0 : onMoveEnd({
+                type: 'moveend',
+                pointerType: pointerType,
+                shiftKey: originalEvent.shiftKey,
+                metaKey: originalEvent.metaKey,
+                ctrlKey: originalEvent.ctrlKey,
+                altKey: originalEvent.altKey
+            });
+        };
+        if (typeof PointerEvent === 'undefined') {
+            let onMouseMove = (e)=>{
+                if (e.button === 0) {
+                    move(e, 'mouse', e.pageX - state.current.lastPosition.pageX, e.pageY - state.current.lastPosition.pageY);
+                    state.current.lastPosition = {
+                        pageX: e.pageX,
+                        pageY: e.pageY
+                    };
+                }
+            };
+            let onMouseUp = (e)=>{
+                if (e.button === 0) {
+                    end(e, 'mouse');
+                    removeGlobalListener(window, 'mousemove', onMouseMove, false);
+                    removeGlobalListener(window, 'mouseup', onMouseUp, false);
+                }
+            };
+            moveProps.onMouseDown = (e)=>{
+                if (e.button === 0) {
+                    start();
+                    e.stopPropagation();
+                    e.preventDefault();
+                    state.current.lastPosition = {
+                        pageX: e.pageX,
+                        pageY: e.pageY
+                    };
+                    addGlobalListener(window, 'mousemove', onMouseMove, false);
+                    addGlobalListener(window, 'mouseup', onMouseUp, false);
+                }
+            };
+            let onTouchMove = (e)=>{
+                let touch = [
+                    ...e.changedTouches
+                ].findIndex(({ identifier: identifier  })=>identifier === state.current.id
+                );
+                if (touch >= 0) {
+                    let { pageX: pageX , pageY: pageY  } = e.changedTouches[touch];
+                    move(e, 'touch', pageX - state.current.lastPosition.pageX, pageY - state.current.lastPosition.pageY);
+                    state.current.lastPosition = {
+                        pageX: pageX,
+                        pageY: pageY
+                    };
+                }
+            };
+            let onTouchEnd = (e)=>{
+                let touch = [
+                    ...e.changedTouches
+                ].findIndex(({ identifier: identifier  })=>identifier === state.current.id
+                );
+                if (touch >= 0) {
+                    end(e, 'touch');
+                    state.current.id = null;
+                    removeGlobalListener(window, 'touchmove', onTouchMove);
+                    removeGlobalListener(window, 'touchend', onTouchEnd);
+                    removeGlobalListener(window, 'touchcancel', onTouchEnd);
+                }
+            };
+            moveProps.onTouchStart = (e)=>{
+                if (e.changedTouches.length === 0 || state.current.id != null) return;
+                let { pageX: pageX , pageY: pageY , identifier: identifier  } = e.changedTouches[0];
+                start();
+                e.stopPropagation();
+                e.preventDefault();
+                state.current.lastPosition = {
+                    pageX: pageX,
+                    pageY: pageY
+                };
+                state.current.id = identifier;
+                addGlobalListener(window, 'touchmove', onTouchMove, false);
+                addGlobalListener(window, 'touchend', onTouchEnd, false);
+                addGlobalListener(window, 'touchcancel', onTouchEnd, false);
+            };
+        } else {
+            let onPointerMove = (e)=>{
+                if (e.pointerId === state.current.id) {
+                    let pointerType = e.pointerType || 'mouse';
+                    // Problems with PointerEvent#movementX/movementY:
+                    // 1. it is always 0 on macOS Safari.
+                    // 2. On Chrome Android, it's scaled by devicePixelRatio, but not on Chrome macOS
+                    move(e, pointerType, e.pageX - state.current.lastPosition.pageX, e.pageY - state.current.lastPosition.pageY);
+                    state.current.lastPosition = {
+                        pageX: e.pageX,
+                        pageY: e.pageY
+                    };
+                }
+            };
+            let onPointerUp = (e)=>{
+                if (e.pointerId === state.current.id) {
+                    let pointerType = e.pointerType || 'mouse';
+                    end(e, pointerType);
+                    state.current.id = null;
+                    removeGlobalListener(window, 'pointermove', onPointerMove, false);
+                    removeGlobalListener(window, 'pointerup', onPointerUp, false);
+                    removeGlobalListener(window, 'pointercancel', onPointerUp, false);
+                }
+            };
+            moveProps.onPointerDown = (e)=>{
+                if (e.button === 0 && state.current.id == null) {
+                    start();
+                    e.stopPropagation();
+                    e.preventDefault();
+                    state.current.lastPosition = {
+                        pageX: e.pageX,
+                        pageY: e.pageY
+                    };
+                    state.current.id = e.pointerId;
+                    addGlobalListener(window, 'pointermove', onPointerMove, false);
+                    addGlobalListener(window, 'pointerup', onPointerUp, false);
+                    addGlobalListener(window, 'pointercancel', onPointerUp, false);
+                }
+            };
+        }
+        let triggerKeyboardMove = (e, deltaX, deltaY)=>{
+            start();
+            move(e, 'keyboard', deltaX, deltaY);
+            end(e, 'keyboard');
+        };
+        moveProps.onKeyDown = (e)=>{
+            switch(e.key){
+                case 'Left':
+                case 'ArrowLeft':
+                    e.preventDefault();
+                    e.stopPropagation();
+                    triggerKeyboardMove(e, -1, 0);
+                    break;
+                case 'Right':
+                case 'ArrowRight':
+                    e.preventDefault();
+                    e.stopPropagation();
+                    triggerKeyboardMove(e, 1, 0);
+                    break;
+                case 'Up':
+                case 'ArrowUp':
+                    e.preventDefault();
+                    e.stopPropagation();
+                    triggerKeyboardMove(e, 0, -1);
+                    break;
+                case 'Down':
+                case 'ArrowDown':
+                    e.preventDefault();
+                    e.stopPropagation();
+                    triggerKeyboardMove(e, 0, 1);
+                    break;
+            }
+        };
+        return moveProps;
+    }, [
+        state,
+        onMoveStart,
+        onMove,
+        onMoveEnd,
+        addGlobalListener,
+        removeGlobalListener
+    ]);
+    return {
+        moveProps: moveProps1
+    };
+}
+
+
+
+var $7d0a636d7a4dcefd$exports = {};
+
+$parcel$export$2($7d0a636d7a4dcefd$exports, "useScrollWheel", () => $7d0a636d7a4dcefd$export$2123ff2b87c81ca);
+
+
+function $7d0a636d7a4dcefd$export$2123ff2b87c81ca(props, ref) {
+    let { onScroll: onScroll , isDisabled: isDisabled  } = props;
+    let onScrollHandler = useCallback((e)=>{
+        // If the ctrlKey is pressed, this is a zoom event, do nothing.
+        if (e.ctrlKey) return;
+        // stop scrolling the page
+        e.preventDefault();
+        e.stopPropagation();
+        if (onScroll) onScroll({
+            deltaX: e.deltaX,
+            deltaY: e.deltaY
+        });
+    }, [
+        onScroll
+    ]);
+    $e9faafb641e167db$export$90fc3a17d93f704c(ref, 'wheel', isDisabled ? null : onScrollHandler);
+}
+
+
+var $8a26561d2877236e$exports = {};
+
+$parcel$export$2($8a26561d2877236e$exports, "useLongPress", () => $8a26561d2877236e$export$c24ed0104d07eab9);
+
+
+
+const $8a26561d2877236e$var$DEFAULT_THRESHOLD = 500;
+function $8a26561d2877236e$export$c24ed0104d07eab9(props) {
+    let { isDisabled: isDisabled , onLongPressStart: onLongPressStart , onLongPressEnd: onLongPressEnd , onLongPress: onLongPress , threshold: threshold = $8a26561d2877236e$var$DEFAULT_THRESHOLD , accessibilityDescription: accessibilityDescription  } = props;
+    const timeRef = useRef(null);
+    let { addGlobalListener: addGlobalListener , removeGlobalListener: removeGlobalListener  } = $03deb23ff14920c4$export$4eaf04e54aa8eed6();
+    let { pressProps: pressProps  } = $f6c31cce2adf654f$export$45712eceda6fad21({
+        isDisabled: isDisabled,
+        onPressStart (e1) {
+            if (e1.pointerType === 'mouse' || e1.pointerType === 'touch') {
+                if (onLongPressStart) onLongPressStart({
+                    ...e1,
+                    type: 'longpressstart'
+                });
+                timeRef.current = setTimeout(()=>{
+                    // Prevent other usePress handlers from also handling this event.
+                    e1.target.dispatchEvent(new PointerEvent('pointercancel', {
+                        bubbles: true
+                    }));
+                    if (onLongPress) onLongPress({
+                        ...e1,
+                        type: 'longpress'
+                    });
+                    timeRef.current = null;
+                }, threshold);
+                // Prevent context menu, which may be opened on long press on touch devices
+                if (e1.pointerType === 'touch') {
+                    let onContextMenu = (e)=>{
+                        e.preventDefault();
+                    };
+                    addGlobalListener(e1.target, 'contextmenu', onContextMenu, {
+                        once: true
+                    });
+                    addGlobalListener(window, 'pointerup', ()=>{
+                        // If no contextmenu event is fired quickly after pointerup, remove the handler
+                        // so future context menu events outside a long press are not prevented.
+                        setTimeout(()=>{
+                            removeGlobalListener(e1.target, 'contextmenu', onContextMenu);
+                        }, 30);
+                    }, {
+                        once: true
+                    });
+                }
+            }
+        },
+        onPressEnd (e) {
+            if (timeRef.current) clearTimeout(timeRef.current);
+            if (onLongPressEnd && (e.pointerType === 'mouse' || e.pointerType === 'touch')) onLongPressEnd({
+                ...e,
+                type: 'longpressend'
+            });
+        }
+    });
+    let descriptionProps = $ef06256079686ba0$export$f8aeda7b10753fa1(onLongPress && !isDisabled ? accessibilityDescription : null);
+    return {
+        longPressProps: $3ef42575df84b30b$export$9d1611c77c2fe928(pressProps, descriptionProps)
+    };
+}
+
+function $parcel$export$1(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $9bf71ea28793e738$exports = {};
+
+$parcel$export$1($9bf71ea28793e738$exports, "FocusScope", () => $9bf71ea28793e738$export$20e40289641fbbb6);
+$parcel$export$1($9bf71ea28793e738$exports, "useFocusManager", () => $9bf71ea28793e738$export$10c5169755ce7bd7);
+$parcel$export$1($9bf71ea28793e738$exports, "getFocusableTreeWalker", () => $9bf71ea28793e738$export$2d6ec8fc375ceafa);
+$parcel$export$1($9bf71ea28793e738$exports, "createFocusManager", () => $9bf71ea28793e738$export$c5251b9e124bf29);
+var $6a99195332edec8b$exports = {};
+
+$parcel$export$1($6a99195332edec8b$exports, "focusSafely", () => $6a99195332edec8b$export$80f3e147d781571c);
+
+
+function $6a99195332edec8b$export$80f3e147d781571c(element) {
+    // If the user is interacting with a virtual cursor, e.g. screen reader, then
+    // wait until after any animated transitions that are currently occurring on
+    // the page before shifting focus. This avoids issues with VoiceOver on iOS
+    // causing the page to scroll when moving focus if the element is transitioning
+    // from off the screen.
+    if ($507fabe10e71c6fb$export$630ff653c5ada6a9() === 'virtual') {
+        let lastFocusedElement = document.activeElement;
+        $bbed8b41f857bcc0$export$24490316f764c430(()=>{
+            // If focus did not move and the element is still in the document, focus it.
+            if (document.activeElement === lastFocusedElement && document.contains(element)) $7215afc6de606d6b$export$de79e2c695e052f3(element);
+        });
+    } else $7215afc6de606d6b$export$de79e2c695e052f3(element);
+}
+
+
+/*
+ * Copyright 2021 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 $645f2e67b85a24c9$var$isStyleVisible(element) {
+    if (!(element instanceof HTMLElement) && !(element instanceof SVGElement)) return false;
+    let { display: display , visibility: visibility  } = element.style;
+    let isVisible = display !== 'none' && visibility !== 'hidden' && visibility !== 'collapse';
+    if (isVisible) {
+        const { getComputedStyle: getComputedStyle  } = element.ownerDocument.defaultView;
+        let { display: computedDisplay , visibility: computedVisibility  } = getComputedStyle(element);
+        isVisible = computedDisplay !== 'none' && computedVisibility !== 'hidden' && computedVisibility !== 'collapse';
+    }
+    return isVisible;
+}
+function $645f2e67b85a24c9$var$isAttributeVisible(element, childElement) {
+    return !element.hasAttribute('hidden') && (element.nodeName === 'DETAILS' && childElement && childElement.nodeName !== 'SUMMARY' ? element.hasAttribute('open') : true);
+}
+function $645f2e67b85a24c9$export$e989c0fffaa6b27a(element, childElement) {
+    return element.nodeName !== '#comment' && $645f2e67b85a24c9$var$isStyleVisible(element) && $645f2e67b85a24c9$var$isAttributeVisible(element, childElement) && (!element.parentElement || $645f2e67b85a24c9$export$e989c0fffaa6b27a(element.parentElement, element));
+}
+
+
+
+
+const $9bf71ea28793e738$var$FocusContext = /*#__PURE__*/ React.createContext(null);
+let $9bf71ea28793e738$var$activeScope = null;
+let $9bf71ea28793e738$var$scopes = new Map();
+function $9bf71ea28793e738$export$20e40289641fbbb6(props) {
+    let { children: children , contain: contain , restoreFocus: restoreFocus , autoFocus: autoFocus  } = props;
+    let startRef = useRef();
+    let endRef = useRef();
+    let scopeRef = useRef([]);
+    let ctx = useContext($9bf71ea28793e738$var$FocusContext);
+    let parentScope = ctx === null || ctx === void 0 ? void 0 : ctx.scopeRef;
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        // Find all rendered nodes between the sentinels and add them to the scope.
+        let node = startRef.current.nextSibling;
+        let nodes = [];
+        while(node && node !== endRef.current){
+            nodes.push(node);
+            node = node.nextSibling;
+        }
+        scopeRef.current = nodes;
+    }, [
+        children,
+        parentScope
+    ]);
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        $9bf71ea28793e738$var$scopes.set(scopeRef, parentScope);
+        return ()=>{
+            // Restore the active scope on unmount if this scope or a descendant scope is active.
+            // Parent effect cleanups run before children, so we need to check if the
+            // parent scope actually still exists before restoring the active scope to it.
+            if ((scopeRef === $9bf71ea28793e738$var$activeScope || $9bf71ea28793e738$var$isAncestorScope(scopeRef, $9bf71ea28793e738$var$activeScope)) && (!parentScope || $9bf71ea28793e738$var$scopes.has(parentScope))) $9bf71ea28793e738$var$activeScope = parentScope;
+            $9bf71ea28793e738$var$scopes.delete(scopeRef);
+        };
+    }, [
+        scopeRef,
+        parentScope
+    ]);
+    $9bf71ea28793e738$var$useFocusContainment(scopeRef, contain);
+    $9bf71ea28793e738$var$useRestoreFocus(scopeRef, restoreFocus, contain);
+    $9bf71ea28793e738$var$useAutoFocus(scopeRef, autoFocus);
+    let focusManager = $9bf71ea28793e738$var$createFocusManagerForScope(scopeRef);
+    return(/*#__PURE__*/ React.createElement($9bf71ea28793e738$var$FocusContext.Provider, {
+        value: {
+            scopeRef: scopeRef,
+            focusManager: focusManager
+        }
+    }, /*#__PURE__*/ React.createElement("span", {
+        "data-focus-scope-start": true,
+        hidden: true,
+        ref: startRef
+    }), children, /*#__PURE__*/ React.createElement("span", {
+        "data-focus-scope-end": true,
+        hidden: true,
+        ref: endRef
+    })));
+}
+function $9bf71ea28793e738$export$10c5169755ce7bd7() {
+    var ref;
+    return (ref = useContext($9bf71ea28793e738$var$FocusContext)) === null || ref === void 0 ? void 0 : ref.focusManager;
+}
+function $9bf71ea28793e738$var$createFocusManagerForScope(scopeRef) {
+    return {
+        focusNext (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { from: from , tabbable: tabbable , wrap: wrap  } = opts;
+            let node = from || document.activeElement;
+            let sentinel = scope[0].previousElementSibling;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = $9bf71ea28793e738$var$isElementInScope(node, scope) ? node : sentinel;
+            let nextNode = walker.nextNode();
+            if (!nextNode && wrap) {
+                walker.currentNode = sentinel;
+                nextNode = walker.nextNode();
+            }
+            if (nextNode) $9bf71ea28793e738$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusPrevious (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { from: from , tabbable: tabbable , wrap: wrap  } = opts;
+            let node = from || document.activeElement;
+            let sentinel = scope[scope.length - 1].nextElementSibling;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = $9bf71ea28793e738$var$isElementInScope(node, scope) ? node : sentinel;
+            let previousNode = walker.previousNode();
+            if (!previousNode && wrap) {
+                walker.currentNode = sentinel;
+                previousNode = walker.previousNode();
+            }
+            if (previousNode) $9bf71ea28793e738$var$focusElement(previousNode, true);
+            return previousNode;
+        },
+        focusFirst (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = scope[0].previousElementSibling;
+            let nextNode = walker.nextNode();
+            if (nextNode) $9bf71ea28793e738$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusLast (opts = {
+        }) {
+            let scope = scopeRef.current;
+            let { tabbable: tabbable  } = opts;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {
+                tabbable: tabbable
+            }, scope);
+            walker.currentNode = scope[scope.length - 1].nextElementSibling;
+            let previousNode = walker.previousNode();
+            if (previousNode) $9bf71ea28793e738$var$focusElement(previousNode, true);
+            return previousNode;
+        }
+    };
+}
+const $9bf71ea28793e738$var$focusableElements = [
+    'input:not([disabled]):not([type=hidden])',
+    'select:not([disabled])',
+    'textarea:not([disabled])',
+    'button:not([disabled])',
+    'a[href]',
+    'area[href]',
+    'summary',
+    'iframe',
+    'object',
+    'embed',
+    'audio[controls]',
+    'video[controls]',
+    '[contenteditable]'
+];
+const $9bf71ea28793e738$var$FOCUSABLE_ELEMENT_SELECTOR = $9bf71ea28793e738$var$focusableElements.join(':not([hidden]),') + ',[tabindex]:not([disabled]):not([hidden])';
+$9bf71ea28793e738$var$focusableElements.push('[tabindex]:not([tabindex="-1"]):not([disabled])');
+const $9bf71ea28793e738$var$TABBABLE_ELEMENT_SELECTOR = $9bf71ea28793e738$var$focusableElements.join(':not([hidden]):not([tabindex="-1"]),');
+function $9bf71ea28793e738$var$getScopeRoot(scope) {
+    return scope[0].parentElement;
+}
+function $9bf71ea28793e738$var$useFocusContainment(scopeRef, contain) {
+    let focusedNode = useRef();
+    let raf = useRef(null);
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        let scope1 = scopeRef.current;
+        if (!contain) return;
+        // Handle the Tab key to contain focus within the scope
+        let onKeyDown = (e)=>{
+            if (e.key !== 'Tab' || e.altKey || e.ctrlKey || e.metaKey || scopeRef !== $9bf71ea28793e738$var$activeScope) return;
+            let focusedElement = document.activeElement;
+            let scope = scopeRef.current;
+            if (!$9bf71ea28793e738$var$isElementInScope(focusedElement, scope)) return;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {
+                tabbable: true
+            }, scope);
+            walker.currentNode = focusedElement;
+            let nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
+            if (!nextElement) {
+                walker.currentNode = e.shiftKey ? scope[scope.length - 1].nextElementSibling : scope[0].previousElementSibling;
+                nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
+            }
+            e.preventDefault();
+            if (nextElement) $9bf71ea28793e738$var$focusElement(nextElement, true);
+        };
+        let onFocus = (e)=>{
+            // If focusing an element in a child scope of the currently active scope, the child becomes active.
+            // Moving out of the active scope to an ancestor is not allowed.
+            if (!$9bf71ea28793e738$var$activeScope || $9bf71ea28793e738$var$isAncestorScope($9bf71ea28793e738$var$activeScope, scopeRef)) {
+                $9bf71ea28793e738$var$activeScope = scopeRef;
+                focusedNode.current = e.target;
+            } else if (scopeRef === $9bf71ea28793e738$var$activeScope && !$9bf71ea28793e738$var$isElementInChildScope(e.target, scopeRef)) {
+                // If a focus event occurs outside the active scope (e.g. user tabs from browser location bar),
+                // restore focus to the previously focused node or the first tabbable element in the active scope.
+                if (focusedNode.current) focusedNode.current.focus();
+                else if ($9bf71ea28793e738$var$activeScope) $9bf71ea28793e738$var$focusFirstInScope($9bf71ea28793e738$var$activeScope.current);
+            } else if (scopeRef === $9bf71ea28793e738$var$activeScope) focusedNode.current = e.target;
+        };
+        let onBlur = (e)=>{
+            // Firefox doesn't shift focus back to the Dialog properly without this
+            raf.current = requestAnimationFrame(()=>{
+                // Use document.activeElement instead of e.relatedTarget so we can tell if user clicked into iframe
+                if (scopeRef === $9bf71ea28793e738$var$activeScope && !$9bf71ea28793e738$var$isElementInChildScope(document.activeElement, scopeRef)) {
+                    $9bf71ea28793e738$var$activeScope = scopeRef;
+                    focusedNode.current = e.target;
+                    focusedNode.current.focus();
+                }
+            });
+        };
+        document.addEventListener('keydown', onKeyDown, false);
+        document.addEventListener('focusin', onFocus, false);
+        scope1.forEach((element)=>element.addEventListener('focusin', onFocus, false)
+        );
+        scope1.forEach((element)=>element.addEventListener('focusout', onBlur, false)
+        );
+        return ()=>{
+            document.removeEventListener('keydown', onKeyDown, false);
+            document.removeEventListener('focusin', onFocus, false);
+            scope1.forEach((element)=>element.removeEventListener('focusin', onFocus, false)
+            );
+            scope1.forEach((element)=>element.removeEventListener('focusout', onBlur, false)
+            );
+        };
+    }, [
+        scopeRef,
+        contain
+    ]);
+    // eslint-disable-next-line arrow-body-style
+    useEffect(()=>{
+        return ()=>cancelAnimationFrame(raf.current)
+        ;
+    }, [
+        raf
+    ]);
+}
+function $9bf71ea28793e738$var$isElementInAnyScope(element) {
+    for (let scope of $9bf71ea28793e738$var$scopes.keys()){
+        if ($9bf71ea28793e738$var$isElementInScope(element, scope.current)) return true;
+    }
+    return false;
+}
+function $9bf71ea28793e738$var$isElementInScope(element, scope) {
+    return scope.some((node)=>node.contains(element)
+    );
+}
+function $9bf71ea28793e738$var$isElementInChildScope(element, scope) {
+    // node.contains in isElementInScope covers child scopes that are also DOM children,
+    // but does not cover child scopes in portals.
+    for (let s of $9bf71ea28793e738$var$scopes.keys()){
+        if ((s === scope || $9bf71ea28793e738$var$isAncestorScope(scope, s)) && $9bf71ea28793e738$var$isElementInScope(element, s.current)) return true;
+    }
+    return false;
+}
+function $9bf71ea28793e738$var$isAncestorScope(ancestor, scope) {
+    let parent = $9bf71ea28793e738$var$scopes.get(scope);
+    if (!parent) return false;
+    if (parent === ancestor) return true;
+    return $9bf71ea28793e738$var$isAncestorScope(ancestor, parent);
+}
+function $9bf71ea28793e738$var$focusElement(element, scroll = false) {
+    if (element != null && !scroll) try {
+        $6a99195332edec8b$export$80f3e147d781571c(element);
+    } catch (err) {
+    // ignore
+    }
+    else if (element != null) try {
+        element.focus();
+    } catch (err1) {
+    // ignore
+    }
+}
+function $9bf71ea28793e738$var$focusFirstInScope(scope) {
+    let sentinel = scope[0].previousElementSibling;
+    let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {
+        tabbable: true
+    }, scope);
+    walker.currentNode = sentinel;
+    $9bf71ea28793e738$var$focusElement(walker.nextNode());
+}
+function $9bf71ea28793e738$var$useAutoFocus(scopeRef, autoFocus) {
+    const autoFocusRef = React.useRef(autoFocus);
+    useEffect(()=>{
+        if (autoFocusRef.current) {
+            $9bf71ea28793e738$var$activeScope = scopeRef;
+            if (!$9bf71ea28793e738$var$isElementInScope(document.activeElement, $9bf71ea28793e738$var$activeScope.current)) $9bf71ea28793e738$var$focusFirstInScope(scopeRef.current);
+        }
+        autoFocusRef.current = false;
+    }, []);
+}
+function $9bf71ea28793e738$var$useRestoreFocus(scopeRef, restoreFocus, contain) {
+    // create a ref during render instead of useLayoutEffect so the active element is saved before a child with autoFocus=true mounts.
+    const nodeToRestoreRef = useRef(typeof document !== 'undefined' ? document.activeElement : null);
+    // useLayoutEffect instead of useEffect so the active element is saved synchronously instead of asynchronously.
+    $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(()=>{
+        let nodeToRestore = nodeToRestoreRef.current;
+        if (!restoreFocus) return;
+        // Handle the Tab key so that tabbing out of the scope goes to the next element
+        // after the node that had focus when the scope mounted. This is important when
+        // using portals for overlays, so that focus goes to the expected element when
+        // tabbing out of the overlay.
+        let onKeyDown = (e)=>{
+            if (e.key !== 'Tab' || e.altKey || e.ctrlKey || e.metaKey) return;
+            let focusedElement = document.activeElement;
+            if (!$9bf71ea28793e738$var$isElementInScope(focusedElement, scopeRef.current)) return;
+            // Create a DOM tree walker that matches all tabbable elements
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(document.body, {
+                tabbable: true
+            });
+            // Find the next tabbable element after the currently focused element
+            walker.currentNode = focusedElement;
+            let nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
+            if (!document.body.contains(nodeToRestore) || nodeToRestore === document.body) nodeToRestore = null;
+            // If there is no next element, or it is outside the current scope, move focus to the
+            // next element after the node to restore to instead.
+            if ((!nextElement || !$9bf71ea28793e738$var$isElementInScope(nextElement, scopeRef.current)) && nodeToRestore) {
+                walker.currentNode = nodeToRestore;
+                // Skip over elements within the scope, in case the scope immediately follows the node to restore.
+                do nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();
+                while ($9bf71ea28793e738$var$isElementInScope(nextElement, scopeRef.current))
+                e.preventDefault();
+                e.stopPropagation();
+                if (nextElement) $9bf71ea28793e738$var$focusElement(nextElement, true);
+                else // If there is no next element and the nodeToRestore isn't within a FocusScope (i.e. we are leaving the top level focus scope)
+                // then move focus to the body.
+                // Otherwise restore focus to the nodeToRestore (e.g menu within a popover -> tabbing to close the menu should move focus to menu trigger)
+                if (!$9bf71ea28793e738$var$isElementInAnyScope(nodeToRestore)) focusedElement.blur();
+                else $9bf71ea28793e738$var$focusElement(nodeToRestore, true);
+            }
+        };
+        if (!contain) document.addEventListener('keydown', onKeyDown, true);
+        return ()=>{
+            if (!contain) document.removeEventListener('keydown', onKeyDown, true);
+            if (restoreFocus && nodeToRestore && $9bf71ea28793e738$var$isElementInScope(document.activeElement, scopeRef.current)) requestAnimationFrame(()=>{
+                if (document.body.contains(nodeToRestore)) $9bf71ea28793e738$var$focusElement(nodeToRestore);
+            });
+        };
+    }, [
+        scopeRef,
+        restoreFocus,
+        contain
+    ]);
+}
+function $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, opts, scope) {
+    let selector = (opts === null || opts === void 0 ? void 0 : opts.tabbable) ? $9bf71ea28793e738$var$TABBABLE_ELEMENT_SELECTOR : $9bf71ea28793e738$var$FOCUSABLE_ELEMENT_SELECTOR;
+    let walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
+        acceptNode (node) {
+            var ref;
+            // Skip nodes inside the starting node.
+            if (opts === null || opts === void 0 ? void 0 : (ref = opts.from) === null || ref === void 0 ? void 0 : ref.contains(node)) return NodeFilter.FILTER_REJECT;
+            if (node.matches(selector) && $645f2e67b85a24c9$export$e989c0fffaa6b27a(node) && (!scope || $9bf71ea28793e738$var$isElementInScope(node, scope)) && (!(opts === null || opts === void 0 ? void 0 : opts.accept) || opts.accept(node))) return NodeFilter.FILTER_ACCEPT;
+            return NodeFilter.FILTER_SKIP;
+        }
+    });
+    if (opts === null || opts === void 0 ? void 0 : opts.from) walker.currentNode = opts.from;
+    return walker;
+}
+function $9bf71ea28793e738$export$c5251b9e124bf29(ref, defaultOptions = {
+}) {
+    return {
+        focusNext (opts = {
+        }) {
+            let root = ref.current;
+            if (!root) return;
+            let { from: from , tabbable: tabbable = defaultOptions.tabbable , wrap: wrap = defaultOptions.wrap , accept: accept = defaultOptions.accept  } = opts;
+            let node = from || document.activeElement;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable,
+                accept: accept
+            });
+            if (root.contains(node)) walker.currentNode = node;
+            let nextNode = walker.nextNode();
+            if (!nextNode && wrap) {
+                walker.currentNode = root;
+                nextNode = walker.nextNode();
+            }
+            if (nextNode) $9bf71ea28793e738$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusPrevious (opts = defaultOptions) {
+            let root = ref.current;
+            if (!root) return;
+            let { from: from , tabbable: tabbable = defaultOptions.tabbable , wrap: wrap = defaultOptions.wrap , accept: accept = defaultOptions.accept  } = opts;
+            let node = from || document.activeElement;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable,
+                accept: accept
+            });
+            if (root.contains(node)) walker.currentNode = node;
+            else {
+                let next = $9bf71ea28793e738$var$last(walker);
+                if (next) $9bf71ea28793e738$var$focusElement(next, true);
+                return next;
+            }
+            let previousNode = walker.previousNode();
+            if (!previousNode && wrap) {
+                walker.currentNode = root;
+                previousNode = $9bf71ea28793e738$var$last(walker);
+            }
+            if (previousNode) $9bf71ea28793e738$var$focusElement(previousNode, true);
+            return previousNode;
+        },
+        focusFirst (opts = defaultOptions) {
+            let root = ref.current;
+            if (!root) return;
+            let { tabbable: tabbable = defaultOptions.tabbable , accept: accept = defaultOptions.accept  } = opts;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable,
+                accept: accept
+            });
+            let nextNode = walker.nextNode();
+            if (nextNode) $9bf71ea28793e738$var$focusElement(nextNode, true);
+            return nextNode;
+        },
+        focusLast (opts = defaultOptions) {
+            let root = ref.current;
+            if (!root) return;
+            let { tabbable: tabbable = defaultOptions.tabbable , accept: accept = defaultOptions.accept  } = opts;
+            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, {
+                tabbable: tabbable,
+                accept: accept
+            });
+            let next = $9bf71ea28793e738$var$last(walker);
+            if (next) $9bf71ea28793e738$var$focusElement(next, true);
+            return next;
+        }
+    };
+}
+function $9bf71ea28793e738$var$last(walker) {
+    let next;
+    let last;
+    do {
+        last = walker.lastChild();
+        if (last) next = last;
+    }while (last)
+    return next;
+}
+
+
+var $907718708eab68af$exports = {};
+
+$parcel$export$1($907718708eab68af$exports, "FocusRing", () => $907718708eab68af$export$1a38b4ad7f578e1d);
+
+
+
+var $f7dceffc5ad7768b$exports = {};
+
+$parcel$export$1($f7dceffc5ad7768b$exports, "useFocusRing", () => $f7dceffc5ad7768b$export$4e328f61c538687f);
+
+
+
+function $f7dceffc5ad7768b$export$4e328f61c538687f(props = {
+}) {
+    let { autoFocus: autoFocus = false , isTextInput: isTextInput , within: within  } = props;
+    let state = useRef({
+        isFocused: false,
+        isFocusVisible: autoFocus || $507fabe10e71c6fb$export$b9b3dfddab17db27()
+    });
+    let [isFocused1, setFocused] = useState(false);
+    let [isFocusVisibleState, setFocusVisible] = useState(()=>state.current.isFocused && state.current.isFocusVisible
+    );
+    let updateState = useCallback(()=>setFocusVisible(state.current.isFocused && state.current.isFocusVisible)
+    , []);
+    let onFocusChange = useCallback((isFocused)=>{
+        state.current.isFocused = isFocused;
+        setFocused(isFocused);
+        updateState();
+    }, [
+        updateState
+    ]);
+    $507fabe10e71c6fb$export$ec71b4b83ac08ec3((isFocusVisible)=>{
+        state.current.isFocusVisible = isFocusVisible;
+        updateState();
+    }, [], {
+        isTextInput: isTextInput
+    });
+    let { focusProps: focusProps  } = $a1ea59d68270f0dd$export$f8168d8dd8fd66e6({
+        isDisabled: within,
+        onFocusChange: onFocusChange
+    });
+    let { focusWithinProps: focusWithinProps  } = $9ab94262bd0047c7$export$420e68273165f4ec({
+        isDisabled: !within,
+        onFocusWithinChange: onFocusChange
+    });
+    return {
+        isFocused: isFocused1,
+        isFocusVisible: state.current.isFocused && isFocusVisibleState,
+        focusProps: within ? focusWithinProps : focusProps
+    };
+}
+
+
+function $907718708eab68af$export$1a38b4ad7f578e1d(props) {
+    let { children: children , focusClass: focusClass , focusRingClass: focusRingClass  } = props;
+    let { isFocused: isFocused , isFocusVisible: isFocusVisible , focusProps: focusProps  } = $f7dceffc5ad7768b$export$4e328f61c538687f(props);
+    let child = React.Children.only(children);
+    return(/*#__PURE__*/ React.cloneElement(child, $3ef42575df84b30b$export$9d1611c77c2fe928(child.props, {
+        ...focusProps,
+        className: clsx({
+            [focusClass || '']: isFocused,
+            [focusRingClass || '']: isFocusVisible
+        })
+    })));
+}
+
+
+var $e6afbd83fe6ebbd2$exports = {};
+
+$parcel$export$1($e6afbd83fe6ebbd2$exports, "FocusableProvider", () => $e6afbd83fe6ebbd2$export$13f3202a3e5ddd5);
+$parcel$export$1($e6afbd83fe6ebbd2$exports, "useFocusable", () => $e6afbd83fe6ebbd2$export$4c014de7c8940b4c);
+
+
+
+
+let $e6afbd83fe6ebbd2$var$FocusableContext = /*#__PURE__*/ React.createContext(null);
+function $e6afbd83fe6ebbd2$var$useFocusableContext(ref) {
+    let context = useContext($e6afbd83fe6ebbd2$var$FocusableContext) || {
+    };
+    $e7801be82b4b2a53$export$4debdb1a3f0fa79e(context, ref);
+    // eslint-disable-next-line
+    let { ref: _ , ...otherProps } = context;
+    return otherProps;
+}
+/**
+ * Provides DOM props to the nearest focusable child.
+ */ function $e6afbd83fe6ebbd2$var$FocusableProvider(props, ref) {
+    let { children: children , ...otherProps } = props;
+    let context = {
+        ...otherProps,
+        ref: ref
+    };
+    return(/*#__PURE__*/ React.createElement($e6afbd83fe6ebbd2$var$FocusableContext.Provider, {
+        value: context
+    }, children));
+}
+let $e6afbd83fe6ebbd2$export$13f3202a3e5ddd5 = /*#__PURE__*/ React.forwardRef($e6afbd83fe6ebbd2$var$FocusableProvider);
+function $e6afbd83fe6ebbd2$export$4c014de7c8940b4c(props, domRef) {
+    let { focusProps: focusProps  } = $a1ea59d68270f0dd$export$f8168d8dd8fd66e6(props);
+    let { keyboardProps: keyboardProps  } = $46d819fcbaf35654$export$8f71654801c2f7cd(props);
+    let interactions = $3ef42575df84b30b$export$9d1611c77c2fe928(focusProps, keyboardProps);
+    let domProps = $e6afbd83fe6ebbd2$var$useFocusableContext(domRef);
+    let interactionProps = props.isDisabled ? {
+    } : domProps;
+    let autoFocusRef = useRef(props.autoFocus);
+    useEffect(()=>{
+        if (autoFocusRef.current && domRef.current) $6a99195332edec8b$export$80f3e147d781571c(domRef.current);
+        autoFocusRef.current = false;
+    }, [
+        domRef
+    ]);
+    return {
+        focusableProps: $3ef42575df84b30b$export$9d1611c77c2fe928({
+            ...interactions,
+            tabIndex: props.excludeFromTabOrder && !props.isDisabled ? -1 : undefined
+        }, interactionProps)
+    };
+}
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $701a24aa0da5b062$exports = {};
+
+$parcel$export($701a24aa0da5b062$exports, "useButton", () => $701a24aa0da5b062$export$ea18c227d4417cc3);
+
+
+
+
+function $701a24aa0da5b062$export$ea18c227d4417cc3(props, ref) {
+    let { elementType: elementType = 'button' , isDisabled: isDisabled , onPress: onPress , onPressStart: onPressStart , onPressEnd: onPressEnd , onPressChange: onPressChange , preventFocusOnPress: // @ts-ignore - undocumented
+    preventFocusOnPress , allowFocusWhenDisabled: // @ts-ignore - undocumented
+    allowFocusWhenDisabled , // @ts-ignore
+    onClick: deprecatedOnClick , href: href , target: target , rel: rel , type: type = 'button'  } = props;
+    let additionalProps;
+    if (elementType === 'button') additionalProps = {
+        type: type,
+        disabled: isDisabled
+    };
+    else additionalProps = {
+        role: 'button',
+        tabIndex: isDisabled ? undefined : 0,
+        href: elementType === 'a' && isDisabled ? undefined : href,
+        target: elementType === 'a' ? target : undefined,
+        type: elementType === 'input' ? type : undefined,
+        disabled: elementType === 'input' ? isDisabled : undefined,
+        'aria-disabled': !isDisabled || elementType === 'input' ? undefined : isDisabled,
+        rel: elementType === 'a' ? rel : undefined
+    };
+    let { pressProps: pressProps , isPressed: isPressed  } = $f6c31cce2adf654f$export$45712eceda6fad21({
+        onPressStart: onPressStart,
+        onPressEnd: onPressEnd,
+        onPressChange: onPressChange,
+        onPress: onPress,
+        isDisabled: isDisabled,
+        preventFocusOnPress: preventFocusOnPress,
+        ref: ref
+    });
+    let { focusableProps: focusableProps  } = $e6afbd83fe6ebbd2$export$4c014de7c8940b4c(props, ref);
+    if (allowFocusWhenDisabled) focusableProps.tabIndex = isDisabled ? -1 : focusableProps.tabIndex;
+    let buttonProps = $3ef42575df84b30b$export$9d1611c77c2fe928(focusableProps, pressProps, $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, {
+        labelable: true
+    }));
+    return {
+        isPressed: isPressed,
+        buttonProps: $3ef42575df84b30b$export$9d1611c77c2fe928(additionalProps, buttonProps, {
+            'aria-haspopup': props['aria-haspopup'],
+            'aria-expanded': props['aria-expanded'],
+            'aria-controls': props['aria-controls'],
+            'aria-pressed': props['aria-pressed'],
+            onClick: (e)=>{
+                if (deprecatedOnClick) {
+                    deprecatedOnClick(e);
+                    console.warn('onClick is deprecated, please use onPress');
+                }
+            }
+        })
+    };
+}
+
+
+var $55f54f7887471b58$exports = {};
+
+$parcel$export($55f54f7887471b58$exports, "useToggleButton", () => $55f54f7887471b58$export$51e84d46ca0bc451);
+
+
+
+function $55f54f7887471b58$export$51e84d46ca0bc451(props, state, ref) {
+    const { isSelected: isSelected  } = state;
+    const { isPressed: isPressed , buttonProps: buttonProps  } = $701a24aa0da5b062$export$ea18c227d4417cc3({
+        ...props,
+        onPress: $ff5963eb1fccf552$export$e08e3b67e392101e(state.toggle, props.onPress)
+    }, ref);
+    return {
+        isPressed: isPressed,
+        buttonProps: $3ef42575df84b30b$export$9d1611c77c2fe928(buttonProps, {
+            'aria-pressed': isSelected
+        })
+    };
+}
+
+/**
+ * Component size.
+ */
+const IconSize = {
+  large: 'large',
+  medium: 'medium',
+  small: 'small'
+};
+
+/**
+ * Component style.
+ */
+const StyledIcon = styled.span`
+  font-style: normal;
+  position: relative;
+
+  ${_ref => {
+  let {
+    $color
+  } = _ref;
+  return $color && Object.keys(ColorPalette).indexOf($color) !== -1 ? css`
+    color: var(--redsift-color-${$color}-main);
+  ` : css`
+    color: ${$color || css`var(--redsift-color-action-active)`};
+  `;
+}}
+
+  ${_ref2 => {
+  let {
+    $size
+  } = _ref2;
+  switch ($size) {
+    case IconSize.large:
+      return css`
+          font-size: 35px;
+          height: 35px;
+          line-height: 35px;
+          width: 35px;
+      
+          & .redsift-badge-standard {
+            position: absolute;
+            right: -23px;
+            top: 0px;
+          }
+        
+          & .redsift-badge-dot {
+            position: absolute;
+            right: -7px;
+            top: 4px;
+          }
+        `;
+    case IconSize.small:
+      return css`
+          font-size: 20px;
+          height: 20px;
+          line-height: 20px;
+          width: 20px;
+      
+          & .redsift-badge-standard {
+            position: absolute;
+            right: -24px;
+            top: -8px;
+          }
+        
+          & .redsift-badge-dot {
+            position: absolute;
+            right: -8px;
+            top: 1px;
+          }
+        `;
+    case IconSize.medium:
+    default:
+      return css`
+          font-size: 24px;
+          height: 24px;
+          line-height: 24px;
+          width: 24px;
+      
+          & .redsift-badge-standard {
+            position: absolute;
+            right: -24px;
+            top: -6px;
+          }
+        
+          & .redsift-badge-dot {
+            position: absolute;
+            right: -8px;
+            top: 2px;
+          }
+        `;
+  }
+}}
+`;
+
+const _excluded$3 = ["aria-hidden", "aria-label", "badge", "className", "color", "icon", "size", "svgProps"];
+const COMPONENT_NAME$4 = 'RedSiftIcon';
+const CLASSNAME$4 = 'redsift-icon';
+const DEFAULT_PROPS$3 = {
+  size: IconSize.medium
+};
+
+/**
+ * The Icon component.
+ */
+const Icon = /*#__PURE__*/forwardRef((props, ref) => {
+  const iconRef = ref || useRef();
+  let {
+      'aria-hidden': ariaHidden,
+      'aria-label': ariaLabel,
+      badge,
+      className,
+      color,
+      icon,
+      size,
+      svgProps
+    } = props,
+    forwardedProps = _objectWithoutProperties(props, _excluded$3);
+  if (!ariaHidden) {
+    ariaHidden = undefined;
+  }
+  return /*#__PURE__*/React.createElement(StyledIcon, _extends({}, forwardedProps, {
+    $color: color,
+    $size: size,
+    "aria-hidden": ariaLabel ? ariaHidden || undefined : true,
+    "aria-label": ariaLabel,
+    className: classNames(Icon.className, className),
+    ref: iconRef
+  }), /*#__PURE__*/React.createElement("svg", _extends({}, svgProps, {
+    "aria-hidden": ariaLabel ? ariaHidden || undefined : true,
+    "aria-label": ariaLabel,
+    focusable: "false",
+    height: "1em",
+    preserveAspectRatio: "xMidYMid meet",
+    role: "img",
+    style: {
+      verticalAlign: '-0.125em'
+    },
+    viewBox: "0 0 24 24",
+    width: "1em"
+  }), /*#__PURE__*/React.createElement("path", {
+    d: icon,
+    fill: "currentColor"
+  })), badge ? badge : null);
+});
+Icon.className = CLASSNAME$4;
+Icon.defaultProps = DEFAULT_PROPS$3;
+Icon.displayName = COMPONENT_NAME$4;
+
+/**
+ * Component variant.
+ */
+const ButtonVariant = {
+  contained: 'contained',
+  outlined: 'outlined',
+  text: 'text'
+};
+/**
+ * Component size.
+ */
+const ButtonSize = {
+  large: 'large',
+  medium: 'medium',
+  small: 'small'
+};
+
+/**
+ * Component style.
+ */
+const StyledButton = styled.button`
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  text-decoration: none;
+
+  ${_ref => {
+  let {
+    $variant,
+    $color,
+    $size,
+    $isDisabled
+  } = _ref;
+  switch ($variant) {
+    case ButtonVariant.outlined:
+      return css`
+          border: 1px solid ${$isDisabled ? 'var(--redsift-color-action-disabled-background)' : `var(--redsift-color-${$color}-outlined-resting)`};
+          background-color: transparent;
+          &, .redsift-icon {
+            color: ${$isDisabled ? 'var(--redsift-color-action-disabled)' : `var(--redsift-color-${$color}-main)`};
+          }
+
+          padding: ${$size === ButtonSize.small ? '4px 8px' : $size === ButtonSize.medium ? '6px 16px' : '8px 24px'};
+        `;
+    case ButtonVariant.text:
+      return css`
+          border: none;
+          background-color: transparent;
+          &, .redsift-icon {
+            color: ${$isDisabled ? 'var(--redsift-color-action-disabled)' : `var(--redsift-color-${$color}-main)`};
+          }
+
+          padding: ${$size === ButtonSize.small ? '4px 4px' : $size === ButtonSize.medium ? '6px 8px' : '8px 8px'};
+        `;
+    case ButtonVariant.contained:
+    default:
+      return css`
+          border: none;
+          background-color: ${$isDisabled ? 'var(--redsift-color-action-disabled-background)' : `var(--redsift-color-${$color}-main)`};
+          &, .redsift-icon {
+            color: ${$isDisabled ? 'var(--redsift-color-action-disabled)' : `var(--redsift-color-${$color}-contrast)`};
+          }
+
+          padding: ${$size === ButtonSize.small ? '4px 8px' : $size === ButtonSize.medium ? '6px 16px' : '8px 24px'};
+        `;
+  }
+}}
+
+  font-family: ${_ref2 => {
+  let {
+    $size
+  } = _ref2;
+  return `var(--redsift-typography-button-${$size}-font-family)`;
+}};
+  font-weight: ${_ref3 => {
+  let {
+    $size
+  } = _ref3;
+  return `var(--redsift-typography-button-${$size}-font-weight)`;
+}};
+  font-size: ${_ref4 => {
+  let {
+    $size
+  } = _ref4;
+  return `var(--redsift-typography-button-${$size}-font-size)`;
+}};
+  line-height: ${_ref5 => {
+  let {
+    $size
+  } = _ref5;
+  return `var(--redsift-typography-button-${$size}-line-height)`;
+}};
+  text-transform: ${_ref6 => {
+  let {
+    $size
+  } = _ref6;
+  return `var(--redsift-typography-button-${$size}-text-transform)`;
+}};
+
+  .redsift-icon {
+    ${_ref7 => {
+  let {
+    $size
+  } = _ref7;
+  return $size === ButtonSize.large ? `
+      height: 24px;
+      width: 24px;
+      font-size: 24px;
+      line-height: 24px;
+    ` : '';
+}}
+
+    ${_ref8 => {
+  let {
+    $size
+  } = _ref8;
+  return $size === ButtonSize.medium ? `
+      height: 20px;
+      width: 20px;
+      font-size: 20px;
+      line-height: 20px;
+    ` : '';
+}}
+
+    ${_ref9 => {
+  let {
+    $size
+  } = _ref9;
+  return $size === ButtonSize.small ? `
+      height: 18px;
+      width: 18px;
+      font-size: 18px;
+      line-height: 18px;
+    ` : '';
+}}
+  }
+
+  .redsift-icon.left {
+    margin-right: 8px;
+  }
+
+  .redsift-icon.right {
+    margin-left: 8px;
+  }
+
+  &:hover,
+  &:focus-visible {
+    outline: none;
+
+    ${_ref10 => {
+  let {
+    $isDisabled,
+    $variant,
+    $color
+  } = _ref10;
+  return !$isDisabled ? css`
+      cursor: pointer;
+
+      ${$variant === ButtonVariant.contained ? css`
+        background-color: var(--redsift-color-${$color}-contained-hover);
+      ` : ''}
+
+      ${$variant === ButtonVariant.outlined ? css`
+        background-color: var(--redsift-color-${$color}-outlined-hover);
+      ` : ''}
+
+      ${$variant === ButtonVariant.text ? css`
+        background-color: var(--redsift-color-${$color}-outlined-hover);
+      ` : ''}
+    ` : '';
+}}
+  }
+
+  ${_ref11 => {
+  let {
+    $fullWidth
+  } = _ref11;
+  return $fullWidth ? `
+    width: 100%;
+    flex-grow: 1;
+
+    .redsift-icon.left {
+      margin-right: unset;
+    }
+
+    .redsift-icon.right {
+      margin-left: unset;
+    }
+
+    span {
+      margin-right: 8px;
+      margin-left: 8px;
+    }
+  ` : '';
+}}
+`;
+
+const _excluded$2 = ["children", "className", "color", "disabled", "fullWidth", "isDisabled", "leftIcon", "onPress", "rightIcon", "size", "variant"];
+const COMPONENT_NAME$3 = 'RedSiftButton';
+const CLASSNAME$3 = 'redsift-button';
+const DEFAULT_PROPS$2 = {
+  color: ColorPalette.primary,
+  size: ButtonSize.large,
+  variant: ButtonVariant.contained
+};
+
+/**
+ * The Button is a semantic button that looks like a button.
+ * 
+ * For a semantic link that looks like a button, please use the ButtonLink component.
+ * For a semantic link that looks like a link, please use the Link component.
+ * For a semantic button that looks like a link, please use the LinkButton component.
+ */
+const Button = /*#__PURE__*/forwardRef((props, ref) => {
+  const buttonRef = ref || useRef();
+  const {
+    buttonProps
+  } = $701a24aa0da5b062$export$ea18c227d4417cc3(_objectSpread2(_objectSpread2({}, props), {}, {
+    preventFocusOnPress: true
+  }), buttonRef);
+  const {
+      children,
+      className,
+      color,
+      disabled,
+      fullWidth,
+      isDisabled,
+      leftIcon,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      onPress,
+      rightIcon,
+      size,
+      variant
+    } = props,
+    forwardedProps = _objectWithoutProperties(props, _excluded$2);
+  return /*#__PURE__*/React.createElement(StyledButton, _extends({}, forwardedProps, buttonProps, {
+    $color: color,
+    $fullWidth: fullWidth,
+    $isDisabled: isDisabled || disabled,
+    $size: size,
+    $variant: variant,
+    "aria-disabled": isDisabled || disabled,
+    className: classNames(Button.className, className),
+    disabled: isDisabled || disabled,
+    ref: buttonRef
+  }), leftIcon ? /*#__PURE__*/React.createElement(Icon, {
+    icon: leftIcon,
+    "aria-hidden": "true",
+    className: "left"
+  }) : null, children && /*#__PURE__*/React.createElement("span", null, children), rightIcon ? /*#__PURE__*/React.createElement(Icon, {
+    icon: rightIcon,
+    "aria-hidden": "true",
+    className: "right"
+  }) : null);
+});
+Button.className = CLASSNAME$3;
+Button.defaultProps = DEFAULT_PROPS$2;
+Button.displayName = COMPONENT_NAME$3;
+
+const ResetButton = /*#__PURE__*/forwardRef((props, ref) => {
+  const {
+    chart,
+    children
+  } = props;
+  return /*#__PURE__*/React.createElement(Button, {
+    ref: ref,
+    variant: "text",
+    size: "small",
+    color: "primary",
+    onPress: () => {
+      chart === null || chart === void 0 ? void 0 : chart.filter(null);
+      redrawAll();
+    }
+  }, children);
+});
+
+/**
+ * Component size.
+ */
+const HorizontalBarChartSize = {
+  large: 'large',
+  medium: 'medium',
+  small: 'small'
+};
+/**
+ * Component theme.
+ */
+const HorizontalBarChartTheme = {
+  default: 'default',
+  dark: 'dark',
+  darker: 'darker',
+  monochrome: 'monochrome'
+};
+
+/**
+ * Component style.
+ */
+const StyledHorizontalBarChart = styled.div`
+  margin: 16px;
+  padding: 16px;
+  color: var(--redsift-color-text-primary);
+
+  .redsift-horizontal-barchart__chart {
+    display: flex;
+    font-family: var(--redsift-typography-font-family-source-code-pro);
+    font-size: 12px;
+    justify-content: center;
+    margin: 8px 0;
+  }
+
+  svg > g {
+    margin: 8px;
+  }
+
+  g.row {
+    text {
+      cursor: pointer;
+    }
+
+    rect {
+      fill-opacity: 0.9;
+      cursor: pointer;
+    }
+
+    rect.deselected {
+      stroke: none;
+      fill: var(--redsift-color-text-disabled);
+    }
+  }
+
+  g.row.focused,
+  g.row:hover {
+    rect {
+      fill-opacity: 0.7;
+    }
+  }
+
+  g.pie-slice.focused rect.deselected {
+    fill-opacity: 0.3;
+  }
+
+  svg:hover,
+  svg:focus {
+    outline: none;
+  }
+
+  svg:focus-visible {
+    outline: auto;
+  }
+
+  .axis {
+    line.grid-line {
+      fill: none;
+      stroke: #ccc;
+      shape-rendering: crispEdges;
+    }
+
+    text {
+      font-family: var(--redsift-typography-font-family-source-code-pro);
+      font-size: 10px;
+    }
+  }
+`;
+const StyledHorizontalBarChartTitle = styled.div`
+  align-items: center;
+  display: flex;
+  flex-direction: row;
+  font-family: var(--redsift-typography-h4-font-family);
+  font-size: var(--redsift-typography-h4-font-size);
+  font-weight: var(--redsift-typography-h4-font-weight);
+  gap: 16px;
+  line-height: var(--redsift-typography-h4-line-height);
+`;
+const StyledHorizontalBarChartCaption = styled.p`
+  font-family: var(--redsift-typography-caption-font-family);
+  font-size: var(--redsift-typography-caption-font-size);
+  font-weight: var(--redsift-typography-caption-font-weight);
+  line-height: var(--redsift-typography-caption-line-height);
+`;
+
+/**
+ * .
+ */
+const useChartAsListbox = _ref => {
+  let {
+    id,
+    querySelector,
+    numberOfGroups,
+    chartRef,
+    chart,
+    orientation = 'horizontal'
+  } = _ref;
+  const currentIndexRef = useRef(0);
+  useEffect(() => {
+    if (numberOfGroups && chartRef) {
+      // Create utils to manipulate focus on options
+      const getAllOptions = () => chartRef.querySelectorAll(querySelector);
+      const getCurrentOption = () => chartRef.querySelector(`${querySelector}._${currentIndexRef.current}`);
+      const next = () => {
+        getCurrentOption().classList.remove('focused');
+        const index = currentIndexRef.current === numberOfGroups - 1 ? 0 : currentIndexRef.current + 1;
+        currentIndexRef.current = index;
+        chartRef.setAttribute('aria-activedescendant', `id${id}__option-${currentIndexRef.current}`);
+        getCurrentOption().classList.add('focused');
+      };
+      const previous = () => {
+        getCurrentOption().classList.remove('focused');
+        const index = currentIndexRef.current === 0 ? numberOfGroups - 1 : currentIndexRef.current - 1;
+        currentIndexRef.current = index;
+        chartRef.setAttribute('aria-activedescendant', `id${id}__option-${currentIndexRef.current}`);
+        getCurrentOption().classList.add('focused');
+      };
+      const focus = () => {
+        chartRef.setAttribute('aria-activedescendant', `id${id}__option-0`);
+        getCurrentOption().classList.add('focused');
+      };
+      const blur = () => {
+        getCurrentOption().classList.remove('focused');
+        currentIndexRef.current = 0;
+        chartRef.setAttribute('aria-activedescendant', '');
+      };
+      const keydown = e => {
+        e.stopPropagation();
+        switch (e.code) {
+          case 'ArrowRight':
+            if (orientation === 'horizontal') {
+              e.preventDefault();
+              next();
+            }
+            break;
+          case 'ArrowLeft':
+            if (orientation === 'horizontal') {
+              e.preventDefault();
+              previous();
+            }
+            break;
+          case 'ArrowDown':
+            if (orientation === 'vertical') {
+              e.preventDefault();
+              next();
+            }
+            break;
+          case 'ArrowUp':
+            if (orientation === 'vertical') {
+              e.preventDefault();
+              previous();
+            }
+            break;
+          case 'Enter':
+          case 'Space':
+            e.preventDefault();
+            chart.selectAll(`${querySelector}._${currentIndexRef.current}`).each(d => {
+              if (d.data && d.data.key) {
+                chart.onClick(d.data);
+              } else if (d.key) {
+                chart.onClick(d);
+              }
+            });
+            break;
+        }
+      };
+      chart.on('postRender', chart => {
+        // Add role and aria attributes to the each option.
+        chart.selectAll(`${querySelector} > title`).attr('id', (d, index) => `id${id}__option-${index}-title`);
+        chart.selectAll(`${querySelector} > text`).attr('aria-hidden', 'true');
+        chart.selectAll(querySelector).attr('id', (_, index) => `id${id}__option-${index}`).attr('role', 'option').attr('aria-labelledby', (_, index) => `id${id}__option-${index}-title`);
+
+        // Add role, aria attributes and keyboard events to the group of options.
+        chartRef.setAttribute('tabIndex', '0');
+        chartRef.setAttribute('role', 'listbox');
+        chartRef.setAttribute('aria-labelledby', `id${id}__title`);
+        chartRef.setAttribute('aria-multiselectable', 'true');
+        chartRef.setAttribute('aria-orientation', orientation);
+        chartRef.setAttribute('aria-activedescendant', `id${id}__option-0`);
+        chartRef.addEventListener('focus', focus);
+        chartRef.addEventListener('blur', blur);
+        chartRef.addEventListener('mouseout', blur);
+        chartRef.addEventListener('keydown', keydown);
+      });
+      chart.on('renderlet', () => {
+        // Add role and aria attributes to the each option.
+        chart.selectAll(`${querySelector} > title`).attr('id', (_, index) => `id${id}__option-${index}-title`);
+        chart.selectAll(`${querySelector} > text`).attr('aria-hidden', 'true');
+
+        // Set aria-selected on each option based on the selection.
+        getAllOptions().forEach(element => {
+          if (element.classList.contains('selected') || element.getElementsByClassName('selected').length) {
+            element.setAttribute('aria-selected', 'true');
+          } else {
+            element.setAttribute('aria-selected', 'false');
+          }
+        });
+      });
+    }
+  }, [chart]);
+};
+
+const _excluded$1 = ["areXLabelsRotated", "caping", "caption", "className", "columnToFilter", "data", "dimension", "group", "isResetable", "localeText", "others", "size", "theme", "title"];
+const COMPONENT_NAME$2 = 'RedSiftHorizontalBarChart';
+const CLASSNAME$2 = 'redsift-horizontal-barchart';
+const DEFAULT_PROPS$1 = {
+  isResetable: true,
+  localeText: {
+    resetLabel: 'Reset'
+  },
+  others: true,
+  size: HorizontalBarChartSize.medium,
+  theme: HorizontalBarChartTheme.default,
+  title: 'Horizontal Bar Chart'
+};
+const sizeToDimension$1 = size => {
+  switch (size) {
+    case HorizontalBarChartSize.small:
+      return {
+        width: 300,
+        height: 200
+      };
+    case HorizontalBarChartSize.large:
+      return {
+        width: 500,
+        height: 400
+      };
+    case HorizontalBarChartSize.medium:
+    default:
+      return {
+        width: 400,
+        height: 300
+      };
+  }
+};
+const HorizontalBarChart = /*#__PURE__*/forwardRef((props, ref) => {
+  const containerRef = ref || useRef();
+  const chartRef = useRef();
+  const id = useId();
+  const [chart, setChart] = useState();
+  const [groups, setGroups] = useState();
+  const {
+      areXLabelsRotated,
+      caping,
+      caption,
+      className,
+      columnToFilter,
+      data,
+      dimension,
+      group,
+      isResetable,
+      localeText,
+      others = DEFAULT_PROPS$1.others,
+      size = DEFAULT_PROPS$1.size,
+      theme,
+      title
+    } = props,
+    forwardedProps = _objectWithoutProperties(props, _excluded$1);
+
+  // Get overriden labels and texts.
+  const {
+    resetLabel
+  } = _objectSpread2(_objectSpread2({}, DEFAULT_PROPS$1.localeText), localeText);
+
+  // Get charts dimensions based on the selected size.
+  const chartDimensions = sizeToDimension$1(size);
+
+  // Get ndx from context or initialize it.
+  const {
+    ndx = crossfilter(data),
+    dispatch,
+    state
+  } = useContext(DashboardContext);
+  const {
+    tableFilters
+  } = state;
+
+  // Set color scheme.
+  let d3colors = ordinal(scheme.default);
+  if (typeof theme === 'string') {
+    d3colors = ordinal(scheme[theme]);
+  } else if (typeof theme === 'object') {
+    d3colors = ordinal().domain([theme.success, theme.warning, theme.danger]).range([successDangerScheme.success, successDangerScheme.warning, successDangerScheme.danger]).unknown(neutral);
+  }
+
+  // useEffect called only once to initialize the chart.
+  useEffect(() => {
+    if (chartRef.current) {
+      config.defaultColors(scheme.default);
+      const rowChart$1 = rowChart(chartRef.current);
+
+      // Compute dimension and group.
+      const computedDimension = ndx.dimension(dimension);
+      const computedGroup = group(computedDimension.group());
+
+      // Initialize the chart.
+      rowChart$1.width(chartDimensions.width - 16).height(chartDimensions.height - (areXLabelsRotated ? 30 : 0)).margins({
+        top: 16,
+        left: 16,
+        right: 16,
+        bottom: 32
+      }).dimension(computedDimension).group(computedGroup).colors(d3colors);
+      rowChart$1.xAxis().ticks(5);
+      if (caping) {
+        rowChart$1.cap(caping);
+        if (others && typeof others === 'string') {
+          rowChart$1.othersLabel(others);
+        } else if (!others) {
+          rowChart$1.othersGrouper(d => d);
+        }
+      }
+
+      // Rotate labels and reset the height, if asked for.
+      if (areXLabelsRotated) {
+        rowChart$1.on('pretransition', rowChart => {
+          rowChart.select('.axis').attr('text-anchor', 'end').selectAll('text').attr('transform', 'translate(-6,5) rotate(-45)');
+          rowChart.select('svg').attr('height', chartDimensions.height);
+        });
+      }
+
+      // Dispatch filters to datagrid when a value is selected or unselected.
+      if (columnToFilter) {
+        rowChart$1.on('filtered', () => {
+          dispatch === null || dispatch === void 0 ? void 0 : dispatch({
+            type: DashboardReducerActionType.FilterTable,
+            filter: {
+              id: rowChart$1.anchorName(),
+              columnField: columnToFilter,
+              operatorValue: 'isAnyOf',
+              value: rowChart$1.filters()
+            }
+          });
+        });
+      }
+
+      // Render the chart.
+      rowChart$1.render();
+
+      // Store chart and number of groups for further use.
+      setChart(rowChart$1);
+      setGroups(computedGroup);
+    }
+  }, []);
+
+  // Filter chart if context is updated by an external component.
+  const filter = tableFilters.find(filter => filter.columnField === columnToFilter && filter.operatorValue === 'isAnyOf');
+  useEffect(() => {
+    if (chart && filter && filter.value && chart.filters() !== filter.value) {
+      const filterValues = filter.value.map(val => {
+        var _groups$all$find;
+        const value = groups === null || groups === void 0 ? void 0 : (_groups$all$find = groups.all().find(_ref => {
+          let {
+            key
+          } = _ref;
+          return key.toLowerCase() === val.toLowerCase();
+        })) === null || _groups$all$find === void 0 ? void 0 : _groups$all$find.key;
+        if (value) {
+          return value;
+        }
+        return val;
+      });
+      if (filterValues) {
+        chart.filter(null);
+        chart.filter([filterValues]);
+        redrawAll();
+      }
+    }
+  }, [filter]);
+
+  // Apply Listbox a11y pattern to the generated dc.js chart.
+  useChartAsListbox({
+    id,
+    querySelector: 'g.row',
+    numberOfGroups: groups === null || groups === void 0 ? void 0 : groups.size(),
+    chartRef: chartRef.current,
+    chart: chart,
+    orientation: 'vertical'
+  });
+  return /*#__PURE__*/React.createElement(StyledHorizontalBarChart, _extends({}, forwardedProps, {
+    className: classNames(HorizontalBarChart.className, className),
+    ref: containerRef
+  }), /*#__PURE__*/React.createElement(StyledHorizontalBarChartTitle, {
+    className: `${HorizontalBarChart.className}__title`,
+    id: `id${id}__title`
+  }, title, chart && isResetable ? /*#__PURE__*/React.createElement(ResetButton, {
+    chart: chart
+  }, resetLabel) : null), /*#__PURE__*/React.createElement("div", {
+    className: `${HorizontalBarChart.className}__chart`,
+    ref: chartRef
+  }), caption ? /*#__PURE__*/React.createElement(StyledHorizontalBarChartCaption, {
+    className: `${HorizontalBarChart.className}__caption`,
+    id: `id${id}__caption`
+  }, caption) : null);
+});
+HorizontalBarChart.className = CLASSNAME$2;
+HorizontalBarChart.defaultProps = DEFAULT_PROPS$1;
+HorizontalBarChart.displayName = COMPONENT_NAME$2;
+
+/**
+ * Component style.
+ */
+const StyledEmptyChart = styled.div`
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  width: 100%;
+  height: 100%;
+
+  .redsift-emptychart-container__img {
+    display: flex;
+    align-items: center;
+    height: 180px;
+  }
+
+  .redsift-emptychart__img {
+    position: relative;
+    width: 150px;
+    height: 150px;
+    border-radius: 150px;
+    background: blueviolet;
+  }
+
+  .redsift-emptychart__title {
+    font-family: var(--redsift-typography-h4-font-family);
+    font-size: var(--redsift-typography-h4-font-size);
+    font-weight: var(--redsift-typography-h4-font-weight);
+    line-height: var(--redsift-typography-h4-line-height);
+  }
+
+  .redsift-emptychart__subtitle {
+    font-family: var(--redsift-typography-body-font-family);
+    font-size: var(--redsift-typography-body-font-size);
+    font-weight: var(--redsift-typography-body-font-weight);
+    line-height: var(--redsift-typography-body-line-height);
+    margin-top: 8px;
+    text-align: center;
+  }
+`;
+const StyledResetButton = styled(Button)`
+  margin-top: 8px;
+`;
+styled.img`
+  max-width: 80%;
+`;
+
+const COMPONENT_NAME$1 = 'RedSiftEmptyChart';
+const CLASSNAME$1 = 'redsift-emptychart';
+const EmptyChart = /*#__PURE__*/forwardRef((props, ref) => {
+  const {
+    resetButtonLabel,
+    subtitle,
+    title
+  } = props;
+  return /*#__PURE__*/React.createElement(StyledEmptyChart, {
+    ref: ref,
+    className: "redsift-emptychart"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: `${EmptyChart.className}-container__img`
+  }, /*#__PURE__*/React.createElement("div", {
+    className: `${EmptyChart.className}__img`
+  })), /*#__PURE__*/React.createElement("div", {
+    className: `${EmptyChart.className}__title`
+  }, title), subtitle ? /*#__PURE__*/React.createElement("div", {
+    className: `${EmptyChart.className}__subtitle`
+  }, subtitle) : null, resetButtonLabel ? /*#__PURE__*/React.createElement(StyledResetButton, {
+    variant: "text",
+    size: "small",
+    color: "primary",
+    leftIcon: mdiRefresh,
+    onPress: () => {
+      filterAll();
+      redrawAll();
+    }
+  }, resetButtonLabel) : null);
+});
+EmptyChart.className = CLASSNAME$1;
+EmptyChart.displayName = COMPONENT_NAME$1;
+
+/**
+ * Component style.
+ */
+const StyledPieChart = styled.div`
+  margin: 8px;
+  padding: 8px;
+  color: var(--redsift-color-text-primary);
+
+  .redsift-piechart__title {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    gap: 16px;
+  }
+
+  ${_ref => {
+  let {
+    $showLabels
+  } = _ref;
+  return !$showLabels ? css`
+          g.pie-label-group text {
+            display: none;
+          }
+        ` : '';
+}}
+
+  g.pie-slice {
+    text {
+      cursor: pointer;
+    }
+
+    path {
+      cursor: pointer;
+      ${_ref2 => {
+  let {
+    $spaced
+  } = _ref2;
+  return $spaced ? css`
+              stroke-width: 2px;
+              stroke: #fff;
+            ` : '';
+}}
+    }
+  }
+
+  g.pie-slice.deselected {
+    path {
+      fill-opacity: 0.5;
+      fill: var(--redsift-color-text-disabled);
+    }
+  }
+
+  g.pie-slice.focused,
+  g.pie-slice:hover {
+    path {
+      fill-opacity: 0.8;
+    }
+  }
+
+  g.pie-slice.deselected.focused {
+    path {
+      fill-opacity: 0.3;
+    }
+  }
+
+  svg:hover,
+  svg:focus {
+    outline: none;
+  }
+
+  svg:focus-visible {
+    outline: auto;
+  }
+`;
+const StyledPieChartContainer = styled.div`
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  font-family: var(--redsift-typography-font-family-source-code-pro);
+  font-size: 11px;
+  justify-content: center;
+  margin: 8px 0;
+  position: relative;
+
+  .redsift-piechart-container__chart {
+    position: relative;
+    ${_ref3 => {
+  let {
+    $isEmpty
+  } = _ref3;
+  return $isEmpty ? css`
+            display: none;
+          ` : '';
+}};
+  }
+`;
+
+const _excluded = ["caping", "caption", "className", "columnToFilter", "data", "isResetable", "labelVariant", "dimension", "group", "localeText", "others", "size", "subtext", "text", "theme", "title", "variant"];
+const COMPONENT_NAME = 'RedSiftPieChart';
+const CLASSNAME = 'redsift-piechart';
+const DEFAULT_PROPS = {
+  isResetable: true,
+  labelVariant: PieChartLabelVariant.internal,
+  localeText: {
+    emptyChartTitle: 'No Data Available',
+    emptyChartSubtitle: 'Please check the applied filters',
+    emptyChartResetLabel: 'Reset all filters',
+    resetLabel: 'Reset'
+  },
+  others: true,
+  size: PieChartSize.medium,
+  theme: PieChartTheme.default,
+  title: 'Pie Chart',
+  variant: PieChartVariant.plain
+};
+const sizeToDimension = size => {
+  switch (size) {
+    case PieChartSize.small:
+      return {
+        width: 200,
+        height: 200
+      };
+    case PieChartSize.large:
+      return {
+        width: 300,
+        height: 300
+      };
+    case PieChartSize.medium:
+    default:
+      return {
+        width: 250,
+        height: 250
+      };
+  }
+};
+const sizeToInnerRadius = size => {
+  switch (size) {
+    case PieChartSize.small:
+      return 50;
+    case PieChartSize.large:
+      return 75;
+    case PieChartSize.medium:
+    default:
+      return 66;
+  }
+};
+const PieChart = /*#__PURE__*/forwardRef((props, ref) => {
+  const chartRef = useRef();
+  const id = useId();
+  const [chart, setChart] = useState();
+  const [groups, setGroups] = useState();
+  const [dimensions, setDimensions] = useState();
+  const {
+      caping,
+      caption,
+      className,
+      columnToFilter,
+      data,
+      isResetable,
+      labelVariant,
+      dimension,
+      group,
+      localeText,
+      others,
+      size,
+      subtext,
+      text,
+      theme,
+      title,
+      variant
+    } = props,
+    forwardedProps = _objectWithoutProperties(props, _excluded);
+
+  // Get overriden labels and texts.
+  const {
+    emptyChartTitle,
+    emptyChartSubtitle,
+    emptyChartResetLabel,
+    resetLabel
+  } = _objectSpread2(_objectSpread2({}, DEFAULT_PROPS.localeText), localeText);
+
+  // Get charts dimensions based on the selected size.
+  const chartDimensions = sizeToDimension(size);
+  const externalRadiusPadding = 8;
+  const innerRadius = sizeToInnerRadius(size);
+
+  // Get ndx from context or initialize it.
+  const {
+    ndx = crossfilter(data),
+    dispatch,
+    state
+  } = useContext(DashboardContext);
+  const {
+    tableFilters
+  } = state;
+
+  // Set color scheme.
+  let d3colors = ordinal(scheme.default);
+  if (typeof theme === 'string') {
+    d3colors = ordinal(scheme[theme]);
+  } else if (typeof theme === 'object') {
+    d3colors = ordinal().domain([theme.success, theme.warning, theme.danger]).range([successDangerScheme.success, successDangerScheme.warning, successDangerScheme.danger]).unknown(neutral);
+  }
+
+  // useEffect called only once to initialize the chart.
+  useEffect(() => {
+    if (chartRef.current) {
+      config.defaultColors(scheme.default);
+      const pieChart$1 = pieChart(chartRef.current);
+
+      // Compute dimension and group.
+      const computedDimension = ndx.dimension(dimension);
+      const computedGroup = group(computedDimension.group());
+
+      // Initialize the chart.
+      pieChart$1.width(chartDimensions.width).height(chartDimensions.height).dimension(computedDimension).group(computedGroup).externalRadiusPadding(externalRadiusPadding).innerRadius(variant === PieChartVariant.donut || variant === PieChartVariant.spacedDonut ? innerRadius : 0).colors(d3colors);
+      if (caping) {
+        pieChart$1.cap(caping);
+        if (others && typeof others === 'string') {
+          pieChart$1.othersLabel(others);
+        } else if (!others) {
+          pieChart$1.othersGrouper(d => d);
+        }
+      }
+
+      // Dispatch filters to datagrid when a value is selected or unselected.
+      if (columnToFilter) {
+        pieChart$1.on('filtered', () => {
+          dispatch === null || dispatch === void 0 ? void 0 : dispatch({
+            type: DashboardReducerActionType.FilterTable,
+            filter: {
+              id: pieChart$1.anchorName(),
+              columnField: columnToFilter,
+              operatorValue: 'isAnyOf',
+              value: pieChart$1.filters()
+            }
+          });
+        });
+      }
+
+      // Render the chart.
+      pieChart$1.render();
+
+      // Store chart and number of groups for further use.
+      setChart(pieChart$1);
+      setDimensions(computedDimension);
+      setGroups(computedGroup);
+    }
+  }, []);
+
+  // Filter chart if context is updated by an external component.
+  const filter = tableFilters.find(filter => filter.columnField === columnToFilter && filter.operatorValue === 'isAnyOf');
+  useEffect(() => {
+    if (chart && filter && filter.value && chart.filters() !== filter.value) {
+      const filterValues = filter.value.map(val => {
+        var _groups$all$find;
+        const value = groups === null || groups === void 0 ? void 0 : (_groups$all$find = groups.all().find(_ref => {
+          let {
+            key
+          } = _ref;
+          return key.toLowerCase() === val.toLowerCase();
+        })) === null || _groups$all$find === void 0 ? void 0 : _groups$all$find.key;
+        if (value) {
+          return value;
+        }
+        return val;
+      });
+      if (filterValues) {
+        chart.filter(null);
+        chart.filter([filterValues]);
+        redrawAll();
+      }
+    }
+  }, [filter]);
+
+  // Apply Listbox a11y pattern to the generated dc.js chart.
+  useChartAsListbox({
+    id,
+    querySelector: 'g.pie-slice',
+    numberOfGroups: groups === null || groups === void 0 ? void 0 : groups.size(),
+    chartRef: chartRef.current,
+    chart: chart
+  });
+  return /*#__PURE__*/React.createElement(StyledPieChart, _extends({}, forwardedProps, {
+    id: id,
+    className: classNames(PieChart.className, className),
+    ref: ref,
+    $spaced: variant === PieChartVariant.spaced || variant === PieChartVariant.spacedDonut,
+    $showLabels: labelVariant === PieChartLabelVariant.internal
+  }), /*#__PURE__*/React.createElement(StyledPieChartTitle, {
+    className: `${PieChart.className}__title`,
+    id: `id${id}__title`
+  }, title, chart && isResetable ? /*#__PURE__*/React.createElement(ResetButton, {
+    chart: chart
+  }, resetLabel) : null), /*#__PURE__*/React.createElement(StyledPieChartContainer, {
+    className: `${PieChart.className}__container`,
+    $isEmpty: (dimensions === null || dimensions === void 0 ? void 0 : dimensions.top(1).length) === 0
+  }, /*#__PURE__*/React.createElement("div", {
+    className: `${PieChart.className}-container__chart`,
+    ref: chartRef
+  }, text ? /*#__PURE__*/React.createElement(StyledPieChartCenterText, {
+    $maxWidth: innerRadius * 2
+  }, /*#__PURE__*/React.createElement("b", null, text), /*#__PURE__*/React.createElement("span", null, subtext)) : null), (dimensions === null || dimensions === void 0 ? void 0 : dimensions.top(1).length) === 0 ? /*#__PURE__*/React.createElement(EmptyChart, {
+    title: emptyChartTitle,
+    subtitle: emptyChartSubtitle,
+    resetButtonLabel: emptyChartResetLabel
+  }) : /*#__PURE__*/React.createElement(React.Fragment, null, labelVariant !== PieChartLabelVariant.none && labelVariant !== PieChartLabelVariant.internal ? /*#__PURE__*/React.createElement("ul", null, chart === null || chart === void 0 ? void 0 : chart.data().map((_ref2, index) => {
+    let {
+      key,
+      value
+    } = _ref2;
+    return /*#__PURE__*/React.createElement(StyledPieChartLabel, {
+      key: `pie-external-label _${index}`,
+      $color: d3colors(key)
+    }, /*#__PURE__*/React.createElement("div", null), /*#__PURE__*/React.createElement("span", null, key), labelVariant === PieChartLabelVariant.externalLabelValue ? /*#__PURE__*/React.createElement("b", null, value) : labelVariant === PieChartLabelVariant.externalLabelPercent ? /*#__PURE__*/React.createElement("b", null, `${(value * 100 / sum(chart.data(), d => d.value)).toFixed(2)}%`) : null);
+  })) : null)), caption ? /*#__PURE__*/React.createElement(StyledPieChartCaption, {
+    className: `${PieChart.className}__caption`,
+    id: `id${id}__caption`
+  }, caption) : null);
+});
+PieChart.className = CLASSNAME;
+PieChart.defaultProps = DEFAULT_PROPS;
+PieChart.displayName = COMPONENT_NAME;
+
+export { Dashboard, DashboardContext, DashboardReducer, DashboardReducerActionType, DataGrid, HorizontalBarChart, HorizontalBarChartSize, HorizontalBarChartTheme, PieChart, initialState };
+//# sourceMappingURL=index.js.map