@arc-ui/components 12.0.0-beta.13 → 12.0.0-beta.14.1

package/dist/_shared/cjs/index-io8xALL_.js

@@ -1,2264 +0,0 @@
-'use strict';
-
-var index = require('./index-BqJfkZWj.js');
-var React = require('react');
-var ReactDOM = require('react-dom');
-var index$4 = require('./index-B349W-g3.js');
-var index$5 = require('./index-Dvj8rZCZ.js');
-var index$1 = require('./index-DiFGFQH4.js');
-var floatingUi_reactDom = require('./floating-ui.react-dom-CJlNwMgv.js');
-var index$2 = require('./index-Dx8AlCbY.js');
-var component = require('./component-DpycPOA_.js');
-var index$3 = require('./index-D6hGsItk.js');
-var component$1 = require('./component-BGCX8GK6.js');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
-
-function $ae6933e535247d3d$export$7d15b64cf5a3a4c4(value, [min, max]) {
-    return Math.min(max, Math.max(min, value));
-}
-
-const $5cb92bef7577960e$var$CONTEXT_UPDATE = 'dismissableLayer.update';
-const $5cb92bef7577960e$var$POINTER_DOWN_OUTSIDE = 'dismissableLayer.pointerDownOutside';
-const $5cb92bef7577960e$var$FOCUS_OUTSIDE = 'dismissableLayer.focusOutside';
-let $5cb92bef7577960e$var$originalBodyPointerEvents;
-const $5cb92bef7577960e$var$DismissableLayerContext = /*#__PURE__*/ React.createContext({
-    layers: new Set(),
-    layersWithOutsidePointerEventsDisabled: new Set(),
-    branches: new Set()
-});
-const $5cb92bef7577960e$export$177fb62ff3ec1f22 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    var _node$ownerDocument;
-    const { disableOutsidePointerEvents: disableOutsidePointerEvents = false , onEscapeKeyDown: onEscapeKeyDown , onPointerDownOutside: onPointerDownOutside , onFocusOutside: onFocusOutside , onInteractOutside: onInteractOutside , onDismiss: onDismiss , ...layerProps } = props;
-    const context = React.useContext($5cb92bef7577960e$var$DismissableLayerContext);
-    const [node1, setNode] = React.useState(null);
-    const ownerDocument = (_node$ownerDocument = node1 === null || node1 === void 0 ? void 0 : node1.ownerDocument) !== null && _node$ownerDocument !== void 0 ? _node$ownerDocument : globalThis === null || globalThis === void 0 ? void 0 : globalThis.document;
-    const [, force] = React.useState({});
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, (node)=>setNode(node)
-    );
-    const layers = Array.from(context.layers);
-    const [highestLayerWithOutsidePointerEventsDisabled] = [
-        ...context.layersWithOutsidePointerEventsDisabled
-    ].slice(-1); // prettier-ignore
-    const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled); // prettier-ignore
-    const index$2 = node1 ? layers.indexOf(node1) : -1;
-    const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;
-    const isPointerEventsEnabled = index$2 >= highestLayerWithOutsidePointerEventsDisabledIndex;
-    const pointerDownOutside = $5cb92bef7577960e$var$usePointerDownOutside((event)=>{
-        const target = event.target;
-        const isPointerDownOnBranch = [
-            ...context.branches
-        ].some((branch)=>branch.contains(target)
-        );
-        if (!isPointerEventsEnabled || isPointerDownOnBranch) return;
-        onPointerDownOutside === null || onPointerDownOutside === void 0 || onPointerDownOutside(event);
-        onInteractOutside === null || onInteractOutside === void 0 || onInteractOutside(event);
-        if (!event.defaultPrevented) onDismiss === null || onDismiss === void 0 || onDismiss();
-    }, ownerDocument);
-    const focusOutside = $5cb92bef7577960e$var$useFocusOutside((event)=>{
-        const target = event.target;
-        const isFocusInBranch = [
-            ...context.branches
-        ].some((branch)=>branch.contains(target)
-        );
-        if (isFocusInBranch) return;
-        onFocusOutside === null || onFocusOutside === void 0 || onFocusOutside(event);
-        onInteractOutside === null || onInteractOutside === void 0 || onInteractOutside(event);
-        if (!event.defaultPrevented) onDismiss === null || onDismiss === void 0 || onDismiss();
-    }, ownerDocument);
-    index$1.$addc16e1bbe58fd0$export$3a72a57244d6e765((event)=>{
-        const isHighestLayer = index$2 === context.layers.size - 1;
-        if (!isHighestLayer) return;
-        onEscapeKeyDown === null || onEscapeKeyDown === void 0 || onEscapeKeyDown(event);
-        if (!event.defaultPrevented && onDismiss) {
-            event.preventDefault();
-            onDismiss();
-        }
-    }, ownerDocument);
-    React.useEffect(()=>{
-        if (!node1) return;
-        if (disableOutsidePointerEvents) {
-            if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
-                $5cb92bef7577960e$var$originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
-                ownerDocument.body.style.pointerEvents = 'none';
-            }
-            context.layersWithOutsidePointerEventsDisabled.add(node1);
-        }
-        context.layers.add(node1);
-        $5cb92bef7577960e$var$dispatchUpdate();
-        return ()=>{
-            if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) ownerDocument.body.style.pointerEvents = $5cb92bef7577960e$var$originalBodyPointerEvents;
-        };
-    }, [
-        node1,
-        ownerDocument,
-        disableOutsidePointerEvents,
-        context
-    ]);
-    /**
-   * We purposefully prevent combining this effect with the `disableOutsidePointerEvents` effect
-   * because a change to `disableOutsidePointerEvents` would remove this layer from the stack
-   * and add it to the end again so the layering order wouldn't be _creation order_.
-   * We only want them to be removed from context stacks when unmounted.
-   */ React.useEffect(()=>{
-        return ()=>{
-            if (!node1) return;
-            context.layers.delete(node1);
-            context.layersWithOutsidePointerEventsDisabled.delete(node1);
-            $5cb92bef7577960e$var$dispatchUpdate();
-        };
-    }, [
-        node1,
-        context
-    ]);
-    React.useEffect(()=>{
-        const handleUpdate = ()=>force({})
-        ;
-        document.addEventListener($5cb92bef7577960e$var$CONTEXT_UPDATE, handleUpdate);
-        return ()=>document.removeEventListener($5cb92bef7577960e$var$CONTEXT_UPDATE, handleUpdate)
-        ;
-    }, []);
-    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({}, layerProps, {
-        ref: composedRefs,
-        style: {
-            pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? 'auto' : 'none' : undefined,
-            ...props.style
-        },
-        onFocusCapture: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onFocusCapture, focusOutside.onFocusCapture),
-        onBlurCapture: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onBlurCapture, focusOutside.onBlurCapture),
-        onPointerDownCapture: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(props.onPointerDownCapture, pointerDownOutside.onPointerDownCapture)
-    }));
-});
-/* -----------------------------------------------------------------------------------------------*/ /**
- * Listens for `pointerdown` outside a react subtree. We use `pointerdown` rather than `pointerup`
- * to mimic layer dismissing behaviour present in OS.
- * Returns props to pass to the node we want to check for outside events.
- */ function $5cb92bef7577960e$var$usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {
-    const handlePointerDownOutside = index.$b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onPointerDownOutside);
-    const isPointerInsideReactTreeRef = React.useRef(false);
-    const handleClickRef = React.useRef(()=>{});
-    React.useEffect(()=>{
-        const handlePointerDown = (event)=>{
-            if (event.target && !isPointerInsideReactTreeRef.current) {
-                const eventDetail = {
-                    originalEvent: event
-                };
-                function handleAndDispatchPointerDownOutsideEvent() {
-                    $5cb92bef7577960e$var$handleAndDispatchCustomEvent($5cb92bef7577960e$var$POINTER_DOWN_OUTSIDE, handlePointerDownOutside, eventDetail, {
-                        discrete: true
-                    });
-                }
-                /**
-         * On touch devices, we need to wait for a click event because browsers implement
-         * a ~350ms delay between the time the user stops touching the display and when the
-         * browser executres events. We need to ensure we don't reactivate pointer-events within
-         * this timeframe otherwise the browser may execute events that should have been prevented.
-         *
-         * Additionally, this also lets us deal automatically with cancellations when a click event
-         * isn't raised because the page was considered scrolled/drag-scrolled, long-pressed, etc.
-         *
-         * This is why we also continuously remove the previous listener, because we cannot be
-         * certain that it was raised, and therefore cleaned-up.
-         */ if (event.pointerType === 'touch') {
-                    ownerDocument.removeEventListener('click', handleClickRef.current);
-                    handleClickRef.current = handleAndDispatchPointerDownOutsideEvent;
-                    ownerDocument.addEventListener('click', handleClickRef.current, {
-                        once: true
-                    });
-                } else handleAndDispatchPointerDownOutsideEvent();
-            } else // We need to remove the event listener in case the outside click has been canceled.
-            // See: https://github.com/radix-ui/primitives/issues/2171
-            ownerDocument.removeEventListener('click', handleClickRef.current);
-            isPointerInsideReactTreeRef.current = false;
-        };
-        /**
-     * if this hook executes in a component that mounts via a `pointerdown` event, the event
-     * would bubble up to the document and trigger a `pointerDownOutside` event. We avoid
-     * this by delaying the event listener registration on the document.
-     * This is not React specific, but rather how the DOM works, ie:
-     * ```
-     * button.addEventListener('pointerdown', () => {
-     *   console.log('I will log');
-     *   document.addEventListener('pointerdown', () => {
-     *     console.log('I will also log');
-     *   })
-     * });
-     */ const timerId = window.setTimeout(()=>{
-            ownerDocument.addEventListener('pointerdown', handlePointerDown);
-        }, 0);
-        return ()=>{
-            window.clearTimeout(timerId);
-            ownerDocument.removeEventListener('pointerdown', handlePointerDown);
-            ownerDocument.removeEventListener('click', handleClickRef.current);
-        };
-    }, [
-        ownerDocument,
-        handlePointerDownOutside
-    ]);
-    return {
-        // ensures we check React component tree (not just DOM tree)
-        onPointerDownCapture: ()=>isPointerInsideReactTreeRef.current = true
-    };
-}
-/**
- * Listens for when focus happens outside a react subtree.
- * Returns props to pass to the root (node) of the subtree we want to check.
- */ function $5cb92bef7577960e$var$useFocusOutside(onFocusOutside, ownerDocument = globalThis === null || globalThis === void 0 ? void 0 : globalThis.document) {
-    const handleFocusOutside = index.$b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onFocusOutside);
-    const isFocusInsideReactTreeRef = React.useRef(false);
-    React.useEffect(()=>{
-        const handleFocus = (event)=>{
-            if (event.target && !isFocusInsideReactTreeRef.current) {
-                const eventDetail = {
-                    originalEvent: event
-                };
-                $5cb92bef7577960e$var$handleAndDispatchCustomEvent($5cb92bef7577960e$var$FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {
-                    discrete: false
-                });
-            }
-        };
-        ownerDocument.addEventListener('focusin', handleFocus);
-        return ()=>ownerDocument.removeEventListener('focusin', handleFocus)
-        ;
-    }, [
-        ownerDocument,
-        handleFocusOutside
-    ]);
-    return {
-        onFocusCapture: ()=>isFocusInsideReactTreeRef.current = true
-        ,
-        onBlurCapture: ()=>isFocusInsideReactTreeRef.current = false
-    };
-}
-function $5cb92bef7577960e$var$dispatchUpdate() {
-    const event = new CustomEvent($5cb92bef7577960e$var$CONTEXT_UPDATE);
-    document.dispatchEvent(event);
-}
-function $5cb92bef7577960e$var$handleAndDispatchCustomEvent(name, handler, detail, { discrete: discrete  }) {
-    const target = detail.originalEvent.target;
-    const event = new CustomEvent(name, {
-        bubbles: false,
-        cancelable: true,
-        detail: detail
-    });
-    if (handler) target.addEventListener(name, handler, {
-        once: true
-    });
-    if (discrete) index.$8927f6f2acc4f386$export$6d1a0317bde7de7f(target, event);
-    else target.dispatchEvent(event);
-}
-
-/** Number of components which have requested interest to have focus guards */ let $3db38b7d1fb3fe6a$var$count = 0;
-/**
- * Injects a pair of focus guards at the edges of the whole DOM tree
- * to ensure `focusin` & `focusout` events can be caught consistently.
- */ function $3db38b7d1fb3fe6a$export$b7ece24a22aeda8c() {
-    React.useEffect(()=>{
-        var _edgeGuards$, _edgeGuards$2;
-        const edgeGuards = document.querySelectorAll('[data-radix-focus-guard]');
-        document.body.insertAdjacentElement('afterbegin', (_edgeGuards$ = edgeGuards[0]) !== null && _edgeGuards$ !== void 0 ? _edgeGuards$ : $3db38b7d1fb3fe6a$var$createFocusGuard());
-        document.body.insertAdjacentElement('beforeend', (_edgeGuards$2 = edgeGuards[1]) !== null && _edgeGuards$2 !== void 0 ? _edgeGuards$2 : $3db38b7d1fb3fe6a$var$createFocusGuard());
-        $3db38b7d1fb3fe6a$var$count++;
-        return ()=>{
-            if ($3db38b7d1fb3fe6a$var$count === 1) document.querySelectorAll('[data-radix-focus-guard]').forEach((node)=>node.remove()
-            );
-            $3db38b7d1fb3fe6a$var$count--;
-        };
-    }, []);
-}
-function $3db38b7d1fb3fe6a$var$createFocusGuard() {
-    const element = document.createElement('span');
-    element.setAttribute('data-radix-focus-guard', '');
-    element.tabIndex = 0;
-    element.style.cssText = 'outline: none; opacity: 0; position: fixed; pointer-events: none';
-    return element;
-}
-
-const $d3863c46a17e8a28$var$AUTOFOCUS_ON_MOUNT = 'focusScope.autoFocusOnMount';
-const $d3863c46a17e8a28$var$AUTOFOCUS_ON_UNMOUNT = 'focusScope.autoFocusOnUnmount';
-const $d3863c46a17e8a28$var$EVENT_OPTIONS = {
-    bubbles: false,
-    cancelable: true
-};
-const $d3863c46a17e8a28$export$20e40289641fbbb6 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { loop: loop = false , trapped: trapped = false , onMountAutoFocus: onMountAutoFocusProp , onUnmountAutoFocus: onUnmountAutoFocusProp , ...scopeProps } = props;
-    const [container1, setContainer] = React.useState(null);
-    const onMountAutoFocus = index.$b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onMountAutoFocusProp);
-    const onUnmountAutoFocus = index.$b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onUnmountAutoFocusProp);
-    const lastFocusedElementRef = React.useRef(null);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, (node)=>setContainer(node)
-    );
-    const focusScope = React.useRef({
-        paused: false,
-        pause () {
-            this.paused = true;
-        },
-        resume () {
-            this.paused = false;
-        }
-    }).current; // Takes care of trapping focus if focus is moved outside programmatically for example
-    React.useEffect(()=>{
-        if (trapped) {
-            function handleFocusIn(event) {
-                if (focusScope.paused || !container1) return;
-                const target = event.target;
-                if (container1.contains(target)) lastFocusedElementRef.current = target;
-                else $d3863c46a17e8a28$var$focus(lastFocusedElementRef.current, {
-                    select: true
-                });
-            }
-            function handleFocusOut(event) {
-                if (focusScope.paused || !container1) return;
-                const relatedTarget = event.relatedTarget; // A `focusout` event with a `null` `relatedTarget` will happen in at least two cases:
-                //
-                // 1. When the user switches app/tabs/windows/the browser itself loses focus.
-                // 2. In Google Chrome, when the focused element is removed from the DOM.
-                //
-                // We let the browser do its thing here because:
-                //
-                // 1. The browser already keeps a memory of what's focused for when the page gets refocused.
-                // 2. In Google Chrome, if we try to focus the deleted focused element (as per below), it
-                //    throws the CPU to 100%, so we avoid doing anything for this reason here too.
-                if (relatedTarget === null) return; // If the focus has moved to an actual legitimate element (`relatedTarget !== null`)
-                // that is outside the container, we move focus to the last valid focused element inside.
-                if (!container1.contains(relatedTarget)) $d3863c46a17e8a28$var$focus(lastFocusedElementRef.current, {
-                    select: true
-                });
-            } // When the focused element gets removed from the DOM, browsers move focus
-            // back to the document.body. In this case, we move focus to the container
-            // to keep focus trapped correctly.
-            function handleMutations(mutations) {
-                const focusedElement = document.activeElement;
-                if (focusedElement !== document.body) return;
-                for (const mutation of mutations)if (mutation.removedNodes.length > 0) $d3863c46a17e8a28$var$focus(container1);
-            }
-            document.addEventListener('focusin', handleFocusIn);
-            document.addEventListener('focusout', handleFocusOut);
-            const mutationObserver = new MutationObserver(handleMutations);
-            if (container1) mutationObserver.observe(container1, {
-                childList: true,
-                subtree: true
-            });
-            return ()=>{
-                document.removeEventListener('focusin', handleFocusIn);
-                document.removeEventListener('focusout', handleFocusOut);
-                mutationObserver.disconnect();
-            };
-        }
-    }, [
-        trapped,
-        container1,
-        focusScope.paused
-    ]);
-    React.useEffect(()=>{
-        if (container1) {
-            $d3863c46a17e8a28$var$focusScopesStack.add(focusScope);
-            const previouslyFocusedElement = document.activeElement;
-            const hasFocusedCandidate = container1.contains(previouslyFocusedElement);
-            if (!hasFocusedCandidate) {
-                const mountEvent = new CustomEvent($d3863c46a17e8a28$var$AUTOFOCUS_ON_MOUNT, $d3863c46a17e8a28$var$EVENT_OPTIONS);
-                container1.addEventListener($d3863c46a17e8a28$var$AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
-                container1.dispatchEvent(mountEvent);
-                if (!mountEvent.defaultPrevented) {
-                    $d3863c46a17e8a28$var$focusFirst($d3863c46a17e8a28$var$removeLinks($d3863c46a17e8a28$var$getTabbableCandidates(container1)), {
-                        select: true
-                    });
-                    if (document.activeElement === previouslyFocusedElement) $d3863c46a17e8a28$var$focus(container1);
-                }
-            }
-            return ()=>{
-                container1.removeEventListener($d3863c46a17e8a28$var$AUTOFOCUS_ON_MOUNT, onMountAutoFocus); // We hit a react bug (fixed in v17) with focusing in unmount.
-                // We need to delay the focus a little to get around it for now.
-                // See: https://github.com/facebook/react/issues/17894
-                setTimeout(()=>{
-                    const unmountEvent = new CustomEvent($d3863c46a17e8a28$var$AUTOFOCUS_ON_UNMOUNT, $d3863c46a17e8a28$var$EVENT_OPTIONS);
-                    container1.addEventListener($d3863c46a17e8a28$var$AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
-                    container1.dispatchEvent(unmountEvent);
-                    if (!unmountEvent.defaultPrevented) $d3863c46a17e8a28$var$focus(previouslyFocusedElement !== null && previouslyFocusedElement !== void 0 ? previouslyFocusedElement : document.body, {
-                        select: true
-                    });
-                     // we need to remove the listener after we `dispatchEvent`
-                    container1.removeEventListener($d3863c46a17e8a28$var$AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
-                    $d3863c46a17e8a28$var$focusScopesStack.remove(focusScope);
-                }, 0);
-            };
-        }
-    }, [
-        container1,
-        onMountAutoFocus,
-        onUnmountAutoFocus,
-        focusScope
-    ]); // Takes care of looping focus (when tabbing whilst at the edges)
-    const handleKeyDown = React.useCallback((event)=>{
-        if (!loop && !trapped) return;
-        if (focusScope.paused) return;
-        const isTabKey = event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey;
-        const focusedElement = document.activeElement;
-        if (isTabKey && focusedElement) {
-            const container = event.currentTarget;
-            const [first, last] = $d3863c46a17e8a28$var$getTabbableEdges(container);
-            const hasTabbableElementsInside = first && last; // we can only wrap focus if we have tabbable edges
-            if (!hasTabbableElementsInside) {
-                if (focusedElement === container) event.preventDefault();
-            } else {
-                if (!event.shiftKey && focusedElement === last) {
-                    event.preventDefault();
-                    if (loop) $d3863c46a17e8a28$var$focus(first, {
-                        select: true
-                    });
-                } else if (event.shiftKey && focusedElement === first) {
-                    event.preventDefault();
-                    if (loop) $d3863c46a17e8a28$var$focus(last, {
-                        select: true
-                    });
-                }
-            }
-        }
-    }, [
-        loop,
-        trapped,
-        focusScope.paused
-    ]);
-    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({
-        tabIndex: -1
-    }, scopeProps, {
-        ref: composedRefs,
-        onKeyDown: handleKeyDown
-    }));
-});
-/* -------------------------------------------------------------------------------------------------
- * Utils
- * -----------------------------------------------------------------------------------------------*/ /**
- * Attempts focusing the first element in a list of candidates.
- * Stops when focus has actually moved.
- */ function $d3863c46a17e8a28$var$focusFirst(candidates, { select: select = false  } = {}) {
-    const previouslyFocusedElement = document.activeElement;
-    for (const candidate of candidates){
-        $d3863c46a17e8a28$var$focus(candidate, {
-            select: select
-        });
-        if (document.activeElement !== previouslyFocusedElement) return;
-    }
-}
-/**
- * Returns the first and last tabbable elements inside a container.
- */ function $d3863c46a17e8a28$var$getTabbableEdges(container) {
-    const candidates = $d3863c46a17e8a28$var$getTabbableCandidates(container);
-    const first = $d3863c46a17e8a28$var$findVisible(candidates, container);
-    const last = $d3863c46a17e8a28$var$findVisible(candidates.reverse(), container);
-    return [
-        first,
-        last
-    ];
-}
-/**
- * Returns a list of potential tabbable candidates.
- *
- * NOTE: This is only a close approximation. For example it doesn't take into account cases like when
- * elements are not visible. This cannot be worked out easily by just reading a property, but rather
- * necessitate runtime knowledge (computed styles, etc). We deal with these cases separately.
- *
- * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
- * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
- */ function $d3863c46a17e8a28$var$getTabbableCandidates(container) {
-    const nodes = [];
-    const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
-        acceptNode: (node)=>{
-            const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';
-            if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP; // `.tabIndex` is not the same as the `tabindex` attribute. It works on the
-            // runtime's understanding of tabbability, so this automatically accounts
-            // for any kind of element that could be tabbed to.
-            return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-        }
-    });
-    while(walker.nextNode())nodes.push(walker.currentNode); // we do not take into account the order of nodes with positive `tabIndex` as it
-    // hinders accessibility to have tab order different from visual order.
-    return nodes;
-}
-/**
- * Returns the first visible element in a list.
- * NOTE: Only checks visibility up to the `container`.
- */ function $d3863c46a17e8a28$var$findVisible(elements, container) {
-    for (const element of elements){
-        // we stop checking if it's hidden at the `container` level (excluding)
-        if (!$d3863c46a17e8a28$var$isHidden(element, {
-            upTo: container
-        })) return element;
-    }
-}
-function $d3863c46a17e8a28$var$isHidden(node, { upTo: upTo  }) {
-    if (getComputedStyle(node).visibility === 'hidden') return true;
-    while(node){
-        // we stop at `upTo` (excluding it)
-        if (upTo !== undefined && node === upTo) return false;
-        if (getComputedStyle(node).display === 'none') return true;
-        node = node.parentElement;
-    }
-    return false;
-}
-function $d3863c46a17e8a28$var$isSelectableInput(element) {
-    return element instanceof HTMLInputElement && 'select' in element;
-}
-function $d3863c46a17e8a28$var$focus(element, { select: select = false  } = {}) {
-    // only focus if that element is focusable
-    if (element && element.focus) {
-        const previouslyFocusedElement = document.activeElement; // NOTE: we prevent scrolling on focus, to minimize jarring transitions for users
-        element.focus({
-            preventScroll: true
-        }); // only select if its not the same element, it supports selection and we need to select
-        if (element !== previouslyFocusedElement && $d3863c46a17e8a28$var$isSelectableInput(element) && select) element.select();
-    }
-}
-/* -------------------------------------------------------------------------------------------------
- * FocusScope stack
- * -----------------------------------------------------------------------------------------------*/ const $d3863c46a17e8a28$var$focusScopesStack = $d3863c46a17e8a28$var$createFocusScopesStack();
-function $d3863c46a17e8a28$var$createFocusScopesStack() {
-    /** A stack of focus scopes, with the active one at the top */ let stack = [];
-    return {
-        add (focusScope) {
-            // pause the currently active focus scope (at the top of the stack)
-            const activeFocusScope = stack[0];
-            if (focusScope !== activeFocusScope) activeFocusScope === null || activeFocusScope === void 0 || activeFocusScope.pause();
-             // remove in case it already exists (because we'll re-add it at the top of the stack)
-            stack = $d3863c46a17e8a28$var$arrayRemove(stack, focusScope);
-            stack.unshift(focusScope);
-        },
-        remove (focusScope) {
-            var _stack$;
-            stack = $d3863c46a17e8a28$var$arrayRemove(stack, focusScope);
-            (_stack$ = stack[0]) === null || _stack$ === void 0 || _stack$.resume();
-        }
-    };
-}
-function $d3863c46a17e8a28$var$arrayRemove(array, item) {
-    const updatedArray = [
-        ...array
-    ];
-    const index = updatedArray.indexOf(item);
-    if (index !== -1) updatedArray.splice(index, 1);
-    return updatedArray;
-}
-function $d3863c46a17e8a28$var$removeLinks(items) {
-    return items.filter((item)=>item.tagName !== 'A'
-    );
-}
-
-const $7e8f5cd07187803e$export$21b07c8f274aebd5 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { children: children , width: width = 10 , height: height = 5 , ...arrowProps } = props;
-    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.svg, index._extends({}, arrowProps, {
-        ref: forwardedRef,
-        width: width,
-        height: height,
-        viewBox: "0 0 30 10",
-        preserveAspectRatio: "none"
-    }), props.asChild ? children : /*#__PURE__*/ React.createElement("polygon", {
-        points: "0,0 30,0 15,10"
-    }));
-});
-/* -----------------------------------------------------------------------------------------------*/ const $7e8f5cd07187803e$export$be92b6f5f03c0fe9 = $7e8f5cd07187803e$export$21b07c8f274aebd5;
-
-/* -------------------------------------------------------------------------------------------------
- * Popper
- * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$POPPER_NAME = 'Popper';
-const [$cf1ac5d9fe0e8206$var$createPopperContext, $cf1ac5d9fe0e8206$export$722aac194ae923] = index.$c512c27ab02ef895$export$50c7b4e9d9f19c1($cf1ac5d9fe0e8206$var$POPPER_NAME);
-const [$cf1ac5d9fe0e8206$var$PopperProvider, $cf1ac5d9fe0e8206$var$usePopperContext] = $cf1ac5d9fe0e8206$var$createPopperContext($cf1ac5d9fe0e8206$var$POPPER_NAME);
-const $cf1ac5d9fe0e8206$export$badac9ada3a0bdf9 = (props)=>{
-    const { __scopePopper: __scopePopper , children: children  } = props;
-    const [anchor, setAnchor] = React.useState(null);
-    return /*#__PURE__*/ React.createElement($cf1ac5d9fe0e8206$var$PopperProvider, {
-        scope: __scopePopper,
-        anchor: anchor,
-        onAnchorChange: setAnchor
-    }, children);
-};
-/* -------------------------------------------------------------------------------------------------
- * PopperAnchor
- * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$ANCHOR_NAME = 'PopperAnchor';
-const $cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopePopper: __scopePopper , virtualRef: virtualRef , ...anchorProps } = props;
-    const context = $cf1ac5d9fe0e8206$var$usePopperContext($cf1ac5d9fe0e8206$var$ANCHOR_NAME, __scopePopper);
-    const ref = React.useRef(null);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, ref);
-    React.useEffect(()=>{
-        // Consumer can anchor the popper to something that isn't
-        // a DOM node e.g. pointer position, so we override the
-        // `anchorRef` with their virtual ref in this case.
-        context.onAnchorChange((virtualRef === null || virtualRef === void 0 ? void 0 : virtualRef.current) || ref.current);
-    });
-    return virtualRef ? null : /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({}, anchorProps, {
-        ref: composedRefs
-    }));
-});
-/* -------------------------------------------------------------------------------------------------
- * PopperContent
- * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$CONTENT_NAME = 'PopperContent';
-const [$cf1ac5d9fe0e8206$var$PopperContentProvider, $cf1ac5d9fe0e8206$var$useContentContext] = $cf1ac5d9fe0e8206$var$createPopperContext($cf1ac5d9fe0e8206$var$CONTENT_NAME);
-const $cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    var _arrowSize$width, _arrowSize$height, _middlewareData$arrow, _middlewareData$arrow2, _middlewareData$arrow3, _middlewareData$trans, _middlewareData$trans2, _middlewareData$hide;
-    const { __scopePopper: __scopePopper , side: side = 'bottom' , sideOffset: sideOffset = 0 , align: align = 'center' , alignOffset: alignOffset = 0 , arrowPadding: arrowPadding = 0 , avoidCollisions: avoidCollisions = true , collisionBoundary: collisionBoundary = [] , collisionPadding: collisionPaddingProp = 0 , sticky: sticky = 'partial' , hideWhenDetached: hideWhenDetached = false , updatePositionStrategy: updatePositionStrategy = 'optimized' , onPlaced: onPlaced , ...contentProps } = props;
-    const context = $cf1ac5d9fe0e8206$var$usePopperContext($cf1ac5d9fe0e8206$var$CONTENT_NAME, __scopePopper);
-    const [content, setContent] = React.useState(null);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, (node)=>setContent(node)
-    );
-    const [arrow, setArrow] = React.useState(null);
-    const arrowSize = index$2.$db6c3485150b8e66$export$1ab7ae714698c4b8(arrow);
-    const arrowWidth = (_arrowSize$width = arrowSize === null || arrowSize === void 0 ? void 0 : arrowSize.width) !== null && _arrowSize$width !== void 0 ? _arrowSize$width : 0;
-    const arrowHeight = (_arrowSize$height = arrowSize === null || arrowSize === void 0 ? void 0 : arrowSize.height) !== null && _arrowSize$height !== void 0 ? _arrowSize$height : 0;
-    const desiredPlacement = side + (align !== 'center' ? '-' + align : '');
-    const collisionPadding = typeof collisionPaddingProp === 'number' ? collisionPaddingProp : {
-        top: 0,
-        right: 0,
-        bottom: 0,
-        left: 0,
-        ...collisionPaddingProp
-    };
-    const boundary = Array.isArray(collisionBoundary) ? collisionBoundary : [
-        collisionBoundary
-    ];
-    const hasExplicitBoundaries = boundary.length > 0;
-    const detectOverflowOptions = {
-        padding: collisionPadding,
-        boundary: boundary.filter($cf1ac5d9fe0e8206$var$isNotNull),
-        // with `strategy: 'fixed'`, this is the only way to get it to respect boundaries
-        altBoundary: hasExplicitBoundaries
-    };
-    const { refs: refs , floatingStyles: floatingStyles , placement: placement , isPositioned: isPositioned , middlewareData: middlewareData  } = floatingUi_reactDom.useFloating({
-        // default to `fixed` strategy so users don't have to pick and we also avoid focus scroll issues
-        strategy: 'fixed',
-        placement: desiredPlacement,
-        whileElementsMounted: (...args)=>{
-            const cleanup = floatingUi_reactDom.autoUpdate(...args, {
-                animationFrame: updatePositionStrategy === 'always'
-            });
-            return cleanup;
-        },
-        elements: {
-            reference: context.anchor
-        },
-        middleware: [
-            floatingUi_reactDom.offset({
-                mainAxis: sideOffset + arrowHeight,
-                alignmentAxis: alignOffset
-            }),
-            avoidCollisions && floatingUi_reactDom.shift({
-                mainAxis: true,
-                crossAxis: false,
-                limiter: sticky === 'partial' ? floatingUi_reactDom.limitShift() : undefined,
-                ...detectOverflowOptions
-            }),
-            avoidCollisions && floatingUi_reactDom.flip({
-                ...detectOverflowOptions
-            }),
-            floatingUi_reactDom.size({
-                ...detectOverflowOptions,
-                apply: ({ elements: elements , rects: rects , availableWidth: availableWidth , availableHeight: availableHeight  })=>{
-                    const { width: anchorWidth , height: anchorHeight  } = rects.reference;
-                    const contentStyle = elements.floating.style;
-                    contentStyle.setProperty('--radix-popper-available-width', `${availableWidth}px`);
-                    contentStyle.setProperty('--radix-popper-available-height', `${availableHeight}px`);
-                    contentStyle.setProperty('--radix-popper-anchor-width', `${anchorWidth}px`);
-                    contentStyle.setProperty('--radix-popper-anchor-height', `${anchorHeight}px`);
-                }
-            }),
-            arrow && floatingUi_reactDom.arrow({
-                element: arrow,
-                padding: arrowPadding
-            }),
-            $cf1ac5d9fe0e8206$var$transformOrigin({
-                arrowWidth: arrowWidth,
-                arrowHeight: arrowHeight
-            }),
-            hideWhenDetached && floatingUi_reactDom.hide({
-                strategy: 'referenceHidden',
-                ...detectOverflowOptions
-            })
-        ]
-    });
-    const [placedSide, placedAlign] = $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement);
-    const handlePlaced = index.$b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onPlaced);
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        if (isPositioned) handlePlaced === null || handlePlaced === void 0 || handlePlaced();
-    }, [
-        isPositioned,
-        handlePlaced
-    ]);
-    const arrowX = (_middlewareData$arrow = middlewareData.arrow) === null || _middlewareData$arrow === void 0 ? void 0 : _middlewareData$arrow.x;
-    const arrowY = (_middlewareData$arrow2 = middlewareData.arrow) === null || _middlewareData$arrow2 === void 0 ? void 0 : _middlewareData$arrow2.y;
-    const cannotCenterArrow = ((_middlewareData$arrow3 = middlewareData.arrow) === null || _middlewareData$arrow3 === void 0 ? void 0 : _middlewareData$arrow3.centerOffset) !== 0;
-    const [contentZIndex, setContentZIndex] = React.useState();
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        if (content) setContentZIndex(window.getComputedStyle(content).zIndex);
-    }, [
-        content
-    ]);
-    return /*#__PURE__*/ React.createElement("div", {
-        ref: refs.setFloating,
-        "data-radix-popper-content-wrapper": "",
-        style: {
-            ...floatingStyles,
-            transform: isPositioned ? floatingStyles.transform : 'translate(0, -200%)',
-            // keep off the page when measuring
-            minWidth: 'max-content',
-            zIndex: contentZIndex,
-            ['--radix-popper-transform-origin']: [
-                (_middlewareData$trans = middlewareData.transformOrigin) === null || _middlewareData$trans === void 0 ? void 0 : _middlewareData$trans.x,
-                (_middlewareData$trans2 = middlewareData.transformOrigin) === null || _middlewareData$trans2 === void 0 ? void 0 : _middlewareData$trans2.y
-            ].join(' ')
-        } // Floating UI interally calculates logical alignment based the `dir` attribute on
-        ,
-        dir: props.dir
-    }, /*#__PURE__*/ React.createElement($cf1ac5d9fe0e8206$var$PopperContentProvider, {
-        scope: __scopePopper,
-        placedSide: placedSide,
-        onArrowChange: setArrow,
-        arrowX: arrowX,
-        arrowY: arrowY,
-        shouldHideArrow: cannotCenterArrow
-    }, /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({
-        "data-side": placedSide,
-        "data-align": placedAlign
-    }, contentProps, {
-        ref: composedRefs,
-        style: {
-            ...contentProps.style,
-            // if the PopperContent hasn't been placed yet (not all measurements done)
-            // we prevent animations so that users's animation don't kick in too early referring wrong sides
-            animation: !isPositioned ? 'none' : undefined,
-            // hide the content if using the hide middleware and should be hidden
-            opacity: (_middlewareData$hide = middlewareData.hide) !== null && _middlewareData$hide !== void 0 && _middlewareData$hide.referenceHidden ? 0 : undefined
-        }
-    }))));
-});
-/* -------------------------------------------------------------------------------------------------
- * PopperArrow
- * -----------------------------------------------------------------------------------------------*/ const $cf1ac5d9fe0e8206$var$ARROW_NAME = 'PopperArrow';
-const $cf1ac5d9fe0e8206$var$OPPOSITE_SIDE = {
-    top: 'bottom',
-    right: 'left',
-    bottom: 'top',
-    left: 'right'
-};
-const $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0 = /*#__PURE__*/ React.forwardRef(function $cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0(props, forwardedRef) {
-    const { __scopePopper: __scopePopper , ...arrowProps } = props;
-    const contentContext = $cf1ac5d9fe0e8206$var$useContentContext($cf1ac5d9fe0e8206$var$ARROW_NAME, __scopePopper);
-    const baseSide = $cf1ac5d9fe0e8206$var$OPPOSITE_SIDE[contentContext.placedSide];
-    return(/*#__PURE__*/ // we have to use an extra wrapper because `ResizeObserver` (used by `useSize`)
-    // doesn't report size as we'd expect on SVG elements.
-    // it reports their bounding box which is effectively the largest path inside the SVG.
-    React.createElement("span", {
-        ref: contentContext.onArrowChange,
-        style: {
-            position: 'absolute',
-            left: contentContext.arrowX,
-            top: contentContext.arrowY,
-            [baseSide]: 0,
-            transformOrigin: {
-                top: '',
-                right: '0 0',
-                bottom: 'center 0',
-                left: '100% 0'
-            }[contentContext.placedSide],
-            transform: {
-                top: 'translateY(100%)',
-                right: 'translateY(50%) rotate(90deg) translateX(-50%)',
-                bottom: `rotate(180deg)`,
-                left: 'translateY(50%) rotate(-90deg) translateX(50%)'
-            }[contentContext.placedSide],
-            visibility: contentContext.shouldHideArrow ? 'hidden' : undefined
-        }
-    }, /*#__PURE__*/ React.createElement($7e8f5cd07187803e$export$be92b6f5f03c0fe9, index._extends({}, arrowProps, {
-        ref: forwardedRef,
-        style: {
-            ...arrowProps.style,
-            // ensures the element can be measured correctly (mostly for if SVG)
-            display: 'block'
-        }
-    }))));
-});
-/*#__PURE__*/ Object.assign($cf1ac5d9fe0e8206$export$79d62cd4e10a3fd0, {
-    displayName: $cf1ac5d9fe0e8206$var$ARROW_NAME
-});
-/* -----------------------------------------------------------------------------------------------*/ function $cf1ac5d9fe0e8206$var$isNotNull(value) {
-    return value !== null;
-}
-const $cf1ac5d9fe0e8206$var$transformOrigin = (options)=>({
-        name: 'transformOrigin',
-        options: options,
-        fn (data) {
-            var _middlewareData$arrow4, _middlewareData$arrow5, _middlewareData$arrow6, _middlewareData$arrow7, _middlewareData$arrow8;
-            const { placement: placement , rects: rects , middlewareData: middlewareData  } = data;
-            const cannotCenterArrow = ((_middlewareData$arrow4 = middlewareData.arrow) === null || _middlewareData$arrow4 === void 0 ? void 0 : _middlewareData$arrow4.centerOffset) !== 0;
-            const isArrowHidden = cannotCenterArrow;
-            const arrowWidth = isArrowHidden ? 0 : options.arrowWidth;
-            const arrowHeight = isArrowHidden ? 0 : options.arrowHeight;
-            const [placedSide, placedAlign] = $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement);
-            const noArrowAlign = {
-                start: '0%',
-                center: '50%',
-                end: '100%'
-            }[placedAlign];
-            const arrowXCenter = ((_middlewareData$arrow5 = (_middlewareData$arrow6 = middlewareData.arrow) === null || _middlewareData$arrow6 === void 0 ? void 0 : _middlewareData$arrow6.x) !== null && _middlewareData$arrow5 !== void 0 ? _middlewareData$arrow5 : 0) + arrowWidth / 2;
-            const arrowYCenter = ((_middlewareData$arrow7 = (_middlewareData$arrow8 = middlewareData.arrow) === null || _middlewareData$arrow8 === void 0 ? void 0 : _middlewareData$arrow8.y) !== null && _middlewareData$arrow7 !== void 0 ? _middlewareData$arrow7 : 0) + arrowHeight / 2;
-            let x = '';
-            let y = '';
-            if (placedSide === 'bottom') {
-                x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
-                y = `${-arrowHeight}px`;
-            } else if (placedSide === 'top') {
-                x = isArrowHidden ? noArrowAlign : `${arrowXCenter}px`;
-                y = `${rects.floating.height + arrowHeight}px`;
-            } else if (placedSide === 'right') {
-                x = `${-arrowHeight}px`;
-                y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
-            } else if (placedSide === 'left') {
-                x = `${rects.floating.width + arrowHeight}px`;
-                y = isArrowHidden ? noArrowAlign : `${arrowYCenter}px`;
-            }
-            return {
-                data: {
-                    x: x,
-                    y: y
-                }
-            };
-        }
-    })
-;
-function $cf1ac5d9fe0e8206$var$getSideAndAlignFromPlacement(placement) {
-    const [side, align = 'center'] = placement.split('-');
-    return [
-        side,
-        align
-    ];
-}
-const $cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9 = $cf1ac5d9fe0e8206$export$badac9ada3a0bdf9;
-const $cf1ac5d9fe0e8206$export$b688253958b8dfe7 = $cf1ac5d9fe0e8206$export$ecd4e1ccab6ed6d;
-const $cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2 = $cf1ac5d9fe0e8206$export$bc4ae5855d3c4fc;
-//# sourceMappingURL=index.mjs.map
-
-const $f1701beae083dbae$export$602eac185826482c = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    var _globalThis$document;
-    const { container: container = globalThis === null || globalThis === void 0 ? void 0 : (_globalThis$document = globalThis.document) === null || _globalThis$document === void 0 ? void 0 : _globalThis$document.body , ...portalProps } = props;
-    return container ? /*#__PURE__*/ ReactDOM.createPortal(/*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({}, portalProps, {
-        ref: forwardedRef
-    })), container) : null;
-});
-
-var effectCar = component.createSidecarMedium();
-
-var nothing = function () {
-    return;
-};
-/**
- * Removes scrollbar from the page and contain the scroll within the Lock
- */
-var RemoveScroll = React__namespace.forwardRef(function (props, parentRef) {
-    var ref = React__namespace.useRef(null);
-    var _a = React__namespace.useState({
-        onScrollCapture: nothing,
-        onWheelCapture: nothing,
-        onTouchMoveCapture: nothing,
-    }), callbacks = _a[0], setCallbacks = _a[1];
-    var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? 'div' : _b, rest = index$3.__rest(props, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noIsolation", "inert", "allowPinchZoom", "as"]);
-    var SideCar = sideCar;
-    var containerRef = component.useMergeRefs([ref, parentRef]);
-    var containerProps = index$3.__assign(index$3.__assign({}, rest), callbacks);
-    return (React__namespace.createElement(React__namespace.Fragment, null,
-        enabled && (React__namespace.createElement(SideCar, { sideCar: effectCar, removeScrollBar: removeScrollBar, shards: shards, noIsolation: noIsolation, inert: inert, setCallbacks: setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref })),
-        forwardProps ? (React__namespace.cloneElement(React__namespace.Children.only(children), index$3.__assign(index$3.__assign({}, containerProps), { ref: containerRef }))) : (React__namespace.createElement(Container, index$3.__assign({}, containerProps, { className: className, ref: containerRef }), children))));
-});
-RemoveScroll.defaultProps = {
-    enabled: true,
-    removeScrollBar: true,
-    inert: false,
-};
-RemoveScroll.classNames = {
-    fullWidth: component$1.fullWidthClassName,
-    zeroRight: component$1.zeroRightClassName,
-};
-
-var passiveSupported = false;
-if (typeof window !== 'undefined') {
-    try {
-        var options = Object.defineProperty({}, 'passive', {
-            get: function () {
-                passiveSupported = true;
-                return true;
-            },
-        });
-        // @ts-ignore
-        window.addEventListener('test', options, options);
-        // @ts-ignore
-        window.removeEventListener('test', options, options);
-    }
-    catch (err) {
-        passiveSupported = false;
-    }
-}
-var nonPassive = passiveSupported ? { passive: false } : false;
-
-var alwaysContainsScroll = function (node) {
-    // textarea will always _contain_ scroll inside self. It only can be hidden
-    return node.tagName === 'TEXTAREA';
-};
-var elementCanBeScrolled = function (node, overflow) {
-    var styles = window.getComputedStyle(node);
-    return (
-    // not-not-scrollable
-    styles[overflow] !== 'hidden' &&
-        // contains scroll inside self
-        !(styles.overflowY === styles.overflowX && !alwaysContainsScroll(node) && styles[overflow] === 'visible'));
-};
-var elementCouldBeVScrolled = function (node) { return elementCanBeScrolled(node, 'overflowY'); };
-var elementCouldBeHScrolled = function (node) { return elementCanBeScrolled(node, 'overflowX'); };
-var locationCouldBeScrolled = function (axis, node) {
-    var current = node;
-    do {
-        // Skip over shadow root
-        if (typeof ShadowRoot !== 'undefined' && current instanceof ShadowRoot) {
-            current = current.host;
-        }
-        var isScrollable = elementCouldBeScrolled(axis, current);
-        if (isScrollable) {
-            var _a = getScrollVariables(axis, current), s = _a[1], d = _a[2];
-            if (s > d) {
-                return true;
-            }
-        }
-        current = current.parentNode;
-    } while (current && current !== document.body);
-    return false;
-};
-var getVScrollVariables = function (_a) {
-    var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;
-    return [
-        scrollTop,
-        scrollHeight,
-        clientHeight,
-    ];
-};
-var getHScrollVariables = function (_a) {
-    var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;
-    return [
-        scrollLeft,
-        scrollWidth,
-        clientWidth,
-    ];
-};
-var elementCouldBeScrolled = function (axis, node) {
-    return axis === 'v' ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);
-};
-var getScrollVariables = function (axis, node) {
-    return axis === 'v' ? getVScrollVariables(node) : getHScrollVariables(node);
-};
-var getDirectionFactor = function (axis, direction) {
-    /**
-     * If the element's direction is rtl (right-to-left), then scrollLeft is 0 when the scrollbar is at its rightmost position,
-     * and then increasingly negative as you scroll towards the end of the content.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollLeft
-     */
-    return axis === 'h' && direction === 'rtl' ? -1 : 1;
-};
-var handleScroll = function (axis, endTarget, event, sourceDelta, noOverscroll) {
-    var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction);
-    var delta = directionFactor * sourceDelta;
-    // find scrollable target
-    var target = event.target;
-    var targetInLock = endTarget.contains(target);
-    var shouldCancelScroll = false;
-    var isDeltaPositive = delta > 0;
-    var availableScroll = 0;
-    var availableScrollTop = 0;
-    do {
-        var _a = getScrollVariables(axis, target), position = _a[0], scroll_1 = _a[1], capacity = _a[2];
-        var elementScroll = scroll_1 - capacity - directionFactor * position;
-        if (position || elementScroll) {
-            if (elementCouldBeScrolled(axis, target)) {
-                availableScroll += elementScroll;
-                availableScrollTop += position;
-            }
-        }
-        target = target.parentNode;
-    } while (
-    // portaled content
-    (!targetInLock && target !== document.body) ||
-        // self content
-        (targetInLock && (endTarget.contains(target) || endTarget === target)));
-    if (isDeltaPositive && ((availableScroll === 0) || (!noOverscroll))) {
-        shouldCancelScroll = true;
-    }
-    else if (!isDeltaPositive &&
-        ((availableScrollTop === 0) || (!noOverscroll))) {
-        shouldCancelScroll = true;
-    }
-    return shouldCancelScroll;
-};
-
-var getTouchXY = function (event) {
-    return 'changedTouches' in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];
-};
-var getDeltaXY = function (event) { return [event.deltaX, event.deltaY]; };
-var extractRef = function (ref) {
-    return ref && 'current' in ref ? ref.current : ref;
-};
-var deltaCompare = function (x, y) { return x[0] === y[0] && x[1] === y[1]; };
-var generateStyle = function (id) { return "\n  .block-interactivity-".concat(id, " {pointer-events: none;}\n  .allow-interactivity-").concat(id, " {pointer-events: all;}\n"); };
-var idCounter = 0;
-var lockStack = [];
-function RemoveScrollSideCar(props) {
-    var shouldPreventQueue = React__namespace.useRef([]);
-    var touchStartRef = React__namespace.useRef([0, 0]);
-    var activeAxis = React__namespace.useRef();
-    var id = React__namespace.useState(idCounter++)[0];
-    var Style = React__namespace.useState(function () { return component.styleSingleton(); })[0];
-    var lastProps = React__namespace.useRef(props);
-    React__namespace.useEffect(function () {
-        lastProps.current = props;
-    }, [props]);
-    React__namespace.useEffect(function () {
-        if (props.inert) {
-            document.body.classList.add("block-interactivity-".concat(id));
-            var allow_1 = index$3.__spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);
-            allow_1.forEach(function (el) { return el.classList.add("allow-interactivity-".concat(id)); });
-            return function () {
-                document.body.classList.remove("block-interactivity-".concat(id));
-                allow_1.forEach(function (el) { return el.classList.remove("allow-interactivity-".concat(id)); });
-            };
-        }
-        return;
-    }, [props.inert, props.lockRef.current, props.shards]);
-    var shouldCancelEvent = React__namespace.useCallback(function (event, parent) {
-        if ('touches' in event && event.touches.length === 2) {
-            return !lastProps.current.allowPinchZoom;
-        }
-        var touch = getTouchXY(event);
-        var touchStart = touchStartRef.current;
-        var deltaX = 'deltaX' in event ? event.deltaX : touchStart[0] - touch[0];
-        var deltaY = 'deltaY' in event ? event.deltaY : touchStart[1] - touch[1];
-        var currentAxis;
-        var target = event.target;
-        var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? 'h' : 'v';
-        // allow horizontal touch move on Range inputs. They will not cause any scroll
-        if ('touches' in event && moveDirection === 'h' && target.type === 'range') {
-            return false;
-        }
-        var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
-        if (!canBeScrolledInMainDirection) {
-            return true;
-        }
-        if (canBeScrolledInMainDirection) {
-            currentAxis = moveDirection;
-        }
-        else {
-            currentAxis = moveDirection === 'v' ? 'h' : 'v';
-            canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
-            // other axis might be not scrollable
-        }
-        if (!canBeScrolledInMainDirection) {
-            return false;
-        }
-        if (!activeAxis.current && 'changedTouches' in event && (deltaX || deltaY)) {
-            activeAxis.current = currentAxis;
-        }
-        if (!currentAxis) {
-            return true;
-        }
-        var cancelingAxis = activeAxis.current || currentAxis;
-        return handleScroll(cancelingAxis, parent, event, cancelingAxis === 'h' ? deltaX : deltaY, true);
-    }, []);
-    var shouldPrevent = React__namespace.useCallback(function (_event) {
-        var event = _event;
-        if (!lockStack.length || lockStack[lockStack.length - 1] !== Style) {
-            // not the last active
-            return;
-        }
-        var delta = 'deltaY' in event ? getDeltaXY(event) : getTouchXY(event);
-        var sourceEvent = shouldPreventQueue.current.filter(function (e) { return e.name === event.type && e.target === event.target && deltaCompare(e.delta, delta); })[0];
-        // self event, and should be canceled
-        if (sourceEvent && sourceEvent.should) {
-            if (event.cancelable) {
-                event.preventDefault();
-            }
-            return;
-        }
-        // outside or shard event
-        if (!sourceEvent) {
-            var shardNodes = (lastProps.current.shards || [])
-                .map(extractRef)
-                .filter(Boolean)
-                .filter(function (node) { return node.contains(event.target); });
-            var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;
-            if (shouldStop) {
-                if (event.cancelable) {
-                    event.preventDefault();
-                }
-            }
-        }
-    }, []);
-    var shouldCancel = React__namespace.useCallback(function (name, delta, target, should) {
-        var event = { name: name, delta: delta, target: target, should: should };
-        shouldPreventQueue.current.push(event);
-        setTimeout(function () {
-            shouldPreventQueue.current = shouldPreventQueue.current.filter(function (e) { return e !== event; });
-        }, 1);
-    }, []);
-    var scrollTouchStart = React__namespace.useCallback(function (event) {
-        touchStartRef.current = getTouchXY(event);
-        activeAxis.current = undefined;
-    }, []);
-    var scrollWheel = React__namespace.useCallback(function (event) {
-        shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
-    }, []);
-    var scrollTouchMove = React__namespace.useCallback(function (event) {
-        shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
-    }, []);
-    React__namespace.useEffect(function () {
-        lockStack.push(Style);
-        props.setCallbacks({
-            onScrollCapture: scrollWheel,
-            onWheelCapture: scrollWheel,
-            onTouchMoveCapture: scrollTouchMove,
-        });
-        document.addEventListener('wheel', shouldPrevent, nonPassive);
-        document.addEventListener('touchmove', shouldPrevent, nonPassive);
-        document.addEventListener('touchstart', scrollTouchStart, nonPassive);
-        return function () {
-            lockStack = lockStack.filter(function (inst) { return inst !== Style; });
-            document.removeEventListener('wheel', shouldPrevent, nonPassive);
-            document.removeEventListener('touchmove', shouldPrevent, nonPassive);
-            document.removeEventListener('touchstart', scrollTouchStart, nonPassive);
-        };
-    }, []);
-    var removeScrollBar = props.removeScrollBar, inert = props.inert;
-    return (React__namespace.createElement(React__namespace.Fragment, null,
-        inert ? React__namespace.createElement(Style, { styles: generateStyle(id) }) : null,
-        removeScrollBar ? React__namespace.createElement(component$1.RemoveScrollBar, { gapMode: "margin" }) : null));
-}
-
-var SideCar = component.exportSidecar(effectCar, RemoveScrollSideCar);
-
-var ReactRemoveScroll = React__namespace.forwardRef(function (props, ref) { return (React__namespace.createElement(RemoveScroll, index$3.__assign({}, props, { ref: ref, sideCar: SideCar }))); });
-ReactRemoveScroll.classNames = RemoveScroll.classNames;
-
-const $cc7e05a45900e73f$var$OPEN_KEYS = [
-    ' ',
-    'Enter',
-    'ArrowUp',
-    'ArrowDown'
-];
-const $cc7e05a45900e73f$var$SELECTION_KEYS = [
-    ' ',
-    'Enter'
-];
-/* -------------------------------------------------------------------------------------------------
- * Select
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$SELECT_NAME = 'Select';
-const [$cc7e05a45900e73f$var$Collection, $cc7e05a45900e73f$var$useCollection, $cc7e05a45900e73f$var$createCollectionScope] = index$4.$e02a7d9cb1dc128c$export$c74125a8e3af6bb2($cc7e05a45900e73f$var$SELECT_NAME);
-const [$cc7e05a45900e73f$var$createSelectContext, $cc7e05a45900e73f$export$286727a75dc039bd] = index.$c512c27ab02ef895$export$50c7b4e9d9f19c1($cc7e05a45900e73f$var$SELECT_NAME, [
-    $cc7e05a45900e73f$var$createCollectionScope,
-    $cf1ac5d9fe0e8206$export$722aac194ae923
-]);
-const $cc7e05a45900e73f$var$usePopperScope = $cf1ac5d9fe0e8206$export$722aac194ae923();
-const [$cc7e05a45900e73f$var$SelectProvider, $cc7e05a45900e73f$var$useSelectContext] = $cc7e05a45900e73f$var$createSelectContext($cc7e05a45900e73f$var$SELECT_NAME);
-const [$cc7e05a45900e73f$var$SelectNativeOptionsProvider, $cc7e05a45900e73f$var$useSelectNativeOptionsContext] = $cc7e05a45900e73f$var$createSelectContext($cc7e05a45900e73f$var$SELECT_NAME);
-const $cc7e05a45900e73f$export$ef9b1a59e592288f = (props)=>{
-    const { __scopeSelect: __scopeSelect , children: children , open: openProp , defaultOpen: defaultOpen , onOpenChange: onOpenChange , value: valueProp , defaultValue: defaultValue , onValueChange: onValueChange , dir: dir , name: name , autoComplete: autoComplete , disabled: disabled , required: required  } = props;
-    const popperScope = $cc7e05a45900e73f$var$usePopperScope(__scopeSelect);
-    const [trigger, setTrigger] = React.useState(null);
-    const [valueNode, setValueNode] = React.useState(null);
-    const [valueNodeHasChildren, setValueNodeHasChildren] = React.useState(false);
-    const direction = index$5.$f631663db3294ace$export$b39126d51d94e6f3(dir);
-    const [open = false, setOpen] = index.$71cd76cc60e0454e$export$6f32135080cb4c3({
-        prop: openProp,
-        defaultProp: defaultOpen,
-        onChange: onOpenChange
-    });
-    const [value, setValue] = index.$71cd76cc60e0454e$export$6f32135080cb4c3({
-        prop: valueProp,
-        defaultProp: defaultValue,
-        onChange: onValueChange
-    });
-    const triggerPointerDownPosRef = React.useRef(null); // We set this to true by default so that events bubble to forms without JS (SSR)
-    const isFormControl = trigger ? Boolean(trigger.closest('form')) : true;
-    const [nativeOptionsSet, setNativeOptionsSet] = React.useState(new Set()); // The native `select` only associates the correct default value if the corresponding
-    // `option` is rendered as a child **at the same time** as itself.
-    // Because it might take a few renders for our items to gather the information to build
-    // the native `option`(s), we generate a key on the `select` to make sure React re-builds it
-    // each time the options change.
-    const nativeSelectKey = Array.from(nativeOptionsSet).map((option)=>option.props.value
-    ).join(';');
-    return /*#__PURE__*/ React.createElement($cf1ac5d9fe0e8206$export$be92b6f5f03c0fe9, popperScope, /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectProvider, {
-        required: required,
-        scope: __scopeSelect,
-        trigger: trigger,
-        onTriggerChange: setTrigger,
-        valueNode: valueNode,
-        onValueNodeChange: setValueNode,
-        valueNodeHasChildren: valueNodeHasChildren,
-        onValueNodeHasChildrenChange: setValueNodeHasChildren,
-        contentId: index$5.$1746a345f3d73bb7$export$f680877a34711e37(),
-        value: value,
-        onValueChange: setValue,
-        open: open,
-        onOpenChange: setOpen,
-        dir: direction,
-        triggerPointerDownPosRef: triggerPointerDownPosRef,
-        disabled: disabled
-    }, /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$Collection.Provider, {
-        scope: __scopeSelect
-    }, /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectNativeOptionsProvider, {
-        scope: props.__scopeSelect,
-        onNativeOptionAdd: React.useCallback((option)=>{
-            setNativeOptionsSet((prev)=>new Set(prev).add(option)
-            );
-        }, []),
-        onNativeOptionRemove: React.useCallback((option)=>{
-            setNativeOptionsSet((prev)=>{
-                const optionsSet = new Set(prev);
-                optionsSet.delete(option);
-                return optionsSet;
-            });
-        }, [])
-    }, children)), isFormControl ? /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$BubbleSelect, {
-        key: nativeSelectKey,
-        "aria-hidden": true,
-        required: required,
-        tabIndex: -1,
-        name: name,
-        autoComplete: autoComplete,
-        value: value // enable form autofill
-        ,
-        onChange: (event)=>setValue(event.target.value)
-        ,
-        disabled: disabled
-    }, value === undefined ? /*#__PURE__*/ React.createElement("option", {
-        value: ""
-    }) : null, Array.from(nativeOptionsSet)) : null));
-};
-/* -------------------------------------------------------------------------------------------------
- * SelectTrigger
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$TRIGGER_NAME = 'SelectTrigger';
-const $cc7e05a45900e73f$export$3ac1e88a1c0b9f1 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , disabled: disabled = false , ...triggerProps } = props;
-    const popperScope = $cc7e05a45900e73f$var$usePopperScope(__scopeSelect);
-    const context = $cc7e05a45900e73f$var$useSelectContext($cc7e05a45900e73f$var$TRIGGER_NAME, __scopeSelect);
-    const isDisabled = context.disabled || disabled;
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, context.onTriggerChange);
-    const getItems = $cc7e05a45900e73f$var$useCollection(__scopeSelect);
-    const [searchRef, handleTypeaheadSearch, resetTypeahead] = $cc7e05a45900e73f$var$useTypeaheadSearch((search)=>{
-        const enabledItems = getItems().filter((item)=>!item.disabled
-        );
-        const currentItem = enabledItems.find((item)=>item.value === context.value
-        );
-        const nextItem = $cc7e05a45900e73f$var$findNextItem(enabledItems, search, currentItem);
-        if (nextItem !== undefined) context.onValueChange(nextItem.value);
-    });
-    const handleOpen = ()=>{
-        if (!isDisabled) {
-            context.onOpenChange(true); // reset typeahead when we open
-            resetTypeahead();
-        }
-    };
-    return /*#__PURE__*/ React.createElement($cf1ac5d9fe0e8206$export$b688253958b8dfe7, index._extends({
-        asChild: true
-    }, popperScope), /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.button, index._extends({
-        type: "button",
-        role: "combobox",
-        "aria-controls": context.contentId,
-        "aria-expanded": context.open,
-        "aria-required": context.required,
-        "aria-autocomplete": "none",
-        dir: context.dir,
-        "data-state": context.open ? 'open' : 'closed',
-        disabled: isDisabled,
-        "data-disabled": isDisabled ? '' : undefined,
-        "data-placeholder": $cc7e05a45900e73f$var$shouldShowPlaceholder(context.value) ? '' : undefined
-    }, triggerProps, {
-        ref: composedRefs // Enable compatibility with native label or custom `Label` "click" for Safari:
-        ,
-        onClick: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(triggerProps.onClick, (event)=>{
-            // Whilst browsers generally have no issue focusing the trigger when clicking
-            // on a label, Safari seems to struggle with the fact that there's no `onClick`.
-            // We force `focus` in this case. Note: this doesn't create any other side-effect
-            // because we are preventing default in `onPointerDown` so effectively
-            // this only runs for a label "click"
-            event.currentTarget.focus();
-        }),
-        onPointerDown: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(triggerProps.onPointerDown, (event)=>{
-            // prevent implicit pointer capture
-            // https://www.w3.org/TR/pointerevents3/#implicit-pointer-capture
-            const target = event.target;
-            if (target.hasPointerCapture(event.pointerId)) target.releasePointerCapture(event.pointerId);
-             // only call handler if it's the left button (mousedown gets triggered by all mouse buttons)
-            // but not when the control key is pressed (avoiding MacOS right click)
-            if (event.button === 0 && event.ctrlKey === false) {
-                handleOpen();
-                context.triggerPointerDownPosRef.current = {
-                    x: Math.round(event.pageX),
-                    y: Math.round(event.pageY)
-                }; // prevent trigger from stealing focus from the active item after opening.
-                event.preventDefault();
-            }
-        }),
-        onKeyDown: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(triggerProps.onKeyDown, (event)=>{
-            const isTypingAhead = searchRef.current !== '';
-            const isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
-            if (!isModifierKey && event.key.length === 1) handleTypeaheadSearch(event.key);
-            if (isTypingAhead && event.key === ' ') return;
-            if ($cc7e05a45900e73f$var$OPEN_KEYS.includes(event.key)) {
-                handleOpen();
-                event.preventDefault();
-            }
-        })
-    })));
-});
-/* -------------------------------------------------------------------------------------------------
- * SelectValue
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$VALUE_NAME = 'SelectValue';
-const $cc7e05a45900e73f$export$e288731fd71264f0 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    // We ignore `className` and `style` as this part shouldn't be styled.
-    const { __scopeSelect: __scopeSelect , className: className , style: style , children: children , placeholder: placeholder = '' , ...valueProps } = props;
-    const context = $cc7e05a45900e73f$var$useSelectContext($cc7e05a45900e73f$var$VALUE_NAME, __scopeSelect);
-    const { onValueNodeHasChildrenChange: onValueNodeHasChildrenChange  } = context;
-    const hasChildren = children !== undefined;
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, context.onValueNodeChange);
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        onValueNodeHasChildrenChange(hasChildren);
-    }, [
-        onValueNodeHasChildrenChange,
-        hasChildren
-    ]);
-    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.span, index._extends({}, valueProps, {
-        ref: composedRefs // we don't want events from the portalled `SelectValue` children to bubble
-        ,
-        style: {
-            pointerEvents: 'none'
-        }
-    }), $cc7e05a45900e73f$var$shouldShowPlaceholder(context.value) ? /*#__PURE__*/ React.createElement(React.Fragment, null, placeholder) : children);
-});
-const $cc7e05a45900e73f$export$99b400cabb58c515 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , children: children , ...iconProps } = props;
-    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.span, index._extends({
-        "aria-hidden": true
-    }, iconProps, {
-        ref: forwardedRef
-    }), children || '▼');
-});
-const $cc7e05a45900e73f$export$b2af6c9944296213 = (props)=>{
-    return /*#__PURE__*/ React.createElement($f1701beae083dbae$export$602eac185826482c, index._extends({
-        asChild: true
-    }, props));
-};
-/* -------------------------------------------------------------------------------------------------
- * SelectContent
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$CONTENT_NAME = 'SelectContent';
-const $cc7e05a45900e73f$export$c973a4b3cb86a03d = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const context = $cc7e05a45900e73f$var$useSelectContext($cc7e05a45900e73f$var$CONTENT_NAME, props.__scopeSelect);
-    const [fragment, setFragment] = React.useState(); // setting the fragment in `useLayoutEffect` as `DocumentFragment` doesn't exist on the server
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        setFragment(new DocumentFragment());
-    }, []);
-    if (!context.open) {
-        const frag = fragment;
-        return frag ? /*#__PURE__*/ ReactDOM.createPortal(/*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectContentProvider, {
-            scope: props.__scopeSelect
-        }, /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$Collection.Slot, {
-            scope: props.__scopeSelect
-        }, /*#__PURE__*/ React.createElement("div", null, props.children))), frag) : null;
-    }
-    return /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectContentImpl, index._extends({}, props, {
-        ref: forwardedRef
-    }));
-});
-/* -------------------------------------------------------------------------------------------------
- * SelectContentImpl
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$CONTENT_MARGIN = 10;
-const [$cc7e05a45900e73f$var$SelectContentProvider, $cc7e05a45900e73f$var$useSelectContentContext] = $cc7e05a45900e73f$var$createSelectContext($cc7e05a45900e73f$var$CONTENT_NAME);
-const $cc7e05a45900e73f$var$SelectContentImpl = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , position: position = 'item-aligned' , onCloseAutoFocus: onCloseAutoFocus , onEscapeKeyDown: onEscapeKeyDown , onPointerDownOutside: onPointerDownOutside , side: //
-    // PopperContent props
-    side , sideOffset: sideOffset , align: align , alignOffset: alignOffset , arrowPadding: arrowPadding , collisionBoundary: collisionBoundary , collisionPadding: collisionPadding , sticky: sticky , hideWhenDetached: hideWhenDetached , avoidCollisions: avoidCollisions , //
-    ...contentProps } = props;
-    const context = $cc7e05a45900e73f$var$useSelectContext($cc7e05a45900e73f$var$CONTENT_NAME, __scopeSelect);
-    const [content, setContent] = React.useState(null);
-    const [viewport, setViewport] = React.useState(null);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, (node)=>setContent(node)
-    );
-    const [selectedItem, setSelectedItem] = React.useState(null);
-    const [selectedItemText, setSelectedItemText] = React.useState(null);
-    const getItems = $cc7e05a45900e73f$var$useCollection(__scopeSelect);
-    const [isPositioned, setIsPositioned] = React.useState(false);
-    const firstValidItemFoundRef = React.useRef(false); // aria-hide everything except the content (better supported equivalent to setting aria-modal)
-    React.useEffect(()=>{
-        if (content) return component.hideOthers(content);
-    }, [
-        content
-    ]); // Make sure the whole tree has focus guards as our `Select` may be
-    // the last element in the DOM (because of the `Portal`)
-    $3db38b7d1fb3fe6a$export$b7ece24a22aeda8c();
-    const focusFirst = React.useCallback((candidates)=>{
-        const [firstItem, ...restItems] = getItems().map((item)=>item.ref.current
-        );
-        const [lastItem] = restItems.slice(-1);
-        const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
-        for (const candidate of candidates){
-            // if focus is already where we want to go, we don't want to keep going through the candidates
-            if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
-            candidate === null || candidate === void 0 || candidate.scrollIntoView({
-                block: 'nearest'
-            }); // viewport might have padding so scroll to its edges when focusing first/last items.
-            if (candidate === firstItem && viewport) viewport.scrollTop = 0;
-            if (candidate === lastItem && viewport) viewport.scrollTop = viewport.scrollHeight;
-            candidate === null || candidate === void 0 || candidate.focus();
-            if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
-        }
-    }, [
-        getItems,
-        viewport
-    ]);
-    const focusSelectedItem = React.useCallback(()=>focusFirst([
-            selectedItem,
-            content
-        ])
-    , [
-        focusFirst,
-        selectedItem,
-        content
-    ]); // Since this is not dependent on layout, we want to ensure this runs at the same time as
-    // other effects across components. Hence why we don't call `focusSelectedItem` inside `position`.
-    React.useEffect(()=>{
-        if (isPositioned) focusSelectedItem();
-    }, [
-        isPositioned,
-        focusSelectedItem
-    ]); // prevent selecting items on `pointerup` in some cases after opening from `pointerdown`
-    // and close on `pointerup` outside.
-    const { onOpenChange: onOpenChange , triggerPointerDownPosRef: triggerPointerDownPosRef  } = context;
-    React.useEffect(()=>{
-        if (content) {
-            let pointerMoveDelta = {
-                x: 0,
-                y: 0
-            };
-            const handlePointerMove = (event)=>{
-                var _triggerPointerDownPo, _triggerPointerDownPo2, _triggerPointerDownPo3, _triggerPointerDownPo4;
-                pointerMoveDelta = {
-                    x: Math.abs(Math.round(event.pageX) - ((_triggerPointerDownPo = (_triggerPointerDownPo2 = triggerPointerDownPosRef.current) === null || _triggerPointerDownPo2 === void 0 ? void 0 : _triggerPointerDownPo2.x) !== null && _triggerPointerDownPo !== void 0 ? _triggerPointerDownPo : 0)),
-                    y: Math.abs(Math.round(event.pageY) - ((_triggerPointerDownPo3 = (_triggerPointerDownPo4 = triggerPointerDownPosRef.current) === null || _triggerPointerDownPo4 === void 0 ? void 0 : _triggerPointerDownPo4.y) !== null && _triggerPointerDownPo3 !== void 0 ? _triggerPointerDownPo3 : 0))
-                };
-            };
-            const handlePointerUp = (event)=>{
-                // If the pointer hasn't moved by a certain threshold then we prevent selecting item on `pointerup`.
-                if (pointerMoveDelta.x <= 10 && pointerMoveDelta.y <= 10) event.preventDefault();
-                else // otherwise, if the event was outside the content, close.
-                if (!content.contains(event.target)) onOpenChange(false);
-                document.removeEventListener('pointermove', handlePointerMove);
-                triggerPointerDownPosRef.current = null;
-            };
-            if (triggerPointerDownPosRef.current !== null) {
-                document.addEventListener('pointermove', handlePointerMove);
-                document.addEventListener('pointerup', handlePointerUp, {
-                    capture: true,
-                    once: true
-                });
-            }
-            return ()=>{
-                document.removeEventListener('pointermove', handlePointerMove);
-                document.removeEventListener('pointerup', handlePointerUp, {
-                    capture: true
-                });
-            };
-        }
-    }, [
-        content,
-        onOpenChange,
-        triggerPointerDownPosRef
-    ]);
-    React.useEffect(()=>{
-        const close = ()=>onOpenChange(false)
-        ;
-        window.addEventListener('blur', close);
-        window.addEventListener('resize', close);
-        return ()=>{
-            window.removeEventListener('blur', close);
-            window.removeEventListener('resize', close);
-        };
-    }, [
-        onOpenChange
-    ]);
-    const [searchRef, handleTypeaheadSearch] = $cc7e05a45900e73f$var$useTypeaheadSearch((search)=>{
-        const enabledItems = getItems().filter((item)=>!item.disabled
-        );
-        const currentItem = enabledItems.find((item)=>item.ref.current === document.activeElement
-        );
-        const nextItem = $cc7e05a45900e73f$var$findNextItem(enabledItems, search, currentItem);
-        if (nextItem) /**
-       * Imperative focus during keydown is risky so we prevent React's batching updates
-       * to avoid potential bugs. See: https://github.com/facebook/react/issues/20332
-       */ setTimeout(()=>nextItem.ref.current.focus()
-        );
-    });
-    const itemRefCallback = React.useCallback((node, value, disabled)=>{
-        const isFirstValidItem = !firstValidItemFoundRef.current && !disabled;
-        const isSelectedItem = context.value !== undefined && context.value === value;
-        if (isSelectedItem || isFirstValidItem) {
-            setSelectedItem(node);
-            if (isFirstValidItem) firstValidItemFoundRef.current = true;
-        }
-    }, [
-        context.value
-    ]);
-    const handleItemLeave = React.useCallback(()=>content === null || content === void 0 ? void 0 : content.focus()
-    , [
-        content
-    ]);
-    const itemTextRefCallback = React.useCallback((node, value, disabled)=>{
-        const isFirstValidItem = !firstValidItemFoundRef.current && !disabled;
-        const isSelectedItem = context.value !== undefined && context.value === value;
-        if (isSelectedItem || isFirstValidItem) setSelectedItemText(node);
-    }, [
-        context.value
-    ]);
-    const SelectPosition = position === 'popper' ? $cc7e05a45900e73f$var$SelectPopperPosition : $cc7e05a45900e73f$var$SelectItemAlignedPosition; // Silently ignore props that are not supported by `SelectItemAlignedPosition`
-    const popperContentProps = SelectPosition === $cc7e05a45900e73f$var$SelectPopperPosition ? {
-        side: side,
-        sideOffset: sideOffset,
-        align: align,
-        alignOffset: alignOffset,
-        arrowPadding: arrowPadding,
-        collisionBoundary: collisionBoundary,
-        collisionPadding: collisionPadding,
-        sticky: sticky,
-        hideWhenDetached: hideWhenDetached,
-        avoidCollisions: avoidCollisions
-    } : {};
-    return /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectContentProvider, {
-        scope: __scopeSelect,
-        content: content,
-        viewport: viewport,
-        onViewportChange: setViewport,
-        itemRefCallback: itemRefCallback,
-        selectedItem: selectedItem,
-        onItemLeave: handleItemLeave,
-        itemTextRefCallback: itemTextRefCallback,
-        focusSelectedItem: focusSelectedItem,
-        selectedItemText: selectedItemText,
-        position: position,
-        isPositioned: isPositioned,
-        searchRef: searchRef
-    }, /*#__PURE__*/ React.createElement(ReactRemoveScroll, {
-        as: index.$5e63c961fc1ce211$export$8c6ed5c666ac1360,
-        allowPinchZoom: true
-    }, /*#__PURE__*/ React.createElement($d3863c46a17e8a28$export$20e40289641fbbb6, {
-        asChild: true // we make sure we're not trapping once it's been closed
-        ,
-        trapped: context.open,
-        onMountAutoFocus: (event)=>{
-            // we prevent open autofocus because we manually focus the selected item
-            event.preventDefault();
-        },
-        onUnmountAutoFocus: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(onCloseAutoFocus, (event)=>{
-            var _context$trigger;
-            (_context$trigger = context.trigger) === null || _context$trigger === void 0 || _context$trigger.focus({
-                preventScroll: true
-            });
-            event.preventDefault();
-        })
-    }, /*#__PURE__*/ React.createElement($5cb92bef7577960e$export$177fb62ff3ec1f22, {
-        asChild: true,
-        disableOutsidePointerEvents: true,
-        onEscapeKeyDown: onEscapeKeyDown,
-        onPointerDownOutside: onPointerDownOutside // When focus is trapped, a focusout event may still happen.
-        ,
-        onFocusOutside: (event)=>event.preventDefault()
-        ,
-        onDismiss: ()=>context.onOpenChange(false)
-    }, /*#__PURE__*/ React.createElement(SelectPosition, index._extends({
-        role: "listbox",
-        id: context.contentId,
-        "data-state": context.open ? 'open' : 'closed',
-        dir: context.dir,
-        onContextMenu: (event)=>event.preventDefault()
-    }, contentProps, popperContentProps, {
-        onPlaced: ()=>setIsPositioned(true)
-        ,
-        ref: composedRefs,
-        style: {
-            // flex layout so we can place the scroll buttons properly
-            display: 'flex',
-            flexDirection: 'column',
-            // reset the outline by default as the content MAY get focused
-            outline: 'none',
-            ...contentProps.style
-        },
-        onKeyDown: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(contentProps.onKeyDown, (event)=>{
-            const isModifierKey = event.ctrlKey || event.altKey || event.metaKey; // select should not be navigated using tab key so we prevent it
-            if (event.key === 'Tab') event.preventDefault();
-            if (!isModifierKey && event.key.length === 1) handleTypeaheadSearch(event.key);
-            if ([
-                'ArrowUp',
-                'ArrowDown',
-                'Home',
-                'End'
-            ].includes(event.key)) {
-                const items = getItems().filter((item)=>!item.disabled
-                );
-                let candidateNodes = items.map((item)=>item.ref.current
-                );
-                if ([
-                    'ArrowUp',
-                    'End'
-                ].includes(event.key)) candidateNodes = candidateNodes.slice().reverse();
-                if ([
-                    'ArrowUp',
-                    'ArrowDown'
-                ].includes(event.key)) {
-                    const currentElement = event.target;
-                    const currentIndex = candidateNodes.indexOf(currentElement);
-                    candidateNodes = candidateNodes.slice(currentIndex + 1);
-                }
-                /**
-         * Imperative focus during keydown is risky so we prevent React's batching updates
-         * to avoid potential bugs. See: https://github.com/facebook/react/issues/20332
-         */ setTimeout(()=>focusFirst(candidateNodes)
-                );
-                event.preventDefault();
-            }
-        })
-    }))))));
-});
-const $cc7e05a45900e73f$var$SelectItemAlignedPosition = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , onPlaced: onPlaced , ...popperProps } = props;
-    const context = $cc7e05a45900e73f$var$useSelectContext($cc7e05a45900e73f$var$CONTENT_NAME, __scopeSelect);
-    const contentContext = $cc7e05a45900e73f$var$useSelectContentContext($cc7e05a45900e73f$var$CONTENT_NAME, __scopeSelect);
-    const [contentWrapper, setContentWrapper] = React.useState(null);
-    const [content, setContent] = React.useState(null);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, (node)=>setContent(node)
-    );
-    const getItems = $cc7e05a45900e73f$var$useCollection(__scopeSelect);
-    const shouldExpandOnScrollRef = React.useRef(false);
-    const shouldRepositionRef = React.useRef(true);
-    const { viewport: viewport , selectedItem: selectedItem , selectedItemText: selectedItemText , focusSelectedItem: focusSelectedItem  } = contentContext;
-    const position = React.useCallback(()=>{
-        if (context.trigger && context.valueNode && contentWrapper && content && viewport && selectedItem && selectedItemText) {
-            const triggerRect = context.trigger.getBoundingClientRect(); // -----------------------------------------------------------------------------------------
-            //  Horizontal positioning
-            // -----------------------------------------------------------------------------------------
-            const contentRect = content.getBoundingClientRect();
-            const valueNodeRect = context.valueNode.getBoundingClientRect();
-            const itemTextRect = selectedItemText.getBoundingClientRect();
-            if (context.dir !== 'rtl') {
-                const itemTextOffset = itemTextRect.left - contentRect.left;
-                const left = valueNodeRect.left - itemTextOffset;
-                const leftDelta = triggerRect.left - left;
-                const minContentWidth = triggerRect.width + leftDelta;
-                const contentWidth = Math.max(minContentWidth, contentRect.width);
-                const rightEdge = window.innerWidth - $cc7e05a45900e73f$var$CONTENT_MARGIN;
-                const clampedLeft = $ae6933e535247d3d$export$7d15b64cf5a3a4c4(left, [
-                    $cc7e05a45900e73f$var$CONTENT_MARGIN,
-                    rightEdge - contentWidth
-                ]);
-                contentWrapper.style.minWidth = minContentWidth + 'px';
-                contentWrapper.style.left = clampedLeft + 'px';
-            } else {
-                const itemTextOffset = contentRect.right - itemTextRect.right;
-                const right = window.innerWidth - valueNodeRect.right - itemTextOffset;
-                const rightDelta = window.innerWidth - triggerRect.right - right;
-                const minContentWidth = triggerRect.width + rightDelta;
-                const contentWidth = Math.max(minContentWidth, contentRect.width);
-                const leftEdge = window.innerWidth - $cc7e05a45900e73f$var$CONTENT_MARGIN;
-                const clampedRight = $ae6933e535247d3d$export$7d15b64cf5a3a4c4(right, [
-                    $cc7e05a45900e73f$var$CONTENT_MARGIN,
-                    leftEdge - contentWidth
-                ]);
-                contentWrapper.style.minWidth = minContentWidth + 'px';
-                contentWrapper.style.right = clampedRight + 'px';
-            } // -----------------------------------------------------------------------------------------
-            // Vertical positioning
-            // -----------------------------------------------------------------------------------------
-            const items = getItems();
-            const availableHeight = window.innerHeight - $cc7e05a45900e73f$var$CONTENT_MARGIN * 2;
-            const itemsHeight = viewport.scrollHeight;
-            const contentStyles = window.getComputedStyle(content);
-            const contentBorderTopWidth = parseInt(contentStyles.borderTopWidth, 10);
-            const contentPaddingTop = parseInt(contentStyles.paddingTop, 10);
-            const contentBorderBottomWidth = parseInt(contentStyles.borderBottomWidth, 10);
-            const contentPaddingBottom = parseInt(contentStyles.paddingBottom, 10);
-            const fullContentHeight = contentBorderTopWidth + contentPaddingTop + itemsHeight + contentPaddingBottom + contentBorderBottomWidth; // prettier-ignore
-            const minContentHeight = Math.min(selectedItem.offsetHeight * 5, fullContentHeight);
-            const viewportStyles = window.getComputedStyle(viewport);
-            const viewportPaddingTop = parseInt(viewportStyles.paddingTop, 10);
-            const viewportPaddingBottom = parseInt(viewportStyles.paddingBottom, 10);
-            const topEdgeToTriggerMiddle = triggerRect.top + triggerRect.height / 2 - $cc7e05a45900e73f$var$CONTENT_MARGIN;
-            const triggerMiddleToBottomEdge = availableHeight - topEdgeToTriggerMiddle;
-            const selectedItemHalfHeight = selectedItem.offsetHeight / 2;
-            const itemOffsetMiddle = selectedItem.offsetTop + selectedItemHalfHeight;
-            const contentTopToItemMiddle = contentBorderTopWidth + contentPaddingTop + itemOffsetMiddle;
-            const itemMiddleToContentBottom = fullContentHeight - contentTopToItemMiddle;
-            const willAlignWithoutTopOverflow = contentTopToItemMiddle <= topEdgeToTriggerMiddle;
-            if (willAlignWithoutTopOverflow) {
-                const isLastItem = selectedItem === items[items.length - 1].ref.current;
-                contentWrapper.style.bottom = "0px";
-                const viewportOffsetBottom = content.clientHeight - viewport.offsetTop - viewport.offsetHeight;
-                const clampedTriggerMiddleToBottomEdge = Math.max(triggerMiddleToBottomEdge, selectedItemHalfHeight + (isLastItem ? viewportPaddingBottom : 0) + viewportOffsetBottom + contentBorderBottomWidth);
-                const height = contentTopToItemMiddle + clampedTriggerMiddleToBottomEdge;
-                contentWrapper.style.height = height + 'px';
-            } else {
-                const isFirstItem = selectedItem === items[0].ref.current;
-                contentWrapper.style.top = "0px";
-                const clampedTopEdgeToTriggerMiddle = Math.max(topEdgeToTriggerMiddle, contentBorderTopWidth + viewport.offsetTop + (isFirstItem ? viewportPaddingTop : 0) + selectedItemHalfHeight);
-                const height = clampedTopEdgeToTriggerMiddle + itemMiddleToContentBottom;
-                contentWrapper.style.height = height + 'px';
-                viewport.scrollTop = contentTopToItemMiddle - topEdgeToTriggerMiddle + viewport.offsetTop;
-            }
-            contentWrapper.style.margin = `${$cc7e05a45900e73f$var$CONTENT_MARGIN}px 0`;
-            contentWrapper.style.minHeight = minContentHeight + 'px';
-            contentWrapper.style.maxHeight = availableHeight + 'px'; // -----------------------------------------------------------------------------------------
-            onPlaced === null || onPlaced === void 0 || onPlaced(); // we don't want the initial scroll position adjustment to trigger "expand on scroll"
-            // so we explicitly turn it on only after they've registered.
-            requestAnimationFrame(()=>shouldExpandOnScrollRef.current = true
-            );
-        }
-    }, [
-        getItems,
-        context.trigger,
-        context.valueNode,
-        contentWrapper,
-        content,
-        viewport,
-        selectedItem,
-        selectedItemText,
-        context.dir,
-        onPlaced
-    ]);
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>position()
-    , [
-        position
-    ]); // copy z-index from content to wrapper
-    const [contentZIndex, setContentZIndex] = React.useState();
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        if (content) setContentZIndex(window.getComputedStyle(content).zIndex);
-    }, [
-        content
-    ]); // When the viewport becomes scrollable at the top, the scroll up button will mount.
-    // Because it is part of the normal flow, it will push down the viewport, thus throwing our
-    // trigger => selectedItem alignment off by the amount the viewport was pushed down.
-    // We wait for this to happen and then re-run the positining logic one more time to account for it.
-    const handleScrollButtonChange = React.useCallback((node)=>{
-        if (node && shouldRepositionRef.current === true) {
-            position();
-            focusSelectedItem === null || focusSelectedItem === void 0 || focusSelectedItem();
-            shouldRepositionRef.current = false;
-        }
-    }, [
-        position,
-        focusSelectedItem
-    ]);
-    return /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectViewportProvider, {
-        scope: __scopeSelect,
-        contentWrapper: contentWrapper,
-        shouldExpandOnScrollRef: shouldExpandOnScrollRef,
-        onScrollButtonChange: handleScrollButtonChange
-    }, /*#__PURE__*/ React.createElement("div", {
-        ref: setContentWrapper,
-        style: {
-            display: 'flex',
-            flexDirection: 'column',
-            position: 'fixed',
-            zIndex: contentZIndex
-        }
-    }, /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({}, popperProps, {
-        ref: composedRefs,
-        style: {
-            // When we get the height of the content, it includes borders. If we were to set
-            // the height without having `boxSizing: 'border-box'` it would be too big.
-            boxSizing: 'border-box',
-            // We need to ensure the content doesn't get taller than the wrapper
-            maxHeight: '100%',
-            ...popperProps.style
-        }
-    }))));
-});
-const $cc7e05a45900e73f$var$SelectPopperPosition = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , align: align = 'start' , collisionPadding: collisionPadding = $cc7e05a45900e73f$var$CONTENT_MARGIN , ...popperProps } = props;
-    const popperScope = $cc7e05a45900e73f$var$usePopperScope(__scopeSelect);
-    return /*#__PURE__*/ React.createElement($cf1ac5d9fe0e8206$export$7c6e2c02157bb7d2, index._extends({}, popperScope, popperProps, {
-        ref: forwardedRef,
-        align: align,
-        collisionPadding: collisionPadding,
-        style: {
-            // Ensure border-box for floating-ui calculations
-            boxSizing: 'border-box',
-            ...popperProps.style,
-            '--radix-select-content-transform-origin': 'var(--radix-popper-transform-origin)',
-            '--radix-select-content-available-width': 'var(--radix-popper-available-width)',
-            '--radix-select-content-available-height': 'var(--radix-popper-available-height)',
-            '--radix-select-trigger-width': 'var(--radix-popper-anchor-width)',
-            '--radix-select-trigger-height': 'var(--radix-popper-anchor-height)'
-        }
-    }));
-});
-/* -------------------------------------------------------------------------------------------------
- * SelectViewport
- * -----------------------------------------------------------------------------------------------*/ const [$cc7e05a45900e73f$var$SelectViewportProvider, $cc7e05a45900e73f$var$useSelectViewportContext] = $cc7e05a45900e73f$var$createSelectContext($cc7e05a45900e73f$var$CONTENT_NAME, {});
-const $cc7e05a45900e73f$var$VIEWPORT_NAME = 'SelectViewport';
-const $cc7e05a45900e73f$export$9ed6e7b40248d36d = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , ...viewportProps } = props;
-    const contentContext = $cc7e05a45900e73f$var$useSelectContentContext($cc7e05a45900e73f$var$VIEWPORT_NAME, __scopeSelect);
-    const viewportContext = $cc7e05a45900e73f$var$useSelectViewportContext($cc7e05a45900e73f$var$VIEWPORT_NAME, __scopeSelect);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, contentContext.onViewportChange);
-    const prevScrollTopRef = React.useRef(0);
-    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("style", {
-        dangerouslySetInnerHTML: {
-            __html: `[data-radix-select-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-select-viewport]::-webkit-scrollbar{display:none}`
-        }
-    }), /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$Collection.Slot, {
-        scope: __scopeSelect
-    }, /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({
-        "data-radix-select-viewport": "",
-        role: "presentation"
-    }, viewportProps, {
-        ref: composedRefs,
-        style: {
-            // we use position: 'relative' here on the `viewport` so that when we call
-            // `selectedItem.offsetTop` in calculations, the offset is relative to the viewport
-            // (independent of the scrollUpButton).
-            position: 'relative',
-            flex: 1,
-            overflow: 'auto',
-            ...viewportProps.style
-        },
-        onScroll: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(viewportProps.onScroll, (event)=>{
-            const viewport = event.currentTarget;
-            const { contentWrapper: contentWrapper , shouldExpandOnScrollRef: shouldExpandOnScrollRef  } = viewportContext;
-            if (shouldExpandOnScrollRef !== null && shouldExpandOnScrollRef !== void 0 && shouldExpandOnScrollRef.current && contentWrapper) {
-                const scrolledBy = Math.abs(prevScrollTopRef.current - viewport.scrollTop);
-                if (scrolledBy > 0) {
-                    const availableHeight = window.innerHeight - $cc7e05a45900e73f$var$CONTENT_MARGIN * 2;
-                    const cssMinHeight = parseFloat(contentWrapper.style.minHeight);
-                    const cssHeight = parseFloat(contentWrapper.style.height);
-                    const prevHeight = Math.max(cssMinHeight, cssHeight);
-                    if (prevHeight < availableHeight) {
-                        const nextHeight = prevHeight + scrolledBy;
-                        const clampedNextHeight = Math.min(availableHeight, nextHeight);
-                        const heightDiff = nextHeight - clampedNextHeight;
-                        contentWrapper.style.height = clampedNextHeight + 'px';
-                        if (contentWrapper.style.bottom === '0px') {
-                            viewport.scrollTop = heightDiff > 0 ? heightDiff : 0; // ensure the content stays pinned to the bottom
-                            contentWrapper.style.justifyContent = 'flex-end';
-                        }
-                    }
-                }
-            }
-            prevScrollTopRef.current = viewport.scrollTop;
-        })
-    }))));
-});
-/* -------------------------------------------------------------------------------------------------
- * SelectGroup
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$GROUP_NAME = 'SelectGroup';
-$cc7e05a45900e73f$var$createSelectContext($cc7e05a45900e73f$var$GROUP_NAME);
-/* -------------------------------------------------------------------------------------------------
- * SelectItem
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$ITEM_NAME = 'SelectItem';
-const [$cc7e05a45900e73f$var$SelectItemContextProvider, $cc7e05a45900e73f$var$useSelectItemContext] = $cc7e05a45900e73f$var$createSelectContext($cc7e05a45900e73f$var$ITEM_NAME);
-const $cc7e05a45900e73f$export$13ef48a934230896 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , value: value , disabled: disabled = false , textValue: textValueProp , ...itemProps } = props;
-    const context = $cc7e05a45900e73f$var$useSelectContext($cc7e05a45900e73f$var$ITEM_NAME, __scopeSelect);
-    const contentContext = $cc7e05a45900e73f$var$useSelectContentContext($cc7e05a45900e73f$var$ITEM_NAME, __scopeSelect);
-    const isSelected = context.value === value;
-    const [textValue, setTextValue] = React.useState(textValueProp !== null && textValueProp !== void 0 ? textValueProp : '');
-    const [isFocused, setIsFocused] = React.useState(false);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, (node)=>{
-        var _contentContext$itemR;
-        return (_contentContext$itemR = contentContext.itemRefCallback) === null || _contentContext$itemR === void 0 ? void 0 : _contentContext$itemR.call(contentContext, node, value, disabled);
-    });
-    const textId = index$5.$1746a345f3d73bb7$export$f680877a34711e37();
-    const handleSelect = ()=>{
-        if (!disabled) {
-            context.onValueChange(value);
-            context.onOpenChange(false);
-        }
-    };
-    if (value === '') throw new Error('A <Select.Item /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder.');
-    return /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectItemContextProvider, {
-        scope: __scopeSelect,
-        value: value,
-        disabled: disabled,
-        textId: textId,
-        isSelected: isSelected,
-        onItemTextChange: React.useCallback((node)=>{
-            setTextValue((prevTextValue)=>{
-                var _node$textContent;
-                return prevTextValue || ((_node$textContent = node === null || node === void 0 ? void 0 : node.textContent) !== null && _node$textContent !== void 0 ? _node$textContent : '').trim();
-            });
-        }, [])
-    }, /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$Collection.ItemSlot, {
-        scope: __scopeSelect,
-        value: value,
-        disabled: disabled,
-        textValue: textValue
-    }, /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({
-        role: "option",
-        "aria-labelledby": textId,
-        "data-highlighted": isFocused ? '' : undefined // `isFocused` caveat fixes stuttering in VoiceOver
-        ,
-        "aria-selected": isSelected && isFocused,
-        "data-state": isSelected ? 'checked' : 'unchecked',
-        "aria-disabled": disabled || undefined,
-        "data-disabled": disabled ? '' : undefined,
-        tabIndex: disabled ? undefined : -1
-    }, itemProps, {
-        ref: composedRefs,
-        onFocus: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(itemProps.onFocus, ()=>setIsFocused(true)
-        ),
-        onBlur: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(itemProps.onBlur, ()=>setIsFocused(false)
-        ),
-        onPointerUp: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(itemProps.onPointerUp, handleSelect),
-        onPointerMove: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(itemProps.onPointerMove, (event)=>{
-            if (disabled) {
-                var _contentContext$onIte;
-                (_contentContext$onIte = contentContext.onItemLeave) === null || _contentContext$onIte === void 0 || _contentContext$onIte.call(contentContext);
-            } else // even though safari doesn't support this option, it's acceptable
-            // as it only means it might scroll a few pixels when using the pointer.
-            event.currentTarget.focus({
-                preventScroll: true
-            });
-        }),
-        onPointerLeave: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(itemProps.onPointerLeave, (event)=>{
-            if (event.currentTarget === document.activeElement) {
-                var _contentContext$onIte2;
-                (_contentContext$onIte2 = contentContext.onItemLeave) === null || _contentContext$onIte2 === void 0 || _contentContext$onIte2.call(contentContext);
-            }
-        }),
-        onKeyDown: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(itemProps.onKeyDown, (event)=>{
-            var _contentContext$searc;
-            const isTypingAhead = ((_contentContext$searc = contentContext.searchRef) === null || _contentContext$searc === void 0 ? void 0 : _contentContext$searc.current) !== '';
-            if (isTypingAhead && event.key === ' ') return;
-            if ($cc7e05a45900e73f$var$SELECTION_KEYS.includes(event.key)) handleSelect(); // prevent page scroll if using the space key to select an item
-            if (event.key === ' ') event.preventDefault();
-        })
-    }))));
-});
-/* -------------------------------------------------------------------------------------------------
- * SelectItemText
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$ITEM_TEXT_NAME = 'SelectItemText';
-const $cc7e05a45900e73f$export$3572fb0fb821ff49 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    // We ignore `className` and `style` as this part shouldn't be styled.
-    const { __scopeSelect: __scopeSelect , className: className , style: style , ...itemTextProps } = props;
-    const context = $cc7e05a45900e73f$var$useSelectContext($cc7e05a45900e73f$var$ITEM_TEXT_NAME, __scopeSelect);
-    const contentContext = $cc7e05a45900e73f$var$useSelectContentContext($cc7e05a45900e73f$var$ITEM_TEXT_NAME, __scopeSelect);
-    const itemContext = $cc7e05a45900e73f$var$useSelectItemContext($cc7e05a45900e73f$var$ITEM_TEXT_NAME, __scopeSelect);
-    const nativeOptionsContext = $cc7e05a45900e73f$var$useSelectNativeOptionsContext($cc7e05a45900e73f$var$ITEM_TEXT_NAME, __scopeSelect);
-    const [itemTextNode, setItemTextNode] = React.useState(null);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, (node)=>setItemTextNode(node)
-    , itemContext.onItemTextChange, (node)=>{
-        var _contentContext$itemT;
-        return (_contentContext$itemT = contentContext.itemTextRefCallback) === null || _contentContext$itemT === void 0 ? void 0 : _contentContext$itemT.call(contentContext, node, itemContext.value, itemContext.disabled);
-    });
-    const textContent = itemTextNode === null || itemTextNode === void 0 ? void 0 : itemTextNode.textContent;
-    const nativeOption = React.useMemo(()=>/*#__PURE__*/ React.createElement("option", {
-            key: itemContext.value,
-            value: itemContext.value,
-            disabled: itemContext.disabled
-        }, textContent)
-    , [
-        itemContext.disabled,
-        itemContext.value,
-        textContent
-    ]);
-    const { onNativeOptionAdd: onNativeOptionAdd , onNativeOptionRemove: onNativeOptionRemove  } = nativeOptionsContext;
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        onNativeOptionAdd(nativeOption);
-        return ()=>onNativeOptionRemove(nativeOption)
-        ;
-    }, [
-        onNativeOptionAdd,
-        onNativeOptionRemove,
-        nativeOption
-    ]);
-    return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.span, index._extends({
-        id: itemContext.textId
-    }, itemTextProps, {
-        ref: composedRefs
-    })), itemContext.isSelected && context.valueNode && !context.valueNodeHasChildren ? /*#__PURE__*/ ReactDOM.createPortal(itemTextProps.children, context.valueNode) : null);
-});
-/* -------------------------------------------------------------------------------------------------
- * SelectItemIndicator
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$ITEM_INDICATOR_NAME = 'SelectItemIndicator';
-const $cc7e05a45900e73f$export$6b9198de19accfe6 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , ...itemIndicatorProps } = props;
-    const itemContext = $cc7e05a45900e73f$var$useSelectItemContext($cc7e05a45900e73f$var$ITEM_INDICATOR_NAME, __scopeSelect);
-    return itemContext.isSelected ? /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.span, index._extends({
-        "aria-hidden": true
-    }, itemIndicatorProps, {
-        ref: forwardedRef
-    })) : null;
-});
-/* -------------------------------------------------------------------------------------------------
- * SelectScrollUpButton
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$SCROLL_UP_BUTTON_NAME = 'SelectScrollUpButton';
-const $cc7e05a45900e73f$export$d8117927658af6d7 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const contentContext = $cc7e05a45900e73f$var$useSelectContentContext($cc7e05a45900e73f$var$SCROLL_UP_BUTTON_NAME, props.__scopeSelect);
-    const viewportContext = $cc7e05a45900e73f$var$useSelectViewportContext($cc7e05a45900e73f$var$SCROLL_UP_BUTTON_NAME, props.__scopeSelect);
-    const [canScrollUp1, setCanScrollUp] = React.useState(false);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, viewportContext.onScrollButtonChange);
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        if (contentContext.viewport && contentContext.isPositioned) {
-            const viewport = contentContext.viewport;
-            function handleScroll() {
-                const canScrollUp = viewport.scrollTop > 0;
-                setCanScrollUp(canScrollUp);
-            }
-            handleScroll();
-            viewport.addEventListener('scroll', handleScroll);
-            return ()=>viewport.removeEventListener('scroll', handleScroll)
-            ;
-        }
-    }, [
-        contentContext.viewport,
-        contentContext.isPositioned
-    ]);
-    return canScrollUp1 ? /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectScrollButtonImpl, index._extends({}, props, {
-        ref: composedRefs,
-        onAutoScroll: ()=>{
-            const { viewport: viewport , selectedItem: selectedItem  } = contentContext;
-            if (viewport && selectedItem) viewport.scrollTop = viewport.scrollTop - selectedItem.offsetHeight;
-        }
-    })) : null;
-});
-/* -------------------------------------------------------------------------------------------------
- * SelectScrollDownButton
- * -----------------------------------------------------------------------------------------------*/ const $cc7e05a45900e73f$var$SCROLL_DOWN_BUTTON_NAME = 'SelectScrollDownButton';
-const $cc7e05a45900e73f$export$ff951e476c12189 = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const contentContext = $cc7e05a45900e73f$var$useSelectContentContext($cc7e05a45900e73f$var$SCROLL_DOWN_BUTTON_NAME, props.__scopeSelect);
-    const viewportContext = $cc7e05a45900e73f$var$useSelectViewportContext($cc7e05a45900e73f$var$SCROLL_DOWN_BUTTON_NAME, props.__scopeSelect);
-    const [canScrollDown1, setCanScrollDown] = React.useState(false);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, viewportContext.onScrollButtonChange);
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        if (contentContext.viewport && contentContext.isPositioned) {
-            const viewport = contentContext.viewport;
-            function handleScroll() {
-                const maxScroll = viewport.scrollHeight - viewport.clientHeight; // we use Math.ceil here because if the UI is zoomed-in
-                // `scrollTop` is not always reported as an integer
-                const canScrollDown = Math.ceil(viewport.scrollTop) < maxScroll;
-                setCanScrollDown(canScrollDown);
-            }
-            handleScroll();
-            viewport.addEventListener('scroll', handleScroll);
-            return ()=>viewport.removeEventListener('scroll', handleScroll)
-            ;
-        }
-    }, [
-        contentContext.viewport,
-        contentContext.isPositioned
-    ]);
-    return canScrollDown1 ? /*#__PURE__*/ React.createElement($cc7e05a45900e73f$var$SelectScrollButtonImpl, index._extends({}, props, {
-        ref: composedRefs,
-        onAutoScroll: ()=>{
-            const { viewport: viewport , selectedItem: selectedItem  } = contentContext;
-            if (viewport && selectedItem) viewport.scrollTop = viewport.scrollTop + selectedItem.offsetHeight;
-        }
-    })) : null;
-});
-const $cc7e05a45900e73f$var$SelectScrollButtonImpl = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { __scopeSelect: __scopeSelect , onAutoScroll: onAutoScroll , ...scrollIndicatorProps } = props;
-    const contentContext = $cc7e05a45900e73f$var$useSelectContentContext('SelectScrollButton', __scopeSelect);
-    const autoScrollTimerRef = React.useRef(null);
-    const getItems = $cc7e05a45900e73f$var$useCollection(__scopeSelect);
-    const clearAutoScrollTimer = React.useCallback(()=>{
-        if (autoScrollTimerRef.current !== null) {
-            window.clearInterval(autoScrollTimerRef.current);
-            autoScrollTimerRef.current = null;
-        }
-    }, []);
-    React.useEffect(()=>{
-        return ()=>clearAutoScrollTimer()
-        ;
-    }, [
-        clearAutoScrollTimer
-    ]); // When the viewport becomes scrollable on either side, the relevant scroll button will mount.
-    // Because it is part of the normal flow, it will push down (top button) or shrink (bottom button)
-    // the viewport, potentially causing the active item to now be partially out of view.
-    // We re-run the `scrollIntoView` logic to make sure it stays within the viewport.
-    index.$9f79659886946c16$export$e5c5a5f917a5871c(()=>{
-        var _activeItem$ref$curre;
-        const activeItem = getItems().find((item)=>item.ref.current === document.activeElement
-        );
-        activeItem === null || activeItem === void 0 || (_activeItem$ref$curre = activeItem.ref.current) === null || _activeItem$ref$curre === void 0 || _activeItem$ref$curre.scrollIntoView({
-            block: 'nearest'
-        });
-    }, [
-        getItems
-    ]);
-    return /*#__PURE__*/ React.createElement(index.$8927f6f2acc4f386$export$250ffa63cdc0d034.div, index._extends({
-        "aria-hidden": true
-    }, scrollIndicatorProps, {
-        ref: forwardedRef,
-        style: {
-            flexShrink: 0,
-            ...scrollIndicatorProps.style
-        },
-        onPointerDown: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(scrollIndicatorProps.onPointerDown, ()=>{
-            if (autoScrollTimerRef.current === null) autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
-        }),
-        onPointerMove: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(scrollIndicatorProps.onPointerMove, ()=>{
-            var _contentContext$onIte3;
-            (_contentContext$onIte3 = contentContext.onItemLeave) === null || _contentContext$onIte3 === void 0 || _contentContext$onIte3.call(contentContext);
-            if (autoScrollTimerRef.current === null) autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
-        }),
-        onPointerLeave: index.$e42e1063c40fb3ef$export$b9ecd428b558ff10(scrollIndicatorProps.onPointerLeave, ()=>{
-            clearAutoScrollTimer();
-        })
-    }));
-});
-/* -----------------------------------------------------------------------------------------------*/ function $cc7e05a45900e73f$var$shouldShowPlaceholder(value) {
-    return value === '' || value === undefined;
-}
-const $cc7e05a45900e73f$var$BubbleSelect = /*#__PURE__*/ React.forwardRef((props, forwardedRef)=>{
-    const { value: value , ...selectProps } = props;
-    const ref = React.useRef(null);
-    const composedRefs = index.$6ed0406888f73fc4$export$c7b2cbe3552a0d05(forwardedRef, ref);
-    const prevValue = index$2.$010c2913dbd2fe3d$export$5cae361ad82dce8b(value); // Bubble value change to parents (e.g form change event)
-    React.useEffect(()=>{
-        const select = ref.current;
-        const selectProto = window.HTMLSelectElement.prototype;
-        const descriptor = Object.getOwnPropertyDescriptor(selectProto, 'value');
-        const setValue = descriptor.set;
-        if (prevValue !== value && setValue) {
-            const event = new Event('change', {
-                bubbles: true
-            });
-            setValue.call(select, value);
-            select.dispatchEvent(event);
-        }
-    }, [
-        prevValue,
-        value
-    ]);
-    /**
-   * We purposefully use a `select` here to support form autofill as much
-   * as possible.
-   *
-   * We purposefully do not add the `value` attribute here to allow the value
-   * to be set programatically and bubble to any parent form `onChange` event.
-   * Adding the `value` will cause React to consider the programatic
-   * dispatch a duplicate and it will get swallowed.
-   *
-   * We use `VisuallyHidden` rather than `display: "none"` because Safari autofill
-   * won't work otherwise.
-   */ return /*#__PURE__*/ React.createElement(index$1.$ea1ef594cf570d83$export$439d29a4e110a164, {
-        asChild: true
-    }, /*#__PURE__*/ React.createElement("select", index._extends({}, selectProps, {
-        ref: composedRefs,
-        defaultValue: value
-    })));
-});
-$cc7e05a45900e73f$var$BubbleSelect.displayName = 'BubbleSelect';
-function $cc7e05a45900e73f$var$useTypeaheadSearch(onSearchChange) {
-    const handleSearchChange = index.$b1b2314f5f9a1d84$export$25bec8c6f54ee79a(onSearchChange);
-    const searchRef = React.useRef('');
-    const timerRef = React.useRef(0);
-    const handleTypeaheadSearch = React.useCallback((key)=>{
-        const search = searchRef.current + key;
-        handleSearchChange(search);
-        (function updateSearch(value) {
-            searchRef.current = value;
-            window.clearTimeout(timerRef.current); // Reset `searchRef` 1 second after it was last updated
-            if (value !== '') timerRef.current = window.setTimeout(()=>updateSearch('')
-            , 1000);
-        })(search);
-    }, [
-        handleSearchChange
-    ]);
-    const resetTypeahead = React.useCallback(()=>{
-        searchRef.current = '';
-        window.clearTimeout(timerRef.current);
-    }, []);
-    React.useEffect(()=>{
-        return ()=>window.clearTimeout(timerRef.current)
-        ;
-    }, []);
-    return [
-        searchRef,
-        handleTypeaheadSearch,
-        resetTypeahead
-    ];
-}
-/**
- * This is the "meat" of the typeahead matching logic. It takes in a list of items,
- * the search and the current item, and returns the next item (or `undefined`).
- *
- * We normalize the search because if a user has repeatedly pressed a character,
- * we want the exact same behavior as if we only had that one character
- * (ie. cycle through items starting with that character)
- *
- * We also reorder the items by wrapping the array around the current item.
- * This is so we always look forward from the current item, and picking the first
- * item will always be the correct one.
- *
- * Finally, if the normalized search is exactly one character, we exclude the
- * current item from the values because otherwise it would be the first to match always
- * and focus would never move. This is as opposed to the regular case, where we
- * don't want focus to move if the current item still matches.
- */ function $cc7e05a45900e73f$var$findNextItem(items, search, currentItem) {
-    const isRepeated = search.length > 1 && Array.from(search).every((char)=>char === search[0]
-    );
-    const normalizedSearch = isRepeated ? search[0] : search;
-    const currentItemIndex = currentItem ? items.indexOf(currentItem) : -1;
-    let wrappedItems = $cc7e05a45900e73f$var$wrapArray(items, Math.max(currentItemIndex, 0));
-    const excludeCurrentItem = normalizedSearch.length === 1;
-    if (excludeCurrentItem) wrappedItems = wrappedItems.filter((v)=>v !== currentItem
-    );
-    const nextItem = wrappedItems.find((item)=>item.textValue.toLowerCase().startsWith(normalizedSearch.toLowerCase())
-    );
-    return nextItem !== currentItem ? nextItem : undefined;
-}
-/**
- * Wraps an array around itself at a given start index
- * Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a', 'b']`
- */ function $cc7e05a45900e73f$var$wrapArray(array, startIndex) {
-    return array.map((_, index)=>array[(startIndex + index) % array.length]
-    );
-}
-const $cc7e05a45900e73f$export$be92b6f5f03c0fe9 = $cc7e05a45900e73f$export$ef9b1a59e592288f;
-const $cc7e05a45900e73f$export$41fb9f06171c75f4 = $cc7e05a45900e73f$export$3ac1e88a1c0b9f1;
-const $cc7e05a45900e73f$export$4c8d1a57a761ef94 = $cc7e05a45900e73f$export$e288731fd71264f0;
-const $cc7e05a45900e73f$export$f04a61298a47a40f = $cc7e05a45900e73f$export$99b400cabb58c515;
-const $cc7e05a45900e73f$export$602eac185826482c = $cc7e05a45900e73f$export$b2af6c9944296213;
-const $cc7e05a45900e73f$export$7c6e2c02157bb7d2 = $cc7e05a45900e73f$export$c973a4b3cb86a03d;
-const $cc7e05a45900e73f$export$d5c6c08dc2d3ca7 = $cc7e05a45900e73f$export$9ed6e7b40248d36d;
-const $cc7e05a45900e73f$export$6d08773d2e66f8f2 = $cc7e05a45900e73f$export$13ef48a934230896;
-const $cc7e05a45900e73f$export$d6e5bf9c43ea9319 = $cc7e05a45900e73f$export$3572fb0fb821ff49;
-const $cc7e05a45900e73f$export$c3468e2714d175fa = $cc7e05a45900e73f$export$6b9198de19accfe6;
-const $cc7e05a45900e73f$export$2f60d3ec9ad468f2 = $cc7e05a45900e73f$export$d8117927658af6d7;
-const $cc7e05a45900e73f$export$bf1aedc3039c8d63 = $cc7e05a45900e73f$export$ff951e476c12189;
-
-exports.$cc7e05a45900e73f$export$2f60d3ec9ad468f2 = $cc7e05a45900e73f$export$2f60d3ec9ad468f2;
-exports.$cc7e05a45900e73f$export$41fb9f06171c75f4 = $cc7e05a45900e73f$export$41fb9f06171c75f4;
-exports.$cc7e05a45900e73f$export$4c8d1a57a761ef94 = $cc7e05a45900e73f$export$4c8d1a57a761ef94;
-exports.$cc7e05a45900e73f$export$602eac185826482c = $cc7e05a45900e73f$export$602eac185826482c;
-exports.$cc7e05a45900e73f$export$6d08773d2e66f8f2 = $cc7e05a45900e73f$export$6d08773d2e66f8f2;
-exports.$cc7e05a45900e73f$export$7c6e2c02157bb7d2 = $cc7e05a45900e73f$export$7c6e2c02157bb7d2;
-exports.$cc7e05a45900e73f$export$be92b6f5f03c0fe9 = $cc7e05a45900e73f$export$be92b6f5f03c0fe9;
-exports.$cc7e05a45900e73f$export$bf1aedc3039c8d63 = $cc7e05a45900e73f$export$bf1aedc3039c8d63;
-exports.$cc7e05a45900e73f$export$c3468e2714d175fa = $cc7e05a45900e73f$export$c3468e2714d175fa;
-exports.$cc7e05a45900e73f$export$d5c6c08dc2d3ca7 = $cc7e05a45900e73f$export$d5c6c08dc2d3ca7;
-exports.$cc7e05a45900e73f$export$d6e5bf9c43ea9319 = $cc7e05a45900e73f$export$d6e5bf9c43ea9319;
-exports.$cc7e05a45900e73f$export$f04a61298a47a40f = $cc7e05a45900e73f$export$f04a61298a47a40f;