@jobber/components 7.8.0 → 7.9.0

package/dist/InputNumber/index.mjs

@@ -1,6 +1,6 @@
-import React__default, { useEffect, useMemo, useCallback, useRef, useState, createContext, useContext, forwardRef, createRef, useImperativeHandle } from 'react';
+import React__default, { useRef, useCallback, useState, useContext, useEffect, useMemo, createContext, forwardRef, createRef, useImperativeHandle } from 'react';
 import { _ as __rest } from '../tslib.es6-es.js';
-import { $ as $8ae05eaa5c114e9c$export$7f54fc3180508a52, a as $18f2051aff69b9bf$export$43bb16f9c6d9e3f7, b as $e9faafb641e167db$export$90fc3a17d93f704c, c as $507fabe10e71c6fb$export$b9b3dfddab17db27, d as $507fabe10e71c6fb$export$ec71b4b83ac08ec3, e as $a1ea59d68270f0dd$export$f8168d8dd8fd66e6, f as $9ab94262bd0047c7$export$420e68273165f4ec, g as $bdb11010cef70236$export$f680877a34711e37, h as $313b98861ee5dd6c$export$d6875122194c7b44, i as $bdb11010cef70236$export$b4cc09c592e8fdb8, j as $3ef42575df84b30b$export$9d1611c77c2fe928, k as $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c, l as $507fabe10e71c6fb$export$8397ddfc504fdb9a, m as $458b0a5536c1a7cf$export$40bfa8c7b0832715, n as $f645667febf57a63$export$4c014de7c8940b4c, o as $65484d02dcb7eb3e$export$457c3d6518dd4c6f, p as $431fbd86ca7dc216$export$f21a1ffae260145a, q as $9446cca9a3875146$export$cb6e0bb50bc19463, r as $9446cca9a3875146$export$7d15b64cf5a3a4c4, s as $fca6afa0e843324b$export$f12b703ca79dfbb1, t as $03deb23ff14920c4$export$4eaf04e54aa8eed6, u as $c87311424ea30a05$export$186c6964ca17d99, v as $c87311424ea30a05$export$a11b0059900ceec8, w as $ff5963eb1fccf552$export$e08e3b67e392101e, x as $c87311424ea30a05$export$fedb369cb70207f1, y as $f39a9eba43920ace$export$86427a43e3e48ebb, z as $64fa3d84918910a7$export$29f1550f4b0d4415, A as $64fa3d84918910a7$export$4d86445c2cf5e3, B as $514c0188e459b4c0$export$5f1af8db9871e1d6, C as $6179b936705e76d3$export$ae780daf29e6d456, D as $64fa3d84918910a7$export$fabf2dc03a41866e, E as $64fa3d84918910a7$export$9d4c57ee4c6ffdd8, F as $64fa3d84918910a7$export$ef03459518577ad4, G as $64fa3d84918910a7$export$2881499e37b75b9a, H as $514c0188e459b4c0$export$9afb8bc826b033ea } from '../Text-es2.js';
+import { c as clsx } from '../clsx-es.js';
 import classnames from 'classnames';
 import { I as Icon } from '../Icon-es.js';
 import { T as Text } from '../Text-es.js';
@@ -11,7 +11,6 @@ import '@jobber/hooks';
 import 'framer-motion';
 import '@jobber/design';
 import '../Button-es.js';
-import '../clsx-es.js';
 import '../Typography-es.js';
 import '../mergeRefs-es.js';
 import '../useFormFieldFocus-es.js';
