@jobber/components 6.123.1 → 6.123.2

package/dist/Text-cjs2.js

@@ -16,36 +16,6 @@ var clsx = require('./clsx-cjs.js');
  */ 
 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");
@@ -60,10 +30,13 @@ function $8ae05eaa5c114e9c$export$7f54fc3180508a52(fn) {
 
 function $1dbecbe27a04f9af$export$14d238f342723f25(defaultValue) {
     let [value, setValue] = (React.useState)(defaultValue);
+    // Keep an up to date copy of value in a ref so we can access the current value in the generator.
+    // This allows us to maintain a stable queue function.
+    let currValue = (React.useRef)(value);
     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)(()=>{
+    let nextRef = (React.useRef)(()=>{
         if (!effect.current) return;
         // Run the generator to the next yield.
         let newValue = effect.current.next();
@@ -75,17 +48,20 @@ function $1dbecbe27a04f9af$export$14d238f342723f25(defaultValue) {
         // 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();
+        if (currValue.current === newValue.value) nextRef.current();
         else setValue(newValue.value);
     });
     ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
+        currValue.current = value;
         // 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();
+        if (effect.current) nextRef.current();
     });
+    let queue = (React.useCallback)((fn)=>{
+        effect.current = fn(currValue.current);
+        nextRef.current();
+    }, [
+        nextRef
+    ]);
     return [
         value,
         queue
@@ -326,7 +302,7 @@ function $f4e2df6bd15f8569$export$98658e8c59125e6a() {
 }
 
 // Source: https://github.com/microsoft/tabster/blob/a89fc5d7e332d48f68d03b1ca6e344489d1c3898/src/Shadowdomize/DOMFunctions.ts#L16
-
+/* eslint-disable rsp-rules/no-non-shadow-contains, rsp-rules/safe-event-target */ 
 
 function $d4ee10de306f2510$export$4282f70798064fe0(node, otherNode) {
     if (!($f4e2df6bd15f8569$export$98658e8c59125e6a)()) return otherNode && node ? node.contains(otherNode) : false;
@@ -350,11 +326,55 @@ const $d4ee10de306f2510$export$cd4e5573fbe2b576 = (doc = document)=>{
     return activeElement;
 };
 function $d4ee10de306f2510$export$e58f029f0fbfdb29(event) {
-    if (($f4e2df6bd15f8569$export$98658e8c59125e6a)() && event.target.shadowRoot) {
-        if (event.composedPath) return event.composedPath()[0];
+    if (($f4e2df6bd15f8569$export$98658e8c59125e6a)() && event.target instanceof Element && event.target.shadowRoot) {
+        var _event_composedPath_, _event_nativeEvent_composedPath_;
+        if ('composedPath' in event) return (_event_composedPath_ = event.composedPath()[0]) !== null && _event_composedPath_ !== void 0 ? _event_composedPath_ : null;
+        else if ('composedPath' in event.nativeEvent) return (_event_nativeEvent_composedPath_ = event.nativeEvent.composedPath()[0]) !== null && _event_nativeEvent_composedPath_ !== void 0 ? _event_nativeEvent_composedPath_ : null;
     }
     return event.target;
 }
+function $d4ee10de306f2510$export$b4f377a2b6254582(node) {
+    if (!node) return false;
+    // Get the active element within the node's parent shadow root (or the document). Can return null.
+    let root = node.getRootNode();
+    let ownerWindow = ($431fbd86ca7dc216$export$f21a1ffae260145a)(node);
+    if (!(root instanceof ownerWindow.Document || root instanceof ownerWindow.ShadowRoot)) return false;
+    let activeElement = root.activeElement;
+    // Check if the active element is within this node. These nodes are within the same shadow root.
+    return activeElement != null && node.contains(activeElement);
+}
+
+/*
+ * 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.
@@ -369,6 +389,7 @@ function $d4ee10de306f2510$export$e58f029f0fbfdb29(event) {
  */ 
 
 
+
 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.
@@ -385,44 +406,13 @@ function $3ef42575df84b30b$export$9d1611c77c2fe928(...args) {
             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 if (key === 'ref' && a && b) result.ref = ($5dc95899b306f630$export$c9058316764c140e)(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");
@@ -499,7 +489,7 @@ 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];
+    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;
 }
 
@@ -624,6 +614,110 @@ const $c87311424ea30a05$export$b7d78993b74f766d = $c87311424ea30a05$var$cached(f
     return $c87311424ea30a05$var$testUserAgent(/Firefox/i);
 });
 
+/*
+ * 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.
+ */ 
+
+
+const $ea8dcbcb9ea1b556$var$RouterContext = /*#__PURE__*/ (React.createContext)({
+    isNative: true,
+    open: $ea8dcbcb9ea1b556$var$openSyntheticLink,
+    useHref: (href)=>href
+});
+function $ea8dcbcb9ea1b556$export$9a302a45f65d0572() {
+    return (React.useContext)($ea8dcbcb9ea1b556$var$RouterContext);
+}
+function $ea8dcbcb9ea1b556$export$efa8c9099e530235(link, modifiers) {
+    // Use getAttribute here instead of link.target. Firefox will default link.target to "_parent" when inside an iframe.
+    let target = link.getAttribute('target');
+    return (!target || target === '_self') && link.origin === location.origin && !link.hasAttribute('download') && !modifiers.metaKey && // open in new tab (mac)
+    !modifiers.ctrlKey && // open in new tab (windows)
+    !modifiers.altKey && // download
+    !modifiers.shiftKey;
+}
+function $ea8dcbcb9ea1b556$export$95185d699e05d4d7(target, modifiers, setOpening = true) {
+    var _window_event_type, _window_event;
+    let { metaKey: metaKey, ctrlKey: ctrlKey, altKey: altKey, shiftKey: shiftKey } = modifiers;
+    // Firefox does not recognize keyboard events as a user action by default, and the popup blocker
+    // will prevent links with target="_blank" from opening. However, it does allow the event if the
+    // Command/Control key is held, which opens the link in a background tab. This seems like the best we can do.
+    // See https://bugzilla.mozilla.org/show_bug.cgi?id=257870 and https://bugzilla.mozilla.org/show_bug.cgi?id=746640.
+    if (($c87311424ea30a05$export$b7d78993b74f766d)() && ((_window_event = window.event) === null || _window_event === void 0 ? void 0 : (_window_event_type = _window_event.type) === null || _window_event_type === void 0 ? void 0 : _window_event_type.startsWith('key')) && target.target === '_blank') {
+        if (($c87311424ea30a05$export$9ac100e40613ea10)()) metaKey = true;
+        else ctrlKey = true;
+    }
+    // WebKit does not support firing click events with modifier keys, but does support keyboard events.
+    // https://github.com/WebKit/WebKit/blob/c03d0ac6e6db178f90923a0a63080b5ca210d25f/Source/WebCore/html/HTMLAnchorElement.cpp#L184
+    let event = ($c87311424ea30a05$export$78551043582a6a98)() && ($c87311424ea30a05$export$9ac100e40613ea10)() && !($c87311424ea30a05$export$7bef049ce92e4224)() && process.env.NODE_ENV !== 'test' ? new KeyboardEvent('keydown', {
+        keyIdentifier: 'Enter',
+        metaKey: metaKey,
+        ctrlKey: ctrlKey,
+        altKey: altKey,
+        shiftKey: shiftKey
+    }) : new MouseEvent('click', {
+        metaKey: metaKey,
+        ctrlKey: ctrlKey,
+        altKey: altKey,
+        shiftKey: shiftKey,
+        detail: 1,
+        bubbles: true,
+        cancelable: true
+    });
+    $ea8dcbcb9ea1b556$export$95185d699e05d4d7.isOpening = setOpening;
+    ($7215afc6de606d6b$export$de79e2c695e052f3)(target);
+    target.dispatchEvent(event);
+    $ea8dcbcb9ea1b556$export$95185d699e05d4d7.isOpening = false;
+}
+// https://github.com/parcel-bundler/parcel/issues/8724
+$ea8dcbcb9ea1b556$export$95185d699e05d4d7.isOpening = false;
+function $ea8dcbcb9ea1b556$var$getSyntheticLink(target, open) {
+    if (target instanceof HTMLAnchorElement) open(target);
+    else if (target.hasAttribute('data-href')) {
+        let link = document.createElement('a');
+        link.href = target.getAttribute('data-href');
+        if (target.hasAttribute('data-target')) link.target = target.getAttribute('data-target');
+        if (target.hasAttribute('data-rel')) link.rel = target.getAttribute('data-rel');
+        if (target.hasAttribute('data-download')) link.download = target.getAttribute('data-download');
+        if (target.hasAttribute('data-ping')) link.ping = target.getAttribute('data-ping');
+        if (target.hasAttribute('data-referrer-policy')) link.referrerPolicy = target.getAttribute('data-referrer-policy');
+        target.appendChild(link);
+        open(link);
+        target.removeChild(link);
+    }
+}
+function $ea8dcbcb9ea1b556$var$openSyntheticLink(target, modifiers) {
+    $ea8dcbcb9ea1b556$var$getSyntheticLink(target, (link)=>$ea8dcbcb9ea1b556$export$95185d699e05d4d7(link, modifiers));
+}
+function $ea8dcbcb9ea1b556$export$7e924b3091a3bd18(props) {
+    let router = $ea8dcbcb9ea1b556$export$9a302a45f65d0572();
+    var _props_href;
+    const href = router.useHref((_props_href = props === null || props === void 0 ? void 0 : props.href) !== null && _props_href !== void 0 ? _props_href : '');
+    return {
+        href: (props === null || props === void 0 ? void 0 : props.href) ? href : undefined,
+        target: props === null || props === void 0 ? void 0 : props.target,
+        rel: props === null || props === void 0 ? void 0 : props.rel,
+        download: props === null || props === void 0 ? void 0 : props.download,
+        ping: props === null || props === void 0 ? void 0 : props.ping,
+        referrerPolicy: props === null || props === void 0 ? void 0 : props.referrerPolicy
+    };
+}
+function $ea8dcbcb9ea1b556$export$13aea1a3cb5e3f1f(e, router, href, routerOptions) {
+    // If a custom router is provided, prevent default and forward if this link should client navigate.
+    if (!router.isNative && e.currentTarget instanceof HTMLAnchorElement && e.currentTarget.href && // If props are applied to a router Link component, it may have already prevented default.
+    !e.isDefaultPrevented() && $ea8dcbcb9ea1b556$export$efa8c9099e530235(e.currentTarget, e) && href) {
+        e.preventDefault();
+        router.open(e.currentTarget, e, href, routerOptions);
+    }
+}
+
 /*
  * Copyright 2020 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
@@ -640,6 +734,7 @@ const $c87311424ea30a05$export$b7d78993b74f766d = $c87311424ea30a05$var$cached(f
 // 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();
@@ -649,31 +744,33 @@ function $bbed8b41f857bcc0$var$setupGlobalEvents() {
         return 'propertyName' in event;
     }
     let onTransitionStart = (e)=>{
-        if (!isTransitionEvent(e) || !e.target) return;
+        let eventTarget = ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
+        if (!isTransitionEvent(e) || !eventTarget) return;
         // Add the transitioning property to the list for this element.
-        let transitions = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+        let transitions = $bbed8b41f857bcc0$var$transitionsByElement.get(eventTarget);
         if (!transitions) {
             transitions = new Set();
-            $bbed8b41f857bcc0$var$transitionsByElement.set(e.target, transitions);
+            $bbed8b41f857bcc0$var$transitionsByElement.set(eventTarget, 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, {
+            eventTarget.addEventListener('transitioncancel', onTransitionEnd, {
                 once: true
             });
         }
         transitions.add(e.propertyName);
     };
     let onTransitionEnd = (e)=>{
-        if (!isTransitionEvent(e) || !e.target) return;
+        let eventTarget = ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
+        if (!isTransitionEvent(e) || !eventTarget) return;
         // Remove property from list of transitioning properties.
-        let properties = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);
+        let properties = $bbed8b41f857bcc0$var$transitionsByElement.get(eventTarget);
         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);
+            eventTarget.removeEventListener('transitioncancel', onTransitionEnd);
+            $bbed8b41f857bcc0$var$transitionsByElement.delete(eventTarget);
         }
         // If no transitioning elements, call all of the queued callbacks.
         if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) {
@@ -842,6 +939,36 @@ function $df56164dff5785e2$export$4338b53315abf666(ref) {
     ]);
 }
 
+/*
+ * 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");
@@ -890,8 +1017,7 @@ function $e9faafb641e167db$export$90fc3a17d93f704c(ref, event, handler, options)
         ref,
         event,
         options,
-        isDisabled,
-        handleEvent
+        isDisabled
     ]);
 }
 
@@ -954,7 +1080,9 @@ function $7d2416ea0959daaa$var$isAttributeVisible(element, childElement) {
     !element.hasAttribute('data-react-aria-prevent-focus') && (element.nodeName === 'DETAILS' && childElement && childElement.nodeName !== 'SUMMARY' ? element.hasAttribute('open') : true);
 }
 function $7d2416ea0959daaa$export$e989c0fffaa6b27a(element, childElement) {
-    if ($7d2416ea0959daaa$var$supportsCheckVisibility) return element.checkVisibility() && !element.closest('[data-react-aria-prevent-focus]');
+    if ($7d2416ea0959daaa$var$supportsCheckVisibility) return element.checkVisibility({
+        visibilityProperty: true
+    }) && !element.closest('[data-react-aria-prevent-focus]');
     return element.nodeName !== '#comment' && $7d2416ea0959daaa$var$isStyleVisible(element) && $7d2416ea0959daaa$var$isAttributeVisible(element, childElement) && (!element.parentElement || $7d2416ea0959daaa$export$e989c0fffaa6b27a(element.parentElement, element));
 }
 
@@ -1014,8 +1142,14 @@ function $b4b717babfbb907b$var$isInert(element) {
  * OF ANY KIND, either express or implied. See the License for the specific language
  * governing permissions and limitations under the License.
  */ 
+var $458b0a5536c1a7cf$var$_React_useInsertionEffect;
+// Use the earliest effect possible to reset the ref below.
+const $458b0a5536c1a7cf$var$useEarlyEffect = typeof document !== 'undefined' ? ($458b0a5536c1a7cf$var$_React_useInsertionEffect = (React)['useInsertionEffect']) !== null && $458b0a5536c1a7cf$var$_React_useInsertionEffect !== void 0 ? $458b0a5536c1a7cf$var$_React_useInsertionEffect : (React).useLayoutEffect : ()=>{};
 function $458b0a5536c1a7cf$export$40bfa8c7b0832715(value, defaultValue, onChange) {
+    // Store the value in both state and a ref. The state value will only be used when uncontrolled.
+    // The ref is used to track the most current value, which is passed to the function setState callback.
     let [stateValue, setStateValue] = (React.useState)(value || defaultValue);
+    let valueRef = (React.useRef)(stateValue);
     let isControlledRef = (React.useRef)(value !== undefined);
     let isControlled = value !== undefined;
     (React.useEffect)(()=>{
@@ -1025,40 +1159,28 @@ function $458b0a5536c1a7cf$export$40bfa8c7b0832715(value, defaultValue, onChange
     }, [
         isControlled
     ]);
+    // After each render, update the ref to the current value.
+    // This ensures that the setState callback argument is reset.
+    // Note: the effect should not have any dependencies so that controlled values always reset.
     let currentValue = isControlled ? value : stateValue;
+    $458b0a5536c1a7cf$var$useEarlyEffect(()=>{
+        valueRef.current = currentValue;
+    });
+    let [, forceUpdate] = (React.useReducer)(()=>({}), {});
     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);
+        // @ts-ignore - TS doesn't know that T cannot be a function.
+        let newValue = typeof value === 'function' ? value(valueRef.current) : value;
+        if (!Object.is(valueRef.current, newValue)) {
+            // Update the ref so that the next setState callback has the most recent value.
+            valueRef.current = newValue;
+            setStateValue(newValue);
+            // Always trigger a re-render, even when controlled, so that the layout effect above runs to reset the value.
+            forceUpdate();
+            // Trigger onChange. Note that if setState is called multiple times in a single event,
+            // onChange will be called for each one instead of only once.
+            onChange === null || onChange === void 0 ? void 0 : onChange(newValue, ...args);
         }
     }, [
-        isControlled,
-        currentValue,
         onChange
     ]);
     return [
@@ -1135,7 +1257,7 @@ function $64fa3d84918910a7$export$2881499e37b75b9a({ values: values, children: c
     return children;
 }
 function $64fa3d84918910a7$export$4d86445c2cf5e3(props) {
-    let { className: className, style: style, children: children, defaultClassName: defaultClassName, defaultChildren: defaultChildren, defaultStyle: defaultStyle, values: values } = props;
+    let { className: className, style: style, children: children, defaultClassName: defaultClassName, defaultChildren: defaultChildren, defaultStyle: defaultStyle, values: values, render: render } = props;
     return (React.useMemo)(()=>{
         let computedClassName;
         let computedStyle;
@@ -1163,7 +1285,8 @@ function $64fa3d84918910a7$export$4d86445c2cf5e3(props) {
                 ...computedStyle
             } : undefined,
             children: computedChildren !== null && computedChildren !== void 0 ? computedChildren : defaultChildren,
-            'data-rac': ''
+            'data-rac': '',
+            render: render ? (props)=>render(props, values) : undefined
         };
     }, [
         className,
@@ -1172,7 +1295,8 @@ function $64fa3d84918910a7$export$4d86445c2cf5e3(props) {
         defaultClassName,
         defaultChildren,
         defaultStyle,
-        values
+        values,
+        render
     ]);
 }
 function $64fa3d84918910a7$export$fabf2dc03a41866e(context, slot) {
@@ -1193,7 +1317,6 @@ function $64fa3d84918910a7$export$fabf2dc03a41866e(context, slot) {
 }
 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,
@@ -1255,6 +1378,41 @@ function $64fa3d84918910a7$export$ef03459518577ad4(props) {
     for(const prop in props)if (!prefix.test(prop)) filteredProps[prop] = props[prop];
     return filteredProps;
 }
+function $64fa3d84918910a7$var$DOMElement(ElementType, props, forwardedRef) {
+    let { render: render, ...otherProps } = props;
+    let elementRef = (React.useRef)(null);
+    let ref = (React.useMemo)(()=>($5dc95899b306f630$export$c9058316764c140e)(forwardedRef, elementRef), [
+        forwardedRef,
+        elementRef
+    ]);
+    ($f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
+        if (process.env.NODE_ENV !== 'production' && render) {
+            if (!elementRef.current) console.warn('Ref was not connected to DOM element returned by custom `render` function. Did you forget to pass through or merge the `ref`?');
+            else if (elementRef.current.localName !== ElementType) console.warn(`Unexpected DOM element returned by custom \`render\` function. Expected <${ElementType}>, got <${elementRef.current.localName}>. This may break the component behavior and accessibility.`);
+        }
+    }, [
+        ElementType,
+        render
+    ]);
+    let domProps = {
+        ...otherProps,
+        ref: ref
+    };
+    if (render) return render(domProps, undefined);
+    return /*#__PURE__*/ (React).createElement(ElementType, domProps);
+}
+const $64fa3d84918910a7$var$domComponentCache = {};
+const $64fa3d84918910a7$export$df3a06d6289f983e = new Proxy({}, {
+    get (target, elementType) {
+        if (typeof elementType !== 'string') return undefined;
+        let res = $64fa3d84918910a7$var$domComponentCache[elementType];
+        if (!res) {
+            res = /*#__PURE__*/ (React.forwardRef)($64fa3d84918910a7$var$DOMElement.bind(null, elementType));
+            $64fa3d84918910a7$var$domComponentCache[elementType] = res;
+        }
+        return res;
+    }
+});
 
 /*
  * Copyright 2020 Adobe. All rights reserved.
@@ -1366,10 +1524,13 @@ function $1e5a04cdaf7d1af8$export$188ec29ebc2bdc3a() {
     }, []);
     // 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'
-    };
+    if (isSSR) {
+        let locale = typeof window !== 'undefined' && window[$1e5a04cdaf7d1af8$var$localeSymbol];
+        return {
+            locale: locale || 'en-US',
+            direction: 'ltr'
+        };
+    }
     return defaultLocale;
 }
 
@@ -1594,24 +1755,22 @@ function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
             }
         };
     }, []);
-    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) {
+        let eventTarget = ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
+        if (eventTarget instanceof HTMLButtonElement || eventTarget instanceof HTMLInputElement || eventTarget instanceof HTMLTextAreaElement || eventTarget instanceof HTMLSelectElement) {
             stateRef.current.isFocused = true;
-            let target = e.target;
+            let target = eventTarget;
             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);
+                    onBlur === null || onBlur === void 0 ? void 0 : onBlur(event);
                 }
                 // We no longer need the MutationObserver once the target is blurred.
                 if (stateRef.current.observer) {
@@ -1626,7 +1785,7 @@ function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
                 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;
+                    let relatedTargetEl = target === ($d4ee10de306f2510$export$cd4e5573fbe2b576)() ? null : ($d4ee10de306f2510$export$cd4e5573fbe2b576)();
                     target.dispatchEvent(new FocusEvent('blur', {
                         relatedTarget: relatedTargetEl
                     }));
@@ -1644,7 +1803,7 @@ function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
             });
         }
     }, [
-        dispatchBlur
+        onBlur
     ]);
 }
 let $8a9cb279dc87e130$export$fda7da73ab5d4c48 = false;
@@ -1657,10 +1816,10 @@ function $8a9cb279dc87e130$export$cabe61c495ee3649(target) {
     $8a9cb279dc87e130$export$fda7da73ab5d4c48 = true;
     let isRefocusing = false;
     let onBlur = (e)=>{
-        if (e.target === activeElement || isRefocusing) e.stopImmediatePropagation();
+        if (($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === activeElement || isRefocusing) e.stopImmediatePropagation();
     };
     let onFocusOut = (e)=>{
-        if (e.target === activeElement || isRefocusing) {
+        if (($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === activeElement || isRefocusing) {
             e.stopImmediatePropagation();
             // If there was no focusable ancestor, we don't expect a focus event.
             // Re-focus the original active element here.
@@ -1672,10 +1831,10 @@ function $8a9cb279dc87e130$export$cabe61c495ee3649(target) {
         }
     };
     let onFocus = (e)=>{
-        if (e.target === target || isRefocusing) e.stopImmediatePropagation();
+        if (($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === target || isRefocusing) e.stopImmediatePropagation();
     };
     let onFocusIn = (e)=>{
-        if (e.target === target || isRefocusing) {
+        if (($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === target || isRefocusing) {
             e.stopImmediatePropagation();
             if (!isRefocusing) {
                 isRefocusing = true;
@@ -1720,7 +1879,7 @@ function $8a9cb279dc87e130$export$cabe61c495ee3649(target) {
 
 
 let $507fabe10e71c6fb$var$currentModality = null;
-let $507fabe10e71c6fb$var$changeHandlers = new Set();
+const $507fabe10e71c6fb$export$901e90a13c50a14e = 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;
@@ -1730,7 +1889,7 @@ const $507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS = {
     Escape: true
 };
 function $507fabe10e71c6fb$var$triggerChangeHandlers(modality, e) {
-    for (let handler of $507fabe10e71c6fb$var$changeHandlers)handler(modality, e);
+    for (let handler of $507fabe10e71c6fb$export$901e90a13c50a14e)handler(modality, e);
 }
 /**
  * Helper function to determine if a KeyboardEvent is unmodified and could make keyboard focus styles visible.
@@ -1740,20 +1899,21 @@ function $507fabe10e71c6fb$var$triggerChangeHandlers(modality, e) {
 }
 function $507fabe10e71c6fb$var$handleKeyboardEvent(e) {
     $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
-    if ($507fabe10e71c6fb$var$isValidKey(e)) {
+    if (!($ea8dcbcb9ea1b556$export$95185d699e05d4d7).isOpening && $507fabe10e71c6fb$var$isValidKey(e)) {
         $507fabe10e71c6fb$var$currentModality = 'keyboard';
         $507fabe10e71c6fb$var$triggerChangeHandlers('keyboard', e);
     }
 }
 function $507fabe10e71c6fb$var$handlePointerEvent(e) {
     $507fabe10e71c6fb$var$currentModality = 'pointer';
+    'pointerType' in e ? e.pointerType : 'mouse';
     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)) {
+    if (!($ea8dcbcb9ea1b556$export$95185d699e05d4d7).isOpening && ($6a7db85432448f7f$export$60278871457622de)(e)) {
         $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
         $507fabe10e71c6fb$var$currentModality = 'virtual';
     }
@@ -1762,7 +1922,7 @@ 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 (($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === window || ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === 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) {
@@ -1882,27 +2042,30 @@ const $507fabe10e71c6fb$var$nonTextInputTypes = new Set([
  * 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;
+    let document1 = ($431fbd86ca7dc216$export$b204af158042fbac)(e ? ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) : undefined);
+    let eventTarget = e ? ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) : undefined;
+    const IHTMLInputElement = typeof window !== 'undefined' ? ($431fbd86ca7dc216$export$f21a1ffae260145a)(eventTarget).HTMLInputElement : HTMLInputElement;
+    const IHTMLTextAreaElement = typeof window !== 'undefined' ? ($431fbd86ca7dc216$export$f21a1ffae260145a)(eventTarget).HTMLTextAreaElement : HTMLTextAreaElement;
+    const IHTMLElement = typeof window !== 'undefined' ? ($431fbd86ca7dc216$export$f21a1ffae260145a)(eventTarget).HTMLElement : HTMLElement;
+    const IKeyboardEvent = typeof window !== 'undefined' ? ($431fbd86ca7dc216$export$f21a1ffae260145a)(eventTarget).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;
+    let activeElement = ($d4ee10de306f2510$export$cd4e5573fbe2b576)(document1);
+    isTextInput = isTextInput || activeElement instanceof IHTMLInputElement && !$507fabe10e71c6fb$var$nonTextInputTypes.has(activeElement.type) || activeElement instanceof IHTMLTextAreaElement || activeElement instanceof IHTMLElement && 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)(()=>{
+        if ((opts === null || opts === void 0 ? void 0 : opts.enabled) === false) return;
         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);
+        $507fabe10e71c6fb$export$901e90a13c50a14e.add(handler);
         return ()=>{
-            $507fabe10e71c6fb$var$changeHandlers.delete(handler);
+            $507fabe10e71c6fb$export$901e90a13c50a14e.delete(handler);
         };
     // eslint-disable-next-line react-hooks/exhaustive-deps
     }, deps);
@@ -1921,18 +2084,19 @@ function $507fabe10e71c6fb$export$ec71b4b83ac08ec3(fn, deps, opts) {
  */ 
 
 function $3ad3f6e1647bc98d$export$80f3e147d781571c(element) {
+    if (!element.isConnected) return;
     // 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;
+        let lastFocusedElement = ($d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument);
         ($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);
+            const activeElement = ($d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument);
+            // If focus did not move or focus was lost to the body, and the element is still in the document, focus it.
+            if ((activeElement === lastFocusedElement || activeElement === ownerDocument.body) && element.isConnected) ($7215afc6de606d6b$export$de79e2c695e052f3)(element);
         });
     } else ($7215afc6de606d6b$export$de79e2c695e052f3)(element);
 }
@@ -1957,7 +2121,7 @@ function $3ad3f6e1647bc98d$export$80f3e147d781571c(element) {
 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 (($d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === e.currentTarget) {
             if (onBlurProp) onBlurProp(e);
             if (onFocusChange) onFocusChange(false);
             return true;
@@ -1970,9 +2134,10 @@ function $a1ea59d68270f0dd$export$f8168d8dd8fd66e6(props) {
     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);
+        let eventTarget = ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
+        const ownerDocument = ($431fbd86ca7dc216$export$b204af158042fbac)(eventTarget);
         const activeElement = ownerDocument ? ($d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument) : ($d4ee10de306f2510$export$cd4e5573fbe2b576)();
-        if (e.target === e.currentTarget && activeElement === ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e.nativeEvent)) {
+        if (eventTarget === e.currentTarget && eventTarget === activeElement) {
             if (onFocusProp) onFocusProp(e);
             if (onFocusChange) onFocusChange(true);
             onSyntheticFocus(e);
@@ -2120,11 +2285,11 @@ function $9ab94262bd0047c7$export$420e68273165f4ec(props) {
     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;
+        if (!($d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) 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)) {
+        if (state.current.isFocusWithin && !($d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, e.relatedTarget)) {
             state.current.isFocusWithin = false;
             removeAllGlobalListeners();
             if (onBlurWithin) onBlurWithin(e);
@@ -2139,12 +2304,13 @@ function $9ab94262bd0047c7$export$420e68273165f4ec(props) {
     let onSyntheticFocus = ($8a9cb279dc87e130$export$715c682d09d639cc)(onBlur);
     let onFocus = (React.useCallback)((e)=>{
         // Ignore events bubbling through portals.
-        if (!e.currentTarget.contains(e.target)) return;
+        if (!($d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) 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);
+        let eventTarget = ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
+        const ownerDocument = ($431fbd86ca7dc216$export$b204af158042fbac)(eventTarget);
         const activeElement = ($d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument);
-        if (!state.current.isFocusWithin && activeElement === ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e.nativeEvent)) {
+        if (!state.current.isFocusWithin && activeElement === eventTarget) {
             if (onFocusWithin) onFocusWithin(e);
             if (onFocusWithinChange) onFocusWithinChange(true);
             state.current.isFocusWithin = true;
@@ -2154,9 +2320,10 @@ function $9ab94262bd0047c7$export$420e68273165f4ec(props) {
             // can manually fire onBlur.
             let currentTarget = e.currentTarget;
             addGlobalListener(ownerDocument, 'focus', (e)=>{
-                if (state.current.isFocusWithin && !($d4ee10de306f2510$export$4282f70798064fe0)(currentTarget, e.target)) {
+                let eventTarget = ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
+                if (state.current.isFocusWithin && !($d4ee10de306f2510$export$4282f70798064fe0)(currentTarget, eventTarget)) {
                     let nativeEvent = new ownerDocument.defaultView.FocusEvent('blur', {
-                        relatedTarget: e.target
+                        relatedTarget: eventTarget
                     });
                     ($8a9cb279dc87e130$export$c2b7abe5d61ec696)(nativeEvent, currentTarget);
                     let event = ($8a9cb279dc87e130$export$525bc4921d56d4a)(nativeEvent);
@@ -2250,7 +2417,7 @@ function $6179b936705e76d3$export$ae780daf29e6d456(props) {
     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;
+            if (isDisabled || pointerType === 'touch' || state.isHovered || !($d4ee10de306f2510$export$4282f70798064fe0)(event.currentTarget, ($d4ee10de306f2510$export$e58f029f0fbfdb29)(event))) return;
             state.isHovered = true;
             let target = event.currentTarget;
             state.target = target;
@@ -2258,8 +2425,8 @@ function $6179b936705e76d3$export$ae780daf29e6d456(props) {
             // 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);
+            addGlobalListener(($431fbd86ca7dc216$export$b204af158042fbac)(($d4ee10de306f2510$export$e58f029f0fbfdb29)(event)), 'pointerover', (e)=>{
+                if (state.isHovered && state.target && !($d4ee10de306f2510$export$4282f70798064fe0)(state.target, ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) triggerHoverEnd(e, e.pointerType);
             }, {
                 capture: true
             });
@@ -2293,7 +2460,7 @@ function $6179b936705e76d3$export$ae780daf29e6d456(props) {
                 triggerHoverStart(e, e.pointerType);
             };
             hoverProps.onPointerLeave = (e)=>{
-                if (!isDisabled && e.currentTarget.contains(e.target)) triggerHoverEnd(e, e.pointerType);
+                if (!isDisabled && ($d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) triggerHoverEnd(e, e.pointerType);
             };
         } else if (process.env.NODE_ENV === 'test') {
             hoverProps.onTouchStart = ()=>{
@@ -2304,7 +2471,7 @@ function $6179b936705e76d3$export$ae780daf29e6d456(props) {
                 state.ignoreEmulatedMouseEvents = false;
             };
             hoverProps.onMouseLeave = (e)=>{
-                if (!isDisabled && e.currentTarget.contains(e.target)) triggerHoverEnd(e, 'mouse');
+                if (!isDisabled && ($d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, ($d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) triggerHoverEnd(e, 'mouse');
             };
         }
         return {
@@ -2351,15 +2518,35 @@ function $6179b936705e76d3$export$ae780daf29e6d456(props) {
 // 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.
+// does the same for appendChild/removeChild/insertBefore as per the issue below
 // 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);
+            return this.content.firstChild;
+        }
+    });
+    Object.defineProperty(HTMLTemplateElement.prototype, 'appendChild', {
+        configurable: true,
+        enumerable: true,
+        value: function(node) {
+            return this.content.appendChild(node);
+        }
+    });
+    Object.defineProperty(HTMLTemplateElement.prototype, 'removeChild', {
+        configurable: true,
+        enumerable: true,
+        value: function(node) {
+            return this.content.removeChild(node);
+        }
+    });
+    Object.defineProperty(HTMLTemplateElement.prototype, 'insertBefore', {
+        configurable: true,
+        enumerable: true,
+        value: function(node, child) {
+            return this.content.insertBefore(node, child);
         }
     });
 }
@@ -2374,9 +2561,7 @@ function $f39a9eba43920ace$export$8dc98ba7eadeaa56(props) {
     // In SSR, portals are not supported by React. Instead, always render into a <template>
     // element, which the browser will never display to the user. In addition, the
     // content is not part of the accessible DOM tree, so it won't affect ids or other accessibility attributes.
-    return /*#__PURE__*/ (React).createElement("template", {
-        "data-react-aria-hidden": true
-    }, children);
+    return /*#__PURE__*/ (React).createElement("template", null, children);
 }
 function $f39a9eba43920ace$export$86427a43e3e48ebb(fn) {
     let Wrapper = (props, ref)=>{
@@ -2407,7 +2592,8 @@ function $f39a9eba43920ace$export$b5d7cc18bb8d2b59() {
 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;
+    let { elementType: elementType = 'span', ...domProps } = props;
+    let ElementType = ($64fa3d84918910a7$export$df3a06d6289f983e)[elementType];
     // @ts-ignore
     return /*#__PURE__*/ (React).createElement(ElementType, {
         className: "react-aria-Text",
@@ -2438,6 +2624,7 @@ exports.$64fa3d84918910a7$export$29f1550f4b0d4415 = $64fa3d84918910a7$export$29f
 exports.$64fa3d84918910a7$export$4d86445c2cf5e3 = $64fa3d84918910a7$export$4d86445c2cf5e3;
 exports.$64fa3d84918910a7$export$9d4c57ee4c6ffdd8 = $64fa3d84918910a7$export$9d4c57ee4c6ffdd8;
 exports.$64fa3d84918910a7$export$c62b8e45d58ddad9 = $64fa3d84918910a7$export$c62b8e45d58ddad9;
+exports.$64fa3d84918910a7$export$df3a06d6289f983e = $64fa3d84918910a7$export$df3a06d6289f983e;
 exports.$64fa3d84918910a7$export$ef03459518577ad4 = $64fa3d84918910a7$export$ef03459518577ad4;
 exports.$64fa3d84918910a7$export$fabf2dc03a41866e = $64fa3d84918910a7$export$fabf2dc03a41866e;
 exports.$65484d02dcb7eb3e$export$457c3d6518dd4c6f = $65484d02dcb7eb3e$export$457c3d6518dd4c6f;
@@ -2461,18 +2648,21 @@ exports.$bdb11010cef70236$export$f680877a34711e37 = $bdb11010cef70236$export$f68
 exports.$c87311424ea30a05$export$186c6964ca17d99 = $c87311424ea30a05$export$186c6964ca17d99;
 exports.$c87311424ea30a05$export$6446a186d09e379e = $c87311424ea30a05$export$6446a186d09e379e;
 exports.$c87311424ea30a05$export$78551043582a6a98 = $c87311424ea30a05$export$78551043582a6a98;
-exports.$c87311424ea30a05$export$7bef049ce92e4224 = $c87311424ea30a05$export$7bef049ce92e4224;
 exports.$c87311424ea30a05$export$9ac100e40613ea10 = $c87311424ea30a05$export$9ac100e40613ea10;
 exports.$c87311424ea30a05$export$a11b0059900ceec8 = $c87311424ea30a05$export$a11b0059900ceec8;
-exports.$c87311424ea30a05$export$b7d78993b74f766d = $c87311424ea30a05$export$b7d78993b74f766d;
 exports.$c87311424ea30a05$export$e1865c3bedcd822b = $c87311424ea30a05$export$e1865c3bedcd822b;
 exports.$c87311424ea30a05$export$fedb369cb70207f1 = $c87311424ea30a05$export$fedb369cb70207f1;
 exports.$d4ee10de306f2510$export$4282f70798064fe0 = $d4ee10de306f2510$export$4282f70798064fe0;
+exports.$d4ee10de306f2510$export$b4f377a2b6254582 = $d4ee10de306f2510$export$b4f377a2b6254582;
 exports.$d4ee10de306f2510$export$cd4e5573fbe2b576 = $d4ee10de306f2510$export$cd4e5573fbe2b576;
 exports.$d4ee10de306f2510$export$e58f029f0fbfdb29 = $d4ee10de306f2510$export$e58f029f0fbfdb29;
 exports.$df56164dff5785e2$export$4338b53315abf666 = $df56164dff5785e2$export$4338b53315abf666;
 exports.$e7801be82b4b2a53$export$4debdb1a3f0fa79e = $e7801be82b4b2a53$export$4debdb1a3f0fa79e;
 exports.$e9faafb641e167db$export$90fc3a17d93f704c = $e9faafb641e167db$export$90fc3a17d93f704c;
+exports.$ea8dcbcb9ea1b556$export$13aea1a3cb5e3f1f = $ea8dcbcb9ea1b556$export$13aea1a3cb5e3f1f;
+exports.$ea8dcbcb9ea1b556$export$7e924b3091a3bd18 = $ea8dcbcb9ea1b556$export$7e924b3091a3bd18;
+exports.$ea8dcbcb9ea1b556$export$95185d699e05d4d7 = $ea8dcbcb9ea1b556$export$95185d699e05d4d7;
+exports.$ea8dcbcb9ea1b556$export$9a302a45f65d0572 = $ea8dcbcb9ea1b556$export$9a302a45f65d0572;
 exports.$f0a04ccd8dbdd83b$export$e5c5a5f917a5871c = $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c;
 exports.$f39a9eba43920ace$export$86427a43e3e48ebb = $f39a9eba43920ace$export$86427a43e3e48ebb;
 exports.$f39a9eba43920ace$export$8dc98ba7eadeaa56 = $f39a9eba43920ace$export$8dc98ba7eadeaa56;