aliveicon 1.0.26 → 1.0.27

package/dist/esm/index.js

@@ -2960,7 +2960,7 @@ const getDefaultConfig = () => {
 };
 const twMerge = /*#__PURE__*/createTailwindMerge(getDefaultConfig);
 
-function cn$11(...inputs) {
+function cn$1e(...inputs) {
     return twMerge(clsx(inputs));
 }
 const squareVariants$1 = {
@@ -2975,7 +2975,7 @@ const squareVariants$1 = {
         transition: { duration: 0.6, ease: 'easeInOut' },
     },
 };
-const pathVariants$C = {
+const pathVariants$I = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -3028,15 +3028,15 @@ function SquareActivity({ size = 28, className, style, autoAnimateOnLoad = false
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$11('rounded-md', className), style: {
+    return (jsx("div", { className: cn$1e('rounded-md', className), style: {
             width: size,
             height: size,
             display: 'inline-block',
             ...style,
-        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "18", height: "18", x: "3", y: "3", rx: "2", variants: squareVariants$1, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M17 12h-2l-2 5-2-10-2 5H7", variants: pathVariants$C, animate: controls, initial: "normal", style: { strokeDasharray: 1 } })] }) }));
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "18", height: "18", x: "3", y: "3", rx: "2", variants: squareVariants$1, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M17 12h-2l-2 5-2-10-2 5H7", variants: pathVariants$I, animate: controls, initial: "normal", style: { strokeDasharray: 1 } })] }) }));
 }
 
-function cn$10(...inputs) {
+function cn$1d(...inputs) {
     return twMerge(clsx(inputs));
 }
 const bounceVariant$1 = {
@@ -3129,14 +3129,14 @@ function AArrowDown({ size = 28, className, style, autoAnimateOnLoad = false, ho
         "M18 7v9",
         "m14 12 4 4 4-4",
     ];
-    return (jsx("div", { className: cn$10('inline-block', className), style: {
+    return (jsx("div", { className: cn$1d('inline-block', className), style: {
             width: size,
             height: size,
             ...style,
         }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx(motion.svg, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", variants: isBounce ? bounceVariant$1 : undefined, animate: isBounce ? controls : undefined, initial: isBounce ? 'normal' : undefined, children: paths.map((d, i) => (jsx(motion.path, { d: d, variants: isBounce ? bouncePathVariants$1 : lineVariants$4, initial: isBounce ? 'hidden' : 'normal', animate: isBounce ? 'visible' : controls, custom: i }, i))) }) }));
 }
 
-function cn$$(...inputs) {
+function cn$1c(...inputs) {
     return twMerge(clsx(inputs));
 }
 const bounceVariant = {
@@ -3229,14 +3229,14 @@ function AArrowUp({ size = 28, className, style, autoAnimateOnLoad = false, hove
         "M18 16V7", // arrow line, now reversed (was 7→16, now 16→7)
         "m22 12-4-4-4 4", // arrow head pointing upward
     ];
-    return (jsx("div", { className: cn$$('inline-block', className), style: {
+    return (jsx("div", { className: cn$1c('inline-block', className), style: {
             width: size,
             height: size,
             ...style,
         }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx(motion.svg, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", variants: isBounce ? bounceVariant : undefined, animate: isBounce ? controls : undefined, initial: isBounce ? 'normal' : undefined, children: paths.map((d, i) => (jsx(motion.path, { d: d, variants: isBounce ? bouncePathVariants : lineVariants$3, initial: isBounce ? 'hidden' : 'normal', animate: isBounce ? 'visible' : controls, custom: i }, i))) }) }));
 }
 
-function cn$_(...inputs) {
+function cn$1b(...inputs) {
     return twMerge(clsx(inputs));
 }
 const circleVariants$1 = {
@@ -3255,7 +3255,7 @@ const circleVariants$1 = {
         },
     },
 };
-const pathVariants$B = {
+const pathVariants$H = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -3307,18 +3307,18 @@ function AccessibilityActivity({ size = 28, className, style, autoAnimateOnLoad
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$_('rounded-md', className), style: {
+    return (jsx("div", { className: cn$1b('rounded-md', className), style: {
             width: size,
             height: size,
             display: 'inline-block',
             ...style,
-        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.circle, { cx: "16", cy: "4", r: "1", variants: circleVariants$1, animate: controls, initial: "normal" }), jsx(motion.path, { d: "m18 19 1-7-6 1", variants: pathVariants$B, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }), jsx(motion.path, { d: "m5 8 3-3 5.5 3-2.36 3.5", variants: pathVariants$B, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }), jsx(motion.path, { d: "M4.24 14.5a5 5 0 0 0 6.88 6", variants: pathVariants$B, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }), jsx(motion.path, { d: "M13.76 17.5a5 5 0 0 0-6.88-6", variants: pathVariants$B, animate: controls, initial: "normal", style: { strokeDasharray: 1 } })] }) }));
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.circle, { cx: "16", cy: "4", r: "1", variants: circleVariants$1, animate: controls, initial: "normal" }), jsx(motion.path, { d: "m18 19 1-7-6 1", variants: pathVariants$H, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }), jsx(motion.path, { d: "m5 8 3-3 5.5 3-2.36 3.5", variants: pathVariants$H, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }), jsx(motion.path, { d: "M4.24 14.5a5 5 0 0 0 6.88 6", variants: pathVariants$H, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }), jsx(motion.path, { d: "M13.76 17.5a5 5 0 0 0-6.88-6", variants: pathVariants$H, animate: controls, initial: "normal", style: { strokeDasharray: 1 } })] }) }));
 }
 
-function cn$Z(...inputs) {
+function cn$1a(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$A = {
+const pathVariants$G = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -3371,15 +3371,15 @@ function Activity({ size = 28, className, style, autoAnimateOnLoad = false, hove
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$Z('rounded-md', className), style: {
+    return (jsx("div", { className: cn$1a('rounded-md', className), style: {
             width: size,
             height: size,
             display: 'inline-block',
             ...style,
-        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.path, { d: "M17 12h-2l-2 5-2-10-2 5H7", variants: pathVariants$A, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }) }) }));
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.path, { d: "M17 12h-2l-2 5-2-10-2 5H7", variants: pathVariants$G, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }) }) }));
 }
 
-function cn$Y(...inputs) {
+function cn$19(...inputs) {
     return twMerge(clsx(inputs));
 }
 const windVariants = {
@@ -3430,11 +3430,11 @@ const AirVent = forwardRef(({ onMouseEnter, onMouseLeave, className, size = 28,
             onMouseLeave?.(e);
         }
     }, [controls, onMouseLeave]);
-    return (jsx("div", { className: cn$Y(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx("path", { d: "M6 12H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2" }), jsx(motion.path, { d: "M6 8h12", variants: windVariants, initial: "normal", animate: controls, custom: 0.1 }), jsx(motion.path, { d: "M18.3 17.7a2.5 2.5 0 0 1-3.16 3.83 2.53 2.53 0 0 1-1.14-2V12", variants: windVariants, initial: "normal", animate: controls, custom: 0 }), jsx(motion.path, { d: "M6.6 15.6A2 2 0 1 0 10 17v-5", variants: windVariants, initial: "normal", animate: controls, custom: 0.2 })] }) }));
+    return (jsx("div", { className: cn$19(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx("path", { d: "M6 12H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2" }), jsx(motion.path, { d: "M6 8h12", variants: windVariants, initial: "normal", animate: controls, custom: 0.1 }), jsx(motion.path, { d: "M18.3 17.7a2.5 2.5 0 0 1-3.16 3.83 2.53 2.53 0 0 1-1.14-2V12", variants: windVariants, initial: "normal", animate: controls, custom: 0 }), jsx(motion.path, { d: "M6.6 15.6A2 2 0 1 0 10 17v-5", variants: windVariants, initial: "normal", animate: controls, custom: 0.2 })] }) }));
 });
 AirVent.displayName = 'AirVent';
 
-function cn$X(...inputs) {
+function cn$18(...inputs) {
     return twMerge(clsx(inputs));
 }
 const screenVariants = {
@@ -3502,7 +3502,7 @@ function Airplay({ size = 28, className, style, autoAnimateOnLoad = false, hover
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$X(className), style: {
+    return (jsx("div", { className: cn$18(className), style: {
             width: size,
             height: size,
             display: 'inline-block',
@@ -3510,7 +3510,7 @@ function Airplay({ size = 28, className, style, autoAnimateOnLoad = false, hover
         }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1", variants: screenVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M12 15l5 6H7z", variants: triangleVariants, initial: "normal", animate: controls })] }) }));
 }
 
-function cn$W(...inputs) {
+function cn$17(...inputs) {
     return twMerge(clsx(inputs));
 }
 const squareVariants = {
@@ -3525,7 +3525,7 @@ const squareVariants = {
         transition: { duration: 0.6, ease: 'easeInOut' },
     },
 };
-const pathVariants$z = {
+const pathVariants$F = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -3577,18 +3577,18 @@ const Album = ({ size = 28, className, style, autoAnimateOnLoad = false, hoverab
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$W('rounded-md', className), style: {
+    return (jsx("div", { className: cn$17('rounded-md', className), style: {
             width: size,
             height: size,
             display: 'inline-block',
             ...style,
-        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2", variants: squareVariants, animate: controls, initial: "normal" }), jsx(motion.polyline, { points: "11 3 11 11 14 8 17 11 17 3", variants: pathVariants$z, animate: controls, initial: "normal", style: { strokeDasharray: 1 } })] }) }));
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2", variants: squareVariants, animate: controls, initial: "normal" }), jsx(motion.polyline, { points: "11 3 11 11 14 8 17 11 17 3", variants: pathVariants$F, animate: controls, initial: "normal", style: { strokeDasharray: 1 } })] }) }));
 };
 
-function cn$V(...inputs) {
+function cn$16(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$y = {
+const pathVariants$E = {
     normal: {
         y: 0,
         x: 0,
@@ -3677,14 +3677,14 @@ const AlarmClock = forwardRef(({ className, size = 28, autoAnimateOnLoad = false
                 clearTimeout(timeoutRef.current);
         };
     }, [autoAnimateOnLoad, startOnce]);
-    return (jsx("div", { className: cn$V(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: { overflow: 'visible' }, children: [jsx(motion.path, { variants: pathVariants$y, initial: "normal", animate: controls, d: "M18 20.5L19.5 22" }), jsx(motion.path, { variants: pathVariants$y, initial: "normal", animate: controls, d: "M6 20.5L4.5 22" }), jsx(motion.path, { variants: pathVariants$y, initial: "normal", animate: controls, d: "M21 13C21 17.968 16.968 22 12 22C7.032 22 3 17.968 3 13C3 8.032 7.032 4 12 4C16.968 4 21 8.032 21 13Z" }), jsx(motion.path, { variants: pathVariants$y, initial: "normal", animate: controls, d: "M15.339 15.862L12.549 14.197C12.063 13.909 11.667 13.216 11.667 12.649V8.95898" }), jsx(motion.path, { variants: secondaryPathVariants$3, initial: "normal", animate: controls, d: "M18 2L21.747 5.31064" }), jsx(motion.path, { variants: secondaryPathVariants$3, initial: "normal", animate: controls, d: "M6 2L2.25304 5.31064" })] }) }));
+    return (jsx("div", { className: cn$16(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: { overflow: 'visible' }, children: [jsx(motion.path, { variants: pathVariants$E, initial: "normal", animate: controls, d: "M18 20.5L19.5 22" }), jsx(motion.path, { variants: pathVariants$E, initial: "normal", animate: controls, d: "M6 20.5L4.5 22" }), jsx(motion.path, { variants: pathVariants$E, initial: "normal", animate: controls, d: "M21 13C21 17.968 16.968 22 12 22C7.032 22 3 17.968 3 13C3 8.032 7.032 4 12 4C16.968 4 21 8.032 21 13Z" }), jsx(motion.path, { variants: pathVariants$E, initial: "normal", animate: controls, d: "M15.339 15.862L12.549 14.197C12.063 13.909 11.667 13.216 11.667 12.649V8.95898" }), jsx(motion.path, { variants: secondaryPathVariants$3, initial: "normal", animate: controls, d: "M18 2L21.747 5.31064" }), jsx(motion.path, { variants: secondaryPathVariants$3, initial: "normal", animate: controls, d: "M6 2L2.25304 5.31064" })] }) }));
 });
 AlarmClock.displayName = 'AlarmClock';
 
-function cn$U(...inputs) {
+function cn$15(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$x = {
+const pathVariants$D = {
     normal: {
         y: 0,
         x: 0,
@@ -3771,14 +3771,14 @@ const AlarmClockCheck = forwardRef(({ className, size = 28, autoAnimateOnLoad =
                 clearTimeout(timeoutRef.current);
         };
     }, [autoAnimateOnLoad, startTimedAnimation]);
-    return (jsx("div", { className: cn$U(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: { overflow: 'visible' }, children: [jsx(motion.circle, { variants: pathVariants$x, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsx(motion.path, { variants: secondaryPathVariants$2, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsx(motion.path, { variants: secondaryPathVariants$2, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsx(motion.path, { variants: pathVariants$x, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsx(motion.path, { variants: pathVariants$x, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsx(motion.path, { variants: pathVariants$x, initial: "normal", animate: controls, d: "m9 13 2 2 4-4" })] }) }));
+    return (jsx("div", { className: cn$15(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: { overflow: 'visible' }, children: [jsx(motion.circle, { variants: pathVariants$D, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsx(motion.path, { variants: secondaryPathVariants$2, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsx(motion.path, { variants: secondaryPathVariants$2, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsx(motion.path, { variants: pathVariants$D, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsx(motion.path, { variants: pathVariants$D, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsx(motion.path, { variants: pathVariants$D, initial: "normal", animate: controls, d: "m9 13 2 2 4-4" })] }) }));
 });
 AlarmClockCheck.displayName = 'AlarmClockCheck';
 
-function cn$T(...inputs) {
+function cn$14(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$w = {
+const pathVariants$C = {
     normal: {
         y: 0,
         x: 0,
@@ -3865,14 +3865,14 @@ const AlarmClockMinus = forwardRef(({ className, size = 28, autoAnimateOnLoad =
                 clearTimeout(timeoutRef.current);
         };
     }, [autoAnimateOnLoad, startTimedAnimation]);
-    return (jsx("div", { className: cn$T(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: { overflow: 'visible' }, children: [jsx(motion.circle, { variants: pathVariants$w, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsx(motion.path, { variants: secondaryPathVariants$1, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsx(motion.path, { variants: secondaryPathVariants$1, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsx(motion.path, { variants: pathVariants$w, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsx(motion.path, { variants: pathVariants$w, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsx(motion.line, { variants: pathVariants$w, initial: "normal", animate: controls, x1: "9", y1: "13", x2: "15", y2: "13" })] }) }));
+    return (jsx("div", { className: cn$14(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: { overflow: 'visible' }, children: [jsx(motion.circle, { variants: pathVariants$C, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsx(motion.path, { variants: secondaryPathVariants$1, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsx(motion.path, { variants: secondaryPathVariants$1, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsx(motion.path, { variants: pathVariants$C, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsx(motion.path, { variants: pathVariants$C, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsx(motion.line, { variants: pathVariants$C, initial: "normal", animate: controls, x1: "9", y1: "13", x2: "15", y2: "13" })] }) }));
 });
 AlarmClockMinus.displayName = 'AlarmClockMinus';
 
-function cn$S(...inputs) {
+function cn$13(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$v = {
+const pathVariants$B = {
     normal: {
         y: 0,
         x: 0,
@@ -3959,11 +3959,11 @@ const AlarmClockPlus = forwardRef(({ className, size = 28, autoAnimateOnLoad = f
                 clearTimeout(timeoutRef.current);
         };
     }, [autoAnimateOnLoad, startTimedAnimation]);
-    return (jsx("div", { className: cn$S(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: { overflow: 'visible' }, children: [jsx(motion.circle, { variants: pathVariants$v, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsx(motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsx(motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsx(motion.path, { variants: pathVariants$v, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsx(motion.path, { variants: pathVariants$v, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsx(motion.line, { variants: pathVariants$v, initial: "normal", animate: controls, x1: "9", y1: "13", x2: "15", y2: "13" }), jsx(motion.line, { variants: pathVariants$v, initial: "normal", animate: controls, y1: "10", x1: "12", y2: "16", x2: "12" })] }) }));
+    return (jsx("div", { className: cn$13(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", style: { overflow: 'visible' }, children: [jsx(motion.circle, { variants: pathVariants$B, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsx(motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsx(motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsx(motion.path, { variants: pathVariants$B, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsx(motion.path, { variants: pathVariants$B, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsx(motion.line, { variants: pathVariants$B, initial: "normal", animate: controls, x1: "9", y1: "13", x2: "15", y2: "13" }), jsx(motion.line, { variants: pathVariants$B, initial: "normal", animate: controls, y1: "10", x1: "12", y2: "16", x2: "12" })] }) }));
 });
 AlarmClockPlus.displayName = 'AlarmClockPlus';
 
-function cn$R(...inputs) {
+function cn$12(...inputs) {
     return twMerge(clsx(inputs));
 }
 const pathMotion = {
@@ -4021,14 +4021,14 @@ const AlignCenter = React.forwardRef(({ size = 28, className, style, onMouseEnte
         }
         onClick?.(e);
     }, [triggerAnimation, onClick, animateOnClick]);
-    return (jsx("div", { className: cn$R("inline-block", className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M17 12H7", variants: pathMotion, initial: "normal", animate: controls }), jsx(motion.path, { d: "M19 18H5", animate: controls, initial: "normal" }), jsx(motion.path, { d: "M21 6H3", animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$12("inline-block", className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M17 12H7", variants: pathMotion, initial: "normal", animate: controls }), jsx(motion.path, { d: "M19 18H5", animate: controls, initial: "normal" }), jsx(motion.path, { d: "M21 6H3", animate: controls, initial: "normal" })] }) }));
 });
 AlignCenter.displayName = "AlignCenter";
 
-function cn$Q(...inputs) {
+function cn$11(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$u = {
+const pathVariants$A = {
     normal: {
         pathLength: 1,
         pathOffset: 0,
@@ -4086,14 +4086,14 @@ const AlignCenterHorizontal = forwardRef(({ size = 28, className, style, autoAni
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$Q('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M2 12h20", variants: pathVariants$u, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4", variants: pathVariants$u, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4", variants: pathVariants$u, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1", variants: pathVariants$u, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1", variants: pathVariants$u, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$11('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M2 12h20", variants: pathVariants$A, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4", variants: pathVariants$A, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4", variants: pathVariants$A, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1", variants: pathVariants$A, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1", variants: pathVariants$A, animate: controls, initial: "normal" })] }) }));
 });
 AlignCenterHorizontal.displayName = 'AlignCenterHorizontal';
 
-function cn$P(...inputs) {
+function cn$10(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$t = {
+const pathVariants$z = {
     normal: {
         pathLength: 1,
         pathOffset: 0,
@@ -4149,14 +4149,14 @@ const AlignCenterVertical = forwardRef(({ size = 28, className, style, autoAnima
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$P('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M12 2v20", variants: pathVariants$t, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M8 10H4a2 2 0 0 1-2-2V6c0-1.1.9-2 2-2h4", variants: pathVariants$t, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M16 10h4a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-4", variants: pathVariants$t, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M8 20H7a2 2 0 0 1-2-2v-2c0-1.1.9-2 2-2h1", variants: pathVariants$t, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M16 14h1a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2h-1", variants: pathVariants$t, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$10('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M12 2v20", variants: pathVariants$z, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M8 10H4a2 2 0 0 1-2-2V6c0-1.1.9-2 2-2h4", variants: pathVariants$z, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M16 10h4a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-4", variants: pathVariants$z, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M8 20H7a2 2 0 0 1-2-2v-2c0-1.1.9-2 2-2h1", variants: pathVariants$z, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M16 14h1a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2h-1", variants: pathVariants$z, animate: controls, initial: "normal" })] }) }));
 });
 AlignCenterVertical.displayName = 'AlignCenterVertical';
 
-function cn$O(...inputs) {
+function cn$$(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$s = {
+const pathVariants$y = {
     normal: {
         pathLength: 1,
         pathOffset: 0,
@@ -4212,14 +4212,14 @@ const AlignEndHorizontal = forwardRef(({ size = 28, className, style, autoAnimat
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$O('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "6", height: "16", x: "4", y: "2", rx: "2", variants: pathVariants$s, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "6", height: "9", x: "14", y: "9", rx: "2", variants: pathVariants$s, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M22 22H2", variants: pathVariants$s, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$$('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "6", height: "16", x: "4", y: "2", rx: "2", variants: pathVariants$y, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "6", height: "9", x: "14", y: "9", rx: "2", variants: pathVariants$y, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M22 22H2", variants: pathVariants$y, animate: controls, initial: "normal" })] }) }));
 });
 AlignEndHorizontal.displayName = 'AlignEndHorizontal';
 
-function cn$N(...inputs) {
+function cn$_(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$r = {
+const pathVariants$x = {
     normal: {
         pathLength: 1,
         pathOffset: 0,
@@ -4275,14 +4275,14 @@ const AlignEndVertical = forwardRef(({ size = 28, className, style, autoAnimateO
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$N('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "16", height: "6", x: "2", y: "4", rx: "2", variants: pathVariants$r, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "9", height: "6", x: "9", y: "14", rx: "2", variants: pathVariants$r, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M22 22V2", variants: pathVariants$r, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$_('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "16", height: "6", x: "2", y: "4", rx: "2", variants: pathVariants$x, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "9", height: "6", x: "9", y: "14", rx: "2", variants: pathVariants$x, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M22 22V2", variants: pathVariants$x, animate: controls, initial: "normal" })] }) }));
 });
 AlignEndVertical.displayName = 'AlignEndVertical';
 
-function cn$M(...inputs) {
+function cn$Z(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$q = {
+const pathVariants$w = {
     normal: {
         pathLength: 1,
         pathOffset: 0,
@@ -4338,14 +4338,14 @@ const AlignHorizontalDistributeCenter = forwardRef(({ size = 28, className, styl
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$M('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "6", height: "14", x: "4", y: "5", rx: "2", variants: pathVariants$q, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "6", height: "10", x: "14", y: "7", rx: "2", variants: pathVariants$q, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M17 22v-5", variants: pathVariants$q, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M17 7V2", variants: pathVariants$q, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M7 22v-3", variants: pathVariants$q, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M7 5V2", variants: pathVariants$q, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$Z('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { width: "6", height: "14", x: "4", y: "5", rx: "2", variants: pathVariants$w, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "6", height: "10", x: "14", y: "7", rx: "2", variants: pathVariants$w, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M17 22v-5", variants: pathVariants$w, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M17 7V2", variants: pathVariants$w, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M7 22v-3", variants: pathVariants$w, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M7 5V2", variants: pathVariants$w, animate: controls, initial: "normal" })] }) }));
 });
 AlignHorizontalDistributeCenter.displayName = 'AlignHorizontalDistributeCenter';
 
-function cn$L(...inputs) {
+function cn$Y(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$p = {
+const pathVariants$v = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -4401,14 +4401,14 @@ const AlignHorizontalDistributeEnd = forwardRef(({ size = 28, className, style,
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$L('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "4", y: "5", rx: "2", variants: pathVariants$p, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "14", y: "7", rx: "2", variants: pathVariants$p, initial: "normal", animate: controls }), jsx(motion.path, { d: "M10 2v20", variants: pathVariants$p, initial: "normal", animate: controls }), jsx(motion.path, { d: "M20 2v20", variants: pathVariants$p, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$Y('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "4", y: "5", rx: "2", variants: pathVariants$v, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "14", y: "7", rx: "2", variants: pathVariants$v, initial: "normal", animate: controls }), jsx(motion.path, { d: "M10 2v20", variants: pathVariants$v, initial: "normal", animate: controls }), jsx(motion.path, { d: "M20 2v20", variants: pathVariants$v, initial: "normal", animate: controls })] }) }));
 });
 AlignHorizontalDistributeEnd.displayName = 'AlignHorizontalDistributeEnd';
 
-function cn$K(...inputs) {
+function cn$X(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$o = {
+const pathVariants$u = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -4464,14 +4464,14 @@ const AlignHorizontalDistributeStart = forwardRef(({ size = 28, className, style
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$K('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "4", y: "5", rx: "2", variants: pathVariants$o, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "14", y: "7", rx: "2", variants: pathVariants$o, initial: "normal", animate: controls }), jsx(motion.path, { d: "M4 2v20", variants: pathVariants$o, initial: "normal", animate: controls }), jsx(motion.path, { d: "M14 2v20", variants: pathVariants$o, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$X('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "4", y: "5", rx: "2", variants: pathVariants$u, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "14", y: "7", rx: "2", variants: pathVariants$u, initial: "normal", animate: controls }), jsx(motion.path, { d: "M4 2v20", variants: pathVariants$u, initial: "normal", animate: controls }), jsx(motion.path, { d: "M14 2v20", variants: pathVariants$u, initial: "normal", animate: controls })] }) }));
 });
 AlignHorizontalDistributeStart.displayName = 'AlignHorizontalDistributeStart';
 
-function cn$J(...inputs) {
+function cn$W(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$n = {
+const pathVariants$t = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -4527,14 +4527,14 @@ const AlignHorizontalJustifyCenter = forwardRef(({ size = 28, className, style,
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$J('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "2", y: "5", rx: "2", variants: pathVariants$n, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "16", y: "7", rx: "2", variants: pathVariants$n, initial: "normal", animate: controls }), jsx(motion.path, { d: "M12 2v20", variants: pathVariants$n, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$W('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "2", y: "5", rx: "2", variants: pathVariants$t, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "16", y: "7", rx: "2", variants: pathVariants$t, initial: "normal", animate: controls }), jsx(motion.path, { d: "M12 2v20", variants: pathVariants$t, initial: "normal", animate: controls })] }) }));
 });
 AlignHorizontalJustifyCenter.displayName = 'AlignHorizontalJustifyCenter';
 
-function cn$I(...inputs) {
+function cn$V(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$m = {
+const pathVariants$s = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -4590,14 +4590,14 @@ const AlignHorizontalJustifyEnd = forwardRef(({ size = 28, className, style, aut
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$I('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "2", y: "5", rx: "2", variants: pathVariants$m, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "12", y: "7", rx: "2", variants: pathVariants$m, initial: "normal", animate: controls }), jsx(motion.path, { d: "M22 2v20", variants: pathVariants$m, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$V('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "2", y: "5", rx: "2", variants: pathVariants$s, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "12", y: "7", rx: "2", variants: pathVariants$s, initial: "normal", animate: controls }), jsx(motion.path, { d: "M22 2v20", variants: pathVariants$s, initial: "normal", animate: controls })] }) }));
 });
 AlignHorizontalJustifyEnd.displayName = 'AlignHorizontalJustifyEnd';
 
-function cn$H(...inputs) {
+function cn$U(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$l = {
+const pathVariants$r = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -4653,14 +4653,14 @@ const AlignHorizontalJustifyStart = forwardRef(({ size = 28, className, style, a
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$H('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "6", y: "5", rx: "2", variants: pathVariants$l, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "16", y: "7", rx: "2", variants: pathVariants$l, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 2v20", variants: pathVariants$l, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$U('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "6", y: "5", rx: "2", variants: pathVariants$r, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "16", y: "7", rx: "2", variants: pathVariants$r, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 2v20", variants: pathVariants$r, initial: "normal", animate: controls })] }) }));
 });
 AlignHorizontalJustifyStart.displayName = 'AlignHorizontalJustifyStart';
 
-function cn$G(...inputs) {
+function cn$T(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$k = {
+const pathVariants$q = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -4716,14 +4716,14 @@ const AlignHorizontalSpaceAround = forwardRef(({ size = 28, className, style, au
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$G('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "10", x: "9", y: "7", rx: "2", variants: pathVariants$k, initial: "normal", animate: controls }), jsx(motion.path, { d: "M4 22V2", variants: pathVariants$k, initial: "normal", animate: controls }), jsx(motion.path, { d: "M20 22V2", variants: pathVariants$k, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$T('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "10", x: "9", y: "7", rx: "2", variants: pathVariants$q, initial: "normal", animate: controls }), jsx(motion.path, { d: "M4 22V2", variants: pathVariants$q, initial: "normal", animate: controls }), jsx(motion.path, { d: "M20 22V2", variants: pathVariants$q, initial: "normal", animate: controls })] }) }));
 });
 AlignHorizontalSpaceAround.displayName = 'AlignHorizontalSpaceAround';
 
-function cn$F(...inputs) {
+function cn$S(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$j = {
+const pathVariants$p = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -4779,14 +4779,14 @@ const AlignHorizontalSpaceBetween = forwardRef(({ size = 28, className, style, a
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$F('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "3", y: "5", rx: "2", variants: pathVariants$j, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "15", y: "7", rx: "2", variants: pathVariants$j, initial: "normal", animate: controls }), jsx(motion.path, { d: "M3 2v20", variants: pathVariants$j, initial: "normal", animate: controls }), jsx(motion.path, { d: "M21 2v20", variants: pathVariants$j, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$S('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "6", height: "14", x: "3", y: "5", rx: "2", variants: pathVariants$p, initial: "normal", animate: controls }), jsx(motion.rect, { width: "6", height: "10", x: "15", y: "7", rx: "2", variants: pathVariants$p, initial: "normal", animate: controls }), jsx(motion.path, { d: "M3 2v20", variants: pathVariants$p, initial: "normal", animate: controls }), jsx(motion.path, { d: "M21 2v20", variants: pathVariants$p, initial: "normal", animate: controls })] }) }));
 });
 AlignHorizontalSpaceBetween.displayName = 'AlignHorizontalSpaceBetween';
 
-function cn$E(...inputs) {
+function cn$R(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$i = {
+const pathVariants$o = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -4842,14 +4842,14 @@ const AlignJustify = forwardRef(({ size = 28, className, style, autoAnimateOnLoa
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$E('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M3 12h18", variants: pathVariants$i, initial: "normal", animate: controls }), jsx(motion.path, { d: "M3 18h18", variants: pathVariants$i, initial: "normal", animate: controls }), jsx(motion.path, { d: "M3 6h18", variants: pathVariants$i, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$R('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M3 12h18", variants: pathVariants$o, initial: "normal", animate: controls }), jsx(motion.path, { d: "M3 18h18", variants: pathVariants$o, initial: "normal", animate: controls }), jsx(motion.path, { d: "M3 6h18", variants: pathVariants$o, initial: "normal", animate: controls })] }) }));
 });
 AlignJustify.displayName = 'AlignJustify';
 
-function cn$D(...inputs) {
+function cn$Q(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$h = {
+const pathVariants$n = {
     normal: (i) => ({
         pathLength: 1,
         pathOffset: 0,
@@ -4875,8 +4875,8 @@ const AlignLeft = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
     const loopRef = useRef(loopOnHover);
     const isControlledRef = useRef(false);
     const triggerAnimation = useCallback(async () => {
-        await controls.start((i) => pathVariants$h.animate(i));
-        await controls.start((i) => pathVariants$h.normal(i));
+        await controls.start((i) => pathVariants$n.animate(i));
+        await controls.start((i) => pathVariants$n.normal(i));
         if (loopRef.current)
             triggerAnimation();
     }, [controls]);
@@ -4890,8 +4890,8 @@ const AlignLeft = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
     useImperativeHandle(ref, () => {
         isControlledRef.current = true;
         return {
-            startAnimation: () => controls.start((i) => pathVariants$h.animate(i)),
-            stopAnimation: () => controls.start((i) => pathVariants$h.normal(i)),
+            startAnimation: () => controls.start((i) => pathVariants$n.animate(i)),
+            stopAnimation: () => controls.start((i) => pathVariants$n.normal(i)),
         };
     }, [controls]);
     const handleMouseEnter = (e) => {
@@ -4901,7 +4901,7 @@ const AlignLeft = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
     };
     const handleMouseLeave = (e) => {
         if (!isControlledRef.current && hoverable)
-            controls.start((i) => pathVariants$h.normal(i));
+            controls.start((i) => pathVariants$n.normal(i));
         onMouseLeave?.(e);
     };
     const handleClick = (e) => {
@@ -4909,14 +4909,14 @@ const AlignLeft = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$D('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M21 6H3", variants: pathVariants$h, custom: 0, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M15 12H3", variants: pathVariants$h, custom: 1, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M17 18H3", variants: pathVariants$h, custom: 2, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$Q('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M21 6H3", variants: pathVariants$n, custom: 0, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M15 12H3", variants: pathVariants$n, custom: 1, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M17 18H3", variants: pathVariants$n, custom: 2, animate: controls, initial: "normal" })] }) }));
 });
 AlignLeft.displayName = 'AlignLeft';
 
-function cn$C(...inputs) {
+function cn$P(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$g = {
+const pathVariants$m = {
     normal: (i) => ({
         pathLength: 1,
         pathOffset: 0,
@@ -4976,14 +4976,14 @@ const AlignRight = forwardRef(({ size = 28, className, style, autoAnimateOnLoad
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$C('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M3 6H21", variants: pathVariants$g, custom: 0, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M9 12H21", variants: pathVariants$g, custom: 1, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M7 18H21", variants: pathVariants$g, custom: 2, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$P('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M3 6H21", variants: pathVariants$m, custom: 0, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M9 12H21", variants: pathVariants$m, custom: 1, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M7 18H21", variants: pathVariants$m, custom: 2, animate: controls, initial: "normal" })] }) }));
 });
 AlignRight.displayName = 'AlignRight';
 
-function cn$B(...inputs) {
+function cn$O(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$f = {
+const pathVariants$l = {
     normal: (i) => ({
         pathLength: 1,
         opacity: 1,
@@ -5027,8 +5027,8 @@ const AlignStartHorizontal = forwardRef(({ size = 28, className, style, autoAnim
     const loopRef = useRef(loopOnHover);
     const isControlledRef = useRef(false);
     const triggerAnimation = useCallback(async () => {
-        await controls.start((i) => i < 1 ? pathVariants$f.animate(i) : rectVariants$5.animate(i - 1));
-        await controls.start((i) => i < 1 ? pathVariants$f.normal(i) : rectVariants$5.normal(i - 1));
+        await controls.start((i) => i < 1 ? pathVariants$l.animate(i) : rectVariants$5.animate(i - 1));
+        await controls.start((i) => i < 1 ? pathVariants$l.normal(i) : rectVariants$5.normal(i - 1));
         if (loopRef.current)
             triggerAnimation();
     }, [controls]);
@@ -5042,8 +5042,8 @@ const AlignStartHorizontal = forwardRef(({ size = 28, className, style, autoAnim
     useImperativeHandle(ref, () => {
         isControlledRef.current = true;
         return {
-            startAnimation: () => controls.start((i) => i < 1 ? pathVariants$f.animate(i) : rectVariants$5.animate(i - 1)),
-            stopAnimation: () => controls.start((i) => i < 1 ? pathVariants$f.normal(i) : rectVariants$5.normal(i - 1)),
+            startAnimation: () => controls.start((i) => i < 1 ? pathVariants$l.animate(i) : rectVariants$5.animate(i - 1)),
+            stopAnimation: () => controls.start((i) => i < 1 ? pathVariants$l.normal(i) : rectVariants$5.normal(i - 1)),
         };
     }, [controls]);
     const handleMouseEnter = (e) => {
@@ -5053,7 +5053,7 @@ const AlignStartHorizontal = forwardRef(({ size = 28, className, style, autoAnim
     };
     const handleMouseLeave = (e) => {
         if (!isControlledRef.current && hoverable)
-            controls.start((i) => i < 1 ? pathVariants$f.normal(i) : rectVariants$5.normal(i - 1));
+            controls.start((i) => i < 1 ? pathVariants$l.normal(i) : rectVariants$5.normal(i - 1));
         onMouseLeave?.(e);
     };
     const handleClick = (e) => {
@@ -5061,14 +5061,14 @@ const AlignStartHorizontal = forwardRef(({ size = 28, className, style, autoAnim
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$B('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M22 2H2", variants: pathVariants$f, custom: 0, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "6", height: "16", x: "4", y: "6", rx: "2", variants: rectVariants$5, custom: 0, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "6", height: "9", x: "14", y: "6", rx: "2", variants: rectVariants$5, custom: 1, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$O('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M22 2H2", variants: pathVariants$l, custom: 0, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "6", height: "16", x: "4", y: "6", rx: "2", variants: rectVariants$5, custom: 0, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "6", height: "9", x: "14", y: "6", rx: "2", variants: rectVariants$5, custom: 1, animate: controls, initial: "normal" })] }) }));
 });
 AlignStartHorizontal.displayName = 'AlignStartHorizontal';
 
-function cn$A(...inputs) {
+function cn$N(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$e = {
+const pathVariants$k = {
     normal: (i) => ({
         pathLength: 1,
         opacity: 1,
@@ -5112,8 +5112,8 @@ const AlignStartVertical = forwardRef(({ size = 28, className, style, autoAnimat
     const loopRef = useRef(loopOnHover);
     const isControlledRef = useRef(false);
     const triggerAnimation = useCallback(async () => {
-        await controls.start((i) => i < 1 ? pathVariants$e.animate(i) : rectVariants$4.animate(i - 1));
-        await controls.start((i) => i < 1 ? pathVariants$e.normal(i) : rectVariants$4.normal(i - 1));
+        await controls.start((i) => i < 1 ? pathVariants$k.animate(i) : rectVariants$4.animate(i - 1));
+        await controls.start((i) => i < 1 ? pathVariants$k.normal(i) : rectVariants$4.normal(i - 1));
         if (loopRef.current)
             triggerAnimation();
     }, [controls]);
@@ -5127,8 +5127,8 @@ const AlignStartVertical = forwardRef(({ size = 28, className, style, autoAnimat
     useImperativeHandle(ref, () => {
         isControlledRef.current = true;
         return {
-            startAnimation: () => controls.start((i) => i < 1 ? pathVariants$e.animate(i) : rectVariants$4.animate(i - 1)),
-            stopAnimation: () => controls.start((i) => i < 1 ? pathVariants$e.normal(i) : rectVariants$4.normal(i - 1)),
+            startAnimation: () => controls.start((i) => i < 1 ? pathVariants$k.animate(i) : rectVariants$4.animate(i - 1)),
+            stopAnimation: () => controls.start((i) => i < 1 ? pathVariants$k.normal(i) : rectVariants$4.normal(i - 1)),
         };
     }, [controls]);
     const handleMouseEnter = (e) => {
@@ -5138,7 +5138,7 @@ const AlignStartVertical = forwardRef(({ size = 28, className, style, autoAnimat
     };
     const handleMouseLeave = (e) => {
         if (!isControlledRef.current && hoverable)
-            controls.start((i) => i < 1 ? pathVariants$e.normal(i) : rectVariants$4.normal(i - 1));
+            controls.start((i) => i < 1 ? pathVariants$k.normal(i) : rectVariants$4.normal(i - 1));
         onMouseLeave?.(e);
     };
     const handleClick = (e) => {
@@ -5146,14 +5146,14 @@ const AlignStartVertical = forwardRef(({ size = 28, className, style, autoAnimat
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$A('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M2 2v20", variants: pathVariants$e, custom: 0, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "16", height: "6", x: "6", y: "4", rx: "2", variants: rectVariants$4, custom: 0, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "9", height: "6", x: "6", y: "14", rx: "2", variants: rectVariants$4, custom: 1, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$N('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M2 2v20", variants: pathVariants$k, custom: 0, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "16", height: "6", x: "6", y: "4", rx: "2", variants: rectVariants$4, custom: 0, animate: controls, initial: "normal" }), jsx(motion.rect, { width: "9", height: "6", x: "6", y: "14", rx: "2", variants: rectVariants$4, custom: 1, animate: controls, initial: "normal" })] }) }));
 });
 AlignStartVertical.displayName = 'AlignStartVertical';
 
-function cn$z(...inputs) {
+function cn$M(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$d = {
+const pathVariants$j = {
     normal: {
         pathLength: 1,
         pathOffset: 0,
@@ -5228,14 +5228,14 @@ const AlignVerticalDistributeCenter = forwardRef(({ size = 28, className, style,
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$z('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M22 17h-3", variants: pathVariants$d, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M22 7h-5", variants: pathVariants$d, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M5 17H2", variants: pathVariants$d, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M7 7H2", variants: pathVariants$d, animate: controls, initial: "normal" }), jsx(motion.rect, { x: "5", y: "14", width: "14", height: "6", rx: "2", variants: rectVariants$3, animate: controls, initial: "normal" }), jsx(motion.rect, { x: "7", y: "4", width: "10", height: "6", rx: "2", variants: rectVariants$3, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$M('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M22 17h-3", variants: pathVariants$j, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M22 7h-5", variants: pathVariants$j, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M5 17H2", variants: pathVariants$j, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M7 7H2", variants: pathVariants$j, animate: controls, initial: "normal" }), jsx(motion.rect, { x: "5", y: "14", width: "14", height: "6", rx: "2", variants: rectVariants$3, animate: controls, initial: "normal" }), jsx(motion.rect, { x: "7", y: "4", width: "10", height: "6", rx: "2", variants: rectVariants$3, animate: controls, initial: "normal" })] }) }));
 });
 AlignVerticalDistributeCenter.displayName = 'AlignVerticalDistributeCenter';
 
-function cn$y(...inputs) {
+function cn$L(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$c = {
+const pathVariants$i = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -5291,14 +5291,14 @@ const AlignVerticalDistributeEnd = forwardRef(({ size = 28, className, style, au
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$y('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "14", height: "6", x: "5", y: "14", rx: "2", variants: pathVariants$c, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "4", rx: "2", variants: pathVariants$c, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 20h20", variants: pathVariants$c, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 10h20", variants: pathVariants$c, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$L('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "14", height: "6", x: "5", y: "14", rx: "2", variants: pathVariants$i, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "4", rx: "2", variants: pathVariants$i, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 20h20", variants: pathVariants$i, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 10h20", variants: pathVariants$i, initial: "normal", animate: controls })] }) }));
 });
 AlignVerticalDistributeEnd.displayName = 'AlignVerticalDistributeEnd';
 
-function cn$x(...inputs) {
+function cn$K(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$b = {
+const pathVariants$h = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -5354,11 +5354,11 @@ const AlignVerticalDistributeStart = forwardRef(({ size = 28, className, style,
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$x('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "14", height: "6", x: "5", y: "14", rx: "2", variants: pathVariants$b, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "4", rx: "2", variants: pathVariants$b, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 14h20", variants: pathVariants$b, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 4h20", variants: pathVariants$b, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$K('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { width: "14", height: "6", x: "5", y: "14", rx: "2", variants: pathVariants$h, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "4", rx: "2", variants: pathVariants$h, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 14h20", variants: pathVariants$h, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 4h20", variants: pathVariants$h, initial: "normal", animate: controls })] }) }));
 });
 AlignVerticalDistributeStart.displayName = 'AlignVerticalDistributeStart';
 
-function cn$w(...inputs) {
+function cn$J(...inputs) {
     return twMerge(clsx(inputs));
 }
 // The line will animate first
@@ -5437,11 +5437,11 @@ const AlignVerticalJustifyCenter = forwardRef(({ size = 28, className, style, au
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$w('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 12h20", variants: lineVariants$2, initial: "normal", animate: controls }), jsx(motion.rect, { width: "14", height: "6", x: "5", y: "16", rx: "2", variants: rectVariants$2, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "2", rx: "2", variants: rectVariants$2, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$J('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 12h20", variants: lineVariants$2, initial: "normal", animate: controls }), jsx(motion.rect, { width: "14", height: "6", x: "5", y: "16", rx: "2", variants: rectVariants$2, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "2", rx: "2", variants: rectVariants$2, initial: "normal", animate: controls })] }) }));
 });
 AlignVerticalJustifyCenter.displayName = 'AlignVerticalJustifyCenter';
 
-function cn$v(...inputs) {
+function cn$I(...inputs) {
     return twMerge(clsx(inputs));
 }
 const lineVariants$1 = {
@@ -5536,11 +5536,11 @@ const AlignVerticalJustifyEnd = forwardRef(({ size = 28, className, style, autoA
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$v('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 22h20", variants: lineVariants$1, initial: "normal", animate: controls }), jsx(motion.rect, { width: "14", height: "6", x: "5", y: "12", rx: "2", variants: middleRectVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "2", rx: "2", variants: topRectVariants$1, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$I('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 22h20", variants: lineVariants$1, initial: "normal", animate: controls }), jsx(motion.rect, { width: "14", height: "6", x: "5", y: "12", rx: "2", variants: middleRectVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "2", rx: "2", variants: topRectVariants$1, initial: "normal", animate: controls })] }) }));
 });
 AlignVerticalJustifyEnd.displayName = 'AlignVerticalJustifyEnd';
 
-function cn$u(...inputs) {
+function cn$H(...inputs) {
     return twMerge(clsx(inputs));
 }
 // Top line will animate first - 0.25 seconds
@@ -5638,11 +5638,11 @@ const AlignVerticalJustifyStart = forwardRef(({ size = 28, className, style, aut
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$u('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 2h20", variants: lineVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "6", rx: "2", variants: topRectVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "14", height: "6", x: "5", y: "16", rx: "2", variants: bottomRectVariants, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$H('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 2h20", variants: lineVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "6", rx: "2", variants: topRectVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "14", height: "6", x: "5", y: "16", rx: "2", variants: bottomRectVariants, initial: "normal", animate: controls })] }) }));
 });
 AlignVerticalJustifyStart.displayName = 'AlignVerticalJustifyStart';
 
-function cn$t(...inputs) {
+function cn$G(...inputs) {
     return twMerge(clsx(inputs));
 }
 const linesVariants$1 = {
@@ -5719,11 +5719,11 @@ const AlignVerticalSpaceAround = forwardRef(({ size = 28, className, style, auto
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$t('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M22 4H2", variants: linesVariants$1, initial: "normal", animate: controls }), jsx(motion.path, { d: "M22 20H2", variants: linesVariants$1, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "9", rx: "2", variants: rectVariants$1, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$G('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M22 4H2", variants: linesVariants$1, initial: "normal", animate: controls }), jsx(motion.path, { d: "M22 20H2", variants: linesVariants$1, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "9", rx: "2", variants: rectVariants$1, initial: "normal", animate: controls })] }) }));
 });
 AlignVerticalSpaceAround.displayName = 'AlignVerticalSpaceAround';
 
-function cn$s(...inputs) {
+function cn$F(...inputs) {
     return twMerge(clsx(inputs));
 }
 const linesVariants = {
@@ -5800,14 +5800,14 @@ const AlignVerticalSpaceBetween = forwardRef(({ size = 28, className, style, aut
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$s('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 21h20", variants: linesVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 3h20", variants: linesVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "14", height: "6", x: "5", y: "15", rx: "2", variants: rectVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "3", rx: "2", variants: rectVariants, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$F('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 21h20", variants: linesVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 3h20", variants: linesVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "14", height: "6", x: "5", y: "15", rx: "2", variants: rectVariants, initial: "normal", animate: controls }), jsx(motion.rect, { width: "10", height: "6", x: "7", y: "3", rx: "2", variants: rectVariants, initial: "normal", animate: controls })] }) }));
 });
 AlignVerticalSpaceBetween.displayName = 'AlignVerticalSpaceBetween';
 
-function cn$r(...inputs) {
+function cn$E(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$a = {
+const pathVariants$g = {
     normal: (custom) => ({
         pathLength: 1,
         opacity: 1,
@@ -5874,19 +5874,19 @@ const Ampersand = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
         }
         onClick?.(e);
     }, [animateOnClick, onClick, triggerAnimation]);
-    return (jsx("div", { className: cn$r(className), style: {
+    return (jsx("div", { className: cn$E(className), style: {
             width: size,
             height: size,
             display: 'inline-block',
             ...style,
-        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M17.5 12c0 4.4-3.6 8-8 8A4.5 4.5 0 0 1 5 15.5c0-6 8-4 8-8.5a3 3 0 1 0-6 0c0 3 2.5 8.5 12 13", variants: pathVariants$a, initial: "normal", animate: controls, custom: 0 }), jsx(motion.path, { d: "M16 12h3", variants: pathVariants$a, initial: "normal", animate: controls, custom: 0.2 })] }) }));
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M17.5 12c0 4.4-3.6 8-8 8A4.5 4.5 0 0 1 5 15.5c0-6 8-4 8-8.5a3 3 0 1 0-6 0c0 3 2.5 8.5 12 13", variants: pathVariants$g, initial: "normal", animate: controls, custom: 0 }), jsx(motion.path, { d: "M16 12h3", variants: pathVariants$g, initial: "normal", animate: controls, custom: 0.2 })] }) }));
 });
 Ampersand.displayName = 'Ampersand';
 
-function cn$q(...inputs) {
+function cn$D(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$9 = {
+const pathVariants$f = {
     normal: {
         pathLength: 1,
         pathOffset: 0,
@@ -5942,14 +5942,14 @@ const Ampersands = forwardRef(({ size = 28, className, style, autoAnimateOnLoad
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$q('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M10 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5", variants: pathVariants$9, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M22 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5", variants: pathVariants$9, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$D('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M10 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5", variants: pathVariants$f, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M22 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5", variants: pathVariants$f, animate: controls, initial: "normal" })] }) }));
 });
 Ampersands.displayName = 'Ampersands';
 
-function cn$p(...inputs) {
+function cn$C(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$8 = {
+const pathVariants$e = {
     normal: {
         pathLength: 1,
         pathOffset: 0,
@@ -6005,11 +6005,11 @@ const Apple = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = fal
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$p('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M12 20.94c1.5 0 2.75 1.06 4 1.06 3 0 6-8 6-12.22A4.91 4.91 0 0 0 17 5c-2.22 0-4 1.44-5 2-1-.56-2.78-2-5-2a4.9 4.9 0 0 0-5 4.78C2 14 5 22 8 22c1.25 0 2.5-1.06 4-1.06Z", variants: pathVariants$8, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M10 2c1 .5 2 2 2 5", variants: pathVariants$8, animate: controls, initial: "normal" })] }) }));
+    return (jsx("div", { className: cn$C('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M12 20.94c1.5 0 2.75 1.06 4 1.06 3 0 6-8 6-12.22A4.91 4.91 0 0 0 17 5c-2.22 0-4 1.44-5 2-1-.56-2.78-2-5-2a4.9 4.9 0 0 0-5 4.78C2 14 5 22 8 22c1.25 0 2.5-1.06 4-1.06Z", variants: pathVariants$e, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M10 2c1 .5 2 2 2 5", variants: pathVariants$e, animate: controls, initial: "normal" })] }) }));
 });
 Apple.displayName = 'Apple';
 
-function cn$o(...inputs) {
+function cn$B(...inputs) {
     return twMerge(clsx(inputs));
 }
 const draw = {
@@ -6059,11 +6059,11 @@ const Ambulance = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$o('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M10 10H6", variants: draw, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2", variants: draw, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M19 18h2a1 1 0 0 0 1-1v-3.28a1 1 0 0 0-.684-.948l-1.923-.641a1 1 0 0 1-.578-.502l-1.539-3.076A1 1 0 0 0 16.382 8H14", variants: draw, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M8 8v4", variants: draw, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M9 18h6", variants: draw, animate: controls, initial: "normal" }), jsx(motion.circle, { cx: "17", cy: "18", r: "2", animate: { scale: [1, 1.2, 1], fill: ['#000', '#000', '#000'] }, transition: { repeat: Infinity, duration: 1 } }), jsx(motion.circle, { cx: "7", cy: "18", r: "2", animate: { scale: [1, 1.2, 1], fill: ['#000', '#000', '#000'] }, transition: { repeat: Infinity, duration: 1, delay: 0.3 } })] }) }));
+    return (jsx("div", { className: cn$B('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M10 10H6", variants: draw, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2", variants: draw, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M19 18h2a1 1 0 0 0 1-1v-3.28a1 1 0 0 0-.684-.948l-1.923-.641a1 1 0 0 1-.578-.502l-1.539-3.076A1 1 0 0 0 16.382 8H14", variants: draw, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M8 8v4", variants: draw, animate: controls, initial: "normal" }), jsx(motion.path, { d: "M9 18h6", variants: draw, animate: controls, initial: "normal" }), jsx(motion.circle, { cx: "17", cy: "18", r: "2", animate: { scale: [1, 1.2, 1], fill: ['#000', '#000', '#000'] }, transition: { repeat: Infinity, duration: 1 } }), jsx(motion.circle, { cx: "7", cy: "18", r: "2", animate: { scale: [1, 1.2, 1], fill: ['#000', '#000', '#000'] }, transition: { repeat: Infinity, duration: 1, delay: 0.3 } })] }) }));
 });
 Ambulance.displayName = 'Ambulance';
 
-function cn$n(...inputs) {
+function cn$A(...inputs) {
     return twMerge(clsx(inputs));
 }
 const DURATION$2 = 0.7;
@@ -6134,14 +6134,14 @@ const Angry = forwardRef(({ className, size = 28, autoAnimateOnLoad = false, hov
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$n('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", initial: "normal", animate: controls, children: [jsx(motion.circle, { cx: "12", cy: "12", r: "10", variants: faceVariants$1 }), jsx(motion.path, { d: "M16 16s-1.5-2-4-2-4 2-4 2", variants: mouthVariants$1 }), jsx(motion.path, { d: "M7.5 8 10 9", variants: eyebrowVariants }), jsx(motion.path, { d: "m14 9 2.5-1", variants: eyebrowVariants }), jsx(motion.path, { d: "M9 10h.01", variants: eyeVariants }), jsx(motion.path, { d: "M15 10h.01", variants: eyeVariants })] }) }));
+    return (jsx("div", { className: cn$A('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", initial: "normal", animate: controls, children: [jsx(motion.circle, { cx: "12", cy: "12", r: "10", variants: faceVariants$1 }), jsx(motion.path, { d: "M16 16s-1.5-2-4-2-4 2-4 2", variants: mouthVariants$1 }), jsx(motion.path, { d: "M7.5 8 10 9", variants: eyebrowVariants }), jsx(motion.path, { d: "m14 9 2.5-1", variants: eyebrowVariants }), jsx(motion.path, { d: "M9 10h.01", variants: eyeVariants }), jsx(motion.path, { d: "M15 10h.01", variants: eyeVariants })] }) }));
 });
 Angry.displayName = 'Angry';
 
-function cn$m(...inputs) {
+function cn$z(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$7 = {
+const pathVariants$d = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -6197,11 +6197,11 @@ const Amphora = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = f
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$m('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M10 2v5.632c0 .424-.272.795-.653.982A6 6 0 0 0 6 14c.006 4 3 7 5 8", variants: pathVariants$7, initial: "normal", animate: controls }), jsx(motion.path, { d: "M10 5H8a2 2 0 0 0 0 4h.68", variants: pathVariants$7, initial: "normal", animate: controls }), jsx(motion.path, { d: "M14 2v5.632c0 .424.272.795.652.982A6 6 0 0 1 18 14c0 4-3 7-5 8", variants: pathVariants$7, initial: "normal", animate: controls }), jsx(motion.path, { d: "M14 5h2a2 2 0 0 1 0 4h-.68", variants: pathVariants$7, initial: "normal", animate: controls }), jsx(motion.path, { d: "M18 22H6", variants: pathVariants$7, initial: "normal", animate: controls }), jsx(motion.path, { d: "M9 2h6", variants: pathVariants$7, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$z('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M10 2v5.632c0 .424-.272.795-.653.982A6 6 0 0 0 6 14c.006 4 3 7 5 8", variants: pathVariants$d, initial: "normal", animate: controls }), jsx(motion.path, { d: "M10 5H8a2 2 0 0 0 0 4h.68", variants: pathVariants$d, initial: "normal", animate: controls }), jsx(motion.path, { d: "M14 2v5.632c0 .424.272.795.652.982A6 6 0 0 1 18 14c0 4-3 7-5 8", variants: pathVariants$d, initial: "normal", animate: controls }), jsx(motion.path, { d: "M14 5h2a2 2 0 0 1 0 4h-.68", variants: pathVariants$d, initial: "normal", animate: controls }), jsx(motion.path, { d: "M18 22H6", variants: pathVariants$d, initial: "normal", animate: controls }), jsx(motion.path, { d: "M9 2h6", variants: pathVariants$d, initial: "normal", animate: controls })] }) }));
 });
 Amphora.displayName = 'Amphora';
 
-function cn$l(...inputs) {
+function cn$y(...inputs) {
     return twMerge(clsx(inputs));
 }
 const Anchor = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
@@ -6260,11 +6260,11 @@ const Anchor = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = fa
             },
         }
     };
-    return (jsx("div", { className: cn$l('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M12 22V8", variants: pathVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M5 12H2a10 10 0 0 0 20 0h-3", variants: pathVariants, initial: "normal", animate: controls }), jsx(motion.circle, { cx: "12", cy: "5", r: "3", variants: pathVariants, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$y('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M12 22V8", variants: pathVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M5 12H2a10 10 0 0 0 20 0h-3", variants: pathVariants, initial: "normal", animate: controls }), jsx(motion.circle, { cx: "12", cy: "5", r: "3", variants: pathVariants, initial: "normal", animate: controls })] }) }));
 });
 Anchor.displayName = 'Anchor';
 
-function cn$k(...inputs) {
+function cn$x(...inputs) {
     return twMerge(clsx(inputs));
 }
 const DURATION$1 = 0.7;
@@ -6350,16 +6350,16 @@ const Annoyed = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = f
         }
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$k('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", animate: controls, initial: "normal", children: [jsx(motion.circle, { cx: "12", cy: "12", r: "10", variants: faceVariants }), jsx(motion.path, { d: "M8 15h8", variants: mouthVariants }), jsx(motion.path, { d: "M8 9h2", variants: leftEyeVariants }), jsx(motion.path, { d: "M14 9h2", variants: rightEyeVariants })] }) }));
+    return (jsx("div", { className: cn$x('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", animate: controls, initial: "normal", children: [jsx(motion.circle, { cx: "12", cy: "12", r: "10", variants: faceVariants }), jsx(motion.path, { d: "M8 15h8", variants: mouthVariants }), jsx(motion.path, { d: "M8 9h2", variants: leftEyeVariants }), jsx(motion.path, { d: "M14 9h2", variants: rightEyeVariants })] }) }));
 });
 Annoyed.displayName = 'Annoyed';
 
-function cn$j(...inputs) {
+function cn$w(...inputs) {
     return twMerge(clsx(inputs));
 }
 const DURATION = 1.2;
 // Animate the antenna lines "wiggle" side to side
-const pathVariants$6 = {
+const pathVariants$c = {
     normal: { rotate: 0, originX: '50%', originY: '100%' },
     animate: {
         rotate: [0, 10, -10, 10, 0],
@@ -6430,11 +6430,11 @@ const Antenna = forwardRef(({ className, size = 28, autoAnimateOnLoad = false, h
             return;
         startAnimation();
     }, [animationTrigger, animateOnClick, startAnimation]);
-    return (jsx("div", { className: cn$j('inline-block', className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, style: { width: size, height: size, ...props.style }, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 12 7 2", variants: pathVariants$6, animate: controls, style: { originX: '50%', originY: '100%' } }), jsx(motion.path, { d: "m7 12 5-10", variants: pathVariants$6, animate: controls, style: { originX: '50%', originY: '100%' } }), jsx(motion.path, { d: "m12 12 5-10", variants: pathVariants$6, animate: controls, style: { originX: '50%', originY: '100%' } }), jsx(motion.path, { d: "m17 12 5-10", variants: pathVariants$6, animate: controls, style: { originX: '50%', originY: '100%' } }), jsx(motion.path, { d: "M4.5 7h15", variants: horizontalLineVariants, animate: controls }), jsx(motion.path, { d: "M12 16v6", variants: verticalLineVariants, animate: controls })] }) }));
+    return (jsx("div", { className: cn$w('inline-block', className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, style: { width: size, height: size, ...props.style }, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M2 12 7 2", variants: pathVariants$c, animate: controls, style: { originX: '50%', originY: '100%' } }), jsx(motion.path, { d: "m7 12 5-10", variants: pathVariants$c, animate: controls, style: { originX: '50%', originY: '100%' } }), jsx(motion.path, { d: "m12 12 5-10", variants: pathVariants$c, animate: controls, style: { originX: '50%', originY: '100%' } }), jsx(motion.path, { d: "m17 12 5-10", variants: pathVariants$c, animate: controls, style: { originX: '50%', originY: '100%' } }), jsx(motion.path, { d: "M4.5 7h15", variants: horizontalLineVariants, animate: controls }), jsx(motion.path, { d: "M12 16v6", variants: verticalLineVariants, animate: controls })] }) }));
 });
 Antenna.displayName = 'Antenna';
 
-function cn$i(...inputs) {
+function cn$v(...inputs) {
     return twMerge(clsx(inputs));
 }
 const circleVariants = {
@@ -6527,14 +6527,14 @@ const Aperture = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
         }
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$i('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.circle, { cx: "12", cy: "12", r: "10", variants: circleVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "m14.31 8 5.74 9.94", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M9.69 8h11.48", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "m7.38 12 5.74-9.94", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M9.69 16 3.95 6.06", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M14.31 16H2.83", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "m16.62 12-5.74 9.94", variants: bladeVariants, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$v('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.circle, { cx: "12", cy: "12", r: "10", variants: circleVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "m14.31 8 5.74 9.94", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M9.69 8h11.48", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "m7.38 12 5.74-9.94", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M9.69 16 3.95 6.06", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M14.31 16H2.83", variants: bladeVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "m16.62 12-5.74 9.94", variants: bladeVariants, initial: "normal", animate: controls })] }) }));
 });
 Aperture.displayName = 'Aperture';
 
-function cn$h(...inputs) {
+function cn$u(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$5 = {
+const pathVariants$b = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -6590,14 +6590,14 @@ const AppWindow = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$h('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { x: "2", y: "4", width: "20", height: "16", rx: "2", variants: pathVariants$5, initial: "normal", animate: controls }), jsx(motion.path, { d: "M10 4v4", variants: pathVariants$5, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 8h20", variants: pathVariants$5, initial: "normal", animate: controls }), jsx(motion.path, { d: "M6 4v4", variants: pathVariants$5, initial: "normal", animate: controls })] }) }));
+    return (jsx("div", { className: cn$u('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { x: "2", y: "4", width: "20", height: "16", rx: "2", variants: pathVariants$b, initial: "normal", animate: controls }), jsx(motion.path, { d: "M10 4v4", variants: pathVariants$b, initial: "normal", animate: controls }), jsx(motion.path, { d: "M2 8h20", variants: pathVariants$b, initial: "normal", animate: controls }), jsx(motion.path, { d: "M6 4v4", variants: pathVariants$b, initial: "normal", animate: controls })] }) }));
 });
 AppWindow.displayName = 'AppWindow';
 
-function cn$g(...inputs) {
+function cn$t(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$4 = {
+const pathVariants$a = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -6661,14 +6661,14 @@ const AppWindowMac = forwardRef(({ size = 28, className, style, autoAnimateOnLoa
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$g('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { x: "2", y: "4", width: "20", height: "16", rx: "2", variants: pathVariants$4, initial: "normal", animate: controls }), jsx(motion.path, { d: "M6 8h.01", initial: { opacity: 1 }, animate: { opacity: [1, 0, 1] }, transition: { ...blinkTransition, delay: 0 } }), jsx(motion.path, { d: "M10 8h.01", initial: { opacity: 1 }, animate: { opacity: [1, 0, 1] }, transition: { ...blinkTransition, delay: 0.5 } }), jsx(motion.path, { d: "M14 8h.01", initial: { opacity: 1 }, animate: { opacity: [1, 0, 1] }, transition: { ...blinkTransition, delay: 1 } })] }) }));
+    return (jsx("div", { className: cn$t('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { x: "2", y: "4", width: "20", height: "16", rx: "2", variants: pathVariants$a, initial: "normal", animate: controls }), jsx(motion.path, { d: "M6 8h.01", initial: { opacity: 1 }, animate: { opacity: [1, 0, 1] }, transition: { ...blinkTransition, delay: 0 } }), jsx(motion.path, { d: "M10 8h.01", initial: { opacity: 1 }, animate: { opacity: [1, 0, 1] }, transition: { ...blinkTransition, delay: 0.5 } }), jsx(motion.path, { d: "M14 8h.01", initial: { opacity: 1 }, animate: { opacity: [1, 0, 1] }, transition: { ...blinkTransition, delay: 1 } })] }) }));
 });
 AppWindowMac.displayName = 'AppWindowMac';
 
-function cn$f(...inputs) {
+function cn$s(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$3 = {
+const pathVariants$9 = {
     normal: {
         opacity: 1,
         pathLength: 1,
@@ -6724,14 +6724,14 @@ const Archive = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = f
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$f('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { x: "2", y: "3", width: "20", height: "5", rx: "1", variants: pathVariants$3, initial: "normal", animate: controls }), jsx(motion.path, { d: "M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8", variants: pathVariants$3, initial: "normal", animate: controls }), jsx("path", { d: "M10 12h4" })] }) }));
+    return (jsx("div", { className: cn$s('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.rect, { x: "2", y: "3", width: "20", height: "5", rx: "1", variants: pathVariants$9, initial: "normal", animate: controls }), jsx(motion.path, { d: "M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8", variants: pathVariants$9, initial: "normal", animate: controls }), jsx("path", { d: "M10 12h4" })] }) }));
 });
 Archive.displayName = 'Archive';
 
-function cn$e(...inputs) {
+function cn$r(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$2 = {
+const pathVariants$8 = {
     initial: {
         pathLength: 1,
         pathOffset: 0,
@@ -6786,14 +6786,14 @@ const ArchiveRestore = forwardRef(({ size = 28, className, style, autoAnimateOnL
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$e('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { x: "2", y: "3", width: "20", height: "5", rx: "1", variants: pathVariants$2, initial: "initial", animate: controls }), jsx(motion.path, { d: "M4 8v11a2 2 0 0 0 2 2h2", variants: pathVariants$2, initial: "initial", animate: controls }), jsx(motion.path, { d: "M20 8v11a2 2 0 0 1-2 2h-2", variants: pathVariants$2, initial: "initial", animate: controls }), jsx(motion.path, { d: "m9 15 3-3 3 3", variants: pathVariants$2, initial: "initial", animate: controls }), jsx(motion.path, { d: "M12 12v9", variants: pathVariants$2, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$r('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { x: "2", y: "3", width: "20", height: "5", rx: "1", variants: pathVariants$8, initial: "initial", animate: controls }), jsx(motion.path, { d: "M4 8v11a2 2 0 0 0 2 2h2", variants: pathVariants$8, initial: "initial", animate: controls }), jsx(motion.path, { d: "M20 8v11a2 2 0 0 1-2 2h-2", variants: pathVariants$8, initial: "initial", animate: controls }), jsx(motion.path, { d: "m9 15 3-3 3 3", variants: pathVariants$8, initial: "initial", animate: controls }), jsx(motion.path, { d: "M12 12v9", variants: pathVariants$8, initial: "initial", animate: controls })] }) }));
 });
 ArchiveRestore.displayName = 'ArchiveRestore';
 
-function cn$d(...inputs) {
+function cn$q(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants$1 = {
+const pathVariants$7 = {
     initial: {
         pathLength: 1,
         pathOffset: 0,
@@ -6848,14 +6848,14 @@ const ArchiveX = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$d('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { x: "2", y: "3", width: "20", height: "5", rx: "1", variants: pathVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8", variants: pathVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "m9.5 17 5-5", variants: pathVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "m9.5 12 5 5", variants: pathVariants$1, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$q('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.rect, { x: "2", y: "3", width: "20", height: "5", rx: "1", variants: pathVariants$7, initial: "initial", animate: controls }), jsx(motion.path, { d: "M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8", variants: pathVariants$7, initial: "initial", animate: controls }), jsx(motion.path, { d: "m9.5 17 5-5", variants: pathVariants$7, initial: "initial", animate: controls }), jsx(motion.path, { d: "m9.5 12 5 5", variants: pathVariants$7, initial: "initial", animate: controls })] }) }));
 });
 ArchiveX.displayName = 'ArchiveX';
 
-function cn$c(...inputs) {
+function cn$p(...inputs) {
     return twMerge(clsx(inputs));
 }
-const pathVariants = {
+const pathVariants$6 = {
     initial: {
         pathLength: 1,
         pathOffset: 0,
@@ -6910,11 +6910,11 @@ const Armchair = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$c('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M19 9V6a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v3", variants: pathVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M3 16a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-9a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z", variants: pathVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M5 18v2", variants: pathVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M19 18v2", variants: pathVariants, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$p('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M19 9V6a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v3", variants: pathVariants$6, initial: "initial", animate: controls }), jsx(motion.path, { d: "M3 16a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-9a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z", variants: pathVariants$6, initial: "initial", animate: controls }), jsx(motion.path, { d: "M5 18v2", variants: pathVariants$6, initial: "initial", animate: controls }), jsx(motion.path, { d: "M19 18v2", variants: pathVariants$6, initial: "initial", animate: controls })] }) }));
 });
 Armchair.displayName = 'Armchair';
 
-function cn$b(...inputs) {
+function cn$o(...inputs) {
     return twMerge(clsx(inputs));
 }
 const groupVariants$2 = {
@@ -6967,11 +6967,11 @@ const ArrowBigDown = forwardRef(({ size = 28, className, style, autoAnimateOnLoa
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$b('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.g, { variants: groupVariants$2, initial: "initial", animate: controls, children: jsx("path", { d: "M15 6v6h4l-7 7-7-7h4V6h6z" }) }) }) }));
+    return (jsx("div", { className: cn$o('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.g, { variants: groupVariants$2, initial: "initial", animate: controls, children: jsx("path", { d: "M15 6v6h4l-7 7-7-7h4V6h6z" }) }) }) }));
 });
 ArrowBigDown.displayName = 'ArrowBigDown';
 
-function cn$a(...inputs) {
+function cn$n(...inputs) {
     return twMerge(clsx(inputs));
 }
 const groupVariants$1 = {
@@ -7024,14 +7024,14 @@ const ArrowBigUp = forwardRef(({ size = 28, className, style, autoAnimateOnLoad
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$a('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.g, { variants: groupVariants$1, initial: "initial", animate: controls, children: jsx("path", { d: "M9 18V12H5l7-7 7 7h-4v6H9z" }) }) }) }));
+    return (jsx("div", { className: cn$n('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.g, { variants: groupVariants$1, initial: "initial", animate: controls, children: jsx("path", { d: "M9 18V12H5l7-7 7 7h-4v6H9z" }) }) }) }));
 });
 ArrowBigUp.displayName = 'ArrowBigUp';
 
-function cn$9(...inputs) {
+function cn$m(...inputs) {
     return twMerge(clsx(inputs));
 }
-const arrowVariants$4 = {
+const arrowVariants$9 = {
     initial: { x: 0, scale: 1 },
     animate: {
         x: [0, -4, 0],
@@ -7080,11 +7080,11 @@ const ArrowBigLeft = forwardRef(({ size = 28, className, style, autoAnimateOnLoa
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$9('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.path, { variants: arrowVariants$4, initial: "initial", animate: controls, d: "M18 15h-6v4l-7-7 7-7v4h6v6z" }) }) }));
+    return (jsx("div", { className: cn$m('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.path, { variants: arrowVariants$9, initial: "initial", animate: controls, d: "M18 15h-6v4l-7-7 7-7v4h6v6z" }) }) }));
 });
 ArrowBigLeft.displayName = 'ArrowBigLeft';
 
-function cn$8(...inputs) {
+function cn$l(...inputs) {
     return twMerge(clsx(inputs));
 }
 const groupVariants = {
@@ -7136,14 +7136,14 @@ const ArrowBigRight = forwardRef(({ size = 28, className, style, autoAnimateOnLo
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$8('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.path, { variants: groupVariants, initial: "initial", animate: controls, d: "M6 9h6V5l7 7-7 7v-4H6V9z" }) }) }));
+    return (jsx("div", { className: cn$l('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: jsx(motion.path, { variants: groupVariants, initial: "initial", animate: controls, d: "M6 9h6V5l7 7-7 7v-4H6V9z" }) }) }));
 });
 ArrowBigRight.displayName = 'ArrowBigRight';
 
-function cn$7(...inputs) {
+function cn$k(...inputs) {
     return twMerge(clsx(inputs));
 }
-const arrowVariants$3 = {
+const arrowVariants$8 = {
     initial: { y: 0, scale: 1 },
     animate: {
         y: [0, 4, 0],
@@ -7203,14 +7203,14 @@ const ArrowBigDownDash = forwardRef(({ size = 28, className, style, autoAnimateO
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$7('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M15 5H9", variants: dashVariants$3, initial: "initial", animate: controls }), jsx(motion.path, { d: "M15 9v3h4l-7 7-7-7h4V9z", variants: arrowVariants$3, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$k('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M15 5H9", variants: dashVariants$3, initial: "initial", animate: controls }), jsx(motion.path, { d: "M15 9v3h4l-7 7-7-7h4V9z", variants: arrowVariants$8, initial: "initial", animate: controls })] }) }));
 });
 ArrowBigDownDash.displayName = 'ArrowBigDownDash';
 
-function cn$6(...inputs) {
+function cn$j(...inputs) {
     return twMerge(clsx(inputs));
 }
-const arrowVariants$2 = {
+const arrowVariants$7 = {
     initial: { x: 0, scale: 1 },
     animate: {
         x: [0, -4, 0],
@@ -7270,14 +7270,14 @@ const ArrowBigLeftDash = forwardRef(({ size = 28, className, style, autoAnimateO
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$6('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M19 15V9", variants: dashVariants$2, initial: "initial", animate: controls }), jsx(motion.path, { d: "M15 15H12v4l-7-7 7-7v4h3v6z", variants: arrowVariants$2, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$j('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M19 15V9", variants: dashVariants$2, initial: "initial", animate: controls }), jsx(motion.path, { d: "M15 15H12v4l-7-7 7-7v4h3v6z", variants: arrowVariants$7, initial: "initial", animate: controls })] }) }));
 });
 ArrowBigLeftDash.displayName = 'ArrowBigLeftDash';
 
-function cn$5(...inputs) {
+function cn$i(...inputs) {
     return twMerge(clsx(inputs));
 }
-const arrowVariants$1 = {
+const arrowVariants$6 = {
     initial: { x: 0, scale: 1 },
     animate: {
         x: [0, 4, 0],
@@ -7337,14 +7337,14 @@ const ArrowBigRightDash = forwardRef(({ size = 28, className, style, autoAnimate
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$5('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M5 9v6", variants: dashVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "M9 9h3V5l7 7-7 7v-4H9V9z", variants: arrowVariants$1, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$i('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M5 9v6", variants: dashVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "M9 9h3V5l7 7-7 7v-4H9V9z", variants: arrowVariants$6, initial: "initial", animate: controls })] }) }));
 });
 ArrowBigRightDash.displayName = 'ArrowBigRightDash';
 
-function cn$4(...inputs) {
+function cn$h(...inputs) {
     return twMerge(clsx(inputs));
 }
-const arrowVariants = {
+const arrowVariants$5 = {
     initial: { y: 0, scale: 1 },
     animate: {
         y: [0, -4, 0],
@@ -7404,11 +7404,11 @@ const ArrowBigUpDash = forwardRef(({ size = 28, className, style, autoAnimateOnL
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$4('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M9 19h6", variants: dashVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M9 15v-3H5l7-7 7 7h-4v3H9z", variants: arrowVariants, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$h('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M9 19h6", variants: dashVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M9 15v-3H5l7-7 7 7h-4v3H9z", variants: arrowVariants$5, initial: "initial", animate: controls })] }) }));
 });
 ArrowBigUpDash.displayName = 'ArrowBigUpDash';
 
-function cn$3(...inputs) {
+function cn$g(...inputs) {
     return twMerge(clsx(inputs));
 }
 const arrowHeadVariants$3 = {
@@ -7470,11 +7470,11 @@ const ArrowDown = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$3('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M12 5v14", variants: arrowLineVariants$3, initial: "initial", animate: controls }), jsx(motion.path, { d: "m19 12-7 7-7-7", variants: arrowHeadVariants$3, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$g('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M12 5v14", variants: arrowLineVariants$3, initial: "initial", animate: controls }), jsx(motion.path, { d: "m19 12-7 7-7-7", variants: arrowHeadVariants$3, initial: "initial", animate: controls })] }) }));
 });
 ArrowDown.displayName = 'ArrowDown';
 
-function cn$2(...inputs) {
+function cn$f(...inputs) {
     return twMerge(clsx(inputs));
 }
 const arrowHeadVariants$2 = {
@@ -7536,11 +7536,11 @@ const ArrowUp = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = f
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$2('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M12 19V5", variants: arrowLineVariants$2, initial: "initial", animate: controls }), jsx(motion.path, { d: "m5 12 7-7 7 7", variants: arrowHeadVariants$2, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$f('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M12 19V5", variants: arrowLineVariants$2, initial: "initial", animate: controls }), jsx(motion.path, { d: "m5 12 7-7 7 7", variants: arrowHeadVariants$2, initial: "initial", animate: controls })] }) }));
 });
 ArrowUp.displayName = 'ArrowUp';
 
-function cn$1(...inputs) {
+function cn$e(...inputs) {
     return twMerge(clsx(inputs));
 }
 const arrowHeadVariants$1 = {
@@ -7602,11 +7602,11 @@ const ArrowLeft = forwardRef(({ size = 28, className, style, autoAnimateOnLoad =
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn$1('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "m12 5-7 7 7 7", variants: arrowHeadVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "M19 12H5", variants: arrowLineVariants$1, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$e('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "m12 5-7 7 7 7", variants: arrowHeadVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "M19 12H5", variants: arrowLineVariants$1, initial: "initial", animate: controls })] }) }));
 });
 ArrowLeft.displayName = 'ArrowLeft';
 
-function cn(...inputs) {
+function cn$d(...inputs) {
     return twMerge(clsx(inputs));
 }
 const arrowHeadVariants = {
@@ -7668,9 +7668,957 @@ const ArrowRight = forwardRef(({ size = 28, className, style, autoAnimateOnLoad
             triggerAnimation();
         onClick?.(e);
     };
-    return (jsx("div", { className: cn('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "m12 5 7 7-7 7", variants: arrowHeadVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M5 12h14", variants: arrowLineVariants, initial: "initial", animate: controls })] }) }));
+    return (jsx("div", { className: cn$d('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "m12 5 7 7-7 7", variants: arrowHeadVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M5 12h14", variants: arrowLineVariants, initial: "initial", animate: controls })] }) }));
 });
 ArrowRight.displayName = 'ArrowRight';
 
-export { AArrowDown, AArrowUp, AccessibilityActivity, Activity, AirVent, Airplay, AlarmClock, AlarmClockCheck, AlarmClockMinus, AlarmClockPlus, Album, AlignCenter, AlignCenterHorizontal, AlignCenterVertical, AlignEndHorizontal, AlignEndVertical, AlignHorizontalDistributeCenter, AlignHorizontalDistributeEnd, AlignHorizontalDistributeStart, AlignHorizontalJustifyCenter, AlignHorizontalJustifyEnd, AlignHorizontalJustifyStart, AlignHorizontalSpaceAround, AlignHorizontalSpaceBetween, AlignJustify, AlignLeft, AlignRight, AlignStartHorizontal, AlignStartVertical, AlignVerticalDistributeCenter, AlignVerticalDistributeEnd, AlignVerticalDistributeStart, AlignVerticalJustifyCenter, AlignVerticalJustifyEnd, AlignVerticalJustifyStart, AlignVerticalSpaceAround, AlignVerticalSpaceBetween, Ambulance, Ampersand, Ampersands, Amphora, Anchor, Angry, Annoyed, Antenna, Aperture, AppWindow, AppWindowMac, Apple, Archive, ArchiveRestore, ArchiveX, Armchair, ArrowBigDown, ArrowBigDownDash, ArrowBigLeft, ArrowBigLeftDash, ArrowBigRight, ArrowBigRightDash, ArrowBigUp, ArrowBigUpDash, ArrowDown, ArrowLeft, ArrowRight, ArrowUp, SquareActivity };
+function cn$c(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const downArrowVariants = {
+    normal: { y: 0 },
+    animate: {
+        y: [0, 3, 0],
+        transition: {
+            duration: 0.5,
+            ease: 'easeInOut',
+        },
+    },
+};
+const upArrowVariants = {
+    normal: { y: 0 },
+    animate: {
+        y: [0, -3, 0],
+        transition: {
+            duration: 0.5,
+            ease: 'easeInOut',
+        },
+    },
+};
+const ArrowDownUp = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad)
+            triggerAnimation();
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.stop(),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        if (!isControlledRef.current && hoverable)
+            triggerAnimation();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        if (!isControlledRef.current && hoverable)
+            controls.stop();
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            triggerAnimation();
+        onClick?.(e);
+    };
+    return (jsx("div", { className: cn$c('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "M3 16l4 4 4-4", variants: downArrowVariants, initial: "normal", animate: controls }), jsx("path", { d: "M7 20V4" }), jsx(motion.path, { d: "M21 8l-4-4-4 4", variants: upArrowVariants, initial: "normal", animate: controls }), jsx("path", { d: "M17 4v16" })] }) }));
+});
+ArrowDownUp.displayName = 'ArrowDownUp';
+
+function cn$b(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const arrowVariants$4 = {
+    normal: { y: 0 },
+    animate: {
+        y: [0, 3, 0],
+        transition: { duration: 0.4, ease: 'easeInOut' },
+    },
+};
+const zeroVariants$1 = {
+    initial: { y: 0 },
+    animate: {
+        y: [0, 10, 0],
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const oneVariants$1 = {
+    initial: { y: 0 },
+    animate: {
+        y: [0, -10, 0],
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const ArrowDown01 = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad)
+            triggerAnimation();
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.stop(),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        if (!isControlledRef.current && hoverable)
+            triggerAnimation();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        if (!isControlledRef.current && hoverable)
+            controls.stop();
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            triggerAnimation();
+        onClick?.(e);
+    };
+    return (jsx("div", { className: cn$b('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "m3 16 4 4 4-4", variants: arrowVariants$4, initial: "normal", animate: controls }), jsx("path", { d: "M7 20V4" }), jsx(motion.rect, { x: "15", y: "4", width: "4", height: "6", ry: "2", variants: zeroVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "M17 20v-6h-2", variants: oneVariants$1, initial: "initial", animate: controls }), jsx(motion.path, { d: "M15 20h4", variants: oneVariants$1, initial: "initial", animate: controls })] }) }));
+});
+ArrowDown01.displayName = 'ArrowDown01';
+
+function cn$a(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const arrowVariants$3 = {
+    normal: { y: 0 },
+    animate: {
+        y: [0, 3, 0],
+        transition: { duration: 0.4, ease: 'easeInOut' },
+    },
+};
+const zeroVariants = {
+    initial: { y: 0 },
+    animate: {
+        y: [10, 0, 10],
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const oneVariants = {
+    initial: { y: 0 },
+    animate: {
+        y: [-10, 0, -10],
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const ArrowDown10 = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad)
+            triggerAnimation();
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.stop(),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        if (!isControlledRef.current && hoverable)
+            triggerAnimation();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        if (!isControlledRef.current && hoverable)
+            controls.stop();
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            triggerAnimation();
+        onClick?.(e);
+    };
+    return (jsx("div", { className: cn$a('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "m3 16 4 4 4-4", variants: arrowVariants$3, initial: "normal", animate: controls }), jsx("path", { d: "M7 20V4" }), jsx(motion.rect, { x: "15", y: "4", width: "4", height: "6", ry: "2", variants: zeroVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M17 20v-6h-2", variants: oneVariants, initial: "initial", animate: controls }), jsx(motion.path, { d: "M15 20h4", variants: oneVariants, initial: "initial", animate: controls })] }) }));
+});
+ArrowDown10.displayName = 'ArrowDown10';
+
+function cn$9(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const arrowVariants$2 = {
+    normal: { y: 0 },
+    animate: {
+        y: [0, 3, 0],
+        transition: { duration: 0.4, ease: 'easeInOut' },
+    },
+};
+const aVariants$1 = {
+    initial: { y: 0 },
+    animate: {
+        y: [0, 10, 0],
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const zVariants$1 = {
+    initial: { y: 0 },
+    animate: {
+        y: [0, -10, 0],
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const ArrowDownAZ = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad)
+            triggerAnimation();
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.stop(),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        if (!isControlledRef.current && hoverable)
+            triggerAnimation();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        if (!isControlledRef.current && hoverable)
+            controls.stop();
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            triggerAnimation();
+        onClick?.(e);
+    };
+    return (jsx("div", { className: cn$9('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "m3 16 4 4 4-4", variants: arrowVariants$2, initial: "normal", animate: controls }), jsx("path", { d: "M7 20V4" }), jsx(motion.text, { x: "15", y: "10", fontSize: "6", variants: aVariants$1, initial: "initial", animate: controls, children: "A" }), jsx(motion.text, { x: "15", y: "20", fontSize: "6", variants: zVariants$1, initial: "initial", animate: controls, children: "Z" })] }) }));
+});
+ArrowDownAZ.displayName = 'ArrowDownAZ';
+
+function cn$8(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const arrowVariants$1 = {
+    normal: { y: 0 },
+    animate: {
+        y: [0, 3, 0],
+        transition: { duration: 0.4, ease: 'easeInOut' },
+    },
+};
+const aVariants = {
+    initial: { y: 0 },
+    animate: {
+        y: [10, 0, 10],
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const zVariants = {
+    initial: { y: 0 },
+    animate: {
+        y: [-10, 0, -10],
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const ArrowDownZA = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad)
+            triggerAnimation();
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.stop(),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        if (!isControlledRef.current && hoverable)
+            triggerAnimation();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        if (!isControlledRef.current && hoverable)
+            controls.stop();
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            triggerAnimation();
+        onClick?.(e);
+    };
+    return (jsx("div", { className: cn$8('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx(motion.path, { d: "m3 16 4 4 4-4", variants: arrowVariants$1, initial: "normal", animate: controls }), jsx("path", { d: "M7 20V4" }), jsx(motion.text, { x: "15", y: "10", fontSize: "6", variants: aVariants, initial: "initial", animate: controls, children: "A" }), jsx(motion.text, { x: "15", y: "20", fontSize: "6", variants: zVariants, initial: "initial", animate: controls, children: "Z" })] }) }));
+});
+ArrowDownZA.displayName = 'ArrowDownZA';
+
+function cn$7(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const arrowVariants = {
+    normal: { y: 0 },
+    animate: {
+        y: [0, 3, 0],
+        transition: { duration: 0.4, ease: 'easeInOut' },
+    },
+};
+const lineDrawVariants = {
+    initial: { pathLength: 1 },
+    animate: {
+        pathLength: [1, 0, 1],
+        transition: { duration: 0.5, ease: 'easeInOut' },
+    },
+};
+const ArrowDownToLine = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad)
+            triggerAnimation();
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.stop(),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        if (!isControlledRef.current && hoverable)
+            triggerAnimation();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        if (!isControlledRef.current && hoverable)
+            controls.stop();
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            triggerAnimation();
+        onClick?.(e);
+    };
+    return (jsx("div", { className: cn$7('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", width: "100%", height: "100%", children: [jsx("path", { d: "M12 17V3" }), jsx(motion.path, { d: "m6 11 6 6 6-6", variants: arrowVariants, initial: "normal", animate: controls }), jsx(motion.path, { d: "M19 21H5", variants: lineDrawVariants, initial: "initial", animate: controls })] }) }));
+});
+ArrowDownToLine.displayName = 'ArrowDownToLine';
+
+function cn$6(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const pathVariants$5 = {
+    normal: (custom) => ({
+        pathLength: 1,
+        opacity: 1,
+        pathOffset: 0,
+        transition: {
+            duration: 0.3,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+    animate: (custom) => ({
+        pathLength: [0, 1],
+        opacity: [0, 1],
+        pathOffset: [1, 0],
+        transition: {
+            duration: 0.6,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+};
+const Asterisk = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    // Imperative handle for external control
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.start('normal'),
+        };
+    });
+    // Loop animation if loopOnHover is true
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        await controls.start('normal');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad) {
+            triggerAnimation();
+        }
+        else if (!hoverable) {
+            controls.start('normal');
+        }
+    }, [autoAnimateOnLoad, controls, hoverable, triggerAnimation]);
+    const handleMouseEnter = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onMouseEnter?.(e);
+    }, [hoverable, onMouseEnter, triggerAnimation]);
+    const handleMouseLeave = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            controls.start('normal');
+        }
+        onMouseLeave?.(e);
+    }, [hoverable, onMouseLeave, controls]);
+    const handleClick = useCallback((e) => {
+        if (animateOnClick && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onClick?.(e);
+    }, [animateOnClick, onClick, triggerAnimation]);
+    return (jsx("div", { className: cn$6(className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "M12 6v12", variants: pathVariants$5, initial: "normal", animate: controls, custom: 0 }), jsx(motion.path, { d: "M17.196 9 6.804 15", variants: pathVariants$5, initial: "normal", animate: controls, custom: 0.2 }), jsx(motion.path, { d: "m6.804 9 10.392 6", variants: pathVariants$5, initial: "normal", animate: controls, custom: 0.4 })] }) }));
+});
+Asterisk.displayName = 'Asterisk';
+
+function cn$5(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const pathVariants$4 = {
+    normal: (custom) => ({
+        pathLength: 1,
+        opacity: 1,
+        pathOffset: 0,
+        transition: {
+            duration: 0.3,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+    animate: (custom) => ({
+        pathLength: [0, 1],
+        opacity: [0, 1],
+        pathOffset: [1, 0],
+        transition: {
+            duration: 0.6,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+};
+const AtSign = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    // Imperative handle for external control
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.start('normal'),
+        };
+    });
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        await controls.start('normal');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad) {
+            triggerAnimation();
+        }
+        else if (!hoverable) {
+            controls.start('normal');
+        }
+    }, [autoAnimateOnLoad, hoverable, controls, triggerAnimation]);
+    const handleMouseEnter = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onMouseEnter?.(e);
+    }, [hoverable, onMouseEnter, triggerAnimation]);
+    const handleMouseLeave = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            controls.start('normal');
+        }
+        onMouseLeave?.(e);
+    }, [hoverable, onMouseLeave, controls]);
+    const handleClick = useCallback((e) => {
+        if (animateOnClick && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onClick?.(e);
+    }, [animateOnClick, onClick, triggerAnimation]);
+    return (jsx("div", { className: cn$5(className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.circle, { cx: "12", cy: "12", r: "4", variants: pathVariants$4, initial: "normal", animate: controls, custom: 0 }), jsx(motion.path, { d: "M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-4 8", variants: pathVariants$4, initial: "normal", animate: controls, custom: 0.6 })] }) }));
+});
+AtSign.displayName = 'AtSign';
+
+function cn$4(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const pathVariants$3 = {
+    normal: (custom) => ({
+        pathLength: 1,
+        opacity: 1,
+        pathOffset: 0,
+        transition: {
+            duration: 0.3,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+    animate: (custom) => ({
+        pathLength: [0, 1],
+        opacity: [0, 1],
+        pathOffset: [1, 0],
+        transition: {
+            duration: 0.7,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+};
+const Atom = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    // Expose start/stop animation methods externally
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.start('normal'),
+        };
+    });
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        await controls.start('normal');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad) {
+            triggerAnimation();
+        }
+        else if (!hoverable) {
+            controls.start('normal');
+        }
+    }, [autoAnimateOnLoad, hoverable, controls, triggerAnimation]);
+    const handleMouseEnter = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onMouseEnter?.(e);
+    }, [hoverable, onMouseEnter, triggerAnimation]);
+    const handleMouseLeave = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            controls.start('normal');
+        }
+        onMouseLeave?.(e);
+    }, [hoverable, onMouseLeave, controls]);
+    const handleClick = useCallback((e) => {
+        if (animateOnClick && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onClick?.(e);
+    }, [animateOnClick, onClick, triggerAnimation]);
+    return (jsx("div", { className: cn$4(className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.circle, { cx: "12", cy: "12", r: "1", variants: pathVariants$3, initial: "normal", animate: controls, custom: 0 }), jsx(motion.path, { d: "M20.2 20.2c2.04-2.03.02-7.36-4.5-11.9-4.54-4.52-9.87-6.54-11.9-4.5-2.04 2.03-.02 7.36 4.5 11.9 4.54 4.52 9.87 6.54 11.9 4.5Z", variants: pathVariants$3, initial: "normal", animate: controls, custom: 0.3 }), jsx(motion.path, { d: "M15.7 15.7c4.52-4.54 6.54-9.87 4.5-11.9-2.03-2.04-7.36-.02-11.9 4.5-4.52 4.54-6.54 9.87-4.5 11.9 2.03 2.04 7.36.02 11.9-4.5Z", variants: pathVariants$3, initial: "normal", animate: controls, custom: 0.6 })] }) }));
+});
+Atom.displayName = 'Atom';
+
+function cn$3(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const variants = {
+    normal: (d) => ({
+        d,
+        transition: { duration: 0.3 },
+    }),
+    animate: (dFrames, duration) => ({
+        d: dFrames,
+        transition: {
+            duration,
+            repeat: Infinity,
+            ease: 'easeInOut',
+        },
+    }),
+};
+const AudioLines = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = true, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const isControlledRef = useRef(false);
+    const loopRef = useRef(loopOnHover);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.start('normal'),
+        };
+    });
+    // Update loop ref when prop changes
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    // Recursive animation loop helper
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        await controls.start('normal');
+        if (loopRef.current) {
+            triggerAnimation();
+        }
+    }, [controls]);
+    // Auto animate on load
+    useEffect(() => {
+        if (autoAnimateOnLoad && !isControlledRef.current) {
+            triggerAnimation();
+        }
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    // Hover handlers
+    const handleMouseEnter = (e) => {
+        if (!isControlledRef.current && hoverable) {
+            triggerAnimation();
+        }
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        if (!isControlledRef.current && hoverable) {
+            controls.start('normal');
+        }
+        onMouseLeave?.(e);
+    };
+    // Click handler
+    const handleClick = (e) => {
+        if (!isControlledRef.current && animateOnClick) {
+            triggerAnimation();
+        }
+        onClick?.(e);
+    };
+    return (jsx("div", { className: cn$3(className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx("path", { d: "M2 10v3" }), jsx(motion.path, { custom: ['M6 6v11', 'M6 10v3', 'M6 6v11'], variants: {
+                        normal: variants.normal('M6 6v11'),
+                        animate: variants.animate(['M6 6v11', 'M6 10v3', 'M6 6v11'], 1.5),
+                    }, initial: "normal", animate: controls, d: "M6 6v11" }), jsx(motion.path, { custom: ['M10 3v18', 'M10 9v5', 'M10 3v18'], variants: {
+                        normal: variants.normal('M10 3v18'),
+                        animate: variants.animate(['M10 3v18', 'M10 9v5', 'M10 3v18'], 1),
+                    }, initial: "normal", animate: controls, d: "M10 3v18" }), jsx(motion.path, { custom: ['M14 8v7', 'M14 6v11', 'M14 8v7'], variants: {
+                        normal: variants.normal('M14 8v7'),
+                        animate: variants.animate(['M14 8v7', 'M14 6v11', 'M14 8v7'], 0.8),
+                    }, initial: "normal", animate: controls, d: "M14 8v7" }), jsx(motion.path, { custom: ['M18 5v13', 'M18 7v9', 'M18 5v13'], variants: {
+                        normal: variants.normal('M18 5v13'),
+                        animate: variants.animate(['M18 5v13', 'M18 7v9', 'M18 5v13'], 1.5),
+                    }, initial: "normal", animate: controls, d: "M18 5v13" }), jsx("path", { d: "M22 10v3" })] }) }));
+});
+AudioLines.displayName = 'AudioLines';
+
+function cn$2(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const pathVariants$2 = {
+    normal: {
+        opacity: 1,
+        pathLength: 1,
+        pathOffset: 0,
+        transition: {
+            duration: 0.4,
+            opacity: { duration: 0.1 },
+        },
+    },
+    animate: {
+        opacity: [0, 1],
+        pathLength: [0, 1],
+        pathOffset: [1, 0],
+        transition: {
+            duration: 0.7,
+            ease: 'linear',
+            opacity: { duration: 0.1 },
+        },
+    },
+};
+function AudioWaveForm({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }) {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const triggerAnimation = useCallback(async () => {
+        console.log("started animation");
+        await controls.start('animate');
+        await controls.start('normal');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad)
+            triggerAnimation();
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    const handleMouseEnter = (e) => {
+        if (hoverable)
+            triggerAnimation();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        if (hoverable)
+            controls.start('normal');
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            triggerAnimation();
+        onClick?.(e);
+    };
+    return (jsx("div", { className: cn$2('rounded-md', className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "100%", height: "100%", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: jsx(motion.path, { d: "M2 13a2 2 0 0 0 2-2V7a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0V4a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0v-4a2 2 0 0 1 2-2", variants: pathVariants$2, animate: controls, initial: "normal", style: { strokeDasharray: 1 } }) }) }));
+}
+
+function cn$1(...inputs) {
+    return twMerge(clsx(inputs));
+}
+const pathVariants$1 = {
+    normal: (custom) => ({
+        pathLength: 1,
+        opacity: 1,
+        pathOffset: 0,
+        transition: {
+            duration: 0.3,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+    animate: (custom) => ({
+        pathLength: [0, 1],
+        opacity: [0, 1],
+        pathOffset: [1, 0],
+        transition: {
+            duration: 0.6,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+};
+const Award = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start('animate'),
+            stopAnimation: () => controls.start('normal'),
+        };
+    });
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        await controls.start('normal');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad) {
+            triggerAnimation();
+        }
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    const handleMouseEnter = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onMouseEnter?.(e);
+    }, [hoverable, onMouseEnter, triggerAnimation]);
+    const handleMouseLeave = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            controls.start('normal');
+        }
+        onMouseLeave?.(e);
+    }, [hoverable, onMouseLeave, controls]);
+    const handleClick = useCallback((e) => {
+        if (animateOnClick && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onClick?.(e);
+    }, [animateOnClick, onClick, triggerAnimation]);
+    return (jsx("div", { className: cn$1(className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [jsx(motion.path, { d: "m15.477 12.89 1.515 8.526a.5.5 0 0 1-.81.47l-3.58-2.687a1 1 0 0 0-1.197 0l-3.586 2.686a.5.5 0 0 1-.81-.469l1.514-8.526", variants: pathVariants$1, initial: "normal", animate: controls, custom: 0 }), jsx(motion.circle, { cx: "12", cy: "8", r: "6", variants: pathVariants$1, initial: "normal", animate: controls, custom: 0.2 })] }) }));
+});
+Award.displayName = 'Award';
+
+function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+// Path drawing variants with staggered delays
+const pathVariants = {
+    normal: (custom) => ({
+        pathLength: 1,
+        opacity: 1,
+        pathOffset: 0,
+        transition: {
+            duration: 0.3,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+    animate: (custom) => ({
+        pathLength: [0, 1],
+        opacity: [0, 1],
+        pathOffset: [1, 0],
+        transition: {
+            duration: 0.7,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+};
+const Axe = forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = useAnimation();
+    const swingControls = useAnimation();
+    const loopRef = useRef(loopOnHover);
+    const isControlledRef = useRef(false);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => {
+                controls.start('animate');
+                swingControls.start('swing');
+            },
+            stopAnimation: () => {
+                controls.start('normal');
+                swingControls.start('rest');
+            },
+        };
+    });
+    const triggerAnimation = useCallback(async () => {
+        await controls.start('animate');
+        swingControls.start('swing');
+        await controls.start('normal');
+        swingControls.start('rest');
+        if (loopRef.current)
+            triggerAnimation();
+    }, [controls, swingControls]);
+    useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    useEffect(() => {
+        if (autoAnimateOnLoad) {
+            triggerAnimation();
+        }
+    }, [autoAnimateOnLoad, triggerAnimation]);
+    const handleMouseEnter = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onMouseEnter?.(e);
+    }, [hoverable, onMouseEnter, triggerAnimation]);
+    const handleMouseLeave = useCallback((e) => {
+        if (hoverable && !isControlledRef.current) {
+            controls.start('normal');
+            swingControls.start('rest');
+        }
+        onMouseLeave?.(e);
+    }, [hoverable, onMouseLeave, controls, swingControls]);
+    const handleClick = useCallback((e) => {
+        if (animateOnClick && !isControlledRef.current) {
+            triggerAnimation();
+        }
+        onClick?.(e);
+    }, [animateOnClick, onClick, triggerAnimation]);
+    return (jsx("div", { className: cn(className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxs(motion.svg, { xmlns: "http://www.w3.org/2000/svg", width: size, height: size, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", animate: swingControls, initial: "rest", style: { originX: '50%', originY: '50%' }, children: [jsx(motion.path, { d: "m14 12-8.381 8.38a1 1 0 0 1-3.001-3L11 9", variants: pathVariants, initial: "normal", animate: controls, custom: 0 }), jsx(motion.path, { d: "M15 15.5a.5.5 0 0 0 .5.5A6.5 6.5 0 0 0 22 9.5a.5.5 0 0 0-.5-.5h-1.672a2 2 0 0 1-1.414-.586l-5.062-5.062a1.205 1.205 0 0 0-1.704 0L9.352 5.648a1.205 1.205 0 0 0 0 1.704l5.062 5.062A2 2 0 0 1 15 13.828z", variants: pathVariants, initial: "normal", animate: controls, custom: 0.3 })] }) }));
+});
+Axe.displayName = 'Axe';
+
+export { AArrowDown, AArrowUp, AccessibilityActivity, Activity, AirVent, Airplay, AlarmClock, AlarmClockCheck, AlarmClockMinus, AlarmClockPlus, Album, AlignCenter, AlignCenterHorizontal, AlignCenterVertical, AlignEndHorizontal, AlignEndVertical, AlignHorizontalDistributeCenter, AlignHorizontalDistributeEnd, AlignHorizontalDistributeStart, AlignHorizontalJustifyCenter, AlignHorizontalJustifyEnd, AlignHorizontalJustifyStart, AlignHorizontalSpaceAround, AlignHorizontalSpaceBetween, AlignJustify, AlignLeft, AlignRight, AlignStartHorizontal, AlignStartVertical, AlignVerticalDistributeCenter, AlignVerticalDistributeEnd, AlignVerticalDistributeStart, AlignVerticalJustifyCenter, AlignVerticalJustifyEnd, AlignVerticalJustifyStart, AlignVerticalSpaceAround, AlignVerticalSpaceBetween, Ambulance, Ampersand, Ampersands, Amphora, Anchor, Angry, Annoyed, Antenna, Aperture, AppWindow, AppWindowMac, Apple, Archive, ArchiveRestore, ArchiveX, Armchair, ArrowBigDown, ArrowBigDownDash, ArrowBigLeft, ArrowBigLeftDash, ArrowBigRight, ArrowBigRightDash, ArrowBigUp, ArrowBigUpDash, ArrowDown, ArrowDown01, ArrowDown10, ArrowDownAZ, ArrowDownToLine, ArrowDownUp, ArrowDownZA, ArrowLeft, ArrowRight, ArrowUp, Asterisk, AtSign, Atom, AudioLines, AudioWaveForm, Award, Axe, SquareActivity };
 //# sourceMappingURL=index.js.map