aliveicon 1.0.32 → 1.1.0

package/dist/cjs/icons/a/Activity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Activity.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/AirVent.js

@@ -0,0 +1,41 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+var useAnimatedIcon = require('../../lib/use-animated-icon.js');
+
+const windVariants = {
+    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.5,
+            ease: 'easeInOut',
+            delay: custom,
+        },
+    }),
+};
+const AirVent = React.forwardRef(({ className, size = 28, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props);
+    return (jsxRuntime.jsx("div", { className: cn.cn(className), ...iconProps, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.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" }), jsxRuntime.jsx(framerMotion.motion.path, { d: "M6 8h12", variants: windVariants, initial: "normal", animate: controls, custom: 0.1 }), jsxRuntime.jsx(framerMotion.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 }), jsxRuntime.jsx(framerMotion.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';
+
+exports.AirVent = AirVent;
+//# sourceMappingURL=AirVent.js.map

package/dist/cjs/icons/a/AirVent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AirVent.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/Airplay.js

@@ -0,0 +1,58 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+var useAnimatedIcon = require('../../lib/use-animated-icon.js');
+
+const screenVariants = {
+    normal: {
+        opacity: 1,
+        pathLength: 1,
+        pathOffset: 0,
+        transition: {
+            duration: 0.3,
+        },
+    },
+    animate: {
+        opacity: [0, 1],
+        pathLength: [0, 1],
+        pathOffset: [1, 0],
+        transition: {
+            duration: 0.6,
+            ease: 'easeInOut',
+        },
+    },
+};
+const triangleVariants = {
+    normal: {
+        scale: 1,
+        opacity: 1,
+        transition: { duration: 0.3 },
+    },
+    animate: {
+        scale: [0.6, 1.1, 1],
+        opacity: [0, 1],
+        transition: {
+            duration: 0.6,
+            ease: 'easeOut',
+        },
+    },
+};
+const Airplay = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props);
+    return (jsxRuntime.jsx("div", { className: cn.cn(className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, ...iconProps, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.jsx(framerMotion.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 }), jsxRuntime.jsx(framerMotion.motion.path, { d: "M12 15l5 6H7z", variants: triangleVariants, initial: "normal", animate: controls })] }) }));
+});
+Airplay.displayName = 'Airplay';
+
+exports.Airplay = Airplay;
+//# sourceMappingURL=Airplay.js.map

package/dist/cjs/icons/a/Airplay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Airplay.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/AlarmClock.js

@@ -0,0 +1,49 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+var useAnimatedIcon = require('../../lib/use-animated-icon.js');
+
+const pathVariants = {
+    normal: {
+        y: 0,
+        x: 0,
+        transition: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+    },
+    animate: {
+        y: -1.5,
+        x: [-1, 1, -1, 1, -1, 0],
+        transition: {
+            x: { duration: 0.3, repeat: Infinity, ease: 'linear' },
+            y: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+        },
+    },
+};
+const secondaryPathVariants = {
+    normal: {
+        y: 0,
+        x: 0,
+        transition: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+    },
+    animate: {
+        y: -2.5,
+        x: [-2, 2, -2, 2, -2, 0],
+        transition: {
+            x: { duration: 0.3, repeat: Infinity, ease: 'linear' },
+            y: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+        },
+    },
+};
+const AlarmClock = React.forwardRef(({ className, size = 28, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, { cycleMs: 700 });
+    return (jsxRuntime.jsx("div", { className: cn.cn(className), ...iconProps, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M18 20.5L19.5 22" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M6 20.5L4.5 22" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, 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" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M15.339 15.862L12.549 14.197C12.063 13.909 11.667 13.216 11.667 12.649V8.95898" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "M18 2L21.747 5.31064" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "M6 2L2.25304 5.31064" })] }) }));
+});
+AlarmClock.displayName = 'AlarmClock';
+
+exports.AlarmClock = AlarmClock;
+//# sourceMappingURL=AlarmClock.js.map

package/dist/cjs/icons/a/AlarmClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlarmClock.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/AlarmClockCheck.js

