@animicons/react-native 0.1.1

package/dist/index.esm.js

@@ -0,0 +1,739 @@
+import React6, { useEffect, useCallback } from 'react';
+import { Circle, Path, Svg } from 'react-native-svg';
+import Animated4, { useAnimatedProps, useSharedValue, withRepeat, withTiming, Easing, withDelay, runOnJS, cancelAnimation, useAnimatedStyle, withSequence } from 'react-native-reanimated';
+import { DURATION, PulsePaths, CheckPaths, LoaderPaths, UploadPaths, WifiPaths, BellPaths, StarPaths, HeartPaths, ECGPaths, HeartRatePaths, LungsPaths, PillPaths, ThermometerPaths, DNAPaths, SyringePaths, BrainPaths, BloodDropPaths, StepsPaths, SleepPaths, OxygenPaths, MedkitPaths } from '@animicons/shared';
+import { Pressable } from 'react-native';
+
+// src/icons/ui/Pulse.tsx
+
+// src/utils/resolveStyle.ts
+function resolveStyle(props, defaults) {
+  const base = props.color ?? defaults.defaultColor;
+  return {
+    stroke: props.strokeColor ?? base,
+    fill: props.fillColor ?? base,
+    secondaryColor: props.secondaryColor ?? `${base}33`,
+    opacity: props.opacity ?? 1,
+    strokeWidth: props.strokeWidth ?? defaults.defaultStrokeWidth
+  };
+}
+function getAnimDuration(speed = "normal") {
+  return DURATION[speed];
+}
+
+// src/icons/ui/Pulse.tsx
+var AnimatedCircle = Animated4.createAnimatedComponent(Circle);
+function usePulseRing(stagger, duration, autoPlay, loop) {
+  const r = useSharedValue(4);
+  const opacity = useSharedValue(0.8);
+  useEffect(() => {
+    if (autoPlay) {
+      r.value = withDelay(stagger, withRepeat(withTiming(20, { duration, easing: Easing.out(Easing.ease) }), loop ? -1 : 1));
+      opacity.value = withDelay(stagger, withRepeat(withTiming(0, { duration, easing: Easing.out(Easing.ease) }), loop ? -1 : 1));
+    } else {
+      cancelAnimation(r);
+      cancelAnimation(opacity);
+    }
+    return () => {
+      cancelAnimation(r);
+      cancelAnimation(opacity);
+    };
+  }, [autoPlay, loop, duration, stagger]);
+  return { r, opacity };
+}
+var Pulse = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, PulsePaths);
+  const ring1 = usePulseRing(0, d.medium, autoPlay, loop);
+  const ring2 = usePulseRing(d.stagger, d.medium, autoPlay, loop);
+  const ring3 = usePulseRing(d.stagger * 2, d.medium, autoPlay, loop);
+  const ap1 = useAnimatedProps(() => ({ r: ring1.r.value, opacity: ring1.opacity.value }));
+  const ap2 = useAnimatedProps(() => ({ r: ring2.r.value, opacity: ring2.opacity.value }));
+  const ap3 = useAnimatedProps(() => ({ r: ring3.r.value, opacity: ring3.opacity.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: PulsePaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedCircle, { animatedProps: ap1, cx: "24", cy: "24", stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none" }), /* @__PURE__ */ React6.createElement(AnimatedCircle, { animatedProps: ap2, cx: "24", cy: "24", stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none" }), /* @__PURE__ */ React6.createElement(AnimatedCircle, { animatedProps: ap3, cx: "24", cy: "24", stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none" }), /* @__PURE__ */ React6.createElement(Circle, { cx: "24", cy: "24", r: 3, fill: s.stroke, opacity: s.opacity }));
+};
+var AnimatedPath = Animated4.createAnimatedComponent(Path);
+var Check = ({
+  size = 48,
+  autoPlay = true,
+  loop = false,
+  speed = "normal",
+  onAnimationEnd,
+  style,
+  ...colorProps
+}) => {
+  const circleProgress = useSharedValue(126);
+  const checkProgress = useSharedValue(30);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, CheckPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      if (loop) {
+        circleProgress.value = withRepeat(withTiming(0, { duration: d.short, easing: Easing.ease }), -1);
+        checkProgress.value = withRepeat(withDelay(d.short * 0.6, withTiming(0, { duration: d.short * 0.6, easing: Easing.ease })), -1);
+      } else {
+        circleProgress.value = withTiming(0, { duration: d.short, easing: Easing.ease });
+        checkProgress.value = withDelay(d.short * 0.6, withTiming(0, { duration: d.short * 0.6, easing: Easing.ease }, () => {
+          if (onAnimationEnd) runOnJS(onAnimationEnd)();
+        }));
+      }
+    } else {
+      cancelAnimation(circleProgress);
+      cancelAnimation(checkProgress);
+    }
+  }, [autoPlay, loop, speed]);
+  const circleProps = useAnimatedProps(() => ({ strokeDashoffset: circleProgress.value }));
+  const checkProps = useAnimatedProps(() => ({ strokeDashoffset: checkProgress.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: CheckPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedPath, { animatedProps: circleProps, d: CheckPaths.circle, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeDasharray: 126, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath, { animatedProps: checkProps, d: CheckPaths.check, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeDasharray: 30, strokeLinecap: "round", opacity: s.opacity }));
+};
+var AnimatedPath2 = Animated4.createAnimatedComponent(Path);
+var Loader = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  onAnimationEnd,
+  style,
+  ...colorProps
+}) => {
+  const rotation = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, LoaderPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      rotation.value = withRepeat(
+        withTiming(360, { duration: d.medium, easing: Easing.linear }),
+        loop ? -1 : 1,
+        false,
+        () => {
+          if (onAnimationEnd) runOnJS(onAnimationEnd)();
+        }
+      );
+    } else {
+      cancelAnimation(rotation);
+    }
+    return () => {
+      cancelAnimation(rotation);
+    };
+  }, [autoPlay, loop, speed, onAnimationEnd]);
+  const animatedProps = useAnimatedProps(() => ({
+    transform: [{ rotate: `${rotation.value}deg` }],
+    originX: 24,
+    originY: 24
+  }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: LoaderPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(
+    AnimatedPath2,
+    {
+      animatedProps,
+      d: LoaderPaths.arc,
+      stroke: s.stroke,
+      strokeWidth: s.strokeWidth,
+      strokeLinecap: "round",
+      fill: "none",
+      opacity: s.opacity
+    }
+  ));
+};
+var AnimatedPath3 = Animated4.createAnimatedComponent(Path);
+var Upload = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const translateY = useSharedValue(0);
+  const barDash = useSharedValue(28);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, UploadPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      translateY.value = withRepeat(
+        withTiming(-6, { duration: d.short, easing: Easing.inOut(Easing.ease) }),
+        loop ? -1 : 1,
+        true
+      );
+      barDash.value = withRepeat(
+        withTiming(0, { duration: d.medium, easing: Easing.inOut(Easing.ease) }),
+        loop ? -1 : 1,
+        true
+      );
+    } else {
+      cancelAnimation(translateY);
+      cancelAnimation(barDash);
+    }
+  }, [autoPlay, loop, speed]);
+  const arrowStyle = useAnimatedStyle(() => ({ transform: [{ translateY: translateY.value }] }));
+  const barProps = useAnimatedProps(() => ({ strokeDashoffset: barDash.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: UploadPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Animated4.View, { style: arrowStyle }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: UploadPaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Path, { d: UploadPaths.arrow, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round", strokeLinejoin: "round", opacity: s.opacity }))), /* @__PURE__ */ React6.createElement(AnimatedPath3, { animatedProps: barProps, d: UploadPaths.bar, stroke: s.stroke, strokeWidth: s.strokeWidth, strokeLinecap: "round", fill: "none", strokeDasharray: 28, opacity: s.opacity }));
+};
+var AnimatedPath4 = Animated4.createAnimatedComponent(Path);
+var Wifi = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const op1 = useSharedValue(0);
+  const op2 = useSharedValue(0);
+  const op3 = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, WifiPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      const anim = (sv, delay) => {
+        sv.value = withDelay(delay, withRepeat(
+          withTiming(1, { duration: d.medium, easing: Easing.inOut(Easing.ease) }),
+          loop ? -1 : 1,
+          true
+        ));
+      };
+      anim(op1, 0);
+      anim(op2, d.stagger);
+      anim(op3, d.stagger * 2);
+    } else {
+      cancelAnimation(op1);
+      cancelAnimation(op2);
+      cancelAnimation(op3);
+    }
+    return () => {
+      cancelAnimation(op1);
+      cancelAnimation(op2);
+      cancelAnimation(op3);
+    };
+  }, [autoPlay, loop, speed]);
+  const ap1 = useAnimatedProps(() => ({ opacity: op1.value }));
+  const ap2 = useAnimatedProps(() => ({ opacity: op2.value }));
+  const ap3 = useAnimatedProps(() => ({ opacity: op3.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: WifiPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedPath4, { animatedProps: ap1, d: WifiPaths.arc1, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round" }), /* @__PURE__ */ React6.createElement(AnimatedPath4, { animatedProps: ap2, d: WifiPaths.arc2, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round" }), /* @__PURE__ */ React6.createElement(AnimatedPath4, { animatedProps: ap3, d: WifiPaths.arc3, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round" }), /* @__PURE__ */ React6.createElement(Circle, { cx: "24", cy: "40", r: 2, fill: s.stroke, opacity: s.opacity }));
+};
+var Bell = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const rotation = useSharedValue(0);
+  const badgeScale = useSharedValue(1);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, BellPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      rotation.value = withRepeat(
+        withSequence(
+          withTiming(15, { duration: d.long * 0.2 }),
+          withTiming(-15, { duration: d.long * 0.2 }),
+          withTiming(8, { duration: d.long * 0.2 }),
+          withTiming(-8, { duration: d.long * 0.2 }),
+          withTiming(0, { duration: d.long * 0.2 })
+        ),
+        loop ? -1 : 1
+      );
+      badgeScale.value = withRepeat(
+        withSequence(withTiming(1.3, { duration: d.long * 0.3 }), withTiming(1, { duration: d.long * 0.7 })),
+        loop ? -1 : 1
+      );
+    } else {
+      cancelAnimation(rotation);
+      cancelAnimation(badgeScale);
+    }
+  }, [autoPlay, loop, speed]);
+  const bellStyle = useAnimatedStyle(() => ({ transform: [{ rotate: `${rotation.value}deg` }] }));
+  const badgeStyle = useAnimatedStyle(() => ({ transform: [{ scale: badgeScale.value }] }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: BellPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Animated4.View, { style: [{ position: "absolute" }, bellStyle] }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: BellPaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Path, { d: BellPaths.bell, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Path, { d: BellPaths.clapper, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Path, { d: BellPaths.handle, stroke: s.stroke, strokeWidth: s.strokeWidth, strokeLinecap: "round", fill: "none", opacity: s.opacity }))), /* @__PURE__ */ React6.createElement(Animated4.View, { style: [{ position: "absolute" }, badgeStyle] }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: BellPaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Circle, { cx: "34", cy: "12", r: 5, fill: s.stroke, opacity: s.opacity }))));
+};
+var AnimatedPath5 = Animated4.createAnimatedComponent(Path);
+var Star = ({
+  size = 48,
+  autoPlay = true,
+  speed = "normal",
+  onAnimationEnd,
+  style,
+  ...colorProps
+}) => {
+  const scaleVal = useSharedValue(1);
+  const sparkleOp = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, StarPaths);
+  const trigger = useCallback(() => {
+    scaleVal.value = withTiming(1.3, { duration: d.short * 0.5 }, () => {
+      scaleVal.value = withTiming(1, { duration: d.short * 0.5 }, () => {
+        if (onAnimationEnd) runOnJS(onAnimationEnd)();
+      });
+    });
+    sparkleOp.value = withTiming(1, { duration: d.short * 0.5 }, () => {
+      sparkleOp.value = withTiming(0, { duration: d.short * 0.5 });
+    });
+  }, [onAnimationEnd, d.short, scaleVal, sparkleOp]);
+  useEffect(() => {
+    if (autoPlay) trigger();
+    return () => {
+      cancelAnimation(scaleVal);
+      cancelAnimation(sparkleOp);
+    };
+  }, [autoPlay, trigger]);
+  const starProps = useAnimatedProps(() => ({ transform: [{ scale: scaleVal.value }], originX: 24, originY: 24 }));
+  const sparkleProps = useAnimatedProps(() => ({ opacity: sparkleOp.value }));
+  return /* @__PURE__ */ React6.createElement(Pressable, { onPress: trigger, style }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: StarPaths.viewBox }, /* @__PURE__ */ React6.createElement(AnimatedPath5, { animatedProps: starProps, d: StarPaths.star, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath5, { animatedProps: sparkleProps, d: StarPaths.sparkle1, fill: s.stroke, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath5, { animatedProps: sparkleProps, d: StarPaths.sparkle2, fill: s.stroke, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath5, { animatedProps: sparkleProps, d: StarPaths.sparkle3, fill: s.stroke, opacity: s.opacity })));
+};
+var AnimatedPath6 = Animated4.createAnimatedComponent(Path);
+var Heart = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const scaleVal = useSharedValue(1);
+  const glowOp = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, HeartPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      const beat = withSequence(
+        withTiming(1.2, { duration: d.short * 0.35, easing: Easing.out(Easing.ease) }),
+        withTiming(1, { duration: d.short * 0.35 }),
+        withTiming(1.15, { duration: d.short * 0.3 }),
+        withTiming(1, { duration: d.medium - d.short })
+      );
+      scaleVal.value = withRepeat(beat, loop ? -1 : 1);
+      glowOp.value = withRepeat(
+        withSequence(
+          withTiming(0.4, { duration: d.short * 0.35 }),
+          withTiming(0, { duration: d.medium - d.short * 0.35 })
+        ),
+        loop ? -1 : 1
+      );
+    } else {
+      cancelAnimation(scaleVal);
+      cancelAnimation(glowOp);
+    }
+  }, [autoPlay, loop, speed]);
+  const heartStyle = useAnimatedStyle(() => ({ transform: [{ scale: scaleVal.value }] }));
+  const glowProps = useAnimatedProps(() => ({ opacity: glowOp.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: HeartPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedPath6, { animatedProps: glowProps, d: HeartPaths.glow, fill: s.secondaryColor, stroke: "none" }), /* @__PURE__ */ React6.createElement(Animated4.View, { style: [{ position: "absolute" }, heartStyle] }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: HeartPaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Path, { d: HeartPaths.heart, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.fill, opacity: s.opacity }))));
+};
+var AnimatedPath7 = Animated4.createAnimatedComponent(Path);
+var ECG = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  onAnimationEnd,
+  style,
+  ...colorProps
+}) => {
+  const dashOffset = useSharedValue(100);
+  const opacity = useSharedValue(1);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, ECGPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      dashOffset.value = withRepeat(
+        withTiming(0, { duration: d.long * 0.7, easing: Easing.inOut(Easing.ease) }),
+        loop ? -1 : 1,
+        false,
+        () => {
+          if (!loop && onAnimationEnd) runOnJS(onAnimationEnd)();
+        }
+      );
+      opacity.value = withRepeat(withTiming(0, { duration: d.long * 0.3, easing: Easing.ease }), loop ? -1 : 1);
+    } else {
+      cancelAnimation(dashOffset);
+      cancelAnimation(opacity);
+    }
+  }, [autoPlay, loop, speed, onAnimationEnd]);
+  const animProps = useAnimatedProps(() => ({ strokeDashoffset: dashOffset.value, opacity: opacity.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: ECGPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedPath7, { animatedProps: animProps, d: ECGPaths.line, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round", strokeLinejoin: "round", strokeDasharray: 100 }));
+};
+var AnimatedPath8 = Animated4.createAnimatedComponent(Path);
+var AnimatedCircle2 = Animated4.createAnimatedComponent(Circle);
+var HeartRate = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  onAnimationEnd,
+  style,
+  ...colorProps
+}) => {
+  const scaleVal = useSharedValue(1);
+  const glowR = useSharedValue(16);
+  const glowOp = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, HeartRatePaths);
+  useEffect(() => {
+    if (autoPlay) {
+      scaleVal.value = withRepeat(
+        withSequence(withTiming(1.2, { duration: d.medium * 0.2 }), withTiming(1, { duration: d.medium * 0.8 })),
+        loop ? -1 : 1,
+        false,
+        () => {
+          if (!loop && onAnimationEnd) runOnJS(onAnimationEnd)();
+        }
+      );
+      glowR.value = withRepeat(
+        withSequence(withTiming(20, { duration: d.medium * 0.2 }), withTiming(16, { duration: d.medium * 0.8 })),
+        loop ? -1 : 1
+      );
+      glowOp.value = withRepeat(
+        withSequence(withTiming(0.5, { duration: d.medium * 0.2 }), withTiming(0, { duration: d.medium * 0.8 })),
+        loop ? -1 : 1
+      );
+    } else {
+      cancelAnimation(scaleVal);
+      cancelAnimation(glowR);
+      cancelAnimation(glowOp);
+    }
+  }, [autoPlay, loop, speed, onAnimationEnd]);
+  const heartProps = useAnimatedProps(() => ({ transform: [{ scale: scaleVal.value }], originX: 24, originY: 24 }));
+  const glowProps = useAnimatedProps(() => ({ r: glowR.value, opacity: glowOp.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: HeartRatePaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedCircle2, { animatedProps: glowProps, cx: "24", cy: "24", fill: s.secondaryColor }), /* @__PURE__ */ React6.createElement(AnimatedPath8, { animatedProps: heartProps, d: HeartRatePaths.heart, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.fill, opacity: s.opacity }));
+};
+var AnimatedPath9 = Animated4.createAnimatedComponent(Path);
+var Lungs = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const scaleL = useSharedValue(1);
+  const scaleR = useSharedValue(1);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, LungsPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      scaleL.value = withRepeat(withTiming(1.08, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+      scaleR.value = withRepeat(withTiming(1.08, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+    } else {
+      cancelAnimation(scaleL);
+      cancelAnimation(scaleR);
+    }
+  }, [autoPlay, loop, speed]);
+  const leftProps = useAnimatedProps(() => ({ transform: [{ scaleX: scaleL.value }, { scaleY: scaleL.value }], originX: 16, originY: 26 }));
+  const rightProps = useAnimatedProps(() => ({ transform: [{ scaleX: scaleR.value }, { scaleY: scaleR.value }], originX: 32, originY: 26 }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: LungsPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedPath9, { animatedProps: leftProps, d: LungsPaths.leftLobe, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, strokeLinecap: "round", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath9, { animatedProps: rightProps, d: LungsPaths.rightLobe, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, strokeLinecap: "round", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Path, { d: LungsPaths.trunk, stroke: s.stroke, strokeWidth: s.strokeWidth, strokeLinecap: "round", fill: "none", opacity: s.opacity }));
+};
+var AnimatedPath10 = Animated4.createAnimatedComponent(Path);
+var Pill = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const translateY = useSharedValue(0);
+  const shineOp = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, PillPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      translateY.value = withRepeat(withTiming(-5, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+      shineOp.value = withRepeat(withTiming(0.8, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+    } else {
+      cancelAnimation(translateY);
+      cancelAnimation(shineOp);
+    }
+  }, [autoPlay, loop, speed]);
+  const bodyStyle = useAnimatedStyle(() => ({ transform: [{ translateY: translateY.value }] }));
+  const shineProps = useAnimatedProps(() => ({ opacity: shineOp.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: PillPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Animated4.View, { style: [{ position: "absolute" }, bodyStyle] }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: PillPaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Path, { d: PillPaths.capsule, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Path, { d: PillPaths.divider, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", opacity: s.opacity }))), /* @__PURE__ */ React6.createElement(AnimatedPath10, { animatedProps: shineProps, d: PillPaths.shine, stroke: "white", strokeWidth: 2, fill: "none", strokeLinecap: "round" }));
+};
+var AnimatedPath11 = Animated4.createAnimatedComponent(Path);
+var Thermometer = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const mercuryScale = useSharedValue(0.2);
+  const tubeRotation = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, ThermometerPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      mercuryScale.value = withRepeat(withTiming(1, { duration: d.long * 0.7, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+      tubeRotation.value = withRepeat(
+        withSequence(
+          withTiming(0, { duration: d.long * 0.6 }),
+          withTiming(3, { duration: d.long * 0.1 }),
+          withTiming(-3, { duration: d.long * 0.1 }),
+          withTiming(2, { duration: d.long * 0.1 }),
+          withTiming(0, { duration: d.long * 0.1 })
+        ),
+        loop ? -1 : 1
+      );
+    } else {
+      cancelAnimation(mercuryScale);
+      cancelAnimation(tubeRotation);
+    }
+  }, [autoPlay, loop, speed]);
+  const mercuryProps = useAnimatedProps(() => ({ transform: [{ scaleY: mercuryScale.value }], originY: 34 }));
+  const tubeStyle = useAnimatedStyle(() => ({ transform: [{ rotate: `${tubeRotation.value}deg` }] }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: ThermometerPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Animated4.View, { style: [{ position: "absolute" }, tubeStyle] }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: ThermometerPaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Path, { d: ThermometerPaths.tube, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, opacity: s.opacity }))), /* @__PURE__ */ React6.createElement(AnimatedPath11, { animatedProps: mercuryProps, d: ThermometerPaths.mercury, fill: s.fill, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Circle, { cx: "24", cy: "40", r: 5, fill: s.fill, opacity: s.opacity }));
+};
+var AnimatedPath12 = Animated4.createAnimatedComponent(Path);
+var DNA = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const translateY = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, DNAPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      translateY.value = withRepeat(withTiming(-16, { duration: d.medium, easing: Easing.linear }), loop ? -1 : 1, true);
+    } else {
+      cancelAnimation(translateY);
+    }
+  }, [autoPlay, loop, speed]);
+  const animProps = useAnimatedProps(() => ({ transform: [{ translateY: translateY.value }] }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: DNAPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedPath12, { animatedProps: animProps, d: DNAPaths.strand1, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath12, { animatedProps: animProps, d: DNAPaths.strand2, stroke: s.secondaryColor, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath12, { animatedProps: animProps, d: `${DNAPaths.rung1} ${DNAPaths.rung2} ${DNAPaths.rung3}`, stroke: s.stroke, strokeWidth: 1.5, fill: "none", strokeLinecap: "round", opacity: s.opacity * 0.6 }));
+};
+var AnimatedPath13 = Animated4.createAnimatedComponent(Path);
+var Syringe = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const plungerX = useSharedValue(0);
+  const liquidScale = useSharedValue(1);
+  const dropOp = useSharedValue(0);
+  const dropY = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, SyringePaths);
+  useEffect(() => {
+    if (autoPlay) {
+      plungerX.value = withRepeat(withSequence(withTiming(8, { duration: d.long * 0.5 }), withTiming(0, { duration: d.long * 0.5 })), loop ? -1 : 1);
+      liquidScale.value = withRepeat(withSequence(withTiming(0.3, { duration: d.long * 0.5 }), withTiming(1, { duration: d.long * 0.5 })), loop ? -1 : 1);
+      dropOp.value = withRepeat(withSequence(withTiming(0, { duration: d.long * 0.49 }), withTiming(1, { duration: d.long * 0.01 }), withTiming(0, { duration: d.long * 0.5 })), loop ? -1 : 1);
+      dropY.value = withRepeat(withSequence(withTiming(0, { duration: d.long * 0.5 }), withTiming(6, { duration: d.long * 0.5 })), loop ? -1 : 1);
+    } else {
+      cancelAnimation(plungerX);
+      cancelAnimation(liquidScale);
+      cancelAnimation(dropOp);
+      cancelAnimation(dropY);
+    }
+  }, [autoPlay, loop, speed]);
+  const plungerStyle = useAnimatedStyle(() => ({ transform: [{ translateX: plungerX.value }] }));
+  const liquidProps = useAnimatedProps(() => ({ transform: [{ scaleX: liquidScale.value }], originX: 14 }));
+  const dropProps = useAnimatedProps(() => ({ opacity: dropOp.value, transform: [{ translateY: dropY.value }] }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: SyringePaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Path, { d: SyringePaths.barrel, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath13, { animatedProps: liquidProps, d: SyringePaths.liquid, fill: s.fill, opacity: s.opacity * 0.7 }), /* @__PURE__ */ React6.createElement(Animated4.View, { style: [{ position: "absolute" }, plungerStyle] }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: SyringePaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Path, { d: SyringePaths.plunger, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round", opacity: s.opacity }))), /* @__PURE__ */ React6.createElement(Path, { d: SyringePaths.needle, stroke: s.stroke, strokeWidth: s.strokeWidth, strokeLinecap: "round", fill: "none", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath13, { animatedProps: dropProps, d: SyringePaths.drop, fill: s.fill }));
+};
+var AnimatedCircle3 = Animated4.createAnimatedComponent(Circle);
+var Brain = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const n1r = useSharedValue(3);
+  const n1op = useSharedValue(0.2);
+  const n2r = useSharedValue(3);
+  const n2op = useSharedValue(0.2);
+  const n3r = useSharedValue(3);
+  const n3op = useSharedValue(0.2);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, BrainPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      const fire = (r, op, delay) => {
+        r.value = withDelay(delay, withRepeat(withTiming(4.5, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true));
+        op.value = withDelay(delay, withRepeat(withTiming(1, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true));
+      };
+      fire(n1r, n1op, 0);
+      fire(n2r, n2op, d.stagger);
+      fire(n3r, n3op, d.stagger * 2);
+    } else {
+      [n1r, n2r, n3r, n1op, n2op, n3op].forEach((sv) => cancelAnimation(sv));
+    }
+    return () => {
+      [n1r, n2r, n3r, n1op, n2op, n3op].forEach((sv) => cancelAnimation(sv));
+    };
+  }, [autoPlay, loop, speed]);
+  const ap1 = useAnimatedProps(() => ({ r: n1r.value, opacity: n1op.value }));
+  const ap2 = useAnimatedProps(() => ({ r: n2r.value, opacity: n2op.value }));
+  const ap3 = useAnimatedProps(() => ({ r: n3r.value, opacity: n3op.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: BrainPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Path, { d: BrainPaths.left, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, strokeLinecap: "round", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Path, { d: BrainPaths.right, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, strokeLinecap: "round", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Path, { d: `${BrainPaths.synapse1} ${BrainPaths.synapse2}`, stroke: s.stroke, strokeWidth: 1, fill: "none", opacity: s.opacity * 0.5 }), /* @__PURE__ */ React6.createElement(AnimatedCircle3, { animatedProps: ap1, cx: "16", cy: "20", fill: s.fill }), /* @__PURE__ */ React6.createElement(AnimatedCircle3, { animatedProps: ap2, cx: "24", cy: "16", fill: s.fill }), /* @__PURE__ */ React6.createElement(AnimatedCircle3, { animatedProps: ap3, cx: "32", cy: "20", fill: s.fill }));
+};
+var AnimatedPath14 = Animated4.createAnimatedComponent(Path);
+var AnimatedCircle4 = Animated4.createAnimatedComponent(Circle);
+var BloodDrop = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const scaleY = useSharedValue(1);
+  const r1 = useSharedValue(6);
+  const op1 = useSharedValue(0.6);
+  const r2 = useSharedValue(6);
+  const op2 = useSharedValue(0.6);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, BloodDropPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      scaleY.value = withRepeat(withTiming(0.85, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+      r1.value = withRepeat(withTiming(10, { duration: d.long, easing: Easing.out(Easing.ease) }), loop ? -1 : 1);
+      op1.value = withRepeat(withTiming(0, { duration: d.long }), loop ? -1 : 1);
+      r2.value = withDelay(d.stagger, withRepeat(withTiming(10, { duration: d.long, easing: Easing.out(Easing.ease) }), loop ? -1 : 1));
+      op2.value = withDelay(d.stagger, withRepeat(withTiming(0, { duration: d.long }), loop ? -1 : 1));
+    } else {
+      [scaleY, r1, op1, r2, op2].forEach((sv) => cancelAnimation(sv));
+    }
+  }, [autoPlay, loop, speed]);
+  const dropProps = useAnimatedProps(() => ({ transform: [{ scaleY: scaleY.value }], originY: 28 }));
+  const rip1Props = useAnimatedProps(() => ({ r: r1.value, opacity: op1.value }));
+  const rip2Props = useAnimatedProps(() => ({ r: r2.value, opacity: op2.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: BloodDropPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedPath14, { animatedProps: dropProps, d: BloodDropPaths.drop, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.fill, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedCircle4, { animatedProps: rip1Props, cx: "24", cy: "42", stroke: s.stroke, strokeWidth: 1.5, fill: "none" }), /* @__PURE__ */ React6.createElement(AnimatedCircle4, { animatedProps: rip2Props, cx: "24", cy: "42", stroke: s.stroke, strokeWidth: 1.5, fill: "none" }));
+};
+var AnimatedPath15 = Animated4.createAnimatedComponent(Path);
+var Steps = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const op1 = useSharedValue(0.3);
+  const op2 = useSharedValue(1);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, StepsPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      op1.value = withRepeat(withTiming(1, { duration: d.medium, easing: Easing.ease }), loop ? -1 : 1, true);
+      op2.value = withRepeat(withTiming(0.3, { duration: d.medium, easing: Easing.ease }), loop ? -1 : 1, true);
+    } else {
+      cancelAnimation(op1);
+      cancelAnimation(op2);
+    }
+  }, [autoPlay, loop, speed]);
+  const f1Props = useAnimatedProps(() => ({ opacity: op1.value }));
+  const f2Props = useAnimatedProps(() => ({ opacity: op2.value }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: StepsPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(AnimatedPath15, { animatedProps: f1Props, d: `${StepsPaths.foot1} ${StepsPaths.toe1a} ${StepsPaths.toe1b}`, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.fill, strokeLinecap: "round" }), /* @__PURE__ */ React6.createElement(AnimatedPath15, { animatedProps: f2Props, d: `${StepsPaths.foot2} ${StepsPaths.toe2a} ${StepsPaths.toe2b}`, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.fill, strokeLinecap: "round" }));
+};
+var AnimatedPath16 = Animated4.createAnimatedComponent(Path);
+var Sleep = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const moonScale = useSharedValue(1);
+  const star1Op = useSharedValue(0.3);
+  const star2Op = useSharedValue(0.3);
+  const z1Y = useSharedValue(0);
+  const z1Op = useSharedValue(0);
+  const z2Y = useSharedValue(0);
+  const z2Op = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, SleepPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      moonScale.value = withRepeat(withTiming(1.05, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+      star1Op.value = withDelay(d.stagger, withRepeat(withTiming(1, { duration: d.long }), loop ? -1 : 1, true));
+      star2Op.value = withDelay(d.stagger * 2, withRepeat(withTiming(1, { duration: d.long }), loop ? -1 : 1, true));
+      z1Op.value = withRepeat(withTiming(1, { duration: d.long * 0.5 }), loop ? -1 : 1, true);
+      z1Y.value = withRepeat(withTiming(-12, { duration: d.long }), loop ? -1 : 1);
+      z2Op.value = withDelay(d.stagger, withRepeat(withTiming(1, { duration: d.long * 0.5 }), loop ? -1 : 1, true));
+      z2Y.value = withDelay(d.stagger, withRepeat(withTiming(-12, { duration: d.long }), loop ? -1 : 1));
+    } else {
+      [moonScale, star1Op, star2Op, z1Y, z1Op, z2Y, z2Op].forEach((sv) => cancelAnimation(sv));
+    }
+  }, [autoPlay, loop, speed]);
+  const moonStyle = useAnimatedStyle(() => ({ transform: [{ scale: moonScale.value }] }));
+  const star1Props = useAnimatedProps(() => ({ opacity: star1Op.value }));
+  const star2Props = useAnimatedProps(() => ({ opacity: star2Op.value }));
+  const z1Props = useAnimatedProps(() => ({ opacity: z1Op.value, transform: [{ translateY: z1Y.value }] }));
+  const z2Props = useAnimatedProps(() => ({ opacity: z2Op.value, transform: [{ translateY: z2Y.value }] }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: SleepPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Animated4.View, { style: [{ position: "absolute" }, moonStyle] }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: SleepPaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Path, { d: SleepPaths.moon, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, opacity: s.opacity }))), /* @__PURE__ */ React6.createElement(AnimatedPath16, { animatedProps: star1Props, d: SleepPaths.star1, fill: s.fill, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath16, { animatedProps: star2Props, d: SleepPaths.star2, fill: s.fill, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedPath16, { animatedProps: z1Props, d: SleepPaths.z1, stroke: s.stroke, strokeWidth: 2, fill: "none", strokeLinecap: "round", strokeLinejoin: "round" }), /* @__PURE__ */ React6.createElement(AnimatedPath16, { animatedProps: z2Props, d: SleepPaths.z2, stroke: s.stroke, strokeWidth: 1.5, fill: "none", strokeLinecap: "round", strokeLinejoin: "round" }));
+};
+var AnimatedCircle5 = Animated4.createAnimatedComponent(Circle);
+var Oxygen = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const rotation = useSharedValue(0);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, OxygenPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      rotation.value = withRepeat(withTiming(360, { duration: d.long, easing: Easing.linear }), loop ? -1 : 1);
+    } else {
+      cancelAnimation(rotation);
+    }
+    return () => {
+      cancelAnimation(rotation);
+    };
+  }, [autoPlay, loop, speed]);
+  const electronProps = useAnimatedProps(() => ({
+    transform: [{ rotate: `${rotation.value}deg` }],
+    originX: 24,
+    originY: 24
+  }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: OxygenPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Path, { d: OxygenPaths.orbit, stroke: s.secondaryColor, strokeWidth: 1, fill: "none", strokeDasharray: "3 3", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Circle, { cx: "18", cy: "20", r: 4, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Circle, { cx: "26", cy: "20", r: 4, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Path, { d: OxygenPaths.bond, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", opacity: s.opacity }), /* @__PURE__ */ React6.createElement(AnimatedCircle5, { animatedProps: electronProps, cx: "40", cy: "24", r: 2.5, fill: s.fill, opacity: s.opacity }));
+};
+var AnimatedPath17 = Animated4.createAnimatedComponent(Path);
+var Medkit = ({
+  size = 48,
+  autoPlay = true,
+  loop = true,
+  speed = "normal",
+  style,
+  ...colorProps
+}) => {
+  const bodyY = useSharedValue(0);
+  const crossScale = useSharedValue(1);
+  const d = getAnimDuration(speed);
+  const s = resolveStyle(colorProps, MedkitPaths);
+  useEffect(() => {
+    if (autoPlay) {
+      bodyY.value = withRepeat(withTiming(-5, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+      crossScale.value = withRepeat(withTiming(1.2, { duration: d.long, easing: Easing.inOut(Easing.ease) }), loop ? -1 : 1, true);
+    } else {
+      cancelAnimation(bodyY);
+      cancelAnimation(crossScale);
+    }
+  }, [autoPlay, loop, speed]);
+  const bodyStyle = useAnimatedStyle(() => ({ transform: [{ translateY: bodyY.value }] }));
+  const crossProps = useAnimatedProps(() => ({ transform: [{ scale: crossScale.value }], originX: 24, originY: 27 }));
+  return /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: MedkitPaths.viewBox, style }, /* @__PURE__ */ React6.createElement(Animated4.View, { style: [{ position: "absolute" }, bodyStyle] }, /* @__PURE__ */ React6.createElement(Svg, { width: size, height: size, viewBox: MedkitPaths.viewBox, style: { position: "absolute" } }, /* @__PURE__ */ React6.createElement(Path, { d: MedkitPaths.box, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: s.secondaryColor, opacity: s.opacity }), /* @__PURE__ */ React6.createElement(Path, { d: MedkitPaths.handle, stroke: s.stroke, strokeWidth: s.strokeWidth, fill: "none", strokeLinecap: "round", opacity: s.opacity }))), /* @__PURE__ */ React6.createElement(AnimatedPath17, { animatedProps: crossProps, d: `${MedkitPaths.crossV} ${MedkitPaths.crossH}`, stroke: s.fill, strokeWidth: 3, strokeLinecap: "round", fill: "none", opacity: s.opacity }));
+};
+
+export { Bell, BloodDrop, Brain, Check, DNA, ECG, Heart, HeartRate, Loader, Lungs, Medkit, Oxygen, Pill, Pulse, Sleep, Star, Steps, Syringe, Thermometer, Upload, Wifi, getAnimDuration, resolveStyle };