@@ -19,6 +18,919 @@ import '../InputValidation-es.js';
 import '../Spinner-es.js';
 import 'react-router-dom';
 
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+const $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c = typeof document !== 'undefined' ? (React__default).useLayoutEffect : ()=>{};
+
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+var $8ae05eaa5c114e9c$var$_React_useInsertionEffect;
+// Use the earliest effect type possible. useInsertionEffect runs during the mutation phase,
+// before all layout effects, but is available only in React 18 and later.
+const $8ae05eaa5c114e9c$var$useEarlyEffect = ($8ae05eaa5c114e9c$var$_React_useInsertionEffect = (React__default)['useInsertionEffect']) !== null && $8ae05eaa5c114e9c$var$_React_useInsertionEffect !== void 0 ? $8ae05eaa5c114e9c$var$_React_useInsertionEffect : ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c);
+function $8ae05eaa5c114e9c$export$7f54fc3180508a52(fn) {
+    const ref = (useRef)(null);
+    $8ae05eaa5c114e9c$var$useEarlyEffect(()=>{
+        ref.current = fn;
+    }, [
+        fn
+    ]);
+    // @ts-ignore
+    return (useCallback)((...args)=>{
+        const f = ref.current;
+        return f === null || f === void 0 ? void 0 : f(...args);
+    }, []);
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+function $1dbecbe27a04f9af$export$14d238f342723f25(defaultValue) {
+    let [value, setValue] = (useState)(defaultValue);
+    let effect = (useRef)(null);
+    // Store the function in a ref so we can always access the current version
+    // which has the proper `value` in scope.
+    let nextRef = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)(()=>{
+        if (!effect.current) return;
+        // Run the generator to the next yield.
+        let newValue = effect.current.next();
+        // If the generator is done, reset the effect.
+        if (newValue.done) {
+            effect.current = null;
+            return;
+        }
+        // If the value is the same as the current value,
+        // then continue to the next yield. Otherwise,
+        // set the value in state and wait for the next layout effect.
+        if (value === newValue.value) nextRef();
+        else setValue(newValue.value);
+    });
+    ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
+        // If there is an effect currently running, continue to the next yield.
+        if (effect.current) nextRef();
+    });
+    let queue = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)((fn)=>{
+        effect.current = fn(value);
+        nextRef();
+    });
+    return [
+        value,
+        queue
+    ];
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // We must avoid a circular dependency with @react-aria/utils, and this useLayoutEffect is
+// guarded by a check that it only runs on the client side.
+// eslint-disable-next-line rulesdir/useLayoutEffectRule
+
+// Default context value to use in case there is no SSRProvider. This is fine for
+// client-only apps. In order to support multiple copies of React Aria potentially
+// being on the page at once, the prefix is set to a random number. SSRProvider
+// will reset this to zero for consistency between server and client, so in the
+// SSR case multiple copies of React Aria is not supported.
+const $b5e257d569688ac6$var$defaultContext = {
+    prefix: String(Math.round(Math.random() * 10000000000)),
+    current: 0
+};
+const $b5e257d569688ac6$var$SSRContext = /*#__PURE__*/ (React__default).createContext($b5e257d569688ac6$var$defaultContext);
+const $b5e257d569688ac6$var$IsSSRContext = /*#__PURE__*/ (React__default).createContext(false);
+let $b5e257d569688ac6$var$canUseDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);
+let $b5e257d569688ac6$var$componentIds = new WeakMap();
+function $b5e257d569688ac6$var$useCounter(isDisabled = false) {
+    let ctx = (useContext)($b5e257d569688ac6$var$SSRContext);
+    let ref = (useRef)(null);
+    // eslint-disable-next-line rulesdir/pure-render
+    if (ref.current === null && !isDisabled) {
+        var _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner, _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+        // In strict mode, React renders components twice, and the ref will be reset to null on the second render.
+        // This means our id counter will be incremented twice instead of once. This is a problem because on the
+        // server, components are only rendered once and so ids generated on the server won't match the client.
+        // In React 18, useId was introduced to solve this, but it is not available in older versions. So to solve this
+        // we need to use some React internals to access the underlying Fiber instance, which is stable between renders.
+        // This is exposed as ReactCurrentOwner in development, which is all we need since StrictMode only runs in development.
+        // To ensure that we only increment the global counter once, we store the starting id for this component in
+        // a weak map associated with the Fiber. On the second render, we reset the global counter to this value.
+        // Since React runs the second render immediately after the first, this is safe.
+        // @ts-ignore
+        let currentOwner = (_React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = (React__default).__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED === void 0 ? void 0 : (_React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner = _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner) === null || _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner === void 0 ? void 0 : _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner.current;
+        if (currentOwner) {
+            let prevComponentValue = $b5e257d569688ac6$var$componentIds.get(currentOwner);
+            if (prevComponentValue == null) // On the first render, and first call to useId, store the id and state in our weak map.
+            $b5e257d569688ac6$var$componentIds.set(currentOwner, {
+                id: ctx.current,
+                state: currentOwner.memoizedState
+            });
+            else if (currentOwner.memoizedState !== prevComponentValue.state) {
+                // On the second render, the memoizedState gets reset by React.
+                // Reset the counter, and remove from the weak map so we don't
+                // do this for subsequent useId calls.
+                ctx.current = prevComponentValue.id;
+                $b5e257d569688ac6$var$componentIds.delete(currentOwner);
+            }
+        }
+        // eslint-disable-next-line rulesdir/pure-render
+        ref.current = ++ctx.current;
+    }
+    // eslint-disable-next-line rulesdir/pure-render
+    return ref.current;
+}
+function $b5e257d569688ac6$var$useLegacySSRSafeId(defaultId) {
+    let ctx = (useContext)($b5e257d569688ac6$var$SSRContext);
+    // If we are rendering in a non-DOM environment, and there's no SSRProvider,
+    // provide a warning to hint to the developer to add one.
+    if (ctx === $b5e257d569688ac6$var$defaultContext && !$b5e257d569688ac6$var$canUseDOM && process.env.NODE_ENV !== 'production') console.warn('When server rendering, you must wrap your application in an <SSRProvider> to ensure consistent ids are generated between the client and server.');
+    let counter = $b5e257d569688ac6$var$useCounter(!!defaultId);
+    let prefix = ctx === $b5e257d569688ac6$var$defaultContext && process.env.NODE_ENV === 'test' ? 'react-aria' : `react-aria${ctx.prefix}`;
+    return defaultId || `${prefix}-${counter}`;
+}
+function $b5e257d569688ac6$var$useModernSSRSafeId(defaultId) {
+    let id = (React__default).useId();
+    let [didSSR] = (useState)($b5e257d569688ac6$export$535bd6ca7f90a273());
+    let prefix = didSSR || process.env.NODE_ENV === 'test' ? 'react-aria' : `react-aria${$b5e257d569688ac6$var$defaultContext.prefix}`;
+    return defaultId || `${prefix}-${id}`;
+}
+const $b5e257d569688ac6$export$619500959fc48b26 = typeof (React__default)['useId'] === 'function' ? $b5e257d569688ac6$var$useModernSSRSafeId : $b5e257d569688ac6$var$useLegacySSRSafeId;
+function $b5e257d569688ac6$var$getSnapshot() {
+    return false;
+}
+function $b5e257d569688ac6$var$getServerSnapshot() {
+    return true;
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function $b5e257d569688ac6$var$subscribe(onStoreChange) {
+    // noop
+    return ()=>{};
+}
+function $b5e257d569688ac6$export$535bd6ca7f90a273() {
+    // In React 18, we can use useSyncExternalStore to detect if we're server rendering or hydrating.
+    if (typeof (React__default)['useSyncExternalStore'] === 'function') return (React__default)['useSyncExternalStore']($b5e257d569688ac6$var$subscribe, $b5e257d569688ac6$var$getSnapshot, $b5e257d569688ac6$var$getServerSnapshot);
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return (useContext)($b5e257d569688ac6$var$IsSSRContext);
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+
+// copied from SSRProvider.tsx to reduce exports, if needed again, consider sharing
+let $bdb11010cef70236$var$canUseDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);
+let $bdb11010cef70236$export$d41a04c74483c6ef = new Map();
+// This allows us to clean up the idsUpdaterMap when the id is no longer used.
+// Map is a strong reference, so unused ids wouldn't be cleaned up otherwise.
+// This can happen in suspended components where mount/unmount is not called.
+let $bdb11010cef70236$var$registry;
+if (typeof FinalizationRegistry !== 'undefined') $bdb11010cef70236$var$registry = new FinalizationRegistry((heldValue)=>{
+    $bdb11010cef70236$export$d41a04c74483c6ef.delete(heldValue);
+});
+function $bdb11010cef70236$export$f680877a34711e37(defaultId) {
+    let [value, setValue] = (useState)(defaultId);
+    let nextId = (useRef)(null);
+    let res = ($b5e257d569688ac6$export$619500959fc48b26)(value);
+    let cleanupRef = (useRef)(null);
+    if ($bdb11010cef70236$var$registry) $bdb11010cef70236$var$registry.register(cleanupRef, res);
+    if ($bdb11010cef70236$var$canUseDOM) {
+        const cacheIdRef = $bdb11010cef70236$export$d41a04c74483c6ef.get(res);
+        if (cacheIdRef && !cacheIdRef.includes(nextId)) cacheIdRef.push(nextId);
+        else $bdb11010cef70236$export$d41a04c74483c6ef.set(res, [
+            nextId
+        ]);
+    }
+    ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
+        let r = res;
+        return ()=>{
+            // In Suspense, the cleanup function may be not called
+            // when it is though, also remove it from the finalization registry.
+            if ($bdb11010cef70236$var$registry) $bdb11010cef70236$var$registry.unregister(cleanupRef);
+            $bdb11010cef70236$export$d41a04c74483c6ef.delete(r);
+        };
+    }, [
+        res
+    ]);
+    // This cannot cause an infinite loop because the ref is always cleaned up.
+    // eslint-disable-next-line
+    (useEffect)(()=>{
+        let newId = nextId.current;
+        if (newId) setValue(newId);
+        return ()=>{
+            if (newId) nextId.current = null;
+        };
+    });
+    return res;
+}
+function $bdb11010cef70236$export$cd8c9cb68f842629(idA, idB) {
+    if (idA === idB) return idA;
+    let setIdsA = $bdb11010cef70236$export$d41a04c74483c6ef.get(idA);
+    if (setIdsA) {
+        setIdsA.forEach((ref)=>ref.current = idB);
+        return idB;
+    }
+    let setIdsB = $bdb11010cef70236$export$d41a04c74483c6ef.get(idB);
+    if (setIdsB) {
+        setIdsB.forEach((ref)=>ref.current = idA);
+        return idA;
+    }
+    return idB;
+}
+function $bdb11010cef70236$export$b4cc09c592e8fdb8(depArray = []) {
+    let id = $bdb11010cef70236$export$f680877a34711e37();
+    let [resolvedId, setResolvedId] = ($1dbecbe27a04f9af$export$14d238f342723f25)(id);
+    let updateId = (useCallback)(()=>{
+        setResolvedId(function*() {
+            yield id;
+            yield document.getElementById(id) ? id : undefined;
+        });
+    }, [
+        id,
+        setResolvedId
+    ]);
+    ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(updateId, [
+        id,
+        updateId,
+        ...depArray
+    ]);
+    return resolvedId;
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ /**
+ * Calls all functions in the order they were chained with the same arguments.
+ */ function $ff5963eb1fccf552$export$e08e3b67e392101e(...callbacks) {
+    return (...args)=>{
+        for (let callback of callbacks)if (typeof callback === 'function') callback(...args);
+    };
+}
+
+const $431fbd86ca7dc216$export$b204af158042fbac = (el)=>{
+    var _el_ownerDocument;
+    return (_el_ownerDocument = el === null || el === void 0 ? void 0 : el.ownerDocument) !== null && _el_ownerDocument !== void 0 ? _el_ownerDocument : document;
+};
+const $431fbd86ca7dc216$export$f21a1ffae260145a = (el)=>{
+    if (el && 'window' in el && el.window === el) return el;
+    const doc = $431fbd86ca7dc216$export$b204af158042fbac(el);
+    return doc.defaultView || window;
+};
+/**
+ * Type guard that checks if a value is a Node. Verifies the presence and type of the nodeType property.
+ */ function $431fbd86ca7dc216$var$isNode(value) {
+    return value !== null && typeof value === 'object' && 'nodeType' in value && typeof value.nodeType === 'number';
+}
+function $431fbd86ca7dc216$export$af51f0f06c0f328a(node) {
+    return $431fbd86ca7dc216$var$isNode(node) && node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && 'host' in node;
+}
+
+let $f4e2df6bd15f8569$var$_shadowDOM = false;
+function $f4e2df6bd15f8569$export$98658e8c59125e6a() {
+    return $f4e2df6bd15f8569$var$_shadowDOM;
+}
+
+// Source: https://github.com/microsoft/tabster/blob/a89fc5d7e332d48f68d03b1ca6e344489d1c3898/src/Shadowdomize/DOMFunctions.ts#L16
+
+
+function $d4ee10de306f2510$export$4282f70798064fe0(node, otherNode) {
+    if (!($f4e2df6bd15f8569$export$98658e8c59125e6a)()) return otherNode && node ? node.contains(otherNode) : false;
+    if (!node || !otherNode) return false;
+    let currentNode = otherNode;
+    while(currentNode !== null){
+        if (currentNode === node) return true;
+        if (currentNode.tagName === 'SLOT' && currentNode.assignedSlot) // Element is slotted
+        currentNode = currentNode.assignedSlot.parentNode;
+        else if (($431fbd86ca7dc216$export$af51f0f06c0f328a)(currentNode)) // Element is in shadow root
+        currentNode = currentNode.host;
+        else currentNode = currentNode.parentNode;
+    }
+    return false;
+}
+const $d4ee10de306f2510$export$cd4e5573fbe2b576 = (doc = document)=>{
+    var _activeElement_shadowRoot;
+    if (!($f4e2df6bd15f8569$export$98658e8c59125e6a)()) return doc.activeElement;
+    let activeElement = doc.activeElement;
+    while(activeElement && 'shadowRoot' in activeElement && ((_activeElement_shadowRoot = activeElement.shadowRoot) === null || _activeElement_shadowRoot === void 0 ? void 0 : _activeElement_shadowRoot.activeElement))activeElement = activeElement.shadowRoot.activeElement;
+    return activeElement;
+};
+function $d4ee10de306f2510$export$e58f029f0fbfdb29(event) {
+    if (($f4e2df6bd15f8569$export$98658e8c59125e6a)() && event.target.shadowRoot) {
+        if (event.composedPath) return event.composedPath()[0];
+    }
+    return event.target;
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+function $3ef42575df84b30b$export$9d1611c77c2fe928(...args) {
+    // Start with a base clone of the first argument. This is a lot faster than starting
+    // with an empty object and adding properties as we go.
+    let result = {
+        ...args[0]
+    };
+    for(let i = 1; i < args.length; i++){
+        let props = args[i];
+        for(let key in props){
+            let a = result[key];
+            let b = props[key];
+            // Chain events
+            if (typeof a === 'function' && typeof b === 'function' && // This is a lot faster than a regex.
+            key[0] === 'o' && key[1] === 'n' && key.charCodeAt(2) >= /* 'A' */ 65 && key.charCodeAt(2) <= /* 'Z' */ 90) result[key] = ($ff5963eb1fccf552$export$e08e3b67e392101e)(a, b);
+            else if ((key === 'className' || key === 'UNSAFE_className') && typeof a === 'string' && typeof b === 'string') result[key] = (clsx)(a, b);
+            else if (key === 'id' && a && b) result.id = ($bdb11010cef70236$export$cd8c9cb68f842629)(a, b);
+            else result[key] = b !== undefined ? b : a;
+        }
+    }
+    return result;
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ function $5dc95899b306f630$export$c9058316764c140e(...refs) {
+    if (refs.length === 1 && refs[0]) return refs[0];
+    return (value)=>{
+        let hasCleanup = false;
+        const cleanups = refs.map((ref)=>{
+            const cleanup = $5dc95899b306f630$var$setRef(ref, value);
+            hasCleanup || (hasCleanup = typeof cleanup == 'function');
+            return cleanup;
+        });
+        if (hasCleanup) return ()=>{
+            cleanups.forEach((cleanup, i)=>{
+                if (typeof cleanup === 'function') cleanup();
+                else $5dc95899b306f630$var$setRef(refs[i], null);
+            });
+        };
+    };
+}
+function $5dc95899b306f630$var$setRef(ref, value) {
+    if (typeof ref === 'function') return ref(value);
+    else if (ref != null) ref.current = value;
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ const $65484d02dcb7eb3e$var$DOMPropNames = new Set([
+    'id'
+]);
+const $65484d02dcb7eb3e$var$labelablePropNames = new Set([
+    'aria-label',
+    'aria-labelledby',
+    'aria-describedby',
+    'aria-details'
+]);
+// See LinkDOMProps in dom.d.ts.
+const $65484d02dcb7eb3e$var$linkPropNames = new Set([
+    'href',
+    'hrefLang',
+    'target',
+    'rel',
+    'download',
+    'ping',
+    'referrerPolicy'
+]);
+const $65484d02dcb7eb3e$var$globalAttrs = new Set([
+    'dir',
+    'lang',
+    'hidden',
+    'inert',
+    'translate'
+]);
+const $65484d02dcb7eb3e$var$globalEvents = new Set([
+    'onClick',
+    'onAuxClick',
+    'onContextMenu',
+    'onDoubleClick',
+    'onMouseDown',
+    'onMouseEnter',
+    'onMouseLeave',
+    'onMouseMove',
+    'onMouseOut',
+    'onMouseOver',
+    'onMouseUp',
+    'onTouchCancel',
+    'onTouchEnd',
+    'onTouchMove',
+    'onTouchStart',
+    'onPointerDown',
+    'onPointerMove',
+    'onPointerUp',
+    'onPointerCancel',
+    'onPointerEnter',
+    'onPointerLeave',
+    'onPointerOver',
+    'onPointerOut',
+    'onGotPointerCapture',
+    'onLostPointerCapture',
+    'onScroll',
+    'onWheel',
+    'onAnimationStart',
+    'onAnimationEnd',
+    'onAnimationIteration',
+    'onTransitionCancel',
+    'onTransitionEnd',
+    'onTransitionRun',
+    'onTransitionStart'
+]);
+const $65484d02dcb7eb3e$var$propRe = /^(data-.*)$/;
+function $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, opts = {}) {
+    let { labelable: labelable, isLink: isLink, global: global, events: events = global, propNames: propNames } = opts;
+    let filteredProps = {};
+    for(const prop in props)if (Object.prototype.hasOwnProperty.call(props, prop) && ($65484d02dcb7eb3e$var$DOMPropNames.has(prop) || labelable && $65484d02dcb7eb3e$var$labelablePropNames.has(prop) || isLink && $65484d02dcb7eb3e$var$linkPropNames.has(prop) || global && $65484d02dcb7eb3e$var$globalAttrs.has(prop) || events && $65484d02dcb7eb3e$var$globalEvents.has(prop) || prop.endsWith('Capture') && $65484d02dcb7eb3e$var$globalEvents.has(prop.slice(0, -7)) || (propNames === null || propNames === void 0 ? void 0 : propNames.has(prop)) || $65484d02dcb7eb3e$var$propRe.test(prop))) filteredProps[prop] = props[prop];
+    return filteredProps;
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ function $7215afc6de606d6b$export$de79e2c695e052f3(element) {
+    if ($7215afc6de606d6b$var$supportsPreventScroll()) element.focus({
+        preventScroll: true
+    });
+    else {
+        let scrollableElements = $7215afc6de606d6b$var$getScrollableElements(element);
+        element.focus();
+        $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements);
+    }
+}
+let $7215afc6de606d6b$var$supportsPreventScrollCached = null;
+function $7215afc6de606d6b$var$supportsPreventScroll() {
+    if ($7215afc6de606d6b$var$supportsPreventScrollCached == null) {
+        $7215afc6de606d6b$var$supportsPreventScrollCached = false;
+        try {
+            let focusElem = document.createElement('div');
+            focusElem.focus({
+                get preventScroll () {
+                    $7215afc6de606d6b$var$supportsPreventScrollCached = true;
+                    return true;
+                }
+            });
+        } catch  {
+        // Ignore
+        }
+    }
+    return $7215afc6de606d6b$var$supportsPreventScrollCached;
+}
+function $7215afc6de606d6b$var$getScrollableElements(element) {
+    let parent = element.parentNode;
+    let scrollableElements = [];
+    let rootScrollingElement = document.scrollingElement || document.documentElement;
+    while(parent instanceof HTMLElement && parent !== rootScrollingElement){
+        if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth) scrollableElements.push({
+            element: parent,
+            scrollTop: parent.scrollTop,
+            scrollLeft: parent.scrollLeft
+        });
+        parent = parent.parentNode;
+    }
+    if (rootScrollingElement instanceof HTMLElement) scrollableElements.push({
+        element: rootScrollingElement,
+        scrollTop: rootScrollingElement.scrollTop,
+        scrollLeft: rootScrollingElement.scrollLeft
+    });
+    return scrollableElements;
+}
+function $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements) {
+    for (let { element: element, scrollTop: scrollTop, scrollLeft: scrollLeft } of scrollableElements){
+        element.scrollTop = scrollTop;
+        element.scrollLeft = scrollLeft;
+    }
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ function $c87311424ea30a05$var$testUserAgent(re) {
+    var _window_navigator_userAgentData;
+    if (typeof window === 'undefined' || window.navigator == null) return false;
+    let brands = (_window_navigator_userAgentData = window.navigator['userAgentData']) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.brands;
+    return Array.isArray(brands) && brands.some((brand)=>re.test(brand.brand)) || re.test(window.navigator.userAgent);
+}
+function $c87311424ea30a05$var$testPlatform(re) {
+    var _window_navigator_userAgentData;
+    return typeof window !== 'undefined' && window.navigator != null ? re.test(((_window_navigator_userAgentData = window.navigator['userAgentData']) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.platform) || window.navigator.platform) : false;
+}
+function $c87311424ea30a05$var$cached(fn) {
+    if (process.env.NODE_ENV === 'test') return fn;
+    let res = null;
+    return ()=>{
+        if (res == null) res = fn();
+        return res;
+    };
+}
+const $c87311424ea30a05$export$9ac100e40613ea10 = $c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$var$testPlatform(/^Mac/i);
+});
+const $c87311424ea30a05$export$186c6964ca17d99 = $c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$var$testPlatform(/^iPhone/i);
+});
+const $c87311424ea30a05$export$7bef049ce92e4224 = $c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$var$testPlatform(/^iPad/i) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
+    $c87311424ea30a05$export$9ac100e40613ea10() && navigator.maxTouchPoints > 1;
+});
+const $c87311424ea30a05$export$fedb369cb70207f1 = $c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$export$186c6964ca17d99() || $c87311424ea30a05$export$7bef049ce92e4224();
+});
+$c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$export$9ac100e40613ea10() || $c87311424ea30a05$export$fedb369cb70207f1();
+});
+$c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$var$testUserAgent(/AppleWebKit/i) && !$c87311424ea30a05$export$6446a186d09e379e();
+});
+const $c87311424ea30a05$export$6446a186d09e379e = $c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$var$testUserAgent(/Chrome/i);
+});
+const $c87311424ea30a05$export$a11b0059900ceec8 = $c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$var$testUserAgent(/Android/i);
+});
+$c87311424ea30a05$var$cached(function() {
+    return $c87311424ea30a05$var$testUserAgent(/Firefox/i);
+});
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // We store a global list of elements that are currently transitioning,
+// mapped to a set of CSS properties that are transitioning for that element.
+// This is necessary rather than a simple count of transitions because of browser
+// bugs, e.g. Chrome sometimes fires both transitionend and transitioncancel rather
+// than one or the other. So we need to track what's actually transitioning so that
+// we can ignore these duplicate events.
+let $bbed8b41f857bcc0$var$transitionsByElement = new Map();
+// A list of callbacks to call once there are no transitioning elements.
+let $bbed8b41f857bcc0$var$transitionCallbacks = new Set();
+function $bbed8b41f857bcc0$var$setupGlobalEvents() {
+    if (typeof window === 'undefined') return;
+    function isTransitionEvent(event) {
+        return 'propertyName' in event;
+    }
+    let onTransitionStart = (e)=>{
+        if (!isTransitionEvent(e) || !e.target) return;
+        // Add the transitioning property to the list for this element.
+        let transitions = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+        if (!transitions) {
+            transitions = new Set();
+            $bbed8b41f857bcc0$var$transitionsByElement.set(e.target, transitions);
+            // The transitioncancel event must be registered on the element itself, rather than as a global
+            // event. This enables us to handle when the node is deleted from the document while it is transitioning.
+            // In that case, the cancel event would have nowhere to bubble to so we need to handle it directly.
+            e.target.addEventListener('transitioncancel', onTransitionEnd, {
+                once: true
+            });
+        }
+        transitions.add(e.propertyName);
+    };
+    let onTransitionEnd = (e)=>{
+        if (!isTransitionEvent(e) || !e.target) return;
+        // Remove property from list of transitioning properties.
+        let properties = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+        if (!properties) return;
+        properties.delete(e.propertyName);
+        // If empty, remove transitioncancel event, and remove the element from the list of transitioning elements.
+        if (properties.size === 0) {
+            e.target.removeEventListener('transitioncancel', onTransitionEnd);
+            $bbed8b41f857bcc0$var$transitionsByElement.delete(e.target);
+        }
+        // If no transitioning elements, call all of the queued callbacks.
+        if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) {
+            for (let cb of $bbed8b41f857bcc0$var$transitionCallbacks)cb();
+            $bbed8b41f857bcc0$var$transitionCallbacks.clear();
+        }
+    };
+    document.body.addEventListener('transitionrun', onTransitionStart);
+    document.body.addEventListener('transitionend', onTransitionEnd);
+}
+if (typeof document !== 'undefined') {
+    if (document.readyState !== 'loading') $bbed8b41f857bcc0$var$setupGlobalEvents();
+    else document.addEventListener('DOMContentLoaded', $bbed8b41f857bcc0$var$setupGlobalEvents);
+}
+/**
+ * Cleans up any elements that are no longer in the document.
+ * This is necessary because we can't rely on transitionend events to fire
+ * for elements that are removed from the document while transitioning.
+ */ function $bbed8b41f857bcc0$var$cleanupDetachedElements() {
+    for (const [eventTarget] of $bbed8b41f857bcc0$var$transitionsByElement)// Similar to `eventTarget instanceof Element && !eventTarget.isConnected`, but avoids
+    // the explicit instanceof check, since it may be different in different contexts.
+    if ('isConnected' in eventTarget && !eventTarget.isConnected) $bbed8b41f857bcc0$var$transitionsByElement.delete(eventTarget);
+}
+function $bbed8b41f857bcc0$export$24490316f764c430(fn) {
+    // Wait one frame to see if an animation starts, e.g. a transition on mount.
+    requestAnimationFrame(()=>{
+        $bbed8b41f857bcc0$var$cleanupDetachedElements();
+        // If no transitions are running, call the function immediately.
+        // Otherwise, add it to a list of callbacks to run at the end of the animation.
+        if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) fn();
+        else $bbed8b41f857bcc0$var$transitionCallbacks.add(fn);
+    });
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+function $03deb23ff14920c4$export$4eaf04e54aa8eed6() {
+    let globalListeners = (useRef)(new Map());
+    let addGlobalListener = (useCallback)((eventTarget, type, listener, options)=>{
+        // Make sure we remove the listener after it is called with the `once` option.
+        let fn = (options === null || options === void 0 ? void 0 : options.once) ? (...args)=>{
+            globalListeners.current.delete(listener);
+            listener(...args);
+        } : listener;
+        globalListeners.current.set(listener, {
+            type: type,
+            eventTarget: eventTarget,
+            fn: fn,
+            options: options
+        });
+        eventTarget.addEventListener(type, fn, options);
+    }, []);
+    let removeGlobalListener = (useCallback)((eventTarget, type, listener, options)=>{
+        var _globalListeners_current_get;
+        let fn = ((_globalListeners_current_get = globalListeners.current.get(listener)) === null || _globalListeners_current_get === void 0 ? void 0 : _globalListeners_current_get.fn) || listener;
+        eventTarget.removeEventListener(type, fn, options);
+        globalListeners.current.delete(listener);
+    }, []);
+    let removeAllGlobalListeners = (useCallback)(()=>{
+        globalListeners.current.forEach((value, key)=>{
+            removeGlobalListener(value.eventTarget, value.type, key, value.options);
+        });
+    }, [
+        removeGlobalListener
+    ]);
+    (useEffect)(()=>{
+        return removeAllGlobalListeners;
+    }, [
+        removeAllGlobalListeners
+    ]);
+    return {
+        addGlobalListener: addGlobalListener,
+        removeGlobalListener: removeGlobalListener,
+        removeAllGlobalListeners: removeAllGlobalListeners
+    };
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+function $313b98861ee5dd6c$export$d6875122194c7b44(props, defaultLabel) {
+    let { id: id, 'aria-label': label, 'aria-labelledby': labelledBy } = props;
+    // If there is both an aria-label and aria-labelledby,
+    // combine them by pointing to the element itself.
+    id = ($bdb11010cef70236$export$f680877a34711e37)(id);
+    if (labelledBy && label) {
+        let ids = new Set([
+            id,
+            ...labelledBy.trim().split(/\s+/)
+        ]);
+        labelledBy = [
+            ...ids
+        ].join(' ');
+    } else if (labelledBy) labelledBy = labelledBy.trim().split(/\s+/).join(' ');
+    // If no labels are provided, use the default
+    if (!label && !labelledBy && defaultLabel) label = defaultLabel;
+    return {
+        id: id,
+        'aria-label': label,
+        'aria-labelledby': labelledBy
+    };
+}
+
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+function $df56164dff5785e2$export$4338b53315abf666(ref) {
+    const objRef = (useRef)(null);
+    const cleanupRef = (useRef)(undefined);
+    const refEffect = (useCallback)((instance)=>{
+        if (typeof ref === 'function') {
+            const refCallback = ref;
+            const refCleanup = refCallback(instance);
+            return ()=>{
+                if (typeof refCleanup === 'function') refCleanup();
+                else refCallback(null);
+            };
+        } else if (ref) {
+            ref.current = instance;
+            return ()=>{
+                ref.current = null;
+            };
+        }
+    }, [
+        ref
+    ]);
+    return (useMemo)(()=>({
+            get current () {
+                return objRef.current;
+            },
+            set current (value){
+                objRef.current = value;
+                if (cleanupRef.current) {
+                    cleanupRef.current();
+                    cleanupRef.current = undefined;
+                }
+                if (value != null) cleanupRef.current = refEffect(value);
+            }
+        }), [
+        refEffect
+    ]);
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+function $e7801be82b4b2a53$export$4debdb1a3f0fa79e(context, ref) {
+    ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
+        if (context && context.ref && ref) {
+            context.ref.current = ref.current;
+            return ()=>{
+                if (context.ref) context.ref.current = null;
+            };
+        }
+    });
+}
+
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+function $e9faafb641e167db$export$90fc3a17d93f704c(ref, event, handler, options) {
+    let handleEvent = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)(handler);
+    let isDisabled = handler == null;
+    (useEffect)(()=>{
+        if (isDisabled || !ref.current) return;
+        let element = ref.current;
+        element.addEventListener(event, handleEvent, options);
+        return ()=>{
+            element.removeEventListener(event, handleEvent, options);
+        };
+    }, [
+        ref,
+        event,
+        options,
+        isDisabled,
+        handleEvent
+    ]);
+}
+
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+function $6a7db85432448f7f$export$60278871457622de(event) {
+    // JAWS/NVDA with Firefox.
+    if (event.pointerType === '' && event.isTrusted) return true;
+    // Android TalkBack's detail value varies depending on the event listener providing the event so we have specific logic here instead
+    // If pointerType is defined, event is from a click listener. For events from mousedown listener, detail === 0 is a sufficient check
+    // to detect TalkBack virtual clicks.
+    if (($c87311424ea30a05$export$a11b0059900ceec8)() && event.pointerType) return event.type === 'click' && event.buttons === 1;
+    return event.detail === 0 && !event.pointerType;
+}
+
 /*
  * Copyright 2023 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -48,6 +960,259 @@ function $99facab73266f662$export$5add1d006293d136(ref, initialValue, onReset) {
     ]);
 }
 
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+function $458b0a5536c1a7cf$export$40bfa8c7b0832715(value, defaultValue, onChange) {
+    let [stateValue, setStateValue] = (useState)(value || defaultValue);
+    let isControlledRef = (useRef)(value !== undefined);
+    let isControlled = value !== undefined;
+    (useEffect)(()=>{
+        let wasControlled = isControlledRef.current;
+        if (wasControlled !== isControlled && process.env.NODE_ENV !== 'production') console.warn(`WARN: A component changed from ${wasControlled ? 'controlled' : 'uncontrolled'} to ${isControlled ? 'controlled' : 'uncontrolled'}.`);
+        isControlledRef.current = isControlled;
+    }, [
+        isControlled
+    ]);
+    let currentValue = isControlled ? value : stateValue;
+    let setValue = (useCallback)((value, ...args)=>{
+        let onChangeCaller = (value, ...onChangeArgs)=>{
+            if (onChange) {
+                if (!Object.is(currentValue, value)) onChange(value, ...onChangeArgs);
+            }
+            if (!isControlled) // If uncontrolled, mutate the currentValue local variable so that
+            // calling setState multiple times with the same value only emits onChange once.
+            // We do not use a ref for this because we specifically _do_ want the value to
+            // reset every render, and assigning to a ref in render breaks aborted suspended renders.
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+            currentValue = value;
+        };
+        if (typeof value === 'function') {
+            if (process.env.NODE_ENV !== 'production') console.warn('We can not support a function callback. See Github Issues for details https://github.com/adobe/react-spectrum/issues/2320');
+            // this supports functional updates https://reactjs.org/docs/hooks-reference.html#functional-updates
+            // when someone using useControlledState calls setControlledState(myFunc)
+            // this will call our useState setState with a function as well which invokes myFunc and calls onChange with the value from myFunc
+            // if we're in an uncontrolled state, then we also return the value of myFunc which to setState looks as though it was just called with myFunc from the beginning
+            // otherwise we just return the controlled value, which won't cause a rerender because React knows to bail out when the value is the same
+            let updateFunction = (oldValue, ...functionArgs)=>{
+                let interceptedValue = value(isControlled ? currentValue : oldValue, ...functionArgs);
+                onChangeCaller(interceptedValue, ...args);
+                if (!isControlled) return interceptedValue;
+                return oldValue;
+            };
+            setStateValue(updateFunction);
+        } else {
+            if (!isControlled) setStateValue(value);
+            onChangeCaller(value, ...args);
+        }
+    }, [
+        isControlled,
+        currentValue,
+        onChange
+    ]);
+    return [
+        currentValue,
+        setValue
+    ];
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ /**
+ * Takes a value and forces it to the closest min/max if it's outside. Also forces it to the closest valid step.
+ */ function $9446cca9a3875146$export$7d15b64cf5a3a4c4(value, min = -Infinity, max = Infinity) {
+    let newValue = Math.min(Math.max(value, min), max);
+    return newValue;
+}
+function $9446cca9a3875146$export$e1a7b8e69ef6c52f(value, step) {
+    let roundedValue = value;
+    let precision = 0;
+    let stepString = step.toString();
+    // Handle negative exponents in exponential notation (e.g., "1e-7" → precision 8)
+    let eIndex = stepString.toLowerCase().indexOf('e-');
+    if (eIndex > 0) precision = Math.abs(Math.floor(Math.log10(Math.abs(step)))) + eIndex;
+    else {
+        let pointIndex = stepString.indexOf('.');
+        if (pointIndex >= 0) precision = stepString.length - pointIndex;
+    }
+    if (precision > 0) {
+        let pow = Math.pow(10, precision);
+        roundedValue = Math.round(roundedValue * pow) / pow;
+    }
+    return roundedValue;
+}
+function $9446cca9a3875146$export$cb6e0bb50bc19463(value, min, max, step) {
+    min = Number(min);
+    max = Number(max);
+    let remainder = (value - (isNaN(min) ? 0 : min)) % step;
+    let snappedValue = $9446cca9a3875146$export$e1a7b8e69ef6c52f(Math.abs(remainder) * 2 >= step ? value + Math.sign(remainder) * (step - Math.abs(remainder)) : value - remainder, step);
+    if (!isNaN(min)) {
+        if (snappedValue < min) snappedValue = min;
+        else if (!isNaN(max) && snappedValue > max) snappedValue = min + Math.floor($9446cca9a3875146$export$e1a7b8e69ef6c52f((max - min) / step, step)) * step;
+    } else if (!isNaN(max) && snappedValue > max) snappedValue = Math.floor($9446cca9a3875146$export$e1a7b8e69ef6c52f(max / step, step)) * step;
+    // correct floating point behavior by rounding to step precision
+    snappedValue = $9446cca9a3875146$export$e1a7b8e69ef6c52f(snappedValue, step);
+    return snappedValue;
+}
+
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+const $64fa3d84918910a7$export$c62b8e45d58ddad9 = Symbol('default');
+function $64fa3d84918910a7$export$2881499e37b75b9a({ values: values, children: children }) {
+    for (let [Context, value] of values)// @ts-ignore
+    children = /*#__PURE__*/ (React__default).createElement(Context.Provider, {
+        value: value
+    }, children);
+    return children;
+}
+function $64fa3d84918910a7$export$4d86445c2cf5e3(props) {
+    let { className: className, style: style, children: children, defaultClassName: defaultClassName, defaultChildren: defaultChildren, defaultStyle: defaultStyle, values: values } = props;
+    return (useMemo)(()=>{
+        let computedClassName;
+        let computedStyle;
+        let computedChildren;
+        if (typeof className === 'function') computedClassName = className({
+            ...values,
+            defaultClassName: defaultClassName
+        });
+        else computedClassName = className;
+        if (typeof style === 'function') computedStyle = style({
+            ...values,
+            defaultStyle: defaultStyle || {}
+        });
+        else computedStyle = style;
+        if (typeof children === 'function') computedChildren = children({
+            ...values,
+            defaultChildren: defaultChildren
+        });
+        else if (children == null) computedChildren = defaultChildren;
+        else computedChildren = children;
+        return {
+            className: computedClassName !== null && computedClassName !== void 0 ? computedClassName : defaultClassName,
+            style: computedStyle || defaultStyle ? {
+                ...defaultStyle,
+                ...computedStyle
+            } : undefined,
+            children: computedChildren !== null && computedChildren !== void 0 ? computedChildren : defaultChildren,
+            'data-rac': ''
+        };
+    }, [
+        className,
+        style,
+        children,
+        defaultClassName,
+        defaultChildren,
+        defaultStyle,
+        values
+    ]);
+}
+function $64fa3d84918910a7$export$fabf2dc03a41866e(context, slot) {
+    let ctx = (useContext)(context);
+    if (slot === null) // An explicit `null` slot means don't use context.
+    return null;
+    if (ctx && typeof ctx === 'object' && 'slots' in ctx && ctx.slots) {
+        let slotKey = slot || $64fa3d84918910a7$export$c62b8e45d58ddad9;
+        if (!ctx.slots[slotKey]) {
+            let availableSlots = new Intl.ListFormat().format(Object.keys(ctx.slots).map((p)=>`"${p}"`));
+            let errorMessage = slot ? `Invalid slot "${slot}".` : 'A slot prop is required.';
+            throw new Error(`${errorMessage} Valid slot names are ${availableSlots}.`);
+        }
+        return ctx.slots[slotKey];
+    }
+    // @ts-ignore
+    return ctx;
+}
+function $64fa3d84918910a7$export$29f1550f4b0d4415(props, ref, context) {
+    let ctx = $64fa3d84918910a7$export$fabf2dc03a41866e(context, props.slot) || {};
+    // @ts-ignore - TS says "Type 'unique symbol' cannot be used as an index type." but not sure why.
+    let { ref: contextRef, ...contextProps } = ctx;
+    let mergedRef = ($df56164dff5785e2$export$4338b53315abf666)((useMemo)(()=>($5dc95899b306f630$export$c9058316764c140e)(ref, contextRef), [
+        ref,
+        contextRef
+    ]));
+    let mergedProps = ($3ef42575df84b30b$export$9d1611c77c2fe928)(contextProps, props);
+    // mergeProps does not merge `style`. Adding this there might be a breaking change.
+    if ('style' in contextProps && contextProps.style && 'style' in props && props.style) {
+        if (typeof contextProps.style === 'function' || typeof props.style === 'function') // @ts-ignore
+        mergedProps.style = (renderProps)=>{
+            let contextStyle = typeof contextProps.style === 'function' ? contextProps.style(renderProps) : contextProps.style;
+            let defaultStyle = {
+                ...renderProps.defaultStyle,
+                ...contextStyle
+            };
+            let style = typeof props.style === 'function' ? props.style({
+                ...renderProps,
+                defaultStyle: defaultStyle
+            }) : props.style;
+            return {
+                ...defaultStyle,
+                ...style
+            };
+        };
+        else // @ts-ignore
+        mergedProps.style = {
+            ...contextProps.style,
+            ...props.style
+        };
+    }
+    return [
+        mergedProps,
+        mergedRef
+    ];
+}
+function $64fa3d84918910a7$export$9d4c57ee4c6ffdd8(initialState = true) {
+    // Initial state is typically based on the parent having an aria-label or aria-labelledby.
+    // If it does, this value should be false so that we don't update the state and cause a rerender when we go through the layoutEffect
+    let [hasSlot, setHasSlot] = (useState)(initialState);
+    let hasRun = (useRef)(false);
+    // A callback ref which will run when the slotted element mounts.
+    // This should happen before the useLayoutEffect below.
+    let ref = (useCallback)((el)=>{
+        hasRun.current = true;
+        setHasSlot(!!el);
+    }, []);
+    // If the callback hasn't been called, then reset to false.
+    ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
+        if (!hasRun.current) setHasSlot(false);
+    }, []);
+    return [
+        ref,
+        hasSlot
+    ];
+}
+function $64fa3d84918910a7$export$ef03459518577ad4(props) {
+    const prefix = /^(data-.*)$/;
+    let filteredProps = {};
+    for(const prop in props)if (!prefix.test(prop)) filteredProps[prop] = props[prop];
+    return filteredProps;
+}
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -151,6 +1316,300 @@ class $319e236875307eab$var$LiveAnnouncer {
     }
 }
 
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // https://en.wikipedia.org/wiki/Right-to-left
+const $148a7a147e38ea7f$var$RTL_SCRIPTS = new Set([
+    'Arab',
+    'Syrc',
+    'Samr',
+    'Mand',
+    'Thaa',
+    'Mend',
+    'Nkoo',
+    'Adlm',
+    'Rohg',
+    'Hebr'
+]);
+const $148a7a147e38ea7f$var$RTL_LANGS = new Set([
+    'ae',
+    'ar',
+    'arc',
+    'bcc',
+    'bqi',
+    'ckb',
+    'dv',
+    'fa',
+    'glk',
+    'he',
+    'ku',
+    'mzn',
+    'nqo',
+    'pnb',
+    'ps',
+    'sd',
+    'ug',
+    'ur',
+    'yi'
+]);
+function $148a7a147e38ea7f$export$702d680b21cbd764(localeString) {
+    // If the Intl.Locale API is available, use it to get the locale's text direction.
+    if (Intl.Locale) {
+        let locale = new Intl.Locale(localeString).maximize();
+        // Use the text info object to get the direction if possible.
+        // @ts-ignore - this was implemented as a property by some browsers before it was standardized as a function.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getTextInfo
+        let textInfo = typeof locale.getTextInfo === 'function' ? locale.getTextInfo() : locale.textInfo;
+        if (textInfo) return textInfo.direction === 'rtl';
+        // Fallback: guess using the script.
+        // This is more accurate than guessing by language, since languages can be written in multiple scripts.
+        if (locale.script) return $148a7a147e38ea7f$var$RTL_SCRIPTS.has(locale.script);
+    }
+    // If not, just guess by the language (first part of the locale)
+    let lang = localeString.split('-')[0];
+    return $148a7a147e38ea7f$var$RTL_LANGS.has(lang);
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+// Locale passed from server by PackageLocalizationProvider.
+const $1e5a04cdaf7d1af8$var$localeSymbol = Symbol.for('react-aria.i18n.locale');
+function $1e5a04cdaf7d1af8$export$f09106e7c6677ec5() {
+    let locale = typeof window !== 'undefined' && window[$1e5a04cdaf7d1af8$var$localeSymbol] || typeof navigator !== 'undefined' && (navigator.language || navigator.userLanguage) || 'en-US';
+    try {
+        Intl.DateTimeFormat.supportedLocalesOf([
+            locale
+        ]);
+    } catch  {
+        locale = 'en-US';
+    }
+    return {
+        locale: locale,
+        direction: ($148a7a147e38ea7f$export$702d680b21cbd764)(locale) ? 'rtl' : 'ltr'
+    };
+}
+let $1e5a04cdaf7d1af8$var$currentLocale = $1e5a04cdaf7d1af8$export$f09106e7c6677ec5();
+let $1e5a04cdaf7d1af8$var$listeners = new Set();
+function $1e5a04cdaf7d1af8$var$updateLocale() {
+    $1e5a04cdaf7d1af8$var$currentLocale = $1e5a04cdaf7d1af8$export$f09106e7c6677ec5();
+    for (let listener of $1e5a04cdaf7d1af8$var$listeners)listener($1e5a04cdaf7d1af8$var$currentLocale);
+}
+function $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a() {
+    let isSSR = ($b5e257d569688ac6$export$535bd6ca7f90a273)();
+    let [defaultLocale, setDefaultLocale] = (useState)($1e5a04cdaf7d1af8$var$currentLocale);
+    (useEffect)(()=>{
+        if ($1e5a04cdaf7d1af8$var$listeners.size === 0) window.addEventListener('languagechange', $1e5a04cdaf7d1af8$var$updateLocale);
+        $1e5a04cdaf7d1af8$var$listeners.add(setDefaultLocale);
+        return ()=>{
+            $1e5a04cdaf7d1af8$var$listeners.delete(setDefaultLocale);
+            if ($1e5a04cdaf7d1af8$var$listeners.size === 0) window.removeEventListener('languagechange', $1e5a04cdaf7d1af8$var$updateLocale);
+        };
+    }, []);
+    // We cannot determine the browser's language on the server, so default to
+    // en-US. This will be updated after hydration on the client to the correct value.
+    if (isSSR) return {
+        locale: 'en-US',
+        direction: 'ltr'
+    };
+    return defaultLocale;
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+const $18f2051aff69b9bf$var$I18nContext = /*#__PURE__*/ (React__default).createContext(null);
+function $18f2051aff69b9bf$export$43bb16f9c6d9e3f7() {
+    let defaultLocale = ($1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a)();
+    let context = (useContext)($18f2051aff69b9bf$var$I18nContext);
+    return context || defaultLocale;
+}
+
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ const $5b160d28a433310d$var$localeSymbol = Symbol.for('react-aria.i18n.locale');
+const $5b160d28a433310d$var$stringsSymbol = Symbol.for('react-aria.i18n.strings');
+let $5b160d28a433310d$var$cachedGlobalStrings = undefined;
+class $5b160d28a433310d$export$c17fa47878dc55b6 {
+    /** Returns a localized string for the given key and locale. */ getStringForLocale(key, locale) {
+        let strings = this.getStringsForLocale(locale);
+        let string = strings[key];
+        if (!string) throw new Error(`Could not find intl message ${key} in ${locale} locale`);
+        return string;
+    }
+    /** Returns all localized strings for the given locale. */ getStringsForLocale(locale) {
+        let strings = this.strings[locale];
+        if (!strings) {
+            strings = $5b160d28a433310d$var$getStringsForLocale(locale, this.strings, this.defaultLocale);
+            this.strings[locale] = strings;
+        }
+        return strings;
+    }
+    static getGlobalDictionaryForPackage(packageName) {
+        if (typeof window === 'undefined') return null;
+        let locale = window[$5b160d28a433310d$var$localeSymbol];
+        if ($5b160d28a433310d$var$cachedGlobalStrings === undefined) {
+            let globalStrings = window[$5b160d28a433310d$var$stringsSymbol];
+            if (!globalStrings) return null;
+            $5b160d28a433310d$var$cachedGlobalStrings = {};
+            for(let pkg in globalStrings)$5b160d28a433310d$var$cachedGlobalStrings[pkg] = new $5b160d28a433310d$export$c17fa47878dc55b6({
+                [locale]: globalStrings[pkg]
+            }, locale);
+        }
+        let dictionary = $5b160d28a433310d$var$cachedGlobalStrings === null || $5b160d28a433310d$var$cachedGlobalStrings === void 0 ? void 0 : $5b160d28a433310d$var$cachedGlobalStrings[packageName];
+        if (!dictionary) throw new Error(`Strings for package "${packageName}" were not included by LocalizedStringProvider. Please add it to the list passed to createLocalizedStringDictionary.`);
+        return dictionary;
+    }
+    constructor(messages, defaultLocale = 'en-US'){
+        // Clone messages so we don't modify the original object.
+        // Filter out entries with falsy values which may have been caused by applying optimize-locales-plugin.
+        this.strings = Object.fromEntries(Object.entries(messages).filter(([, v])=>v));
+        this.defaultLocale = defaultLocale;
+    }
+}
+function $5b160d28a433310d$var$getStringsForLocale(locale, strings, defaultLocale = 'en-US') {
+    // If there is an exact match, use it.
+    if (strings[locale]) return strings[locale];
+    // Attempt to find the closest match by language.
+    // For example, if the locale is fr-CA (French Canadian), but there is only
+    // an fr-FR (France) set of strings, use that.
+    // This could be replaced with Intl.LocaleMatcher once it is supported.
+    // https://github.com/tc39/proposal-intl-localematcher
+    let language = $5b160d28a433310d$var$getLanguage(locale);
+    if (strings[language]) return strings[language];
+    for(let key in strings){
+        if (key.startsWith(language + '-')) return strings[key];
+    }
+    // Nothing close, use english.
+    return strings[defaultLocale];
+}
+function $5b160d28a433310d$var$getLanguage(locale) {
+    // @ts-ignore
+    if (Intl.Locale) // @ts-ignore
+    return new Intl.Locale(locale).language;
+    return locale.split('-')[0];
+}
+
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ const $6db58dc88e78b024$var$pluralRulesCache = new Map();
+const $6db58dc88e78b024$var$numberFormatCache = new Map();
+class $6db58dc88e78b024$export$2f817fcdc4b89ae0 {
+    /** Formats a localized string for the given key with the provided variables. */ format(key, variables) {
+        let message = this.strings.getStringForLocale(key, this.locale);
+        return typeof message === 'function' ? message(variables, this) : message;
+    }
+    plural(count, options, type = 'cardinal') {
+        let opt = options['=' + count];
+        if (opt) return typeof opt === 'function' ? opt() : opt;
+        let key = this.locale + ':' + type;
+        let pluralRules = $6db58dc88e78b024$var$pluralRulesCache.get(key);
+        if (!pluralRules) {
+            pluralRules = new Intl.PluralRules(this.locale, {
+                type: type
+            });
+            $6db58dc88e78b024$var$pluralRulesCache.set(key, pluralRules);
+        }
+        let selected = pluralRules.select(count);
+        opt = options[selected] || options.other;
+        return typeof opt === 'function' ? opt() : opt;
+    }
+    number(value) {
+        let numberFormat = $6db58dc88e78b024$var$numberFormatCache.get(this.locale);
+        if (!numberFormat) {
+            numberFormat = new Intl.NumberFormat(this.locale);
+            $6db58dc88e78b024$var$numberFormatCache.set(this.locale, numberFormat);
+        }
+        return numberFormat.format(value);
+    }
+    select(options, value) {
+        let opt = options[value] || options.other;
+        return typeof opt === 'function' ? opt() : opt;
+    }
+    constructor(locale, strings){
+        this.locale = locale;
+        this.strings = strings;
+    }
+}
+
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+const $fca6afa0e843324b$var$cache = new WeakMap();
+function $fca6afa0e843324b$var$getCachedDictionary(strings) {
+    let dictionary = $fca6afa0e843324b$var$cache.get(strings);
+    if (!dictionary) {
+        dictionary = new ($5b160d28a433310d$export$c17fa47878dc55b6)(strings);
+        $fca6afa0e843324b$var$cache.set(strings, dictionary);
+    }
+    return dictionary;
+}
+function $fca6afa0e843324b$export$87b761675e8eaa10(strings, packageName) {
+    return packageName && ($5b160d28a433310d$export$c17fa47878dc55b6).getGlobalDictionaryForPackage(packageName) || $fca6afa0e843324b$var$getCachedDictionary(strings);
+}
+function $fca6afa0e843324b$export$f12b703ca79dfbb1(strings, packageName) {
+    let { locale: locale } = ($18f2051aff69b9bf$export$43bb16f9c6d9e3f7)();
+    let dictionary = $fca6afa0e843324b$export$87b761675e8eaa10(strings, packageName);
+    return (useMemo)(()=>new ($6db58dc88e78b024$export$2f817fcdc4b89ae0)(locale, dictionary), [
+        locale,
+        dictionary
+    ]);
+}
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -464,108 +1923,574 @@ class $6c7bd7858deea686$var$NumberParserImpl {
             else if (options.minimumFractionDigits == null) options.minimumFractionDigits = options.maximumFractionDigits;
         // if both are specified, let the normal Range Error be thrown
         }
-        this.formatter = new Intl.NumberFormat(locale, options);
-        this.options = this.formatter.resolvedOptions();
-        this.symbols = $6c7bd7858deea686$var$getSymbols(locale, this.formatter, this.options, options);
-        var _this_options_minimumFractionDigits, _this_options_maximumFractionDigits;
-        if (this.options.style === 'percent' && (((_this_options_minimumFractionDigits = this.options.minimumFractionDigits) !== null && _this_options_minimumFractionDigits !== void 0 ? _this_options_minimumFractionDigits : 0) > 18 || ((_this_options_maximumFractionDigits = this.options.maximumFractionDigits) !== null && _this_options_maximumFractionDigits !== void 0 ? _this_options_maximumFractionDigits : 0) > 18)) console.warn('NumberParser cannot handle percentages with greater than 18 decimal places, please reduce the number in your options.');
-    }
-}
-const $6c7bd7858deea686$var$nonLiteralParts = new Set([
-    'decimal',
-    'fraction',
-    'integer',
-    'minusSign',
-    'plusSign',
-    'group'
-]);
-// This list is derived from https://www.unicode.org/cldr/charts/43/supplemental/language_plural_rules.html#comparison and includes
-// all unique numbers which we need to check in order to determine all the plural forms for a given locale.
-// See: https://github.com/adobe/react-spectrum/pull/5134/files#r1337037855 for used script
-const $6c7bd7858deea686$var$pluralNumbers = [
-    0,
-    4,
-    2,
-    1,
-    11,
-    20,
-    3,
-    7,
-    100,
-    21,
-    0.1,
-    1.1
-];
-function $6c7bd7858deea686$var$getSymbols(locale, formatter, intlOptions, originalOptions) {
-    var _allParts_find, _posAllParts_find, _decimalParts_find, _allParts_find1;
-    // formatter needs access to all decimal places in order to generate the correct literal strings for the plural set
-    let symbolFormatter = new Intl.NumberFormat(locale, {
-        ...intlOptions,
-        // Resets so we get the full range of symbols
-        minimumSignificantDigits: 1,
-        maximumSignificantDigits: 21,
-        roundingIncrement: 1,
-        roundingPriority: 'auto',
-        roundingMode: 'halfExpand'
-    });
-    // Note: some locale's don't add a group symbol until there is a ten thousands place
-    let allParts = symbolFormatter.formatToParts(-10000.111);
-    let posAllParts = symbolFormatter.formatToParts(10000.111);
-    let pluralParts = $6c7bd7858deea686$var$pluralNumbers.map((n)=>symbolFormatter.formatToParts(n));
-    var _allParts_find_value;
-    let minusSign = (_allParts_find_value = (_allParts_find = allParts.find((p)=>p.type === 'minusSign')) === null || _allParts_find === void 0 ? void 0 : _allParts_find.value) !== null && _allParts_find_value !== void 0 ? _allParts_find_value : '-';
-    let plusSign = (_posAllParts_find = posAllParts.find((p)=>p.type === 'plusSign')) === null || _posAllParts_find === void 0 ? void 0 : _posAllParts_find.value;
-    // Safari does not support the signDisplay option, but our number parser polyfills it.
-    // If no plus sign was returned, but the original options contained signDisplay, default to the '+' character.
-    if (!plusSign && ((originalOptions === null || originalOptions === void 0 ? void 0 : originalOptions.signDisplay) === 'exceptZero' || (originalOptions === null || originalOptions === void 0 ? void 0 : originalOptions.signDisplay) === 'always')) plusSign = '+';
-    // If maximumSignificantDigits is 1 (the minimum) then we won't get decimal characters out of the above formatters
-    // Percent also defaults to 0 fractionDigits, so we need to make a new one that isn't percent to get an accurate decimal
-    let decimalParts = new Intl.NumberFormat(locale, {
-        ...intlOptions,
-        minimumFractionDigits: 2,
-        maximumFractionDigits: 2
-    }).formatToParts(0.001);
-    let decimal = (_decimalParts_find = decimalParts.find((p)=>p.type === 'decimal')) === null || _decimalParts_find === void 0 ? void 0 : _decimalParts_find.value;
-    let group = (_allParts_find1 = allParts.find((p)=>p.type === 'group')) === null || _allParts_find1 === void 0 ? void 0 : _allParts_find1.value;
-    // this set is also for a regex, it's all literals that might be in the string we want to eventually parse that
-    // don't contribute to the numerical value
-    let allPartsLiterals = allParts.filter((p)=>!$6c7bd7858deea686$var$nonLiteralParts.has(p.type)).map((p)=>$6c7bd7858deea686$var$escapeRegex(p.value));
-    let pluralPartsLiterals = pluralParts.flatMap((p)=>p.filter((p)=>!$6c7bd7858deea686$var$nonLiteralParts.has(p.type)).map((p)=>$6c7bd7858deea686$var$escapeRegex(p.value)));
-    let sortedLiterals = [
-        ...new Set([
-            ...allPartsLiterals,
-            ...pluralPartsLiterals
-        ])
-    ].sort((a, b)=>b.length - a.length);
-    let literals = sortedLiterals.length === 0 ? new RegExp('[\\p{White_Space}]', 'gu') : new RegExp(`${sortedLiterals.join('|')}|[\\p{White_Space}]`, 'gu');
-    // These are for replacing non-latn characters with the latn equivalent
-    let numerals = [
-        ...new Intl.NumberFormat(intlOptions.locale, {
-            useGrouping: false
-        }).format(9876543210)
-    ].reverse();
-    let indexes = new Map(numerals.map((d, i)=>[
-            d,
-            i
-        ]));
-    let numeral = new RegExp(`[${numerals.join('')}]`, 'g');
-    let index = (d)=>String(indexes.get(d));
+        this.formatter = new Intl.NumberFormat(locale, options);
+        this.options = this.formatter.resolvedOptions();
+        this.symbols = $6c7bd7858deea686$var$getSymbols(locale, this.formatter, this.options, options);
+        var _this_options_minimumFractionDigits, _this_options_maximumFractionDigits;
+        if (this.options.style === 'percent' && (((_this_options_minimumFractionDigits = this.options.minimumFractionDigits) !== null && _this_options_minimumFractionDigits !== void 0 ? _this_options_minimumFractionDigits : 0) > 18 || ((_this_options_maximumFractionDigits = this.options.maximumFractionDigits) !== null && _this_options_maximumFractionDigits !== void 0 ? _this_options_maximumFractionDigits : 0) > 18)) console.warn('NumberParser cannot handle percentages with greater than 18 decimal places, please reduce the number in your options.');
+    }
+}
+const $6c7bd7858deea686$var$nonLiteralParts = new Set([
+    'decimal',
+    'fraction',
+    'integer',
+    'minusSign',
+    'plusSign',
+    'group'
+]);
+// This list is derived from https://www.unicode.org/cldr/charts/43/supplemental/language_plural_rules.html#comparison and includes
+// all unique numbers which we need to check in order to determine all the plural forms for a given locale.
+// See: https://github.com/adobe/react-spectrum/pull/5134/files#r1337037855 for used script
+const $6c7bd7858deea686$var$pluralNumbers = [
+    0,
+    4,
+    2,
+    1,
+    11,
+    20,
+    3,
+    7,
+    100,
+    21,
+    0.1,
+    1.1
+];
+function $6c7bd7858deea686$var$getSymbols(locale, formatter, intlOptions, originalOptions) {
+    var _allParts_find, _posAllParts_find, _decimalParts_find, _allParts_find1;
+    // formatter needs access to all decimal places in order to generate the correct literal strings for the plural set
+    let symbolFormatter = new Intl.NumberFormat(locale, {
+        ...intlOptions,
+        // Resets so we get the full range of symbols
+        minimumSignificantDigits: 1,
+        maximumSignificantDigits: 21,
+        roundingIncrement: 1,
+        roundingPriority: 'auto',
+        roundingMode: 'halfExpand'
+    });
+    // Note: some locale's don't add a group symbol until there is a ten thousands place
+    let allParts = symbolFormatter.formatToParts(-10000.111);
+    let posAllParts = symbolFormatter.formatToParts(10000.111);
+    let pluralParts = $6c7bd7858deea686$var$pluralNumbers.map((n)=>symbolFormatter.formatToParts(n));
+    var _allParts_find_value;
+    let minusSign = (_allParts_find_value = (_allParts_find = allParts.find((p)=>p.type === 'minusSign')) === null || _allParts_find === void 0 ? void 0 : _allParts_find.value) !== null && _allParts_find_value !== void 0 ? _allParts_find_value : '-';
+    let plusSign = (_posAllParts_find = posAllParts.find((p)=>p.type === 'plusSign')) === null || _posAllParts_find === void 0 ? void 0 : _posAllParts_find.value;
+    // Safari does not support the signDisplay option, but our number parser polyfills it.
+    // If no plus sign was returned, but the original options contained signDisplay, default to the '+' character.
+    if (!plusSign && ((originalOptions === null || originalOptions === void 0 ? void 0 : originalOptions.signDisplay) === 'exceptZero' || (originalOptions === null || originalOptions === void 0 ? void 0 : originalOptions.signDisplay) === 'always')) plusSign = '+';
+    // If maximumSignificantDigits is 1 (the minimum) then we won't get decimal characters out of the above formatters
+    // Percent also defaults to 0 fractionDigits, so we need to make a new one that isn't percent to get an accurate decimal
+    let decimalParts = new Intl.NumberFormat(locale, {
+        ...intlOptions,
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2
+    }).formatToParts(0.001);
+    let decimal = (_decimalParts_find = decimalParts.find((p)=>p.type === 'decimal')) === null || _decimalParts_find === void 0 ? void 0 : _decimalParts_find.value;
+    let group = (_allParts_find1 = allParts.find((p)=>p.type === 'group')) === null || _allParts_find1 === void 0 ? void 0 : _allParts_find1.value;
+    // this set is also for a regex, it's all literals that might be in the string we want to eventually parse that
+    // don't contribute to the numerical value
+    let allPartsLiterals = allParts.filter((p)=>!$6c7bd7858deea686$var$nonLiteralParts.has(p.type)).map((p)=>$6c7bd7858deea686$var$escapeRegex(p.value));
+    let pluralPartsLiterals = pluralParts.flatMap((p)=>p.filter((p)=>!$6c7bd7858deea686$var$nonLiteralParts.has(p.type)).map((p)=>$6c7bd7858deea686$var$escapeRegex(p.value)));
+    let sortedLiterals = [
+        ...new Set([
+            ...allPartsLiterals,
+            ...pluralPartsLiterals
+        ])
+    ].sort((a, b)=>b.length - a.length);
+    let literals = sortedLiterals.length === 0 ? new RegExp('[\\p{White_Space}]', 'gu') : new RegExp(`${sortedLiterals.join('|')}|[\\p{White_Space}]`, 'gu');
+    // These are for replacing non-latn characters with the latn equivalent
+    let numerals = [
+        ...new Intl.NumberFormat(intlOptions.locale, {
+            useGrouping: false
+        }).format(9876543210)
+    ].reverse();
+    let indexes = new Map(numerals.map((d, i)=>[
+            d,
+            i
+        ]));
+    let numeral = new RegExp(`[${numerals.join('')}]`, 'g');
+    let index = (d)=>String(indexes.get(d));
+    return {
+        minusSign: minusSign,
+        plusSign: plusSign,
+        decimal: decimal,
+        group: group,
+        literals: literals,
+        numeral: numeral,
+        index: index
+    };
+}
+function $6c7bd7858deea686$var$replaceAll(str, find, replace) {
+    if (str.replaceAll) return str.replaceAll(find, replace);
+    return str.split(find).join(replace);
+}
+function $6c7bd7858deea686$var$escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+function $a916eb452884faea$export$b7a616150fdb9f44(options = {}) {
+    let { locale: locale } = ($18f2051aff69b9bf$export$43bb16f9c6d9e3f7)();
+    return (useMemo)(()=>new ($488c6ddbf4ef74c2$export$cc77c4ff7e8673c5)(locale, options), [
+        locale,
+        options
+    ]);
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+function $8a9cb279dc87e130$export$525bc4921d56d4a(nativeEvent) {
+    let event = nativeEvent;
+    event.nativeEvent = nativeEvent;
+    event.isDefaultPrevented = ()=>event.defaultPrevented;
+    // cancelBubble is technically deprecated in the spec, but still supported in all browsers.
+    event.isPropagationStopped = ()=>event.cancelBubble;
+    event.persist = ()=>{};
+    return event;
+}
+function $8a9cb279dc87e130$export$c2b7abe5d61ec696(event, target) {
+    Object.defineProperty(event, 'target', {
+        value: target
+    });
+    Object.defineProperty(event, 'currentTarget', {
+        value: target
+    });
+}
+function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
+    let stateRef = (useRef)({
+        isFocused: false,
+        observer: null
+    });
+    // Clean up MutationObserver on unmount. See below.
+    ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
+        const state = stateRef.current;
+        return ()=>{
+            if (state.observer) {
+                state.observer.disconnect();
+                state.observer = null;
+            }
+        };
+    }, []);
+    let dispatchBlur = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)((e)=>{
+        onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
+    });
+    // This function is called during a React onFocus event.
+    return (useCallback)((e)=>{
+        // React does not fire onBlur when an element is disabled. https://github.com/facebook/react/issues/9142
+        // Most browsers fire a native focusout event in this case, except for Firefox. In that case, we use a
+        // MutationObserver to watch for the disabled attribute, and dispatch these events ourselves.
+        // For browsers that do, focusout fires before the MutationObserver, so onBlur should not fire twice.
+        if (e.target instanceof HTMLButtonElement || e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement || e.target instanceof HTMLSelectElement) {
+            stateRef.current.isFocused = true;
+            let target = e.target;
+            let onBlurHandler = (e)=>{
+                stateRef.current.isFocused = false;
+                if (target.disabled) {
+                    // For backward compatibility, dispatch a (fake) React synthetic event.
+                    let event = $8a9cb279dc87e130$export$525bc4921d56d4a(e);
+                    dispatchBlur(event);
+                }
+                // We no longer need the MutationObserver once the target is blurred.
+                if (stateRef.current.observer) {
+                    stateRef.current.observer.disconnect();
+                    stateRef.current.observer = null;
+                }
+            };
+            target.addEventListener('focusout', onBlurHandler, {
+                once: true
+            });
+            stateRef.current.observer = new MutationObserver(()=>{
+                if (stateRef.current.isFocused && target.disabled) {
+                    var _stateRef_current_observer;
+                    (_stateRef_current_observer = stateRef.current.observer) === null || _stateRef_current_observer === void 0 ? void 0 : _stateRef_current_observer.disconnect();
+                    let relatedTargetEl = target === document.activeElement ? null : document.activeElement;
+                    target.dispatchEvent(new FocusEvent('blur', {
+                        relatedTarget: relatedTargetEl
+                    }));
+                    target.dispatchEvent(new FocusEvent('focusout', {
+                        bubbles: true,
+                        relatedTarget: relatedTargetEl
+                    }));
+                }
+            });
+            stateRef.current.observer.observe(target, {
+                attributes: true,
+                attributeFilter: [
+                    'disabled'
+                ]
+            });
+        }
+    }, [
+        dispatchBlur
+    ]);
+}
+let $8a9cb279dc87e130$export$fda7da73ab5d4c48 = false;
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // Portions of the code in this file are based on code from react.
+// Original licensing for the following can be found in the
+// NOTICE file in the root directory of this source tree.
+// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions
+
+
+
+
+let $507fabe10e71c6fb$var$currentModality = null;
+let $507fabe10e71c6fb$var$changeHandlers = new Set();
+let $507fabe10e71c6fb$export$d90243b58daecda7 = new Map(); // We use a map here to support setting event listeners across multiple document objects.
+let $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+let $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;
+// Only Tab or Esc keys will make focus visible on text input elements
+const $507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS = {
+    Tab: true,
+    Escape: true
+};
+function $507fabe10e71c6fb$var$triggerChangeHandlers(modality, e) {
+    for (let handler of $507fabe10e71c6fb$var$changeHandlers)handler(modality, e);
+}
+/**
+ * Helper function to determine if a KeyboardEvent is unmodified and could make keyboard focus styles visible.
+ */ function $507fabe10e71c6fb$var$isValidKey(e) {
+    // Control and Shift keys trigger when navigating back to the tab with keyboard.
+    return !(e.metaKey || !($c87311424ea30a05$export$9ac100e40613ea10)() && e.altKey || e.ctrlKey || e.key === 'Control' || e.key === 'Shift' || e.key === 'Meta');
+}
+function $507fabe10e71c6fb$var$handleKeyboardEvent(e) {
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+    if ($507fabe10e71c6fb$var$isValidKey(e)) {
+        $507fabe10e71c6fb$var$currentModality = 'keyboard';
+        $507fabe10e71c6fb$var$triggerChangeHandlers('keyboard', e);
+    }
+}
+function $507fabe10e71c6fb$var$handlePointerEvent(e) {
+    $507fabe10e71c6fb$var$currentModality = 'pointer';
+    if (e.type === 'mousedown' || e.type === 'pointerdown') {
+        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+        $507fabe10e71c6fb$var$triggerChangeHandlers('pointer', e);
+    }
+}
+function $507fabe10e71c6fb$var$handleClickEvent(e) {
+    if (($6a7db85432448f7f$export$60278871457622de)(e)) {
+        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+        $507fabe10e71c6fb$var$currentModality = 'virtual';
+    }
+}
+function $507fabe10e71c6fb$var$handleFocusEvent(e) {
+    // Firefox fires two extra focus events when the user first clicks into an iframe:
+    // first on the window, then on the document. We ignore these events so they don't
+    // cause keyboard focus rings to appear.
+    if (e.target === window || e.target === document || ($8a9cb279dc87e130$export$fda7da73ab5d4c48) || !e.isTrusted) return;
+    // If a focus event occurs without a preceding keyboard or pointer event, switch to virtual modality.
+    // This occurs, for example, when navigating a form with the next/previous buttons on iOS.
+    if (!$507fabe10e71c6fb$var$hasEventBeforeFocus && !$507fabe10e71c6fb$var$hasBlurredWindowRecently) {
+        $507fabe10e71c6fb$var$currentModality = 'virtual';
+        $507fabe10e71c6fb$var$triggerChangeHandlers('virtual', e);
+    }
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+    $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;
+}
+function $507fabe10e71c6fb$var$handleWindowBlur() {
+    // When the window is blurred, reset state. This is necessary when tabbing out of the window,
+    // for example, since a subsequent focus event won't be fired.
+    $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
+    $507fabe10e71c6fb$var$hasBlurredWindowRecently = true;
+}
+/**
+ * Setup global event listeners to control when keyboard focus style should be visible.
+ */ function $507fabe10e71c6fb$var$setupGlobalFocusEvents(element) {
+    if (typeof window === 'undefined' || typeof document === 'undefined' || $507fabe10e71c6fb$export$d90243b58daecda7.get(($431fbd86ca7dc216$export$f21a1ffae260145a)(element))) return;
+    const windowObject = ($431fbd86ca7dc216$export$f21a1ffae260145a)(element);
+    const documentObject = ($431fbd86ca7dc216$export$b204af158042fbac)(element);
+    // Programmatic focus() calls shouldn't affect the current input modality.
+    // However, we need to detect other cases when a focus event occurs without
+    // a preceding user event (e.g. screen reader focus). Overriding the focus
+    // method on HTMLElement.prototype is a bit hacky, but works.
+    let focus = windowObject.HTMLElement.prototype.focus;
+    windowObject.HTMLElement.prototype.focus = function() {
+        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
+        focus.apply(this, arguments);
+    };
+    documentObject.addEventListener('keydown', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+    documentObject.addEventListener('keyup', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+    documentObject.addEventListener('click', $507fabe10e71c6fb$var$handleClickEvent, true);
+    // Register focus events on the window so they are sure to happen
+    // before React's event listeners (registered on the document).
+    windowObject.addEventListener('focus', $507fabe10e71c6fb$var$handleFocusEvent, true);
+    windowObject.addEventListener('blur', $507fabe10e71c6fb$var$handleWindowBlur, false);
+    if (typeof PointerEvent !== 'undefined') {
+        documentObject.addEventListener('pointerdown', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        documentObject.addEventListener('pointermove', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        documentObject.addEventListener('pointerup', $507fabe10e71c6fb$var$handlePointerEvent, true);
+    } else if (process.env.NODE_ENV === 'test') {
+        documentObject.addEventListener('mousedown', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        documentObject.addEventListener('mousemove', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        documentObject.addEventListener('mouseup', $507fabe10e71c6fb$var$handlePointerEvent, true);
+    }
+    // Add unmount handler
+    windowObject.addEventListener('beforeunload', ()=>{
+        $507fabe10e71c6fb$var$tearDownWindowFocusTracking(element);
+    }, {
+        once: true
+    });
+    $507fabe10e71c6fb$export$d90243b58daecda7.set(windowObject, {
+        focus: focus
+    });
+}
+const $507fabe10e71c6fb$var$tearDownWindowFocusTracking = (element, loadListener)=>{
+    const windowObject = ($431fbd86ca7dc216$export$f21a1ffae260145a)(element);
+    const documentObject = ($431fbd86ca7dc216$export$b204af158042fbac)(element);
+    if (loadListener) documentObject.removeEventListener('DOMContentLoaded', loadListener);
+    if (!$507fabe10e71c6fb$export$d90243b58daecda7.has(windowObject)) return;
+    windowObject.HTMLElement.prototype.focus = $507fabe10e71c6fb$export$d90243b58daecda7.get(windowObject).focus;
+    documentObject.removeEventListener('keydown', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+    documentObject.removeEventListener('keyup', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
+    documentObject.removeEventListener('click', $507fabe10e71c6fb$var$handleClickEvent, true);
+    windowObject.removeEventListener('focus', $507fabe10e71c6fb$var$handleFocusEvent, true);
+    windowObject.removeEventListener('blur', $507fabe10e71c6fb$var$handleWindowBlur, false);
+    if (typeof PointerEvent !== 'undefined') {
+        documentObject.removeEventListener('pointerdown', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        documentObject.removeEventListener('pointermove', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        documentObject.removeEventListener('pointerup', $507fabe10e71c6fb$var$handlePointerEvent, true);
+    } else if (process.env.NODE_ENV === 'test') {
+        documentObject.removeEventListener('mousedown', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        documentObject.removeEventListener('mousemove', $507fabe10e71c6fb$var$handlePointerEvent, true);
+        documentObject.removeEventListener('mouseup', $507fabe10e71c6fb$var$handlePointerEvent, true);
+    }
+    $507fabe10e71c6fb$export$d90243b58daecda7.delete(windowObject);
+};
+function $507fabe10e71c6fb$export$2f1888112f558a7d(element) {
+    const documentObject = ($431fbd86ca7dc216$export$b204af158042fbac)(element);
+    let loadListener;
+    if (documentObject.readyState !== 'loading') $507fabe10e71c6fb$var$setupGlobalFocusEvents(element);
+    else {
+        loadListener = ()=>{
+            $507fabe10e71c6fb$var$setupGlobalFocusEvents(element);
+        };
+        documentObject.addEventListener('DOMContentLoaded', loadListener);
+    }
+    return ()=>$507fabe10e71c6fb$var$tearDownWindowFocusTracking(element, loadListener);
+}
+// Server-side rendering does not have the document object defined
+// eslint-disable-next-line no-restricted-globals
+if (typeof document !== 'undefined') $507fabe10e71c6fb$export$2f1888112f558a7d();
+function $507fabe10e71c6fb$export$b9b3dfddab17db27() {
+    return $507fabe10e71c6fb$var$currentModality !== 'pointer';
+}
+function $507fabe10e71c6fb$export$630ff653c5ada6a9() {
+    return $507fabe10e71c6fb$var$currentModality;
+}
+function $507fabe10e71c6fb$export$8397ddfc504fdb9a(modality) {
+    $507fabe10e71c6fb$var$currentModality = modality;
+    $507fabe10e71c6fb$var$triggerChangeHandlers(modality, null);
+}
+const $507fabe10e71c6fb$var$nonTextInputTypes = new Set([
+    'checkbox',
+    'radio',
+    'range',
+    'color',
+    'file',
+    'image',
+    'button',
+    'submit',
+    'reset'
+]);
+/**
+ * If this is attached to text input component, return if the event is a focus event (Tab/Escape keys pressed) so that
+ * focus visible style can be properly set.
+ */ function $507fabe10e71c6fb$var$isKeyboardFocusEvent(isTextInput, modality, e) {
+    let document1 = ($431fbd86ca7dc216$export$b204af158042fbac)(e === null || e === void 0 ? void 0 : e.target);
+    const IHTMLInputElement = typeof window !== 'undefined' ? ($431fbd86ca7dc216$export$f21a1ffae260145a)(e === null || e === void 0 ? void 0 : e.target).HTMLInputElement : HTMLInputElement;
+    const IHTMLTextAreaElement = typeof window !== 'undefined' ? ($431fbd86ca7dc216$export$f21a1ffae260145a)(e === null || e === void 0 ? void 0 : e.target).HTMLTextAreaElement : HTMLTextAreaElement;
+    const IHTMLElement = typeof window !== 'undefined' ? ($431fbd86ca7dc216$export$f21a1ffae260145a)(e === null || e === void 0 ? void 0 : e.target).HTMLElement : HTMLElement;
+    const IKeyboardEvent = typeof window !== 'undefined' ? ($431fbd86ca7dc216$export$f21a1ffae260145a)(e === null || e === void 0 ? void 0 : e.target).KeyboardEvent : KeyboardEvent;
+    // For keyboard events that occur on a non-input element that will move focus into input element (aka ArrowLeft going from Datepicker button to the main input group)
+    // we need to rely on the user passing isTextInput into here. This way we can skip toggling focus visiblity for said input element
+    isTextInput = isTextInput || document1.activeElement instanceof IHTMLInputElement && !$507fabe10e71c6fb$var$nonTextInputTypes.has(document1.activeElement.type) || document1.activeElement instanceof IHTMLTextAreaElement || document1.activeElement instanceof IHTMLElement && document1.activeElement.isContentEditable;
+    return !(isTextInput && modality === 'keyboard' && e instanceof IKeyboardEvent && !$507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS[e.key]);
+}
+function $507fabe10e71c6fb$export$ec71b4b83ac08ec3(fn, deps, opts) {
+    $507fabe10e71c6fb$var$setupGlobalFocusEvents();
+    (useEffect)(()=>{
+        let handler = (modality, e)=>{
+            // We want to early return for any keyboard events that occur inside text inputs EXCEPT for Tab and Escape
+            if (!$507fabe10e71c6fb$var$isKeyboardFocusEvent(!!(opts === null || opts === void 0 ? void 0 : opts.isTextInput), modality, e)) return;
+            fn($507fabe10e71c6fb$export$b9b3dfddab17db27());
+        };
+        $507fabe10e71c6fb$var$changeHandlers.add(handler);
+        return ()=>{
+            $507fabe10e71c6fb$var$changeHandlers.delete(handler);
+        };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+function $3ad3f6e1647bc98d$export$80f3e147d781571c(element) {
+    // If the user is interacting with a virtual cursor, e.g. screen reader, then
+    // wait until after any animated transitions that are currently occurring on
+    // the page before shifting focus. This avoids issues with VoiceOver on iOS
+    // causing the page to scroll when moving focus if the element is transitioning
+    // from off the screen.
+    const ownerDocument = ($431fbd86ca7dc216$export$b204af158042fbac)(element);
+    const activeElement = ($d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument);
+    if (($507fabe10e71c6fb$export$630ff653c5ada6a9)() === 'virtual') {
+        let lastFocusedElement = activeElement;
+        ($bbed8b41f857bcc0$export$24490316f764c430)(()=>{
+            // If focus did not move and the element is still in the document, focus it.
+            if (($d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument) === lastFocusedElement && element.isConnected) ($7215afc6de606d6b$export$de79e2c695e052f3)(element);
+        });
+    } else ($7215afc6de606d6b$export$de79e2c695e052f3)(element);
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // Portions of the code in this file are based on code from react.
+// Original licensing for the following can be found in the
+// NOTICE file in the root directory of this source tree.
+// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions
+
+
+
+function $a1ea59d68270f0dd$export$f8168d8dd8fd66e6(props) {
+    let { isDisabled: isDisabled, onFocus: onFocusProp, onBlur: onBlurProp, onFocusChange: onFocusChange } = props;
+    const onBlur = (useCallback)((e)=>{
+        if (e.target === e.currentTarget) {
+            if (onBlurProp) onBlurProp(e);
+            if (onFocusChange) onFocusChange(false);
+            return true;
+        }
+    }, [
+        onBlurProp,
+        onFocusChange
+    ]);
+    const onSyntheticFocus = ($8a9cb279dc87e130$export$715c682d09d639cc)(onBlur);
+    const onFocus = (useCallback)((e)=>{
+        // Double check that document.activeElement actually matches e.target in case a previously chained
+        // focus handler already moved focus somewhere else.
+        const ownerDocument = ($431fbd86ca7dc216$export$b204af158042fbac)(e.target);
+        const activeElement = ownerDocument ? ($d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument) : ($d4ee10de306f2510$export$cd4e5573fbe2b576)();
+        if (e.target === e.currentTarget && activeElement === ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e.nativeEvent)) {
+            if (onFocusProp) onFocusProp(e);
+            if (onFocusChange) onFocusChange(true);
+            onSyntheticFocus(e);
+        }
+    }, [
+        onFocusChange,
+        onFocusProp,
+        onSyntheticFocus
+    ]);
     return {
-        minusSign: minusSign,
-        plusSign: plusSign,
-        decimal: decimal,
-        group: group,
-        literals: literals,
-        numeral: numeral,
-        index: index
+        focusProps: {
+            onFocus: !isDisabled && (onFocusProp || onFocusChange || onBlurProp) ? onFocus : undefined,
+            onBlur: !isDisabled && (onBlurProp || onFocusChange) ? onBlur : undefined
+        }
     };
 }
-function $6c7bd7858deea686$var$replaceAll(str, find, replace) {
-    if (str.replaceAll) return str.replaceAll(find, replace);
-    return str.split(find).join(replace);
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ function $93925083ecbb358c$export$48d1ea6320830260(handler) {
+    if (!handler) return undefined;
+    let shouldStopPropagation = true;
+    return (e)=>{
+        let event = {
+            ...e,
+            preventDefault () {
+                e.preventDefault();
+            },
+            isDefaultPrevented () {
+                return e.isDefaultPrevented();
+            },
+            stopPropagation () {
+                if (shouldStopPropagation && process.env.NODE_ENV !== 'production') console.error('stopPropagation is now the default behavior for events in React Spectrum. You can use continuePropagation() to revert this behavior.');
+                else shouldStopPropagation = true;
+            },
+            continuePropagation () {
+                shouldStopPropagation = false;
+            },
+            isPropagationStopped () {
+                return shouldStopPropagation;
+            }
+        };
+        handler(event);
+        if (shouldStopPropagation) e.stopPropagation();
+    };
 }
-function $6c7bd7858deea686$var$escapeRegex(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+function $46d819fcbaf35654$export$8f71654801c2f7cd(props) {
+    return {
+        keyboardProps: props.isDisabled ? {} : {
+            onKeyDown: ($93925083ecbb358c$export$48d1ea6320830260)(props.onKeyDown),
+            onKeyUp: ($93925083ecbb358c$export$48d1ea6320830260)(props.onKeyUp)
+        }
+    };
 }
 
 /*
@@ -581,12 +2506,279 @@ function $6c7bd7858deea686$var$escapeRegex(string) {
  */ 
 
 
-function $a916eb452884faea$export$b7a616150fdb9f44(options = {}) {
-    let { locale: locale } = ($18f2051aff69b9bf$export$43bb16f9c6d9e3f7)();
-    return (useMemo)(()=>new ($488c6ddbf4ef74c2$export$cc77c4ff7e8673c5)(locale, options), [
-        locale,
-        options
+
+
+let $f645667febf57a63$export$f9762fab77588ecb = /*#__PURE__*/ (React__default).createContext(null);
+function $f645667febf57a63$var$useFocusableContext(ref) {
+    let context = (useContext)($f645667febf57a63$export$f9762fab77588ecb) || {};
+    ($e7801be82b4b2a53$export$4debdb1a3f0fa79e)(context, ref);
+    // eslint-disable-next-line
+    let { ref: _, ...otherProps } = context;
+    return otherProps;
+}
+function $f645667febf57a63$export$4c014de7c8940b4c(props, domRef) {
+    let { focusProps: focusProps } = ($a1ea59d68270f0dd$export$f8168d8dd8fd66e6)(props);
+    let { keyboardProps: keyboardProps } = ($46d819fcbaf35654$export$8f71654801c2f7cd)(props);
+    let interactions = ($3ef42575df84b30b$export$9d1611c77c2fe928)(focusProps, keyboardProps);
+    let domProps = $f645667febf57a63$var$useFocusableContext(domRef);
+    let interactionProps = props.isDisabled ? {} : domProps;
+    let autoFocusRef = (useRef)(props.autoFocus);
+    (useEffect)(()=>{
+        if (autoFocusRef.current && domRef.current) ($3ad3f6e1647bc98d$export$80f3e147d781571c)(domRef.current);
+        autoFocusRef.current = false;
+    }, [
+        domRef
+    ]);
+    // Always set a tabIndex so that Safari allows focusing native buttons and inputs.
+    let tabIndex = props.excludeFromTabOrder ? -1 : 0;
+    if (props.isDisabled) tabIndex = undefined;
+    return {
+        focusableProps: ($3ef42575df84b30b$export$9d1611c77c2fe928)({
+            ...interactions,
+            tabIndex: tabIndex
+        }, interactionProps)
+    };
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // Portions of the code in this file are based on code from react.
+// Original licensing for the following can be found in the
+// NOTICE file in the root directory of this source tree.
+// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions
+
+
+
+function $9ab94262bd0047c7$export$420e68273165f4ec(props) {
+    let { isDisabled: isDisabled, onBlurWithin: onBlurWithin, onFocusWithin: onFocusWithin, onFocusWithinChange: onFocusWithinChange } = props;
+    let state = (useRef)({
+        isFocusWithin: false
+    });
+    let { addGlobalListener: addGlobalListener, removeAllGlobalListeners: removeAllGlobalListeners } = ($03deb23ff14920c4$export$4eaf04e54aa8eed6)();
+    let onBlur = (useCallback)((e)=>{
+        // Ignore events bubbling through portals.
+        if (!e.currentTarget.contains(e.target)) return;
+        // We don't want to trigger onBlurWithin and then immediately onFocusWithin again
+        // when moving focus inside the element. Only trigger if the currentTarget doesn't
+        // include the relatedTarget (where focus is moving).
+        if (state.current.isFocusWithin && !e.currentTarget.contains(e.relatedTarget)) {
+            state.current.isFocusWithin = false;
+            removeAllGlobalListeners();
+            if (onBlurWithin) onBlurWithin(e);
+            if (onFocusWithinChange) onFocusWithinChange(false);
+        }
+    }, [
+        onBlurWithin,
+        onFocusWithinChange,
+        state,
+        removeAllGlobalListeners
+    ]);
+    let onSyntheticFocus = ($8a9cb279dc87e130$export$715c682d09d639cc)(onBlur);
+    let onFocus = (useCallback)((e)=>{
+        // Ignore events bubbling through portals.
+        if (!e.currentTarget.contains(e.target)) return;
+        // Double check that document.activeElement actually matches e.target in case a previously chained
+        // focus handler already moved focus somewhere else.
+        const ownerDocument = ($431fbd86ca7dc216$export$b204af158042fbac)(e.target);
+        const activeElement = ($d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument);
+        if (!state.current.isFocusWithin && activeElement === ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e.nativeEvent)) {
+            if (onFocusWithin) onFocusWithin(e);
+            if (onFocusWithinChange) onFocusWithinChange(true);
+            state.current.isFocusWithin = true;
+            onSyntheticFocus(e);
+            // Browsers don't fire blur events when elements are removed from the DOM.
+            // However, if a focus event occurs outside the element we're tracking, we
+            // can manually fire onBlur.
+            let currentTarget = e.currentTarget;
+            addGlobalListener(ownerDocument, 'focus', (e)=>{
+                if (state.current.isFocusWithin && !($d4ee10de306f2510$export$4282f70798064fe0)(currentTarget, e.target)) {
+                    let nativeEvent = new ownerDocument.defaultView.FocusEvent('blur', {
+                        relatedTarget: e.target
+                    });
+                    ($8a9cb279dc87e130$export$c2b7abe5d61ec696)(nativeEvent, currentTarget);
+                    let event = ($8a9cb279dc87e130$export$525bc4921d56d4a)(nativeEvent);
+                    onBlur(event);
+                }
+            }, {
+                capture: true
+            });
+        }
+    }, [
+        onFocusWithin,
+        onFocusWithinChange,
+        onSyntheticFocus,
+        addGlobalListener,
+        onBlur
+    ]);
+    if (isDisabled) return {
+        focusWithinProps: {
+            // These cannot be null, that would conflict in mergeProps
+            onFocus: undefined,
+            onBlur: undefined
+        }
+    };
+    return {
+        focusWithinProps: {
+            onFocus: onFocus,
+            onBlur: onBlur
+        }
+    };
+}
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ // Portions of the code in this file are based on code from react.
+// Original licensing for the following can be found in the
+// NOTICE file in the root directory of this source tree.
+// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions
+
+
+// iOS fires onPointerEnter twice: once with pointerType="touch" and again with pointerType="mouse".
+// We want to ignore these emulated events so they do not trigger hover behavior.
+// See https://bugs.webkit.org/show_bug.cgi?id=214609.
+let $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;
+let $6179b936705e76d3$var$hoverCount = 0;
+function $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents() {
+    $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = true;
+    // Clear globalIgnoreEmulatedMouseEvents after a short timeout. iOS fires onPointerEnter
+    // with pointerType="mouse" immediately after onPointerUp and before onFocus. On other
+    // devices that don't have this quirk, we don't want to ignore a mouse hover sometime in
+    // the distant future because a user previously touched the element.
+    setTimeout(()=>{
+        $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;
+    }, 50);
+}
+function $6179b936705e76d3$var$handleGlobalPointerEvent(e) {
+    if (e.pointerType === 'touch') $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents();
+}
+function $6179b936705e76d3$var$setupGlobalTouchEvents() {
+    if (typeof document === 'undefined') return;
+    if ($6179b936705e76d3$var$hoverCount === 0) {
+        if (typeof PointerEvent !== 'undefined') document.addEventListener('pointerup', $6179b936705e76d3$var$handleGlobalPointerEvent);
+        else if (process.env.NODE_ENV === 'test') document.addEventListener('touchend', $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents);
+    }
+    $6179b936705e76d3$var$hoverCount++;
+    return ()=>{
+        $6179b936705e76d3$var$hoverCount--;
+        if ($6179b936705e76d3$var$hoverCount > 0) return;
+        if (typeof PointerEvent !== 'undefined') document.removeEventListener('pointerup', $6179b936705e76d3$var$handleGlobalPointerEvent);
+        else if (process.env.NODE_ENV === 'test') document.removeEventListener('touchend', $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents);
+    };
+}
+function $6179b936705e76d3$export$ae780daf29e6d456(props) {
+    let { onHoverStart: onHoverStart, onHoverChange: onHoverChange, onHoverEnd: onHoverEnd, isDisabled: isDisabled } = props;
+    let [isHovered, setHovered] = (useState)(false);
+    let state = (useRef)({
+        isHovered: false,
+        ignoreEmulatedMouseEvents: false,
+        pointerType: '',
+        target: null
+    }).current;
+    (useEffect)($6179b936705e76d3$var$setupGlobalTouchEvents, []);
+    let { addGlobalListener: addGlobalListener, removeAllGlobalListeners: removeAllGlobalListeners } = ($03deb23ff14920c4$export$4eaf04e54aa8eed6)();
+    let { hoverProps: hoverProps, triggerHoverEnd: triggerHoverEnd } = (useMemo)(()=>{
+        let triggerHoverStart = (event, pointerType)=>{
+            state.pointerType = pointerType;
+            if (isDisabled || pointerType === 'touch' || state.isHovered || !event.currentTarget.contains(event.target)) return;
+            state.isHovered = true;
+            let target = event.currentTarget;
+            state.target = target;
+            // When an element that is hovered over is removed, no pointerleave event is fired by the browser,
+            // even though the originally hovered target may have shrunk in size so it is no longer hovered.
+            // However, a pointerover event will be fired on the new target the mouse is over.
+            // In Chrome this happens immediately. In Safari and Firefox, it happens upon moving the mouse one pixel.
+            addGlobalListener(($431fbd86ca7dc216$export$b204af158042fbac)(event.target), 'pointerover', (e)=>{
+                if (state.isHovered && state.target && !($d4ee10de306f2510$export$4282f70798064fe0)(state.target, e.target)) triggerHoverEnd(e, e.pointerType);
+            }, {
+                capture: true
+            });
+            if (onHoverStart) onHoverStart({
+                type: 'hoverstart',
+                target: target,
+                pointerType: pointerType
+            });
+            if (onHoverChange) onHoverChange(true);
+            setHovered(true);
+        };
+        let triggerHoverEnd = (event, pointerType)=>{
+            let target = state.target;
+            state.pointerType = '';
+            state.target = null;
+            if (pointerType === 'touch' || !state.isHovered || !target) return;
+            state.isHovered = false;
+            removeAllGlobalListeners();
+            if (onHoverEnd) onHoverEnd({
+                type: 'hoverend',
+                target: target,
+                pointerType: pointerType
+            });
+            if (onHoverChange) onHoverChange(false);
+            setHovered(false);
+        };
+        let hoverProps = {};
+        if (typeof PointerEvent !== 'undefined') {
+            hoverProps.onPointerEnter = (e)=>{
+                if ($6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents && e.pointerType === 'mouse') return;
+                triggerHoverStart(e, e.pointerType);
+            };
+            hoverProps.onPointerLeave = (e)=>{
+                if (!isDisabled && e.currentTarget.contains(e.target)) triggerHoverEnd(e, e.pointerType);
+            };
+        } else if (process.env.NODE_ENV === 'test') {
+            hoverProps.onTouchStart = ()=>{
+                state.ignoreEmulatedMouseEvents = true;
+            };
+            hoverProps.onMouseEnter = (e)=>{
+                if (!state.ignoreEmulatedMouseEvents && !$6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents) triggerHoverStart(e, 'mouse');
+                state.ignoreEmulatedMouseEvents = false;
+            };
+            hoverProps.onMouseLeave = (e)=>{
+                if (!isDisabled && e.currentTarget.contains(e.target)) triggerHoverEnd(e, 'mouse');
+            };
+        }
+        return {
+            hoverProps: hoverProps,
+            triggerHoverEnd: triggerHoverEnd
+        };
+    }, [
+        onHoverStart,
+        onHoverChange,
+        onHoverEnd,
+        isDisabled,
+        state,
+        addGlobalListener,
+        removeAllGlobalListeners
     ]);
+    (useEffect)(()=>{
+        // Call the triggerHoverEnd as soon as isDisabled changes to true
+        // Safe to call triggerHoverEnd, it will early return if we aren't currently hovering
+        if (isDisabled) triggerHoverEnd({
+            currentTarget: state.target
+        }, state.pointerType);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        isDisabled
+    ]);
+    return {
+        hoverProps: hoverProps,
+        isHovered: isHovered
+    };
 }
 
 /*
@@ -1255,6 +3447,45 @@ function $d841c8010a73d545$export$4f384c9210e583c3(props, state, inputRef) {
     };
 }
 
+/*
+ * Copyright 2024 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+// React doesn't understand the <template> element, which doesn't have children like a normal element.
+// It will throw an error during hydration when it expects the firstChild to contain content rendered
+// on the server, when in reality, the browser will have placed this inside the `content` document fragment.
+// This monkey patches the firstChild property for our special hidden template elements to work around this error.
+// See https://github.com/facebook/react/issues/19932
+if (typeof HTMLTemplateElement !== 'undefined') {
+    const getFirstChild = Object.getOwnPropertyDescriptor(Node.prototype, 'firstChild').get;
+    Object.defineProperty(HTMLTemplateElement.prototype, 'firstChild', {
+        configurable: true,
+        enumerable: true,
+        get: function() {
+            if (this.dataset.reactAriaHidden) return this.content.firstChild;
+            else return getFirstChild.call(this);
+        }
+    });
+}
+const $f39a9eba43920ace$export$94b6d0abf7d33e8c = /*#__PURE__*/ (createContext)(false);
+function $f39a9eba43920ace$export$86427a43e3e48ebb(fn) {
+    let Wrapper = (props, ref)=>{
+        let isHidden = (useContext)($f39a9eba43920ace$export$94b6d0abf7d33e8c);
+        if (isHidden) return null;
+        return fn(props, ref);
+    };
+    // @ts-ignore - for react dev tools
+    Wrapper.displayName = fn.displayName || fn.name;
+    return (forwardRef)(Wrapper);
+}
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -2431,6 +4662,30 @@ const $01b77f81d0f07f68$export$b04be29aa201d4f5 = /*#__PURE__*/ ($f39a9eba43920a
 
 const $d2b4bc8c273e7be6$export$24d547caef80ccd1 = /*#__PURE__*/ (createContext)({});
 
+/*
+ * Copyright 2022 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+const $514c0188e459b4c0$export$9afb8bc826b033ea = /*#__PURE__*/ (createContext)({});
+const $514c0188e459b4c0$export$5f1af8db9871e1d6 = /*#__PURE__*/ (forwardRef)(function Text(props, ref) {
+    [props, ref] = ($64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $514c0188e459b4c0$export$9afb8bc826b033ea);
+    let { elementType: ElementType = 'span', ...domProps } = props;
+    // @ts-ignore
+    return /*#__PURE__*/ (React__default).createElement(ElementType, {
+        className: "react-aria-Text",
+        ...domProps,
+        ref: ref
+    });
+});
+
 /*
  * Copyright 2023 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");