@jobber/components 7.8.0 → 7.9.0

package/dist/InputNumber/index.cjs

@@ -2,10 +2,10 @@
 
 var React = require('react');
 var tslib_es6 = require('../tslib.es6-cjs.js');
-var Text = require('../Text-cjs2.js');
+var clsx = require('../clsx-cjs.js');
 var classnames = require('classnames');
 var Icon = require('../Icon-cjs.js');
-var Text$1 = require('../Text-cjs.js');
+var Text = require('../Text-cjs.js');
 var filterDataAttributes = require('../filterDataAttributes-cjs.js');
 var FormField = require('../FormField-cjs.js');
 require('react-hook-form');
@@ -13,7 +13,6 @@ require('@jobber/hooks');
 require('framer-motion');
 require('@jobber/design');
 require('../Button-cjs.js');
-require('../clsx-cjs.js');
 require('../Typography-cjs.js');
 require('../mergeRefs-cjs.js');
 require('../useFormFieldFocus-cjs.js');
@@ -21,6 +20,919 @@ require('../InputValidation-cjs.js');
 require('../Spinner-cjs.js');
 require('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).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)['useInsertionEffect']) !== null && $8ae05eaa5c114e9c$var$_React_useInsertionEffect !== void 0 ? $8ae05eaa5c114e9c$var$_React_useInsertionEffect : ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c);
+function $8ae05eaa5c114e9c$export$7f54fc3180508a52(fn) {
+    const ref = (React.useRef)(null);
+    $8ae05eaa5c114e9c$var$useEarlyEffect(()=>{
+        ref.current = fn;
+    }, [
+        fn
+    ]);
+    // @ts-ignore
+    return (React.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] = (React.useState)(defaultValue);
+    let effect = (React.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).createContext($b5e257d569688ac6$var$defaultContext);
+const $b5e257d569688ac6$var$IsSSRContext = /*#__PURE__*/ (React).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 = (React.useContext)($b5e257d569688ac6$var$SSRContext);
+    let ref = (React.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).__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 = (React.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).useId();
+    let [didSSR] = (React.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)['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)['useSyncExternalStore'] === 'function') return (React)['useSyncExternalStore']($b5e257d569688ac6$var$subscribe, $b5e257d569688ac6$var$getSnapshot, $b5e257d569688ac6$var$getServerSnapshot);
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return (React.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] = (React.useState)(defaultId);
+    let nextId = (React.useRef)(null);
+    let res = ($b5e257d569688ac6$export$619500959fc48b26)(value);
+    let cleanupRef = (React.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
+    (React.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 = (React.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.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 = (React.useRef)(new Map());
+    let addGlobalListener = (React.useCallback)((eventTarget, type, listener, options)=>{
+        // Make sure we remove the listener after it is called with the `once` option.
+        let fn = (options === null || options === void 0 ? void 0 : options.once) ? (...args)=>{
+            globalListeners.current.delete(listener);
+            listener(...args);
+        } : listener;
+        globalListeners.current.set(listener, {
+            type: type,
+            eventTarget: eventTarget,
+            fn: fn,
+            options: options
+        });
+        eventTarget.addEventListener(type, fn, options);
+    }, []);
+    let removeGlobalListener = (React.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 = (React.useCallback)(()=>{
+        globalListeners.current.forEach((value, key)=>{
+            removeGlobalListener(value.eventTarget, value.type, key, value.options);
+        });
+    }, [
+        removeGlobalListener
+    ]);
+    (React.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 = (React.useRef)(null);
+    const cleanupRef = (React.useRef)(undefined);
+    const refEffect = (React.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 (React.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;
+    (React.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");
@@ -34,7 +946,7 @@ require('react-router-dom');
  */ 
 
 function $99facab73266f662$export$5add1d006293d136(ref, initialValue, onReset) {
-    let handleReset = (Text.$8ae05eaa5c114e9c$export$7f54fc3180508a52)(()=>{
+    let handleReset = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)(()=>{
         if (onReset) onReset(initialValue);
     });
     (React.useEffect)(()=>{
@@ -50,6 +962,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] = (React.useState)(value || defaultValue);
+    let isControlledRef = (React.useRef)(value !== undefined);
+    let isControlled = value !== undefined;
+    (React.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 = (React.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).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 (React.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 = (React.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)((React.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] = (React.useState)(initialState);
+    let hasRun = (React.useRef)(false);
+    // A callback ref which will run when the slotted element mounts.
+    // This should happen before the useLayoutEffect below.
+    let ref = (React.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");
@@ -153,6 +1318,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] = (React.useState)($1e5a04cdaf7d1af8$var$currentLocale);
+    (React.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).createContext(null);
+function $18f2051aff69b9bf$export$43bb16f9c6d9e3f7() {
+    let defaultLocale = ($1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a)();
+    let context = (React.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 (React.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");
@@ -466,108 +1925,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 (React.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 = (React.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 (React.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();
+    (React.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 = (React.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 = (React.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)
+        }
+    };
 }
 
 /*
@@ -583,12 +2508,279 @@ function $6c7bd7858deea686$var$escapeRegex(string) {
  */ 
 
 
-function $a916eb452884faea$export$b7a616150fdb9f44(options = {}) {
-    let { locale: locale } = (Text.$18f2051aff69b9bf$export$43bb16f9c6d9e3f7)();
-    return (React.useMemo)(()=>new ($488c6ddbf4ef74c2$export$cc77c4ff7e8673c5)(locale, options), [
-        locale,
-        options
+
+
+let $f645667febf57a63$export$f9762fab77588ecb = /*#__PURE__*/ (React).createContext(null);
+function $f645667febf57a63$var$useFocusableContext(ref) {
+    let context = (React.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 = (React.useRef)(props.autoFocus);
+    (React.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 = (React.useRef)({
+        isFocusWithin: false
+    });
+    let { addGlobalListener: addGlobalListener, removeAllGlobalListeners: removeAllGlobalListeners } = ($03deb23ff14920c4$export$4eaf04e54aa8eed6)();
+    let onBlur = (React.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 = (React.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] = (React.useState)(false);
+    let state = (React.useRef)({
+        isHovered: false,
+        ignoreEmulatedMouseEvents: false,
+        pointerType: '',
+        target: null
+    }).current;
+    (React.useEffect)($6179b936705e76d3$var$setupGlobalTouchEvents, []);
+    let { addGlobalListener: addGlobalListener, removeAllGlobalListeners: removeAllGlobalListeners } = ($03deb23ff14920c4$export$4eaf04e54aa8eed6)();
+    let { hoverProps: hoverProps, triggerHoverEnd: triggerHoverEnd } = (React.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
     ]);
+    (React.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
+    };
 }
 
 /*
@@ -618,14 +2810,14 @@ function $7d0a636d7a4dcefd$export$2123ff2b87c81ca(props, ref) {
     }, [
         onScroll
     ]);
-    (Text.$e9faafb641e167db$export$90fc3a17d93f704c)(ref, 'wheel', isDisabled ? undefined : onScrollHandler);
+    ($e9faafb641e167db$export$90fc3a17d93f704c)(ref, 'wheel', isDisabled ? undefined : onScrollHandler);
 }
 
 function $f7dceffc5ad7768b$export$4e328f61c538687f(props = {}) {
     let { autoFocus: autoFocus = false, isTextInput: isTextInput, within: within } = props;
     let state = (React.useRef)({
         isFocused: false,
-        isFocusVisible: autoFocus || (Text.$507fabe10e71c6fb$export$b9b3dfddab17db27)()
+        isFocusVisible: autoFocus || ($507fabe10e71c6fb$export$b9b3dfddab17db27)()
     });
     let [isFocused, setFocused] = (React.useState)(false);
     let [isFocusVisibleState, setFocusVisible] = (React.useState)(()=>state.current.isFocused && state.current.isFocusVisible);
@@ -637,17 +2829,17 @@ function $f7dceffc5ad7768b$export$4e328f61c538687f(props = {}) {
     }, [
         updateState
     ]);
-    (Text.$507fabe10e71c6fb$export$ec71b4b83ac08ec3)((isFocusVisible)=>{
+    ($507fabe10e71c6fb$export$ec71b4b83ac08ec3)((isFocusVisible)=>{
         state.current.isFocusVisible = isFocusVisible;
         updateState();
     }, [], {
         isTextInput: isTextInput
     });
-    let { focusProps: focusProps } = (Text.$a1ea59d68270f0dd$export$f8168d8dd8fd66e6)({
+    let { focusProps: focusProps } = ($a1ea59d68270f0dd$export$f8168d8dd8fd66e6)({
         isDisabled: within,
         onFocusChange: onFocusChange
     });
-    let { focusWithinProps: focusWithinProps } = (Text.$9ab94262bd0047c7$export$420e68273165f4ec)({
+    let { focusWithinProps: focusWithinProps } = ($9ab94262bd0047c7$export$420e68273165f4ec)({
         isDisabled: !within,
         onFocusWithinChange: onFocusChange
     });
@@ -671,8 +2863,8 @@ function $f7dceffc5ad7768b$export$4e328f61c538687f(props = {}) {
  */ 
 function $d191a55c9702f145$export$8467354a121f1b9f(props) {
     let { id: id, label: label, 'aria-labelledby': ariaLabelledby, 'aria-label': ariaLabel, labelElementType: labelElementType = 'label' } = props;
-    id = (Text.$bdb11010cef70236$export$f680877a34711e37)(id);
-    let labelId = (Text.$bdb11010cef70236$export$f680877a34711e37)();
+    id = ($bdb11010cef70236$export$f680877a34711e37)(id);
+    let labelId = ($bdb11010cef70236$export$f680877a34711e37)();
     let labelProps = {};
     if (label) {
         ariaLabelledby = ariaLabelledby ? `${labelId} ${ariaLabelledby}` : labelId;
@@ -681,7 +2873,7 @@ function $d191a55c9702f145$export$8467354a121f1b9f(props) {
             htmlFor: labelElementType === 'label' ? id : undefined
         };
     } else if (!ariaLabelledby && !ariaLabel && process.env.NODE_ENV !== 'production') console.warn('If you do not provide a visible label, you must specify an aria-label or aria-labelledby attribute for accessibility');
-    let fieldProps = (Text.$313b98861ee5dd6c$export$d6875122194c7b44)({
+    let fieldProps = ($313b98861ee5dd6c$export$d6875122194c7b44)({
         id: id,
         'aria-label': ariaLabel,
         'aria-labelledby': ariaLabelledby
@@ -707,19 +2899,19 @@ function $d191a55c9702f145$export$8467354a121f1b9f(props) {
 function $2baaea4c71418dea$export$294aa081a6c6f55d(props) {
     let { description: description, errorMessage: errorMessage, isInvalid: isInvalid, validationState: validationState } = props;
     let { labelProps: labelProps, fieldProps: fieldProps } = ($d191a55c9702f145$export$8467354a121f1b9f)(props);
-    let descriptionId = (Text.$bdb11010cef70236$export$b4cc09c592e8fdb8)([
+    let descriptionId = ($bdb11010cef70236$export$b4cc09c592e8fdb8)([
         Boolean(description),
         Boolean(errorMessage),
         isInvalid,
         validationState
     ]);
-    let errorMessageId = (Text.$bdb11010cef70236$export$b4cc09c592e8fdb8)([
+    let errorMessageId = ($bdb11010cef70236$export$b4cc09c592e8fdb8)([
         Boolean(description),
         Boolean(errorMessage),
         isInvalid,
         validationState
     ]);
-    fieldProps = (Text.$3ef42575df84b30b$export$9d1611c77c2fe928)(fieldProps, {
+    fieldProps = ($3ef42575df84b30b$export$9d1611c77c2fe928)(fieldProps, {
         'aria-describedby': [
             descriptionId,
             // Use aria-describedby for error message because aria-errormessage is unsupported using VoiceOver or NVDA. See https://github.com/adobe/react-spectrum/issues/1346#issuecomment-740136268
@@ -920,7 +3112,7 @@ function $e5be200c675c3b3a$var$isEqualValidation(a, b) {
 function $e93e671b31057976$export$b8473d3665f3a75a(props, state, ref) {
     let { validationBehavior: validationBehavior, focus: focus } = props;
     // This is a useLayoutEffect so that it runs before the useEffect in useFormValidationState, which commits the validation change.
-    (Text.$f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
+    ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
         if (validationBehavior === 'native' && (ref === null || ref === void 0 ? void 0 : ref.current) && !ref.current.disabled) {
             let errorMessage = state.realtimeValidation.isInvalid ? state.realtimeValidation.validationErrors.join(' ') || 'Invalid value.' : '';
             ref.current.setCustomValidity(errorMessage);
@@ -931,10 +3123,10 @@ function $e93e671b31057976$export$b8473d3665f3a75a(props, state, ref) {
         }
     });
     let isIgnoredReset = (React.useRef)(false);
-    let onReset = (Text.$8ae05eaa5c114e9c$export$7f54fc3180508a52)(()=>{
+    let onReset = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)(()=>{
         if (!isIgnoredReset.current) state.resetValidation();
     });
-    let onInvalid = (Text.$8ae05eaa5c114e9c$export$7f54fc3180508a52)((e)=>{
+    let onInvalid = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)((e)=>{
         var _ref_current;
         // Only commit validation if we are not already displaying one.
         // This avoids clearing server errors that the user didn't actually fix.
@@ -946,12 +3138,12 @@ function $e93e671b31057976$export$b8473d3665f3a75a(props, state, ref) {
             if (focus) focus();
             else (_ref_current1 = ref.current) === null || _ref_current1 === void 0 ? void 0 : _ref_current1.focus();
             // Always show focus ring.
-            (Text.$507fabe10e71c6fb$export$8397ddfc504fdb9a)('keyboard');
+            ($507fabe10e71c6fb$export$8397ddfc504fdb9a)('keyboard');
         }
         // Prevent default browser error UI from appearing.
         e.preventDefault();
     });
-    let onChange = (Text.$8ae05eaa5c114e9c$export$7f54fc3180508a52)(()=>{
+    let onChange = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)(()=>{
         state.commitValidation();
     });
     (React.useEffect)(()=>{
@@ -1041,8 +3233,8 @@ function $e93e671b31057976$var$getFirstInvalidInput(form) {
 
 function $2d73ec29415bd339$export$712718f7aec83d5(props, ref) {
     let { inputElementType: inputElementType = 'input', isDisabled: isDisabled = false, isRequired: isRequired = false, isReadOnly: isReadOnly = false, type: type = 'text', validationBehavior: validationBehavior = 'aria' } = props;
-    let [value, setValue] = (Text.$458b0a5536c1a7cf$export$40bfa8c7b0832715)(props.value, props.defaultValue || '', props.onChange);
-    let { focusableProps: focusableProps } = (Text.$f645667febf57a63$export$4c014de7c8940b4c)(props, ref);
+    let [value, setValue] = ($458b0a5536c1a7cf$export$40bfa8c7b0832715)(props.value, props.defaultValue || '', props.onChange);
+    let { focusableProps: focusableProps } = ($f645667febf57a63$export$4c014de7c8940b4c)(props, ref);
     let validationState = ($e5be200c675c3b3a$export$fc1a364ae1f3ff10)({
         ...props,
         value: value
@@ -1053,7 +3245,7 @@ function $2d73ec29415bd339$export$712718f7aec83d5(props, ref) {
         isInvalid: isInvalid,
         errorMessage: props.errorMessage || validationErrors
     });
-    let domProps = (Text.$65484d02dcb7eb3e$export$457c3d6518dd4c6f)(props, {
+    let domProps = ($65484d02dcb7eb3e$export$457c3d6518dd4c6f)(props, {
         labelable: true
     });
     const inputOnlyProps = {
@@ -1072,7 +3264,7 @@ function $2d73ec29415bd339$export$712718f7aec83d5(props, ref) {
         // future major version.
         // https://github.com/facebook/react/issues/19474
         // https://github.com/facebook/react/issues/11896
-        if (ref.current instanceof (Text.$431fbd86ca7dc216$export$f21a1ffae260145a)(ref.current).HTMLTextAreaElement) {
+        if (ref.current instanceof ($431fbd86ca7dc216$export$f21a1ffae260145a)(ref.current).HTMLTextAreaElement) {
             let input = ref.current;
             Object.defineProperty(input, 'defaultValue', {
                 get: ()=>input.value,
@@ -1085,7 +3277,7 @@ function $2d73ec29415bd339$export$712718f7aec83d5(props, ref) {
     ]);
     return {
         labelProps: labelProps,
-        inputProps: (Text.$3ef42575df84b30b$export$9d1611c77c2fe928)(domProps, inputElementType === 'input' ? inputOnlyProps : undefined, {
+        inputProps: ($3ef42575df84b30b$export$9d1611c77c2fe928)(domProps, inputElementType === 'input' ? inputOnlyProps : undefined, {
             disabled: isDisabled,
             readOnly: isReadOnly,
             required: isRequired && validationBehavior === 'native',
@@ -1156,7 +3348,7 @@ function $d841c8010a73d545$export$4f384c9210e583c3(props, state, inputRef) {
     // Use the native event if available so that we can prevent invalid deletions.
     // We do not attempt to polyfill this in Firefox since it would be very complicated,
     // the benefit of doing so is fairly minor, and it's going to be natively supported soon.
-    let onBeforeInputFallback = (Text.$8ae05eaa5c114e9c$export$7f54fc3180508a52)((e)=>{
+    let onBeforeInputFallback = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)((e)=>{
         let input = inputRef.current;
         if (!input) return;
         // Compute the next value of the input if the event is allowed to proceed.
@@ -1217,7 +3409,7 @@ function $d841c8010a73d545$export$4f384c9210e583c3(props, state, inputRef) {
     let { labelProps: labelProps, inputProps: textFieldProps, descriptionProps: descriptionProps, errorMessageProps: errorMessageProps, ...validation } = ($2d73ec29415bd339$export$712718f7aec83d5)(props, inputRef);
     let compositionStartState = (React.useRef)(null);
     return {
-        inputProps: (Text.$3ef42575df84b30b$export$9d1611c77c2fe928)(textFieldProps, {
+        inputProps: ($3ef42575df84b30b$export$9d1611c77c2fe928)(textFieldProps, {
             onBeforeInput: onBeforeInput,
             onCompositionStart () {
                 // Chrome does not implement Input Events Level 2, which specifies the insertFromComposition
@@ -1257,6 +3449,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__*/ (React.createContext)(false);
+function $f39a9eba43920ace$export$86427a43e3e48ebb(fn) {
+    let Wrapper = (props, ref)=>{
+        let isHidden = (React.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 (React.forwardRef)(Wrapper);
+}
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -1275,14 +3506,14 @@ function $de67e98908f0c6ee$export$7f629e9dc1ecf37c(props) {
     let { minValue: minValue, maxValue: maxValue, step: step, formatOptions: formatOptions, value: value, defaultValue: defaultValue = NaN, onChange: onChange, locale: locale, isDisabled: isDisabled, isReadOnly: isReadOnly } = props;
     if (value === null) value = NaN;
     if (value !== undefined && !isNaN(value)) {
-        if (step !== undefined && !isNaN(step)) value = (Text.$9446cca9a3875146$export$cb6e0bb50bc19463)(value, minValue, maxValue, step);
-        else value = (Text.$9446cca9a3875146$export$7d15b64cf5a3a4c4)(value, minValue, maxValue);
+        if (step !== undefined && !isNaN(step)) value = ($9446cca9a3875146$export$cb6e0bb50bc19463)(value, minValue, maxValue, step);
+        else value = ($9446cca9a3875146$export$7d15b64cf5a3a4c4)(value, minValue, maxValue);
     }
     if (!isNaN(defaultValue)) {
-        if (step !== undefined && !isNaN(step)) defaultValue = (Text.$9446cca9a3875146$export$cb6e0bb50bc19463)(defaultValue, minValue, maxValue, step);
-        else defaultValue = (Text.$9446cca9a3875146$export$7d15b64cf5a3a4c4)(defaultValue, minValue, maxValue);
+        if (step !== undefined && !isNaN(step)) defaultValue = ($9446cca9a3875146$export$cb6e0bb50bc19463)(defaultValue, minValue, maxValue, step);
+        else defaultValue = ($9446cca9a3875146$export$7d15b64cf5a3a4c4)(defaultValue, minValue, maxValue);
     }
-    let [numberValue, setNumberValue] = (Text.$458b0a5536c1a7cf$export$40bfa8c7b0832715)(value, isNaN(defaultValue) ? NaN : defaultValue, onChange);
+    let [numberValue, setNumberValue] = ($458b0a5536c1a7cf$export$40bfa8c7b0832715)(value, isNaN(defaultValue) ? NaN : defaultValue, onChange);
     let [initialValue] = (React.useState)(numberValue);
     let [inputValue, setInputValue] = (React.useState)(()=>isNaN(numberValue) ? '' : new ($488c6ddbf4ef74c2$export$cc77c4ff7e8673c5)(locale, formatOptions).format(numberValue));
     let numberParser = (React.useMemo)(()=>new ($6c7bd7858deea686$export$cd11ab140839f11d)(locale, formatOptions), [
@@ -1343,8 +3574,8 @@ function $de67e98908f0c6ee$export$7f629e9dc1ecf37c(props) {
         }
         // Clamp to min and max, round to the nearest step, and round to specified number of digits
         let clampedValue;
-        if (step === undefined || isNaN(step)) clampedValue = (Text.$9446cca9a3875146$export$7d15b64cf5a3a4c4)(parsedValue, minValue, maxValue);
-        else clampedValue = (Text.$9446cca9a3875146$export$cb6e0bb50bc19463)(parsedValue, minValue, maxValue, step);
+        if (step === undefined || isNaN(step)) clampedValue = ($9446cca9a3875146$export$7d15b64cf5a3a4c4)(parsedValue, minValue, maxValue);
+        else clampedValue = ($9446cca9a3875146$export$cb6e0bb50bc19463)(parsedValue, minValue, maxValue, step);
         clampedValue = numberParser.parse(format(clampedValue));
         setNumberValue(clampedValue);
         // in a controlled state, the numberValue won't change, so we won't go back to our old input without help
@@ -1357,13 +3588,13 @@ function $de67e98908f0c6ee$export$7f629e9dc1ecf37c(props) {
             // if the input is empty, start from the min/max value when incrementing/decrementing,
             // or zero if there is no min/max value defined.
             let newValue = isNaN(minMax) ? 0 : minMax;
-            return (Text.$9446cca9a3875146$export$cb6e0bb50bc19463)(newValue, minValue, maxValue, clampStep);
+            return ($9446cca9a3875146$export$cb6e0bb50bc19463)(newValue, minValue, maxValue, clampStep);
         } else {
             // otherwise, first snap the current value to the nearest step. if it moves in the direction
             // we're going, use that value, otherwise add the step and snap that value.
-            let newValue = (Text.$9446cca9a3875146$export$cb6e0bb50bc19463)(prev, minValue, maxValue, clampStep);
+            let newValue = ($9446cca9a3875146$export$cb6e0bb50bc19463)(prev, minValue, maxValue, clampStep);
             if (operation === '+' && newValue > prev || operation === '-' && newValue < prev) return newValue;
-            return (Text.$9446cca9a3875146$export$cb6e0bb50bc19463)($de67e98908f0c6ee$var$handleDecimalOperation(operation, prev, clampStep), minValue, maxValue, clampStep);
+            return ($9446cca9a3875146$export$cb6e0bb50bc19463)($de67e98908f0c6ee$var$handleDecimalOperation(operation, prev, clampStep), minValue, maxValue, clampStep);
         }
     };
     let increment = ()=>{
@@ -1384,7 +3615,7 @@ function $de67e98908f0c6ee$export$7f629e9dc1ecf37c(props) {
     };
     let incrementToMax = ()=>{
         if (maxValue != null) {
-            setNumberValue((Text.$9446cca9a3875146$export$cb6e0bb50bc19463)(maxValue, minValue, maxValue, clampStep));
+            setNumberValue(($9446cca9a3875146$export$cb6e0bb50bc19463)(maxValue, minValue, maxValue, clampStep));
             validation.commitValidation();
         }
     };
@@ -1394,7 +3625,7 @@ function $de67e98908f0c6ee$export$7f629e9dc1ecf37c(props) {
             validation.commitValidation();
         }
     };
-    let canIncrement = (React.useMemo)(()=>!isDisabled && !isReadOnly && (isNaN(parsedValue) || maxValue === undefined || isNaN(maxValue) || (Text.$9446cca9a3875146$export$cb6e0bb50bc19463)(parsedValue, minValue, maxValue, clampStep) > parsedValue || $de67e98908f0c6ee$var$handleDecimalOperation('+', parsedValue, clampStep) <= maxValue), [
+    let canIncrement = (React.useMemo)(()=>!isDisabled && !isReadOnly && (isNaN(parsedValue) || maxValue === undefined || isNaN(maxValue) || ($9446cca9a3875146$export$cb6e0bb50bc19463)(parsedValue, minValue, maxValue, clampStep) > parsedValue || $de67e98908f0c6ee$var$handleDecimalOperation('+', parsedValue, clampStep) <= maxValue), [
         isDisabled,
         isReadOnly,
         minValue,
@@ -1402,7 +3633,7 @@ function $de67e98908f0c6ee$export$7f629e9dc1ecf37c(props) {
         clampStep,
         parsedValue
     ]);
-    let canDecrement = (React.useMemo)(()=>!isDisabled && !isReadOnly && (isNaN(parsedValue) || minValue === undefined || isNaN(minValue) || (Text.$9446cca9a3875146$export$cb6e0bb50bc19463)(parsedValue, minValue, maxValue, clampStep) < parsedValue || $de67e98908f0c6ee$var$handleDecimalOperation('-', parsedValue, clampStep) >= minValue), [
+    let canDecrement = (React.useMemo)(()=>!isDisabled && !isReadOnly && (isNaN(parsedValue) || minValue === undefined || isNaN(minValue) || ($9446cca9a3875146$export$cb6e0bb50bc19463)(parsedValue, minValue, maxValue, clampStep) < parsedValue || $de67e98908f0c6ee$var$handleDecimalOperation('-', parsedValue, clampStep) >= minValue), [
         isDisabled,
         isReadOnly,
         minValue,
@@ -1713,7 +3944,7 @@ function $parcel$interopDefault$1(a) {
 function $d2e8511e6f209edf$export$e908e06f4b8e3402(props) {
     const _async = (React.useRef)(undefined);
     let { value: value, textValue: textValue, minValue: minValue, maxValue: maxValue, isDisabled: isDisabled, isReadOnly: isReadOnly, isRequired: isRequired, onIncrement: onIncrement, onIncrementPage: onIncrementPage, onDecrement: onDecrement, onDecrementPage: onDecrementPage, onDecrementToMin: onDecrementToMin, onIncrementToMax: onIncrementToMax } = props;
-    const stringFormatter = (Text.$fca6afa0e843324b$export$f12b703ca79dfbb1)((($parcel$interopDefault$1($a99895ee3dc79e61$exports))), '@react-aria/spinbutton');
+    const stringFormatter = ($fca6afa0e843324b$export$f12b703ca79dfbb1)((($parcel$interopDefault$1($a99895ee3dc79e61$exports))), '@react-aria/spinbutton');
     const clearAsync = ()=>clearTimeout(_async.current);
     (React.useEffect)(()=>{
         return ()=>clearAsync();
@@ -1783,7 +4014,7 @@ function $d2e8511e6f209edf$export$e908e06f4b8e3402(props) {
     }, [
         ariaTextValue
     ]);
-    const onIncrementPressStart = (Text.$8ae05eaa5c114e9c$export$7f54fc3180508a52)((initialStepDelay)=>{
+    const onIncrementPressStart = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)((initialStepDelay)=>{
         clearAsync();
         onIncrement === null || onIncrement === void 0 ? void 0 : onIncrement();
         // Start spinning after initial delay
@@ -1791,7 +4022,7 @@ function $d2e8511e6f209edf$export$e908e06f4b8e3402(props) {
             if (maxValue === undefined || isNaN(maxValue) || value === undefined || isNaN(value) || value < maxValue) onIncrementPressStart(60);
         }, initialStepDelay);
     });
-    const onDecrementPressStart = (Text.$8ae05eaa5c114e9c$export$7f54fc3180508a52)((initialStepDelay)=>{
+    const onDecrementPressStart = ($8ae05eaa5c114e9c$export$7f54fc3180508a52)((initialStepDelay)=>{
         clearAsync();
         onDecrement === null || onDecrement === void 0 ? void 0 : onDecrement();
         // Start spinning after initial delay
@@ -1802,7 +4033,7 @@ function $d2e8511e6f209edf$export$e908e06f4b8e3402(props) {
     let cancelContextMenu = (e)=>{
         e.preventDefault();
     };
-    let { addGlobalListener: addGlobalListener, removeAllGlobalListeners: removeAllGlobalListeners } = (Text.$03deb23ff14920c4$export$4eaf04e54aa8eed6)();
+    let { addGlobalListener: addGlobalListener, removeAllGlobalListeners: removeAllGlobalListeners } = ($03deb23ff14920c4$export$4eaf04e54aa8eed6)();
     return {
         spinButtonProps: {
             role: 'spinbutton',
@@ -2178,9 +4409,9 @@ function $parcel$interopDefault(a) {
 function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
     let { id: id, decrementAriaLabel: decrementAriaLabel, incrementAriaLabel: incrementAriaLabel, isDisabled: isDisabled, isReadOnly: isReadOnly, isRequired: isRequired, minValue: minValue, maxValue: maxValue, autoFocus: autoFocus, label: label, formatOptions: formatOptions, onBlur: onBlur = ()=>{}, onFocus: onFocus, onFocusChange: onFocusChange, onKeyDown: onKeyDown, onKeyUp: onKeyUp, description: description, errorMessage: errorMessage, isWheelDisabled: isWheelDisabled, ...otherProps } = props;
     let { increment: increment, incrementToMax: incrementToMax, decrement: decrement, decrementToMin: decrementToMin, numberValue: numberValue, inputValue: inputValue, commit: commit, commitValidation: commitValidation } = state;
-    const stringFormatter = (Text.$fca6afa0e843324b$export$f12b703ca79dfbb1)((($parcel$interopDefault($280a227d7cb94b92$exports))), '@react-aria/numberfield');
-    let inputId = (Text.$bdb11010cef70236$export$f680877a34711e37)(id);
-    let { focusProps: focusProps } = (Text.$a1ea59d68270f0dd$export$f8168d8dd8fd66e6)({
+    const stringFormatter = ($fca6afa0e843324b$export$f12b703ca79dfbb1)((($parcel$interopDefault($280a227d7cb94b92$exports))), '@react-aria/numberfield');
+    let inputId = ($bdb11010cef70236$export$f680877a34711e37)(id);
+    let { focusProps: focusProps } = ($a1ea59d68270f0dd$export$f8168d8dd8fd66e6)({
         onBlur () {
             // Set input value to normalized valid value
             commit();
@@ -2214,7 +4445,7 @@ function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
         textValue: textValue
     });
     let [focusWithin, setFocusWithin] = (React.useState)(false);
-    let { focusWithinProps: focusWithinProps } = (Text.$9ab94262bd0047c7$export$420e68273165f4ec)({
+    let { focusWithinProps: focusWithinProps } = ($9ab94262bd0047c7$export$420e68273165f4ec)({
         isDisabled: isDisabled,
         onFocusWithinChange: setFocusWithin
     });
@@ -2244,13 +4475,13 @@ function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
     let hasDecimals = ((_intlOptions_maximumFractionDigits = intlOptions.maximumFractionDigits) !== null && _intlOptions_maximumFractionDigits !== void 0 ? _intlOptions_maximumFractionDigits : 0) > 0;
     let hasNegative = state.minValue === undefined || isNaN(state.minValue) || state.minValue < 0;
     let inputMode = 'numeric';
-    if ((Text.$c87311424ea30a05$export$186c6964ca17d99)()) {
+    if (($c87311424ea30a05$export$186c6964ca17d99)()) {
         // iPhone doesn't have a minus sign in either numeric or decimal.
         // Note this is only for iPhone, not iPad, which always has both
         // minus and decimal in numeric.
         if (hasNegative) inputMode = 'text';
         else if (hasDecimals) inputMode = 'decimal';
-    } else if ((Text.$c87311424ea30a05$export$a11b0059900ceec8)()) {
+    } else if (($c87311424ea30a05$export$a11b0059900ceec8)()) {
         // Android numeric has both a decimal point and minus key.
         // decimal does not have a minus key.
         if (hasNegative) inputMode = 'numeric';
@@ -2259,7 +4490,7 @@ function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
     let onChange = (value)=>{
         if (state.validate(value)) state.setInputValue(value);
     };
-    let domProps = (Text.$65484d02dcb7eb3e$export$457c3d6518dd4c6f)(props);
+    let domProps = ($65484d02dcb7eb3e$export$457c3d6518dd4c6f)(props);
     let onKeyDownEnter = (React.useCallback)((e)=>{
         if (e.nativeEvent.isComposing) return;
         if (e.key === 'Enter') {
@@ -2296,7 +4527,7 @@ function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
         onBlur: onBlur,
         onFocus: onFocus,
         onFocusChange: onFocusChange,
-        onKeyDown: (React.useMemo)(()=>(Text.$ff5963eb1fccf552$export$e08e3b67e392101e)(onKeyDownEnter, onKeyDown), [
+        onKeyDown: (React.useMemo)(()=>($ff5963eb1fccf552$export$e08e3b67e392101e)(onKeyDownEnter, onKeyDown), [
             onKeyDownEnter,
             onKeyDown
         ]),
@@ -2305,11 +4536,11 @@ function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
         errorMessage: errorMessage
     }, state, inputRef);
     ($99facab73266f662$export$5add1d006293d136)(inputRef, state.defaultNumberValue, state.setNumberValue);
-    let inputProps = (Text.$3ef42575df84b30b$export$9d1611c77c2fe928)(spinButtonProps, focusProps, textFieldProps, {
+    let inputProps = ($3ef42575df84b30b$export$9d1611c77c2fe928)(spinButtonProps, focusProps, textFieldProps, {
         // override the spinbutton role, we can't focus a spin button with VO
         role: null,
         // ignore aria-roledescription on iOS so that required state will announce when it is present
-        'aria-roledescription': !(Text.$c87311424ea30a05$export$fedb369cb70207f1)() ? stringFormatter.format('numberField') : null,
+        'aria-roledescription': !($c87311424ea30a05$export$fedb369cb70207f1)() ? stringFormatter.format('numberField') : null,
         'aria-valuemax': null,
         'aria-valuemin': null,
         'aria-valuenow': null,
@@ -2342,9 +4573,9 @@ function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
     let fieldLabel = props['aria-label'] || (typeof props.label === 'string' ? props.label : '');
     let ariaLabelledby;
     if (!fieldLabel) ariaLabelledby = props.label != null ? labelProps.id : props['aria-labelledby'];
-    let incrementId = (Text.$bdb11010cef70236$export$f680877a34711e37)();
-    let decrementId = (Text.$bdb11010cef70236$export$f680877a34711e37)();
-    let incrementButtonProps = (Text.$3ef42575df84b30b$export$9d1611c77c2fe928)(incButtonProps, {
+    let incrementId = ($bdb11010cef70236$export$f680877a34711e37)();
+    let decrementId = ($bdb11010cef70236$export$f680877a34711e37)();
+    let incrementButtonProps = ($3ef42575df84b30b$export$9d1611c77c2fe928)(incButtonProps, {
         'aria-label': incrementAriaLabel || stringFormatter.format('increase', {
             fieldLabel: fieldLabel
         }).trim(),
@@ -2357,7 +4588,7 @@ function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
         isDisabled: !state.canIncrement,
         onPressStart: onButtonPressStart
     });
-    let decrementButtonProps = (Text.$3ef42575df84b30b$export$9d1611c77c2fe928)(decButtonProps, {
+    let decrementButtonProps = ($3ef42575df84b30b$export$9d1611c77c2fe928)(decButtonProps, {
         'aria-label': decrementAriaLabel || stringFormatter.format('decrease', {
             fieldLabel: fieldLabel
         }).trim(),
@@ -2403,8 +4634,8 @@ function $81397a9303501bda$export$23f548e970bdf099(props, state, inputRef) {
 
 
 const $01b77f81d0f07f68$export$75b6ee27786ba447 = /*#__PURE__*/ (React.createContext)({});
-const $01b77f81d0f07f68$export$b04be29aa201d4f5 = /*#__PURE__*/ (Text.$f39a9eba43920ace$export$86427a43e3e48ebb)(function Label(props, ref) {
-    [props, ref] = (Text.$64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $01b77f81d0f07f68$export$75b6ee27786ba447);
+const $01b77f81d0f07f68$export$b04be29aa201d4f5 = /*#__PURE__*/ ($f39a9eba43920ace$export$86427a43e3e48ebb)(function Label(props, ref) {
+    [props, ref] = ($64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $01b77f81d0f07f68$export$75b6ee27786ba447);
     let { elementType: ElementType = 'label', ...labelProps } = props;
     // @ts-ignore
     return /*#__PURE__*/ (React).createElement(ElementType, {
@@ -2433,6 +4664,30 @@ const $01b77f81d0f07f68$export$b04be29aa201d4f5 = /*#__PURE__*/ (Text.$f39a9eba4
 
 const $d2b4bc8c273e7be6$export$24d547caef80ccd1 = /*#__PURE__*/ (React.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__*/ (React.createContext)({});
+const $514c0188e459b4c0$export$5f1af8db9871e1d6 = /*#__PURE__*/ (React.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).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");
@@ -2458,17 +4713,17 @@ const $ee014567cb39d3f0$export$f551688fc98f2e09 = /*#__PURE__*/ (React.forwardRe
 });
 const $ee014567cb39d3f0$var$FieldErrorInner = /*#__PURE__*/ (React.forwardRef)((props, ref)=>{
     let validation = (React.useContext)($ee014567cb39d3f0$export$ff05c3ac10437e03);
-    let domProps = (Text.$65484d02dcb7eb3e$export$457c3d6518dd4c6f)(props, {
+    let domProps = ($65484d02dcb7eb3e$export$457c3d6518dd4c6f)(props, {
         global: true
     });
-    let renderProps = (Text.$64fa3d84918910a7$export$4d86445c2cf5e3)({
+    let renderProps = ($64fa3d84918910a7$export$4d86445c2cf5e3)({
         ...props,
         defaultClassName: 'react-aria-FieldError',
         defaultChildren: validation.validationErrors.length === 0 ? undefined : validation.validationErrors.join(' '),
         values: validation
     });
     if (renderProps.children == null) return null;
-    return /*#__PURE__*/ (React).createElement((Text.$514c0188e459b4c0$export$5f1af8db9871e1d6), {
+    return /*#__PURE__*/ (React).createElement(($514c0188e459b4c0$export$5f1af8db9871e1d6), {
         slot: "errorMessage",
         ...domProps,
         ...renderProps,
@@ -2506,9 +4761,9 @@ const $d3e0e05bdfcf66bd$export$c24727297075ec6a = /*#__PURE__*/ (React.createCon
 
 const $a049562f99e7db0e$export$f9c6924e160136d1 = /*#__PURE__*/ (React.createContext)({});
 const $a049562f99e7db0e$export$eb2fcfdbd7ba97d4 = /*#__PURE__*/ (React.forwardRef)(function Group(props, ref) {
-    [props, ref] = (Text.$64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $a049562f99e7db0e$export$f9c6924e160136d1);
+    [props, ref] = ($64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $a049562f99e7db0e$export$f9c6924e160136d1);
     let { isDisabled: isDisabled, isInvalid: isInvalid, onHoverStart: onHoverStart, onHoverChange: onHoverChange, onHoverEnd: onHoverEnd, ...otherProps } = props;
-    let { hoverProps: hoverProps, isHovered: isHovered } = (Text.$6179b936705e76d3$export$ae780daf29e6d456)({
+    let { hoverProps: hoverProps, isHovered: isHovered } = ($6179b936705e76d3$export$ae780daf29e6d456)({
         onHoverStart: onHoverStart,
         onHoverChange: onHoverChange,
         onHoverEnd: onHoverEnd,
@@ -2519,7 +4774,7 @@ const $a049562f99e7db0e$export$eb2fcfdbd7ba97d4 = /*#__PURE__*/ (React.forwardRe
     });
     isDisabled !== null && isDisabled !== void 0 ? isDisabled : isDisabled = !!props['aria-disabled'] && props['aria-disabled'] !== 'false';
     isInvalid !== null && isInvalid !== void 0 ? isInvalid : isInvalid = !!props['aria-invalid'] && props['aria-invalid'] !== 'false';
-    let renderProps = (Text.$64fa3d84918910a7$export$4d86445c2cf5e3)({
+    let renderProps = ($64fa3d84918910a7$export$4d86445c2cf5e3)({
         ...props,
         values: {
             isHovered: isHovered,
@@ -2532,7 +4787,7 @@ const $a049562f99e7db0e$export$eb2fcfdbd7ba97d4 = /*#__PURE__*/ (React.forwardRe
     });
     var _props_role, _props_slot;
     return /*#__PURE__*/ (React).createElement("div", {
-        ...(Text.$3ef42575df84b30b$export$9d1611c77c2fe928)(otherProps, focusProps, hoverProps),
+        ...($3ef42575df84b30b$export$9d1611c77c2fe928)(otherProps, focusProps, hoverProps),
         ...renderProps,
         ref: ref,
         role: (_props_role = props.role) !== null && _props_role !== void 0 ? _props_role : 'group',
@@ -2565,15 +4820,15 @@ let $3985021b0ad6602f$var$filterHoverProps = (props)=>{
     let { onHoverStart: onHoverStart, onHoverChange: onHoverChange, onHoverEnd: onHoverEnd, ...otherProps } = props;
     return otherProps;
 };
-const $3985021b0ad6602f$export$f5b8910cec6cf069 = /*#__PURE__*/ (Text.$f39a9eba43920ace$export$86427a43e3e48ebb)(function Input(props, ref) {
-    [props, ref] = (Text.$64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $3985021b0ad6602f$export$37fb8590cf2c088c);
-    let { hoverProps: hoverProps, isHovered: isHovered } = (Text.$6179b936705e76d3$export$ae780daf29e6d456)(props);
+const $3985021b0ad6602f$export$f5b8910cec6cf069 = /*#__PURE__*/ ($f39a9eba43920ace$export$86427a43e3e48ebb)(function Input(props, ref) {
+    [props, ref] = ($64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $3985021b0ad6602f$export$37fb8590cf2c088c);
+    let { hoverProps: hoverProps, isHovered: isHovered } = ($6179b936705e76d3$export$ae780daf29e6d456)(props);
     let { isFocused: isFocused, isFocusVisible: isFocusVisible, focusProps: focusProps } = ($f7dceffc5ad7768b$export$4e328f61c538687f)({
         isTextInput: true,
         autoFocus: props.autoFocus
     });
     let isInvalid = !!props['aria-invalid'] && props['aria-invalid'] !== 'false';
-    let renderProps = (Text.$64fa3d84918910a7$export$4d86445c2cf5e3)({
+    let renderProps = ($64fa3d84918910a7$export$4d86445c2cf5e3)({
         ...props,
         values: {
             isHovered: isHovered,
@@ -2585,7 +4840,7 @@ const $3985021b0ad6602f$export$f5b8910cec6cf069 = /*#__PURE__*/ (Text.$f39a9eba4
         defaultClassName: 'react-aria-Input'
     });
     return /*#__PURE__*/ (React).createElement("input", {
-        ...(Text.$3ef42575df84b30b$export$9d1611c77c2fe928)($3985021b0ad6602f$var$filterHoverProps(props), focusProps, hoverProps),
+        ...($3ef42575df84b30b$export$9d1611c77c2fe928)($3985021b0ad6602f$var$filterHoverProps(props), focusProps, hoverProps),
         ...renderProps,
         ref: ref,
         "data-focused": isFocused || undefined,
@@ -2621,24 +4876,24 @@ const $3985021b0ad6602f$export$f5b8910cec6cf069 = /*#__PURE__*/ (Text.$f39a9eba4
 const $b91743d66a0ed188$export$b414a48cf5dcbc11 = /*#__PURE__*/ (React.createContext)(null);
 const $b91743d66a0ed188$export$6cc906c6cff9bec5 = /*#__PURE__*/ (React.createContext)(null);
 const $b91743d66a0ed188$export$63c5fa0b2fdccd2e = /*#__PURE__*/ (React.forwardRef)(function NumberField(props, ref) {
-    [props, ref] = (Text.$64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $b91743d66a0ed188$export$b414a48cf5dcbc11);
-    let { validationBehavior: formValidationBehavior } = (Text.$64fa3d84918910a7$export$fabf2dc03a41866e)(($d3e0e05bdfcf66bd$export$c24727297075ec6a)) || {};
+    [props, ref] = ($64fa3d84918910a7$export$29f1550f4b0d4415)(props, ref, $b91743d66a0ed188$export$b414a48cf5dcbc11);
+    let { validationBehavior: formValidationBehavior } = ($64fa3d84918910a7$export$fabf2dc03a41866e)(($d3e0e05bdfcf66bd$export$c24727297075ec6a)) || {};
     var _props_validationBehavior, _ref;
     let validationBehavior = (_ref = (_props_validationBehavior = props.validationBehavior) !== null && _props_validationBehavior !== void 0 ? _props_validationBehavior : formValidationBehavior) !== null && _ref !== void 0 ? _ref : 'native';
-    let { locale: locale } = (Text.$18f2051aff69b9bf$export$43bb16f9c6d9e3f7)();
+    let { locale: locale } = ($18f2051aff69b9bf$export$43bb16f9c6d9e3f7)();
     let state = ($de67e98908f0c6ee$export$7f629e9dc1ecf37c)({
         ...props,
         locale: locale,
         validationBehavior: validationBehavior
     });
     let inputRef = (React.useRef)(null);
-    let [labelRef, label] = (Text.$64fa3d84918910a7$export$9d4c57ee4c6ffdd8)(!props['aria-label'] && !props['aria-labelledby']);
+    let [labelRef, label] = ($64fa3d84918910a7$export$9d4c57ee4c6ffdd8)(!props['aria-label'] && !props['aria-labelledby']);
     let { labelProps: labelProps, groupProps: groupProps, inputProps: inputProps, incrementButtonProps: incrementButtonProps, decrementButtonProps: decrementButtonProps, descriptionProps: descriptionProps, errorMessageProps: errorMessageProps, ...validation } = ($81397a9303501bda$export$23f548e970bdf099)({
-        ...(Text.$64fa3d84918910a7$export$ef03459518577ad4)(props),
+        ...($64fa3d84918910a7$export$ef03459518577ad4)(props),
         label: label,
         validationBehavior: validationBehavior
     }, state, inputRef);
-    let renderProps = (Text.$64fa3d84918910a7$export$4d86445c2cf5e3)({
+    let renderProps = ($64fa3d84918910a7$export$4d86445c2cf5e3)({
         ...props,
         values: {
             state: state,
@@ -2648,11 +4903,11 @@ const $b91743d66a0ed188$export$63c5fa0b2fdccd2e = /*#__PURE__*/ (React.forwardRe
         },
         defaultClassName: 'react-aria-NumberField'
     });
-    let DOMProps = (Text.$65484d02dcb7eb3e$export$457c3d6518dd4c6f)(props, {
+    let DOMProps = ($65484d02dcb7eb3e$export$457c3d6518dd4c6f)(props, {
         global: true
     });
     delete DOMProps.id;
-    return /*#__PURE__*/ (React).createElement((Text.$64fa3d84918910a7$export$2881499e37b75b9a), {
+    return /*#__PURE__*/ (React).createElement(($64fa3d84918910a7$export$2881499e37b75b9a), {
         values: [
             [
                 $b91743d66a0ed188$export$6cc906c6cff9bec5,
@@ -2686,7 +4941,7 @@ const $b91743d66a0ed188$export$63c5fa0b2fdccd2e = /*#__PURE__*/ (React.forwardRe
                 }
             ],
             [
-                (Text.$514c0188e459b4c0$export$9afb8bc826b033ea),
+                ($514c0188e459b4c0$export$9afb8bc826b033ea),
                 {
                     slots: {
                         description: descriptionProps,
@@ -2751,10 +5006,10 @@ const InputNumberRebuilt = React.forwardRef((props, ref) => {
                     React.createElement($3985021b0ad6602f$export$f5b8910cec6cf069, Object.assign({ className: styles.input, placeholder: " " // used for CSS minilabel
                         , ref: inputRef }, dataAttrs)),
                     React.createElement($01b77f81d0f07f68$export$b04be29aa201d4f5, { className: styles.label }, placeholder)))),
-        description && (React.createElement(Text.$514c0188e459b4c0$export$5f1af8db9871e1d6, { className: styles.description, elementType: "div", slot: "description" }, stringDescription ? (React.createElement(Text$1.Text, { size: "small", variation: "subdued" }, description)) : (description))),
+        description && (React.createElement($514c0188e459b4c0$export$5f1af8db9871e1d6, { className: styles.description, elementType: "div", slot: "description" }, stringDescription ? (React.createElement(Text.Text, { size: "small", variation: "subdued" }, description)) : (description))),
         error && (React.createElement($ee014567cb39d3f0$export$f551688fc98f2e09, { className: styles.fieldError },
             React.createElement(Icon.Icon, { color: "critical", name: "alert", size: "small" }),
-            React.createElement(Text$1.Text, { size: "small", variation: "error" }, error)))));
+            React.createElement(Text.Text, { size: "small", variation: "error" }, error)))));
 });
 InputNumberRebuilt.displayName = "InputNumberRebuilt";