@tarsis/toolkit 0.5.2 → 0.5.3

package/dist/{index-CmzNwlcp.cjs → index-C1HOJZOl.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-const index$2 = require('./index-CEXzqVuq.cjs');
+const index$2 = require('./index-BH-WDme3.cjs');
 
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {

package/dist/{index-DqgylTr3.js → index-CBTCt41n.js}

@@ -1,11 +1,10 @@
-import { p as isBrowser$1, q as isObject$3, r as resolveElements, s as interpolate$2, t as frame$2, v as isMotionValue, J as JSAnimation, w as featureDefinitions, x as isControllingVariants, y as isVariantLabel, z as isForcedMotionValue, A as buildHTMLStyles, B as buildSVGAttrs, C as isSVGTag, D as useConstant, E as isVariantNode, F as isAnimationControls, G as resolveVariantFromProps, H as scrapeMotionValuesFromProps, I as scrapeMotionValuesFromProps$1, M as MotionConfigContext, K as optimizedAppearDataAttribute, L as warning, N as invariant, O as warnOnce, S as SVGVisualElement, P as HTMLVisualElement, Q as resolveVariant, R as animateTarget, T as variantProps, U as isKeyframesTarget, V as variantPriorityOrder, W as mixNumber, X as frameData, Y as pipe$1, Z as cancelFrame, _ as secondsToMilliseconds, $ as millisecondsToSeconds, a0 as progress$2, a1 as clamp$3, a2 as createBox, a3 as measurePageBox, a4 as convertBoxToBoundingBox, a5 as convertBoundingBoxToBox, a6 as addValueToWillChange, a7 as animateMotionValue, a8 as percent, a9 as noop$4, aa as microtask, ab as addUniqueItem, ac as removeItem, ad as time$1, ae as px$2, af as circOut, ag as scalePoint, ah as SubscriptionManager, ai as isSVGElement$1, aj as isSVGSVGElement, ak as getValueTransition, al as frameSteps, am as hasTransform, an as translateAxis, ao as transformBox, ap as hasScale, aq as applyBoxDelta, ar as has2DTranslate, as as applyTreeDeltas, at as createDelta, au as motionValue, av as animateSingleValue, aw as scaleCorrectors, ax as getOptimisedAppearId, ay as useMotionValue, az as collectMotionValues, aA as createScopedAnimate, f as useLiveRef, m as useThrottle, g as useMatchMedia, l as useRaf, b as useDebounce, i as useOutsideClick, o as useWindowReady, e as useInterval, d as useEffectEvent$1, h as useOklch } from './useWindowReady-CpmawCsz.js';
-import { g as getPath, a as lerp$1, d as distance$2, l as lineEq, w as wait } from './svg-CoSCBw2u.js';
+import { p as isBrowser$1, q as isObject$3, r as resolveElements, s as interpolate$2, t as frame$2, v as isMotionValue, J as JSAnimation, M as MotionConfigContext, w as useConstant, x as featureDefinitions, y as isControllingVariants, z as isVariantLabel, A as isForcedMotionValue, B as buildHTMLStyles, C as buildSVGAttrs, D as isSVGTag, E as isVariantNode, F as isAnimationControls, G as resolveVariantFromProps, H as scrapeMotionValuesFromProps, I as scrapeMotionValuesFromProps$1, K as optimizedAppearDataAttribute, L as warning, N as invariant, O as warnOnce, S as SVGVisualElement, P as HTMLVisualElement, Q as resolveVariant, R as animateTarget, T as variantProps, U as isKeyframesTarget, V as variantPriorityOrder, W as mixNumber, X as frameData, Y as pipe$1, Z as cancelFrame, _ as secondsToMilliseconds, $ as millisecondsToSeconds, a0 as progress$2, a1 as clamp$3, a2 as createBox, a3 as measurePageBox, a4 as convertBoxToBoundingBox, a5 as convertBoundingBoxToBox, a6 as addValueToWillChange, a7 as animateMotionValue, a8 as percent, a9 as noop$4, aa as microtask, ab as addUniqueItem, ac as removeItem, ad as time$1, ae as px$2, af as circOut, ag as scalePoint, ah as SubscriptionManager, ai as isSVGElement$1, aj as isSVGSVGElement, ak as getValueTransition, al as frameSteps, am as hasTransform, an as translateAxis, ao as transformBox, ap as hasScale, aq as applyBoxDelta, ar as has2DTranslate, as as applyTreeDeltas, at as createDelta, au as motionValue, av as animateSingleValue, aw as scaleCorrectors, ax as getOptimisedAppearId, ay as useMotionValue, az as collectMotionValues, aA as hasReducedMotionListener, aB as initPrefersReducedMotion, aC as prefersReducedMotion, aD as createScopedAnimate, f as useLiveRef, m as useThrottle, g as useMatchMedia, l as useRaf, b as useDebounce, i as useOutsideClick, o as useWindowReady, e as useInterval, d as useEffectEvent$1, h as useOklch } from './useWindowReady-DVV-s65K.js';
+import { n as noop$5, D as getPath, z as lerp$1, x as distance$2, y as lineEq, C as wait } from './svg-CQLdTbLk.js';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import * as React from 'react';
-import React__default, { useRef, useEffect, useState, useMemo, createContext, useLayoutEffect, useContext, useId as useId$1, useCallback, Fragment as Fragment$1, createElement as createElement$1, useInsertionEffect as useInsertionEffect$1, forwardRef, Component, Children, cloneElement, isValidElement } from 'react';
+import React__default, { useRef, useEffect, useState, useMemo, createContext, useLayoutEffect, useId as useId$1, useContext, useInsertionEffect as useInsertionEffect$1, useCallback, Children, isValidElement, Fragment as Fragment$1, createElement as createElement$1, forwardRef, Component, cloneElement } from 'react';
 import * as ReactDOM from 'react-dom';
 import ReactDOM__default, { unstable_batchedUpdates } from 'react-dom';
-import { noop as noop$5 } from './server.js';
 
 function r$1(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r$1(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r$1(e))&&(n&&(n+=" "),n+=t);return n}
 
@@ -52088,11 +52087,11 @@ const BubblyParticlesButton = () => {
   );
 };
 
-const root$4i = "_root_6u0yf_1";
-const button$o = "_button_6u0yf_13";
-const p$1 = "_p_6u0yf_26";
-const text$z = "_text_6u0yf_26";
-const effects = "_effects_6u0yf_240";
+const root$4i = "_root_yhweb_1";
+const button$o = "_button_yhweb_13";
+const p$1 = "_p_yhweb_26";
+const text$z = "_text_yhweb_26";
+const effects = "_effects_yhweb_240";
 const styles$4G = {
 	root: root$4i,
 	button: button$o,
@@ -59987,6 +59986,205 @@ function asNumber$1(v) {
     return typeof v === "number" ? v : parseFloat(v);
 }
 
+/**
+ * Taken from https://github.com/radix-ui/primitives/blob/main/packages/react/compose-refs/src/compose-refs.tsx
+ */
+/**
+ * Set a given ref to a given value
+ * This utility takes care of different types of refs: callback refs and RefObject(s)
+ */
+function setRef(ref, value) {
+    if (typeof ref === "function") {
+        return ref(value);
+    }
+    else if (ref !== null && ref !== undefined) {
+        ref.current = value;
+    }
+}
+/**
+ * A utility to compose multiple refs together
+ * Accepts callback refs and RefObject(s)
+ */
+function composeRefs(...refs) {
+    return (node) => {
+        let hasCleanup = false;
+        const cleanups = refs.map((ref) => {
+            const cleanup = setRef(ref, node);
+            if (!hasCleanup && typeof cleanup === "function") {
+                hasCleanup = true;
+            }
+            return cleanup;
+        });
+        // React <19 will log an error to the console if a callback ref returns a
+        // value. We don't use ref cleanups internally so this will only happen if a
+        // user's ref callback returns a value, which we only expect if they are
+        // using the cleanup functionality added in React 19.
+        if (hasCleanup) {
+            return () => {
+                for (let i = 0; i < cleanups.length; i++) {
+                    const cleanup = cleanups[i];
+                    if (typeof cleanup === "function") {
+                        cleanup();
+                    }
+                    else {
+                        setRef(refs[i], null);
+                    }
+                }
+            };
+        }
+    };
+}
+/**
+ * A custom hook that composes multiple refs
+ * Accepts callback refs and RefObject(s)
+ */
+function useComposedRefs(...refs) {
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    return React.useCallback(composeRefs(...refs), refs);
+}
+
+/**
+ * Measurement functionality has to be within a separate component
+ * to leverage snapshot lifecycle.
+ */
+class PopChildMeasure extends React.Component {
+    getSnapshotBeforeUpdate(prevProps) {
+        const element = this.props.childRef.current;
+        if (element && prevProps.isPresent && !this.props.isPresent) {
+            const parent = element.offsetParent;
+            const parentWidth = isHTMLElement$2(parent)
+                ? parent.offsetWidth || 0
+                : 0;
+            const size = this.props.sizeRef.current;
+            size.height = element.offsetHeight || 0;
+            size.width = element.offsetWidth || 0;
+            size.top = element.offsetTop;
+            size.left = element.offsetLeft;
+            size.right = parentWidth - size.width - size.left;
+        }
+        return null;
+    }
+    /**
+     * Required with getSnapshotBeforeUpdate to stop React complaining.
+     */
+    componentDidUpdate() { }
+    render() {
+        return this.props.children;
+    }
+}
+function PopChild({ children, isPresent, anchorX, root }) {
+    const id = useId$1();
+    const ref = useRef(null);
+    const size = useRef({
+        width: 0,
+        height: 0,
+        top: 0,
+        left: 0,
+        right: 0,
+    });
+    const { nonce } = useContext(MotionConfigContext);
+    /**
+     * In React 19, refs are passed via props.ref instead of element.ref.
+     * We check props.ref first (React 19) and fall back to element.ref (React 18).
+     */
+    const childRef = children.props?.ref ??
+        children?.ref;
+    const composedRef = useComposedRefs(ref, childRef);
+    /**
+     * We create and inject a style block so we can apply this explicit
+     * sizing in a non-destructive manner by just deleting the style block.
+     *
+     * We can't apply size via render as the measurement happens
+     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the
+     * styles directly on the DOM node, we might be overwriting
+     * styles set via the style prop.
+     */
+    useInsertionEffect$1(() => {
+        const { width, height, top, left, right } = size.current;
+        if (isPresent || !ref.current || !width || !height)
+            return;
+        const x = anchorX === "left" ? `left: ${left}` : `right: ${right}`;
+        ref.current.dataset.motionPopId = id;
+        const style = document.createElement("style");
+        if (nonce)
+            style.nonce = nonce;
+        const parent = root ?? document.head;
+        parent.appendChild(style);
+        if (style.sheet) {
+            style.sheet.insertRule(`
+          [data-motion-pop-id="${id}"] {
+            position: absolute !important;
+            width: ${width}px !important;
+            height: ${height}px !important;
+            ${x}px !important;
+            top: ${top}px !important;
+          }
+        `);
+        }
+        return () => {
+            if (parent.contains(style)) {
+                parent.removeChild(style);
+            }
+        };
+    }, [isPresent]);
+    return (jsx(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: React.cloneElement(children, { ref: composedRef }) }));
+}
+
+const PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, anchorX, root }) => {
+    const presenceChildren = useConstant(newChildrenMap);
+    const id = useId$1();
+    let isReusedContext = true;
+    let context = useMemo(() => {
+        isReusedContext = false;
+        return {
+            id,
+            initial,
+            isPresent,
+            custom,
+            onExitComplete: (childId) => {
+                presenceChildren.set(childId, true);
+                for (const isComplete of presenceChildren.values()) {
+                    if (!isComplete)
+                        return; // can stop searching when any is incomplete
+                }
+                onExitComplete && onExitComplete();
+            },
+            register: (childId) => {
+                presenceChildren.set(childId, false);
+                return () => presenceChildren.delete(childId);
+            },
+        };
+    }, [isPresent, presenceChildren, onExitComplete]);
+    /**
+     * If the presence of a child affects the layout of the components around it,
+     * we want to make a new context value to ensure they get re-rendered
+     * so they can detect that layout change.
+     */
+    if (presenceAffectsLayout && isReusedContext) {
+        context = { ...context };
+    }
+    useMemo(() => {
+        presenceChildren.forEach((_, key) => presenceChildren.set(key, false));
+    }, [isPresent]);
+    /**
+     * If there's no `motion` components to fire exit animations, we want to remove this
+     * component immediately.
+     */
+    React.useEffect(() => {
+        !isPresent &&
+            !presenceChildren.size &&
+            onExitComplete &&
+            onExitComplete();
+    }, [isPresent]);
+    if (mode === "popLayout") {
+        children = (jsx(PopChild, { isPresent: isPresent, anchorX: anchorX, root: root, children: children }));
+    }
+    return (jsx(PresenceContext.Provider, { value: context, children: children }));
+};
+function newChildrenMap() {
+    return new Map();
+}
+
 /**
  * When a component is the child of `AnimatePresence`, it can use `usePresence`
  * to access information about whether it's still present in the React tree.
@@ -60027,6 +60225,181 @@ function usePresence(subscribe = true) {
     return !isPresent && onExitComplete ? [false, safeToRemove] : [true];
 }
 
+const getChildKey = (child) => child.key || "";
+function onlyElements(children) {
+    const filtered = [];
+    // We use forEach here instead of map as map mutates the component key by preprending `.$`
+    Children.forEach(children, (child) => {
+        if (isValidElement(child))
+            filtered.push(child);
+    });
+    return filtered;
+}
+
+/**
+ * `AnimatePresence` enables the animation of components that have been removed from the tree.
+ *
+ * When adding/removing more than a single child, every child **must** be given a unique `key` prop.
+ *
+ * Any `motion` components that have an `exit` property defined will animate out when removed from
+ * the tree.
+ *
+ * ```jsx
+ * import { motion, AnimatePresence } from 'framer-motion'
+ *
+ * export const Items = ({ items }) => (
+ *   <AnimatePresence>
+ *     {items.map(item => (
+ *       <motion.div
+ *         key={item.id}
+ *         initial={{ opacity: 0 }}
+ *         animate={{ opacity: 1 }}
+ *         exit={{ opacity: 0 }}
+ *       />
+ *     ))}
+ *   </AnimatePresence>
+ * )
+ * ```
+ *
+ * You can sequence exit animations throughout a tree using variants.
+ *
+ * If a child contains multiple `motion` components with `exit` props, it will only unmount the child
+ * once all `motion` components have finished animating out. Likewise, any components using
+ * `usePresence` all need to call `safeToRemove`.
+ *
+ * @public
+ */
+const AnimatePresence = ({ children, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode = "sync", propagate = false, anchorX = "left", root }) => {
+    const [isParentPresent, safeToRemove] = usePresence(propagate);
+    /**
+     * Filter any children that aren't ReactElements. We can only track components
+     * between renders with a props.key.
+     */
+    const presentChildren = useMemo(() => onlyElements(children), [children]);
+    /**
+     * Track the keys of the currently rendered children. This is used to
+     * determine which children are exiting.
+     */
+    const presentKeys = propagate && !isParentPresent ? [] : presentChildren.map(getChildKey);
+    /**
+     * If `initial={false}` we only want to pass this to components in the first render.
+     */
+    const isInitialRender = useRef(true);
+    /**
+     * A ref containing the currently present children. When all exit animations
+     * are complete, we use this to re-render the component with the latest children
+     * *committed* rather than the latest children *rendered*.
+     */
+    const pendingPresentChildren = useRef(presentChildren);
+    /**
+     * Track which exiting children have finished animating out.
+     */
+    const exitComplete = useConstant(() => new Map());
+    /**
+     * Track which components are currently processing exit to prevent duplicate processing.
+     */
+    const exitingComponents = useRef(new Set());
+    /**
+     * Save children to render as React state. To ensure this component is concurrent-safe,
+     * we check for exiting children via an effect.
+     */
+    const [diffedChildren, setDiffedChildren] = useState(presentChildren);
+    const [renderedChildren, setRenderedChildren] = useState(presentChildren);
+    useIsomorphicLayoutEffect$2(() => {
+        isInitialRender.current = false;
+        pendingPresentChildren.current = presentChildren;
+        /**
+         * Update complete status of exiting children.
+         */
+        for (let i = 0; i < renderedChildren.length; i++) {
+            const key = getChildKey(renderedChildren[i]);
+            if (!presentKeys.includes(key)) {
+                if (exitComplete.get(key) !== true) {
+                    exitComplete.set(key, false);
+                }
+            }
+            else {
+                exitComplete.delete(key);
+                exitingComponents.current.delete(key);
+            }
+        }
+    }, [renderedChildren, presentKeys.length, presentKeys.join("-")]);
+    const exitingChildren = [];
+    if (presentChildren !== diffedChildren) {
+        let nextChildren = [...presentChildren];
+        /**
+         * Loop through all the currently rendered components and decide which
+         * are exiting.
+         */
+        for (let i = 0; i < renderedChildren.length; i++) {
+            const child = renderedChildren[i];
+            const key = getChildKey(child);
+            if (!presentKeys.includes(key)) {
+                nextChildren.splice(i, 0, child);
+                exitingChildren.push(child);
+            }
+        }
+        /**
+         * If we're in "wait" mode, and we have exiting children, we want to
+         * only render these until they've all exited.
+         */
+        if (mode === "wait" && exitingChildren.length) {
+            nextChildren = exitingChildren;
+        }
+        setRenderedChildren(onlyElements(nextChildren));
+        setDiffedChildren(presentChildren);
+        /**
+         * Early return to ensure once we've set state with the latest diffed
+         * children, we can immediately re-render.
+         */
+        return null;
+    }
+    if (process.env.NODE_ENV !== "production" &&
+        mode === "wait" &&
+        renderedChildren.length > 1) {
+        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
+    }
+    /**
+     * If we've been provided a forceRender function by the LayoutGroupContext,
+     * we can use it to force a re-render amongst all surrounding components once
+     * all components have finished animating out.
+     */
+    const { forceRender } = useContext(LayoutGroupContext);
+    return (jsx(Fragment, { children: renderedChildren.map((child) => {
+            const key = getChildKey(child);
+            const isPresent = propagate && !isParentPresent
+                ? false
+                : presentChildren === renderedChildren ||
+                    presentKeys.includes(key);
+            const onExit = () => {
+                if (exitingComponents.current.has(key)) {
+                    return;
+                }
+                exitingComponents.current.add(key);
+                if (exitComplete.has(key)) {
+                    exitComplete.set(key, true);
+                }
+                else {
+                    return;
+                }
+                let isEveryExitComplete = true;
+                exitComplete.forEach((isExitComplete) => {
+                    if (!isExitComplete)
+                        isEveryExitComplete = false;
+                });
+                if (isEveryExitComplete) {
+                    forceRender?.();
+                    setRenderedChildren(pendingPresentChildren.current);
+                    propagate && safeToRemove?.();
+                    onExitComplete && onExitComplete();
+                }
+            };
+            return (jsx(PresenceChild, { isPresent: isPresent, initial: !isInitialRender.current || initial
+                    ? undefined
+                    : false, custom: custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode, root: root, onExitComplete: isPresent ? undefined : onExit, anchorX: anchorX, children: child }, key));
+        }) }));
+};
+
 const LazyContext = createContext({ strict: false });
 
 function loadFeatures(features) {
@@ -64688,6 +65061,47 @@ function useSpring$1(source, options = {}) {
     return value;
 }
 
+/**
+ * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.
+ *
+ * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing
+ * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.
+ *
+ * It will actively respond to changes and re-render your components with the latest setting.
+ *
+ * ```jsx
+ * export function Sidebar({ isOpen }) {
+ *   const shouldReduceMotion = useReducedMotion()
+ *   const closedX = shouldReduceMotion ? 0 : "-100%"
+ *
+ *   return (
+ *     <motion.div animate={{
+ *       opacity: isOpen ? 1 : 0,
+ *       x: isOpen ? 0 : closedX
+ *     }} />
+ *   )
+ * }
+ * ```
+ *
+ * @return boolean
+ *
+ * @public
+ */
+function useReducedMotion() {
+    /**
+     * Lazy initialisation of prefersReducedMotion
+     */
+    !hasReducedMotionListener.current && initPrefersReducedMotion();
+    const [shouldReduceMotion] = useState(prefersReducedMotion.current);
+    if (process.env.NODE_ENV !== "production") {
+        warnOnce(shouldReduceMotion !== true, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled");
+    }
+    /**
+     * TODO See if people miss automatically updating shouldReduceMotion setting
+     */
+    return shouldReduceMotion;
+}
+
 function useAnimate() {
     const scope = useConstant(() => ({
         current: null, // Will be hydrated by React
@@ -67686,9 +68100,9 @@ const NeonButton = ({ className = "", ...rest }) => {
   return /* @__PURE__ */ jsx("button", { type: "button", ...rest, className: clsx(styles$48.root, className), children: "Neon" });
 };
 
-const root$3P = "_root_v0k72_2";
-const i$6 = "_i_v0k72_22";
-const text$s = "_text_v0k72_482";
+const root$3P = "_root_1ol0v_2";
+const i$6 = "_i_1ol0v_22";
+const text$s = "_text_1ol0v_482";
 const styles$47 = {
 	root: root$3P,
 	i: i$6,
@@ -77679,9 +78093,11 @@ function useRole(context, props) {
   } : {}, [enabled, reference, floating, item]);
 }
 
-const tooltip = "_tooltip_45btf_1";
+const tooltip = "_tooltip_pli88_1";
+const tooltipContent = "_tooltipContent_pli88_6";
 const styles$2R = {
-	tooltip: tooltip
+	tooltip: tooltip,
+	tooltipContent: tooltipContent
 };
 
 const Tooltip = ({
@@ -77692,7 +78108,29 @@ const Tooltip = ({
   placement = "top",
   offset: offsetValue = 8
 }) => {
-  const [isOpen, setIsOpen] = useState(false);
+  const [isOpen, setIsOpen] = useState(true);
+  const shouldReduceMotion = useReducedMotion();
+  const variants = shouldReduceMotion ? void 0 : {
+    initial: { scale: 0.6, opacity: 0 },
+    animate: {
+      scale: 1,
+      opacity: 1,
+      transition: {
+        type: "spring",
+        stiffness: 150,
+        damping: 20,
+        mass: 1.2
+      }
+    },
+    exit: {
+      scale: 0.4,
+      opacity: 0,
+      transition: {
+        duration: 0.1,
+        ease: "easeIn"
+      }
+    }
+  };
   const { refs, floatingStyles, context } = useFloating({
     open: isOpen,
     onOpenChange: setIsOpen,
@@ -77748,16 +78186,27 @@ const Tooltip = ({
     };
     return /* @__PURE__ */ jsxs(Fragment, { children: [
       cloneElement(childElement, mergedProps),
-      isOpen && /* @__PURE__ */ jsx(FloatingPortal, { children: /* @__PURE__ */ jsx(
+      /* @__PURE__ */ jsx(FloatingPortal, { children: /* @__PURE__ */ jsx(AnimatePresence, { mode: "wait", children: isOpen && /* @__PURE__ */ jsx(
         "div",
         {
           ref: refs.setFloating,
           style: floatingStyles,
           ...getFloatingProps(),
-          className: clsx(styles$2R.tooltip, className),
-          children: label
-        }
-      ) })
+          className: styles$2R.tooltip,
+          children: /* @__PURE__ */ jsx(
+            motion.div,
+            {
+              className: clsx(styles$2R.tooltipContent, className),
+              variants,
+              initial: shouldReduceMotion ? void 0 : "initial",
+              animate: shouldReduceMotion ? void 0 : "animate",
+              exit: shouldReduceMotion ? void 0 : "exit",
+              children: label
+            }
+          )
+        },
+        "tooltip"
+      ) }) })
     ] });
   }
   return /* @__PURE__ */ jsxs(Fragment, { children: [
@@ -77770,16 +78219,27 @@ const Tooltip = ({
         children
       }
     ),
-    isOpen && /* @__PURE__ */ jsx(FloatingPortal, { children: /* @__PURE__ */ jsx(
+    /* @__PURE__ */ jsx(FloatingPortal, { children: /* @__PURE__ */ jsx(AnimatePresence, { mode: "wait", children: isOpen && /* @__PURE__ */ jsx(
       "div",
       {
         ref: refs.setFloating,
         style: floatingStyles,
         ...getFloatingProps(),
-        className: clsx(styles$2R.tooltip, className),
-        children: label
-      }
-    ) })
+        className: styles$2R.tooltip,
+        children: /* @__PURE__ */ jsx(
+          motion.div,
+          {
+            className: clsx(styles$2R.tooltipContent, className),
+            variants,
+            initial: shouldReduceMotion ? void 0 : "initial",
+            animate: shouldReduceMotion ? void 0 : "animate",
+            exit: shouldReduceMotion ? void 0 : "exit",
+            children: label
+          }
+        )
+      },
+      "tooltip"
+    ) }) })
   ] });
 };
 
@@ -80137,7 +80597,7 @@ const EndlessLoader = ({ container }) => {
         return;
       }
       try {
-        const GLModule = await import('./gl-MYQC24ZU.js');
+        const GLModule = await import('./gl-BE-pAc_o.js');
         if (!isActiveRef.current) {
           return;
         }
@@ -86078,11 +86538,11 @@ const ScrambledText = ({ children, reveal = false }) => {
   );
 };
 
-const root$Y = "_root_1osmz_1";
-const line = "_line_1osmz_9";
-const word$1 = "_word_1osmz_14";
-const link = "_link_1osmz_18";
-const letter = "_letter_1osmz_22";
+const root$Y = "_root_19h89_1";
+const line = "_line_19h89_9";
+const word$1 = "_word_19h89_14";
+const link = "_link_19h89_18";
+const letter = "_letter_19h89_22";
 const styles$11 = {
 	root: root$Y,
 	line: line,
@@ -96036,7 +96496,7 @@ const Lock = () => {
       }
     };
     const asynchronously = async () => {
-      const Flickity = await import('./index-B6Kl363b.js').then(n => n.i).then((m) => m.default);
+      const Flickity = await import('./index-DI2YEpFt.js').then(n => n.i).then((m) => m.default);
       if (!rowsRef.current || !window) return;
       const rows = rowsRef.current.children;
       for (let i = 0, len = rows.length; i < len; i++) {

package/dist/{index-B6Kl363b.js → index-DI2YEpFt.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './index-DqgylTr3.js';
+import { g as getDefaultExportFromCjs } from './index-CBTCt41n.js';
 
 function _mergeNamespaces(n, m) {
   for (var i = 0; i < m.length; i++) {