aliveicon 1.0.31 → 1.1.0

package/dist/cjs/icons/r/Repeat.js

@@ -0,0 +1,39 @@
+'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 animateTarget = (i) => ({
+    pathLength: [0, 1],
+    opacity: [0, 1],
+    transition: {
+        duration: 0.5,
+        delay: i * 0.1,
+        ease: 'easeInOut',
+    },
+});
+const Repeat = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, {
+        rest: 'visible',
+        animate: animateTarget,
+    });
+    const paths = [
+        'M17 2l4 4-4 4',
+        'M3 11v-1a4 4 0 0 1 4-4h14',
+        'M7 22l-4-4 4-4',
+        'M21 13v1a4 4 0 0 1-4 4H3',
+    ];
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, ...iconProps, children: jsxRuntime.jsx("svg", { "aria-hidden": "true", 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: paths.map((d, i) => (jsxRuntime.jsx(framerMotion.motion.path, { d: d, initial: "visible", animate: controls, custom: i, variants: {
+                    visible: { pathLength: 1, opacity: 1 },
+                } }, i))) }) }));
+});
+Repeat.displayName = 'Repeat';
+
+exports.Repeat = Repeat;
+//# sourceMappingURL=Repeat.js.map

package/dist/cjs/icons/r/Repeat.js.map

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

package/dist/cjs/icons/r/Repeat2.js

@@ -0,0 +1,39 @@
+'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 animateTarget = (i) => ({
+    pathLength: [0, 1],
+    opacity: [0, 1],
+    transition: {
+        duration: 0.5,
+        delay: i * 0.1,
+        ease: 'easeInOut',
+    },
+});
+const Repeat2 = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, {
+        rest: 'visible',
+        animate: animateTarget,
+    });
+    const paths = [
+        'M2 9l3-3 3 3',
+        'M13 18H7a2 2 0 0 1-2-2V6',
+        'M22 15l-3 3-3-3',
+        'M11 6h6a2 2 0 0 1 2 2v10',
+    ];
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, ...iconProps, children: jsxRuntime.jsx("svg", { "aria-hidden": "true", 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: paths.map((d, i) => (jsxRuntime.jsx(framerMotion.motion.path, { d: d, initial: "visible", animate: controls, custom: i, variants: {
+                    visible: { pathLength: 1, opacity: 1 },
+                } }, i))) }) }));
+});
+Repeat2.displayName = 'Repeat2';
+
+exports.Repeat2 = Repeat2;
+//# sourceMappingURL=Repeat2.js.map

package/dist/cjs/icons/r/Repeat2.js.map

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

package/dist/cjs/icons/r/Replace.js

@@ -0,0 +1,96 @@
+'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');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const Replace = React.forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = framerMotion.useAnimation();
+    const loopRef = React.useRef(loopOnHover);
+    const isControlledRef = React.useRef(false);
+    const animate = React.useCallback(async () => {
+        await controls.start((i) => {
+            const common = {
+                transition: {
+                    duration: 0.6,
+                    ease: 'easeInOut',
+                    delay: i * 0.05,
+                },
+            };
+            if (i <= 3) {
+                return { opacity: [0, 1], scale: [0.6, 1], ...common };
+            }
+            if (i === 4) {
+                return { pathLength: [0, 1], opacity: [0, 1], ...common };
+            }
+            if (i === 5) {
+                return { y: [-10, 0], opacity: [0, 1], ...common };
+            }
+            return { scale: [0.8, 1], opacity: [0, 1], ...common };
+        });
+        await controls.start('visible');
+        if (loopRef.current)
+            animate();
+    }, [controls]);
+    React.useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    React.useEffect(() => {
+        if (autoAnimateOnLoad)
+            animate();
+    }, [autoAnimateOnLoad, animate]);
+    React.useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: animate,
+            stopAnimation: () => controls.start('visible'),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        loopRef.current = loopOnHover;
+        if (!isControlledRef.current && hoverable)
+            animate();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        loopRef.current = false;
+        if (!isControlledRef.current && hoverable) {
+            controls.start('visible');
+        }
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            animate();
+        onClick?.(e);
+    };
+    const elements = [
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M14 4a2 2 0 0 1 2-2" }, "p1"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M16 10a2 2 0 0 1-2-2" }, "p2"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M20 2a2 2 0 0 1 2 2" }, "p3"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M22 8a2 2 0 0 1-2 2" }, "p4"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "m3 7 3 3 3-3" }, "arrow"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M6 10V5a3 3 0 0 1 3-3h1" }, "line"),
+        jsxRuntime.jsx(framerMotion.motion.rect, { x: "2", y: "14", width: "8", height: "8", rx: "2" }, "rect"),
+    ];
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxRuntime.jsx("svg", { "aria-hidden": "true", 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: elements.map((el, i) => React__default["default"].cloneElement(el, {
+                initial: 'visible',
+                animate: controls,
+                custom: i,
+                variants: {
+                    visible: { opacity: 1, scale: 1, y: 0, pathLength: 1 },
+                },
+            })) }) }));
+});
+Replace.displayName = 'Replace';
+
+exports.Replace = Replace;
+//# sourceMappingURL=Replace.js.map