@@ -0,0 +1,103 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+
+const pathVariants = {
+    normal: {
+        y: 0,
+        x: 0,
+        transition: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+    },
+    animate: {
+        y: -1.5,
+        x: [-1, 1, -1, 1, -1, 0],
+        transition: {
+            x: { duration: 0.3, repeat: Infinity, ease: 'linear' },
+            y: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+        },
+    },
+};
+const secondaryPathVariants = {
+    normal: {
+        y: 0,
+        x: 0,
+        transition: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+    },
+    animate: {
+        y: -2.5,
+        x: [-2, 2, -2, 2, -2, 0],
+        transition: {
+            x: { duration: 0.3, repeat: Infinity, ease: 'linear' },
+            y: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+        },
+    },
+};
+const AlarmClockCheck = React.forwardRef(({ className, size = 28, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = framerMotion.useAnimation();
+    const isControlledRef = React.useRef(false);
+    const timeoutRef = React.useRef(null);
+    const startAnimation = React.useCallback(() => {
+        controls.start('animate');
+    }, [controls]);
+    const stopAnimation = React.useCallback(() => {
+        controls.start('normal');
+    }, [controls]);
+    const startTimedAnimation = React.useCallback(() => {
+        startAnimation();
+        if (timeoutRef.current)
+            clearTimeout(timeoutRef.current);
+        timeoutRef.current = setTimeout(() => {
+            stopAnimation();
+        }, 700);
+    }, [startAnimation, stopAnimation]);
+    React.useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => startTimedAnimation(),
+            stopAnimation: () => stopAnimation(),
+        };
+    });
+    const handleMouseEnter = React.useCallback((e) => {
+        if (!isControlledRef.current && hoverable) {
+            if (loopOnHover) {
+                startAnimation();
+            }
+            else {
+                startTimedAnimation();
+            }
+        }
+        onMouseEnter?.(e);
+    }, [hoverable, loopOnHover, onMouseEnter, startAnimation, startTimedAnimation]);
+    const handleMouseLeave = React.useCallback((e) => {
+        if (!isControlledRef.current && hoverable && loopOnHover) {
+            stopAnimation();
+        }
+        onMouseLeave?.(e);
+    }, [hoverable, loopOnHover, onMouseLeave, stopAnimation]);
+    const handleClick = React.useCallback((e) => {
+        if (!isControlledRef.current && animateOnClick) {
+            startTimedAnimation();
+        }
+        onClick?.(e);
+    }, [animateOnClick, onClick, startTimedAnimation]);
+    React.useEffect(() => {
+        if (autoAnimateOnLoad) {
+            startTimedAnimation();
+        }
+        return () => {
+            if (timeoutRef.current)
+                clearTimeout(timeoutRef.current);
+        };
+    }, [autoAnimateOnLoad, startTimedAnimation]);
+    return (jsxRuntime.jsx("div", { className: cn.cn(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.jsx(framerMotion.motion.circle, { variants: pathVariants, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "m9 13 2 2 4-4" })] }) }));
+});
+AlarmClockCheck.displayName = 'AlarmClockCheck';
+
+exports.AlarmClockCheck = AlarmClockCheck;
+//# sourceMappingURL=AlarmClockCheck.js.map

package/dist/cjs/icons/a/AlarmClockCheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlarmClockCheck.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/AlarmClockMinus.js

@@ -0,0 +1,103 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+
+const pathVariants = {
+    normal: {
+        y: 0,
+        x: 0,
+        transition: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+    },
+    animate: {
+        y: -1.5,
+        x: [-1, 1, -1, 1, -1, 0],
+        transition: {
+            x: { duration: 0.3, repeat: Infinity, ease: 'linear' },
+            y: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+        },
+    },
+};
+const secondaryPathVariants = {
+    normal: {
+        y: 0,
+        x: 0,
+        transition: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+    },
+    animate: {
+        y: -2.5,
+        x: [-2, 2, -2, 2, -2, 0],
+        transition: {
+            x: { duration: 0.3, repeat: Infinity, ease: 'linear' },
+            y: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+        },
+    },
+};
+const AlarmClockMinus = React.forwardRef(({ className, size = 28, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = framerMotion.useAnimation();
+    const isControlledRef = React.useRef(false);
+    const timeoutRef = React.useRef(null);
+    const startAnimation = React.useCallback(() => {
+        controls.start('animate');
+    }, [controls]);
+    const stopAnimation = React.useCallback(() => {
+        controls.start('normal');
+    }, [controls]);
+    const startTimedAnimation = React.useCallback(() => {
+        startAnimation();
+        if (timeoutRef.current)
+            clearTimeout(timeoutRef.current);
+        timeoutRef.current = setTimeout(() => {
+            stopAnimation();
+        }, 700);
+    }, [startAnimation, stopAnimation]);
+    React.useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => startTimedAnimation(),
+            stopAnimation: () => stopAnimation(),
+        };
+    });
+    const handleMouseEnter = React.useCallback((e) => {
+        if (!isControlledRef.current && hoverable) {
+            if (loopOnHover) {
+                startAnimation();
+            }
+            else {
+                startTimedAnimation();
+            }
+        }
+        onMouseEnter?.(e);
+    }, [hoverable, loopOnHover, onMouseEnter, startAnimation, startTimedAnimation]);
+    const handleMouseLeave = React.useCallback((e) => {
+        if (!isControlledRef.current && hoverable && loopOnHover) {
+            stopAnimation();
+        }
+        onMouseLeave?.(e);
+    }, [hoverable, loopOnHover, onMouseLeave, stopAnimation]);
+    const handleClick = React.useCallback((e) => {
+        if (!isControlledRef.current && animateOnClick) {
+            startTimedAnimation();
+        }
+        onClick?.(e);
+    }, [animateOnClick, onClick, startTimedAnimation]);
+    React.useEffect(() => {
+        if (autoAnimateOnLoad) {
+            startTimedAnimation();
+        }
+        return () => {
+            if (timeoutRef.current)
+                clearTimeout(timeoutRef.current);
+        };
+    }, [autoAnimateOnLoad, startTimedAnimation]);
+    return (jsxRuntime.jsx("div", { className: cn.cn(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.jsx(framerMotion.motion.circle, { variants: pathVariants, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsxRuntime.jsx(framerMotion.motion.line, { variants: pathVariants, initial: "normal", animate: controls, x1: "9", y1: "13", x2: "15", y2: "13" })] }) }));
+});
+AlarmClockMinus.displayName = 'AlarmClockMinus';
+
+exports.AlarmClockMinus = AlarmClockMinus;
+//# sourceMappingURL=AlarmClockMinus.js.map

