3-ay6knybmraf.js

js diks.net collected 2026-09-24 10:27:51 UTC 83,919 bytes, 1,545 lines download raw bytes

1;!function(){try { var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof global?global:"undefined"!=typeof window?window:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&((e._debugIds|| (e._debugIds={}))[n]="ce027bbb-4ed3-f7c3-305f-7d20ab552395")}catch(e){}}();
2(globalThis["TURBOPACK"] || (globalThis["TURBOPACK"] = [])).push([typeof document === "object" ? document.currentScript : undefined,
3429427, 371330, 
4((__turbopack_context__) => {
5"use strict";
6
7// MERGED MODULE: [project]/node_modules/@react-aria/focus/dist/useFocusRing.mjs [app-client] (ecmascript)
8;
9// MERGED MODULE: [project]/node_modules/@react-aria/interactions/dist/useFocusVisible.mjs [app-client] (ecmascript)
10;
11var __TURBOPACK__imported__module__247167__ = __turbopack_context__.i(247167);
12// MERGED MODULE: [project]/node_modules/@react-aria/interactions/dist/utils.mjs [app-client] (ecmascript)
13;
14// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/useLayoutEffect.mjs [app-client] (ecmascript)
15;
16var __TURBOPACK__imported__module__271645__ = __turbopack_context__.i(271645);
17;
18/*
19 * Copyright 2020 Adobe. All rights reserved.
20 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
21 * you may not use this file except in compliance with the License. You may obtain a copy
22 * of the License at http://www.apache.org/licenses/LICENSE-2.0
23 *
24 * Unless required by applicable law or agreed to in writing, software distributed under
25 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
26 * OF ANY KIND, either express or implied. See the License for the specific language
27 * governing permissions and limitations under the License.
28 */ const $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c = typeof document !== 'undefined' ? (0, __TURBOPACK__imported__module__271645__["default"]).useLayoutEffect : ()=>{};
29;
30// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/DOMFunctions.mjs [app-client] (ecmascript)
31;
32// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/domHelpers.mjs [app-client] (ecmascript)
33;
34const $431fbd86ca7dc216$export$b204af158042fbac = (el)=>{
35    var _el_ownerDocument;
36    return (_el_ownerDocument = el === null || el === void 0 ? void 0 : el.ownerDocument) !== null && _el_ownerDocument !== void 0 ? _el_ownerDocument : document;
37};
38const $431fbd86ca7dc216$export$f21a1ffae260145a = (el)=>{
39    if (el && 'window' in el && el.window === el) return el;
40    const doc = $431fbd86ca7dc216$export$b204af158042fbac(el);
41    return doc.defaultView || window;
42};
43/**
44 * Type guard that checks if a value is a Node. Verifies the presence and type of the nodeType property.
45 */ function $431fbd86ca7dc216$var$isNode(value) {
46    return value !== null && typeof value === 'object' && 'nodeType' in value && typeof value.nodeType === 'number';
47}
48function $431fbd86ca7dc216$export$af51f0f06c0f328a(node) {
49    return $431fbd86ca7dc216$var$isNode(node) && node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && 'host' in node;
50}
51;
52// MERGED MODULE: [project]/node_modules/@react-stately/flags/dist/import.mjs [app-client] (ecmascript)
53;
54/*
55 * Copyright 2023 Adobe. All rights reserved.
56 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
57 * you may not use this file except in compliance with the License. You may obtain a copy
58 * of the License at http://www.apache.org/licenses/LICENSE-2.0
59 *
60 * Unless required by applicable law or agreed to in writing, software distributed under
61 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
62 * OF ANY KIND, either express or implied. See the License for the specific language
63 * governing permissions and limitations under the License.
64 */ let $f4e2df6bd15f8569$var$_tableNestedRows = false;
65let $f4e2df6bd15f8569$var$_shadowDOM = false;
66function $f4e2df6bd15f8569$export$d9d8a0f82de49530() {
67    $f4e2df6bd15f8569$var$_tableNestedRows = true;
68}
69function $f4e2df6bd15f8569$export$1b00cb14a96194e6() {
70    return $f4e2df6bd15f8569$var$_tableNestedRows;
71}
72function $f4e2df6bd15f8569$export$12b151d9882e9985() {
73    $f4e2df6bd15f8569$var$_shadowDOM = true;
74}
75function $f4e2df6bd15f8569$export$98658e8c59125e6a() {
76    return $f4e2df6bd15f8569$var$_shadowDOM;
77}
78;
79;
80;
81// Source: https://github.com/microsoft/tabster/blob/a89fc5d7e332d48f68d03b1ca6e344489d1c3898/src/Shadowdomize/DOMFunctions.ts#L16
82/* eslint-disable rsp-rules/no-non-shadow-contains, rsp-rules/safe-event-target */ function $d4ee10de306f2510$export$4282f70798064fe0(node, otherNode) {

83    if (!(0, $f4e2df6bd15f8569$export$98658e8c59125e6a)()) return otherNode && node ? node.contains(otherNode) : false;
84    if (!node || !otherNode) return false;
85    let currentNode = otherNode;
86    while(currentNode !== null){
87        if (currentNode === node) return true;
88        if (currentNode.tagName === 'SLOT' && currentNode.assignedSlot) currentNode = currentNode.assignedSlot.parentNode;
89        else if ((0, $431fbd86ca7dc216$export$af51f0f06c0f328a)(currentNode)) currentNode = currentNode.host;
90        else currentNode = currentNode.parentNode;
91    }
92    return false;
93}
94const $d4ee10de306f2510$export$cd4e5573fbe2b576 = function() {
95    let doc = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : document;
96    var _activeElement_shadowRoot;
97    if (!(0, $f4e2df6bd15f8569$export$98658e8c59125e6a)()) return doc.activeElement;
98    let activeElement = doc.activeElement;
99    while(activeElement && 'shadowRoot' in activeElement && ((_activeElement_shadowRoot = activeElement.shadowRoot) === null || _activeElement_shadowRoot === void 0 ? void 0 : _activeElement_shadowRoot.activeElement))activeElement = activeElement.shadowRoot.activeElement;
100    return activeElement;
101};
102function $d4ee10de306f2510$export$e58f029f0fbfdb29(event) {
103    if ((0, $f4e2df6bd15f8569$export$98658e8c59125e6a)() && event.target instanceof Element && event.target.shadowRoot) {
104        var _event_composedPath_, _event_nativeEvent_composedPath_;
105        if ('composedPath' in event) return (_event_composedPath_ = event.composedPath()[0]) !== null && _event_composedPath_ !== void 0 ? _event_composedPath_ : null;
106        else if ('composedPath' in event.nativeEvent) return (_event_nativeEvent_composedPath_ = event.nativeEvent.composedPath()[0]) !== null && _event_nativeEvent_composedPath_ !== void 0 ? _event_nativeEvent_composedPath_ : null;
107    }
108    return event.target;
109}
110function $d4ee10de306f2510$export$b4f377a2b6254582(node) {
111    if (!node) return false;
112    // Get the active element within the node's parent shadow root (or the document). Can return null.
113    let root = node.getRootNode();
114    let ownerWindow = (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(node);
115    if (!(root instanceof ownerWindow.Document || root instanceof ownerWindow.ShadowRoot)) return false;
116    let activeElement = root.activeElement;
117    // Check if the active element is within this node. These nodes are within the same shadow root.
118    return activeElement != null && node.contains(activeElement);
119}
120;
121// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/isFocusable.mjs [app-client] (ecmascript)
122;
123// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/isElementVisible.mjs [app-client] (ecmascript)
124;
125;
126/*
127 * Copyright 2021 Adobe. All rights reserved.
128 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
129 * you may not use this file except in compliance with the License. You may obtain a copy
130 * of the License at http://www.apache.org/licenses/LICENSE-2.0
131 *
132 * Unless required by applicable law or agreed to in writing, software distributed under
133 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
134 * OF ANY KIND, either express or implied. See the License for the specific language
135 * governing permissions and limitations under the License.
136 */ const $7d2416ea0959daaa$var$supportsCheckVisibility = typeof Element !== 'undefined' && 'checkVisibility' in Element.prototype;
137function $7d2416ea0959daaa$var$isStyleVisible(element) {
138    const windowObject = (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(element);
139    if (!(element instanceof windowObject.HTMLElement) && !(element instanceof windowObject.SVGElement)) return false;
140    let { display: display, visibility: visibility } = element.style;
141    let isVisible = display !== 'none' && visibility !== 'hidden' && visibility !== 'collapse';
142    if (isVisible) {
143        const { getComputedStyle: getComputedStyle } = element.ownerDocument.defaultView;
144        let { display: computedDisplay, visibility: computedVisibility } = getComputedStyle(element);
145        isVisible = computedDisplay !== 'none' && computedVisibility !== 'hidden' && computedVisibility !== 'collapse';
146    }
147    return isVisible;
148}
149function $7d2416ea0959daaa$var$isAttributeVisible(element, childElement) {
150    return !element.hasAttribute('hidden') && // Ignore HiddenSelect when tree walking.
151    !element.hasAttribute('data-react-aria-prevent-focus') && (element.nodeName === 'DETAILS' && childElement && childElement.nodeName !== 'SUMMARY' ? element.hasAttribute('open') : true);
152}
153function $7d2416ea0959daaa$export$e989c0fffaa6b27a(element, childElement) {
154    if ($7d2416ea0959daaa$var$supportsCheckVisibility) return element.checkVisibility({
155        visibilityProperty: true
156    }) && !element.closest('[data-react-aria-prevent-focus]');
157    return element.nodeName !== '#comment' && $7d2416ea0959daaa$var$isStyleVisible(element) && $7d2416ea0959daaa$var$isAttributeVisible(element, childElement) && (!element.parentElement || $7d2416ea0959daaa$export$e989c0fffaa6b27a(element.parentElement, element));
158}
159;
160;
161/*
162 * Copyright 2025 Adobe. All rights reserved.
163 * This file is licensed to you under the Apache License, Version 2.0 (the "License");

164 * you may not use this file except in compliance with the License. You may obtain a copy
165 * of the License at http://www.apache.org/licenses/LICENSE-2.0
166 *
167 * Unless required by applicable law or agreed to in writing, software distributed under
168 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
169 * OF ANY KIND, either express or implied. See the License for the specific language
170 * governing permissions and limitations under the License.
171 */ const $b4b717babfbb907b$var$focusableElements = [
172    'input:not([disabled]):not([type=hidden])',
173    'select:not([disabled])',
174    'textarea:not([disabled])',
175    'button:not([disabled])',
176    'a[href]',
177    'area[href]',
178    'summary',
179    'iframe',
180    'object',
181    'embed',
182    'audio[controls]',
183    'video[controls]',
184    '[contenteditable]:not([contenteditable^="false"])',
185    'permission'
186];
187const $b4b717babfbb907b$var$FOCUSABLE_ELEMENT_SELECTOR = $b4b717babfbb907b$var$focusableElements.join(':not([hidden]),') + ',[tabindex]:not([disabled]):not([hidden])';
188$b4b717babfbb907b$var$focusableElements.push('[tabindex]:not([tabindex="-1"]):not([disabled])');
189const $b4b717babfbb907b$var$TABBABLE_ELEMENT_SELECTOR = $b4b717babfbb907b$var$focusableElements.join(':not([hidden]):not([tabindex="-1"]),');
190function $b4b717babfbb907b$export$4c063cf1350e6fed(element) {
191    return element.matches($b4b717babfbb907b$var$FOCUSABLE_ELEMENT_SELECTOR) && (0, $7d2416ea0959daaa$export$e989c0fffaa6b27a)(element) && !$b4b717babfbb907b$var$isInert(element);
192}
193function $b4b717babfbb907b$export$bebd5a1431fec25d(element) {
194    return element.matches($b4b717babfbb907b$var$TABBABLE_ELEMENT_SELECTOR) && (0, $7d2416ea0959daaa$export$e989c0fffaa6b27a)(element) && !$b4b717babfbb907b$var$isInert(element);
195}
196function $b4b717babfbb907b$var$isInert(element) {
197    let node = element;
198    while(node != null){
199        if (node instanceof node.ownerDocument.defaultView.HTMLElement && node.inert) return true;
200        node = node.parentElement;
201    }
202    return false;
203}
204;
205// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/focusWithoutScrolling.mjs [app-client] (ecmascript)
206;
207/*
208 * Copyright 2020 Adobe. All rights reserved.
209 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
210 * you may not use this file except in compliance with the License. You may obtain a copy
211 * of the License at http://www.apache.org/licenses/LICENSE-2.0
212 *
213 * Unless required by applicable law or agreed to in writing, software distributed under
214 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
215 * OF ANY KIND, either express or implied. See the License for the specific language
216 * governing permissions and limitations under the License.
217 */ function $7215afc6de606d6b$export$de79e2c695e052f3(element) {
218    if ($7215afc6de606d6b$var$supportsPreventScroll()) element.focus({
219        preventScroll: true
220    });
221    else {
222        let scrollableElements = $7215afc6de606d6b$var$getScrollableElements(element);
223        element.focus();
224        $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements);
225    }
226}
227let $7215afc6de606d6b$var$supportsPreventScrollCached = null;
228function $7215afc6de606d6b$var$supportsPreventScroll() {
229    if ($7215afc6de606d6b$var$supportsPreventScrollCached == null) {
230        $7215afc6de606d6b$var$supportsPreventScrollCached = false;
231        try {
232            let focusElem = document.createElement('div');
233            focusElem.focus({
234                get preventScroll () {
235                    $7215afc6de606d6b$var$supportsPreventScrollCached = true;
236                    return true;
237                }
238            });
239        } catch (unused) {
240        // Ignore
241        }
242    }
243    return $7215afc6de606d6b$var$supportsPreventScrollCached;
244}
245function $7215afc6de606d6b$var$getScrollableElements(element) {
246    let parent = element.parentNode;
247    let scrollableElements = [];
248    let rootScrollingElement = document.scrollingElement || document.documentElement;
249    while(parent instanceof HTMLElement && parent !== rootScrollingElement){
250        if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth) scrollableElements.push({
251            element: parent,
252            scrollTop: parent.scrollTop,
253            scrollLeft: parent.scrollLeft
254        });
255        parent = parent.parentNode;
256    }
257    if (rootScrollingElement instanceof HTMLElement) scrollableElements.push({
258        element: rootScrollingElement,
259        scrollTop: rootScrollingElement.scrollTop,
260        scrollLeft: rootScrollingElement.scrollLeft
261    });
262    return scrollableElements;
263}
264function $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements) {
265    for (let { element: element, scrollTop: scrollTop, scrollLeft: scrollLeft } of scrollableElements){
266        element.scrollTop = scrollTop;
267        element.scrollLeft = scrollLeft;
268    }
269}
270;
271var __TURBOPACK__imported__module__271645__1 = __TURBOPACK__imported__module__271645__;
272;
273;
274/*
275 * Copyright 2020 Adobe. All rights reserved.
276 * This file is licensed to you under the Apache License, Version 2.0 (the "License");

277 * you may not use this file except in compliance with the License. You may obtain a copy
278 * of the License at http://www.apache.org/licenses/LICENSE-2.0
279 *
280 * Unless required by applicable law or agreed to in writing, software distributed under
281 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
282 * OF ANY KIND, either express or implied. See the License for the specific language
283 * governing permissions and limitations under the License.
284 */ function $8a9cb279dc87e130$export$525bc4921d56d4a(nativeEvent) {
285    let event = nativeEvent;
286    event.nativeEvent = nativeEvent;
287    event.isDefaultPrevented = ()=>event.defaultPrevented;
288    // cancelBubble is technically deprecated in the spec, but still supported in all browsers.
289    event.isPropagationStopped = ()=>event.cancelBubble;
290    event.persist = ()=>{};
291    return event;
292}
293function $8a9cb279dc87e130$export$c2b7abe5d61ec696(event, target) {
294    Object.defineProperty(event, 'target', {
295        value: target
296    });
297    Object.defineProperty(event, 'currentTarget', {
298        value: target
299    });
300}
301function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
302    let stateRef = (0, __TURBOPACK__imported__module__271645__1["useRef"])({
303        isFocused: false,
304        observer: null
305    });
306    // Clean up MutationObserver on unmount. See below.
307    (0, $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c)(()=>{
308        const state = stateRef.current;
309        return ()=>{
310            if (state.observer) {
311                state.observer.disconnect();
312                state.observer = null;
313            }
314        };
315    }, []);
316    // This function is called during a React onFocus event.
317    return (0, __TURBOPACK__imported__module__271645__1["useCallback"])((e)=>{
318        // React does not fire onBlur when an element is disabled. https://github.com/facebook/react/issues/9142
319        // Most browsers fire a native focusout event in this case, except for Firefox. In that case, we use a
320        // MutationObserver to watch for the disabled attribute, and dispatch these events ourselves.
321        // For browsers that do, focusout fires before the MutationObserver, so onBlur should not fire twice.
322        let eventTarget = (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
323        if (eventTarget instanceof HTMLButtonElement || eventTarget instanceof HTMLInputElement || eventTarget instanceof HTMLTextAreaElement || eventTarget instanceof HTMLSelectElement) {
324            stateRef.current.isFocused = true;
325            let target = eventTarget;
326            let onBlurHandler = (e)=>{
327                stateRef.current.isFocused = false;
328                if (target.disabled) {
329                    // For backward compatibility, dispatch a (fake) React synthetic event.
330                    let event = $8a9cb279dc87e130$export$525bc4921d56d4a(e);
331                    onBlur === null || onBlur === void 0 ? void 0 : onBlur(event);
332                }
333                // We no longer need the MutationObserver once the target is blurred.
334                if (stateRef.current.observer) {
335                    stateRef.current.observer.disconnect();
336                    stateRef.current.observer = null;
337                }
338            };
339            target.addEventListener('focusout', onBlurHandler, {
340                once: true
341            });
342            stateRef.current.observer = new MutationObserver(()=>{
343                if (stateRef.current.isFocused && target.disabled) {
344                    var _stateRef_current_observer;
345                    (_stateRef_current_observer = stateRef.current.observer) === null || _stateRef_current_observer === void 0 ? void 0 : _stateRef_current_observer.disconnect();
346                    let relatedTargetEl = target === (0, $d4ee10de306f2510$export$cd4e5573fbe2b576)() ? null : (0, $d4ee10de306f2510$export$cd4e5573fbe2b576)();
347                    target.dispatchEvent(new FocusEvent('blur', {
348                        relatedTarget: relatedTargetEl
349                    }));
350                    target.dispatchEvent(new FocusEvent('focusout', {
351                        bubbles: true,
352                        relatedTarget: relatedTargetEl
353                    }));
354                }
355            });
356            stateRef.current.observer.observe(target, {
357                attributes: true,
358                attributeFilter: [
359                    'disabled'
360                ]
361            });
362        }
363    }, [
364        onBlur
365    ]);
366}
367let $8a9cb279dc87e130$export$fda7da73ab5d4c48 = false;

368function $8a9cb279dc87e130$export$cabe61c495ee3649(target) {
369    // The browser will focus the nearest focusable ancestor of our target.
370    while(target && !(0, $b4b717babfbb907b$export$4c063cf1350e6fed)(target))target = target.parentElement;
371    let window1 = (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(target);
372    let activeElement = window1.document.activeElement;
373    if (!activeElement || activeElement === target) return;
374    $8a9cb279dc87e130$export$fda7da73ab5d4c48 = true;
375    let isRefocusing = false;
376    let onBlur = (e)=>{
377        if ((0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === activeElement || isRefocusing) e.stopImmediatePropagation();
378    };
379    let onFocusOut = (e)=>{
380        if ((0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === activeElement || isRefocusing) {
381            e.stopImmediatePropagation();
382            // If there was no focusable ancestor, we don't expect a focus event.
383            // Re-focus the original active element here.
384            if (!target && !isRefocusing) {
385                isRefocusing = true;
386                (0, $7215afc6de606d6b$export$de79e2c695e052f3)(activeElement);
387                cleanup();
388            }
389        }
390    };
391    let onFocus = (e)=>{
392        if ((0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === target || isRefocusing) e.stopImmediatePropagation();
393    };
394    let onFocusIn = (e)=>{
395        if ((0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === target || isRefocusing) {
396            e.stopImmediatePropagation();
397            if (!isRefocusing) {
398                isRefocusing = true;
399                (0, $7215afc6de606d6b$export$de79e2c695e052f3)(activeElement);
400                cleanup();
401            }
402        }
403    };
404    window1.addEventListener('blur', onBlur, true);
405    window1.addEventListener('focusout', onFocusOut, true);
406    window1.addEventListener('focusin', onFocusIn, true);
407    window1.addEventListener('focus', onFocus, true);
408    let cleanup = ()=>{
409        cancelAnimationFrame(raf);
410        window1.removeEventListener('blur', onBlur, true);
411        window1.removeEventListener('focusout', onFocusOut, true);
412        window1.removeEventListener('focusin', onFocusIn, true);
413        window1.removeEventListener('focus', onFocus, true);
414        $8a9cb279dc87e130$export$fda7da73ab5d4c48 = false;
415        isRefocusing = false;
416    };
417    let raf = requestAnimationFrame(cleanup);
418    return cleanup;
419}
420;
421// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/platform.mjs [app-client] (ecmascript)
422;
423var __TURBOPACK__imported__module__247167__1 = __TURBOPACK__imported__module__247167__;
424/*
425 * Copyright 2020 Adobe. All rights reserved.
426 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
427 * you may not use this file except in compliance with the License. You may obtain a copy
428 * of the License at http://www.apache.org/licenses/LICENSE-2.0
429 *
430 * Unless required by applicable law or agreed to in writing, software distributed under
431 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
432 * OF ANY KIND, either express or implied. See the License for the specific language
433 * governing permissions and limitations under the License.
434 */ function $c87311424ea30a05$var$testUserAgent(re) {
435    var _window_navigator_userAgentData;
436    if (typeof window === 'undefined' || window.navigator == null) return false;
437    let brands = (_window_navigator_userAgentData = window.navigator['userAgentData']) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.brands;
438    return Array.isArray(brands) && brands.some((brand)=>re.test(brand.brand)) || re.test(window.navigator.userAgent);
439}
440function $c87311424ea30a05$var$testPlatform(re) {
441    var _window_navigator_userAgentData;
442    return typeof window !== 'undefined' && window.navigator != null ? re.test(((_window_navigator_userAgentData = window.navigator['userAgentData']) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.platform) || window.navigator.platform) : false;

443}
444function $c87311424ea30a05$var$cached(fn) {
445    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
446    ;
447    let res = null;
448    return ()=>{
449        if (res == null) res = fn();
450        return res;
451    };
452}
453const $c87311424ea30a05$export$9ac100e40613ea10 = $c87311424ea30a05$var$cached(function() {
454    return $c87311424ea30a05$var$testPlatform(/^Mac/i);
455});
456const $c87311424ea30a05$export$186c6964ca17d99 = $c87311424ea30a05$var$cached(function() {
457    return $c87311424ea30a05$var$testPlatform(/^iPhone/i);
458});
459const $c87311424ea30a05$export$7bef049ce92e4224 = $c87311424ea30a05$var$cached(function() {
460    return $c87311424ea30a05$var$testPlatform(/^iPad/i) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
461    $c87311424ea30a05$export$9ac100e40613ea10() && navigator.maxTouchPoints > 1;
462});
463const $c87311424ea30a05$export$fedb369cb70207f1 = $c87311424ea30a05$var$cached(function() {
464    return $c87311424ea30a05$export$186c6964ca17d99() || $c87311424ea30a05$export$7bef049ce92e4224();
465});
466const $c87311424ea30a05$export$e1865c3bedcd822b = $c87311424ea30a05$var$cached(function() {
467    return $c87311424ea30a05$export$9ac100e40613ea10() || $c87311424ea30a05$export$fedb369cb70207f1();
468});
469const $c87311424ea30a05$export$78551043582a6a98 = $c87311424ea30a05$var$cached(function() {
470    return $c87311424ea30a05$var$testUserAgent(/AppleWebKit/i) && !$c87311424ea30a05$export$6446a186d09e379e();
471});
472const $c87311424ea30a05$export$6446a186d09e379e = $c87311424ea30a05$var$cached(function() {
473    return $c87311424ea30a05$var$testUserAgent(/Chrome/i);
474});
475const $c87311424ea30a05$export$a11b0059900ceec8 = $c87311424ea30a05$var$cached(function() {
476    return $c87311424ea30a05$var$testUserAgent(/Android/i);
477});
478const $c87311424ea30a05$export$b7d78993b74f766d = $c87311424ea30a05$var$cached(function() {
479    return $c87311424ea30a05$var$testUserAgent(/Firefox/i);
480});
481;
482// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/openLink.mjs [app-client] (ecmascript)
483;
484var __TURBOPACK__imported__module__247167__2 = __TURBOPACK__imported__module__247167__;
485var __TURBOPACK__imported__module__271645__2 = __TURBOPACK__imported__module__271645__;
486;
487;
488;
489/*
490 * Copyright 2023 Adobe. All rights reserved.
491 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
492 * you may not use this file except in compliance with the License. You may obtain a copy
493 * of the License at http://www.apache.org/licenses/LICENSE-2.0
494 *
495 * Unless required by applicable law or agreed to in writing, software distributed under
496 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
497 * OF ANY KIND, either express or implied. See the License for the specific language
498 * governing permissions and limitations under the License.
499 */ const $ea8dcbcb9ea1b556$var$RouterContext = /*#__PURE__*/ (0, __TURBOPACK__imported__module__271645__2["createContext"])({
500    isNative: true,
501    open: $ea8dcbcb9ea1b556$var$openSyntheticLink,
502    useHref: (href)=>href
503});
504function $ea8dcbcb9ea1b556$export$323e4fc2fa4753fb(props) {
505    let { children: children, navigate: navigate, useHref: useHref } = props;
506    let ctx = (0, __TURBOPACK__imported__module__271645__2["useMemo"])(()=>({
507            isNative: false,
508            open: (target, modifiers, href, routerOptions)=>{
509                $ea8dcbcb9ea1b556$var$getSyntheticLink(target, (link)=>{
510                    if ($ea8dcbcb9ea1b556$export$efa8c9099e530235(link, modifiers)) navigate(href, routerOptions);
511                    else $ea8dcbcb9ea1b556$export$95185d699e05d4d7(link, modifiers);
512                });
513            },
514            useHref: useHref || ((href)=>href)
515        }), [
516        navigate,
517        useHref
518    ]);
519    return /*#__PURE__*/ (0, __TURBOPACK__imported__module__271645__2["default"]).createElement($ea8dcbcb9ea1b556$var$RouterContext.Provider, {
520        value: ctx
521    }, children);
522}
523function $ea8dcbcb9ea1b556$export$9a302a45f65d0572() {
524    return (0, __TURBOPACK__imported__module__271645__2["useContext"])($ea8dcbcb9ea1b556$var$RouterContext);
525}
526function $ea8dcbcb9ea1b556$export$efa8c9099e530235(link, modifiers) {
527    // Use getAttribute here instead of link.target. Firefox will default link.target to "_parent" when inside an iframe.
528    let target = link.getAttribute('target');
529    return (!target || target === '_self') && link.origin === location.origin && !link.hasAttribute('download') && !modifiers.metaKey && // open in new tab (mac)
530    !modifiers.ctrlKey && // open in new tab (windows)
531    !modifiers.altKey && // download

532    !modifiers.shiftKey;
533}
534function $ea8dcbcb9ea1b556$export$95185d699e05d4d7(target, modifiers) {
535    let setOpening = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
536    var _window_event_type, _window_event;
537    let { metaKey: metaKey, ctrlKey: ctrlKey, altKey: altKey, shiftKey: shiftKey } = modifiers;
538    // Firefox does not recognize keyboard events as a user action by default, and the popup blocker
539    // will prevent links with target="_blank" from opening. However, it does allow the event if the
540    // Command/Control key is held, which opens the link in a background tab. This seems like the best we can do.
541    // See https://bugzilla.mozilla.org/show_bug.cgi?id=257870 and https://bugzilla.mozilla.org/show_bug.cgi?id=746640.
542    if ((0, $c87311424ea30a05$export$b7d78993b74f766d)() && ((_window_event = window.event) === null || _window_event === void 0 ? void 0 : (_window_event_type = _window_event.type) === null || _window_event_type === void 0 ? void 0 : _window_event_type.startsWith('key')) && target.target === '_blank') {
543        if ((0, $c87311424ea30a05$export$9ac100e40613ea10)()) metaKey = true;
544        else ctrlKey = true;
545    }
546    // WebKit does not support firing click events with modifier keys, but does support keyboard events.
547    // https://github.com/WebKit/WebKit/blob/c03d0ac6e6db178f90923a0a63080b5ca210d25f/Source/WebCore/html/HTMLAnchorElement.cpp#L184
548    let event = (0, $c87311424ea30a05$export$78551043582a6a98)() && (0, $c87311424ea30a05$export$9ac100e40613ea10)() && !(0, $c87311424ea30a05$export$7bef049ce92e4224)() && ("TURBOPACK compile-time value", "production") !== 'test' ? new KeyboardEvent('keydown', {
549        keyIdentifier: 'Enter',
550        metaKey: metaKey,
551        ctrlKey: ctrlKey,
552        altKey: altKey,
553        shiftKey: shiftKey
554    }) : new MouseEvent('click', {
555        metaKey: metaKey,
556        ctrlKey: ctrlKey,
557        altKey: altKey,
558        shiftKey: shiftKey,
559        detail: 1,
560        bubbles: true,
561        cancelable: true
562    });
563    $ea8dcbcb9ea1b556$export$95185d699e05d4d7.isOpening = setOpening;
564    (0, $7215afc6de606d6b$export$de79e2c695e052f3)(target);
565    target.dispatchEvent(event);
566    $ea8dcbcb9ea1b556$export$95185d699e05d4d7.isOpening = false;
567}
568// https://github.com/parcel-bundler/parcel/issues/8724
569$ea8dcbcb9ea1b556$export$95185d699e05d4d7.isOpening = false;
570function $ea8dcbcb9ea1b556$var$getSyntheticLink(target, open) {
571    if (target instanceof HTMLAnchorElement) open(target);
572    else if (target.hasAttribute('data-href')) {
573        let link = document.createElement('a');
574        link.href = target.getAttribute('data-href');
575        if (target.hasAttribute('data-target')) link.target = target.getAttribute('data-target');
576        if (target.hasAttribute('data-rel')) link.rel = target.getAttribute('data-rel');
577        if (target.hasAttribute('data-download')) link.download = target.getAttribute('data-download');
578        if (target.hasAttribute('data-ping')) link.ping = target.getAttribute('data-ping');
579        if (target.hasAttribute('data-referrer-policy')) link.referrerPolicy = target.getAttribute('data-referrer-policy');
580        target.appendChild(link);
581        open(link);
582        target.removeChild(link);
583    }
584}
585function $ea8dcbcb9ea1b556$var$openSyntheticLink(target, modifiers) {
586    $ea8dcbcb9ea1b556$var$getSyntheticLink(target, (link)=>$ea8dcbcb9ea1b556$export$95185d699e05d4d7(link, modifiers));
587}
588function $ea8dcbcb9ea1b556$export$bdc77b0c0a3a85d6(props) {
589    let router = $ea8dcbcb9ea1b556$export$9a302a45f65d0572();
590    var _props_href;
591    const href = router.useHref((_props_href = props.href) !== null && _props_href !== void 0 ? _props_href : '');
592    return {
593        'data-href': props.href ? href : undefined,
594        'data-target': props.target,
595        'data-rel': props.rel,
596        'data-download': props.download,
597        'data-ping': props.ping,
598        'data-referrer-policy': props.referrerPolicy
599    };
600}
601function $ea8dcbcb9ea1b556$export$51437d503373d223(props) {
602    return {
603        'data-href': props.href,
604        'data-target': props.target,
605        'data-rel': props.rel,
606        'data-download': props.download,
607        'data-ping': props.ping,
608        'data-referrer-policy': props.referrerPolicy
609    };
610}
611function $ea8dcbcb9ea1b556$export$7e924b3091a3bd18(props) {
612    let router = $ea8dcbcb9ea1b556$export$9a302a45f65d0572();
613    var _props_href;
614    const href = router.useHref((_props_href = props === null || props === void 0 ? void 0 : props.href) !== null && _props_href !== void 0 ? _props_href : '');
615    return {
616        href: (props === null || props === void 0 ? void 0 : props.href) ? href : undefined,
617        target: props === null || props === void 0 ? void 0 : props.target,
618        rel: props === null || props === void 0 ? void 0 : props.rel,
619        download: props === null || props === void 0 ? void 0 : props.download,
620        ping: props === null || props === void 0 ? void 0 : props.ping,
621        referrerPolicy: props === null || props === void 0 ? void 0 : props.referrerPolicy
622    };
623}
624function $ea8dcbcb9ea1b556$export$13aea1a3cb5e3f1f(e, router, href, routerOptions) {
625    // If a custom router is provided, prevent default and forward if this link should client navigate.
626    if (!router.isNative && e.currentTarget instanceof HTMLAnchorElement && e.currentTarget.href && // If props are applied to a router Link component, it may have already prevented default.
627    !e.isDefaultPrevented() && $ea8dcbcb9ea1b556$export$efa8c9099e530235(e.currentTarget, e) && href) {
628        e.preventDefault();
629        router.open(e.currentTarget, e, href, routerOptions);
630    }
631}
632;
633// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/isVirtualEvent.mjs [app-client] (ecmascript)
634;
635;
636/*
637 * Copyright 2022 Adobe. All rights reserved.
638 * This file is licensed to you under the Apache License, Version 2.0 (the "License");

639 * you may not use this file except in compliance with the License. You may obtain a copy
640 * of the License at http://www.apache.org/licenses/LICENSE-2.0
641 *
642 * Unless required by applicable law or agreed to in writing, software distributed under
643 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
644 * OF ANY KIND, either express or implied. See the License for the specific language
645 * governing permissions and limitations under the License.
646 */ function $6a7db85432448f7f$export$60278871457622de(event) {
647    // JAWS/NVDA with Firefox.
648    if (event.pointerType === '' && event.isTrusted) return true;
649    // Android TalkBack's detail value varies depending on the event listener providing the event so we have specific logic here instead
650    // If pointerType is defined, event is from a click listener. For events from mousedown listener, detail === 0 is a sufficient check
651    // to detect TalkBack virtual clicks.
652    if ((0, $c87311424ea30a05$export$a11b0059900ceec8)() && event.pointerType) return event.type === 'click' && event.buttons === 1;
653    return event.detail === 0 && !event.pointerType;
654}
655function $6a7db85432448f7f$export$29bf1b5f2c56cf63(event) {
656    // If the pointer size is zero, then we assume it's from a screen reader.
657    // Android TalkBack double tap will sometimes return a event with width and height of 1
658    // and pointerType === 'mouse' so we need to check for a specific combination of event attributes.
659    // Cannot use "event.pressure === 0" as the sole check due to Safari pointer events always returning pressure === 0
660    // instead of .5, see https://bugs.webkit.org/show_bug.cgi?id=206216. event.pointerType === 'mouse' is to distingush
661    // Talkback double tap from Windows Firefox touch screen press
662    return !(0, $c87311424ea30a05$export$a11b0059900ceec8)() && event.width === 0 && event.height === 0 || event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.pointerType === 'mouse';
663}
664;
665var __TURBOPACK__imported__module__271645__3 = __TURBOPACK__imported__module__271645__;
666// MERGED MODULE: [project]/node_modules/@react-aria/ssr/dist/SSRProvider.mjs [app-client] (ecmascript)
667;
668var __TURBOPACK__imported__module__247167__3 = __TURBOPACK__imported__module__247167__;
669var __TURBOPACK__imported__module__271645__4 = __TURBOPACK__imported__module__271645__;
670;
671/*
672 * Copyright 2020 Adobe. All rights reserved.
673 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
674 * you may not use this file except in compliance with the License. You may obtain a copy
675 * of the License at http://www.apache.org/licenses/LICENSE-2.0
676 *
677 * Unless required by applicable law or agreed to in writing, software distributed under
678 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
679 * OF ANY KIND, either express or implied. See the License for the specific language
680 * governing permissions and limitations under the License.
681 */ // We must avoid a circular dependency with @react-aria/utils, and this useLayoutEffect is
682// guarded by a check that it only runs on the client side.
683// eslint-disable-next-line rulesdir/useLayoutEffectRule
684// Default context value to use in case there is no SSRProvider. This is fine for
685// client-only apps. In order to support multiple copies of React Aria potentially
686// being on the page at once, the prefix is set to a random number. SSRProvider
687// will reset this to zero for consistency between server and client, so in the
688// SSR case multiple copies of React Aria is not supported.
689const $b5e257d569688ac6$var$defaultContext = {
690    prefix: String(Math.round(Math.random() * 10000000000)),
691    current: 0
692};
693const $b5e257d569688ac6$var$SSRContext = /*#__PURE__*/ (0, __TURBOPACK__imported__module__271645__4["default"]).createContext($b5e257d569688ac6$var$defaultContext);
694const $b5e257d569688ac6$var$IsSSRContext = /*#__PURE__*/ (0, __TURBOPACK__imported__module__271645__4["default"]).createContext(false);
695// This is only used in React < 18.

696function $b5e257d569688ac6$var$LegacySSRProvider(props) {
697    let cur = (0, __TURBOPACK__imported__module__271645__4["useContext"])($b5e257d569688ac6$var$SSRContext);
698    let counter = $b5e257d569688ac6$var$useCounter(cur === $b5e257d569688ac6$var$defaultContext);
699    let [isSSR, setIsSSR] = (0, __TURBOPACK__imported__module__271645__4["useState"])(true);
700    let value = (0, __TURBOPACK__imported__module__271645__4["useMemo"])(()=>({
701            // If this is the first SSRProvider, start with an empty string prefix, otherwise
702            // append and increment the counter.
703            prefix: cur === $b5e257d569688ac6$var$defaultContext ? '' : "".concat(cur.prefix, "-").concat(counter),
704            current: 0
705        }), [
706        cur,
707        counter
708    ]);
709    // If on the client, and the component was initially server rendered,
710    // then schedule a layout effect to update the component after hydration.
711    if (typeof document !== 'undefined') // because the condition never changes after mounting.
712    // eslint-disable-next-line react-hooks/rules-of-hooks
713    (0, __TURBOPACK__imported__module__271645__4["useLayoutEffect"])(()=>{
714        setIsSSR(false);
715    }, []);
716    return /*#__PURE__*/ (0, __TURBOPACK__imported__module__271645__4["default"]).createElement($b5e257d569688ac6$var$SSRContext.Provider, {
717        value: value
718    }, /*#__PURE__*/ (0, __TURBOPACK__imported__module__271645__4["default"]).createElement($b5e257d569688ac6$var$IsSSRContext.Provider, {
719        value: isSSR
720    }, props.children));
721}
722let $b5e257d569688ac6$var$warnedAboutSSRProvider = false;

723function $b5e257d569688ac6$export$9f8ac96af4b1b2ae(props) {
724    if (typeof (0, __TURBOPACK__imported__module__271645__4["default"])['useId'] === 'function') {
725        if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
726        ;
727        return /*#__PURE__*/ (0, __TURBOPACK__imported__module__271645__4["default"]).createElement((0, __TURBOPACK__imported__module__271645__4["default"]).Fragment, null, props.children);
728    }
729    return /*#__PURE__*/ (0, __TURBOPACK__imported__module__271645__4["default"]).createElement($b5e257d569688ac6$var$LegacySSRProvider, props);
730}
731let $b5e257d569688ac6$var$canUseDOM = Boolean(typeof window !== 'undefined' && window.document && window.document.createElement);
732let $b5e257d569688ac6$var$componentIds = new WeakMap();
733function $b5e257d569688ac6$var$useCounter() {
734    let isDisabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
735    let ctx = (0, __TURBOPACK__imported__module__271645__4["useContext"])($b5e257d569688ac6$var$SSRContext);
736    let ref = (0, __TURBOPACK__imported__module__271645__4["useRef"])(null);
737    // eslint-disable-next-line rulesdir/pure-render
738    if (ref.current === null && !isDisabled) {
739        var _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner, _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
740        // In strict mode, React renders components twice, and the ref will be reset to null on the second render.
741        // This means our id counter will be incremented twice instead of once. This is a problem because on the
742        // server, components are only rendered once and so ids generated on the server won't match the client.
743        // In React 18, useId was introduced to solve this, but it is not available in older versions. So to solve this
744        // we need to use some React internals to access the underlying Fiber instance, which is stable between renders.
745        // This is exposed as ReactCurrentOwner in development, which is all we need since StrictMode only runs in development.
746        // To ensure that we only increment the global counter once, we store the starting id for this component in
747        // a weak map associated with the Fiber. On the second render, we reset the global counter to this value.
748        // Since React runs the second render immediately after the first, this is safe.
749        // @ts-ignore
750        let currentOwner = (_React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = (0, __TURBOPACK__imported__module__271645__4["default"]).__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED === void 0 ? void 0 : (_React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner = _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner) === null || _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner === void 0 ? void 0 : _React___SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_ReactCurrentOwner.current;
751        if (currentOwner) {
752            let prevComponentValue = $b5e257d569688ac6$var$componentIds.get(currentOwner);
753            if (prevComponentValue == null) $b5e257d569688ac6$var$componentIds.set(currentOwner, {
754                id: ctx.current,
755                state: currentOwner.memoizedState
756            });
757            else if (currentOwner.memoizedState !== prevComponentValue.state) {
758                // On the second render, the memoizedState gets reset by React.
759                // Reset the counter, and remove from the weak map so we don't
760                // do this for subsequent useId calls.
761                ctx.current = prevComponentValue.id;
762                $b5e257d569688ac6$var$componentIds.delete(currentOwner);
763            }
764        }
765        // eslint-disable-next-line rulesdir/pure-render
766        ref.current = ++ctx.current;
767    }
768    // eslint-disable-next-line rulesdir/pure-render
769    return ref.current;
770}
771function $b5e257d569688ac6$var$useLegacySSRSafeId(defaultId) {

772    let ctx = (0, __TURBOPACK__imported__module__271645__4["useContext"])($b5e257d569688ac6$var$SSRContext);
773    // If we are rendering in a non-DOM environment, and there's no SSRProvider,
774    // provide a warning to hint to the developer to add one.
775    if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
776    ;
777    let counter = $b5e257d569688ac6$var$useCounter(!!defaultId);
778    let prefix = ("TURBOPACK compile-time falsy", 0) ? "TURBOPACK unreachable" : "react-aria".concat(ctx.prefix);
779    return defaultId || "".concat(prefix, "-").concat(counter);
780}
781function $b5e257d569688ac6$var$useModernSSRSafeId(defaultId) {
782    let id = (0, __TURBOPACK__imported__module__271645__4["default"]).useId();
783    let [didSSR] = (0, __TURBOPACK__imported__module__271645__4["useState"])($b5e257d569688ac6$export$535bd6ca7f90a273());
784    let prefix = didSSR || ("TURBOPACK compile-time value", "production") === 'test' ? 'react-aria' : "react-aria".concat($b5e257d569688ac6$var$defaultContext.prefix);
785    return defaultId || "".concat(prefix, "-").concat(id);
786}
787const $b5e257d569688ac6$export$619500959fc48b26 = typeof (0, __TURBOPACK__imported__module__271645__4["default"])['useId'] === 'function' ? $b5e257d569688ac6$var$useModernSSRSafeId : $b5e257d569688ac6$var$useLegacySSRSafeId;
788function $b5e257d569688ac6$var$getSnapshot() {
789    return false;
790}
791function $b5e257d569688ac6$var$getServerSnapshot() {
792    return true;
793}
794// eslint-disable-next-line @typescript-eslint/no-unused-vars
795function $b5e257d569688ac6$var$subscribe(onStoreChange) {
796    // noop
797    return ()=>{};
798}
799function $b5e257d569688ac6$export$535bd6ca7f90a273() {
800    // In React 18, we can use useSyncExternalStore to detect if we're server rendering or hydrating.
801    if (typeof (0, __TURBOPACK__imported__module__271645__4["default"])['useSyncExternalStore'] === 'function') return (0, __TURBOPACK__imported__module__271645__4["default"])['useSyncExternalStore']($b5e257d569688ac6$var$subscribe, $b5e257d569688ac6$var$getSnapshot, $b5e257d569688ac6$var$getServerSnapshot);
802    // eslint-disable-next-line react-hooks/rules-of-hooks
803    return (0, __TURBOPACK__imported__module__271645__4["useContext"])($b5e257d569688ac6$var$IsSSRContext);
804}
805;
806;
807;
808;
809;
810/*
811 * Copyright 2020 Adobe. All rights reserved.
812 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
813 * you may not use this file except in compliance with the License. You may obtain a copy
814 * of the License at http://www.apache.org/licenses/LICENSE-2.0
815 *
816 * Unless required by applicable law or agreed to in writing, software distributed under
817 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
818 * OF ANY KIND, either express or implied. See the License for the specific language
819 * governing permissions and limitations under the License.
820 */ // Portions of the code in this file are based on code from react.
821// Original licensing for the following can be found in the
822// NOTICE file in the root directory of this source tree.
823// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions
824let $507fabe10e71c6fb$var$currentModality = null;
825let $507fabe10e71c6fb$var$currentPointerType = 'keyboard';
826const $507fabe10e71c6fb$export$901e90a13c50a14e = new Set();
827let $507fabe10e71c6fb$export$d90243b58daecda7 = new Map(); // We use a map here to support setting event listeners across multiple document objects.
828let $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
829let $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;
830// Only Tab or Esc keys will make focus visible on text input elements
831const $507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS = {
832    Tab: true,
833    Escape: true
834};
835function $507fabe10e71c6fb$var$triggerChangeHandlers(modality, e) {
836    for (let handler of $507fabe10e71c6fb$export$901e90a13c50a14e)handler(modality, e);
837}
838/**
839 * Helper function to determine if a KeyboardEvent is unmodified and could make keyboard focus styles visible.
840 */ function $507fabe10e71c6fb$var$isValidKey(e) {
841    // Control and Shift keys trigger when navigating back to the tab with keyboard.
842    return !(e.metaKey || !(0, $c87311424ea30a05$export$9ac100e40613ea10)() && e.altKey || e.ctrlKey || e.key === 'Control' || e.key === 'Shift' || e.key === 'Meta');
843}
844function $507fabe10e71c6fb$var$handleKeyboardEvent(e) {
845    $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
846    if (!(0, $ea8dcbcb9ea1b556$export$95185d699e05d4d7).isOpening && $507fabe10e71c6fb$var$isValidKey(e)) {
847        $507fabe10e71c6fb$var$currentModality = 'keyboard';
848        $507fabe10e71c6fb$var$currentPointerType = 'keyboard';
849        $507fabe10e71c6fb$var$triggerChangeHandlers('keyboard', e);
850    }
851}
852function $507fabe10e71c6fb$var$handlePointerEvent(e) {
853    $507fabe10e71c6fb$var$currentModality = 'pointer';
854    $507fabe10e71c6fb$var$currentPointerType = 'pointerType' in e ? e.pointerType : 'mouse';
855    if (e.type === 'mousedown' || e.type === 'pointerdown') {
856        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
857        $507fabe10e71c6fb$var$triggerChangeHandlers('pointer', e);
858    }
859}
860function $507fabe10e71c6fb$var$handleClickEvent(e) {
861    if (!(0, $ea8dcbcb9ea1b556$export$95185d699e05d4d7).isOpening && (0, $6a7db85432448f7f$export$60278871457622de)(e)) {
862        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
863        $507fabe10e71c6fb$var$currentModality = 'virtual';
864        $507fabe10e71c6fb$var$currentPointerType = 'virtual';
865    }
866}
867function $507fabe10e71c6fb$var$handleFocusEvent(e) {
868    // Firefox fires two extra focus events when the user first clicks into an iframe:
869    // first on the window, then on the document. We ignore these events so they don't
870    // cause keyboard focus rings to appear.
871    if ((0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === window || (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === document || (0, $8a9cb279dc87e130$export$fda7da73ab5d4c48) || !e.isTrusted) return;
872    // If a focus event occurs without a preceding keyboard or pointer event, switch to virtual modality.
873    // This occurs, for example, when navigating a form with the next/previous buttons on iOS.
874    if (!$507fabe10e71c6fb$var$hasEventBeforeFocus && !$507fabe10e71c6fb$var$hasBlurredWindowRecently) {
875        $507fabe10e71c6fb$var$currentModality = 'virtual';
876        $507fabe10e71c6fb$var$currentPointerType = 'virtual';
877        $507fabe10e71c6fb$var$triggerChangeHandlers('virtual', e);
878    }
879    $507fabe10e71c6fb$var$hasEventBeforeFocus = false;

880    $507fabe10e71c6fb$var$hasBlurredWindowRecently = false;
881}
882function $507fabe10e71c6fb$var$handleWindowBlur() {
883    if (0, $8a9cb279dc87e130$export$fda7da73ab5d4c48) return;
884    // When the window is blurred, reset state. This is necessary when tabbing out of the window,
885    // for example, since a subsequent focus event won't be fired.
886    $507fabe10e71c6fb$var$hasEventBeforeFocus = false;
887    $507fabe10e71c6fb$var$hasBlurredWindowRecently = true;
888}
889/**
890 * Setup global event listeners to control when keyboard focus style should be visible.
891 */ function $507fabe10e71c6fb$var$setupGlobalFocusEvents(element) {
892    if (typeof window === 'undefined' || typeof document === 'undefined' || $507fabe10e71c6fb$export$d90243b58daecda7.get((0, $431fbd86ca7dc216$export$f21a1ffae260145a)(element))) return;
893    const windowObject = (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(element);
894    const documentObject = (0, $431fbd86ca7dc216$export$b204af158042fbac)(element);
895    // Programmatic focus() calls shouldn't affect the current input modality.
896    // However, we need to detect other cases when a focus event occurs without
897    // a preceding user event (e.g. screen reader focus). Overriding the focus
898    // method on HTMLElement.prototype is a bit hacky, but works.
899    let focus = windowObject.HTMLElement.prototype.focus;
900    windowObject.HTMLElement.prototype.focus = function() {
901        $507fabe10e71c6fb$var$hasEventBeforeFocus = true;
902        focus.apply(this, arguments);
903    };
904    documentObject.addEventListener('keydown', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
905    documentObject.addEventListener('keyup', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
906    documentObject.addEventListener('click', $507fabe10e71c6fb$var$handleClickEvent, true);
907    // Register focus events on the window so they are sure to happen
908    // before React's event listeners (registered on the document).
909    windowObject.addEventListener('focus', $507fabe10e71c6fb$var$handleFocusEvent, true);
910    windowObject.addEventListener('blur', $507fabe10e71c6fb$var$handleWindowBlur, false);
911    if (typeof PointerEvent !== 'undefined') {
912        documentObject.addEventListener('pointerdown', $507fabe10e71c6fb$var$handlePointerEvent, true);
913        documentObject.addEventListener('pointermove', $507fabe10e71c6fb$var$handlePointerEvent, true);
914        documentObject.addEventListener('pointerup', $507fabe10e71c6fb$var$handlePointerEvent, true);
915    } else if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
916    ;
917    // Add unmount handler
918    windowObject.addEventListener('beforeunload', ()=>{
919        $507fabe10e71c6fb$var$tearDownWindowFocusTracking(element);
920    }, {
921        once: true
922    });
923    $507fabe10e71c6fb$export$d90243b58daecda7.set(windowObject, {
924        focus: focus
925    });
926}
927const $507fabe10e71c6fb$var$tearDownWindowFocusTracking = (element, loadListener)=>{
928    const windowObject = (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(element);
929    const documentObject = (0, $431fbd86ca7dc216$export$b204af158042fbac)(element);
930    if (loadListener) documentObject.removeEventListener('DOMContentLoaded', loadListener);
931    if (!$507fabe10e71c6fb$export$d90243b58daecda7.has(windowObject)) return;
932    windowObject.HTMLElement.prototype.focus = $507fabe10e71c6fb$export$d90243b58daecda7.get(windowObject).focus;
933    documentObject.removeEventListener('keydown', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
934    documentObject.removeEventListener('keyup', $507fabe10e71c6fb$var$handleKeyboardEvent, true);
935    documentObject.removeEventListener('click', $507fabe10e71c6fb$var$handleClickEvent, true);
936    windowObject.removeEventListener('focus', $507fabe10e71c6fb$var$handleFocusEvent, true);
937    windowObject.removeEventListener('blur', $507fabe10e71c6fb$var$handleWindowBlur, false);
938    if (typeof PointerEvent !== 'undefined') {
939        documentObject.removeEventListener('pointerdown', $507fabe10e71c6fb$var$handlePointerEvent, true);
940        documentObject.removeEventListener('pointermove', $507fabe10e71c6fb$var$handlePointerEvent, true);
941        documentObject.removeEventListener('pointerup', $507fabe10e71c6fb$var$handlePointerEvent, true);
942    } else if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
943    ;
944    $507fabe10e71c6fb$export$d90243b58daecda7.delete(windowObject);
945};
946function $507fabe10e71c6fb$export$2f1888112f558a7d(element) {
947    const documentObject = (0, $431fbd86ca7dc216$export$b204af158042fbac)(element);
948    let loadListener;
949    if (documentObject.readyState !== 'loading') $507fabe10e71c6fb$var$setupGlobalFocusEvents(element);
950    else {
951        loadListener = ()=>{
952            $507fabe10e71c6fb$var$setupGlobalFocusEvents(element);
953        };
954        documentObject.addEventListener('DOMContentLoaded', loadListener);
955    }
956    return ()=>$507fabe10e71c6fb$var$tearDownWindowFocusTracking(element, loadListener);
957}
958// Server-side rendering does not have the document object defined
959// eslint-disable-next-line no-restricted-globals
960if (typeof document !== 'undefined') $507fabe10e71c6fb$export$2f1888112f558a7d();
961function $507fabe10e71c6fb$export$b9b3dfddab17db27() {
962    return $507fabe10e71c6fb$var$currentModality !== 'pointer';
963}
964function $507fabe10e71c6fb$export$630ff653c5ada6a9() {
965    return $507fabe10e71c6fb$var$currentModality;
966}
967function $507fabe10e71c6fb$export$8397ddfc504fdb9a(modality) {
968    $507fabe10e71c6fb$var$currentModality = modality;
969    $507fabe10e71c6fb$var$currentPointerType = modality === 'pointer' ? 'mouse' : modality;
970    $507fabe10e71c6fb$var$triggerChangeHandlers(modality, null);
971}
972function $507fabe10e71c6fb$export$887a228355cf7d95() {
973    return $507fabe10e71c6fb$var$currentPointerType;
974}
975function $507fabe10e71c6fb$export$98e20ec92f614cfe() {
976    $507fabe10e71c6fb$var$setupGlobalFocusEvents();
977    let [modality, setModality] = (0, __TURBOPACK__imported__module__271645__3["useState"])($507fabe10e71c6fb$var$currentModality);
978    (0, __TURBOPACK__imported__module__271645__3["useEffect"])(()=>{
979        let handler = ()=>{
980            setModality($507fabe10e71c6fb$var$currentModality);
981        };
982        $507fabe10e71c6fb$export$901e90a13c50a14e.add(handler);
983        return ()=>{
984            $507fabe10e71c6fb$export$901e90a13c50a14e.delete(handler);
985        };
986    }, []);
987    return (0, $b5e257d569688ac6$export$535bd6ca7f90a273)() ? null : modality;
988}
989const $507fabe10e71c6fb$var$nonTextInputTypes = new Set([
990    'checkbox',
991    'radio',
992    'range',
993    'color',
994    'file',
995    'image',
996    'button',
997    'submit',
998    'reset'
999]);
1000/**
1001 * If this is attached to text input component, return if the event is a focus event (Tab/Escape keys pressed) so that
1002 * focus visible style can be properly set.
1003 */ function $507fabe10e71c6fb$var$isKeyboardFocusEvent(isTextInput, modality, e) {
1004    let document1 = (0, $431fbd86ca7dc216$export$b204af158042fbac)(e ? (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) : undefined);
1005    let eventTarget = e ? (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) : undefined;
1006    const IHTMLInputElement = typeof window !== 'undefined' ? (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(eventTarget).HTMLInputElement : HTMLInputElement;
1007    const IHTMLTextAreaElement = typeof window !== 'undefined' ? (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(eventTarget).HTMLTextAreaElement : HTMLTextAreaElement;
1008    const IHTMLElement = typeof window !== 'undefined' ? (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(eventTarget).HTMLElement : HTMLElement;
1009    const IKeyboardEvent = typeof window !== 'undefined' ? (0, $431fbd86ca7dc216$export$f21a1ffae260145a)(eventTarget).KeyboardEvent : KeyboardEvent;
1010    // For keyboard events that occur on a non-input element that will move focus into input element (aka ArrowLeft going from Datepicker button to the main input group)
1011    // we need to rely on the user passing isTextInput into here. This way we can skip toggling focus visiblity for said input element
1012    let activeElement = (0, $d4ee10de306f2510$export$cd4e5573fbe2b576)(document1);
1013    isTextInput = isTextInput || activeElement instanceof IHTMLInputElement && !$507fabe10e71c6fb$var$nonTextInputTypes.has(activeElement.type) || activeElement instanceof IHTMLTextAreaElement || activeElement instanceof IHTMLElement && activeElement.isContentEditable;
1014    return !(isTextInput && modality === 'keyboard' && e instanceof IKeyboardEvent && !$507fabe10e71c6fb$var$FOCUS_VISIBLE_INPUT_KEYS[e.key]);
1015}
1016function $507fabe10e71c6fb$export$ffd9e5021c1fb2d6() {
1017    let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};

1018    let { isTextInput: isTextInput, autoFocus: autoFocus } = props;
1019    let [isFocusVisibleState, setFocusVisible] = (0, __TURBOPACK__imported__module__271645__3["useState"])(autoFocus || $507fabe10e71c6fb$export$b9b3dfddab17db27());
1020    $507fabe10e71c6fb$export$ec71b4b83ac08ec3((isFocusVisible)=>{
1021        setFocusVisible(isFocusVisible);
1022    }, [
1023        isTextInput
1024    ], {
1025        isTextInput: isTextInput
1026    });
1027    return {
1028        isFocusVisible: isFocusVisibleState
1029    };
1030}
1031function $507fabe10e71c6fb$export$ec71b4b83ac08ec3(fn, deps, opts) {
1032    $507fabe10e71c6fb$var$setupGlobalFocusEvents();
1033    (0, __TURBOPACK__imported__module__271645__3["useEffect"])(()=>{
1034        if ((opts === null || opts === void 0 ? void 0 : opts.enabled) === false) return;
1035        let handler = (modality, e)=>{
1036            // We want to early return for any keyboard events that occur inside text inputs EXCEPT for Tab and Escape
1037            if (!$507fabe10e71c6fb$var$isKeyboardFocusEvent(!!(opts === null || opts === void 0 ? void 0 : opts.isTextInput), modality, e)) return;
1038            fn($507fabe10e71c6fb$export$b9b3dfddab17db27());
1039        };
1040        $507fabe10e71c6fb$export$901e90a13c50a14e.add(handler);
1041        return ()=>{
1042            $507fabe10e71c6fb$export$901e90a13c50a14e.delete(handler);
1043        };
1044    // eslint-disable-next-line react-hooks/exhaustive-deps
1045    }, deps);
1046}
1047;
1048// MERGED MODULE: [project]/node_modules/@react-aria/interactions/dist/useFocus.mjs [app-client] (ecmascript)
1049;
1050var __TURBOPACK__imported__module__271645__5 = __TURBOPACK__imported__module__271645__;
1051;
1052;
1053;
1054/*
1055 * Copyright 2020 Adobe. All rights reserved.
1056 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
1057 * you may not use this file except in compliance with the License. You may obtain a copy
1058 * of the License at http://www.apache.org/licenses/LICENSE-2.0
1059 *
1060 * Unless required by applicable law or agreed to in writing, software distributed under
1061 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
1062 * OF ANY KIND, either express or implied. See the License for the specific language
1063 * governing permissions and limitations under the License.
1064 */ // Portions of the code in this file are based on code from react.
1065// Original licensing for the following can be found in the
1066// NOTICE file in the root directory of this source tree.
1067// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions
1068function $a1ea59d68270f0dd$export$f8168d8dd8fd66e6(props) {
1069    let { isDisabled: isDisabled, onFocus: onFocusProp, onBlur: onBlurProp, onFocusChange: onFocusChange } = props;
1070    const onBlur = (0, __TURBOPACK__imported__module__271645__5["useCallback"])((e)=>{
1071        if ((0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e) === e.currentTarget) {
1072            if (onBlurProp) onBlurProp(e);
1073            if (onFocusChange) onFocusChange(false);
1074            return true;
1075        }
1076    }, [
1077        onBlurProp,
1078        onFocusChange
1079    ]);
1080    const onSyntheticFocus = (0, $8a9cb279dc87e130$export$715c682d09d639cc)(onBlur);
1081    const onFocus = (0, __TURBOPACK__imported__module__271645__5["useCallback"])((e)=>{
1082        // Double check that document.activeElement actually matches e.target in case a previously chained
1083        // focus handler already moved focus somewhere else.
1084        let eventTarget = (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
1085        const ownerDocument = (0, $431fbd86ca7dc216$export$b204af158042fbac)(eventTarget);
1086        const activeElement = ownerDocument ? (0, $d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument) : (0, $d4ee10de306f2510$export$cd4e5573fbe2b576)();
1087        if (eventTarget === e.currentTarget && eventTarget === activeElement) {
1088            if (onFocusProp) onFocusProp(e);
1089            if (onFocusChange) onFocusChange(true);
1090            onSyntheticFocus(e);
1091        }
1092    }, [
1093        onFocusChange,
1094        onFocusProp,
1095        onSyntheticFocus
1096    ]);
1097    return {
1098        focusProps: {
1099            onFocus: !isDisabled && (onFocusProp || onFocusChange || onBlurProp) ? onFocus : undefined,
1100            onBlur: !isDisabled && (onBlurProp || onFocusChange) ? onBlur : undefined
1101        }
1102    };
1103}
1104;
1105// MERGED MODULE: [project]/node_modules/@react-aria/interactions/dist/useFocusWithin.mjs [app-client] (ecmascript)
1106;
1107var __TURBOPACK__imported__module__271645__6 = __TURBOPACK__imported__module__271645__;
1108// MERGED MODULE: [project]/node_modules/@react-aria/utils/dist/useGlobalListeners.mjs [app-client] (ecmascript)
1109;
1110var __TURBOPACK__imported__module__271645__7 = __TURBOPACK__imported__module__271645__;
1111;
1112/*
1113 * Copyright 2020 Adobe. All rights reserved.
1114 * This file is licensed to you under the Apache License, Version 2.0 (the "License");

1115 * you may not use this file except in compliance with the License. You may obtain a copy
1116 * of the License at http://www.apache.org/licenses/LICENSE-2.0
1117 *
1118 * Unless required by applicable law or agreed to in writing, software distributed under
1119 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
1120 * OF ANY KIND, either express or implied. See the License for the specific language
1121 * governing permissions and limitations under the License.
1122 */ function $03deb23ff14920c4$export$4eaf04e54aa8eed6() {
1123    let globalListeners = (0, __TURBOPACK__imported__module__271645__7["useRef"])(new Map());
1124    let addGlobalListener = (0, __TURBOPACK__imported__module__271645__7["useCallback"])((eventTarget, type, listener, options)=>{
1125        // Make sure we remove the listener after it is called with the `once` option.
1126        let fn = (options === null || options === void 0 ? void 0 : options.once) ? function() {
1127            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
1128                args[_key] = arguments[_key];
1129            }
1130            globalListeners.current.delete(listener);
1131            listener(...args);
1132        } : listener;
1133        globalListeners.current.set(listener, {
1134            type: type,
1135            eventTarget: eventTarget,
1136            fn: fn,
1137            options: options
1138        });
1139        eventTarget.addEventListener(type, fn, options);
1140    }, []);
1141    let removeGlobalListener = (0, __TURBOPACK__imported__module__271645__7["useCallback"])((eventTarget, type, listener, options)=>{
1142        var _globalListeners_current_get;
1143        let fn = ((_globalListeners_current_get = globalListeners.current.get(listener)) === null || _globalListeners_current_get === void 0 ? void 0 : _globalListeners_current_get.fn) || listener;
1144        eventTarget.removeEventListener(type, fn, options);
1145        globalListeners.current.delete(listener);
1146    }, []);
1147    let removeAllGlobalListeners = (0, __TURBOPACK__imported__module__271645__7["useCallback"])(()=>{
1148        globalListeners.current.forEach((value, key)=>{
1149            removeGlobalListener(value.eventTarget, value.type, key, value.options);
1150        });
1151    }, [
1152        removeGlobalListener
1153    ]);
1154    (0, __TURBOPACK__imported__module__271645__7["useEffect"])(()=>{
1155        return removeAllGlobalListeners;
1156    }, [
1157        removeAllGlobalListeners
1158    ]);
1159    return {
1160        addGlobalListener: addGlobalListener,
1161        removeGlobalListener: removeGlobalListener,
1162        removeAllGlobalListeners: removeAllGlobalListeners
1163    };
1164}
1165;
1166;
1167;
1168;
1169/*
1170 * Copyright 2020 Adobe. All rights reserved.
1171 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
1172 * you may not use this file except in compliance with the License. You may obtain a copy
1173 * of the License at http://www.apache.org/licenses/LICENSE-2.0
1174 *
1175 * Unless required by applicable law or agreed to in writing, software distributed under
1176 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
1177 * OF ANY KIND, either express or implied. See the License for the specific language
1178 * governing permissions and limitations under the License.
1179 */ // Portions of the code in this file are based on code from react.
1180// Original licensing for the following can be found in the
1181// NOTICE file in the root directory of this source tree.
1182// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions
1183function $9ab94262bd0047c7$export$420e68273165f4ec(props) {
1184    let { isDisabled: isDisabled, onBlurWithin: onBlurWithin, onFocusWithin: onFocusWithin, onFocusWithinChange: onFocusWithinChange } = props;
1185    let state = (0, __TURBOPACK__imported__module__271645__6["useRef"])({
1186        isFocusWithin: false
1187    });
1188    let { addGlobalListener: addGlobalListener, removeAllGlobalListeners: removeAllGlobalListeners } = (0, $03deb23ff14920c4$export$4eaf04e54aa8eed6)();
1189    let onBlur = (0, __TURBOPACK__imported__module__271645__6["useCallback"])((e)=>{
1190        // Ignore events bubbling through portals.
1191        if (!(0, $d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) return;
1192        // We don't want to trigger onBlurWithin and then immediately onFocusWithin again
1193        // when moving focus inside the element. Only trigger if the currentTarget doesn't
1194        // include the relatedTarget (where focus is moving).
1195        if (state.current.isFocusWithin && !(0, $d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, e.relatedTarget)) {
1196            state.current.isFocusWithin = false;

1197            removeAllGlobalListeners();
1198            if (onBlurWithin) onBlurWithin(e);
1199            if (onFocusWithinChange) onFocusWithinChange(false);
1200        }
1201    }, [
1202        onBlurWithin,
1203        onFocusWithinChange,
1204        state,
1205        removeAllGlobalListeners
1206    ]);
1207    let onSyntheticFocus = (0, $8a9cb279dc87e130$export$715c682d09d639cc)(onBlur);
1208    let onFocus = (0, __TURBOPACK__imported__module__271645__6["useCallback"])((e)=>{
1209        // Ignore events bubbling through portals.
1210        if (!(0, $d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) return;
1211        // Double check that document.activeElement actually matches e.target in case a previously chained
1212        // focus handler already moved focus somewhere else.
1213        let eventTarget = (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
1214        const ownerDocument = (0, $431fbd86ca7dc216$export$b204af158042fbac)(eventTarget);
1215        const activeElement = (0, $d4ee10de306f2510$export$cd4e5573fbe2b576)(ownerDocument);
1216        if (!state.current.isFocusWithin && activeElement === eventTarget) {
1217            if (onFocusWithin) onFocusWithin(e);
1218            if (onFocusWithinChange) onFocusWithinChange(true);
1219            state.current.isFocusWithin = true;
1220            onSyntheticFocus(e);
1221            // Browsers don't fire blur events when elements are removed from the DOM.
1222            // However, if a focus event occurs outside the element we're tracking, we
1223            // can manually fire onBlur.
1224            let currentTarget = e.currentTarget;
1225            addGlobalListener(ownerDocument, 'focus', (e)=>{
1226                let eventTarget = (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e);
1227                if (state.current.isFocusWithin && !(0, $d4ee10de306f2510$export$4282f70798064fe0)(currentTarget, eventTarget)) {
1228                    let nativeEvent = new ownerDocument.defaultView.FocusEvent('blur', {
1229                        relatedTarget: eventTarget
1230                    });
1231                    (0, $8a9cb279dc87e130$export$c2b7abe5d61ec696)(nativeEvent, currentTarget);
1232                    let event = (0, $8a9cb279dc87e130$export$525bc4921d56d4a)(nativeEvent);
1233                    onBlur(event);
1234                }
1235            }, {
1236                capture: true
1237            });
1238        }
1239    }, [
1240        onFocusWithin,
1241        onFocusWithinChange,
1242        onSyntheticFocus,
1243        addGlobalListener,
1244        onBlur
1245    ]);
1246    if (isDisabled) return {
1247        focusWithinProps: {
1248            // These cannot be null, that would conflict in mergeProps
1249            onFocus: undefined,
1250            onBlur: undefined
1251        }
1252    };
1253    return {
1254        focusWithinProps: {
1255            onFocus: onFocus,
1256            onBlur: onBlur
1257        }
1258    };
1259}
1260;
1261var __TURBOPACK__imported__module__271645__8 = __TURBOPACK__imported__module__271645__;
1262;
1263;
1264function $f7dceffc5ad7768b$export$4e328f61c538687f() {
1265    let props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
1266    let { autoFocus: autoFocus = false, isTextInput: isTextInput, within: within } = props;
1267    let state = (0, __TURBOPACK__imported__module__271645__8["useRef"])({
1268        isFocused: false,
1269        isFocusVisible: autoFocus || (0, $507fabe10e71c6fb$export$b9b3dfddab17db27)()
1270    });
1271    let [isFocused, setFocused] = (0, __TURBOPACK__imported__module__271645__8["useState"])(false);
1272    let [isFocusVisibleState, setFocusVisible] = (0, __TURBOPACK__imported__module__271645__8["useState"])(()=>state.current.isFocused && state.current.isFocusVisible);
1273    let updateState = (0, __TURBOPACK__imported__module__271645__8["useCallback"])(()=>setFocusVisible(state.current.isFocused && state.current.isFocusVisible), []);
1274    let onFocusChange = (0, __TURBOPACK__imported__module__271645__8["useCallback"])((isFocused)=>{
1275        state.current.isFocused = isFocused;
1276        state.current.isFocusVisible = (0, $507fabe10e71c6fb$export$b9b3dfddab17db27)();
1277        setFocused(isFocused);
1278        updateState();
1279    }, [
1280        updateState
1281    ]);
1282    (0, $507fabe10e71c6fb$export$ec71b4b83ac08ec3)((isFocusVisible1)=>{
1283        state.current.isFocusVisible = isFocusVisible1;
1284        updateState();
1285    }, [
1286        isTextInput,
1287        isFocused
1288    ], {
1289        enabled: isFocused,
1290        isTextInput: isTextInput
1291    });
1292    let { focusProps: focusProps } = (0, $a1ea59d68270f0dd$export$f8168d8dd8fd66e6)({
1293        isDisabled: within,
1294        onFocusChange: onFocusChange
1295    });
1296    let { focusWithinProps: focusWithinProps } = (0, $9ab94262bd0047c7$export$420e68273165f4ec)({
1297        isDisabled: !within,
1298        onFocusWithinChange: onFocusChange
1299    });
1300    return {
1301        isFocused: isFocused,
1302        isFocusVisible: isFocusVisibleState,
1303        focusProps: within ? focusWithinProps : focusProps
1304    };
1305}
1306;
1307__turbopack_context__.s([
1308    "useFocusRing",
1309    0,
1310    $f7dceffc5ad7768b$export$4e328f61c538687f
1311], 429427);
1312// MERGED MODULE: [project]/node_modules/@react-aria/interactions/dist/useHover.mjs [app-client] (ecmascript)
1313;
1314var __TURBOPACK__imported__module__247167__4 = __TURBOPACK__imported__module__247167__;
1315var __TURBOPACK__imported__module__271645__9 = __TURBOPACK__imported__module__271645__;
1316;
1317;
1318/*
1319 * Copyright 2020 Adobe. All rights reserved.
1320 * This file is licensed to you under the Apache License, Version 2.0 (the "License");

1321 * you may not use this file except in compliance with the License. You may obtain a copy
1322 * of the License at http://www.apache.org/licenses/LICENSE-2.0
1323 *
1324 * Unless required by applicable law or agreed to in writing, software distributed under
1325 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
1326 * OF ANY KIND, either express or implied. See the License for the specific language
1327 * governing permissions and limitations under the License.
1328 */ // Portions of the code in this file are based on code from react.
1329// Original licensing for the following can be found in the
1330// NOTICE file in the root directory of this source tree.
1331// See https://github.com/facebook/react/tree/cc7c1aece46a6b69b41958d731e0fd27c94bfc6c/packages/react-interactions
1332// iOS fires onPointerEnter twice: once with pointerType="touch" and again with pointerType="mouse".
1333// We want to ignore these emulated events so they do not trigger hover behavior.
1334// See https://bugs.webkit.org/show_bug.cgi?id=214609.
1335let $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;
1336let $6179b936705e76d3$var$hoverCount = 0;
1337function $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents() {
1338    $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = true;
1339    // Clear globalIgnoreEmulatedMouseEvents after a short timeout. iOS fires onPointerEnter
1340    // with pointerType="mouse" immediately after onPointerUp and before onFocus. On other
1341    // devices that don't have this quirk, we don't want to ignore a mouse hover sometime in
1342    // the distant future because a user previously touched the element.
1343    setTimeout(()=>{
1344        $6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents = false;
1345    }, 50);
1346}
1347function $6179b936705e76d3$var$handleGlobalPointerEvent(e) {
1348    if (e.pointerType === 'touch') $6179b936705e76d3$var$setGlobalIgnoreEmulatedMouseEvents();
1349}
1350function $6179b936705e76d3$var$setupGlobalTouchEvents() {
1351    if (typeof document === 'undefined') return;
1352    if ($6179b936705e76d3$var$hoverCount === 0) {
1353        if (typeof PointerEvent !== 'undefined') document.addEventListener('pointerup', $6179b936705e76d3$var$handleGlobalPointerEvent);
1354        else if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
1355        ;
1356    }
1357    $6179b936705e76d3$var$hoverCount++;
1358    return ()=>{
1359        $6179b936705e76d3$var$hoverCount--;
1360        if ($6179b936705e76d3$var$hoverCount > 0) return;
1361        if (typeof PointerEvent !== 'undefined') document.removeEventListener('pointerup', $6179b936705e76d3$var$handleGlobalPointerEvent);
1362        else if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
1363        ;
1364    };
1365}
1366function $6179b936705e76d3$export$ae780daf29e6d456(props) {
1367    let { onHoverStart: onHoverStart, onHoverChange: onHoverChange, onHoverEnd: onHoverEnd, isDisabled: isDisabled } = props;
1368    let [isHovered, setHovered] = (0, __TURBOPACK__imported__module__271645__9["useState"])(false);
1369    let state = (0, __TURBOPACK__imported__module__271645__9["useRef"])({
1370        isHovered: false,
1371        ignoreEmulatedMouseEvents: false,
1372        pointerType: '',
1373        target: null
1374    }).current;
1375    (0, __TURBOPACK__imported__module__271645__9["useEffect"])($6179b936705e76d3$var$setupGlobalTouchEvents, []);
1376    let { addGlobalListener: addGlobalListener, removeAllGlobalListeners: removeAllGlobalListeners } = (0, $03deb23ff14920c4$export$4eaf04e54aa8eed6)();
1377    let { hoverProps: hoverProps, triggerHoverEnd: triggerHoverEnd } = (0, __TURBOPACK__imported__module__271645__9["useMemo"])(()=>{
1378        let triggerHoverStart = (event, pointerType)=>{
1379            state.pointerType = pointerType;
1380            if (isDisabled || pointerType === 'touch' || state.isHovered || !(0, $d4ee10de306f2510$export$4282f70798064fe0)(event.currentTarget, (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(event))) return;
1381            state.isHovered = true;
1382            let target = event.currentTarget;
1383            state.target = target;
1384            // When an element that is hovered over is removed, no pointerleave event is fired by the browser,
1385            // even though the originally hovered target may have shrunk in size so it is no longer hovered.
1386            // However, a pointerover event will be fired on the new target the mouse is over.
1387            // In Chrome this happens immediately. In Safari and Firefox, it happens upon moving the mouse one pixel.
1388            addGlobalListener((0, $431fbd86ca7dc216$export$b204af158042fbac)((0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(event)), 'pointerover', (e)=>{
1389                if (state.isHovered && state.target && !(0, $d4ee10de306f2510$export$4282f70798064fe0)(state.target, (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) triggerHoverEnd(e, e.pointerType);
1390            }, {
1391                capture: true
1392            });

1393            if (onHoverStart) onHoverStart({
1394                type: 'hoverstart',
1395                target: target,
1396                pointerType: pointerType
1397            });
1398            if (onHoverChange) onHoverChange(true);
1399            setHovered(true);
1400        };
1401        let triggerHoverEnd = (event, pointerType)=>{
1402            let target = state.target;
1403            state.pointerType = '';
1404            state.target = null;
1405            if (pointerType === 'touch' || !state.isHovered || !target) return;
1406            state.isHovered = false;
1407            removeAllGlobalListeners();
1408            if (onHoverEnd) onHoverEnd({
1409                type: 'hoverend',
1410                target: target,
1411                pointerType: pointerType
1412            });
1413            if (onHoverChange) onHoverChange(false);
1414            setHovered(false);
1415        };
1416        let hoverProps = {};
1417        if (typeof PointerEvent !== 'undefined') {
1418            hoverProps.onPointerEnter = (e)=>{
1419                if ($6179b936705e76d3$var$globalIgnoreEmulatedMouseEvents && e.pointerType === 'mouse') return;
1420                triggerHoverStart(e, e.pointerType);
1421            };
1422            hoverProps.onPointerLeave = (e)=>{
1423                if (!isDisabled && (0, $d4ee10de306f2510$export$4282f70798064fe0)(e.currentTarget, (0, $d4ee10de306f2510$export$e58f029f0fbfdb29)(e))) triggerHoverEnd(e, e.pointerType);
1424            };
1425        } else if ("TURBOPACK compile-time falsy", 0) //TURBOPACK unreachable
1426        ;
1427        return {
1428            hoverProps: hoverProps,
1429            triggerHoverEnd: triggerHoverEnd
1430        };
1431    }, [
1432        onHoverStart,
1433        onHoverChange,
1434        onHoverEnd,
1435        isDisabled,
1436        state,
1437        addGlobalListener,
1438        removeAllGlobalListeners
1439    ]);
1440    (0, __TURBOPACK__imported__module__271645__9["useEffect"])(()=>{
1441        // Call the triggerHoverEnd as soon as isDisabled changes to true
1442        // Safe to call triggerHoverEnd, it will early return if we aren't currently hovering
1443        if (isDisabled) triggerHoverEnd({
1444            currentTarget: state.target
1445        }, state.pointerType);
1446    // eslint-disable-next-line react-hooks/exhaustive-deps
1447    }, [
1448        isDisabled
1449    ]);
1450    return {
1451        hoverProps: hoverProps,
1452        isHovered: isHovered
1453    };
1454}
1455;
1456__turbopack_context__.s([
1457    "useHover",
1458    0,
1459    $6179b936705e76d3$export$ae780daf29e6d456
1460], 371330);
1461}),
1462394487, ((__turbopack_context__) => {
1463"use strict";
1464
1465var __TURBOPACK__imported__module__271645__ = __turbopack_context__.i(271645);
1466var __TURBOPACK__imported__module__402155__ = __turbopack_context__.i(402155);
1467var __TURBOPACK__imported__module__746725__ = __turbopack_context__.i(746725);
1468var __TURBOPACK__imported__module__914189__ = __turbopack_context__.i(914189);
1469;
1470;
1471;
1472;
1473function E(e) {
1474    let t = e.width / 2, n = e.height / 2;
1475    return {
1476        top: e.clientY - n,
1477        right: e.clientX + t,
1478        bottom: e.clientY + n,
1479        left: e.clientX - t
1480    };
1481}
1482function P(e, t) {
1483    return !(!e || !t || e.right < t.left || e.left > t.right || e.bottom < t.top || e.top > t.bottom);
1484}
1485function w() {
1486    let { disabled: e = !1 } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
1487    let t = (0, __TURBOPACK__imported__module__271645__["useRef"])(null), [n, l] = (0, __TURBOPACK__imported__module__271645__["useState"])(!1), r = (0, __TURBOPACK__imported__module__746725__["useDisposables"])(), o = (0, __TURBOPACK__imported__module__914189__["useEvent"])(()=>{
1488        t.current = null, l(!1), r.dispose();
1489    }), f = (0, __TURBOPACK__imported__module__914189__["useEvent"])((s)=>{
1490        if (r.dispose(), t.current === null) {
1491            t.current = s.currentTarget, l(!0);
1492            {
1493                let i = (0, __TURBOPACK__imported__module__402155__["getOwnerDocument"])(s.currentTarget);
1494                r.addEventListener(i, "pointerup", o, !1), r.addEventListener(i, "pointermove", (c)=>{
1495                    if (t.current) {
1496                        let p = E(c);
1497                        l(P(p, t.current.getBoundingClientRect()));
1498                    }
1499                }, !1), r.addEventListener(i, "pointercancel", o, !1);
1500            }
1501        }
1502    });
1503    return {

1504        pressed: n,
1505        pressProps: e ? {} : {
1506            onPointerDown: f,
1507            onPointerUp: o,
1508            onClick: o
1509        }
1510    };
1511}
1512;
1513__turbopack_context__.s([
1514    "useActivePress",
1515    0,
1516    w
1517]);
1518}),
1519144279, ((__turbopack_context__) => {
1520"use strict";
1521
1522var __TURBOPACK__imported__module__271645__ = __turbopack_context__.i(271645);
1523;
1524function e(t, u) {
1525    return (0, __TURBOPACK__imported__module__271645__["useMemo"])(()=>{
1526        var n;
1527        if (t.type) return t.type;
1528        let r = (n = t.as) != null ? n : "button";
1529        if (typeof r == "string" && r.toLowerCase() === "button" || (u == null ? void 0 : u.tagName) === "BUTTON" && !u.hasAttribute("type")) return "button";
1530    }, [
1531        t.type,
1532        t.as,
1533        u
1534    ]);
1535}
1536;
1537__turbopack_context__.s([
1538    "useResolveButtonType",
1539    0,
1540    e
1541]);
1542}),
1543]);
1544
1545//# debugId=ce027bbb-4ed3-f7c3-305f-7d20ab552395

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.