package/dist/cjs/icons/r/Replace.js.map

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

package/dist/cjs/icons/r/ReplaceAll.js

@@ -0,0 +1,95 @@
+'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');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const ReplaceAll = React.forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = framerMotion.useAnimation();
+    const loopRef = React.useRef(loopOnHover);
+    const isControlledRef = React.useRef(false);
+    const animate = React.useCallback(async () => {
+        await controls.start((i) => {
+            const transition = {
+                duration: 0.6,
+                ease: 'easeInOut',
+                delay: i * 0.05,
+            };
+            if (i <= 5) {
+                return { opacity: [0, 1], scale: [0.6, 1], transition };
+            }
+            if (i === 6) {
+                return { pathLength: [0, 1], opacity: [0, 1], transition };
+            }
+            if (i === 7) {
+                return { y: [-10, 0], opacity: [0, 1], transition };
+            }
+            return { scale: [0.8, 1], opacity: [0, 1], transition };
+        });
+        await controls.start('visible');
+        if (loopRef.current)
+            animate();
+    }, [controls]);
+    React.useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    React.useEffect(() => {
+        if (autoAnimateOnLoad)
+            animate();
+    }, [autoAnimateOnLoad, animate]);
+    React.useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: animate,
+            stopAnimation: () => controls.start('visible'),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        loopRef.current = loopOnHover;
+        if (!isControlledRef.current && hoverable)
+            animate();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        loopRef.current = false;
+        if (!isControlledRef.current && hoverable)
+            controls.start('visible');
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            animate();
+        onClick?.(e);
+    };
+    const elements = [
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M14 14a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2" }, "p1"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M14 4a2 2 0 0 1 2-2" }, "p2"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M16 10a2 2 0 0 1-2-2" }, "p3"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M20 14a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2" }, "p4"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M20 2a2 2 0 0 1 2 2" }, "p5"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M22 8a2 2 0 0 1-2 2" }, "p6"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "m3 7 3 3 3-3" }, "arrow"),
+        jsxRuntime.jsx(framerMotion.motion.path, { d: "M6 10V5a3 3 0 0 1 3-3h1" }, "line"),
+        jsxRuntime.jsx(framerMotion.motion.rect, { x: "2", y: "14", width: "8", height: "8", rx: "2" }, "rect"),
+    ];
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxRuntime.jsx("svg", { "aria-hidden": "true", 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: elements.map((el, i) => React__default["default"].cloneElement(el, {
+                initial: 'visible',
+                animate: controls,
+                custom: i,
+                variants: {
+                    visible: { opacity: 1, scale: 1, y: 0, pathLength: 1 },
+                },
+            })) }) }));
+});
+ReplaceAll.displayName = 'ReplaceAll';
+
+exports.ReplaceAll = ReplaceAll;
+//# sourceMappingURL=ReplaceAll.js.map

package/dist/cjs/icons/r/ReplaceAll.js.map

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

package/dist/cjs/icons/r/Reply.js

@@ -0,0 +1,34 @@
+'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 animateTarget = (i) => {
+    return {
+        pathLength: [0, 1],
+        opacity: [0, 1],
+        transition: {
+            duration: 0.6,
+            delay: i * 0.1,
+            ease: 'easeInOut',
+        },
+    };
+};
+const Reply = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, {
+        rest: 'visible',
+        animate: animateTarget,
+    });
+    const paths = ['M20 18v-2a4 4 0 0 0-4-4H4', 'M9 17l-5-5 5-5'];
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, ...iconProps, children: jsxRuntime.jsx("svg", { "aria-hidden": "true", 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: paths.map((d, i) => (jsxRuntime.jsx(framerMotion.motion.path, { d: d, initial: "visible", animate: controls, custom: i, variants: { visible: { pathLength: 1, opacity: 1 } } }, i))) }) }));
+});
+Reply.displayName = 'Reply';
+
+exports.Reply = Reply;
+//# sourceMappingURL=Reply.js.map

package/dist/cjs/icons/r/Reply.js.map

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

package/dist/cjs/icons/r/ReplyAll.js

