@aussieljk/forkbook 0.0.0-stage → 0.0.1-10

package/dist/manager/_manager-chunks/runtime-jj8qYc2n.js

@@ -0,0 +1,3488 @@
+import { a as __toESM, n as __esmMin } from "./runtime-BdGkqNEt.js";
+import { Cr as init__storybook_global_react, Er as useCallback, Fr as useRef, Ir as useState, Mr as useLayoutEffect, Nr as useMemo, Pr as useReducer, _r as _storybook_global_react_exports, kr as useEffect, mr as Component, vr as cloneElement } from "./runtime-DG61zYUm.js";
+import { n as require_react_is, p as require_prop_types } from "./runtime-CBQsKmch.js";
+import { a as _inheritsLoose, l as _extends, o as init_inheritsLoose, t as _objectWithoutPropertiesLoose } from "./runtime-DtCVCy4G.js";
+//#region ../../node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function getSymbols(object) {
+	return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+/**
+* Gets the `toStringTag` of `value`.
+*
+* @private
+* @param {T} value The value to query.
+* @returns {string} Returns the `Object.prototype.toString.call` result.
+*/
+function getTag(value) {
+	if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
+	return Object.prototype.toString.call(value);
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+var regexpTag, stringTag, numberTag, booleanTag, symbolTag, dateTag, mapTag, setTag, arrayTag, functionTag, arrayBufferTag, objectTag, errorTag, dataViewTag, uint8ArrayTag, uint8ClampedArrayTag, uint16ArrayTag, uint32ArrayTag, bigUint64ArrayTag, int8ArrayTag, int16ArrayTag, int32ArrayTag, bigInt64ArrayTag, float32ArrayTag, float64ArrayTag;
+function init_tags() {
+	return (init_tags = __esmMin((() => {
+		regexpTag = "[object RegExp]";
+		stringTag = "[object String]";
+		numberTag = "[object Number]";
+		booleanTag = "[object Boolean]";
+		symbolTag = "[object Symbol]";
+		dateTag = "[object Date]";
+		mapTag = "[object Map]";
+		setTag = "[object Set]";
+		arrayTag = "[object Array]";
+		functionTag = "[object Function]";
+		arrayBufferTag = "[object ArrayBuffer]";
+		objectTag = "[object Object]";
+		errorTag = "[object Error]";
+		dataViewTag = "[object DataView]";
+		uint8ArrayTag = "[object Uint8Array]";
+		uint8ClampedArrayTag = "[object Uint8ClampedArray]";
+		uint16ArrayTag = "[object Uint16Array]";
+		uint32ArrayTag = "[object Uint32Array]";
+		bigUint64ArrayTag = "[object BigUint64Array]";
+		int8ArrayTag = "[object Int8Array]";
+		int16ArrayTag = "[object Int16Array]";
+		int32ArrayTag = "[object Int32Array]";
+		bigInt64ArrayTag = "[object BigInt64Array]";
+		float32ArrayTag = "[object Float32Array]";
+		float64ArrayTag = "[object Float64Array]";
+	})))();
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/_internal/globalThis.mjs
+var globalThis_;
+function init_globalThis() {
+	return (init_globalThis = __esmMin((() => {
+		globalThis_ = typeof globalThis === "object" && globalThis || typeof window === "object" && window || typeof self === "object" && self || typeof global === "object" && global || (function() {
+			return this;
+		})();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/predicate/isBuffer.mjs
+/**
+* Checks if the given value is a Buffer instance.
+*
+* This function tests whether the provided value is an instance of Buffer.
+* It returns `true` if the value is a Buffer, and `false` otherwise.
+*
+* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
+*
+* @param x - The value to check if it is a Buffer.
+* @returns Returns `true` if `x` is a Buffer, else `false`.
+*
+* @example
+* const buffer = Buffer.from("test");
+* console.log(isBuffer(buffer)); // true
+*
+* const notBuffer = "not a buffer";
+* console.log(isBuffer(notBuffer)); // false
+*/
+function isBuffer(x) {
+	return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x);
+}
+function init_isBuffer() {
+	return (init_isBuffer = __esmMin((() => {
+		init_globalThis();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+/**
+* Checks if a given value is a plain object.
+*
+* @param value - The value to check.
+* @returns True if the value is a plain object, otherwise false.
+*
+* @example
+* ```typescript
+* // ✅👇 True
+*
+* isPlainObject({ });                       // ✅
+* isPlainObject({ key: 'value' });          // ✅
+* isPlainObject({ key: new Date() });       // ✅
+* isPlainObject(new Object());              // ✅
+* isPlainObject(Object.create(null));       // ✅
+* isPlainObject({ nested: { key: true} });  // ✅
+* isPlainObject(new Proxy({}, {}));         // ✅
+* isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
+*
+* // ✅👇 (cross-realms, node context, workers, ...)
+* const runInNewContext = await import('node:vm').then(
+*     (mod) => mod.runInNewContext
+* );
+* isPlainObject(runInNewContext('({})'));   // ✅
+*
+* // ❌👇 False
+*
+* class Test { };
+* isPlainObject(new Test())           // ❌
+* isPlainObject(10);                  // ❌
+* isPlainObject(null);                // ❌
+* isPlainObject('hello');             // ❌
+* isPlainObject([]);                  // ❌
+* isPlainObject(new Date());          // ❌
+* isPlainObject(new Uint8Array([1])); // ❌
+* isPlainObject(Buffer.from('ABC'));  // ❌
+* isPlainObject(Promise.resolve({})); // ❌
+* isPlainObject(Object.create({}));   // ❌
+* isPlainObject(new (class Cls {}));  // ❌
+* isPlainObject(globalThis);          // ❌,
+* ```
+*/
+function isPlainObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/compat/util/eq.mjs
+/**
+* Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
+*
+* @param value The value to compare.
+* @param other The other value to compare.
+* @returns Returns `true` if the values are equivalent, else `false`.
+*
+* @example
+* eq(1, 1); // true
+* eq(0, -0); // true
+* eq(NaN, NaN); // true
+* eq('a', Object('a')); // false
+*/
+function eq(value, other) {
+	return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
+/**
+* Compares two values for equality using a custom comparison function.
+*
+* The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison.
+*
+* This function also uses the custom equality function to compare values inside objects,
+* arrays, maps, sets, and other complex structures, ensuring a deep comparison.
+*
+* This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases.
+*
+* The custom comparison function can take up to six parameters:
+* - `x`: The value from the first object `a`.
+* - `y`: The value from the second object `b`.
+* - `property`: The property key used to get `x` and `y`.
+* - `xParent`: The parent of the first value `x`.
+* - `yParent`: The parent of the second value `y`.
+* - `stack`: An internal stack (Map) to handle circular references.
+*
+* @param a - The first value to compare.
+* @param b - The second value to compare.
+* @param areValuesEqual - A function to customize the comparison.
+*   If it returns a boolean, that result will be used. If it returns undefined,
+*   the default equality comparison will be used.
+* @returns `true` if the values are equal according to the customizer, otherwise `false`.
+*
+* @example
+* const customizer = (a, b) => {
+*   if (typeof a === 'string' && typeof b === 'string') {
+*     return a.toLowerCase() === b.toLowerCase();
+*   }
+* };
+* isEqualWith('Hello', 'hello', customizer); // true
+* isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true
+* isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true
+*/
+function isEqualWith(a, b, areValuesEqual) {
+	return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
+}
+function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
+	const result = areValuesEqual(a, b, property, aParent, bParent, stack);
+	if (result !== void 0) return result;
+	if (typeof a === typeof b) switch (typeof a) {
+		case "bigint":
+		case "string":
+		case "boolean":
+		case "symbol":
+		case "undefined": return a === b;
+		case "number": return a === b || Object.is(a, b);
+		case "function": return a === b;
+		case "object": return areObjectsEqual(a, b, stack, areValuesEqual);
+	}
+	return areObjectsEqual(a, b, stack, areValuesEqual);
+}
+function areObjectsEqual(a, b, stack, areValuesEqual) {
+	if (Object.is(a, b)) return true;
+	let aTag = getTag(a);
+	let bTag = getTag(b);
+	if (aTag === "[object Arguments]") aTag = objectTag;
+	if (bTag === "[object Arguments]") bTag = objectTag;
+	if (aTag !== bTag) return false;
+	switch (aTag) {
+		case stringTag: return a.toString() === b.toString();
+		case numberTag: return eq(a.valueOf(), b.valueOf());
+		case booleanTag:
+		case dateTag:
+		case symbolTag: return Object.is(a.valueOf(), b.valueOf());
+		case regexpTag: return a.source === b.source && a.flags === b.flags;
+		case functionTag: return a === b;
+	}
+	stack = stack ?? /* @__PURE__ */ new Map();
+	const aStack = stack.get(a);
+	const bStack = stack.get(b);
+	if (aStack != null && bStack != null) return aStack === b;
+	stack.set(a, b);
+	stack.set(b, a);
+	try {
+		switch (aTag) {
+			case mapTag:
+				if (a.size !== b.size) return false;
+				for (const [key, value] of a.entries()) if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) return false;
+				return true;
+			case setTag: {
+				if (a.size !== b.size) return false;
+				const aValues = Array.from(a.values());
+				const bValues = Array.from(b.values());
+				for (let i = 0; i < aValues.length; i++) {
+					const aValue = aValues[i];
+					const index = bValues.findIndex((bValue) => {
+						return isEqualWithImpl(aValue, bValue, void 0, a, b, stack, areValuesEqual);
+					});
+					if (index === -1) return false;
+					bValues.splice(index, 1);
+				}
+				return true;
+			}
+			case arrayTag:
+			case uint8ArrayTag:
+			case uint8ClampedArrayTag:
+			case uint16ArrayTag:
+			case uint32ArrayTag:
+			case bigUint64ArrayTag:
+			case int8ArrayTag:
+			case int16ArrayTag:
+			case int32ArrayTag:
+			case bigInt64ArrayTag:
+			case float32ArrayTag:
+			case float64ArrayTag:
+				if (isBuffer(a) !== isBuffer(b)) return false;
+				if (a.length !== b.length) return false;
+				for (let i = 0; i < a.length; i++) if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) return false;
+				return true;
+			case arrayBufferTag:
+				if (a.byteLength !== b.byteLength) return false;
+				return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+			case dataViewTag:
+				if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) return false;
+				return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+			case errorTag: return a.name === b.name && a.message === b.message;
+			case objectTag: {
+				if (!(areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || isPlainObject(a) && isPlainObject(b))) return false;
+				const aKeys = [...Object.keys(a), ...getSymbols(a)];
+				const bKeys = [...Object.keys(b), ...getSymbols(b)];
+				if (aKeys.length !== bKeys.length) return false;
+				for (let i = 0; i < aKeys.length; i++) {
+					const propKey = aKeys[i];
+					const aProp = a[propKey];
+					if (!Object.hasOwn(b, propKey)) return false;
+					const bProp = b[propKey];
+					if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) return false;
+				}
+				return true;
+			}
+			default: return false;
+		}
+	} finally {
+		stack.delete(a);
+		stack.delete(b);
+	}
+}
+function init_isEqualWith() {
+	return (init_isEqualWith = __esmMin((() => {
+		init_tags();
+		init_isBuffer();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/function/noop.mjs
+/**
+* A no-operation function that does nothing.
+* This can be used as a placeholder or default function.
+*
+* @example
+* noop(); // Does nothing
+*
+* @returns This function does not return anything.
+*/
+function noop$1() {}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/predicate/isEqual.mjs
+/**
+* Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.
+*
+* @param a - The first value to compare.
+* @param b - The second value to compare.
+* @returns `true` if the values are equal, otherwise `false`.
+*
+* @example
+* isEqual(1, 1); // true
+* isEqual({ a: 1 }, { a: 1 }); // true
+* isEqual(/abc/g, /abc/g); // true
+* isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
+* isEqual([1, 2, 3], [1, 2, 3]); // true
+*/
+function isEqual(a, b) {
+	return isEqualWith(a, b, noop$1);
+}
+function init_isEqual() {
+	return (init_isEqual = __esmMin((() => {
+		init_isEqualWith();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/clsx/dist/clsx.mjs
+function r$1(e) {
+	var t, f, n = "";
+	if ("string" == typeof e || "number" == typeof e) n += e;
+	else if ("object" == typeof e) if (Array.isArray(e)) {
+		var o = e.length;
+		for (t = 0; t < o; t++) e[t] && (f = r$1(e[t])) && (n && (n += " "), n += f);
+	} else for (f in e) e[f] && (n && (n += " "), n += f);
+	return n;
+}
+function clsx() {
+	for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r$1(e)) && (n && (n += " "), n += t);
+	return n;
+}
+function init_clsx() {
+	return (init_clsx = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/function/debounce.mjs
+/**
+* Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+* have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+* method to cancel any pending execution.
+*
+* @template F - The type of function.
+* @param func - The function to debounce.
+* @param debounceMs - The number of milliseconds to delay.
+* @param options - The options object
+* @param options.signal - An optional AbortSignal to cancel the debounced function.
+* @param options.edges - An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+* @returns A new debounced function with a `cancel` method.
+*
+* @example
+* const debouncedFunction = debounce(() => {
+*   console.log('Function executed');
+* }, 1000);
+*
+* // Will log 'Function executed' after 1 second if not called again in that time
+* debouncedFunction();
+*
+* // Will not log anything as the previous call is canceled
+* debouncedFunction.cancel();
+*
+* // With AbortSignal
+* const controller = new AbortController();
+* const signal = controller.signal;
+* const debouncedWithSignal = debounce(() => {
+*  console.log('Function executed');
+* }, 1000, { signal });
+*
+* debouncedWithSignal();
+*
+* // Will cancel the debounced function call
+* controller.abort();
+*/
+function debounce$1(func, debounceMs, { signal, edges } = {}) {
+	let pendingThis = void 0;
+	let pendingArgs = null;
+	const leading = edges != null && edges.includes("leading");
+	const trailing = edges == null || edges.includes("trailing");
+	const invoke = () => {
+		if (pendingArgs !== null) {
+			func.apply(pendingThis, pendingArgs);
+			pendingThis = void 0;
+			pendingArgs = null;
+		}
+	};
+	const onTimerEnd = () => {
+		if (trailing) invoke();
+		cancel();
+	};
+	let timeoutId = null;
+	const schedule = () => {
+		if (timeoutId != null) clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => {
+			timeoutId = null;
+			onTimerEnd();
+		}, debounceMs);
+	};
+	const cancelTimer = () => {
+		if (timeoutId !== null) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+	};
+	const cancel = () => {
+		cancelTimer();
+		pendingThis = void 0;
+		pendingArgs = null;
+	};
+	const flush = () => {
+		invoke();
+	};
+	const debounced = function(...args) {
+		if (signal?.aborted) return;
+		pendingThis = this;
+		pendingArgs = args;
+		const isFirstCall = timeoutId == null;
+		schedule();
+		if (leading && isFirstCall) invoke();
+	};
+	debounced.schedule = schedule;
+	debounced.cancel = cancel;
+	debounced.flush = flush;
+	signal?.addEventListener("abort", cancel, { once: true });
+	return debounced;
+}
+function init_debounce() {
+	return (init_debounce = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/es-toolkit/dist/function/throttle.mjs
+/**
+* Creates a throttled function that only invokes the provided function at most once
+* per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+* within the wait time will not trigger the execution of the original function.
+*
+* @template F - The type of function.
+* @param func - The function to throttle.
+* @param throttleMs - The number of milliseconds to throttle executions to.
+* @returns A new throttled function that accepts the same parameters as the original function.
+*
+* @example
+* const throttledFunction = throttle(() => {
+*   console.log('Function executed');
+* }, 1000);
+*
+* // Will log 'Function executed' immediately
+* throttledFunction();
+*
+* // Will not log anything as it is within the throttle time
+* throttledFunction();
+*
+* // After 1 second
+* setTimeout(() => {
+*   throttledFunction(); // Will log 'Function executed'
+* }, 1000);
+*/
+function throttle(func, throttleMs, { signal, edges = ["leading", "trailing"] } = {}) {
+	let pendingAt = null;
+	const debounced = debounce$1(function(...args) {
+		pendingAt = Date.now();
+		func.apply(this, args);
+	}, throttleMs, {
+		signal,
+		edges
+	});
+	const throttled = function(...args) {
+		if (pendingAt == null) pendingAt = Date.now();
+		if (Date.now() - pendingAt >= throttleMs) {
+			pendingAt = Date.now();
+			func.apply(this, args);
+			debounced.cancel();
+			debounced.schedule();
+			return;
+		}
+		debounced.apply(this, args);
+	};
+	throttled.cancel = debounced.cancel;
+	throttled.flush = debounced.flush;
+	return throttled;
+}
+function init_throttle() {
+	return (init_throttle = __esmMin((() => {})))();
+}
+//#endregion
+//#region ../../node_modules/compute-scroll-into-view/dist/index.js
+var t, e, n, o, l, r;
+function init_dist() {
+	return (init_dist = __esmMin((() => {
+		t = (t) => "object" == typeof t && null != t && 1 === t.nodeType;
+		e = (t, e) => (!e || "hidden" !== t) && "visible" !== t && "clip" !== t;
+		n = (t, n) => {
+			if (t.clientHeight < t.scrollHeight || t.clientWidth < t.scrollWidth) {
+				const o = getComputedStyle(t, null);
+				return e(o.overflowY, n) || e(o.overflowX, n) || ((t) => {
+					const e = ((t) => {
+						if (!t.ownerDocument || !t.ownerDocument.defaultView) return null;
+						try {
+							return t.ownerDocument.defaultView.frameElement;
+						} catch (t) {
+							return null;
+						}
+					})(t);
+					return !!e && (e.clientHeight < t.scrollHeight || e.clientWidth < t.scrollWidth);
+				})(t);
+			}
+			return !1;
+		};
+		o = (t, e, n, o, l, r, i, s) => r < t && i > e || r > t && i < e ? 0 : r <= t && s <= n || i >= e && s >= n ? r - t - o : i > e && s < n || r < t && s > n ? i - e + l : 0;
+		l = (t) => {
+			const e = t.parentElement;
+			return null == e ? t.getRootNode().host || null : e;
+		};
+		r = (e, r) => {
+			var i, s, d, h;
+			if ("undefined" == typeof document) return [];
+			const { scrollMode: c, block: f, inline: u, boundary: a, skipOverflowHiddenElements: g } = r, p = "function" == typeof a ? a : (t) => t !== a;
+			if (!t(e)) throw new TypeError("Invalid target");
+			const m = document.scrollingElement || document.documentElement, w = [];
+			let W = e;
+			for (; t(W) && p(W);) {
+				if (W = l(W), W === m) {
+					w.push(W);
+					break;
+				}
+				null != W && W === document.body && n(W) && !n(document.documentElement) || null != W && n(W, g) && w.push(W);
+			}
+			const b = null != (s = null == (i = window.visualViewport) ? void 0 : i.width) ? s : innerWidth, H = null != (h = null == (d = window.visualViewport) ? void 0 : d.height) ? h : innerHeight, { scrollX: y, scrollY: M } = window, { height: v, width: E, top: x, right: C, bottom: I, left: R } = e.getBoundingClientRect(), { top: T, right: B, bottom: F, left: V } = ((t) => {
+				const e = window.getComputedStyle(t);
+				return {
+					top: parseFloat(e.scrollMarginTop) || 0,
+					right: parseFloat(e.scrollMarginRight) || 0,
+					bottom: parseFloat(e.scrollMarginBottom) || 0,
+					left: parseFloat(e.scrollMarginLeft) || 0
+				};
+			})(e);
+			let k = "start" === f || "nearest" === f ? x - T : "end" === f ? I + F : x + v / 2 - T + F, D = "center" === u ? R + E / 2 - V + B : "end" === u ? C + B : R - V;
+			const L = [];
+			for (let t = 0; t < w.length; t++) {
+				const e = w[t], { height: l, width: r, top: i, right: s, bottom: d, left: h } = e.getBoundingClientRect();
+				if ("if-needed" === c && x >= 0 && R >= 0 && I <= H && C <= b && (e === m && !n(e) || x >= i && I <= d && R >= h && C <= s)) return L;
+				const a = getComputedStyle(e), g = parseInt(a.borderLeftWidth, 10), p = parseInt(a.borderTopWidth, 10), W = parseInt(a.borderRightWidth, 10), T = parseInt(a.borderBottomWidth, 10);
+				let B = 0, F = 0;
+				const V = "offsetWidth" in e ? e.offsetWidth - e.clientWidth - g - W : 0, S = "offsetHeight" in e ? e.offsetHeight - e.clientHeight - p - T : 0, X = "offsetWidth" in e ? 0 === e.offsetWidth ? 0 : r / e.offsetWidth : 0, Y = "offsetHeight" in e ? 0 === e.offsetHeight ? 0 : l / e.offsetHeight : 0;
+				if (m === e) B = "start" === f ? k : "end" === f ? k - H : "nearest" === f ? o(M, M + H, H, p, T, M + k, M + k + v, v) : k - H / 2, F = "start" === u ? D : "center" === u ? D - b / 2 : "end" === u ? D - b : o(y, y + b, b, g, W, y + D, y + D + E, E), B = Math.max(0, B + M), F = Math.max(0, F + y);
+				else {
+					B = "start" === f ? k - i - p : "end" === f ? k - d + T + S : "nearest" === f ? o(i, d, l, p, T + S, k, k + v, v) : k - (i + l / 2) + S / 2, F = "start" === u ? D - h - g : "center" === u ? D - (h + r / 2) + V / 2 : "end" === u ? D - s + W + V : o(h, s, r, g, W + V, D, D + E, E);
+					const { scrollLeft: t, scrollTop: n } = e;
+					B = 0 === Y ? 0 : Math.max(0, Math.min(n + B / Y, e.scrollHeight - l / Y + S)), F = 0 === X ? 0 : Math.max(0, Math.min(t + F / X, e.scrollWidth - r / X + V)), k += n - B, D += t - F;
+				}
+				L.push({
+					el: e,
+					top: B,
+					left: F
+				});
+			}
+			return L;
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/downshift/dist/downshift.esm.mjs
+/**
+* This generates a unique ID for an instance of Downshift
+* @return {string} the unique ID
+*/
+function generateId() {
+	return String(idCounter++);
+}
+function useLatestRef(value) {
+	var ref = useRef(value);
+	useIsomorphicLayoutEffect(function() {
+		ref.current = value;
+	}, [value]);
+	return ref;
+}
+function handleRefs() {
+	for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) refs[_key] = arguments[_key];
+	return function(node) {
+		refs.forEach(function(ref) {
+			if (typeof ref === "function") ref(node);
+			else if (ref) ref.current = node;
+		});
+	};
+}
+/**
+* This is intended to be used to compose event handlers.
+* They are executed in order until one of them sets
+* `event.preventDownshiftDefault = true`.
+* @param fns the event handler functions
+* @return the event handler to add to an element
+*/
+function callAllEventHandlers() {
+	for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) fns[_key] = arguments[_key];
+	return function(event) {
+		for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) args[_key2 - 1] = arguments[_key2];
+		return fns.some(function(fn) {
+			if (fn) fn.apply(void 0, [event].concat(args));
+			return event.preventDownshiftDefault || event.hasOwnProperty("nativeEvent") && event.nativeEvent.preventDownshiftDefault;
+		});
+	};
+}
+/**
+* Simple debounce implementation. Will call the given
+* function once after the time given has passed since
+* it was last called.
+*/
+function debounce(fn, time) {
+	var timeoutId;
+	function cancel() {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+	function wrapper() {
+		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+		cancel();
+		timeoutId = setTimeout(function() {
+			timeoutId = null;
+			fn.apply(void 0, args);
+		}, time);
+	}
+	wrapper.cancel = cancel;
+	return wrapper;
+}
+/**
+* Get the status node or create it if it does not already exist.
+*/
+function getStatusDiv(document) {
+	var statusDiv = document.getElementById("a11y-status-message");
+	if (statusDiv) return statusDiv;
+	statusDiv = document.createElement("div");
+	statusDiv.setAttribute("id", "a11y-status-message");
+	statusDiv.setAttribute("role", "status");
+	statusDiv.setAttribute("aria-live", "polite");
+	statusDiv.setAttribute("aria-relevant", "additions text");
+	Object.assign(statusDiv.style, {
+		border: "0",
+		clip: "rect(0 0 0 0)",
+		height: "1px",
+		margin: "-1px",
+		overflow: "hidden",
+		padding: "0",
+		position: "absolute",
+		width: "1px"
+	});
+	document.body.appendChild(statusDiv);
+	return statusDiv;
+}
+/**
+* Sets aria live status to a div element that's visually hidden.
+*/
+function setStatus(status, document) {
+	if (!status || !document) return;
+	var div = getStatusDiv(document);
+	div.textContent = status;
+	cleanupStatus(document);
+}
+/**
+* Removes the status element from the DOM
+*/
+function cleanupStatusDiv(document) {
+	var statusDiv = document == null ? void 0 : document.getElementById("a11y-status-message");
+	if (statusDiv) statusDiv.remove();
+}
+function noop() {}
+/**
+* This will perform a shallow merge of the given state object
+* with the state coming from props
+* (for the controlled component scenario)
+* This is used in state updater functions so they're referencing
+* the right state regardless of where it comes from.
+*
+* @param state The state of the component/hook.
+* @param props The props that may contain controlled values.
+* @returns The merged controlled state.
+*/
+function getState(state, props) {
+	if (!props) return state;
+	return Object.keys(state).reduce(function(newState, key) {
+		if (props[key] !== void 0) newState[key] = props[key];
+		return newState;
+	}, _extends({}, state));
+}
+/**
+* Scroll node into view if necessary
+* @param {HTMLElement} node the element that should scroll into view
+* @param {HTMLElement} menuNode the menu element of the component
+*/
+function scrollIntoView(node, menuNode) {
+	if (!node) return;
+	r(node, {
+		boundary: menuNode,
+		block: "nearest",
+		scrollMode: "if-needed"
+	}).forEach(function(_ref) {
+		var el = _ref.el, top = _ref.top, left = _ref.left;
+		el.scrollTop = top;
+		el.scrollLeft = left;
+	});
+}
+/**
+* Normalizes the 'key' property of a KeyboardEvent in IE/Edge
+* @param event a keyboardEvent object
+* @return keyboard key
+*/
+function normalizeArrowKey(event) {
+	var key = event.key, keyCode = event.keyCode;
+	/* istanbul ignore next (ie) */
+	if (keyCode >= 37 && keyCode <= 40 && !key.startsWith("Arrow")) return "Arrow" + key;
+	return key;
+}
+/**
+* Returns the next non-disabled highlightedIndex value.
+*
+* @param start The current highlightedIndex.
+* @param backwards If true, it will search backwards from the start.
+* @param items The items array.
+* @param isItemDisabled Function that tells if an item is disabled or not.
+* @param circular If the search reaches the end, if it can search again starting from the other end.
+* @returns The next non-disabled index.
+*/
+function getNonDisabledIndex(start, backwards, items, isItemDisabled, circular) {
+	if (circular === void 0) circular = false;
+	var count = items.length;
+	if (backwards) {
+		for (var index = start; index >= 0; index--) if (!isItemDisabled(items[index], index)) return index;
+	} else for (var _index = start; _index < count; _index++) if (!isItemDisabled(items[_index], _index)) return _index;
+	if (circular) return getNonDisabledIndex(backwards ? count - 1 : 0, backwards, items, isItemDisabled);
+	return -1;
+}
+/**
+* Returns the next non-disabled highlightedIndex value.
+*
+* @param start The current highlightedIndex.
+* @param offset The offset from the current highlightedIndex to start searching.
+* @param items The items array.
+* @param isItemDisabled Function that tells if an item is disabled or not.
+* @param circular If the search reaches the end, if it can search again starting from the other end.
+* @returns The next highlightedIndex.
+*/
+function getHighlightedIndex(start, offset, items, isItemDisabled, circular) {
+	if (circular === void 0) circular = false;
+	var count = items.length;
+	if (count === 0) return -1;
+	var itemsLastIndex = count - 1;
+	if (typeof start !== "number" || start < 0 || start > itemsLastIndex) start = offset > 0 ? -1 : itemsLastIndex + 1;
+	var current = start + offset;
+	if (current < 0) current = circular ? itemsLastIndex : 0;
+	else if (current > itemsLastIndex) current = circular ? 0 : itemsLastIndex;
+	var highlightedIndex = getNonDisabledIndex(current, offset < 0, items, isItemDisabled, circular);
+	if (highlightedIndex === -1) return start >= count ? -1 : start;
+	return highlightedIndex;
+}
+/**
+* Checks if event target is within the downshift elements.
+*
+* @param target Target to check.
+* @param downshiftElements The elements that form downshift (list, toggle button etc).
+* @param environment The window context where downshift renders.
+* @param checkActiveElement Whether to also check activeElement.
+*
+* @returns Whether or not the target is within downshift elements.
+*/
+function targetWithinDownshift(target, downshiftElements, environment, checkActiveElement) {
+	if (checkActiveElement === void 0) checkActiveElement = true;
+	return !!environment && downshiftElements.some(function(contextNode) {
+		return contextNode && (isOrContainsNode(contextNode, target, environment) || checkActiveElement && isOrContainsNode(contextNode, environment.document.activeElement, environment));
+	});
+}
+/**
+* @param parent the parent node
+* @param child the child node
+* @param environment The window context where downshift renders.
+* @return Whether the parent is the child or the child is in the parent
+*/
+function isOrContainsNode(parent, child, environment) {
+	return parent === child || child instanceof environment.Node && parent.contains(child);
+}
+/**
+* Accepts a parameter and returns it if it's a function
+* or a noop function if it's not. This allows us to
+* accept a callback, but not worry about it if it's not
+* passed.
+* @param {Function} cb the callback
+* @return {Function} a function
+*/
+function cbToCb(cb) {
+	return typeof cb === "function" ? cb : noop;
+}
+/**
+* Default implementation for status message. Only added when menu is open.
+* Will specify if there are results in the list, and if so, how many,
+* and what keys are relevant.
+*
+* @param {Object} param the downshift state and other relevant properties
+* @return {String} the a11y status message
+*/
+function getA11yStatusMessage(_ref) {
+	var isOpen = _ref.isOpen, resultCount = _ref.resultCount, previousResultCount = _ref.previousResultCount;
+	if (!isOpen) return "";
+	if (!resultCount) return "No results are available.";
+	if (resultCount !== previousResultCount) return resultCount + " result" + (resultCount === 1 ? " is" : "s are") + " available, use up and down arrow keys to navigate. Press Enter key to select.";
+	return "";
+}
+/**
+* Takes an argument and if it's an array, returns the first item in the array
+* otherwise returns the argument
+* @param {*} arg the maybe-array
+* @param {*} defaultValue the value if arg is falsey not defined
+* @return {*} the arg or it's first item
+*/
+function unwrapArray(arg, defaultValue) {
+	arg = Array.isArray(arg) ? /* istanbul ignore next (preact) */ arg[0] : arg;
+	if (!arg && defaultValue) return defaultValue;
+	else return arg;
+}
+/**
+* @param {Object} element (P)react element
+* @return {Boolean} whether it's a DOM element
+*/
+function isDOMElement(element) {
+	return typeof element.type === "string";
+}
+/**
+* @param {Object} element (P)react element
+* @return {Object} the props
+*/
+function getElementProps(element) {
+	return element.props;
+}
+/**
+* @param {Object} state the state object
+* @return {Object} state that is relevant to downshift
+*/
+function pickState(state) {
+	if (state === void 0) state = {};
+	var result = {};
+	stateKeys.forEach(function(k) {
+		if (state.hasOwnProperty(k)) result[k] = state[k];
+	});
+	return result;
+}
+function capitalizeString(string) {
+	return "" + string.slice(0, 1).toUpperCase() + string.slice(1);
+}
+function callOnChangeProps(action, props, state, newState) {
+	var type = action.type;
+	var changes = {};
+	var keys = Object.keys(state);
+	for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {
+		var key = _keys[_i];
+		invokeOnChangeHandler(key, action, props, state, newState);
+		if (newState[key] !== state[key]) changes[key] = newState[key];
+	}
+	if (typeof props.onStateChange === "function" && Object.keys(changes).length) props.onStateChange(_extends({ type }, changes));
+}
+function invokeOnChangeHandler(key, action, props, state, newState) {
+	if (newState[key] === state[key]) return;
+	var handler = props["on" + capitalizeString(key) + "Change"];
+	if (typeof handler !== "function") return;
+	var type = action.type;
+	handler(_extends({ type }, newState));
+}
+/**
+* Computes the controlled state using a the previous state, props,
+* two reducers, one from downshift and an optional one from the user.
+* Also calls the onChange handlers for state values that have changed.
+*
+* @param reducer Reducer function from downshift.
+* @param props The hook props, also passed to createInitialState.
+* @param createInitialState Function that returns the initial state.
+* @param isStateEqual Function that checks if a previous state is equal to the next.
+* @returns An array with the state and an action dispatcher.
+*/
+function useEnhancedReducer(reducer, props, createInitialState, isStateEqual) {
+	var prevStateRef = useRef({});
+	var enhancedReducer = useCallback(function(_ref, action) {
+		var state = _ref.state;
+		state = getState(state, action.props);
+		var changes = reducer(state, action);
+		var newState = action.props.stateReducer(state, _extends({}, action, { changes }));
+		return {
+			state: _extends({}, state, newState),
+			lastAction: action
+		};
+	}, [reducer]);
+	var _React$useReducer = useReducer(enhancedReducer, props, function(p) {
+		return {
+			state: createInitialState(p),
+			lastAction: void 0
+		};
+	}), _React$useReducer$ = _React$useReducer[0], state = _React$useReducer$.state, lastAction = _React$useReducer$.lastAction, dispatch = _React$useReducer[1];
+	var propsRef = useLatestRef(props);
+	var dispatchWithProps = useCallback(function(action) {
+		return dispatch(_extends({}, action, { props: propsRef.current }));
+	}, [propsRef]);
+	useEffect(function() {
+		if (lastAction) {
+			var prevState = getState(prevStateRef.current, lastAction.props);
+			if (!isStateEqual(prevState, state)) callOnChangeProps(lastAction, lastAction.props, prevState, state);
+		}
+		prevStateRef.current = state;
+	}, [
+		state,
+		lastAction,
+		isStateEqual
+	]);
+	return [state, dispatchWithProps];
+}
+/**
+* Wraps the useEnhancedReducer and applies the controlled prop values before
+* returning the new state.
+* @param reducer Reducer function from downshift.
+* @param props The hook props, also passed to createInitialState.
+* @param createInitialState Function that returns the initial state.
+* @param isStateEqual Function that checks if a previous state is equal to the next.
+* @returns An array with the state and an action dispatcher.
+*/
+function useControlledReducer$1(reducer, props, createInitialState, isStateEqual) {
+	var _useEnhancedReducer = useEnhancedReducer(reducer, props, createInitialState, isStateEqual), state = _useEnhancedReducer[0], dispatch = _useEnhancedReducer[1];
+	return [getState(state, props), dispatch];
+}
+/**
+* Returns both the item and index when both or either is passed.
+*
+* @param itemProp The item which could be undefined.
+* @param indexProp The index which could be undefined.
+* @param items The array of items to get the item based on index.
+* @param errorMessage The error to be thrown if index and item could not be returned for any reason.
+* @returns An array with item and index.
+*/
+function getItemAndIndex(itemProp, indexProp, items, errorMessage) {
+	if (itemProp !== void 0 && indexProp !== void 0) return [itemProp, indexProp];
+	if (itemProp !== void 0) {
+		if (items.indexOf(itemProp) < 0) throw new Error(errorMessage);
+		return [itemProp, items.indexOf(itemProp)];
+	}
+	if (indexProp !== void 0) {
+		var item = items[indexProp];
+		if (item === void 0) throw new Error(errorMessage);
+		return [item, indexProp];
+	}
+	throw new Error(errorMessage);
+}
+/**
+* Tracks if it's the first render.
+*/
+function useIsInitialMount() {
+	var isInitialMountRef = useRef(true);
+	useEffect(function() {
+		isInitialMountRef.current = false;
+		return function() {
+			isInitialMountRef.current = true;
+		};
+	}, []);
+	return isInitialMountRef.current;
+}
+/**
+* Returns the default value based on the defaultProp and defaultStateValue.
+*
+* @param defaultProp The default prop value.
+* @param defaultStateValue The default state value.
+* @returns The resolved default value.
+*/
+function getDefaultValue(defaultProp, defaultStateValue) {
+	return defaultProp === void 0 ? defaultStateValue : defaultProp;
+}
+/**
+* Returns the initial value for a state variable, based on the following precedence:
+* 1. The controlled value (if it's not undefined)
+* 2. The initialValue (if it's not undefined)
+* 3. The defaultValue (if it's not undefined)
+* 4. The defaultStateValue
+*
+* @param value The controlled value of the state variable.
+* @param initialValue The initial value of the state variable.
+* @param defaultValue The default value of the state variable.
+* @param defaultStateValue The default state value to use if all other values are undefined.
+* @returns The initial value for the state variable.
+*/
+function getInitialValue(value, initialValue, defaultValue, defaultStateValue) {
+	if (value !== void 0) return value;
+	if (initialValue !== void 0) return initialValue;
+	if (defaultValue !== void 0) return defaultValue;
+	return defaultStateValue;
+}
+/**
+* Adds an a11y aria live status message if getA11yStatusMessage is passed.
+* @param getA11yStatusMessage The function that builds the status message.
+* @param options The options to be passed to getA11yStatusMessage if called.
+* @param dependencyArray The dependency array that triggers the status message setter via useEffect.
+* @param environment The environment object containing the document.
+*/
+function useA11yMessageStatus(getA11yStatusMessage, options, dependencyArray, environment) {
+	var document = environment == null ? void 0 : environment.document;
+	var isInitialMount = useIsInitialMount();
+	useEffect(function() {
+		if (!getA11yStatusMessage || isInitialMount || !document) return;
+		updateA11yStatus(getA11yStatusMessage(options), document);
+	}, dependencyArray);
+	useEffect(function() {
+		return function() {
+			updateA11yStatus.cancel();
+			cleanupStatusDiv(document);
+		};
+	}, [document]);
+}
+function useElementIdsR18$1(_ref) {
+	var id = _ref.id, labelId = _ref.labelId, menuId = _ref.menuId, getItemId = _ref.getItemId, toggleButtonId = _ref.toggleButtonId, inputId = _ref.inputId;
+	var reactId = "downshift-" + reactUseId$1();
+	if (!id) id = reactId;
+	return useMemo(function() {
+		return {
+			labelId: labelId != null ? labelId : id + "-label",
+			menuId: menuId != null ? menuId : id + "-menu",
+			getItemId: getItemId != null ? getItemId : function(index) {
+				return id + "-item-" + index;
+			},
+			toggleButtonId: toggleButtonId != null ? toggleButtonId : id + "-toggle-button",
+			inputId: inputId != null ? inputId : id + "-input"
+		};
+	}, [
+		getItemId,
+		id,
+		inputId,
+		labelId,
+		menuId,
+		toggleButtonId
+	]);
+}
+function useElementIdsLegacy$1(_ref2) {
+	var id = _ref2.id, labelId = _ref2.labelId, menuId = _ref2.menuId, getItemId = _ref2.getItemId, toggleButtonId = _ref2.toggleButtonId, inputId = _ref2.inputId;
+	var baseId = useState(function() {
+		return id != null ? id : "downshift-" + generateId();
+	})[0];
+	return useMemo(function() {
+		return {
+			labelId: labelId != null ? labelId : baseId + "-label",
+			menuId: menuId != null ? menuId : baseId + "-menu",
+			getItemId: getItemId != null ? getItemId : function(index) {
+				return baseId + "-item-" + index;
+			},
+			toggleButtonId: toggleButtonId != null ? toggleButtonId : baseId + "-toggle-button",
+			inputId: inputId != null ? inputId : baseId + "-input"
+		};
+	}, [
+		getItemId,
+		inputId,
+		labelId,
+		menuId,
+		toggleButtonId,
+		baseId
+	]);
+}
+/**
+* Returns the new highlightedIndex based on the defaultHighlightedIndex prop, if it's not disabled.
+*
+* @param props Props passed to the hook.
+* @returns The highlighted index.
+*/
+function getDefaultHighlightedIndex(items, isItemDisabled, defaultHighlightedIndex) {
+	var highlightedIndex = getDefaultValue(defaultHighlightedIndex, dropdownDefaultStateValues.highlightedIndex);
+	if (items[highlightedIndex] && isItemDisabled(items[highlightedIndex], highlightedIndex)) return -1;
+	return highlightedIndex;
+}
+/**
+* Handles selection on Enter / Alt + ArrowUp. Closes the menu and resets the highlighted index, unless there is a highlighted.
+* In that case, selects the item and resets to defaults for open state and highlighted idex.
+*
+* @param props The Dropdown props.
+* @param highlightedIndex The index from the state.
+* @param inputValue Also return the input value for state.
+* @returns The changes for the state.
+*/
+function getChangesOnSelection(items, itemToString, defaultIsOpen, defaultHighlightedIndex, highlightedIndex, inputValue) {
+	var shouldSelect = items.length && highlightedIndex >= 0;
+	return _extends({
+		isOpen: false,
+		highlightedIndex: -1
+	}, shouldSelect && _extends({
+		selectedItem: items[highlightedIndex],
+		isOpen: getDefaultValue(defaultIsOpen, dropdownDefaultStateValues.isOpen),
+		highlightedIndex: getDefaultValue(defaultHighlightedIndex, dropdownDefaultStateValues.highlightedIndex)
+	}, inputValue && { inputValue: itemToString(items[highlightedIndex]) }));
+}
+/**
+* Returns the highlighted index when the menu is opened.
+* Takes into account the initialHighlightedIndex, defaultHighlightedIndex,
+* selectedItem, and the open direction offset.
+*
+* @param items The list of items.
+* @param initialHighlightedIndex The initial highlighted index prop.
+* @param defaultHighlightedIndex The default highlighted index prop.
+* @param isItemDisabled Callback to determine if an item is disabled.
+* @param itemToKey Callback to get a unique key from an item.
+* @param selectedItem The currently selected item.
+* @param highlightedIndex The current highlighted index from state.
+* @param offset The direction of navigation: positive opens downward, negative opens upward.
+* @returns The new highlighted index.
+*/
+function getHighlightedIndexOnOpen(items, initialHighlightedIndex, defaultHighlightedIndex, isItemDisabled, itemToKey, selectedItem, highlightedIndex, offset) {
+	if (items.length === 0) return -1;
+	if (initialHighlightedIndex !== void 0 && highlightedIndex === initialHighlightedIndex && (initialHighlightedIndex === -1 || items[initialHighlightedIndex] !== void 0 && !isItemDisabled(items[initialHighlightedIndex], initialHighlightedIndex))) return initialHighlightedIndex;
+	if (defaultHighlightedIndex !== void 0 && (defaultHighlightedIndex === -1 || items[defaultHighlightedIndex] !== void 0 && !isItemDisabled(items[defaultHighlightedIndex], defaultHighlightedIndex))) return defaultHighlightedIndex;
+	if (selectedItem) return items.findIndex(function(item) {
+		return itemToKey(selectedItem) === itemToKey(item);
+	});
+	if (offset < 0 && items[items.length - 1] && !isItemDisabled(items[items.length - 1], items.length - 1)) return items.length - 1;
+	if (offset > 0 && items[0] && !isItemDisabled(items[0], 0)) return 0;
+	return -1;
+}
+function getInitialState$3(props) {
+	var selectedItem = getInitialValue(props.selectedItem, props.initialSelectedItem, props.defaultSelectedItem, dropdownDefaultStateValues.selectedItem);
+	var isOpen = getInitialValue(props.isOpen, props.initialIsOpen, props.defaultIsOpen, dropdownDefaultStateValues.isOpen);
+	var highlightedIndex = getInitialHighlightedIndex(props);
+	var inputValue = getInitialValue(props.inputValue, props.initialInputValue, props.defaultInputValue, dropdownDefaultStateValues.inputValue);
+	return {
+		highlightedIndex: highlightedIndex < 0 && selectedItem && isOpen ? props.items.findIndex(function(item) {
+			return props.itemToKey(item) === props.itemToKey(selectedItem);
+		}) : highlightedIndex,
+		isOpen,
+		selectedItem,
+		inputValue
+	};
+}
+/**
+* Returns the new highlightedIndex based on the initialHighlightedIndex prop, if not disabled.
+* @param props Props from useCombobox or useSelect.
+* @returns The highlighted index.
+*/
+function getInitialHighlightedIndex(props) {
+	var highlightedIndex = getInitialValue(props.highlightedIndex, props.initialHighlightedIndex, props.defaultHighlightedIndex, dropdownDefaultStateValues.highlightedIndex);
+	if (highlightedIndex > -1 && props.items[highlightedIndex] && props.isItemDisabled(props.items[highlightedIndex], highlightedIndex)) return -1;
+	return highlightedIndex;
+}
+/**
+* Tracks mouse and touch events, such as mouseDown, touchMove and touchEnd.
+*
+* @param environment The environment to add the event listeners to, for instance window.
+* @param handleBlur The function that is called if mouseDown or touchEnd occured outside the downshiftElements.
+* @param downshiftRefs The refs for the elements that should not trigger a blur action from mouseDown or touchEnd.
+* @returns A ref holding the mouse and touch events information. Read `.current` only inside event handlers/effects.
+*/
+function useMouseAndTouchTracker(environment, handleBlur, downshiftRefs) {
+	var mouseAndTouchTrackersRef = useRef({
+		isMouseDown: false,
+		isTouchMove: false,
+		isTouchEnd: false
+	});
+	var getDownshiftElements = useCallback(function() {
+		return downshiftRefs.map(function(ref) {
+			return ref.current;
+		});
+	}, [downshiftRefs]);
+	useEffect(function() {
+		if (!environment) return noop;
+		function onMouseDown() {
+			mouseAndTouchTrackersRef.current.isTouchEnd = false;
+			mouseAndTouchTrackersRef.current.isMouseDown = true;
+		}
+		function onMouseUp(event) {
+			mouseAndTouchTrackersRef.current.isMouseDown = false;
+			if (!targetWithinDownshift(event.target, getDownshiftElements(), environment)) handleBlur();
+		}
+		function onTouchStart() {
+			mouseAndTouchTrackersRef.current.isTouchEnd = false;
+			mouseAndTouchTrackersRef.current.isTouchMove = false;
+		}
+		function onTouchMove() {
+			mouseAndTouchTrackersRef.current.isTouchMove = true;
+		}
+		function onTouchEnd(event) {
+			mouseAndTouchTrackersRef.current.isTouchEnd = true;
+			if (!mouseAndTouchTrackersRef.current.isTouchMove && !targetWithinDownshift(event.target, getDownshiftElements(), environment, false)) handleBlur();
+		}
+		environment.addEventListener("mousedown", onMouseDown);
+		environment.addEventListener("mouseup", onMouseUp);
+		environment.addEventListener("touchstart", onTouchStart);
+		environment.addEventListener("touchmove", onTouchMove);
+		environment.addEventListener("touchend", onTouchEnd);
+		return function cleanup() {
+			environment.removeEventListener("mousedown", onMouseDown);
+			environment.removeEventListener("mouseup", onMouseUp);
+			environment.removeEventListener("touchstart", onTouchStart);
+			environment.removeEventListener("touchmove", onTouchMove);
+			environment.removeEventListener("touchend", onTouchEnd);
+		};
+	}, [
+		environment,
+		getDownshiftElements,
+		handleBlur
+	]);
+	return mouseAndTouchTrackersRef;
+}
+/**
+* Utility hook that scrolls an item from a menu into view.
+* @param scrollIntoView The function that does the scroll.
+* @param highlightedIndex The index of the item that should be scrolled.
+* @param isOpen If the menu is open or not.
+* @param menuRef The ref to the menu element.
+* @param itemsRef The ref to the object containing item elements.
+* @param getItemId The function to get the item id from index.
+* @returns Function that when called prevents the scroll.
+*/
+function useScrollIntoView(scrollIntoView, highlightedIndex, isOpen, menuRef, itemsRef, getItemId) {
+	var shouldScrollRef = useRef(true);
+	useIsomorphicLayoutEffect(function() {
+		if (highlightedIndex < 0 || !isOpen || !Object.keys(itemsRef.current).length) return;
+		if (shouldScrollRef.current) {
+			var itemElement = itemsRef.current[getItemId(highlightedIndex)];
+			if (itemElement && menuRef.current) scrollIntoView(itemElement, menuRef.current);
+		} else shouldScrollRef.current = true;
+	}, [highlightedIndex]);
+	return useCallback(function preventScroll() {
+		shouldScrollRef.current = false;
+	}, []);
+}
+/**
+* Check if a state is equal for dropdowns, by comparing isOpen, inputValue, highlightedIndex and selected item.
+* Used by useSelect and useCombobox.
+*
+* @param prevState The previous dropdown state.
+* @param newState The new dropdown state.
+* @returns Whether the states are deeply equal.
+*/
+function isDropdownStateEqual(prevState, newState) {
+	return prevState.isOpen === newState.isOpen && prevState.inputValue === newState.inputValue && prevState.highlightedIndex === newState.highlightedIndex && prevState.selectedItem === newState.selectedItem;
+}
+function downshiftCommonReducer(state, props, action, stateChangeTypes) {
+	var type = action.type;
+	var changes;
+	switch (type) {
+		case stateChangeTypes.ItemMouseMove:
+			changes = { highlightedIndex: action.disabled ? -1 : action.index };
+			break;
+		case stateChangeTypes.MenuMouseLeave:
+			changes = { highlightedIndex: -1 };
+			break;
+		case stateChangeTypes.ToggleButtonClick:
+		case stateChangeTypes.FunctionToggleMenu:
+			changes = {
+				isOpen: !state.isOpen,
+				highlightedIndex: state.isOpen ? -1 : getHighlightedIndexOnOpen(props.items, props.initialHighlightedIndex, props.defaultHighlightedIndex, props.isItemDisabled, props.itemToKey, state.selectedItem, state.highlightedIndex, 0)
+			};
+			break;
+		case stateChangeTypes.FunctionOpenMenu:
+			changes = {
+				isOpen: true,
+				highlightedIndex: getHighlightedIndexOnOpen(props.items, props.initialHighlightedIndex, props.defaultHighlightedIndex, props.isItemDisabled, props.itemToKey, state.selectedItem, state.highlightedIndex, 0)
+			};
+			break;
+		case stateChangeTypes.FunctionCloseMenu:
+			changes = { isOpen: false };
+			break;
+		case stateChangeTypes.FunctionSetHighlightedIndex:
+			var highlightedIndex = action.highlightedIndex;
+			changes = { highlightedIndex: props.isItemDisabled(props.items[highlightedIndex], highlightedIndex) ? -1 : highlightedIndex };
+			break;
+		case stateChangeTypes.FunctionSetInputValue:
+			changes = { inputValue: action.inputValue };
+			break;
+		case stateChangeTypes.FunctionReset:
+			changes = {
+				highlightedIndex: getDefaultHighlightedIndex(props.items, props.isItemDisabled, props.defaultHighlightedIndex),
+				isOpen: getDefaultValue(props.defaultIsOpen, dropdownDefaultStateValues.isOpen),
+				selectedItem: getDefaultValue(props.defaultSelectedItem, dropdownDefaultStateValues.selectedItem),
+				inputValue: getDefaultValue(props.defaultInputValue, dropdownDefaultStateValues.inputValue)
+			};
+			break;
+		default: throw new Error("Reducer called without proper action type.");
+	}
+	return _extends({}, state, changes);
+}
+function getItemIndexByCharacterKey(_ref) {
+	var keysSoFar = _ref.keysSoFar, highlightedIndex = _ref.highlightedIndex, items = _ref.items, itemToString = _ref.itemToString, isItemDisabled = _ref.isItemDisabled;
+	var lowerCasedKeysSoFar = keysSoFar.toLowerCase();
+	for (var _index = 0; _index < items.length; _index++) {
+		var offsetIndex = (_index + highlightedIndex + (keysSoFar.length < 2 ? 1 : 0)) % items.length;
+		var _item = items[offsetIndex];
+		if (_item !== void 0 && itemToString(_item).toLowerCase().startsWith(lowerCasedKeysSoFar) && !isItemDisabled(_item, offsetIndex)) return offsetIndex;
+	}
+	return highlightedIndex;
+}
+function downshiftSelectReducer(state, action) {
+	var type = action.type, props = action.props;
+	var changes;
+	switch (type) {
+		case ItemClick$1:
+			changes = {
+				isOpen: getDefaultValue(props.defaultIsOpen, dropdownDefaultStateValues.isOpen),
+				highlightedIndex: getDefaultHighlightedIndex(props.items, props.isItemDisabled, props.defaultHighlightedIndex),
+				selectedItem: props.items[action.index]
+			};
+			break;
+		case ToggleButtonKeyDownCharacter:
+			var lowercasedKey = action.key;
+			var inputValue = "" + state.inputValue + lowercasedKey;
+			changes = {
+				inputValue,
+				highlightedIndex: getItemIndexByCharacterKey({
+					keysSoFar: inputValue,
+					highlightedIndex: !state.isOpen && state.selectedItem ? props.items.findIndex(function(item) {
+						return props.itemToKey(item) === props.itemToKey(state.selectedItem);
+					}) : state.highlightedIndex,
+					items: props.items,
+					itemToString: props.itemToString,
+					isItemDisabled: props.isItemDisabled
+				}),
+				isOpen: true
+			};
+			break;
+		case ToggleButtonKeyDownArrowDown:
+			var altKey = action.altKey;
+			changes = {
+				highlightedIndex: state.isOpen ? getHighlightedIndex(state.highlightedIndex, 1, props.items, props.isItemDisabled) : altKey && state.selectedItem == null ? -1 : getHighlightedIndexOnOpen(props.items, props.initialHighlightedIndex, props.defaultHighlightedIndex, props.isItemDisabled, props.itemToKey, state.selectedItem, state.highlightedIndex, 1),
+				isOpen: true
+			};
+			break;
+		case ToggleButtonKeyDownArrowUp:
+			var _altKey = action.altKey;
+			if (state.isOpen && _altKey) changes = getChangesOnSelection(props.items, props.itemToString, props.defaultIsOpen, props.defaultHighlightedIndex, state.highlightedIndex, false);
+			else changes = {
+				highlightedIndex: state.isOpen ? getHighlightedIndex(state.highlightedIndex, -1, props.items, props.isItemDisabled) : getHighlightedIndexOnOpen(props.items, props.initialHighlightedIndex, props.defaultHighlightedIndex, props.isItemDisabled, props.itemToKey, state.selectedItem, state.highlightedIndex, -1),
+				isOpen: true
+			};
+			break;
+		case ToggleButtonKeyDownEnter:
+		case ToggleButtonKeyDownSpaceButton:
+			changes = getChangesOnSelection(props.items, props.itemToString, props.defaultIsOpen, props.defaultHighlightedIndex, state.highlightedIndex, false);
+			break;
+		case ToggleButtonKeyDownHome:
+			changes = {
+				highlightedIndex: getNonDisabledIndex(0, false, props.items, props.isItemDisabled),
+				isOpen: true
+			};
+			break;
+		case ToggleButtonKeyDownEnd:
+			changes = {
+				highlightedIndex: getNonDisabledIndex(props.items.length - 1, true, props.items, props.isItemDisabled),
+				isOpen: true
+			};
+			break;
+		case ToggleButtonKeyDownPageUp:
+			changes = { highlightedIndex: getHighlightedIndex(state.highlightedIndex, -10, props.items, props.isItemDisabled) };
+			break;
+		case ToggleButtonKeyDownPageDown:
+			changes = { highlightedIndex: getHighlightedIndex(state.highlightedIndex, 10, props.items, props.isItemDisabled) };
+			break;
+		case ToggleButtonKeyDownEscape:
+			changes = {
+				isOpen: false,
+				highlightedIndex: -1
+			};
+			break;
+		case ToggleButtonBlur:
+			changes = _extends({
+				isOpen: false,
+				highlightedIndex: -1
+			}, state.highlightedIndex >= 0 && props.items.length && { selectedItem: props.items[state.highlightedIndex] });
+			break;
+		case FunctionSelectItem$1:
+			changes = { selectedItem: action.selectedItem };
+			break;
+		default: return downshiftCommonReducer(state, props, action, stateChangeTypes$3);
+	}
+	return _extends({}, state, changes);
+}
+function useSelect(userProps) {
+	if (userProps === void 0) userProps = {};
+	validatePropTypes$1(userProps, useSelect, propTypes$3);
+	var props = _extends({}, dropdownDefaultProps, userProps);
+	var items = props.items, isItemDisabled = props.isItemDisabled, scrollIntoView = props.scrollIntoView, environment = props.environment, getA11yStatusMessage = props.getA11yStatusMessage;
+	var _useControlledReducer = useControlledReducer$1(downshiftSelectReducer, props, getInitialState$3, isDropdownStateEqual), state = _useControlledReducer[0], dispatch = _useControlledReducer[1];
+	var isOpen = state.isOpen, highlightedIndex = state.highlightedIndex, selectedItem = state.selectedItem, inputValue = state.inputValue;
+	var toggleButtonRef = useRef(null);
+	var menuRef = useRef(null);
+	var itemsRef = useRef({});
+	var clearTimeoutRef = useRef(null);
+	var elementIds = useElementIds$1(props);
+	/**
+	* Ref to read `state` in handlers to preserve referential identity.
+	* Only to be used in handlers and effects.
+	* **never access this in getters**
+	*/
+	var stateRef = useLatestRef(state);
+	useA11yMessageStatus(getA11yStatusMessage, state, [
+		isOpen,
+		highlightedIndex,
+		selectedItem,
+		inputValue
+	], environment);
+	var preventScroll = useScrollIntoView(scrollIntoView, highlightedIndex, isOpen, menuRef, itemsRef, elementIds.getItemId);
+	useEffect(function() {
+		clearTimeoutRef.current = debounce(function(outerDispatch) {
+			outerDispatch({
+				type: FunctionSetInputValue$1,
+				inputValue: ""
+			});
+		}, 500);
+		return function() {
+			var _clearTimeoutRef$curr;
+			(_clearTimeoutRef$curr = clearTimeoutRef.current) == null || _clearTimeoutRef$curr.cancel();
+		};
+	}, []);
+	useEffect(function() {
+		if (!inputValue) return;
+		clearTimeoutRef.current == null || clearTimeoutRef.current(dispatch);
+	}, [dispatch, inputValue]);
+	useControlPropsValidator({
+		props,
+		state
+	});
+	useEffect(function() {
+		if (getInitialValue(props.isOpen, props.initialIsOpen, props.defaultIsOpen, dropdownDefaultStateValues.isOpen) && toggleButtonRef.current) toggleButtonRef.current.focus();
+	}, []);
+	var mouseAndTouchTrackers = useMouseAndTouchTracker(environment, useCallback(function handleBlur() {
+		if (stateRef.current.isOpen) dispatch({ type: ToggleButtonBlur });
+	}, [dispatch, stateRef]), useMemo(function() {
+		return [menuRef, toggleButtonRef];
+	}, []));
+	var setGetterPropCallInfo = useGetterPropsCalledChecker("getMenuProps", "getToggleButtonProps");
+	useEffect(function() {
+		if (!isOpen) itemsRef.current = {};
+	}, [isOpen]);
+	var toggleButtonKeyDownHandlers = useMemo(function() {
+		return {
+			ArrowDown: function ArrowDown(event) {
+				event.preventDefault();
+				dispatch({
+					type: ToggleButtonKeyDownArrowDown,
+					altKey: event.altKey
+				});
+			},
+			ArrowUp: function ArrowUp(event) {
+				event.preventDefault();
+				dispatch({
+					type: ToggleButtonKeyDownArrowUp,
+					altKey: event.altKey
+				});
+			},
+			Home: function Home(event) {
+				event.preventDefault();
+				dispatch({ type: ToggleButtonKeyDownHome });
+			},
+			End: function End(event) {
+				event.preventDefault();
+				dispatch({ type: ToggleButtonKeyDownEnd });
+			},
+			Escape: function Escape() {
+				if (stateRef.current.isOpen) dispatch({ type: ToggleButtonKeyDownEscape });
+			},
+			Enter: function Enter(event) {
+				event.preventDefault();
+				dispatch({ type: stateRef.current.isOpen ? ToggleButtonKeyDownEnter : ToggleButtonClick$1 });
+			},
+			PageUp: function PageUp(event) {
+				if (stateRef.current.isOpen) {
+					event.preventDefault();
+					dispatch({ type: ToggleButtonKeyDownPageUp });
+				}
+			},
+			PageDown: function PageDown(event) {
+				if (stateRef.current.isOpen) {
+					event.preventDefault();
+					dispatch({ type: ToggleButtonKeyDownPageDown });
+				}
+			},
+			" ": function _(event) {
+				event.preventDefault();
+				var currentState = stateRef.current;
+				if (!currentState.isOpen) {
+					dispatch({ type: ToggleButtonClick$1 });
+					return;
+				}
+				if (currentState.inputValue) dispatch({
+					type: ToggleButtonKeyDownCharacter,
+					key: " "
+				});
+				else dispatch({ type: ToggleButtonKeyDownSpaceButton });
+			}
+		};
+	}, [dispatch, stateRef]);
+	var getLabelProps = useCallback(function(labelProps) {
+		var _ref = labelProps != null ? labelProps : {}, onClick = _ref.onClick, rest = _objectWithoutPropertiesLoose(_ref, _excluded$3);
+		return _extends({
+			id: elementIds.labelId,
+			htmlFor: elementIds.toggleButtonId,
+			onClick: callAllEventHandlers(onClick, function labelHandleClick() {
+				var _toggleButtonRef$curr;
+				(_toggleButtonRef$curr = toggleButtonRef.current) == null || _toggleButtonRef$curr.focus();
+			})
+		}, rest);
+	}, [elementIds]);
+	var getMenuProps = useCallback(function(menuProps, otherProps) {
+		var _extends2;
+		var _ref2 = menuProps != null ? menuProps : {}, onMouseLeave = _ref2.onMouseLeave, _ref2$refKey = _ref2.refKey, refKey = _ref2$refKey === void 0 ? "ref" : _ref2$refKey, ref = _ref2.ref, ariaLabel = _ref2["aria-label"], rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$3);
+		var _ref3$suppressRefErro = (otherProps != null ? otherProps : {}).suppressRefError, suppressRefError = _ref3$suppressRefErro === void 0 ? false : _ref3$suppressRefErro;
+		var menuHandleMouseLeave = function menuHandleMouseLeave() {
+			dispatch({ type: MenuMouseLeave$1 });
+		};
+		setGetterPropCallInfo("getMenuProps", suppressRefError, refKey, menuRef);
+		return _extends((_extends2 = {}, _extends2[refKey] = handleRefs(ref, function(menuNode) {
+			menuRef.current = menuNode;
+		}), _extends2.id = elementIds.menuId, _extends2.role = "listbox", _extends2["aria-label"] = ariaLabel, _extends2["aria-labelledby"] = ariaLabel ? void 0 : "" + elementIds.labelId, _extends2.onMouseLeave = callAllEventHandlers(onMouseLeave, menuHandleMouseLeave), _extends2), rest);
+	}, [
+		dispatch,
+		setGetterPropCallInfo,
+		elementIds
+	]);
+	var getToggleButtonProps = useCallback(function(toggleButtonProps, otherProps) {
+		var _extends3;
+		var _ref4 = toggleButtonProps != null ? toggleButtonProps : {}, onBlur = _ref4.onBlur, onClick = _ref4.onClick;
+		_ref4.onPress;
+		var onKeyDown = _ref4.onKeyDown, _ref4$refKey = _ref4.refKey, refKey = _ref4$refKey === void 0 ? "ref" : _ref4$refKey, ref = _ref4.ref, rest = _objectWithoutPropertiesLoose(_ref4, _excluded3$2);
+		var _ref5$suppressRefErro = (otherProps != null ? otherProps : {}).suppressRefError, suppressRefError = _ref5$suppressRefErro === void 0 ? false : _ref5$suppressRefErro;
+		var toggleButtonHandleClick = function toggleButtonHandleClick() {
+			dispatch({ type: ToggleButtonClick$1 });
+		};
+		var toggleButtonHandleBlur = function toggleButtonHandleBlur() {
+			if (stateRef.current.isOpen && !mouseAndTouchTrackers.current.isMouseDown) dispatch({ type: ToggleButtonBlur });
+		};
+		var toggleButtonHandleKeyDown = function toggleButtonHandleKeyDown(event) {
+			var key = normalizeArrowKey(event);
+			if (key && key in toggleButtonKeyDownHandlers) toggleButtonKeyDownHandlers[key](event);
+			else if (/^\S{1}$/.test(key)) dispatch({
+				type: ToggleButtonKeyDownCharacter,
+				key
+			});
+		};
+		var toggleProps = _extends((_extends3 = {}, _extends3[refKey] = handleRefs(ref, function(toggleButtonNode) {
+			toggleButtonRef.current = toggleButtonNode;
+		}), _extends3["aria-activedescendant"] = isOpen && highlightedIndex > -1 ? elementIds.getItemId(highlightedIndex) : "", _extends3["aria-controls"] = elementIds.menuId, _extends3["aria-expanded"] = isOpen, _extends3["aria-haspopup"] = "listbox", _extends3["aria-labelledby"] = rest["aria-label"] ? void 0 : "" + elementIds.labelId, _extends3.id = elementIds.toggleButtonId, _extends3.role = "combobox", _extends3.tabIndex = 0, _extends3.onBlur = callAllEventHandlers(onBlur, toggleButtonHandleBlur), _extends3), rest);
+		if (!rest.disabled) Object.assign(toggleProps, {
+			onClick: callAllEventHandlers(onClick, toggleButtonHandleClick),
+			onKeyDown: callAllEventHandlers(onKeyDown, toggleButtonHandleKeyDown)
+		});
+		setGetterPropCallInfo("getToggleButtonProps", suppressRefError, refKey, toggleButtonRef);
+		return toggleProps;
+	}, [
+		dispatch,
+		elementIds,
+		isOpen,
+		highlightedIndex,
+		mouseAndTouchTrackers,
+		setGetterPropCallInfo,
+		toggleButtonKeyDownHandlers,
+		stateRef
+	]);
+	var getItemProps = useCallback(function(itemProps) {
+		var _extends4;
+		var _ref6 = itemProps != null ? itemProps : {}, itemProp = _ref6.item, indexProp = _ref6.index, onMouseMove = _ref6.onMouseMove, onClick = _ref6.onClick, onMouseDown = _ref6.onMouseDown;
+		_ref6.onPress;
+		var _ref6$refKey = _ref6.refKey, refKey = _ref6$refKey === void 0 ? "ref" : _ref6$refKey, disabledProp = _ref6.disabled, ref = _ref6.ref, rest = _objectWithoutPropertiesLoose(_ref6, _excluded4$1);
+		if (disabledProp !== void 0) console.warn("Passing \"disabled\" as an argument to getItemProps is not supported anymore. Please use the isItemDisabled prop from useSelect.");
+		var _getItemAndIndex = getItemAndIndex(itemProp, indexProp, items, "Pass either item or index to getItemProps!"), item = _getItemAndIndex[0], index = _getItemAndIndex[1];
+		var disabled = isItemDisabled(item, index);
+		var itemHandleMouseMove = function itemHandleMouseMove() {
+			if (mouseAndTouchTrackers.current.isTouchEnd || index === stateRef.current.highlightedIndex) return;
+			preventScroll();
+			dispatch({
+				type: ItemMouseMove$1,
+				index,
+				disabled
+			});
+		};
+		var itemHandleClick = function itemHandleClick() {
+			dispatch({
+				type: ItemClick$1,
+				index
+			});
+		};
+		var resultItemProps = _extends((_extends4 = {}, _extends4[refKey] = handleRefs(ref, function(itemNode) {
+			if (itemNode) itemsRef.current[elementIds.getItemId(index)] = itemNode;
+		}), _extends4["aria-disabled"] = disabled, _extends4["aria-selected"] = item === selectedItem, _extends4.id = elementIds.getItemId(index), _extends4.role = "option", _extends4.onMouseMove = callAllEventHandlers(onMouseMove, itemHandleMouseMove), _extends4.onMouseDown = callAllEventHandlers(onMouseDown, function itemHandleMouseDown(e) {
+			return e.preventDefault();
+		}), _extends4), rest);
+		if (!disabled) Object.assign(resultItemProps, { onClick: callAllEventHandlers(onClick, itemHandleClick) });
+		return resultItemProps;
+	}, [
+		items,
+		isItemDisabled,
+		selectedItem,
+		elementIds,
+		mouseAndTouchTrackers,
+		preventScroll,
+		dispatch,
+		stateRef
+	]);
+	var toggleMenu = useCallback(function() {
+		dispatch({ type: FunctionToggleMenu$1 });
+	}, [dispatch]);
+	var closeMenu = useCallback(function() {
+		dispatch({ type: FunctionCloseMenu$1 });
+	}, [dispatch]);
+	return {
+		getToggleButtonProps,
+		getLabelProps,
+		getMenuProps,
+		getItemProps,
+		toggleMenu,
+		openMenu: useCallback(function() {
+			dispatch({ type: FunctionOpenMenu$1 });
+		}, [dispatch]),
+		closeMenu,
+		setHighlightedIndex: useCallback(function(newHighlightedIndex) {
+			dispatch({
+				type: FunctionSetHighlightedIndex$1,
+				highlightedIndex: newHighlightedIndex
+			});
+		}, [dispatch]),
+		selectItem: useCallback(function(newSelectedItem) {
+			dispatch({
+				type: FunctionSelectItem$1,
+				selectedItem: newSelectedItem
+			});
+		}, [dispatch]),
+		reset: useCallback(function() {
+			dispatch({ type: FunctionReset$2 });
+		}, [dispatch]),
+		setInputValue: useCallback(function(newInputValue) {
+			dispatch({
+				type: FunctionSetInputValue$1,
+				inputValue: newInputValue
+			});
+		}, [dispatch]),
+		highlightedIndex,
+		isOpen,
+		selectedItem,
+		inputValue
+	};
+}
+function getInitialState$2(props) {
+	var initialState = getInitialState$3(props);
+	var selectedItem = initialState.selectedItem;
+	var inputValue = initialState.inputValue;
+	if (inputValue === "" && selectedItem && props.defaultInputValue === void 0 && props.initialInputValue === void 0 && props.inputValue === void 0) inputValue = props.itemToString(selectedItem);
+	return _extends({}, initialState, { inputValue });
+}
+/**
+* The useCombobox version of useControlledReducer, which also
+* checks if the controlled prop selectedItem changed between
+* renders. If so, it will also update inputValue with its
+* string equivalent. It uses the common useEnhancedReducer to
+* compute the rest of the state.
+*
+* @param reducer Reducer function from downshift.
+* @param props The hook props, also passed to createInitialState.
+* @param createInitialState Function that returns the initial state.
+* @param isStateEqual Function that checks if a previous state is equal to the next.
+* @returns An array with the state and an action dispatcher.
+*/
+function useControlledReducer(reducer, props, createInitialState, isStateEqual) {
+	var previousSelectedItemRef = useRef(null);
+	var _useEnhancedReducer = useEnhancedReducer(reducer, props, createInitialState, isStateEqual), state = _useEnhancedReducer[0], dispatch = _useEnhancedReducer[1];
+	var isInitialMount = useIsInitialMount();
+	useEffect(function() {
+		if (props.selectedItem === void 0) return;
+		if (!isInitialMount) {
+			if (props.itemToKey(props.selectedItem) !== props.itemToKey(previousSelectedItemRef.current)) dispatch({
+				type: ControlledPropUpdatedSelectedItem,
+				inputValue: props.itemToString(props.selectedItem)
+			});
+		}
+		previousSelectedItemRef.current = state.selectedItem === previousSelectedItemRef.current ? props.selectedItem : state.selectedItem;
+	}, [state.selectedItem, props.selectedItem]);
+	return [getState(state, props), dispatch];
+}
+function downshiftUseComboboxReducer(state, action) {
+	var type = action.type, props = action.props;
+	var changes;
+	switch (type) {
+		case ItemClick:
+			changes = {
+				isOpen: getDefaultValue(props.defaultIsOpen, dropdownDefaultStateValues.isOpen),
+				highlightedIndex: getDefaultHighlightedIndex(props.items, props.isItemDisabled, props.defaultHighlightedIndex),
+				selectedItem: props.items[action.index],
+				inputValue: props.itemToString(props.items[action.index])
+			};
+			break;
+		case InputKeyDownArrowDown:
+			if (state.isOpen) changes = { highlightedIndex: getHighlightedIndex(state.highlightedIndex, 1, props.items, props.isItemDisabled, true) };
+			else changes = {
+				highlightedIndex: action.altKey && state.selectedItem == null ? -1 : getHighlightedIndexOnOpen(props.items, props.initialHighlightedIndex, props.defaultHighlightedIndex, props.isItemDisabled, props.itemToKey, state.selectedItem, state.highlightedIndex, 1),
+				isOpen: props.items.length >= 0
+			};
+			break;
+		case InputKeyDownArrowUp:
+			if (state.isOpen) {
+				if (action.altKey) changes = getChangesOnSelection(props.items, props.itemToString, props.defaultIsOpen, props.defaultHighlightedIndex, state.highlightedIndex, true);
+				else changes = { highlightedIndex: getHighlightedIndex(state.highlightedIndex, -1, props.items, props.isItemDisabled, true) };
+			} else changes = {
+				highlightedIndex: getHighlightedIndexOnOpen(props.items, props.initialHighlightedIndex, props.defaultHighlightedIndex, props.isItemDisabled, props.itemToKey, state.selectedItem, state.highlightedIndex, -1),
+				isOpen: props.items.length >= 0
+			};
+			break;
+		case InputKeyDownEnter:
+			changes = getChangesOnSelection(props.items, props.itemToString, props.defaultIsOpen, props.defaultHighlightedIndex, state.highlightedIndex, true);
+			break;
+		case InputKeyDownEscape:
+			changes = _extends({
+				isOpen: false,
+				highlightedIndex: -1
+			}, !state.isOpen && {
+				selectedItem: null,
+				inputValue: ""
+			});
+			break;
+		case InputKeyDownPageUp:
+			changes = { highlightedIndex: getHighlightedIndex(state.highlightedIndex, -10, props.items, props.isItemDisabled, true) };
+			break;
+		case InputKeyDownPageDown:
+			changes = { highlightedIndex: getHighlightedIndex(state.highlightedIndex, 10, props.items, props.isItemDisabled, true) };
+			break;
+		case InputKeyDownHome:
+			changes = { highlightedIndex: getNonDisabledIndex(0, false, props.items, props.isItemDisabled) };
+			break;
+		case InputKeyDownEnd:
+			changes = { highlightedIndex: getNonDisabledIndex(props.items.length - 1, true, props.items, props.isItemDisabled) };
+			break;
+		case InputBlur:
+			changes = _extends({
+				isOpen: false,
+				highlightedIndex: -1
+			}, state.highlightedIndex >= 0 && props.items.length && action.selectItem && {
+				selectedItem: props.items[state.highlightedIndex],
+				inputValue: props.itemToString(props.items[state.highlightedIndex])
+			});
+			break;
+		case InputChange:
+			changes = {
+				isOpen: true,
+				highlightedIndex: getDefaultHighlightedIndex(props.items, props.isItemDisabled, props.defaultHighlightedIndex),
+				inputValue: action.inputValue
+			};
+			break;
+		case InputClick:
+			changes = {
+				isOpen: !state.isOpen,
+				highlightedIndex: state.isOpen ? -1 : getHighlightedIndexOnOpen(props.items, props.initialHighlightedIndex, props.defaultHighlightedIndex, props.isItemDisabled, props.itemToKey, state.selectedItem, state.highlightedIndex, 0)
+			};
+			break;
+		case FunctionSelectItem:
+			changes = {
+				selectedItem: action.selectedItem,
+				inputValue: props.itemToString(action.selectedItem)
+			};
+			break;
+		case ControlledPropUpdatedSelectedItem:
+			changes = { inputValue: action.inputValue };
+			break;
+		default: return downshiftCommonReducer(state, props, action, stateChangeTypes$2);
+	}
+	return _extends({}, state, changes);
+}
+function useCombobox(userProps) {
+	if (userProps === void 0) userProps = {};
+	validatePropTypes$1(userProps, useCombobox, propTypes$2);
+	var props = _extends({}, dropdownDefaultProps, userProps);
+	var items = props.items, isItemDisabled = props.isItemDisabled, scrollIntoView = props.scrollIntoView, environment = props.environment, getA11yStatusMessage = props.getA11yStatusMessage;
+	var _useControlledReducer = useControlledReducer(downshiftUseComboboxReducer, props, getInitialState$2, isDropdownStateEqual), state = _useControlledReducer[0], dispatch = _useControlledReducer[1];
+	var isOpen = state.isOpen, highlightedIndex = state.highlightedIndex, selectedItem = state.selectedItem, inputValue = state.inputValue;
+	var menuRef = useRef(null);
+	var itemsRef = useRef({});
+	var inputRef = useRef(null);
+	var toggleButtonRef = useRef(null);
+	var isInitialMount = useIsInitialMount();
+	var elementIds = useElementIds$1(props);
+	var previousResultCountRef = useRef();
+	/**
+	* Ref to read `state` in handlers to preserve referential identity.
+	* Only to be used in handlers and effects.
+	* **never access this in getters**
+	*/
+	var stateRef = useLatestRef(state);
+	useA11yMessageStatus(getA11yStatusMessage, state, [
+		isOpen,
+		highlightedIndex,
+		selectedItem,
+		inputValue
+	], environment);
+	var preventScroll = useScrollIntoView(scrollIntoView, highlightedIndex, isOpen, menuRef, itemsRef, elementIds.getItemId);
+	useControlPropsValidator({
+		state,
+		props
+	});
+	useEffect(function() {
+		if (getInitialValue(props.isOpen, props.initialIsOpen, props.defaultIsOpen, dropdownDefaultStateValues.isOpen) && inputRef.current) inputRef.current.focus();
+	}, []);
+	useEffect(function() {
+		if (!isInitialMount) previousResultCountRef.current = items.length;
+	});
+	var mouseAndTouchTrackers = useMouseAndTouchTracker(environment, useCallback(function handleBlur() {
+		if (stateRef.current.isOpen) dispatch({ type: InputBlur });
+	}, [dispatch, stateRef]), useMemo(function() {
+		return [
+			menuRef,
+			toggleButtonRef,
+			inputRef
+		];
+	}, []));
+	var setGetterPropCallInfo = useGetterPropsCalledChecker("getInputProps", "getMenuProps");
+	useEffect(function() {
+		if (!isOpen) itemsRef.current = {};
+	}, [isOpen]);
+	useEffect(function() {
+		var _inputRef$current;
+		if (!isOpen || !(environment != null && environment.document) || !((_inputRef$current = inputRef.current) != null && _inputRef$current.focus)) return;
+		if (environment.document.activeElement !== inputRef.current) inputRef.current.focus();
+	}, [isOpen, environment]);
+	var inputKeyDownHandlers = useMemo(function() {
+		return {
+			ArrowDown: function ArrowDown(event) {
+				event.preventDefault();
+				dispatch({
+					type: InputKeyDownArrowDown,
+					altKey: event.altKey
+				});
+			},
+			ArrowUp: function ArrowUp(event) {
+				event.preventDefault();
+				dispatch({
+					type: InputKeyDownArrowUp,
+					altKey: event.altKey
+				});
+			},
+			Home: function Home(event) {
+				if (!stateRef.current.isOpen) return;
+				event.preventDefault();
+				dispatch({ type: InputKeyDownHome });
+			},
+			End: function End(event) {
+				if (!stateRef.current.isOpen) return;
+				event.preventDefault();
+				dispatch({ type: InputKeyDownEnd });
+			},
+			Escape: function Escape(event) {
+				var latestState = stateRef.current;
+				if (latestState.isOpen || latestState.inputValue || latestState.selectedItem || latestState.highlightedIndex > -1) {
+					event.preventDefault();
+					dispatch({ type: InputKeyDownEscape });
+				}
+			},
+			Enter: function Enter(event) {
+				if (!stateRef.current.isOpen || event.which === 229) return;
+				event.preventDefault();
+				dispatch({ type: InputKeyDownEnter });
+			},
+			PageUp: function PageUp(event) {
+				if (stateRef.current.isOpen) {
+					event.preventDefault();
+					dispatch({ type: InputKeyDownPageUp });
+				}
+			},
+			PageDown: function PageDown(event) {
+				if (stateRef.current.isOpen) {
+					event.preventDefault();
+					dispatch({ type: InputKeyDownPageDown });
+				}
+			}
+		};
+	}, [dispatch, stateRef]);
+	var getLabelProps = useCallback(function(labelProps) {
+		return _extends({
+			id: elementIds.labelId,
+			htmlFor: elementIds.inputId
+		}, labelProps);
+	}, [elementIds]);
+	var getMenuProps = useCallback(function(menuProps, otherProps) {
+		var _extends2;
+		var _ref = menuProps != null ? menuProps : {}, onMouseLeave = _ref.onMouseLeave, _ref$refKey = _ref.refKey, refKey = _ref$refKey === void 0 ? "ref" : _ref$refKey, ref = _ref.ref, ariaLabel = _ref["aria-label"], rest = _objectWithoutPropertiesLoose(_ref, _excluded$2);
+		var _ref2$suppressRefErro = (otherProps != null ? otherProps : {}).suppressRefError;
+		setGetterPropCallInfo("getMenuProps", _ref2$suppressRefErro === void 0 ? false : _ref2$suppressRefErro, refKey, menuRef);
+		return _extends((_extends2 = {}, _extends2[refKey] = handleRefs(ref, function(menuNode) {
+			menuRef.current = menuNode;
+		}), _extends2.id = elementIds.menuId, _extends2.role = "listbox", _extends2["aria-label"] = ariaLabel, _extends2["aria-labelledby"] = ariaLabel ? void 0 : "" + elementIds.labelId, _extends2.onMouseLeave = callAllEventHandlers(onMouseLeave, function() {
+			dispatch({ type: MenuMouseLeave });
+		}), _extends2), rest);
+	}, [
+		dispatch,
+		setGetterPropCallInfo,
+		elementIds
+	]);
+	var getItemProps = useCallback(function(itemProps) {
+		var _extends3, _ref4;
+		var _ref3 = itemProps != null ? itemProps : {}, itemProp = _ref3.item, indexProp = _ref3.index, _ref3$refKey = _ref3.refKey, refKey = _ref3$refKey === void 0 ? "ref" : _ref3$refKey, ref = _ref3.ref, onMouseMove = _ref3.onMouseMove, onMouseDown = _ref3.onMouseDown, onClick = _ref3.onClick;
+		_ref3.onPress;
+		var disabledProp = _ref3.disabled, rest = _objectWithoutPropertiesLoose(_ref3, _excluded2$2);
+		if (disabledProp !== void 0) console.warn("Passing \"disabled\" as an argument to getItemProps is not supported anymore. Please use the isItemDisabled prop from useCombobox.");
+		var _getItemAndIndex = getItemAndIndex(itemProp, indexProp, items, "Pass either item or index to getItemProps!"), item = _getItemAndIndex[0], index = _getItemAndIndex[1];
+		var disabled = isItemDisabled(item, index);
+		var onSelectKey = "onClick";
+		var customClickHandler = onClick;
+		return _extends((_extends3 = {}, _extends3[refKey] = handleRefs(ref, function(itemNode) {
+			if (itemNode) itemsRef.current[elementIds.getItemId(index)] = itemNode;
+		}), _extends3["aria-disabled"] = disabled, _extends3["aria-selected"] = index === highlightedIndex, _extends3.id = elementIds.getItemId(index), _extends3.role = "option", _extends3), !disabled && (_ref4 = {}, _ref4[onSelectKey] = callAllEventHandlers(customClickHandler, function itemHandleClick() {
+			dispatch({
+				type: ItemClick,
+				index
+			});
+		}), _ref4), {
+			onMouseMove: callAllEventHandlers(onMouseMove, function itemHandleMouseMove() {
+				if (mouseAndTouchTrackers.current.isTouchEnd || index === stateRef.current.highlightedIndex) return;
+				preventScroll();
+				dispatch({
+					type: ItemMouseMove,
+					index,
+					disabled
+				});
+			}),
+			onMouseDown: callAllEventHandlers(onMouseDown, function itemHandleMouseDown(e) {
+				return e.preventDefault();
+			})
+		}, rest);
+	}, [
+		dispatch,
+		elementIds,
+		items,
+		isItemDisabled,
+		highlightedIndex,
+		mouseAndTouchTrackers,
+		preventScroll,
+		stateRef
+	]);
+	var getToggleButtonProps = useCallback(function(toggleButtonProps) {
+		var _extends4;
+		var _ref5 = toggleButtonProps != null ? toggleButtonProps : {}, onClick = _ref5.onClick;
+		_ref5.onPress;
+		var _ref5$refKey = _ref5.refKey, refKey = _ref5$refKey === void 0 ? "ref" : _ref5$refKey, ref = _ref5.ref, rest = _objectWithoutPropertiesLoose(_ref5, _excluded3$1);
+		return _extends((_extends4 = {}, _extends4[refKey] = handleRefs(ref, function(toggleButtonNode) {
+			toggleButtonRef.current = toggleButtonNode;
+		}), _extends4["aria-controls"] = elementIds.menuId, _extends4["aria-expanded"] = isOpen, _extends4.id = elementIds.toggleButtonId, _extends4.tabIndex = -1, _extends4), !rest.disabled && _extends({}, { onClick: callAllEventHandlers(onClick, function toggleButtonHandleClick() {
+			dispatch({ type: ToggleButtonClick });
+		}) }), rest);
+	}, [
+		dispatch,
+		isOpen,
+		elementIds
+	]);
+	var getInputProps = useCallback(function(inputProps, otherProps) {
+		var _extends5;
+		var _ref6 = inputProps != null ? inputProps : {}, ariaLabel = _ref6["aria-label"], onKeyDown = _ref6.onKeyDown, onChange = _ref6.onChange, onInput = _ref6.onInput, onBlur = _ref6.onBlur;
+		_ref6.onChangeText;
+		var onClick = _ref6.onClick, _ref6$refKey = _ref6.refKey, refKey = _ref6$refKey === void 0 ? "ref" : _ref6$refKey, ref = _ref6.ref, rest = _objectWithoutPropertiesLoose(_ref6, _excluded4);
+		var _ref7$suppressRefErro = (otherProps != null ? otherProps : {}).suppressRefError;
+		setGetterPropCallInfo("getInputProps", _ref7$suppressRefErro === void 0 ? false : _ref7$suppressRefErro, refKey, inputRef);
+		var inputHandleKeyDown = function inputHandleKeyDown(event) {
+			var key = normalizeArrowKey(event);
+			if (key && key in inputKeyDownHandlers) inputKeyDownHandlers[key](event);
+		};
+		var inputHandleChange = function inputHandleChange(event) {
+			dispatch({
+				type: InputChange,
+				inputValue: event.target.value
+			});
+		};
+		var inputHandleBlur = function inputHandleBlur(event) {
+			/* istanbul ignore else */
+			if (environment != null && environment.document && stateRef.current.isOpen && !mouseAndTouchTrackers.current.isMouseDown) dispatch({
+				type: InputBlur,
+				selectItem: !(event.relatedTarget === null && environment.document.activeElement !== environment.document.body)
+			});
+		};
+		var inputHandleClick = function inputHandleClick() {
+			dispatch({ type: InputClick });
+		};
+		/* istanbul ignore next (preact) */
+		var onChangeKey = "onChange";
+		var eventHandlers = {};
+		if (!rest.disabled) {
+			var _eventHandlers;
+			eventHandlers = (_eventHandlers = {}, _eventHandlers[onChangeKey] = callAllEventHandlers(onChange, onInput, inputHandleChange), _eventHandlers.onKeyDown = callAllEventHandlers(onKeyDown, inputHandleKeyDown), _eventHandlers.onBlur = callAllEventHandlers(onBlur, inputHandleBlur), _eventHandlers.onClick = callAllEventHandlers(onClick, inputHandleClick), _eventHandlers);
+		}
+		return _extends((_extends5 = {}, _extends5[refKey] = handleRefs(ref, function(inputNode) {
+			inputRef.current = inputNode;
+		}), _extends5["aria-activedescendant"] = isOpen && highlightedIndex > -1 ? elementIds.getItemId(highlightedIndex) : "", _extends5["aria-autocomplete"] = "list", _extends5["aria-controls"] = elementIds.menuId, _extends5["aria-expanded"] = isOpen, _extends5["aria-labelledby"] = ariaLabel ? void 0 : elementIds.labelId, _extends5["aria-label"] = ariaLabel, _extends5.autoComplete = "off", _extends5.id = elementIds.inputId, _extends5.role = "combobox", _extends5.value = inputValue, _extends5), eventHandlers, rest);
+	}, [
+		dispatch,
+		elementIds,
+		environment,
+		inputKeyDownHandlers,
+		isOpen,
+		highlightedIndex,
+		inputValue,
+		mouseAndTouchTrackers,
+		setGetterPropCallInfo,
+		stateRef
+	]);
+	var toggleMenu = useCallback(function() {
+		dispatch({ type: FunctionToggleMenu });
+	}, [dispatch]);
+	var closeMenu = useCallback(function() {
+		dispatch({ type: FunctionCloseMenu });
+	}, [dispatch]);
+	var openMenu = useCallback(function() {
+		dispatch({ type: FunctionOpenMenu });
+	}, [dispatch]);
+	var setHighlightedIndex = useCallback(function(newHighlightedIndex) {
+		dispatch({
+			type: FunctionSetHighlightedIndex,
+			highlightedIndex: newHighlightedIndex
+		});
+	}, [dispatch]);
+	var selectItem = useCallback(function(newSelectedItem) {
+		dispatch({
+			type: FunctionSelectItem,
+			selectedItem: newSelectedItem
+		});
+	}, [dispatch]);
+	return {
+		getItemProps,
+		getLabelProps,
+		getMenuProps,
+		getInputProps,
+		getToggleButtonProps,
+		toggleMenu,
+		openMenu,
+		closeMenu,
+		setHighlightedIndex,
+		setInputValue: useCallback(function(newInputValue) {
+			dispatch({
+				type: FunctionSetInputValue,
+				inputValue: newInputValue
+			});
+		}, [dispatch]),
+		selectItem,
+		reset: useCallback(function() {
+			dispatch({ type: FunctionReset$1 });
+		}, [dispatch]),
+		highlightedIndex,
+		isOpen,
+		selectedItem,
+		inputValue
+	};
+}
+/**
+* Gets the initial state based on the provided props. It uses initial, default
+* and controlled props related to state in order to compute the initial value.
+*
+* @param {Object} props Props passed to the hook.
+* @returns {Object} The initial state.
+*/
+function getInitialState$1(props) {
+	return {
+		activeIndex: getInitialValue(props.activeIndex, props.initialActiveIndex, props.defaultActiveIndex, defaultStateValues.activeIndex),
+		selectedItems: getInitialValue(props.selectedItems, props.initialSelectedItems, props.defaultSelectedItems, defaultStateValues.selectedItems)
+	};
+}
+/**
+* Returns true if dropdown keydown operation is permitted. Should not be
+* allowed on keydown with modifier keys (ctrl, alt, shift, meta), on
+* input element with text content that is either highlighted or selection
+* cursor is not at the starting position.
+*
+* @param {KeyboardEvent} event The event from keydown.
+* @returns {boolean} Whether the operation is allowed.
+*/
+function isKeyDownOperationPermitted(event) {
+	if (event.shiftKey || event.metaKey || event.ctrlKey || event.altKey) return false;
+	var element = event.target;
+	if (element instanceof HTMLInputElement && element.value !== "" && (element.selectionStart !== 0 || element.selectionEnd !== 0)) return false;
+	return true;
+}
+/**
+* Check if a state is equal for taglist, by comparing active index and selected items.
+* Used by useSelect and useCombobox.
+*
+* @param {Object} prevState
+* @param {Object} newState
+* @returns {boolean} Wheather the states are deeply equal.
+*/
+function isStateEqual$1(prevState, newState) {
+	return prevState.selectedItems === newState.selectedItems && prevState.activeIndex === newState.activeIndex;
+}
+function downshiftMultipleSelectionReducer(state, action) {
+	var type = action.type, index = action.index, selectedItem = action.selectedItem, props = action.props;
+	var activeIndex = state.activeIndex, selectedItems = state.selectedItems;
+	var changes;
+	switch (type) {
+		case SelectedItemClick:
+			changes = { activeIndex: index };
+			break;
+		case SelectedItemKeyDownNavigationPrevious:
+			changes = { activeIndex: activeIndex - 1 < 0 ? 0 : activeIndex - 1 };
+			break;
+		case SelectedItemKeyDownNavigationNext:
+			changes = { activeIndex: activeIndex + 1 >= selectedItems.length ? -1 : activeIndex + 1 };
+			break;
+		case SelectedItemKeyDownBackspace:
+		case SelectedItemKeyDownDelete:
+			if (activeIndex < 0) break;
+			var newActiveIndex = activeIndex;
+			if (selectedItems.length === 1) newActiveIndex = -1;
+			else if (activeIndex === selectedItems.length - 1) newActiveIndex = selectedItems.length - 2;
+			changes = _extends({ selectedItems: [].concat(selectedItems.slice(0, activeIndex), selectedItems.slice(activeIndex + 1)) }, { activeIndex: newActiveIndex });
+			break;
+		case DropdownKeyDownNavigationPrevious:
+			changes = { activeIndex: selectedItems.length - 1 };
+			break;
+		case DropdownKeyDownBackspace:
+			changes = { selectedItems: selectedItems.slice(0, selectedItems.length - 1) };
+			break;
+		case FunctionAddSelectedItem:
+			changes = { selectedItems: [].concat(selectedItems, [selectedItem]) };
+			break;
+		case DropdownClick:
+			changes = { activeIndex: -1 };
+			break;
+		case FunctionRemoveSelectedItem:
+			var _newActiveIndex = activeIndex;
+			var selectedItemIndex = selectedItems.findIndex(function(item) {
+				return props.itemToKey(item) === props.itemToKey(selectedItem);
+			});
+			if (selectedItemIndex < 0) break;
+			if (selectedItems.length === 1) _newActiveIndex = -1;
+			else if (selectedItemIndex === selectedItems.length - 1) _newActiveIndex = selectedItems.length - 2;
+			changes = {
+				selectedItems: [].concat(selectedItems.slice(0, selectedItemIndex), selectedItems.slice(selectedItemIndex + 1)),
+				activeIndex: _newActiveIndex
+			};
+			break;
+		case FunctionSetSelectedItems:
+			changes = { selectedItems: action.selectedItems };
+			break;
+		case FunctionSetActiveIndex:
+			changes = { activeIndex: action.activeIndex };
+			break;
+		case FunctionReset:
+			changes = {
+				activeIndex: getDefaultValue(props.defaultActiveIndex, defaultStateValues.activeIndex),
+				selectedItems: getDefaultValue(props.defaultSelectedItems, defaultStateValues.selectedItems)
+			};
+			break;
+		default: throw new Error("Reducer called without proper action type.");
+	}
+	return _extends({}, state, changes);
+}
+function useMultipleSelection(userProps) {
+	if (userProps === void 0) userProps = {};
+	validatePropTypes(userProps, useMultipleSelection);
+	var props = _extends({}, defaultProps, userProps);
+	var getA11yStatusMessage = props.getA11yStatusMessage, environment = props.environment, keyNavigationNext = props.keyNavigationNext, keyNavigationPrevious = props.keyNavigationPrevious;
+	var _useControlledReducer = useControlledReducer$1(downshiftMultipleSelectionReducer, props, getInitialState$1, isStateEqual$1), state = _useControlledReducer[0], dispatch = _useControlledReducer[1];
+	var activeIndex = state.activeIndex, selectedItems = state.selectedItems;
+	var isInitialMount = useIsInitialMount();
+	var dropdownRef = useRef(null);
+	var selectedItemRefs = useRef(null);
+	if (selectedItemRefs.current === null) selectedItemRefs.current = /* @__PURE__ */ new Map();
+	useA11yMessageStatus(getA11yStatusMessage, state, [activeIndex, selectedItems], environment);
+	useEffect(function() {
+		if (isInitialMount) return;
+		if (activeIndex === -1 && dropdownRef.current) dropdownRef.current.focus();
+		else {
+			var _selectedItemRefs$cur;
+			(_selectedItemRefs$cur = selectedItemRefs.current.get(activeIndex)) == null || _selectedItemRefs$cur.focus();
+		}
+	}, [activeIndex]);
+	useControlPropsValidator({
+		props,
+		state
+	});
+	var setGetterPropCallInfo = useGetterPropsCalledChecker("getDropdownProps");
+	var selectedItemKeyDownHandlers = useMemo(function() {
+		var _ref = {};
+		return _ref[keyNavigationPrevious] = function() {
+			dispatch({ type: SelectedItemKeyDownNavigationPrevious });
+		}, _ref[keyNavigationNext] = function() {
+			dispatch({ type: SelectedItemKeyDownNavigationNext });
+		}, _ref.Delete = function Delete() {
+			dispatch({ type: SelectedItemKeyDownDelete });
+		}, _ref.Backspace = function Backspace() {
+			dispatch({ type: SelectedItemKeyDownBackspace });
+		}, _ref;
+	}, [
+		dispatch,
+		keyNavigationNext,
+		keyNavigationPrevious
+	]);
+	var dropdownKeyDownHandlers = useMemo(function() {
+		var _ref2 = {};
+		return _ref2[keyNavigationPrevious] = function(event) {
+			if (isKeyDownOperationPermitted(event)) dispatch({ type: DropdownKeyDownNavigationPrevious });
+		}, _ref2.Backspace = function Backspace(event) {
+			if (isKeyDownOperationPermitted(event)) dispatch({ type: DropdownKeyDownBackspace });
+		}, _ref2;
+	}, [dispatch, keyNavigationPrevious]);
+	return {
+		getSelectedItemProps: useCallback(function(_temp) {
+			var _extends2;
+			var _ref3 = _temp === void 0 ? {} : _temp, _ref3$refKey = _ref3.refKey, refKey = _ref3$refKey === void 0 ? "ref" : _ref3$refKey, ref = _ref3.ref, onClick = _ref3.onClick, onKeyDown = _ref3.onKeyDown, selectedItemProp = _ref3.selectedItem, indexProp = _ref3.index, rest = _objectWithoutPropertiesLoose(_ref3, _excluded$1);
+			var index = getItemAndIndex(selectedItemProp, indexProp, selectedItems, "Pass either item or index to getSelectedItemProps!")[1];
+			var isFocusable = index > -1 && index === activeIndex;
+			return _extends((_extends2 = {}, _extends2[refKey] = handleRefs(ref, function(selectedItemNode) {
+				if (selectedItemNode) selectedItemRefs.current.set(index, selectedItemNode);
+				else selectedItemRefs.current["delete"](index);
+			}), _extends2.tabIndex = isFocusable ? 0 : -1, _extends2.onClick = callAllEventHandlers(onClick, function selectedItemHandleClick() {
+				dispatch({
+					type: SelectedItemClick,
+					index
+				});
+			}), _extends2.onKeyDown = callAllEventHandlers(onKeyDown, function selectedItemHandleKeyDown(event) {
+				var key = normalizeArrowKey(event);
+				if (key && selectedItemKeyDownHandlers[key]) selectedItemKeyDownHandlers[key](event);
+			}), _extends2), rest);
+		}, [
+			dispatch,
+			selectedItems,
+			activeIndex,
+			selectedItemKeyDownHandlers
+		]),
+		getDropdownProps: useCallback(function(_temp2, _temp3) {
+			var _extends3;
+			var _ref4 = _temp2 === void 0 ? {} : _temp2, _ref4$refKey = _ref4.refKey, refKey = _ref4$refKey === void 0 ? "ref" : _ref4$refKey, ref = _ref4.ref, onKeyDown = _ref4.onKeyDown, onClick = _ref4.onClick, _ref4$preventKeyActio = _ref4.preventKeyAction, preventKeyAction = _ref4$preventKeyActio === void 0 ? false : _ref4$preventKeyActio, rest = _objectWithoutPropertiesLoose(_ref4, _excluded2$1);
+			var _ref5$suppressRefErro = (_temp3 === void 0 ? {} : _temp3).suppressRefError;
+			setGetterPropCallInfo("getDropdownProps", _ref5$suppressRefErro === void 0 ? false : _ref5$suppressRefErro, refKey, dropdownRef);
+			return _extends((_extends3 = {}, _extends3[refKey] = handleRefs(ref, function(dropdownNode) {
+				if (dropdownNode) dropdownRef.current = dropdownNode;
+			}), _extends3), !preventKeyAction && {
+				onKeyDown: callAllEventHandlers(onKeyDown, function dropdownHandleKeyDown(event) {
+					var key = normalizeArrowKey(event);
+					if (key && dropdownKeyDownHandlers[key]) dropdownKeyDownHandlers[key](event);
+				}),
+				onClick: callAllEventHandlers(onClick, function dropdownHandleClick() {
+					dispatch({ type: DropdownClick });
+				})
+			}, rest);
+		}, [
+			dispatch,
+			dropdownKeyDownHandlers,
+			setGetterPropCallInfo
+		]),
+		addSelectedItem: useCallback(function(selectedItem) {
+			dispatch({
+				type: FunctionAddSelectedItem,
+				selectedItem
+			});
+		}, [dispatch]),
+		removeSelectedItem: useCallback(function(selectedItem) {
+			dispatch({
+				type: FunctionRemoveSelectedItem,
+				selectedItem
+			});
+		}, [dispatch]),
+		setSelectedItems: useCallback(function(newSelectedItems) {
+			dispatch({
+				type: FunctionSetSelectedItems,
+				selectedItems: newSelectedItems
+			});
+		}, [dispatch]),
+		setActiveIndex: useCallback(function(newActiveIndex) {
+			dispatch({
+				type: FunctionSetActiveIndex,
+				activeIndex: newActiveIndex
+			});
+		}, [dispatch]),
+		reset: useCallback(function() {
+			dispatch({ type: FunctionReset });
+		}, [dispatch]),
+		selectedItems,
+		activeIndex
+	};
+}
+function useTagGroupReducer(state, action) {
+	var type = action.type;
+	var changes;
+	switch (type) {
+		case TagClick:
+			changes = { activeIndex: action.index };
+			break;
+		case TagGroupKeyDownArrowLeft:
+			changes = { activeIndex: state.activeIndex === 0 ? state.items.length - 1 : state.activeIndex - 1 };
+			break;
+		case TagGroupKeyDownArrowRight:
+			changes = { activeIndex: state.activeIndex === state.items.length - 1 ? 0 : state.activeIndex + 1 };
+			break;
+		case TagGroupKeyDownBackspace:
+		case TagGroupKeyDownDelete:
+			var newItems = [].concat(state.items.slice(0, state.activeIndex), state.items.slice(state.activeIndex + 1));
+			var newActiveIndex = newItems.length === 0 ? -1 : newItems.length === state.activeIndex ? state.activeIndex - 1 : state.activeIndex;
+			changes = {
+				items: [].concat(state.items.slice(0, state.activeIndex), state.items.slice(state.activeIndex + 1)),
+				activeIndex: newActiveIndex
+			};
+			break;
+		case TagRemoveClick:
+			var _newItems = [].concat(state.items.slice(0, action.index), state.items.slice(action.index + 1));
+			changes = {
+				items: _newItems,
+				activeIndex: _newItems.length === 0 ? -1 : _newItems.length === action.index ? action.index - 1 : action.index
+			};
+			break;
+		case FunctionAddItem:
+			var _newItems2 = [];
+			if (action.index === void 0) _newItems2 = [].concat(state.items, [action.item]);
+			else _newItems2 = [].concat(state.items.slice(0, action.index), [action.item], state.items.slice(action.index));
+			var _newActiveIndex2 = state.activeIndex === -1 ? _newItems2.length - 1 : state.activeIndex;
+			changes = {
+				items: _newItems2,
+				activeIndex: _newActiveIndex2
+			};
+			break;
+		default: throw new Error("Invalid useTagGroup reducer action.");
+	}
+	return _extends({}, state, changes);
+}
+function useElementIdsR18(_ref) {
+	var id = _ref.id, tagGroupId = _ref.tagGroupId, getTagId = _ref.getTagId;
+	var reactId = "downshift-" + reactUseId();
+	if (!id) id = reactId;
+	return useMemo(function() {
+		return {
+			tagGroupId: tagGroupId != null ? tagGroupId : id + "-tag-group",
+			getTagId: getTagId != null ? getTagId : function(index) {
+				return id + "-tag-" + index;
+			}
+		};
+	}, [
+		getTagId,
+		id,
+		tagGroupId
+	]);
+}
+function useElementIdsLegacy(_ref2) {
+	var id = _ref2.id, getTagId = _ref2.getTagId, tagGroupId = _ref2.tagGroupId;
+	var baseId = useState(function() {
+		return id != null ? id : "downshift-" + generateId();
+	})[0];
+	return useMemo(function() {
+		return {
+			tagGroupId: tagGroupId != null ? tagGroupId : baseId + "-tag-group",
+			getTagId: getTagId != null ? getTagId : function(index) {
+				return baseId + "-tag-" + index;
+			}
+		};
+	}, [
+		getTagId,
+		baseId,
+		tagGroupId
+	]);
+}
+function getInitialState(props) {
+	var _ref, _props$items, _ref2, _props$activeIndex;
+	var items = (_ref = (_props$items = props.items) != null ? _props$items : props.initialItems) != null ? _ref : [];
+	return {
+		activeIndex: (_ref2 = (_props$activeIndex = props.activeIndex) != null ? _props$activeIndex : props.initialActiveIndex) != null ? _ref2 : items.length === 0 ? -1 : 0,
+		items
+	};
+}
+function isStateEqual(oldState, newState) {
+	return oldState.activeIndex === newState.activeIndex && oldState.items === newState.items;
+}
+function useAccessibleDescription(document, description) {
+	useEffect(function() {
+		if (!document) return;
+		var accessibleDescriptionElement = document.createElement("div");
+		accessibleDescriptionElement.setAttribute("id", A11Y_DESCRIPTION_ELEMENT_ID);
+		accessibleDescriptionElement.style.display = "none";
+		accessibleDescriptionElement.textContent = description;
+		document.body.appendChild(accessibleDescriptionElement);
+		return function() {
+			accessibleDescriptionElement.remove();
+		};
+	}, [description, document]);
+}
+function getMergedProps(userProps) {
+	return _extends({
+		stateReducer: function stateReducer(_s, _ref) {
+			return _ref.changes;
+		},
+		environment: typeof window === "undefined" || false ? void 0 : window,
+		removeElementDescription: "Press Delete or Backspace to remove tag."
+	}, userProps);
+}
+/**
+* Focuses the tag at activeIndex when it changes or when an item is removed.
+*/
+function useRovingTagFocus(activeIndex, itemsLength, getTagId) {
+	var itemRefs = useRef({});
+	var previousActiveIndexRef = useRef(activeIndex);
+	var previousItemsLengthRef = useRef(itemsLength);
+	useEffect(function() {
+		if (activeIndex !== -1 && previousActiveIndexRef.current !== -1 && activeIndex !== previousActiveIndexRef.current || previousItemsLengthRef.current === itemsLength + 1) {
+			var _itemRefs$current$get;
+			(_itemRefs$current$get = itemRefs.current[getTagId(activeIndex)]) == null || _itemRefs$current$get.focus();
+		}
+		previousActiveIndexRef.current = activeIndex;
+		previousItemsLengthRef.current = itemsLength;
+	}, [
+		activeIndex,
+		getTagId,
+		itemsLength
+	]);
+	return itemRefs;
+}
+var import_prop_types, unknown, mouseUp, itemMouseEnter, keyDownArrowUp, keyDownArrowDown, keyDownEscape, keyDownEnter, keyDownHome, keyDownEnd, clickItem, blurInput, changeInput, keyDownSpaceButton, clickButton, blurButton, controlledPropUpdatedSelectedItem, touchEnd, stateChangeTypes$4, idCounter, useIsomorphicLayoutEffect, cleanupStatus, validatePropTypes$1, stateKeys, _excluded$4, _excluded2$4, _excluded3$3, _excluded4$2, _excluded5, Downshift, propTypes$4, updateA11yStatus, dropdownPropTypes, dropdownDefaultProps, dropdownDefaultStateValues, reactUseId$1, useElementIds$1, useControlPropsValidator, useGetterPropsCalledChecker, propTypes$3, ToggleButtonClick$1, ToggleButtonKeyDownArrowDown, ToggleButtonKeyDownArrowUp, ToggleButtonKeyDownCharacter, ToggleButtonKeyDownEscape, ToggleButtonKeyDownHome, ToggleButtonKeyDownEnd, ToggleButtonKeyDownEnter, ToggleButtonKeyDownSpaceButton, ToggleButtonKeyDownPageUp, ToggleButtonKeyDownPageDown, ToggleButtonBlur, MenuMouseLeave$1, ItemMouseMove$1, ItemClick$1, FunctionToggleMenu$1, FunctionOpenMenu$1, FunctionCloseMenu$1, FunctionSetHighlightedIndex$1, FunctionSelectItem$1, FunctionSetInputValue$1, FunctionReset$2, stateChangeTypes$3, _excluded$3, _excluded2$3, _excluded3$2, _excluded4$1, InputKeyDownArrowDown, InputKeyDownArrowUp, InputKeyDownEscape, InputKeyDownHome, InputKeyDownEnd, InputKeyDownPageUp, InputKeyDownPageDown, InputKeyDownEnter, InputChange, InputBlur, InputClick, MenuMouseLeave, ItemMouseMove, ItemClick, ToggleButtonClick, FunctionToggleMenu, FunctionOpenMenu, FunctionCloseMenu, FunctionSetHighlightedIndex, FunctionSelectItem, FunctionSetInputValue, FunctionReset$1, ControlledPropUpdatedSelectedItem, stateChangeTypes$2, propTypes$2, _excluded$2, _excluded2$2, _excluded3$1, _excluded4, defaultStateValues, defaultProps, validatePropTypes, SelectedItemClick, SelectedItemKeyDownDelete, SelectedItemKeyDownBackspace, SelectedItemKeyDownNavigationNext, SelectedItemKeyDownNavigationPrevious, DropdownKeyDownNavigationPrevious, DropdownKeyDownBackspace, DropdownClick, FunctionAddSelectedItem, FunctionRemoveSelectedItem, FunctionSetSelectedItems, FunctionSetActiveIndex, FunctionReset, stateChangeTypes$1, _excluded$1, _excluded2$1, TagClick, TagGroupKeyDownArrowLeft, TagGroupKeyDownArrowRight, TagGroupKeyDownDelete, TagGroupKeyDownBackspace, TagRemoveClick, FunctionAddItem, stateChangeTypes, reactUseId, useElementIds, A11Y_DESCRIPTION_ELEMENT_ID, propTypes, _excluded, _excluded2, _excluded3, _useTagGroup;
+function init_downshift_esm() {
+	return (init_downshift_esm = __esmMin((() => {
+		init_inheritsLoose();
+		import_prop_types = /* @__PURE__ */ __toESM(require_prop_types(), 1);
+		init__storybook_global_react();
+		require_react_is();
+		init_dist();
+		unknown = 0;
+		mouseUp = 1;
+		itemMouseEnter = 2;
+		keyDownArrowUp = 3;
+		keyDownArrowDown = 4;
+		keyDownEscape = 5;
+		keyDownEnter = 6;
+		keyDownHome = 7;
+		keyDownEnd = 8;
+		clickItem = 9;
+		blurInput = 10;
+		changeInput = 11;
+		keyDownSpaceButton = 12;
+		clickButton = 13;
+		blurButton = 14;
+		controlledPropUpdatedSelectedItem = 15;
+		touchEnd = 16;
+		stateChangeTypes$4 = /*#__PURE__*/ Object.freeze({
+			__proto__: null,
+			blurButton,
+			blurInput,
+			changeInput,
+			clickButton,
+			clickItem,
+			controlledPropUpdatedSelectedItem,
+			itemMouseEnter,
+			keyDownArrowDown,
+			keyDownArrowUp,
+			keyDownEnd,
+			keyDownEnter,
+			keyDownEscape,
+			keyDownHome,
+			keyDownSpaceButton,
+			mouseUp,
+			touchEnd,
+			unknown
+		});
+		idCounter = 0;
+		useIsomorphicLayoutEffect = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined" || false ? useLayoutEffect : useEffect;
+		cleanupStatus = debounce(function(document) {
+			getStatusDiv(document).textContent = "";
+		}, 500);
+		validatePropTypes$1 = noop;
+		stateKeys = [
+			"highlightedIndex",
+			"inputValue",
+			"isOpen",
+			"selectedItem",
+			"type"
+		];
+		_excluded$4 = ["refKey", "ref"];
+		_excluded2$4 = [
+			"onClick",
+			"onPress",
+			"onKeyDown",
+			"onKeyUp",
+			"onBlur"
+		];
+		_excluded3$3 = [
+			"onKeyDown",
+			"onBlur",
+			"onChange",
+			"onInput",
+			"onChangeText"
+		];
+		_excluded4$2 = ["refKey", "ref"];
+		_excluded5 = [
+			"onMouseMove",
+			"onMouseDown",
+			"onClick",
+			"onPress",
+			"index",
+			"item"
+		];
+		Downshift = /*#__PURE__*/ function() {
+			var Downshift = /*#__PURE__*/ function(_Component) {
+				function Downshift(_props) {
+					var _this = _Component.call(this, _props) || this;
+					_this.id = _this.props.id || "downshift-" + generateId();
+					_this.menuId = _this.props.menuId || _this.id + "-menu";
+					_this.labelId = _this.props.labelId || _this.id + "-label";
+					_this.inputId = _this.props.inputId || _this.id + "-input";
+					_this.getItemId = _this.props.getItemId || function(index) {
+						return _this.id + "-item-" + index;
+					};
+					_this.items = [];
+					_this.itemCount = null;
+					_this.previousResultCount = 0;
+					_this.timeoutIds = [];
+					/**
+					* @param {Function} fn the function to call after the time
+					* @param {Number} time the time to wait
+					*/
+					_this.internalSetTimeout = function(fn, time) {
+						var id = setTimeout(function() {
+							_this.timeoutIds = _this.timeoutIds.filter(function(i) {
+								return i !== id;
+							});
+							fn();
+						}, time);
+						_this.timeoutIds.push(id);
+					};
+					_this.setItemCount = function(count) {
+						_this.itemCount = count;
+					};
+					_this.unsetItemCount = function() {
+						_this.itemCount = null;
+					};
+					_this.isItemDisabled = function(_item, index) {
+						var currentElementNode = _this.getItemNodeFromIndex(index);
+						return currentElementNode && currentElementNode.hasAttribute("disabled");
+					};
+					_this.setHighlightedIndex = function(highlightedIndex, otherStateToSet) {
+						if (highlightedIndex === void 0) highlightedIndex = _this.props.defaultHighlightedIndex;
+						if (otherStateToSet === void 0) otherStateToSet = {};
+						otherStateToSet = pickState(otherStateToSet);
+						_this.internalSetState(_extends({ highlightedIndex }, otherStateToSet));
+					};
+					_this.clearSelection = function(cb) {
+						_this.internalSetState({
+							selectedItem: null,
+							inputValue: "",
+							highlightedIndex: _this.props.defaultHighlightedIndex,
+							isOpen: _this.props.defaultIsOpen
+						}, cb);
+					};
+					_this.selectItem = function(item, otherStateToSet, cb) {
+						otherStateToSet = pickState(otherStateToSet);
+						_this.internalSetState(_extends({
+							isOpen: _this.props.defaultIsOpen,
+							highlightedIndex: _this.props.defaultHighlightedIndex,
+							selectedItem: item,
+							inputValue: _this.props.itemToString(item)
+						}, otherStateToSet), cb);
+					};
+					_this.selectItemAtIndex = function(itemIndex, otherStateToSet, cb) {
+						var item = _this.items[itemIndex];
+						if (item == null) return;
+						_this.selectItem(item, otherStateToSet, cb);
+					};
+					_this.selectHighlightedItem = function(otherStateToSet, cb) {
+						return _this.selectItemAtIndex(_this.getState().highlightedIndex, otherStateToSet, cb);
+					};
+					_this.internalSetState = function(stateToSet, cb) {
+						var isItemSelected, onChangeArg;
+						var onStateChangeArg = {};
+						var isStateToSetFunction = typeof stateToSet === "function";
+						if (!isStateToSetFunction && stateToSet.hasOwnProperty("inputValue")) _this.props.onInputValueChange(stateToSet.inputValue, _extends({}, _this.getStateAndHelpers(), stateToSet));
+						return _this.setState(function(state) {
+							var _newStateToSet;
+							state = _this.getState(state);
+							var newStateToSet = isStateToSetFunction ? stateToSet(state) : stateToSet;
+							newStateToSet = _this.props.stateReducer(state, newStateToSet);
+							isItemSelected = newStateToSet.hasOwnProperty("selectedItem");
+							var nextState = {};
+							if (isItemSelected && newStateToSet.selectedItem !== state.selectedItem) onChangeArg = newStateToSet.selectedItem;
+							(_newStateToSet = newStateToSet).type || (_newStateToSet.type = unknown);
+							Object.keys(newStateToSet).forEach(function(key) {
+								if (state[key] !== newStateToSet[key]) onStateChangeArg[key] = newStateToSet[key];
+								if (key === "type") return;
+								newStateToSet[key];
+								if (_this.props[key] === void 0) nextState[key] = newStateToSet[key];
+							});
+							if (isStateToSetFunction && newStateToSet.hasOwnProperty("inputValue")) _this.props.onInputValueChange(newStateToSet.inputValue, _extends({}, _this.getStateAndHelpers(), newStateToSet));
+							return nextState;
+						}, function() {
+							cbToCb(cb)();
+							if (Object.keys(onStateChangeArg).length > 1) _this.props.onStateChange(onStateChangeArg, _this.getStateAndHelpers());
+							if (isItemSelected) _this.props.onSelect(stateToSet.selectedItem, _this.getStateAndHelpers());
+							if (onChangeArg !== void 0) _this.props.onChange(onChangeArg, _this.getStateAndHelpers());
+							_this.props.onUserAction(onStateChangeArg, _this.getStateAndHelpers());
+						});
+					};
+					_this.rootRef = function(node) {
+						return _this._rootNode = node;
+					};
+					_this.getRootProps = function(_temp, _temp2) {
+						var _extends2;
+						var _ref = _temp === void 0 ? {} : _temp, _ref$refKey = _ref.refKey, refKey = _ref$refKey === void 0 ? "ref" : _ref$refKey, ref = _ref.ref, rest = _objectWithoutPropertiesLoose(_ref, _excluded$4);
+						var _ref2$suppressRefErro = (_temp2 === void 0 ? {} : _temp2).suppressRefError, suppressRefError = _ref2$suppressRefErro === void 0 ? false : _ref2$suppressRefErro;
+						_this.getRootProps.called = true;
+						_this.getRootProps.refKey = refKey;
+						_this.getRootProps.suppressRefError = suppressRefError;
+						var isOpen = _this.getState().isOpen;
+						return _extends((_extends2 = {}, _extends2[refKey] = handleRefs(ref, _this.rootRef), _extends2.role = "combobox", _extends2["aria-expanded"] = isOpen, _extends2["aria-haspopup"] = "listbox", _extends2["aria-owns"] = isOpen ? _this.menuId : void 0, _extends2["aria-labelledby"] = _this.labelId, _extends2), rest);
+					};
+					_this.keyDownHandlers = {
+						ArrowDown: function ArrowDown(event) {
+							var _this2 = this;
+							event.preventDefault();
+							if (this.getState().isOpen) {
+								var amount = event.shiftKey ? 5 : 1;
+								this.moveHighlightedIndex(amount, { type: keyDownArrowDown });
+							} else this.internalSetState({
+								isOpen: true,
+								type: keyDownArrowDown
+							}, function() {
+								var itemCount = _this2.getItemCount();
+								if (itemCount > 0) {
+									var highlightedIndex = _this2.getState().highlightedIndex;
+									var nextHighlightedIndex = getHighlightedIndex(highlightedIndex, 1, { length: itemCount }, _this2.isItemDisabled, true);
+									_this2.setHighlightedIndex(nextHighlightedIndex, { type: keyDownArrowDown });
+								}
+							});
+						},
+						ArrowUp: function ArrowUp(event) {
+							var _this3 = this;
+							event.preventDefault();
+							if (this.getState().isOpen) {
+								var amount = event.shiftKey ? -5 : -1;
+								this.moveHighlightedIndex(amount, { type: keyDownArrowUp });
+							} else this.internalSetState({
+								isOpen: true,
+								type: keyDownArrowUp
+							}, function() {
+								var itemCount = _this3.getItemCount();
+								if (itemCount > 0) {
+									var highlightedIndex = _this3.getState().highlightedIndex;
+									var nextHighlightedIndex = getHighlightedIndex(highlightedIndex, -1, { length: itemCount }, _this3.isItemDisabled, true);
+									_this3.setHighlightedIndex(nextHighlightedIndex, { type: keyDownArrowUp });
+								}
+							});
+						},
+						Enter: function Enter(event) {
+							if (event.which === 229) return;
+							var _this$getState2 = this.getState(), isOpen = _this$getState2.isOpen, highlightedIndex = _this$getState2.highlightedIndex;
+							if (isOpen && highlightedIndex != null) {
+								event.preventDefault();
+								var item = this.items[highlightedIndex];
+								var itemNode = this.getItemNodeFromIndex(highlightedIndex);
+								if (item == null || itemNode && itemNode.hasAttribute("disabled")) return;
+								this.selectHighlightedItem({ type: keyDownEnter });
+							}
+						},
+						Escape: function Escape(event) {
+							event.preventDefault();
+							this.reset(_extends({ type: keyDownEscape }, !this.state.isOpen && {
+								selectedItem: null,
+								inputValue: ""
+							}));
+						}
+					};
+					_this.buttonKeyDownHandlers = _extends({}, _this.keyDownHandlers, { " ": function _(event) {
+						event.preventDefault();
+						this.toggleMenu({ type: keyDownSpaceButton });
+					} });
+					_this.inputKeyDownHandlers = _extends({}, _this.keyDownHandlers, {
+						Home: function Home(event) {
+							var isOpen = this.getState().isOpen;
+							if (!isOpen) return;
+							event.preventDefault();
+							var itemCount = this.getItemCount();
+							if (itemCount <= 0 || !isOpen) return;
+							var newHighlightedIndex = getNonDisabledIndex(0, false, { length: itemCount }, this.isItemDisabled);
+							this.setHighlightedIndex(newHighlightedIndex, { type: keyDownHome });
+						},
+						End: function End(event) {
+							var isOpen = this.getState().isOpen;
+							if (!isOpen) return;
+							event.preventDefault();
+							var itemCount = this.getItemCount();
+							if (itemCount <= 0 || !isOpen) return;
+							var newHighlightedIndex = getNonDisabledIndex(itemCount - 1, true, { length: itemCount }, this.isItemDisabled);
+							this.setHighlightedIndex(newHighlightedIndex, { type: keyDownEnd });
+						}
+					});
+					_this.getToggleButtonProps = function(_temp3) {
+						var _ref3 = _temp3 === void 0 ? {} : _temp3, onClick = _ref3.onClick;
+						_ref3.onPress;
+						var onKeyDown = _ref3.onKeyDown, onKeyUp = _ref3.onKeyUp, onBlur = _ref3.onBlur, rest = _objectWithoutPropertiesLoose(_ref3, _excluded2$4);
+						var isOpen = _this.getState().isOpen;
+						var enabledEventHandlers = {
+							onClick: callAllEventHandlers(onClick, _this.buttonHandleClick),
+							onKeyDown: callAllEventHandlers(onKeyDown, _this.buttonHandleKeyDown),
+							onKeyUp: callAllEventHandlers(onKeyUp, _this.buttonHandleKeyUp),
+							onBlur: callAllEventHandlers(onBlur, _this.buttonHandleBlur)
+						};
+						var eventHandlers = rest.disabled ? {} : enabledEventHandlers;
+						return _extends({
+							type: "button",
+							role: "button",
+							"aria-label": isOpen ? "close menu" : "open menu",
+							"aria-haspopup": true,
+							"data-toggle": true
+						}, eventHandlers, rest);
+					};
+					_this.buttonHandleKeyUp = function(event) {
+						event.preventDefault();
+					};
+					_this.buttonHandleKeyDown = function(event) {
+						var key = normalizeArrowKey(event);
+						if (_this.buttonKeyDownHandlers[key]) _this.buttonKeyDownHandlers[key].call(_this, event);
+					};
+					_this.buttonHandleClick = function(event) {
+						event.preventDefault();
+						/* istanbul ignore if (can't reasonably test this) */
+						if (_this.props.environment) {
+							var _this$props$environme = _this.props.environment.document, body = _this$props$environme.body, activeElement = _this$props$environme.activeElement;
+							if (body && body === activeElement) event.target.focus();
+						}
+						_this.internalSetTimeout(function() {
+							return _this.toggleMenu({ type: clickButton });
+						});
+					};
+					_this.buttonHandleBlur = function(event) {
+						var blurTarget = event.target;
+						_this.internalSetTimeout(function() {
+							if (_this.isMouseDown || !_this.props.environment) return;
+							var activeElement = _this.props.environment.document.activeElement;
+							if ((activeElement == null || activeElement.id !== _this.inputId) && activeElement !== blurTarget) _this.reset({ type: blurButton });
+						});
+					};
+					_this.getLabelProps = function(props) {
+						return _extends({
+							htmlFor: _this.inputId,
+							id: _this.labelId
+						}, props);
+					};
+					_this.getInputProps = function(_temp4) {
+						var _ref4 = _temp4 === void 0 ? {} : _temp4, onKeyDown = _ref4.onKeyDown, onBlur = _ref4.onBlur, onChange = _ref4.onChange, onInput = _ref4.onInput;
+						_ref4.onChangeText;
+						var rest = _objectWithoutPropertiesLoose(_ref4, _excluded3$3);
+						var onChangeKey;
+						var eventHandlers = {};
+						onChangeKey = "onChange";
+						var _this$getState6 = _this.getState(), inputValue = _this$getState6.inputValue, isOpen = _this$getState6.isOpen, highlightedIndex = _this$getState6.highlightedIndex;
+						if (!rest.disabled) {
+							var _eventHandlers;
+							eventHandlers = (_eventHandlers = {}, _eventHandlers[onChangeKey] = callAllEventHandlers(onChange, onInput, _this.inputHandleChange), _eventHandlers.onKeyDown = callAllEventHandlers(onKeyDown, _this.inputHandleKeyDown), _eventHandlers.onBlur = callAllEventHandlers(onBlur, _this.inputHandleBlur), _eventHandlers);
+						}
+						return _extends({
+							"aria-autocomplete": "list",
+							"aria-activedescendant": isOpen && typeof highlightedIndex === "number" && highlightedIndex >= 0 ? _this.getItemId(highlightedIndex) : void 0,
+							"aria-controls": isOpen ? _this.menuId : void 0,
+							"aria-labelledby": rest && rest["aria-label"] ? void 0 : _this.labelId,
+							autoComplete: "off",
+							value: inputValue,
+							id: _this.inputId
+						}, eventHandlers, rest);
+					};
+					_this.inputHandleKeyDown = function(event) {
+						var key = normalizeArrowKey(event);
+						if (key && _this.inputKeyDownHandlers[key]) _this.inputKeyDownHandlers[key].call(_this, event);
+					};
+					_this.inputHandleChange = function(event) {
+						_this.internalSetState({
+							type: changeInput,
+							isOpen: true,
+							inputValue: event.target.value,
+							highlightedIndex: _this.props.defaultHighlightedIndex
+						});
+					};
+					_this.inputHandleBlur = function() {
+						_this.internalSetTimeout(function() {
+							var _activeElement$datase;
+							if (_this.isMouseDown || !_this.props.environment) return;
+							var activeElement = _this.props.environment.document.activeElement;
+							if (!((activeElement == null || (_activeElement$datase = activeElement.dataset) == null ? void 0 : _activeElement$datase.toggle) && _this._rootNode && _this._rootNode.contains(activeElement))) _this.reset({ type: blurInput });
+						});
+					};
+					_this.menuRef = function(node) {
+						_this._menuNode = node;
+					};
+					_this.getMenuProps = function(_temp5, _temp6) {
+						var _extends3;
+						var _ref5 = _temp5 === void 0 ? {} : _temp5, _ref5$refKey = _ref5.refKey, refKey = _ref5$refKey === void 0 ? "ref" : _ref5$refKey, ref = _ref5.ref, props = _objectWithoutPropertiesLoose(_ref5, _excluded4$2);
+						var _ref6$suppressRefErro = (_temp6 === void 0 ? {} : _temp6).suppressRefError, suppressRefError = _ref6$suppressRefErro === void 0 ? false : _ref6$suppressRefErro;
+						_this.getMenuProps.called = true;
+						_this.getMenuProps.refKey = refKey;
+						_this.getMenuProps.suppressRefError = suppressRefError;
+						return _extends((_extends3 = {}, _extends3[refKey] = handleRefs(ref, _this.menuRef), _extends3.role = "listbox", _extends3["aria-labelledby"] = props && props["aria-label"] ? void 0 : _this.labelId, _extends3.id = _this.menuId, _extends3), props);
+					};
+					_this.getItemProps = function(_temp7) {
+						var _enabledEventHandlers;
+						var _ref7 = _temp7 === void 0 ? {} : _temp7, onMouseMove = _ref7.onMouseMove, onMouseDown = _ref7.onMouseDown, onClick = _ref7.onClick;
+						_ref7.onPress;
+						var index = _ref7.index, _ref7$item = _ref7.item, item = _ref7$item === void 0 ? /* istanbul ignore next */ void 0 : _ref7$item, rest = _objectWithoutPropertiesLoose(_ref7, _excluded5);
+						if (index === void 0) {
+							_this.items.push(item);
+							index = _this.items.indexOf(item);
+						} else _this.items[index] = item;
+						var onSelectKey = "onClick";
+						var customClickHandler = onClick;
+						var enabledEventHandlers = (_enabledEventHandlers = {
+							onMouseMove: callAllEventHandlers(onMouseMove, function() {
+								if (index === _this.getState().highlightedIndex) return;
+								_this.setHighlightedIndex(index, { type: itemMouseEnter });
+								_this.avoidScrolling = true;
+								_this.internalSetTimeout(function() {
+									return _this.avoidScrolling = false;
+								}, 250);
+							}),
+							onMouseDown: callAllEventHandlers(onMouseDown, function(event) {
+								event.preventDefault();
+							})
+						}, _enabledEventHandlers[onSelectKey] = callAllEventHandlers(customClickHandler, function() {
+							_this.selectItemAtIndex(index, { type: clickItem });
+						}), _enabledEventHandlers);
+						var eventHandlers = rest.disabled ? { onMouseDown: enabledEventHandlers.onMouseDown } : enabledEventHandlers;
+						return _extends({
+							id: _this.getItemId(index),
+							role: "option",
+							"aria-selected": _this.getState().highlightedIndex === index
+						}, eventHandlers, rest);
+					};
+					_this.clearItems = function() {
+						_this.items = [];
+					};
+					_this.reset = function(otherStateToSet, cb) {
+						if (otherStateToSet === void 0) otherStateToSet = {};
+						otherStateToSet = pickState(otherStateToSet);
+						_this.internalSetState(function(_ref8) {
+							var selectedItem = _ref8.selectedItem;
+							return _extends({
+								isOpen: _this.props.defaultIsOpen,
+								highlightedIndex: _this.props.defaultHighlightedIndex,
+								inputValue: _this.props.itemToString(selectedItem)
+							}, otherStateToSet);
+						}, cb);
+					};
+					_this.toggleMenu = function(otherStateToSet, cb) {
+						if (otherStateToSet === void 0) otherStateToSet = {};
+						otherStateToSet = pickState(otherStateToSet);
+						_this.internalSetState(function(_ref9) {
+							var isOpen = _ref9.isOpen;
+							return _extends({ isOpen: !isOpen }, isOpen && { highlightedIndex: _this.props.defaultHighlightedIndex }, otherStateToSet);
+						}, function() {
+							var _this$getState7 = _this.getState(), isOpen = _this$getState7.isOpen, highlightedIndex = _this$getState7.highlightedIndex;
+							if (isOpen) {
+								if (_this.getItemCount() > 0 && typeof highlightedIndex === "number") _this.setHighlightedIndex(highlightedIndex, otherStateToSet);
+							}
+							cbToCb(cb)();
+						});
+					};
+					_this.openMenu = function(cb) {
+						_this.internalSetState({ isOpen: true }, cb);
+					};
+					_this.closeMenu = function(cb) {
+						_this.internalSetState({ isOpen: false }, cb);
+					};
+					_this.updateStatus = debounce(function() {
+						var _this$props;
+						if (!((_this$props = _this.props) != null && (_this$props = _this$props.environment) != null && _this$props.document)) return;
+						var state = _this.getState();
+						var item = _this.items[state.highlightedIndex];
+						var resultCount = _this.getItemCount();
+						var status = _this.props.getA11yStatusMessage(_extends({
+							itemToString: _this.props.itemToString,
+							previousResultCount: _this.previousResultCount,
+							resultCount,
+							highlightedItem: item
+						}, state));
+						_this.previousResultCount = resultCount;
+						setStatus(status, _this.props.environment.document);
+					}, 200);
+					var _this$props2 = _this.props, defaultHighlightedIndex = _this$props2.defaultHighlightedIndex, _this$props2$initialH = _this$props2.initialHighlightedIndex, _highlightedIndex = _this$props2$initialH === void 0 ? defaultHighlightedIndex : _this$props2$initialH, defaultIsOpen = _this$props2.defaultIsOpen, _this$props2$initialI = _this$props2.initialIsOpen, _isOpen = _this$props2$initialI === void 0 ? defaultIsOpen : _this$props2$initialI, _this$props2$initialI2 = _this$props2.initialInputValue, _inputValue = _this$props2$initialI2 === void 0 ? "" : _this$props2$initialI2, _this$props2$initialS = _this$props2.initialSelectedItem, _selectedItem = _this$props2$initialS === void 0 ? null : _this$props2$initialS;
+					var _state = _this.getState({
+						highlightedIndex: _highlightedIndex,
+						isOpen: _isOpen,
+						inputValue: _inputValue,
+						selectedItem: _selectedItem
+					});
+					if (_state.selectedItem != null && _this.props.initialInputValue === void 0) _state.inputValue = _this.props.itemToString(_state.selectedItem);
+					_this.state = _state;
+					return _this;
+				}
+				_inheritsLoose(Downshift, _Component);
+				var _proto = Downshift.prototype;
+				/**
+				* Clear all running timeouts
+				*/
+				_proto.internalClearTimeouts = function internalClearTimeouts() {
+					this.timeoutIds.forEach(function(id) {
+						clearTimeout(id);
+					});
+					this.timeoutIds = [];
+				};
+				_proto.getState = function getState$1(stateToMerge) {
+					if (stateToMerge === void 0) stateToMerge = this.state;
+					return getState(stateToMerge, this.props);
+				};
+				_proto.getItemCount = function getItemCount() {
+					var itemCount = this.items.length;
+					if (this.itemCount != null) itemCount = this.itemCount;
+					else if (this.props.itemCount !== void 0) itemCount = this.props.itemCount;
+					return itemCount;
+				};
+				_proto.getItemNodeFromIndex = function getItemNodeFromIndex(index) {
+					return this.props.environment ? this.props.environment.document.getElementById(this.getItemId(index)) : null;
+				};
+				_proto.scrollHighlightedItemIntoView = function scrollHighlightedItemIntoView() {
+					var node = this.getItemNodeFromIndex(this.getState().highlightedIndex);
+					this.props.scrollIntoView(node, this._menuNode);
+				};
+				_proto.moveHighlightedIndex = function moveHighlightedIndex(amount, otherStateToSet) {
+					var itemCount = this.getItemCount();
+					var highlightedIndex = this.getState().highlightedIndex;
+					if (itemCount > 0) {
+						var nextHighlightedIndex = getHighlightedIndex(highlightedIndex, amount, { length: itemCount }, this.isItemDisabled, true);
+						this.setHighlightedIndex(nextHighlightedIndex, otherStateToSet);
+					}
+				};
+				_proto.getStateAndHelpers = function getStateAndHelpers() {
+					var _this$getState9 = this.getState(), highlightedIndex = _this$getState9.highlightedIndex, inputValue = _this$getState9.inputValue, selectedItem = _this$getState9.selectedItem, isOpen = _this$getState9.isOpen;
+					var itemToString = this.props.itemToString;
+					var id = this.id;
+					var getRootProps = this.getRootProps, getToggleButtonProps = this.getToggleButtonProps, getLabelProps = this.getLabelProps, getMenuProps = this.getMenuProps, getInputProps = this.getInputProps, getItemProps = this.getItemProps, openMenu = this.openMenu, closeMenu = this.closeMenu, toggleMenu = this.toggleMenu, selectItem = this.selectItem, selectItemAtIndex = this.selectItemAtIndex, selectHighlightedItem = this.selectHighlightedItem, setHighlightedIndex = this.setHighlightedIndex, clearSelection = this.clearSelection, clearItems = this.clearItems;
+					return {
+						getRootProps,
+						getToggleButtonProps,
+						getLabelProps,
+						getMenuProps,
+						getInputProps,
+						getItemProps,
+						reset: this.reset,
+						openMenu,
+						closeMenu,
+						toggleMenu,
+						selectItem,
+						selectItemAtIndex,
+						selectHighlightedItem,
+						setHighlightedIndex,
+						clearSelection,
+						clearItems,
+						setItemCount: this.setItemCount,
+						unsetItemCount: this.unsetItemCount,
+						setState: this.internalSetState,
+						itemToString,
+						id,
+						highlightedIndex,
+						inputValue,
+						isOpen,
+						selectedItem
+					};
+				};
+				_proto.componentDidMount = function componentDidMount() {
+					var _this4 = this;
+					/* istanbul ignore if (react-native or SSR) */
+					if (!this.props.environment) this.cleanup = function() {
+						_this4.internalClearTimeouts();
+					};
+					else {
+						var onMouseDown = function onMouseDown() {
+							_this4.isMouseDown = true;
+						};
+						var onMouseUp = function onMouseUp(event) {
+							_this4.isMouseDown = false;
+							if (!targetWithinDownshift(event.target, [_this4._rootNode, _this4._menuNode], _this4.props.environment) && _this4.getState().isOpen) _this4.reset({ type: mouseUp }, function() {
+								return _this4.props.onOuterClick(_this4.getStateAndHelpers());
+							});
+						};
+						var onTouchStart = function onTouchStart() {
+							_this4.isTouchMove = false;
+						};
+						var onTouchMove = function onTouchMove() {
+							_this4.isTouchMove = true;
+						};
+						var onTouchEnd = function onTouchEnd(event) {
+							var contextWithinDownshift = targetWithinDownshift(event.target, [_this4._rootNode, _this4._menuNode], _this4.props.environment, false);
+							if (!_this4.isTouchMove && !contextWithinDownshift && _this4.getState().isOpen) _this4.reset({ type: touchEnd }, function() {
+								return _this4.props.onOuterClick(_this4.getStateAndHelpers());
+							});
+						};
+						var environment = this.props.environment;
+						environment.addEventListener("mousedown", onMouseDown);
+						environment.addEventListener("mouseup", onMouseUp);
+						environment.addEventListener("touchstart", onTouchStart);
+						environment.addEventListener("touchmove", onTouchMove);
+						environment.addEventListener("touchend", onTouchEnd);
+						this.cleanup = function() {
+							_this4.internalClearTimeouts();
+							_this4.updateStatus.cancel();
+							environment.removeEventListener("mousedown", onMouseDown);
+							environment.removeEventListener("mouseup", onMouseUp);
+							environment.removeEventListener("touchstart", onTouchStart);
+							environment.removeEventListener("touchmove", onTouchMove);
+							environment.removeEventListener("touchend", onTouchEnd);
+						};
+					}
+				};
+				_proto.shouldScroll = function shouldScroll(prevState, prevProps) {
+					var currentHighlightedIndex = (this.props.highlightedIndex === void 0 ? this.getState() : this.props).highlightedIndex;
+					var prevHighlightedIndex = (prevProps.highlightedIndex === void 0 ? prevState : prevProps).highlightedIndex;
+					return currentHighlightedIndex && this.getState().isOpen && !prevState.isOpen || currentHighlightedIndex !== prevHighlightedIndex;
+				};
+				_proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
+					if (this.props.selectedItem !== void 0 && this.props.selectedItemChanged(prevProps.selectedItem, this.props.selectedItem)) this.internalSetState({
+						type: controlledPropUpdatedSelectedItem,
+						inputValue: this.props.itemToString(this.props.selectedItem)
+					});
+					if (!this.avoidScrolling && this.shouldScroll(prevState, prevProps)) this.scrollHighlightedItemIntoView();
+					this.updateStatus();
+				};
+				_proto.componentWillUnmount = function componentWillUnmount() {
+					this.cleanup();
+				};
+				_proto.render = function render() {
+					var children = unwrapArray(this.props.children, noop);
+					this.clearItems();
+					this.getRootProps.called = false;
+					this.getRootProps.refKey = void 0;
+					this.getRootProps.suppressRefError = void 0;
+					this.getMenuProps.called = false;
+					this.getMenuProps.refKey = void 0;
+					this.getMenuProps.suppressRefError = void 0;
+					this.getLabelProps.called = false;
+					this.getInputProps.called = false;
+					var element = unwrapArray(children(this.getStateAndHelpers()));
+					if (!element) return null;
+					if (this.getRootProps.called || this.props.suppressRefError) return element;
+					else if (isDOMElement(element)) return /*#__PURE__*/ cloneElement(element, this.getRootProps(getElementProps(element)));
+				};
+				return Downshift;
+			}(Component);
+			Downshift.defaultProps = {
+				defaultHighlightedIndex: null,
+				defaultIsOpen: false,
+				getA11yStatusMessage,
+				itemToString: function itemToString(i) {
+					if (i == null) return "";
+					return String(i);
+				},
+				onStateChange: noop,
+				onInputValueChange: noop,
+				onUserAction: noop,
+				onChange: noop,
+				onSelect: noop,
+				onOuterClick: noop,
+				selectedItemChanged: function selectedItemChanged(prevItem, item) {
+					return prevItem !== item;
+				},
+				environment: typeof window === "undefined" || false ? void 0 : window,
+				stateReducer: function stateReducer(state, stateToSet) {
+					return stateToSet;
+				},
+				suppressRefError: false,
+				scrollIntoView
+			};
+			Downshift.stateChangeTypes = stateChangeTypes$4;
+			return Downshift;
+		}();
+		propTypes$4 = {
+			environment: import_prop_types.default.shape({
+				addEventListener: import_prop_types.default.func.isRequired,
+				removeEventListener: import_prop_types.default.func.isRequired,
+				document: import_prop_types.default.shape({
+					createElement: import_prop_types.default.func.isRequired,
+					getElementById: import_prop_types.default.func.isRequired,
+					activeElement: import_prop_types.default.any.isRequired,
+					body: import_prop_types.default.any.isRequired
+				}).isRequired,
+				Node: import_prop_types.default.func.isRequired
+			}),
+			itemToKey: import_prop_types.default.func,
+			stateReducer: import_prop_types.default.func
+		};
+		updateA11yStatus = debounce(function(status, document) {
+			setStatus(status, document);
+		}, 200);
+		dropdownPropTypes = _extends({}, propTypes$4, {
+			getA11yStatusMessage: import_prop_types.default.func,
+			highlightedIndex: import_prop_types.default.number,
+			defaultHighlightedIndex: import_prop_types.default.number,
+			initialHighlightedIndex: import_prop_types.default.number,
+			isOpen: import_prop_types.default.bool,
+			defaultIsOpen: import_prop_types.default.bool,
+			initialIsOpen: import_prop_types.default.bool,
+			selectedItem: import_prop_types.default.any,
+			initialSelectedItem: import_prop_types.default.any,
+			defaultSelectedItem: import_prop_types.default.any,
+			id: import_prop_types.default.string,
+			labelId: import_prop_types.default.string,
+			menuId: import_prop_types.default.string,
+			getItemId: import_prop_types.default.func,
+			toggleButtonId: import_prop_types.default.string,
+			onSelectedItemChange: import_prop_types.default.func,
+			onHighlightedIndexChange: import_prop_types.default.func,
+			onStateChange: import_prop_types.default.func,
+			onIsOpenChange: import_prop_types.default.func,
+			scrollIntoView: import_prop_types.default.func
+		});
+		dropdownDefaultProps = {
+			itemToString: function itemToString(item) {
+				return item ? String(item) : "";
+			},
+			itemToKey: function itemToKey(item) {
+				return item;
+			},
+			isItemDisabled: function isItemDisabled(_item) {
+				return false;
+			},
+			stateReducer: function stateReducer(_state, actionAndChanges) {
+				return actionAndChanges.changes;
+			},
+			scrollIntoView,
+			environment: typeof window === "undefined" || false ? void 0 : window
+		};
+		dropdownDefaultStateValues = {
+			highlightedIndex: -1,
+			isOpen: false,
+			selectedItem: null,
+			inputValue: ""
+		};
+		reactUseId$1 = _extends({}, _storybook_global_react_exports).useId;
+		useElementIds$1 = typeof reactUseId$1 === "function" ? useElementIdsR18$1 : useElementIdsLegacy$1;
+		useControlPropsValidator = noop;
+		useGetterPropsCalledChecker = function useGetterPropsCalledChecker() {
+			return noop;
+		};
+		propTypes$3 = _extends({}, dropdownPropTypes, {
+			items: import_prop_types.default.array.isRequired,
+			isItemDisabled: import_prop_types.default.func
+		});
+		ToggleButtonClick$1 = 0;
+		ToggleButtonKeyDownArrowDown = 1;
+		ToggleButtonKeyDownArrowUp = 2;
+		ToggleButtonKeyDownCharacter = 3;
+		ToggleButtonKeyDownEscape = 4;
+		ToggleButtonKeyDownHome = 5;
+		ToggleButtonKeyDownEnd = 6;
+		ToggleButtonKeyDownEnter = 7;
+		ToggleButtonKeyDownSpaceButton = 8;
+		ToggleButtonKeyDownPageUp = 9;
+		ToggleButtonKeyDownPageDown = 10;
+		ToggleButtonBlur = 11;
+		MenuMouseLeave$1 = 12;
+		ItemMouseMove$1 = 13;
+		ItemClick$1 = 14;
+		FunctionToggleMenu$1 = 15;
+		FunctionOpenMenu$1 = 16;
+		FunctionCloseMenu$1 = 17;
+		FunctionSetHighlightedIndex$1 = 18;
+		FunctionSelectItem$1 = 19;
+		FunctionSetInputValue$1 = 20;
+		FunctionReset$2 = 21;
+		stateChangeTypes$3 = /*#__PURE__*/ Object.freeze({
+			__proto__: null,
+			FunctionCloseMenu: FunctionCloseMenu$1,
+			FunctionOpenMenu: FunctionOpenMenu$1,
+			FunctionReset: FunctionReset$2,
+			FunctionSelectItem: FunctionSelectItem$1,
+			FunctionSetHighlightedIndex: FunctionSetHighlightedIndex$1,
+			FunctionSetInputValue: FunctionSetInputValue$1,
+			FunctionToggleMenu: FunctionToggleMenu$1,
+			ItemClick: ItemClick$1,
+			ItemMouseMove: ItemMouseMove$1,
+			MenuMouseLeave: MenuMouseLeave$1,
+			ToggleButtonBlur,
+			ToggleButtonClick: ToggleButtonClick$1,
+			ToggleButtonKeyDownArrowDown,
+			ToggleButtonKeyDownArrowUp,
+			ToggleButtonKeyDownCharacter,
+			ToggleButtonKeyDownEnd,
+			ToggleButtonKeyDownEnter,
+			ToggleButtonKeyDownEscape,
+			ToggleButtonKeyDownHome,
+			ToggleButtonKeyDownPageDown,
+			ToggleButtonKeyDownPageUp,
+			ToggleButtonKeyDownSpaceButton
+		});
+		_excluded$3 = ["onClick"];
+		_excluded2$3 = [
+			"onMouseLeave",
+			"refKey",
+			"ref",
+			"aria-label"
+		];
+		_excluded3$2 = [
+			"onBlur",
+			"onClick",
+			"onPress",
+			"onKeyDown",
+			"refKey",
+			"ref"
+		];
+		_excluded4$1 = [
+			"item",
+			"index",
+			"onMouseMove",
+			"onClick",
+			"onMouseDown",
+			"onPress",
+			"refKey",
+			"disabled",
+			"ref"
+		];
+		useSelect.stateChangeTypes = stateChangeTypes$3;
+		InputKeyDownArrowDown = 0;
+		InputKeyDownArrowUp = 1;
+		InputKeyDownEscape = 2;
+		InputKeyDownHome = 3;
+		InputKeyDownEnd = 4;
+		InputKeyDownPageUp = 5;
+		InputKeyDownPageDown = 6;
+		InputKeyDownEnter = 7;
+		InputChange = 8;
+		InputBlur = 9;
+		InputClick = 10;
+		MenuMouseLeave = 11;
+		ItemMouseMove = 12;
+		ItemClick = 13;
+		ToggleButtonClick = 14;
+		FunctionToggleMenu = 15;
+		FunctionOpenMenu = 16;
+		FunctionCloseMenu = 17;
+		FunctionSetHighlightedIndex = 18;
+		FunctionSelectItem = 19;
+		FunctionSetInputValue = 20;
+		FunctionReset$1 = 21;
+		ControlledPropUpdatedSelectedItem = 22;
+		stateChangeTypes$2 = /*#__PURE__*/ Object.freeze({
+			__proto__: null,
+			ControlledPropUpdatedSelectedItem,
+			FunctionCloseMenu,
+			FunctionOpenMenu,
+			FunctionReset: FunctionReset$1,
+			FunctionSelectItem,
+			FunctionSetHighlightedIndex,
+			FunctionSetInputValue,
+			FunctionToggleMenu,
+			InputBlur,
+			InputChange,
+			InputClick,
+			InputKeyDownArrowDown,
+			InputKeyDownArrowUp,
+			InputKeyDownEnd,
+			InputKeyDownEnter,
+			InputKeyDownEscape,
+			InputKeyDownHome,
+			InputKeyDownPageDown,
+			InputKeyDownPageUp,
+			ItemClick,
+			ItemMouseMove,
+			MenuMouseLeave,
+			ToggleButtonClick
+		});
+		propTypes$2 = _extends({}, dropdownPropTypes, {
+			items: import_prop_types.default.array.isRequired,
+			isItemDisabled: import_prop_types.default.func,
+			inputValue: import_prop_types.default.string,
+			defaultInputValue: import_prop_types.default.string,
+			initialInputValue: import_prop_types.default.string,
+			inputId: import_prop_types.default.string,
+			onInputValueChange: import_prop_types.default.func
+		});
+		_excluded$2 = [
+			"onMouseLeave",
+			"refKey",
+			"ref",
+			"aria-label"
+		];
+		_excluded2$2 = [
+			"item",
+			"index",
+			"refKey",
+			"ref",
+			"onMouseMove",
+			"onMouseDown",
+			"onClick",
+			"onPress",
+			"disabled"
+		];
+		_excluded3$1 = [
+			"onClick",
+			"onPress",
+			"refKey",
+			"ref"
+		];
+		_excluded4 = [
+			"aria-label",
+			"onKeyDown",
+			"onChange",
+			"onInput",
+			"onBlur",
+			"onChangeText",
+			"onClick",
+			"refKey",
+			"ref"
+		];
+		useCombobox.stateChangeTypes = stateChangeTypes$2;
+		defaultStateValues = {
+			activeIndex: -1,
+			selectedItems: []
+		};
+		dropdownPropTypes.stateReducer, dropdownPropTypes.itemToKey, dropdownPropTypes.environment, import_prop_types.default.array, import_prop_types.default.array, import_prop_types.default.array, import_prop_types.default.func, import_prop_types.default.number, import_prop_types.default.number, import_prop_types.default.number, import_prop_types.default.func, import_prop_types.default.func, import_prop_types.default.string, import_prop_types.default.string;
+		defaultProps = {
+			itemToKey: dropdownDefaultProps.itemToKey,
+			stateReducer: dropdownDefaultProps.stateReducer,
+			environment: dropdownDefaultProps.environment,
+			keyNavigationNext: "ArrowRight",
+			keyNavigationPrevious: "ArrowLeft"
+		};
+		validatePropTypes = noop;
+		SelectedItemClick = 0;
+		SelectedItemKeyDownDelete = 1;
+		SelectedItemKeyDownBackspace = 2;
+		SelectedItemKeyDownNavigationNext = 3;
+		SelectedItemKeyDownNavigationPrevious = 4;
+		DropdownKeyDownNavigationPrevious = 5;
+		DropdownKeyDownBackspace = 6;
+		DropdownClick = 7;
+		FunctionAddSelectedItem = 8;
+		FunctionRemoveSelectedItem = 9;
+		FunctionSetSelectedItems = 10;
+		FunctionSetActiveIndex = 11;
+		FunctionReset = 12;
+		stateChangeTypes$1 = /*#__PURE__*/ Object.freeze({
+			__proto__: null,
+			DropdownClick,
+			DropdownKeyDownBackspace,
+			DropdownKeyDownNavigationPrevious,
+			FunctionAddSelectedItem,
+			FunctionRemoveSelectedItem,
+			FunctionReset,
+			FunctionSetActiveIndex,
+			FunctionSetSelectedItems,
+			SelectedItemClick,
+			SelectedItemKeyDownBackspace,
+			SelectedItemKeyDownDelete,
+			SelectedItemKeyDownNavigationNext,
+			SelectedItemKeyDownNavigationPrevious
+		});
+		_excluded$1 = [
+			"refKey",
+			"ref",
+			"onClick",
+			"onKeyDown",
+			"selectedItem",
+			"index"
+		];
+		_excluded2$1 = [
+			"refKey",
+			"ref",
+			"onKeyDown",
+			"onClick",
+			"preventKeyAction"
+		];
+		useMultipleSelection.stateChangeTypes = stateChangeTypes$1;
+		TagClick = 0;
+		TagGroupKeyDownArrowLeft = 1;
+		TagGroupKeyDownArrowRight = 2;
+		TagGroupKeyDownDelete = 3;
+		TagGroupKeyDownBackspace = 4;
+		TagRemoveClick = 5;
+		FunctionAddItem = 6;
+		stateChangeTypes = /*#__PURE__*/ Object.freeze({
+			__proto__: null,
+			FunctionAddItem,
+			TagClick,
+			TagGroupKeyDownArrowLeft,
+			TagGroupKeyDownArrowRight,
+			TagGroupKeyDownBackspace,
+			TagGroupKeyDownDelete,
+			TagRemoveClick
+		});
+		reactUseId = _extends({}, _storybook_global_react_exports).useId;
+		useElementIds = typeof reactUseId === "function" ? useElementIdsR18 : useElementIdsLegacy;
+		A11Y_DESCRIPTION_ELEMENT_ID = "tag-group-a11y-description";
+		propTypes = { isItemDisabled: import_prop_types.default.func };
+		_excluded = ["onKeyDown"];
+		_excluded2 = [
+			"index",
+			"refKey",
+			"ref",
+			"onClick"
+		];
+		_excluded3 = ["index", "onClick"];
+		_useTagGroup = function useTagGroup(userProps) {
+			var _props$environment;
+			if (userProps === void 0) userProps = {};
+			validatePropTypes$1(userProps, _useTagGroup, propTypes);
+			var props = getMergedProps(userProps);
+			var _useControlledReducer = useControlledReducer$1(useTagGroupReducer, props, getInitialState, isStateEqual), state = _useControlledReducer[0], dispatch = _useControlledReducer[1];
+			var activeIndex = state.activeIndex, items = state.items;
+			var elementIds = useElementIds({
+				getTagId: props.getTagId,
+				id: props.id,
+				tagGroupId: props.tagGroupId
+			});
+			useAccessibleDescription((_props$environment = props.environment) == null ? void 0 : _props$environment.document, props.removeElementDescription);
+			var itemRefs = useRovingTagFocus(activeIndex, items.length, elementIds.getTagId);
+			var getTagGroupProps = useCallback(function(options) {
+				var _ref = options != null ? options : {}, onKeyDown = _ref.onKeyDown, rest = _objectWithoutPropertiesLoose(_ref, _excluded);
+				return _extends({
+					id: elementIds.tagGroupId,
+					"aria-live": "polite",
+					"aria-atomic": "false",
+					"aria-relevant": "additions",
+					role: "listbox",
+					onKeyDown: callAllEventHandlers(onKeyDown, function handleKeyDown(e) {
+						switch (e.key) {
+							case "ArrowLeft":
+								dispatch({ type: TagGroupKeyDownArrowLeft });
+								break;
+							case "ArrowRight":
+								dispatch({ type: TagGroupKeyDownArrowRight });
+								break;
+							case "Delete":
+								dispatch({ type: TagGroupKeyDownDelete });
+								break;
+							case "Backspace": dispatch({ type: TagGroupKeyDownBackspace });
+						}
+					})
+				}, rest);
+			}, [dispatch, elementIds.tagGroupId]);
+			var getTagProps = useCallback(function(options) {
+				var _extends2;
+				var index = options.index, _options$refKey = options.refKey, refKey = _options$refKey === void 0 ? "ref" : _options$refKey, ref = options.ref, onClick = options.onClick, rest = _objectWithoutPropertiesLoose(options, _excluded2);
+				if (!Number.isInteger(index) || index < 0) throw new Error("Pass correct item index to getTagProps!");
+				var handleClick = function handleClick() {
+					dispatch({
+						type: TagClick,
+						index
+					});
+				};
+				var tagId = elementIds.getTagId(index);
+				return _extends((_extends2 = { "aria-describedby": A11Y_DESCRIPTION_ELEMENT_ID }, _extends2[refKey] = handleRefs(ref, function(itemNode) {
+					if (itemNode) itemRefs.current[tagId] = itemNode;
+				}), _extends2["aria-labelledby"] = tagId, _extends2.role = "option", _extends2.id = tagId, _extends2.onClick = callAllEventHandlers(onClick, handleClick), _extends2.tabIndex = activeIndex === index ? 0 : -1, _extends2), rest);
+			}, [
+				dispatch,
+				elementIds,
+				activeIndex,
+				itemRefs
+			]);
+			var getTagRemoveProps = useCallback(function(options) {
+				var index = options.index, onClick = options.onClick, rest = _objectWithoutPropertiesLoose(options, _excluded3);
+				if (!Number.isInteger(index) || index < 0) throw new Error("Pass correct item index to getTagRemoveProps!");
+				var handleClick = function handleClick(event) {
+					event.stopPropagation();
+					dispatch({
+						type: TagRemoveClick,
+						index
+					});
+				};
+				var tagId = elementIds.getTagId(index);
+				var tagRemoveId = tagId + "-remove";
+				return _extends({
+					id: tagRemoveId,
+					tabIndex: -1,
+					"aria-labelledby": tagRemoveId + " " + tagId,
+					onClick: callAllEventHandlers(onClick, handleClick)
+				}, rest);
+			}, [elementIds, dispatch]);
+			return {
+				activeIndex,
+				addItem: useCallback(function(item, index) {
+					dispatch({
+						type: FunctionAddItem,
+						item,
+						index
+					});
+				}, [dispatch]),
+				getTagGroupProps,
+				getTagProps,
+				getTagRemoveProps,
+				items
+			};
+		};
+		_useTagGroup.stateChangeTypes = stateChangeTypes;
+	})))();
+}
+//#endregion
+export { debounce$1 as a, init_clsx as c, throttle as i, init_isEqual as l, init_downshift_esm as n, init_debounce as o, init_throttle as r, clsx as s, Downshift as t, isEqual as u };