package/dist/cjs/icons/a/AlarmClockMinus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlarmClockMinus.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/AlarmClockPlus.js

@@ -0,0 +1,103 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+
+const pathVariants = {
+    normal: {
+        y: 0,
+        x: 0,
+        transition: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+    },
+    animate: {
+        y: -1.5,
+        x: [-1, 1, -1, 1, -1, 0],
+        transition: {
+            x: { duration: 0.3, repeat: Infinity, ease: 'linear' },
+            y: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+        },
+    },
+};
+const secondaryPathVariants = {
+    normal: {
+        y: 0,
+        x: 0,
+        transition: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+    },
+    animate: {
+        y: -2.5,
+        x: [-2, 2, -2, 2, -2, 0],
+        transition: {
+            x: { duration: 0.3, repeat: Infinity, ease: 'linear' },
+            y: { duration: 0.2, type: 'spring', stiffness: 200, damping: 25 },
+        },
+    },
+};
+const AlarmClockPlus = React.forwardRef(({ className, size = 28, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = framerMotion.useAnimation();
+    const isControlledRef = React.useRef(false);
+    const timeoutRef = React.useRef(null);
+    const startAnimation = React.useCallback(() => {
+        controls.start('animate');
+    }, [controls]);
+    const stopAnimation = React.useCallback(() => {
+        controls.start('normal');
+    }, [controls]);
+    const startTimedAnimation = React.useCallback(() => {
+        startAnimation();
+        if (timeoutRef.current)
+            clearTimeout(timeoutRef.current);
+        timeoutRef.current = setTimeout(() => {
+            stopAnimation();
+        }, 700);
+    }, [startAnimation, stopAnimation]);
+    React.useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => startTimedAnimation(),
+            stopAnimation: () => stopAnimation(),
+        };
+    });
+    const handleMouseEnter = React.useCallback((e) => {
+        if (!isControlledRef.current && hoverable) {
+            if (loopOnHover) {
+                startAnimation();
+            }
+            else {
+                startTimedAnimation();
+            }
+        }
+        onMouseEnter?.(e);
+    }, [hoverable, loopOnHover, onMouseEnter, startAnimation, startTimedAnimation]);
+    const handleMouseLeave = React.useCallback((e) => {
+        if (!isControlledRef.current && hoverable && loopOnHover) {
+            stopAnimation();
+        }
+        onMouseLeave?.(e);
+    }, [hoverable, loopOnHover, onMouseLeave, stopAnimation]);
+    const handleClick = React.useCallback((e) => {
+        if (!isControlledRef.current && animateOnClick) {
+            startTimedAnimation();
+        }
+        onClick?.(e);
+    }, [animateOnClick, onClick, startTimedAnimation]);
+    React.useEffect(() => {
+        if (autoAnimateOnLoad) {
+            startTimedAnimation();
+        }
+        return () => {
+            if (timeoutRef.current)
+                clearTimeout(timeoutRef.current);
+        };
+    }, [autoAnimateOnLoad, startTimedAnimation]);
+    return (jsxRuntime.jsx("div", { className: cn.cn(className), onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.jsx(framerMotion.motion.circle, { variants: pathVariants, initial: "normal", animate: controls, cx: "12", cy: "13", r: "8" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "M5 3 2 6" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: secondaryPathVariants, initial: "normal", animate: controls, d: "m22 6-3-3" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M6.38 18.7 4 21" }), jsxRuntime.jsx(framerMotion.motion.path, { variants: pathVariants, initial: "normal", animate: controls, d: "M17.64 18.67 20 21" }), jsxRuntime.jsx(framerMotion.motion.line, { variants: pathVariants, initial: "normal", animate: controls, x1: "9", y1: "13", x2: "15", y2: "13" }), jsxRuntime.jsx(framerMotion.motion.line, { variants: pathVariants, initial: "normal", animate: controls, y1: "10", x1: "12", y2: "16", x2: "12" })] }) }));
+});
+AlarmClockPlus.displayName = 'AlarmClockPlus';
+
+exports.AlarmClockPlus = AlarmClockPlus;
+//# sourceMappingURL=AlarmClockPlus.js.map

package/dist/cjs/icons/a/AlarmClockPlus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlarmClockPlus.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/Album.js

@@ -0,0 +1,57 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+var useAnimatedIcon = require('../../lib/use-animated-icon.js');
+
+const squareVariants = {
+    normal: {
+        scale: 1,
+        opacity: 1,
+        transition: { duration: 0.4 },
+    },
+    animate: {
+        scale: 1.1,
+        opacity: 0.9,
+        transition: { duration: 0.6, ease: 'easeInOut' },
+    },
+};
+const pathVariants = {
+    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.6,
+            ease: 'linear',
+            opacity: { duration: 0.1 },
+        },
+    },
+};
+const Album = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props);
+    return (jsxRuntime.jsx("div", { className: cn.cn('rounded-md', className), style: {
+            width: size,
+            height: size,
+            display: 'inline-block',
+            ...style,
+        }, ...iconProps, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.jsx(framerMotion.motion.rect, { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2", variants: squareVariants, animate: controls, initial: "normal" }), jsxRuntime.jsx(framerMotion.motion.polyline, { points: "11 3 11 11 14 8 17 11 17 3", variants: pathVariants, animate: controls, initial: "normal", style: { strokeDasharray: 1 } })] }) }));
+});
+Album.displayName = 'Album';
+
+exports.Album = Album;
+//# sourceMappingURL=Album.js.map

package/dist/cjs/icons/a/Album.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Album.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/AlignCenter.js

@@ -0,0 +1,31 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+var useAnimatedIcon = require('../../lib/use-animated-icon.js');
+
+const pathMotion = {
+    normal: {
+        translateX: 0,
+    },
+    animate: {
+        translateX: [0, 3, -3, 2, -2, 0],
+        transition: {
+            ease: 'linear',
+            duration: 1,
+        },
+    },
+};
+const AlignCenter = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props);
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, ...iconProps, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.jsx(framerMotion.motion.path, { d: "M17 12H7", variants: pathMotion, initial: "normal", animate: controls }), jsxRuntime.jsx(framerMotion.motion.path, { d: "M19 18H5", animate: controls, initial: "normal" }), jsxRuntime.jsx(framerMotion.motion.path, { d: "M21 6H3", animate: controls, initial: "normal" })] }) }));
+});
+AlignCenter.displayName = 'AlignCenter';
+
+exports.AlignCenter = AlignCenter;
+//# sourceMappingURL=AlignCenter.js.map