@@ -0,0 +1,34 @@
+'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 animateTarget = (i) => ({
+    pathLength: [0, 1],
+    opacity: [0, 1],
+    transition: {
+        duration: 0.5,
+        delay: i * 0.1,
+        ease: 'easeInOut',
+    },
+});
+const ReplyAll = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, {
+        rest: 'visible',
+        animate: animateTarget,
+    });
+    const paths = ['M12 17l-5-5 5-5', 'M22 18v-2a4 4 0 0 0-4-4H7', 'M7 17l-5-5 5-5'];
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, ...iconProps, children: jsxRuntime.jsx("svg", { "aria-hidden": "true", 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: paths.map((d, i) => (jsxRuntime.jsx(framerMotion.motion.path, { d: d, initial: "visible", animate: controls, custom: i, variants: {
+                    visible: { pathLength: 1, opacity: 1 },
+                } }, i))) }) }));
+});
+ReplyAll.displayName = 'ReplyAll';
+
+exports.ReplyAll = ReplyAll;
+//# sourceMappingURL=ReplyAll.js.map

package/dist/cjs/icons/r/ReplyAll.js.map

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

package/dist/cjs/icons/r/Rewind.js

@@ -0,0 +1,32 @@
+'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 animateTarget = (i) => ({
+    pathLength: [0, 1],
+    opacity: [0, 1],
+    transition: {
+        duration: 0.5,
+        delay: i * 0.1,
+        ease: 'easeInOut',
+    },
+});
+const Rewind = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, {
+        rest: 'visible',
+        animate: animateTarget,
+    });
+    const polygons = ['M11 19L2 12L11 5V19Z', 'M22 19L13 12L22 5V19Z'];
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, ...iconProps, children: jsxRuntime.jsx("svg", { "aria-hidden": "true", 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: polygons.map((d, i) => (jsxRuntime.jsx(framerMotion.motion.path, { d: d, initial: "visible", animate: controls, custom: i, variants: { visible: { pathLength: 1, opacity: 1 } } }, i))) }) }));
+});
+Rewind.displayName = 'Rewind';
+
+exports.Rewind = Rewind;
+//# sourceMappingURL=Rewind.js.map

package/dist/cjs/icons/r/Rewind.js.map

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

package/dist/cjs/icons/r/Ribbon.js

@@ -0,0 +1,40 @@
+'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 animateTarget = (i) => ({
+    pathLength: [0, 1],
+    opacity: [0, 1],
+    transition: {
+        duration: 0.6,
+        delay: i * 0.1,
+        ease: 'easeInOut',
+    },
+});
+const Ribbon = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, {
+        rest: 'visible',
+        animate: animateTarget,
+    });
+    const paths = [
+        'M12 11.22C11 9.997 10 9 10 8a2 2 0 0 1 4 0c0 1-.998 2.002-2.01 3.22',
+        'm12 18 2.57-3.5',
+        'M6.243 9.016a7 7 0 0 1 11.507-.009',
+        'M9.35 14.53 12 11.22',
+        'M9.35 14.53C7.728 12.246 6 10.221 6 7a6 5 0 0 1 12 0c-.005 3.22-1.778 5.235-3.43 7.5l3.557 4.527a1 1 0 0 1-.203 1.43l-1.894 1.36a1 1 0 0 1-1.384-.215L12 18l-2.679 3.593a1 1 0 0 1-1.39.213l-1.865-1.353a1 1 0 0 1-.203-1.422z',
+    ];
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, ...iconProps, children: jsxRuntime.jsx("svg", { "aria-hidden": "true", 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: paths.map((d, i) => (jsxRuntime.jsx(framerMotion.motion.path, { d: d, initial: "visible", animate: controls, custom: i, variants: {
+                    visible: { pathLength: 1, opacity: 1 },
+                } }, i))) }) }));
+});
+Ribbon.displayName = 'Ribbon';
+
+exports.Ribbon = Ribbon;
+//# sourceMappingURL=Ribbon.js.map

package/dist/cjs/icons/r/Ribbon.js.map

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

package/dist/cjs/icons/r/Rocket.js

