{"version":3,"file":"138-2f8b15c9a2c48f89ae14.js","mappings":"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","sources":["webpack://waldencast/./node_modules/@swc/helpers/src/_define_property.mjs","webpack://waldencast/./node_modules/clsx/dist/clsx.m.js","webpack://waldencast/./node_modules/@react-aria/utils/dist/import.mjs","webpack://waldencast/./node_modules/@react-aria/interactions/dist/import.mjs","webpack://waldencast/./node_modules/@react-aria/focus/dist/import.mjs"],"sourcesContent":["export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n","function r(e){var t,f,n=\"\";if(\"string\"==typeof e||\"number\"==typeof e)n+=e;else if(\"object\"==typeof e)if(Array.isArray(e))for(t=0;t<e.length;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=\" \"),n+=f);else for(t in e)e[t]&&(n&&(n+=\" \"),n+=t);return n}export function clsx(){for(var e,t,f=0,n=\"\";f<arguments.length;)(e=arguments[f++])&&(t=r(e))&&(n&&(n+=\" \"),n+=t);return n}export default clsx;","import {clamp as $4507461a1b870123$re_export$clamp, snapValueToStep as $4507461a1b870123$re_export$snapValueToStep} from \"@react-stately/utils\";\nimport $12uGp$react, {useState as $12uGp$useState, useRef as $12uGp$useRef, useCallback as $12uGp$useCallback, useEffect as $12uGp$useEffect} from \"react\";\nimport {useSSRSafeId as $12uGp$useSSRSafeId} from \"@react-aria/ssr\";\nimport $12uGp$clsx from \"clsx\";\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ /*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nconst $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c = typeof window !== \"undefined\" ? (0, $12uGp$react).useLayoutEffect : ()=>{};\n\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\nfunction $1dbecbe27a04f9af$export$14d238f342723f25(defaultValue) {\n    let [value, setValue] = (0, $12uGp$useState)(defaultValue);\n    let valueRef = (0, $12uGp$useRef)(value);\n    let effect = (0, $12uGp$useRef)(null);\n    // Must be stable so that `queue` is stable.\n    let nextIter = (0, $12uGp$useCallback)(()=>{\n        // Run the generator to the next yield.\n        let newValue = effect.current.next();\n        while(!newValue.done && valueRef.current === newValue.value)// If the value is the same as the current value,\n        // then continue to the next yield. Otherwise,\n        // set the value in state and wait for the next layout effect.\n        newValue = effect.current.next();\n        // If the generator is done, reset the effect.\n        if (newValue.done) {\n            effect.current = null;\n            return;\n        }\n        // Always update valueRef when setting the state.\n        // This is needed because the function is not regenerated with the new state value since\n        // they must be stable across renders. Instead, it gets carried in the ref, but the setState\n        // is also needed in order to cause a rerender.\n        setValue(newValue.value);\n        valueRef.current = newValue.value;\n    // this list of dependencies is stable, setState and refs never change after first render.\n    }, [\n        setValue,\n        valueRef,\n        effect\n    ]);\n    (0, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{\n        // If there is an effect currently running, continue to the next yield.\n        if (effect.current) nextIter();\n    });\n    // queue must be a stable function, much like setState.\n    let queue = (0, $12uGp$useCallback)((fn)=>{\n        effect.current = fn(valueRef.current);\n        nextIter();\n    // this list of dependencies is stable, setState and refs never change after first render.\n    // in addition, nextIter is stable as outlined above\n    }, [\n        nextIter,\n        effect,\n        valueRef\n    ]);\n    return [\n        value,\n        queue\n    ];\n}\n\n\nlet $bdb11010cef70236$var$idsUpdaterMap = new Map();\nfunction $bdb11010cef70236$export$f680877a34711e37(defaultId) {\n    let [value, setValue] = (0, $12uGp$useState)(defaultId);\n    let nextId = (0, $12uGp$useRef)(null);\n    let res = (0, $12uGp$useSSRSafeId)(value);\n    let updateValue = (0, $12uGp$useCallback)((val)=>{\n        nextId.current = val;\n    }, []);\n    $bdb11010cef70236$var$idsUpdaterMap.set(res, updateValue);\n    (0, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{\n        let r = res;\n        return ()=>{\n            $bdb11010cef70236$var$idsUpdaterMap.delete(r);\n        };\n    }, [\n        res\n    ]);\n    // This cannot cause an infinite loop because the ref is updated first.\n    // eslint-disable-next-line\n    (0, $12uGp$useEffect)(()=>{\n        let newId = nextId.current;\n        if (newId) {\n            nextId.current = null;\n            setValue(newId);\n        }\n    });\n    return res;\n}\nfunction $bdb11010cef70236$export$cd8c9cb68f842629(idA, idB) {\n    if (idA === idB) return idA;\n    let setIdA = $bdb11010cef70236$var$idsUpdaterMap.get(idA);\n    if (setIdA) {\n        setIdA(idB);\n        return idB;\n    }\n    let setIdB = $bdb11010cef70236$var$idsUpdaterMap.get(idB);\n    if (setIdB) {\n        setIdB(idA);\n        return idA;\n    }\n    return idB;\n}\nfunction $bdb11010cef70236$export$b4cc09c592e8fdb8(depArray = []) {\n    let id = $bdb11010cef70236$export$f680877a34711e37();\n    let [resolvedId, setResolvedId] = (0, $1dbecbe27a04f9af$export$14d238f342723f25)(id);\n    let updateId = (0, $12uGp$useCallback)(()=>{\n        setResolvedId(function*() {\n            yield id;\n            yield document.getElementById(id) ? id : undefined;\n        });\n    }, [\n        id,\n        setResolvedId\n    ]);\n    (0, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(updateId, [\n        id,\n        updateId,\n        ...depArray\n    ]);\n    return resolvedId;\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ /**\n * Calls all functions in the order they were chained with the same arguments.\n */ function $ff5963eb1fccf552$export$e08e3b67e392101e(...callbacks) {\n    return (...args)=>{\n        for (let callback of callbacks)if (typeof callback === \"function\") callback(...args);\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\nfunction $3ef42575df84b30b$export$9d1611c77c2fe928(...args) {\n    // Start with a base clone of the first argument. This is a lot faster than starting\n    // with an empty object and adding properties as we go.\n    let result = {\n        ...args[0]\n    };\n    for(let i = 1; i < args.length; i++){\n        let props = args[i];\n        for(let key in props){\n            let a = result[key];\n            let b = props[key];\n            // Chain events\n            if (typeof a === \"function\" && typeof b === \"function\" && // This is a lot faster than a regex.\n            key[0] === \"o\" && key[1] === \"n\" && key.charCodeAt(2) >= /* 'A' */ 65 && key.charCodeAt(2) <= /* 'Z' */ 90) result[key] = (0, $ff5963eb1fccf552$export$e08e3b67e392101e)(a, b);\n            else if ((key === \"className\" || key === \"UNSAFE_className\") && typeof a === \"string\" && typeof b === \"string\") result[key] = (0, $12uGp$clsx)(a, b);\n            else if (key === \"id\" && a && b) result.id = (0, $bdb11010cef70236$export$cd8c9cb68f842629)(a, b);\n            else result[key] = b !== undefined ? b : a;\n        }\n    }\n    return result;\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ function $5dc95899b306f630$export$c9058316764c140e(...refs) {\n    if (refs.length === 1) return refs[0];\n    return (value)=>{\n        for (let ref of refs){\n            if (typeof ref === \"function\") ref(value);\n            else if (ref != null) ref.current = value;\n        }\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ const $65484d02dcb7eb3e$var$DOMPropNames = new Set([\n    \"id\"\n]);\nconst $65484d02dcb7eb3e$var$labelablePropNames = new Set([\n    \"aria-label\",\n    \"aria-labelledby\",\n    \"aria-describedby\",\n    \"aria-details\"\n]);\nconst $65484d02dcb7eb3e$var$propRe = /^(data-.*)$/;\nfunction $65484d02dcb7eb3e$export$457c3d6518dd4c6f(props, opts = {}) {\n    let { labelable: labelable , propNames: propNames  } = opts;\n    let filteredProps = {};\n    for(const prop in props)if (Object.prototype.hasOwnProperty.call(props, prop) && ($65484d02dcb7eb3e$var$DOMPropNames.has(prop) || labelable && $65484d02dcb7eb3e$var$labelablePropNames.has(prop) || (propNames === null || propNames === void 0 ? void 0 : propNames.has(prop)) || $65484d02dcb7eb3e$var$propRe.test(prop))) filteredProps[prop] = props[prop];\n    return filteredProps;\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ function $7215afc6de606d6b$export$de79e2c695e052f3(element) {\n    if ($7215afc6de606d6b$var$supportsPreventScroll()) element.focus({\n        preventScroll: true\n    });\n    else {\n        let scrollableElements = $7215afc6de606d6b$var$getScrollableElements(element);\n        element.focus();\n        $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements);\n    }\n}\nlet $7215afc6de606d6b$var$supportsPreventScrollCached = null;\nfunction $7215afc6de606d6b$var$supportsPreventScroll() {\n    if ($7215afc6de606d6b$var$supportsPreventScrollCached == null) {\n        $7215afc6de606d6b$var$supportsPreventScrollCached = false;\n        try {\n            var focusElem = document.createElement(\"div\");\n            focusElem.focus({\n                get preventScroll () {\n                    $7215afc6de606d6b$var$supportsPreventScrollCached = true;\n                    return true;\n                }\n            });\n        } catch (e) {\n        // Ignore\n        }\n    }\n    return $7215afc6de606d6b$var$supportsPreventScrollCached;\n}\nfunction $7215afc6de606d6b$var$getScrollableElements(element) {\n    var parent = element.parentNode;\n    var scrollableElements = [];\n    var rootScrollingElement = document.scrollingElement || document.documentElement;\n    while(parent instanceof HTMLElement && parent !== rootScrollingElement){\n        if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth) scrollableElements.push({\n            element: parent,\n            scrollTop: parent.scrollTop,\n            scrollLeft: parent.scrollLeft\n        });\n        parent = parent.parentNode;\n    }\n    if (rootScrollingElement instanceof HTMLElement) scrollableElements.push({\n        element: rootScrollingElement,\n        scrollTop: rootScrollingElement.scrollTop,\n        scrollLeft: rootScrollingElement.scrollLeft\n    });\n    return scrollableElements;\n}\nfunction $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements) {\n    for (let { element: element , scrollTop: scrollTop , scrollLeft: scrollLeft  } of scrollableElements){\n        element.scrollTop = scrollTop;\n        element.scrollLeft = scrollLeft;\n    }\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ function $ab71dadb03a6fb2e$export$622cea445a1c5b7d(element, reverse, orientation = \"horizontal\") {\n    let rect = element.getBoundingClientRect();\n    if (reverse) return orientation === \"horizontal\" ? rect.right : rect.bottom;\n    return orientation === \"horizontal\" ? rect.left : rect.top;\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // We store a global list of elements that are currently transitioning,\n// mapped to a set of CSS properties that are transitioning for that element.\n// This is necessary rather than a simple count of transitions because of browser\n// bugs, e.g. Chrome sometimes fires both transitionend and transitioncancel rather\n// than one or the other. So we need to track what's actually transitioning so that\n// we can ignore these duplicate events.\nlet $bbed8b41f857bcc0$var$transitionsByElement = new Map();\n// A list of callbacks to call once there are no transitioning elements.\nlet $bbed8b41f857bcc0$var$transitionCallbacks = new Set();\nfunction $bbed8b41f857bcc0$var$setupGlobalEvents() {\n    if (typeof window === \"undefined\") return;\n    let onTransitionStart = (e)=>{\n        // Add the transitioning property to the list for this element.\n        let transitions = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);\n        if (!transitions) {\n            transitions = new Set();\n            $bbed8b41f857bcc0$var$transitionsByElement.set(e.target, transitions);\n            // The transitioncancel event must be registered on the element itself, rather than as a global\n            // event. This enables us to handle when the node is deleted from the document while it is transitioning.\n            // In that case, the cancel event would have nowhere to bubble to so we need to handle it directly.\n            e.target.addEventListener(\"transitioncancel\", onTransitionEnd);\n        }\n        transitions.add(e.propertyName);\n    };\n    let onTransitionEnd = (e)=>{\n        // Remove property from list of transitioning properties.\n        let properties = $bbed8b41f857bcc0$var$transitionsByElement.get(e.target);\n        if (!properties) return;\n        properties.delete(e.propertyName);\n        // If empty, remove transitioncancel event, and remove the element from the list of transitioning elements.\n        if (properties.size === 0) {\n            e.target.removeEventListener(\"transitioncancel\", onTransitionEnd);\n            $bbed8b41f857bcc0$var$transitionsByElement.delete(e.target);\n        }\n        // If no transitioning elements, call all of the queued callbacks.\n        if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) {\n            for (let cb of $bbed8b41f857bcc0$var$transitionCallbacks)cb();\n            $bbed8b41f857bcc0$var$transitionCallbacks.clear();\n        }\n    };\n    document.body.addEventListener(\"transitionrun\", onTransitionStart);\n    document.body.addEventListener(\"transitionend\", onTransitionEnd);\n}\nif (typeof document !== \"undefined\") {\n    if (document.readyState !== \"loading\") $bbed8b41f857bcc0$var$setupGlobalEvents();\n    else document.addEventListener(\"DOMContentLoaded\", $bbed8b41f857bcc0$var$setupGlobalEvents);\n}\nfunction $bbed8b41f857bcc0$export$24490316f764c430(fn) {\n    // Wait one frame to see if an animation starts, e.g. a transition on mount.\n    requestAnimationFrame(()=>{\n        // If no transitions are running, call the function immediately.\n        // Otherwise, add it to a list of callbacks to run at the end of the animation.\n        if ($bbed8b41f857bcc0$var$transitionsByElement.size === 0) fn();\n        else $bbed8b41f857bcc0$var$transitionCallbacks.add(fn);\n    });\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n// Keep track of elements that we are currently handling dragging for via useDrag1D.\n// If there's an ancestor and a descendant both using useDrag1D(), and the user starts\n// dragging the descendant, we don't want useDrag1D events to fire for the ancestor.\nconst $9cc09df9fd7676be$var$draggingElements = [];\nfunction $9cc09df9fd7676be$export$7bbed75feba39706(props) {\n    console.warn(\"useDrag1D is deprecated, please use `useMove` instead https://react-spectrum.adobe.com/react-aria/useMove.html\");\n    let { containerRef: containerRef , reverse: reverse , orientation: orientation , onHover: onHover , onDrag: onDrag , onPositionChange: onPositionChange , onIncrement: onIncrement , onDecrement: onDecrement , onIncrementToMax: onIncrementToMax , onDecrementToMin: onDecrementToMin , onCollapseToggle: onCollapseToggle  } = props;\n    let getPosition = (e)=>orientation === \"horizontal\" ? e.clientX : e.clientY;\n    let getNextOffset = (e)=>{\n        let containerOffset = (0, $ab71dadb03a6fb2e$export$622cea445a1c5b7d)(containerRef.current, reverse, orientation);\n        let mouseOffset = getPosition(e);\n        let nextOffset = reverse ? containerOffset - mouseOffset : mouseOffset - containerOffset;\n        return nextOffset;\n    };\n    let dragging = (0, $12uGp$useRef)(false);\n    let prevPosition = (0, $12uGp$useRef)(0);\n    // Keep track of the current handlers in a ref so that the events can access them.\n    let handlers = (0, $12uGp$useRef)({\n        onPositionChange: onPositionChange,\n        onDrag: onDrag\n    });\n    handlers.current.onDrag = onDrag;\n    handlers.current.onPositionChange = onPositionChange;\n    let onMouseDragged = (e)=>{\n        e.preventDefault();\n        let nextOffset = getNextOffset(e);\n        if (!dragging.current) {\n            dragging.current = true;\n            if (handlers.current.onDrag) handlers.current.onDrag(true);\n            if (handlers.current.onPositionChange) handlers.current.onPositionChange(nextOffset);\n        }\n        if (prevPosition.current === nextOffset) return;\n        prevPosition.current = nextOffset;\n        if (onPositionChange) onPositionChange(nextOffset);\n    };\n    let onMouseUp = (e)=>{\n        const target = e.target;\n        dragging.current = false;\n        let nextOffset = getNextOffset(e);\n        if (handlers.current.onDrag) handlers.current.onDrag(false);\n        if (handlers.current.onPositionChange) handlers.current.onPositionChange(nextOffset);\n        $9cc09df9fd7676be$var$draggingElements.splice($9cc09df9fd7676be$var$draggingElements.indexOf(target), 1);\n        window.removeEventListener(\"mouseup\", onMouseUp, false);\n        window.removeEventListener(\"mousemove\", onMouseDragged, false);\n    };\n    let onMouseDown = (e)=>{\n        const target = e.currentTarget;\n        // If we're already handling dragging on a descendant with useDrag1D, then\n        // we don't want to handle the drag motion on this target as well.\n        if ($9cc09df9fd7676be$var$draggingElements.some((elt)=>target.contains(elt))) return;\n        $9cc09df9fd7676be$var$draggingElements.push(target);\n        window.addEventListener(\"mousemove\", onMouseDragged, false);\n        window.addEventListener(\"mouseup\", onMouseUp, false);\n    };\n    let onMouseEnter = ()=>{\n        if (onHover) onHover(true);\n    };\n    let onMouseOut = ()=>{\n        if (onHover) onHover(false);\n    };\n    let onKeyDown = (e)=>{\n        switch(e.key){\n            case \"Left\":\n            case \"ArrowLeft\":\n                if (orientation === \"horizontal\") {\n                    e.preventDefault();\n                    if (onDecrement && !reverse) onDecrement();\n                    else if (onIncrement && reverse) onIncrement();\n                }\n                break;\n            case \"Up\":\n            case \"ArrowUp\":\n                if (orientation === \"vertical\") {\n                    e.preventDefault();\n                    if (onDecrement && !reverse) onDecrement();\n                    else if (onIncrement && reverse) onIncrement();\n                }\n                break;\n            case \"Right\":\n            case \"ArrowRight\":\n                if (orientation === \"horizontal\") {\n                    e.preventDefault();\n                    if (onIncrement && !reverse) onIncrement();\n                    else if (onDecrement && reverse) onDecrement();\n                }\n                break;\n            case \"Down\":\n            case \"ArrowDown\":\n                if (orientation === \"vertical\") {\n                    e.preventDefault();\n                    if (onIncrement && !reverse) onIncrement();\n                    else if (onDecrement && reverse) onDecrement();\n                }\n                break;\n            case \"Home\":\n                e.preventDefault();\n                if (onDecrementToMin) onDecrementToMin();\n                break;\n            case \"End\":\n                e.preventDefault();\n                if (onIncrementToMax) onIncrementToMax();\n                break;\n            case \"Enter\":\n                e.preventDefault();\n                if (onCollapseToggle) onCollapseToggle();\n                break;\n        }\n    };\n    return {\n        onMouseDown: onMouseDown,\n        onMouseEnter: onMouseEnter,\n        onMouseOut: onMouseOut,\n        onKeyDown: onKeyDown\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nfunction $03deb23ff14920c4$export$4eaf04e54aa8eed6() {\n    let globalListeners = (0, $12uGp$useRef)(new Map());\n    let addGlobalListener = (0, $12uGp$useCallback)((eventTarget, type, listener, options)=>{\n        // Make sure we remove the listener after it is called with the `once` option.\n        let fn = (options === null || options === void 0 ? void 0 : options.once) ? (...args)=>{\n            globalListeners.current.delete(listener);\n            listener(...args);\n        } : listener;\n        globalListeners.current.set(listener, {\n            type: type,\n            eventTarget: eventTarget,\n            fn: fn,\n            options: options\n        });\n        eventTarget.addEventListener(type, listener, options);\n    }, []);\n    let removeGlobalListener = (0, $12uGp$useCallback)((eventTarget, type, listener, options)=>{\n        var _globalListeners_current_get;\n        let fn = ((_globalListeners_current_get = globalListeners.current.get(listener)) === null || _globalListeners_current_get === void 0 ? void 0 : _globalListeners_current_get.fn) || listener;\n        eventTarget.removeEventListener(type, fn, options);\n        globalListeners.current.delete(listener);\n    }, []);\n    let removeAllGlobalListeners = (0, $12uGp$useCallback)(()=>{\n        globalListeners.current.forEach((value, key)=>{\n            removeGlobalListener(value.eventTarget, value.type, key, value.options);\n        });\n    }, [\n        removeGlobalListener\n    ]);\n    // eslint-disable-next-line arrow-body-style\n    (0, $12uGp$useEffect)(()=>{\n        return removeAllGlobalListeners;\n    }, [\n        removeAllGlobalListeners\n    ]);\n    return {\n        addGlobalListener: addGlobalListener,\n        removeGlobalListener: removeGlobalListener,\n        removeAllGlobalListeners: removeAllGlobalListeners\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nfunction $313b98861ee5dd6c$export$d6875122194c7b44(props, defaultLabel) {\n    let { id: id , \"aria-label\": label , \"aria-labelledby\": labelledBy  } = props;\n    // If there is both an aria-label and aria-labelledby,\n    // combine them by pointing to the element itself.\n    id = (0, $bdb11010cef70236$export$f680877a34711e37)(id);\n    if (labelledBy && label) {\n        let ids = new Set([\n            ...labelledBy.trim().split(/\\s+/),\n            id\n        ]);\n        labelledBy = [\n            ...ids\n        ].join(\" \");\n    } else if (labelledBy) labelledBy = labelledBy.trim().split(/\\s+/).join(\" \");\n    // If no labels are provided, use the default\n    if (!label && !labelledBy && defaultLabel) label = defaultLabel;\n    return {\n        id: id,\n        \"aria-label\": label,\n        \"aria-labelledby\": labelledBy\n    };\n}\n\n\n/*\n * Copyright 2021 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\nfunction $df56164dff5785e2$export$4338b53315abf666(forwardedRef) {\n    const objRef = (0, $12uGp$useRef)();\n    /**\n   * We're using `useLayoutEffect` here instead of `useEffect` because we want\n   * to make sure that the `ref` value is up to date before other places in the\n   * the execution cycle try to read it.\n   */ (0, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{\n        if (!forwardedRef) return;\n        if (typeof forwardedRef === \"function\") forwardedRef(objRef.current);\n        else forwardedRef.current = objRef.current;\n        return ()=>{\n            if (typeof forwardedRef === \"function\") forwardedRef(null);\n            else forwardedRef.current = null;\n        };\n    }, [\n        forwardedRef\n    ]);\n    return objRef;\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nfunction $4f58c5f72bcf79f7$export$496315a1608d9602(effect, dependencies) {\n    const isInitialMount = (0, $12uGp$useRef)(true);\n    (0, $12uGp$useEffect)(()=>{\n        if (isInitialMount.current) isInitialMount.current = false;\n        else effect();\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, dependencies);\n}\n\n\n\n\nfunction $9daab02d461809db$var$hasResizeObserver() {\n    return typeof window.ResizeObserver !== \"undefined\";\n}\nfunction $9daab02d461809db$export$683480f191c0e3ea(options) {\n    const { ref: ref , onResize: onResize  } = options;\n    (0, $12uGp$useEffect)(()=>{\n        let element = ref === null || ref === void 0 ? void 0 : ref.current;\n        if (!element) return;\n        if (!$9daab02d461809db$var$hasResizeObserver()) {\n            window.addEventListener(\"resize\", onResize, false);\n            return ()=>{\n                window.removeEventListener(\"resize\", onResize, false);\n            };\n        } else {\n            const resizeObserverInstance = new window.ResizeObserver((entries)=>{\n                if (!entries.length) return;\n                onResize();\n            });\n            resizeObserverInstance.observe(element);\n            return ()=>{\n                if (element) resizeObserverInstance.unobserve(element);\n            };\n        }\n    }, [\n        onResize,\n        ref\n    ]);\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nfunction $e7801be82b4b2a53$export$4debdb1a3f0fa79e(context, ref) {\n    (0, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{\n        if (context && context.ref && ref) {\n            context.ref.current = ref.current;\n            return ()=>{\n                context.ref.current = null;\n            };\n        }\n    }, [\n        context,\n        ref\n    ]);\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ function $62d8ded9296f3872$export$cfa2225e87938781(node) {\n    if ($62d8ded9296f3872$export$2bb74740c4e19def(node)) node = node.parentElement;\n    while(node && !$62d8ded9296f3872$export$2bb74740c4e19def(node))node = node.parentElement;\n    return node || document.scrollingElement || document.documentElement;\n}\nfunction $62d8ded9296f3872$export$2bb74740c4e19def(node) {\n    let style = window.getComputedStyle(node);\n    return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n// @ts-ignore\nlet $5df64b3807dc15ee$var$visualViewport = typeof window !== \"undefined\" && window.visualViewport;\nfunction $5df64b3807dc15ee$export$d699905dd57c73ca() {\n    let [size, setSize] = (0, $12uGp$useState)(()=>$5df64b3807dc15ee$var$getViewportSize());\n    (0, $12uGp$useEffect)(()=>{\n        // Use visualViewport api to track available height even on iOS virtual keyboard opening\n        let onResize = ()=>{\n            setSize((size)=>{\n                let newSize = $5df64b3807dc15ee$var$getViewportSize();\n                if (newSize.width === size.width && newSize.height === size.height) return size;\n                return newSize;\n            });\n        };\n        if (!$5df64b3807dc15ee$var$visualViewport) window.addEventListener(\"resize\", onResize);\n        else $5df64b3807dc15ee$var$visualViewport.addEventListener(\"resize\", onResize);\n        return ()=>{\n            if (!$5df64b3807dc15ee$var$visualViewport) window.removeEventListener(\"resize\", onResize);\n            else $5df64b3807dc15ee$var$visualViewport.removeEventListener(\"resize\", onResize);\n        };\n    }, []);\n    return size;\n}\nfunction $5df64b3807dc15ee$var$getViewportSize() {\n    return {\n        width: ($5df64b3807dc15ee$var$visualViewport === null || $5df64b3807dc15ee$var$visualViewport === void 0 ? void 0 : $5df64b3807dc15ee$var$visualViewport.width) || window.innerWidth,\n        height: ($5df64b3807dc15ee$var$visualViewport === null || $5df64b3807dc15ee$var$visualViewport === void 0 ? void 0 : $5df64b3807dc15ee$var$visualViewport.height) || window.innerHeight\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\nlet $ef06256079686ba0$var$descriptionId = 0;\nconst $ef06256079686ba0$var$descriptionNodes = new Map();\nfunction $ef06256079686ba0$export$f8aeda7b10753fa1(description) {\n    let [id, setId] = (0, $12uGp$useState)(undefined);\n    (0, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{\n        if (!description) return;\n        let desc = $ef06256079686ba0$var$descriptionNodes.get(description);\n        if (!desc) {\n            let id = `react-aria-description-${$ef06256079686ba0$var$descriptionId++}`;\n            setId(id);\n            let node = document.createElement(\"div\");\n            node.id = id;\n            node.style.display = \"none\";\n            node.textContent = description;\n            document.body.appendChild(node);\n            desc = {\n                refCount: 0,\n                element: node\n            };\n            $ef06256079686ba0$var$descriptionNodes.set(description, desc);\n        } else setId(desc.element.id);\n        desc.refCount++;\n        return ()=>{\n            if (--desc.refCount === 0) {\n                desc.element.remove();\n                $ef06256079686ba0$var$descriptionNodes.delete(description);\n            }\n        };\n    }, [\n        description\n    ]);\n    return {\n        \"aria-describedby\": description ? id : undefined\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ function $c87311424ea30a05$var$testUserAgent(re) {\n    var _window_navigator_userAgentData;\n    if (typeof window === \"undefined\" || window.navigator == null) return false;\n    return ((_window_navigator_userAgentData = window.navigator[\"userAgentData\"]) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.brands.some((brand)=>re.test(brand.brand))) || re.test(window.navigator.userAgent);\n}\nfunction $c87311424ea30a05$var$testPlatform(re) {\n    var _window_navigator_userAgentData;\n    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;\n}\nfunction $c87311424ea30a05$export$9ac100e40613ea10() {\n    return $c87311424ea30a05$var$testPlatform(/^Mac/i);\n}\nfunction $c87311424ea30a05$export$186c6964ca17d99() {\n    return $c87311424ea30a05$var$testPlatform(/^iPhone/i);\n}\nfunction $c87311424ea30a05$export$7bef049ce92e4224() {\n    return $c87311424ea30a05$var$testPlatform(/^iPad/i) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.\n    $c87311424ea30a05$export$9ac100e40613ea10() && navigator.maxTouchPoints > 1;\n}\nfunction $c87311424ea30a05$export$fedb369cb70207f1() {\n    return $c87311424ea30a05$export$186c6964ca17d99() || $c87311424ea30a05$export$7bef049ce92e4224();\n}\nfunction $c87311424ea30a05$export$e1865c3bedcd822b() {\n    return $c87311424ea30a05$export$9ac100e40613ea10() || $c87311424ea30a05$export$fedb369cb70207f1();\n}\nfunction $c87311424ea30a05$export$78551043582a6a98() {\n    return $c87311424ea30a05$var$testUserAgent(/AppleWebKit/i) && !$c87311424ea30a05$export$6446a186d09e379e();\n}\nfunction $c87311424ea30a05$export$6446a186d09e379e() {\n    return $c87311424ea30a05$var$testUserAgent(/Chrome/i);\n}\nfunction $c87311424ea30a05$export$a11b0059900ceec8() {\n    return $c87311424ea30a05$var$testUserAgent(/Android/i);\n}\n\n\n/*\n * Copyright 2021 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nfunction $e9faafb641e167db$export$90fc3a17d93f704c(ref, event, handler, options) {\n    let handlerRef = (0, $12uGp$useRef)(handler);\n    handlerRef.current = handler;\n    let isDisabled = handler == null;\n    (0, $12uGp$useEffect)(()=>{\n        if (isDisabled) return;\n        let element = ref.current;\n        let handler = (e)=>handlerRef.current.call(this, e);\n        element.addEventListener(event, handler, options);\n        return ()=>{\n            element.removeEventListener(event, handler, options);\n        };\n    }, [\n        ref,\n        event,\n        options,\n        isDisabled\n    ]);\n}\n\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nfunction $2f04cbc44ee30ce0$export$53a0910f038337bd(scrollView, element) {\n    let offsetX = $2f04cbc44ee30ce0$var$relativeOffset(scrollView, element, \"left\");\n    let offsetY = $2f04cbc44ee30ce0$var$relativeOffset(scrollView, element, \"top\");\n    let width = element.offsetWidth;\n    let height = element.offsetHeight;\n    let x = scrollView.scrollLeft;\n    let y = scrollView.scrollTop;\n    // Account for top/left border offsetting the scroll top/Left\n    let { borderTopWidth: borderTopWidth , borderLeftWidth: borderLeftWidth  } = getComputedStyle(scrollView);\n    let borderAdjustedX = scrollView.scrollLeft + parseInt(borderLeftWidth, 10);\n    let borderAdjustedY = scrollView.scrollTop + parseInt(borderTopWidth, 10);\n    // Ignore end/bottom border via clientHeight/Width instead of offsetHeight/Width\n    let maxX = borderAdjustedX + scrollView.clientWidth;\n    let maxY = borderAdjustedY + scrollView.clientHeight;\n    if (offsetX <= x) x = offsetX - parseInt(borderLeftWidth, 10);\n    else if (offsetX + width > maxX) x += offsetX + width - maxX;\n    if (offsetY <= borderAdjustedY) y = offsetY - parseInt(borderTopWidth, 10);\n    else if (offsetY + height > maxY) y += offsetY + height - maxY;\n    scrollView.scrollLeft = x;\n    scrollView.scrollTop = y;\n}\n/**\n * Computes the offset left or top from child to ancestor by accumulating\n * offsetLeft or offsetTop through intervening offsetParents.\n */ function $2f04cbc44ee30ce0$var$relativeOffset(ancestor, child, axis) {\n    const prop = axis === \"left\" ? \"offsetLeft\" : \"offsetTop\";\n    let sum = 0;\n    while(child.offsetParent){\n        sum += child[prop];\n        if (child.offsetParent === ancestor) break;\n        else if (child.offsetParent.contains(ancestor)) {\n            // If the ancestor is not `position:relative`, then we stop at\n            // _its_ offset parent, and we subtract off _its_ offset, so that\n            // we end up with the proper offset from child to ancestor.\n            sum -= ancestor[prop];\n            break;\n        }\n        child = child.offsetParent;\n    }\n    return sum;\n}\nfunction $2f04cbc44ee30ce0$export$c826860796309d1b(targetElement, opts) {\n    if (document.contains(targetElement)) {\n        let root = document.scrollingElement || document.documentElement;\n        let isScrollPrevented = window.getComputedStyle(root).overflow === \"hidden\";\n        // If scrolling is not currently prevented then we aren’t in a overlay nor is a overlay open, just use element.scrollIntoView to bring the element into view\n        if (!isScrollPrevented) {\n            var // use scrollIntoView({block: 'nearest'}) instead of .focus to check if the element is fully in view or not since .focus()\n            // won't cause a scroll if the element is already focused and doesn't behave consistently when an element is partially out of view horizontally vs vertically\n            _targetElement_scrollIntoView;\n            let { left: originalLeft , top: originalTop  } = targetElement.getBoundingClientRect();\n            targetElement === null || targetElement === void 0 ? void 0 : (_targetElement_scrollIntoView = targetElement.scrollIntoView) === null || _targetElement_scrollIntoView === void 0 ? void 0 : _targetElement_scrollIntoView.call(targetElement, {\n                block: \"nearest\"\n            });\n            let { left: newLeft , top: newTop  } = targetElement.getBoundingClientRect();\n            // Account for sub pixel differences from rounding\n            if (Math.abs(originalLeft - newLeft) > 1 || Math.abs(originalTop - newTop) > 1) {\n                var _opts_containingElement, _opts_containingElement_scrollIntoView, _targetElement_scrollIntoView1;\n                opts === null || opts === void 0 ? void 0 : (_opts_containingElement = opts.containingElement) === null || _opts_containingElement === void 0 ? void 0 : (_opts_containingElement_scrollIntoView = _opts_containingElement.scrollIntoView) === null || _opts_containingElement_scrollIntoView === void 0 ? void 0 : _opts_containingElement_scrollIntoView.call(_opts_containingElement, {\n                    block: \"center\",\n                    inline: \"center\"\n                });\n                (_targetElement_scrollIntoView1 = targetElement.scrollIntoView) === null || _targetElement_scrollIntoView1 === void 0 ? void 0 : _targetElement_scrollIntoView1.call(targetElement, {\n                    block: \"nearest\"\n                });\n            }\n        } else {\n            let scrollParent = (0, $62d8ded9296f3872$export$cfa2225e87938781)(targetElement);\n            // If scrolling is prevented, we don't want to scroll the body since it might move the overlay partially offscreen and the user can't scroll it back into view.\n            while(targetElement && scrollParent && targetElement !== root && scrollParent !== root){\n                $2f04cbc44ee30ce0$export$53a0910f038337bd(scrollParent, targetElement);\n                targetElement = scrollParent;\n                scrollParent = (0, $62d8ded9296f3872$export$cfa2225e87938781)(targetElement);\n            }\n        }\n    }\n}\n\n\n\n/*\n * Copyright 2022 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nfunction $6a7db85432448f7f$export$60278871457622de(event) {\n    // JAWS/NVDA with Firefox.\n    if (event.mozInputSource === 0 && event.isTrusted) return true;\n    // Android TalkBack's detail value varies depending on the event listener providing the event so we have specific logic here instead\n    // If pointerType is defined, event is from a click listener. For events from mousedown listener, detail === 0 is a sufficient check\n    // to detect TalkBack virtual clicks.\n    if ((0, $c87311424ea30a05$export$a11b0059900ceec8)() && event.pointerType) return event.type === \"click\" && event.buttons === 1;\n    return event.detail === 0 && !event.pointerType;\n}\nfunction $6a7db85432448f7f$export$29bf1b5f2c56cf63(event) {\n    // If the pointer size is zero, then we assume it's from a screen reader.\n    // Android TalkBack double tap will sometimes return a event with width and height of 1\n    // and pointerType === 'mouse' so we need to check for a specific combination of event attributes.\n    // Cannot use \"event.pressure === 0\" as the sole check due to Safari pointer events always returning pressure === 0\n    // instead of .5, see https://bugs.webkit.org/show_bug.cgi?id=206216. event.pointerType === 'mouse' is to distingush\n    // Talkback double tap from Windows Firefox touch screen press\n    return event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === \"mouse\";\n}\n\n\n/*\n * Copyright 2023 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\nfunction $8ae05eaa5c114e9c$export$7f54fc3180508a52(fn) {\n    const ref = (0, $12uGp$useRef)(null);\n    (0, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{\n        ref.current = fn;\n    }, [\n        fn\n    ]);\n    return (0, $12uGp$useCallback)((...args)=>{\n        const f = ref.current;\n        return f(...args);\n    }, []);\n}\n\n\n\n\nexport {$bdb11010cef70236$export$f680877a34711e37 as useId, $bdb11010cef70236$export$cd8c9cb68f842629 as mergeIds, $bdb11010cef70236$export$b4cc09c592e8fdb8 as useSlotId, $ff5963eb1fccf552$export$e08e3b67e392101e as chain, $3ef42575df84b30b$export$9d1611c77c2fe928 as mergeProps, $5dc95899b306f630$export$c9058316764c140e as mergeRefs, $65484d02dcb7eb3e$export$457c3d6518dd4c6f as filterDOMProps, $7215afc6de606d6b$export$de79e2c695e052f3 as focusWithoutScrolling, $ab71dadb03a6fb2e$export$622cea445a1c5b7d as getOffset, $bbed8b41f857bcc0$export$24490316f764c430 as runAfterTransition, $9cc09df9fd7676be$export$7bbed75feba39706 as useDrag1D, $03deb23ff14920c4$export$4eaf04e54aa8eed6 as useGlobalListeners, $313b98861ee5dd6c$export$d6875122194c7b44 as useLabels, $df56164dff5785e2$export$4338b53315abf666 as useObjectRef, $4f58c5f72bcf79f7$export$496315a1608d9602 as useUpdateEffect, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c as useLayoutEffect, $9daab02d461809db$export$683480f191c0e3ea as useResizeObserver, $e7801be82b4b2a53$export$4debdb1a3f0fa79e as useSyncRef, $62d8ded9296f3872$export$cfa2225e87938781 as getScrollParent, $62d8ded9296f3872$export$2bb74740c4e19def as isScrollable, $5df64b3807dc15ee$export$d699905dd57c73ca as useViewportSize, $ef06256079686ba0$export$f8aeda7b10753fa1 as useDescription, $c87311424ea30a05$export$9ac100e40613ea10 as isMac, $c87311424ea30a05$export$186c6964ca17d99 as isIPhone, $c87311424ea30a05$export$7bef049ce92e4224 as isIPad, $c87311424ea30a05$export$fedb369cb70207f1 as isIOS, $c87311424ea30a05$export$e1865c3bedcd822b as isAppleDevice, $c87311424ea30a05$export$78551043582a6a98 as isWebKit, $c87311424ea30a05$export$6446a186d09e379e as isChrome, $c87311424ea30a05$export$a11b0059900ceec8 as isAndroid, $e9faafb641e167db$export$90fc3a17d93f704c as useEvent, $1dbecbe27a04f9af$export$14d238f342723f25 as useValueEffect, $2f04cbc44ee30ce0$export$53a0910f038337bd as scrollIntoView, $2f04cbc44ee30ce0$export$c826860796309d1b as scrollIntoViewport, $4507461a1b870123$re_export$clamp as clamp, $4507461a1b870123$re_export$snapValueToStep as snapValueToStep, $6a7db85432448f7f$export$60278871457622de as isVirtualClick, $6a7db85432448f7f$export$29bf1b5f2c56cf63 as isVirtualPointerEvent, $8ae05eaa5c114e9c$export$7f54fc3180508a52 as useEffectEvent};\n//# sourceMappingURL=module.js.map\n","import {mergeProps as $bx7SL$mergeProps, useSyncRef as $bx7SL$useSyncRef, useGlobalListeners as $bx7SL$useGlobalListeners, isVirtualClick as $bx7SL$isVirtualClick, focusWithoutScrolling as $bx7SL$focusWithoutScrolling, isVirtualPointerEvent as $bx7SL$isVirtualPointerEvent, isIOS as $bx7SL$isIOS, runAfterTransition as $bx7SL$runAfterTransition, useLayoutEffect as $bx7SL$useLayoutEffect, isMac as $bx7SL$isMac, useEvent as $bx7SL$useEvent, useDescription as $bx7SL$useDescription} from \"@react-aria/utils\";\nimport $bx7SL$react, {useRef as $bx7SL$useRef, useContext as $bx7SL$useContext, useState as $bx7SL$useState, useMemo as $bx7SL$useMemo, useEffect as $bx7SL$useEffect, useCallback as $bx7SL$useCallback} from \"react\";\nimport {useIsSSR as $bx7SL$useIsSSR} from \"@react-aria/ssr\";\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ /*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // Portions of the code in this file are based on code from react.\n// Original licensing for the following can be found in the\n// NOTICE file in the root directory of this source tree.\n// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n// Note that state only matters here for iOS. Non-iOS gets user-select: none applied to the target element\n// rather than at the document level so we just need to apply/remove user-select: none for each pressed element individually\nlet $14c0b72509d70225$var$state = \"default\";\nlet $14c0b72509d70225$var$savedUserSelect = \"\";\nlet $14c0b72509d70225$var$modifiedElementMap = new WeakMap();\nfunction $14c0b72509d70225$export$16a4697467175487(target) {\n    if ((0, $bx7SL$isIOS)()) {\n        if ($14c0b72509d70225$var$state === \"default\") {\n            $14c0b72509d70225$var$savedUserSelect = document.documentElement.style.webkitUserSelect;\n            document.documentElement.style.webkitUserSelect = \"none\";\n        }\n        $14c0b72509d70225$var$state = \"disabled\";\n    } else if (target instanceof HTMLElement || target instanceof SVGElement) {\n        // If not iOS, store the target's original user-select and change to user-select: none\n        // Ignore state since it doesn't apply for non iOS\n        $14c0b72509d70225$var$modifiedElementMap.set(target, target.style.userSelect);\n        target.style.userSelect = \"none\";\n    }\n}\nfunction $14c0b72509d70225$export$b0d6fa1ab32e3295(target) {\n    if ((0, $bx7SL$isIOS)()) {\n        // If the state is already default, there's nothing to do.\n        // If it is restoring, then there's no need to queue a second restore.\n        if ($14c0b72509d70225$var$state !== \"disabled\") return;\n        $14c0b72509d70225$var$state = \"restoring\";\n        // There appears to be a delay on iOS where selection still might occur\n        // after pointer up, so wait a bit before removing user-select.\n        setTimeout(()=>{\n            // Wait for any CSS transitions to complete so we don't recompute style\n            // for the whole page in the middle of the animation and cause jank.\n            (0, $bx7SL$runAfterTransition)(()=>{\n                // Avoid race conditions\n                if ($14c0b72509d70225$var$state === \"restoring\") {\n                    if (document.documentElement.style.webkitUserSelect === \"none\") document.documentElement.style.webkitUserSelect = $14c0b72509d70225$var$savedUserSelect || \"\";\n                    $14c0b72509d70225$var$savedUserSelect = \"\";\n                    $14c0b72509d70225$var$state = \"default\";\n                }\n            });\n        }, 300);\n    } else if (target instanceof HTMLElement || target instanceof SVGElement) // If not iOS, restore the target's original user-select if any\n    // Ignore state since it doesn't apply for non iOS\n    {\n        if (target && $14c0b72509d70225$var$modifiedElementMap.has(target)) {\n            let targetOldUserSelect = $14c0b72509d70225$var$modifiedElementMap.get(target);\n            if (target.style.userSelect === \"none\") target.style.userSelect = targetOldUserSelect;\n            if (target.getAttribute(\"style\") === \"\") target.removeAttribute(\"style\");\n            $14c0b72509d70225$var$modifiedElementMap.delete(target);\n        }\n    }\n}\n\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \nconst $ae1eeba8b9eafd08$export$5165eccb35aaadb5 = (0, $bx7SL$react).createContext(null);\n$ae1eeba8b9eafd08$export$5165eccb35aaadb5.displayName = \"PressResponderContext\";\n\n\n\nfunction $f6c31cce2adf654f$var$usePressResponderContext(props) {\n    // Consume context from <PressResponder> and merge with props.\n    let context = (0, $bx7SL$useContext)((0, $ae1eeba8b9eafd08$export$5165eccb35aaadb5));\n    if (context) {\n        let { register: register , ...contextProps } = context;\n        props = (0, $bx7SL$mergeProps)(contextProps, props);\n        register();\n    }\n    (0, $bx7SL$useSyncRef)(context, props.ref);\n    return props;\n}\nfunction $f6c31cce2adf654f$export$45712eceda6fad21(props) {\n    let { onPress: onPress , onPressChange: onPressChange , onPressStart: onPressStart , onPressEnd: onPressEnd , onPressUp: onPressUp , isDisabled: isDisabled , isPressed: isPressedProp , preventFocusOnPress: preventFocusOnPress , shouldCancelOnPointerExit: shouldCancelOnPointerExit , allowTextSelectionOnPress: allowTextSelectionOnPress , // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ref: _ , ...domProps } = $f6c31cce2adf654f$var$usePressResponderContext(props);\n    let propsRef = (0, $bx7SL$useRef)(null);\n    propsRef.current = {\n        onPress: onPress,\n        onPressChange: onPressChange,\n        onPressStart: onPressStart,\n        onPressEnd: onPressEnd,\n        onPressUp: onPressUp,\n        isDisabled: isDisabled,\n        shouldCancelOnPointerExit: shouldCancelOnPointerExit\n    };\n    let [isPressed, setPressed] = (0, $bx7SL$useState)(false);\n    let ref = (0, $bx7SL$useRef)({\n        isPressed: false,\n        ignoreEmulatedMouseEvents: false,\n        ignoreClickAfterPress: false,\n        didFirePressStart: false,\n        activePointerId: null,\n        target: null,\n        isOverTarget: false,\n        pointerType: null\n    });\n    let { addGlobalListener: addGlobalListener , removeAllGlobalListeners: removeAllGlobalListeners  } = (0, $bx7SL$useGlobalListeners)();\n    let pressProps = (0, $bx7SL$useMemo)(()=>{\n        let state = ref.current;\n        let triggerPressStart = (originalEvent, pointerType)=>{\n            let { onPressStart: onPressStart , onPressChange: onPressChange , isDisabled: isDisabled  } = propsRef.current;\n            if (isDisabled || state.didFirePressStart) return;\n            if (onPressStart) onPressStart({\n                type: \"pressstart\",\n                pointerType: pointerType,\n                target: originalEvent.currentTarget,\n                shiftKey: originalEvent.shiftKey,\n                metaKey: originalEvent.metaKey,\n                ctrlKey: originalEvent.ctrlKey,\n                altKey: originalEvent.altKey\n            });\n            if (onPressChange) onPressChange(true);\n            state.didFirePressStart = true;\n            setPressed(true);\n        };\n        let triggerPressEnd = (originalEvent, pointerType, wasPressed = true)=>{\n            let { onPressEnd: onPressEnd , onPressChange: onPressChange , onPress: onPress , isDisabled: isDisabled  } = propsRef.current;\n            if (!state.didFirePressStart) return;\n            state.ignoreClickAfterPress = true;\n            state.didFirePressStart = false;\n            if (onPressEnd) onPressEnd({\n                type: \"pressend\",\n                pointerType: pointerType,\n                target: originalEvent.currentTarget,\n                shiftKey: originalEvent.shiftKey,\n                metaKey: originalEvent.metaKey,\n                ctrlKey: originalEvent.ctrlKey,\n                altKey: originalEvent.altKey\n            });\n            if (onPressChange) onPressChange(false);\n            setPressed(false);\n            if (onPress && wasPressed && !isDisabled) onPress({\n                type: \"press\",\n                pointerType: pointerType,\n                target: originalEvent.currentTarget,\n                shiftKey: originalEvent.shiftKey,\n                metaKey: originalEvent.metaKey,\n                ctrlKey: originalEvent.ctrlKey,\n                altKey: originalEvent.altKey\n            });\n        };\n        let triggerPressUp = (originalEvent, pointerType)=>{\n            let { onPressUp: onPressUp , isDisabled: isDisabled  } = propsRef.current;\n            if (isDisabled) return;\n            if (onPressUp) onPressUp({\n                type: \"pressup\",\n                pointerType: pointerType,\n                target: originalEvent.currentTarget,\n                shiftKey: originalEvent.shiftKey,\n                metaKey: originalEvent.metaKey,\n                ctrlKey: originalEvent.ctrlKey,\n                altKey: originalEvent.altKey\n            });\n        };\n        let cancel = (e)=>{\n            if (state.isPressed) {\n                if (state.isOverTarget) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType, false);\n                state.isPressed = false;\n                state.isOverTarget = false;\n                state.activePointerId = null;\n                state.pointerType = null;\n                removeAllGlobalListeners();\n                if (!allowTextSelectionOnPress) (0, $14c0b72509d70225$export$b0d6fa1ab32e3295)(state.target);\n            }\n        };\n        let pressProps = {\n            onKeyDown (e) {\n                if ($f6c31cce2adf654f$var$isValidKeyboardEvent(e.nativeEvent, e.currentTarget) && e.currentTarget.contains(e.target)) {\n                    if ($f6c31cce2adf654f$var$shouldPreventDefaultKeyboard(e.target, e.key)) e.preventDefault();\n                    e.stopPropagation();\n                    // If the event is repeating, it may have started on a different element\n                    // after which focus moved to the current element. Ignore these events and\n                    // only handle the first key down event.\n                    if (!state.isPressed && !e.repeat) {\n                        state.target = e.currentTarget;\n                        state.isPressed = true;\n                        triggerPressStart(e, \"keyboard\");\n                        // Focus may move before the key up event, so register the event on the document\n                        // instead of the same element where the key down event occurred.\n                        addGlobalListener(document, \"keyup\", onKeyUp, false);\n                    }\n                } else if (e.key === \"Enter\" && $f6c31cce2adf654f$var$isHTMLAnchorLink(e.currentTarget)) // If the target is a link, we won't have handled this above because we want the default\n                // browser behavior to open the link when pressing Enter. But we still need to prevent\n                // default so that elements above do not also handle it (e.g. table row).\n                e.stopPropagation();\n            },\n            onKeyUp (e) {\n                if ($f6c31cce2adf654f$var$isValidKeyboardEvent(e.nativeEvent, e.currentTarget) && !e.repeat && e.currentTarget.contains(e.target)) triggerPressUp($f6c31cce2adf654f$var$createEvent(state.target, e), \"keyboard\");\n            },\n            onClick (e) {\n                if (e && !e.currentTarget.contains(e.target)) return;\n                if (e && e.button === 0) {\n                    e.stopPropagation();\n                    if (isDisabled) e.preventDefault();\n                    // If triggered from a screen reader or by using element.click(),\n                    // trigger as if it were a keyboard click.\n                    if (!state.ignoreClickAfterPress && !state.ignoreEmulatedMouseEvents && (state.pointerType === \"virtual\" || (0, $bx7SL$isVirtualClick)(e.nativeEvent))) {\n                        // Ensure the element receives focus (VoiceOver on iOS does not do this)\n                        if (!isDisabled && !preventFocusOnPress) (0, $bx7SL$focusWithoutScrolling)(e.currentTarget);\n                        triggerPressStart(e, \"virtual\");\n                        triggerPressUp(e, \"virtual\");\n                        triggerPressEnd(e, \"virtual\");\n                    }\n                    state.ignoreEmulatedMouseEvents = false;\n                    state.ignoreClickAfterPress = false;\n                }\n            }\n        };\n        let onKeyUp = (e)=>{\n            if (state.isPressed && $f6c31cce2adf654f$var$isValidKeyboardEvent(e, state.target)) {\n                if ($f6c31cce2adf654f$var$shouldPreventDefaultKeyboard(e.target, e.key)) e.preventDefault();\n                e.stopPropagation();\n                state.isPressed = false;\n                let target = e.target;\n                triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), \"keyboard\", state.target.contains(target));\n                removeAllGlobalListeners();\n                // If the target is a link, trigger the click method to open the URL,\n                // but defer triggering pressEnd until onClick event handler.\n                if (state.target instanceof HTMLElement && state.target.contains(target) && ($f6c31cce2adf654f$var$isHTMLAnchorLink(state.target) || state.target.getAttribute(\"role\") === \"link\")) state.target.click();\n            }\n        };\n        if (typeof PointerEvent !== \"undefined\") {\n            pressProps.onPointerDown = (e)=>{\n                // Only handle left clicks, and ignore events that bubbled through portals.\n                if (e.button !== 0 || !e.currentTarget.contains(e.target)) return;\n                // iOS safari fires pointer events from VoiceOver with incorrect coordinates/target.\n                // Ignore and let the onClick handler take care of it instead.\n                // https://bugs.webkit.org/show_bug.cgi?id=222627\n                // https://bugs.webkit.org/show_bug.cgi?id=223202\n                if ((0, $bx7SL$isVirtualPointerEvent)(e.nativeEvent)) {\n                    state.pointerType = \"virtual\";\n                    return;\n                }\n                // Due to browser inconsistencies, especially on mobile browsers, we prevent\n                // default on pointer down and handle focusing the pressable element ourselves.\n                if ($f6c31cce2adf654f$var$shouldPreventDefault(e.currentTarget)) e.preventDefault();\n                state.pointerType = e.pointerType;\n                e.stopPropagation();\n                if (!state.isPressed) {\n                    state.isPressed = true;\n                    state.isOverTarget = true;\n                    state.activePointerId = e.pointerId;\n                    state.target = e.currentTarget;\n                    if (!isDisabled && !preventFocusOnPress) (0, $bx7SL$focusWithoutScrolling)(e.currentTarget);\n                    if (!allowTextSelectionOnPress) (0, $14c0b72509d70225$export$16a4697467175487)(state.target);\n                    triggerPressStart(e, state.pointerType);\n                    addGlobalListener(document, \"pointermove\", onPointerMove, false);\n                    addGlobalListener(document, \"pointerup\", onPointerUp, false);\n                    addGlobalListener(document, \"pointercancel\", onPointerCancel, false);\n                }\n            };\n            pressProps.onMouseDown = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                if (e.button === 0) {\n                    // Chrome and Firefox on touch Windows devices require mouse down events\n                    // to be canceled in addition to pointer events, or an extra asynchronous\n                    // focus event will be fired.\n                    if ($f6c31cce2adf654f$var$shouldPreventDefault(e.currentTarget)) e.preventDefault();\n                    e.stopPropagation();\n                }\n            };\n            pressProps.onPointerUp = (e)=>{\n                // iOS fires pointerup with zero width and height, so check the pointerType recorded during pointerdown.\n                if (!e.currentTarget.contains(e.target) || state.pointerType === \"virtual\") return;\n                // Only handle left clicks\n                // Safari on iOS sometimes fires pointerup events, even\n                // when the touch isn't over the target, so double check.\n                if (e.button === 0 && $f6c31cce2adf654f$var$isOverTarget(e, e.currentTarget)) triggerPressUp(e, state.pointerType || e.pointerType);\n            };\n            // Safari on iOS < 13.2 does not implement pointerenter/pointerleave events correctly.\n            // Use pointer move events instead to implement our own hit testing.\n            // See https://bugs.webkit.org/show_bug.cgi?id=199803\n            let onPointerMove = (e)=>{\n                if (e.pointerId !== state.activePointerId) return;\n                if ($f6c31cce2adf654f$var$isOverTarget(e, state.target)) {\n                    if (!state.isOverTarget) {\n                        state.isOverTarget = true;\n                        triggerPressStart($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType);\n                    }\n                } else if (state.isOverTarget) {\n                    state.isOverTarget = false;\n                    triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType, false);\n                    if (propsRef.current.shouldCancelOnPointerExit) cancel(e);\n                }\n            };\n            let onPointerUp = (e)=>{\n                if (e.pointerId === state.activePointerId && state.isPressed && e.button === 0) {\n                    if ($f6c31cce2adf654f$var$isOverTarget(e, state.target)) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType);\n                    else if (state.isOverTarget) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType, false);\n                    state.isPressed = false;\n                    state.isOverTarget = false;\n                    state.activePointerId = null;\n                    state.pointerType = null;\n                    removeAllGlobalListeners();\n                    if (!allowTextSelectionOnPress) (0, $14c0b72509d70225$export$b0d6fa1ab32e3295)(state.target);\n                }\n            };\n            let onPointerCancel = (e)=>{\n                cancel(e);\n            };\n            pressProps.onDragStart = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                // Safari does not call onPointerCancel when a drag starts, whereas Chrome and Firefox do.\n                cancel(e);\n            };\n        } else {\n            pressProps.onMouseDown = (e)=>{\n                // Only handle left clicks\n                if (e.button !== 0 || !e.currentTarget.contains(e.target)) return;\n                // Due to browser inconsistencies, especially on mobile browsers, we prevent\n                // default on mouse down and handle focusing the pressable element ourselves.\n                if ($f6c31cce2adf654f$var$shouldPreventDefault(e.currentTarget)) e.preventDefault();\n                e.stopPropagation();\n                if (state.ignoreEmulatedMouseEvents) return;\n                state.isPressed = true;\n                state.isOverTarget = true;\n                state.target = e.currentTarget;\n                state.pointerType = (0, $bx7SL$isVirtualClick)(e.nativeEvent) ? \"virtual\" : \"mouse\";\n                if (!isDisabled && !preventFocusOnPress) (0, $bx7SL$focusWithoutScrolling)(e.currentTarget);\n                triggerPressStart(e, state.pointerType);\n                addGlobalListener(document, \"mouseup\", onMouseUp, false);\n            };\n            pressProps.onMouseEnter = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                e.stopPropagation();\n                if (state.isPressed && !state.ignoreEmulatedMouseEvents) {\n                    state.isOverTarget = true;\n                    triggerPressStart(e, state.pointerType);\n                }\n            };\n            pressProps.onMouseLeave = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                e.stopPropagation();\n                if (state.isPressed && !state.ignoreEmulatedMouseEvents) {\n                    state.isOverTarget = false;\n                    triggerPressEnd(e, state.pointerType, false);\n                    if (propsRef.current.shouldCancelOnPointerExit) cancel(e);\n                }\n            };\n            pressProps.onMouseUp = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                if (!state.ignoreEmulatedMouseEvents && e.button === 0) triggerPressUp(e, state.pointerType);\n            };\n            let onMouseUp = (e)=>{\n                // Only handle left clicks\n                if (e.button !== 0) return;\n                state.isPressed = false;\n                removeAllGlobalListeners();\n                if (state.ignoreEmulatedMouseEvents) {\n                    state.ignoreEmulatedMouseEvents = false;\n                    return;\n                }\n                if ($f6c31cce2adf654f$var$isOverTarget(e, state.target)) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType);\n                else if (state.isOverTarget) triggerPressEnd($f6c31cce2adf654f$var$createEvent(state.target, e), state.pointerType, false);\n                state.isOverTarget = false;\n            };\n            pressProps.onTouchStart = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                e.stopPropagation();\n                let touch = $f6c31cce2adf654f$var$getTouchFromEvent(e.nativeEvent);\n                if (!touch) return;\n                state.activePointerId = touch.identifier;\n                state.ignoreEmulatedMouseEvents = true;\n                state.isOverTarget = true;\n                state.isPressed = true;\n                state.target = e.currentTarget;\n                state.pointerType = \"touch\";\n                // Due to browser inconsistencies, especially on mobile browsers, we prevent default\n                // on the emulated mouse event and handle focusing the pressable element ourselves.\n                if (!isDisabled && !preventFocusOnPress) (0, $bx7SL$focusWithoutScrolling)(e.currentTarget);\n                if (!allowTextSelectionOnPress) (0, $14c0b72509d70225$export$16a4697467175487)(state.target);\n                triggerPressStart(e, state.pointerType);\n                addGlobalListener(window, \"scroll\", onScroll, true);\n            };\n            pressProps.onTouchMove = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                e.stopPropagation();\n                if (!state.isPressed) return;\n                let touch = $f6c31cce2adf654f$var$getTouchById(e.nativeEvent, state.activePointerId);\n                if (touch && $f6c31cce2adf654f$var$isOverTarget(touch, e.currentTarget)) {\n                    if (!state.isOverTarget) {\n                        state.isOverTarget = true;\n                        triggerPressStart(e, state.pointerType);\n                    }\n                } else if (state.isOverTarget) {\n                    state.isOverTarget = false;\n                    triggerPressEnd(e, state.pointerType, false);\n                    if (propsRef.current.shouldCancelOnPointerExit) cancel(e);\n                }\n            };\n            pressProps.onTouchEnd = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                e.stopPropagation();\n                if (!state.isPressed) return;\n                let touch = $f6c31cce2adf654f$var$getTouchById(e.nativeEvent, state.activePointerId);\n                if (touch && $f6c31cce2adf654f$var$isOverTarget(touch, e.currentTarget)) {\n                    triggerPressUp(e, state.pointerType);\n                    triggerPressEnd(e, state.pointerType);\n                } else if (state.isOverTarget) triggerPressEnd(e, state.pointerType, false);\n                state.isPressed = false;\n                state.activePointerId = null;\n                state.isOverTarget = false;\n                state.ignoreEmulatedMouseEvents = true;\n                if (!allowTextSelectionOnPress) (0, $14c0b72509d70225$export$b0d6fa1ab32e3295)(state.target);\n                removeAllGlobalListeners();\n            };\n            pressProps.onTouchCancel = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                e.stopPropagation();\n                if (state.isPressed) cancel(e);\n            };\n            let onScroll = (e)=>{\n                if (state.isPressed && e.target.contains(state.target)) cancel({\n                    currentTarget: state.target,\n                    shiftKey: false,\n                    ctrlKey: false,\n                    metaKey: false,\n                    altKey: false\n                });\n            };\n            pressProps.onDragStart = (e)=>{\n                if (!e.currentTarget.contains(e.target)) return;\n                cancel(e);\n            };\n        }\n        return pressProps;\n    }, [\n        addGlobalListener,\n        isDisabled,\n        preventFocusOnPress,\n        removeAllGlobalListeners,\n        allowTextSelectionOnPress\n    ]);\n    // Remove user-select: none in case component unmounts immediately after pressStart\n    // eslint-disable-next-line arrow-body-style\n    (0, $bx7SL$useEffect)(()=>{\n        return ()=>{\n            if (!allowTextSelectionOnPress) // eslint-disable-next-line react-hooks/exhaustive-deps\n            (0, $14c0b72509d70225$export$b0d6fa1ab32e3295)(ref.current.target);\n        };\n    }, [\n        allowTextSelectionOnPress\n    ]);\n    return {\n        isPressed: isPressedProp || isPressed,\n        pressProps: (0, $bx7SL$mergeProps)(domProps, pressProps)\n    };\n}\nfunction $f6c31cce2adf654f$var$isHTMLAnchorLink(target) {\n    return target.tagName === \"A\" && target.hasAttribute(\"href\");\n}\nfunction $f6c31cce2adf654f$var$isValidKeyboardEvent(event, currentTarget) {\n    const { key: key , code: code  } = event;\n    const element = currentTarget;\n    const role = element.getAttribute(\"role\");\n    // Accessibility for keyboards. Space and Enter only.\n    // \"Spacebar\" is for IE 11\n    return (key === \"Enter\" || key === \" \" || key === \"Spacebar\" || code === \"Space\") && !(element instanceof HTMLInputElement && !$f6c31cce2adf654f$var$isValidInputKey(element, key) || element instanceof HTMLTextAreaElement || element.isContentEditable) && // A link with a valid href should be handled natively,\n    // unless it also has role='button' and was triggered using Space.\n    (!$f6c31cce2adf654f$var$isHTMLAnchorLink(element) || role === \"button\" && key !== \"Enter\") && // An element with role='link' should only trigger with Enter key\n    !(role === \"link\" && key !== \"Enter\");\n}\nfunction $f6c31cce2adf654f$var$getTouchFromEvent(event) {\n    const { targetTouches: targetTouches  } = event;\n    if (targetTouches.length > 0) return targetTouches[0];\n    return null;\n}\nfunction $f6c31cce2adf654f$var$getTouchById(event, pointerId) {\n    const changedTouches = event.changedTouches;\n    for(let i = 0; i < changedTouches.length; i++){\n        const touch = changedTouches[i];\n        if (touch.identifier === pointerId) return touch;\n    }\n    return null;\n}\nfunction $f6c31cce2adf654f$var$createEvent(target, e) {\n    return {\n        currentTarget: target,\n        shiftKey: e.shiftKey,\n        ctrlKey: e.ctrlKey,\n        metaKey: e.metaKey,\n        altKey: e.altKey\n    };\n}\nfunction $f6c31cce2adf654f$var$getPointClientRect(point) {\n    let offsetX = point.width / 2 || point.radiusX || 0;\n    let offsetY = point.height / 2 || point.radiusY || 0;\n    return {\n        top: point.clientY - offsetY,\n        right: point.clientX + offsetX,\n        bottom: point.clientY + offsetY,\n        left: point.clientX - offsetX\n    };\n}\nfunction $f6c31cce2adf654f$var$areRectanglesOverlapping(a, b) {\n    // check if they cannot overlap on x axis\n    if (a.left > b.right || b.left > a.right) return false;\n    // check if they cannot overlap on y axis\n    if (a.top > b.bottom || b.top > a.bottom) return false;\n    return true;\n}\nfunction $f6c31cce2adf654f$var$isOverTarget(point, target) {\n    let rect = target.getBoundingClientRect();\n    let pointRect = $f6c31cce2adf654f$var$getPointClientRect(point);\n    return $f6c31cce2adf654f$var$areRectanglesOverlapping(rect, pointRect);\n}\nfunction $f6c31cce2adf654f$var$shouldPreventDefault(target) {\n    // We cannot prevent default if the target is a draggable element.\n    return !(target instanceof HTMLElement) || !target.draggable;\n}\nfunction $f6c31cce2adf654f$var$shouldPreventDefaultKeyboard(target, key) {\n    if (target instanceof HTMLInputElement) return !$f6c31cce2adf654f$var$isValidInputKey(target, key);\n    if (target instanceof HTMLButtonElement) return target.type !== \"submit\";\n    return true;\n}\nconst $f6c31cce2adf654f$var$nonTextInputTypes = new Set([\n    \"checkbox\",\n    \"radio\",\n    \"range\",\n    \"color\",\n    \"file\",\n    \"image\",\n    \"button\",\n    \"submit\",\n    \"reset\"\n]);\nfunction $f6c31cce2adf654f$var$isValidInputKey(target, key) {\n    // Only space should toggle checkboxes and radios, not enter.\n    return target.type === \"checkbox\" || target.type === \"radio\" ? key === \" \" : $f6c31cce2adf654f$var$nonTextInputTypes.has(target.type);\n}\n\n\n\nconst $3b117e43dc0ca95d$export$27c701ed9e449e99 = /*#__PURE__*/ (0, $bx7SL$react).forwardRef(({ children: children , ...props }, ref)=>{\n    let newRef = (0, $bx7SL$useRef)();\n    ref = ref !== null && ref !== void 0 ? ref : newRef;\n    let { pressProps: pressProps  } = (0, $f6c31cce2adf654f$export$45712eceda6fad21)({\n        ...props,\n        ref: ref\n    });\n    let child = (0, $bx7SL$react).Children.only(children);\n    return /*#__PURE__*/ (0, $bx7SL$react).cloneElement(child, // @ts-ignore\n    {\n        ref: ref,\n        ...(0, $bx7SL$mergeProps)(child.props, pressProps)\n    });\n});\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\nconst $f1ab8c75478c6f73$export$3351871ee4b288b8 = /*#__PURE__*/ (0, $bx7SL$react).forwardRef(({ children: children , ...props }, ref)=>{\n    let isRegistered = (0, $bx7SL$useRef)(false);\n    let prevContext = (0, $bx7SL$useContext)((0, $ae1eeba8b9eafd08$export$5165eccb35aaadb5));\n    let context = (0, $bx7SL$mergeProps)(prevContext || {}, {\n        ...props,\n        ref: ref || (prevContext === null || prevContext === void 0 ? void 0 : prevContext.ref),\n        register () {\n            isRegistered.current = true;\n            if (prevContext) prevContext.register();\n        }\n    });\n    (0, $bx7SL$useSyncRef)(prevContext, ref);\n    (0, $bx7SL$useEffect)(()=>{\n        if (!isRegistered.current) console.warn(\"A PressResponder was rendered without a pressable child. Either call the usePress hook, or wrap your DOM node with <Pressable> component.\");\n    }, []);\n    return /*#__PURE__*/ (0, $bx7SL$react).createElement((0, $ae1eeba8b9eafd08$export$5165eccb35aaadb5).Provider, {\n        value: context\n    }, children);\n});\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // Portions of the code in this file are based on code from react.\n// Original licensing for the following can be found in the\n// NOTICE file in the root directory of this source tree.\n// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\nclass $8a9cb279dc87e130$export$905e7fc544a71f36 {\n    isDefaultPrevented() {\n        return this.nativeEvent.defaultPrevented;\n    }\n    preventDefault() {\n        this.defaultPrevented = true;\n        this.nativeEvent.preventDefault();\n    }\n    stopPropagation() {\n        this.nativeEvent.stopPropagation();\n        this.isPropagationStopped = ()=>true;\n    }\n    isPropagationStopped() {\n        return false;\n    }\n    persist() {}\n    constructor(type, nativeEvent){\n        this.nativeEvent = nativeEvent;\n        this.target = nativeEvent.target;\n        this.currentTarget = nativeEvent.currentTarget;\n        this.relatedTarget = nativeEvent.relatedTarget;\n        this.bubbles = nativeEvent.bubbles;\n        this.cancelable = nativeEvent.cancelable;\n        this.defaultPrevented = nativeEvent.defaultPrevented;\n        this.eventPhase = nativeEvent.eventPhase;\n        this.isTrusted = nativeEvent.isTrusted;\n        this.timeStamp = nativeEvent.timeStamp;\n        this.type = type;\n    }\n}\nfunction $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {\n    let stateRef = (0, $bx7SL$useRef)({\n        isFocused: false,\n        onBlur: onBlur,\n        observer: null\n    });\n    stateRef.current.onBlur = onBlur;\n    // Clean up MutationObserver on unmount. See below.\n    // eslint-disable-next-line arrow-body-style\n    (0, $bx7SL$useLayoutEffect)(()=>{\n        const state = stateRef.current;\n        return ()=>{\n            if (state.observer) {\n                state.observer.disconnect();\n                state.observer = null;\n            }\n        };\n    }, []);\n    // This function is called during a React onFocus event.\n    return (0, $bx7SL$useCallback)((e)=>{\n        // React does not fire onBlur when an element is disabled. https://github.com/facebook/react/issues/9142\n        // Most browsers fire a native focusout event in this case, except for Firefox. In that case, we use a\n        // MutationObserver to watch for the disabled attribute, and dispatch these events ourselves.\n        // For browsers that do, focusout fires before the MutationObserver, so onBlur should not fire twice.\n        if (e.target instanceof HTMLButtonElement || e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement || e.target instanceof HTMLSelectElement) {\n            stateRef.current.isFocused = true;\n            let target = e.target;\n            let onBlurHandler = (e)=>{\n                var // For backward compatibility, dispatch a (fake) React synthetic event.\n                _stateRef_current, _stateRef_current_onBlur;\n                stateRef.current.isFocused = false;\n                if (target.disabled) (_stateRef_current_onBlur = (_stateRef_current = stateRef.current).onBlur) === null || _stateRef_current_onBlur === void 0 ? void 0 : _stateRef_current_onBlur.call(_stateRef_current, new $8a9cb279dc87e130$export$905e7fc544a71f36(\"blur\", e));\n                // We no longer need the MutationObserver once the target is blurred.\n                if (stateRef.current.observer) {\n                    stateRef.current.observer.disconnect();\n                    stateRef.current.observer = null;\n                }\n            };\n            target.addEventListener(\"focusout\", onBlurHandler, {\n                once: true\n            });\n            stateRef.current.observer = new MutationObserver(()=>{\n                if (stateRef.current.isFocused && target.disabled) {\n                    stateRef.current.observer.disconnect();\n                    target.dispatchEvent(new FocusEvent(\"blur\"));\n                    target.dispatchEvent(new FocusEvent(\"focusout\", {\n                        bubbles: true\n                    }));\n                }\n            });\n            stateRef.current.observer.observe(target, {\n                attributes: true,\n                attributeFilter: [\n                    \"disabled\"\n                ]\n            });\n        }\n    }, []);\n}\n\n\nfunction $a1ea59d68270f0dd$export$f8168d8dd8fd66e6(props) {\n    let { isDisabled: isDisabled , onFocus: onFocusProp , onBlur: onBlurProp , onFocusChange: onFocusChange  } = props;\n    const onBlur = (0, $bx7SL$useCallback)((e)=>{\n        if (e.target === e.currentTarget) {\n            if (onBlurProp) onBlurProp(e);\n            if (onFocusChange) onFocusChange(false);\n            return true;\n        }\n    }, [\n        onBlurProp,\n        onFocusChange\n    ]);\n    const onSyntheticFocus = (0, $8a9cb279dc87e130$export$715c682d09d639cc)(onBlur);\n    const onFocus = (0, $bx7SL$useCallback)((e)=>{\n        // Double check that document.activeElement actually matches e.target in case a previously chained\n        // focus handler already moved focus somewhere else.\n        if (e.target === e.currentTarget && document.activeElement === e.target) {\n            if (onFocusProp) onFocusProp(e);\n            if (onFocusChange) onFocusChange(true);\n            onSyntheticFocus(e);\n        }\n    }, [\n        onFocusChange,\n        onFocusProp,\n        onSyntheticFocus\n    ]);\n    return {\n        focusProps: {\n            onFocus: !isDisabled && (onFocusProp || onFocusChange || onBlurProp) ? onFocus : undefined,\n            onBlur: !isDisabled && (onBlurProp || onFocusChange) ? onBlur : undefined\n        }\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // Portions of the code in this file are based on code from react.\n// Original licensing for the following can be found in the\n// NOTICE file in the root directory of this source tree.\n// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions\n\n\n\nlet $507fabe10e71c6fb$var$currentModality = null;\nlet $507fabe10e71c6fb$var$changeHandlers = new Set();\nlet $507fabe10e71c6fb$var$hasSetupGlobalListeners = false;\nlet $507fabe10e71c6fb$var$hasEventBeforeFocus = false;\nlet $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;\n// Only Tab or Esc keys will make focus visible on text input elements\nconst $507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS = {\n    Tab: true,\n    Escape: true\n};\nfunction $507fabe10e71c6fb$var$triggerChangeHandlers(modality, e) {\n    for (let handler of $507fabe10e71c6fb$var$changeHandlers)handler(modality, e);\n}\n/**\n * Helper function to determine if a KeyboardEvent is unmodified and could make keyboard focus styles visible.\n */ function $507fabe10e71c6fb$var$isValidKey(e) {\n    // Control and Shift keys trigger when navigating back to the tab with keyboard.\n    return !(e.metaKey || !(0, $bx7SL$isMac)() && e.altKey || e.ctrlKey || e.key === \"Control\" || e.key === \"Shift\" || e.key === \"Meta\");\n}\nfunction $507fabe10e71c6fb$var$handleKeyboardEvent(e) {\n    $507fabe10e71c6fb$var$hasEventBeforeFocus = true;\n    if ($507fabe10e71c6fb$var$isValidKey(e)) {\n        $507fabe10e71c6fb$var$currentModality = \"keyboard\";\n        $507fabe10e71c6fb$var$triggerChangeHandlers(\"keyboard\", e);\n    }\n}\nfunction $507fabe10e71c6fb$var$handlePointerEvent(e) {\n    $507fabe10e71c6fb$var$currentModality = \"pointer\";\n    if (e.type === \"mousedown\" || e.type === \"pointerdown\") {\n        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;\n        $507fabe10e71c6fb$var$triggerChangeHandlers(\"pointer\", e);\n    }\n}\nfunction $507fabe10e71c6fb$var$handleClickEvent(e) {\n    if ((0, $bx7SL$isVirtualClick)(e)) {\n        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;\n        $507fabe10e71c6fb$var$currentModality = \"virtual\";\n    }\n}\nfunction $507fabe10e71c6fb$var$handleFocusEvent(e) {\n    // Firefox fires two extra focus events when the user first clicks into an iframe:\n    // first on the window, then on the document. We ignore these events so they don't\n    // cause keyboard focus rings to appear.\n    if (e.target === window || e.target === document) return;\n    // If a focus event occurs without a preceding keyboard or pointer event, switch to virtual modality.\n    // This occurs, for example, when navigating a form with the next/previous buttons on iOS.\n    if (!$507fabe10e71c6fb$var$hasEventBeforeFocus && !$507fabe10e71c6fb$var$hasBlurredWindowRecently) {\n        $507fabe10e71c6fb$var$currentModality = \"virtual\";\n        $507fabe10e71c6fb$var$triggerChangeHandlers(\"virtual\", e);\n    }\n    $507fabe10e71c6fb$var$hasEventBeforeFocus = false;\n    $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;\n}\nfunction $507fabe10e71c6fb$var$handleWindowBlur() {\n    // When the window is blurred, reset state. This is necessary when tabbing out of the window,\n    // for example, since a subsequent focus event won't be fired.\n    $507fabe10e71c6fb$var$hasEventBeforeFocus = false;\n    $507fabe10e71c6fb$var$hasBlurredWindowRecently = true;\n}\n/**\n * Setup global event listeners to control when keyboard focus style should be visible.\n */ function $507fabe10e71c6fb$var$setupGlobalFocusEvents() {\n    if (typeof window === \"undefined\" || $507fabe10e71c6fb$var$hasSetupGlobalListeners) return;\n    // Programmatic focus() calls shouldn't affect the current input modality.\n    // However, we need to detect other cases when a focus event occurs without\n    // a preceding user event (e.g. screen reader focus). Overriding the focus\n    // method on HTMLElement.prototype is a bit hacky, but works.\n    let focus = HTMLElement.prototype.focus;\n    HTMLElement.prototype.focus = function() {\n        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;\n        focus.apply(this, arguments);\n    };\n    document.addEventListener(\"keydown\", $507fabe10e71c6fb$var$handleKeyboardEvent, true);\n    document.addEventListener(\"keyup\", $507fabe10e71c6fb$var$handleKeyboardEvent, true);\n    document.addEventListener(\"click\", $507fabe10e71c6fb$var$handleClickEvent, true);\n    // Register focus events on the window so they are sure to happen\n    // before React's event listeners (registered on the document).\n    window.addEventListener(\"focus\", $507fabe10e71c6fb$var$handleFocusEvent, true);\n    window.addEventListener(\"blur\", $507fabe10e71c6fb$var$handleWindowBlur, false);\n    if (typeof PointerEvent !== \"undefined\") {\n        document.addEventListener(\"pointerdown\", $507fabe10e71c6fb$var$handlePointerEvent, true);\n        document.addEventListener(\"pointermove\", $507fabe10e71c6fb$var$handlePointerEvent, true);\n        document.addEventListener(\"pointerup\", $507fabe10e71c6fb$var$handlePointerEvent, true);\n    } else {\n        document.addEventListener(\"mousedown\", $507fabe10e71c6fb$var$handlePointerEvent, true);\n        document.addEventListener(\"mousemove\", $507fabe10e71c6fb$var$handlePointerEvent, true);\n        document.addEventListener(\"mouseup\", $507fabe10e71c6fb$var$handlePointerEvent, true);\n    }\n    $507fabe10e71c6fb$var$hasSetupGlobalListeners = true;\n}\nif (typeof document !== \"undefined\") {\n    if (document.readyState !== \"loading\") $507fabe10e71c6fb$var$setupGlobalFocusEvents();\n    else document.addEventListener(\"DOMContentLoaded\", $507fabe10e71c6fb$var$setupGlobalFocusEvents);\n}\nfunction $507fabe10e71c6fb$export$b9b3dfddab17db27() {\n    return $507fabe10e71c6fb$var$currentModality !== \"pointer\";\n}\nfunction $507fabe10e71c6fb$export$630ff653c5ada6a9() {\n    return $507fabe10e71c6fb$var$currentModality;\n}\nfunction $507fabe10e71c6fb$export$8397ddfc504fdb9a(modality) {\n    $507fabe10e71c6fb$var$currentModality = modality;\n    $507fabe10e71c6fb$var$triggerChangeHandlers(modality, null);\n}\nfunction $507fabe10e71c6fb$export$98e20ec92f614cfe() {\n    $507fabe10e71c6fb$var$setupGlobalFocusEvents();\n    let [modality, setModality] = (0, $bx7SL$useState)($507fabe10e71c6fb$var$currentModality);\n    (0, $bx7SL$useEffect)(()=>{\n        let handler = ()=>{\n            setModality($507fabe10e71c6fb$var$currentModality);\n        };\n        $507fabe10e71c6fb$var$changeHandlers.add(handler);\n        return ()=>{\n            $507fabe10e71c6fb$var$changeHandlers.delete(handler);\n        };\n    }, []);\n    return (0, $bx7SL$useIsSSR)() ? null : modality;\n}\n/**\n * If this is attached to text input component, return if the event is a focus event (Tab/Escape keys pressed) so that\n * focus visible style can be properly set.\n */ function $507fabe10e71c6fb$var$isKeyboardFocusEvent(isTextInput, modality, e) {\n    return !(isTextInput && modality === \"keyboard\" && e instanceof KeyboardEvent && !$507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS[e.key]);\n}\nfunction $507fabe10e71c6fb$export$ffd9e5021c1fb2d6(props = {}) {\n    let { isTextInput: isTextInput , autoFocus: autoFocus  } = props;\n    let [isFocusVisibleState, setFocusVisible] = (0, $bx7SL$useState)(autoFocus || $507fabe10e71c6fb$export$b9b3dfddab17db27());\n    $507fabe10e71c6fb$export$ec71b4b83ac08ec3((isFocusVisible)=>{\n        setFocusVisible(isFocusVisible);\n    }, [\n        isTextInput\n    ], {\n        isTextInput: isTextInput\n    });\n    return {\n        isFocusVisible: isFocusVisibleState\n    };\n}\nfunction $507fabe10e71c6fb$export$ec71b4b83ac08ec3(fn, deps, opts) {\n    $507fabe10e71c6fb$var$setupGlobalFocusEvents();\n    (0, $bx7SL$useEffect)(()=>{\n        let handler = (modality, e)=>{\n            if (!$507fabe10e71c6fb$var$isKeyboardFocusEvent(opts === null || opts === void 0 ? void 0 : opts.isTextInput, modality, e)) return;\n            fn($507fabe10e71c6fb$export$b9b3dfddab17db27());\n        };\n        $507fabe10e71c6fb$var$changeHandlers.add(handler);\n        return ()=>{\n            $507fabe10e71c6fb$var$changeHandlers.delete(handler);\n        };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, deps);\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // Portions of the code in this file are based on code from react.\n// Original licensing for the following can be found in the\n// NOTICE file in the root directory of this source tree.\n// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions\n\n\nfunction $9ab94262bd0047c7$export$420e68273165f4ec(props) {\n    let { isDisabled: isDisabled , onBlurWithin: onBlurWithin , onFocusWithin: onFocusWithin , onFocusWithinChange: onFocusWithinChange  } = props;\n    let state = (0, $bx7SL$useRef)({\n        isFocusWithin: false\n    });\n    let onBlur = (0, $bx7SL$useCallback)((e)=>{\n        // We don't want to trigger onBlurWithin and then immediately onFocusWithin again\n        // when moving focus inside the element. Only trigger if the currentTarget doesn't\n        // include the relatedTarget (where focus is moving).\n        if (state.current.isFocusWithin && !e.currentTarget.contains(e.relatedTarget)) {\n            state.current.isFocusWithin = false;\n            if (onBlurWithin) onBlurWithin(e);\n            if (onFocusWithinChange) onFocusWithinChange(false);\n        }\n    }, [\n        onBlurWithin,\n        onFocusWithinChange,\n        state\n    ]);\n    let onSyntheticFocus = (0, $8a9cb279dc87e130$export$715c682d09d639cc)(onBlur);\n    let onFocus = (0, $bx7SL$useCallback)((e)=>{\n        // Double check that document.activeElement actually matches e.target in case a previously chained\n        // focus handler already moved focus somewhere else.\n        if (!state.current.isFocusWithin && document.activeElement === e.target) {\n            if (onFocusWithin) onFocusWithin(e);\n            if (onFocusWithinChange) onFocusWithinChange(true);\n            state.current.isFocusWithin = true;\n            onSyntheticFocus(e);\n        }\n    }, [\n        onFocusWithin,\n        onFocusWithinChange,\n        onSyntheticFocus\n    ]);\n    if (isDisabled) return {\n        focusWithinProps: {\n            onFocus: null,\n            onBlur: null\n        }\n    };\n    return {\n        focusWithinProps: {\n            onFocus: onFocus,\n            onBlur: onBlur\n        }\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // Portions of the code in this file are based on code from react.\n// Original licensing for the following can be found in the\n// NOTICE file in the root directory of this source tree.\n// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions\n\n// iOS fires onPointerEnter twice: once with pointerType=\"touch\" and again with pointerType=\"mouse\".\n// We want to ignore these emulated events so they do not trigger hover behavior.\n// See https://bugs.webkit.org/show_bug.cgi?id=214609.\nlet $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;\nlet $6179b936705e76d3$var$hoverCount = 0;\nfunction $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents() {\n    $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = true;\n    // Clear globalIgnoreEmulatedMouseEvents after a short timeout. iOS fires onPointerEnter\n    // with pointerType=\"mouse\" immediately after onPointerUp and before onFocus. On other\n    // devices that don't have this quirk, we don't want to ignore a mouse hover sometime in\n    // the distant future because a user previously touched the element.\n    setTimeout(()=>{\n        $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;\n    }, 50);\n}\nfunction $6179b936705e76d3$var$handleGlobalPointerEvent(e) {\n    if (e.pointerType === \"touch\") $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents();\n}\nfunction $6179b936705e76d3$var$setupGlobalTouchEvents() {\n    if (typeof document === \"undefined\") return;\n    if (typeof PointerEvent !== \"undefined\") document.addEventListener(\"pointerup\", $6179b936705e76d3$var$handleGlobalPointerEvent);\n    else document.addEventListener(\"touchend\", $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents);\n    $6179b936705e76d3$var$hoverCount++;\n    return ()=>{\n        $6179b936705e76d3$var$hoverCount--;\n        if ($6179b936705e76d3$var$hoverCount > 0) return;\n        if (typeof PointerEvent !== \"undefined\") document.removeEventListener(\"pointerup\", $6179b936705e76d3$var$handleGlobalPointerEvent);\n        else document.removeEventListener(\"touchend\", $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents);\n    };\n}\nfunction $6179b936705e76d3$export$ae780daf29e6d456(props) {\n    let { onHoverStart: onHoverStart , onHoverChange: onHoverChange , onHoverEnd: onHoverEnd , isDisabled: isDisabled  } = props;\n    let [isHovered, setHovered] = (0, $bx7SL$useState)(false);\n    let state = (0, $bx7SL$useRef)({\n        isHovered: false,\n        ignoreEmulatedMouseEvents: false,\n        pointerType: \"\",\n        target: null\n    }).current;\n    (0, $bx7SL$useEffect)($6179b936705e76d3$var$setupGlobalTouchEvents, []);\n    let { hoverProps: hoverProps , triggerHoverEnd: triggerHoverEnd  } = (0, $bx7SL$useMemo)(()=>{\n        let triggerHoverStart = (event, pointerType)=>{\n            state.pointerType = pointerType;\n            if (isDisabled || pointerType === \"touch\" || state.isHovered || !event.currentTarget.contains(event.target)) return;\n            state.isHovered = true;\n            let target = event.currentTarget;\n            state.target = target;\n            if (onHoverStart) onHoverStart({\n                type: \"hoverstart\",\n                target: target,\n                pointerType: pointerType\n            });\n            if (onHoverChange) onHoverChange(true);\n            setHovered(true);\n        };\n        let triggerHoverEnd = (event, pointerType)=>{\n            state.pointerType = \"\";\n            state.target = null;\n            if (pointerType === \"touch\" || !state.isHovered) return;\n            state.isHovered = false;\n            let target = event.currentTarget;\n            if (onHoverEnd) onHoverEnd({\n                type: \"hoverend\",\n                target: target,\n                pointerType: pointerType\n            });\n            if (onHoverChange) onHoverChange(false);\n            setHovered(false);\n        };\n        let hoverProps = {};\n        if (typeof PointerEvent !== \"undefined\") {\n            hoverProps.onPointerEnter = (e)=>{\n                if ($6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents && e.pointerType === \"mouse\") return;\n                triggerHoverStart(e, e.pointerType);\n            };\n            hoverProps.onPointerLeave = (e)=>{\n                if (!isDisabled && e.currentTarget.contains(e.target)) triggerHoverEnd(e, e.pointerType);\n            };\n        } else {\n            hoverProps.onTouchStart = ()=>{\n                state.ignoreEmulatedMouseEvents = true;\n            };\n            hoverProps.onMouseEnter = (e)=>{\n                if (!state.ignoreEmulatedMouseEvents && !$6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents) triggerHoverStart(e, \"mouse\");\n                state.ignoreEmulatedMouseEvents = false;\n            };\n            hoverProps.onMouseLeave = (e)=>{\n                if (!isDisabled && e.currentTarget.contains(e.target)) triggerHoverEnd(e, \"mouse\");\n            };\n        }\n        return {\n            hoverProps: hoverProps,\n            triggerHoverEnd: triggerHoverEnd\n        };\n    }, [\n        onHoverStart,\n        onHoverChange,\n        onHoverEnd,\n        isDisabled,\n        state\n    ]);\n    (0, $bx7SL$useEffect)(()=>{\n        // Call the triggerHoverEnd as soon as isDisabled changes to true\n        // Safe to call triggerHoverEnd, it will early return if we aren't currently hovering\n        if (isDisabled) triggerHoverEnd({\n            currentTarget: state.target\n        }, state.pointerType);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [\n        isDisabled\n    ]);\n    return {\n        hoverProps: hoverProps,\n        isHovered: isHovered\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ // Portions of the code in this file are based on code from react.\n// Original licensing for the following can be found in the\n// NOTICE file in the root directory of this source tree.\n// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions\n\nfunction $e0b6e0b68ec7f50f$export$872b660ac5a1ff98(props) {\n    let { ref: ref , onInteractOutside: onInteractOutside , isDisabled: isDisabled , onInteractOutsideStart: onInteractOutsideStart  } = props;\n    let stateRef = (0, $bx7SL$useRef)({\n        isPointerDown: false,\n        ignoreEmulatedMouseEvents: false,\n        onInteractOutside: onInteractOutside,\n        onInteractOutsideStart: onInteractOutsideStart\n    });\n    let state = stateRef.current;\n    state.onInteractOutside = onInteractOutside;\n    state.onInteractOutsideStart = onInteractOutsideStart;\n    (0, $bx7SL$useEffect)(()=>{\n        if (isDisabled) return;\n        let onPointerDown = (e)=>{\n            if ($e0b6e0b68ec7f50f$var$isValidEvent(e, ref) && state.onInteractOutside) {\n                if (state.onInteractOutsideStart) state.onInteractOutsideStart(e);\n                state.isPointerDown = true;\n            }\n        };\n        // Use pointer events if available. Otherwise, fall back to mouse and touch events.\n        if (typeof PointerEvent !== \"undefined\") {\n            let onPointerUp = (e)=>{\n                if (state.isPointerDown && state.onInteractOutside && $e0b6e0b68ec7f50f$var$isValidEvent(e, ref)) state.onInteractOutside(e);\n                state.isPointerDown = false;\n            };\n            // changing these to capture phase fixed combobox\n            document.addEventListener(\"pointerdown\", onPointerDown, true);\n            document.addEventListener(\"pointerup\", onPointerUp, true);\n            return ()=>{\n                document.removeEventListener(\"pointerdown\", onPointerDown, true);\n                document.removeEventListener(\"pointerup\", onPointerUp, true);\n            };\n        } else {\n            let onMouseUp = (e)=>{\n                if (state.ignoreEmulatedMouseEvents) state.ignoreEmulatedMouseEvents = false;\n                else if (state.isPointerDown && state.onInteractOutside && $e0b6e0b68ec7f50f$var$isValidEvent(e, ref)) state.onInteractOutside(e);\n                state.isPointerDown = false;\n            };\n            let onTouchEnd = (e)=>{\n                state.ignoreEmulatedMouseEvents = true;\n                if (state.onInteractOutside && state.isPointerDown && $e0b6e0b68ec7f50f$var$isValidEvent(e, ref)) state.onInteractOutside(e);\n                state.isPointerDown = false;\n            };\n            document.addEventListener(\"mousedown\", onPointerDown, true);\n            document.addEventListener(\"mouseup\", onMouseUp, true);\n            document.addEventListener(\"touchstart\", onPointerDown, true);\n            document.addEventListener(\"touchend\", onTouchEnd, true);\n            return ()=>{\n                document.removeEventListener(\"mousedown\", onPointerDown, true);\n                document.removeEventListener(\"mouseup\", onMouseUp, true);\n                document.removeEventListener(\"touchstart\", onPointerDown, true);\n                document.removeEventListener(\"touchend\", onTouchEnd, true);\n            };\n        }\n    }, [\n        ref,\n        state,\n        isDisabled\n    ]);\n}\nfunction $e0b6e0b68ec7f50f$var$isValidEvent(event, ref) {\n    if (event.button > 0) return false;\n    if (event.target) {\n        // if the event target is no longer in the document, ignore\n        const ownerDocument = event.target.ownerDocument;\n        if (!ownerDocument || !ownerDocument.documentElement.contains(event.target)) return false;\n        // If the target is within a top layer element (e.g. toasts), ignore.\n        if (event.target.closest(\"[data-react-aria-top-layer]\")) return false;\n    }\n    return ref.current && !ref.current.contains(event.target);\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ /*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ function $93925083ecbb358c$export$48d1ea6320830260(handler) {\n    if (!handler) return;\n    let shouldStopPropagation = true;\n    return (e)=>{\n        let event = {\n            ...e,\n            preventDefault () {\n                e.preventDefault();\n            },\n            isDefaultPrevented () {\n                return e.isDefaultPrevented();\n            },\n            stopPropagation () {\n                console.error(\"stopPropagation is now the default behavior for events in React Spectrum. You can use continuePropagation() to revert this behavior.\");\n            },\n            continuePropagation () {\n                shouldStopPropagation = false;\n            }\n        };\n        handler(event);\n        if (shouldStopPropagation) e.stopPropagation();\n    };\n}\n\n\nfunction $46d819fcbaf35654$export$8f71654801c2f7cd(props) {\n    return {\n        keyboardProps: props.isDisabled ? {} : {\n            onKeyDown: (0, $93925083ecbb358c$export$48d1ea6320830260)(props.onKeyDown),\n            onKeyUp: (0, $93925083ecbb358c$export$48d1ea6320830260)(props.onKeyUp)\n        }\n    };\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\nfunction $e8a7022cf87cba2a$export$36da96379f79f245(props) {\n    let { onMoveStart: onMoveStart , onMove: onMove , onMoveEnd: onMoveEnd  } = props;\n    let state = (0, $bx7SL$useRef)({\n        didMove: false,\n        lastPosition: null,\n        id: null\n    });\n    let { addGlobalListener: addGlobalListener , removeGlobalListener: removeGlobalListener  } = (0, $bx7SL$useGlobalListeners)();\n    let moveProps = (0, $bx7SL$useMemo)(()=>{\n        let moveProps = {};\n        let start = ()=>{\n            (0, $14c0b72509d70225$export$16a4697467175487)();\n            state.current.didMove = false;\n        };\n        let move = (originalEvent, pointerType, deltaX, deltaY)=>{\n            if (deltaX === 0 && deltaY === 0) return;\n            if (!state.current.didMove) {\n                state.current.didMove = true;\n                onMoveStart === null || onMoveStart === void 0 ? void 0 : onMoveStart({\n                    type: \"movestart\",\n                    pointerType: pointerType,\n                    shiftKey: originalEvent.shiftKey,\n                    metaKey: originalEvent.metaKey,\n                    ctrlKey: originalEvent.ctrlKey,\n                    altKey: originalEvent.altKey\n                });\n            }\n            onMove({\n                type: \"move\",\n                pointerType: pointerType,\n                deltaX: deltaX,\n                deltaY: deltaY,\n                shiftKey: originalEvent.shiftKey,\n                metaKey: originalEvent.metaKey,\n                ctrlKey: originalEvent.ctrlKey,\n                altKey: originalEvent.altKey\n            });\n        };\n        let end = (originalEvent, pointerType)=>{\n            (0, $14c0b72509d70225$export$b0d6fa1ab32e3295)();\n            if (state.current.didMove) onMoveEnd === null || onMoveEnd === void 0 ? void 0 : onMoveEnd({\n                type: \"moveend\",\n                pointerType: pointerType,\n                shiftKey: originalEvent.shiftKey,\n                metaKey: originalEvent.metaKey,\n                ctrlKey: originalEvent.ctrlKey,\n                altKey: originalEvent.altKey\n            });\n        };\n        if (typeof PointerEvent === \"undefined\") {\n            let onMouseMove = (e)=>{\n                if (e.button === 0) {\n                    move(e, \"mouse\", e.pageX - state.current.lastPosition.pageX, e.pageY - state.current.lastPosition.pageY);\n                    state.current.lastPosition = {\n                        pageX: e.pageX,\n                        pageY: e.pageY\n                    };\n                }\n            };\n            let onMouseUp = (e)=>{\n                if (e.button === 0) {\n                    end(e, \"mouse\");\n                    removeGlobalListener(window, \"mousemove\", onMouseMove, false);\n                    removeGlobalListener(window, \"mouseup\", onMouseUp, false);\n                }\n            };\n            moveProps.onMouseDown = (e)=>{\n                if (e.button === 0) {\n                    start();\n                    e.stopPropagation();\n                    e.preventDefault();\n                    state.current.lastPosition = {\n                        pageX: e.pageX,\n                        pageY: e.pageY\n                    };\n                    addGlobalListener(window, \"mousemove\", onMouseMove, false);\n                    addGlobalListener(window, \"mouseup\", onMouseUp, false);\n                }\n            };\n            let onTouchMove = (e)=>{\n                let touch = [\n                    ...e.changedTouches\n                ].findIndex(({ identifier: identifier  })=>identifier === state.current.id);\n                if (touch >= 0) {\n                    let { pageX: pageX , pageY: pageY  } = e.changedTouches[touch];\n                    move(e, \"touch\", pageX - state.current.lastPosition.pageX, pageY - state.current.lastPosition.pageY);\n                    state.current.lastPosition = {\n                        pageX: pageX,\n                        pageY: pageY\n                    };\n                }\n            };\n            let onTouchEnd = (e)=>{\n                let touch = [\n                    ...e.changedTouches\n                ].findIndex(({ identifier: identifier  })=>identifier === state.current.id);\n                if (touch >= 0) {\n                    end(e, \"touch\");\n                    state.current.id = null;\n                    removeGlobalListener(window, \"touchmove\", onTouchMove);\n                    removeGlobalListener(window, \"touchend\", onTouchEnd);\n                    removeGlobalListener(window, \"touchcancel\", onTouchEnd);\n                }\n            };\n            moveProps.onTouchStart = (e)=>{\n                if (e.changedTouches.length === 0 || state.current.id != null) return;\n                let { pageX: pageX , pageY: pageY , identifier: identifier  } = e.changedTouches[0];\n                start();\n                e.stopPropagation();\n                e.preventDefault();\n                state.current.lastPosition = {\n                    pageX: pageX,\n                    pageY: pageY\n                };\n                state.current.id = identifier;\n                addGlobalListener(window, \"touchmove\", onTouchMove, false);\n                addGlobalListener(window, \"touchend\", onTouchEnd, false);\n                addGlobalListener(window, \"touchcancel\", onTouchEnd, false);\n            };\n        } else {\n            let onPointerMove = (e)=>{\n                if (e.pointerId === state.current.id) {\n                    let pointerType = e.pointerType || \"mouse\";\n                    // Problems with PointerEvent#movementX/movementY:\n                    // 1. it is always 0 on macOS Safari.\n                    // 2. On Chrome Android, it's scaled by devicePixelRatio, but not on Chrome macOS\n                    move(e, pointerType, e.pageX - state.current.lastPosition.pageX, e.pageY - state.current.lastPosition.pageY);\n                    state.current.lastPosition = {\n                        pageX: e.pageX,\n                        pageY: e.pageY\n                    };\n                }\n            };\n            let onPointerUp = (e)=>{\n                if (e.pointerId === state.current.id) {\n                    let pointerType = e.pointerType || \"mouse\";\n                    end(e, pointerType);\n                    state.current.id = null;\n                    removeGlobalListener(window, \"pointermove\", onPointerMove, false);\n                    removeGlobalListener(window, \"pointerup\", onPointerUp, false);\n                    removeGlobalListener(window, \"pointercancel\", onPointerUp, false);\n                }\n            };\n            moveProps.onPointerDown = (e)=>{\n                if (e.button === 0 && state.current.id == null) {\n                    start();\n                    e.stopPropagation();\n                    e.preventDefault();\n                    state.current.lastPosition = {\n                        pageX: e.pageX,\n                        pageY: e.pageY\n                    };\n                    state.current.id = e.pointerId;\n                    addGlobalListener(window, \"pointermove\", onPointerMove, false);\n                    addGlobalListener(window, \"pointerup\", onPointerUp, false);\n                    addGlobalListener(window, \"pointercancel\", onPointerUp, false);\n                }\n            };\n        }\n        let triggerKeyboardMove = (e, deltaX, deltaY)=>{\n            start();\n            move(e, \"keyboard\", deltaX, deltaY);\n            end(e, \"keyboard\");\n        };\n        moveProps.onKeyDown = (e)=>{\n            switch(e.key){\n                case \"Left\":\n                case \"ArrowLeft\":\n                    e.preventDefault();\n                    e.stopPropagation();\n                    triggerKeyboardMove(e, -1, 0);\n                    break;\n                case \"Right\":\n                case \"ArrowRight\":\n                    e.preventDefault();\n                    e.stopPropagation();\n                    triggerKeyboardMove(e, 1, 0);\n                    break;\n                case \"Up\":\n                case \"ArrowUp\":\n                    e.preventDefault();\n                    e.stopPropagation();\n                    triggerKeyboardMove(e, 0, -1);\n                    break;\n                case \"Down\":\n                case \"ArrowDown\":\n                    e.preventDefault();\n                    e.stopPropagation();\n                    triggerKeyboardMove(e, 0, 1);\n                    break;\n            }\n        };\n        return moveProps;\n    }, [\n        state,\n        onMoveStart,\n        onMove,\n        onMoveEnd,\n        addGlobalListener,\n        removeGlobalListener\n    ]);\n    return {\n        moveProps: moveProps\n    };\n}\n\n\n\n/*\n * Copyright 2021 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\nfunction $7d0a636d7a4dcefd$export$2123ff2b87c81ca(props, ref) {\n    let { onScroll: onScroll , isDisabled: isDisabled  } = props;\n    let onScrollHandler = (0, $bx7SL$useCallback)((e)=>{\n        // If the ctrlKey is pressed, this is a zoom event, do nothing.\n        if (e.ctrlKey) return;\n        // stop scrolling the page\n        e.preventDefault();\n        e.stopPropagation();\n        if (onScroll) onScroll({\n            deltaX: e.deltaX,\n            deltaY: e.deltaY\n        });\n    }, [\n        onScroll\n    ]);\n    (0, $bx7SL$useEvent)(ref, \"wheel\", isDisabled ? null : onScrollHandler);\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\nconst $8a26561d2877236e$var$DEFAULT_THRESHOLD = 500;\nfunction $8a26561d2877236e$export$c24ed0104d07eab9(props) {\n    let { isDisabled: isDisabled , onLongPressStart: onLongPressStart , onLongPressEnd: onLongPressEnd , onLongPress: onLongPress , threshold: threshold = $8a26561d2877236e$var$DEFAULT_THRESHOLD , accessibilityDescription: accessibilityDescription  } = props;\n    const timeRef = (0, $bx7SL$useRef)(null);\n    let { addGlobalListener: addGlobalListener , removeGlobalListener: removeGlobalListener  } = (0, $bx7SL$useGlobalListeners)();\n    let { pressProps: pressProps  } = (0, $f6c31cce2adf654f$export$45712eceda6fad21)({\n        isDisabled: isDisabled,\n        onPressStart (e) {\n            if (e.pointerType === \"mouse\" || e.pointerType === \"touch\") {\n                if (onLongPressStart) onLongPressStart({\n                    ...e,\n                    type: \"longpressstart\"\n                });\n                timeRef.current = setTimeout(()=>{\n                    // Prevent other usePress handlers from also handling this event.\n                    e.target.dispatchEvent(new PointerEvent(\"pointercancel\", {\n                        bubbles: true\n                    }));\n                    if (onLongPress) onLongPress({\n                        ...e,\n                        type: \"longpress\"\n                    });\n                    timeRef.current = null;\n                }, threshold);\n                // Prevent context menu, which may be opened on long press on touch devices\n                if (e.pointerType === \"touch\") {\n                    let onContextMenu = (e)=>{\n                        e.preventDefault();\n                    };\n                    addGlobalListener(e.target, \"contextmenu\", onContextMenu, {\n                        once: true\n                    });\n                    addGlobalListener(window, \"pointerup\", ()=>{\n                        // If no contextmenu event is fired quickly after pointerup, remove the handler\n                        // so future context menu events outside a long press are not prevented.\n                        setTimeout(()=>{\n                            removeGlobalListener(e.target, \"contextmenu\", onContextMenu);\n                        }, 30);\n                    }, {\n                        once: true\n                    });\n                }\n            }\n        },\n        onPressEnd (e) {\n            if (timeRef.current) clearTimeout(timeRef.current);\n            if (onLongPressEnd && (e.pointerType === \"mouse\" || e.pointerType === \"touch\")) onLongPressEnd({\n                ...e,\n                type: \"longpressend\"\n            });\n        }\n    });\n    let descriptionProps = (0, $bx7SL$useDescription)(onLongPress && !isDisabled ? accessibilityDescription : null);\n    return {\n        longPressProps: (0, $bx7SL$mergeProps)(pressProps, descriptionProps)\n    };\n}\n\n\n\n\nexport {$3b117e43dc0ca95d$export$27c701ed9e449e99 as Pressable, $f1ab8c75478c6f73$export$3351871ee4b288b8 as PressResponder, $a1ea59d68270f0dd$export$f8168d8dd8fd66e6 as useFocus, $507fabe10e71c6fb$export$b9b3dfddab17db27 as isFocusVisible, $507fabe10e71c6fb$export$630ff653c5ada6a9 as getInteractionModality, $507fabe10e71c6fb$export$8397ddfc504fdb9a as setInteractionModality, $507fabe10e71c6fb$export$98e20ec92f614cfe as useInteractionModality, $507fabe10e71c6fb$export$ffd9e5021c1fb2d6 as useFocusVisible, $507fabe10e71c6fb$export$ec71b4b83ac08ec3 as useFocusVisibleListener, $9ab94262bd0047c7$export$420e68273165f4ec as useFocusWithin, $6179b936705e76d3$export$ae780daf29e6d456 as useHover, $e0b6e0b68ec7f50f$export$872b660ac5a1ff98 as useInteractOutside, $46d819fcbaf35654$export$8f71654801c2f7cd as useKeyboard, $e8a7022cf87cba2a$export$36da96379f79f245 as useMove, $f6c31cce2adf654f$export$45712eceda6fad21 as usePress, $7d0a636d7a4dcefd$export$2123ff2b87c81ca as useScrollWheel, $8a26561d2877236e$export$c24ed0104d07eab9 as useLongPress};\n//# sourceMappingURL=module.js.map\n","import $6nfFC$swchelperssrc_define_propertymjs from \"@swc/helpers/src/_define_property.mjs\";\nimport $6nfFC$react, {useRef as $6nfFC$useRef, useContext as $6nfFC$useContext, useMemo as $6nfFC$useMemo, useEffect as $6nfFC$useEffect, useState as $6nfFC$useState, useCallback as $6nfFC$useCallback} from \"react\";\nimport {useLayoutEffect as $6nfFC$useLayoutEffect, runAfterTransition as $6nfFC$runAfterTransition, focusWithoutScrolling as $6nfFC$focusWithoutScrolling, mergeProps as $6nfFC$mergeProps, useSyncRef as $6nfFC$useSyncRef} from \"@react-aria/utils\";\nimport {getInteractionModality as $6nfFC$getInteractionModality, isFocusVisible as $6nfFC$isFocusVisible, useFocusVisibleListener as $6nfFC$useFocusVisibleListener, useFocus as $6nfFC$useFocus, useFocusWithin as $6nfFC$useFocusWithin, useKeyboard as $6nfFC$useKeyboard} from \"@react-aria/interactions\";\nimport $6nfFC$clsx from \"clsx\";\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ /*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the 'License');\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\nfunction $6a99195332edec8b$export$80f3e147d781571c(element) {\n    // If the user is interacting with a virtual cursor, e.g. screen reader, then\n    // wait until after any animated transitions that are currently occurring on\n    // the page before shifting focus. This avoids issues with VoiceOver on iOS\n    // causing the page to scroll when moving focus if the element is transitioning\n    // from off the screen.\n    if ((0, $6nfFC$getInteractionModality)() === \"virtual\") {\n        let lastFocusedElement = document.activeElement;\n        (0, $6nfFC$runAfterTransition)(()=>{\n            // If focus did not move and the element is still in the document, focus it.\n            if (document.activeElement === lastFocusedElement && document.contains(element)) (0, $6nfFC$focusWithoutScrolling)(element);\n        });\n    } else (0, $6nfFC$focusWithoutScrolling)(element);\n}\n\n\n/*\n * Copyright 2021 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ function $645f2e67b85a24c9$var$isStyleVisible(element) {\n    if (!(element instanceof HTMLElement) && !(element instanceof SVGElement)) return false;\n    let { display: display , visibility: visibility  } = element.style;\n    let isVisible = display !== \"none\" && visibility !== \"hidden\" && visibility !== \"collapse\";\n    if (isVisible) {\n        const { getComputedStyle: getComputedStyle  } = element.ownerDocument.defaultView;\n        let { display: computedDisplay , visibility: computedVisibility  } = getComputedStyle(element);\n        isVisible = computedDisplay !== \"none\" && computedVisibility !== \"hidden\" && computedVisibility !== \"collapse\";\n    }\n    return isVisible;\n}\nfunction $645f2e67b85a24c9$var$isAttributeVisible(element, childElement) {\n    return !element.hasAttribute(\"hidden\") && (element.nodeName === \"DETAILS\" && childElement && childElement.nodeName !== \"SUMMARY\" ? element.hasAttribute(\"open\") : true);\n}\nfunction $645f2e67b85a24c9$export$e989c0fffaa6b27a(element, childElement) {\n    return element.nodeName !== \"#comment\" && $645f2e67b85a24c9$var$isStyleVisible(element) && $645f2e67b85a24c9$var$isAttributeVisible(element, childElement) && (!element.parentElement || $645f2e67b85a24c9$export$e989c0fffaa6b27a(element.parentElement, element));\n}\n\n\n\n\nconst $9bf71ea28793e738$var$FocusContext = /*#__PURE__*/ (0, $6nfFC$react).createContext(null);\nlet $9bf71ea28793e738$var$activeScope = null;\nfunction $9bf71ea28793e738$export$20e40289641fbbb6(props) {\n    let { children: children , contain: contain , restoreFocus: restoreFocus , autoFocus: autoFocus  } = props;\n    let startRef = (0, $6nfFC$useRef)();\n    let endRef = (0, $6nfFC$useRef)();\n    let scopeRef = (0, $6nfFC$useRef)([]);\n    let { parentNode: parentNode  } = (0, $6nfFC$useContext)($9bf71ea28793e738$var$FocusContext) || {};\n    // Create a tree node here so we can add children to it even before it is added to the tree.\n    let node = (0, $6nfFC$useMemo)(()=>new $9bf71ea28793e738$var$TreeNode({\n            scopeRef: scopeRef\n        }), [\n        scopeRef\n    ]);\n    (0, $6nfFC$useLayoutEffect)(()=>{\n        // If a new scope mounts outside the active scope, (e.g. DialogContainer launched from a menu),\n        // use the active scope as the parent instead of the parent from context. Layout effects run bottom\n        // up, so if the parent is not yet added to the tree, don't do this. Only the outer-most FocusScope\n        // that is being added should get the activeScope as its parent.\n        let parent = parentNode || $9bf71ea28793e738$export$d06fae2ee68b101e.root;\n        if ($9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(parent.scopeRef) && $9bf71ea28793e738$var$activeScope && !$9bf71ea28793e738$var$isAncestorScope($9bf71ea28793e738$var$activeScope, parent.scopeRef)) {\n            let activeNode = $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode($9bf71ea28793e738$var$activeScope);\n            if (activeNode) parent = activeNode;\n        }\n        // Add the node to the parent, and to the tree.\n        parent.addChild(node);\n        $9bf71ea28793e738$export$d06fae2ee68b101e.addNode(node);\n    }, [\n        node,\n        parentNode\n    ]);\n    (0, $6nfFC$useLayoutEffect)(()=>{\n        let node = $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scopeRef);\n        node.contain = contain;\n    }, [\n        contain\n    ]);\n    (0, $6nfFC$useLayoutEffect)(()=>{\n        // Find all rendered nodes between the sentinels and add them to the scope.\n        let node = startRef.current.nextSibling;\n        let nodes = [];\n        while(node && node !== endRef.current){\n            nodes.push(node);\n            node = node.nextSibling;\n        }\n        scopeRef.current = nodes;\n    }, [\n        children\n    ]);\n    $9bf71ea28793e738$var$useActiveScopeTracker(scopeRef, restoreFocus, contain);\n    $9bf71ea28793e738$var$useFocusContainment(scopeRef, contain);\n    $9bf71ea28793e738$var$useRestoreFocus(scopeRef, restoreFocus, contain);\n    $9bf71ea28793e738$var$useAutoFocus(scopeRef, autoFocus);\n    // this layout effect needs to run last so that focusScopeTree cleanup happens at the last moment possible\n    (0, $6nfFC$useEffect)(()=>{\n        if (scopeRef) {\n            let activeElement = document.activeElement;\n            let scope = null;\n            // In strict mode, active scope is incorrectly updated since cleanup will run even though scope hasn't unmounted.\n            // To fix this, we need to update the actual activeScope here\n            if ($9bf71ea28793e738$var$isElementInScope(activeElement, scopeRef.current)) {\n                // Since useLayoutEffect runs for children first, we need to traverse the focusScope tree and find the bottom most scope that\n                // contains the active element and set that as the activeScope\n                for (let node of $9bf71ea28793e738$export$d06fae2ee68b101e.traverse())if ($9bf71ea28793e738$var$isElementInScope(activeElement, node.scopeRef.current)) scope = node;\n                if (scope === $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scopeRef)) $9bf71ea28793e738$var$activeScope = scope.scopeRef;\n            }\n            return ()=>{\n                // Scope may have been re-parented.\n                let parentScope = $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scopeRef).parent.scopeRef;\n                // Restore the active scope on unmount if this scope or a descendant scope is active.\n                // Parent effect cleanups run before children, so we need to check if the\n                // parent scope actually still exists before restoring the active scope to it.\n                if ((scopeRef === $9bf71ea28793e738$var$activeScope || $9bf71ea28793e738$var$isAncestorScope(scopeRef, $9bf71ea28793e738$var$activeScope)) && (!parentScope || $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(parentScope))) $9bf71ea28793e738$var$activeScope = parentScope;\n                $9bf71ea28793e738$export$d06fae2ee68b101e.removeTreeNode(scopeRef);\n            };\n        }\n    }, [\n        scopeRef\n    ]);\n    let focusManager = (0, $6nfFC$useMemo)(()=>$9bf71ea28793e738$var$createFocusManagerForScope(scopeRef), []);\n    let value = (0, $6nfFC$useMemo)(()=>({\n            focusManager: focusManager,\n            parentNode: node\n        }), [\n        node,\n        focusManager\n    ]);\n    return /*#__PURE__*/ (0, $6nfFC$react).createElement($9bf71ea28793e738$var$FocusContext.Provider, {\n        value: value\n    }, /*#__PURE__*/ (0, $6nfFC$react).createElement(\"span\", {\n        \"data-focus-scope-start\": true,\n        hidden: true,\n        ref: startRef\n    }), children, /*#__PURE__*/ (0, $6nfFC$react).createElement(\"span\", {\n        \"data-focus-scope-end\": true,\n        hidden: true,\n        ref: endRef\n    }));\n}\nfunction $9bf71ea28793e738$export$10c5169755ce7bd7() {\n    var _useContext;\n    return (_useContext = (0, $6nfFC$useContext)($9bf71ea28793e738$var$FocusContext)) === null || _useContext === void 0 ? void 0 : _useContext.focusManager;\n}\nfunction $9bf71ea28793e738$var$createFocusManagerForScope(scopeRef) {\n    return {\n        focusNext (opts = {}) {\n            let scope = scopeRef.current;\n            let { from: from , tabbable: tabbable , wrap: wrap , accept: accept  } = opts;\n            let node = from || document.activeElement;\n            let sentinel = scope[0].previousElementSibling;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {\n                tabbable: tabbable,\n                accept: accept\n            }, scope);\n            walker.currentNode = $9bf71ea28793e738$var$isElementInScope(node, scope) ? node : sentinel;\n            let nextNode = walker.nextNode();\n            if (!nextNode && wrap) {\n                walker.currentNode = sentinel;\n                nextNode = walker.nextNode();\n            }\n            if (nextNode) $9bf71ea28793e738$var$focusElement(nextNode, true);\n            return nextNode;\n        },\n        focusPrevious (opts = {}) {\n            let scope = scopeRef.current;\n            let { from: from , tabbable: tabbable , wrap: wrap , accept: accept  } = opts;\n            let node = from || document.activeElement;\n            let sentinel = scope[scope.length - 1].nextElementSibling;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {\n                tabbable: tabbable,\n                accept: accept\n            }, scope);\n            walker.currentNode = $9bf71ea28793e738$var$isElementInScope(node, scope) ? node : sentinel;\n            let previousNode = walker.previousNode();\n            if (!previousNode && wrap) {\n                walker.currentNode = sentinel;\n                previousNode = walker.previousNode();\n            }\n            if (previousNode) $9bf71ea28793e738$var$focusElement(previousNode, true);\n            return previousNode;\n        },\n        focusFirst (opts = {}) {\n            let scope = scopeRef.current;\n            let { tabbable: tabbable , accept: accept  } = opts;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {\n                tabbable: tabbable,\n                accept: accept\n            }, scope);\n            walker.currentNode = scope[0].previousElementSibling;\n            let nextNode = walker.nextNode();\n            if (nextNode) $9bf71ea28793e738$var$focusElement(nextNode, true);\n            return nextNode;\n        },\n        focusLast (opts = {}) {\n            let scope = scopeRef.current;\n            let { tabbable: tabbable , accept: accept  } = opts;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {\n                tabbable: tabbable,\n                accept: accept\n            }, scope);\n            walker.currentNode = scope[scope.length - 1].nextElementSibling;\n            let previousNode = walker.previousNode();\n            if (previousNode) $9bf71ea28793e738$var$focusElement(previousNode, true);\n            return previousNode;\n        }\n    };\n}\nconst $9bf71ea28793e738$var$focusableElements = [\n    \"input:not([disabled]):not([type=hidden])\",\n    \"select:not([disabled])\",\n    \"textarea:not([disabled])\",\n    \"button:not([disabled])\",\n    \"a[href]\",\n    \"area[href]\",\n    \"summary\",\n    \"iframe\",\n    \"object\",\n    \"embed\",\n    \"audio[controls]\",\n    \"video[controls]\",\n    \"[contenteditable]\"\n];\nconst $9bf71ea28793e738$var$FOCUSABLE_ELEMENT_SELECTOR = $9bf71ea28793e738$var$focusableElements.join(\":not([hidden]),\") + \",[tabindex]:not([disabled]):not([hidden])\";\n$9bf71ea28793e738$var$focusableElements.push('[tabindex]:not([tabindex=\"-1\"]):not([disabled])');\nconst $9bf71ea28793e738$var$TABBABLE_ELEMENT_SELECTOR = $9bf71ea28793e738$var$focusableElements.join(':not([hidden]):not([tabindex=\"-1\"]),');\nfunction $9bf71ea28793e738$var$getScopeRoot(scope) {\n    return scope[0].parentElement;\n}\nfunction $9bf71ea28793e738$var$shouldContainFocus(scopeRef) {\n    let scope = $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode($9bf71ea28793e738$var$activeScope);\n    while(scope && scope.scopeRef !== scopeRef){\n        if (scope.contain) return false;\n        scope = scope.parent;\n    }\n    return true;\n}\nfunction $9bf71ea28793e738$var$useFocusContainment(scopeRef, contain) {\n    let focusedNode = (0, $6nfFC$useRef)();\n    let raf = (0, $6nfFC$useRef)(null);\n    (0, $6nfFC$useLayoutEffect)(()=>{\n        let scope = scopeRef.current;\n        if (!contain) {\n            // if contain was changed, then we should cancel any ongoing waits to pull focus back into containment\n            if (raf.current) {\n                cancelAnimationFrame(raf.current);\n                raf.current = null;\n            }\n            return;\n        }\n        // Handle the Tab key to contain focus within the scope\n        let onKeyDown = (e)=>{\n            if (e.key !== \"Tab\" || e.altKey || e.ctrlKey || e.metaKey || !$9bf71ea28793e738$var$shouldContainFocus(scopeRef)) return;\n            let focusedElement = document.activeElement;\n            let scope = scopeRef.current;\n            if (!$9bf71ea28793e738$var$isElementInScope(focusedElement, scope)) return;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {\n                tabbable: true\n            }, scope);\n            walker.currentNode = focusedElement;\n            let nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();\n            if (!nextElement) {\n                walker.currentNode = e.shiftKey ? scope[scope.length - 1].nextElementSibling : scope[0].previousElementSibling;\n                nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();\n            }\n            e.preventDefault();\n            if (nextElement) $9bf71ea28793e738$var$focusElement(nextElement, true);\n        };\n        let onFocus = (e)=>{\n            // If focusing an element in a child scope of the currently active scope, the child becomes active.\n            // Moving out of the active scope to an ancestor is not allowed.\n            if ((!$9bf71ea28793e738$var$activeScope || $9bf71ea28793e738$var$isAncestorScope($9bf71ea28793e738$var$activeScope, scopeRef)) && $9bf71ea28793e738$var$isElementInScope(e.target, scopeRef.current)) {\n                $9bf71ea28793e738$var$activeScope = scopeRef;\n                focusedNode.current = e.target;\n            } else if ($9bf71ea28793e738$var$shouldContainFocus(scopeRef) && !$9bf71ea28793e738$var$isElementInChildScope(e.target, scopeRef)) {\n                // If a focus event occurs outside the active scope (e.g. user tabs from browser location bar),\n                // restore focus to the previously focused node or the first tabbable element in the active scope.\n                if (focusedNode.current) focusedNode.current.focus();\n                else if ($9bf71ea28793e738$var$activeScope) $9bf71ea28793e738$var$focusFirstInScope($9bf71ea28793e738$var$activeScope.current);\n            } else if ($9bf71ea28793e738$var$shouldContainFocus(scopeRef)) focusedNode.current = e.target;\n        };\n        let onBlur = (e)=>{\n            // Firefox doesn't shift focus back to the Dialog properly without this\n            if (raf.current) cancelAnimationFrame(raf.current);\n            raf.current = requestAnimationFrame(()=>{\n                // Use document.activeElement instead of e.relatedTarget so we can tell if user clicked into iframe\n                if ($9bf71ea28793e738$var$shouldContainFocus(scopeRef) && !$9bf71ea28793e738$var$isElementInChildScope(document.activeElement, scopeRef)) {\n                    $9bf71ea28793e738$var$activeScope = scopeRef;\n                    if (document.body.contains(e.target)) {\n                        focusedNode.current = e.target;\n                        focusedNode.current.focus();\n                    } else if ($9bf71ea28793e738$var$activeScope) $9bf71ea28793e738$var$focusFirstInScope($9bf71ea28793e738$var$activeScope.current);\n                }\n            });\n        };\n        document.addEventListener(\"keydown\", onKeyDown, false);\n        document.addEventListener(\"focusin\", onFocus, false);\n        scope.forEach((element)=>element.addEventListener(\"focusin\", onFocus, false));\n        scope.forEach((element)=>element.addEventListener(\"focusout\", onBlur, false));\n        return ()=>{\n            document.removeEventListener(\"keydown\", onKeyDown, false);\n            document.removeEventListener(\"focusin\", onFocus, false);\n            scope.forEach((element)=>element.removeEventListener(\"focusin\", onFocus, false));\n            scope.forEach((element)=>element.removeEventListener(\"focusout\", onBlur, false));\n        };\n    }, [\n        scopeRef,\n        contain\n    ]);\n    // eslint-disable-next-line arrow-body-style\n    (0, $6nfFC$useEffect)(()=>{\n        return ()=>{\n            if (raf.current) cancelAnimationFrame(raf.current);\n        };\n    }, [\n        raf\n    ]);\n}\nfunction $9bf71ea28793e738$var$isElementInAnyScope(element) {\n    return $9bf71ea28793e738$var$isElementInChildScope(element);\n}\nfunction $9bf71ea28793e738$var$isElementInScope(element, scope) {\n    return scope.some((node)=>node.contains(element));\n}\nfunction $9bf71ea28793e738$var$isElementInChildScope(element, scope = null) {\n    // If the element is within a top layer element (e.g. toasts), always allow moving focus there.\n    if (element instanceof Element && element.closest(\"[data-react-aria-top-layer]\")) return true;\n    // node.contains in isElementInScope covers child scopes that are also DOM children,\n    // but does not cover child scopes in portals.\n    for (let { scopeRef: s  } of $9bf71ea28793e738$export$d06fae2ee68b101e.traverse($9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scope))){\n        if ($9bf71ea28793e738$var$isElementInScope(element, s.current)) return true;\n    }\n    return false;\n}\nfunction $9bf71ea28793e738$export$1258395f99bf9cbf(element) {\n    return $9bf71ea28793e738$var$isElementInChildScope(element, $9bf71ea28793e738$var$activeScope);\n}\nfunction $9bf71ea28793e738$var$isAncestorScope(ancestor, scope) {\n    var _focusScopeTree_getTreeNode;\n    let parent = (_focusScopeTree_getTreeNode = $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scope)) === null || _focusScopeTree_getTreeNode === void 0 ? void 0 : _focusScopeTree_getTreeNode.parent;\n    while(parent){\n        if (parent.scopeRef === ancestor) return true;\n        parent = parent.parent;\n    }\n    return false;\n}\nfunction $9bf71ea28793e738$var$focusElement(element, scroll = false) {\n    if (element != null && !scroll) try {\n        (0, $6a99195332edec8b$export$80f3e147d781571c)(element);\n    } catch (err) {\n    // ignore\n    }\n    else if (element != null) try {\n        element.focus();\n    } catch (err1) {\n    // ignore\n    }\n}\nfunction $9bf71ea28793e738$var$focusFirstInScope(scope, tabbable = true) {\n    let sentinel = scope[0].previousElementSibling;\n    let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {\n        tabbable: tabbable\n    }, scope);\n    walker.currentNode = sentinel;\n    let nextNode = walker.nextNode();\n    // If the scope does not contain a tabbable element, use the first focusable element.\n    if (tabbable && !nextNode) {\n        walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa($9bf71ea28793e738$var$getScopeRoot(scope), {\n            tabbable: false\n        }, scope);\n        walker.currentNode = sentinel;\n        nextNode = walker.nextNode();\n    }\n    $9bf71ea28793e738$var$focusElement(nextNode);\n}\nfunction $9bf71ea28793e738$var$useAutoFocus(scopeRef, autoFocus) {\n    const autoFocusRef = (0, $6nfFC$react).useRef(autoFocus);\n    (0, $6nfFC$useEffect)(()=>{\n        if (autoFocusRef.current) {\n            $9bf71ea28793e738$var$activeScope = scopeRef;\n            if (!$9bf71ea28793e738$var$isElementInScope(document.activeElement, $9bf71ea28793e738$var$activeScope.current)) $9bf71ea28793e738$var$focusFirstInScope(scopeRef.current);\n        }\n        autoFocusRef.current = false;\n    }, [\n        scopeRef\n    ]);\n}\nfunction $9bf71ea28793e738$var$useActiveScopeTracker(scopeRef, restore, contain) {\n    // tracks the active scope, in case restore and contain are both false.\n    // if either are true, this is tracked in useRestoreFocus or useFocusContainment.\n    (0, $6nfFC$useLayoutEffect)(()=>{\n        if (restore || contain) return;\n        let scope = scopeRef.current;\n        let onFocus = (e)=>{\n            let target = e.target;\n            if ($9bf71ea28793e738$var$isElementInScope(target, scopeRef.current)) $9bf71ea28793e738$var$activeScope = scopeRef;\n            else if (!$9bf71ea28793e738$var$isElementInAnyScope(target)) $9bf71ea28793e738$var$activeScope = null;\n        };\n        document.addEventListener(\"focusin\", onFocus, false);\n        scope.forEach((element)=>element.addEventListener(\"focusin\", onFocus, false));\n        return ()=>{\n            document.removeEventListener(\"focusin\", onFocus, false);\n            scope.forEach((element)=>element.removeEventListener(\"focusin\", onFocus, false));\n        };\n    }, [\n        scopeRef,\n        restore,\n        contain\n    ]);\n}\nfunction $9bf71ea28793e738$var$shouldRestoreFocus(scopeRef) {\n    let scope = $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode($9bf71ea28793e738$var$activeScope);\n    while(scope && scope.scopeRef !== scopeRef){\n        if (scope.nodeToRestore) return false;\n        scope = scope.parent;\n    }\n    return (scope === null || scope === void 0 ? void 0 : scope.scopeRef) === scopeRef;\n}\nfunction $9bf71ea28793e738$var$useRestoreFocus(scopeRef, restoreFocus, contain) {\n    // create a ref during render instead of useLayoutEffect so the active element is saved before a child with autoFocus=true mounts.\n    const nodeToRestoreRef = (0, $6nfFC$useRef)(typeof document !== \"undefined\" ? document.activeElement : null);\n    // restoring scopes should all track if they are active regardless of contain, but contain already tracks it plus logic to contain the focus\n    // restoring-non-containing scopes should only care if they become active so they can perform the restore\n    (0, $6nfFC$useLayoutEffect)(()=>{\n        let scope = scopeRef.current;\n        if (!restoreFocus || contain) return;\n        let onFocus = ()=>{\n            // If focusing an element in a child scope of the currently active scope, the child becomes active.\n            // Moving out of the active scope to an ancestor is not allowed.\n            if ((!$9bf71ea28793e738$var$activeScope || $9bf71ea28793e738$var$isAncestorScope($9bf71ea28793e738$var$activeScope, scopeRef)) && $9bf71ea28793e738$var$isElementInScope(document.activeElement, scopeRef.current)) $9bf71ea28793e738$var$activeScope = scopeRef;\n        };\n        document.addEventListener(\"focusin\", onFocus, false);\n        scope.forEach((element)=>element.addEventListener(\"focusin\", onFocus, false));\n        return ()=>{\n            document.removeEventListener(\"focusin\", onFocus, false);\n            scope.forEach((element)=>element.removeEventListener(\"focusin\", onFocus, false));\n        };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [\n        scopeRef,\n        contain\n    ]);\n    // useLayoutEffect instead of useEffect so the active element is saved synchronously instead of asynchronously.\n    (0, $6nfFC$useLayoutEffect)(()=>{\n        if (!restoreFocus) return;\n        $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scopeRef).nodeToRestore = nodeToRestoreRef.current;\n        // Handle the Tab key so that tabbing out of the scope goes to the next element\n        // after the node that had focus when the scope mounted. This is important when\n        // using portals for overlays, so that focus goes to the expected element when\n        // tabbing out of the overlay.\n        let onKeyDown = (e)=>{\n            if (e.key !== \"Tab\" || e.altKey || e.ctrlKey || e.metaKey) return;\n            let focusedElement = document.activeElement;\n            if (!$9bf71ea28793e738$var$isElementInScope(focusedElement, scopeRef.current)) return;\n            let nodeToRestore = $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scopeRef).nodeToRestore;\n            // Create a DOM tree walker that matches all tabbable elements\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(document.body, {\n                tabbable: true\n            });\n            // Find the next tabbable element after the currently focused element\n            walker.currentNode = focusedElement;\n            let nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();\n            if (!document.body.contains(nodeToRestore) || nodeToRestore === document.body) {\n                nodeToRestore = null;\n                $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scopeRef).nodeToRestore = null;\n            }\n            // If there is no next element, or it is outside the current scope, move focus to the\n            // next element after the node to restore to instead.\n            if ((!nextElement || !$9bf71ea28793e738$var$isElementInScope(nextElement, scopeRef.current)) && nodeToRestore) {\n                walker.currentNode = nodeToRestore;\n                // Skip over elements within the scope, in case the scope immediately follows the node to restore.\n                do nextElement = e.shiftKey ? walker.previousNode() : walker.nextNode();\n                while ($9bf71ea28793e738$var$isElementInScope(nextElement, scopeRef.current));\n                e.preventDefault();\n                e.stopPropagation();\n                if (nextElement) $9bf71ea28793e738$var$focusElement(nextElement, true);\n                else // If there is no next element and the nodeToRestore isn't within a FocusScope (i.e. we are leaving the top level focus scope)\n                // then move focus to the body.\n                // Otherwise restore focus to the nodeToRestore (e.g menu within a popover -> tabbing to close the menu should move focus to menu trigger)\n                if (!$9bf71ea28793e738$var$isElementInAnyScope(nodeToRestore)) focusedElement.blur();\n                else $9bf71ea28793e738$var$focusElement(nodeToRestore, true);\n            }\n        };\n        if (!contain) document.addEventListener(\"keydown\", onKeyDown, true);\n        return ()=>{\n            if (!contain) document.removeEventListener(\"keydown\", onKeyDown, true);\n            let nodeToRestore = $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(scopeRef).nodeToRestore;\n            // if we already lost focus to the body and this was the active scope, then we should attempt to restore\n            if (restoreFocus && nodeToRestore && // eslint-disable-next-line react-hooks/exhaustive-deps\n            ($9bf71ea28793e738$var$isElementInScope(document.activeElement, scopeRef.current) || document.activeElement === document.body && $9bf71ea28793e738$var$shouldRestoreFocus(scopeRef))) {\n                // freeze the focusScopeTree so it persists after the raf, otherwise during unmount nodes are removed from it\n                let clonedTree = $9bf71ea28793e738$export$d06fae2ee68b101e.clone();\n                requestAnimationFrame(()=>{\n                    // Only restore focus if we've lost focus to the body, the alternative is that focus has been purposefully moved elsewhere\n                    if (document.activeElement === document.body) {\n                        // look up the tree starting with our scope to find a nodeToRestore still in the DOM\n                        let treeNode = clonedTree.getTreeNode(scopeRef);\n                        while(treeNode){\n                            if (treeNode.nodeToRestore && document.body.contains(treeNode.nodeToRestore)) {\n                                $9bf71ea28793e738$var$focusElement(treeNode.nodeToRestore);\n                                return;\n                            }\n                            treeNode = treeNode.parent;\n                        }\n                        // If no nodeToRestore was found, focus the first element in the nearest\n                        // ancestor scope that is still in the tree.\n                        treeNode = clonedTree.getTreeNode(scopeRef);\n                        while(treeNode){\n                            if (treeNode.scopeRef && $9bf71ea28793e738$export$d06fae2ee68b101e.getTreeNode(treeNode.scopeRef)) {\n                                $9bf71ea28793e738$var$focusFirstInScope(treeNode.scopeRef.current, true);\n                                return;\n                            }\n                            treeNode = treeNode.parent;\n                        }\n                    }\n                });\n            }\n        };\n    }, [\n        scopeRef,\n        restoreFocus,\n        contain\n    ]);\n}\nfunction $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, opts, scope) {\n    let selector = (opts === null || opts === void 0 ? void 0 : opts.tabbable) ? $9bf71ea28793e738$var$TABBABLE_ELEMENT_SELECTOR : $9bf71ea28793e738$var$FOCUSABLE_ELEMENT_SELECTOR;\n    let walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {\n        acceptNode (node) {\n            var _opts_from;\n            // Skip nodes inside the starting node.\n            if (opts === null || opts === void 0 ? void 0 : (_opts_from = opts.from) === null || _opts_from === void 0 ? void 0 : _opts_from.contains(node)) return NodeFilter.FILTER_REJECT;\n            if (node.matches(selector) && (0, $645f2e67b85a24c9$export$e989c0fffaa6b27a)(node) && (!scope || $9bf71ea28793e738$var$isElementInScope(node, scope)) && (!(opts === null || opts === void 0 ? void 0 : opts.accept) || opts.accept(node))) return NodeFilter.FILTER_ACCEPT;\n            return NodeFilter.FILTER_SKIP;\n        }\n    });\n    if (opts === null || opts === void 0 ? void 0 : opts.from) walker.currentNode = opts.from;\n    return walker;\n}\nfunction $9bf71ea28793e738$export$c5251b9e124bf29(ref, defaultOptions = {}) {\n    return {\n        focusNext (opts = {}) {\n            let root = ref.current;\n            if (!root) return;\n            let { from: from , tabbable: tabbable = defaultOptions.tabbable , wrap: wrap = defaultOptions.wrap , accept: accept = defaultOptions.accept  } = opts;\n            let node = from || document.activeElement;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, {\n                tabbable: tabbable,\n                accept: accept\n            });\n            if (root.contains(node)) walker.currentNode = node;\n            let nextNode = walker.nextNode();\n            if (!nextNode && wrap) {\n                walker.currentNode = root;\n                nextNode = walker.nextNode();\n            }\n            if (nextNode) $9bf71ea28793e738$var$focusElement(nextNode, true);\n            return nextNode;\n        },\n        focusPrevious (opts = defaultOptions) {\n            let root = ref.current;\n            if (!root) return;\n            let { from: from , tabbable: tabbable = defaultOptions.tabbable , wrap: wrap = defaultOptions.wrap , accept: accept = defaultOptions.accept  } = opts;\n            let node = from || document.activeElement;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, {\n                tabbable: tabbable,\n                accept: accept\n            });\n            if (root.contains(node)) walker.currentNode = node;\n            else {\n                let next = $9bf71ea28793e738$var$last(walker);\n                if (next) $9bf71ea28793e738$var$focusElement(next, true);\n                return next;\n            }\n            let previousNode = walker.previousNode();\n            if (!previousNode && wrap) {\n                walker.currentNode = root;\n                previousNode = $9bf71ea28793e738$var$last(walker);\n            }\n            if (previousNode) $9bf71ea28793e738$var$focusElement(previousNode, true);\n            return previousNode;\n        },\n        focusFirst (opts = defaultOptions) {\n            let root = ref.current;\n            if (!root) return;\n            let { tabbable: tabbable = defaultOptions.tabbable , accept: accept = defaultOptions.accept  } = opts;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, {\n                tabbable: tabbable,\n                accept: accept\n            });\n            let nextNode = walker.nextNode();\n            if (nextNode) $9bf71ea28793e738$var$focusElement(nextNode, true);\n            return nextNode;\n        },\n        focusLast (opts = defaultOptions) {\n            let root = ref.current;\n            if (!root) return;\n            let { tabbable: tabbable = defaultOptions.tabbable , accept: accept = defaultOptions.accept  } = opts;\n            let walker = $9bf71ea28793e738$export$2d6ec8fc375ceafa(root, {\n                tabbable: tabbable,\n                accept: accept\n            });\n            let next = $9bf71ea28793e738$var$last(walker);\n            if (next) $9bf71ea28793e738$var$focusElement(next, true);\n            return next;\n        }\n    };\n}\nfunction $9bf71ea28793e738$var$last(walker) {\n    let next;\n    let last;\n    do {\n        last = walker.lastChild();\n        if (last) next = last;\n    }while (last);\n    return next;\n}\nclass $9bf71ea28793e738$var$Tree {\n    get size() {\n        return this.fastMap.size;\n    }\n    getTreeNode(data) {\n        return this.fastMap.get(data);\n    }\n    addTreeNode(scopeRef, parent, nodeToRestore) {\n        let parentNode = this.fastMap.get(parent !== null && parent !== void 0 ? parent : null);\n        let node = new $9bf71ea28793e738$var$TreeNode({\n            scopeRef: scopeRef\n        });\n        parentNode.addChild(node);\n        node.parent = parentNode;\n        this.fastMap.set(scopeRef, node);\n        if (nodeToRestore) node.nodeToRestore = nodeToRestore;\n    }\n    addNode(node) {\n        this.fastMap.set(node.scopeRef, node);\n    }\n    removeTreeNode(scopeRef) {\n        // never remove the root\n        if (scopeRef === null) return;\n        let node = this.fastMap.get(scopeRef);\n        let parentNode = node.parent;\n        // when we remove a scope, check if any sibling scopes are trying to restore focus to something inside the scope we're removing\n        // if we are, then replace the siblings restore with the restore from the scope we're removing\n        for (let current of this.traverse())if (current !== node && node.nodeToRestore && current.nodeToRestore && node.scopeRef.current && $9bf71ea28793e738$var$isElementInScope(current.nodeToRestore, node.scopeRef.current)) current.nodeToRestore = node.nodeToRestore;\n        let children = node.children;\n        parentNode.removeChild(node);\n        if (children.size > 0) children.forEach((child)=>parentNode.addChild(child));\n        this.fastMap.delete(node.scopeRef);\n    }\n    // Pre Order Depth First\n    *traverse(node = this.root) {\n        if (node.scopeRef != null) yield node;\n        if (node.children.size > 0) for (let child of node.children)yield* this.traverse(child);\n    }\n    clone() {\n        let newTree = new $9bf71ea28793e738$var$Tree();\n        for (let node of this.traverse())newTree.addTreeNode(node.scopeRef, node.parent.scopeRef, node.nodeToRestore);\n        return newTree;\n    }\n    constructor(){\n        (0, $6nfFC$swchelperssrc_define_propertymjs)(this, \"fastMap\", new Map());\n        this.root = new $9bf71ea28793e738$var$TreeNode({\n            scopeRef: null\n        });\n        this.fastMap.set(null, this.root);\n    }\n}\nclass $9bf71ea28793e738$var$TreeNode {\n    addChild(node) {\n        this.children.add(node);\n        node.parent = this;\n    }\n    removeChild(node) {\n        this.children.delete(node);\n        node.parent = undefined;\n    }\n    constructor(props){\n        (0, $6nfFC$swchelperssrc_define_propertymjs)(this, \"children\", new Set());\n        (0, $6nfFC$swchelperssrc_define_propertymjs)(this, \"contain\", false);\n        this.scopeRef = props.scopeRef;\n    }\n}\nlet $9bf71ea28793e738$export$d06fae2ee68b101e = new $9bf71ea28793e738$var$Tree();\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\n\n\n\nfunction $f7dceffc5ad7768b$export$4e328f61c538687f(props = {}) {\n    let { autoFocus: autoFocus = false , isTextInput: isTextInput , within: within  } = props;\n    let state = (0, $6nfFC$useRef)({\n        isFocused: false,\n        isFocusVisible: autoFocus || (0, $6nfFC$isFocusVisible)()\n    });\n    let [isFocused, setFocused] = (0, $6nfFC$useState)(false);\n    let [isFocusVisibleState, setFocusVisible] = (0, $6nfFC$useState)(()=>state.current.isFocused && state.current.isFocusVisible);\n    let updateState = (0, $6nfFC$useCallback)(()=>setFocusVisible(state.current.isFocused && state.current.isFocusVisible), []);\n    let onFocusChange = (0, $6nfFC$useCallback)((isFocused)=>{\n        state.current.isFocused = isFocused;\n        setFocused(isFocused);\n        updateState();\n    }, [\n        updateState\n    ]);\n    (0, $6nfFC$useFocusVisibleListener)((isFocusVisible)=>{\n        state.current.isFocusVisible = isFocusVisible;\n        updateState();\n    }, [], {\n        isTextInput: isTextInput\n    });\n    let { focusProps: focusProps  } = (0, $6nfFC$useFocus)({\n        isDisabled: within,\n        onFocusChange: onFocusChange\n    });\n    let { focusWithinProps: focusWithinProps  } = (0, $6nfFC$useFocusWithin)({\n        isDisabled: !within,\n        onFocusWithinChange: onFocusChange\n    });\n    return {\n        isFocused: isFocused,\n        isFocusVisible: state.current.isFocused && isFocusVisibleState,\n        focusProps: within ? focusWithinProps : focusProps\n    };\n}\n\n\nfunction $907718708eab68af$export$1a38b4ad7f578e1d(props) {\n    let { children: children , focusClass: focusClass , focusRingClass: focusRingClass  } = props;\n    let { isFocused: isFocused , isFocusVisible: isFocusVisible , focusProps: focusProps  } = (0, $f7dceffc5ad7768b$export$4e328f61c538687f)(props);\n    let child = (0, $6nfFC$react).Children.only(children);\n    return /*#__PURE__*/ (0, $6nfFC$react).cloneElement(child, (0, $6nfFC$mergeProps)(child.props, {\n        ...focusProps,\n        className: (0, $6nfFC$clsx)({\n            [focusClass || \"\"]: isFocused,\n            [focusRingClass || \"\"]: isFocusVisible\n        })\n    }));\n}\n\n\n/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\n\nlet $e6afbd83fe6ebbd2$var$FocusableContext = /*#__PURE__*/ (0, $6nfFC$react).createContext(null);\nfunction $e6afbd83fe6ebbd2$var$useFocusableContext(ref) {\n    let context = (0, $6nfFC$useContext)($e6afbd83fe6ebbd2$var$FocusableContext) || {};\n    (0, $6nfFC$useSyncRef)(context, ref);\n    // eslint-disable-next-line\n    let { ref: _ , ...otherProps } = context;\n    return otherProps;\n}\n/**\n * Provides DOM props to the nearest focusable child.\n */ function $e6afbd83fe6ebbd2$var$FocusableProvider(props, ref) {\n    let { children: children , ...otherProps } = props;\n    let context = {\n        ...otherProps,\n        ref: ref\n    };\n    return /*#__PURE__*/ (0, $6nfFC$react).createElement($e6afbd83fe6ebbd2$var$FocusableContext.Provider, {\n        value: context\n    }, children);\n}\nlet $e6afbd83fe6ebbd2$export$13f3202a3e5ddd5 = /*#__PURE__*/ (0, $6nfFC$react).forwardRef($e6afbd83fe6ebbd2$var$FocusableProvider);\nfunction $e6afbd83fe6ebbd2$export$4c014de7c8940b4c(props, domRef) {\n    let { focusProps: focusProps  } = (0, $6nfFC$useFocus)(props);\n    let { keyboardProps: keyboardProps  } = (0, $6nfFC$useKeyboard)(props);\n    let interactions = (0, $6nfFC$mergeProps)(focusProps, keyboardProps);\n    let domProps = $e6afbd83fe6ebbd2$var$useFocusableContext(domRef);\n    let interactionProps = props.isDisabled ? {} : domProps;\n    let autoFocusRef = (0, $6nfFC$useRef)(props.autoFocus);\n    (0, $6nfFC$useEffect)(()=>{\n        if (autoFocusRef.current && domRef.current) (0, $6a99195332edec8b$export$80f3e147d781571c)(domRef.current);\n        autoFocusRef.current = false;\n    }, [\n        domRef\n    ]);\n    return {\n        focusableProps: (0, $6nfFC$mergeProps)({\n            ...interactions,\n            tabIndex: props.excludeFromTabOrder && !props.isDisabled ? -1 : undefined\n        }, interactionProps)\n    };\n}\n\n\n\n\n/*\n * Copyright 2022 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */ \n\n\nfunction $83013635b024ae3d$export$eac1895992b9f3d6(ref, options) {\n    let isDisabled = options === null || options === void 0 ? void 0 : options.isDisabled;\n    let [hasTabbableChild, setHasTabbableChild] = (0, $6nfFC$useState)(false);\n    (0, $6nfFC$useLayoutEffect)(()=>{\n        if ((ref === null || ref === void 0 ? void 0 : ref.current) && !isDisabled) {\n            let update = ()=>{\n                if (ref.current) {\n                    let walker = (0, $9bf71ea28793e738$export$2d6ec8fc375ceafa)(ref.current, {\n                        tabbable: true\n                    });\n                    setHasTabbableChild(!!walker.nextNode());\n                }\n            };\n            update();\n            // Update when new elements are inserted, or the tabIndex/disabled attribute updates.\n            let observer = new MutationObserver(update);\n            observer.observe(ref.current, {\n                subtree: true,\n                childList: true,\n                attributes: true,\n                attributeFilter: [\n                    \"tabIndex\",\n                    \"disabled\"\n                ]\n            });\n            return ()=>{\n                // Disconnect mutation observer when a React update occurs on the top-level component\n                // so we update synchronously after re-rendering. Otherwise React will emit act warnings\n                // in tests since mutation observers fire asynchronously. The mutation observer is necessary\n                // so we also update if a child component re-renders and adds/removes something tabbable.\n                observer.disconnect();\n            };\n        }\n    });\n    return isDisabled ? false : hasTabbableChild;\n}\n\n\n\n\nexport {$9bf71ea28793e738$export$20e40289641fbbb6 as FocusScope, $9bf71ea28793e738$export$10c5169755ce7bd7 as useFocusManager, $9bf71ea28793e738$export$2d6ec8fc375ceafa as getFocusableTreeWalker, $9bf71ea28793e738$export$c5251b9e124bf29 as createFocusManager, $9bf71ea28793e738$export$1258395f99bf9cbf as isElementInChildOfActiveScope, $907718708eab68af$export$1a38b4ad7f578e1d as FocusRing, $e6afbd83fe6ebbd2$export$13f3202a3e5ddd5 as FocusableProvider, $e6afbd83fe6ebbd2$export$4c014de7c8940b4c as useFocusable, $f7dceffc5ad7768b$export$4e328f61c538687f as useFocusRing, $6a99195332edec8b$export$80f3e147d781571c as focusSafely, $83013635b024ae3d$export$eac1895992b9f3d6 as useHasTabbableChild};\n//# sourceMappingURL=module.js.map\n"],"names":["_defineProperty","obj","key","value","Object","defineProperty","enumerable","configurable","writable","r","e","t","f","n","Array","isArray","length","arguments","$f0a04ccd8dbdd83b$export$e5c5a5f917a5871c","window","useLayoutEffect","$bdb11010cef70236$var$idsUpdaterMap","Map","$bdb11010cef70236$export$cd8c9cb68f842629","idA","idB","setIdA","get","setIdB","$ff5963eb1fccf552$export$e08e3b67e392101e","callbacks","args","callback","$7215afc6de606d6b$export$de79e2c695e052f3","element","$7215afc6de606d6b$var$supportsPreventScrollCached","document","createElement","focus","preventScroll","$7215afc6de606d6b$var$supportsPreventScroll","scrollableElements","parent","parentNode","rootScrollingElement","scrollingElement","documentElement","HTMLElement","offsetHeight","scrollHeight","offsetWidth","scrollWidth","push","scrollTop","scrollLeft","$7215afc6de606d6b$var$getScrollableElements","$7215afc6de606d6b$var$restoreScrollPosition","Set","$bbed8b41f857bcc0$var$transitionsByElement","$bbed8b41f857bcc0$var$transitionCallbacks","$bbed8b41f857bcc0$var$setupGlobalEvents","onTransitionEnd","properties","target","delete","propertyName","size","removeEventListener","cb","clear","body","addEventListener","transitions","set","add","$c87311424ea30a05$export$9ac100e40613ea10","re","navigator","test","_window_navigator_userAgentData","platform","$6a7db85432448f7f$export$60278871457622de","event","mozInputSource","isTrusted","brands","some","brand","userAgent","pointerType","type","buttons","detail","readyState","visualViewport","WeakMap","createContext","displayName","$8a9cb279dc87e130$export$905e7fc544a71f36","isDefaultPrevented","this","nativeEvent","defaultPrevented","preventDefault","stopPropagation","isPropagationStopped","persist","constructor","currentTarget","relatedTarget","bubbles","cancelable","eventPhase","timeStamp","$8a9cb279dc87e130$export$715c682d09d639cc","onBlur","stateRef","isFocused","observer","current","state","disconnect","HTMLButtonElement","HTMLInputElement","HTMLTextAreaElement","HTMLSelectElement","onBlurHandler","_stateRef_current","_stateRef_current_onBlur","disabled","call","once","MutationObserver","dispatchEvent","FocusEvent","observe","attributes","attributeFilter","$507fabe10e71c6fb$var$currentModality","$507fabe10e71c6fb$var$changeHandlers","$507fabe10e71c6fb$var$hasSetupGlobalListeners","$507fabe10e71c6fb$var$hasEventBeforeFocus","$507fabe10e71c6fb$var$hasBlurredWindowRecently","$507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS","Tab","Escape","$507fabe10e71c6fb$var$triggerChangeHandlers","modality","handler","$507fabe10e71c6fb$var$handleKeyboardEvent","metaKey","altKey","ctrlKey","$507fabe10e71c6fb$var$isValidKey","$507fabe10e71c6fb$var$handlePointerEvent","$507fabe10e71c6fb$var$handleClickEvent","$507fabe10e71c6fb$var$handleFocusEvent","$507fabe10e71c6fb$var$handleWindowBlur","$507fabe10e71c6fb$var$setupGlobalFocusEvents","prototype","apply","PointerEvent","$507fabe10e71c6fb$export$b9b3dfddab17db27","$645f2e67b85a24c9$export$e989c0fffaa6b27a","childElement","nodeName","SVGElement","display","visibility","style","isVisible","getComputedStyle","ownerDocument","defaultView","computedDisplay","computedVisibility","$645f2e67b85a24c9$var$isStyleVisible","hasAttribute","$645f2e67b85a24c9$var$isAttributeVisible","parentElement","$9bf71ea28793e738$var$FocusContext","$9bf71ea28793e738$var$activeScope","$9bf71ea28793e738$export$20e40289641fbbb6","props","children","contain","restoreFocus","autoFocus","startRef","endRef","scopeRef","node","$9bf71ea28793e738$var$TreeNode","$9bf71ea28793e738$export$d06fae2ee68b101e","root","getTreeNode","$9bf71ea28793e738$var$isAncestorScope","activeNode","addChild","addNode","nextSibling","nodes","restore","scope","onFocus","$9bf71ea28793e738$var$isElementInScope","$9bf71ea28793e738$var$isElementInAnyScope","forEach","$9bf71ea28793e738$var$useActiveScopeTracker","focusedNode","raf","cancelAnimationFrame","onKeyDown","$9bf71ea28793e738$var$shouldContainFocus","focusedElement","activeElement","walker","$9bf71ea28793e738$export$2d6ec8fc375ceafa","$9bf71ea28793e738$var$getScopeRoot","tabbable","currentNode","nextElement","shiftKey","previousNode","nextNode","nextElementSibling","previousElementSibling","$9bf71ea28793e738$var$focusElement","$9bf71ea28793e738$var$isElementInChildScope","$9bf71ea28793e738$var$focusFirstInScope","requestAnimationFrame","contains","$9bf71ea28793e738$var$useFocusContainment","nodeToRestoreRef","nodeToRestore","blur","$9bf71ea28793e738$var$shouldRestoreFocus","clonedTree","clone","treeNode","$9bf71ea28793e738$var$useRestoreFocus","autoFocusRef","useRef","$9bf71ea28793e738$var$useAutoFocus","traverse","parentScope","removeTreeNode","focusManager","focusNext","opts","from","wrap","accept","sentinel","focusPrevious","focusFirst","focusLast","$9bf71ea28793e738$var$createFocusManagerForScope","Provider","hidden","ref","$9bf71ea28793e738$export$10c5169755ce7bd7","_useContext","$9bf71ea28793e738$var$focusableElements","$9bf71ea28793e738$var$FOCUSABLE_ELEMENT_SELECTOR","join","$9bf71ea28793e738$var$TABBABLE_ELEMENT_SELECTOR","Element","closest","s","ancestor","_focusScopeTree_getTreeNode","scroll","err1","lastFocusedElement","fn","err","selector","createTreeWalker","NodeFilter","SHOW_ELEMENT","acceptNode","_opts_from","FILTER_REJECT","matches","FILTER_SKIP","FILTER_ACCEPT","$9bf71ea28793e738$var$Tree","fastMap","data","addTreeNode","removeChild","child","newTree","undefined","$f7dceffc5ad7768b$export$4e328f61c538687f","isTextInput","within","isFocusVisible","setFocused","isFocusVisibleState","setFocusVisible","updateState","onFocusChange","deps","KeyboardEvent","$507fabe10e71c6fb$var$isKeyboardFocusEvent","focusProps","isDisabled","onFocusProp","onBlurProp","onSyntheticFocus","focusWithinProps","onBlurWithin","onFocusWithin","onFocusWithinChange","isFocusWithin","$907718708eab68af$export$1a38b4ad7f578e1d","focusClass","focusRingClass","Children","only","cloneElement","result","i","a","b","charCodeAt","id","className"],"sourceRoot":""}