@neurodyn/react-ar 0.0.0-canary-20260817174540

package/dist/191.js

@@ -0,0 +1,4274 @@
+/*! For license information please see 191.js.LICENSE.txt */
+export const __rspack_esm_id = "191";
+export const __rspack_esm_ids = [
+    "191"
+];
+export const __webpack_modules__ = {
+    "../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.3/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js" (__unused_rspack_module, exports, __webpack_require__) {
+        /**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ "production" !== process.env.NODE_ENV && function() {
+            function is(x, y) {
+                return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+            }
+            function useSyncExternalStore$2(subscribe, getSnapshot) {
+                didWarnOld18Alpha || void 0 === React.startTransition || (didWarnOld18Alpha = !0, console.error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."));
+                var value = getSnapshot();
+                if (!didWarnUncachedGetSnapshot) {
+                    var cachedValue = getSnapshot();
+                    objectIs(value, cachedValue) || (console.error("The result of getSnapshot should be cached to avoid an infinite loop"), didWarnUncachedGetSnapshot = !0);
+                }
+                cachedValue = useState({
+                    inst: {
+                        value: value,
+                        getSnapshot: getSnapshot
+                    }
+                });
+                var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+                useLayoutEffect(function() {
+                    inst.value = value;
+                    inst.getSnapshot = getSnapshot;
+                    checkIfSnapshotChanged(inst) && forceUpdate({
+                        inst: inst
+                    });
+                }, [
+                    subscribe,
+                    value,
+                    getSnapshot
+                ]);
+                useEffect(function() {
+                    checkIfSnapshotChanged(inst) && forceUpdate({
+                        inst: inst
+                    });
+                    return subscribe(function() {
+                        checkIfSnapshotChanged(inst) && forceUpdate({
+                            inst: inst
+                        });
+                    });
+                }, [
+                    subscribe
+                ]);
+                useDebugValue(value);
+                return value;
+            }
+            function checkIfSnapshotChanged(inst) {
+                var latestGetSnapshot = inst.getSnapshot;
+                inst = inst.value;
+                try {
+                    var nextValue = latestGetSnapshot();
+                    return !objectIs(inst, nextValue);
+                } catch (error) {
+                    return !0;
+                }
+            }
+            function useSyncExternalStore$1(subscribe, getSnapshot) {
+                return getSnapshot();
+            }
+            "u" > typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+            var React = __webpack_require__("react"), objectIs = "function" == typeof Object.is ? Object.is : is, useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue, didWarnOld18Alpha = !1, didWarnUncachedGetSnapshot = !1, shim = "u" < typeof window || void 0 === window.document || void 0 === window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+            exports.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+            "u" > typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+        }();
+    },
+    "../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.3/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js" (__unused_rspack_module, exports, __webpack_require__) {
+        /**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */ var React = __webpack_require__("react");
+        function is(x, y) {
+            return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+        }
+        var objectIs = "function" == typeof Object.is ? Object.is : is, useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue;
+        function useSyncExternalStore$2(subscribe, getSnapshot) {
+            var value = getSnapshot(), _useState = useState({
+                inst: {
+                    value: value,
+                    getSnapshot: getSnapshot
+                }
+            }), inst = _useState[0].inst, forceUpdate = _useState[1];
+            useLayoutEffect(function() {
+                inst.value = value;
+                inst.getSnapshot = getSnapshot;
+                checkIfSnapshotChanged(inst) && forceUpdate({
+                    inst: inst
+                });
+            }, [
+                subscribe,
+                value,
+                getSnapshot
+            ]);
+            useEffect(function() {
+                checkIfSnapshotChanged(inst) && forceUpdate({
+                    inst: inst
+                });
+                return subscribe(function() {
+                    checkIfSnapshotChanged(inst) && forceUpdate({
+                        inst: inst
+                    });
+                });
+            }, [
+                subscribe
+            ]);
+            useDebugValue(value);
+            return value;
+        }
+        function checkIfSnapshotChanged(inst) {
+            var latestGetSnapshot = inst.getSnapshot;
+            inst = inst.value;
+            try {
+                var nextValue = latestGetSnapshot();
+                return !objectIs(inst, nextValue);
+            } catch (error) {
+                return !0;
+            }
+        }
+        function useSyncExternalStore$1(subscribe, getSnapshot) {
+            return getSnapshot();
+        }
+        var shim = "u" < typeof window || void 0 === window.document || void 0 === window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+        exports.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+    },
+    "../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.3/node_modules/use-sync-external-store/shim/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        if ('production' === process.env.NODE_ENV) module.exports = __webpack_require__("../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.3/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js");
+        else module.exports = __webpack_require__("../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.3/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js");
+    },
+    "../../node_modules/.pnpm/@radix-ui+react-avatar@1.1.10_@types+react-dom@19.2.3_@types+react@19.2.9__@types+react_d8fd4e0f3e6dc8c66630acea8953961b/node_modules/@radix-ui/react-avatar/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            bL: ()=>Root,
+            H4: ()=>Fallback,
+            _V: ()=>Image
+        });
+        var external_react_ = __webpack_require__("react");
+        var dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-context@1.1.2_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-context/dist/index.mjs");
+        var react_use_callback_ref_dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-use-callback-ref@1.1.1_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs");
+        var react_use_layout_effect_dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-use-layout-effect@1.1.1_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs");
+        var react_primitive_dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-primitive@2.1.3_@types+react-dom@19.2.3_@types+react@19.2.9__@types+rea_57eb89d0235dc4221ced9969d75eafcb/node_modules/@radix-ui/react-primitive/dist/index.mjs");
+        var shim = __webpack_require__("../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.3/node_modules/use-sync-external-store/shim/index.js");
+        function useIsHydrated() {
+            return (0, shim.useSyncExternalStore)(subscribe, ()=>true, ()=>false);
+        }
+        function subscribe() {
+            return ()=>{};
+        }
+        var jsx_runtime_ = __webpack_require__("react/jsx-runtime");
+        var AVATAR_NAME = "Avatar";
+        var [createAvatarContext, createAvatarScope] = (0, dist.A)(AVATAR_NAME);
+        var [AvatarProvider, useAvatarContext] = createAvatarContext(AVATAR_NAME);
+        var Avatar = external_react_.forwardRef((props, forwardedRef)=>{
+            const { __scopeAvatar, ...avatarProps } = props;
+            const [imageLoadingStatus, setImageLoadingStatus] = external_react_.useState("idle");
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(AvatarProvider, {
+                scope: __scopeAvatar,
+                imageLoadingStatus,
+                onImageLoadingStatusChange: setImageLoadingStatus,
+                children: /* @__PURE__ */ (0, jsx_runtime_.jsx)(react_primitive_dist.sG.span, {
+                    ...avatarProps,
+                    ref: forwardedRef
+                })
+            });
+        });
+        Avatar.displayName = AVATAR_NAME;
+        var IMAGE_NAME = "AvatarImage";
+        var AvatarImage = external_react_.forwardRef((props, forwardedRef)=>{
+            const { __scopeAvatar, src, onLoadingStatusChange = ()=>{}, ...imageProps } = props;
+            const context = useAvatarContext(IMAGE_NAME, __scopeAvatar);
+            const imageLoadingStatus = useImageLoadingStatus(src, imageProps);
+            const handleLoadingStatusChange = (0, react_use_callback_ref_dist.c)((status)=>{
+                onLoadingStatusChange(status);
+                context.onImageLoadingStatusChange(status);
+            });
+            (0, react_use_layout_effect_dist.N)(()=>{
+                if ("idle" !== imageLoadingStatus) handleLoadingStatusChange(imageLoadingStatus);
+            }, [
+                imageLoadingStatus,
+                handleLoadingStatusChange
+            ]);
+            return "loaded" === imageLoadingStatus ? /* @__PURE__ */ (0, jsx_runtime_.jsx)(react_primitive_dist.sG.img, {
+                ...imageProps,
+                ref: forwardedRef,
+                src
+            }) : null;
+        });
+        AvatarImage.displayName = IMAGE_NAME;
+        var FALLBACK_NAME = "AvatarFallback";
+        var AvatarFallback = external_react_.forwardRef((props, forwardedRef)=>{
+            const { __scopeAvatar, delayMs, ...fallbackProps } = props;
+            const context = useAvatarContext(FALLBACK_NAME, __scopeAvatar);
+            const [canRender, setCanRender] = external_react_.useState(void 0 === delayMs);
+            external_react_.useEffect(()=>{
+                if (void 0 !== delayMs) {
+                    const timerId = window.setTimeout(()=>setCanRender(true), delayMs);
+                    return ()=>window.clearTimeout(timerId);
+                }
+            }, [
+                delayMs
+            ]);
+            return canRender && "loaded" !== context.imageLoadingStatus ? /* @__PURE__ */ (0, jsx_runtime_.jsx)(react_primitive_dist.sG.span, {
+                ...fallbackProps,
+                ref: forwardedRef
+            }) : null;
+        });
+        AvatarFallback.displayName = FALLBACK_NAME;
+        function resolveLoadingStatus(image, src) {
+            if (!image) return "idle";
+            if (!src) return "error";
+            if (image.src !== src) image.src = src;
+            return image.complete && image.naturalWidth > 0 ? "loaded" : "loading";
+        }
+        function useImageLoadingStatus(src, { referrerPolicy, crossOrigin }) {
+            const isHydrated = useIsHydrated();
+            const imageRef = external_react_.useRef(null);
+            const image = (()=>{
+                if (!isHydrated) return null;
+                if (!imageRef.current) imageRef.current = new window.Image();
+                return imageRef.current;
+            })();
+            const [loadingStatus, setLoadingStatus] = external_react_.useState(()=>resolveLoadingStatus(image, src));
+            (0, react_use_layout_effect_dist.N)(()=>{
+                setLoadingStatus(resolveLoadingStatus(image, src));
+            }, [
+                image,
+                src
+            ]);
+            (0, react_use_layout_effect_dist.N)(()=>{
+                const updateStatus = (status)=>()=>{
+                        setLoadingStatus(status);
+                    };
+                if (!image) return;
+                const handleLoad = updateStatus("loaded");
+                const handleError = updateStatus("error");
+                image.addEventListener("load", handleLoad);
+                image.addEventListener("error", handleError);
+                if (referrerPolicy) image.referrerPolicy = referrerPolicy;
+                if ("string" == typeof crossOrigin) image.crossOrigin = crossOrigin;
+                return ()=>{
+                    image.removeEventListener("load", handleLoad);
+                    image.removeEventListener("error", handleError);
+                };
+            }, [
+                image,
+                crossOrigin,
+                referrerPolicy
+            ]);
+            return loadingStatus;
+        }
+        var Root = Avatar;
+        var Image = AvatarImage;
+        var Fallback = AvatarFallback;
+    },
+    "../../node_modules/.pnpm/@radix-ui+react-context@1.1.2_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-context/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>createContextScope
+        });
+        var react__rspack_import_0 = __webpack_require__("react");
+        var react_jsx_runtime__rspack_import_1 = __webpack_require__("react/jsx-runtime");
+        function createContextScope(scopeName, createContextScopeDeps = []) {
+            let defaultContexts = [];
+            function createContext3(rootComponentName, defaultContext) {
+                const BaseContext = react__rspack_import_0.createContext(defaultContext);
+                const index = defaultContexts.length;
+                defaultContexts = [
+                    ...defaultContexts,
+                    defaultContext
+                ];
+                const Provider = (props)=>{
+                    const { scope, children, ...context } = props;
+                    const Context = scope?.[scopeName]?.[index] || BaseContext;
+                    const value = react__rspack_import_0.useMemo(()=>context, Object.values(context));
+                    return /* @__PURE__ */ (0, react_jsx_runtime__rspack_import_1.jsx)(Context.Provider, {
+                        value,
+                        children
+                    });
+                };
+                Provider.displayName = rootComponentName + "Provider";
+                function useContext2(consumerName, scope) {
+                    const Context = scope?.[scopeName]?.[index] || BaseContext;
+                    const context = react__rspack_import_0.useContext(Context);
+                    if (context) return context;
+                    if (void 0 !== defaultContext) return defaultContext;
+                    throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``);
+                }
+                return [
+                    Provider,
+                    useContext2
+                ];
+            }
+            const createScope = ()=>{
+                const scopeContexts = defaultContexts.map((defaultContext)=>react__rspack_import_0.createContext(defaultContext));
+                return function(scope) {
+                    const contexts = scope?.[scopeName] || scopeContexts;
+                    return react__rspack_import_0.useMemo(()=>({
+                            [`__scope${scopeName}`]: {
+                                ...scope,
+                                [scopeName]: contexts
+                            }
+                        }), [
+                        scope,
+                        contexts
+                    ]);
+                };
+            };
+            createScope.scopeName = scopeName;
+            return [
+                createContext3,
+                composeContextScopes(createScope, ...createContextScopeDeps)
+            ];
+        }
+        function composeContextScopes(...scopes) {
+            const baseScope = scopes[0];
+            if (1 === scopes.length) return baseScope;
+            const createScope = ()=>{
+                const scopeHooks = scopes.map((createScope2)=>({
+                        useScope: createScope2(),
+                        scopeName: createScope2.scopeName
+                    }));
+                return function(overrideScopes) {
+                    const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName })=>{
+                        const scopeProps = useScope(overrideScopes);
+                        const currentScope = scopeProps[`__scope${scopeName}`];
+                        return {
+                            ...nextScopes2,
+                            ...currentScope
+                        };
+                    }, {});
+                    return react__rspack_import_0.useMemo(()=>({
+                            [`__scope${baseScope.scopeName}`]: nextScopes
+                        }), [
+                        nextScopes
+                    ]);
+                };
+            };
+            createScope.scopeName = baseScope.scopeName;
+            return createScope;
+        }
+    },
+    "../../node_modules/.pnpm/@radix-ui+react-primitive@2.1.3_@types+react-dom@19.2.3_@types+react@19.2.9__@types+rea_57eb89d0235dc4221ced9969d75eafcb/node_modules/@radix-ui/react-primitive/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            sG: ()=>Primitive
+        });
+        var react__rspack_import_0 = __webpack_require__("react");
+        __webpack_require__("react-dom");
+        var _radix_ui_react_slot__rspack_import_3 = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-slot@1.2.3_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-slot/dist/index.mjs");
+        var react_jsx_runtime__rspack_import_2 = __webpack_require__("react/jsx-runtime");
+        var NODES = [
+            "a",
+            "button",
+            "div",
+            "form",
+            "h2",
+            "h3",
+            "img",
+            "input",
+            "label",
+            "li",
+            "nav",
+            "ol",
+            "p",
+            "select",
+            "span",
+            "svg",
+            "ul"
+        ];
+        var Primitive = NODES.reduce((primitive, node)=>{
+            const Slot = (0, _radix_ui_react_slot__rspack_import_3.TL)(`Primitive.${node}`);
+            const Node = react__rspack_import_0.forwardRef((props, forwardedRef)=>{
+                const { asChild, ...primitiveProps } = props;
+                const Comp = asChild ? Slot : node;
+                if ("u" > typeof window) window[Symbol.for("radix-ui")] = true;
+                return /* @__PURE__ */ (0, react_jsx_runtime__rspack_import_2.jsx)(Comp, {
+                    ...primitiveProps,
+                    ref: forwardedRef
+                });
+            });
+            Node.displayName = `Primitive.${node}`;
+            return {
+                ...primitive,
+                [node]: Node
+            };
+        }, {});
+    },
+    "../../node_modules/.pnpm/@radix-ui+react-scroll-area@1.2.10_@types+react-dom@19.2.3_@types+react@19.2.9__@types+_72027b192e15199e0021686129280684/node_modules/@radix-ui/react-scroll-area/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            LM: ()=>Viewport,
+            bL: ()=>dist_Root,
+            OK: ()=>Corner,
+            VM: ()=>ScrollAreaScrollbar,
+            lr: ()=>ScrollAreaThumb
+        });
+        var external_react_ = __webpack_require__("react");
+        var dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-primitive@2.1.3_@types+react-dom@19.2.3_@types+react@19.2.9__@types+rea_57eb89d0235dc4221ced9969d75eafcb/node_modules/@radix-ui/react-primitive/dist/index.mjs");
+        var react_compose_refs_dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-compose-refs@1.1.2_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-compose-refs/dist/index.mjs");
+        var react_use_layout_effect_dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-use-layout-effect@1.1.1_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs");
+        function useStateMachine(initialState, machine) {
+            return external_react_.useReducer((state, event)=>{
+                const nextState = machine[state][event];
+                return nextState ?? state;
+            }, initialState);
+        }
+        var Presence = (props)=>{
+            const { present, children } = props;
+            const presence = usePresence(present);
+            const child = "function" == typeof children ? children({
+                present: presence.isPresent
+            }) : external_react_.Children.only(children);
+            const ref = (0, react_compose_refs_dist.s)(presence.ref, getElementRef(child));
+            const forceMount = "function" == typeof children;
+            return forceMount || presence.isPresent ? external_react_.cloneElement(child, {
+                ref
+            }) : null;
+        };
+        Presence.displayName = "Presence";
+        function usePresence(present) {
+            const [node, setNode] = external_react_.useState();
+            const stylesRef = external_react_.useRef(null);
+            const prevPresentRef = external_react_.useRef(present);
+            const prevAnimationNameRef = external_react_.useRef("none");
+            const initialState = present ? "mounted" : "unmounted";
+            const [state, send] = useStateMachine(initialState, {
+                mounted: {
+                    UNMOUNT: "unmounted",
+                    ANIMATION_OUT: "unmountSuspended"
+                },
+                unmountSuspended: {
+                    MOUNT: "mounted",
+                    ANIMATION_END: "unmounted"
+                },
+                unmounted: {
+                    MOUNT: "mounted"
+                }
+            });
+            external_react_.useEffect(()=>{
+                const currentAnimationName = getAnimationName(stylesRef.current);
+                prevAnimationNameRef.current = "mounted" === state ? currentAnimationName : "none";
+            }, [
+                state
+            ]);
+            (0, react_use_layout_effect_dist.N)(()=>{
+                const styles = stylesRef.current;
+                const wasPresent = prevPresentRef.current;
+                const hasPresentChanged = wasPresent !== present;
+                if (hasPresentChanged) {
+                    const prevAnimationName = prevAnimationNameRef.current;
+                    const currentAnimationName = getAnimationName(styles);
+                    if (present) send("MOUNT");
+                    else if ("none" === currentAnimationName || styles?.display === "none") send("UNMOUNT");
+                    else {
+                        const isAnimating = prevAnimationName !== currentAnimationName;
+                        wasPresent && isAnimating ? send("ANIMATION_OUT") : send("UNMOUNT");
+                    }
+                    prevPresentRef.current = present;
+                }
+            }, [
+                present,
+                send
+            ]);
+            (0, react_use_layout_effect_dist.N)(()=>{
+                if (node) {
+                    let timeoutId;
+                    const ownerWindow = node.ownerDocument.defaultView ?? window;
+                    const handleAnimationEnd = (event)=>{
+                        const currentAnimationName = getAnimationName(stylesRef.current);
+                        const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
+                        if (event.target === node && isCurrentAnimation) {
+                            send("ANIMATION_END");
+                            if (!prevPresentRef.current) {
+                                const currentFillMode = node.style.animationFillMode;
+                                node.style.animationFillMode = "forwards";
+                                timeoutId = ownerWindow.setTimeout(()=>{
+                                    if ("forwards" === node.style.animationFillMode) node.style.animationFillMode = currentFillMode;
+                                });
+                            }
+                        }
+                    };
+                    const handleAnimationStart = (event)=>{
+                        if (event.target === node) prevAnimationNameRef.current = getAnimationName(stylesRef.current);
+                    };
+                    node.addEventListener("animationstart", handleAnimationStart);
+                    node.addEventListener("animationcancel", handleAnimationEnd);
+                    node.addEventListener("animationend", handleAnimationEnd);
+                    return ()=>{
+                        ownerWindow.clearTimeout(timeoutId);
+                        node.removeEventListener("animationstart", handleAnimationStart);
+                        node.removeEventListener("animationcancel", handleAnimationEnd);
+                        node.removeEventListener("animationend", handleAnimationEnd);
+                    };
+                }
+                send("ANIMATION_END");
+            }, [
+                node,
+                send
+            ]);
+            return {
+                isPresent: [
+                    "mounted",
+                    "unmountSuspended"
+                ].includes(state),
+                ref: external_react_.useCallback((node2)=>{
+                    stylesRef.current = node2 ? getComputedStyle(node2) : null;
+                    setNode(node2);
+                }, [])
+            };
+        }
+        function getAnimationName(styles) {
+            return styles?.animationName || "none";
+        }
+        function getElementRef(element) {
+            let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+            let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+            if (mayWarn) return element.ref;
+            getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+            mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+            if (mayWarn) return element.props.ref;
+            return element.props.ref || element.ref;
+        }
+        var react_context_dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-context@1.1.2_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-context/dist/index.mjs");
+        var react_use_callback_ref_dist = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-use-callback-ref@1.1.1_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs");
+        var jsx_runtime_ = __webpack_require__("react/jsx-runtime");
+        var DirectionContext = external_react_.createContext(void 0);
+        function useDirection(localDir) {
+            const globalDir = external_react_.useContext(DirectionContext);
+            return localDir || globalDir || "ltr";
+        }
+        function clamp(value, [min, max]) {
+            return Math.min(max, Math.max(min, value));
+        }
+        "u" > typeof window && window.document && window.document.createElement;
+        function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+            return function(event) {
+                originalEventHandler?.(event);
+                if (false === checkForDefaultPrevented || !event.defaultPrevented) return ourEventHandler?.(event);
+            };
+        }
+        function dist_useStateMachine(initialState, machine) {
+            return external_react_.useReducer((state, event)=>{
+                const nextState = machine[state][event];
+                return nextState ?? state;
+            }, initialState);
+        }
+        var SCROLL_AREA_NAME = "ScrollArea";
+        var [createScrollAreaContext, createScrollAreaScope] = (0, react_context_dist.A)(SCROLL_AREA_NAME);
+        var [ScrollAreaProvider, useScrollAreaContext] = createScrollAreaContext(SCROLL_AREA_NAME);
+        var ScrollArea = external_react_.forwardRef((props, forwardedRef)=>{
+            const { __scopeScrollArea, type = "hover", dir, scrollHideDelay = 600, ...scrollAreaProps } = props;
+            const [scrollArea, setScrollArea] = external_react_.useState(null);
+            const [viewport, setViewport] = external_react_.useState(null);
+            const [content, setContent] = external_react_.useState(null);
+            const [scrollbarX, setScrollbarX] = external_react_.useState(null);
+            const [scrollbarY, setScrollbarY] = external_react_.useState(null);
+            const [cornerWidth, setCornerWidth] = external_react_.useState(0);
+            const [cornerHeight, setCornerHeight] = external_react_.useState(0);
+            const [scrollbarXEnabled, setScrollbarXEnabled] = external_react_.useState(false);
+            const [scrollbarYEnabled, setScrollbarYEnabled] = external_react_.useState(false);
+            const composedRefs = (0, react_compose_refs_dist.s)(forwardedRef, (node)=>setScrollArea(node));
+            const direction = useDirection(dir);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaProvider, {
+                scope: __scopeScrollArea,
+                type,
+                dir: direction,
+                scrollHideDelay,
+                scrollArea,
+                viewport,
+                onViewportChange: setViewport,
+                content,
+                onContentChange: setContent,
+                scrollbarX,
+                onScrollbarXChange: setScrollbarX,
+                scrollbarXEnabled,
+                onScrollbarXEnabledChange: setScrollbarXEnabled,
+                scrollbarY,
+                onScrollbarYChange: setScrollbarY,
+                scrollbarYEnabled,
+                onScrollbarYEnabledChange: setScrollbarYEnabled,
+                onCornerWidthChange: setCornerWidth,
+                onCornerHeightChange: setCornerHeight,
+                children: /* @__PURE__ */ (0, jsx_runtime_.jsx)(dist.sG.div, {
+                    dir: direction,
+                    ...scrollAreaProps,
+                    ref: composedRefs,
+                    style: {
+                        position: "relative",
+                        ["--radix-scroll-area-corner-width"]: cornerWidth + "px",
+                        ["--radix-scroll-area-corner-height"]: cornerHeight + "px",
+                        ...props.style
+                    }
+                })
+            });
+        });
+        ScrollArea.displayName = SCROLL_AREA_NAME;
+        var VIEWPORT_NAME = "ScrollAreaViewport";
+        var ScrollAreaViewport = external_react_.forwardRef((props, forwardedRef)=>{
+            const { __scopeScrollArea, children, nonce, ...viewportProps } = props;
+            const context = useScrollAreaContext(VIEWPORT_NAME, __scopeScrollArea);
+            const ref = external_react_.useRef(null);
+            const composedRefs = (0, react_compose_refs_dist.s)(forwardedRef, ref, context.onViewportChange);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsxs)(jsx_runtime_.Fragment, {
+                children: [
+                    /* @__PURE__ */ (0, jsx_runtime_.jsx)("style", {
+                        dangerouslySetInnerHTML: {
+                            __html: "[data-radix-scroll-area-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-scroll-area-viewport]::-webkit-scrollbar{display:none}"
+                        },
+                        nonce
+                    }),
+                    /* @__PURE__ */ (0, jsx_runtime_.jsx)(dist.sG.div, {
+                        "data-radix-scroll-area-viewport": "",
+                        ...viewportProps,
+                        ref: composedRefs,
+                        style: {
+                            overflowX: context.scrollbarXEnabled ? "scroll" : "hidden",
+                            overflowY: context.scrollbarYEnabled ? "scroll" : "hidden",
+                            ...props.style
+                        },
+                        children: /* @__PURE__ */ (0, jsx_runtime_.jsx)("div", {
+                            ref: context.onContentChange,
+                            style: {
+                                minWidth: "100%",
+                                display: "table"
+                            },
+                            children
+                        })
+                    })
+                ]
+            });
+        });
+        ScrollAreaViewport.displayName = VIEWPORT_NAME;
+        var SCROLLBAR_NAME = "ScrollAreaScrollbar";
+        var ScrollAreaScrollbar = external_react_.forwardRef((props, forwardedRef)=>{
+            const { forceMount, ...scrollbarProps } = props;
+            const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+            const { onScrollbarXEnabledChange, onScrollbarYEnabledChange } = context;
+            const isHorizontal = "horizontal" === props.orientation;
+            external_react_.useEffect(()=>{
+                isHorizontal ? onScrollbarXEnabledChange(true) : onScrollbarYEnabledChange(true);
+                return ()=>{
+                    isHorizontal ? onScrollbarXEnabledChange(false) : onScrollbarYEnabledChange(false);
+                };
+            }, [
+                isHorizontal,
+                onScrollbarXEnabledChange,
+                onScrollbarYEnabledChange
+            ]);
+            return "hover" === context.type ? /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarHover, {
+                ...scrollbarProps,
+                ref: forwardedRef,
+                forceMount
+            }) : "scroll" === context.type ? /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarScroll, {
+                ...scrollbarProps,
+                ref: forwardedRef,
+                forceMount
+            }) : "auto" === context.type ? /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarAuto, {
+                ...scrollbarProps,
+                ref: forwardedRef,
+                forceMount
+            }) : "always" === context.type ? /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarVisible, {
+                ...scrollbarProps,
+                ref: forwardedRef
+            }) : null;
+        });
+        ScrollAreaScrollbar.displayName = SCROLLBAR_NAME;
+        var ScrollAreaScrollbarHover = external_react_.forwardRef((props, forwardedRef)=>{
+            const { forceMount, ...scrollbarProps } = props;
+            const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+            const [visible, setVisible] = external_react_.useState(false);
+            external_react_.useEffect(()=>{
+                const scrollArea = context.scrollArea;
+                let hideTimer = 0;
+                if (scrollArea) {
+                    const handlePointerEnter = ()=>{
+                        window.clearTimeout(hideTimer);
+                        setVisible(true);
+                    };
+                    const handlePointerLeave = ()=>{
+                        hideTimer = window.setTimeout(()=>setVisible(false), context.scrollHideDelay);
+                    };
+                    scrollArea.addEventListener("pointerenter", handlePointerEnter);
+                    scrollArea.addEventListener("pointerleave", handlePointerLeave);
+                    return ()=>{
+                        window.clearTimeout(hideTimer);
+                        scrollArea.removeEventListener("pointerenter", handlePointerEnter);
+                        scrollArea.removeEventListener("pointerleave", handlePointerLeave);
+                    };
+                }
+            }, [
+                context.scrollArea,
+                context.scrollHideDelay
+            ]);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(Presence, {
+                present: forceMount || visible,
+                children: /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarAuto, {
+                    "data-state": visible ? "visible" : "hidden",
+                    ...scrollbarProps,
+                    ref: forwardedRef
+                })
+            });
+        });
+        var ScrollAreaScrollbarScroll = external_react_.forwardRef((props, forwardedRef)=>{
+            const { forceMount, ...scrollbarProps } = props;
+            const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+            const isHorizontal = "horizontal" === props.orientation;
+            const debounceScrollEnd = useDebounceCallback(()=>send("SCROLL_END"), 100);
+            const [state, send] = dist_useStateMachine("hidden", {
+                hidden: {
+                    SCROLL: "scrolling"
+                },
+                scrolling: {
+                    SCROLL_END: "idle",
+                    POINTER_ENTER: "interacting"
+                },
+                interacting: {
+                    SCROLL: "interacting",
+                    POINTER_LEAVE: "idle"
+                },
+                idle: {
+                    HIDE: "hidden",
+                    SCROLL: "scrolling",
+                    POINTER_ENTER: "interacting"
+                }
+            });
+            external_react_.useEffect(()=>{
+                if ("idle" === state) {
+                    const hideTimer = window.setTimeout(()=>send("HIDE"), context.scrollHideDelay);
+                    return ()=>window.clearTimeout(hideTimer);
+                }
+            }, [
+                state,
+                context.scrollHideDelay,
+                send
+            ]);
+            external_react_.useEffect(()=>{
+                const viewport = context.viewport;
+                const scrollDirection = isHorizontal ? "scrollLeft" : "scrollTop";
+                if (viewport) {
+                    let prevScrollPos = viewport[scrollDirection];
+                    const handleScroll = ()=>{
+                        const scrollPos = viewport[scrollDirection];
+                        const hasScrollInDirectionChanged = prevScrollPos !== scrollPos;
+                        if (hasScrollInDirectionChanged) {
+                            send("SCROLL");
+                            debounceScrollEnd();
+                        }
+                        prevScrollPos = scrollPos;
+                    };
+                    viewport.addEventListener("scroll", handleScroll);
+                    return ()=>viewport.removeEventListener("scroll", handleScroll);
+                }
+            }, [
+                context.viewport,
+                isHorizontal,
+                send,
+                debounceScrollEnd
+            ]);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(Presence, {
+                present: forceMount || "hidden" !== state,
+                children: /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarVisible, {
+                    "data-state": "hidden" === state ? "hidden" : "visible",
+                    ...scrollbarProps,
+                    ref: forwardedRef,
+                    onPointerEnter: composeEventHandlers(props.onPointerEnter, ()=>send("POINTER_ENTER")),
+                    onPointerLeave: composeEventHandlers(props.onPointerLeave, ()=>send("POINTER_LEAVE"))
+                })
+            });
+        });
+        var ScrollAreaScrollbarAuto = external_react_.forwardRef((props, forwardedRef)=>{
+            const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+            const { forceMount, ...scrollbarProps } = props;
+            const [visible, setVisible] = external_react_.useState(false);
+            const isHorizontal = "horizontal" === props.orientation;
+            const handleResize = useDebounceCallback(()=>{
+                if (context.viewport) {
+                    const isOverflowX = context.viewport.offsetWidth < context.viewport.scrollWidth;
+                    const isOverflowY = context.viewport.offsetHeight < context.viewport.scrollHeight;
+                    setVisible(isHorizontal ? isOverflowX : isOverflowY);
+                }
+            }, 10);
+            useResizeObserver(context.viewport, handleResize);
+            useResizeObserver(context.content, handleResize);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(Presence, {
+                present: forceMount || visible,
+                children: /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarVisible, {
+                    "data-state": visible ? "visible" : "hidden",
+                    ...scrollbarProps,
+                    ref: forwardedRef
+                })
+            });
+        });
+        var ScrollAreaScrollbarVisible = external_react_.forwardRef((props, forwardedRef)=>{
+            const { orientation = "vertical", ...scrollbarProps } = props;
+            const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+            const thumbRef = external_react_.useRef(null);
+            const pointerOffsetRef = external_react_.useRef(0);
+            const [sizes, setSizes] = external_react_.useState({
+                content: 0,
+                viewport: 0,
+                scrollbar: {
+                    size: 0,
+                    paddingStart: 0,
+                    paddingEnd: 0
+                }
+            });
+            const thumbRatio = getThumbRatio(sizes.viewport, sizes.content);
+            const commonProps = {
+                ...scrollbarProps,
+                sizes,
+                onSizesChange: setSizes,
+                hasThumb: Boolean(thumbRatio > 0 && thumbRatio < 1),
+                onThumbChange: (thumb)=>thumbRef.current = thumb,
+                onThumbPointerUp: ()=>pointerOffsetRef.current = 0,
+                onThumbPointerDown: (pointerPos)=>pointerOffsetRef.current = pointerPos
+            };
+            function getScrollPosition(pointerPos, dir) {
+                return getScrollPositionFromPointer(pointerPos, pointerOffsetRef.current, sizes, dir);
+            }
+            if ("horizontal" === orientation) return /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarX, {
+                ...commonProps,
+                ref: forwardedRef,
+                onThumbPositionChange: ()=>{
+                    if (context.viewport && thumbRef.current) {
+                        const scrollPos = context.viewport.scrollLeft;
+                        const offset = getThumbOffsetFromScroll(scrollPos, sizes, context.dir);
+                        thumbRef.current.style.transform = `translate3d(${offset}px, 0, 0)`;
+                    }
+                },
+                onWheelScroll: (scrollPos)=>{
+                    if (context.viewport) context.viewport.scrollLeft = scrollPos;
+                },
+                onDragScroll: (pointerPos)=>{
+                    if (context.viewport) context.viewport.scrollLeft = getScrollPosition(pointerPos, context.dir);
+                }
+            });
+            if ("vertical" === orientation) return /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarY, {
+                ...commonProps,
+                ref: forwardedRef,
+                onThumbPositionChange: ()=>{
+                    if (context.viewport && thumbRef.current) {
+                        const scrollPos = context.viewport.scrollTop;
+                        const offset = getThumbOffsetFromScroll(scrollPos, sizes);
+                        thumbRef.current.style.transform = `translate3d(0, ${offset}px, 0)`;
+                    }
+                },
+                onWheelScroll: (scrollPos)=>{
+                    if (context.viewport) context.viewport.scrollTop = scrollPos;
+                },
+                onDragScroll: (pointerPos)=>{
+                    if (context.viewport) context.viewport.scrollTop = getScrollPosition(pointerPos);
+                }
+            });
+            return null;
+        });
+        var ScrollAreaScrollbarX = external_react_.forwardRef((props, forwardedRef)=>{
+            const { sizes, onSizesChange, ...scrollbarProps } = props;
+            const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+            const [computedStyle, setComputedStyle] = external_react_.useState();
+            const ref = external_react_.useRef(null);
+            const composeRefs = (0, react_compose_refs_dist.s)(forwardedRef, ref, context.onScrollbarXChange);
+            external_react_.useEffect(()=>{
+                if (ref.current) setComputedStyle(getComputedStyle(ref.current));
+            }, [
+                ref
+            ]);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarImpl, {
+                "data-orientation": "horizontal",
+                ...scrollbarProps,
+                ref: composeRefs,
+                sizes,
+                style: {
+                    bottom: 0,
+                    left: "rtl" === context.dir ? "var(--radix-scroll-area-corner-width)" : 0,
+                    right: "ltr" === context.dir ? "var(--radix-scroll-area-corner-width)" : 0,
+                    ["--radix-scroll-area-thumb-width"]: getThumbSize(sizes) + "px",
+                    ...props.style
+                },
+                onThumbPointerDown: (pointerPos)=>props.onThumbPointerDown(pointerPos.x),
+                onDragScroll: (pointerPos)=>props.onDragScroll(pointerPos.x),
+                onWheelScroll: (event, maxScrollPos)=>{
+                    if (context.viewport) {
+                        const scrollPos = context.viewport.scrollLeft + event.deltaX;
+                        props.onWheelScroll(scrollPos);
+                        if (isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos)) event.preventDefault();
+                    }
+                },
+                onResize: ()=>{
+                    if (ref.current && context.viewport && computedStyle) onSizesChange({
+                        content: context.viewport.scrollWidth,
+                        viewport: context.viewport.offsetWidth,
+                        scrollbar: {
+                            size: ref.current.clientWidth,
+                            paddingStart: toInt(computedStyle.paddingLeft),
+                            paddingEnd: toInt(computedStyle.paddingRight)
+                        }
+                    });
+                }
+            });
+        });
+        var ScrollAreaScrollbarY = external_react_.forwardRef((props, forwardedRef)=>{
+            const { sizes, onSizesChange, ...scrollbarProps } = props;
+            const context = useScrollAreaContext(SCROLLBAR_NAME, props.__scopeScrollArea);
+            const [computedStyle, setComputedStyle] = external_react_.useState();
+            const ref = external_react_.useRef(null);
+            const composeRefs = (0, react_compose_refs_dist.s)(forwardedRef, ref, context.onScrollbarYChange);
+            external_react_.useEffect(()=>{
+                if (ref.current) setComputedStyle(getComputedStyle(ref.current));
+            }, [
+                ref
+            ]);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaScrollbarImpl, {
+                "data-orientation": "vertical",
+                ...scrollbarProps,
+                ref: composeRefs,
+                sizes,
+                style: {
+                    top: 0,
+                    right: "ltr" === context.dir ? 0 : void 0,
+                    left: "rtl" === context.dir ? 0 : void 0,
+                    bottom: "var(--radix-scroll-area-corner-height)",
+                    ["--radix-scroll-area-thumb-height"]: getThumbSize(sizes) + "px",
+                    ...props.style
+                },
+                onThumbPointerDown: (pointerPos)=>props.onThumbPointerDown(pointerPos.y),
+                onDragScroll: (pointerPos)=>props.onDragScroll(pointerPos.y),
+                onWheelScroll: (event, maxScrollPos)=>{
+                    if (context.viewport) {
+                        const scrollPos = context.viewport.scrollTop + event.deltaY;
+                        props.onWheelScroll(scrollPos);
+                        if (isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos)) event.preventDefault();
+                    }
+                },
+                onResize: ()=>{
+                    if (ref.current && context.viewport && computedStyle) onSizesChange({
+                        content: context.viewport.scrollHeight,
+                        viewport: context.viewport.offsetHeight,
+                        scrollbar: {
+                            size: ref.current.clientHeight,
+                            paddingStart: toInt(computedStyle.paddingTop),
+                            paddingEnd: toInt(computedStyle.paddingBottom)
+                        }
+                    });
+                }
+            });
+        });
+        var [ScrollbarProvider, useScrollbarContext] = createScrollAreaContext(SCROLLBAR_NAME);
+        var ScrollAreaScrollbarImpl = external_react_.forwardRef((props, forwardedRef)=>{
+            const { __scopeScrollArea, sizes, hasThumb, onThumbChange, onThumbPointerUp, onThumbPointerDown, onThumbPositionChange, onDragScroll, onWheelScroll, onResize, ...scrollbarProps } = props;
+            const context = useScrollAreaContext(SCROLLBAR_NAME, __scopeScrollArea);
+            const [scrollbar, setScrollbar] = external_react_.useState(null);
+            const composeRefs = (0, react_compose_refs_dist.s)(forwardedRef, (node)=>setScrollbar(node));
+            const rectRef = external_react_.useRef(null);
+            const prevWebkitUserSelectRef = external_react_.useRef("");
+            const viewport = context.viewport;
+            const maxScrollPos = sizes.content - sizes.viewport;
+            const handleWheelScroll = (0, react_use_callback_ref_dist.c)(onWheelScroll);
+            const handleThumbPositionChange = (0, react_use_callback_ref_dist.c)(onThumbPositionChange);
+            const handleResize = useDebounceCallback(onResize, 10);
+            function handleDragScroll(event) {
+                if (rectRef.current) {
+                    const x = event.clientX - rectRef.current.left;
+                    const y = event.clientY - rectRef.current.top;
+                    onDragScroll({
+                        x,
+                        y
+                    });
+                }
+            }
+            external_react_.useEffect(()=>{
+                const handleWheel = (event)=>{
+                    const element = event.target;
+                    const isScrollbarWheel = scrollbar?.contains(element);
+                    if (isScrollbarWheel) handleWheelScroll(event, maxScrollPos);
+                };
+                document.addEventListener("wheel", handleWheel, {
+                    passive: false
+                });
+                return ()=>document.removeEventListener("wheel", handleWheel, {
+                        passive: false
+                    });
+            }, [
+                viewport,
+                scrollbar,
+                maxScrollPos,
+                handleWheelScroll
+            ]);
+            external_react_.useEffect(handleThumbPositionChange, [
+                sizes,
+                handleThumbPositionChange
+            ]);
+            useResizeObserver(scrollbar, handleResize);
+            useResizeObserver(context.content, handleResize);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollbarProvider, {
+                scope: __scopeScrollArea,
+                scrollbar,
+                hasThumb,
+                onThumbChange: (0, react_use_callback_ref_dist.c)(onThumbChange),
+                onThumbPointerUp: (0, react_use_callback_ref_dist.c)(onThumbPointerUp),
+                onThumbPositionChange: handleThumbPositionChange,
+                onThumbPointerDown: (0, react_use_callback_ref_dist.c)(onThumbPointerDown),
+                children: /* @__PURE__ */ (0, jsx_runtime_.jsx)(dist.sG.div, {
+                    ...scrollbarProps,
+                    ref: composeRefs,
+                    style: {
+                        position: "absolute",
+                        ...scrollbarProps.style
+                    },
+                    onPointerDown: composeEventHandlers(props.onPointerDown, (event)=>{
+                        const mainPointer = 0;
+                        if (event.button === mainPointer) {
+                            const element = event.target;
+                            element.setPointerCapture(event.pointerId);
+                            rectRef.current = scrollbar.getBoundingClientRect();
+                            prevWebkitUserSelectRef.current = document.body.style.webkitUserSelect;
+                            document.body.style.webkitUserSelect = "none";
+                            if (context.viewport) context.viewport.style.scrollBehavior = "auto";
+                            handleDragScroll(event);
+                        }
+                    }),
+                    onPointerMove: composeEventHandlers(props.onPointerMove, handleDragScroll),
+                    onPointerUp: composeEventHandlers(props.onPointerUp, (event)=>{
+                        const element = event.target;
+                        if (element.hasPointerCapture(event.pointerId)) element.releasePointerCapture(event.pointerId);
+                        document.body.style.webkitUserSelect = prevWebkitUserSelectRef.current;
+                        if (context.viewport) context.viewport.style.scrollBehavior = "";
+                        rectRef.current = null;
+                    })
+                })
+            });
+        });
+        var THUMB_NAME = "ScrollAreaThumb";
+        var ScrollAreaThumb = external_react_.forwardRef((props, forwardedRef)=>{
+            const { forceMount, ...thumbProps } = props;
+            const scrollbarContext = useScrollbarContext(THUMB_NAME, props.__scopeScrollArea);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(Presence, {
+                present: forceMount || scrollbarContext.hasThumb,
+                children: /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaThumbImpl, {
+                    ref: forwardedRef,
+                    ...thumbProps
+                })
+            });
+        });
+        var ScrollAreaThumbImpl = external_react_.forwardRef((props, forwardedRef)=>{
+            const { __scopeScrollArea, style, ...thumbProps } = props;
+            const scrollAreaContext = useScrollAreaContext(THUMB_NAME, __scopeScrollArea);
+            const scrollbarContext = useScrollbarContext(THUMB_NAME, __scopeScrollArea);
+            const { onThumbPositionChange } = scrollbarContext;
+            const composedRef = (0, react_compose_refs_dist.s)(forwardedRef, (node)=>scrollbarContext.onThumbChange(node));
+            const removeUnlinkedScrollListenerRef = external_react_.useRef(void 0);
+            const debounceScrollEnd = useDebounceCallback(()=>{
+                if (removeUnlinkedScrollListenerRef.current) {
+                    removeUnlinkedScrollListenerRef.current();
+                    removeUnlinkedScrollListenerRef.current = void 0;
+                }
+            }, 100);
+            external_react_.useEffect(()=>{
+                const viewport = scrollAreaContext.viewport;
+                if (viewport) {
+                    const handleScroll = ()=>{
+                        debounceScrollEnd();
+                        if (!removeUnlinkedScrollListenerRef.current) {
+                            const listener = addUnlinkedScrollListener(viewport, onThumbPositionChange);
+                            removeUnlinkedScrollListenerRef.current = listener;
+                            onThumbPositionChange();
+                        }
+                    };
+                    onThumbPositionChange();
+                    viewport.addEventListener("scroll", handleScroll);
+                    return ()=>viewport.removeEventListener("scroll", handleScroll);
+                }
+            }, [
+                scrollAreaContext.viewport,
+                debounceScrollEnd,
+                onThumbPositionChange
+            ]);
+            return /* @__PURE__ */ (0, jsx_runtime_.jsx)(dist.sG.div, {
+                "data-state": scrollbarContext.hasThumb ? "visible" : "hidden",
+                ...thumbProps,
+                ref: composedRef,
+                style: {
+                    width: "var(--radix-scroll-area-thumb-width)",
+                    height: "var(--radix-scroll-area-thumb-height)",
+                    ...style
+                },
+                onPointerDownCapture: composeEventHandlers(props.onPointerDownCapture, (event)=>{
+                    const thumb = event.target;
+                    const thumbRect = thumb.getBoundingClientRect();
+                    const x = event.clientX - thumbRect.left;
+                    const y = event.clientY - thumbRect.top;
+                    scrollbarContext.onThumbPointerDown({
+                        x,
+                        y
+                    });
+                }),
+                onPointerUp: composeEventHandlers(props.onPointerUp, scrollbarContext.onThumbPointerUp)
+            });
+        });
+        ScrollAreaThumb.displayName = THUMB_NAME;
+        var CORNER_NAME = "ScrollAreaCorner";
+        var ScrollAreaCorner = external_react_.forwardRef((props, forwardedRef)=>{
+            const context = useScrollAreaContext(CORNER_NAME, props.__scopeScrollArea);
+            const hasBothScrollbarsVisible = Boolean(context.scrollbarX && context.scrollbarY);
+            const hasCorner = "scroll" !== context.type && hasBothScrollbarsVisible;
+            return hasCorner ? /* @__PURE__ */ (0, jsx_runtime_.jsx)(ScrollAreaCornerImpl, {
+                ...props,
+                ref: forwardedRef
+            }) : null;
+        });
+        ScrollAreaCorner.displayName = CORNER_NAME;
+        var ScrollAreaCornerImpl = external_react_.forwardRef((props, forwardedRef)=>{
+            const { __scopeScrollArea, ...cornerProps } = props;
+            const context = useScrollAreaContext(CORNER_NAME, __scopeScrollArea);
+            const [width, setWidth] = external_react_.useState(0);
+            const [height, setHeight] = external_react_.useState(0);
+            const hasSize = Boolean(width && height);
+            useResizeObserver(context.scrollbarX, ()=>{
+                const height2 = context.scrollbarX?.offsetHeight || 0;
+                context.onCornerHeightChange(height2);
+                setHeight(height2);
+            });
+            useResizeObserver(context.scrollbarY, ()=>{
+                const width2 = context.scrollbarY?.offsetWidth || 0;
+                context.onCornerWidthChange(width2);
+                setWidth(width2);
+            });
+            return hasSize ? /* @__PURE__ */ (0, jsx_runtime_.jsx)(dist.sG.div, {
+                ...cornerProps,
+                ref: forwardedRef,
+                style: {
+                    width,
+                    height,
+                    position: "absolute",
+                    right: "ltr" === context.dir ? 0 : void 0,
+                    left: "rtl" === context.dir ? 0 : void 0,
+                    bottom: 0,
+                    ...props.style
+                }
+            }) : null;
+        });
+        function toInt(value) {
+            return value ? parseInt(value, 10) : 0;
+        }
+        function getThumbRatio(viewportSize, contentSize) {
+            const ratio = viewportSize / contentSize;
+            return isNaN(ratio) ? 0 : ratio;
+        }
+        function getThumbSize(sizes) {
+            const ratio = getThumbRatio(sizes.viewport, sizes.content);
+            const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
+            const thumbSize = (sizes.scrollbar.size - scrollbarPadding) * ratio;
+            return Math.max(thumbSize, 18);
+        }
+        function getScrollPositionFromPointer(pointerPos, pointerOffset, sizes, dir = "ltr") {
+            const thumbSizePx = getThumbSize(sizes);
+            const thumbCenter = thumbSizePx / 2;
+            const offset = pointerOffset || thumbCenter;
+            const thumbOffsetFromEnd = thumbSizePx - offset;
+            const minPointerPos = sizes.scrollbar.paddingStart + offset;
+            const maxPointerPos = sizes.scrollbar.size - sizes.scrollbar.paddingEnd - thumbOffsetFromEnd;
+            const maxScrollPos = sizes.content - sizes.viewport;
+            const scrollRange = "ltr" === dir ? [
+                0,
+                maxScrollPos
+            ] : [
+                -1 * maxScrollPos,
+                0
+            ];
+            const interpolate = linearScale([
+                minPointerPos,
+                maxPointerPos
+            ], scrollRange);
+            return interpolate(pointerPos);
+        }
+        function getThumbOffsetFromScroll(scrollPos, sizes, dir = "ltr") {
+            const thumbSizePx = getThumbSize(sizes);
+            const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
+            const scrollbar = sizes.scrollbar.size - scrollbarPadding;
+            const maxScrollPos = sizes.content - sizes.viewport;
+            const maxThumbPos = scrollbar - thumbSizePx;
+            const scrollClampRange = "ltr" === dir ? [
+                0,
+                maxScrollPos
+            ] : [
+                -1 * maxScrollPos,
+                0
+            ];
+            const scrollWithoutMomentum = clamp(scrollPos, scrollClampRange);
+            const interpolate = linearScale([
+                0,
+                maxScrollPos
+            ], [
+                0,
+                maxThumbPos
+            ]);
+            return interpolate(scrollWithoutMomentum);
+        }
+        function linearScale(input, output) {
+            return (value)=>{
+                if (input[0] === input[1] || output[0] === output[1]) return output[0];
+                const ratio = (output[1] - output[0]) / (input[1] - input[0]);
+                return output[0] + ratio * (value - input[0]);
+            };
+        }
+        function isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos) {
+            return scrollPos > 0 && scrollPos < maxScrollPos;
+        }
+        var addUnlinkedScrollListener = (node, handler = ()=>{})=>{
+            let prevPosition = {
+                left: node.scrollLeft,
+                top: node.scrollTop
+            };
+            let rAF = 0;
+            (function loop() {
+                const position = {
+                    left: node.scrollLeft,
+                    top: node.scrollTop
+                };
+                const isHorizontalScroll = prevPosition.left !== position.left;
+                const isVerticalScroll = prevPosition.top !== position.top;
+                if (isHorizontalScroll || isVerticalScroll) handler();
+                prevPosition = position;
+                rAF = window.requestAnimationFrame(loop);
+            })();
+            return ()=>window.cancelAnimationFrame(rAF);
+        };
+        function useDebounceCallback(callback, delay) {
+            const handleCallback = (0, react_use_callback_ref_dist.c)(callback);
+            const debounceTimerRef = external_react_.useRef(0);
+            external_react_.useEffect(()=>()=>window.clearTimeout(debounceTimerRef.current), []);
+            return external_react_.useCallback(()=>{
+                window.clearTimeout(debounceTimerRef.current);
+                debounceTimerRef.current = window.setTimeout(handleCallback, delay);
+            }, [
+                handleCallback,
+                delay
+            ]);
+        }
+        function useResizeObserver(element, onResize) {
+            const handleResize = (0, react_use_callback_ref_dist.c)(onResize);
+            (0, react_use_layout_effect_dist.N)(()=>{
+                let rAF = 0;
+                if (element) {
+                    const resizeObserver = new ResizeObserver(()=>{
+                        cancelAnimationFrame(rAF);
+                        rAF = window.requestAnimationFrame(handleResize);
+                    });
+                    resizeObserver.observe(element);
+                    return ()=>{
+                        window.cancelAnimationFrame(rAF);
+                        resizeObserver.unobserve(element);
+                    };
+                }
+            }, [
+                element,
+                handleResize
+            ]);
+        }
+        var dist_Root = ScrollArea;
+        var Viewport = ScrollAreaViewport;
+        var Corner = ScrollAreaCorner;
+    },
+    "../../node_modules/.pnpm/@radix-ui+react-slot@1.2.3_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-slot/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            TL: ()=>createSlot,
+            bL: ()=>Slot
+        });
+        var react__rspack_import_0 = __webpack_require__("react");
+        var _radix_ui_react_compose_refs__rspack_import_2 = __webpack_require__("../../node_modules/.pnpm/@radix-ui+react-compose-refs@1.1.2_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-compose-refs/dist/index.mjs");
+        var react_jsx_runtime__rspack_import_1 = __webpack_require__("react/jsx-runtime");
+        function createSlot(ownerName) {
+            const SlotClone = /* @__PURE__ */ createSlotClone(ownerName);
+            const Slot2 = react__rspack_import_0.forwardRef((props, forwardedRef)=>{
+                const { children, ...slotProps } = props;
+                const childrenArray = react__rspack_import_0.Children.toArray(children);
+                const slottable = childrenArray.find(isSlottable);
+                if (slottable) {
+                    const newElement = slottable.props.children;
+                    const newChildren = childrenArray.map((child)=>{
+                        if (child !== slottable) return child;
+                        if (react__rspack_import_0.Children.count(newElement) > 1) return react__rspack_import_0.Children.only(null);
+                        return react__rspack_import_0.isValidElement(newElement) ? newElement.props.children : null;
+                    });
+                    return /* @__PURE__ */ (0, react_jsx_runtime__rspack_import_1.jsx)(SlotClone, {
+                        ...slotProps,
+                        ref: forwardedRef,
+                        children: react__rspack_import_0.isValidElement(newElement) ? react__rspack_import_0.cloneElement(newElement, void 0, newChildren) : null
+                    });
+                }
+                return /* @__PURE__ */ (0, react_jsx_runtime__rspack_import_1.jsx)(SlotClone, {
+                    ...slotProps,
+                    ref: forwardedRef,
+                    children
+                });
+            });
+            Slot2.displayName = `${ownerName}.Slot`;
+            return Slot2;
+        }
+        var Slot = /* @__PURE__ */ createSlot("Slot");
+        function createSlotClone(ownerName) {
+            const SlotClone = react__rspack_import_0.forwardRef((props, forwardedRef)=>{
+                const { children, ...slotProps } = props;
+                if (react__rspack_import_0.isValidElement(children)) {
+                    const childrenRef = getElementRef(children);
+                    const props2 = mergeProps(slotProps, children.props);
+                    if (children.type !== react__rspack_import_0.Fragment) props2.ref = forwardedRef ? (0, _radix_ui_react_compose_refs__rspack_import_2.t)(forwardedRef, childrenRef) : childrenRef;
+                    return react__rspack_import_0.cloneElement(children, props2);
+                }
+                return react__rspack_import_0.Children.count(children) > 1 ? react__rspack_import_0.Children.only(null) : null;
+            });
+            SlotClone.displayName = `${ownerName}.SlotClone`;
+            return SlotClone;
+        }
+        var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable");
+        function isSlottable(child) {
+            return react__rspack_import_0.isValidElement(child) && "function" == typeof child.type && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
+        }
+        function mergeProps(slotProps, childProps) {
+            const overrideProps = {
+                ...childProps
+            };
+            for(const propName in childProps){
+                const slotPropValue = slotProps[propName];
+                const childPropValue = childProps[propName];
+                const isHandler = /^on[A-Z]/.test(propName);
+                if (isHandler) {
+                    if (slotPropValue && childPropValue) overrideProps[propName] = (...args)=>{
+                        const result = childPropValue(...args);
+                        slotPropValue(...args);
+                        return result;
+                    };
+                    else if (slotPropValue) overrideProps[propName] = slotPropValue;
+                } else if ("style" === propName) overrideProps[propName] = {
+                    ...slotPropValue,
+                    ...childPropValue
+                };
+                else if ("className" === propName) overrideProps[propName] = [
+                    slotPropValue,
+                    childPropValue
+                ].filter(Boolean).join(" ");
+            }
+            return {
+                ...slotProps,
+                ...overrideProps
+            };
+        }
+        function getElementRef(element) {
+            let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+            let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+            if (mayWarn) return element.ref;
+            getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+            mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+            if (mayWarn) return element.props.ref;
+            return element.props.ref || element.ref;
+        }
+    },
+    "../../node_modules/.pnpm/@radix-ui+react-use-callback-ref@1.1.1_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            c: ()=>useCallbackRef
+        });
+        var react__rspack_import_0 = __webpack_require__("react");
+        function useCallbackRef(callback) {
+            const callbackRef = react__rspack_import_0.useRef(callback);
+            react__rspack_import_0.useEffect(()=>{
+                callbackRef.current = callback;
+            });
+            return react__rspack_import_0.useMemo(()=>(...args)=>callbackRef.current?.(...args), []);
+        }
+    },
+    "../../node_modules/.pnpm/@radix-ui+react-use-layout-effect@1.1.1_@types+react@19.2.9_react@19.2.3/node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            N: ()=>useLayoutEffect2
+        });
+        var react__rspack_import_0 = __webpack_require__("react");
+        var useLayoutEffect2 = globalThis?.document ? react__rspack_import_0.useLayoutEffect : ()=>{};
+    },
+    "../../node_modules/.pnpm/embla-carousel-react@8.6.0_react@19.2.3/node_modules/embla-carousel-react/esm/embla-carousel-react.esm.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>useEmblaCarousel
+        });
+        var external_react_ = __webpack_require__("react");
+        function isObject(subject) {
+            return '[object Object]' === Object.prototype.toString.call(subject);
+        }
+        function isRecord(subject) {
+            return isObject(subject) || Array.isArray(subject);
+        }
+        function canUseDOM() {
+            return !!("u" > typeof window && window.document && window.document.createElement);
+        }
+        function areOptionsEqual(optionsA, optionsB) {
+            const optionsAKeys = Object.keys(optionsA);
+            const optionsBKeys = Object.keys(optionsB);
+            if (optionsAKeys.length !== optionsBKeys.length) return false;
+            const breakpointsA = JSON.stringify(Object.keys(optionsA.breakpoints || {}));
+            const breakpointsB = JSON.stringify(Object.keys(optionsB.breakpoints || {}));
+            if (breakpointsA !== breakpointsB) return false;
+            return optionsAKeys.every((key)=>{
+                const valueA = optionsA[key];
+                const valueB = optionsB[key];
+                if ('function' == typeof valueA) return `${valueA}` === `${valueB}`;
+                if (!isRecord(valueA) || !isRecord(valueB)) return valueA === valueB;
+                return areOptionsEqual(valueA, valueB);
+            });
+        }
+        function sortAndMapPluginToOptions(plugins) {
+            return plugins.concat().sort((a, b)=>a.name > b.name ? 1 : -1).map((plugin)=>plugin.options);
+        }
+        function arePluginsEqual(pluginsA, pluginsB) {
+            if (pluginsA.length !== pluginsB.length) return false;
+            const optionsA = sortAndMapPluginToOptions(pluginsA);
+            const optionsB = sortAndMapPluginToOptions(pluginsB);
+            return optionsA.every((optionA, index)=>{
+                const optionB = optionsB[index];
+                return areOptionsEqual(optionA, optionB);
+            });
+        }
+        function isNumber(subject) {
+            return 'number' == typeof subject;
+        }
+        function isString(subject) {
+            return 'string' == typeof subject;
+        }
+        function isBoolean(subject) {
+            return 'boolean' == typeof subject;
+        }
+        function embla_carousel_esm_isObject(subject) {
+            return '[object Object]' === Object.prototype.toString.call(subject);
+        }
+        function mathAbs(n) {
+            return Math.abs(n);
+        }
+        function mathSign(n) {
+            return Math.sign(n);
+        }
+        function deltaAbs(valueB, valueA) {
+            return mathAbs(valueB - valueA);
+        }
+        function factorAbs(valueB, valueA) {
+            if (0 === valueB || 0 === valueA) return 0;
+            if (mathAbs(valueB) <= mathAbs(valueA)) return 0;
+            const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA));
+            return mathAbs(diff / valueB);
+        }
+        function roundToTwoDecimals(num) {
+            return Math.round(100 * num) / 100;
+        }
+        function arrayKeys(array) {
+            return objectKeys(array).map(Number);
+        }
+        function arrayLast(array) {
+            return array[arrayLastIndex(array)];
+        }
+        function arrayLastIndex(array) {
+            return Math.max(0, array.length - 1);
+        }
+        function arrayIsLastIndex(array, index) {
+            return index === arrayLastIndex(array);
+        }
+        function arrayFromNumber(n, startAt = 0) {
+            return Array.from(Array(n), (_, i)=>startAt + i);
+        }
+        function objectKeys(object) {
+            return Object.keys(object);
+        }
+        function objectsMergeDeep(objectA, objectB) {
+            return [
+                objectA,
+                objectB
+            ].reduce((mergedObjects, currentObject)=>{
+                objectKeys(currentObject).forEach((key)=>{
+                    const valueA = mergedObjects[key];
+                    const valueB = currentObject[key];
+                    const areObjects = embla_carousel_esm_isObject(valueA) && embla_carousel_esm_isObject(valueB);
+                    mergedObjects[key] = areObjects ? objectsMergeDeep(valueA, valueB) : valueB;
+                });
+                return mergedObjects;
+            }, {});
+        }
+        function isMouseEvent(evt, ownerWindow) {
+            return void 0 !== ownerWindow.MouseEvent && evt instanceof ownerWindow.MouseEvent;
+        }
+        function Alignment(align, viewSize) {
+            const predefined = {
+                start,
+                center,
+                end
+            };
+            function start() {
+                return 0;
+            }
+            function center(n) {
+                return end(n) / 2;
+            }
+            function end(n) {
+                return viewSize - n;
+            }
+            function measure(n, index) {
+                if (isString(align)) return predefined[align](n);
+                return align(viewSize, n, index);
+            }
+            const self = {
+                measure
+            };
+            return self;
+        }
+        function EventStore() {
+            let listeners = [];
+            function add(node, type, handler, options = {
+                passive: true
+            }) {
+                let removeListener;
+                if ('addEventListener' in node) {
+                    node.addEventListener(type, handler, options);
+                    removeListener = ()=>node.removeEventListener(type, handler, options);
+                } else {
+                    const legacyMediaQueryList = node;
+                    legacyMediaQueryList.addListener(handler);
+                    removeListener = ()=>legacyMediaQueryList.removeListener(handler);
+                }
+                listeners.push(removeListener);
+                return self;
+            }
+            function clear() {
+                listeners = listeners.filter((remove)=>remove());
+            }
+            const self = {
+                add,
+                clear
+            };
+            return self;
+        }
+        function Animations(ownerDocument, ownerWindow, update, render) {
+            const documentVisibleHandler = EventStore();
+            const fixedTimeStep = 1000 / 60;
+            let lastTimeStamp = null;
+            let accumulatedTime = 0;
+            let animationId = 0;
+            function init() {
+                documentVisibleHandler.add(ownerDocument, 'visibilitychange', ()=>{
+                    if (ownerDocument.hidden) reset();
+                });
+            }
+            function destroy() {
+                stop();
+                documentVisibleHandler.clear();
+            }
+            function animate(timeStamp) {
+                if (!animationId) return;
+                if (!lastTimeStamp) {
+                    lastTimeStamp = timeStamp;
+                    update();
+                    update();
+                }
+                const timeElapsed = timeStamp - lastTimeStamp;
+                lastTimeStamp = timeStamp;
+                accumulatedTime += timeElapsed;
+                while(accumulatedTime >= fixedTimeStep){
+                    update();
+                    accumulatedTime -= fixedTimeStep;
+                }
+                const alpha = accumulatedTime / fixedTimeStep;
+                render(alpha);
+                if (animationId) animationId = ownerWindow.requestAnimationFrame(animate);
+            }
+            function start() {
+                if (animationId) return;
+                animationId = ownerWindow.requestAnimationFrame(animate);
+            }
+            function stop() {
+                ownerWindow.cancelAnimationFrame(animationId);
+                lastTimeStamp = null;
+                accumulatedTime = 0;
+                animationId = 0;
+            }
+            function reset() {
+                lastTimeStamp = null;
+                accumulatedTime = 0;
+            }
+            const self = {
+                init,
+                destroy,
+                start,
+                stop,
+                update,
+                render
+            };
+            return self;
+        }
+        function Axis(axis, contentDirection) {
+            const isRightToLeft = 'rtl' === contentDirection;
+            const isVertical = 'y' === axis;
+            const scroll = isVertical ? 'y' : 'x';
+            const cross = isVertical ? 'x' : 'y';
+            const sign = !isVertical && isRightToLeft ? -1 : 1;
+            const startEdge = getStartEdge();
+            const endEdge = getEndEdge();
+            function measureSize(nodeRect) {
+                const { height, width } = nodeRect;
+                return isVertical ? height : width;
+            }
+            function getStartEdge() {
+                if (isVertical) return 'top';
+                return isRightToLeft ? 'right' : 'left';
+            }
+            function getEndEdge() {
+                if (isVertical) return 'bottom';
+                return isRightToLeft ? 'left' : 'right';
+            }
+            function direction(n) {
+                return n * sign;
+            }
+            const self = {
+                scroll,
+                cross,
+                startEdge,
+                endEdge,
+                measureSize,
+                direction
+            };
+            return self;
+        }
+        function Limit(min = 0, max = 0) {
+            const length = mathAbs(min - max);
+            function reachedMin(n) {
+                return n < min;
+            }
+            function reachedMax(n) {
+                return n > max;
+            }
+            function reachedAny(n) {
+                return reachedMin(n) || reachedMax(n);
+            }
+            function constrain(n) {
+                if (!reachedAny(n)) return n;
+                return reachedMin(n) ? min : max;
+            }
+            function removeOffset(n) {
+                if (!length) return n;
+                return n - length * Math.ceil((n - max) / length);
+            }
+            const self = {
+                length,
+                max,
+                min,
+                constrain,
+                reachedAny,
+                reachedMax,
+                reachedMin,
+                removeOffset
+            };
+            return self;
+        }
+        function Counter(max, start, loop) {
+            const { constrain } = Limit(0, max);
+            const loopEnd = max + 1;
+            let counter = withinLimit(start);
+            function withinLimit(n) {
+                return loop ? mathAbs((loopEnd + n) % loopEnd) : constrain(n);
+            }
+            function get() {
+                return counter;
+            }
+            function set(n) {
+                counter = withinLimit(n);
+                return self;
+            }
+            function add(n) {
+                return clone().set(get() + n);
+            }
+            function clone() {
+                return Counter(max, get(), loop);
+            }
+            const self = {
+                get,
+                set,
+                add,
+                clone
+            };
+            return self;
+        }
+        function DragHandler(axis, rootNode, ownerDocument, ownerWindow, target, dragTracker, location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, baseFriction, watchDrag) {
+            const { cross: crossAxis, direction } = axis;
+            const focusNodes = [
+                'INPUT',
+                'SELECT',
+                'TEXTAREA'
+            ];
+            const nonPassiveEvent = {
+                passive: false
+            };
+            const initEvents = EventStore();
+            const dragEvents = EventStore();
+            const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20));
+            const snapForceBoost = {
+                mouse: 300,
+                touch: 400
+            };
+            const freeForceBoost = {
+                mouse: 500,
+                touch: 600
+            };
+            const baseSpeed = dragFree ? 43 : 25;
+            let isMoving = false;
+            let startScroll = 0;
+            let startCross = 0;
+            let pointerIsDown = false;
+            let preventScroll = false;
+            let preventClick = false;
+            let isMouse = false;
+            function init(emblaApi) {
+                if (!watchDrag) return;
+                function downIfAllowed(evt) {
+                    if (isBoolean(watchDrag) || watchDrag(emblaApi, evt)) down(evt);
+                }
+                const node = rootNode;
+                initEvents.add(node, 'dragstart', (evt)=>evt.preventDefault(), nonPassiveEvent).add(node, 'touchmove', ()=>void 0, nonPassiveEvent).add(node, 'touchend', ()=>void 0).add(node, 'touchstart', downIfAllowed).add(node, 'mousedown', downIfAllowed).add(node, 'touchcancel', up).add(node, 'contextmenu', up).add(node, 'click', click, true);
+            }
+            function destroy() {
+                initEvents.clear();
+                dragEvents.clear();
+            }
+            function addDragEvents() {
+                const node = isMouse ? ownerDocument : rootNode;
+                dragEvents.add(node, 'touchmove', move, nonPassiveEvent).add(node, 'touchend', up).add(node, 'mousemove', move, nonPassiveEvent).add(node, 'mouseup', up);
+            }
+            function isFocusNode(node) {
+                const nodeName = node.nodeName || '';
+                return focusNodes.includes(nodeName);
+            }
+            function forceBoost() {
+                const boost = dragFree ? freeForceBoost : snapForceBoost;
+                const type = isMouse ? 'mouse' : 'touch';
+                return boost[type];
+            }
+            function allowedForce(force, targetChanged) {
+                const next = index.add(-1 * mathSign(force));
+                const baseForce = scrollTarget.byDistance(force, !dragFree).distance;
+                if (dragFree || mathAbs(force) < goToNextThreshold) return baseForce;
+                if (skipSnaps && targetChanged) return 0.5 * baseForce;
+                return scrollTarget.byIndex(next.get(), 0).distance;
+            }
+            function down(evt) {
+                const isMouseEvt = isMouseEvent(evt, ownerWindow);
+                isMouse = isMouseEvt;
+                preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving;
+                isMoving = deltaAbs(target.get(), location.get()) >= 2;
+                if (isMouseEvt && 0 !== evt.button) return;
+                if (isFocusNode(evt.target)) return;
+                pointerIsDown = true;
+                dragTracker.pointerDown(evt);
+                scrollBody.useFriction(0).useDuration(0);
+                target.set(location);
+                addDragEvents();
+                startScroll = dragTracker.readPoint(evt);
+                startCross = dragTracker.readPoint(evt, crossAxis);
+                eventHandler.emit('pointerDown');
+            }
+            function move(evt) {
+                const isTouchEvt = !isMouseEvent(evt, ownerWindow);
+                if (isTouchEvt && evt.touches.length >= 2) return up(evt);
+                const lastScroll = dragTracker.readPoint(evt);
+                const lastCross = dragTracker.readPoint(evt, crossAxis);
+                const diffScroll = deltaAbs(lastScroll, startScroll);
+                const diffCross = deltaAbs(lastCross, startCross);
+                if (!preventScroll && !isMouse) {
+                    if (!evt.cancelable) return up(evt);
+                    preventScroll = diffScroll > diffCross;
+                    if (!preventScroll) return up(evt);
+                }
+                const diff = dragTracker.pointerMove(evt);
+                if (diffScroll > dragThreshold) preventClick = true;
+                scrollBody.useFriction(0.3).useDuration(0.75);
+                animation.start();
+                target.add(direction(diff));
+                evt.preventDefault();
+            }
+            function up(evt) {
+                const currentLocation = scrollTarget.byDistance(0, false);
+                const targetChanged = currentLocation.index !== index.get();
+                const rawForce = dragTracker.pointerUp(evt) * forceBoost();
+                const force = allowedForce(direction(rawForce), targetChanged);
+                const forceFactor = factorAbs(rawForce, force);
+                const speed = baseSpeed - 10 * forceFactor;
+                const friction = baseFriction + forceFactor / 50;
+                preventScroll = false;
+                pointerIsDown = false;
+                dragEvents.clear();
+                scrollBody.useDuration(speed).useFriction(friction);
+                scrollTo.distance(force, !dragFree);
+                isMouse = false;
+                eventHandler.emit('pointerUp');
+            }
+            function click(evt) {
+                if (preventClick) {
+                    evt.stopPropagation();
+                    evt.preventDefault();
+                    preventClick = false;
+                }
+            }
+            function pointerDown() {
+                return pointerIsDown;
+            }
+            const self = {
+                init,
+                destroy,
+                pointerDown
+            };
+            return self;
+        }
+        function DragTracker(axis, ownerWindow) {
+            const logInterval = 170;
+            let startEvent;
+            let lastEvent;
+            function readTime(evt) {
+                return evt.timeStamp;
+            }
+            function readPoint(evt, evtAxis) {
+                const property = evtAxis || axis.scroll;
+                const coord = `client${'x' === property ? 'X' : 'Y'}`;
+                return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord];
+            }
+            function pointerDown(evt) {
+                startEvent = evt;
+                lastEvent = evt;
+                return readPoint(evt);
+            }
+            function pointerMove(evt) {
+                const diff = readPoint(evt) - readPoint(lastEvent);
+                const expired = readTime(evt) - readTime(startEvent) > logInterval;
+                lastEvent = evt;
+                if (expired) startEvent = evt;
+                return diff;
+            }
+            function pointerUp(evt) {
+                if (!startEvent || !lastEvent) return 0;
+                const diffDrag = readPoint(lastEvent) - readPoint(startEvent);
+                const diffTime = readTime(evt) - readTime(startEvent);
+                const expired = readTime(evt) - readTime(lastEvent) > logInterval;
+                const force = diffDrag / diffTime;
+                const isFlick = diffTime && !expired && mathAbs(force) > 0.1;
+                return isFlick ? force : 0;
+            }
+            const self = {
+                pointerDown,
+                pointerMove,
+                pointerUp,
+                readPoint
+            };
+            return self;
+        }
+        function NodeRects() {
+            function measure(node) {
+                const { offsetTop, offsetLeft, offsetWidth, offsetHeight } = node;
+                const offset = {
+                    top: offsetTop,
+                    right: offsetLeft + offsetWidth,
+                    bottom: offsetTop + offsetHeight,
+                    left: offsetLeft,
+                    width: offsetWidth,
+                    height: offsetHeight
+                };
+                return offset;
+            }
+            const self = {
+                measure
+            };
+            return self;
+        }
+        function PercentOfView(viewSize) {
+            function measure(n) {
+                return n / 100 * viewSize;
+            }
+            const self = {
+                measure
+            };
+            return self;
+        }
+        function ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects) {
+            const observeNodes = [
+                container
+            ].concat(slides);
+            let resizeObserver;
+            let containerSize;
+            let slideSizes = [];
+            let destroyed = false;
+            function readSize(node) {
+                return axis.measureSize(nodeRects.measure(node));
+            }
+            function init(emblaApi) {
+                if (!watchResize) return;
+                containerSize = readSize(container);
+                slideSizes = slides.map(readSize);
+                function defaultCallback(entries) {
+                    for (const entry of entries){
+                        if (destroyed) return;
+                        const isContainer = entry.target === container;
+                        const slideIndex = slides.indexOf(entry.target);
+                        const lastSize = isContainer ? containerSize : slideSizes[slideIndex];
+                        const newSize = readSize(isContainer ? container : slides[slideIndex]);
+                        const diffSize = mathAbs(newSize - lastSize);
+                        if (diffSize >= 0.5) {
+                            emblaApi.reInit();
+                            eventHandler.emit('resize');
+                            break;
+                        }
+                    }
+                }
+                resizeObserver = new ResizeObserver((entries)=>{
+                    if (isBoolean(watchResize) || watchResize(emblaApi, entries)) defaultCallback(entries);
+                });
+                ownerWindow.requestAnimationFrame(()=>{
+                    observeNodes.forEach((node)=>resizeObserver.observe(node));
+                });
+            }
+            function destroy() {
+                destroyed = true;
+                if (resizeObserver) resizeObserver.disconnect();
+            }
+            const self = {
+                init,
+                destroy
+            };
+            return self;
+        }
+        function ScrollBody(location, offsetLocation, previousLocation, target, baseDuration, baseFriction) {
+            let scrollVelocity = 0;
+            let scrollDirection = 0;
+            let scrollDuration = baseDuration;
+            let scrollFriction = baseFriction;
+            let rawLocation = location.get();
+            let rawLocationPrevious = 0;
+            function seek() {
+                const displacement = target.get() - location.get();
+                const isInstant = !scrollDuration;
+                let scrollDistance = 0;
+                if (isInstant) {
+                    scrollVelocity = 0;
+                    previousLocation.set(target);
+                    location.set(target);
+                    scrollDistance = displacement;
+                } else {
+                    previousLocation.set(location);
+                    scrollVelocity += displacement / scrollDuration;
+                    scrollVelocity *= scrollFriction;
+                    rawLocation += scrollVelocity;
+                    location.add(scrollVelocity);
+                    scrollDistance = rawLocation - rawLocationPrevious;
+                }
+                scrollDirection = mathSign(scrollDistance);
+                rawLocationPrevious = rawLocation;
+                return self;
+            }
+            function settled() {
+                const diff = target.get() - offsetLocation.get();
+                return mathAbs(diff) < 0.001;
+            }
+            function duration() {
+                return scrollDuration;
+            }
+            function direction() {
+                return scrollDirection;
+            }
+            function velocity() {
+                return scrollVelocity;
+            }
+            function useBaseDuration() {
+                return useDuration(baseDuration);
+            }
+            function useBaseFriction() {
+                return useFriction(baseFriction);
+            }
+            function useDuration(n) {
+                scrollDuration = n;
+                return self;
+            }
+            function useFriction(n) {
+                scrollFriction = n;
+                return self;
+            }
+            const self = {
+                direction,
+                duration,
+                velocity,
+                seek,
+                settled,
+                useBaseFriction,
+                useBaseDuration,
+                useFriction,
+                useDuration
+            };
+            return self;
+        }
+        function ScrollBounds(limit, location, target, scrollBody, percentOfView) {
+            const pullBackThreshold = percentOfView.measure(10);
+            const edgeOffsetTolerance = percentOfView.measure(50);
+            const frictionLimit = Limit(0.1, 0.99);
+            let disabled = false;
+            function shouldConstrain() {
+                if (disabled) return false;
+                if (!limit.reachedAny(target.get())) return false;
+                if (!limit.reachedAny(location.get())) return false;
+                return true;
+            }
+            function constrain(pointerDown) {
+                if (!shouldConstrain()) return;
+                const edge = limit.reachedMin(location.get()) ? 'min' : 'max';
+                const diffToEdge = mathAbs(limit[edge] - location.get());
+                const diffToTarget = target.get() - location.get();
+                const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance);
+                target.subtract(diffToTarget * friction);
+                if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {
+                    target.set(limit.constrain(target.get()));
+                    scrollBody.useDuration(25).useBaseFriction();
+                }
+            }
+            function toggleActive(active) {
+                disabled = !active;
+            }
+            const self = {
+                shouldConstrain,
+                constrain,
+                toggleActive
+            };
+            return self;
+        }
+        function ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance) {
+            const scrollBounds = Limit(-contentSize + viewSize, 0);
+            const snapsBounded = measureBounded();
+            const scrollContainLimit = findScrollContainLimit();
+            const snapsContained = measureContained();
+            function usePixelTolerance(bound, snap) {
+                return deltaAbs(bound, snap) <= 1;
+            }
+            function findScrollContainLimit() {
+                const startSnap = snapsBounded[0];
+                const endSnap = arrayLast(snapsBounded);
+                const min = snapsBounded.lastIndexOf(startSnap);
+                const max = snapsBounded.indexOf(endSnap) + 1;
+                return Limit(min, max);
+            }
+            function measureBounded() {
+                return snapsAligned.map((snapAligned, index)=>{
+                    const { min, max } = scrollBounds;
+                    const snap = scrollBounds.constrain(snapAligned);
+                    const isFirst = !index;
+                    const isLast = arrayIsLastIndex(snapsAligned, index);
+                    if (isFirst) return max;
+                    if (isLast) return min;
+                    if (usePixelTolerance(min, snap)) return min;
+                    if (usePixelTolerance(max, snap)) return max;
+                    return snap;
+                }).map((scrollBound)=>parseFloat(scrollBound.toFixed(3)));
+            }
+            function measureContained() {
+                if (contentSize <= viewSize + pixelTolerance) return [
+                    scrollBounds.max
+                ];
+                if ('keepSnaps' === containScroll) return snapsBounded;
+                const { min, max } = scrollContainLimit;
+                return snapsBounded.slice(min, max);
+            }
+            const self = {
+                snapsContained,
+                scrollContainLimit
+            };
+            return self;
+        }
+        function ScrollLimit(contentSize, scrollSnaps, loop) {
+            const max = scrollSnaps[0];
+            const min = loop ? max - contentSize : arrayLast(scrollSnaps);
+            const limit = Limit(min, max);
+            const self = {
+                limit
+            };
+            return self;
+        }
+        function ScrollLooper(contentSize, limit, location, vectors) {
+            const jointSafety = 0.1;
+            const min = limit.min + jointSafety;
+            const max = limit.max + jointSafety;
+            const { reachedMin, reachedMax } = Limit(min, max);
+            function shouldLoop(direction) {
+                if (1 === direction) return reachedMax(location.get());
+                if (-1 === direction) return reachedMin(location.get());
+                return false;
+            }
+            function loop(direction) {
+                if (!shouldLoop(direction)) return;
+                const loopDistance = -1 * direction * contentSize;
+                vectors.forEach((v)=>v.add(loopDistance));
+            }
+            const self = {
+                loop
+            };
+            return self;
+        }
+        function ScrollProgress(limit) {
+            const { max, length } = limit;
+            function get(n) {
+                const currentLocation = n - max;
+                return length ? currentLocation / -length : 0;
+            }
+            const self = {
+                get
+            };
+            return self;
+        }
+        function ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll) {
+            const { startEdge, endEdge } = axis;
+            const { groupSlides } = slidesToScroll;
+            const alignments = measureSizes().map(alignment.measure);
+            const snaps = measureUnaligned();
+            const snapsAligned = measureAligned();
+            function measureSizes() {
+                return groupSlides(slideRects).map((rects)=>arrayLast(rects)[endEdge] - rects[0][startEdge]).map(mathAbs);
+            }
+            function measureUnaligned() {
+                return slideRects.map((rect)=>containerRect[startEdge] - rect[startEdge]).map((snap)=>-mathAbs(snap));
+            }
+            function measureAligned() {
+                return groupSlides(snaps).map((g)=>g[0]).map((snap, index)=>snap + alignments[index]);
+            }
+            const self = {
+                snaps,
+                snapsAligned
+            };
+            return self;
+        }
+        function SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes) {
+            const { groupSlides } = slidesToScroll;
+            const { min, max } = scrollContainLimit;
+            const slideRegistry = createSlideRegistry();
+            function createSlideRegistry() {
+                const groupedSlideIndexes = groupSlides(slideIndexes);
+                const doNotContain = !containSnaps || 'keepSnaps' === containScroll;
+                if (1 === scrollSnaps.length) return [
+                    slideIndexes
+                ];
+                if (doNotContain) return groupedSlideIndexes;
+                return groupedSlideIndexes.slice(min, max).map((group, index, groups)=>{
+                    const isFirst = !index;
+                    const isLast = arrayIsLastIndex(groups, index);
+                    if (isFirst) {
+                        const range = arrayLast(groups[0]) + 1;
+                        return arrayFromNumber(range);
+                    }
+                    if (isLast) {
+                        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1;
+                        return arrayFromNumber(range, arrayLast(groups)[0]);
+                    }
+                    return group;
+                });
+            }
+            const self = {
+                slideRegistry
+            };
+            return self;
+        }
+        function ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {
+            const { reachedAny, removeOffset, constrain } = limit;
+            function minDistance(distances) {
+                return distances.concat().sort((a, b)=>mathAbs(a) - mathAbs(b))[0];
+            }
+            function findTargetSnap(target) {
+                const distance = loop ? removeOffset(target) : constrain(target);
+                const ascDiffsToSnaps = scrollSnaps.map((snap, index)=>({
+                        diff: shortcut(snap - distance, 0),
+                        index
+                    })).sort((d1, d2)=>mathAbs(d1.diff) - mathAbs(d2.diff));
+                const { index } = ascDiffsToSnaps[0];
+                return {
+                    index,
+                    distance
+                };
+            }
+            function shortcut(target, direction) {
+                const targets = [
+                    target,
+                    target + contentSize,
+                    target - contentSize
+                ];
+                if (!loop) return target;
+                if (!direction) return minDistance(targets);
+                const matchingTargets = targets.filter((t)=>mathSign(t) === direction);
+                if (matchingTargets.length) return minDistance(matchingTargets);
+                return arrayLast(targets) - contentSize;
+            }
+            function byIndex(index, direction) {
+                const diffToSnap = scrollSnaps[index] - targetVector.get();
+                const distance = shortcut(diffToSnap, direction);
+                return {
+                    index,
+                    distance
+                };
+            }
+            function byDistance(distance, snap) {
+                const target = targetVector.get() + distance;
+                const { index, distance: targetSnapDistance } = findTargetSnap(target);
+                const reachedBound = !loop && reachedAny(target);
+                if (!snap || reachedBound) return {
+                    index,
+                    distance
+                };
+                const diffToSnap = scrollSnaps[index] - targetSnapDistance;
+                const snapDistance = distance + shortcut(diffToSnap, 0);
+                return {
+                    index,
+                    distance: snapDistance
+                };
+            }
+            const self = {
+                byDistance,
+                byIndex,
+                shortcut
+            };
+            return self;
+        }
+        function ScrollTo(animation, indexCurrent, indexPrevious, scrollBody, scrollTarget, targetVector, eventHandler) {
+            function scrollTo(target) {
+                const distanceDiff = target.distance;
+                const indexDiff = target.index !== indexCurrent.get();
+                targetVector.add(distanceDiff);
+                if (distanceDiff) if (scrollBody.duration()) animation.start();
+                else {
+                    animation.update();
+                    animation.render(1);
+                    animation.update();
+                }
+                if (indexDiff) {
+                    indexPrevious.set(indexCurrent.get());
+                    indexCurrent.set(target.index);
+                    eventHandler.emit('select');
+                }
+            }
+            function distance(n, snap) {
+                const target = scrollTarget.byDistance(n, snap);
+                scrollTo(target);
+            }
+            function index(n, direction) {
+                const targetIndex = indexCurrent.clone().set(n);
+                const target = scrollTarget.byIndex(targetIndex.get(), direction);
+                scrollTo(target);
+            }
+            const self = {
+                distance,
+                index
+            };
+            return self;
+        }
+        function SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler, watchFocus) {
+            const focusListenerOptions = {
+                passive: true,
+                capture: true
+            };
+            let lastTabPressTime = 0;
+            function init(emblaApi) {
+                if (!watchFocus) return;
+                function defaultCallback(index) {
+                    const nowTime = new Date().getTime();
+                    const diffTime = nowTime - lastTabPressTime;
+                    if (diffTime > 10) return;
+                    eventHandler.emit('slideFocusStart');
+                    root.scrollLeft = 0;
+                    const group = slideRegistry.findIndex((group)=>group.includes(index));
+                    if (!isNumber(group)) return;
+                    scrollBody.useDuration(0);
+                    scrollTo.index(group, 0);
+                    eventHandler.emit('slideFocus');
+                }
+                eventStore.add(document, 'keydown', registerTabPress, false);
+                slides.forEach((slide, slideIndex)=>{
+                    eventStore.add(slide, 'focus', (evt)=>{
+                        if (isBoolean(watchFocus) || watchFocus(emblaApi, evt)) defaultCallback(slideIndex);
+                    }, focusListenerOptions);
+                });
+            }
+            function registerTabPress(event) {
+                if ('Tab' === event.code) lastTabPressTime = new Date().getTime();
+            }
+            const self = {
+                init
+            };
+            return self;
+        }
+        function Vector1D(initialValue) {
+            let value = initialValue;
+            function get() {
+                return value;
+            }
+            function set(n) {
+                value = normalizeInput(n);
+            }
+            function add(n) {
+                value += normalizeInput(n);
+            }
+            function subtract(n) {
+                value -= normalizeInput(n);
+            }
+            function normalizeInput(n) {
+                return isNumber(n) ? n : n.get();
+            }
+            const self = {
+                get,
+                set,
+                add,
+                subtract
+            };
+            return self;
+        }
+        function Translate(axis, container) {
+            const translate = 'x' === axis.scroll ? x : y;
+            const containerStyle = container.style;
+            let previousTarget = null;
+            let disabled = false;
+            function x(n) {
+                return `translate3d(${n}px,0px,0px)`;
+            }
+            function y(n) {
+                return `translate3d(0px,${n}px,0px)`;
+            }
+            function to(target) {
+                if (disabled) return;
+                const newTarget = roundToTwoDecimals(axis.direction(target));
+                if (newTarget === previousTarget) return;
+                containerStyle.transform = translate(newTarget);
+                previousTarget = newTarget;
+            }
+            function toggleActive(active) {
+                disabled = !active;
+            }
+            function clear() {
+                if (disabled) return;
+                containerStyle.transform = '';
+                if (!container.getAttribute('style')) container.removeAttribute('style');
+            }
+            const self = {
+                clear,
+                to,
+                toggleActive
+            };
+            return self;
+        }
+        function SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, location, slides) {
+            const roundingSafety = 0.5;
+            const ascItems = arrayKeys(slideSizesWithGaps);
+            const descItems = arrayKeys(slideSizesWithGaps).reverse();
+            const loopPoints = startPoints().concat(endPoints());
+            function removeSlideSizes(indexes, from) {
+                return indexes.reduce((a, i)=>a - slideSizesWithGaps[i], from);
+            }
+            function slidesInGap(indexes, gap) {
+                return indexes.reduce((a, i)=>{
+                    const remainingGap = removeSlideSizes(a, gap);
+                    return remainingGap > 0 ? a.concat([
+                        i
+                    ]) : a;
+                }, []);
+            }
+            function findSlideBounds(offset) {
+                return snaps.map((snap, index)=>({
+                        start: snap - slideSizes[index] + roundingSafety + offset,
+                        end: snap + viewSize - roundingSafety + offset
+                    }));
+            }
+            function findLoopPoints(indexes, offset, isEndEdge) {
+                const slideBounds = findSlideBounds(offset);
+                return indexes.map((index)=>{
+                    const initial = isEndEdge ? 0 : -contentSize;
+                    const altered = isEndEdge ? contentSize : 0;
+                    const boundEdge = isEndEdge ? 'end' : 'start';
+                    const loopPoint = slideBounds[index][boundEdge];
+                    return {
+                        index,
+                        loopPoint,
+                        slideLocation: Vector1D(-1),
+                        translate: Translate(axis, slides[index]),
+                        target: ()=>location.get() > loopPoint ? initial : altered
+                    };
+                });
+            }
+            function startPoints() {
+                const gap = scrollSnaps[0];
+                const indexes = slidesInGap(descItems, gap);
+                return findLoopPoints(indexes, contentSize, false);
+            }
+            function endPoints() {
+                const gap = viewSize - scrollSnaps[0] - 1;
+                const indexes = slidesInGap(ascItems, gap);
+                return findLoopPoints(indexes, -contentSize, true);
+            }
+            function canLoop() {
+                return loopPoints.every(({ index })=>{
+                    const otherIndexes = ascItems.filter((i)=>i !== index);
+                    return removeSlideSizes(otherIndexes, viewSize) <= 0.1;
+                });
+            }
+            function loop() {
+                loopPoints.forEach((loopPoint)=>{
+                    const { target, translate, slideLocation } = loopPoint;
+                    const shiftLocation = target();
+                    if (shiftLocation === slideLocation.get()) return;
+                    translate.to(shiftLocation);
+                    slideLocation.set(shiftLocation);
+                });
+            }
+            function clear() {
+                loopPoints.forEach((loopPoint)=>loopPoint.translate.clear());
+            }
+            const self = {
+                canLoop,
+                clear,
+                loop,
+                loopPoints
+            };
+            return self;
+        }
+        function SlidesHandler(container, eventHandler, watchSlides) {
+            let mutationObserver;
+            let destroyed = false;
+            function init(emblaApi) {
+                if (!watchSlides) return;
+                function defaultCallback(mutations) {
+                    for (const mutation of mutations)if ('childList' === mutation.type) {
+                        emblaApi.reInit();
+                        eventHandler.emit('slidesChanged');
+                        break;
+                    }
+                }
+                mutationObserver = new MutationObserver((mutations)=>{
+                    if (destroyed) return;
+                    if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) defaultCallback(mutations);
+                });
+                mutationObserver.observe(container, {
+                    childList: true
+                });
+            }
+            function destroy() {
+                if (mutationObserver) mutationObserver.disconnect();
+                destroyed = true;
+            }
+            const self = {
+                init,
+                destroy
+            };
+            return self;
+        }
+        function SlidesInView(container, slides, eventHandler, threshold) {
+            const intersectionEntryMap = {};
+            let inViewCache = null;
+            let notInViewCache = null;
+            let intersectionObserver;
+            let destroyed = false;
+            function init() {
+                intersectionObserver = new IntersectionObserver((entries)=>{
+                    if (destroyed) return;
+                    entries.forEach((entry)=>{
+                        const index = slides.indexOf(entry.target);
+                        intersectionEntryMap[index] = entry;
+                    });
+                    inViewCache = null;
+                    notInViewCache = null;
+                    eventHandler.emit('slidesInView');
+                }, {
+                    root: container.parentElement,
+                    threshold
+                });
+                slides.forEach((slide)=>intersectionObserver.observe(slide));
+            }
+            function destroy() {
+                if (intersectionObserver) intersectionObserver.disconnect();
+                destroyed = true;
+            }
+            function createInViewList(inView) {
+                return objectKeys(intersectionEntryMap).reduce((list, slideIndex)=>{
+                    const index = parseInt(slideIndex);
+                    const { isIntersecting } = intersectionEntryMap[index];
+                    const inViewMatch = inView && isIntersecting;
+                    const notInViewMatch = !inView && !isIntersecting;
+                    if (inViewMatch || notInViewMatch) list.push(index);
+                    return list;
+                }, []);
+            }
+            function get(inView = true) {
+                if (inView && inViewCache) return inViewCache;
+                if (!inView && notInViewCache) return notInViewCache;
+                const slideIndexes = createInViewList(inView);
+                if (inView) inViewCache = slideIndexes;
+                if (!inView) notInViewCache = slideIndexes;
+                return slideIndexes;
+            }
+            const self = {
+                init,
+                destroy,
+                get
+            };
+            return self;
+        }
+        function SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow) {
+            const { measureSize, startEdge, endEdge } = axis;
+            const withEdgeGap = slideRects[0] && readEdgeGap;
+            const startGap = measureStartGap();
+            const endGap = measureEndGap();
+            const slideSizes = slideRects.map(measureSize);
+            const slideSizesWithGaps = measureWithGaps();
+            function measureStartGap() {
+                if (!withEdgeGap) return 0;
+                const slideRect = slideRects[0];
+                return mathAbs(containerRect[startEdge] - slideRect[startEdge]);
+            }
+            function measureEndGap() {
+                if (!withEdgeGap) return 0;
+                const style = ownerWindow.getComputedStyle(arrayLast(slides));
+                return parseFloat(style.getPropertyValue(`margin-${endEdge}`));
+            }
+            function measureWithGaps() {
+                return slideRects.map((rect, index, rects)=>{
+                    const isFirst = !index;
+                    const isLast = arrayIsLastIndex(rects, index);
+                    if (isFirst) return slideSizes[index] + startGap;
+                    if (isLast) return slideSizes[index] + endGap;
+                    return rects[index + 1][startEdge] - rect[startEdge];
+                }).map(mathAbs);
+            }
+            const self = {
+                slideSizes,
+                slideSizesWithGaps,
+                startGap,
+                endGap
+            };
+            return self;
+        }
+        function SlidesToScroll(axis, viewSize, slidesToScroll, loop, containerRect, slideRects, startGap, endGap, pixelTolerance) {
+            const { startEdge, endEdge, direction } = axis;
+            const groupByNumber = isNumber(slidesToScroll);
+            function byNumber(array, groupSize) {
+                return arrayKeys(array).filter((i)=>i % groupSize === 0).map((i)=>array.slice(i, i + groupSize));
+            }
+            function bySize(array) {
+                if (!array.length) return [];
+                return arrayKeys(array).reduce((groups, rectB, index)=>{
+                    const rectA = arrayLast(groups) || 0;
+                    const isFirst = 0 === rectA;
+                    const isLast = rectB === arrayLastIndex(array);
+                    const edgeA = containerRect[startEdge] - slideRects[rectA][startEdge];
+                    const edgeB = containerRect[startEdge] - slideRects[rectB][endEdge];
+                    const gapA = !loop && isFirst ? direction(startGap) : 0;
+                    const gapB = !loop && isLast ? direction(endGap) : 0;
+                    const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA));
+                    if (index && chunkSize > viewSize + pixelTolerance) groups.push(rectB);
+                    if (isLast) groups.push(array.length);
+                    return groups;
+                }, []).map((currentSize, index, groups)=>{
+                    const previousSize = Math.max(groups[index - 1] || 0);
+                    return array.slice(previousSize, currentSize);
+                });
+            }
+            function groupSlides(array) {
+                return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array);
+            }
+            const self = {
+                groupSlides
+            };
+            return self;
+        }
+        function Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler) {
+            const { align, axis: scrollAxis, direction, startIndex, loop, duration, dragFree, dragThreshold, inViewThreshold, slidesToScroll: groupSlides, skipSnaps, containScroll, watchResize, watchSlides, watchDrag, watchFocus } = options;
+            const pixelTolerance = 2;
+            const nodeRects = NodeRects();
+            const containerRect = nodeRects.measure(container);
+            const slideRects = slides.map(nodeRects.measure);
+            const axis = Axis(scrollAxis, direction);
+            const viewSize = axis.measureSize(containerRect);
+            const percentOfView = PercentOfView(viewSize);
+            const alignment = Alignment(align, viewSize);
+            const containSnaps = !loop && !!containScroll;
+            const readEdgeGap = loop || !!containScroll;
+            const { slideSizes, slideSizesWithGaps, startGap, endGap } = SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow);
+            const slidesToScroll = SlidesToScroll(axis, viewSize, groupSlides, loop, containerRect, slideRects, startGap, endGap, pixelTolerance);
+            const { snaps, snapsAligned } = ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll);
+            const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps);
+            const { snapsContained, scrollContainLimit } = ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance);
+            const scrollSnaps = containSnaps ? snapsContained : snapsAligned;
+            const { limit } = ScrollLimit(contentSize, scrollSnaps, loop);
+            const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);
+            const indexPrevious = index.clone();
+            const slideIndexes = arrayKeys(slides);
+            const update = ({ dragHandler, scrollBody, scrollBounds, options: { loop } })=>{
+                if (!loop) scrollBounds.constrain(dragHandler.pointerDown());
+                scrollBody.seek();
+            };
+            const render = ({ scrollBody, translate, location, offsetLocation, previousLocation, scrollLooper, slideLooper, dragHandler, animation, eventHandler, scrollBounds, options: { loop } }, alpha)=>{
+                const shouldSettle = scrollBody.settled();
+                const withinBounds = !scrollBounds.shouldConstrain();
+                const hasSettled = loop ? shouldSettle : shouldSettle && withinBounds;
+                const hasSettledAndIdle = hasSettled && !dragHandler.pointerDown();
+                if (hasSettledAndIdle) animation.stop();
+                const interpolatedLocation = location.get() * alpha + previousLocation.get() * (1 - alpha);
+                offsetLocation.set(interpolatedLocation);
+                if (loop) {
+                    scrollLooper.loop(scrollBody.direction());
+                    slideLooper.loop();
+                }
+                translate.to(offsetLocation.get());
+                if (hasSettledAndIdle) eventHandler.emit('settle');
+                if (!hasSettled) eventHandler.emit('scroll');
+            };
+            const animation = Animations(ownerDocument, ownerWindow, ()=>update(engine), (alpha)=>render(engine, alpha));
+            const friction = 0.68;
+            const startLocation = scrollSnaps[index.get()];
+            const location = Vector1D(startLocation);
+            const previousLocation = Vector1D(startLocation);
+            const offsetLocation = Vector1D(startLocation);
+            const target = Vector1D(startLocation);
+            const scrollBody = ScrollBody(location, offsetLocation, previousLocation, target, duration, friction);
+            const scrollTarget = ScrollTarget(loop, scrollSnaps, contentSize, limit, target);
+            const scrollTo = ScrollTo(animation, index, indexPrevious, scrollBody, scrollTarget, target, eventHandler);
+            const scrollProgress = ScrollProgress(limit);
+            const eventStore = EventStore();
+            const slidesInView = SlidesInView(container, slides, eventHandler, inViewThreshold);
+            const { slideRegistry } = SlideRegistry(containSnaps, containScroll, scrollSnaps, scrollContainLimit, slidesToScroll, slideIndexes);
+            const slideFocus = SlideFocus(root, slides, slideRegistry, scrollTo, scrollBody, eventStore, eventHandler, watchFocus);
+            const engine = {
+                ownerDocument,
+                ownerWindow,
+                eventHandler,
+                containerRect,
+                slideRects,
+                animation,
+                axis,
+                dragHandler: DragHandler(axis, root, ownerDocument, ownerWindow, target, DragTracker(axis, ownerWindow), location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, friction, watchDrag),
+                eventStore,
+                percentOfView,
+                index,
+                indexPrevious,
+                limit,
+                location,
+                offsetLocation,
+                previousLocation,
+                options,
+                resizeHandler: ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects),
+                scrollBody,
+                scrollBounds: ScrollBounds(limit, offsetLocation, target, scrollBody, percentOfView),
+                scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [
+                    location,
+                    offsetLocation,
+                    previousLocation,
+                    target
+                ]),
+                scrollProgress,
+                scrollSnapList: scrollSnaps.map(scrollProgress.get),
+                scrollSnaps,
+                scrollTarget,
+                scrollTo,
+                slideLooper: SlideLooper(axis, viewSize, contentSize, slideSizes, slideSizesWithGaps, snaps, scrollSnaps, offsetLocation, slides),
+                slideFocus,
+                slidesHandler: SlidesHandler(container, eventHandler, watchSlides),
+                slidesInView,
+                slideIndexes,
+                slideRegistry,
+                slidesToScroll,
+                target,
+                translate: Translate(axis, container)
+            };
+            return engine;
+        }
+        function EventHandler() {
+            let listeners = {};
+            let api;
+            function init(emblaApi) {
+                api = emblaApi;
+            }
+            function getListeners(evt) {
+                return listeners[evt] || [];
+            }
+            function emit(evt) {
+                getListeners(evt).forEach((e)=>e(api, evt));
+                return self;
+            }
+            function on(evt, cb) {
+                listeners[evt] = getListeners(evt).concat([
+                    cb
+                ]);
+                return self;
+            }
+            function off(evt, cb) {
+                listeners[evt] = getListeners(evt).filter((e)=>e !== cb);
+                return self;
+            }
+            function clear() {
+                listeners = {};
+            }
+            const self = {
+                init,
+                emit,
+                off,
+                on,
+                clear
+            };
+            return self;
+        }
+        const defaultOptions = {
+            align: 'center',
+            axis: 'x',
+            container: null,
+            slides: null,
+            containScroll: 'trimSnaps',
+            direction: 'ltr',
+            slidesToScroll: 1,
+            inViewThreshold: 0,
+            breakpoints: {},
+            dragFree: false,
+            dragThreshold: 10,
+            loop: false,
+            skipSnaps: false,
+            duration: 25,
+            startIndex: 0,
+            active: true,
+            watchDrag: true,
+            watchResize: true,
+            watchSlides: true,
+            watchFocus: true
+        };
+        function OptionsHandler(ownerWindow) {
+            function mergeOptions(optionsA, optionsB) {
+                return objectsMergeDeep(optionsA, optionsB || {});
+            }
+            function optionsAtMedia(options) {
+                const optionsAtMedia = options.breakpoints || {};
+                const matchedMediaOptions = objectKeys(optionsAtMedia).filter((media)=>ownerWindow.matchMedia(media).matches).map((media)=>optionsAtMedia[media]).reduce((a, mediaOption)=>mergeOptions(a, mediaOption), {});
+                return mergeOptions(options, matchedMediaOptions);
+            }
+            function optionsMediaQueries(optionsList) {
+                return optionsList.map((options)=>objectKeys(options.breakpoints || {})).reduce((acc, mediaQueries)=>acc.concat(mediaQueries), []).map(ownerWindow.matchMedia);
+            }
+            const self = {
+                mergeOptions,
+                optionsAtMedia,
+                optionsMediaQueries
+            };
+            return self;
+        }
+        function PluginsHandler(optionsHandler) {
+            let activePlugins = [];
+            function init(emblaApi, plugins) {
+                activePlugins = plugins.filter(({ options })=>false !== optionsHandler.optionsAtMedia(options).active);
+                activePlugins.forEach((plugin)=>plugin.init(emblaApi, optionsHandler));
+                return plugins.reduce((map, plugin)=>Object.assign(map, {
+                        [plugin.name]: plugin
+                    }), {});
+            }
+            function destroy() {
+                activePlugins = activePlugins.filter((plugin)=>plugin.destroy());
+            }
+            const self = {
+                init,
+                destroy
+            };
+            return self;
+        }
+        function EmblaCarousel(root, userOptions, userPlugins) {
+            const ownerDocument = root.ownerDocument;
+            const ownerWindow = ownerDocument.defaultView;
+            const optionsHandler = OptionsHandler(ownerWindow);
+            const pluginsHandler = PluginsHandler(optionsHandler);
+            const mediaHandlers = EventStore();
+            const eventHandler = EventHandler();
+            const { mergeOptions, optionsAtMedia, optionsMediaQueries } = optionsHandler;
+            const { on, off, emit } = eventHandler;
+            const reInit = reActivate;
+            let destroyed = false;
+            let engine;
+            let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions);
+            let options = mergeOptions(optionsBase);
+            let pluginList = [];
+            let pluginApis;
+            let container;
+            let slides;
+            function storeElements() {
+                const { container: userContainer, slides: userSlides } = options;
+                const customContainer = isString(userContainer) ? root.querySelector(userContainer) : userContainer;
+                container = customContainer || root.children[0];
+                const customSlides = isString(userSlides) ? container.querySelectorAll(userSlides) : userSlides;
+                slides = [].slice.call(customSlides || container.children);
+            }
+            function createEngine(options) {
+                const engine = Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler);
+                if (options.loop && !engine.slideLooper.canLoop()) {
+                    const optionsWithoutLoop = Object.assign({}, options, {
+                        loop: false
+                    });
+                    return createEngine(optionsWithoutLoop);
+                }
+                return engine;
+            }
+            function activate(withOptions, withPlugins) {
+                if (destroyed) return;
+                optionsBase = mergeOptions(optionsBase, withOptions);
+                options = optionsAtMedia(optionsBase);
+                pluginList = withPlugins || pluginList;
+                storeElements();
+                engine = createEngine(options);
+                optionsMediaQueries([
+                    optionsBase,
+                    ...pluginList.map(({ options })=>options)
+                ]).forEach((query)=>mediaHandlers.add(query, 'change', reActivate));
+                if (!options.active) return;
+                engine.translate.to(engine.location.get());
+                engine.animation.init();
+                engine.slidesInView.init();
+                engine.slideFocus.init(self);
+                engine.eventHandler.init(self);
+                engine.resizeHandler.init(self);
+                engine.slidesHandler.init(self);
+                if (engine.options.loop) engine.slideLooper.loop();
+                if (container.offsetParent && slides.length) engine.dragHandler.init(self);
+                pluginApis = pluginsHandler.init(self, pluginList);
+            }
+            function reActivate(withOptions, withPlugins) {
+                const startIndex = selectedScrollSnap();
+                deActivate();
+                activate(mergeOptions({
+                    startIndex
+                }, withOptions), withPlugins);
+                eventHandler.emit('reInit');
+            }
+            function deActivate() {
+                engine.dragHandler.destroy();
+                engine.eventStore.clear();
+                engine.translate.clear();
+                engine.slideLooper.clear();
+                engine.resizeHandler.destroy();
+                engine.slidesHandler.destroy();
+                engine.slidesInView.destroy();
+                engine.animation.destroy();
+                pluginsHandler.destroy();
+                mediaHandlers.clear();
+            }
+            function destroy() {
+                if (destroyed) return;
+                destroyed = true;
+                mediaHandlers.clear();
+                deActivate();
+                eventHandler.emit('destroy');
+                eventHandler.clear();
+            }
+            function scrollTo(index, jump, direction) {
+                if (!options.active || destroyed) return;
+                engine.scrollBody.useBaseFriction().useDuration(true === jump ? 0 : options.duration);
+                engine.scrollTo.index(index, direction || 0);
+            }
+            function scrollNext(jump) {
+                const next = engine.index.add(1).get();
+                scrollTo(next, jump, -1);
+            }
+            function scrollPrev(jump) {
+                const prev = engine.index.add(-1).get();
+                scrollTo(prev, jump, 1);
+            }
+            function canScrollNext() {
+                const next = engine.index.add(1).get();
+                return next !== selectedScrollSnap();
+            }
+            function canScrollPrev() {
+                const prev = engine.index.add(-1).get();
+                return prev !== selectedScrollSnap();
+            }
+            function scrollSnapList() {
+                return engine.scrollSnapList;
+            }
+            function scrollProgress() {
+                return engine.scrollProgress.get(engine.offsetLocation.get());
+            }
+            function selectedScrollSnap() {
+                return engine.index.get();
+            }
+            function previousScrollSnap() {
+                return engine.indexPrevious.get();
+            }
+            function slidesInView() {
+                return engine.slidesInView.get();
+            }
+            function slidesNotInView() {
+                return engine.slidesInView.get(false);
+            }
+            function plugins() {
+                return pluginApis;
+            }
+            function internalEngine() {
+                return engine;
+            }
+            function rootNode() {
+                return root;
+            }
+            function containerNode() {
+                return container;
+            }
+            function slideNodes() {
+                return slides;
+            }
+            const self = {
+                canScrollNext,
+                canScrollPrev,
+                containerNode,
+                internalEngine,
+                destroy,
+                off,
+                on,
+                emit,
+                plugins,
+                previousScrollSnap,
+                reInit,
+                rootNode,
+                scrollNext,
+                scrollPrev,
+                scrollProgress,
+                scrollSnapList,
+                scrollTo,
+                selectedScrollSnap,
+                slideNodes,
+                slidesInView,
+                slidesNotInView
+            };
+            activate(userOptions, userPlugins);
+            setTimeout(()=>eventHandler.emit('init'), 0);
+            return self;
+        }
+        EmblaCarousel.globalOptions = void 0;
+        function useEmblaCarousel(options = {}, plugins = []) {
+            const storedOptions = (0, external_react_.useRef)(options);
+            const storedPlugins = (0, external_react_.useRef)(plugins);
+            const [emblaApi, setEmblaApi] = (0, external_react_.useState)();
+            const [viewport, setViewport] = (0, external_react_.useState)();
+            const reInit = (0, external_react_.useCallback)(()=>{
+                if (emblaApi) emblaApi.reInit(storedOptions.current, storedPlugins.current);
+            }, [
+                emblaApi
+            ]);
+            (0, external_react_.useEffect)(()=>{
+                if (areOptionsEqual(storedOptions.current, options)) return;
+                storedOptions.current = options;
+                reInit();
+            }, [
+                options,
+                reInit
+            ]);
+            (0, external_react_.useEffect)(()=>{
+                if (arePluginsEqual(storedPlugins.current, plugins)) return;
+                storedPlugins.current = plugins;
+                reInit();
+            }, [
+                plugins,
+                reInit
+            ]);
+            (0, external_react_.useEffect)(()=>{
+                if (canUseDOM() && viewport) {
+                    EmblaCarousel.globalOptions = useEmblaCarousel.globalOptions;
+                    const newEmblaApi = EmblaCarousel(viewport, storedOptions.current, storedPlugins.current);
+                    setEmblaApi(newEmblaApi);
+                    return ()=>newEmblaApi.destroy();
+                }
+                setEmblaApi(void 0);
+            }, [
+                viewport,
+                setEmblaApi
+            ]);
+            return [
+                setViewport,
+                emblaApi
+            ];
+        }
+        useEmblaCarousel.globalOptions = void 0;
+    },
+    "../../node_modules/.pnpm/vaul@1.1.2_@types+react-dom@19.2.3_@types+react@19.2.9__@types+react@19.2.9_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/vaul/dist/index.mjs" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            _s: ()=>Drawer
+        });
+        var _radix_ui_react_dialog__rspack_import_0 = __webpack_require__("@radix-ui/react-dialog");
+        var react__rspack_import_1 = __webpack_require__("react");
+        function __insertCSS(code) {
+            if (!code || "u" < typeof document) return;
+            let head = document.head || document.getElementsByTagName('head')[0];
+            let style = document.createElement('style');
+            style.type = 'text/css';
+            head.appendChild(style);
+            style.styleSheet ? style.styleSheet.cssText = code : style.appendChild(document.createTextNode(code));
+        }
+        const DrawerContext = react__rspack_import_1["default"].createContext({
+            drawerRef: {
+                current: null
+            },
+            overlayRef: {
+                current: null
+            },
+            onPress: ()=>{},
+            onRelease: ()=>{},
+            onDrag: ()=>{},
+            onNestedDrag: ()=>{},
+            onNestedOpenChange: ()=>{},
+            onNestedRelease: ()=>{},
+            openProp: void 0,
+            dismissible: false,
+            isOpen: false,
+            isDragging: false,
+            keyboardIsOpen: {
+                current: false
+            },
+            snapPointsOffset: null,
+            snapPoints: null,
+            handleOnly: false,
+            modal: false,
+            shouldFade: false,
+            activeSnapPoint: null,
+            onOpenChange: ()=>{},
+            setActiveSnapPoint: ()=>{},
+            closeDrawer: ()=>{},
+            direction: 'bottom',
+            shouldAnimate: {
+                current: true
+            },
+            shouldScaleBackground: false,
+            setBackgroundColorOnScale: true,
+            noBodyStyles: false,
+            container: null,
+            autoFocus: false
+        });
+        const useDrawerContext = ()=>{
+            const context = react__rspack_import_1["default"].useContext(DrawerContext);
+            if (!context) throw new Error('useDrawerContext must be used within a Drawer.Root');
+            return context;
+        };
+        __insertCSS("[data-vaul-drawer]{touch-action:none;will-change:transform;transition:transform .5s cubic-bezier(.32, .72, 0, 1);animation-duration:.5s;animation-timing-function:cubic-bezier(0.32,0.72,0,1)}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=bottom][data-state=open]{animation-name:slideFromBottom}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=bottom][data-state=closed]{animation-name:slideToBottom}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=top][data-state=open]{animation-name:slideFromTop}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=top][data-state=closed]{animation-name:slideToTop}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=left][data-state=open]{animation-name:slideFromLeft}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=left][data-state=closed]{animation-name:slideToLeft}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=right][data-state=open]{animation-name:slideFromRight}[data-vaul-drawer][data-vaul-snap-points=false][data-vaul-drawer-direction=right][data-state=closed]{animation-name:slideToRight}[data-vaul-drawer][data-vaul-snap-points=true][data-vaul-drawer-direction=bottom]{transform:translate3d(0,var(--initial-transform,100%),0)}[data-vaul-drawer][data-vaul-snap-points=true][data-vaul-drawer-direction=top]{transform:translate3d(0,calc(var(--initial-transform,100%) * -1),0)}[data-vaul-drawer][data-vaul-snap-points=true][data-vaul-drawer-direction=left]{transform:translate3d(calc(var(--initial-transform,100%) * -1),0,0)}[data-vaul-drawer][data-vaul-snap-points=true][data-vaul-drawer-direction=right]{transform:translate3d(var(--initial-transform,100%),0,0)}[data-vaul-drawer][data-vaul-delayed-snap-points=true][data-vaul-drawer-direction=top]{transform:translate3d(0,var(--snap-point-height,0),0)}[data-vaul-drawer][data-vaul-delayed-snap-points=true][data-vaul-drawer-direction=bottom]{transform:translate3d(0,var(--snap-point-height,0),0)}[data-vaul-drawer][data-vaul-delayed-snap-points=true][data-vaul-drawer-direction=left]{transform:translate3d(var(--snap-point-height,0),0,0)}[data-vaul-drawer][data-vaul-delayed-snap-points=true][data-vaul-drawer-direction=right]{transform:translate3d(var(--snap-point-height,0),0,0)}[data-vaul-overlay][data-vaul-snap-points=false]{animation-duration:.5s;animation-timing-function:cubic-bezier(0.32,0.72,0,1)}[data-vaul-overlay][data-vaul-snap-points=false][data-state=open]{animation-name:fadeIn}[data-vaul-overlay][data-state=closed]{animation-name:fadeOut}[data-vaul-animate=false]{animation:none!important}[data-vaul-overlay][data-vaul-snap-points=true]{opacity:0;transition:opacity .5s cubic-bezier(.32, .72, 0, 1)}[data-vaul-overlay][data-vaul-snap-points=true]{opacity:1}[data-vaul-drawer]:not([data-vaul-custom-container=true])::after{content:'';position:absolute;background:inherit;background-color:inherit}[data-vaul-drawer][data-vaul-drawer-direction=top]::after{top:initial;bottom:100%;left:0;right:0;height:200%}[data-vaul-drawer][data-vaul-drawer-direction=bottom]::after{top:100%;bottom:initial;left:0;right:0;height:200%}[data-vaul-drawer][data-vaul-drawer-direction=left]::after{left:initial;right:100%;top:0;bottom:0;width:200%}[data-vaul-drawer][data-vaul-drawer-direction=right]::after{left:100%;right:initial;top:0;bottom:0;width:200%}[data-vaul-overlay][data-vaul-snap-points=true]:not([data-vaul-snap-points-overlay=true]):not(\n[data-state=closed]\n){opacity:0}[data-vaul-overlay][data-vaul-snap-points-overlay=true]{opacity:1}[data-vaul-handle]{display:block;position:relative;opacity:.7;background:#e2e2e4;margin-left:auto;margin-right:auto;height:5px;width:32px;border-radius:1rem;touch-action:pan-y}[data-vaul-handle]:active,[data-vaul-handle]:hover{opacity:1}[data-vaul-handle-hitarea]{position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);width:max(100%,2.75rem);height:max(100%,2.75rem);touch-action:inherit}@media (hover:hover) and (pointer:fine){[data-vaul-drawer]{user-select:none}}@media (pointer:fine){[data-vaul-handle-hitarea]:{width:100%;height:100%}}@keyframes fadeIn{from{opacity:0}to{opacity:1}}@keyframes fadeOut{to{opacity:0}}@keyframes slideFromBottom{from{transform:translate3d(0,var(--initial-transform,100%),0)}to{transform:translate3d(0,0,0)}}@keyframes slideToBottom{to{transform:translate3d(0,var(--initial-transform,100%),0)}}@keyframes slideFromTop{from{transform:translate3d(0,calc(var(--initial-transform,100%) * -1),0)}to{transform:translate3d(0,0,0)}}@keyframes slideToTop{to{transform:translate3d(0,calc(var(--initial-transform,100%) * -1),0)}}@keyframes slideFromLeft{from{transform:translate3d(calc(var(--initial-transform,100%) * -1),0,0)}to{transform:translate3d(0,0,0)}}@keyframes slideToLeft{to{transform:translate3d(calc(var(--initial-transform,100%) * -1),0,0)}}@keyframes slideFromRight{from{transform:translate3d(var(--initial-transform,100%),0,0)}to{transform:translate3d(0,0,0)}}@keyframes slideToRight{to{transform:translate3d(var(--initial-transform,100%),0,0)}}");
+        function isMobileFirefox() {
+            const userAgent = navigator.userAgent;
+            return "u" > typeof window && (/Firefox/.test(userAgent) && /Mobile/.test(userAgent) || /FxiOS/.test(userAgent));
+        }
+        function isMac() {
+            return testPlatform(/^Mac/);
+        }
+        function isIPhone() {
+            return testPlatform(/^iPhone/);
+        }
+        function isSafari() {
+            return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+        }
+        function isIPad() {
+            return testPlatform(/^iPad/) || isMac() && navigator.maxTouchPoints > 1;
+        }
+        function isIOS() {
+            return isIPhone() || isIPad();
+        }
+        function testPlatform(re) {
+            return "u" > typeof window && null != window.navigator ? re.test(window.navigator.platform) : void 0;
+        }
+        const KEYBOARD_BUFFER = 24;
+        const useIsomorphicLayoutEffect = "u" > typeof window ? react__rspack_import_1.useLayoutEffect : react__rspack_import_1.useEffect;
+        function chain$1(...callbacks) {
+            return (...args)=>{
+                for (let callback of callbacks)if ('function' == typeof callback) callback(...args);
+            };
+        }
+        const visualViewport = "u" > typeof document && window.visualViewport;
+        function isScrollable(node) {
+            let style = window.getComputedStyle(node);
+            return /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+        }
+        function getScrollParent(node) {
+            if (isScrollable(node)) node = node.parentElement;
+            while(node && !isScrollable(node))node = node.parentElement;
+            return node || document.scrollingElement || document.documentElement;
+        }
+        const nonTextInputTypes = new Set([
+            'checkbox',
+            'radio',
+            'range',
+            'color',
+            'file',
+            'image',
+            'button',
+            'submit',
+            'reset'
+        ]);
+        let preventScrollCount = 0;
+        let restore;
+        function usePreventScroll(options = {}) {
+            let { isDisabled } = options;
+            useIsomorphicLayoutEffect(()=>{
+                if (isDisabled) return;
+                preventScrollCount++;
+                if (1 === preventScrollCount) {
+                    if (isIOS()) restore = preventScrollMobileSafari();
+                }
+                return ()=>{
+                    preventScrollCount--;
+                    if (0 === preventScrollCount) null == restore || restore();
+                };
+            }, [
+                isDisabled
+            ]);
+        }
+        function preventScrollMobileSafari() {
+            let scrollable;
+            let lastY = 0;
+            let onTouchStart = (e)=>{
+                scrollable = getScrollParent(e.target);
+                if (scrollable === document.documentElement && scrollable === document.body) return;
+                lastY = e.changedTouches[0].pageY;
+            };
+            let onTouchMove = (e)=>{
+                if (!scrollable || scrollable === document.documentElement || scrollable === document.body) return void e.preventDefault();
+                let y = e.changedTouches[0].pageY;
+                let scrollTop = scrollable.scrollTop;
+                let bottom = scrollable.scrollHeight - scrollable.clientHeight;
+                if (0 === bottom) return;
+                if (scrollTop <= 0 && y > lastY || scrollTop >= bottom && y < lastY) e.preventDefault();
+                lastY = y;
+            };
+            let onTouchEnd = (e)=>{
+                let target = e.target;
+                if (isInput(target) && target !== document.activeElement) {
+                    e.preventDefault();
+                    target.style.transform = 'translateY(-2000px)';
+                    target.focus();
+                    requestAnimationFrame(()=>{
+                        target.style.transform = '';
+                    });
+                }
+            };
+            let onFocus = (e)=>{
+                let target = e.target;
+                if (isInput(target)) {
+                    target.style.transform = 'translateY(-2000px)';
+                    requestAnimationFrame(()=>{
+                        target.style.transform = '';
+                        if (visualViewport) if (visualViewport.height < window.innerHeight) requestAnimationFrame(()=>{
+                            scrollIntoView(target);
+                        });
+                        else visualViewport.addEventListener('resize', ()=>scrollIntoView(target), {
+                            once: true
+                        });
+                    });
+                }
+            };
+            let onWindowScroll = ()=>{
+                window.scrollTo(0, 0);
+            };
+            let scrollX = window.pageXOffset;
+            let scrollY = window.pageYOffset;
+            let restoreStyles = chain$1(setStyle(document.documentElement, 'paddingRight', `${window.innerWidth - document.documentElement.clientWidth}px`));
+            window.scrollTo(0, 0);
+            let removeEvents = chain$1(addEvent(document, 'touchstart', onTouchStart, {
+                passive: false,
+                capture: true
+            }), addEvent(document, 'touchmove', onTouchMove, {
+                passive: false,
+                capture: true
+            }), addEvent(document, 'touchend', onTouchEnd, {
+                passive: false,
+                capture: true
+            }), addEvent(document, 'focus', onFocus, true), addEvent(window, 'scroll', onWindowScroll));
+            return ()=>{
+                restoreStyles();
+                removeEvents();
+                window.scrollTo(scrollX, scrollY);
+            };
+        }
+        function setStyle(element, style, value) {
+            let cur = element.style[style];
+            element.style[style] = value;
+            return ()=>{
+                element.style[style] = cur;
+            };
+        }
+        function addEvent(target, event, handler, options) {
+            target.addEventListener(event, handler, options);
+            return ()=>{
+                target.removeEventListener(event, handler, options);
+            };
+        }
+        function scrollIntoView(target) {
+            let root = document.scrollingElement || document.documentElement;
+            while(target && target !== root){
+                let scrollable = getScrollParent(target);
+                if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== target) {
+                    let scrollableTop = scrollable.getBoundingClientRect().top;
+                    let targetTop = target.getBoundingClientRect().top;
+                    let targetBottom = target.getBoundingClientRect().bottom;
+                    const keyboardHeight = scrollable.getBoundingClientRect().bottom + KEYBOARD_BUFFER;
+                    if (targetBottom > keyboardHeight) scrollable.scrollTop += targetTop - scrollableTop;
+                }
+                target = scrollable.parentElement;
+            }
+        }
+        function isInput(target) {
+            return target instanceof HTMLInputElement && !nonTextInputTypes.has(target.type) || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;
+        }
+        function setRef(ref, value) {
+            if ('function' == typeof ref) ref(value);
+            else if (null != ref) ref.current = value;
+        }
+        function composeRefs(...refs) {
+            return (node)=>refs.forEach((ref)=>setRef(ref, node));
+        }
+        function useComposedRefs(...refs) {
+            return react__rspack_import_1.useCallback(composeRefs(...refs), refs);
+        }
+        const cache = new WeakMap();
+        function set(el, styles, ignoreCache = false) {
+            if (!el || !(el instanceof HTMLElement)) return;
+            let originalStyles = {};
+            Object.entries(styles).forEach(([key, value])=>{
+                if (key.startsWith('--')) return void el.style.setProperty(key, value);
+                originalStyles[key] = el.style[key];
+                el.style[key] = value;
+            });
+            if (ignoreCache) return;
+            cache.set(el, originalStyles);
+        }
+        function reset(el, prop) {
+            if (!el || !(el instanceof HTMLElement)) return;
+            let originalStyles = cache.get(el);
+            if (!originalStyles) return;
+            el.style[prop] = originalStyles[prop];
+        }
+        const isVertical = (direction)=>{
+            switch(direction){
+                case 'top':
+                case 'bottom':
+                    return true;
+                case 'left':
+                case 'right':
+                    return false;
+                default:
+                    return direction;
+            }
+        };
+        function getTranslate(element, direction) {
+            if (!element) return null;
+            const style = window.getComputedStyle(element);
+            const transform = style.transform || style.webkitTransform || style.mozTransform;
+            let mat = transform.match(/^matrix3d\((.+)\)$/);
+            if (mat) return parseFloat(mat[1].split(', ')[isVertical(direction) ? 13 : 12]);
+            mat = transform.match(/^matrix\((.+)\)$/);
+            return mat ? parseFloat(mat[1].split(', ')[isVertical(direction) ? 5 : 4]) : null;
+        }
+        function dampenValue(v) {
+            return 8 * (Math.log(v + 1) - 2);
+        }
+        function assignStyle(element, style) {
+            if (!element) return ()=>{};
+            const prevStyle = element.style.cssText;
+            Object.assign(element.style, style);
+            return ()=>{
+                element.style.cssText = prevStyle;
+            };
+        }
+        function chain(...fns) {
+            return (...args)=>{
+                for (const fn of fns)if ('function' == typeof fn) fn(...args);
+            };
+        }
+        const TRANSITIONS = {
+            DURATION: 0.5,
+            EASE: [
+                0.32,
+                0.72,
+                0,
+                1
+            ]
+        };
+        const VELOCITY_THRESHOLD = 0.4;
+        const CLOSE_THRESHOLD = 0.25;
+        const SCROLL_LOCK_TIMEOUT = 100;
+        const BORDER_RADIUS = 8;
+        const NESTED_DISPLACEMENT = 16;
+        const WINDOW_TOP_OFFSET = 26;
+        const DRAG_CLASS = 'vaul-dragging';
+        function useCallbackRef(callback) {
+            const callbackRef = react__rspack_import_1["default"].useRef(callback);
+            react__rspack_import_1["default"].useEffect(()=>{
+                callbackRef.current = callback;
+            });
+            return react__rspack_import_1["default"].useMemo(()=>(...args)=>null == callbackRef.current ? void 0 : callbackRef.current.call(callbackRef, ...args), []);
+        }
+        function useUncontrolledState({ defaultProp, onChange }) {
+            const uncontrolledState = react__rspack_import_1["default"].useState(defaultProp);
+            const [value] = uncontrolledState;
+            const prevValueRef = react__rspack_import_1["default"].useRef(value);
+            const handleChange = useCallbackRef(onChange);
+            react__rspack_import_1["default"].useEffect(()=>{
+                if (prevValueRef.current !== value) {
+                    handleChange(value);
+                    prevValueRef.current = value;
+                }
+            }, [
+                value,
+                prevValueRef,
+                handleChange
+            ]);
+            return uncontrolledState;
+        }
+        function useControllableState({ prop, defaultProp, onChange = ()=>{} }) {
+            const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({
+                defaultProp,
+                onChange
+            });
+            const isControlled = void 0 !== prop;
+            const value = isControlled ? prop : uncontrolledProp;
+            const handleChange = useCallbackRef(onChange);
+            const setValue = react__rspack_import_1["default"].useCallback((nextValue)=>{
+                if (isControlled) {
+                    const setter = nextValue;
+                    const value = 'function' == typeof nextValue ? setter(prop) : nextValue;
+                    if (value !== prop) handleChange(value);
+                } else setUncontrolledProp(nextValue);
+            }, [
+                isControlled,
+                prop,
+                setUncontrolledProp,
+                handleChange
+            ]);
+            return [
+                value,
+                setValue
+            ];
+        }
+        function useSnapPoints({ activeSnapPointProp, setActiveSnapPointProp, snapPoints, drawerRef, overlayRef, fadeFromIndex, onSnapPointChange, direction = 'bottom', container, snapToSequentialPoint }) {
+            const [activeSnapPoint, setActiveSnapPoint] = useControllableState({
+                prop: activeSnapPointProp,
+                defaultProp: null == snapPoints ? void 0 : snapPoints[0],
+                onChange: setActiveSnapPointProp
+            });
+            const [windowDimensions, setWindowDimensions] = react__rspack_import_1["default"].useState("u" > typeof window ? {
+                innerWidth: window.innerWidth,
+                innerHeight: window.innerHeight
+            } : void 0);
+            react__rspack_import_1["default"].useEffect(()=>{
+                function onResize() {
+                    setWindowDimensions({
+                        innerWidth: window.innerWidth,
+                        innerHeight: window.innerHeight
+                    });
+                }
+                window.addEventListener('resize', onResize);
+                return ()=>window.removeEventListener('resize', onResize);
+            }, []);
+            const isLastSnapPoint = react__rspack_import_1["default"].useMemo(()=>activeSnapPoint === (null == snapPoints ? void 0 : snapPoints[snapPoints.length - 1]) || null, [
+                snapPoints,
+                activeSnapPoint
+            ]);
+            const activeSnapPointIndex = react__rspack_import_1["default"].useMemo(()=>{
+                var _snapPoints_findIndex;
+                return null != (_snapPoints_findIndex = null == snapPoints ? void 0 : snapPoints.findIndex((snapPoint)=>snapPoint === activeSnapPoint)) ? _snapPoints_findIndex : null;
+            }, [
+                snapPoints,
+                activeSnapPoint
+            ]);
+            const shouldFade = snapPoints && snapPoints.length > 0 && (fadeFromIndex || 0 === fadeFromIndex) && !Number.isNaN(fadeFromIndex) && snapPoints[fadeFromIndex] === activeSnapPoint || !snapPoints;
+            const snapPointsOffset = react__rspack_import_1["default"].useMemo(()=>{
+                const containerSize = container ? {
+                    width: container.getBoundingClientRect().width,
+                    height: container.getBoundingClientRect().height
+                } : "u" > typeof window ? {
+                    width: window.innerWidth,
+                    height: window.innerHeight
+                } : {
+                    width: 0,
+                    height: 0
+                };
+                var _snapPoints_map;
+                return null != (_snapPoints_map = null == snapPoints ? void 0 : snapPoints.map((snapPoint)=>{
+                    const isPx = 'string' == typeof snapPoint;
+                    let snapPointAsNumber = 0;
+                    if (isPx) snapPointAsNumber = parseInt(snapPoint, 10);
+                    if (isVertical(direction)) {
+                        const height = isPx ? snapPointAsNumber : windowDimensions ? snapPoint * containerSize.height : 0;
+                        if (windowDimensions) return 'bottom' === direction ? containerSize.height - height : -containerSize.height + height;
+                        return height;
+                    }
+                    const width = isPx ? snapPointAsNumber : windowDimensions ? snapPoint * containerSize.width : 0;
+                    if (windowDimensions) return 'right' === direction ? containerSize.width - width : -containerSize.width + width;
+                    return width;
+                })) ? _snapPoints_map : [];
+            }, [
+                snapPoints,
+                windowDimensions,
+                container
+            ]);
+            const activeSnapPointOffset = react__rspack_import_1["default"].useMemo(()=>null !== activeSnapPointIndex ? null == snapPointsOffset ? void 0 : snapPointsOffset[activeSnapPointIndex] : null, [
+                snapPointsOffset,
+                activeSnapPointIndex
+            ]);
+            const snapToPoint = react__rspack_import_1["default"].useCallback((dimension)=>{
+                var _snapPointsOffset_findIndex;
+                const newSnapPointIndex = null != (_snapPointsOffset_findIndex = null == snapPointsOffset ? void 0 : snapPointsOffset.findIndex((snapPointDim)=>snapPointDim === dimension)) ? _snapPointsOffset_findIndex : null;
+                onSnapPointChange(newSnapPointIndex);
+                set(drawerRef.current, {
+                    transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,
+                    transform: isVertical(direction) ? `translate3d(0, ${dimension}px, 0)` : `translate3d(${dimension}px, 0, 0)`
+                });
+                snapPointsOffset && newSnapPointIndex !== snapPointsOffset.length - 1 && void 0 !== fadeFromIndex && newSnapPointIndex !== fadeFromIndex && newSnapPointIndex < fadeFromIndex ? set(overlayRef.current, {
+                    transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,
+                    opacity: '0'
+                }) : set(overlayRef.current, {
+                    transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,
+                    opacity: '1'
+                });
+                setActiveSnapPoint(null == snapPoints ? void 0 : snapPoints[Math.max(newSnapPointIndex, 0)]);
+            }, [
+                drawerRef.current,
+                snapPoints,
+                snapPointsOffset,
+                fadeFromIndex,
+                overlayRef,
+                setActiveSnapPoint
+            ]);
+            react__rspack_import_1["default"].useEffect(()=>{
+                if (activeSnapPoint || activeSnapPointProp) {
+                    var _snapPoints_findIndex;
+                    const newIndex = null != (_snapPoints_findIndex = null == snapPoints ? void 0 : snapPoints.findIndex((snapPoint)=>snapPoint === activeSnapPointProp || snapPoint === activeSnapPoint)) ? _snapPoints_findIndex : -1;
+                    if (snapPointsOffset && -1 !== newIndex && 'number' == typeof snapPointsOffset[newIndex]) snapToPoint(snapPointsOffset[newIndex]);
+                }
+            }, [
+                activeSnapPoint,
+                activeSnapPointProp,
+                snapPoints,
+                snapPointsOffset,
+                snapToPoint
+            ]);
+            function onRelease({ draggedDistance, closeDrawer, velocity, dismissible }) {
+                if (void 0 === fadeFromIndex) return;
+                const currentPosition = 'bottom' === direction || 'right' === direction ? (null != activeSnapPointOffset ? activeSnapPointOffset : 0) - draggedDistance : (null != activeSnapPointOffset ? activeSnapPointOffset : 0) + draggedDistance;
+                const isOverlaySnapPoint = activeSnapPointIndex === fadeFromIndex - 1;
+                const isFirst = 0 === activeSnapPointIndex;
+                const hasDraggedUp = draggedDistance > 0;
+                if (isOverlaySnapPoint) set(overlayRef.current, {
+                    transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`
+                });
+                if (!snapToSequentialPoint && velocity > 2 && !hasDraggedUp) {
+                    if (dismissible) closeDrawer();
+                    else snapToPoint(snapPointsOffset[0]);
+                    return;
+                }
+                if (!snapToSequentialPoint && velocity > 2 && hasDraggedUp && snapPointsOffset && snapPoints) return void snapToPoint(snapPointsOffset[snapPoints.length - 1]);
+                const closestSnapPoint = null == snapPointsOffset ? void 0 : snapPointsOffset.reduce((prev, curr)=>{
+                    if ('number' != typeof prev || 'number' != typeof curr) return prev;
+                    return Math.abs(curr - currentPosition) < Math.abs(prev - currentPosition) ? curr : prev;
+                });
+                const dim = isVertical(direction) ? window.innerHeight : window.innerWidth;
+                if (velocity > VELOCITY_THRESHOLD && Math.abs(draggedDistance) < 0.4 * dim) {
+                    const dragDirection = hasDraggedUp ? 1 : -1;
+                    if (dragDirection > 0 && isLastSnapPoint && snapPoints) return void snapToPoint(snapPointsOffset[snapPoints.length - 1]);
+                    if (isFirst && dragDirection < 0 && dismissible) closeDrawer();
+                    if (null === activeSnapPointIndex) return;
+                    snapToPoint(snapPointsOffset[activeSnapPointIndex + dragDirection]);
+                    return;
+                }
+                snapToPoint(closestSnapPoint);
+            }
+            function onDrag({ draggedDistance }) {
+                if (null === activeSnapPointOffset) return;
+                const newValue = 'bottom' === direction || 'right' === direction ? activeSnapPointOffset - draggedDistance : activeSnapPointOffset + draggedDistance;
+                if (('bottom' === direction || 'right' === direction) && newValue < snapPointsOffset[snapPointsOffset.length - 1]) return;
+                if (('top' === direction || 'left' === direction) && newValue > snapPointsOffset[snapPointsOffset.length - 1]) return;
+                set(drawerRef.current, {
+                    transform: isVertical(direction) ? `translate3d(0, ${newValue}px, 0)` : `translate3d(${newValue}px, 0, 0)`
+                });
+            }
+            function getPercentageDragged(absDraggedDistance, isDraggingDown) {
+                if (!snapPoints || 'number' != typeof activeSnapPointIndex || !snapPointsOffset || void 0 === fadeFromIndex) return null;
+                const isOverlaySnapPoint = activeSnapPointIndex === fadeFromIndex - 1;
+                const isOverlaySnapPointOrHigher = activeSnapPointIndex >= fadeFromIndex;
+                if (isOverlaySnapPointOrHigher && isDraggingDown) return 0;
+                if (isOverlaySnapPoint && !isDraggingDown) return 1;
+                if (!shouldFade && !isOverlaySnapPoint) return null;
+                const targetSnapPointIndex = isOverlaySnapPoint ? activeSnapPointIndex + 1 : activeSnapPointIndex - 1;
+                const snapPointDistance = isOverlaySnapPoint ? snapPointsOffset[targetSnapPointIndex] - snapPointsOffset[targetSnapPointIndex - 1] : snapPointsOffset[targetSnapPointIndex + 1] - snapPointsOffset[targetSnapPointIndex];
+                const percentageDragged = absDraggedDistance / Math.abs(snapPointDistance);
+                if (isOverlaySnapPoint) return 1 - percentageDragged;
+                return percentageDragged;
+            }
+            return {
+                isLastSnapPoint,
+                activeSnapPoint,
+                shouldFade,
+                getPercentageDragged,
+                setActiveSnapPoint,
+                activeSnapPointIndex,
+                onRelease,
+                onDrag,
+                snapPointsOffset
+            };
+        }
+        const noop = ()=>()=>{};
+        function useScaleBackground() {
+            const { direction, isOpen, shouldScaleBackground, setBackgroundColorOnScale, noBodyStyles } = useDrawerContext();
+            const timeoutIdRef = react__rspack_import_1["default"].useRef(null);
+            const initialBackgroundColor = (0, react__rspack_import_1.useMemo)(()=>document.body.style.backgroundColor, []);
+            function getScale() {
+                return (window.innerWidth - WINDOW_TOP_OFFSET) / window.innerWidth;
+            }
+            react__rspack_import_1["default"].useEffect(()=>{
+                if (isOpen && shouldScaleBackground) {
+                    if (timeoutIdRef.current) clearTimeout(timeoutIdRef.current);
+                    const wrapper = document.querySelector('[data-vaul-drawer-wrapper]') || document.querySelector('[vaul-drawer-wrapper]');
+                    if (!wrapper) return;
+                    chain(setBackgroundColorOnScale && !noBodyStyles ? assignStyle(document.body, {
+                        background: 'black'
+                    }) : noop, assignStyle(wrapper, {
+                        transformOrigin: isVertical(direction) ? 'top' : 'left',
+                        transitionProperty: 'transform, border-radius',
+                        transitionDuration: `${TRANSITIONS.DURATION}s`,
+                        transitionTimingFunction: `cubic-bezier(${TRANSITIONS.EASE.join(',')})`
+                    }));
+                    const wrapperStylesCleanup = assignStyle(wrapper, {
+                        borderRadius: `${BORDER_RADIUS}px`,
+                        overflow: 'hidden',
+                        ...isVertical(direction) ? {
+                            transform: `scale(${getScale()}) translate3d(0, calc(env(safe-area-inset-top) + 14px), 0)`
+                        } : {
+                            transform: `scale(${getScale()}) translate3d(calc(env(safe-area-inset-top) + 14px), 0, 0)`
+                        }
+                    });
+                    return ()=>{
+                        wrapperStylesCleanup();
+                        timeoutIdRef.current = window.setTimeout(()=>{
+                            if (initialBackgroundColor) document.body.style.background = initialBackgroundColor;
+                            else document.body.style.removeProperty('background');
+                        }, 1000 * TRANSITIONS.DURATION);
+                    };
+                }
+            }, [
+                isOpen,
+                shouldScaleBackground,
+                initialBackgroundColor
+            ]);
+        }
+        let previousBodyPosition = null;
+        function usePositionFixed({ isOpen, modal, nested, hasBeenOpened, preventScrollRestoration, noBodyStyles }) {
+            const [activeUrl, setActiveUrl] = react__rspack_import_1["default"].useState(()=>"u" > typeof window ? window.location.href : '');
+            const scrollPos = react__rspack_import_1["default"].useRef(0);
+            const setPositionFixed = react__rspack_import_1["default"].useCallback(()=>{
+                if (!isSafari()) return;
+                if (null === previousBodyPosition && isOpen && !noBodyStyles) {
+                    previousBodyPosition = {
+                        position: document.body.style.position,
+                        top: document.body.style.top,
+                        left: document.body.style.left,
+                        height: document.body.style.height,
+                        right: 'unset'
+                    };
+                    const { scrollX, innerHeight } = window;
+                    document.body.style.setProperty('position', 'fixed', 'important');
+                    Object.assign(document.body.style, {
+                        top: `${-scrollPos.current}px`,
+                        left: `${-scrollX}px`,
+                        right: '0px',
+                        height: 'auto'
+                    });
+                    window.setTimeout(()=>window.requestAnimationFrame(()=>{
+                            const bottomBarHeight = innerHeight - window.innerHeight;
+                            if (bottomBarHeight && scrollPos.current >= innerHeight) document.body.style.top = `${-(scrollPos.current + bottomBarHeight)}px`;
+                        }), 300);
+                }
+            }, [
+                isOpen
+            ]);
+            const restorePositionSetting = react__rspack_import_1["default"].useCallback(()=>{
+                if (!isSafari()) return;
+                if (null !== previousBodyPosition && !noBodyStyles) {
+                    const y = -parseInt(document.body.style.top, 10);
+                    const x = -parseInt(document.body.style.left, 10);
+                    Object.assign(document.body.style, previousBodyPosition);
+                    window.requestAnimationFrame(()=>{
+                        if (preventScrollRestoration && activeUrl !== window.location.href) return void setActiveUrl(window.location.href);
+                        window.scrollTo(x, y);
+                    });
+                    previousBodyPosition = null;
+                }
+            }, [
+                activeUrl
+            ]);
+            react__rspack_import_1["default"].useEffect(()=>{
+                function onScroll() {
+                    scrollPos.current = window.scrollY;
+                }
+                onScroll();
+                window.addEventListener('scroll', onScroll);
+                return ()=>{
+                    window.removeEventListener('scroll', onScroll);
+                };
+            }, []);
+            react__rspack_import_1["default"].useEffect(()=>{
+                if (!modal) return;
+                return ()=>{
+                    if ("u" < typeof document) return;
+                    const hasDrawerOpened = !!document.querySelector('[data-vaul-drawer]');
+                    if (hasDrawerOpened) return;
+                    restorePositionSetting();
+                };
+            }, [
+                modal,
+                restorePositionSetting
+            ]);
+            react__rspack_import_1["default"].useEffect(()=>{
+                if (nested || !hasBeenOpened) return;
+                if (isOpen) {
+                    const isStandalone = window.matchMedia('(display-mode: standalone)').matches;
+                    isStandalone || setPositionFixed();
+                    if (!modal) window.setTimeout(()=>{
+                        restorePositionSetting();
+                    }, 500);
+                } else restorePositionSetting();
+            }, [
+                isOpen,
+                hasBeenOpened,
+                activeUrl,
+                modal,
+                nested,
+                setPositionFixed,
+                restorePositionSetting
+            ]);
+            return {
+                restorePositionSetting
+            };
+        }
+        function Root({ open: openProp, onOpenChange, children, onDrag: onDragProp, onRelease: onReleaseProp, snapPoints, shouldScaleBackground = false, setBackgroundColorOnScale = true, closeThreshold = CLOSE_THRESHOLD, scrollLockTimeout = SCROLL_LOCK_TIMEOUT, dismissible = true, handleOnly = false, fadeFromIndex = snapPoints && snapPoints.length - 1, activeSnapPoint: activeSnapPointProp, setActiveSnapPoint: setActiveSnapPointProp, fixed, modal = true, onClose, nested, noBodyStyles = false, direction = 'bottom', defaultOpen = false, disablePreventScroll = true, snapToSequentialPoint = false, preventScrollRestoration = false, repositionInputs = true, onAnimationEnd, container, autoFocus = false }) {
+            var _drawerRef_current, _drawerRef_current1;
+            const [isOpen = false, setIsOpen] = useControllableState({
+                defaultProp: defaultOpen,
+                prop: openProp,
+                onChange: (o)=>{
+                    null == onOpenChange || onOpenChange(o);
+                    if (!o && !nested) restorePositionSetting();
+                    setTimeout(()=>{
+                        null == onAnimationEnd || onAnimationEnd(o);
+                    }, 1000 * TRANSITIONS.DURATION);
+                    if (o && !modal) {
+                        if ("u" > typeof window) window.requestAnimationFrame(()=>{
+                            document.body.style.pointerEvents = 'auto';
+                        });
+                    }
+                    if (!o) document.body.style.pointerEvents = 'auto';
+                }
+            });
+            const [hasBeenOpened, setHasBeenOpened] = react__rspack_import_1["default"].useState(false);
+            const [isDragging, setIsDragging] = react__rspack_import_1["default"].useState(false);
+            const [justReleased, setJustReleased] = react__rspack_import_1["default"].useState(false);
+            const overlayRef = react__rspack_import_1["default"].useRef(null);
+            const openTime = react__rspack_import_1["default"].useRef(null);
+            const dragStartTime = react__rspack_import_1["default"].useRef(null);
+            const dragEndTime = react__rspack_import_1["default"].useRef(null);
+            const lastTimeDragPrevented = react__rspack_import_1["default"].useRef(null);
+            const isAllowedToDrag = react__rspack_import_1["default"].useRef(false);
+            const nestedOpenChangeTimer = react__rspack_import_1["default"].useRef(null);
+            const pointerStart = react__rspack_import_1["default"].useRef(0);
+            const keyboardIsOpen = react__rspack_import_1["default"].useRef(false);
+            const shouldAnimate = react__rspack_import_1["default"].useRef(!defaultOpen);
+            const previousDiffFromInitial = react__rspack_import_1["default"].useRef(0);
+            const drawerRef = react__rspack_import_1["default"].useRef(null);
+            const drawerHeightRef = react__rspack_import_1["default"].useRef((null == (_drawerRef_current = drawerRef.current) ? void 0 : _drawerRef_current.getBoundingClientRect().height) || 0);
+            const drawerWidthRef = react__rspack_import_1["default"].useRef((null == (_drawerRef_current1 = drawerRef.current) ? void 0 : _drawerRef_current1.getBoundingClientRect().width) || 0);
+            const initialDrawerHeight = react__rspack_import_1["default"].useRef(0);
+            const onSnapPointChange = react__rspack_import_1["default"].useCallback((activeSnapPointIndex)=>{
+                if (snapPoints && activeSnapPointIndex === snapPointsOffset.length - 1) openTime.current = new Date();
+            }, []);
+            const { activeSnapPoint, activeSnapPointIndex, setActiveSnapPoint, onRelease: onReleaseSnapPoints, snapPointsOffset, onDrag: onDragSnapPoints, shouldFade, getPercentageDragged: getSnapPointsPercentageDragged } = useSnapPoints({
+                snapPoints,
+                activeSnapPointProp,
+                setActiveSnapPointProp,
+                drawerRef,
+                fadeFromIndex,
+                overlayRef,
+                onSnapPointChange,
+                direction,
+                container,
+                snapToSequentialPoint
+            });
+            usePreventScroll({
+                isDisabled: !isOpen || isDragging || !modal || justReleased || !hasBeenOpened || !repositionInputs || !disablePreventScroll
+            });
+            const { restorePositionSetting } = usePositionFixed({
+                isOpen,
+                modal,
+                nested: null != nested ? nested : false,
+                hasBeenOpened,
+                preventScrollRestoration,
+                noBodyStyles
+            });
+            function getScale() {
+                return (window.innerWidth - WINDOW_TOP_OFFSET) / window.innerWidth;
+            }
+            function onPress(event) {
+                var _drawerRef_current, _drawerRef_current1;
+                if (!dismissible && !snapPoints) return;
+                if (drawerRef.current && !drawerRef.current.contains(event.target)) return;
+                drawerHeightRef.current = (null == (_drawerRef_current = drawerRef.current) ? void 0 : _drawerRef_current.getBoundingClientRect().height) || 0;
+                drawerWidthRef.current = (null == (_drawerRef_current1 = drawerRef.current) ? void 0 : _drawerRef_current1.getBoundingClientRect().width) || 0;
+                setIsDragging(true);
+                dragStartTime.current = new Date();
+                if (isIOS()) window.addEventListener('touchend', ()=>isAllowedToDrag.current = false, {
+                    once: true
+                });
+                event.target.setPointerCapture(event.pointerId);
+                pointerStart.current = isVertical(direction) ? event.pageY : event.pageX;
+            }
+            function shouldDrag(el, isDraggingInDirection) {
+                var _window_getSelection;
+                let element = el;
+                const highlightedText = null == (_window_getSelection = window.getSelection()) ? void 0 : _window_getSelection.toString();
+                const swipeAmount = drawerRef.current ? getTranslate(drawerRef.current, direction) : null;
+                const date = new Date();
+                if ('SELECT' === element.tagName) return false;
+                if (element.hasAttribute('data-vaul-no-drag') || element.closest('[data-vaul-no-drag]')) return false;
+                if ('right' === direction || 'left' === direction) return true;
+                if (openTime.current && date.getTime() - openTime.current.getTime() < 500) return false;
+                if (null !== swipeAmount) {
+                    if ('bottom' === direction ? swipeAmount > 0 : swipeAmount < 0) return true;
+                }
+                if (highlightedText && highlightedText.length > 0) return false;
+                if (lastTimeDragPrevented.current && date.getTime() - lastTimeDragPrevented.current.getTime() < scrollLockTimeout && 0 === swipeAmount) {
+                    lastTimeDragPrevented.current = date;
+                    return false;
+                }
+                if (isDraggingInDirection) {
+                    lastTimeDragPrevented.current = date;
+                    return false;
+                }
+                while(element){
+                    if (element.scrollHeight > element.clientHeight) {
+                        if (0 !== element.scrollTop) {
+                            lastTimeDragPrevented.current = new Date();
+                            return false;
+                        }
+                        if ('dialog' === element.getAttribute('role')) break;
+                    }
+                    element = element.parentNode;
+                }
+                return true;
+            }
+            function onDrag(event) {
+                if (!drawerRef.current) return;
+                if (isDragging) {
+                    const directionMultiplier = 'bottom' === direction || 'right' === direction ? 1 : -1;
+                    const draggedDistance = (pointerStart.current - (isVertical(direction) ? event.pageY : event.pageX)) * directionMultiplier;
+                    const isDraggingInDirection = draggedDistance > 0;
+                    const noCloseSnapPointsPreCondition = snapPoints && !dismissible && !isDraggingInDirection;
+                    if (noCloseSnapPointsPreCondition && 0 === activeSnapPointIndex) return;
+                    const absDraggedDistance = Math.abs(draggedDistance);
+                    const wrapper = document.querySelector('[data-vaul-drawer-wrapper]');
+                    const drawerDimension = 'bottom' === direction || 'top' === direction ? drawerHeightRef.current : drawerWidthRef.current;
+                    let percentageDragged = absDraggedDistance / drawerDimension;
+                    const snapPointPercentageDragged = getSnapPointsPercentageDragged(absDraggedDistance, isDraggingInDirection);
+                    if (null !== snapPointPercentageDragged) percentageDragged = snapPointPercentageDragged;
+                    if (noCloseSnapPointsPreCondition && percentageDragged >= 1) return;
+                    if (!isAllowedToDrag.current && !shouldDrag(event.target, isDraggingInDirection)) return;
+                    drawerRef.current.classList.add(DRAG_CLASS);
+                    isAllowedToDrag.current = true;
+                    set(drawerRef.current, {
+                        transition: 'none'
+                    });
+                    set(overlayRef.current, {
+                        transition: 'none'
+                    });
+                    if (snapPoints) onDragSnapPoints({
+                        draggedDistance
+                    });
+                    if (isDraggingInDirection && !snapPoints) {
+                        const dampenedDraggedDistance = dampenValue(draggedDistance);
+                        const translateValue = Math.min(-1 * dampenedDraggedDistance, 0) * directionMultiplier;
+                        set(drawerRef.current, {
+                            transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`
+                        });
+                        return;
+                    }
+                    const opacityValue = 1 - percentageDragged;
+                    if (shouldFade || fadeFromIndex && activeSnapPointIndex === fadeFromIndex - 1) {
+                        null == onDragProp || onDragProp(event, percentageDragged);
+                        set(overlayRef.current, {
+                            opacity: `${opacityValue}`,
+                            transition: 'none'
+                        }, true);
+                    }
+                    if (wrapper && overlayRef.current && shouldScaleBackground) {
+                        const scaleValue = Math.min(getScale() + percentageDragged * (1 - getScale()), 1);
+                        const borderRadiusValue = 8 - 8 * percentageDragged;
+                        const translateValue = Math.max(0, 14 - 14 * percentageDragged);
+                        set(wrapper, {
+                            borderRadius: `${borderRadiusValue}px`,
+                            transform: isVertical(direction) ? `scale(${scaleValue}) translate3d(0, ${translateValue}px, 0)` : `scale(${scaleValue}) translate3d(${translateValue}px, 0, 0)`,
+                            transition: 'none'
+                        }, true);
+                    }
+                    if (!snapPoints) {
+                        const translateValue = absDraggedDistance * directionMultiplier;
+                        set(drawerRef.current, {
+                            transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`
+                        });
+                    }
+                }
+            }
+            react__rspack_import_1["default"].useEffect(()=>{
+                window.requestAnimationFrame(()=>{
+                    shouldAnimate.current = true;
+                });
+            }, []);
+            react__rspack_import_1["default"].useEffect(()=>{
+                var _window_visualViewport;
+                function onVisualViewportChange() {
+                    if (!drawerRef.current || !repositionInputs) return;
+                    const focusedElement = document.activeElement;
+                    if (isInput(focusedElement) || keyboardIsOpen.current) {
+                        var _window_visualViewport;
+                        const visualViewportHeight = (null == (_window_visualViewport = window.visualViewport) ? void 0 : _window_visualViewport.height) || 0;
+                        const totalHeight = window.innerHeight;
+                        let diffFromInitial = totalHeight - visualViewportHeight;
+                        const drawerHeight = drawerRef.current.getBoundingClientRect().height || 0;
+                        const isTallEnough = drawerHeight > 0.8 * totalHeight;
+                        if (!initialDrawerHeight.current) initialDrawerHeight.current = drawerHeight;
+                        const offsetFromTop = drawerRef.current.getBoundingClientRect().top;
+                        if (Math.abs(previousDiffFromInitial.current - diffFromInitial) > 60) keyboardIsOpen.current = !keyboardIsOpen.current;
+                        if (snapPoints && snapPoints.length > 0 && snapPointsOffset && activeSnapPointIndex) {
+                            const activeSnapPointHeight = snapPointsOffset[activeSnapPointIndex] || 0;
+                            diffFromInitial += activeSnapPointHeight;
+                        }
+                        previousDiffFromInitial.current = diffFromInitial;
+                        if (drawerHeight > visualViewportHeight || keyboardIsOpen.current) {
+                            const height = drawerRef.current.getBoundingClientRect().height;
+                            let newDrawerHeight = height;
+                            if (height > visualViewportHeight) newDrawerHeight = visualViewportHeight - (isTallEnough ? offsetFromTop : WINDOW_TOP_OFFSET);
+                            if (fixed) drawerRef.current.style.height = `${height - Math.max(diffFromInitial, 0)}px`;
+                            else drawerRef.current.style.height = `${Math.max(newDrawerHeight, visualViewportHeight - offsetFromTop)}px`;
+                        } else if (!isMobileFirefox()) drawerRef.current.style.height = `${initialDrawerHeight.current}px`;
+                        if (snapPoints && snapPoints.length > 0 && !keyboardIsOpen.current) drawerRef.current.style.bottom = "0px";
+                        else drawerRef.current.style.bottom = `${Math.max(diffFromInitial, 0)}px`;
+                    }
+                }
+                null == (_window_visualViewport = window.visualViewport) || _window_visualViewport.addEventListener('resize', onVisualViewportChange);
+                return ()=>{
+                    var _window_visualViewport;
+                    return null == (_window_visualViewport = window.visualViewport) ? void 0 : _window_visualViewport.removeEventListener('resize', onVisualViewportChange);
+                };
+            }, [
+                activeSnapPointIndex,
+                snapPoints,
+                snapPointsOffset
+            ]);
+            function closeDrawer(fromWithin) {
+                cancelDrag();
+                null == onClose || onClose();
+                if (!fromWithin) setIsOpen(false);
+                setTimeout(()=>{
+                    if (snapPoints) setActiveSnapPoint(snapPoints[0]);
+                }, 1000 * TRANSITIONS.DURATION);
+            }
+            function resetDrawer() {
+                if (!drawerRef.current) return;
+                const wrapper = document.querySelector('[data-vaul-drawer-wrapper]');
+                const currentSwipeAmount = getTranslate(drawerRef.current, direction);
+                set(drawerRef.current, {
+                    transform: 'translate3d(0, 0, 0)',
+                    transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`
+                });
+                set(overlayRef.current, {
+                    transition: `opacity ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,
+                    opacity: '1'
+                });
+                if (shouldScaleBackground && currentSwipeAmount && currentSwipeAmount > 0 && isOpen) set(wrapper, {
+                    borderRadius: `${BORDER_RADIUS}px`,
+                    overflow: 'hidden',
+                    ...isVertical(direction) ? {
+                        transform: `scale(${getScale()}) translate3d(0, calc(env(safe-area-inset-top) + 14px), 0)`,
+                        transformOrigin: 'top'
+                    } : {
+                        transform: `scale(${getScale()}) translate3d(calc(env(safe-area-inset-top) + 14px), 0, 0)`,
+                        transformOrigin: 'left'
+                    },
+                    transitionProperty: 'transform, border-radius',
+                    transitionDuration: `${TRANSITIONS.DURATION}s`,
+                    transitionTimingFunction: `cubic-bezier(${TRANSITIONS.EASE.join(',')})`
+                }, true);
+            }
+            function cancelDrag() {
+                if (!isDragging || !drawerRef.current) return;
+                drawerRef.current.classList.remove(DRAG_CLASS);
+                isAllowedToDrag.current = false;
+                setIsDragging(false);
+                dragEndTime.current = new Date();
+            }
+            function onRelease(event) {
+                if (!isDragging || !drawerRef.current) return;
+                drawerRef.current.classList.remove(DRAG_CLASS);
+                isAllowedToDrag.current = false;
+                setIsDragging(false);
+                dragEndTime.current = new Date();
+                const swipeAmount = getTranslate(drawerRef.current, direction);
+                if (!event || !shouldDrag(event.target, false) || !swipeAmount || Number.isNaN(swipeAmount)) return;
+                if (null === dragStartTime.current) return;
+                const timeTaken = dragEndTime.current.getTime() - dragStartTime.current.getTime();
+                const distMoved = pointerStart.current - (isVertical(direction) ? event.pageY : event.pageX);
+                const velocity = Math.abs(distMoved) / timeTaken;
+                if (velocity > 0.05) {
+                    setJustReleased(true);
+                    setTimeout(()=>{
+                        setJustReleased(false);
+                    }, 200);
+                }
+                if (snapPoints) {
+                    const directionMultiplier = 'bottom' === direction || 'right' === direction ? 1 : -1;
+                    onReleaseSnapPoints({
+                        draggedDistance: distMoved * directionMultiplier,
+                        closeDrawer,
+                        velocity,
+                        dismissible
+                    });
+                    null == onReleaseProp || onReleaseProp(event, true);
+                    return;
+                }
+                if ('bottom' === direction || 'right' === direction ? distMoved > 0 : distMoved < 0) {
+                    resetDrawer();
+                    null == onReleaseProp || onReleaseProp(event, true);
+                    return;
+                }
+                if (velocity > VELOCITY_THRESHOLD) {
+                    closeDrawer();
+                    null == onReleaseProp || onReleaseProp(event, false);
+                    return;
+                }
+                var _drawerRef_current_getBoundingClientRect_height;
+                const visibleDrawerHeight = Math.min(null != (_drawerRef_current_getBoundingClientRect_height = drawerRef.current.getBoundingClientRect().height) ? _drawerRef_current_getBoundingClientRect_height : 0, window.innerHeight);
+                var _drawerRef_current_getBoundingClientRect_width;
+                const visibleDrawerWidth = Math.min(null != (_drawerRef_current_getBoundingClientRect_width = drawerRef.current.getBoundingClientRect().width) ? _drawerRef_current_getBoundingClientRect_width : 0, window.innerWidth);
+                const isHorizontalSwipe = 'left' === direction || 'right' === direction;
+                if (Math.abs(swipeAmount) >= (isHorizontalSwipe ? visibleDrawerWidth : visibleDrawerHeight) * closeThreshold) {
+                    closeDrawer();
+                    null == onReleaseProp || onReleaseProp(event, false);
+                    return;
+                }
+                null == onReleaseProp || onReleaseProp(event, true);
+                resetDrawer();
+            }
+            react__rspack_import_1["default"].useEffect(()=>{
+                if (isOpen) {
+                    set(document.documentElement, {
+                        scrollBehavior: 'auto'
+                    });
+                    openTime.current = new Date();
+                }
+                return ()=>{
+                    reset(document.documentElement, 'scrollBehavior');
+                };
+            }, [
+                isOpen
+            ]);
+            function onNestedOpenChange(o) {
+                const scale = o ? (window.innerWidth - NESTED_DISPLACEMENT) / window.innerWidth : 1;
+                const initialTranslate = o ? -NESTED_DISPLACEMENT : 0;
+                if (nestedOpenChangeTimer.current) window.clearTimeout(nestedOpenChangeTimer.current);
+                set(drawerRef.current, {
+                    transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,
+                    transform: isVertical(direction) ? `scale(${scale}) translate3d(0, ${initialTranslate}px, 0)` : `scale(${scale}) translate3d(${initialTranslate}px, 0, 0)`
+                });
+                if (!o && drawerRef.current) nestedOpenChangeTimer.current = setTimeout(()=>{
+                    const translateValue = getTranslate(drawerRef.current, direction);
+                    set(drawerRef.current, {
+                        transition: 'none',
+                        transform: isVertical(direction) ? `translate3d(0, ${translateValue}px, 0)` : `translate3d(${translateValue}px, 0, 0)`
+                    });
+                }, 500);
+            }
+            function onNestedDrag(_event, percentageDragged) {
+                if (percentageDragged < 0) return;
+                const initialScale = (window.innerWidth - NESTED_DISPLACEMENT) / window.innerWidth;
+                const newScale = initialScale + percentageDragged * (1 - initialScale);
+                const newTranslate = -NESTED_DISPLACEMENT + percentageDragged * NESTED_DISPLACEMENT;
+                set(drawerRef.current, {
+                    transform: isVertical(direction) ? `scale(${newScale}) translate3d(0, ${newTranslate}px, 0)` : `scale(${newScale}) translate3d(${newTranslate}px, 0, 0)`,
+                    transition: 'none'
+                });
+            }
+            function onNestedRelease(_event, o) {
+                const dim = isVertical(direction) ? window.innerHeight : window.innerWidth;
+                const scale = o ? (dim - NESTED_DISPLACEMENT) / dim : 1;
+                const translate = o ? -NESTED_DISPLACEMENT : 0;
+                if (o) set(drawerRef.current, {
+                    transition: `transform ${TRANSITIONS.DURATION}s cubic-bezier(${TRANSITIONS.EASE.join(',')})`,
+                    transform: isVertical(direction) ? `scale(${scale}) translate3d(0, ${translate}px, 0)` : `scale(${scale}) translate3d(${translate}px, 0, 0)`
+                });
+            }
+            react__rspack_import_1["default"].useEffect(()=>{
+                if (!modal) window.requestAnimationFrame(()=>{
+                    document.body.style.pointerEvents = 'auto';
+                });
+            }, [
+                modal
+            ]);
+            return /*#__PURE__*/ react__rspack_import_1["default"].createElement(_radix_ui_react_dialog__rspack_import_0.Root, {
+                defaultOpen: defaultOpen,
+                onOpenChange: (open)=>{
+                    if (!dismissible && !open) return;
+                    if (open) setHasBeenOpened(true);
+                    else closeDrawer(true);
+                    setIsOpen(open);
+                },
+                open: isOpen
+            }, /*#__PURE__*/ react__rspack_import_1["default"].createElement(DrawerContext.Provider, {
+                value: {
+                    activeSnapPoint,
+                    snapPoints,
+                    setActiveSnapPoint,
+                    drawerRef,
+                    overlayRef,
+                    onOpenChange,
+                    onPress,
+                    onRelease,
+                    onDrag,
+                    dismissible,
+                    shouldAnimate,
+                    handleOnly,
+                    isOpen,
+                    isDragging,
+                    shouldFade,
+                    closeDrawer,
+                    onNestedDrag,
+                    onNestedOpenChange,
+                    onNestedRelease,
+                    keyboardIsOpen,
+                    modal,
+                    snapPointsOffset,
+                    activeSnapPointIndex,
+                    direction,
+                    shouldScaleBackground,
+                    setBackgroundColorOnScale,
+                    noBodyStyles,
+                    container,
+                    autoFocus
+                }
+            }, children));
+        }
+        const Overlay = /*#__PURE__*/ react__rspack_import_1["default"].forwardRef(function({ ...rest }, ref) {
+            const { overlayRef, snapPoints, onRelease, shouldFade, isOpen, modal, shouldAnimate } = useDrawerContext();
+            const composedRef = useComposedRefs(ref, overlayRef);
+            const hasSnapPoints = snapPoints && snapPoints.length > 0;
+            if (!modal) return null;
+            const onMouseUp = react__rspack_import_1["default"].useCallback((event)=>onRelease(event), [
+                onRelease
+            ]);
+            return /*#__PURE__*/ react__rspack_import_1["default"].createElement(_radix_ui_react_dialog__rspack_import_0.Overlay, {
+                onMouseUp: onMouseUp,
+                ref: composedRef,
+                "data-vaul-overlay": "",
+                "data-vaul-snap-points": isOpen && hasSnapPoints ? 'true' : 'false',
+                "data-vaul-snap-points-overlay": isOpen && shouldFade ? 'true' : 'false',
+                "data-vaul-animate": (null == shouldAnimate ? void 0 : shouldAnimate.current) ? 'true' : 'false',
+                ...rest
+            });
+        });
+        Overlay.displayName = 'Drawer.Overlay';
+        const Content = /*#__PURE__*/ react__rspack_import_1["default"].forwardRef(function({ onPointerDownOutside, style, onOpenAutoFocus, ...rest }, ref) {
+            const { drawerRef, onPress, onRelease, onDrag, keyboardIsOpen, snapPointsOffset, activeSnapPointIndex, modal, isOpen, direction, snapPoints, container, handleOnly, shouldAnimate, autoFocus } = useDrawerContext();
+            const [delayedSnapPoints, setDelayedSnapPoints] = react__rspack_import_1["default"].useState(false);
+            const composedRef = useComposedRefs(ref, drawerRef);
+            const pointerStartRef = react__rspack_import_1["default"].useRef(null);
+            const lastKnownPointerEventRef = react__rspack_import_1["default"].useRef(null);
+            const wasBeyondThePointRef = react__rspack_import_1["default"].useRef(false);
+            const hasSnapPoints = snapPoints && snapPoints.length > 0;
+            useScaleBackground();
+            const isDeltaInDirection = (delta, direction, threshold = 0)=>{
+                if (wasBeyondThePointRef.current) return true;
+                const deltaY = Math.abs(delta.y);
+                const deltaX = Math.abs(delta.x);
+                const isDeltaX = deltaX > deltaY;
+                const dFactor = [
+                    'bottom',
+                    'right'
+                ].includes(direction) ? 1 : -1;
+                if ('left' === direction || 'right' === direction) {
+                    const isReverseDirection = delta.x * dFactor < 0;
+                    if (!isReverseDirection && deltaX >= 0 && deltaX <= threshold) return isDeltaX;
+                } else {
+                    const isReverseDirection = delta.y * dFactor < 0;
+                    if (!isReverseDirection && deltaY >= 0 && deltaY <= threshold) return !isDeltaX;
+                }
+                wasBeyondThePointRef.current = true;
+                return true;
+            };
+            react__rspack_import_1["default"].useEffect(()=>{
+                if (hasSnapPoints) window.requestAnimationFrame(()=>{
+                    setDelayedSnapPoints(true);
+                });
+            }, []);
+            function handleOnPointerUp(event) {
+                pointerStartRef.current = null;
+                wasBeyondThePointRef.current = false;
+                onRelease(event);
+            }
+            return /*#__PURE__*/ react__rspack_import_1["default"].createElement(_radix_ui_react_dialog__rspack_import_0.Content, {
+                "data-vaul-drawer-direction": direction,
+                "data-vaul-drawer": "",
+                "data-vaul-delayed-snap-points": delayedSnapPoints ? 'true' : 'false',
+                "data-vaul-snap-points": isOpen && hasSnapPoints ? 'true' : 'false',
+                "data-vaul-custom-container": container ? 'true' : 'false',
+                "data-vaul-animate": (null == shouldAnimate ? void 0 : shouldAnimate.current) ? 'true' : 'false',
+                ...rest,
+                ref: composedRef,
+                style: snapPointsOffset && snapPointsOffset.length > 0 ? {
+                    '--snap-point-height': `${snapPointsOffset[null != activeSnapPointIndex ? activeSnapPointIndex : 0]}px`,
+                    ...style
+                } : style,
+                onPointerDown: (event)=>{
+                    if (handleOnly) return;
+                    null == rest.onPointerDown || rest.onPointerDown.call(rest, event);
+                    pointerStartRef.current = {
+                        x: event.pageX,
+                        y: event.pageY
+                    };
+                    onPress(event);
+                },
+                onOpenAutoFocus: (e)=>{
+                    null == onOpenAutoFocus || onOpenAutoFocus(e);
+                    if (!autoFocus) e.preventDefault();
+                },
+                onPointerDownOutside: (e)=>{
+                    null == onPointerDownOutside || onPointerDownOutside(e);
+                    if (!modal || e.defaultPrevented) return void e.preventDefault();
+                    if (keyboardIsOpen.current) keyboardIsOpen.current = false;
+                },
+                onFocusOutside: (e)=>{
+                    if (!modal) return void e.preventDefault();
+                },
+                onPointerMove: (event)=>{
+                    lastKnownPointerEventRef.current = event;
+                    if (handleOnly) return;
+                    null == rest.onPointerMove || rest.onPointerMove.call(rest, event);
+                    if (!pointerStartRef.current) return;
+                    const yPosition = event.pageY - pointerStartRef.current.y;
+                    const xPosition = event.pageX - pointerStartRef.current.x;
+                    const swipeStartThreshold = 'touch' === event.pointerType ? 10 : 2;
+                    const delta = {
+                        x: xPosition,
+                        y: yPosition
+                    };
+                    const isAllowedToSwipe = isDeltaInDirection(delta, direction, swipeStartThreshold);
+                    if (isAllowedToSwipe) onDrag(event);
+                    else if (Math.abs(xPosition) > swipeStartThreshold || Math.abs(yPosition) > swipeStartThreshold) pointerStartRef.current = null;
+                },
+                onPointerUp: (event)=>{
+                    null == rest.onPointerUp || rest.onPointerUp.call(rest, event);
+                    pointerStartRef.current = null;
+                    wasBeyondThePointRef.current = false;
+                    onRelease(event);
+                },
+                onPointerOut: (event)=>{
+                    null == rest.onPointerOut || rest.onPointerOut.call(rest, event);
+                    handleOnPointerUp(lastKnownPointerEventRef.current);
+                },
+                onContextMenu: (event)=>{
+                    null == rest.onContextMenu || rest.onContextMenu.call(rest, event);
+                    if (lastKnownPointerEventRef.current) handleOnPointerUp(lastKnownPointerEventRef.current);
+                }
+            });
+        });
+        Content.displayName = 'Drawer.Content';
+        const LONG_HANDLE_PRESS_TIMEOUT = 250;
+        const DOUBLE_TAP_TIMEOUT = 120;
+        const Handle = /*#__PURE__*/ react__rspack_import_1["default"].forwardRef(function({ preventCycle = false, children, ...rest }, ref) {
+            const { closeDrawer, isDragging, snapPoints, activeSnapPoint, setActiveSnapPoint, dismissible, handleOnly, isOpen, onPress, onDrag } = useDrawerContext();
+            const closeTimeoutIdRef = react__rspack_import_1["default"].useRef(null);
+            const shouldCancelInteractionRef = react__rspack_import_1["default"].useRef(false);
+            function handleStartCycle() {
+                if (shouldCancelInteractionRef.current) return void handleCancelInteraction();
+                window.setTimeout(()=>{
+                    handleCycleSnapPoints();
+                }, DOUBLE_TAP_TIMEOUT);
+            }
+            function handleCycleSnapPoints() {
+                if (isDragging || preventCycle || shouldCancelInteractionRef.current) return void handleCancelInteraction();
+                handleCancelInteraction();
+                if (!snapPoints || 0 === snapPoints.length) {
+                    if (!dismissible) closeDrawer();
+                    return;
+                }
+                const isLastSnapPoint = activeSnapPoint === snapPoints[snapPoints.length - 1];
+                if (isLastSnapPoint && dismissible) return void closeDrawer();
+                const currentSnapIndex = snapPoints.findIndex((point)=>point === activeSnapPoint);
+                if (-1 === currentSnapIndex) return;
+                const nextSnapPoint = snapPoints[currentSnapIndex + 1];
+                setActiveSnapPoint(nextSnapPoint);
+            }
+            function handleStartInteraction() {
+                closeTimeoutIdRef.current = window.setTimeout(()=>{
+                    shouldCancelInteractionRef.current = true;
+                }, LONG_HANDLE_PRESS_TIMEOUT);
+            }
+            function handleCancelInteraction() {
+                if (closeTimeoutIdRef.current) window.clearTimeout(closeTimeoutIdRef.current);
+                shouldCancelInteractionRef.current = false;
+            }
+            return /*#__PURE__*/ react__rspack_import_1["default"].createElement("div", {
+                onClick: handleStartCycle,
+                onPointerCancel: handleCancelInteraction,
+                onPointerDown: (e)=>{
+                    if (handleOnly) onPress(e);
+                    handleStartInteraction();
+                },
+                onPointerMove: (e)=>{
+                    if (handleOnly) onDrag(e);
+                },
+                ref: ref,
+                "data-vaul-drawer-visible": isOpen ? 'true' : 'false',
+                "data-vaul-handle": "",
+                "aria-hidden": "true",
+                ...rest
+            }, /*#__PURE__*/ react__rspack_import_1["default"].createElement("span", {
+                "data-vaul-handle-hitarea": "",
+                "aria-hidden": "true"
+            }, children));
+        });
+        Handle.displayName = 'Drawer.Handle';
+        function NestedRoot({ onDrag, onOpenChange, open: nestedIsOpen, ...rest }) {
+            const { onNestedDrag, onNestedOpenChange, onNestedRelease } = useDrawerContext();
+            if (!onNestedDrag) throw new Error('Drawer.NestedRoot must be placed in another drawer');
+            return /*#__PURE__*/ react__rspack_import_1["default"].createElement(Root, {
+                nested: true,
+                open: nestedIsOpen,
+                onClose: ()=>{
+                    onNestedOpenChange(false);
+                },
+                onDrag: (e, p)=>{
+                    onNestedDrag(e, p);
+                    null == onDrag || onDrag(e, p);
+                },
+                onOpenChange: (o)=>{
+                    if (o) onNestedOpenChange(o);
+                    null == onOpenChange || onOpenChange(o);
+                },
+                onRelease: onNestedRelease,
+                ...rest
+            });
+        }
+        function Portal(props) {
+            const context = useDrawerContext();
+            const { container = context.container, ...portalProps } = props;
+            return /*#__PURE__*/ react__rspack_import_1["default"].createElement(_radix_ui_react_dialog__rspack_import_0.Portal, {
+                container: container,
+                ...portalProps
+            });
+        }
+        const Drawer = {
+            Root,
+            NestedRoot,
+            Content,
+            Overlay,
+            Trigger: _radix_ui_react_dialog__rspack_import_0.Trigger,
+            Portal,
+            Handle,
+            Close: _radix_ui_react_dialog__rspack_import_0.Close,
+            Title: _radix_ui_react_dialog__rspack_import_0.Title,
+            Description: _radix_ui_react_dialog__rspack_import_0.Description
+        };
+    }
+};