@@ -0,0 +1,85 @@
+'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 Rocket = React.forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = framerMotion.useAnimation();
+    const fireControls = framerMotion.useAnimation();
+    const loopRef = React.useRef(loopOnHover);
+    const isControlledRef = React.useRef(false);
+    const animate = React.useCallback(async () => {
+        controls.start({
+            x: [0, 0, -3, 2, -2, 1, -1, 0],
+            y: [0, -3, 0, -2, -3, -1, -2, 0],
+            transition: {
+                duration: 6,
+                ease: 'easeInOut',
+                repeat: Infinity,
+                repeatType: 'reverse',
+                times: [0, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1],
+            },
+        });
+        fireControls.start({
+            d: [
+                'M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z',
+                'M4.5 16.5c-1.5 1.26-3 5.5-3 5.5s4.74-1 6-2.5c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z',
+                'M4.5 16.5c-1.5 1.26-2.2 4.8-2.2 4.8s3.94-0.3 5.2-1.8c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z',
+                'M4.5 16.5c-1.5 1.26-2.8 5.2-2.8 5.2s4.54-0.7 5.8-2.2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z',
+                'M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z',
+            ],
+            transition: {
+                duration: 2,
+                ease: [0.4, 0, 0.2, 1],
+                repeat: Infinity,
+                times: [0, 0.2, 0.5, 0.8, 1],
+            },
+        });
+    }, [controls, fireControls]);
+    React.useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    React.useEffect(() => {
+        if (autoAnimateOnLoad)
+            animate();
+    }, [autoAnimateOnLoad, animate]);
+    React.useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: animate,
+            stopAnimation: () => {
+                controls.stop();
+                fireControls.stop();
+            },
+        };
+    });
+    const handleMouseEnter = (e) => {
+        loopRef.current = loopOnHover;
+        if (!isControlledRef.current && hoverable)
+            animate();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        loopRef.current = false;
+        if (!isControlledRef.current && hoverable) {
+            controls.stop();
+            fireControls.stop();
+        }
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            animate();
+        onClick?.(e);
+    };
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size, ...style }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxRuntime.jsxs(framerMotion.motion.svg, { "aria-hidden": "true", 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, children: [jsxRuntime.jsx(framerMotion.motion.path, { d: "M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z", animate: fireControls }), jsxRuntime.jsx("path", { d: "m12 15-3-3a22 22 0 0 1 2-3.95A12.88 12.88 0 0 1 22 2c0 2.72-.78 7.5-6 11a22.35 22.35 0 0 1-4 2z" }), jsxRuntime.jsx("path", { d: "M9 12H4s.55-3.03 2-4c1.62-1.08 5 0 5 0" }), jsxRuntime.jsx("path", { d: "M12 15v5s3.03-.55 4-2c1.08-1.62 0-5 0-5" })] }) }));
+});
+Rocket.displayName = 'Rocket';
+
+exports.Rocket = Rocket;
+//# sourceMappingURL=Rocket.js.map

package/dist/cjs/icons/r/Rocket.js.map

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

package/dist/cjs/icons/r/RockingChair.js

@@ -0,0 +1,68 @@
+'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 rockingVariants = {
+    normal: { rotate: 0 },
+    animate: {
+        rotate: [-2, 2, -1.5, 1.5, -1, 1, -0.5, 0],
+        transition: {
+            duration: 2,
+            repeat: Infinity,
+            ease: 'easeInOut',
+            times: [0, 0.15, 0.3, 0.45, 0.6, 0.75, 0.9, 1],
+        },
+    },
+};
+const RockingChair = React.forwardRef(({ className, size = 28, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = framerMotion.useAnimation();
+    const loopRef = React.useRef(loopOnHover);
+    const isControlledRef = React.useRef(false);
+    const animate = React.useCallback(async () => {
+        await controls.start('animate');
+        if (loopRef.current)
+            animate();
+    }, [controls]);
+    React.useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    React.useEffect(() => {
+        if (autoAnimateOnLoad)
+            animate();
+    }, [autoAnimateOnLoad, animate]);
+    React.useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: animate,
+            stopAnimation: () => controls.start('normal'),
+        };
+    });
+    const handleMouseEnter = (e) => {
+        loopRef.current = loopOnHover;
+        if (!isControlledRef.current && hoverable)
+            animate();
+        onMouseEnter?.(e);
+    };
+    const handleMouseLeave = (e) => {
+        loopRef.current = false;
+        if (!isControlledRef.current && hoverable)
+            controls.start('normal');
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            animate();
+        onClick?.(e);
+    };
+    return (jsxRuntime.jsx("div", { className: cn.cn('inline-block', className), style: { width: size, height: size }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: handleClick, ...props, children: jsxRuntime.jsxs(framerMotion.motion.svg, { "aria-hidden": "true", 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", variants: rockingVariants, initial: "normal", animate: controls, children: [jsxRuntime.jsx("polyline", { points: "3.5 2 6.5 12.5 18 12.5" }), jsxRuntime.jsx("line", { x1: "9.5", y1: "12.5", x2: "5.5", y2: "20" }), jsxRuntime.jsx("line", { x1: "15", y1: "12.5", x2: "18.5", y2: "20" }), jsxRuntime.jsx("path", { d: "M2.75 18a13 13 0 0 0 18.5 0" })] }) }));
+});
+RockingChair.displayName = 'RockingChair';
+
+exports.RockingChair = RockingChair;
+//# sourceMappingURL=RockingChair.js.map

package/dist/cjs/icons/r/RockingChair.js.map

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