aliveicon 1.0.32 → 1.1.0

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

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

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

@@ -0,0 +1,42 @@
+'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 RefreshCwOff = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, {
+        rest: 'visible',
+        animate: animateTarget,
+    });
+    const paths = [
+        'M21 8L18.74 5.74A9.75 9.75 0 0 0 12 3C11 3 10.03 3.16 9.13 3.47',
+        'M8 16H3v5',
+        'M3 12C3 9.51 4 7.26 5.64 5.64',
+        'M3 16l2.26 2.26A9.75 9.75 0 0 0 12 21c2.49 0 4.74-1 6.36-2.64',
+        'M21 12c0 1-.16 1.97-.47 2.87',
+        'M21 3v5h-5',
+        'M22 22L2 2',
+    ];
+    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))) }) }));
+});
+RefreshCwOff.displayName = 'RefreshCwOff';
+
+exports.RefreshCwOff = RefreshCwOff;
+//# sourceMappingURL=RefreshCwOff.js.map

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

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

package/dist/cjs/icons/r/Refrigerator.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 animateTarget = (i) => ({
+    pathLength: [0, 1],
+    opacity: [0, 1],
+    transition: {
+        duration: 0.5,
+        delay: i * 0.1,
+        ease: 'easeInOut',
+    },
+});
+const Refrigerator = React.forwardRef(({ className, size = 28, style, ...props }, ref) => {
+    const { controls, iconProps } = useAnimatedIcon.useAnimatedIcon(ref, props, {
+        rest: 'visible',
+        animate: animateTarget,
+    });
+    const paths = [
+        'M5 6a4 4 0 0 1 4-4h6a4 4 0 0 1 4 4v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6Z',
+        'M5 10h14',
+        'M15 7v6',
+    ];
+    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))) }) }));
+});
+Refrigerator.displayName = 'Refrigerator';
+
+exports.Refrigerator = Refrigerator;
+//# sourceMappingURL=Refrigerator.js.map

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

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

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

@@ -0,0 +1,83 @@
+'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 Regex = React.forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const controls = framerMotion.useAnimation();
+    const boxControls = framerMotion.useAnimation();
+    const loopRef = React.useRef(loopOnHover);
+    const isControlledRef = React.useRef(false);
+    const animate = React.useCallback(async () => {
+        await controls.start((i) => ({
+            pathLength: [0, 1],
+            opacity: [0, 1],
+            transition: {
+                duration: 0.6,
+                delay: i * 0.1,
+                ease: 'easeInOut',
+            },
+        }));
+        await boxControls.start({
+            scale: [0.8, 1],
+            opacity: [0, 1],
+            transition: { duration: 0.3 },
+        });
+        await controls.start('visible');
+        await boxControls.start('visible');
+        if (loopRef.current)
+            animate();
+    }, [controls, boxControls]);
+    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');
+                boxControls.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');
+            boxControls.start('visible');
+        }
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            animate();
+        onClick?.(e);
+    };
+    const paths = ['M17 3v10', 'M12.67 5.5l8.66 5', 'M12.67 10.5l8.66-5'];
+    const box = 'M9 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2z';
+    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("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))), jsxRuntime.jsx(framerMotion.motion.path, { d: box, initial: "visible", animate: boxControls, variants: {
+                        visible: { pathLength: 1, opacity: 1, scale: 1 },
+                    } })] }) }));
+});
+Regex.displayName = 'Regex';
+
+exports.Regex = Regex;
+//# sourceMappingURL=Regex.js.map

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

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

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

@@ -0,0 +1,71 @@
+'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 RemoveFormatting = React.forwardRef(({ size = 28, className, style, autoAnimateOnLoad = false, hoverable = true, loopOnHover = false, animateOnClick = false, onMouseEnter, onMouseLeave, onClick, ...props }, ref) => {
+    const pathControls = framerMotion.useAnimation();
+    const loopRef = React.useRef(loopOnHover);
+    const isControlledRef = React.useRef(false);
+    const animate = React.useCallback(async () => {
+        await pathControls.start((i) => ({
+            pathLength: [0, 1],
+            opacity: [0, 1],
+            transition: {
+                duration: 0.5,
+                delay: i * 0.12,
+                ease: 'easeInOut',
+            },
+        }));
+        await pathControls.start('visible');
+        if (loopRef.current)
+            animate();
+    }, [pathControls]);
+    React.useEffect(() => {
+        loopRef.current = loopOnHover;
+    }, [loopOnHover]);
+    React.useEffect(() => {
+        if (autoAnimateOnLoad)
+            animate();
+    }, [autoAnimateOnLoad, animate]);
+    React.useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: animate,
+            stopAnimation: () => {
+                pathControls.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) {
+            pathControls.start('visible');
+        }
+        onMouseLeave?.(e);
+    };
+    const handleClick = (e) => {
+        if (animateOnClick)
+            animate();
+        onClick?.(e);
+    };
+    const paths = ['M4 7V4h16v3', 'M5 20h6', 'M13 4L8 20', 'M15 15l5 5', 'M20 15l-5 5'];
+    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: paths.map((d, i) => (jsxRuntime.jsx(framerMotion.motion.path, { d: d, initial: "visible", animate: pathControls, custom: i, variants: {
+                    visible: { pathLength: 1, opacity: 1 },
+                } }, i))) }) }));
+});
+RemoveFormatting.displayName = 'RemoveFormatting';
+
+exports.RemoveFormatting = RemoveFormatting;
+//# sourceMappingURL=RemoveFormatting.js.map

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

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

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}