@tarsis/toolkit 0.5.2 → 0.5.4

package/dist/{index-CEXzqVuq.cjs → index-6NDqwIhT.cjs}

@@ -1,11 +1,10 @@
 'use strict';
 
-const useWindowReady = require('./useWindowReady-ow3ZpIjd.cjs');
-const svg$q = require('./svg-Bi5ULzxB.cjs');
+const useWindowReady = require('./useWindowReady-Il0Ibn7I.cjs');
+const svg$q = require('./svg-BT_esDTZ.cjs');
 const jsxRuntime = require('react/jsx-runtime');
 const React = require('react');
 const ReactDOM = require('react-dom');
-const server = require('./server.cjs');
 
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
@@ -52108,11 +52107,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_fbkx4_1";
+const button$o = "_button_fbkx4_13";
+const p$1 = "_p_fbkx4_26";
+const text$z = "_text_fbkx4_26";
+const effects = "_effects_fbkx4_240";
 const styles$4G = {
 	root: root$4i,
 	button: button$o,
@@ -60007,6 +60006,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__namespace.useCallback(composeRefs(...refs), refs);
+}
+
+/**
+ * Measurement functionality has to be within a separate component
+ * to leverage snapshot lifecycle.
+ */
+class PopChildMeasure extends React__namespace.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 = React.useId();
+    const ref = React.useRef(null);
+    const size = React.useRef({
+        width: 0,
+        height: 0,
+        top: 0,
+        left: 0,
+        right: 0,
+    });
+    const { nonce } = React.useContext(useWindowReady.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.
+     */
+    React.useInsertionEffect(() => {
+        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 (jsxRuntime.jsx(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: React__namespace.cloneElement(children, { ref: composedRef }) }));
+}
+
+const PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, anchorX, root }) => {
+    const presenceChildren = useWindowReady.useConstant(newChildrenMap);
+    const id = React.useId();
+    let isReusedContext = true;
+    let context = React.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 };
+    }
+    React.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__namespace.useEffect(() => {
+        !isPresent &&
+            !presenceChildren.size &&
+            onExitComplete &&
+            onExitComplete();
+    }, [isPresent]);
+    if (mode === "popLayout") {
+        children = (jsxRuntime.jsx(PopChild, { isPresent: isPresent, anchorX: anchorX, root: root, children: children }));
+    }
+    return (jsxRuntime.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.
@@ -60047,6 +60245,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 `.$`
+    React.Children.forEach(children, (child) => {
+        if (React.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 = React.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 = React.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 = React.useRef(presentChildren);
+    /**
+     * Track which exiting children have finished animating out.
+     */
+    const exitComplete = useWindowReady.useConstant(() => new Map());
+    /**
+     * Track which components are currently processing exit to prevent duplicate processing.
+     */
+    const exitingComponents = React.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] = React.useState(presentChildren);
+    const [renderedChildren, setRenderedChildren] = React.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 } = React.useContext(LayoutGroupContext);
+    return (jsxRuntime.jsx(jsxRuntime.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 (jsxRuntime.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 = React.createContext({ strict: false });
 
 function loadFeatures(features) {
@@ -64708,6 +65081,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
+     */
+    !useWindowReady.hasReducedMotionListener.current && useWindowReady.initPrefersReducedMotion();
+    const [shouldReduceMotion] = React.useState(useWindowReady.prefersReducedMotion.current);
+    if (process.env.NODE_ENV !== "production") {
+        useWindowReady.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 = useWindowReady.useConstant(() => ({
         current: null, // Will be hydrated by React
@@ -65132,7 +65546,7 @@ const styles$4x = {
 
 const DDDButton = ({
   children,
-  onClick = server.noop,
+  onClick = svg$q.noop,
   className = ""
 }) => /* @__PURE__ */ jsxRuntime.jsx(
   "button",
@@ -67706,9 +68120,9 @@ const NeonButton = ({ className = "", ...rest }) => {
   return /* @__PURE__ */ jsxRuntime.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_1asaw_2";
+const i$6 = "_i_1asaw_22";
+const text$s = "_text_1asaw_482";
 const styles$47 = {
 	root: root$3P,
 	i: i$6,
@@ -68207,7 +68621,7 @@ const styles$40 = {
 const ProgressButton = ({
   children,
   className = "",
-  onClick = server.noop,
+  onClick = svg$q.noop,
   ...props
 }) => {
   const [isLoading, setIsLoading] = React.useState(true);
@@ -69812,7 +70226,7 @@ const styles$3B = {
 
 const CardTile = ({
   children,
-  onClick = server.noop,
+  onClick = svg$q.noop,
   className = ""
 }) => /* @__PURE__ */ jsxRuntime.jsx(
   "button",
@@ -70245,7 +70659,7 @@ const styles$3r = {
 
 const ProductTile = ({
   children,
-  onClick = server.noop,
+  onClick = svg$q.noop,
   className = ""
 }) => /* @__PURE__ */ jsxRuntime.jsx(
   "button",
@@ -72939,7 +73353,7 @@ const styles$2$ = {
 	root: root$2N
 };
 
-const SplashCursor = ({ onClick = server.noop }) => {
+const SplashCursor = ({ onClick = svg$q.noop }) => {
   const ref = React.useRef(null);
   const onClickRef = useWindowReady.useLiveRef(onClick);
   React.useEffect(() => {
@@ -77699,9 +78113,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 = ({
@@ -77710,9 +78126,35 @@ const Tooltip = ({
   delay = 0,
   className,
   placement = "top",
-  offset: offsetValue = 8
+  offset: offsetValue = 8,
+  animate = true
 }) => {
   const [isOpen, setIsOpen] = React.useState(false);
+  const shouldReduceMotion = useReducedMotion();
+  const variants = shouldReduceMotion ? void 0 : {
+    initial: {
+      scale: animate ? 0.6 : 1,
+      opacity: animate ? 0.8 : 1
+    },
+    animate: {
+      scale: 1,
+      opacity: 1,
+      transition: {
+        type: "spring",
+        stiffness: 150,
+        damping: 20,
+        mass: 1.2
+      }
+    },
+    exit: {
+      scale: animate ? 0.4 : 1,
+      opacity: animate ? 0.8 : 1,
+      transition: {
+        duration: 0.1,
+        ease: "easeIn"
+      }
+    }
+  };
   const { refs, floatingStyles, context } = useFloating({
     open: isOpen,
     onOpenChange: setIsOpen,
@@ -77768,16 +78210,27 @@ const Tooltip = ({
     };
     return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
       React.cloneElement(childElement, mergedProps),
-      isOpen && /* @__PURE__ */ jsxRuntime.jsx(FloatingPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      /* @__PURE__ */ jsxRuntime.jsx(FloatingPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(AnimatePresence, { mode: "wait", children: isOpen && /* @__PURE__ */ jsxRuntime.jsx(
         "div",
         {
           ref: refs.setFloating,
           style: floatingStyles,
           ...getFloatingProps(),
-          className: clsx(styles$2R.tooltip, className),
-          children: label
-        }
-      ) })
+          className: styles$2R.tooltip,
+          children: /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
@@ -77790,16 +78243,27 @@ const Tooltip = ({
         children
       }
     ),
-    isOpen && /* @__PURE__ */ jsxRuntime.jsx(FloatingPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(
+    /* @__PURE__ */ jsxRuntime.jsx(FloatingPortal, { children: /* @__PURE__ */ jsxRuntime.jsx(AnimatePresence, { mode: "wait", children: isOpen && /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
         ref: refs.setFloating,
         style: floatingStyles,
         ...getFloatingProps(),
-        className: clsx(styles$2R.tooltip, className),
-        children: label
-      }
-    ) })
+        className: styles$2R.tooltip,
+        children: /* @__PURE__ */ jsxRuntime.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"
+    ) }) })
   ] });
 };
 
@@ -78085,8 +78549,8 @@ const DockMotionItem = ({
 const originX = { originX: "center" };
 const DockMotion$1 = ({
   children,
-  onMouseEnter = server.noop,
-  onMouseLeave = server.noop,
+  onMouseEnter = svg$q.noop,
+  onMouseLeave = svg$q.noop,
   className = ""
 }) => {
   const mouseX = useWindowReady.useMotionValue(null);
@@ -78539,7 +79003,7 @@ const styles$2H = {
 	isOpen: isOpen
 };
 
-const HamburgerX = ({ isOpen, onClick = server.noop }) => /* @__PURE__ */ jsxRuntime.jsx(
+const HamburgerX = ({ isOpen, onClick = svg$q.noop }) => /* @__PURE__ */ jsxRuntime.jsx(
   "button",
   {
     type: "button",
@@ -80157,7 +80621,7 @@ const EndlessLoader = ({ container }) => {
         return;
       }
       try {
-        const GLModule = await Promise.resolve().then(() => require('./gl-DkwP1ATh.cjs'));
+        const GLModule = await Promise.resolve().then(() => require('./gl-BMhxJtUR.cjs'));
         if (!isActiveRef.current) {
           return;
         }
@@ -80809,7 +81273,7 @@ const styles$1Z = {
 
 const SpinningClickAnimation = ({
   children = null,
-  onClick = server.noop,
+  onClick = svg$q.noop,
   className = ""
 }) => {
   const ref = React.useRef(null);
@@ -86098,11 +86562,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_jg827_1";
+const line = "_line_jg827_9";
+const word$1 = "_word_jg827_14";
+const link = "_link_jg827_18";
+const letter = "_letter_jg827_22";
 const styles$11 = {
 	root: root$Y,
 	line: line,
@@ -96056,7 +96520,7 @@ const Lock = () => {
       }
     };
     const asynchronously = async () => {
-      const Flickity = await Promise.resolve().then(() => require('./index-CmzNwlcp.cjs')).then(n => n.index).then((m) => m.default);
+      const Flickity = await Promise.resolve().then(() => require('./index-DoJenARH.cjs')).then(n => n.index).then((m) => m.default);
       if (!rowsRef.current || !window) return;
       const rows = rowsRef.current.children;
       for (let i = 0, len = rows.length; i < len; i++) {