package/dist/cjs/icons/a/AlignCenter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlignCenter.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/icons/a/AlignCenterHorizontal.js

@@ -0,0 +1,38 @@
+'use client';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var framerMotion = require('framer-motion');
+var React = require('react');
+var cn = require('../../lib/cn.js');
+var useAnimatedIcon = require('../../lib/use-animated-icon.js');
+
+const pathVariants = {
+    normal: {
+        pathLength: 1,
+        pathOffset: 0,
+        opacity: 1,
+        transition: {
+            duration: 0.4,
+        },
+    },
+    animate: {
+        pathLength: [0, 1],
+        pathOffset: [1, 0],
+        opacity: [0, 1],
+        transition: {
+            duration: 0.7,
+            ease: 'easeInOut',
+        },
+    },
+};
+const AlignCenterHorizontal = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props);
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, ...iconProps, children: jsxRuntime.jsxs("svg", { "aria-hidden": "true", 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: [jsxRuntime.jsx(framerMotion.motion.path, { d: "M2 12h20", variants: pathVariants, animate: controls, initial: "normal" }), jsxRuntime.jsx(framerMotion.motion.path, { d: "M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4", variants: pathVariants, animate: controls, initial: "normal" }), jsxRuntime.jsx(framerMotion.motion.path, { d: "M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4", variants: pathVariants, animate: controls, initial: "normal" }), jsxRuntime.jsx(framerMotion.motion.path, { d: "M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1", variants: pathVariants, animate: controls, initial: "normal" }), jsxRuntime.jsx(framerMotion.motion.path, { d: "M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1", variants: pathVariants, animate: controls, initial: "normal" })] }) }));
+});
+AlignCenterHorizontal.displayName = 'AlignCenterHorizontal';
+
+exports.AlignCenterHorizontal = AlignCenterHorizontal;
+//# sourceMappingURL=AlignCenterHorizontal.js.map

package/dist/cjs/icons/a/AlignCenterHorizontal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlignCenterHorizontal.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}